Spring Framework

一、Spring

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。

dependencies：

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

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.8</version>
</dependency>

优点：

  • 开源免费的框架
  • 轻量级、非入侵式的框架
  • 控制反转（IOC），面向切面编程（AOP）
  • 支持事务的处理，框架的整合

二、IOC理论

​ inversion of control 控制反转

  • 采用依赖注入技术之后，A的代码只需要定义一个私有的B对象，不需要直接new来获得这个对象，而是通过相关的容器控制程序来将B对象在外部new出来并注入到A类里的引用中。而具体获取的方法、对象被获取时的状态由配置文件（如XML）来指定。

  • 可以把IoC模式看作工厂模式的升华，把IoC容器看作是一个大工厂，只不过这个大工厂里要生成的对象都是在XML文件中给出定义的。利用Java 的“反射”编程，根据XML中给出的类定义生成相应的对象。从实现来看，以前在工厂模式里写死了的对象，IoC模式改为配置XML文件，这就把工厂和要生成的对象两者隔离，极大提高了灵活性和可维护性。

  • IoC中最基本的Java技术就是“反射”编程。

三、HelloSpring

pojo:

package com.collapsar.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 + '\'' +
                '}';
    }
}

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="hello" class="com.collapsar.pojo.Hello">
         <property name="str" value="Spring"/>
    </bean>

</beans>

Test:

@Test
public void test(){
    //获取spring上下文对象
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    Hello hello = (Hello) context.getBean("hello");
    System.out.println(hello.toString());
}

四、IOC容器 创建对象的方式

1、默认使用无参构造创建对象

2、若要使用有参构造创建对象

​ 下标赋值：

 <bean id="user" class="com.collapsar.pojo.User">
         <constructor-arg index="0" value="kennyS"/>
</bean>

通过类型创建：（不推荐）

<bean id="user" class="com.collapsar.pojo.User">
    <constructor-arg type="java.lang.String" value="kennyS"/>
</bean>

直接通过参数名：

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

对象是在spring容器生成时产生的

五、Spring配置

5.1 别名

可以额外增加一个名称

<alias name="user" alias="xxxxxx"/>

5.2 Bean配置

id: bean的唯一标识，相当于实例化对象
class: bean对象所对应的全限定名
name: 别名，可以同时取多个

 <bean id="user" class="com.collapsar.pojo.User" name="u1 u2,u3">
       <property name="name" value="kennyS"/>
</bean>

5.3 import

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

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

</beans>

六、依赖注入

6.1 构造器注入

详见四ioc容器创建对象

6.2 Set方式注入（★）

  • 依赖注入：set注入

    • 环境：

    • package com.collapsar.pojo;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

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 wife;
    private Properties info;
    
    get、set、toString
        
}

    • beans:

    • <?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="student" class="com.collapsar.pojo.Student">
        <property name="name" value="Niko"/>
    </bean>

</beans>

注入：

<?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.collapsar.pojo.Address">
        <property name="address" value="ChengDu"/>
    </bean>
    <bean id="student" class="com.collapsar.pojo.Student">
        <property name="name" value="Niko"/>
        <property name="address" ref="address"/>
        <property name="books">
            <array>
                <value>java</value>
                <value>go</value>
                <value>python</value>
            </array>
        </property>
        <property name="hobbies">
            <list>
                <value>music</value>
                <value>basketball</value>
                <value>coding</value>
            </list>
        </property>
        <property name="card">
            <map>
                <entry key="身份证" value="897009391"/>
                <entry key="银行卡" value="1723748532"/>
            </map>
        </property>
        <property name="games">
            <set>
                <value>csgo</value>
                <value>lol</value>
                <value>wzry</value>
            </set>
        </property>
        <property name="wife">
            <null/>
        </property>
        <property name="info">
            <props>
                <prop key="id">2020131014</prop>
                <prop key="sex">male</prop>
            </props>
        </property>
    </bean>

</beans>

6.3 拓展方式

P 标签注入： (properties)

本质就是set注入

<bean id="student" class="com.collapsar.pojo.Student" P:name="Niko">

C标签注入：(constructor)

本质就是构造器注入

<bean id="student" class="com.collapsar.pojo.Student" C:name="Niko">

6.4 bean的作用域

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.

七、Bean的自动装配

  • 自动装配是spring满足bean依赖的一种方式
  • spring会在上下文中自动寻找，并自动给bean装配

spring中有三种装配方式：

  1. xml
  2. java
  3. 隐式自动装配 ★

环境：一个人有一狗一猫

原始bean：

<bean id="cat" class="com.collapsar.pojo.Cat"/>
<bean id="dog" class="com.collapsar.pojo.Dog"/>
    
<bean id="people" class="com.collapsar.pojo.People">
    <property name="cat" ref="cat"/>
    <property name="dog" ref="dog"/>
    <property name="name" value="kennyS"/>
</bean>

7.1 ByName

<bean id="people" class="com.collapsar.pojo.People" autowire="byName">
    <property name="name" value="kennyS"/>
</bean>

自动在容器上下文中查找和自己对象set方法后面值对应的beanid

7.2 ByType

<bean id="people" class="com.collapsar.pojo.People" autowire="byType">
    <property name="name" value="kennyS"/>
</bean>

自动在容器上下文中查找和自己对象属性类型相同的bean

7.3 使用注解自动装配

导入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: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方法了，前提是这个属性在ioc容器中存在，且符合bytype

@Nullable  //字段标记这个注解说明这个字段可以为null

@Autowired(required=false) //对象可以为空

若环境比较复杂，无法通过一个@Autowired完成，可以使用@Qualifier(value="")的方式来指定一个唯一的bean对象注入

@Resource

也可以用来自动装配，是通过byname实现，如果找不到名字则使用bytype

八、使用注解开发

spring 4 之后，要使用注解开发，必须要导入aop包

还有context约束：

<context:annotation-config/>

指定要扫描的包，注解生效

 <context:component-scan base-package="com.collapsar.poj"/>

属性的注入

//等价于 <bean id="user" class="com.collapsar.pojo.User">
//Component 组件
@Component
public class User {
    //相当于<property name="name" value="kennyS"/>
    @Value("kennyS")
    public String name;
}

衍生注解

@Component有几个衍生注解，按照mvc分层

  • dao 【@Repository】

  • service 【@Service】

  • controller【@Controller】

代表将其类注册到spring中，装配Bean

作用域

@Scope("singleton")

xml与注解区别：

  • xml使用于各个场合，维护简便
  • 注解不是自己类无法使用，维护相对复杂

最佳实践：

  • xml用来管理bean
  • 注解用来属性注入

九、使用Java的方式配置Spring

完全不使用spring xml配置，都由java写

User:

package com.collapsar.pojo;

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

@Component
public class User {

    @Value("kennyS")
    public String name;

    public String getName() {
        return name;
    }

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

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

config

package com.collapsar.config;

import com.collapsar.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class XConfig {

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

test

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(XConfig.class);
User user = (User) context.getBean("getUser");
System.out.println(user.name);

十、动态代理

  • 动态代理和静态代理角色一样
  • 代理类是动态生成的
  • 动态代理分为：基于接口的和基于类的
    • 基于接口：JDK动态代理
    • 基于类：cglib
    • java字节码实现：javassist

了解两个类：proxy和invocationHandler

host:

package com.collapsar.service;

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

ProxyInvocationHandler:

package com.collapsar.service;

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

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

    //被代理的接口
    private Rent rent;

    public void setRent(Rent rent){
        this.rent = rent;
    }
    //生成代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this);
    }
    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质就是使用反射机制实现
        Object result = method.invoke(rent, args);
        return result;
    }
}

client:

package com.collapsar.service;

public class Client {
    public static void main(String[] args){
        //真实角色
        Host host = new Host();
        //代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setRent(host);

        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();
    }
}

十一、AOP

11.1 AOP简介

AOP称为面向切面编程，在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限等待，Struts2的拦截器设计就是基于AOP的思想，是个比较经典的例子。

一 AOP的基本概念

(1)Aspect(切面):通常是一个类，里面可以定义切入点和通知

(2)JointPoint(连接点):程序执行过程中明确的点，一般是方法的调用

(3)Advice(通知):AOP在特定的切入点上执行的增强处理，有before,after,afterReturning,afterThrowing,around

(4)Pointcut(切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式

(5)AOP代理：AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类

二 Spring AOP

Spring中的AOP代理还是离不开Spring的IOC容器，代理的生成，管理及其依赖关系都是由IOC容器负责，Spring默认使用JDK动态代理，在需要代理类而不是代理接口的时候，Spring会自动切换为使用CGLIB代理，不过现在的项目都是面向接口编程，所以JDK动态代理相对来说用的还是多一些。

11.2 spring实现aop

先导入dependency org.aspectj aspectjweaver

  <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
            <scope>runtime</scope>
        </dependency>

execution(* com.sample.service.impl..*.*(..))

解释如下：

符号 含义
execution（） 表达式的主体
第一个” * “符号 表示返回值的类型任意
com.sample.service.impl AOP所切的服务的包名，即，我们的业务部分
包名后面的”..“ 表示当前包及子包
第二个” * “ 表示类名，*即所有类。此处可以自定义，下文有举例
.*(..) 表示任何方法名，括号表示参数，两个点表示任何参数类型

方式一：使用spring的api接口

log before:

package com.collapsar.service;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

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

userService

package com.collapsar.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 select() {
        System.out.println("查询用户");
    }
}

afterLog

package com.collapsar.service;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

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

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

    <bean id="userService" class="com.collapsar.service.UserServiceImpl"/>
    <bean id="log" class="com.collapsar.service.log"/>
    <bean id="afterLog" class="com.collapsar.service.AfterLog"/>
<!--配置aop：要导入aop约束-->
    <aop:config>
        <!--切入点： expression:表达式,execution(要执行的位置)-->
        <aop:pointcut id="pointcut" expression="execution(* com.collapsar.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>

    </aop:config>

</beans>

test

@Test
public void test(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    //动态代理的是接口！
    UserService userService = (UserService) context.getBean("userService");
    userService.add();
}

方式二：自定义实现aop

类：

package com.collapsar.service;

public class DiyPointcut {
    public void before(){
        System.out.println("方法执行前");
    }
    public void after(){
        System.out.println("方法执行后");
    }

}

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

    <bean id="userService" class="com.collapsar.service.UserServiceImpl"/>
    <bean id="log" class="com.collapsar.service.log"/>
    <bean id="afterLog" class="com.collapsar.service.AfterLog"/>

    <bean id="diy" class="com.collapsar.service.DiyPointcut"/>
    <aop:config>
        <aop:aspect ref="diy">
            <aop:pointcut id="point" expression="execution(* com.collapsar.service.UserServiceImpl.*(..))"/>
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

</beans>

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

    <bean id="userService" class="com.collapsar.service.UserServiceImpl"/>
    <bean id="log" class="com.collapsar.service.log"/>
    <bean id="afterLog" class="com.collapsar.service.AfterLog"/>

    <bean id="annotationPointcut" class="com.collapsar.service.AnnotationPointcut"/>
    <!--开启注解支持-->
    <aop:aspectj-autoproxy/>

</beans>

package com.collapsar.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AnnotationPointcut {
    @Before("execution(* com.collapsar.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("方法执行前");
    }
    @After("execution(* com.collapsar.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("方法执行后");
    }
    //在环绕增强中，我们可以给定一个参数，代表我们要处理切入的点
    @Around("execution(* com.collapsar.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable{
        System.out.println("环绕前");
        Signature signature = jp.getSignature();//获得签名
        System.out.println("signature:"+signature);
        //执行方法
        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }
}

十二、整合Mybatis

相关jar包：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.8</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.25</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.7</version>
</dependency>
<dependency>
    <groupId>springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>1.2.6</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.6</version>
</dependency>

12.1 Mybatis-Spring

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许 MyBatis 参与到 Spring 的事务管理之中，创建映射器 mapper 和 SqlSession 并注入到 bean 中，以及将 Mybatis 的异常转换为 Spring 的 DataAccessException。 最终，可以做到应用代码不依赖于 MyBatis，Spring 或 MyBatis-Spring。

12.2 方式一

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

    <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?Unicode=true &amp; characterEncoding=utf8 &amp; useSSL=true"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:Mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/collapsar/mapper/*.xml"/>
    </bean>
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" 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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
<import resource="spring-dao.xml"/>

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

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.collapsar.mapper.UserMapper">
<select id="selectUser" resultType="User">
    select * from mybatis.user
</select>
</mapper>

UserMapperImpl.java

package com.collapsar.mapper;

import com.collapsar.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;
    }

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

12.3 方式二

extends SqlSessionDaoSupport

UserMapperImpl2.java

package com.collapsar.mapper;

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

import java.util.List;

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

applicationContext.xml

(spring-dao.xml中不需要SqlSessionTemplate):

<bean id="userMapper2" class="com.collapsar.mapper.UserMapperImpl2">
  <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

十三、声明式事务

  • 原子性
    • 事务是数据库的逻辑工作单位,事务中包括的诸操作要么全做,要么全不做.
  • 一致性
    • 事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态.一致性与原子性是密切相关的.
  • 隔离性
    • 一个事务的执行不能被其他事务干扰.
  • 持久性
    • 一个事务一旦提交,它对数据库中数据的改变就应该是永久性的

声明式事务：AOP

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>
<!--配置切入-->
<aop:config>
    <aop:pointcut id="txPointcut" expression="execution(* com.collapsar.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
</aop:config>

编程式事务：代码中管理

public class UserService {
  private final PlatformTransactionManager transactionManager;
  public UserService(PlatformTransactionManager transactionManager) {
    this.transactionManager = transactionManager;
  }
  public void createUser() {
    TransactionStatus txStatus =
        transactionManager.getTransaction(new DefaultTransactionDefinition());
    try {
      userMapper.insertUser(user);
    } catch (Exception e) {
      transactionManager.rollback(txStatus);
      throw e;
    }
    transactionManager.commit(txStatus);
  }
}
posted @ 2021-07-24 23:16  Un1verse  阅读(104)  评论(0)    收藏  举报