Spring个人进阶

Spring中bean的生命周期

class --》 实例化对象–》属性填充 —》Aware—》初始化 —》销毁

实例化 ---------- 推断构造方法并利用java 反射机制来实例化bean

填充属性---------- 利用set方法

Aware（这种类型接口作用是加载资源到Spring容器中，获取一些资源属性，Aware前面的名字就对应哪种资源）

• 是否实现BeanNameAware接口 如果实现了则执行setBeanName方法
• 是否实现BeanClassLoaderAware接口 如果实现了则执行setBeanClassLoader方法
• 是否实现BeanFactoryAware接口 如果实现了则执行setBeanFactory方法
• 。。。中间还有好几个aware接口
• 是否实现ApplicationContextAware接口 如果实现了则执行setApplicationContext方法

例如ApplicationContextAware:

初始化前 ---------- BeanPostProcessor前置处理

初始化 ---------- 有三种方式可以实现初始化

1. 实现InitializingBean接口的afterPropertiesSet方法
2. 加@PostConstruct注解标注的方法
3. 配置的init-method

初始化后 ---------- 执行BeanPostProcessor后置处理

Bean的销毁阶段

---

循环依赖

什么是循环依赖？ 简单的例子：A对象依赖B对象，B对象依赖A对象。

那么循环依赖是个问题吗？
如果不考虑spring，单纯的在java中循环依赖并不会出现问题，因为对象之间相互依赖是很正常的事情

这样，A、B就依赖上了。

但是，在Spring中循环依赖就是一个问题，为什么？
因为，在Spring中，一个对象并不是简单的new出来，是一个bean，是会经历一系列的Bean的生命周期（存在属性赋值），就是因为Bean的生命周期所以才会出现循环依赖问题。

那spring是如何解决循环依赖的呢？
（如果两个相互依赖的类中只有有参构造方法，则是无法解决循环依赖的）

解决循环依赖问题涉及到三个重要的缓存。

1. 一级缓存也就是单例池（存的是成品bean）
2. 二级缓存（存的是半成品bean）
3. 三级缓存（存的是初始化的对象）

解决A和B 循环依赖流程：

1. 先实例化A
2. 将实例化的A放到三级缓存里
3. （然后给A加一个正在创建bean的标记）
4. 注入属性B，发现单例池里没有B
5. 实例化B
6. 发现B也依赖于A
7. 这时通过标记发现A正在创建，就证明存在了循环依赖现象
8. 将三级缓存里的A转移到二级缓存里（如果A存在AOP，则提前AOP生成代理对象）
9. 然后B依赖注入二级缓存里的A
10. 初始化B
11. 完成B的创建
12. 最后A依赖注入创建好的B
13. 初始化A
14. A和B的bean都创建完成

---

Spring的AOP

什么是AOP？

AOP：Aspect Oriented Programming，面向切面编程。通过预编译和运行期动态代理实现程序功能的统一维护。

Spring中AOP是如何实现的？

AOP底层是基于动态代理的，动态代理方式分为两种：JDK动态代理和CGLIB动态代理。
而spring实现AOP究竟用用哪一种代理方式？
取决于被代理的类是否实现了接口。
如果实现了接口则默认使用JDK动态代理，如果没有实现任何接口，则只能使用cglib动态代理

1. JDK动态代理：
JDK动态代理是为接口生成代理对象。要求被代理的类必须实现一个接口，它的核心是实现了InvocationHandler接口和继承Proxy类。
2. CGLIB动态代理：
底层是 代理类继承于初始类
代理类中增加一个成员变量target指向之前的实例化对象
代理类重写初始类的方法（代理逻辑 + target的对应方法）

AOP使用案例（注解方式）

配置类：

package com.coderzpw;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@EnableAspectJAutoProxy             // 开启AOP注解方式支持
@ComponentScan("com.coderzpw")      // 扫描该路径下的包
public class AppConfig {
}

被切方法：

package com.coderzpw.aop;

import org.springframework.stereotype.Component;

@Component
public class AopTest {

    public void insert(){
        System.out.println("插入方法");
    }
    public void delete(){
        System.out.println("删除方法");
    }
    public void update(){
        System.out.println("修改方法");
    }
    public void select(){
        System.out.println("修改方法");
    }
}

切面类：

package com.coderzpw.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect    // 标注这个类是一个切面
public class MyAspect {

    @Before("execution(* com.coderzpw.aop.AopTest.*(..))")      // 配置切入点，切点对应的是方法
    public void before(){
        System.out.println("----方法执行前----");
    }

    @After("execution(* com.coderzpw.aop.AopTest.*(..))")      // 配置切入点，切点对应的是方法
    public void after(){
        System.out.println("----方法执行后----");
    }

    //  在循环增强中，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.coderzpw.aop.AopTest.*(..))")      // 配置切入点，切点对应的是方法
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前");

        Signature signature = joinPoint.getSignature();// 获得签名（方法的信息）
        System.out.println("方法信息:"+signature);
        // 执行方法（返回值是执行的返回值结果，如果是void类型的就返回null）
        Object proceed = joinPoint.proceed();

        System.out.println("环绕后");
        System.out.println(proceed);
    }
}

测试方法类：

package com.coderzpw;

import com.coderzpw.aop.AopTest;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        AopTest aopTest = applicationContext.getBean(AopTest.class);
        aopTest.update();
    }
}

执行结果：

AOP 几个应用场景

场景一： 记录日志
场景二： 事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ）
等。。。。

---

如何生成一个bean？

编程式：
1.BeanDefinition

AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(Student.class);     // 定义一个bean
applicationContext.registerBeanDefinition("student",beanDefinition);    // 注册到容器里

声明式：

1. @Component
2. @Bean
3. < bean >

---

面试总结篇

@Autowired注解与@Resource注解的区别

相同点：
都可以写在字段和setter方法上，用来实现属性的依赖注入。

不同点：

• 提供方不同：@Autowired属于springframework下的包，属于spring框架；而@Resource属于javax下的包，属于jdk的。
• 注入方式：@Autowired只能按照类型注入，如果存在同一类型的多个bean，则可以结合@Qualifier来指定bean的名称进行注入；@Resource默认是按照byName自动注入，也提供了byType注入。
• 属性：@Autowired默认情况下要求依赖的对象必须存在，如果想要允许为null值，可以设置它的required属性为false； @Resource有两个重要的属性：name和type，name属性指定bean的名称，type属性用来指定bean的类型。

什么是Spring IOC容器？（说一下IOC）

IOC就是控制反转。指的是：把传统上的程序代码直接创建和操控对象的权利，转移给spring容器进行创建和管理。
spring IOC负责创建对象、管理对象、装配对象，并且管理这些对象的整个生命周期。

说一下DI（依赖注入）

DI依赖注入，和控制反转是同一概念的不同角度的描述。即应用程序在运行时依赖IOC容器来动态注入对象需要的外部依赖。

说一下AOP

AOP：Aspect Oriented Programming，面向切面编程。通过预编译和运行期动态代理实现程序功能的统一维护。
AOP底层是基于动态代理的，动态代理方式分为两种：JDK动态代理和CGLIB动态代理。
而spring实现AOP究竟用用哪一种代理方式？
取决于被代理的类是否实现了接口。
如果实现了接口则默认使用JDK动态代理，如果没有实现任何接口，则只能使用cglib动态代理

1. JDK动态代理：
JDK动态代理是为接口生成代理对象。要求被代理的类必须实现一个接口，它的核心是实现了InvocationHandler接口和继承Proxy类。
2. CGLIB动态代理：
底层是 代理类继承于初始类
代理类中增加一个成员变量target指向之前的实例化对象
代理类重写初始类的方法（代理逻辑 + target的对应方法）

那spring是如何解决循环依赖的呢？
（如果两个相互依赖的类中只有有参构造方法，则是无法解决循环依赖的）

解决循环依赖问题涉及到三个重要的缓存。

1. 一级缓存也就是单例池（存的是成品bean）
2. 二级缓存（存的是半成品bean）
3. 三级缓存（存的是初始化的对象）

解决A和B 循环依赖流程：

1. 先实例化A
2. 将实例化的A放到三级缓存里
3. （然后给A加一个正在创建bean的标记）
4. 注入属性B，发现单例池里没有B
5. 实例化B
6. 发现B也依赖于A
7. 这时通过标记发现A正在创建，就证明存在了循环依赖现象
8. 将三级缓存里的A转移到二级缓存里（如果A存在AOP，则提前AOP生成代理对象）
9. 然后B依赖注入二级缓存里的A
10. 初始化B
11. 完成B的创建
12. 最后A依赖注入创建好的B
13. 初始化A
14. A和B的bean都创建完成

SpringBoot和SpringCloud的区别和关系？

• SpringBoot专注于快速方便的开发单个个体微服务
• SpringCloud是关注全局的微服务协调整理治理架构，它将SpringBoot开发的一个个单体微服务整合并管理起来。为各个微服务之间提供配置管理、服务发现、断路器、路由、网关等集成服务
• SpringBoot可以离开SpringCloud独立使用开发项目，但是SpringCloud离不开SpringBoot，属于依赖关系