Spring学习笔记——（3）Spring中的Bean（二）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/shaohe18362202126/article/details/81516681

*接上篇：Spring学习笔记——（2）Spring中的Bean（一）

9、Bean 的生命周期

（1）生命周期过程

Bean:

public class Car {

	private String brand;

	public Car() {
		System.out.println("Car's construct...");
	}

	// 初始化方法
	public void init() {
		System.out.println("init Car...");
	}

	// 销毁方法
	public void destory() {
		System.out.println("destory Car...");
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
		System.out.println("setter brand");
	}

	@Override
	public String toString() {
		return "Car [brand=" + brand + "]";
	}

}

配置文件：

<!-- 设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法. -->
<bean id="car" class="com.shaohe.spring.beans.cycle.Car"
		init-method="init" destroy-method="destory" p:brand="audit"></bean>

Main:

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("bean-cycle.xml");
Car car = (Car) ctx.getBean("car");
System.out.println(car);
// 关闭IOC容器
ctx.close();

运行结果：

（2）Bean 后置处理器

• Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
• Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例. 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
• 对Bean 后置处理器而言, 需要实现 org.springframework.beans.factory.config.BeanPostProcessor 接口. 在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口的以下两个方法:postProcessAfterInitialization、postProcessBeforeInitialization

后置处理器：

public class MyBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("postProcessAfterInitialization:  " + bean + "," + beanName);
		return bean;
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("postProcessBeforeInitialization:  " + bean + "," + beanName);
		return bean;
	}
}

配置后置处理器：

<!--配置后置处理器，只需要class属性，IOC容器自动识别是后置处理器-->
<bean class="com.shaohe.spring.beans.cycle.MyBeanPostProcessor"></bean>

运行结果：

10、通过工厂方法配置Bean

（1）静态工厂方法 

• 调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节.
• 要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用 <constrctor-arg> 元素为该方法传递方法参数.

静态工厂：

/**
 * 静态工厂方法:直接调用某一个类的静态方法就可以返回bean的实例
 */
public class StaticFactory {

	private static Map<String, Car> cars = new HashMap<String, Car>();

	static {
		cars.put("audi", new Car("audi", 452000));
		cars.put("baoma", new Car("baoma", 15260000));
	}

	/**
	 * 静态工厂方法
	 * 
	 * @param brand
	 *            参数
	 * @return bean的实例
	 */
	public static Car getCar(String brand) {
		return cars.get(brand);
	}
}

配置：

<!--通过静态方法配置bean -->
<!-- 通过静态工厂方法: 一个类中有一个静态方法, 可以返回一个类的实例(了解) -->
<!-- 在 class 中指定静态工厂方法的全类名, 在 factory-method 中指定静态工厂方法的方法名 -->
<bean id="car1" class="com.shaohe.spring.beans.factory.StaticFactory"
		factory-method="getCar">
    <!-- 可以通过 constructor-arg 子节点为静态工厂方法指定参数 -->
    <constructor-arg value="audi"></constructor-arg>
</bean>

（2）实例工厂方法

• 实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节.
• 要声明通过实例工厂方法创建的 Bean：在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean、在 factory-method 属性里指定该工厂方法的名称、使用 construtor-arg 元素为工厂方法传递方法参数

实例工厂：

/**
 * 实例工厂方法：即需要创建工厂本身，再调用工厂的实例方法来返回bean的实例
 */
public class InstanceFactory {

	private Map<String, Car> cars;

	public InstanceFactory() {
		cars = new HashMap<String, Car>();
		cars.put("audi", new Car("audi", 452000));
		cars.put("baoma", new Car("baoma", 15260000));
	}

	public Car getCar(String brand) {
		return cars.get(brand);
	}
}

配置：

<!-- 配置实例工厂的实例 -->
<bean id="instanceFactory" class="com.shaohe.spring.beans.factory.InstanceFactory"></bean>

<!-- 实例工厂方法来创建 bean 实例 -->
<!--factory-bean 指向工厂 bean, factory-method 指定工厂方法  -->
<bean id="car2" factory-bean="instanceFactory" factory-method="getCar">
	<!-- 通过 constructor-arg 执行调用工厂方法需要传入的参数 -->
	<constructor-arg value="baoma"></constructor-arg>
</bean>

11、FactoryBean配置 Bean

创建一个FactoryBean

public class CarFactoryBean implements FactoryBean<Car> {

	/**
	 * 返回bean实例
	 */
	@Override
	public Car getObject() throws Exception {
		return new Car("BMW", 540000);
	}

	/**
	 * 返回bean类型
	 */
	@Override
	public Class<?> getObjectType() {
		return Car.class;
	}

	/**
	 * 返回是否单例
	 */
	@Override
	public boolean isSingleton() {
		return true;
	}

}

配置bean

<!-- 
	通过FactoryBean来配置Bean的实例
	class：指向FactoryBean的全类名
	property可以注入属性
	实例返回的实例对象是通过FactoryBean的getObject方法
-->
<bean id="car" class="com.shaohe.spring.beans.factorybean.CarFactoryBean"></bean>

12、通过注解来配置Bean

（1）组件注解

• 组件扫描(component scanning):  Spring 能够从 classpath 下自动扫描, 侦测和实例化具有特定注解的组件. 
• 特定组件包括：@Component: 基本注解, 标识了一个受 Spring 管理的组件、@Respository: 标识持久层组件、@Service: 标识服务层(业务层)组件、@Controller: 标识表现层组件
• 对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称
• 当在组件类上使用了特定的注解之后, 还需要在 Spring 的配置文件中声明 <context:component-scan> ：base-package 属性指定一个需要扫描的基类包，Spring 容器将会扫描这个基类包里及其子包中的所有类. 当需要扫描多个包时, 可以使用逗号分隔.

注解：

声明 <context:component-scan> ：

<context:component-scan base-package="com.shaohe.spring.beans.annotation"></context:component-scan>

调用：

public static void main(String[] args) {
	ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("bean-annotation.xml");
	// Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称
	TestObject obj = (TestObject) ctx.getBean("testObject");
	System.out.println(obj);
	UserService userService = (UserService) ctx.getBean("userServiceImpl");
	System.out.println(userService.getUserName());
	System.out.println(userService);
}

如果仅希望扫描特定的类而非基包下的所有类，可使用 resource-pattern 属性过滤特定的类，示例：

<context:include-filter> 子节点表示要包含的目标类
<context:exclude-filter> 子节点表示要排除在外的目标类
<context:component-scan> 下可以拥有若干个 <context:include-filter> 和 <context:exclude-filter> 子节点

<context:include-filter> 和 <context:exclude-filter> 子节点支持多种类型的过滤表达式

（2）自动装配

<context:component-scan> 元素还会自动注册 AutowiredAnnotationBeanPostProcessor 实例, 该实例可以自动装配具有 @Autowired 和 @Resource 、@Inject注解的属性

1、@Authwired

• 构造器，普通字段(即使是非 public)，一切具有参数的方法都可以应用@Authwired 注解
• 默认情况下, 所有使用 @Authwired 注解的属性都需要被设置. 当 Spring 找不到匹配的 Bean 装配属性时, 会抛出异常, 若某一属性允许不被设置, 可以设置 @Authwired 注解的 required 属性为 false

• 默认情况下, 当 IOC 容器里存在多个类型兼容的 Bean 时, 通过类型的自动装配将无法工作. 此时可以在 @Qualifier 注解里提供 Bean 的名称. Spring 允许对方法的入参标注 @Qualifiter 已指定注入 Bean 的名称

• @Authwired 注解也可以应用在数组类型的属性上, 此时 Spring 将会把所有匹配的 Bean 进行自动装配、
• @Authwired 注解也可以应用在集合属性上, 此时 Spring 读取该集合的类型信息, 然后自动装配所有与之兼容的 Bean. 
• @Authwired 注解用在 java.util.Map 上时, 若该 Map 的键值为 String, 那么 Spring 将自动装配与之 Map 值类型兼容的 Bean, 此时 Bean 的名称作为键值

2、@Resource、@Inject

• @Resource、@Inject 两个注解和 @Autowired 注解的功用类似
• @Resource 注解要求提供一个 Bean 名称的属性，若该属性为空，则自动采用标注处的变量或方法名作为 Bean 的名称
• @Inject 和 @Autowired 注解一样也是按类型匹配注入的 Bean， 但没有 reqired 属性
• 建议使用 @Autowired 注解

13、泛型依赖注入

Spring 4.x 中可以为子类注入子类对应的泛型类型的成员变量的引用

父类：

//Service层
public class BaseService<T> {

	@Autowired
	private BaseDao<T> baseDao;

	public void add(T entity) {
		System.out.println("service add... ：" + baseDao);
		baseDao.add(entity);
	}

}
//DAO层
public class BaseDao<T> {

	public void add(T entity) {
		System.out.println("dao add..." + entity);
	}
}

子类：

@Service
public class UserService extends BaseService<User> {

}


@Repository
public class UserDao extends BaseDao<User> {

}

调用：

public class MainGeneric {

	public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("bean-generic.xml");
		UserService userService = (UserService) ctx.getBean("userService");
		userService.add(new User());
	}
}

父类建立的引用关系，BaseService引用BaseDao。在子类UserService和UserDao注入的泛型User在父类中自动注入。

14、整合多个配置文件

• Spring 允许通过 <import> 将多个配置文件引入到一个文件中，进行配置文件的集成。这样在启动 Spring 容器时，仅需要指定这个合并好的配置文件就可以。
• import 元素的 resource 属性支持 Spring 的标准的路径资源