一、Spring概述

1.1 web项目开发中的耦合度问题

  • 在Servlet中需要调用service中的方法,则需要在Servlet类中通过new关键字创建Service的实例

    1. public interface ProductService{
    2. public List<Product> listProducts();
    3. }
    1. public class ProductServiceImpl1 implements ProductService{
    2. public List<Product> listProducts(){
    3. //查询热销商品
    4. }
    5. }
    1. public class ProductServiceImpl2 implements ProductService{
    2. public List<Product> listProducts(){
    3. //查询好评商品
    4. }
    5. }
    1. public class ProductListServlet extends HttpServlet{
    2. //在servlet中使用new关键字创建ProductServiceImpl1对象,增加了servlet和service的耦合度
    3. private ProductService productService = new ProductServiceImpl1();
    4. protected void doGet(HttpServletRequest request,HttpServletResponse response){
    5. doPost(request,response);
    6. }
    7. protected void doPost(HttpServletRequest request,HttpServletResponse response){
    8. productService.listProducts();
    9. }
    10. }
  • 在service实现类中需要调用DAO中的方法,也需要在servcie实现类通过new关键字创建DAO实现类对象

  • 如果使用new关键字创建对象:
    • 失去了面向接口编程的灵活性
    • 代码的侵入性增强(增加了耦合度)、降低了代码的灵活性
    • 增强项目的扩展性

1.2 面向接口编程

面向接口编程
image.png

解决方案:在Servlet中定义Service接口的对象变量,不使用new关键字创建实现类对象,在servlet的实例化的时候,通过反射动态地给Service对象变量赋值。

如何实现:Spring可以做到!!!

1.3 Spring介绍

Spring是一个轻量级的控制反转和面向切面的容器框架,用来解决企业项目开发的复杂度问题—解耦

  • 轻量级:体积小,对代码没有侵入性
  • 控制反转:IoC(Inverse of Control),把创建对象的工作交由Spring完成,Spring在创建对象的时候同时可以完成对象属性赋值(DI)
  • 面向切面:AOP(Aspect Oriented Programming)面向切面编程,可以在不改变原有业务逻辑的情况下实现对业务的增强
  • 容器:实例的容器,管理创建的对象

1.4 Spring架构

1.4.1 Core Container

Spring容器组件,用于完成实例的创建和管理

  • core
  • beans 实例管理
  • context 容器上下文

1.4.2 AOP、Aspects

Spring AOP组件,实现面向切面编程

  • aop
  • aspects

1.4.3 web

Spring web组件实际指的是SpringMVC框架,实现web项目的MVC控制

  • web (Spring对web项目的支持)
  • webmvc (SpringMVC组件)

1.4.4 Data Access

Spring数据访问组件,也是一个基于JDBC封装的持久层框架(即使没有mybatis,Spring也可以完成持久化操作)

  • tx

1.4.5 Test

Spring的单元测试组件,提供了Spring环境下的单元测试支持

  • test

二、Spring IoC — 基于XML

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

2.1 Spring框架部署(IoC)

2.1.1 创建Maven工程
  • Java
  • Web

2.1.2 添加SpringIoC依赖
  • core
  • beans
  • aop
  • expression
  • context 导入这一个,其他的自动导入(传递依赖)
  1. <dependency>
  2. <groupId>org.springframework</groupId>
  3. <artifactId>spring-context</artifactId>
  4. <version>5.2.13.RELEASE</version>
  5. </dependency>

2.1.3 创建Spring配置文件

通过配置文件”告诉”Spring容器创建什么对象,给对象属性赋什么值

  • 在resources目录下创建名为appicationContext.xml的文件(文件名是可以自定义的)
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans.xsd">
  6. <!-- 对于一个xml文件如果作为框架的配置文件,需要遵守框架的配置规则 -->
  7. <!-- 通常一个框架为了让开发者能够正确的配置,都会提供xml的规范文件(dtd\xsd) -->
  8. </beans>

2.2 SpringIoC使用

使用 SpringIoC组件创建并管理对象

2.2.1 创建一个实体类
  1. public class Student {
  2. private String stuNum;
  3. private String stuName;
  4. private String stuGender;
  5. private int stuAge;
  6. private Date enterenceTime; //入学日期
  7. }

2.2.2 在Spring配置文件中配置实体类
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans.xsd">
  6. <!--通过bean将实体类配置给Spring进行管理,id表示实体类的唯一表示-->
  7. <bean id="stu" class="com.qfedu.ioc.bean.Student">
  8. <property name="stuNum" value="10002"/>
  9. <property name="stuName" value="李斯"/>
  10. <property name="stuGender" value="女"/>
  11. <property name="stuAge" value="20"/>
  12. </bean>
  13. </beans>

2.2.3 初始化Spring对象工厂,获取对象
  • ClassPathXMLApplicationContext
  1. //1.初始化Spring容器,加载Spring配置文件
  2. ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  3. //2.通过Spring容器获取Student对象
  4. Student student2 = (Student) context.getBean("stu");

2.3 IoC和DI

  • IoC (Inverse of Control) 控制反转,通过Spring对象工厂完成对象的创建
  • DI (Dependency Injection)依赖注入,在Spring完成对象创建的同时依赖Spring容器完成对象属性的赋值

2.3.1 IoC

当我们需要通过Spring对象工厂创建某个类的对象时候,需要将这个交给Spring管理——通过bean标签配置

  1. <!--通过bean将实体类配置给Spring进行管理,id表示实体类的唯一表示-->
  2. <bean id="stu" class="com.qfedu.ioc.bean.Student"></bean>
  3. <bean id="book" class="com.qfedu.ioc.bean.Book"></bean>

2.3.2 DI

通过Spring容器给创建的对象属性赋值

  1. <bean id="clazz" class="com.qfedu.ioc.bean.Clazz"></bean>
  2. <!--通过bean将实体类配置给Spring进行管理,id表示实体类的唯一表示-->
  3. <bean id="stu" class="com.qfedu.ioc.bean.Student" autowire="byName">
  4. <property name="stuNum" value="10001"/>
  5. </bean>

2.4 DI依赖注入

2.4.1 依赖注入三种方式

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

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

  • set方法注入
  • 构造器注入
  • 接口注入(不常用)

2.4.2 set方法注入

在bean标签中通过配置property标签给属性属性赋值,实际上就是通过反射调用set方法完成属性的注入

简单类型及字符串

  • 直接通过property标签的value属性赋值
  1. <!--通过bean将实体类配置给Spring进行管理,id表示实体类的唯一表示-->
  2. <bean id="stu" class="com.qfedu.ioc.bean.Student" autowire="byName">
  3. <!-- 简单类型 -->
  4. <property name="stuNum" value="10001"/>
  5. <property name="stuAge" value="12"/>
  6. <!-- 字符串类型-->
  7. <property name="weight" value="62.3"/>
  8. </bean>

日期类型

  • 方式1:在property标签中通过ref引用Spring容器中的一个对象
  1. <bean id="date" class="java.util.Date"></bean>
  2. <bean id="stu" class="com.qfedu.ioc.bean.Student" >
  3. <!-- 日期类型-->
  4. <property name="enterenceTime" ref="date"/>
  5. </bean>
  • 方式2:在property标签中添加子标签bean来指定对象
  1. <bean id="stu" class="com.qfedu.ioc.bean.Student" >
  2. <!-- 日期类型-->
  3. <property name="enterenceTime">
  4. <bean class="java.util.Date"/>
  5. </property>
  6. </bean>

自定义类对象属性

  • 方式1:
  1. <bean id="cla" class="com.qfedu.ioc.bean.Clazz">
  2. <property name="classId" value="2010"/>
  3. <property name="className" value="Java2010"/>
  4. </bean>
  5. <bean id="stu" class="com.qfedu.ioc.bean.Student">
  6. <!-- 自定义对象类型-->
  7. <property name="clazz" ref="cla"/>
  8. </bean>
  • 方式2
  1. <bean id="stu" class="com.qfedu.ioc.bean.Student">
  2. <!-- 自定义对象类型-->
  3. <property name="clazz">
  4. <bean class="com.qfedu.ioc.bean.Clazz">
  5. <property name="classId" value="2010"/>
  6. <property name="className" value="Java2010"/>
  7. </bean>
  8. </property>
  9. </bean>

集合类型

  • List

    • List List中的元素是字符串或者简单类型的封装类

      1. <property name="hobbies" value="旅游,电影"/>
      1. <property name="hobbies" >
      2. <list>
      3. <value>旅游</value>
      4. <value>电影</value>
      5. <value>Java</value>
      6. </list>
      7. </property>
    • List

      1. <property name="hobbies" >
      2. <list>
      3. <bean class="com.qfedu.ioc.bean.Book"/>
      4. <bean class="com.qfedu.ioc.bean.Book"/>
      5. <bean class="com.qfedu.ioc.bean.Book"/>
      6. <bean class="com.qfedu.ioc.bean.Book"/>
      7. </list>
      8. </property>
      1. <property name="hobbies" >
      2. <list>
      3. <ref bean="book"></ref> <!--引用容器中的备案-->
      4. <ref bean="book"></ref>
      5. </list>
      6. </property>
  • Set

    1. <property name="sets">
    2. <set>
    3. <!--和list元素注入方式相同-->
    4. </set>
    5. </property>
  • Map

    1. <property name="maps">
    2. <map>
    3. <entry>
    4. <key>
    5. <value>k1</value>
    6. </key>
    7. <value>123</value>
    8. </entry>
    9. <entry>
    10. <key>
    11. <value>k2</value>
    12. </key>
    13. <value>456</value>
    14. </entry>
    15. </map>
    16. </property>
  • Properties

    1. <property name="properties">
    2. <props>
    3. <prop key="k1">aaa</prop>
    4. <prop key="k2">bbb</prop>
    5. </props>
    6. </property>

2.4.3 构造器注入

简单类型、字符串、对象

  1. public class Student {
  2. private String stuNum;
  3. private String stuName;
  4. private String stuGender;
  5. private int stuAge;
  6. private double weight;
  7. private Date enterenceTime; //入学日期
  8. private Clazz clazz;
  9. public Student(String stuNum, String stuName, String stuGender, int stuAge, double weight, Date enterenceTime, Clazz clazz) {
  10. this.stuNum = stuNum;
  11. this.stuName = stuName;
  12. this.stuGender = stuGender;
  13. this.stuAge = stuAge;
  14. this.weight = weight;
  15. this.enterenceTime = enterenceTime;
  16. this.clazz = clazz;
  17. }
  18. }
  1. <bean id="date" class="java.util.Date"></bean>
  2. <bean id="stu" class="com.qfedu.ioc.bean.Student">
  3. <constructor-arg index="0" value="10001"/> <!--字符串类型-->
  4. <constructor-arg index="2" value="女"/>
  5. <constructor-arg index="1" value="张三"/>
  6. <constructor-arg index="3" value="21"/> <!--简单类型-->
  7. <constructor-arg index="4" value="62.5"/>
  8. <constructor-arg index="5" ref="date"/> <!--对象类型-->
  9. <constructor-arg index="6"> <!--对象类型-->
  10. <bean class="com.qfedu.ioc.bean.Clazz"></bean>
  11. </constructor-arg>
  12. </bean>

集合类型属性

  1. public class Student{
  2. private List<String> hobbies;
  3. private Set<String> sets;
  4. private Map<String,Object> maps;
  5. private Properties properties;
  6. public Student(List<String> hobbies, Set<String> sets, Map<String, Object> maps, Properties properties) {
  7. this.hobbies = hobbies;
  8. this.sets = sets;
  9. this.maps = maps;
  10. this.properties = properties;
  11. }
  12. }
  1. <bean id="stu1" class="com.qfedu.ioc.bean.Student">
  2. <constructor-arg index="0">
  3. <list>
  4. <value>11</value>
  5. <value>22</value>
  6. <value>33</value>
  7. </list>
  8. </constructor-arg>
  9. <constructor-arg index="1">
  10. <set>
  11. <value>aa</value>
  12. <value>bb</value>
  13. <value>cc</value>
  14. </set>
  15. </constructor-arg>
  16. <constructor-arg index="2">
  17. <map>
  18. <entry>
  19. <key><value>key1</value></key>
  20. <value>value1</value>
  21. </entry>
  22. <entry>
  23. <key><value>key2</value></key>
  24. <value>value2</value>
  25. </entry>
  26. </map>
  27. </constructor-arg>
  28. <constructor-arg index="3">
  29. <props>
  30. <prop key="k1">v1</prop>
  31. <prop key="k2">v2</prop>
  32. </props>
  33. </constructor-arg>
  34. </bean>

2.5 Bean的作用域

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

  • scope=”singleton” 表示当前bean是单例模式(默认饿汉模式,Spring容器初始化阶段就会完成此对象的创建;当在bean标签中设置 lazy-init=”true”变为懒汉模式)
  • scope=”prototype” 表示当前bean为非单例模式,每次通过Spring容器获取此bean的对象时都会创建一个新的对象
  • 单例
  1. <bean id="book" class="com.qfedu.ioc.bean.Book" scope="singleton" lazy-init="true"></bean>
  • 多例
  1. <bean id="book" class="com.qfedu.ioc.bean.Book" scope="prototype"></bean>

2.6 Bean的声明周期方法

在bean标签中通过init-method属性指定当前bean的初始化方法,初始化方法在构造器执行之后执行,通过destroy-method属性指定当前bean的销毁方法,销毁方法在对象销毁之前执行—>

  • Bean类

    1. public class Book {
    2. private int bookId;
    3. private String bookName;
    4. //初始化方法:在创建当前类对象时调用的方法,进行一些资源准备工作
    5. public void init(){
    6. System.out.println("-------init");
    7. }
    8. //销毁方法:在Spring容器销毁对象时调用此方法,进行一些资源回收性的操作
    9. public void destory(){
    10. System.out.println("-------destory");
    11. }
    12. }
  • Spring配置文件

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

2.7 自动装配

自动装配:Spring在实例化当前bean的时候从Spring容器中找到匹配的实例赋值给当前bean的属性

自动装配策略有两种:

  • byName 根据当前Bean的属性名在Spring容器中寻找匹配的对象 ,如果根据name找到了bean但是类型不匹配则抛出异常
  • byType 根据当前Bean的属性类型在Spring容器中寻找匹配的对象,如果根据类型找到了多个bean也会抛出异常
  • byName
  1. <bean id="clazz" class="com.qfedu.ioc.bean.Clazz"></bean>
  2. <bean id="stu2" class="com.qfedu.ioc.bean.Student" autowire="byName"></bean>
  • byType
  1. <bean id="clazz2" class="com.qfedu.ioc.bean.Clazz"></bean>
  2. <bean id="stu2" class="com.qfedu.ioc.bean.Student" autowire="byType"></bean>

2.8 SpringIoC 工作原理

image.png

三、Spring IoC — 基于注解

SpringIoc的使用,需要我们通过XML将类声明给Spring容器进行管理,从而通过Spring工厂完成对象的创建及属性值的注入;

Spring除了提供基于XML的配置方式,同时提供了基于注解的配置:直接在实体类中添加注解声明给Spring容器管理,以简化开发步骤。

3.1 Spring框架部署

3.1.1 创建Maven项目

3.2.2 添加SpringIoC依赖
  1. <dependency>
  2. <groupId>org.springframework</groupId>
  3. <artifactId>spring-context</artifactId>
  4. <version>5.2.13.RELEASE</version>
  5. </dependency>

3.2.3 创建Spring配置文件
  • 因为Spring容器初始化时,只会加载applicationContext.xml文件,那么我们在实体类中添加的注解就不会被Spring扫描,所以我们需要在applicationContext.xml声明Spring的扫描范围,以达到Spring初始化时扫描带有注解的实体类并完成初始化工作
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans
  6. http://www.springframework.org/schema/beans/spring-beans.xsd
  7. http://www.springframework.org/schema/context
  8. http://www.springframework.org/schema/context/spring-context.xsd">
  9. <!-- 声明使用注解配置 -->
  10. <context:annotation-config/>
  11. <!-- 声明Spring工厂注解的扫描范围 -->
  12. <context:component-scan base-package="com.qfedu.beans"/>
  13. </beans>

3.2 IoC常用注解

3.2.1 @Component
  • 类注解,声明此类被Spring容器进行管理,相当于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 除了控制器、servcie和DAO之外的类一律使用此注解声明

3.2.2 @Scope
  • 类注解,用于声明当前类单例模式还是非单例模式,相当于bean标签的scope属性
  • @Scope(“prototype”) 表示声明当前类为非单例模式(默认单例模式)

3.2.3 @Lazy
  • 类注解,用于声明一个单例模式的Bean是否为懒汉模式
  • @Lazy(true) 表示声明为懒汉模式,默认为饿汉模式

3.2.4 @PostConstruct
  • 方法注解,声明一个方法为当前类的初始化方法(在构造器之后执行),相当于bean标签的init-method属性

3.2.5 @PreDestroy
  • 方法注解,声明一个方法为当前类的销毁方法(在对象从容器中释放之前执行),相当于bean标签的destory-method属性

3.2.6 @Autowired
  • 属性注解、方法注解(set方法),声明当前属性自动装配,默认byType
  • @Autowired(required = false) 通过requried属性设置当前自动装配是否为必须(默认必须——如果没有找到类型与属性类型匹配的bean则抛出异常)
  • byType
  • ref引用
  • **@Qualifier**指定名字去找引用,因此byName在这没有意义
  1. @Autowired
  2. public void setClazz(@Qualifier("c2") Clazz clazz) {
  3. this.clazz = clazz;
  4. }

3.2.7 @Resource
  • 属性注解,也用于声明属性自动装配
  • 默认装配方式为byName,如果根据byName没有找到对应的bean,则继续根据byType寻找对应的bean,根据byType如果依然没有找到Bean或者找到不止一个类型匹配的bean,则抛出异常。

四、代理设计模式

4.1 生活中的代理

image.png

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

4.2 静态代理

静态代理,代理类只能够为特定的类生产代理对象,不能代理任意类

image.png

使用代理的好处

1.被代理类中只用关注核心业务的实现,将通用的管理型逻辑(事务管理、日志管理)和业务逻辑分离

2.将通用的代码放在代理类中实现,提供了代码的复用性

3.通过在代理类添加业务逻辑,实现对原有业务逻辑的扩展(增强)

4.3 动态代理

动态代理,几乎可以为所有的类产生代理对象

动态代理的实现方式有2种:

  • JDK动态代理
  • CGLib动态代理

4.3.1 JDK动态代理
  • JDK动态代理类实现:
  1. /***
  2. * JDK动态代理:是通过被代理对象实现的接口产生其代理对象的
  3. * 1.创建一个类,实现InvocationHandler接口,重写invoke方法
  4. * 2.在类种定义一个Object类型的变量,并提供这个变量的有参构造器,用于将被代理对象传递进来
  5. * 3.定义getProxy方法,用于创建并返回代理对象
  6. */
  7. public class JDKDynamicProxy implements InvocationHandler {
  8. //被代理对象
  9. private Object obj;
  10. public JDKDynamicProxy(Object obj) {
  11. this.obj = obj;
  12. }
  13. //产生代理对象,返回代理对象
  14. public Object getProxy(){
  15. //1.获取被代理对象的类加载器
  16. ClassLoader classLoader = obj.getClass().getClassLoader();
  17. //2.获取被代理对象的类实现的接口
  18. Class<?>[] interfaces = obj.getClass().getInterfaces();
  19. //3.产生代理对象(通过被代理对象的类加载器及实现的接口)
  20. //第一个参数:被代理对象的类加载器
  21. //第二个参数:被代理对象实现的接口
  22. //第三个参数:使用产生代理对象调用方法时,用于拦截方法执行的处理器
  23. Object proxy = Proxy.newProxyInstance(classLoader, interfaces,this);
  24. return proxy;
  25. }
  26. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  27. begin();
  28. Object returnValue = method.invoke(obj,args); //执行method方法(insert)
  29. commit();
  30. return returnValue;
  31. }
  32. public void begin(){
  33. System.out.println("----------开启事务");
  34. }
  35. public void commit(){
  36. System.out.println("----------提交事务");
  37. }
  38. }
  • 测试
  1. //创建被代理对象
  2. BookDAOImpl bookDAO = new BookDAOImpl();
  3. StudentDAOImpl studentDAO = new StudentDAOImpl();
  4. //创建动态代理类对象,并将被代理对象传递到代理类中赋值给obj
  5. JDKDynamicProxy jdkDynamicProxy = new JDKDynamicProxy(studentDAO);
  6. //proxy就是产生的代理对象:产生的代理对象可以强转成被代理对象实现的接口类型
  7. GenaralDAO proxy = (GenaralDAO)jdkDynamicProxy.getProxy();
  8. //使用代理对象调用方法,并不会执行调用的方法,而是进入到创建代理对象时指定的InvocationHandler类种的invoke方法
  9. //调用的方法作为一个Method参数,传递给了invoke方法
  10. proxy.insert(student);

4.3.2 CGLib动态代理

由于JDK动态代理是通过被代理类实现的接口来创建代理对象的,因此JDK动态代理只能代理实现了接口的类的对象。如果一个类没有实现任何接口,该如何产生代理对象呢?

CGLib动态代理,是通过创建被代理类的子类来创建代理对象的,因此即使没有实现任何接口的类也可以通过CGLib产生代理对象

CGLib动态代理不能为final类创建代理对象

  • 添加CGLib的依赖
  1. <!-- https://mvnrepository.com/artifact/cglib/cglib -->
  2. <dependency>
  3. <groupId>cglib</groupId>
  4. <artifactId>cglib</artifactId>
  5. <version>3.3.0</version>
  6. </dependency>
  • CGLib动态代理实现:
  1. /**
  2. * 1.添加cglib依赖
  3. * 2.创建一个类,实现MethodInterceptor接口,同时实现接口中的intercept方法
  4. * 3.在类中定义一个Object类型的变量,并提供这个变量的有参构造器,用于传递被代理对象
  5. * 4.定义getProxy方法创建并返回代理对象(代理对象是通过创建被代理类的子类来创建的)
  6. */
  7. public class CGLibDynamicProxy implements MethodInterceptor {
  8. private Object obj;
  9. public CGLibDynamicProxy(Object obj) {
  10. this.obj = obj;
  11. }
  12. public Object getProxy(){
  13. Enhancer enhancer = new Enhancer();
  14. enhancer.setSuperclass(obj.getClass());
  15. enhancer.setCallback(this);
  16. Object proxy = enhancer.create();
  17. return proxy;
  18. }
  19. public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  20. begin();
  21. Object returnValue = method.invoke(obj,objects); //通过反射调用被代理类的方法
  22. commit();
  23. return returnValue;
  24. }
  25. public void begin(){
  26. System.out.println("----------开启事务");
  27. }
  28. public void commit(){
  29. System.out.println("----------提交事务");
  30. }
  31. }
  • 测试
  1. //创建被代理对象
  2. BookDAOImpl bookDAO = new BookDAOImpl();
  3. StudentDAOImpl studentDAO = new StudentDAOImpl();
  4. //通过cglib动态代理类创建代理对象
  5. CGLibDynamicProxy cgLibDynamicProxy = new CGLibDynamicProxy(bookDAO);
  6. //代理对象实际上是被代理对象子类,因此代理对象可直接强转为被代理类类型
  7. BookDAOImpl proxy = (BookDAOImpl) cgLibDynamicProxy.getProxy();
  8. //使用对象调用方法,实际上并没有执行这个方法,而是执行了代理类中的intercept方法,将当前调用的方法以及方法中的参数传递到intercept方法
  9. proxy.update();

五、Spring AOP

5.1 AOP 概念

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

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

image.png

5.2 Spring AOP框架部署

5.2.1 创建Maven项目

5.2.2 添加依赖
  • context
  • aspects
  1. <dependency>
  2. <groupId>org.springframework</groupId>
  3. <artifactId>spring-context</artifactId>
  4. <version>5.2.13.RELEASE</version>
  5. </dependency>
  6. <dependency>
  7. <groupId>org.springframework</groupId>
  8. <artifactId>spring-aspects</artifactId>
  9. <version>5.2.13.RELEASE</version>
  10. </dependency>

5.2.3 创建spring配置文件
  • 需要引入aop的命名空间
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:aop="http://www.springframework.org/schema/aop"
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans
  6. http://www.springframework.org/schema/beans/spring-beans.xsd
  7. http://www.springframework.org/schema/aop
  8. http://www.springframework.org/schema/aop/spring-aop.xsd">
  9. </beans>

5.3 AOP配置—基于XML

在DAO的方法添加开启事务和提交事务的逻辑

5.3.1 创建一个类,定义要添加的业务逻辑
  1. public class TxManager {
  2. public void begin(){
  3. System.out.println("-----------开启事务");
  4. }
  5. public void commit(){
  6. System.out.println("-----------提交事务");
  7. }
  8. }

5.3.2 配置aop
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:aop="http://www.springframework.org/schema/aop"
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans
  6. http://www.springframework.org/schema/beans/spring-beans.xsd
  7. http://www.springframework.org/schema/aop
  8. http://www.springframework.org/schema/aop/spring-aop.xsd">
  9. <bean id="bookDAO" class="com.qfedu.dao.BookDAOImpl"></bean>
  10. <bean id="studentDAO" class="com.qfedu.dao.StudentDAOImpl"></bean>
  11. <!---->
  12. <bean id="txManager" class="com.qfedu.utils.TxManager"></bean>
  13. <aop:config>
  14. <!--声明切入点-->
  15. <!-- <aop:pointcut id="book_update" expression="execution(* com.qfedu.dao.BookDAOImpl,update())" -->
  16. <aop:pointcut id="book_all" expression="execution(* com.qfedu.dao.*.*(..))"/>
  17. <!--声明txManager为切面类-->
  18. <aop:aspect ref="txManager">
  19. <!--通知-->
  20. <aop:before method="begin" pointcut-ref="book_all"/>
  21. <aop:after method="commit" pointcut-ref="book_all"/>
  22. </aop:aspect>
  23. </aop:config>
  24. </beans>

AOP开发步骤

1.创建切面类,在切面类定义切点方法

2.将切面类配置给Spring容器

3.声明切入点

4.配置AOP的通知策略

5.4 切入点的声明

5.4.1 各种切入点声明方式
  1. <!--使用aop:pointcut标签声明切入点:切入点可以是一个方法-->
  2. <aop:pointcut id="book_insert" expression="execution(* com.qfedu.dao.BookDAOImpl.insert())"/>
  3. <!--BookDAOImpl类中所有无参数无返回值的方法-->
  4. <aop:pointcut id="book_pc1" expression="execution(void com.qfedu.dao.BookDAOImpl.*())"/>
  5. <!--BookDAOImpl类中所有无返回值的方法-->
  6. <aop:pointcut id="book_pc2" expression="execution(void com.qfedu.dao.BookDAOImpl.*(..))"/>
  7. <!--BookDAOImpl类中所有无参数的方法-->
  8. <aop:pointcut id="book_pc3" expression="execution(* com.qfedu.dao.BookDAOImpl.*())"/>
  9. <!--BookDAOImpl类中所有方法-->
  10. <aop:pointcut id="book_pc4" expression="execution(* com.qfedu.dao.BookDAOImpl.*(..))"/>
  11. <!--dao包中所有类中的所有方法-->
  12. <aop:pointcut id="pc5" expression="execution(* com.qfedu.dao.*.*(..))"/>
  13. <!--dao包中所有类中的insert方法-->
  14. <aop:pointcut id="pc6" expression="execution(* com.qfedu.dao.*.insert(..))"/>
  15. <!--dao包中所有类中的insert方法-->
  16. <aop:pointcut id="pc7" expression="execution(* *(..))"/>

5.4.2 AOP使用注意事项
  1. //如果要使用Spring aop面向切面编程,调用切入点方法的对象必须通过Spring容器获取
  2. //如果一个类中的方法被声明为切入点并且织入了切点之后,通过Spring容器获取该类对象,实则获取到的是一个代理对象
  3. //如果一个类中的方法没有被声明为切入点,通过Spring容器获取的就是这个类真实创建的对象
  4. //BookServiceImpl bookService = new BookServiceImpl();
  5. BookServiceImpl bookService = (BookServiceImpl) context.getBean("bookServiceImpl");
  6. bookService.addBook();

5.5 AOP通知策略

AOP通知策略:就是声明将切面类中的切点方法如何织入到切入点

  • before
  • after
  • after-throwing
  • after-returning
  • around

5.5.1 定义切面类
  1. public class MyAspect {
  2. public void method1(){
  3. System.out.println("~~~~~~~method1");
  4. }
  5. public void method2(){
  6. System.out.println("~~~~~~~method2");
  7. }
  8. public void method3(){
  9. System.out.println("~~~~~~~method3");
  10. }
  11. public void method4(){
  12. System.out.println("~~~~~~~method4");
  13. }
  14. //环绕通知的切点方法,必须准守如下的定义规则:
  15. //1.必须带有一个ProceedingJoinPoint类型的参数
  16. //2.必须有Object类型的返回值
  17. //3.在前后增强的业务逻辑之间执行Object v = point.proceed();
  18. //4.方法最后返回v
  19. public Object method5(ProceedingJoinPoint point) throws Throwable {
  20. System.out.println("~~~~~~~method5---before");
  21. //此代码的执行,就表示切入点方法的执行
  22. Object v = point.proceed();
  23. System.out.println("~~~~~~~method5---after");
  24. return v;
  25. }
  26. }

5.5.2 配置切面类
  1. <bean id="myAspect" class="com.qfedu.utils.MyAspect"></bean>
  2. <aop:config>
  3. <!--使用aop:pointcut标签声明切入点:切入点可以是一个方法-->
  4. <aop:pointcut id="book_insert" expression="execution(* com.qfedu.dao.BookDAOImpl.insert())"/>
  5. <aop:aspect ref="myAspect">
  6. <!--aop:before 前置通知,切入到指定切入点之前-->
  7. <aop:before method="method1" pointcut-ref="book_insert"/>
  8. <!--aop:after 后置通知,切入到指定切入点之后-->
  9. <aop:after method="method2" pointcut-ref="book_insert"/>
  10. <!--aop:after-throwing 异常通知,切入点抛出异常之后-->
  11. <aop:after-throwing method="method3" pointcut-ref="book_insert"/>
  12. <!--aop:after-returning 方法返回值返回之后,对于一个Java方法而言return返回值也是方法的一部分
  13. 因此“方法返回值返回之后”和“方法执行结束”是同一个时间点,随意after 和 after-returning根据配置
  14. 的顺序决定执行顺序-->
  15. <aop:after-returning method="method4" pointcut-ref="book_insert"/>
  16. <aop:around method="method5" pointcut-ref="book_insert"/>
  17. </aop:aspect>
  18. </aop:config>

六、Spring AOP 注解配置

6.1 Spring AOP 注解配置框架部署

6.1.1 创建Maven工程

6.1.2 添加Spring依赖
  • context
  • aspects

6.1.3 Spring配置文件
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:aop="http://www.springframework.org/schema/aop"
  6. xsi:schemaLocation="http://www.springframework.org/schema/beans
  7. http://www.springframework.org/schema/beans/spring-beans.xsd
  8. http://www.springframework.org/schema/context
  9. http://www.springframework.org/schema/context/spring-context.xsd
  10. http://www.springframework.org/schema/aop
  11. http://www.springframework.org/schema/aop/spring-aop.xsd">
  12. <context:annotation-config></context:annotation-config>
  13. <context:component-scan base-package="com.qfedu"></context:component-scan>
  14. <!-- 基于注解配置的aop代理 -->
  15. <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  16. </beans>

6.2 AOP注解配置案例

  1. @Component
  2. @Aspect
  3. public class TransactionManager {
  4. @Pointcut("execution(* com.qfedu.dao.*.*(..))")
  5. public void pc1(){}
  6. @Before("pc1()")
  7. public void begin(){
  8. System.out.println("~~~~开启事务");
  9. }
  10. @After("pc1()")
  11. public void commit(){
  12. System.out.println("~~~~提交事务");
  13. }
  14. @Around("pc1()")
  15. public Object printExecuteTime(ProceedingJoinPoint point) throws Throwable {
  16. long time1 = System.currentTimeMillis();
  17. Object v = point.proceed();
  18. long time2 = System.currentTimeMillis();
  19. System.out.println("----time:"+(time2-time1));
  20. return v;
  21. }
  22. }

**注意**:注解使用虽然方便,但是只能在源码上添加注解,因此我们的自定义类提倡使用注解配置;但如果如果使用到第三方提供的类则需要通过xml配置形式完成配置。

七、Spring整合MyBatis

Spring两大核心思想:IoC 和 AOP

IoC : 控制反转,Spring容器可以完成对象的创建、属性注入、对象管理等工作

AOP : 面向切面,在不修改原有业务逻辑的情况下,实现原有业务的增强

7.1 Spring可以对MyBatis提供哪些支持?

  • IoC支持 SpringIoC 可以为MyBatis完成DataSource、SqlSessionFactory、SqlSession以及DAO对象的创建
  • AOP支持使用Spring提供的事务管理切面类完成对MyBatis数据库操作中的事务管理

7.2 Spring整合MyBatis准备工作

7.2.1 创建Maven工程

7.2.2 部署MyBatis框架
  • 添加依赖
    • Mysql驱动
    • mybatis
  1. <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
  2. <dependency>
  3. <groupId>mysql</groupId>
  4. <artifactId>mysql-connector-java</artifactId>
  5. <version>5.1.47</version>
  6. </dependency>
  7. <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
  8. <dependency>
  9. <groupId>org.mybatis</groupId>
  10. <artifactId>mybatis</artifactId>
  11. <version>3.4.6</version>
  12. </dependency>
  • 创建MyBatis配置文件(创建配置文件之后无需进行任何配置)mybatis-config.xml
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  3. "http://mybatis.org/dtd/mybatis-3-config.dtd">
  4. <configuration>
  5. </configuration>

7.2.3 部署Spring框架
  • 添加依赖
  1. <dependency>
  2. <groupId>org.springframework</groupId>
  3. <artifactId>spring-context</artifactId>
  4. <version>5.2.13.RELEASE</version>
  5. </dependency>
  6. <dependency>
  7. <groupId>org.springframework</groupId>
  8. <artifactId>spring-aspects</artifactId>
  9. <version>5.2.13.RELEASE</version>
  10. </dependency>
  11. <dependency>
  12. <groupId>org.springframework</groupId>
  13. <artifactId>spring-jdbc</artifactId>
  14. <version>5.2.13.RELEASE</version>
  15. </dependency>
  • 创建Spring配置文件:applicationContext.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:aop="http://www.springframework.org/schema/aop"
  6. xsi:schemaLocation="http://www.springframework.org/schema/beans
  7. http://www.springframework.org/schema/beans/spring-beans.xsd
  8. http://www.springframework.org/schema/context
  9. http://www.springframework.org/schema/context/spring-context.xsd
  10. http://www.springframework.org/schema/aop
  11. http://www.springframework.org/schema/aop/spring-aop.xsd">
  12. </beans>

7.2.4 添加Spring整合MyBatis的依赖
  • mybatis-spring 就是mybatis提供的兼容Spring的补丁
  1. <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
  2. <dependency>
  3. <groupId>org.mybatis</groupId>
  4. <artifactId>mybatis-spring</artifactId>
  5. <version>1.3.2</version>
  6. </dependency>

7.3 Spring整合MyBatis整合IoC配置

7.3.1 整合Druid连接池
  • 添加druid的依赖
  1. <dependency>
  2. <groupId>com.alibaba</groupId>
  3. <artifactId>druid</artifactId>
  4. <version>1.1.10</version>
  5. </dependency>
  • 创建druid.properties属性文件
  1. druid.driver=com.mysql.jdbc.Driver
  2. druid.url=jdbc:mysql://localhost:3306/db_2010_mybatis?characterEncoding=utf-8&useSSL=false
  3. druid.username=root
  4. druid.password=admin123
  5. ## 连接池参数
  6. druid.pool.init=1
  7. druid.pool.minIdle=3
  8. druid.pool.maxActive=20
  9. druid.pool.timeout=30000

init:初始化连接数

minIdle:高峰期过后,不要的连接一定会被销毁,但会保留最小数目的连接

maxActive:最大连接数,若所需更多,需等待释放

timeout:超时时间

  • 在applicationContext.xml中配置DruidDataSource
  1. <!--加载druid.properties属性文件-->
  2. <context:property-placeholder location="classpath:druid.properties"/>
  3. <!--依赖Spring容器完成数据源DataSource的创建-->
  4. <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
  5. <property name="driverClassName" value="${druid.driver}"/>
  6. <property name="url" value="${druid.url}"/>
  7. <property name="username" value="${druid.username}"/>
  8. <property name="password" value="${druid.password}"/>
  9. <property name="initialSize" value="${druid.pool.init}"/>
  10. <property name="minIdle" value="${druid.pool.minIdle}"/>
  11. <property name="maxActive" value="${druid.pool.maxActive}"/>
  12. <property name="maxWait" value="${druid.pool.timeout}"/>
  13. </bean>

7.3.2 整合MyBatis—创建SqlSessionFactory

依赖Spring容器创建MyBatis的SqlSessionFactory对象

  1. <!--依赖Spring容器完成MyBatis的SqlSessionFactory对象的创建-->
  2. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" >
  3. <!--配置数据源-->
  4. <property name="dataSource" ref="druidDataSource"/>
  5. <!--配置mapper映射文件的路径-->
  6. <property name="mapperLocations" value="classpath:mappers/*Mapper.xml"/>
  7. <!--配置需要定义别名的实体类的包-->
  8. <property name="typeAliasesPackage" value="com.qfedu.pojo"/>
  9. <!--可选:配置MyBatis的主配置文件-->
  10. <property name="configLocation" value="classpath:mybatis-config.xml"/>
  11. </bean>

7.3.3 整合MyBatis-创建Mapper
  1. <!--加载dao包中的所有DAO接口,通过sqlSessionFactory获取SqlSession,然后创建所有的DAO接口对象,存储在Spring容器-->
  2. <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  3. <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
  4. <property name="basePackage" value="com.qfedu.dao"/>
  5. </bean>

7.4 Spring整合MyBatis整合AOP配置

使用Spring提供的事务管理切面类 完成DAO中增删改操作的事务管理

7.4.1 事务的隔离级别

隔离级别从最宽松到最严格

isolation 设置事务隔离级别:READ_UNCOMMITTED ,READ_COMMITTED , REPEATABLE_READ , SERIALIZABLE

image.png

7.4.2 事务的传播机制

propagation 设置事务的传播机制

  • REQUIRED 如果上层方法没有事务,则创建一个新的事务;如果已经存在事务,则加入到事务中。
  • SUPPORTS 如果上层方法没有事务,则以非事务方式执行;如果已经存在事务,则加入到事务中。
  • REQUIRES_NEW 如果上层方法没有事务,则创建一个新的事务;如果已经存在事务,则将当前事务挂起。 (不要放在事物中执行)
  • NOT_SUPPORTED 如果上层方法没有事务,则以非事务方式执行;如果已经存在事务,则将当前事务挂起。 (不要放在事物中执行)
  • NEVER 如果上层方法没有事务,则以非事务方式执行;如果已经存在事务,则抛出异常。
  • MANDATORY 如果上层方法已经存在事务,则加入到事务中执行;如果不存在事务则抛出异常。 (必须在事物中执行)
  • NESTED 如果上层方法没有事务,则创建一个新的事务;如果已经存在事务,则嵌套到当前事务中。

7.4.3 Spring AOP事务管理配置—XML配置
  1. <!--1.将Spring提供的事务管理配置配置给Spring容器-->
  2. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  3. <property name="dataSource" ref="druidDataSource"/>
  4. </bean>
  5. <!--2.通过Spring jdbc提供的 tx标签,声明事务管理策略-->
  6. <tx:advice id="txAdvice" transaction-manager="transactionManager">
  7. <tx:attributes>
  8. <tx:method name="insert*" isolation="REPEATABLE_READ" propagation="REQUIRED"/>
  9. <tx:method name="delete*" isolation="REPEATABLE_READ" propagation="REQUIRED"/>
  10. <tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED"/>
  11. <tx:method name="query*" isolation="REPEATABLE_READ" propagation="SUPPORTS"/>
  12. </tx:attributes>
  13. </tx:advice>
  14. <!--3.将事务管理策略以AOP配置 应用于DAO操作方法-->
  15. <aop:config>
  16. <aop:pointcut id="crud" expression="execution(* com.qfedu.service.*.*(..))"/>
  17. <aop:advisor advice-ref="txAdvice" pointcut-ref="crud"/>
  18. </aop:config>

7.4.4 Spring AOP事务管理配置—注解配置
  • 在applicationContext.xml中配置事务管理,声明使用注解方式进行事务配置
  1. <!--使用注解进行事务管理前提是 IoC需要进行注解配置-->
  2. <context:annotation-config/>
  3. <context:component-scan base-package="com.qfedu"/>
  4. <!--1.将Spring提供的事务管理配置配置给Spring容器-->
  5. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  6. <property name="dataSource" ref="druidDataSource"/>
  7. </bean>
  8. <!--2.声明使用注解完成事务配置-->
  9. <tx:annotation-driven transaction-manager="transactionManager"/>
  • 在需要Spring进行事务管理的方法上添加@Transactional注解
  1. @Transactional(isolation = Isolation.REPEATABLE_READ ,propagation = Propagation.SUPPORTS )
  2. public List<User> listUsers() {
  3. return userDAO.queryUsers();
  4. }

八、基于Spring的单元测试

如果想要使用Spring容器实现属性注入、实现AOP面向切面编程,对象必须通过Spring容器获取;为了便于Spring环境下的测试,Spring提供了test组件,专门针对Spring环境进行单元测试。

8.1 添加依赖

  1. <dependency>
  2. <groupId>junit</groupId>
  3. <artifactId>junit</artifactId>
  4. <version>4.12</version>
  5. <scope>test</scope>
  6. </dependency>
  7. <dependency>
  8. <groupId>org.springframework</groupId>
  9. <artifactId>spring-test</artifactId>
  10. <version>5.2.13.RELEASE</version>
  11. </dependency>

8.2 编写单元测试类

8.2.1 创建一个单元测试类

8.2.2 添加注解
  1. //1.通过@RunWith 声明当前测试类位于Spring容器环境(被Spring容器管理)
  2. @RunWith(SpringJUnit4ClassRunner.class)
  3. //2.通过@ContextConfiguration 声明当前测试环境的Spring容器运行时加载的配置文件
  4. @ContextConfiguration("classpath:applicationContext.xml")
  5. public class UserServiceImplTest {
  6. //因为当前测试类是基于Spring容器运行的,当前测试类的对象是通过Spring容器创建的
  7. //因此可以通过Spring容器实现属性的注入
  8. @Resource
  9. private UserService userServiceImpl2;
  10. @Resource
  11. private UserService userServiceImpl;
  12. @Test
  13. public void test(){
  14. List<User> users = userServiceImpl.listUsers();
  15. System.out.println(users);
  16. }
  17. }