1、Spring

1.1、简介

==自己了解==

导入 Maven 包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.16.RELEASE</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.16.RELEASE</version>
</dependency>

1.2、优点

  • Spring 是一个开源的免费的框架 (容器)
  • Spring 是一个轻量级的、非入侵式的框架
  • 控制反转,面向切面编程(AOP)
  • 支持事务处理,对框架整合的支持

==Spring 是一个轻量级的控制反转 (IOC) 和面向切面编程 (AOP) 的框架==

1.3、组成

img

1.4、拓展

现代化 Java 开发(基于 Spring 开发)

Spring (构建一切) —-> Spring Boot(协调一切) ———> Spring Cloud (连接一切)

  • Spring Boot
    • 一个快速开发的脚手架
    • 基于 Spring Boot 可以快速的开发单个微服务
  • Spring Cloud
    • 其是基于 Spring Boot 实现的

弊端:

​ 配置十分繁琐

2、IOC 理论推导

  1. UserDao 接口
  2. UserDaoImpl 实现类
  3. UserServer 业务接口
  4. UserServicelImpl 业务实现类

在之前的业务中 用户的需求可能会影响原来的代码,需要根据用户的需求去修改原代码. 如果程序代码量十分大, 修改一次的代价会十分昂贵!

image-20210916140339691

使用一个 Set 接口实现

1
2
3
4
5
6
private UserDao userDao;

//利用 set 进行 动态实现值的注入
public void setUserDao(Userdao userDao) {
this.userDao = userDao;
}
  • 之前程序是主动创建对象, 控制权在程序设计者手上

  • 使用 set 注入后, 程序不再具有主动性, 而是变成了被动接收对象

    ​ 这种思想从本质上解决了问题, 程序设计人员不需要去管理对象的创建. 系统的耦合性大大降低, 可以更加专注的在业务的实现上. IOC 原型

image-20210916140357265

IOC 本质

控制反转IoC(Inversion of Control),是一种设计思想,DI(依赖注入)是实现IoC的一种方法,也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方,个人认为所谓控制反转就是:获得依赖对象的方式反转了。

在这里插入图片描述

**Container Overview **(IOC容器)

container magic

3、 Hello Spring

beans.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--使用 Spring 来创建对象, 在 Spring 中这些都称为 Bean

类型 变量名 = new 类型();
Hello hello = new Hello();

bean == 对象 new Hello();

id = 变量名
class = new 的对象
property 相当于给对象中的属性设置一个值

ref: 引用 Spring 容器中创建好的对象
value: 具体的值 基本数据类型
-->
<bean id="hello" class="com.cu1.pojo.Hello">
<property name="str" value="Spring"/>
</bean>
</beans>

Test

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.cu1;

import com.cu1.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
public static void main(String[] args) {
//获取 Spring 的上下文对象 获取 ApplicationContext; 拿到 Spring 容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//对象都在 Spring 管理 如果要使用 直接去里面取出来就可以 需要什么 就直接 get 什么
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
}

  • Hello 对象是由 Spring 创建
  • hello 对象的属性是由 Spring 容器设置的

这个过程就叫做控制反转:

​ 控制: 谁来控制对象的创建, 传统应用程序的对象是由程序本身控制创建的, 使用 Spring 后, 对象是由 Spring 来创建的

​ 反转: 程序本身不创建对象, 而变成被动的接收对象

​ 依赖注入: 就是利用 set 方法来进行注入

​ IOC 是一种编程思想, 由主动的编程变为被动的接收

​ 可以通过 new ClassPathXmlApplicationContext 去浏览底层源码

到了现在, 彻底不需要去程序中改动, 要实现不同的操作, 只需要在 xml 配置文件中进行修改, 所谓的 IOC, 一句话来搞定:

对象由 Spring 来创建, 管理和装配

4、IOC 创建对象的方式

  1. 使用无参构造创建对象

  2. 假设要使用有参构造构造对象

    1. 下标赋值

      1
      2
      3
      4
      5
      <!--第一种, 下标赋值-->
      <bean id="user" class="com.cu1.pojo.User">
      <constructor-arg index="0" value="Cu1"/>

      </bean>
    2. 通过参数类型创建

      1
      2
      3
      4
      5
      6
      7
      <!--第二种, 用参数类型进行赋值
      type 为参数类型
      不建议使用
      -->
      <bean id="user" class="com.cu1.pojo.User">
      <constructor-arg type="java.lang.String" value="Cuii*"/>
      </bean>
    3. 参数名

      1
      2
      3
      4
      <!--第三种, 直接利用参数名来赋值-->
      <bean id="user" class="com.cu1.pojo.User">
      <constructor-arg name="name" value="Cu1"/>
      </bean>
  3. Spring 容器在注册创建时自动创建 bean 中的所有对象, 即已经初始化了,. 且多次 get 对象得到的为同一个对象, 即内存中仅有一个实例

5、Spring 配置

5.1、别名

1
2
<!--别名, 如果添加了别名, 我们也可以通过别名获取对象-->
<alias name="user" alias="userNew"/>

5.2、Bean 的配置

1
2
3
4
5
6
7
8
<!--
id: bean的唯一标识符, 也就是相当于学的对象名
class: bean 对象所对应的全限定名: 包名 + 类名
name: 也是别名, 而且 name 可以同时取多个别名 可以通过 ": ' ' ," 这三个分割
-->
<bean id="userT" class="com.cu1.pojo.User" name="user2, user3">
<property name="name" value="Cu1"/>
</bean>

5.3、Import

import 一般用于团队开发使用, 其可以将多个配置文件, 导入合并为 1 个

假设现在项目中有多个人开发 这两个人负责不同的类开发, 不同的类需要注册在不同的 Bean 中, 可以利用 Import 将所有人的 Beans.xml 合并为一个总的

  • 1 beans.xml
  • 2 beans1.xml
  • 合并到 applicationContext.xml
1
2
3
4
5
6
7
8
9
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="beans.xml"/>
<import resource="beans1.xml"/>

</beans>

到时候直接使用总的配置就可以了, 假设内容相同 在合并中会被自动合并

6、 依赖注入

6.1、构造器注入

前面已经介绍过

6.2、Set 方式注入

  • 依赖注入: Set 注入
    • 依赖: bean 对象的创建依赖于容器
    • 注入: bean 对象中的所有属性, 由容器来注入

[环境搭建]

  1. 复杂类型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Address {
    private String address;

    public String getAddress() {
    return address;
    }

    public void setAddress(String address) {
    this.address = address;
    }
    }
  2. 真实测试对象

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String, String> card;
    private Set<String> games;
    private Properties info;
    private String wife;

    public String getName() {
    return name;
    }

    public void setName(String name) {
    this.name = name;
    }

    public Address getAddress() {
    return address;
    }

    public void setAddress(Address address) {
    this.address = address;
    }

    public String[] getBooks() {
    return books;
    }

    public void setBooks(String[] books) {
    this.books = books;
    }

    public List<String> getHobbys() {
    return hobbys;
    }

    public void setHobbys(List<String> hobbys) {
    this.hobbys = hobbys;
    }

    public Map<String, String> getCard() {
    return card;
    }

    public void setCard(Map<String, String> card) {
    this.card = card;
    }

    public Set<String> getGames() {
    return games;
    }

    public void setGames(Set<String> games) {
    this.games = games;
    }

    public Properties getInfo() {
    return info;
    }

    public void setInfo(Properties info) {
    this.info = info;
    }

    public String getWife() {
    return wife;
    }

    public void setWife(String wife) {
    this.wife = wife;
    }

    @Override
    public String toString() {
    return "Student{" +
    "name='" + name + '\'' +
    ", address=" + address +
    ", books=" + Arrays.toString(books) +
    ", hobbys=" + hobbys +
    ", card=" + card +
    ", games=" + games +
    ", info=" + info +
    ", wife='" + wife + '\'' +
    '}';
    }
    }

  1. Beans.xml

    1
    2
    3
    4
    <bean id="student" class="com.cu1.pojo.Student">
    <!--第一种, 普通值注入, value-->
    <property name="name" value="Cu1"/>
    </bean>
  1. 测试类

    1
    2
    3
    4
    5
    6
    7
    public class Test {
    public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    Student student = (Student) context.getBean("student");
    System.out.println(student);
    }
    }

==完善注入信息==

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">


<bean id="address" class="com.cu1.pojo.Address">
<property name="address" value="烟台"/>
</bean>

<bean id="student" class="com.cu1.pojo.Student">
<!--第一种, 普通值注入, value-->
<property name="name" value="Cu1"/>
<!--第二种, bean 注入, 使用 ref 去注入-->
<property name="address" ref="address"/>
<!--数组注入-->
<property name="books">
<array>
<value> 红楼梦 </value>
<value> 海上灵光 </value>
<value> 水浒 </value>
<value> 西游记 </value>
</array>
</property>
<!--List 注入-->
<property name="hobbys">
<list>
<value> 听歌 </value>
<value> 电影 </value>
<value> 代码 </value>
</list>
</property>
<!--map 注入-->
<property name="card">
<map>
<entry key="身份证" value="111132372979739487"/>
<entry key="银行卡" value="329649286896834686"/>
</map>
</property>
<!--Set 注入-->
<property name="games">
<set>
<value>LOL</value>
<value>Nz</value>
<value>GTA5</value>
</set>
</property>
<!--null-->
<property name="wife">
<null/>
</property>
<!--Properties
key = value
key = value
key = value
...
key 写括号里面
value 写 > < 尖括号中间
可以参考数据库连接的 Property 文件写
-->
<property name="info">
<props>
<prop key="学号">19214174</prop>
<prop key="性别"></prop>
<prop key="姓名">Cu1</prop>
</props>
</property>
</bean>

</beans>

6.3、拓展方式注入

可以使用 p 命名空间和 c 命名空间进行注入

官方解释:

官方文档 1.4.2

使用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?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:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">

<!--p 命名空间注入 可以直接注入属性的值 property-->
<!--<bean id="user" class="com.cu1.pojo.User" p:name="Cu1" p:age="20"/>-->

<!--c 命名空间注入, 通过构造器注入 construct-args-->
<bean id="user" class="com.cu1.pojo.User" c:name="Cu1" c:age="20"/>


</beans>

测试:

1
2
3
4
5
6
7
8
9
10
11
12
13
import com.cu1.pojo.Student;
import com.cu1.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
final User user = context.getBean("user", User.class);
System.out.println(user);
}
}

注意点:

  • p 命名空间和 c 命名空间不能直接使用, 需要导入 xml 约束
1
2
xmlns:c="http://www.springframework.org/schema/c"    
xmlns:p="http://www.springframework.org/schema/p"

6.4、Bean 的作用域

image-20210918202047617

6.4.1、The Singleton Scope 单例模式1.51

==Spring 默认机制==

1
2
3
4
5
<!--
scope 设置单例模式(默认模式)
此处为显示设置单例模式
-->
<bean id="user" class="com.cu1.pojo.User" c:name="Cu1" c:age="20" scope="singleton"/>

6.4.2、The Prototype Scope 原型模式1.52

==每一次从容器中 get 的时候都会产生一个新对象==

1
<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>

6.4.3、其余的 request, session, application 这些个只能在 Web 开发中使用

7、Bean 的自动装配

  • 自动装配是 Spring 满足 Bean 依赖的一种方式
  • Spring 会在上下文中自动寻找, 并给Bean 装配属性

==在 Spring 中有三种装配方式:==

  1. 在 xml 中显示的配置
  2. 在 Java 中显示配置
  3. ==隐式的自动装配==

7.1、测试

环境搭建

  • 一个人有两个宠物

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    package com.cu1.pojo;

    public class Person {
    private Cat cat;
    private Dog dog;
    private String name;

    public Cat getCat() {
    return cat;
    }

    public void setCat(Cat cat) {
    this.cat = cat;
    }

    public Dog getDog() {
    return dog;
    }

    public void setDog(Dog dog) {
    this.dog = dog;
    }

    public String getName() {
    return name;
    }

    public void setName(String name) {
    this.name = name;
    }

    @Override
    public String toString() {
    return "Person{" +
    "cat=" + cat.shout() +
    ", dog=" + dog.shout() +
    ", name='" + name + '\'' +
    '}';
    }
    }

7.2、ByName 自动装配

1
2
3
4
5
6
<!--
byName 会自动在容器上下文中查找, 和自己对象 set 方法后面的值对应 Bean id
-->
<bean id="person" class="com.cu1.pojo.Person" autowire="byName">
<property name="name" value="Cu1"/>
</bean>

7.3、ByType 自动装配

1
2
3
4
5
6
<!--
byType 会自动在容器上下文中查找, 和自己对象 属性类型相同的 Bean
-->
<bean id="person" class="com.cu1.pojo.Person" autowire="byType">
<property name="name" value="Cu1"/>
</bean>

小结:

  • ByName 时需要保证所有 Bean 的 id 唯一, 并且这个 Bean 需要和自动注入的属性的 set 方法的值一致

  • ByName 时需要保证所有 Bean 的 class 唯一, 并且这个 Bean 需要和自动注入的属性的属性类型的值一致

7.4、使用注解实现自动装配

JDK1.5 支持的注解, Spring 在 JDK2.5就开始支持

要使用注解须知:

  1. 导入约束: context 约束

  2. 配置注解的支持 ==记得开启配置注解支持 context:annotation-config/==

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    <?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

    </beans>

@Autowired

​ 在属性上使用即可, 也可以在 set 方法上使用 (使用注解不需要再自己写 set 方法)

​ 使用 Autowired 可以不用编写 set 方法, 前提注入的自动装配属性在 IOC (Spring) 容器中存在, 且符合名字 byName

@Nullable

​ 字段标记了这个注解, 表示这个字段可以为 NULL

1
2
3
4
5
6
7
8
public @interface Autowired {
boolean required() default true;
}


//如果显示定义了Autowired 的 requid 属性为 false 说明这个对象可以 null 否则不允许为空
@Autowired(required = false)
private Cat cat;
1
2
3
4
5
6
7
8
public class Person {
//如果显示定义了Autowired 的 requid 属性为 false 说明这个对象可以 null 否则不允许为空
@Autowired(required = false)
private Cat cat;
@Autowired
private Dog dog;
private String name;

如果 @Autowired 自动装配无法通过一个注解装配完成的时候, 可以使用

@Qualifier(value = “xxx”) 去配置 @Autowired 所指定的唯一 Bean 对象

1
2
3
4
5
6
7
8
9
public class Person {
//如果显示定义了Autowired 的 requid 属性为 false 说明这个对象可以 null 否则不允许为空
@Autowired(required = false)
private Cat cat;
@Autowired
@Qualifier(value = "dog")
private Dog dog;
private String name;
}

@Resource 如果不指定唯一 Bean 对象就先按照名称如果找不到就按照类型

@Resource(name = “xxx”) 指定唯一 Bean 对象

小结:

@Resource 和 @Autowired 的区别:

  • 都是自动装配 都可以放在属性字段上

  • @Autowired 通过 byType 的方式实现 且必须要求这个对象存在

  • @Resoucre 默认通过 byName 的方式实现, 如果找不到名字, 则通过 byType 方式实现, 如果两个都找不到的情况下, 就报错

    [常用]

  • 执行顺序不同 @Autowired 通过 byType 寻找 , 在通过 byName 寻找 @Resource 则相反

8、使用注解开发

在 Spring 4 之后, 要使用注解开发, 必须要保证 aop 的包导入了

image-20210923133350132

使用注解需要导入 context 约束 并增加注解支持

  • @Component: 组件 放在类上 说明这个类被 Spring 管理了, 也就是 Bean
  1. Bean
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//等价于<bean id="user" class="com.cu1.pojo.User"/>
//@Component 组件
@Component
public class User {
private String name = "Cu1";

public void setName(String name) {
this.name = name;
}

public String getName() {
return name;
}

@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
  1. 属性如何注入
1
2
3
4
5
6
7
8
9
10

//等价于<bean id="user" class="com.cu1.pojo.User"/>
//@Component 组件
@Component
public class User {
//相当于<property name="name" value="Cu1"/> 也可以放在 Set 方法上
@Value("Cu1")
private String name;
}

  1. 衍生的注解

    @Component 有几个衍生的注解 在 Web 开发中 会按照 mvc 三层架构分层

    • dao [@Repository]
    • service [@Service]
    • contronller [@Controller]

    这四个注解功能都是一样的 都是代表将某个类注册到 Spring 中 装配 Bean

  2. 自动装配置

  3. 作用域

    1
    @Scope("") 
  4. 小结

    xml 与注解:

    • xml 更加万能 适用于任何场合 维护简单方便
    • 注解不是自己的类使用不了 使用相对复杂

    最佳实践:

    • xml 负责管理类的注册
    • 注解负责属性的注入
    • 在使用过程中只需要注意一个问题 必须要注解生效 就需要开启注解支持
    1
    2
    3
    4
    <!--开启注解支持-->
    <context:annotation-config/>
    <!--指定要扫描的包 这个包下的注解就会生效-->
    <context:component-scan base-package="com.cu1"/>

9、使用 java 的方式配置 Spring

现在完全不需要使用 Spring 的 xml 配置了, 全权交给 Java 来做

JavaConfig 是 Spring 的一个子项目, 在 Spring4 之后 它成为了一个核心功能

  • 实体类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    //这个注解说明这个类被 Spring 注册到了容器中
    @Component
    public class User {

    //注入值
    @Value("Cu1")
    private String name;

    public String getName() {
    return name;
    }

    public void setName(String name) {
    this.name = name;
    }

    @Override
    public String toString() {
    return "User{" +
    "name='" + name + '\'' +
    '}';
    }
    }

  • 配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//类似于 Bean
//这个也会被 Spring 容器托管 因为它本来就是一个 @Component
//@Configuration 代表这是一个配置类就和之前的 Beans.xml 一样
@Configuration
@ComponentScan("com.cu1.pojo") //扫描包
//相当于 Bean.xml 中的 import 标签
@Import(MyConfig2.class)
public class MyConfig {
//注册一个 Bean 就相当于之前写的一个 Bean 标签,
//这个方法的名字就相当于 Bean 标签中的 Id 属性, 方法的返回值就相当于 Bean 标签中的 Class
@Bean
public User getUser() {
//该返回值就是要注入到 Bean 的对象
return new User();
}
}

  • 测试类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class Test {

    public static void main(String[] args) {
    /*如果完全使用了配置类方式去做, 就只能通过 AnnotationConfig 上下文来获取容器, 通过配置类的 Class 对象加载*/
    ApplicationContext Context = new AnnotationConfigApplicationContext(MyConfig.class);
    User getUser = Context.getBean("getUser", User.class);
    System.out.println(getUser);
    }
    }

这种纯 Java 的配置方式, 在 SpringBoot 中随处可见

10、代理模式

学代理模式的理由:

​ 因为这即是 SpringAOP 的底层 [SpringAOP 和 SpringMVC]

代理模式的分类:

  • 静态代理
  • 动态代理

10.1、静态代理

角色分析:

  • 抽象角色: 一般会使用接口或者抽象类来解决
  • 真实角色: 被代理的角色
  • 代理角色: 代理真实角色, 代理真实角色后, 一般会做一些附属操作
  • 客户: 访问代理对象的人

代码步骤:

  1. 接口

    1
    2
    3
    4
    //租房
    public interface Rent {
    public void rent();
    }
  2. 真实角色

    1
    2
    3
    4
    5
    6
    7
    //房东
    public class Host implements Rent {
    @Override
    public void rent() {
    System.out.println("房东要租房子!");
    }
    }
  3. 代理角色

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    //中介
    public class Proxy implements Rent {
    private Host host;

    public Proxy(Host host) {
    this.host = host;
    }

    public Host getHost() {
    return host;
    }

    @Override
    public void rent() {
    this.seeHouse();
    host.rent();
    this.hetong();
    this.fare();
    }

    public void setHost(Host host) {
    this.host = host;
    }

    //看房
    public void seeHouse() {
    System.out.println("中介带你看房");
    }

    //收中介费
    public void fare() {
    System.out.println("收中介费");
    }

    //签租赁合同
    public void hetong() {
    System.out.println("签租赁合同");
    }
    }

  4. 客户端访问代理角色

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class Client {
    public static void main(String[] args) {
    Host host = new Host();
    //代理 中介帮房东租房子, 但是代理一般会有一些附属操作
    Proxy proxy = new Proxy(host);

    //你不需要面对房东 直接找中介租房即可
    proxy.rent();
    }
    }

代理模式的好处:

  • 可以使真实角色的操作更加纯粹, 不用去关注一些公共的业务
  • 公共业务就交给代理角色, 实现了业务的分工
  • 公共业务发生扩展的时候方便集中管理

缺点:

  • 一个真实角色就会产生一个代理角色 代码量会翻倍 ———–>开发效率会降低

10.2、加深理解

基本架构

  • Service 层

    1
    2
    3
    4
    5
    6
    7
    public interface UserSerivce {
    public void add();
    public void delete();
    public void update();
    public void query();
    }

  • 实现类 Impl层

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    public class UserSerivceImpl implements UserSerivce {

    @Override
    public void add() {
    System.out.println("使用了 add 方法");
    System.out.println("增加了一个用户");
    }

    @Override
    public void delete() {
    System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
    System.out.println("修改了一个用户");
    }

    @Override
    public void query() {
    System.out.println("查询了一个用户");
    }

    /*
    * 1. 改动原来已经写好的代码是大忌
    *
    * */
    }

  • 代理层 Proxy

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    public class UserServiceProxy implements UserSerivce {

    UserSerivceImpl userSerivceImpl;

    public void setUserSerivceImpl(UserSerivceImpl userSerivceImpl) {
    this.userSerivceImpl = userSerivceImpl;
    }

    @Override
    public void add() {
    log(":add");
    userSerivceImpl.add();
    }

    @Override
    public void delete() {
    log(":delete");
    userSerivceImpl.delete();
    }

    @Override
    public void update() {
    log(":udpate");
    userSerivceImpl.update();
    }

    @Override
    public void query() {
    log("query");
    userSerivceImpl.query();
    }
    //日志方法
    public void log(String msg) {
    System.out.println("[Debug]使用了" + msg + "方法");
    }
    }

  • 控制层

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Client {
    public static void main(String[] args) {
    UserSerivceImpl userSerivce = new UserSerivceImpl();

    UserServiceProxy userServiceProxy = new UserServiceProxy();
    userServiceProxy.setUserSerivceImpl(userSerivce);

    userServiceProxy.add();
    }
    }

10.3、动态代理

  • 动态代理和静态代理角色一样
  • 动态代理的代理类是动态生成的, 不是直接写好的
  • 动态代理分为两大类: 基于接口的动态代理, 基于类的动态代理
    • 基于接口 —– JDK 动态代理 [在此处使用]
    • 基于类: cglib
    • Java 字节码 JavaSist

需要了解两个类: Proxy 代理, InvocationHandler: 调用处理程序

10.3.1、InvocationHandler

​ 动态代理的好处

  • 可以使真实角色的操作更加纯粹, 不用去关注一些公共的业务
  • 公共业务就交给代理角色, 实现了业务的分工
  • 公共业务发生扩展的时候方便集中管理
  • 一个动态代理类代理的是一个接口, 一般代理一类的业务
  • 一个动态代理类可以代理多个类, 只要实现了同一个接口

ProxyInvocatonHandler 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//会使用这个类自动生成代理类
public class ProxyInvocatonHandler implements InvocationHandler {

//被代理的接口
private Object target;

//生成得到的代理类
public Object getProxy() {
return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}

//处理代理实例并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

log(method.getName());

//动态代理的本质就是使用反射机制实现
Object invoke = method.invoke(target, args);

return invoke;
}

public void setTarget(Object target) { this.target = target; }

public void log(String msg) { System.out.println("执行了" + msg + "方法"); }

}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Client {
public static void main(String[] args) {
//真实角色
UserSerivceImpl userSerivce = new UserSerivceImpl();
//代理角色 不存在
ProxyInvocatonHandler pih = new ProxyInvocatonHandler();

//设置要代理的对象
pih.setTarget(userSerivce);

//动态生成代理类
UserSerivce proxy = (UserSerivce) pih.getProxy();

proxy.delete();
}
}

结构分析:

  1. 流程:

    首先通过 利用 Set 方法接收某一个实现接口的类, 在调用public Object getProxy() {} 方法获取到代理类 然后通过代理类去掉用 ProxyInvocatonHandler 类中的public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {} 函数去调用利用代理类要运行的接口的实现类的某个要运行的方法

  2. 被代理对象

1
2
//被代理的接口
private Object target;

target 表示被代理的实体对象, 也即某一个接口的实现类, 即可参考第一个 demo 中的房东

  1. 设置要代理的对象

    1
    2
    //设置要代理的对象
    pih.setTarget(userSerivce);
  2. 处理代理实例并返回结果

1
2
3
4
5
6
7
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log(method.getName());
//动态代理的本质就是使用反射机制实现
Object invoke = method.invoke(target, args);
return invoke;
}
  • proxy 代理类
  • method 代理类要调用的实现类中实现的接口方法
  • Object [] args 代理类要调用的实现类中实现的接口方法的参数
  1. 通过 Proxy 类的静态方法得到的 Proxy 代理类

    1
    2
    3
    4
    5
    //生成得到的代理类
    public Object getProxy() {
    return Proxy.newProxyInstance(this.getClass().getClassLoader(),
    target.getClass().getInterfaces(), this);
    }
    • this.getClass().getClassLoder 获取 ProxyInvocatonHandler 类的类加载器
    • target.getClass().getInterfaces() 获取当前实现类的接口, 以便获得接口及其方法中的信息, 以便在调用实现类方法时找到相对应的方法及其实现作为参数 method 传递给 invoke 方法
    • this 则是提供自身以便代理类 proxy 进行调用 invoke 方法

11、AOP

11.1、什么是 AOP

​ AOP : 面向切面编程, 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术. AOP 是 OOP 的延续, 是 Spring 框架中的一个重要内容, 是函数式编程的一种衍生泛型. 利用 AOP 可以对业务逻辑的各个部分进行隔离, 从而使得业务逻辑各部分之间的耦合度降低, 提高程序的可重用性, 同时提高了开发效率

11.2、 AOP 在 Spring 中的作用

==提供声明式事务, 允许用户自定义切面==

  • 横切关注点: 跨越应用程序多个模块的方法或者功能. 即是, 与业务逻辑无关, 但是需要关注的部分, 就是横切关注点. 如日志, 安全, 缓存, 事务等等
  • 切面 (ASPECT): 横切关注点 被模块化的特殊对象. 即它是一个类
  • 通知 (Advice): 切面必须要完成的工作. 即, 它是类中的一个方法
  • 目标( Target): 被通知对象
  • 代理 (Proxy): 向目标对象应用通知之后创建的对象
  • 切入点 (PointCut): 切面通知执行的 “地点的定义”
  • 连接点 (JointPoint): 于切入点匹配的执行点

Spring AOP 中 通过 Advice 定义横切逻辑, Spring 中支持五种类型的1 Advice

通知(Advice)

在特定的连接点,AOP框架执行的动作。

Spring AOP 提供了5种类型的通知:

  • 前置通知(Before):在目标方法被调用之前调用通知功能。
  • 后置通知(After):在目标方法完成之后调用通知,无论该方法是否发生异常。
  • 后置返回通知(After-returning):在目标方法成功执行之后调用通知。
  • 异常抛出通知(After-throwing):在目标方法抛出异常后调用通知。
  • 环绕通知(Around):通知包裹了被通知的方法,在被通知的方法调用之前和调用之后执行自定义的行为。

即 AOP 在不改变原有代码的情况下, 去增加新的功能

11.3、使用 Spring 实现 AOP

使用 AOP 需要导入一个依赖包

1
2
3
4
5
6
7
8
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.7</version>
<scope>runtime</scope>
</dependency>

方式一: 使用 Spring 的 API 接口

  • 接口:

    1
    2
    3
    4
    5
    6
    public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
    }
  • 实现类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    public class UserServiceImpl implements UserService {

    @Override
    public void add() {
    System.out.println("增加了一个用户");
    }

    @Override
    public void delete() {
    System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
    System.out.println("修改了一个用户");
    }

    @Override
    public void select() {
    System.out.println("查询了一个用户");
    }
    }
  • 要在原实现功能上增加的两个方法类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public class AfterLog implements AfterReturningAdvice {
    //returnValue 返回值
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
    System.out.println("执行了" + method.getName() + "方法, 返回结果为: " + returnValue);
    }
    }

    public class Log implements MethodBeforeAdvice {
    /*method 要执行的目标对象的方法
    * args 参数
    * target 目标对象
    * */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
    System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了");
    }
    }

  • XML 文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    <?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
    https://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--注册 Bean-->
    <bean id="userService" class="com.cu1.Service.UserServiceImpl"/>
    <bean id="log" class="com.cu1.Log.Log"/>
    <bean id="afterLog" class="com.cu1.Log.AfterLog"/>

    <!--方式一: 使用原生 Spring API 接口-->
    <!--配置 AOP 需要导入 AOP 的约束-->
    <aop:config>
    <!--切入点 experssion: 表达式 execution(要执行的位置 * * * * * *)-->
    <aop:pointcut id="pointcut" expression="execution(* com.cu1.Service.UserServiceImpl.*())"/>
    <!--执行环绕增加-->
    <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

    </beans>
  • 测试

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class MyTest {
    public static void main(String[] args) {
    ApplicationContext Context = new ClassPathXmlApplicationContext("applicationContext.xml");

    //动态代理的是接口
    UserService userService = (UserService)Context.getBean("userService");

    userService.select();
    }
    }

思考:

ApplicationContext Context = new ClassPathXmlApplicationContext("applicationContext.xml"); 时 Spring 根据 AOP 标签中的实现类要代理的某些方法以及这个其他要通过代理执行这些方法的其他方法, 并返回一个代理类 其中继承了实现类中要代理方法的接口, 这些接口的实现是通过调用实现类的方法完成, 并加入将一些核心操作之外, 即实现代理模式

方式二: 自定义来实现 AOP [相对于第一种更简单]

  • 自定义类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

    public class DiyPointCut {

    public void before() {
    System.out.println("======方法执行前=======");
    }

    public void after() {
    System.out.println("======方法执行后========");
    }
    }

  • XML 文件配置

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    <!--方式二: 自定义类-->
    <bean id="diy" class="com.cu1.Diy.DiyPointCut"/>

    <aop:config>
    <!--自定义切面 ref 要引用的类-->
    <aop:aspect ref="diy">
    <!--切入点-->
    <aop:pointcut id="poincut" expression="execution(* com.cu1.Service.UserServiceImpl.*())"/>
    <!--通知-->
    <aop:before method="before" pointcut-ref="poincut"/>
    <aop:after method="after" pointcut-ref="poincut"/>
    </aop:aspect>
    </aop:config>

    <aop:aspect ref="diy"></aop:aspect> 表示告诉 Spring 要在代理类中加入的代理方法的类是哪一个

    <aop:pointcut id="poincut" expression="execution(* com.cu1.Service.UserServiceImpl.*())"/>

    告诉 Spring Diy 类的对象 diy 中的方法要代理的是哪一个实体类以及它实现的什么方法、

    1
    2
    3
    <!--通知-->
    <aop:before method="before" pointcut-ref="poincut"/>
    <aop:after method="after" pointcut-ref="poincut"/>

    告诉 Spring Diy 类的 diy 对象中的某些方法在代理类中处于要代理方法的什么位置, 以及在什么被代理类中的什么被代理方法中使用这个方法

方式三: 使用注解实现

  • XML

    1
    2
    3
    4
    <!--方式三: -->
    <bean id="annotationPointCut" class="com.cu1.AnnotationPoinCut.AnnotationPointCut"/>
    <!--开启注解支持 JDK(默认) false cglib (true)-->
    <aop:aspectj-autoproxy proxy-target-class="false"/>
  • java 类的注解实现 AOP

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    //使用注解方式实现 AOP
    @Aspect //标注这个类是一个切面
    public class AnnotationPointCut {
    @Before("execution(* com.cu1.Service.UserServiceImpl.*())")
    public void before() {
    System.out.println("=======方法执行前========");
    }

    @After("execution(* com.cu1.Service.UserServiceImpl.*())")
    public void after() {
    System.out.println("=======方法执行前后=======");
    }

    //在环绕增强中 可以给定一个参数 代表要获取处理切入的点
    @Around("execution(* com.cu1.Service.UserServiceImpl.*())")
    public void around(ProceedingJoinPoint jp) throws Throwable {
    System.out.println("环绕前");

    //执行方法
    Object proceed = jp.proceed();

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

12、整合 MyBatis

==文档==

步骤:

  1. 导入相关 Jar 包

    • junit
    • MyBatis
    • MySQL
    • Spring
    • AOP 织入
    • MyBaits-Spring

    ==pom.xml 文件依赖==

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    <dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.16.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
    <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
    <!--<scope>runtime</scope>-->
    </dependency>

    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    </dependency>

    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.21</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.6</version>
    </dependency>


    <!--Spring 操作数据库的话 还需要一个 Spring-jdbc 的包-->
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.9</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
    <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.6</version>
    </dependency>

    </dependencies>
  2. 编写配置文件

  3. 测试

12.1、回忆 MyBatis

  1. 编写实体类
  2. 编写核心配置文件
  3. 编写接口
  4. 编写 Mapper.xml
  5. 测试

12.2、MyBatis -Spring

方式一:

  1. 编写数据源:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    <?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
    https://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--!DataSource 使用 Spring 的数据源替换 MyBatis 的配置 c3P0, dbcp, druid
    此处使用 Spring 的 JDBC
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://:3306/?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
    <property name="username" value=""/>
    <property name="password" value=""/>
    </bean>

    <!--SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!--绑定 MyBatis 配置文件-->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <property name="mapperLocations" value="classpath:com/cu1/mapper/*.xml"/>
    </bean>

    <!--SqlSessionTemplate 等价于原来使用的 sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <!--只能使用构造器注入 sqlSessionFactory, 因为它没有 Set 方法-->
    <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>


    </beans>
  2. SqlSessionFactory

  3. SqlSessionTemplate

  4. 需要给接口加实现类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public class UserMapperImpl  implements UserMapper {

    //在原来, 所有操作都使用 SqlSession 来执行, 现在都使用 SqlSessionTemplate

    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
    this.sqlSession = sqlSession;
    }

    @Override
    public List<User> selectUser() {
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    return mapper.selectUser();
    }
    }

  5. 测试 (将自己写的实现类注入到 Spring 中测试使用)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    <?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
    https://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd">
    <import resource="Spring-dao.xml"/>


    <bean id="userMapper" class="com.cu1.mapper.UserMapperImpl">
    <property name="sqlSession" ref="sqlSession"/>
    </bean>

    </beans>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class Test {
    @org.junit.Test
    public void test() throws IOException {
    ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("Spring-dao.xml");
    UserMapper userMapper = classPathXmlApplicationContext.getBean("userMapper", UserMapper.class);
    List<User> users = userMapper.selectUser();
    for (User user : users) {
    System.out.println(user);
    }
    }
    }

方式二:

​ 利用实现类继承 SqlSessionDaoSupport 类并利用其 getSqlSession() 方法得到 sqlSession

  1. 实现类
1
2
3
4
5
6
7
8
9
10
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {

@Override
public List<User> selectUser() {
SqlSession sqlSession = getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
return mapper.selectUser();
}
}

  1. 在 Spring 中注册实现类

    1
    2
    3
    <bean id="userMapper2" class="com.cu1.mapper.UserMapperImpl2">
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
  2. 测试

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Test {
    @org.junit.Test
    public void test() throws IOException {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
    List<User> users = userMapper.selectUser();
    for (User user : users) {
    System.out.println(user);
    }
    }
    }

13、声明式事务

1、回顾事务

  • 把一组业务当作一个业务来做, 要么都成功, 要么都失败
  • 事务在项目开发中, 十分的重要, 涉及到数据的一致性问题, 不能马虎
  • 确保完整性和一致性

事务 ACID 原则:

  • 原子性
  • 一致性
  • 隔离性
    • 多一个业务可能操作同一个资源, 防止数据损坏
  • 持久性
    • 事务一旦提交, 无论系统发生什么问题, 结果都不会再被影响, 被持久化的写到存储器中

2、Spring 中的事务管理

  • 声明式事务: AOP

  • 编程式事务: 需要再代码中, 进行事务的管理

    开启事务以及配置事务的 XML

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    <?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
    https://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--!DataSource 使用 Spring 的数据源替换 MyBatis 的配置 c3P0, dbcp, druid
    此处使用 Spring 的 JDBC
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://47.100.227.175:3306/School?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
    <property name="username" value="MysqlRoot"/>
    <property name="password" value="370802mysql"/>
    </bean>

    <!--SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!--绑定 MyBatis 配置文件-->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <property name="mapperLocations" value="classpath:com/cu1/mapper/*.xml"/>
    </bean>

    <!--SqlSessionTemplate 等价于原来使用的 sqlSession-->
    <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
    <!--只能使用构造器注入 sqlSessionFactory, 因为它没有 Set 方法-->
    <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <!--配置声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <constructor-arg ref="dataSource" />
    </bean>

    <!--结合 AOP 实现事务的织入-->
    <!--配置事务通知:-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!--给哪一些方法配置事务-->
    <!--配置事务的传播特性: new propagation=""
    propagation="REQUIRED 支持当前事务, 如果没有当前事务, 就新建一个事务, 这是最常见的选择, 也是 Spring 默认选择
    propagation="SUPPORTS" 支持当前事务, 如果当前没有事务, 就以非事务方式执行
    propagation="MANDATORY" 支持当前事务, 如果当前没有事务, 就抛出异常
    propagation="REQUIRES_NEW" 新建事务, 如果当前存在事务, 就把当前事务挂起
    propagation="NOT_SUPPORTED" 以非事务方式执行操作, 如果当前存在事务, 就把当前事务挂起
    propagation="NEVER" 以非事务方式执行, 如果当前存在事务, 则抛出异常
    propagation="NESTED" 支持当前事务, 如果当前事务存在, 则执行一个嵌套事务, 如果当前没有事务, 就新建一个事务
    read-only="true" 只读权限
    -->
    <tx:attributes>
    <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
    </tx:advice>

    <!--配置事务切入-->
    <aop:config>
    <aop:pointcut id="pointCut" expression="execution(* com.cu1.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pointCut"/>
    </aop:config>

    </beans>


为什么需要事务?

  • 如果不配置事务, 可能存在数据提交不一致的情况下:
  • 如果不在 Spring 中配置声明事务, 就需要在代码中手动配置事务
  • 事务在项目开发中十分重要, 涉及到数据的一致性和完整性问题, 不容马虎