回顾 Spring

什么是Spring?

 spring是一个为了简化企业级开发，它是轻量级的、使用IoC、AOP等进行开发的一站式框架。比如，控制反转&依赖注入、面向切面编程、spring事务管理、通过spring继承其他框架（Spring继承jdbc、mybatis等）。

什么是控制反转（IoC）和依赖注入（DI）?

依赖关系：当一个对象a的某些操作需要通过调用另一个对象b中的方法来实现时，说明a依赖于对象b，a与b是依赖关系。

IoC：控制反转

       使用者之前使用对象的时候都需要自己手动的创建和组装，而现在这些创建和组装都交给了spring容器来进行管理，需要使用这个对象的时候，我们可以直接去spring容器中查找使用这个对象。之前创建和组装对象都是我们自己手动的进行创建，现在交由spring来进行创建和组装了，对象的构建被反转了，就叫做控制反转。IOC是面向对象编程的一种设计原则，它可以降低系统代码的耦合度，使系统更加有利于维护和扩展。

        依赖注入是Spring容器中创建对象时给其设置依赖对象的方式，比如给Spring一个清单，清单中列出了需要创建B对象以及其他的一些对象（可能包含B类型中需要依赖的对象），此时spring 在创建B的时候，会看B对象需要依赖哪些对象，然后去spring容器中查找看没有这些对象，如果有就去将其创建好，然后将其传递给B对象；可能B需要依赖于很多对象，B创建之前完全不需要知道其他对象是否存在或者其他对象在哪里以及被他们是如何创建，而spring容器会将B依赖对象主动创建好并将 其注入到B中去，比如spring容器创建B的时候，发现B需要依赖于A，那么spring容器在清单中找到A的定义并将其创建好之后，注入到B对象中。

IOC容器

        IOC容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置，对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。我们不需要我们手动的创建对象，需要使用的对象都保存在IOC容器进行管理，当我们需要使用的时候直接从IOC容器中直接获取即可。

1. IoC将对象创建和组装的主动控制权交给了spring容器去做，避免我们自己手动的创建对象，创建对象的过程被反转了，降低了系统的耦合度，利于系统的维护和扩展。
2. DI依赖注入，表示spring容器中创建对象时给其设置依赖对象的方式，通过某些注入方式可以让系统更加灵活，比如自动注入等可以让系统变的很灵活，比如自动注入等可以让系统变的更加灵活。
3. Spring容器（IOC容器）：主要负责容器中对象的创建、组装、对象查找、对象生命周期的管理等操作。（IOC容器：主要对对象的整个生命周期进行管理，需要的时候直接从IOC容器中获取即可。）的IOC容器也叫spring容器。

Bean

Bean概念

       由Spring容器管理的对象称为Bean对象。

创建Bean对象

1. 通过反射机制创建bean对象
2. 通过静态工厂创建bean对象（可以创建静态工厂，内部提供一些静态方法来生成所需要的对象，将这些静态方法创建的对象交给spring以供使用。）
3. 通过实例工厂创建bean对象（让spring容器去调用某些对象的某些实例方法来生成bean对象放在容器中以供使用。）
4. 通过FactoryBean创建bean对象（FactoryBean可以让spring容器通过这个接口的实现来创建我们需要的bean对象。）

单例bean（scope = singleton）

       当scope的值设置为singleton的时候，整个spring容器中只会存在一个bean实例，通过容器多次查找 bean的时候（调用BeanFactory的getBean方法或者bean之间注入依赖的bean对象的时候），返回的 都是同一个bean对象，singleton是scope的默认值，所以spring容器中默认创建的bean对象是单例的， 通常spring容器在启动的时候，会将scope为singleton的bean创建好放在容器中（有个特殊的情况，当 bean的lazy被设置为true的时候，表示懒加载，那么使用的时候才会创建），用的时候直接返回。

使用注意：

         单例bean是整个应用共享的，所以需要考虑到线程安全问题，之前在Spring MVC的时候，spring MVC中controller默认是单例的，有些开发者在controller中创建了一些变量，那么 这些变量实际上是共享的，controllet可能被多个线程同时访问，这些线程并发去修改controller中的共享变量，可能会出现数据错乱的问题，所以使用的时候需要特别注意。    

总结：

1. spring容器自带的2种作用域，分别是singleton 和 prototype ；还有3种分别是spring web
   容器环境中才支持的request 、 session 、 application
2. singleton是spring容器默认的作用域，一个Spring容器中同名的bean实例只有一个，多次获得到的是同一个bean，单例的bean需要考虑线程安全问题。
3. prototype是多例的，每次从容器中获取同名的bean，都会重新创建一个；多例bean使用的时候需要考虑创建bean对性能的影响
4. 一个应用中有多个spring容器
5. 自定义scope3个步骤，实现Scope接口，将实现类注册到spring容器中，使用自定义的scope

CGLIB和Java动态代理的区别

1. Java动态代理只能够对接口进行代理，不能对普通的类进行代理（因为所有生成的代理类都有共同的父类Proxy，Java类继承机制中不允许多继承）；CGLIB能够代理普通类
2. Java动态代理使用Java原生的反射机制进行处理，在生成类上比较高效；CGLIB使用是直接对字节码进行操作，在类的执行过程中比较高效

注解

什么是注解？

注解：可以标记包,类,方法,属性,参数等。和 Javadoc 不同， Java 标注可以通过反射获取标注内容。注解是对代码的一种增强，可以在代码编译或者程序运行期间获取注解的信息，然后根据这 些信息做各种牛逼的事情。

1. 在类上使用@Configuration注解
2. 通过AnnotationConfigApplicationContext容器来加@Configuration注解修饰的类

@ComponentScan

        用于去扫描某些包及其子包中所有的类，然后将满足一定条件的类作为bean注册到 spring容器容器中。

@ComponentScan工作的过程：

1. Spring会扫描指定的包，且会递归下面子包，得到一批类的数组
2. 然后这些类会经过各种过滤器，最后剩下的类会被注册到容器中

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {
    String value() default "";
}

@Target({ElementType.TYPE}) 
@Retention(RetentionPolicy.RUNTIME) 
@Documented 
@Component 
public @interface Repository { 
    @AliasFor(annotation = Component.class) 
    String value() default ""; 
}
/*
Repository上面有@Component注解。
value参数上面有 @AliasFor(annotation = Component.class) ，设置value参数的时候，也相
当于给 @Component 注解中的value设置值。
*/

      按模块的方式进行导入，需要哪个导入哪个，不需要的时候，直接修改一下总的配置类，调整一下 @Import就可以了，非常方便。@Import可以用来批量导入任何普通的组件、配置类，将这些类中定义的所有bean注册到容器。

 @Conditional：注解可以标注在spring需要处理的对象上（配置类、@Bean方法），相当于加了个条件判断，通过判断的结果，让spring觉得是否要继续处理被这个注解标注的对象。

@Autowired、@Resource、 @Primary、@Qulifier

 @Autowired：注入依赖对象

作用：实现依赖注入，spring容器会对bean中所有字段、方法进行遍历，标注有@Autowied注解的，都会进行注入。

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    boolean required() default true;
}

@Resource：注入依赖对象

作用：实现依赖注入，spring容器会对bean中所有字段、方法进行遍历，标注有@Resourse注解的，都会进行注入。

@Documented
@Retention(RUNTIME)
@Target(TYPE)
public @interface Resources {
   /**
    * Array used for multiple resource declarations.
    */
   Resource[] value();
}

@Qualifier：限定符

作用：可以在依赖注入查找候选者的过程中对后选择进行过滤；可以用在类上；也可以用在依赖注入的地方，可以对候选者的查找进行过滤

@Autowired和@Resource的区别？

• @Autowired注解是spring提供的，而@Resource是由J2EE提供的
• @Autowired注解默认是通过byType类型注入，而@Resourse默认是通过byName类型注入
• @Autowired注解注入的对象需要在IOC容器中存在，否则需要加上属性required = false，表示忽略当前到注入的bean，如果有直接注入，没有跳过，不会报错。
• @Autowired：先byType再byName；@Resource：先byName再byType（当指定@Resource name属性时，只会byName）

 @Scope、@DependsOn、@ImportResource、@Lazy

• @Scope：用来定义bean 的作用域；2种用法：第1种：标注在类上；第2种：和@Bean一起标注在方法上
• @DependsOn：用来指定当前bean依赖的bean，可以确保在创建当前bean之前，先将依赖的 bean创建好；2种用法：第1种：标注在类上；第2种：和@Bean一起标注在方法上
• @ImportResource：标注在配置类上，用来引入bean定义的配置文件
• @Lazy：让bean延迟初始化；常见3种用法：第1种：标注在类上；第2种：标注在配置类上，会对配置类中所有的@Bean标注的方法有效；第3种：和@Bean一起标注在方法上

父子容器

       假设系统中有两个模块：module1和module2，两个模块是独立开发的，module2会用到module1中的一些类，module1会将自己打包为jar，提供给module2使用。

在mondule1中有三个类：Service1、Service2（Service2中需要用到Service1）、Module1Confi（spring配置类）

在mondule2中有三个类：Service1、Service2（使用module2中的Service1，使用module1中的Service2）、Module1Config（spring配置类）

测试运行报错，原因在于因为两个模块中都有Service1，被注册到 spring容器的时候，bean名称会冲突，导致注册失败。

如何解决？

          对module1中的Service1进行修改？

          这个估计是行不通的，module1是别人以jar的方式提供给我们的， 源码我们是无法修改的。 而module2是我们自己的开发的，里面的东西我们可以随意调整，那么我们可以去修改一下module2中 的Service1，可以修改一下类名，或者修改一下这个bean的名称，此时是可以解决问题的。 不过大家有没有想过一个问题：如果我们的模块中有很多类都出现了这种问题，此时我们一个个去重构，还是比较痛苦的，并且代码重构之后，还涉及到重新测试的问题，工作量也是蛮大的，这些都是风险。 而spring中的父子容器就可以很好的解决上面这种问题。

什么是父子容器？

创建spring容器的时候，可以给当前容器指定一个父容器。

BeanFactory的方式

//创建父容器
parentFactory DefaultListableBeanFactory parentFactory = new DefaultListableBeanFactory(); //创建一个子容器
childFactory DefaultListableBeanFactory childFactory = new DefaultListableBeanFactory(); 
//调用setParentBeanFactory指定父容器 
childFactory.setParentBeanFactory(parentFactory);

ApplicationContext的方式

//创建父容器 
AnnotationConfigApplicationContext parentContext = new AnnotationConfigApplicationContext(); 
//启动父容器 
parentContext.refresh(); 
//创建子容器 
AnnotationConfigApplicationContext childContext = new AnnotationConfigApplicationContext(); //给子容器设置父容器 
childContext.setParent(parentContext); 
//启动子容器 
childContext.refresh();

特点：

1. 父容器和子容器是相互隔离的，他们内部可以存在名称相同的bean
2. 子容器可以访问父容器中的bean，而父容器不能访问子容器中的bean
3. 调用子容器的getBean方法获取Bean的时候，会沿着当前容器开始向上面的容器进行查找，直到找到对应的bean为止。
4. 子容器中可以通过任何注入方式注入父容器中的bean，而父容器中是无法注入子容器中的bean

Springmvc中只使用一个容器是否可以？

只使用一个容器是可以正常运行的

那么springmvc中为什么需要用到父子容器？

       我们通常使用Spring mvc 的时候，采用3层结构，controller、service、dao；父容器中会包含dao层和service层，而子容器中包含的只有Controller，这两个容器组成了父子容器的结构，controller层通常注册service层的bean。

 采用父子容器可以避免有些人在service1层去注入controller层的bean，导致整个依赖层次是比较混乱的。

父容器和子容器的需求也是不一样的，比如父容器中需要有事务的支持，会注入一些支持事务的组件，而子容器中controller完全用不到这些，对这些并不关心，子容器中需要注入一下springmvc相关的bean，而这些bean父容器中同样是不会用到的，也是不关心一些东西，将这些相互不关心的东西隔开，可以有效的避免一些不必要的错误，而父子容器加载的速度也会快一些。

Spring国际化

public class A{
    B b;
}
public class B{
    C c;
}
public class C{
    A a;
}

        只有单例的bean会通过三级缓存提前暴露来解决循环依赖的问题，而非单例的bean ，每次从容器中获 取都是一个新的对象，都会重新创建，所以非单例的 bean 是没有缓存的，不会将其放到三级缓存中。

什么是AOP？

        将业务之外的代码，例如事务提交，获得sqlsession，获得接口代理，事务提交，关闭sqlsession等管理起来。使用预编译的方式和动态代理的方式，使用程序可以统一维护的一种技术。

原理：使用jdk代理和动态代理来创建代理对象，通过代理对象来访问目标对象，而代理对象融入增强的代码，最终起到对目标对象增强的效果。

作用：可以将业务逻辑之间进行隔离，降低耦合度，使得开发维护方便。

AOP到底为程序带来了哪些好处？

    可以将一些公共的，重复出现的非业务代码进行提取，然后使用动态代理的方式，为我们的业务代码横切添加额外提取的功能，而且不需要显示的在业务代码中调用，可以通过一个代理对象，来帮助我们调用这些抽取出来的方法。

Spring中AOP一些概念

目标对象（target）：目标对象指将要被增强的对象，即包含主业务逻辑的类对象

连接点（JoinPoint）：连接点，程序执行的某一个点，比如执行某个方法，在spring AOP中Join Point总是表示一个方法的执行。

代理对象（Proxy）：AOP会通过代理的凡是，对目标对象生成一个代理对象，代理对象中会加入需要增强功能，通过代理对象来间接的方式目标对象，起到增强目标对象的效果。

通知（Advice）：需要在目标对象中增强的功能，如上面说的：业务方法前验证用户的功能、方法执行之后打印方法的执行日志。

通知中有连个重要的信息：方法的什么地方，执行什么操作，这两个信息通过通知来指定。

方法的什么地方？之前、之后、包裹目标方法、方法抛出异常后等。

如：

• 在方法执行之前验证用户是否有效
• 在方法执行之后，打印方法的执行耗时
• 在方法抛出异常后，记录异常信息发送到mq.

切入点（Pointcut）:用来指定需要使用到哪些地方，比如需要用在哪些类的方法上，切入点就是做这个配置的

切面（Aspect）：通知和切入点的组合。切面来定义在哪些地方执行什么操作

顾问（Advisor）：Advisor其实就是Pointcut和Advice的组合，Advice是要增强的逻辑，而增强的逻辑要在什么地方执行时通过Pointcut来指定的，所以Advice必须与Pointcut组合在一起，就诞生了Advisor这个类，spring AOP中提供了一个Advisor接口将Pointcut与Advice的组合起来。

@Aspect有5种通知

• @Before：前置通知，在方法执行之前执行
• @Around：环绕通知，围绕着方法执行
• @After：后置通知，在方法执行之后执行
• @AfterReturning：返回通知，在方法返回结果之后执行
• @AfterThrowing：异常通知，在方法抛出异常之后

@Aspect 
public class BeforeAspect {
 
    @Before("execution(* com.Service1.*(..))") 
    public void before(JoinPoint joinPoint) { 
        System.out.println("我是前置通知!"); 
    } 
}
/*
1. 类上需要使用@Aspect
2. 任意方法上使用@Before标注，将这个方法作为前置通知，目标方法被调用之前，会自动回调
这个方法
3. 被@Before标注的方法参数可以为空，或者为JoinPoint类型，当为JointPoint类型时，必须
为第一个参数
4. 被@Before标注的方法名称可以随意命名，符合java规范就行，其他通知也类型
*/
 

环绕通知会包裹目标方法的执行，可以在通知内部调用ProceedingJoinPoint.process方法继续执行下一个拦截器
用起来和@Before类似，但是有两点不一样
1. 若需要获取目标方法的信息，需要将ProceedingJoinPoint作为第一个参数
2. 通常使用Object类型作为方法的返回值，返回值也可以为void
特点：环绕通知比较特殊，其他4种类型的通知都可以用环绕通知来实现。

@After：后置通知

• 不管目标方法是否有异常，后置通知都会执行
• 这种通知无法获取方法返回值
• 可以使用JoinPoint作为方法的第一个参数，用来获取连接点的信息。

@AfterReturning：返回通知

返回通知，在方法返回结果之后执行

特点：

• 可以获取到方法的返回值
• 当目标方法返回异常的时候，这个通知不会被调用，这点和@After通知是有区别的 

 @AfterThrowing：异常通知

在方法抛出异常之后会回调@AfterThrowing标注的方法。

@AfterThrowing标注的方法可以指定异常的类型，当被调用的方法触发该异常及其子类型的异常之后，会触发异常方法的回调，也可以不指定异常类型，此时会匹配所有异常。

特点： 不论异常是否被异常通知捕获，异常还会继续向外抛出。

@EnableAspectJAutoProxy：用来启用自动代理的创建，简单点理解：会找到容器中所有标注有@Aspect注解的bean以及Advisor类型的bean，会将他们转换为Advisor 集合，spring会通过Advisor集合对容器中满足切入点表达式的bean生成代理对象，整个都是 spring容器启动的过程中自动完成的。

@EnableAsync & @Async 实现方法异步调用

@EnableAsync & @Async