Spring(4)

Spring的Bean的配置形式

1.基于XML的形式(无需讲解)

2.基于注解的形式(需要引入AOP的jar包，此jar包实现了AOP的注解)

当在Spring配置文件中引入类扫描注解命名空间并且指定被扫描的包，Spring就能够从classpath下自动扫描此包以及子包，侦测和实例化具有特定注解的组件

特定的组件包括：

--Component:基本注解，标识了一个受Spring管理的组件

--Respository:标识持久层组件

--Service:标识服务层(业务层)组件

--Controller:标识表现层组件

对于扫描到的组件，Spring有默认的命名策略

--如果未通过value属性标识组件的名称，那么会使用非限定类名，即取类名的首字母小写

--通过value属性标识组件名称

类扫描注解命名空间(Context命名空间)：

xmlns:context="http://www.springframework.org/schema/context"

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd">

类扫描注解解析器：

<context:component-scan base-package=""></context:component-scan>

如果希望扫描到指定包下的类而非基包下的所有的类，可以使用resource-pattern属性过滤掉特定的类

<context:component-scan base-package="cn.jc.spring.annotation" resource-pattern="xxx包名/*.class"></context:component-scan>

context注解解析器的子节点

--context:include-filter 表示要包含的目标类

--context:exclude-filter 表示要排除在外的目标类

该注解解析器下可以拥有若干个子节点，子节点支持多种类型的过滤表达式，常用的类别：annotation,assinable

<!-- <context:component-scan base-package="cn.jc.spring.annotation">
　　　　<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
　　</context:component-scan>

-->

<!-- <context:component-scan base-package="cn.jc.spring.annotation">
　　　　<context:exclude-filter type="assignable" expression="cn.jc.spring.annotation.repository.UserRepository"/>
　　 </context:component-scan>

-->

<context:component-scan base-package="cn.jc.spring.annotation" use-default-filters="false">
　　<context:include-filter type="assignable" expression="cn.jc.spring.annotation.repository.UserRepository"/>
</context:component-scan>

属性注解

<context:component-scan> 元素除了扫描包及其子包下的类并且将Bean交给Spring容器装配之外，还可以自动注册AutowiredAnnotationBeanPostProcessor实例的后置处理器，该实例可以自动装配

具有@Autowired和@Resource以及@Inject注解的属性

@Autowired注解属性可以放在任意的三个位置

首先会自动装配具有兼容类型的单个bean属性，也就是会根据类型去匹配IOC容器中被装配的Bean

其次如果是找不到，就会根据属性名称和IOC容器中被装配的bean的id的名称相匹配，如果相同则匹配成功

也可以使用注解@Qualifier("")指定属性的名称与所需的被装配的bean的id名称相同(这种情况下通常是在一个借口多个实现类的情况下，为了指明需要使用哪个实现类，可以使用注解@Qualifier("")属性指定使用哪个bean的id)，使用这个@Qualifier("")需要使用@Autowired，两个都需要的

--构造器

--普通字段(即使是非public)

直接在字段上加@Autowired，IOC容器会检查这个属性有没有被装配，如果被装配，则自动会给属性赋值

如果发现这个属性没有被IOC所装配，此时加了注解@Autowired会报错的，如果不想被报错，可以加上属性@Autowired(required=true)，输出的结果会是null

--带参数的方法(setter方法)

在setter方法上加@Autowired注解，IOC容器中如果属性被装配，那么就可以为属性赋值

如果是需要指定使用哪个bean对象，可以使用@Qualifier("")和@Autowired，放在setter方法上的

也可以把@Qualifier("")放在setter方法的带参数的旁边，这样也是可以的

举个例子：

@Autowired
public void setUserJdbcRepositoryImpl1(@Qualifier("userJdbcRepositoryImpl")UserRepository userJdbcRepositoryImpl1) {
this.userJdbcRepositoryImpl1 = userJdbcRepositoryImpl1;
}

除了@Autowired和@Qualifier("")可以为属性赋值之外，还可以使用@Resource(name=""),此属性名称要和IOC容器中被管理的bean的id的名字要相同，如果不指明name属性，就会根据类型相匹配

@Inject 也是根据类型匹配为属性赋值，但是没有required属性

Spring的Bean的配置方式

1.通过全类名的形式(反射机制)

id在IOC容器中必须是唯一的

如果id没有指定，Spring自动将权限定性类名作为Bean的名字

id可以指定多个名字，名字之间可以用逗号、分号或者空格隔开

2.通过工厂方法(静态工厂方法和实例工厂方法)

静态工厂方法：简单的说就是通过调用某个类的的静态的方法就可以返回Bean实例，在Spring的配置文件中需要配置静态工厂方法的全类名，指明静态方法，使用constructor-arg来配置静态方法传入的参数

例子：

Bean实例：

public class Car {

private String broad;

private double speed;

public Car(String broad, double speed) {

this.broad = broad;

this.speed = speed;

}

public Car() {

}

@Override

public String toString() {

return "Car [broad=" + broad + ", speed=" + speed + "]";

}

public void setBroad(String broad) {

this.broad = broad;

}

public void setSpeed(double speed) {

this.speed = speed;

}

静态工厂类：

/**

* 静态工厂方法：通过调用某个类的静态方法就可以返回Bean的实例

* */

public class StaticCarFactory {

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

static{

cars.put("audio", new Car("audio", 100));

cars.put("ford", new Car("ford", 200));

}

//静态方法

public static Car getCar(String name){

return cars.get(name);

}

Spring配置文件：

<!--

class属性：指向静态工厂方法的全类名

factory-method:指向静态工厂方法的名字

constructor-arg:如果工厂方法需要传入参数，则使用constructor-arg来配置参数

-->

<constructor-arg value="audio"></constructor-arg>

</bean>

测试类

ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factory.xml");

Car car = (Car)ctx.getBean("car1");

System.out.println(car);

实例工厂方法：先创建工厂对象本身，再调用工厂的实例方法来返回Bean实例

例子

实例工厂类：

/**

* 通过调用实例工厂的方法即先需要创建工厂对象本身，再调用工厂的实例方法来返回bean的实例

* */

public class InstanceCarFactory {

private Map<String, Car> cars = null;

public InstanceCarFactory(){

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

cars.put("audio", new Car("audio", 1000));

cars.put("fode", new Car("fode", 2000));

}

public Car getCar(String name){

return cars.get(name);

}

Spring配置文件：

<constructor-arg value="fode"></constructor-arg>

</bean>

测试类

Car car2 = (Car)ctx.getBean("car2");

System.out.println(car2);

3.通过FactoryBean的方式

通过实现FactoryBean的接口来调用getObject的方法，从而获取Bean实例

例子

实现FactoryBean接口的实现类

package cn.jc.spring.factorybean;

import org.springframework.beans.factory.FactoryBean;

/**

* 使用FactoryBean的方式来配置Bean

* 自定义的FactoryBean需要实现spring提供的FactoryBean接口

* */

public class CarFactoryBean implements FactoryBean<Car> {

private String brand;

public void setBrand(String brand){

this.brand = brand;

}

/**

* 返回bean的对象

public Car getObject() throws Exception {

return new Car(brand, 20000);

}

/**

* 返回bean的类型

public Class<?> getObjectType() {

return Car.class;

}

/**

* 是否是单实例的

public boolean isSingleton() {

return true;

}

Bean类：

package cn.jc.spring.factorybean;

public class Car {

private String broad;

private double speed;

public Car(String broad, double speed) {

this.broad = broad;

this.speed = speed;

}

public Car() {

}

@Override

public String toString() {

return "Car [broad=" + broad + ", speed=" + speed + "]";

}

public void setBroad(String broad) {

this.broad = broad;

}

public void setSpeed(double speed) {

this.speed = speed;

}

Spring配置文件：

<?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">

<!-- 通过FactoryBean来配置bean的实例

class：指向FactoryBean的全类名

property：配置FactoryBean的属性

返回的实例是FactoryBean的getObject()方法返回的实例

-->

</bean>

</beans>

测试main:

package cn.jc.spring.factorybean;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

public static void main(String[] args) {

ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factorybean.xml");

Car car = (Car)ctx.getBean("car");

System.out.println(car.toString());

}

依赖注入的方式

1.属性注入

2.构造器注入

　　。可以使用index和type来区分重载的构造器，注意构造器必须要有空的构造方法，因为IOC容器要调动空的构造方法创建对象

属性注入的细节

　。不管是字面值还是引用，赋值都可以使用元素<value/>或者<ref/>元素标签

　。如果字面值中包含特殊字符，可以使用<![CDATA[值]]>

　。可以使用专用的<null/>元素标签作为字符串或者对象的空值

　　<constructor-arg index="0" type="java.lang.String"><null/></constructor-arg>

　。支持级联属性赋值

</bean>

</property>

</bean>　

　。集合属性的赋值

<list>

<constructor-arg value="aodi"></constructor-arg>

<constructor-arg value="0.9"></constructor-arg>

</bean>

</list>

</property>

<list>

</list>

</property>

<set>

</set>

</property>

<map>

</map>

</property>

</bean>

<props>

<prop key="user">root</prop>

<prop key="password">root</prop>

<prop key="jdbcUrl">jdbc:mysql:///test</prop>

<prop key="driverClass">com.mysql.jdbc.Driver</prop>

</props>

</property>

</bean>

　。配置单例的集合bean

配置单例的集合bean，以供多个bean引用，需要打入util的命名空间

util的命名空间：

xmlns:util=“http://www.springframework.org/schema/util”

xsi:schemaLocation=“http://www.springframework.org/schema/util

http://www.springframework.org/schema/util/spring-util-2.5.xsd“

例子：

<util:list id="cars">

</util:list>

</bean>

　。使用P的命名空间

使用p的命名空间给属性赋值需要导入p的命名空间　　　

xmlns:p="http://www.springframework.org/schema/p"

例子：

</bean>

<constructor-arg index="0" type="java.lang.String" value="benchi"></constructor-arg>

<constructor-arg index="1" type="double" value="250"></constructor-arg>

</bean>

<!—单例的集合bean-->

<util:list id="cars">

</util:list>

自动装配

1.类型自动装配

2.名字自动装配

例子：

自动装配的缺点：

1.自动装配将会配置bean的所有的属性

2.autowire属性要么根据类型，要么根据名称，不可以两者兼而有之

Bean之间的关系

1.继承

继承bean，利用属性parent继承父bean的id值，可以拥有父bean的属性和属性值

并不是 <bean> 元素里的所有属性都会被继承. 比如: autowire, abstract 等.

2.依赖

依赖bean的配置（依赖bean会在本bean实例化之前创建好，依赖bean需要先配置好此bean。如果依赖于多个bean那么可以用逗号或者空格分开）：

bean的作用域

1.单例(singleton)

单例的bean，非延迟加载，当初始化SpringIOC容器的时候就创建了所有的唯一的实例(通过调用默认的构造方法)

2.多例(prototype)

多例的bean,延迟加载，当初始化SpringIOC容器之后，调用getBean方法之后，才会创建相应的实例对象(不唯一)

使用外部属性文件

spEL

SpringIOC容器中bean的生命周期

1.当初始化IOC容器(单例Bean),调用默认的构造函数，容器会创建单例的bean对象，如果scope是多例的，将会延迟加载，在getBean的时候才会创建对象并获取

2.为bean的属性赋值，通过调用setter方法

3.调用bean的初始化方法

4.当关闭spring的IOC容器的时候，调用销毁方法

Spring bean的后置处理器

当在Spring配置文件中配置了Spring bean的后置处理器之后，IOC容器对bean的管理周期将会更加的细致化

bean 的后置处理器允许在调用初始化方法的前后对bean进行额外处理，他是对IOC容器中的所有的bean实例逐一处理，而非处理单一实例，比如检查bean属性的正确性或者是更改bean属性。对bean处理完之后，可以返回最新的bean对象

具体的后置处理器需要实现BeanPostProcessor接口，并且覆盖两个方法，还需要在Spring的配置文件中配置Spring bean的后置处理器

public class MyBeanPostProcessor implements BeanPostProcessor {

@Override

public Object postProcessAfterInitialization(Object bean, String beanName)

throws BeansException {

Car car = new Car();

car.setBrand("fote");

System.out.println("postProcessAfterInitialization"+car+","+beanName);

return car;

}

@Override

public Object postProcessBeforeInitialization(Object bean, String beanName)

throws BeansException {

System.out.println("postProcessBeforeInitialization"+bean+","+beanName);

return bean;

}

实体类：

package cn.jc.spring.cycle;

public class Car {
private String brand;

public Car(){
System.out.println("cars constructor...");
}
public void setBrand(String brand){
System.out.println("setBrand...");
this.brand = brand;
}
public void init2(){
System.out.println("init....");
}
public void destory(){
System.out.println("destory...");
}

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

测试类：

package cn.jc.spring.cycle;

import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-cycle.xml");
Car car = (Car)ctx.getBean("carcar");
System.out.println(car);
ConfigurableApplicationContext cac = (ConfigurableApplicationContext)ctx;
cac.close();
}
}

此时Spring IOC容器对bean的生命周期的管理：

调用默认的构造函数，创建bean对象（scope单例非延迟），如果scope是多例时，将会延迟加载，在getBean时才会调用默认的构造方法，创建bean对象
为bean的属性赋值或者是对其他bean的引用
将 Bean 实例传递给 Bean 后置处理器的postProcessBeforeInitialization 方法
调用bean的初始化方法
将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法
可以使用Bean对象了
当关闭spring的IOC容器时，调用销毁方法

Spring4.x的新特性

泛型依赖注入

子类继承父类，子类注入，父类获取的是子类的泛型的对象

举个例子：

BaseService类：

package cn.jc.spring.generic.di;

import org.springframework.beans.factory.annotation.Autowired;

public class BaseService<T> {
@Autowired
protected BaseRepository<T> repository;
　　　　public void add(){
　　　　System.out.println("add ....");
　　　　System.out.println(repository);
　　}
}

BaseRespository类：

package cn.jc.spring.generic.di;

　　public class BaseRepository<T> {

}

UserService类

package cn.jc.spring.generic.di;

import org.springframework.stereotype.Service;

@Service
public class UserService extends BaseService<User> {

}

UserRepository

package cn.jc.spring.generic.di;

import org.springframework.stereotype.Repository;

@Repository
public class UserRepository extends BaseRepository<User> {

}

User类

package cn.jc.spring.generic.di;

　　public class User {

}

beans-generic-di.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"
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:component-scan base-package="cn.jc.spring.generic.di"></context:component-scan>

</beans>

Main 测试类

package cn.jc.spring.generic.di;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
　　　　public static void main(String[] args) {
　　　　ApplicationContext ac = new ClassPathXmlApplicationContext("beans-generic-di.xml");
　　　　UserService userService = (UserService)ac.getBean("userService");
　　　　userService.add();
　　}
}

输出的结果：

add ....
cn.jc.spring.generic.di.UserRepository@5684ce7a