石杉笔记（2) Spring Ioc、aop

╰+哭是因爲堅強的太久メ 2023-07-17 14:26 11阅读 0赞

### 1、spring 的 IOC 机制 和 AOP 机制的理解 ###

### servlet 时期： ###

写一套系统，web 服务器，tomcat，一旦启动之后，可以监听一个端口号的http请求

然后可以静请求转交给servlet、jsp，配合起来使用的，servlet 处理请求

public void MyServlet {
        
        private MyService myService = new MyServiceImpl();
       
        public void doPost(HttpServletRequest request) {
        
            //    对请求一桶处理
            //    调用自己的业务逻辑组件，去执行一些业务逻辑
            myService.doService();
        }
    }
    
    public interface MyService{
    }
    
    public class MyServiceImpl implements MyService{
    }

![20200322165528431.png][]

这个tomcat + servlet 的low的系统中，有几十个地方，都是直接用MyService myService = new MyServiceImpl()，直接创建、引用和依赖一个MyServiceImpl 这样的一个类的对象，这些引用的地方都跟 MyServiceImpl 类直接耦合在了一起

如果我们想用 NewServiceManagerImpl implements MyService 这个接口的，所有的实现逻辑都不同了，那就需要修改原本的引用 MyServiceImpl 这个类

> 修改麻烦，耦合性大，改动后测试成本也大

### spring 时期： ###

Spring IOC 框架，控制反转，依赖注入，解耦合

xml 文件进行一个配置，进化到了基于注解来进行自动依赖注入

@Controller
    public class MyController {
         
        @Resource
        private MyService myService;
       
        public void doRequest(HttpServletRequest request) {
        
            //    对请求一桶处理
            //    调用自己的业务逻辑组件，去执行一些业务逻辑
            myService.doService();
        }
    }
    
    
    public interface MyService{
    }
    
    @Service
    public class MyServiceImpl implements MyService{
    }

spring ioc, spring 容器，根据xml 配置，或者你的注解，去实例化你的一些bean 对象，然后根据xml 配置或者注解，去对 bean 对象之间的引用关系，去进行依赖注入，某个 bean 依赖了另外一个bean

> 底层的核心技术：**反射**，会通过反射的技术，直接根据你的类去自己构建对应的对象出来，用的就是反射技术

spring ioc ，系统的类 与 类 之间彻底的解耦合

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 1][]

### 2、spring aop 机制 ###

面向切面编程，Aspect

spring 在运行的时候，动态代理技术，AOP 的核心技术，就是动态代理

### 3、cglib 动态代理， 与jdk 动态代理的区别 ###

优先是jdk 动态代理，其次是 cglib 动态代理

其实就是动态的创建一个代理类出来，创建这个代理类的实例对象，在这个里面引用你真正自己写的类，所有的方法的调用，都是先走代理类的对象，他负责做一些代码上的增强，再去调用你写的那个类

spring里使用aop，比如你对一批类和他们的方法做了一个切面，定义好了要在这些类的方法里增强的代码，spring必然要对哪些类生成动态代理，在动态代理中去执行你定义的一些增强代码

如果你的类是实现了某个接口的，spring aop 会使用jdk 动态代理，生成一个跟你实现同样接口的一个代理类，构造一个实例对象出来，**jdk 动态代理，其实就是在你的类有接口的时候，就会来使用**

很多时候可能某个类是**没有实现接口的，spring aop 会改用cglib 来生成动态代理，它是生成你的类的一个子类**，他可以动态生成字节码，覆盖你的一些方 法，在方法里加入增强的代码

百度：jdk动态代理代码示例，cglib 动态代理代码示例

### 4、spring 中的Bean 是线程安全的吗 ###

Spring 容器中的bean 可以分为 5 个范围：

（1）singleton：默认，每个容器中只有一个 bean 的实例

（2）prototype：为每一个 bean 请求提供一个实例

一般下面几种一般不会用，

（3）request：为每一个网络请求创建一个实例，在请求完成以后，bean 会失效并被垃圾回收器回收

（4）session：与 request 范围类似，确保每个session 中有一个bean 的实例，在 session 过期后， bean 会随之失效

（5）global-session

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 2][]

默认spring bean 会创建一个单例的对象实例，**springBean 是线程不安全的**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 3][]

### 5、spring事务原理 ###

事务的实现原理，事务传播机制，如果说加了一个@Transactional 注解，此时就 Spring 会使用 AOP 思想，对你的这个方法在执行之前，先去开启事务，执行完毕后，根据方法是否报错，决定回滚还是提交事务

@Transaction(propagation = Propagation.REQUIRED)
    public void methodA() {
        methodB();
        // do something
    }
    
    @Transaction(propagation = Propagation.REQUIRED)
    public void methodB() {
        // do something
    }

（1）***required***: 如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的设置

（2）supports：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行

（3）mandatory：支持当前事务，如果当前存在事务，就加入该事务，**如果不存在就抛出异常**

（4）***requires\_new***: 创建新事务，**无论当前存在不存在，都创建新事务**

（5）not\_supported: 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起

（6）never： 以非事务方式执行，***如果当前存在事务，则抛出异常***

***（7）nested: 嵌套事务，外层事务如果回滚，会导致内层的事务也回滚；但是内层的事务如果回滚，仅仅是回滚自己的代码***

> *** 嵌套事务：***
> 
> 开启一个事务
> 
> 执行方法A 里的一些代码，doSomethingPre()
> 
> 设置一个回滚点，savePoint
> 
> 执行方法B里面的一些代码
> 
> 如果方法 B 抛出异常，此时进行回滚，回滚到之前的 savePoint
> 
> 执行方法A 里的一些代码，doSomethingPost()
> 
> 提交或回滚事务

面试演练：

（a）业务逻辑：方法A 调用 B，希望如果A 出错了，仅仅回滚方法 A， 不能回滚方法 B， 必须得用 Requires\_new 传播机制，让两方法事务不同

（b）方法A 调用方法B，如果出错，方法B 只能回滚他自己，方法A可以带着方法 B一起回滚，这个是nested传播机制

### 6、spring核心原理 ###

spring bean 生命周期，从创建 -> 使用 -> 销毁

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 4][]

（1）实例化Bean: 如果要是用一个bean的话

（2）设置对象属性（依赖注入）：

他需要去看看，你的这个bean 依赖了谁，把你以来的bean 也创建出来，给你进行一个注入，比如通过构造函数

public class MyService {
    
       @Resource
       private MyDao myDao;
    }

（3）处理aware 接口

如果这个Bean 已经实现了ApplicationContextAware 接口，spring容器就会调用我们的bean的

setApplicationContext(ApplicationContext) 方法，传入Spring 的上下文，把Spring容器给传递给这个bean

（4）BeanPostProcessor

如果想对 Bean 进行一些自定义的处理，那么可以让 Bean 实现了 BeanPostProcessor 接口，那将会调用

postProcessBeforeInitialization(Object obj, String s)方法

（5）InitializingBean 与 init-method:

如果Bean 在 Spring 配置文件中配置 init-method 属性，则会自动调用其配置的初始化

（6）如果这个Bean 实现了 BeanPostProcessor 接口，将会调用 postProcessAfterInitialization(Object obj, String s) 方法

（7）DisposableBean

当Bean 不再需要时，会经过清理阶段，如果Bean 实现了 DisposableBean 这个接口，会调用其实现的 destory() 方法

（8）destory-method

最后，如果这个bean的 spring配置中配置了 destory-method属性，会自动调用其配置的销毁方法

创建 + 初始化一个bean -> spring容器管理的bean 长期存活 -> 销毁bean（两个回调函数）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 5][]

[20200322165528431.png]: /images/20230528/bdcdba032e7040728f3a7a139d322625.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70]: /images/20230528/7cdf669fcfe04bb184c34ca8b04c2070.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 1]: /images/20230528/76ba1c618439494c8ff116dbf46fbf0d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 2]: /images/20230528/686e0d9e907a4e8dad2b286cb23575e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 3]: /images/20230528/f9900c41b22945cdbda99d8c42e914f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 4]: /images/20230528/c8b0875c165546f5be50765c20b90397.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mjc1MjMz_size_16_color_FFFFFF_t_70 5]: /images/20230528/02a96a2dfd4b409a8932e32cec852d73.png