Spring框架完全掌握(上)

zoukankan html css js c++ java

Spring框架完全掌握(上)
引言

前面我写了一篇关于Spring的快速入门，旨在帮助大家能够快速地了解和使用Spring。既然是快速入门，讲解的肯定只是一些比较泛的知识，那么对于Spring的一些深入内容，我决定将其分为上、下两部分，希望能帮到你们。

Bean的作用域

作用域相信大家都了解，我们先来看一个案例。
创建一个bean类：
```
package com.itcast.spring.bean.scope;

public class Car {

	private String brand;
	private String corp;
	private double price;
	private int maxSpeed;

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public String getCorp() {
		return corp;
	}

	public void setCorp(String corp) {
		this.corp = corp;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	public int getMaxSpeed() {
		return maxSpeed;
	}

	public void setMaxSpeed(int maxSpeed) {
		this.maxSpeed = maxSpeed;
	}

	@Override
	public String toString() {
		return "Car [brand=" + brand + ", corp=" + corp + ", price=" + price + ", maxSpeed=" + maxSpeed + "]";
	}
}
```
在配置文件中进行配置：
```
<?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="car" class="com.itcast.spring.bean.scope.Car">
		<property name="brand" value="BMW"></property>
		<property name="corp" value="ShangHai"></property>
		<property name="price" value="350000"></property>
		<property name="maxSpeed" value="240"></property>
	</bean>

</beans>
```
接下来编写测试代码：
```
public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-scope.xml");
		Car car = (Car) ctx.getBean("car");
		Car car2 = (Car) ctx.getBean("car");
		System.out.println(car == car2);
}
```
运行结果：
```
true
```
从这里我们得知，从容器中取出的两个Car其实是同一个对象，这是为什么呢？
这就涉及到bean的作用域，其实默认情况下Spring会给bean设置一个作用域singleton，此时的bean是一个单例的bean，也就是说在整个容器中这个bean只会存在一个实例。我们可以通过bean节点中的scope属性来设置bean的作用域。
```
<?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="car" class="com.itcast.spring.bean.scope.Car" scope="prototype">
		<property name="brand" value="BMW"></property>
		<property name="corp" value="ShangHai"></property>
		<property name="price" value="350000"></property>
		<property name="maxSpeed" value="240"></property>
	</bean>

</beans>
```
这里我将bean的作用域设置为了prototype，意思是原型的，也就就说，在这种情况下，每次去容器中获取bean，它都会返回一个新的对象。
我们重新运行测试代码，会发现结果为false，验证了刚才的结论。

使用外部属性文件

在配置文件里配置bean时，有时候需要在bean的配置里混入系统部署的细节信息，而这些部署细节实际上需要和bean相分离。
对于这样的需求，Spring提供了一个PropertyPlaceholderConfigurer的BeanFactory后置处理器，这个处理器允许用户将bean配置的部分内容外移到属性文件中，可以在bean配置文件里使用形式为${var}的变量，PropertyPlaceholderConfigurer从属性文件中加载属性，并使用这些属性来替换变量。
假设我现在需要在Spring配置文件中配置关于数据库连接的基本信息，此时我们应该将这些基本信息抽取成一个属性文件(db_info.properties)放在外面：
```
user=root
password=123456
url=jdbc:mysql:///test
driver=com.mysql.jdbc.Driver
```
然后配置一下c3p0的bean类：
```
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	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-4.0.xsd">

	
	<context:property-placeholder location="classpath:db_info.properties"/>
	
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="user" value="${user}"></property>
		<property name="password" value="${password}"></property>
		<property name="driverClass" value="${driver}"></property>
		<property name="jdbcUrl" value="${url}"></property>
	</bean>

</beans>
```
编写测试代码：
```
public static void main(String[] args) throws SQLException {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-properties.xml");
		ComboPooledDataSource dataSource = (ComboPooledDataSource) ctx.getBean("dataSource");
		System.out.println(dataSource.getConnection());
	}
}
```
运行结果：
```
com.mchange.v2.c3p0.impl.NewProxyConnection@35a50a4c
```
这样也能成功获取数据库连接，而且在之后的修改过程将非常方便，只需要去寻找连接数据库的属性文件即可。

SpEL

SpEL是Spring表达式语言，是一个支持查询和操作对象图的表达式语言。
它的语法类似于jsp中的EL，但它以#{}作为定界符，所有在大括号内的字符都将被认为是SpEL。
1.字面量
- 整数：<property name="count" value="#{5}"/>
- 小数：<property name="frequency" value="#{88.8}"/>
- 科学计数法：<property name="capacity" value="#{1e4}"/>
- 布尔值：<property name="enable" value="#{false}"/>
- 字符串：<property name="name" value="#{'value'}"/>
- 字符串：<property name="name" value="#{"value"}"/>
但如果仅仅是用于字面量的赋值而使用SpEL，会显得这是多此一举。所以一般不用作字面量的赋值。
2.引用bean及其属性和方法
- 引用其它对象
  <property name="prefix" value="#{prefixGenerator}"></property>
- 引用其它对象属性
  <property name="suffix" value="#{sequenceGenerator2.suffix}"></property>
- 引用其它对象方法
  <property name="suffix" value="#{sequenceGenerator2.toString}"></property>
- 引用其它对象的静态属性
  <property name="initValue" value="#{T(java.lang.Math).PI}"></property>
SpEL同时还支持运算符，例如：+、-、*、/、%等；支持逻辑运算符，例如and、or、not、if-else等；支持正则表达式。

Bean的生命周期

SpringIOC容器可以管理bean的生命周期，Spring允许在bean生命周期的特定点执行指定的任务。
SpringIOC容器对bean的生命周期进行管理的过程如下：
1. 通过构造器或工厂方法创建bean实例
2. 为bean的属性设置值和对其它bean的引用
3. 调用bean的初始化方法
4. bean可以使用了
5. 当容器关闭时，调用bean的销毁方法
很多人可能会奇怪，一个普通的bean类怎么会有初始化和销毁方法呢？这当然是没有的，只不过Spring提供了一种方式来指定bean的初始化和销毁方法。
我们编写一个案例感受一下。
创建一个bean类：
```
package com.itcast.spring.bean.cycle;

public class Car {

	private String brand;

	public Car() {
		System.out.println("Constructor...");
	}

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

	public void init() {
		System.out.println("init...");
	}

	public void destory() {
		System.out.println("destory...");
	}
}
```
在配置文件中进行配置：
```
<?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="car" class="com.itcast.spring.bean.cycle.Car"
		init-method="init" destroy-method="destory">
		<property name="brand" value="BMW"></property>
	</bean>

</beans>
```
编写测试代码：
```
public static void main(String[] args) {
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans-cycle.xml");
		Car car = (Car) ctx.getBean("car");
		System.out.println(car);
		
		//关闭IOC容器
		ctx.close();
	}
```
运行结果：
```
Constructor...
setBrand...
init...
com.itcast.spring.bean.cycle.Car@91161c7
八月 21, 2019 2:05:00 下午 org.springframework.context.support.AbstractApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@3f91beef: startup date [Wed Aug 21 14:05:00 CST 2019]; root of context hierarchy
destory...
```
从运行结果可以看出，容器首先构造出了Car类，然后为其设置了属性值，接着调用了init方法，最后在容器关闭的时候调用destory方法。需要注意的是，在Car类中的初始化和销毁方法并不一定非得写成init和destory，方法名可以是任意的，只需要在配置时指定初始化和销毁的方法即可。

对于bean的生命周期管理，Spring框架为我们提供了更加细粒度的操作——后置处理器。
bean后置处理器允许在调用初始化方法前后对bean进行额外的处理。而且它能够对IOC容器中的所有bean实例逐一处理，而非单一实例，其典型应用是：检查bean属性的正确性或根据特定的标准更改bean的属性。
添加了bean后置处理器之后的bean，它的生命周期将会发生变化，具体过程如下：
1. 通过构造器或工厂方法创建bean实例
2. 为bean的属性设置值和对其它bean的引用
3. 将bean实例传递给bean后置处理器的postProcessBeforeInitialization方法
4. 调用bean的初始化方法
5. 将bean实例传递给bean后置处理器的postProcessAfterInitialization方法
6. bean可以使用了
7. 当容器关闭时，调用bean的销毁方法
那么如何实现后置处理器呢？
创建一个类实现接口BeanPostProcessor：
```
package com.itcast.spring.bean.cycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

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;
	}
}
```
然后在配置文件中加上对后置处理器的配置：
```

<bean class="com.itcast.spring.bean.cycle.MyBeanPostProcessor"></bean>
```
这是一个比较特殊的bean，所以无需指定id，Spring会自动寻找该bean进行处理。
其它代码不用改动，接下来重新运行测试代码：
```
Constructor...
setBrand...
postProcessBeforeInitialization...:com.itcast.spring.bean.cycle.Car@77caeb3e,car
init...
postProcessAfterInitialization...:com.itcast.spring.bean.cycle.Car@77caeb3e,car
com.itcast.spring.bean.cycle.Car@77caeb3e
八月 21, 2019 2:17:28 下午 org.springframework.context.support.AbstractApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@3f91beef: startup date [Wed Aug 21 14:17:28 CST 2019]; root of context hierarchy
destory...
```
此时对于bean生命周期的掌控将更加到位。

FactoryBean实现配置Bean

Spring为我们提供了很多种方式配置bean，其中FactoryBean配置bean的方式也是十分常用的。如何实现呢？
创建类实现FactoryBean接口：
```
package com.itcast.spring.bean.factorybean;

import org.springframework.beans.factory.FactoryBean;

public class CarFactoryBean implements FactoryBean<Car> {

	@Override
	public Car getObject() throws Exception {
		return new Car("BMW",480000);
	}

	@Override
	public Class<?> getObjectType() {
		return Car.class;
	}

	@Override
	public boolean isSingleton() {
		return true;
	}
}
```
需要实现三个方法，分别返回对象实例，对象类型，和该对象是否为单例。
在配置文件中进行配置：
```
<?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="car" class="com.itcast.spring.bean.factorybean.CarFactoryBean">
		
	</bean>
	
</beans>
```
编写测试代码：
```
public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-beanfactory.xml");
		Car car = (Car) ctx.getBean("car");
		System.out.println(car);
}
```
运行结果：
```
Car [brand=BMW, price=480000.0]
```
这样的方法配置的bean是实现FactoryBean接口的类实例，得到的却是getObject方法返回的实例。

注解实现配置Bean

在Spring中还能够通过注解来配置bean，但在这之前，我们必须了解一下Spring中的组件扫描。
组件扫描(component scanning)：Spring能够从classpath路径下自动扫描、侦测和实例化具有特定注解的组件。
特定组件包括：
- @Component：基本注解，标识了一个受Spring管理的组件
- @Respository：标识持久层组件
- @Service：标识业务层组件
- @Controller：标识表现层组件
对于扫描到的组件，Spring有默认的命名策略：即使用非限定类名，第一个字母小写，也可以在注解中通过value属性值标识组件的名称。
虽然每个注解对应着相应的组件，但是Spring并不能准确识别出项目中的层级分布，也就是说，这些注解其实是可以随意使用的，但是为了规范，项目中还是会按照这个标准来使用。
当我们在组件类上使用的特定的注解之后，还需要在Spring的配置文件中声明<context:component-scan>
然后在该节点中设置base-package属性，该属性指定一个需要扫描的基类包，Spring容器将会扫描这个基类包及其子包下的所有类。当发现这些类中有对应的注解之后，Spring会管理这些类。
如果仅希望扫描特定的类而非基包下的所有类，可使用resource-pattern属性过滤特定的类，例如：
```
<context:component-scan
	base-package="com.itcast.spring.bean.annotation"
	resource-pattern="repository/*.class">
</context:component-scan>
```
它将只扫描repository包下的类。
<context:include-filter>和<context:exclude-filter>子节点还支持多种类型的过滤表达式。<context:include-filter>能够指定包含哪些指定表达式的组件；而<context:exclude-filter>能够指定排除哪些指定表达式的组件。
查看全文

相关阅读:
java8 日期时间之间的关系
 redis bind连不上的坑
 mysql 表结构转excel表格
 软件工程实践总结
 Beta答辩总结
 Beta 冲刺（7/7）
Beta 冲刺（6/7）
Beta 冲刺（5/7）
Beta 冲刺（4/7）
Beta 冲刺（3/7）

原文地址：https://www.cnblogs.com/blizzawang/p/11411516.html

Spring框架完全掌握(上)

引言

Bean的作用域

使用外部属性文件

SpEL

Bean的生命周期

FactoryBean实现配置Bean

注解实现配置Bean