Spring5笔记

Vesuvius688

已于 2023-02-02 09:40:12 修改

阅读量587

点赞数 1

分类专栏：个人笔记文章标签： spring java ssm

于 2021-10-17 17:03:56 首次发布

本文链接：https://blog.csdn.net/Alan_Walker688/article/details/120812413

版权

个人笔记专栏收录该内容

15 篇文章 0 订阅

订阅专栏

本篇文章是观看B站UP主狂神说关于 Spring 讲解的视频，借鉴 Spring 官方文档以及CSDN博主夜里的雨相关文章整理的个人 Spring 笔记。因笔者能力有限，文章难免有错误之处，欢迎各位评论勘误，共同探讨！

Spring5笔记

1、Spring
- 1.1 简介
- 1.2 优点
- 1.3 组成
- 1.4 扩展
- 1.5 弊端
2、IoC 理论
- 2.1 传统的调用
- 2.2 改良（通过Set方法）
- 2.3 IoC本质
3、HelloSpring
4、Spring 配置
- 4.1 别名
- 4.2 Bean 的配置
- 4.3 import
5、依赖注入 (DI)
- 5.1 构造器注入
- 5.2 Set注入
- 5.3 c/p 命名空间注入
6、Bean 的自动装配
- 6.1 Bean 的三种装配方式
- 6.2 自动装配测试
- 6.3 使用注解实现自动装配
7、使用注解开发
- 7.1 Bean
- 7.2 衍生的注解
- 7.3 作用域 @scope
- 7.4 注解与 xml 配置小结
8、动态代理
- 8.1 静态代理
- 8.2 动态代理
9、AOP
- 9.1 什么是 AOP？
- 9.2 AOP 在 Spring 中的使用
- 9.3 使用 Spring 实现 AOP
10、Spring 整合 Mybatis
- 10.1 方式一
- 10.2 方式二
11、声明式事务

1、Spring

1.1 简介

Spring 理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！
官方文档：https://spring.io/projects/spring-framework#overview
官方下载：https://repo1.maven.org/maven2/org/springframework/spring/
GitHub：https://github.com/spring-projects/spring-framework

Spring Web MVC 依赖包：https://mvnrepository.com/artifact/org.springframework/spring-webmvc

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.9</version>
</dependency>

1.2 优点

Spring 是一个开源的免费框架（容器）
Spring 是一个轻量级的非入侵式的框架
控制反转（IoC），面向切面编程（AOP）
支持事务的处理，支持框架整合

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

1.3 组成

Spring 七大模块

1.4 扩展

现代化的 Java 开发 -----> 基于 Spring 的开发

基于 Spring 的开发

Spring Boot
- 一个快速开发的脚手架
- 基于 SpringBoot 可以快速地开发单个微服务
- 约定大于配置
- 学习 Spring Boot 的前提是完全掌握 Spring 及 Spring MVC
Spring Cloud
- Spring Cloud 是基于 Spring Boot 实现的

1.5 弊端

配置十分繁琐，人称：”配置地狱！“

2、IoC 理论

2.1 传统的调用

UserDao

public interface UserDao {
    void getUser();
}

UserDaoImpl

public class UserDaoImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("默认获取用户数据");
    }
}

UserService

public interface UserService {
    void getUser();
}

UserServiceImpl

public class UserServiceImpl implements UserService{
    private UserDao userDao = new UserDaoImpl();
    
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

测试

public class UserDaoTest {
    @Test
    public void getUser() {
        UserService userService = new UserServiceImpl();
        userService.getUser();
    }
}

上述方式，用户的需求可能会影响原来的代码，我们需要根据用户的需求去修改原代码；如果程序代码量十分大，那么修改一次的成本代价十分昂贵！

传统方式

2.2 改良（通过Set方法）

public class UserServiceImpl implements UserService{
    private UserDao userDao;
	//在 Service 层的实现类（UserServiceImpl）增加一个 Set() 方法
	//利用 set 动态实现值的注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

Set() 方法实际上是动态改变了 UserDao userDao 的初始化部分（new UserDaoImpl()）

测试代码改为

public class UserDaoTest {
    @Test
    public void getUser() {
        UserService userService = new UserServiceImpl();
        ((UserServiceImpl) userService).setUserDao(new UserDaoImpl());
        userService.getUser();
    }
}

之前，程序是主动创建对象！控制权在程序员手上！
使用 Set 注入后，程序不再具有主动性，而是变成了被动的接受对象！（主动权在用户手上）

本质上解决了问题，程序员不用再去管理对象的创建

系统的耦合性大大降低，可以更专注在业务的实现上

这是IOC（控制反转）的原型，反转(理解)：主动权交给了用户

IOC方式

2.3 IoC本质

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

IoC思想

采用 XML 方式配置 Bean 的时候，Bean 的定义信息是和实现分离的，而采用注解的方式可以把二者合为一体，Bean 的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种面向对象编程的设计思想。
依赖注入 (Dependency Injection, DI) 是 IoC 思想的实现方式。
IoC容器是实现依赖注入的关键，本质是一个工厂。

3、HelloSpring

在父模块中导入 jar 包

<dependency>
    <!--Spring5-->
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.10</version>
</dependency>
<dependency>
    <!--JUnit测试-->
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.7.1</version>
</dependency>

在实体类包 pojo 中创建 Hello.java

package com.sit.pojo;

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

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

在 resource 中创建 beans.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
    	类型 变量名 = new 类型();
    	Hello hello = new Hello();
    	
    	bean = 对象 (hello)
    	id = 变量名 (hello)
    	class = new的对象 (new Hello();)
    	property 相当于给对象中的属性设值，令 str="Hello Spring"
    -->
    
    <bean id="hello" class="com.sit.pojo.Hello">
        <property name="str" value="Hello Spring!"/>
    </bean>

</beans>

在 test 包中建立测试类 HelloTest

package com.sit.pojo;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloTest {
    @Test
    public void hello() {
        //获取 Spring 的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //对象已由 Spring 管理，使用时直接用 getBean() 获取就行了
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);
    }
}

Spring 管理对象的核心之一是用 set 注入，所以在 pojo 实体类中必须要有 set() 方法

public void setStr(String str) {
    this.str = str;
}

IoC：对象由 Spring 创建、管理及装配！

B站弹幕里面的一种理解：

原来的程序：你写好菜单准备好菜，等到客人来了自己把菜炒好招待，相当于你请人吃饭；
现在的程序：你告诉餐厅你需要哪些菜，客人来的时候，餐厅把你需要的菜做好送到你家
IoC：炒菜这件事不再由你自己来做，而是委托给了第三方——餐厅来做
区别：如果你还需要其他的菜，就不需要自己看菜谱买材料并做好，而是告诉餐厅你要什么菜，到时候直接让餐厅做好送给你

小结：

在不使用注解的方式下，所有类的装配都要在 beans.xml 文件中；
所有的 bean 都要通过容器来获取；
从容器里面取得的 bean 就是一个对象，用对象调用方法即可。

思考：

User user1 = (User) context.getBean("user");
User user2 = (User) context.getBean("user");
system.out.println(user1 == user2); //结果为true

在配置文件加载的时候，容器中管理的对象就已经被初始化了。

4、Spring 配置

4.1 别名

<bean id="user" class="com.sit.pojo.User">
    <constructor-arg name="name" value="Spring"/>
</bean>

<alias name="user" alias="userAlias"/>
<!-- 使用时
	User user2 = (User) context.getBean("userAlias");	
-->

常用于自动配置别名——经过下列配置后可以在写 class 路径时省略包路径

<typeAliases>
    <package name="com.sit.pojo"/>
</typeAliases>

<!--上面的 bean 可以写为下面的形式-->
<bean id="user" class="User">
    <constructor-arg name="name" value="Spring"/>
</bean>

4.2 Bean 的配置

<!--id: bean 的唯一标识符，相当于对象名
    class：bean对象所对应的全限定名: 类的全路径 + 类型
    name: 给 bean 起别名,可通过空格、逗号、分号同时起多个别名
-->
<bean id="user" class="User" name="u1 u2,u3;u4">
    <property name="name" value="Spring"/>
</bean>
<!-- 使用时
	User user2 = (User) context.getBean("u1/u2/u3/u4");	
-->

4.3 import

import 一般用于团队开发使用，它可以将多个配置文件，导入合并为一个总的配置文件。

假设，现在一个项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的 beans.xml 中，我们可以利
用 import 将所有人的 beans.xml 合并为一个总的配置文件。

张三(beans1.xml)
李四(beans2.xml)
王五(beans3.xml)

在 ApplicationContext.xml 中使用 import 整合配置文件

<import resource="beans1.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>

各个 xml 配置文件会按照在总的 xml 配置文件中的导入顺序来进行创建，后导入的配置文件会重写先导入的，最终实例化的对象会是后导入总 xml 文件中的那个。

5、依赖注入 (DI)

5.1 构造器注入

5.1.0 IoC 创建对象的方式

默认使用无参构造创建对象 (了解)

<bean id="user" class="com.sit.pojo.User">
    <!--0.默认方式：使用无参构造创建对象-->
    <property name="name" value="张三"/>
</bean>

使用有参构造创建对象

2.1 通过下标赋值 (了解)

<!--1.通过下标使用有参构造创建对象(了解)-->
<!--index 指的是有参构造中参数的下标，从0开始-->
	<constructor-arg index="0" value="李四"/>

2.2 通过类型赋值（不建议使用）

<!--2.通过参数类型创建对象（不建议使用）-->
	<constructor-arg type="java.lang.String" value="王五"/>

2.3 通过名称赋值 (常用)

<!--3.通过参数名称创建对象(常用)-->
    <!--ref 引用 Spring 中已经创建好的对象-->
    <!--value 是一个具体的值，基本数据类型-->
    <constructor-arg name="name" value="赵六"/>

5.1.1. 在 pojo 包中创建一个 User 类

package com.sit.pojo;

public class User {
    private String name;

    public User() {
        System.out.println("调用了User的无参构造！");
    }

    public User(String name) {
        this.name = name;
        System.out.println("调用了User的有参构造！");
    }

    public String getName() {
        return name;
    }

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

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

5.1.2 创建 beans.xml 文件并添加如下代码

<bean id="user" class="com.sit.pojo.User">
    <!--3.通过参数名称创建对象(常用)-->
    <constructor-arg name="name" value="赵六"/>
</bean>

5.1.3 在测试类中增加一个测试方法

@Test
public void user() {
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User user = (User) context.getBean("user");
    System.out.println(user);
}

5.2 Set注入

5.2.1. 复杂类型

Address类

package com.sit.pojo;

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

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

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

5.2.2. 真实测试对象

Student类

package com.sit.pojo;

import java.util.*;

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String, String> card;
    private Set<String> games;
    private String girlfriend;
    private Properties info;

    //省略各个属性的get()和set()方法

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", \naddress=" + address +
                ", \nbooks=" + Arrays.toString(books) +
                ", \nhobbies=" + hobbies +
                ", \ncard=" + card +
                ", \ngames=" + games +
                ", \ngirlfriend='" + girlfriend + '\'' +
                ", \ninfo=" + info +
                '}';
    }
}

5.2.3. 配置 beans.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">

    <bean id="address" class="com.sit.pojo.Address">
        <property name="address" value="四川峨眉山"/>
    </bean>

    <bean id="student" class="com.sit.pojo.Student">
        <property name="name" value="张无忌"/>
        <property name="address" ref="address"/>
        <property name="books">
            <array>
                <value>《降龙十八掌》</value>
                <value>《六脉神剑》</value>
                <value>《凌波微步》</value>
                <value>《独孤九剑》</value>
            </array>
        </property>
        <property name="hobbies">
            <list>
                <value>听音乐</value>
                <value>乒乓球</value>
                <value>敲代码</value>
                <value>看电影</value>
            </list>
        </property>
        <property name="card">
            <map>
                <entry key="身份证号" value="123456789101112131415"/>
                <entry key="学生证号" value="161718192021222324252"/>
                <entry key="银行卡号" value="627282930313233343536"/>
                <entry key="社保卡号" value="373839404142434445464"/>
            </map>
        </property>
        <property name="games">
            <set>
                <value>英雄联盟</value>
                <value>原神</value>
                <value>刺客信条</value>
                <value>盗贼之海</value>
            </set>
        </property>
        <property name="girlfriend">
            <null/>
        </property>
        <property name="info">
            <props>
                <prop key="性别">男</prop>
                <prop key="年龄">22</prop>
                <prop key="班级">7484950</prop>
                <prop key="政治面貌">共青团员</prop>
            </props>
        </property>
    </bean>
</beans>

5.2.4. 测试

StudentTest 类

package com.sit.pojo;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class StudentTest {
    @Test
    public void student() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student);
    }
}

5.3 c/p 命名空间注入

Tips: c 是 constructor 的首字母，p 是 property 的首字母；c 命名空间利用构造器注入，p 命名空间利用 Set 方法注入。

5.3.0 使用 c/p 命名空间需要在 xml 文件头部导入约束

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

5.3.1 在 pojo 包中添加实体类 User.java

package com.sit.pojo;

public class User {
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //省略属性的get()和set()方法

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

5.3.2 配置 userbeans.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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userP" class="com.sit.pojo.User" p:name="张三" p:age="18" scope="singleton"/>

    <bean id="userC" class="com.sit.pojo.User" c:name="李四" c:age="20" scope="prototype"/>
</beans>

5.3.3 创建测试类 UserTest.java

package com.sit.pojo;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserTest {
    @Test
    public void user() {
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User userP = context.getBean("userP", User.class);
        System.out.println("userP: " + userP);
        User userP2 = context.getBean("userP", User.class);
        System.out.print("userP==userP2: ");
        System.out.println(userP==userP2);	//结果为true (注意beans.xml中scope="singleton")
        User userC = context.getBean("userC", User.class);
        System.out.println("userC: " + userC);
        User userC2 = context.getBean("userC", User.class);
        System.out.print("userC==userC2: ");
        System.out.println(userC==userC2);	//结果为false (注意beans.xml中scope="prototype")
    }
}

5.3.4 Bean Scopes (作用域)

Scope	Description
singleton	(Default) Scopes a single bean definition to a single object instance for each Spring IoC container.
prototype	Scopes a single bean definition to any number of object instances.
request	Scopes a single bean definition to the lifecycle of a single HTTP request. That is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring `ApplicationContext`.
session	Scopes a single bean definition to the lifecycle of an HTTP `Session`. Only valid in the context of a web-aware Spring `ApplicationContext`.
application	Scopes a single bean definition to the lifecycle of a `ServletContext`. Only valid in the context of a web-aware Spring `ApplicationContext`.
websocket	Scopes a single bean definition to the lifecycle of a `WebSocket`. Only valid in the context of a web-aware Spring `ApplicationContext`.

作用域	描述
singleton	在每一个 Spring 容器中，一个 Bean 定义只有一个对象实例（默认）。
prototype	允许 Bean 的定义可以被实例化任意次（每次调用都创建一个实例）。
request	在一次 HTTP 请求中，每个 Bean 定义对应一个实例，该作用域仅在基于 Web 的 Spring 上下文（例如 Spring MVC）中才有效。
session	在一个 HTTP `Session` 中，每个 Bean 定义对应一个实例，该作用域仅在基于 Web 的 Spring 上下文（例如 Spring MVC）中才有效。
application	在一个 `ServletContext` 中，每个 Bean 定义对应一个实例，该作用域仅在基于 Web 的 Spring 上下文（例如 Spring MVC）中才有效。
websocket	在一个 `WebSocket` 中，每个 Bean 定义对应一个实例，该作用域仅在基于 Web 的 Spring 上下文（例如 Spring MVC）中才有效。

单例模式 (默认)
```
<bean id="userP" class="com.sit.pojo.User" p:name="张三" p:age="18" scope="singleton"/>
```
单例模式是把对象放到 pool 中，需要时再取出来，但使用的都是同一个对象实例。

原型模式

<bean id="userC" class="com.sit.pojo.User" c:name="李四" c:age="20" scope="prototype"/>

prototype

其余的 request、session、application 和 websocket 只能在web开发中使用！

6、Bean 的自动装配

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

6.1 Bean 的三种装配方式

在 xml 中显示配置
在 java 中显示配置
隐式地自动装配
- ByType 自动装配：自动查找和自己对象 set() 方法参数类型相同的 Bean
  
  需要保证所有的 class 全局唯一
- ByName 自动装配：自动查找和自己对象 set() 方法对应的值对应的 id

6.2 自动装配测试

在 pojo 包中创建 Cat.java

package com.sit.pojo;

public class Cat {
    public void shout() {
        System.out.println("喵~喵~喵~");
    }
}

在 pojo 包中创建 Dog.java

package com.sit.pojo;

public class Dog {
    public void shout() {
        System.out.println("汪~汪~汪~");
    }
}

在 pojo 包中创建 Person.java

package com.sit.pojo;

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

    //省略属性的 get() 和 set() 方法

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

xml 文件配置—— ByType 自动装配

<?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="cat" class="com.sit.pojo.Cat"/>
    <bean id="dog" class="com.sit.pojo.Dog"/>
    
    <!--ByType 会在容器自动查找和自己对象属性相同的 bean
		例如，Dog dog; 那么就会查找 pojo 的 Dog 类，再进行自动装配
	-->
    <bean id="person" class="com.sit.pojo.Person" autowire="byType">
        <property name="name" value="lbw"></property>
        <!--下列两行可省略-->
    	<!--<property name="cat" ref="cat"/>-->
		<!--<property name="dog" ref="dog"/>-->
    </bean>

</beans>

xml 文件配置—— ByName 自动装配

<!--id 必须为小写字母，写作大写则会报 NullPointer 异常-->
<bean id="cat" class="com.sit.pojo.Cat"/>
<bean id="dog" class="com.sit.pojo.Dog"/>
<!--byname 会在容器自动查找和自己对象 set()方法的 set 后面的值对应的id
  例如:setDog()，取 set 后面的字符"dog"作为id，则要 id = dog 才可以进行自动装配
 -->
<bean id="person" class="com.sit.pojo.Person" autowire="byName">
	<property name="name" value="lbw"></property>
    <!--下列两行可省略-->
    <!--<property name="cat" ref="cat"/>-->
	<!--<property name="dog" ref="dog"/>-->
</bean>

在 test 包中新建测试类 PersonTest.java

package com.sit.pojo;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class PersonTest {
    @Test
    public void test1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Person person = context.getBean("person", Person.class);
        person.getCat().shout();
        person.getDog().shout();
    }
}

6.3 使用注解实现自动装配

6.3.1 @Autowired

在 beans.xml 头部导入 context 约束

xmlns:context="http://www.springframework.org/schema/context"

配置注解的支持

<?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 				http://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>

在 person.java 中添加 @Autowired 注解

package com.sit.pojo;

import org.springframework.beans.factory.annotation.Autowired;

public class Person {
    @Autowired(required = false)
    private Cat cat;
    @Autowired(required = false)
    private Dog dog;
    private String name;

    //省略属性的 get() 和 set() 方法

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

@Autowired 默认匹配方式是 ByType
可以在属性和 set() 方法上使用
可以省略 set() 方法（前提是自动装配的属性在 Spring 容器里且要符合 ByName 自动装配）
如果定义了 @Autowired 的 required 属性为 false，说明这个对象可以为 null，否则不允许为空(false 表示找不到装配，不抛出异常)
```
//@AutoWired 的源码
public @interface Autowired {
    boolean required() default true;
}
```

6.3.2 @Autowired + @Qualifer

如果 xml 文件中同一个对象被多个 bean 使用，@Autowired 无法按照类型(ByType)找到，可以添加 @Qualifier 指定id查找

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog")
    private Dog dog;
    private String name;
}

6.3.3 @Resource

@Resource 默认匹配方式是 ByName

public class People {
    @Resource(name="cat")
    private Cat cat;
    @Resource(name="dog")
    private Dog dog;
    private String name;
}

6.3.4 @Resource和@Autowired的异同

都是用来自动装配的，都可以放在属性字段上
@Autowired 默认通过 byType 的方式实现，而且必须要求这个对象存在！
@Resource 默认通过 byName 的方式实现，如果找不到名字，则通过 byType 实现！如果两个都找不到的情况下，就报错！
执行顺序不同：@Autowired 先通过 byType 的方式匹配；@Resource 先通过 byName 的方式匹配。

7、使用注解开发

使用注解开发首先要保证 spring-aop.jar 包的导入

spring-aop.jar

然后需要在 xml 文件中导入 context 约束

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

</beans>

7.1 Bean

在 xml 文件中添加 <context:component-scan /> 标签，因为它包含了 <context:annotation-config />，所以后者可以省略。

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.sit"/>
    <!--开启注解支持-->
<!--<context:annotation-config/>-->
</beans>

在 pojo 包下的实体类上可以增加 @Component 和 @value 注解

package com.sit.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * 注解 Component 等价于 <bean id="user" class="com.sit.pojo.User/>
 */
@Component
public class User {
    /**
     * 注解 Value 等价于 <property name="name" value="小米"/>
     */
    @Value("小米")
    public String name;
}

7.2 衍生的注解

@Component 有几个衍生注解，会按照web开发中的 MVC 架构中分层。

@Repository——Dao层
@Service——Service层
@Controller——Controller层

上述四个注解的功能都是代表将某个类注册到容器中。

7.3 作用域 @scope

//原型模式: prototype 单例模式: singleton
//@scope("prototype") 相当于 <bean scope="prototype"/>
@Component 
@scope("prototype")
public class User { 
    //相当于 <property name="name" value="小米"/> 
    @value("小米") 
    public String name; 
    
    //也可以放在 set() 方法上面
    @value("小米")
    public void setName(String name) { 
        this.name = name; 
    }
}

7.4 注解与 xml 配置小结

xml 配置更加万能、维护简单、适用于任何场合
注解形式简单、维护复杂、不是自己的类不能使用

最佳使用方式：

使用 xml 管理 bean
使用注解完成属性的注入
在 xml 文件中开启注解支持

8、动态代理

代理模式是 Spring AOP 的底层

分类：静态代理和动态代理

代理模式的优点：

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

代理模式的缺点：

一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会降低。

代理模式

角色分析：

抽象角色：一般使用接口或抽象类解决；
真实角色：被代理的角色；
代理角色：代理真实角色，代理后一般会做一些附属操作；
客户：访问代理对象的人。

8.1 静态代理

代码步骤：

接口

package com.sit.pojo;

public interface Host {
	public void rent();
}

真实角色

package com.sit.pojo;

public class HostMaster implements Host{	
	public void rent() {
		System.out.println("房东要出租房子");
	}
}

代理角色

package com.sit.pojo;

public class Proxy {

	public Host host;
	
	public Proxy() {
		
	}
	
	public Proxy(Host host) {
		this.host = host;
	}
	
	public void rent() {
		seeHouse();
		host.rent();
		fee();
		sign();
	}
	//看房
	public void seeHouse() {
		System.out.println("看房子");
	}
	//收费
	public void fee() {
		System.out.println("收中介费");
	}
	//合同
	public void sign() {
		System.out.println("签合同");
	}		
}

客户

package com.sit.pojo;

import com.sit.pojo.Host;
import com.sit.pojo.HostMaster;
import com.sit.pojo.Proxy;

public class Client {

	public static void main(String[] args) {
		//房东要出租房子
		Host host = new HostMaster();
		//中介帮房东出租房子，但也收取一定费用（增加一些房东不做的操作）
		Proxy proxy = new Proxy(host);
		//客户不用和房东商量，但通过中介的代理还是租到了房子
		proxy.rent();
	}
}

AOP 横向开发

8.2 动态代理

动态代理的底层是反射机制，动态代理类是动态生成的。

了解两个类：

Proxy：代理类
InvocationHandler：调用处理类

动态代理有两大类：

基于接口：JDK 的动态代理
基于类：CGLib

动态代理的优点：

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

实例：

接口 Host.java

package com.sit.pojo2;

public interface Host {
	public void rent();
	
}

接口实现类 HostMaster.java

package com.sit.pojo2;

public class HostMaster implements Host{	
	public void rent() {
		System.out.println("房东要租房子");
	}
}

代理角色的调用处理类

package com.sit.pojo2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

///用这个类，自动生成代理
public class ProxyInvocationHandler implements InvocationHandler {

	// 被代理的接口
	public HostMaster hostMaster ;
	
	public void setHostMaster(HostMaster hostMaster) {
		this.hostMaster = hostMaster;
	}

	// 得到生成的代理类 
	public Object getProxy() {
		// newProxyInstance() -> 生成代理对象，就不用再写具体的代理类了
		// this.getClass().getClassLoader() -> 找到加载类的位置
		// hostMaster.getClass().getInterfaces() -> 代理的具体接口
		// this -> 代表了接口 InvocationHandler 的实现类 ProxyInvocationHandler
		return Proxy.newProxyInstance(this.getClass().getClassLoader(), hostMaster.getClass().getInterfaces(), this);


	// 处理代理实例并返回结果
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		seeHouse();
		// 动态代理的本质，就是使用反射机制实现的
        // invoke()执行它真正要执行的方法
		Object result = method.invoke(hostMaster, args);
		fee();
		return result;
	}

	public void seeHouse() {
		System.out.println("看房子");
	}

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

}

用户类

package com.sit.pojo2;

import com.sit.pojo2.Host;
import com.sit.pojo2.HostMaster;
import com.sit.pojo2.ProxyInvocationHandler;

public class Client2 {

	public static void main(String[] args) {
        
		//真实角色
		HostMaster hostMaster = new HostMaster();
        
		//代理角色，现在没有；用代理角色的调用处理类来实现 Host 接口的调用
		ProxyInvocationHandler pih = new ProxyInvocationHandler();
        
        //pih -> HostMaster接口类 -> Host接口
		pih.setHostMaster(hostMaster);
        
		//获取newProxyInstance动态生成代理类
		Host proxy = (Host) pih.getProxy();
		
		proxy.rent();

	}
}

可以总结出一个代理工具类

///用这个类，自动生代理
public class ProxyInvocationHandler implements InvocationHandler {

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

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

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

	// 处理代理实例并返回结果
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// 动态代理的本质，就是使用反射机制实现的
		// invoke()执行它真正要执行的方法
		Object result = method.invoke(target, args);
		return result;
	}

}

9、AOP

9.1 什么是 AOP？

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

9.2 AOP 在 Spring 中的使用

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

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

AOP 逻辑

在 Spring AOP 中，通过 Advice 定义横切逻辑，Spring 支持5种类型的 Advice：

Spring Advice

即 AOP 在不改变原有代码的情况下增加新的功能。（代理）

9.3 使用 Spring 实现 AOP

9.3.1 导入 jar 包

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

9.3.2 方式一：使用原生 Spring API

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"
       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 http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService" class="com.sit.service.UserServiceImpl"/>
    <bean id="beforeLog" class="com.sit.log.BeforeLog"/>
    <bean id="afterLog" class="com.sit.log.AfterLog"/>

    <!--方式一: 使用原生Spring API 接口实现AOP-->
    <!--配置AOP: 需要先导入AOP的约束-->
    <aop:config>
        <!--切入点-->
        <!--execution(修饰词 返回值 列名 方法名 参数)-->
        <aop:pointcut id="pointcut1" expression="execution(* com.sit.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增强-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut1"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut1"/>
    </aop:config>
    
</beans>

UserService.java

package com.sit.service;

public interface UserService {
    /**
     * 增加用户
     */
    void add();
    /**
     * 删除用户
     */
    void delete();
    /**
     * 修改用户
     */
    void update();
    /**
     * 查询用户
     */
    void query();
}

UserServiceImpl.java

package com.sit.service;

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 query() {
        System.out.println("查询了一个用户");
    }
}

前置 BeforeLog.java

package com.sit.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class BeforeLog implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了!");
    }
}

后置 AfterLog.java

package com.sit.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + method.getName() + "方法, 返回结果为" + returnValue);
    }
}

测试类 UserServiceTest.java

package com.sit.service;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserServiceTest {
    @Test
    public void aopAspectTest() {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
        userService.delete();
        userService.update();
        userService.query();
    }
 
}

9.3.3 方式二：自定义类实现 AOP

修改 ApplicationContext.xml

<!--方式二: 自定义类实现AOP-->
    <bean id="diyPointCut" class="com.sit.diy.DiyPointCut"/>
    <!--自定义切面，ref 要引用的类-->
    <aop:config>
        <aop:aspect ref="diyPointCut">
            <!--切入点-->
            <aop:pointcut id="pointcut2" expression="execution(* com.sit.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="beforeLog" pointcut-ref="pointcut2"/>
            <aop:after method="afterLog" pointcut-ref="pointcut2"/>
        </aop:aspect>
    </aop:config>

自定义切入点类

package com.sit.diy;

public class DiyPointCut {
    public void beforeLog() {
        System.out.println("==========执行前==========");
    }
    public void afterLog() {
        System.out.println("==========执行后==========");
    }
}

测试

package com.sit.service;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserServiceTest {
    @Test
    public void aopAdvisorTest() {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
        userService.delete();
        userService.update();
        userService.query();

    }
}

9.3.4 方式三：使用注解实现

修改 ApplicationContext.xml

<!--方式三: 使用注解实现AOP-->
    <bean id="annotationPointCut" class="com.sit.diy.AnnotationPointCut"/>
    <!--开启注解支持   1.JDK(默认 proxy-target-class="false")  2.cglib(proxy-target-class="true")-->
    <aop:aspectj-autoproxy/>

使用注解实现切入点

package com.sit.diy;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AnnotationPointCut {
    @Before("execution(* com.sit.service.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("==========方法执行前==========");
    }
    @After("execution(* com.sit.service.UserServiceImpl.*(..))")
    public void after() {
        System.out.println("==========方法执行后==========");
    }
}

测试

package com.sit.service;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserServiceTest {
    @Test
    public void aopAnnotationTest() {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
        userService.delete();
        userService.update();
        userService.query();
    }
}

10、Spring 整合 Mybatis

Mybatis-Spring 官网：https://mybatis.org/spring/zh/

Mybatis 的配置流程：

编写实体类
编写核心配置文件
编写接口
编写 Mapper.xml
测试

10.1 方式一

编写数据源配置
sqlSessionFactory
sqlSessionTemplate（相当于 sqlSession）
实现接口
将实现类注入 Spring 种
测试

先导入 jar 包

<dependencies>
    <dependency>
        <!--JUnit-->
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.7.1</version>
    </dependency>
    <dependency>
        <!--mybatis-->
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <!--Spring操作数据库-->
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>
</dependencies>

<!--解决资源导出失败的问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

代码步骤：

pojo实体类 User.java

package com.sit.pojo;

public class User {
    private int id;
    private String name;
    private String password;

    public User() {
    }

    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

    //省略属性的 set() 和 get() 方法

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

接口 UserMapper.java

package com.sit.mapper;

import com.sit.pojo.User;

import java.util.List;

public interface UserMapper {
    /**
     * 查询用户
     * @return 用户列表
     */
    List<User> queryUsers();
}

接口实现类 UserMapperImpl.java

package com.sit.mapper;

import com.sit.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

public class UserMapperImpl implements UserMapper {
    //所有操作在原来都使用 sqlSession 来执行，现在都使用 SqlSessionTemplate
    private SqlSessionTemplate sqlSession;

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

    /**
     * 查询用户
     *
     * @return 用户列表
     */
    public List<User> queryUsers() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.queryUsers();
    }
}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.sit.mapper.UserMapper">

    <select id="queryUsers" resultType="user">
        select * from mybatis.user
    </select>

</mapper>

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<!--开启日志-->
	<settings>
		<setting name="logImpl" value="STDOUT_LOGGING" />
	</settings>
	
	<!--可以给实体类起别名 -->
	<typeAliases> 
		<package name="com.sit.pojo" />
	</typeAliases>

</configuration>

spring-dao.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">

    <!--DataSource: 使用 Spring 的数据源替换 Mybatis 的配置  (c3p0、dbcp、druid、Spring JDBC等)
        这里使用 Spring 提供的 JDBC : org.springframework.jdbc.datasource
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?serverTimezone=Asia/Shanghai&amp;useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </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/sit/mapper/*.xml"/>
    </bean>

    <!--Spring 整合 Mybatis 方式1-->
    <!--SqlSessionTemplate : 就是 SqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--无set()方法，只能通过构造器注入-->
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>

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">

    <import resource="spring-dao.xml"/>

    <!--Spring 整合 Mybatis 方式1-->
    <bean id="userMapper" class="com.sit.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

</beans>

测试类 UserMapperTest.java

package com.sit.mapper;

import com.sit.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class UserMapperTest {
    @Test
    public void userMapperBySpring1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.queryUsers()) {
            System.out.println(user);
        }
    }
}

10.2 方式二

修改 UserService 的实现类

package com.sit.mapper;

import com.sit.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    /**
     * 查询用户
     *
     * @return 用户列表
     */
    public List<User> queryUsers() {
        return getSqlSession().getMapper(UserMapper.class).queryUsers();
    }
}

spring-dao.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"
	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
		https://www.springframework.org/schema/aop/spring-aop.xsd">
		
	<!--DataSource:使用Spring的数帮源替换Mybatis的配置 c3p0 dbcp druid 
		这使用Spring提供的JDBC: org.springframework.jdbc.datasource -->
	<!--data source -->
	<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName"
			value="com.mysql.cj.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=Asia/Shanghai"/>
		<property name="username" value="root" />
		<property name="password" value="root" />
	</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:mapper/*.xml"/>
    </bean>
    
	<!-- 方法二：SqlSessionTemplate 可以不写了-->
    
</beans>

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">

    <import resource="spring-dao.xml"/>

    <!--Spring 整合 Mybatis 方式2-->
    <bean id="userMapper2" class="com.sit.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
    
</beans>

测试

package com.sit.mapper;

import com.sit.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class UserMapperTest {
    @Test
    public void userMapperBySpring2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
        for (User user : userMapper.queryUsers()) {
            System.out.println(user);
        }
    }
}

11、声明式事务

事务的 ACID 特性：
- 原子性(Atomicity)
- 一致性(Consistency)
- 隔离性(Isolation)
- 持久性(Durability)

参考文章：https://www.cnblogs.com/malaikuangren/archive/2012/04/06/2434760.html

Spring 中的事务管理
- 声明式事务：AOP
- 编程式事务：需要在代码中进行事务管理
为什么需要声明式事务？
- 事务在项目的开发中非常重要，涉及到数据的一致性和完整性问题；
- 如果不配置事务，可能会存在数据提交不一致的情况；
- 如果不在 Spring 中配置声明式事务，就需要在代码中去手动配置事务。

声明式事务

导入 jar 包

<dependencies>
    <dependency>
        <!--JUnit-->
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.7.1</version>
    </dependency>
    <dependency>
        <!--mysql-->
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.21</version>
    </dependency>
    <dependency>
        <!--mybatis-->
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <!--Spring操作数据库-->
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>
</dependencies>

<!--解决资源导出失败的问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

实体类 User.java

package com.sit.pojo;

public class User {
    private int id;
    private String name;
    private String password;

    public User() {
    }

    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

    //省略属性的 get() 和 set() 方法

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

接口 UserMapper.java

package com.sit.mapper;

import com.sit.pojo.User;

import java.util.List;

public interface UserMapper {
    /**
     * 查询用户
     * @return 用户列表
     */
    List<User> queryUsers();

    /**
     * 添加一个用户
     * @param user 用户信息
     * @return 是否成功添加
     */
    int addUser(User user);

    /**
     * 删除一个用户
     * @param id 用户 id
     * @return 是否成功删除
     */
    int deleteUser(int id);
}

接口实现类 UserMapperImpl.java

package com.sit.mapper;

import com.sit.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

public class UserMapperImpl implements UserMapper {
    private SqlSessionTemplate sqlSession;

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

    /**
     * 查询用户
     *
     * @return 用户列表
     */
    public List<User> queryUsers() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User(8, "豆豆", "959893");

        addUser(user);
        deleteUser(8);

        return mapper.queryUsers();
    }

    /**
     * 添加一个用户
     *
     * @param user 用户信息
     * @return 是否成功添加
     */
    public int addUser(User user) {
        return sqlSession.getMapper(UserMapper.class).addUser(user);
    }

    /**
     * 删除一个用户
     *
     * @param id 用户 id
     * @return 是否成功删除
     */
    public int deleteUser(int id) {
        return sqlSession.getMapper(UserMapper.class).deleteUser(id);
    }
    
}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.sit.mapper.UserMapper">

    <select id="queryUsers" resultType="user">
        select * from mybatis.user
    </select>

    <insert id="addUser" parameterType="user">
        insert into mybatis.user values (#{id}, #{name}, #{password})
    </insert>

    <delete id="deleteUser" parameterType="_int">
        deleteDELETE from mybatis.user where id = #{id}
        <!-- deleteDELETE是故意写错的 -->
    </delete>
    
</mapper>

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- configuration -->
<configuration>
	
	<!--开启日志-->
	<settings>
		<setting name="logImpl" value="STDOUT_LOGGING" />
	</settings>
	
	<!--可以给实体类起别名-->
	<typeAliases> 
		<package name="com.sit.pojo" />
	</typeAliases>

</configuration>

spring-dao.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" xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx http://www.springframework.org/schema/beans/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/beans/spring-aop.xsd">

    <!--DataSource: 使用 Spring 的数据源替换 Mybatis 的配置  (c3p0、dbcp、druid、Spring JDBC等)
        这里使用 Spring 提供的 JDBC : org.springframework.jdbc.datasource
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?serverTimezone=Asia/Shanghai&amp;useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </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/sit/mapper/*.xml"/>
    </bean>

    <!--Spring 整合 Mybatis 方式1-->
    <!--SqlSessionTemplate : 就是 SqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--无set()方法，只能通过构造器注入-->
        <constructor-arg name="sqlSessionFactory" 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">
        <!--给哪些方法配置事务-->
        <tx:attributes>
            <!--配置事务的传播特性 propagation (默认为 REQUIRED)-->
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="query" read-only="true"/>
<!--            <tx:method name="*" propagation="REQUIRED"/>-->
        </tx:attributes>
    </tx:advice>
    <!--配置 AOP-->
    <aop:config>
        <aop:pointcut id="pointCut" expression="execution(* com.sit.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointCut"/>
    </aop:config>
    
</beans>

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">

    <import resource="spring-dao.xml"/>

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

</beans>

测试类

package com.sit.mapper;

import com.sit.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;


public class UserMapperTest {
    @Test
    public void userMapperBySpring() {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.queryUsers()) {
            System.out.println(user);
        }
    }
}

Vesuvius688

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring5笔记

本篇文章是观看B站UP主狂神说关于 Spring 讲解的视频，借鉴 Spring 官方文档以及CSDN博主夜里的雨相关文章整理的个人 Spring 笔记。因笔者能力有限，文章难免有错误之处，欢迎各位评论勘误，共同探讨！Spring5笔记1、Spring1.1 简介1.2 优点1.3 组成1.4 扩展1.5 弊端2、IOC 理论2.1 传统的调用2.2 改良（通过Set方法）2.3 IOC本质3、HelloSpring4、Spring 配置4.1 别名4.2 Bean 的配置4.3 import5、依赖注入
复制链接

扫一扫