0
点赞
收藏
分享

微信扫一扫

Spring概述、搭建、配置、属性注入


Spring概述:

一、什么是 Spring :

Spring概述、搭建、配置、属性注入_xml

Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson

在其著作 Expert One-On-One J2EE Development and Design 中阐述的部分理念和原型衍生而来。

它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使

用者选择使用哪一个组件,同时为 J2EE 应用程序开发提供集成的框架。Spring 使用基本的 JavaBean

来完成以前只可能由 EJB 完成的事情。然而,Spring 的用途不仅限于服务器端的开发。从简单性、

可测试性和松耦合的角度而言,任何 Java 应用都可以从 Spring 中受益。Spring 的核心是控制反转

(IoC)和面向切面(AOP)。简单来说,Spring 是一个分层的 JavaSE/EEfull-stack(一站式) 轻量级开源框架。

二、为什么学习 Spring:

  • 方便解耦,简化开发 Spring: 就是一个大工厂,可以将所有对象创建和依赖关系维护,交给 Spring 管理
  • AOP 编程的支持 Spring: 提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能
  • 声明式事务的支持: 只需要通过配置就可以完成对事务的管理,而无需手动编程
  • 方便程序的测试:Spring 对 Junit4 支持,可以通过注解方便的测试 Spring 程序
  • 方便集成各种优秀框架 :Spring 不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz 等)的直接支持
  • 降低 JavaEE API 的使用难度
  • Spring 对 JavaEE 开发中非常难用的一些 API(JDBC、JavaMail、远程调用等),都提供了封装,使这些 API 应用难度大大降低

三、Spring介绍

(1)三层架构中spring位置:

Spring概述、搭建、配置、属性注入_xml_02

 (2)spring一站式框架

    正是因为spring框架性质是属于容器性质的.

    容器中装什么对象就有什么功能.所以可以一站式.

    不仅不排斥其他框架,还能帮其他框架管理对象.

    aop支持

    ioc思想

    spring jdbc

    aop 事务

    junit 测试支持

 

四、Spring搭建

(1)导包:

Spring的包很多,不是每一个都要导进来,看自己的需要导入核心包以及依赖包和工具包

一般都会用到的包有:

Spring概述、搭建、配置、属性注入_Spring入门_03

日志包log4j.jar:

(2):创建一个Bean:

package cn.hncu.bean;

public class User {

public User() {
System.out.println("User对象空参构造方法!!!!");
}
private String name;
private Integer age;

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}


@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}

}

(3):书写配置文件注册对象到容器 

3.1配置文件名任意(建议applicationContext.xml) 位置任意(建议放到src下)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">

<!--将user对象交给Spring管理 -->
<bean name="User" class="cn.hncu.bean.User">

</bean>

</beans>

3.2 导入约束                      

(4)代码测试:

 

五、Spring概念

(1)思想:IOC、DI

IOC: inverse of Control 反转控制,

指的是 对象的创建权反转(交给)给 Spring.

作用是实现了程序的解耦合

将我们创建对象的方式反转了

以前对象的创建是有我们开发人员自己维护,包括依赖关系也是自己注入。

使用Spring之后,对象的创建以及依赖关系可以由Spring完成创建以及注入。

反转控制就是反转了对象的创建方式,从我们自己创建反转给了程序。

原理图:

Spring概述、搭建、配置、属性注入_Spring入门_04

DI: Dependency Injection 依赖注入,实现IOC思想需要DI作支持。

 

Spring概述、搭建、配置、属性注入_User_05

(2)applicationContext&BeanFactory

    2.1BeanFactory接口:

        spring原始接口.针对原始接口的实现类功能较为单一

        BeanFactory接口实现类的容器.特点是每次在获得对象时才会创建对象
   

    2.2ApplicationContext

         每次容器启动时就会创建容器中配置的所有对象.并提供更多功能

         丛类路径下加载配置文件:ClassPathXmlApplicationContext

         从硬盘绝对路径下加载配置文件:FileSystemXmlApplicationContext("d:/xxx/yyy/xxx")

         结论:web开发中,使用applicationContext. 在资源匮乏的环境可以使用BeanFactory.

 

六、Spring配置详解

    Bean元素

    Bean元素进阶

    spring创建对象的方式

    spring的分模块配置 

 Bean元素:

Spring概述、搭建、配置、属性注入_spring_06

Bean元素进阶:

   scope属性

  • singleton(默认值):单例对象.被标识为单例的对象在spring容器中只会存在一个实例
  • prototype:多例原型.被标识为多例的对象,每次再获得才会创建.每次创建都是新的对象.整合struts2时,ActionBean必须配置为多例的.
  •  request:web环境下.对象与request生命周期一致.(了解)
  •    session:web环境下,对象与session生命周期一致.

  生命周期属性

  •   配置一个方法作为生命周期初始化方法.spring会在对象创建之后立即调用:init-method
  •   配置一个方法作为生命周期的销毁方法.spring容器在关闭并销毁所有容器中的对象之前调用: destory-metho     

spring创建对象的方式  

三种对象创建方式:

1.空参构造             

2.静态工厂(了解)

3.实例工厂(了解)

Spring概述、搭建、配置、属性注入_xml_07

 

Spring概述、搭建、配置、属性注入_User_08

spring的分模块配置:

Spring概述、搭建、配置、属性注入_User_09

 

七、Spring属性注入:

注入方式

set方法注入

构造函数注入

p名称空间注入

spel注入

 set方法注入 :

<!-- set方式注入: -->
<bean name="User" class="cn.hncu.bean.User">
<!--值类型注入: 为User对象中名为name的属性注入tom作为值 -->
<property name="name" value="Tom"></property>
<property name="age" value="20"></property>
<!-- 引用类型注入: 为car属性注入下方配置的car对象 -->
<property name="car" ref="car"></property>
</bean>

<!-- 将car对象配置到容器中 -->
<bean name="car" class="cn.hncu.bean.Car">
<property name="name" value="兰博基尼"></property>
<property name="color" value="黄色"></property>
</bean>

Demo:

@Test
public void fun1(){

//1 创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/hncu/injection/applicationContext.xml");
//2 向容器"要"user对象
User u = (User) ac.getBean("User");
//3 打印user对象
System.out.println(u);

}

构造函数注入:

<!-- 构造函数注入 -->
<bean id="User2" class="cn.hncu.bean.User">
<!-- name属性: 构造函数的参数名 -->
<!-- index属性: 构造函数的参数索引 -->
<!-- type属性: 构造函数的参数类型 -->
<constructor-arg name="name" index="0" type="java.lang.Integer"
value="999"></constructor-arg>
<constructor-arg name="car" ref="car" index="1"></constructor-arg>
</bean>

Demo:

@Test
public void fun2(){

//1 创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/hncu/injection/applicationContext.xml");
//2 向容器"要"user对象
User u = (User) ac.getBean("User2");
//3 打印user对象
System.out.println(u);

}

p名称空间注入:

p名称空间注入, 走set方法
    1.导入P名称空间  xmlns:p="http://www.springframework.org/schema/p"
    2.使用p:属性完成注入
        |-值类型: p:属性名="值"
        |-对象类型: p:属性名-ref="bean名称"

<!-- p名称空间注入, 走set方法 1.导入P名称空间 xmlns:p="http://www.springframework.org/schema/p" 
2.使用p:属性完成注入 |-值类型: p:属性名="值" |-对象类型: p:属性名-ref="bean名称" -->
<bean name="User3" class="cn.hncu.bean.User" p:name="jack"
p:age="20" p:car-ref="car"></bean>

demo:

@Test
public void fun3(){

//1 创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/hncu/injection/applicationContext.xml");
//2 向容器"要"user对象
User u = (User) ac.getBean("User3");
//3 打印user对象
System.out.println(u);

}

spel注入

<!-- spel注入: spring Expression Language sping表达式语言 -->
<bean name="User4" class="cn.hncu.bean.User">
<property name="name" value="#{User.name}"></property>
<property name="age" value="#{User3.age}"></property>
<property name="car" ref="car"></property>
</bean>

demo:

@Test
public void fun4(){

//1 创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/hncu/injection/applicationContext.xml");
//2 向容器"要"user对象
User u = (User) ac.getBean("User4");
//3 打印user对象
System.out.println(u);

}

 

复杂类型注入

demo:

@Test
public void fun5(){

//1 创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/hncu/injection/applicationContext.xml");
//2 向容器"要"user对象
CollectionBean cb = (CollectionBean) ac.getBean("cb");
//3 打印user对象
System.out.println(cb);

}

数组

<!-- 复杂类型注入 -->
<bean name="cb" class="cn.hncu.injection.CollectionBean">
<!-- 如果数组中只准备注入一个值(对象),直接使用value|ref即可 <property name="arr" value="tom" ></property> -->
<property name="arr">
<array>
<value>tom</value>
<value>jerry</value>
<ref bean="User4" />
</array>
</property>

List

<!-- 如果List中只准备注入一个值(对象),直接使用value|ref即可 <property name="list" value="jack" ></property> -->
<property name="list">
<list>
<value>jack</value>
<value>rose</value>
<ref bean="User3" />
</list>
</property>

Map

<!-- map类型注入 -->
<property name="map">
<map>
<entry key="url" value="jdbc:mysql:///crm"></entry>
<entry key="User" value-ref="User4"></entry>
<entry key-ref="User3" value-ref="User2"></entry>
</map>
</property>

Properties

<!-- prperties 类型注入 -->
<property name="prop">
<props>
<prop key="driverClass">com.jdbc.mysql.Driver</prop>
<prop key="userName">root</prop>
<prop key="password">1234</prop>
</props>
</property>
</bean>

 

 

 

 

   

举报

相关推荐

0 条评论