Java核心知识点整理大全13-笔记

往期快速传送门👆：

[6.1.7.5. Spring Bean 生命周期](#6.1.7.5. Spring Bean 生命周期)

实例化

[IOC 依赖注入](#IOC 依赖注入)

[setBeanName 实现](#setBeanName 实现)

[BeanFactoryAware 实现](#BeanFactoryAware 实现)

[ApplicationContextAware 实现](#ApplicationContextAware 实现)

[postProcessBeforeInitialization 接口实现-初始化预处理](#postProcessBeforeInitialization 接口实现-初始化预处理)

init-method

postProcessAfterInitialization

[Destroy 过期自动清理阶段](#Destroy 过期自动清理阶段)

[6.1.7.6. Spring 依赖注入四种方式构造器注](#6.1.7.6. Spring 依赖注入四种方式构造器注)

构造器注入

[setter 方法注入](#setter 方法注入)

静态工厂注入

实例工厂

[6.1.7.7. 5 种不同方式的自动装配](#6.1.7.7. 5 种不同方式的自动装配)

[6.1.8. Spring APO 原理](#6.1.8. Spring APO 原理)

[6.1.8.1. 概念](#6.1.8.1. 概念)

[AOP 主要应用场景有：](#AOP 主要应用场景有：)

[6.1.8.2. AOP 核心概念](#6.1.8.2. AOP 核心概念)

[6.1.8.1. AOP 两种代理方式](#6.1.8.1. AOP 两种代理方式)

[JDK 动态接口代理](#JDK 动态接口代理)

[CGLib 动态代理](#CGLib 动态代理)

[6.1.8.2. 实现原理：](#6.1.8.2. 实现原理：)

[6.1.9. Spring MVC 原理](#6.1.9. Spring MVC 原理)

[6.1.10. Spring Boot 原理](#6.1.10. Spring Boot 原理)

[1. 创建独立的 Spring 应用程序](#1. 创建独立的 Spring 应用程序)

[2. 嵌入的 Tomcat，无需部署 WAR 文件](#2. 嵌入的 Tomcat，无需部署 WAR 文件)

[3. 简化 Maven 配置](#3. 简化 Maven 配置)

[4. 自动配置 Spring](#4. 自动配置 Spring)

[5. 提供生产就绪型功能，如指标，健康检查和外部配置](#5. 提供生产就绪型功能，如指标，健康检查和外部配置)

[6. 绝对没有代码生成和对 XML 没有要求配置 [1]](#6. 绝对没有代码生成和对 XML 没有要求配置 [1])

6.1.7.5. Spring Bean 生命周期

实例化

实例化一个 Bean，也就是我们常说的 new。

IOC 依赖注入

按照 Spring 上下文对实例化的 Bean 进行配置，也就是 IOC 注入。

setBeanName 实现

如果这个 Bean 已经实现了 BeanNameAware 接口，会调用它实现的 setBeanName(String) 方法，此处传递的就是 Spring 配置文件中 Bean 的 id 值

BeanFactoryAware 实现

如果这个 Bean 已经实现了 BeanFactoryAware 接口，会调用它实现的 setBeanFactory， setBeanFactory(BeanFactory)传递的是 Spring 工厂自身（可以用这个方式来获取其它 Bean，只需在 Spring 配置文件中配置一个普通的 Bean 就可以）。

ApplicationContextAware 实现

如果这个 Bean 已经实现了 ApplicationContextAware 接口，会调用 setApplicationContext(ApplicationContext)方法，传入 Spring 上下文（同样这个方式也可以实现步骤 4 的内容，但比 4 更好，因为 ApplicationContext 是 BeanFactory 的子接口，有更多的实现方法）

postProcessBeforeInitialization 接口实现-初始化预处理

如果这个 Bean 关联了 BeanPostProcessor 接口，将会调用 postProcessBeforeInitialization(Object obj, String s)方法，BeanPostProcessor 经常被用作是 Bean 内容的更改，并且由于这个是在 Bean 初始化结束时调用那个的方法，也可以被应用于内存或缓存技术。

init-method

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

postProcessAfterInitialization

如果这个 Bean 关联了 BeanPostProcessor 接口，将会调用 postProcessAfterInitialization(Object obj, String s)方法。注：以上工作完成以后就可以应用这个 Bean 了，那这个 Bean 是一个 Singleton 的，所以一般情况下我们调用同一个 id 的 Bean 会是在内容地址相同的实例，当然在 Spring 配置文件中也可以配置非 Singleton。

Destroy 过期自动清理阶段

当 Bean 不再需要时，会经过清理阶段，如果 Bean 实现了 DisposableBean 这个接口，会调用那个其实现的 destroy()方法； destroy-method 自配置清理
最后，如果这个 Bean 的 Spring 配置中配置了 destroy-method 属性，会自动调用其配置的销毁方法

bean 标签有两个重要的属性（init-method 和 destroy-method）。用它们你可以自己定制初始化和注销方法。它们也有相应的注解（@PostConstruct 和@PreDestroy）。

6.1.7.6. Spring 依赖注入四种方式构造器注

构造器注入

java 复制代码

/*带参数，方便利用构造器进行注入*/
 public CatDaoImpl(String message){
 this. message = message;
 }
<bean id="CatDaoImpl" class="com.CatDaoImpl">
<constructor-arg value=" message "></constructor-arg>
</bean>

setter 方法注入

java 复制代码

public class Id {
 private int id;
 public int getId() { return id; }
 public void setId(int id) { this.id = id; }
}
<bean id="id" class="com.id "> <property name="id" value="123"></property> </bean>

静态工厂注入

静态工厂顾名思义，就是通过调用静态工厂的方法来获取自己需要的对象，为了让 spring 管理所有对象，我们不能直接通过"工程类.静态方法()"来获取对象，而是依然通过 spring 注入的形式获取：

java 复制代码

public class DaoFactory { //静态工厂
 public static final FactoryDao getStaticFactoryDaoImpl(){
 return new StaticFacotryDaoImpl();
 }
}
public class SpringAction {
 private FactoryDao staticFactoryDao; //注入对象
 //注入对象的 set 方法
 public void setStaticFactoryDao(FactoryDao staticFactoryDao) {
 this.staticFactoryDao = staticFactoryDao;
 }
}
//factory-method="getStaticFactoryDaoImpl"指定调用哪个工厂方法
 <bean name="springAction" class=" SpringAction" >
 <!--使用静态工厂的方法注入对象,对应下面的配置文件-->
 <property name="staticFactoryDao" ref="staticFactoryDao"></property>
 </bean>
 <!--此处获取对象的方式是从工厂类中获取静态方法-->
<bean name="staticFactoryDao" class="DaoFactory"
factory-method="getStaticFactoryDaoImpl"></bean>

实例工厂

实例工厂的意思是获取对象实例的方法不是静态的，所以你需要首先 new 工厂类，再调用普通的实例方法：

java 复制代码

 public class DaoFactory { //实例工厂
 public FactoryDao getFactoryDaoImpl(){
 return new FactoryDaoImpl();
}
}
public class SpringAction {
 private FactoryDao factoryDao; //注入对象
 public void setFactoryDao(FactoryDao factoryDao) {
 this.factoryDao = factoryDao;
 }
}
 <bean name="springAction" class="SpringAction">
 <!--使用实例工厂的方法注入对象,对应下面的配置文件-->
 <property name="factoryDao" ref="factoryDao"></property>
 </bean>
 <!--此处获取对象的方式是从工厂类中获取实例方法-->
<bean name="daoFactory" class="com.DaoFactory"></bean>
<bean name="factoryDao" factory-bean="daoFactory"
factory-method="getFactoryDaoImpl"></bean>

6.1.7.7. 5 种不同方式的自动装配

Spring 装配包括手动装配和自动装配，手动装配是有基于 xml 装配、构造方法、setter 方法等自动装配有五种自动装配的方式，可以用来指导 Spring 容器用自动装配方式来进行依赖注入。 1. no：默认的方式是不进行自动装配，通过显式设置 ref 属性来进行装配。 2. byName：通过参数名自动装配，Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byname，之后容器试图匹配、装配和该 bean 的属性具有相同名字的 bean。 3. byType：通过参数类型自动装配，Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byType，之后容器试图匹配、装配和该 bean 的属性具有相同类型的 bean。如果有多个 bean 符合条件，则抛出错误。 4. constructor：这个方式类似于 byType，但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。 5. autodetect：首先尝试使用 constructor 来自动装配，如果无法工作，则使用 byType 方式。

6.1.8. Spring APO 原理

6.1.8.1. 概念

"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。使用"横切"技术，AOP 把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

AOP 主要应用场景有：

Authentication 权限
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading 懒加载
Debugging 调试
logging, tracing, profiling and monitoring 记录跟踪优化校准
Performance optimization 性能优化
Persistence 持久化
Resource pooling 资源池
Synchronization 同步
Transactions 事务

6.1.8.2. AOP 核心概念

1、切面（aspect）：类是对物体特征的抽象，切面就是对横切关注点的抽象

2、横切关注点：对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点。

3、连接点（joinpoint）：被拦截到的点，因为 Spring 只支持方法类型的连接点，所以在 Spring 中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器。

4、切入点（pointcut）：对连接点进行拦截的定义

5、通知（advice）：所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类。

6、目标对象：代理的目标对象

7、织入（weave）：将切面应用到目标对象并导致代理对象创建的过程

8、引入（introduction）：在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段。

6.1.8.1. AOP 两种代理方式

Spring 提供了两种方式来生成代理对象: JDKProxy 和 Cglib，具体使用哪种方式生成由 AopProxyFactory 根据 AdvisedSupport 对象的配置来决定。默认的策略是如果目标类是接口，则使用 JDK 动态代理技术，否则使用 Cglib 来生成代理。

JDK 动态接口代理

JDK 动态代理主要涉及到 java.lang.reflect 包中的两个类：Proxy 和 InvocationHandler。 InvocationHandler是一个接口，通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态将横切逻辑和业务逻辑编制在一起。Proxy 利用 InvocationHandler 动态创建一个符合某一接口的实例，生成目标类的代理对象。

CGLib 动态代理

：CGLib 全称为 Code Generation Library，是一个强大的高性能，高质量的代码生成类库，可以在运行期扩展 Java 类与实现 Java 接口，CGLib 封装了 asm，可以再运行期动态生成新的 class。和 JDK 动态代理相比较：JDK 创建代理有一个限制，就是只能为接口创建代理实例，而对于没有通过接口定义业务方法的类，则可以通过 CGLib 创建动态代理。

6.1.8.2. 实现原理：

java 复制代码

@Aspect
public class TransactionDemo {
 @Pointcut(value="execution(* com.yangxin.core.service.*.*.*(..))")
 public void point(){
 }
 @Before(value="point()")
 public void before(){
 System.out.println("transaction begin");
 }
 @AfterReturning(value = "point()")
 public void after(){
 System.out.println("transaction commit");
 }
 @Around("point()")
 public void around(ProceedingJoinPoint joinPoint) throws Throwable{
 System.out.println("transaction begin");
 joinPoint.proceed();
 System.out.println("transaction commit");
 }
}

6.1.9. Spring MVC 原理

Spring 的模型-视图-控制器（MVC）框架是围绕一个 DispatcherServlet 来设计的，这个 Servlet 会把请求分发给各个处理器，并支持可配置的处理器映射、视图渲染、本地化、时区与主题渲染等，甚至还能支持文件上传。

Http 请求到 DispatcherServlet

(1) 客户端请求提交到 DispatcherServlet。

HandlerMapping 寻找处理器

(2) 由 DispatcherServlet 控制器查询一个或多个 HandlerMapping，找到处理请求的 Controller。

调用处理器 Controller

(3) DispatcherServlet 将请求提交到 Controller。

Controller 调用业务逻辑处理后，返回 ModelAndView

(4)(5)调用业务处理和返回结果：Controller 调用业务逻辑处理后，返回 ModelAndView。

DispatcherServlet 查询 ModelAndView

(6)(7)处理视图映射并返回模型： DispatcherServlet 查询一个或多个 ViewResoler 视图解析器，找到 ModelAndView 指定的视图。

ModelAndView 反馈浏览器 HTTP

(8) Http 响应：视图负责将结果显示到客户端

6.1.10. Spring Boot 原理

Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot 致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。其特点如下：

Java核心知识点整理大全13-笔记

6.1.7.5. Spring Bean 生命周期

实例化

IOC 依赖注入

setBeanName 实现

BeanFactoryAware 实现

ApplicationContextAware 实现

postProcessBeforeInitialization 接口实现-初始化预处理

init-method

postProcessAfterInitialization

Destroy 过期自动清理阶段

6.1.7.6. Spring 依赖注入四种方式 构造器注

构造器注入

setter 方法注入

静态工厂注入

实例工厂

6.1.7.7. 5 种不同方式的自动装配

6.1.8. Spring APO 原理

6.1.8.1. 概念

AOP 主要应用场景有：

6.1.8.2. AOP 核心概念

6.1.8.1. AOP 两种代理方式

JDK 动态接口代理

CGLib 动态代理

6.1.8.2. 实现原理：

6.1.9. Spring MVC 原理

6.1.10. Spring Boot 原理

1. 创建独立的 Spring 应用程序

2. 嵌入的 Tomcat，无需部署 WAR 文件

3. 简化 Maven 配置

4. 自动配置 Spring

5. 提供生产就绪型功能，如指标，健康检查和外部配置

6. 绝对没有代码生成和对 XML 没有要求配置 [1]

6.1.7.6. Spring 依赖注入四种方式构造器注