【JavaLearn】#（30）框架引入、Spring框架、Spring IOC的基本使用、常用注解(IoC)、Spring整合Mybatis、Spring AOP内容、代理设计模式、SpringTX

LRcoding

于 2024-02-20 22:51:32 发布

阅读量776

点赞数 19

分类专栏： JavaLearn 文章标签： spring mybatis 设计模式

本文链接：https://blog.csdn.net/qq_38134242/article/details/136200342

版权

JavaLearn 专栏收录该内容

30 篇文章 3 订阅

订阅专栏

1.框架引入

之前的学习中，实现一个功能的大致流程是：

创建一个 web项目
创建数据库
使用 jsp技术完成页面的创建
使用 Servlet + MVC + Mybatis 完成功能开发

问题：在基于 MVC的整个代码流程中，如果某个功能实现需要10个步骤，会发现其中至少有一半以上的步骤都是重复的。（例如：查询所有学生信息、查询所有班级信息，这两个代码除了sql语句及结果遍历处理的方式不同外，其余全部相同）

解决：不同的功能重复的代码不再重复声明，只声明与功能相关的代码即可。（封装）

实现方案：

不同的方法中出现了重复代码 --> 封装为工具方法，然后进行调用，并增加自己业务需要的代码
不同的类中出现了重复代码 --> 封装为工具类
不同的项目出现了重复代码 --> 封装为 jar包
- jar包本质：代码的 class文件的压缩包（JDK可以直接进行调用，无需解压）
- jar包的使用：将 jar包放到项目中，然后 add as library；或使用 Maven来统一管理
- jar包的特点：项目引入新功能的同时，保证了原有代码的结构层次

2.框架的概念和使用

框架其实就是不同的项目都会使用到的代码的封装（软件的半成品）

框架本质就是别人封装好的功能代码，以一堆 jar包的形式让我们调用（业务代码由我们自己编写）

框架的一般使用步骤：

将 jar包导入到自己的项目中
查阅 API文档，调用相关方法完成功能开发
配置框架的配置文件（框架代码运行需要的常量数据）

3.Spring框架简介

概念：是一个控制反转（IoC）和面向切面（AOP）的轻量级框架，适用于任何 Java程序。

作用：

简化企业项目的开发流程，提升开发效率
便于代码的后续维护升级
降低代码间耦合性

重点内容：IoC（控制反转）、AOP（面向切面）、TX（事务管理）

Spring框架结构（内部集成了很多功能，可以根据需求选择对应的子框架使用）：

4.Spring IoC

4.1 引入

问题：MVC的结构体系，在一定程度上降低了代码的冗余，但层与层之间的耦合性过高（在controller(servlet)层直接使用new创建了service层对象，修改时需要改多个地方），造成代码维护升级麻烦。

解决：由直接调用改为间接，使用 Spring IoC，将层与层对象之间的关系进行解耦

4.2 原理

将对象的创建交给 Spring容器对象去做，我们不再通过 new的方式去获取对象，而是直接从 Spring容器对象内拿；

运营管理科技创新孵化平台

4.3 基本使用示例

作用：将耦合性非常高的对象进行解耦

使用时机：若不考虑业务特殊要求，一般用于 servlet（controller层）与 service之间解耦，Service与 mapper之间解耦。

使用流程：

创建 Maven项目（在前后端未分离时，一般创建 war类型项目）

引入 IoC相关的 jar包

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.1.3</version>
</dependency>

<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>

可以通过 "Show Diagram"按钮查看相关依赖关系：

在 resources下创建并配置 applicationcontext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 配置要让 Spring容器对象通过 反射 创建的对象的全限定类名 -->
    <bean id="us" class="com.lwclick.service.impl.UserServiceImpl" />

</beans>

在需要创建对象的位置，获取 Spring的容器对象，并从中获取对应的业务层对象

// 创建 Spring的容器对象
// ============= 在创建 Spring容器对象时，applicationcontext.xml中配置的所有 bean都会被创建
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationcontext.xml");

// 通过容器对象，根据id，获取业务层对象
UserService us = ac.getBean("us", UserService.class);

4.4 Spring IoC创建对象的三种方式

问题：上述方式让 Spring容器对象替我们创建对象时，无法创建带有指定的初始化数据的对象（实体类对象）。

解决：可通过构造器方式、**属性注入(get/set)**方式、工厂模式 3种方式创建带有初始化数据的实体类对象

4.4.1 通过构造器方式

其他步骤与上述 4.3的操作一致，区别在于 applicationcontext.xml文件中的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 构造器方式
        ==== 无参构造器
            特点：Spring容器创建对象的默认方式
            使用：在配置文件中直接使用 bean标签配置即可 -->
    <bean id="us" class="com.lwclick.entity.User" />


    <!-- 构造器方式
        ==== 有参数的构造器    （在类中必须提前声明对应的构造器！！！）
            特点：根据配置，调用相应的有参构造器，创建带有初始化数据的对象
            使用：constructor-arg子标签   一个子标签代表一个参数
                属性： index：有参构造器中，参数的下标（即第几个）
                       type：参数的类型，全限定类名
                       name：参数的形参名
                       value：要初始化的值 -->
    <bean id="us2" class="com.lwclick.entity.User">
        <constructor-arg index="0" type="java.lang.Integer" name="uid" value="123" />
        <constructor-arg index="1" type="java.lang.String" name="uName" value="zhangsan" />
    </bean>
</beans>

4.4.2 属性注入(get/set)方式

先通过空构造器创建一个对象，然后再使用 set方法进行初始化赋值。（必须先声明属性的 set方法！！！）

<!-- 属性注入方式
        ==== 通过 set方法 （必须先声明属性的 set方法！）
            特点：相当于创建一个空对象，然后使用 set方法赋值
            使用：property 子标签
                属性： name：要赋值的属性名
                      value：赋的值-->
<bean id="us3" class="com.lwclick.entity.User">
    <property name="uid" value="456" />
    <property name="uName" value="lisi" />
</bean>

4.4.3 工厂模式

例如，有个业务需要创建 A对象，但是 A对象的创建依赖于 B对象，而 B对象的创建又依赖于 C对象。

则相关代码为：C c = new C(); B b = new B©; A a = new A(b); —> 代码的阅读性极差

解决：将对象的创建过程进行封装，直接返回创建好的对象 —> 工厂设计模式。

静态工厂：生产对象的方法是静态方法（用 static修饰方法，直接使用类名.方法名调用）

动态工厂：生产对象的方法是非静态方法（不用 static修饰，使用时需要 new创建对象，再用对象.方法名调用）

IoC方案：Spring容器创建工厂，并自动调用对应的工厂方法，生产对象，存储到容器中，供我们获取。

public class UserFactory {
    public User newInstance() {
        System.out.println("动态工厂方法");
        // ......其他逻辑代码
        return new User();
    }

    public static User newStaticInstance() {
        System.out.println("静态工厂方法");
        // ......其他逻辑代码
        return new User();
    }
}

applicationcontext.xml文件：

<!-- 工厂模式
        ==== 动态工厂  （需要先自己创建工厂类！！）
            特点：创建对象的类型，是否带有初始化数据等，都在工厂内的方法中编写逻辑
            使用：先创建工厂bean，然后配置对象bean 标签的 factory-bean和 factory-method属性 -->
<!-- 先声明工厂 bean -->
<bean id="usFactory" class="com.lwclick.entity.UserFactory" />
<!-- 让工厂去生产对象 -->
<bean id="us4" factory-bean="usFactory" factory-method="newInstance" />


<!-- 工厂模式
        ==== 静态工厂  （需要先自己创建工厂类！！）
            特点：在工厂内编写静态方法（static修饰）
            使用：无需再创建工厂bean，相当于直接类名调用 -->
<bean id="us5" class="com.lwclick.entity.UserFactory" factory-method="newStaticInstance" />

4.5 IoC的依赖注入 DI

不管是属性注入方式还是构造器方式，创建对象时，赋值赋予的都是基本类型的数据，如何解决引用类型的属性赋值问题呢？

解决：使用依赖注入（DI），让 Spring容器根据对象之间的依赖关系（例如 A的创建依赖于 B），将涉及到的对象全都配置为 Bean对象，完成对象的创建及组装过程。

4.5.1 构造器方式

<!-- DI-构造器方式
        ==== 使用 constructor-arg子标签的 ref属性 -->
<bean id="us6" class="com.lwclick.entity.User">
    <constructor-arg index="0" type="java.lang.Integer" name="uid" value="12345" />
    <constructor-arg index="1" type="java.lang.String" name="uName" value="wangwu" />
    <!-- 使用 ref属性，引用 Person对象的bean -->
    <constructor-arg index="2" type="com.lwclick.entity.Person" name="person" ref="personBean" />
</bean>

    <!-- 配置 Person类对象的 bean -->
    <bean id="personBean" class="com.lwclick.entity.Person">
        <!-- Person类中需要自定义相应的构造器 -->
        <constructor-arg index="0" type="java.lang.Integer" name="sex" value="0" />
    </bean>

4.5.2 属性注入方式

<!-- 配置 Person类对象的 bean -->
<bean id="personBean" class="com.lwclick.entity.Person">
    <!-- Person类中需要自定义相应的构造器 -->
    <constructor-arg index="0" type="java.lang.Integer" name="sex" value="0" />
</bean>

<!-- DI-属性注入方式
        ==== 使用 property子标签的 ref属性 -->
<bean id="us7" class="com.lwclick.entity.User">
    <!-- Person类中需要有对应属性的 set方法 -->
    <property name="uid" value="54321" />
    <property name="uName" value="zhaoliu" />
    <property name="person" ref="personBean" />
</bean>

4.6 IoC创建对象的单例、多例模式

从 Spring容器对象中，根据键名获取对象时，同一键名获取的对象都是同一个（Spring IoC创建对象时，默认是单例(singleton)的，在 Spring容器对象被创建的时候，完成初始化创建）

多例模式：在配置 bean时，修改 scope属性为 prototype，代表只有当从 Spring容器中获取对象时才进行创建，每次获取都重新创建。

applicationcontext.xml中

<!-- 修改 bean标签的 scope为 prototype（多例模式） -->
<bean id="personBean" class="com.lwclick.entity.Person" scope="prototype">
    <constructor-arg index="0" type="java.lang.Integer" name="sex" value="0" />
</bean>

代码中获取时

// 多例模式时，并不会在创建 Spring容器对象时，就完成对象的初始化
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
// 而是在真正获取对象时，才进行创建，每次获取，创建的都是新的
Person personBean = ac.getBean("personBean", Person.class);

4.7 IoC的自动注入

通过前面的依赖注入DI，我们可以根据对象之间的依赖关系，让 Spring容器对象帮我们创建一个组装好的对象。但是如果依赖关系特别多，使用 ref注入时会很麻烦。

解决：告诉 Spring容器对象依赖关系的注入规则（配置 bean的 autowire属性），让它自动完成注入。

根据 bean的 id和属性名一致的规则 – byName

<!-- 配置 bean的 autowire属性为 byName（根据 bean的 id与属性名一致的规则） -->
<bean id="us" class="com.lwclick.entity.User" autowire="byName"/>

<!-- Person实体类的 bean的 id，要与 User实体类中的 “属性名” 一致（ private Person person; ） -->
<bean id="person" class="com.lwclick.entity.Person" scope="prototype">
    <constructor-arg index="0" type="java.lang.Integer" name="sex" value="0" />
</bean>

根据 bean的类型和属性的类型一致的规则 – byType

即要注入的 bean（Person）的类型(class属性的值)，与被注入的实体类（User）中的属性的类型一致（注：同类型的 bean只能有一个，否则报错）
根据构造器形参的类型和bean的类型一致的规则 – constructor
不使用自动注入 – no

使用默认规则 – default

可以在 beans上配置属性 default-autowire

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
       
       default-autowire="byName">  <!-- 那么所有的bean都会默认使用 byName的形式进行自动注入 -->
</beans>

4.8 常用注解简介(IoC)

@Component：一般用于普通 Java类
- 相当于配置文件的 bean标签，将某个类的对象放到 Spring容器中
- bean的 id默认为首字母小写的类名，也可用 value属性自己进行设置
```
@Component
public class MyAdvice {}
```
@Service：专门用来表明该类为业务类
- 相当于配置文件的 bean标签，专门在业务类上使用
- bean的 id默认为首字母小写的类名，可自行设置
```
@Service
public class UserServiceImpl implements UserService {}
```
@Controller：专门用来表明该类为控制层类
- 相当于配置文件的 bean标签，在SpringMVC的控制器类上使用
- bean的 id默认为首字母小写的类名，可自行设置
```
@Controller
public class UserController {}
```
@Repository：在数据库功能类上使用
- 相当于配置文件的 bean标签，在数据库功能类（mapper层）使用
@Resource：相当于依赖注入（需要结合@Controller、@Service或者@Component使用）
- 相当于 bean标签下的 property标签
- JDK官方的注解，会先按照 byName的方式注入，如果没有则按照 byType的方式，如果都没有则不注入
- 注入时，属性不需要提供 get/set方法
@Autowired：相当于依赖注入（需要结合@Controller、@Service或者@Component使用）
- Spring提供的注解，默认使用 byType方式
@Value：用来替换配置文件中的属性注入
- 在属性上声明，注入时，属性无需提供 get/set方法
```
@Value("${name}")
private String name;
```

5.Spring整合 Mybatis

使用 Spring IoC技术解决之前项目中存在的高耦合，即实现 service与 mapper层，servlet与 service层解耦。

5.1 基本步骤

在 pom.xml中配置 Spring IoC及 Spring整合Mybatis的依赖

<!-- =============== Spring IoC的依赖 ================ -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.1.3</version>
</dependency>
<dependency>
    <!-- 在 applicationcontext.xml中存储数据源的依赖 -->
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>6.1.3</version>
</dependency>
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>

<!-- =============== Mybatis的依赖 ================ -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.15</version>
</dependency>

<!-- =============== Spring整合 Mybatis的依赖 ================ -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>3.0.3</version>
</dependency>

在 resources文件夹下创建 applicationcontext.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 传统方式写法：
        InputStream is = Resources.getResourceAsStream("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = factory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        -->

    <!-- 创建数据源 bean对象
 			id一般为 dataSource，方便通过 byName方式自动注入，此处为了便于区分，使用自定义名称！ -->
    <bean id="myDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- mysql8.0 的Driver要多加一个 cj -->
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:/localhost:3306/db-demo"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!-- 配置 SqlSession的工厂 bean -->
    <bean id="fact" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 依赖注入，数据源 -->
        <property name="dataSource" ref="myDataSource"/>
        <!-- 设置实体类的路径： 相当于在单独使用 mybatis时，mybatis.xml中的 typeAliases配置项 -->
        <property name="typeAliasesPackage" value="com.lwclick.entity"/>
    </bean>

    <!-- 配置 Mapper扫描信息： 相当于 mybatis.xml中的 mappers标签
           Spring容器对象被创建时，会自动创建所有bean，当创建该bean时，将扫描对应的 mapper层接口生成对应的实例化对象
           然后都放到 Spring容器中，使用时，以mapper层接口名(首字母小写)的形式获取，例如 userMapper-->
    <bean id="mapperScan" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入factory：
			此处使用 sqlSessionFactory，结合ref属性，但是不推荐！！！
			在后面会将数据库的连接参数独立出来，进行解耦，
			【到时会使用 sqlSessionFactoryBeanName，结合 value属性】 -->
        <property name="sqlSessionFactory" ref="fact"/>
        <!-- 配置 mapper扫描路径 -->
        <property name="basePackage" value="com.lwclick.mapper"/>
    </bean>
</beans>

实现 service层与 mapper层的解耦

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = ac.getBean("userMapper", UserMapper.class);
// 使用 userMapper完成其他操作...

至于 servlet层与 service层的解耦实现方式比较简单，只需在 applicationcontext.xml中配置相应 impl类的bean，然后在 servlet层通过 spring容器对象直接获取即可。

<bean id="us" class="com.lwclick.service.impl.UserServiceImpl"/>

5.2 代码优化

在 tomcat创建线程处理请求时，Servlet对象只会被创建一次，会被多个线程共享。

Servlet对象创建时机：默认在第一次请求的时候被创建，往后都不再重新创建（如果配置了 loadOnStartUp，则在服务器启动时就会完成初始化创建）。

因此，servlet层与 service层的解耦，优化时可以通过 Servlet的 init方法进行 spring容器对象的创建，则只会创建一次（如果在 service方法中创建，则会创建多次）

而 service层与 mapper层的解耦，优化时，可以通过依赖注入的方式完成初始化。

<bean id="us" class="com.lwclick.service.impl.UserServiceImpl">
    <!-- 需要在 UserServiceImpl类中，创建 userMapper属性（private UserMapper userMapper），并创建 setter方法-->
    <property name="userMapper" ref="userMapper"/> <!-- ref的值为上面配置的mapper层扫描的bean(mapperScan)，创建完放到spring容器中去的，因此可直接用 -->
</bean>

5.3 进一步优化

目前代码中获取 Spring容器对象，都是通过 ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");实现，如果配置文件名字发生改变，还需要修改源码！

解决：在 web.xml中配置

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <!-- 配置全局参数： 配置 Spring容器配置文件的路径 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationcontext.xml</param-value>
  </context-param>

  <!-- 配置监听器， 需要 pom依赖
          <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>6.1.3</version>
          </dependency>   -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

代码中的修改（此处为使用 Servlet时的解决方案，了解即可）：

ApplicationContext ac = WebApplicationContextUtils.getWebApplicationContext(this.getServeltContext());

6.Spring AOP

需求：在保留原有功能逻辑的基础上，增加新的业务逻辑。（如果有源码，可能阅读之前的逻辑，再对源码进行修改替换；但是如果没有源码，还想增加功能逻辑，怎么处理？）

解决：使用 AOP（面向切面的编程）

6.1 原理图

基本思路：对象A中的 testA()方法是我们最初的内容，现在要对其升级，而且不想改变源码，则声明一个对象 B，在对象 B中重写 testA()方法（由于都实现了接口C，所以需要进行重写），通过在B对象的testA()中，调用 A对象的testA()方法，并在其前后加一些内容（将增加的内容独立出去，即E、F类，减小耦合），完成扩展。

6.2 名词解释

真实对象：要进行功能扩展的对象，相当于原理图中的对象A
代理对象：通过 AOP完成功能扩展的对象，相当于原理图中的对象B
切点：要进行功能扩展的地方，此处配置到了方法，相当于 testA()方法
前置通知方法：在切点之前执行的扩展方法
后置通知方法：在切点之后执行的扩展方法
切面：由前置通知方法+切点+后置通知方法形成的横向执行的面
织入：由前置通知方法+切点+后置通知方法形成切面的过程

6.3 SchemaBase方式实现 AOP

配置相关依赖

<!-- 配置 Spring IoC的依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.1.3</version>
</dependency>
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>

<!-- 配置 Spring AOP的依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>6.1.3</version>
</dependency>

在与需要升级的service包的同级目录下创建 advice包，并创建前置通知类和后置通知类

前置通知类（实现 MethodBeforeAdvice接口，重写 before方法）

package com.lwclick.advice;

import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;

public class MyBeforeAdvice implements MethodBeforeAdvice {
    /**
     * @param method 切点的方法对象
     * @param args   代理对象的扩展方法 接收的实参的数组（扩展方法接收的实参和切点方法一致）
     * @param target 真实对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("我在原方法的【前面】进行扩展");
    }
}

后置通知类（实现 AfterReturningAdvice接口，重写 afterReturning方法）

package com.lwclick.advice;

import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;

public class MyAfterAdvice implements AfterReturningAdvice {
    /**
     * @param returnValue 返回的值
     * @param method      切点的方法对象
     * @param args        代理对象的扩展方法接收的实参的数组
     * @param target      真实对象
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("我在原方法【返回结果之前】进行扩展");
    }
}

在 applicationcontext.xml文件中进行配置

<?xml version="1.0" encoding="UTF-8"?>
<!-- 配置aop需要增加 
		xmlns:aop="http://www.springframework.org/schema/aop" 
			http://www.springframework.org/schema/aop
       		 https://www.springframework.org/schema/aop/spring-aop.xsd  -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置需要升级的方法所在类的bean -->
    <bean id="sourceClass" class="com.lwclick.service.impl.UserServiceImpl"/>

    <!-- 将前置通知类配置为 bean -->
    <bean id="before" class="com.lwclick.advice.MyBeforeAdvice"/>
    <!-- 将后置通知类配置为 bean -->
    <bean id="after" class="com.lwclick.advice.MyAfterAdvice"/>

    <!-- 告诉 aop组装的规则 -->
    <aop:config>
        <!-- ======== 配置需要升级哪个方法！！！    【会生成代理对象进行处理】 ======== -->
        <aop:pointcut id="myPointcut" expression="execution(* com.lwclick.service.impl.UserServiceImpl.demo())"/>
        <!-- 具体的组装规则 -->
        <aop:advisor advice-ref="after" pointcut-ref="myPointcut"/>
        <aop:advisor advice-ref="before" pointcut-ref="myPointcut"/>
    </aop:config>
</beans>

在代码中进行使用（注意：经过AOP扩展后的内容，已不是它本身，而是Spring AOP生成的代理对象 – 夺舍）

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = ac.getBean("sourceClass", UserService.class);

userService.demo();  // 此时调用的 demo()，已不是原方法

– 还可以使用 环绕通知 实现与前置通知+后置通知相同的效果：

在 advice包下，声明环绕通知类

环绕通知类（实现 MethodInterceptor类，重写 invoke方法）

package com.lwclick.advice;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyRoundAdvice implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("环绕通知---前");

        Object proceed = invocation.proceed();  // 原始方法进行执行

        System.out.println("环绕通知---后");
        return proceed;
    }
}

同样在 applicationcontext.xml中进行配置

异常通知的配置方式同理：

在 advice包下，声明异常通知类

异常通知类（实现 ThrowsAdvice类，创建 afterThrowing方法）

package com.lwclick.advice;

import org.springframework.aop.ThrowsAdvice;

public class MyThrowsAdvice implements ThrowsAdvice {
    public void afterThrowing(Exception ex) throws Throwable {
        System.out.println("异常通知");
    }
}

在 applicationcontext.xml中进行配置

6.4 AspectJ方式实现 AOP

问题：使用 SchemaBased方式实现功能扩展时，一个扩展代码就需要声明一个类，太繁杂。

解决：使用AspectJ方式

配置相关依赖（IoC、AOP的依赖）

创建一个通知类

package com.lwclick.advice;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAdvice {

    public void testBefore() {
        System.out.println("=== 前置通知 ===");
    }

    public void testAfter() {
        System.out.println("=== 后置通知 ===");
    }

    public Object testRound(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("=== 环绕前 ===");

        Object proceed = joinPoint.proceed();

        System.out.println("=== 环绕后 ===");
        return proceed;
    }
    
    public void testThrow(Exception ex) {
        System.out.println("=== 异常通知 ===");
    }
}

在 applicationcontext.xml中配置（使用<aop:aspect>标签）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置需要升级的方法所在类的bean -->
    <bean id="sourceClass" class="com.lwclick.service.impl.UserServiceImpl"/>
    <!-- 配置通知的bean -->
    <bean id="advice" class="com.lwclick.advice.MyAdvice"/>

    <!-- 告诉 aop组装的规则 -->
    <aop:config>
        <aop:aspect ref="advice">
            <!-- ======== 配置需要升级哪个方法！！！ ======== -->
            <aop:pointcut id="myPointcut" expression="execution(* com.lwclick.service.impl.UserServiceImpl.demo())"/>  <!-- 该切点只在当前标签下有效！ -->
            
            <!-- 配置具体的通知方法!!! -->
            <aop:before method="testBefore" pointcut-ref="myPointcut"/>
            <aop:after-returning method="testAfter" pointcut-ref="myPointcut"/>
            <aop:around method="testRound" pointcut-ref="myPointcut"/>
            <aop:after-throwing method="testThrow" pointcut-ref="myPointcut" throwing="ex"/>
        </aop:aspect>
    </aop:config>
</beans>

6.5 切点的声明格式

execution(访问修饰符  返回值类型  包名.类名.方法名称(方法参数))

访问修饰符：可省略
返回值类型、包名、类名、方法名称：都可用 * 代替（表示任意的）
包名与类名之间一个点代表当前包下的类，两个点代表当前包及其子包下的类
参数列表可以使用两个点，代表任意个数的任意参数列表

6.6 注解方式实现 AOP

Spring AOP的注解方式的实现，是基于 AspectJ方式的

6.6.1 相关注解

@Pointcut：在切点方法上使用

声明切点

@Pointcut("execution(* com.lwclick.service.impl.UserServiceImpl.demo())")
public void pointcut(){}

@Aspect：结合 @Component在通知类上使用
- 声明该类为通知类
```
@Component
@Aspect
public class MyAdvice {}
```
@Before：在前置通知方法上使用
- 声明方法为前置通知方法
- 需要在其中声明对应的切点的全限定路径（如果切点与通知方法在同一个类中，则可以直接写切点的方法名）
```
@Before("pointcut()")
public void testBefore() {
    System.out.println("=== 前置通知 ===");
}
```
@After：在后置通知方法上使用
- 声明方法为后置通知方法
- 需要在其中声明对应的切点的全限定路径
@Around：在环绕通知方法上声明
- 声明方法为环绕通知方法
- 需要在其中声明对应的切点的全限定路径
@AfterThrowing：在异常通知方法上声明
- 声明方法为异常通知方法

6.6.2 基本步骤

需要在 applicationcontext.xml中，声明注解的使用路径，及开启AOP注解

<?xml version="1.0" encoding="UTF-8"?>
<!-- 配置context【注解扫描】需要增加 
		xmlns:aop="http://www.springframework.org/schema/context" 
			http://www.springframework.org/schema/context
       		 https://www.springframework.org/schema/context/spring-context.xsd  -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/context/spring-aop.xsd">

    <!-- 配置注解扫描：即使用注解的路径 -->
    <context:component-scan base-package="com.lwclick.advice,com.lwclick.service"/>
    <!-- 开启 AOP注解（使之生效） -->
    <aop:aspectj-autoproxy expose-proxy="true"/>
</beans>

通知类：

@Component
@Aspect
public class MyAdvice {

    @Pointcut("execution(* com.lwclick.service.impl.UserServiceImpl.demo())")
    public void pointcut(){}

    @Before("pointcut()")
    public void testBefore() {
        System.out.println("=== 前置通知 ===");
    }

    @After("pointcut()")
    public void testAfter() {
        System.out.println("=== 后置通知 ===");
    }

    @Around("pointcut()")
    public Object testRound(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("=== 环绕前 ===");

        Object proceed = joinPoint.proceed();

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

    @AfterThrowing(value = "pointcut()", throwing = "e")
    public void testThrow(Exception e) {
        System.out.println("=== 异常通知 ===");
    }
}

业务类：

@Service
public class UserServiceImpl implements UserService {
    @Override
    public void demo() {
        System.out.println("11111111111");
    }
}

测试方法：

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = ac.getBean("userServiceImpl", UserService.class); // 并没有在配置文件中创建userServiceImpl的bean，但是可以直接获取  【因为使用了注解】

userService.demo();

7.代理设计模式(AOP底层实现逻辑)

将对某个功能的调用以及实现的代码封装(隐藏)起来，避免调用方式以及实现代码的直接暴露。

7.1 静态代理

真实对象：要进行功能扩展的对象
真实方法：要进行功能扩展的方法
代理对象：调用真实对象并完成功能扩展的对象
代理方法：调用真实方法的扩展方法

代理对象和代理方法由程序员自己编写实现。

在代理对象的代理方法中，调用真实对象的真实方法，然后将代理对象和代理方法对外暴露。

7.2 动态代理

代理对象和代理方法是动态生成的，底层流程与静态代理的逻辑是一致的

JDK动态代理（官方提供）

真实对象和代理对象要实现相同的接口，方便用户调用代理对象
CGLib动态代理（第三方）

代理对象继承真实对象

7.2.1 JDK动态代理

声明接口，并在接口中声明要进行代理的方法

public interface MyInterface {
    // 声明方法
    void testMethod(String name);
}

创建真实对象，实现接口，并完成方法的实现

// 真实对象实现接口
public class MyTrueClass implements MyInterface {
    @Override
    public void testMethod(String name) {
        System.out.println("我是JDK动态代理的真实对象的真实方法：" + name);
    }
}

创建代理对象，并声明对应的扩展代码

public class MyJdkProxy implements InvocationHandler {
    /**
     * @param proxy  代理对象
     * @param method 代理方法
     * @param args   存储代理方法接收的实参的数组
     * @return
     * @throws Throwable
     *
     * 动态生成的代理方法，自动调用该方法
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("JDK动态代理---前");

        MyTrueClass myTrueClass = new MyTrueClass();
        myTrueClass.testMethod((String) args[0]);

        System.out.println("JDK动态代理---后");
        return null;
    }
}

测试

public class TestMain {
    public static void main(String[] args) {
        // 获取代理对象
        MyInterface myInterface = (MyInterface) Proxy.newProxyInstance(
                TestMain.class.getClassLoader(),
                new Class[] {MyInterface.class},  // 代理对象实现接口
                new MyJdkProxy());

        // 使用代理对象
        myInterface.testMethod("张三");
    }
}

7.2.2 CGLib动态代理

配置相关依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

声明真实对象和真实方法

public class MyTrueClass {
    
    public void testCGLibMethod() {
        System.out.println("我是CGLib动态代理的真实方法");
    }
}

创建代理对象，并声明代理方法，完成扩展代码的声明

import java.lang.reflect.Method;

public class MyCGLibProxy implements MethodInterceptor {

    /**
     * @param o           代理对象
     * @param method      真实方法
     * @param objects     存储了代理方法接收的实参的数组
     * @param methodProxy 代理方法
     * @return
     * @throws Throwable
     *
     * 该方法由代理方法自动调用，我们在该方法中声明扩展代码，以及调用真实方法即可
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("=== CGLib扩展前 ===");

        Object invoked = methodProxy.invokeSuper(o, objects);

        System.out.println("=== CGLib扩展后 ===");
        return invoked;
    }
}

测试

import net.sf.cglib.proxy.Enhancer;

public class TestMain {
    public static void main(String[] args) {
        // 创建 CGLib对象
        Enhancer en = new Enhancer();
        // 设置代理对象需要【继承】的真实对象
        en.setSuperclass(MyTrueClass.class);
        // 设置代理方法要调用的代码
        en.setCallback(new MyCGLibProxy());
        // 获取代理对象
        MyTrueClass myTrueClass = (MyTrueClass) en.create();

        // 使用代理对象
        myTrueClass.testCGLibMethod();
    }
}

注意：此时可能会报错 Unable to make protected final java.lang.Class java.lang.ClassLoader.defineClass，是由于从 JDK9开始有关反射相关的功能就被限制了，了解原理即可

7.3 AOP底层代理模式

Spring AOP底层默认使用的是 JDK动态代理，同时也支持 CGLib动态代理，可以在 applicationcontext.xml配置文件中进行开启

<aop:aspectj-autoproxy proxy-target-class="true"/>

8.SpringTX的使用

使用 SpringTX实现 Spring整合 Mybatis后的事务管理

如图所示，中间的传统方式即为编程式事务（事务管理代码由程序员自己编写）；而使用 Spring提供的事务管理的通知类，即为声明式事务（事务管理代码由第三方直接提供，程序员直接使用即可）

8.1 基本步骤

配置相关依赖

<!-- Spring TX依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>6.1.3</version>
</dependency>

<!-- SpringIoC、SpringAOP、Spring整合Mybatis、Mybatis、数据库驱动  的依赖 -->

在 applicationcontext.yml中配置 Spring的事务管理

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx
       https://www.springframework.org/schema/tx/spring-tx.xsd">

    <bean id="myDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- mysql8.0 的Driver要多加一个 cj -->
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:/localhost:3306/db-demo"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!-- ============= 配置事务管理 ============== -->
    <!-- 配置事务管理 bean（通知bean） -->
    <bean id="myTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDataSource"/>    <!-- 配置要管理哪个数据库的事务 -->
    </bean>

    <!-- 配置具体的事务管理方法：对 AOP切点的通配范围的进一步缩减，【对没有事务的方法不进行代理】 -->
    <tx:advice id="myAdvice" transaction-manager="myTransactionManager">
        <tx:attributes>
            <!-- 只对【方法名】为以下形式的方法进行代理 -->
            <tx:method name="ins*"/>
            <tx:method name="del*"/>
            <tx:method name="upd*"/>
            <tx:method name="sel*"/>
        </tx:attributes>
    </tx:advice>

    <!-- 配置事务管理的切面 -->
    <aop:config>
        <aop:pointcut id="myPointcut" expression="execution(* com.lwclick.service.impl.*.*(..))"/>
        <aop:advisor advice-ref="myAdvice" pointcut-ref="myPointcut"/>
    </aop:config>
</beans>

8.2 声明式事务的属性解释

即上述代码中 <tx:method>标签内的属性

name：哪些方法需要有事务控制
- 支持 * 通配符
readonly：是否是只读事务
- 如果为 true，代表为只读事务，会对数据库查询性能有一定的提升
- false(默认值)：代表为需要提交的事务
propagation：事务传播行为（即 A方法去调用 B方法时，如何管理事务）
- REQUIRED(默认值)：如果 A有事务，则 B在事务中执行，如果 A没有，则 B新建一个事务
- SUPPORTS：如果 A有事务，则 B在事务中执行，如果 A没有，那么就不在事务中执行
- MANDATORY：必须在事务中执行，如果 A有事务，则 B在事务中执行，如果没有，则报错
- REQUIRES_NEW：必须在事务中执行，如果 A有事务，则把其挂起，如果没有，则新建事务
- NOT_SUPPORTED：必须在非事务下执行，如果 A没有事务，则 B正常执行，如果有事务，则将事务挂起
- NEVER：必须在非事务下执行，如果 A没有事务，则 B正常执行，如果有事务，则报错
- NESTED：必须在事务状态下执行，如果没有事务，则新建一个，如果有，则创建一个嵌套的
isolation：事务隔离级别（在多线程或并发访问下，如果保证读到的数据具有完整性）

脏读：A事务读到了 B事务还未提交的数据，B事务可能对数据又进行了改变，就导致 A读到的数据与数据库中的数据不一致。

不可重复读（主要针对的是修改操作）：A事务中有两次查询，第一次查询后，B事务将数据库中的值进行了修改，A事务第二次查询时，查到的值和第一次的不一样。

幻读（主要针对的是新增或删除操作）：A事务按照特定条件查询出结果，B事务此时又插入了一条符合条件的数据，导致 A事务查询出的数据和数据库中的数据不一致。
- DEFAULT(默认值)，由底层数据库自动判断应该使用什么隔离级别
- READ_UNCOMMITTED：可以读取未提交的数据，可能出现脏读、不可重复读、幻读，但效率最高
- READ_COMMITTED：只能读取其他事务已提交的数据，可防止脏读，但是可能出现不可重复读、幻读
- REPEATABLE_READ：对读取的数据加锁，防止其他事务修改，可防止脏读、不可重复读，可能出现幻读，MySQL默认隔离级别
- SERIALIZABLE：对整个表加锁，一个事务在操作数据时，其他事务都需要等待，最安全，但效率最低
rollback-for：出现什么异常时回滚
no-rollback-for：出现什么异常时不回滚

9.Spring配置文件中引入其他配置文件

之前数据库的连接信息都是在 Spring的配置文件 applicationcontext.xml中直接写的，修改时需要各种找，很麻烦

解决：创建 db.properties文件声明数据库连接参数，然后在 Spring配置文件中引入

创建 db.properties文件

mysql.driver=com.mysql.cj.jdbc.Driver
mysql.url=jdbc:mysql:/localhost:3306/db-demo
mysql.username=root
mysql.password=root

在 Spring配置文件 applicationcontext.xml中引入文件

<context:property-placeholder location="classpath:db.properties"/>

在数据源 bean中使用 ${}的方式获取值

<bean id="myDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="${mysql.driver}"/>
    <property name="url" value="${mysql.url}"/>
    <property name="username" value="${mysql.username}"/>
    <property name="password" value="${mysql.password}"/>
</bean>

修改 mapper扫描配置信息

<bean id="fact" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!-- 如果数据源 bean的 id为 dataSource时，可以不写，会自动注入-->
    <property name="dataSource" ref="myDataSource"/>
    <property name="typeAliasesPackage" value="com.lwclick.entity"/>
</bean>

<!-- ========== 修改内容 ============ -->
<bean id="mapperScan" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!-- 此处不再使用上面5.1步骤时的 <property name="sqlSessionFactory" ref="fact"/> 方式-->
    <property name="sqlSessionFactoryBeanName" value="fact"/>
    <property name="basePackage" value="com.lwclick.mapper"/>
</bean>

LRcoding

关注

19
点赞
踩
23

收藏

觉得还不错? 一键收藏
打赏
0
评论
【JavaLearn】#（30）框架引入、Spring框架、Spring IOC的基本使用、常用注解(IoC)、Spring整合Mybatis、Spring AOP内容、代理设计模式、SpringTX

框架引入、Spring框架、Spring IOC的基本使用、常用注解(IoC)、Spring整合Mybatis、Spring AOP内容、代理设计模式、SpringTX
复制链接

扫一扫