Spring框架学习-详细

1. Spring简介

1.1 面向接口编程

多态：一个父类/接口的引用可以执行其任何一个子类/实现类的对象。
问题： 在Servlet中需要调用Service中的方法，则需要在Servlet类中通过使用new关键字创建Service 的实例对象；在Service实现类中需要调用DAO中的方法，也需要在Service实现类中通过new关键字创建DAO实现类对象。这增加了代码的耦合性、失去了面向接口编程的灵活性。

解决方案： 面向接口编程。在Service中定义Service接口的对象变量，不适用new关键字创建实现类对象，在servlet的实例化的时候，通过反射动态的给Service对象变量赋值。
如何实现： Spring可以实现。

1.2 Spring简介

Spring是一个轻量级的控制反转（IoC）和 面向切面（AOP）的容器框架。用途：用来解决企业项目开发的复杂度问题——解耦。
特征：

• 轻量级：体积小，对代码没有侵入性
• 控制反转：IoC（Inverse of Control），把原来该由我们手动new创建对象以及对对象属性赋值（DI，依赖注入）的操作交给了Spring去完成。
• 面向切面：AOP（Aspect Oriented Programming），可以在不改变原有业务逻辑的情况下实现对业务的增强。比如事务的管理操作。
• 容器：实例的容器，管理创建的对象。

1.3 Spring体系结构

Spring的生态体系：
Spring Framework：IoC、AOP。核心框架。
Spring Boot：工具框架
Spring Data：Spring提供的数据访问的客户端。（比如访问数据库会用到jpa）
Spring Cloud：微服务架构
Spring Security：安全框架

• Spring的架构图：
  Spring中的各个组件学习：

1. Core Container：核心容器，是Spring提供的所有功能的基础。Spring的容器组件，用于完成实例的创建和管理。
   Beans：对象（实例）管理
   Core：
   context：容器上下文
   SpEL(expression)：Spring expression Language，表达式语言。
2. AOP、Aspects：Spring的AOP组件，实现面向切面编程
   AOP：
   Aspects：
3. web：spring web组件指的是Spring MVC框架（所以Spring MVC其实是Spring的一个组件，只不过我们学习的时候当成一个框架去学习）。用来实现web项目的MVC控制
   web：Spring对web项目的支持
   webMVC：SpringMVC组件
4. Data Acess：Spring数据访问组件，也是一个基于JDBC封装的持久层框架（即使没有MyBatis，Spring也可以完成持久化操作）。
   tx：关于事务管理的组件

什么事持久层？
答：可以理解成数据 保存在 数据库或者硬盘一类可以保存很长时间的设备里面，不像放在内存中那样断电就消失了，也就是把数据存在持久化设备上，mybatis就是持久层。

5. Test：Spring的单元测试组件们提供了Spring环境下的单元测试支持
   test

2 Spring IoC - 基于XML

Spring IOC容器组件，可以完成对象的创建、对象属性赋值、对象管理。

2.1 Sping框架部署（IoC）

步骤如下：

1. 创建Maven工程
   Spring可以在**Java项目使用也可以在Web项目**使用
2. 添加Spring IoC依赖
   核心的四个（core、beans、expression、context(导入context其他四个也会默认导入)）+aop
3. 创建Spring配置文件
   通过配置文件“告诉”Spring容器创建什么对象，给对象属性赋什么值
   在resources目录下创建名为applicationContext.xml的文件名（可自定义）

2.2 Spring IoC使用

使用Spring IoC创建对象并管理对象

步骤如下：

1. 创建一个实体类
2. 在Spring配置文件中配置实体类
   配置文件一般起名为applicationContext.xml
3. 初始化Spring对象工厂，获取对象

ClassPathXMLApplicationContext context = new ClassPathXMLApplicationContext("applicationContext.xml");

2.3 IoC和DI

• IoC 控制反转，通过Spring对象工厂完成对象的创建（创建对象）
• DI 依赖注入，在Spring完成对象创建的同时依赖Spring容器完成对象属性的赋值（既创建对象又赋值）

1. IoC：当我们需要通过Spring对象工厂创建某个类的对象的时候，需要将这个交给Spring管理——通过bean标签配置
2. DI：通过Spring容器给创建的对象属性赋值

2.4 DI依赖注入

Spring容器加载配置文件之后，通过反射创建类的对象，并给属性赋值；

Spring容器通过反射方法实现属性注入有三种方式

• set方法注入
• 构造器注入
• 接口注入（不常用）

1. set方法注入

在bean标签中通过配置property属性的方式，给属性赋值。（配置property实际上就是通过反射调用set方法给属性赋值，完成属性的注入，所以要求必须得有set方法才行）

（1）简单类型（int、float、double）以及字符串 ：直接通过property标签的value属性赋值

在这里插入代码片

（2）日期对象 ：方式1：在property标签中通过ref引用Spring容器中的一个对象；方式2：在property标签中添加字标签bean来指定对象

在这里插入代码片

（3）自定义类对象属性 ：方式1：在property标签中通过ref引用Spring容器中的一个对象；方式2：在property标签中添加字标签bean来指定对象

在这里插入代码片

（4）集合类型 ：
a）List：List中的元素是字符串或简单类型的封装，直接赋值；List中的元素使对象类型，则在list标签内加上bean的子标签，或者加上ref引用现有容器中的bean即可
b）Set：与List元素的注入方式相同
c）Map：

<property name="maps"><map><entry><key><value>k1</value></key><value>abc</value></entry><entry><key><value>k2</value></key><value>def</value></entry></map>
</property>

2. 构造器注入

（1）简单类型、字符串类型、对象类型：

（2）集合类型属性：

2.5 Bean的作用域

在bean标签中可以用过scope属性指定对象的作用域：

• scope="singleton"：表示当前bean 是单例模式。（且默认是饿汉模式，即Spring容器初始化阶段就会完成此对象的创建；当在bean标签中设置lazy-init="true"则会变为懒汉模式，什么时候要这个对象什么时候才会创建）每次通过Spring容器获取此bean的对象时都是同一个对象。
• scope="prototype"：表示当前bean为非单例模式，即多例模式。每次通过Spring容器获取此bean的对象时都会创建一个新的对象。

2.6 bean的声明周期方法

在bean标签中通过init-method属性指定当前bean的初始化方法，初始化方法在构造器执行之后执行；
通过destroy-method属性指定当前bean的销毁方法，销毁方法在对象销毁之前执行。
具体功能在开发中需要根据具体的业务需求进行操作。

• Bean类

public class Book{private int bookId;private String bookName;//初始化方法：在创建当前类对象时调用的方法，进行一些资源准备的操作public void init(){//	函数内容}//销毁方法：在Spring容器销毁对象时调用此方法，进行一些资源回收性的操作public void destroy(){//	函数内容}
}

• Spring配置文件

<bean id="book" class="com.qfedu.ioc.bean.Book" scope="prototype" init-method="init" destroy-method="destroy">
</bean>

2.7 自动装配

• 自动装配：Spring在实例化当前bean的时候从Spring容器中找到匹配的实例赋值给当前bean的属性autowire
• 自动装配的策略有两种：
  （1）byName：根据当前Bean的属性名在Spring 容器中寻找匹配的对象，如果根据name找到了bean但是类型不匹配则会抛出异常
  （2）byType：根据当前Bean的属性类型在Spring容器中寻找匹配的对象，如果根据类型找到了多个bean也会抛出异常

2.8 Spring IOC 工作原理

【图】

3 Spring IOC - 基于注解

Spring IOC的使用，需要我们通过XML将类声明给Spring容器进行管理，从而通过Spring工厂完成对象的创建及属性值的注入；
Spring除了提供基于XML的配置方式，同时提供了基于注解的配置：即直接在实体类中添加注解声明给Spring容器管理，以简化开发步骤；

3.1 Spring 框架部署

步骤如下：

1. 创建Maven项目
2. 添加Spring IOC的依赖：给pom.xml配置文件里添加依赖<dependency>
3. 创建Spring配置文件：applicationContext.xml
   因为Spring容器初始化时，只会加载applicationContext.xml文件，因此我们在实体类中添加的注解就不会被Spring扫描，所以我们需要在applicationContext.xml声明Spring的扫描范围，已达到Spring初始化时扫描带有注解的实体类并完成初始化工作

3.2 IoC常用注解

1. @Component

• 类注解，用于声明此类被Spring容器管理，相当于xml中的bean标签作用
• @Component(value="stu")可以通过value属性用于指定当前bean的id，相当于bean标签的id属性，value属性也可省略，若省略则默认当前类的id为类名首字母改小写
• 除了@Component之外，@Service、@Controller、@Repository这三个注解也可以将类声明给Spring管理，主要是语义上的区别
  • @Controller注解主要声明将控制器类配置给Spring管理，比如Servlet
  • @Service注解主要声明业务处理类配置Spring管理，Service接口的实现类
  • @Repository主要声明持久化类配置给Spring管理，比如DAO接口
  • @Component除了控制器、service和DAO之外的类一律使用此注解声明

2. @Scope

• @Scope注解：用于声明当前类是单例模式还是非单例模式，相当于bean标签的scope属性，默认是单例模式
• @Scope("prototype")：声明当前类是非单例模式

3. @Lazy

• @Lazy:类注解，用于声明一个单例模式的Bean是否为懒汉模式，默认为true懒汉模式
• @Lazy(false)：声明当前类是恶汉模式

4. @PostConstruct 与@PreDestory

• @PostConstruct：方法注解，声明一个方法为当前类的初始化方法（在构造器之后执行），相当于bean标签的init-method属性
• @PreDestory：方法注解，声明一个方法为当前类的销毁方法（在对象从容器中释放之前执行），相当于bean标签的destory-method属性

5. @Autowired

• 属性注解、方法朱姐（set方法），声明当前属性自动装配，默认根据类型匹配byType，默认如果没有找到类型与属性匹配的bean则抛出异常（required=true）
• @Autowired(required=false)通过required属性配置当前自动装配的对象是否是必须的，false就表示非必须
• @Qualifier("clazz")：放到参数的set方法的参数引用括号里，表明其属性的set是按照这个名字去取的

@Autowired
public void setClazz(@Qualifier("c2") Clazz clazz){this.clazz = clazz;
}

6. @Resource

• 属性注解，也用于默认属性自动装配
• 默认装配方式byName；若根据byName没有找到对应的bean，则继续根据byType寻找对应的bean，根据byType如果没有找到bean或找到不止一个类型的bean，则抛出异常

4 代理设计模式

4.1 生活中的代理

代理设计模式的优点：将通用性的工作都交给代理对象完成，被代理对象只需专注自己的核心业务

4.2 静态代理

• 静态代理： 代理类只能为特定的类生产代理对象，不能代理任意类
• 使用代理的好处：
  （1）被代理类中只用关注核心业务的实现，将通用的管理型逻辑（事务管理、日志管理）和业务逻辑分离
  （2）将通用的代码（事务管理、日志管理等）放在代理类中实现，提供了代码的复用性
  （3）通过在代理类添加业务逻辑，实现对原有业务逻辑的扩展（增强）

4.3 动态代理

• 动态代理： 几乎可以为所有的类产生代理对象
• 动态代理的实现方式有2种：

1. JDK动态代理
2. CGLib动态代理

JDK动态代理实现

• JDK动态代理，是通过被代理对象实现的接口产生其代理对象的：

1. 创建一个类，实现InvocationHandler接口，重写invoke方法
2. 在类中定义一个Object类型的变量，并提供这个变量的有参构造器，用于将被代理对象传递进来
3. 定义getProxy方法，用于创建并返回代理对象

CGLib动态代理实现

• 由于JDK动态代理是通过被代理类实现的接口来创建代理对象的，因此JDK动态代理只能代理实现了接口的类的对象。如果一个类没有实现任何接口，该如何产生代理对象呢？
• CGLib动态代理，是通过创建被代理类的子类来创建代理对象的，因此即使没有实现任何接口的类也可以通过CGLib产生代理对象
• CGLib动态代理不能为final类创建代理对象

1. 添加cglib的依赖

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.3.0</version>
</dependency>

2. 创建一个类，实现MethodInterceptor接口，同时实现接口中的intercept方法
3. 在类中定义一个Object类型的变量，并提供这个变量的有参构造器，用于传递被代理对象
4. 定义getProxy方法创建并返回代理对象（代理对象是通过创建被代理类的自雷来创建的）

5 Spring AOP

5.1 AOP 的概念

Aspect Oriented Programming 面向切面编程，是一种利用“横切”的技术（底层实现就是动态代理），对原有的业务逻辑进行拦截，并且可以再这个拦截的横切面上添加特定的业务逻辑，对原有的业务进行增强。

基于动态代理实现在不改变原有业务的情况下对业务逻辑进行增强。

连接点：程序中的所有方法都是连接点
切入点：被Spring横切的方法
切点：添加到切入点的新增的业务方法
切面：就是定义切点方法的类
通过配置来告诉Spring AOP需要将切点放到切入点的位置

5.2 Spring AOP框架部署

1. 创建Maven项目
2. 添加依赖：context、aspects
3. 创建配置Spring配置文件
4. 需要引入aop的命名空间

5.3 AOP配置——基于XML

在DAO的方法添加开启事务和提交事务的逻辑
AOP开发步骤：

1. 创建一个切面类，定义要添加的业务逻辑，在切面类定义切点方法
2. 在配置文件applicationContext.xml中配置aop，将切面类配置给Spring容器
   （1）声明切入点
   （2）声明切面类
3. 配置AOP的通知策略

5.4 切入点的声明

注意：
如果要使用Spring aop面向切面编程，调用切入点的方法的对象必须通过Spring容器获取；
如果一个类中的方法被声明为切入点并且织入了切入点之后，通过Spring容器获取该类对象，实则获取到的是一个代理对象；
如果一个类中的方法没有被声明为切入点，通过Spring容器获取的就是这个类真实创建的对象

各种切入点的声明方式：
（待更新）

AOP使用注意事项：
（待更新）