Spring的学习（二、Spring中的Bean）

Bean的配置

 

Spring容器支持两种格式的配置文件，分别为properties文件格式和XML文件格式（常用），其中XML这种配置方式是通过XML文件来注册并管理Bean之间的依赖关系的。

XML配置文件

XML配置文件的根元素是<beans>，里面包含了多个<bean>子元素，每个<bean>定义了一个bean，并描述了该Bean如何被装配到Spring容器中。

<bean>元素中的属性

（1）id：一个Bean的唯一标识符，Spring容器对Bean的配置、管理都通过该属性来完成。

（2）name：Spring容器对Bean的配置、管理也都可以通过该属性来完成。可以有多个name，中间用逗号或者分号隔开。一般想要给Bean添加别名或想要使用一些不合法的XML字符，如：/，就可以通过name属性进行设置。

（3）class：该属性指定了Bean的具体实现类，它必须是一个完整的类名，使用类的全限定名。

（4）scope：用来设定Bean实例的作用域，其属性值有singleton（单例）、prototype（原型）、request、session和global Session。默认为singleton。

（5）constructor-arg：bean元素的子元素，可以使用此元素传入构造参数进行实例化。该元素的index属性指定构造参数的序号（从0开始），type属性指定构造参数的类型，其参数值可以通过ref属性或者value属性直接指定，也可以通过ref或value元素指定。

（6）property：bean元素的子元素，用于调用Bean实例中的Setter方法完成属性赋值，从而完成依赖注入。该元素的name属性指定Bean实例中的相应属性名，属性值可通过ref或value属性直接指定。

（7）ref：property、constructor-arg等元素的子元素，该元素中的bean属性用于指定对Bean工厂中某个Bean实例的引用。

（8）value：property、constructor-arg等元素的子元素，用来直接指定一个常量值。

（9）list：用于封装List或数组类型的依赖注入。

（10）set：用于封装Set类型属性的依赖注入。

（11）map：用于封装Map类型属性的依赖注入。

（12）entry：map元素的子元素，用于设置一个键值对。其key属性指定字符串类型的键值，ref或value子元素指定其值。

注意：如果在Bean中未指定id和name，则Spring会将class值当作id使用。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--使用id属性定义bean1，其对应的实现类为com.tm.bean.bean1 -->
    <bean id="bean1" class="com.tm.bean.bean1" />
    <!--使用name属性定义bean2，其对应的实现类为com.tm.bean.bean2-->
    <bean name="bean2" class="com.tm.bean.bean2" />
</beans>

Bean的实例化

 

Spring中，实例化Bean有三种方式：构造器实例化、静态工厂方式实例化、实例工厂方式实例化。

1. 构造器实例化

构造器实例化是指Spring容器通过Bean对应的类中默认的构造函数来实例化Bean。

beans1.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--使用id属性定义bean1，其对应的实现类为com.tm.bean.Bean1 -->
    <bean id="bean1" class="com.tm.bean.Bean1" />
</beans>

Bean1.java

package cn.tm.bean

public class Bean1{
    
}

测试类

public class test(){
    @Test
    public void test(){
        //这里要填写xml对应的配置文件的路径。在加载时，Spring容器会通bean1的实现类Bean1中的默认无参构造函数对Bean进行实例化
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(...beans1.xml);
        System.out.println(applicationContext.getBean("bean1"));
    }
}

2. 静态工厂方式实例化

该方式要求自己创建一个静态工厂的方法来创建Bean的实例。

beans2.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--使用id属性定义bean2，通过class属性指定其对应的工厂实现类为MyBean2Factory，factory-method属性指定方法名 -->
    <bean id="bean2" class="com.tm.bean.MyBean2Factory" factory-method="createBean" />
</beans>

Bean2.java

package cn.tm.bean;

public class Bean2{
    
}

MyBean2Factory.java

package cn.tm.bean;

public class MyBean2Factory{
    //使用自己的工厂创建bean实例
    public static Bean2 createBean(){
        return new Bean2();
    }
}

测试类

public class test(){
    @Test
    public void test(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(...beans2.xml);
        System.out.println(applicationContext.getBean("bean2"));
    }
}

3. 实例工厂方式实例化

该种方式的工厂类中，不再使用静态方法创建Bean实例，而是采用直接创建Bean实例的方式。同时，在配置文件中，需要实例化的Bean也不是通过class属性直接指向其实例化的类，而是通过factory-bean属性配置一个实例工厂，然后使用factory-method属性确定使用工厂中的哪个方法。

beans3.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 配置工厂 -->
    <bean id="MyBean3Factory" class="com.tm.bean.MyBean3Factory"/>
    <!-- 使用factory-bean属性配置一个实例工厂，使用factory-method属性确定使用工厂中的哪个方法 -->
    <bean id="bean3" factory-bean="MyBean3Factory" factory-method="createBean"></bean>
</beans>

Bean3.java

package cn.tm.bean;

public class Bean3{
    
}

MyBean3Factory.java

package cn.tm.bean;

public class MyBean3Factory{
    //默认的无参构造方法
    public MyBean3Factory(){
        System.out.println("bean3工厂实例化中");
    }
    //创建Bean的方法
    public Bean3 createBean(){
        return new Bean3();
    }
}

测试类

public class test(){
    @Test
    public void test(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(...beans3.xml);
        System.out.println(applicationContext.getBean("bean3"));
    }
}

Bean的作用域

 

Spring容器在初始化一个Bean实例时，可以同时为其指定特定的作用域。作用域的种类一共分为5种：singleton、prototype、request、session、global Session。

1. singleton（单例模式）

单例模式，使用singleton定义的Bean在Spring容器中将只有一个实例，也就是说，无论有多少个Bean引用它，始终指向同一个对象。（Spring默认）

2. prototype（原型模式）

原型模式，每次通过Spring容器获取的prototype定义的Bean时，容器都将新建一个新的Bean实例。

3. request

在一次HTTP请求中，容器会返回该Bean的同一个实例。对于不同的HTTP请求，会产生一个新的Bean，该Bean仅在当前HTTP Request内有效。

4. session

在一次HTTP Session中，容器会返回该Bean的同一个实例。对于不同的HTTP请求，会产生一个新的Bean，该Bean仅在当前HTTP Session内有效。

5. global Session

在一个全局的HTTP Session中，容器会返回该Bean的同一个实例。仅在使用portlet context时有效。

上面这5种，singleton和prototype是最常用的。

Singleton作用域

单例模式对于无会话状态的Bean来说，是最理想的选择。（比如：Dao组件、Service组件）具体配置如下：

<bean id="bean5" class="com.tm.bean.bean5" scope="singleton" />

测试类

public class test(){
    @Test
    public void test(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(...beans5.xml);
        //两次输出是一样的
        System.out.println(applicationContext.getBean("bean5"));
        System.out.println(applicationContext.getBean("bean5"));
    }
}

Prototype作用域

代码同Singleton一样，只需要将scope对应的属性值改成prototype即可。

Bean的生命周期

参考：https://www.cnblogs.com/javazhiyin/p/10905294.html 

Bean的装配方式

Bean的装配可以理解为依赖关系注入，Bean的装配方式即Bean依赖注入的方式，Spring容器支持多种形式的Bean的装配方式，如基于XML的装配、基于Annotation的装配和自动装配等。

基于XML的装配

Spring依赖注入有两种方式：设值注入（Setter Injection）和构造注入（Constructor Injection）。

在Spring实例化Bean的过程中，Spring首先调用Bean的默认构造方法来实例化Bean对象，然后通过反射的方式调用setter方法来注入属性值。因此，设值注入要求一个Bean必须满足以下两点要求：

1. Bean类必须提供一个默认的构造方法。

2. Bean类必须为需要注入的属性提供对应的setter方法。

使用设值注入时，在Spring配置文件中，需要使用<bean>元素的子元素<property>元素来为每个属性注入值。

使用构造注入时，在配置文件里，主要是使用<constructor-arg>标签来定义构造方法的参数，可以使用其value属性（或子元素）来设置该参数的值。

User.java

package cn.tm.bean;

public class User{
    private String username;
    private Integer password;
    
    //默认构造
    public User(){
        super();
    }
    //构造方法注入
    public User(String username,Integer password){
        super();
        this.username = username;
        this.password = password;
    }
    //省略username和password的get、set方法，省略toString方法
}

Beans6.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--使用构造方式装配user实例-->
    <bean>
        <!-- 构造方式装配User类的实例。constructor-arg元素用来定义构造方法的参数，其属性值表示其索引，从0开始。value属性用于设置注入的值 -->
        <constructor-arg index="0" value="zhangsan"/>
        <constructor-arg index="1" value="1234"/>
    </bean>
    <!--使用Set方式装配user实例-->
    <bean>
        <!--设值注入方式装配User类的实例。使用其property元素用于调用Bean实例中的Setter方法完成属性赋值，从而完成依赖注入 -->
        <property name="username" value="lisi"></property>
        <property name="password" value="4321"></property>
    </bean>
</beans>

测试类

public class test(){
    @Test
    public void test(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(...beans6.xml);
        System.out.println(applicationContext.getBean("user1"));//输出zhangsan 1234
        System.out.println(applicationContext.getBean("user2"));//输出lisi 4321
    }
}

基于Annotation的装配

XML配置文件的方式有时候过于臃肿，jdk1.5之后提供了Annotation（注解）功能，Spring也提供了对Annotation技术的全面支持。常用注解如下：

（1）@Component：（把普通pojo实例化到spring容器中，相当于配置文件中的 <bean id="" class=""/>）

可以使用此注解描述Spring中的Bean，但它是一个泛化的概念，仅仅表示一个组件（Bean），并且可以作用在任何层次。就是说当我们的类不属于各种归类的时候（不属于@Controller、@Services等的时候），我们就可以使用@Component来标注这个类。

（2）@Repository：（实现dao访问）

作用同@Component，用于标注数据访问层，也可以说用于标注数据访问组件，即DAO组件。用于将数据访问层（dao层）的类标识为Spring中的Bean。

（3）@Service：（注入dao）

作用同@Component，用于标注服务层，主要用来进行业务的逻辑处理。用于将业务层的类标识为Spring中的Bean。

（4）@Controller：（注入服务）

作用同@Component，通常作用在控制层（如Struts2的Action）。用于将控制层的类标识为Spring中的Bean。

（5）@Autowired：

 用于对Bean的属性变量、属性的Set方法及构造函数进行标注，配合对应的注解处理器完成Bean的自动配置工作。默认按照Bean的类型进行装配。

（6）@Resource：

其作用与Autowired一样。其区别在于@Autowired默认按照Bean类型装配，而Resource默认按照Bean实例名称进行装配。@Resource中有两个重要属性：name和type。Spring将name属性解析为Bean实例名称，type属性解析为Bean实例类型。如果指定name属性，则按实例名称进行装配；如果指定type属性，则按Bean类型进行装配；如果都不指定，则先按Bean实例名称装配，如果不能匹配，再按照Bean类型进行装配；如果都无法匹配，则抛出NoSuchBeanDefinitionException异常。

（7）@Qualifier：

与@Autowired注解配合使用，会将默认的按Bean类型装配修改为按Bean的实例名称装配，Bean的实例名称由@Qualifier注解的参数指定。

在上面的注解中，虽然@Repository、@Service、@Controller功能与@Component注解的功能相同，但为了使标注类本身用途更加清晰，建议单独使用。

下面演示如何通过这些注解来装配Bean：

Beans7.xml

这里要注意：相比上面的xml配置文件，这里头部分，新添加了两个context代码。http://www.springframework.org/schema/context和http://www.springframework.org/schema/context/spring-context.xsd

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
       
       <!-- 使用context命名空间，通知spring扫描指定目录，进行注解的解析 -->
       <context:component-scan base-package="cn.tm.bean"/>

</beans>

UserDao.java

package cn.tm.bean;
public interface UserDao{
    public void save();
}

UserDaoImpl.java

package cn.tm.bean;
//这里使用@Repository注解将UserDaoImpl类标识为Spring中的Bean，其写法相当于配置文件中<bean id="userDao" class="cn.tm.bean.userDaoImpl"/>的书写。
@Repository("userDao")
public class UserDaoImpl implements UserDao{
    public void save(){
        System.out.println("userdao...save...");
    }
}

UserService.java

package cn.tm.bean;
public interface UserService{
    public void save();
}

UserServiceImpl.java

package cn.tm.bean;
//@Service注解将UserServiceImpl类标识为Spring中的Bean，写法相当于配置文件中<bean id="userService" class="cn.tm.bean.UserServiceImpl" />的书写。
@Service("userService")
public class UserServiceImpl implements UserService{
    //使用@Resource注解标注在属性userDao上，也可以标注在userDao的set方法上，相当于配置文件中的<property name="userDao" ref="userDao"/>的写法。
    @Resource(name="userDao")
    private UserDao userDao;
    //userDao的set方法
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }
    public void save(){
        //调用userDao中的save方法
        this.userDao.save();
        System。out.println("userservice...save...");
    }
}

UserAction.java

package cn.tm.bean;
//使用@Controller注解标注UserAction类，写法相当于配置文件中的<bean id="userAction" class="cn.tm.bean.UserAction" />
@Controller("userAction")
public class UserAction{
    //相当于配置文件中的<property name="userService" ref="userService" />
    @Resource(name="userService")
    private UserService userService;
    //userService的set方法
    public void setUserService(UserService userService){
        this.userService = userService;
    }
    public void save(){
        //调用userService中的save方法
        this.userService.save();
        System.out.println("userAction...save...");
    }
}

测试类

public class test(){
    @Test
    public void test(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(...beans7.xml);
        UserAction userAction = (UserAction)applicationContext.getBean("userAction");
        //输出实例
        System.out.println(userAction);
        //调用userAction中的save()方法
        userAction.save();
        //最后结果从上到下分别为
        //cn.tm.bean.UserAction@bffa22
        //userdao...save...
        //userservice...save...
        //userAction...save...
    }
}

自动装配

所谓自动装配就是将一个Bean注入到其他Bean的Property中。

要使用自动装配，就需要配置<bean>元素的autowire属性。autowire属性有5个值，说明如下：

（1）byName：根据Property的Name自动装配，如果一个Bean的name，和另一个Bean中的Property的name相同，则自动装配这个Bean到Property中。

（2）byType：根据Property的数据类型（Type）自动装配，如果一个Bean的数据类型，兼容另一个Bean中Property的数据类型，则自动装配。

（3）constructor：根据构造函数参数的数据类型，进行byType模式的自动装配。

（4）autodetect：如果发现默认的构造函数，用constructor模式，否则用byType模式。

（5）no：默认情况下，不使用自动装配，Bean依赖必须通过ref元素定义。

将上面的Beans7.xml改进一下。

Beans8.xml

注意：默认情况下，配置文件中需要通过ref来装配Bean，但设置了autowire="byName"，Spring会自动寻找与属性名字userDao相同的<bean>，找到后，通过调用setUserDao(UserDao userDao)将其注入属性，这时就不需要通过ref来装配了。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
       
       <bean id="userDao" class="cn.tm.bean.UserDaoImpl" />
       <bean id="userService" class="cn.tm.bean.UserServiceImpl" autowire="byName" />
       <bean id="userAction" class="cn.tm.bean.UserAction" autowire="byName" />
</beans>

参考：

1. 《SSH框架整合实战教程》

持续更新！！！