【八股】Spring篇

why Spring?

1.使用它的IOC功能，在解耦上达到了配置级别。
2.使用它对数据库访问事务相关的封装。
3.各种其他组件与Spring的融合，在Spring中更加方便快捷的继承其他一些组件。

IoC和DI

👉IOC是Inversion of Control的缩写，“控制反转”之意。

• 在没有引入IOC容器之前，对象A依赖于对象B，那么对象A在初始化或者运行到某一点的时候，自己必须主动去创建对象B或者使用已经创建的对象B。无论是创建还是使用对象B，控制权都在自己手上。
• 在引入IOC容器之后，对象A与对象B之间就失去了直接联系，所以，当对象A运行到需要对象B的时候，IOC容器会主动创建一个对象B注入到对象A需要的地方。 对象A获得依赖对象B的过程,由主动行为变为了被动行为，控制权颠倒过来了，这就是“控制反转”这个名称的由来。

👉依赖注入(DI)是IoC的一种实现方式，指把依赖关系注入到对象中
哪种DI方式建议使用?构造器注入和Setter方法注入。最好的解决方案是用构造器参数实现强制依赖，setter方法实现可选依赖。

bean

什么是Bean

Spring IoC容器创建、管理和依赖注入的对象称之为bean
一个bean定义包括如何创建一个bean，它的生命周期详情及它的依赖。

bean的作用域Scope有哪些

sinleton：默认，单例，在启动时会自动实例化（也可以用lazy-init属性进行控制）
prototype：多例，启动时不实例化，将bean交给调用者后不再管理它的生命周期
request：每次HTTP请求都会创建一个bean，请求处理完后销毁这个bean。
session：同一个HTTP session共享一个bean，session结束后销毁Bean
globalXession：同一个全局session共享一个bean，一般用于portlet应用环境
后面三者仅适用于webApplicationContext环境

什么是内部Bean

当一个bean仅被用作另一个bean的属性时，它能被声明为一个内部bean，为了定义inner bean，在Spring 的 基于XML的 配置元数据中，可以在或元素内使用 元素，内部bean通常是匿名的，它们的Scope一般是prototype。

bean是单例的吗？是线程安全的吗？

👉是单例，默认是singleton，在spring IOC容器中只有一个实例，但可以通过@Scope(“prototype”)设置为多个实例
👉不是线程安全的，在bean中如果定义了可修改的成员变量会存在线程安全问题，可以用多例或加锁来解决。但一般我们在spring中的bean都是无状态的对象，这些是线程安全的。

Spring IOC配置Bean的方式

XML 文件 | 注解 | Java程序

1. 在XML文件中使用元素写Bean的配置信息，比如Bean的ID 类名和依赖关系
2. 基于注解标记bean，spring会自动扫描并创建这些bean，常见的注解包括 @Component、@Service、@Repository 和 @Controller
3. 定义Java配置类，使用@Configuration和@Bean注解

bean是如何被管理的？简述生命周期

👉在Spring框架中，一旦把一个bean纳入到Spring IoC容器之中，这个bean的生命周期就会交由容器进行管理，一般担当管理者角色的是BeanFactory或ApplicationContext。

👉实例化，初始化，使用，销毁

1. 通过BeanDefinition获得bean的定义信息
2. 调用构造函数实例化bean
3. bean的依赖注入
4. 处理Aware接口
5. BeanPostProcessor前置
6. 初始化方法（InitializingBean和init-method）
7. BeanPostProcessor后置
8. 销毁bean
   

Spring自动装配

• 限制
  👉如果使用了构造器注入或者setter注入，那么将覆盖自动装配的依赖关系。
  👉基本数据类型的值、字符串字面量、类字面量无法使用自动装配来注入。
  👉优先考虑使用显式的装配来进行更精确的依赖注入而不是使用自动装配。
• 方式
  👉no：不进行自动装配，手动设置Bean的依赖关系。
  👉byName：根据Bean的名字进行自动装配。
  👉byType：根据Bean的类型进行自动装配。
  👉constructor：类似于byType，不过是应用于构造器的参数，如果正好有一个Bean与构造器的参数类型相同则可以自动装配，否则会导致错误。
  👉autodetect：如果有默认的构造器，则通过constructor的方式进行自动装配，否则使用byType的方式进行自动装配。

循环依赖

即一个实例或多个实例存在相互依赖的关系，有点像死锁，可能会导致Spring容器无法完成Bean的实例化和依赖注入

如何处理循环依赖问题？取决于bean的作用域和注入方式

👉Singleton作用域下的属性注入
在Singleton作用域下，使用Setter方法进行属性注入时，Spring可以解决循环依赖的问题。【因为单例Bean在实例化后就会被放入容器中，即使在属性注入之前也是可用的。】
👉Prototype作用域下的属性注入
在Prototype作用域下，Spring无法直接解决循环依赖问题。但是，只要其中一个Bean改为Singleton作用域，就可以解决循环依赖的问题。【因为单例Bean的实例化顺序是不受影响的，即使循环依赖也能够被解决。】
👉Singleton作用域下的构造函数注入
在Singleton作用域下，使用构造函数进行属性注入时，Spring无法解决循环依赖的问题。【因为构造函数注入会导致Bean在实例化的过程中就需要引用其他Bean，而此时其他Bean可能还未完成实例化，因此会导致循环依赖。但可以通过使用@Lazy注解来延迟加载Bean，以解决这个问题，即在需要使用Bean时再进行实例化。】

解决循环依赖的三级缓存

👉一级缓存：存储的是完整的单例Bean对象，这个Bean对象已经赋值过了。
👉二级缓存：存储的是早期的单例Bean对象，这个Bean对象属性还没有赋值。
👉三级缓存：存储的是单例工厂对象，每一个单例Bean对象都会对应一个单例工厂对象。

• 解决流程：

1. 先实例化A对象，同时创建其工厂对象存入三级缓存。
2. A对象属性赋值需要B对象，实例化B对象，同时创建B的工厂对象，存入三级缓存。
3. B属性赋值需要注入A对象，于是从三级缓存中获取A的工厂对象，生成A对象存入二级缓存。
4. B通过二级缓存里获取A对象，属性赋值成功，于是B对象创建成功，存入一级缓存。
5. 此时A对象从一级缓存中获取B对象，注入成功，并将A对象存入一级缓存。
6. 将二级缓存的临时对象A清除。

注解

SpringBoot中定义一个post注解

1. 创建控制器：使用 @RestController 注解标记该类，并使用 @PostMapping 注解定义处理 POST 请求的方法。

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api") // 基础路径
public class MyController {

    @PostMapping("/submit") // 处理 POST 请求的路径
    public String handlePostRequest(@RequestBody MyRequestBody requestBody) {
        // 处理请求数据
        return "Received data: " + requestBody.getData();
    }
}

2. 创建请求体类，用于接收 POST 请求中的 JSON 数据：

public class MyRequestBody {
    private String data;

    // Getter 和 Setter 方法
    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }
}

3. 测试 POST 请求：使用 Postman、cURL 或任何其他 HTTP 客户端工具来测试这个 POST 请求。例如，使用 cURL 发送请求：

curl -X POST http://localhost:8080/api/submit -H "Content-Type: application/json" -d '{"data": "Hello, World!"}'

4. 运行应用：Spring Boot 应用运行后，然后你就可以发送 POST 请求到 /api/submit 端点，控制器将处理请求并返回响应。

自定义注解

😀应用：

• 日志记录：在方法调用前后自动记录日志。
• 权限控制：验证用户是否有权访问某个方法。
• 事务管理：标记哪些方法需要事务支持。
• 配置元数据：为框架提供配置信息。

😀创建和处理自定义注解的步骤：

1. 定义注解：使用 @interface，并通过元注解配置其行为（如 @Retention 和 @Target）
2. 使用注解：在方法上标记该注解。
3. 处理注解：通过反射获取并处理注解，添加所需的业务逻辑。

示例：定义一个自定义注解LogExecutionTime

// 1. 定义自定义注解
@Retention(RetentionPolicy.RUNTIME) // 注解在运行时可用
@Target(ElementType.METHOD) // 该注解只能应用于方法
public @interface LogExecutionTime {
}

public class MyService {
	// 2. 使用自定义注解
    @LogExecutionTime 
    public void serve() {
        // 模拟方法执行
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Service executed");
    }
}

import java.lang.reflect.Method;
//通过反射来实现处理自定义注解
public class AnnotationProcessor {
    public static void processAnnotations() {
        Method[] methods = MyService.class.getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(LogExecutionTime.class)) {
                long start = System.currentTimeMillis();
                try {
                    method.invoke(new MyService()); // 调用注解的方法
                } catch (Exception e) {
                    e.printStackTrace();
                }
                long end = System.currentTimeMillis();
                System.out.println("Execution time: " + (end - start) + " ms");
            }
        }
    }
}

// 可以在主方法中调用处理程序
public class Main {
    public static void main(String[] args) {
        AnnotationProcessor.processAnnotations();
    }
}

元注解有哪些

元注解是用来注解其他注解的注解
👉@Retention
注解的保留策略，即注解在编译后是否被保留到运行时。
常见取值有 RetentionPolicy.SOURCE、CLASS、RUNTIME。
👉@Target
注解可以应用的目标类型，包括类、接口、方法、字段等。
常见取值有 ElementType.TYPE、METHOD、FIELD 等。
👉@Document
注解是否包含在 Java 文档中。如果一个注解使用了 @Documented 元注解，则它将会包含在生成的 Java 文档中。
👉@Inherited
注解是否具有继承性。如果一个类标记了一个带有 @Inherited 注解的注解，则它的子类将自动继承该注解。
👉@Autowired
用于实现自动装配功能，可标记在字段、构造方法、方法或参数上，告诉 Spring 框架自动注入相关的依赖。

Spring常用注解

👉@Component、@Controller、@Service、@Repository：将实体类对象实例化到spring中，纳入spring管理。
👉@Autowired：对类成员变量、方法及构造函数进行自动装配，默认根据类型自动装配。
👉@Qualifier：结合@Autowired一起使用用于根据名称进行自动装配。(同一接口有多个实现类，Autowired不知道装配哪个类型)
👉@Scope:标注Bean的作用范围。
👉@Configuration:指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解。
👉@ComponentScan：用于指定 Spring 在初始化容器时要扫描的包。
👉@Bean：使用在方法上，标注将该方法的返回值存储到Spring容器中。
👉@Import：使用@Import导入的类会被Spring加载到IOC容器中。
👉@Aspect、@Before、@After、@Around、@Pointcut：用于切面编程（AOP）

SpringMVC注解

👉@RequestMapping：用于将任意HTTP 请求映射到控制器方法上。
各种衍生注解，如：@GetMapping、@PostMapping、@PutMapping等。
👉@RequestBody：将前端传过来的json数据转化为java对象。
👉@ResponseBody：将controller方法返回的java对象转化为json对象响应给客户端。
👉@RequestParam：将请求参数绑定到控制器的方法参数上
👉@PathVariable：从请求路径下中获取请求参数(/user/{id})，传递给方法的形参。
👉@RequestHeader：将请求头中的参数值映射到控制器的参数中。
👉@RestController：@Controller + @ResponseBody

Spring MVC

用来构建web应用的，是Spring框架的一部分，它将应用程序分为三个主要部分：模型（Model）、视图（View）和控制器（Controller）。

SpringMVC的执行流程

👉公共步骤

1. 用户发送出请求到前端控制器DispatcherServlet 【调度中心】
2. DispatcherServlet收到请求调用处理器映射器HandlerMapping 【根据请求的URL】
3. HandlerMapping找到具体的处理器Controller，生成处理器对象及处理器拦截器Interceptor(如果有)，再一起返回给DispatcherServlet
4. DispatcherServlet调用处理器适配器HandlerAdapter
5. HandlerAdapter经过适配调用具体的处理器（Handler/Controller）

🐖JSP视图版本
6. Controller执行完成返回一个ModelAndView对象给HandlerAdapter
7. HandlerAdapter将ModelAndView返回给DispatcherServlet
8. DispatcherServlet将ModelAndView传给视图解析器ViewReslover
9. ViewReslover解析后返回具体的视图View
10. DispatcherServlet根据View进行渲染视图（将模型数据填充到视图中）
11. DispatcherServlet响应用户

🐱前后端分离开发版本
12. 方法上添加了@ResponseBody，通过HttpMessageConverter将返回结果转换为JSON并响应

Springboot自动配置原理

在Spring Boot项目中的引导类上有一个注解@SpringBootApplication，这个注解是对三个注解进行了封装
@SpringBootConfiguration：@Configuration【声明自己是spring的一个配置类，可替换xml文件】和@Index【加速启动】
@ComponentScan：扫描被@Component (@Service,@Controller)注解的 bean，默认扫描当前包及其子包，可以自定义不扫描某些 bean。
@EnableAutoConfiguration：实现自动化配置的核心注解。继承了@Import注解，用于导入指定的类或配置类，它会返回一个string数组，里面是需要导入IoC容器的类。底层就是加载在META-INF/spring.factories 和 META-INF/spring/org.springframework.book.autoconfigure.AutoConfiguration.imports文件中的信息，这两个配置文件里面存储的是类的全类名，后置都是AutoConfiguration

AOP

AOP是面向切面编程，也可以说是面向特定方法编程，是基于动态代理实现的，它主要是用于将公共的逻辑写在一个切面里，在我们其他个性化的业务逻辑代码中，如果需要这个公共逻辑，就将原始业务对象进行代理，注入切面，而无需修改原有的代码即可完成需求。

优点：对代码无侵入，耦合度低，维护方便，减少重复代码。

应用：权限控制、异常处理、记录日志、事务管理等

事务管理的AOP思想

Spring事务管理，底层其实也是通过AOP来实现的，只要添加@Transactional注解之后，AOP程序自动会在原始方法运行前先来开启事务，在原始方法运行完毕之后提交或回滚事务

项目中AOP的编码流程

1. 自定义一个注解@ApiLimitedRole，通过第三步中切点的指定，使用了该注解的方法要走AOP。
2. 使用@Component和@Aspect配置ApiLimitedRoleAspect类，在这个类中配置AOP
3. @Pointcut定义切点为check()方法，来告诉spring在什么时候进行依赖注入。这里指定了

("@annotation(com.imooc.bilibili.domain.annotation.ApiLimitedRole)"，表示当执行到我们自定义的这个注解的时候就执行。

1. @Before("check() && @annotation(apiLimitedRole)")定义before方法，指走到切点之后先走这个before。在这里查询数据库得到当前用户所对应的权限列表，然后和自己设置的权限列表相比对，如果二者有交集则抛出异常不让访问。【如：LV0的用户不能投稿，则将LV0写入禁止的权限列表，查询当前用户等级是否为LV0】
2. 通过上述配置，只需要在需要权限验证的方法上面加上一个@ApiLimitedRole，并指定不能访问该接口的等级，即可通过AOP实现权限控制。

AOP的核心概念

• Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。

• Joint Point（连接点）：原业务方法的反射？是切面方法的形参。比如通过jointpoint.getArgs()可以获得原业务方法的参数，通过jointpoint.proceed()调用原业务方法。

  • 对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型
  • 对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型

• Point Cut（切入点）：匹配Target

  • execution：类似于正则表达式一样，来定位方法
  • @annotation：找自定义注解定位方法

• Advice（通知）：

  • @Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行
  • @Before：前置通知，此注解标注的通知方法在目标方法前被执行
  • @After ：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行
  • @AfterReturning ： 返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行
  • @AfterThrowing ： 异常后通知，此注解标注的通知方法发生异常后执行

• Target（目标对象）：需要被代理的原业务方法，其上有@自定义注解标注。

[tbc]