本文链接： https://blog.csdn.net/m0_38060977/article/details/102756659

一 IOC/DI

1 介绍

反转资源获取的方向. 传统的资源查找方式要求组件向容器发起请求查找资源. 作为回应, 容器适时的返回资源. 而应用了 IOC 之后, 则是容器主动地将资源推送给它所管理的组件, 组件所要做的仅是选择一种合适的方式来接受资源. 这种行为也被称为查找的被动形式

DI(Dependency Injection) — IOC 的一种实现手段：即组件以一些预先定义好的方式(例如: setter 方法)接受来自如容器的资源注入. 相对于 IOC 而言，这种表述更直接（容器向组件注入资源，方式有：属性注入、构造器注入

2 依赖注入的方式

Autowired/resource 等等（可以再属性、构造器、sertter上标注）
setter方法注入（xml中的利用property标签，实际是调用sertter方法）
构造器注入
静态/实例工厂（只找到xml里面的用法）

3 Spring容器

在 Spring IOC 容器读取 Bean 配置创建 Bean 实例之前, 必须对它进行实例化. 只有在容器实例化后, 才可以从 IOC 容器里获取 Bean 实例并使用.

Spring 提供了两种类型的 IOC 容器实现.

BeanFactory: IOC 容器的基本实现.
ApplicationContext: 提供了更多的高级特性. 是 BeanFactory 的子接口.
BeanFactory 是 Spring 框架的基础设施，面向 Spring 本身；ApplicationContext 面向使用 Spring 框架的开发者，几乎所有的应用场合都**直接使用 ApplicationContext **而非底层的 BeanFactory。无论使用何种方式, 配置文件是相同的

4 IOC实现过程

参考:https://blog.csdn.net/q982151756/article/details/80291998

spring的IoC容器在实现控制反转和依赖注入的过程中,可以划分为两个阶段:

容器启动阶段
Bean实例化阶段

这两个阶段中,IoC容器分别作了以下这些事情:

先讲BeanFactroy中的过程

1.容器启动阶段

1.加载配置文件信息,封装成BeanDefinition
2.处理所有的BeanFactoryPostProcessor（在对象创建前，可以修改对象定义）

2.Bean实例化阶段

各种Aware接口
参考:https://blog.csdn.net/q982151756/article/details/80299547
总结几点:
1.容器是如何实现将Aware接口中规定的依赖注入到已经生成的对象中的呢?
通过BeanPostProcessor.因为BeanPostProcessor会处理所有的对象实例。所以在spring容器中实例化过程的某一步骤时，容器会找到之前注册到容器的ApplicationContextAwareProcessor这个BeanPostProcessor的实现类，然后就会调用其postProcessBeforeInitialization()方法，检查并设置Aware相关依赖。

二 AOP

1 AOP中的相关概念

Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
Target（目标对象）：织入 Advice 的目标对象.。
Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程

详见：
基本概念
 point cut 用法等等

2 srping中的动态代理

2.1 jdk动态代理

通过创建接口的子类来实现的
详见：https://blog.csdn.net/q982151756/article/details/80586894

2.2 cglib

CGLIB（基于ASM的字节码生成库）会动态创建一个目标类的子类，然后返回该子类的对象，也就是增强对象。
通过动态字节码技术实现的：动态态字节码技术就是通过转换字节码生成新的类来实现改变一个类的内部逻辑的
基本用法参见：https://www.cnblogs.com/xrq730/p/6661692.html
总结
1.可以定义不同的拦截策略（通过CallbackFilter）
2.final方法不能被代理，Object的部分方法也会被代理
3.方法内部调用也会被代理，全程代理（不同于jdk动态代理）
4.spring aop中即使用了cglib，类中互相调用也不会被代理(特殊处理了)

3、4点原理

public class CarProxy  implements MethodInterceptor {
    private Object target;

    CarProxy(Object target){
        this.target = target;
    }

    @Override
    public Object intercept(Object object, Method method, Object[] objects, MethodProxy proxy) throws Throwable {
        System.out.println("Before Method Invoke");
//object是代理类（增强类，子类）； method是父类的method； objects是参数，没什么好说的；proxy是代理类的method
//        proxy.invokeSuper(object, objects);一般都是这么调的，所以全程一直被代理
//        proxy.invoke(object,objects);//有异常
//        System.out.println(object);
//        System.out.println(method);
        method.invoke(target,objects);//类似jdk动态代理的实现，spring aop使用cglib也类似这样。这样内部方法互相调用就不会被代理
        System.out.println("After Method Invoke");

        return object;
    }

}

原理参考: Cglib动态代理实现原理

参考资料

Spring（2）IOC和AOP的基本用法

目录