深入浅出Spring

reading: 2021-05-05

Spring词义春天，意图给开发行业带来春天，它小巧且功能强大，提供了IoC控制反转与AOP等功能。现如今，Java开发又被戏称为Spring开发。

1、Spring

1.1、Spring资源

官网：https://spring.io/

中文文档：https://www.docs4dev.com/docs/zh/spring-framework/5.1.3.RELEASE/reference

github：https://github.com/spring-projects

maven:

<!--在maven中导入webmvc会自动导入Spring其他依赖-->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.6</version>
</dependency>

Spring学习路线：Spring Framework->Spring Mvc->Spring Boot->Spring Cloud

1.2、Spring介绍

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

1.3、Spring模块

Spring由七大模块组成（图片来源于官网）

2、IoC对象创建

2.1、IoC理论

IoC（Inversion of Control）：控制反转。

DI（Dependency Injection）：依赖注入，DI是IoC的一种实现。

IoC主要解决类之间的互相依赖导致的紧耦合。在面向对象程序设计中，随着功能的增添，程序越发庞大，对象与对象之间的依赖也越来越复杂，常常改一个地方，其他处也会随之出现问题。

注：图片来源于官网。

配置方式：

xml：最传统的方式
注释：Spring2.5之后
Java：Spring3.0之后

控制：谁来创建对象，传统应用程序的对象由程序本身创建，在Spring中，对象由Spring通过反射创建。

反转：程序本身不创建对象，变为被动接受对象。

依赖注入：使用Bean的set方法进行注入。

2.2、无参构造

Spring文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="hello" class="com.jiuzhao73.pojo.Hello">
        <property name="val" value="Hello,Spring!"/>
    </bean>
</beans>

在xml文件中，id相当于对象名，class全限定类名，property属性

1	ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

使用ClassPathXmlApplicationContext加载IoC容器。

一个IoC容器持有一个或多个bean。

2.3、有参构造

Spring对于有偿构造主要使用“constructor-arg”标签实现。

1、index

<!--使用下标传递参数-->
<bean id="indexHello" class="com.jiuzhao73.pojo.Hello">
    <constructor-arg index="0" value="index"/>
</bean>

index从0开始，依次对构造函数依次赋值。

2、type

<!--使用类型全名传递参数-->
<bean id="typeHello" class="com.jiuzhao73.pojo.Hello">
    <constructor-arg type="java.lang.String" value="type"/>
</bean>

type使用类型的全限定名进行赋值，例，当重载构造方法时，构造方法的参数名相同类型不同，type可以很好的解决传参问题。

3、name

<!--使用参数名称进行传参-->
<bean id="nameHello" class="com.jiuzhao73.pojo.Hello">
    <constructor-arg name="val" value="name"/>
</bean>

在构造方法中，构造方法没有重载，或构造方法的参数没有重名时使用。

2.4、重点

IoC容器在加载完成xml文件，对象在这时创建完成，在之后获取的对象都是同一对象，不需要重新创建。

3、Spring配置

3.1、alias别名

1 2	<!--别名--> <alias name="hello" alias="h"/>

起别名之后俩个名称都可以获取到对象。

3.2、bean配置

1	<bean id="setHello" class="com.jiuzhao73.pojo.Hello" name="sh,sHello"/>

id相当于对象名。
class类名。
name相当于别名，别名可以使用多个，用”,”或” “间隔。

3.3、import导入

import一般用于团队开发，他可以将多个配置文件合并，最后只需要读取这个文件就可以获取所有对象。

1
2
3

<!--导入-->
<import resource="dal.xml"/>
<import resource="bll.xml"/>

4、DI依赖注入

4.1、构造器注入

见IcO对象创建。

4.2、Set注入

注入类型：

1	bean \| ref \| idref \| list \| set \| map \| props \| value \| null

依赖注入：Set注入

依赖：bean对象的创建依赖于容器

注入：bean对象中的所有属性，由容器来注入

例子：

Teacher类：

public class Teacher {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
}

Student类：

public class Student {
    private String name;
    private Teacher teacher;
    private String[] books;
    private List<String> hobbies;
    private Map<String, Integer> result;
    private Set<String> games;
    private Student friends;
    private Properties info;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
    public String[] getBooks() {
        return books;
    }
    public void setBooks(String[] books) {
        this.books = books;
    }
    public List<String> getHobbies() {
        return hobbies;
    }
    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }
    public Map<String, Integer> getResult() {
        return result;
    }
    public void setResult(Map<String, Integer> result) {
        this.result = result;
    }
    public Set<String> getGames() {
        return games;
    }
    public void setGames(Set<String> games) {
        this.games = games;
    }
    public Student getFriends() {
        return friends;
    }
    public void setFriends(Student friends) {
        this.friends = friends;
    }
    public Properties getInfo() {
        return info;
    }
    public void setInfo(Properties info) {
        this.info = info;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", teacher=" + teacher +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", result=" + result +
                ", games=" + games +
                ", friends=" + friends +
                ", info=" + info +
                '}';
    }
}

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="teacher" class="com.jiuzhao73.pojo.Teacher">
        <property name="name" value="allPeople"/>
    </bean>
    <bean id="student" class="com.jiuzhao73.pojo.Student">
        <!--value注入-->
        <property name="name" value="久曌"/>
        <!--bean注入-->
        <property name="teacher" ref="teacher"/>
        <!--空注入-->
        <property name="friends">
            <null/>
        </property>
        <!--数组注入-->
        <property name="books">
            <array value-type="java.lang.String">
                <value>《Java编程思想》</value>
                <value>《算法导论》</value>
            </array>
        </property>
        <!--list注入-->
        <property name="hobbies">
            <list value-type="java.lang.String">
                <value>运动</value>
                <value>阅读</value>
            </list>
        </property>
        <!--set注入-->
        <property name="games">
            <set value-type="java.lang.String">
                <value>植物大战僵尸</value>
            </set>
        </property>
        <!--map注入-->
        <property name="result">
            <map key-type="java.lang.String" value-type="java.lang.Integer">
                <entry key="高数" value="70"/>
                <entry key="java" value="90"/>
                <entry key="数据结构" value="73"/>
            </map>
        </property>
        <!--properties注入-->
        <property name="info">
            <props>
                <prop key="phone">12345678989</prop>
                <prop key="id">1231</prop>
                <prop key="mail">2312312@qq.com</prop>
            </props>
        </property>
    </bean>
</beans>

测试：

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

结果：

4.3、扩展方式注入

其他注入方式：

c命名空间：使用构造器赋值
p命名空间：使用set注入

导入约束：

<!--p命名空间-->
xmlns:p="http://www.springframework.org/schema/p"
<!--c命名空间-->
xmlns:c="http://www.springframework.org/schema/c"

<!--c命名空间,使用构造函数-->
<bean id="root" class="com.jiuzhao73.pojo.User" c:name="root" c:pwd="123456"/>
<!--p命名空间,使用set注入-->
<bean id="jiuzhao" class="com.jiuzhao73.pojo.User" p:name="jiuzhao" p:pwd="123"/>

4.4、作用域

1、singleton（单例模式）

bean对象的默认作用域为单例，但是也可以显示设置。如：

1	<bean id="jiuzhao" class="com.jiuzhao73.pojo.User" scope="singleton"/>

2、prototype（原型模式）

1	<bean id="jiuzhao" class="com.jiuzhao73.pojo.User" scope="prototype"/>

3、其他作用域

在web开发时使用：

request
session
application
websocket

5、bean的自动装配

5.1、自动装配

自动装配（autowire），即不需要手动注入，由Spring自动识别，注入属性对象等。

自动装配设置：在bean标签中的autowire属性

5.2、byName

<bean id="pants" class="com.jiuzhao73.pojo.Pants">
    <property name="name" value="SportsPants"/>
</bean>
<bean id="clothes" class="com.jiuzhao73.pojo.Clothes" p:name="t-shirt"/>
<bean id="root" class="com.jiuzhao73.pojo.People" autowire="byName">
    <property name="name" value="root"/>
</bean>

byName会匹配对象名与set注入的名称一致的对象，进行自动装配，存在对象名不标准注入失败问题。

5.3、byType

1
2
3

<bean id="root" class="com.jiuzhao73.pojo.People" autowire="byType">
    <property name="name" value="root"/>
</bean>

byType需要属性类型一致，进行自动装配，存在单个bean文件类型只能出现一次问题。

5.4、注解装配

注释与xml孰优孰劣：

The short answer is “it depends.” The long answer is that each approach has its pros and cons, and, usually, it is up to the developer to decide which strategy suits them better.

官网大意：视情况而定。

注释更短、更简洁，xml擅长链接组件。

步骤：

导入注解约束：

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

注解支持：

1	<context:annotation-config/>

@Autowire

@Autowired
private Clothes clothes;
@Autowired
private Pants pants;

@Autowire在属性上使用，标记自动装配，使用注解甚至不需要拥有set方法（使用反射），原理是byName与byType的整合（先对bean类型进行匹配，若有多个匹配的类型，在使用名称匹配）。

@Nullable注释给参数使用，不报空指针异常。

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

@Autowired(required = [false|true])：true默认，不允许为空；当为false时，标志该属性可为空。

@Qualifier(value = “”)指定自动装配的名称

1
2
3

@Autowired
@Qualifier(value = "pants1")
private Pants pants;

@Resource（java原生注解）

@Target({TYPE, FIELD, METHOD})
@Retention(RUNTIME)
public @interface Resource {
    String name() default "";
    String lookup() default "";
    Class<?> type() default java.lang.Object.class;
    enum AuthenticationType {
            CONTAINER,
            APPLICATION
    }
    AuthenticationType authenticationType() default AuthenticationType.CONTAINER;
    boolean shareable() default true;
    String mappedName() default "";
    String description() default "";
}

6、Annotation开发

6.1、开启注解开发

注意：在Spring4之后，注解需导入spring-aop包。

<?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-->
<!--开启注解-->
<context:annotation-config/>
<!--扫描注解-->
<context:component-scan base-package="com.jiuzhao73"/>

6.2、@Component类

@Component

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {
    String value() default "";
}

在web开发中，经常使用mvc三层架构进行分层，从而诞生出了与之对映的三个的衍生注解：

dao层：@Repository
service层：@Service
controller层：@Controller

四个注解功能基本一致。

6.3、@Value属性

@Value:

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Value {
    String value();
}

6.4、@Scope作用域

1	@Scope("singleton")

singleton
prototype
request
session
application
websocket

6.5、自动装配

注解自动装配

6.6、示例

使用：

@Component
public class User {
    @Value("root")
    private String name;
    //@Value("root")
    public void setName(String name) {
        this.name = name;
    }
}

使用@Component默认对象名为类名小写，更换对象名可对参数value赋值。

@Value负责给属性赋值。当@Value用在方法上时，相当于传递一个值给这个方法，不需要固定set名称。例：

//@Value("root")
public void sdfsdf(String name) {
    this.name = name;
}

也可以赋值成功！

关于xml与注解较好的使用方式：使用@Value进行属性注入，在xml对对象进行管理。

6.7、@ComponentScan扫描

@Configuration
@ComponentScan(value = "com.jiuzhao73.pojo",
        excludeFilters = @ComponentScan.Filter(),
        includeFilters =@ComponentScan.Filter())
public class JavaConfig {}

scan过滤器：

@Retention(RetentionPolicy.RUNTIME)
@Target({})
public @interface Filter {
    FilterType type() default FilterType.ANNOTATION;
    @AliasFor("classes")
    Class<?>[] value() default {};
    @AliasFor("value")
    Class<?>[] classes() default {};
    String[] pattern() default {};
}

excludeFilters，includeFilters过滤器

关闭过滤器：useDefaultFilters=false

6.8、@Import导入

@Import注释：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {
    Class<?>[] value();
}

7、基于Java配置

官网：

The central artifacts in Spring’s new Java-configuration support are @Configuration-annotated classes and @Bean-annotated methods.

7.1、@Configuration

源码：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";

    boolean proxyBeanMethods() default true;
}

@Configuration是一个用于类的@Component注释，由Spring容器托管，其主要目的是作为Bean定义的来源。

7.2、@Bean

源码：

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Bean {
    @AliasFor("name")
    String[] value() default {};
    @AliasFor("value")
    String[] name() default {};
    /** @deprecated */
    @Deprecated
    Autowire autowire() default Autowire.NO;
    boolean autowireCandidate() default true;
    String initMethod() default "";
    String destroyMethod() default "(inferred)";
}

@Bean主要用于方法，可设置名称（name与value基本等价），做创建作用。

7.3、AnnotationConfigApplicationContext

示例：

创建bean类

@Component
public class User {
    @Value("1")
    private int id;
    @Value("123456")
    private String pwd;
}

创建Config类

@Configuration
public class JavaConfig {
    @Bean
    public User getUser(){
        return new User();
    }
}

AnnotationConfigApplicationContext创建IoC容器

public void test(){
    ApplicationContext context=new AnnotationConfigApplicationContext(JavaConfig.class);
    User user = context.getBean("getUser", User.class);
    System.out.println(user);
}

完全不使用xml文件，AnnotationConfigApplicationContext便可构建IoC容器。

AnnotationConfigApplicationContext也可以接受普通的@Component类和使用JSR-330元数据注释的类。

7.4、扫描scan(String…)

AnnotationConfigApplicationContext.scan(String…)方法会扫描一个包，加载@Component类。

@Test
public void test(){
    AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext();
    context.scan("com.jiuzhao73.pojo");
    context.refresh();
    User user = context.getBean("user", User.class);
}

或者

在JavaConfig使用注解，扫描：

1
2
3

@Configuration
@ComponentScan("com.jiuzhao73.pojo")
public class JavaConfig {}

8、Proxy代理模式

代理模式，为其他对象提供一种代理以控制对这个对象的访问。

通俗的来讲，就是对俩个直接通讯的类进行解耦，使其依靠于第三方执行。

1、静态代理

由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。

2、动态代理

Java的动态代理比代理的思想更进一步，它可以动态地创建代理并动态处理对所代理方法的调用。

API文档：

每一个动态代理类都必须要实现InvocationHandler接口，并且每个代理类的实例都关联一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发由InvocationHandler这个接口的invoke()方法进行调用。

public interface InvocationHandler {
    /**
    args：调用真实对象某个方法时接受的参数。
	proxy：指我们做代理的那个真实对象。
	method：指代的是我们所要调用真实对象的某个方法的Method对象。
    */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

public class Proxy implements java.io.Serializable {
    ...
   	/**
   	loader（类加载器）:类加载器，需要代理对象和目标对象指定为同一加载器。
   	interfaces:代理实现的接口列表。
    h:一个InvocationHandler对象，代理对象关联哪一个。
    */
    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h) 
        throws IllegalArgumentException{}
	...
}

9、AOP

9.1、什么是AOP

Aspect Oriented Programming(面向切面编程)，平时oop开发是纵向开发，aop是横向开发，也可以叫做事件开发。

SpringAOP术语：

Aspect(切面 ): 横切关注点被模块化的特殊对象。
横切关注点：跨越应用程序多个模块的方法或功能。
Join point(连接点):与切入点匹配的执行点。
Advice(通知):切面必须完成的工作。即类的一个方法。
Pointcut(切入点):切面通知执行的地点的定义。
Target object(目标对象): 被通知（切面）的对象（目标对象）。

插入位置:

Before advice(前置通知)
After returning advice(返回通知)
After throwing advice(异常抛出通知)
After (finally) advice(后置通知)
Around advice(环绕通知)

Spring4.0
　　　　正常情况：环绕前置=====@Before======目标方法执行=====环绕返回=====环绕最终=====@After=====@AfterReturning
　　　　异常情况：环绕前置=====@Before======目标方法执行=====环绕异常=====环绕最终=====@After=====@AfterThrowing
Spring5.28
　　　　正常情况：环绕前置=====@Before=====目标方法执行=====@AfterReturning=====@After=====环绕返回=====环绕最终
　　　　异常情况：环绕前置=====@Before=====目标方法执行=====@AfterThrowing=====@After=====环绕异常=====环绕最终

9.2、Spring中AOP实现

maven：

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

1、SpringAPI

实现接口：

public interface AfterReturningAdvice extends AfterAdvice {
	void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;
}
public interface MethodBeforeAdvice extends BeforeAdvice {
	void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
}

依赖导入：

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"

配置aop：

<bean id="log" class="com.jiuzhao73.demo1.pojo.Log"/>
<bean id="returnSell" class="com.jiuzhao73.demo1.pojo.ReturnSell"/>
<bean id="seller" class="com.jiuzhao73.demo1.pojo.TicketSeller"/>
<aop:config>
    <aop:pointcut id="sellCut" expression="execution(* com.jiuzhao73.demo1.pojo.Sell.* (..))"/>
   	<aop:advisor advice-ref="returnSell" pointcut-ref="sellCut"/>
    <aop:advisor advice-ref="log" pointcut-ref="sellCut"/>
</aop:config>

JavaAPI:

AroundAdvice

1
2
3

public interface MethodInterceptor extends Interceptor {
    Object invoke(MethodInvocation invocation) throws Throwable;
}

MethodBeforeAdvice

1
2
3

public interface MethodBeforeAdvice extends BeforeAdvice {
    void before(Method m, Object[] args, Object target) throws Throwable;
}

实现接口的before()方法，在方法之后调用。

AfterReturningAdvice

1
2
3

public interface AfterReturningAdvice extends Advice {
    void afterReturning(Object returnValue, Method m, Object[] args, Object target) throws Throwable;
}

IntroductionInterceptor

1
2
3

public interface IntroductionInterceptor extends MethodInterceptor {
    boolean implementsInterface(Class intf);
}

ThrowsAdvice

是个标签，在连接点抛出异常后调用引发通知。

1	afterThrowing([Method, args, target], subclassOfThrowable)

例：

public class RemoteThrowsAdvice implements ThrowsAdvice {
    public void afterThrowing(RemoteException ex) throws Throwable {
        // Do something with remote exception
    }
}

2、标签实现

<bean id="aop" class="com.jiuzhao73.demo1.pojo.Aop"/>
<aop:config>
    <aop:aspect ref="aop">
        <aop:pointcut id="sell" expression="execution(* com.jiuzhao73.demo1.pojo.Sell.*(..))"/>
        <aop:after pointcut-ref="sell" method="after"/>
        <aop:before pointcut-ref="sell" method="before"/>
    </aop:aspect>
</aop:config>

3、Annotation实现

在Spring中使用注解实现aop需开启注解自动代理，并注入被搜索类。

<!--开启注解自动代理-->
<aop:aspectj-autoproxy/>
<!--注入搜索类-->
<bean id="annotation" class="com.jiuzhao73.demo1.pojo.AopAnnotation"/>

使用@Aspect注解

@Aspect
public class AopAnnotation {
    @Before("execution(* com.jiuzhao73.demo1.pojo.Sell.*(..))")
    public void before(){
        System.out.println("before");
    }
    @After("execution(* com.jiuzhao73.demo1.pojo.Sell.*(..))")
    public void after(){
        System.out.println("after");
    }
}

4、execution表达式

execution(<修饰符模式>?<返回类型模式><方法名模式>(<参数模式>)<异常模式>?)

除了返回类型模式，方法名模式和参数模式外，其它项都是可选的。

例：

1	execution(* com.jiuzhao73.demo1.pojo.Sell.*(..))

‘’*’’——>通配符（可能表示任意返回类型，某个包下的任意类，或任意包等等）

“..”——>表示任何参数类型

10、MyBatis-Spring

10.1、MyBatis与MyBatis-Spring

官网：http://mybatis.org/spring/zh/sqlsession.html

MyBatis框架：

Spring-MyBatis:

10.2、SqlSession

1、SqlSessionTemplate

DataSouce->SqlSessionFactoryBean->SqlSessionTemplate->mapper:

<!--javax.sql.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/test?serverTimezone=UTC&amp;useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=true"/>
    <property name="username" value="root"/>
    <property name="password" value="XXXXXX"/>
</bean>
<!--SqlSessionFactoryBean等同与SqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="configLocation" value="classpath:myBatis-config.xml"/>
</bean>
<!--SqlSessionTemplate等同于SqlSession-->
<bean id="template" class="org.mybatis.spring.SqlSessionTemplate">
    <constructor-arg ref="sqlSessionFactory"/>
</bean>
<!--UserMapperImpl使用SqlSession执行sql语句-->
<bean id="mapper" class="com.jiuzhao73.dao.UserMapperImpl">
    <property name="sessionTemplate" ref="template"/>
</bean>

UserMapperImpl类:

public class UserMapperImpl implements UserMapper {
    private SqlSessionTemplate sessionTemplate;
    public void setSessionTemplate(SqlSessionTemplate sessionTemplate) {
        this.sessionTemplate = sessionTemplate;
    }
    @Override
    public List<User> select() {
        return sessionTemplate.getMapper(UserMapper.class).select();
    }
}

2、SqlSessionDaoSupport

DataSouce->SqlSessionFactoryBean->UserMapperImpl2（SqlSessionDaoSupport子类）:

<!--前面两步与SqlSessionTemplate相同-->
<bean id="mapper2" class="com.jiuzhao73.dao.UserMapperImpl2">
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

UserMapperImpl2类:

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    @Override
    public List<User> select() {
        return getSqlSession().getMapper(UserMapper.class).select();
    }
}

SqlSessionDaoSupport类实现了getSqlSession()方法，因此我们可以很轻松的获取SqlSession不需要去设置属性。

10.3、事务

1、标准配置

开启 Spring 的事务处理功能，在 Spring 的配置文件中创建一个 DataSourceTransactionManager 对象:

1
2
3

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <constructor-arg ref="dataSource" />
</bean>

Mybatis本身也有的两套事务管理器(type=”[JDBC|MANAGED]”)，在使用Spring时我们则没有必要配置Mybatis的事务管理器。

2、声明式事务

导入tx:

1
2
3

xmlns:tx="http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx
https://www.springframework.org/schema/tx/spring-tx.xsd

在拥有DataSourceTransactionManager对象后，创建事务通知interceptor，对需要开启事务的方法设定为切入点，interceptor做为通知。

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <constructor-arg ref="dataSource" />
</bean>
<tx:advice id="interceptor" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="select" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>
<aop:config>
    <aop:pointcut id="txPointcut" expression="execution(* com.jiuzhao73.dao.*(..))"/>
    <aop:advisor advice-ref="interceptor" pointcut-ref="txPointcut"/>
</aop:config>

参考文献

尽管这不是一个详尽的清单，但还是希望对大家有所启示。

[1]Rod Johnson, Juergen Hoeller, Keith Donald, Colin Sampaleanu, Rob Harrop, Thomas Risberg, Alef Arendsen, Darren Davison, Dmitriy Kopylenko, Mark Pollack, Thierry Templier, Erwin Vervaet, Portia Tung, Ben Hale, Adrian Colyer, John Lewis, Costin Leau, Mark Fisher, Sam Brannen, Ramnivas Laddad, Arjen Poutsma, Chris Beams, Tareq Abedrabbo, Andy Clement, Dave Syer, Oliver Gierke, Rossen Stoyanchev, Phillip Webb, Rob Winch, Brian Clozel, Stephane Nicoll, Sebastien Deleuze, Jay Bryant, Mark Paluch.Spring官网文档[EB/OL]:2021