Aware接口

定义：Spring中提供了一些以Aware结尾的接口，实现了Aware接口的Bean在被初始化后，可以获取相应资源，通过Aware接口，可以对Spring相应资源进行操作（慎重）,前提配置<bean>标签，并使用ioc容器去记性加载。

ApplicationContextAware:Bean类实现该接口，通过该接口提供的方法，可以直接获取spring上下文，而不用我们自己手动创建。

BeanNameAware:Bean类实现该接口，通过该接口提供的方法，可以直接获取<bean>标签的Id。

ApplicationEventPublisherAware:提供事件的发布。

BeanClassLoaderAware:找到相关的类加载器。

案例：通过传入的Bean的ID和传入的ApplicationContext对象，来获取Bean的对象（原理:IOC容器加载配置文件，通过<bean>标签，去实例化Bean，由于实现了XXXAware接口，通过setXXX方法，去获取相应的资源）

public class MoocApplicationContext implements ApplicationContextAware,BeanNameAware {

private String name;（通过这种方式就可以在其他方法中进行使用该对象，例如判断某个对象是否存在）

@Override

public void setApplicationContext(ApplicationContext ac) throws BeansException {

System.out.println("setApplicationContext的ApplicationContext："+ac.hashCode());

System.out.println(ac.getBean(this.name,MoocApplicationContext.class));

}

@Override

public void setBeanName(String name) {

this.name=name;

System.out.println("setBeanNamename的方法"+name);

}

}

xml:

   <bean id="moocApplicationContext" class="MoocApplicationContext" ></bean>

测试：

@Test

public void testMooc(){

ApplicationContext ac=new ClassPathXmlApplicationContext("spring-ioc.xml");

System.out.println("test的ApplicationContext:"+ac.hashCode());

}

结果：

setBeanNamename的方法moocApplicationContext

setApplicationContext的ApplicationContext：1516607441

MoocApplicationContext@4c7335b1

test的ApplicationContext:1516607441

Spring Bean装配之Bean的配置项及作用域

Bean的常用配置项（包括这些配置的含义和作用）

Id:整个IOC容器中Bean的唯一标识。

Class:具体实现的哪一个类，这里为类的路径（理论上只配置Class即可）。

Scope：Bean的作用域。

Constructor arguments：构造器的参数。

Properties：属性。

Autowiring mode:自动装配的模式。

lazy-initialization mode：懒加载模式。

Initialization/destruction method:初始化和销毁方法。

从IOC容器中获取对象的两种方式：

1、通过Id来获取，必须配置Id。

2、通过Bean的类型来获取，只配置Class即可。

Bean的作用域

singleton：单例，指一个IOC容器（ApplicationContext）中只存在一个标识singleton的对象（默认为单例模式）。

prototype:每次请求（通过getBean()方法）创建一个实例的时候，都会获得一个不同的对象，destroy方式不生效（请求完成后，这个实例也就不会再使用了，会被垃圾回收器回收）。

request：每次http请求创建一个实例，仅在当前的request内有效（request范围内，向IOC容器中获取这个对象，都是同一个实例，当有另一个的request请求，则会创建一个新的实例）。

session：同上，每次http请求创建，当前session内有效。

global session：基于portlet的web中有效（Spring对portlet也提供了支持），如果在单独的web应用中，golbal session和session作用域一样。

portlet定义了global session扩展：portlet更多做应用的集成，比如ON系统、HR系统、财务系统等等，通常在一个企业内部，不会每一个系统都去进行登录，所以就会使用porlet，把每一个常用的功能都列在里面,做成一个单点登录，点击相应任一区域或链接，跳到相应系统中，这其实就是两个系统两个Web应用了，所以这一定不会是一个session，所以global session就是指这种情况下session的作用范围。

Spring官网对作用域的解释

Bean的生命周期

Bean的自动装配

Resource和ResourceLoader（IOC加载资源文件（Spring的XML配置文件）用到的类，也可以加载其他资源文件）

Spring注入概念:指在启动Spring容器加载bean配置的时候，完成对变量的复制行为。（扫描xml文件中的bean标签时，实例化对象的同时，完成成员变量的赋值）

Spring常用的注入方式：

设值注入：通过一个属性或者成员变量的Set方法进行注入

<bean id="injectionService" class="com.imooc.ioc.injection.service.InjectionServiceImpl">

<property name="injectionDAO" ref="injectionDAO"/>

</bean>

<bean id="injectionDAO" class="com.imooc.ioc.injection.dao.InjectionDAOImpl">

</bean>

构造注入

<bean id="injectionService" class="com.imooc.ioc.injection.service.InjectionServiceImpl">

<constructor-arg name="injectionDAO" ref="injectionDAO"/>

</bean>

<bean id="injectionDAO" class="com.imooc.ioc.injection.dao.InjectionDAOImpl">

</bean>

一、接口及面向接口编程

接口:

1、用于沟通的中介物的抽象化。（相当于中间者，外部与接口沟通，但不与接口实现类进行沟通）

2、实体把自己提供给外界的一种抽象化说明，用以由内部操作分离出外部沟通方法，使其能被修改内部而不影响外界其他实体与其交互的方式（接口提供外部功能，至于内部的具体实现不对外公开，比如：注册，只需要提供手机号、密码等信息就可以进行注册，具体怎么实现的，逻辑怎样判断的，数据存储在哪里等具体实现逻辑不对外公开）

3、对应java接口即声明，声明了哪些方法是对外公开提供的，在Java8中，接口可以拥有方法体，（某种程度上和抽象类具有相似的功能）。

面向接口编程：

1、结构设计中，分清层次及调用关系，每层只向外（上层）提供一组功能接口，各层间仅依赖接口而非实现类。（多态的体现）

2、优点：接口实现的变动不影响各层间的调用，这一点在向外提供公共服务或者在企业内部提供公共服务中尤为重要，由于公共服务，所以稳定性一定很重要（对外提供接口保证了接口的稳定性，对于接口的实现可以根据某一时期的具体情况或者某一时期具体逻辑的变化进行调整）

3、面向接口编程中的“接口”：用于隐藏具体实现和实现多态性的组件，面向接口编程在IOC中应用非常广泛（对外提供调用说明的，但不包含具体的实现，具体的实现由接口实现类完成）

二、什么是IOC

IOC概念：（Inversion of Control）控制反转，控制权的转移，应用程序本身不负责依赖对象的创建和维护，而是由外部容器负责创建（创建对象并且组装对象之间的依赖关系）和维护（正常情况下使用对象则需要new对象，而使用外部容器之后，对象就被容器管理了，包括对象的创建、初始化、销毁等，对象就可以直接从容器中直接拿过来用），IOC容器在初始化时，会创建一系列的对象，同时把对象之间的依赖关系通过注入的方式组织起来。（组装：一个类A，和一个类B，类A把类B作为自己的属性，当IOC进行实例化时，先实例化A，再实例化B，再把B注入到A中）

比喻：我们手动去new一个对象，就像我们想要一所房子，我们自己手动的买材料去建造，而使用容器之后，就像找开发商，直接可以入住房子。

DI概念：(Dependency Injection)依赖注入，控制反转的一种实现方式，获得依赖对象的过程由自身管理变为了由IOC容器主动注入，所谓依赖注入，就是由IOC容器在运行期间，动态地将某种依赖关系注入到对象之中。

IOC目的：创建对象并且组装对象之间的关系（IOC容器在初始化时，会初始化一系列的对象，同时能把对象之间的依赖关系通过注入的方式组织起来）例如：一个类A里存在另一个类B的声明，IOC会负责创建A和B的对象，并通过A的构造方法注入B的实例。

Spring官网给出IOC工作原理

描述IOC

三、Spring的Bean配置

1、在IOC容器中所有的对象都称为Bean。

2、Spring的Bean配置方式有两种：基于XML配置、注解配置。

3、XML中配置：<bean id="bean的唯一标识",class="交给容器管理的类的路径"></bean>

四、Bean容器的初始化

基础：两个包：

org.springframework.beans

org.springframework.context

beans提供BeanFactory及其子类，它提供配置结构和基本功能，并加载初始化Bean

context提供ApplicationContext及实现类保存了Bean对象并在Spring中被广泛使用

初始化ApplicationContext方式：

1、加载本地文件（指定磁盘下某路径下的xml文件）

2、Classpath（相对路径，相对项目的路径）

3、Web应用中依赖servlet或Listener初始化Bean容器（两种方式，任选其一）

例子：

Spring Bean装配之Spring对JSR支持的说明

1：Spring支持使用JSR-250@Resource注解，通常用于成员变量和set方法上，这是一种在JavaEE5和6的通用模式（当然7也是支持的），Spring对对象的管理也支持这种方式。

2：@Resource有一个name属性，并且Spring默认把该name作为被注入bean的名称（如果没有显示指定name属性，默认名称是属性名或者set方法名，默认是根据注解的位置）。

3：注解提供的名字被解析为一个Bean的名称（@Resource的name属性），这个过程是由ApplicationContext中的CommonAnnotationBeanPostProcessor发现并处理的。

@PostConstruct和@PreDestroy

1:CommonAnnotationBeanPostProcessor不仅能识别JSR-250中的生命周期注解@Resource，在Spring2.5中引入支持初始化回调和销毁回调，前提是CommonAnnotationBeanPostProcessor这个类已经在Spring的ApplicationContext中注册了。（只有CommonAnnotationBeanPostProcessor类在IOC容器中注册了，才能处理@Resource，@PostConstruct，@PreDestroy）。

注意：自动注入，用Map<String,Object>map盛放所有的容器中的bean，然后循环打印所有的bean所属的类就能看到这个类了org.springframework.context.annotation.CommonAnnotationBeanPostProcessor，有这个类的bean。

@PostConstruct和@PreDestroy:这两个注解一般在的方法上，在初始化Bean和销毁之前，都会去调用这两个注解下的方法。

案例：（@Resource案例）

步骤1：

@Component

public class JsrDao {

public void print(){

System.out.println("JsrDao的方法执行了");

}

}

@Component

public class JsrService {

// @Resource

private JsrDao jsrDao;

public void print(){

jsrDao.print();

}

@Resource

public void setJsrDao(JsrDao jsrDao) {

this.jsrDao = jsrDao;

}

}

步骤2：

@Configuration

@ComponentScan

public class JsrConfig {

}

测试：

public class TestJsr {

@Test

public void testJsr(){

ApplicationContext ac=new AnnotationConfigApplicationContext(JsrConfig.class);

JsrService js=ac.getBean("jsrService",JsrService.class);

js.print();

}

}

结果：JsrDao的方法执行了

知识拓展：

@Resource和@Autowired都是做bean的注入时使用，其实@Resource并不是Spring的注解，它的包是javax.annotation.Resource，需要导入，但是Spring支持该注解的注入。

1、共同点

两者都可以写在字段和setter方法上。两者如果都写在字段上，那么就不需要再写setter方法。

2、不同点

（1）@Autowired

@Autowired为Spring提供的注解，需要导入包org.springframework.beans.factory.annotation.Autowired;只按照byType注入。

public class TestServiceImpl {    // 下面两种@Autowired只要使用一种即可    @Autowired    private UserDao userDao; // 用于字段上         @Autowired    public void setUserDao(UserDao userDao) { // 用于属性的方法上         this.userDao = userDao;     } }

@Autowired注解是按照类型（byType）装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它的required属性为false。如果我们想使用按照名称（byName）来装配，可以结合@Qualifier注解一起使用。如下：

public class TestServiceImpl {     @Autowired     @Qualifier("userDao")    private UserDao userDao;  }

（2）@Resource

@Resource默认按照ByName自动注入，由J2EE提供，需要导入包javax.annotation.Resource。@Resource有两个重要的属性：name和type，而Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以，如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不制定name也不制定type属性，这时将通过反射机制使用byName自动注入策略。

public class TestServiceImpl {    // 下面两种@Resource只要使用一种即可     @Resource(name="userDao")    private UserDao userDao; // 用于字段上         @Resource(name="userDao")    public void setUserDao(UserDao userDao) { // 用于属性的setter方法上         this.userDao = userDao;     } }

注：最好是将@Resource放在setter方法上，因为这样更符合面向对象的思想，通过set、get去操作属性，而不是直接去操作属性。

@Resource装配顺序：

①如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。

②如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。

③如果指定了type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。

④如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配。

@Resource的作用相当于@Autowired，只不过@Autowired按照byType自动注入。

@PostConstruct和@PreDestroy（和以上案例相似，主要增加两个方法，并关闭Spring上下文）

@Component

public class JsrService {

@Resource

private JsrDao jsrDao;

public void print(){

jsrDao.print();

}

public void setJsrDao(JsrDao jsrDao) {

this.jsrDao = jsrDao;

}

@PostConstruct

public void jsrInit(){

System.out.println("Bean初始化方法执行了");

}

@PreDestroy

public void jsrDestroy(){

System.out.println("Bean销毁方法执行了");

}

}

测试：

@Test

public void testJsr(){

AbstractApplicationContext ac=new AnnotationConfigApplicationContext(JsrConfig.class);

JsrService js=ac.getBean("jsrService",JsrService.class);

js.print();

ac.close();

}

结果：（和XML文件配置的init-method和destroy-method一样的功能）

Bean初始化方法执行了

JsrDao的方法执行了

Bean销毁方法执行了

使用JSR330标准注解

1：从Spring3.0开始支持JSR330标准注解（依赖注入注解），其扫描方式与Spring注解一致。

2：使用JSR330需要依赖javax.inject包。

3：使用Maven引入方式如下。

@Inject注解：等效于@Autowired，可以使用于类、属性、方法、构造器上。

@Named注解：使用特定名称进行依赖注入，与@Qualifier是等效的，还可以注解在类上，相当于@Component。（同一种类型的Bean在IOC容器中有多个时候，可以使用@Named指定特定的Bean）

在方法上：

在类上：

案例：@Inject和@Named

把@Componet换成@Named，@Resource换成Inject，执行结果相同。

基于泛型的自动装配（Spring4新增的内容，和SPI使用方式相似，只不过Spring提供了更简便的使用方式。API:应用编程接口。SPI：针对服务框架开发或者一些工具的基础使用的特殊类型接口。）

基于依赖对象泛型的自动装配案例

步骤1：

public class IntegerStore {

}

public class StringStore{

@Autowired

private IntegerStore s2;

public void print(){

System.out.println("s2:  "+s2);

}

}

步骤2：

@Configuration

public class StoreConfig {

@Bean

public StringStore stringStore(){

return new StringStore();

}

@Bean

public IntegerStore integerStore(){

return new IntegerStore();

}

}

步骤4：测试

@Test

public void testStore(){

ApplicationContext ac=new AnnotationConfigApplicationContext(StoreConfig.class);

StringStore ss=ac.getBean("stringStore",StringStore.class);

ss.print();

}

结果：（如果不加@Autowired注解，s2:为空）

s2:  IntegerStore@3323f4c5

基于集合泛型的自动装配（注意：不能使用@Autowired注解，要使用@Resource注解，并且使用@Resource(name="名字1")，去匹配@Bean(name="名字1")。

步骤1：

public class IntegerStore {

}

public class StringStore {

public StringStore() {

System.out.println("无参构造方法执行了");

}

private List<IntegerStore> list;

@Resource(name = "ll")

public void setList(List<IntegerStore> list) {

this.list = list;

}

public void print() {

for (IntegerStore store : list) {

System.out.println(store);

}

}

}

步骤2：

@Configuration

public class StoreConfig {

@Bean(name = "ll")

public List<IntegerStore> ll() {

List<IntegerStore> lis = new ArrayList<IntegerStore>();

lis.add(new IntegerStore());

lis.add(new IntegerStore());

lis.add(new IntegerStore());

return lis;

}

@Bean(name = "stringStore")

public StringStore stringStore() {

return new StringStore();

}

}

测试：

@Test

public void testStore() {

ApplicationContext ac = new AnnotationConfigApplicationContext(StoreConfig.class);

StringStore ss = ac.getBean("stringStore", StringStore.class);

ss.print();

}

}

结果：

无参构造方法执行了

IntegerStore@2b2c8b14

IntegerStore@795ee430

IntegerStore@44d74990

Autowired扩展——自定义qualifier注解（自定义自动化注入配置）

Advisors

1、advisor就像一个小的自包含的方面，只有一个advice。

2、切面自身通过一个bean表示，并且必须实现某个advice接口，同时，advisor也可以很好的利用AspectJ的切入点表达式（后面介绍AspectJ实现AOP时会介绍到AspectJ的切入点表达式）。

3、Spring通过配置文件中<aop:advisor>元素支持advisor，实际使用中，大多数情况下它会和transactional advice（事物相关的advice）配合使用（也可以有其他使用方式，根据项目或者工程的实际情况来决定）。

4、为了定义一个advisor的优先级以便让advice可以有序，可以使用order属性来定义advisor的顺序。

advisor的配置（<tx:advice>是对于事物的相关声明，通过这种方式使用advisor，这种方式是在使用Spring事物的控制时，经常使用的方式）

案例：（没有讲解advisor的案例，讲解了环绕通知的一个案例，适用场景：统计逻辑功能方法的调用次数，例如统计某方法调用3次，就不让调用了）

步骤1：

public class ServiceFunction {

public void print1(){

System.out.println("逻辑功能方法1执行了");

}

public void print2(){

System.out.println("逻辑功能方法2执行了");

throw new RuntimeException();

}

}

步骤2：

public class AspectFunction {

private int max_times;

public int getMax_times() {

return max_times;

}

public void setMax_times(int max_times) {

this.max_times = max_times;

}

public Object aspectFunction(ProceedingJoinPoint pjp) throws Throwable{

int num_times=0;

do{

num_times++;

try{

System.out.println(num_times+"次");

return pjp.proceed();

}catch(RuntimeException e){

}

}while(num_times<=max_times);

System.out.println("方法总共执行了"+num_times+"次");

return null;

}

}

步骤3：

Introductions应用（简介的advice，作用：在不改变对象和类的代码的前提下，为对象和类添加新的方法。）

Introduction定义：简介允许一个切面声明一个实现指定接口的通知对象，并且提供一个接口实现类(接口的实现类，来代表实例化好的Bean)来代表这些对象。

Introductions的实现：由<aop:aspect>中的<aop:declare-parents>元素声明，该元素用于声明所有匹配的类型，拥有一个新的parent（接口声明的对象可以指向getBean获得的对象）。

<aop:declare-parents>属性

type-matching="expression表达式（表示匹配什么样的类型）。

implement-interface="接口的路径"（切面类的接口）。

default-impl=“切面类的路径”。

案例：

步骤1：编写逻辑功能接口（限制逻辑功能），并提供它的实现类。

public interface ServiceInterfaceFunction {

public void print();

}

public class ServiceFunction implements ServiceInterfaceFunction {

@Override

public void print() {

System.out.println("逻辑功能接口实现类的方法执行了");

}

}

public class ServiceGongNeng {

}

步骤2：配置<aspect:config>（有接口的SpringAOP实现，使用JavaSE动态代理，也就是JDK代理，JDK动态代理只能对实现了接口的类生成代理，而不能针对类，所以要配置<aop:declare-parents>）。

步骤3:测试

@Test

public void testaop(){

ApplicationContext ac=new ClassPathXmlApplicationContext("spring-aop-schema-advice.xml");

ServiceInterfaceFunction sif=(ServiceInterfaceFunction)ac.getBean("serviceGongNeng",ServiceGongNeng.class);

sif.print();

}

结果：正常可以执行接口实现类里的方法。（注意：types-matching="springAOP.ServiceGongNeng"没有execution）

重点扩展：所有基于配置文件的aspects，只支持单例模式（Single Model）。

Advice应用下

Around advice(环绕通知):切面方法的第一个参数必须是ProceedingJoinPoint类型。（并且在这个切面方法里，有一个proceed（）方法：当前业务方法的返回值，无论是void类型还是其他类型返回值，都使用Object retVal=pjp.proceed()这种方式，业务方法执行前（这行代码前）业务方法执行后（这行代码后），都可以做我们的切面功能，最后返回retVal对象。）

Around advice案例（配置了环绕通知，抛出异常通知就无效了，因为环绕通知的方法始终有返回值，pjp.proceed()表示逻辑方法的执行，如果逻辑方法抛出异常，根据是否要进行处理在环绕通知的方法里进行捕获或者往外抛出）

步骤1：spring配置

步骤2：切面的环绕通知方法。

public Object aroundAspect(ProceedingJoinPoint pjp){

Object obj=null;

try {

System.out.println("切面的前环绕通知功能实现了");

obj = pjp.proceed();

System.out.println("切面的后环绕通知功能实现了");

} catch (Throwable e) {

e.printStackTrace();

}

return obj;

}

Advice parameters（通知方法里的参数）：逻辑功能方法的参数，通过配置，可以传入到切面的通知方法里。

案例（环绕通知参数）

步骤1：编写逻辑功能的方法，并有两个参数。

步骤2：编写配置文件，切面、环绕通知等（注意：配置方法里的参数名要和逻辑方法参数名相同，并且环绕通知方法名和参数名相同）。

测试：

@Test

public void test(){

ApplicationContext ac=new ClassPathXmlApplicationContext("spring-aop-schema-advice.xml");

ServiceFunction sf=ac.getBean("serviceFunction",ServiceFunction.class);

sf.serviceFunction("小明",5);

}

结果：

切面前置通知功能实现了

名字为小明

5次

切面的前环绕通知功能实现了

逻辑功能实现了

切面的后环绕通知功能实现了

切面后置通知功能实现了

切面返回后通知功能实现了

Advice应用（advice的配置）

Before advice的两种配置方式

<aop:before  pointcut-ref="切入点的Id"  method="切面的方法"/>。直接设置切入点（就不用单独设置<aop:point-cut/>标签了）

<aop:before  pointcut="execution(*  com.xyz.myapp.dao..(..))"  method="doAccessCheck"/>

案例：（前置）

步骤1：编写逻辑功能类、切面功能类、并编写各自的方法。

代码：

步骤2：编写XML配置，实例化逻辑功能类的Bean和切面功能类的Bean，配置切面、切入点、通知。

案例：（After return advice返回后通知）

<aop:after-returning>returning属性，限制方法的返回值，例如retVal。（arg-names为参数名称，它是严格匹配的。）

步骤1：编写逻辑功能类、切面功能类、并编写各自的方法（和以上相似，只不过切面类多了一个方法）。

步骤2：编写XML配置，实例化逻辑功能类的Bean和切面功能类的Bean，配置切面、切入点、通知。

案例：（抛出异常后通知After throwing advice，<aop:after-throwing>标签多了一个throwing属性，它是限制可被传递的异常参数名称）

步骤1：编写逻辑功能类、切面功能类、并编写各自的方法（编写发生异常后切面要执行的方法）

步骤2：编写XML配置，实例化逻辑功能类的Bean和切面功能类的Bean，配置切面、切入点、抛出异常通知。

案例：（后置通知After (finally） advice)

步骤1：编写逻辑功能类、切面功能类、并编写各自的方法（编写逻辑方法执行后要执行的切面方法）

步骤2：编写XML配置，实例化逻辑功能类的Bean和切面功能类的Bean，配置切面、切入点、抛出异常通知。

案例：（环绕通知After (finally） advice)

步骤1：编写逻辑功能类、切面功能类、并编写各自的方法（编写逻辑方法执行后要执行的切面方法）

步骤2：编写XML配置，实例化逻辑功能类的Bean和切面功能类的Bean，配置切面、切入点、抛出异常通知。