Spring核心

一、核心基础

（一）基于XML的使用

　　1、Ioc配置

　　　　（1）Bean标签介绍

　　　　　　bean标签作用：用于配置被Spring容器管理的bean信息。默认情况下它调用的是类中的无参构造函数，如果没有无参构造，则不能创建。

　　　　　　bean标签属性：

　　　　（2）Bean标签的实例化方式

　　　　a、使用默认无参构造函数（推荐）

　　　　在默认情况下，他会根据默认的无参构造函数来创建对象，如果不存在无参对象，则创建失败。

<?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="userService" class="com.lcl.galaxy.spring.service.impl.UserServiceImpl"/>
</beans>

　　　　b、使用静态工厂创建

　　　　使用工厂类的静态方法创建一个对象，并将对象放入Spring容器中

package com.lcl.galaxy.spring.factory;

import com.lcl.galaxy.spring.service.UserService;
import com.lcl.galaxy.spring.service.impl.UserServiceImpl;

public class StaticFactory {
    public static UserService createUserService(){
        return new UserServiceImpl();
    }
}

    <bean id="userService2" class="com.lcl.galaxy.spring.factory.StaticFactory" factory-method="createUserService"/>

　　　　c、实例工厂（了解）

　　　　先将工厂类放入Spring容器中，然后再引用工厂Bean

package com.lcl.galaxy.spring.factory;

import com.lcl.galaxy.spring.service.UserService;
import com.lcl.galaxy.spring.service.impl.UserServiceImpl;

public class InstanceFactory {
    public UserService createUserService(){
        return new UserServiceImpl();
    }
}

    <bean id="instanceFactory" class="com.lcl.galaxy.spring.factory.InstanceFactory"/>
    <bean id="userService3" factory-bean="instanceFactory" factory-method="createUserService"/>

　　2、DI配置

　　　　DI是指Bean中的属性，依赖（属性）分为简单类型（String和8种基本类型）、对象类型、集合类型；

　　　　依赖注入是Spring IoC的具体实现；

　　　　（1）依赖注入

　　　　为什么要依赖注入：因为Bean对象的创建我们都交给了Spring创建，那么Bean对象种的指，也肯定是需要交给Spring来赋值的。

　　　　依赖注入的方式有两种：构造函数注入和set方法注入

　　　　a、构造函数注入

　　　　构造函数注入就是使用类的构造函数，给成员变量赋值，赋值是Spring直接进行的赋值。

package com.lcl.galaxy.spring.service.impl;

import com.lcl.galaxy.spring.domain.UserDo;
import com.lcl.galaxy.spring.service.UserService;

public class UserServiceImpl implements UserService {

    private String id;
    private String name;

    @Override
    public UserDo getUserById() {
        return UserDo.builder().id(this.id).name(this.name).build();
    }

    public UserServiceImpl(){
        this.id = "initId";
        this.name = "initName";
    }

    public UserServiceImpl(String id, String name){
        this.id = id;
        this.name = name;
    }

}

    <bean id="userService4" class="com.lcl.galaxy.spring.service.impl.UserServiceImpl">
        <constructor-arg name="id" value="1"/>
        <constructor-arg name="name" value="lcl"/>
    </bean>

　　　　从上面可以看到，给Service传值，类中必须要有构造函数，同时在bean标签中还需要设置constructor-arg标签，在constructor-arg标签中，有以下几个属性：

　　　　　　　　index：指定参数在构造函数中的索引位置

　　　　　　　　name：指定参数在构造函数中的名称

　　　　　　　　value：赋值操作，可以对简单类型赋值（简单类型：8中基本类型+String）

　　　　　　　　ref：赋值操作，可以配置在spring中已经配置的bean

　　　　b、set方法注入

　　　　　　set方法注入有手动的装配方式（Xml方式）和自动装配方式（注解方式：会用到@Autowired、@Resource、@Inject这些注解）

　　　　　　手动的装配方式，需要设置bean标签的property标签，同时需要在bean对象中有setter方法。

    <bean id="userService5" class="com.lcl.galaxy.spring.service.impl.UserServiceImpl">
        <property name="id" value="1"/>
        <property name="name" value="lcl"/>
    </bean>

　　　　（2）依赖注入不同类型

 　　　　　   a、简单类型

    <bean id="userService4" class="com.lcl.galaxy.spring.service.impl.UserServiceImpl">
        <constructor-arg name="id" value="1"/>
        <constructor-arg name="name" value="lcl"/>
    </bean>

　　　　　　b、引用类型

    <bean id="userDao" class="com.lcl.galaxy.spring.dao.UserDao"/>
    <bean id="userService6" class="com.lcl.galaxy.spring.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

　　　　　　c、集合类型-List

    <bean id="collectionDto" class="com.lcl.galaxy.spring.dto.CollectionDto">
        <property name="nameList">
            <list>
                <value>lcl</value>
                <value>qmm</value>
            </list>
        </property>
    </bean>

　　　　　　d、集合类型-Set

    <bean id="collectionDto2" class="com.lcl.galaxy.spring.dto.CollectionDto">
        <property name="nameList">
            <set>
                <value>lcl</value>
                <value>qmm</value>
            </set>
        </property>
    </bean>

　　　　　　e、集合类型-Map

    <bean id="collectionDto3" class="com.lcl.galaxy.spring.dto.CollectionDto">
        <property name="nameMap">
            <map>
                <entry key="lcl" value="18"/>
                <entry key="qmm" value="15"/>
            </map>
        </property>
    </bean>

　　　　　　f、集合类型-properties

    <bean id="collectionDto4" class="com.lcl.galaxy.spring.dto.CollectionDto">
        <property name="properties">
            <props>
                <prop key="lcl">21</prop>
                <prop key="qmm">18</prop>
            </props>
        </property>
    </bean>

（二）基于注解和XML的混合使用

　　　　这里使用注解和XML混合使用，主要是指的在XML文件中设置自动扫描，而在具体的bean中使用@Service等注解以便spring可以扫描到。

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

    <context:component-scan base-package="com.lcl.galaxy.spring"/>
</beans>

package com.lcl.galaxy.spring.service.impl;

import com.lcl.galaxy.spring.service.UserService2;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class UserServiceImpl2 implements UserService2 {

    public UserServiceImpl2(){
      log.info("无参构造被调用");
    }
}

　　　　那么具体有哪些注解可以被扫描到，清单如下所示：

 <bean id="" class=""/>

<property name="" value=""/>
<property name="" ref=""/>

<bean id="" class="" scope=""/>

   <bean id="" class="" init-method="" destroy-method=""/>

　　　　xml配置和注解配置的对比

（三）基于纯注解的使用

　　　　1、@Configuration

　　　　　　@Configuration是用来配置Bean的，对应的就是原来spring的xml配置文件，同样，在主函数中也是需要加载该配置类的

package com.lcl.galaxy.spring.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Configuration;

@Configuration
@Slf4j
public class SpringConfiguration {

    public SpringConfiguration(){
        log.info("spring容器启动");
    }
}

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);

　　　　对应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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.2.xsd">

</beans>

ApplicationContext factory2=new ClassPathXmlApplicationContext("classpath:spring-config2.xml");

　　　2、@Bean

　　　　Bean标签用来注册bean

    @Bean
    @Scope("singletion")
    public DefaultSqlSessionFactory getSqlSession(){
        return new DefaultSqlSessionFactory(new org.apache.ibatis.session.Configuration());
    }

　　　　对应XML编写

<bean id="userDao" class="com.lcl.galaxy.spring.dao.UserDao"/>

　　3、@CompenentScan

　　　　指定要扫描的包

@Configuration
@Slf4j
@ComponentScan(basePackages = "com.lcl.galaxy.spring")
public class SpringConfiguration {

    public SpringConfiguration(){
        log.info("spring容器启动");
    }

}

　　　　对应xml代码

    <context:component-scan base-package="com.lcl.galaxy.spring"/>

　　4、@PropertySource

　　加载properties文件的内容

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://******
jdbc.username=******
jdbc.password=******

package com.lcl.galaxy.spring.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;

@Configuration
@PropertySource("classpath:db.properties")
@Slf4j
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean(name = "dataSource")
    public DataSource createDataSource() throws Exception{
        DataSource dataSource = new ComboPooledDataSource();
        ((ComboPooledDataSource) dataSource).setDriverClass(driver);
        ((ComboPooledDataSource) dataSource).setJdbcUrl(url);
        ((ComboPooledDataSource) dataSource).setUser(username);
        ((ComboPooledDataSource) dataSource).setPassword(password);
        log.info("dabasource=============【{}】", dataSource);
        return dataSource;
    }
}

　　对应XML代码

    <context:property-placeholder location="classpath:db.properties"/>
    <bean id="dataSource2" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

　　5、@Import

　　　　导入其他Spring配置类

@Configuration
@Slf4j
@ComponentScan(basePackages = "com.lcl.galaxy.spring")
@Import(JdbcConfig.class)
public class SpringConfiguration {
}

　　　　Xml代码

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

二、核心高级

（一）AOP

　　1、相关术语

　　2、织入过程

　　　　对于AOP的织入过程，可以分为动态织入和静态织入。

　　　　其中，动态织入实在运行时动态的将要增强的代码织入到目标类中，这种一般基于动态代理来完成，例如JDK的动态代理（Proxy，通过反射实现）或者CGLIB动态代理（通过继承实现），其中，Spring Aop采用的就是基于运行时增强的动态代理技术

　　（1）静态代理：AspectJ

　　　　静态代理是在程序进行编译的时候进行的织入，这就需要一种特殊的程序编译器，例如acj编译器，他主要是先将增强的源代码编译成字节码文件（class文件），然后在编译目标对象时，将增强的字节码文件一起织入，生成最终增强后的字节码文件。

　　（2）动态代理

　　　　spring AOP是通过动态代理技术实现的，而动态代理又是通过反射实现的。动态代理有两种实现方式：基于接口的JDK动态代理和基于接口的CGLIB动态代理。

　　　　无论是基于什么的动态代理，都是在运行期，针对目标对象胜场Proxy代理对象，然后在代理对象中织入增强处理。

　　　a、JDK动态代理

    public static UserService getProxyByJdk(final UserService userService){
        //使用proxy类生成代理对象
        UserService proxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(),
                new InvocationHandler() {
                    //代理对象方法一执行，invoke方法就会执行一次
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if("save".equals(method.getName())){
                            log.info("=============记录日志==============");
                        }
                        //让service类的save方法正常的执行下去
                        return method.invoke(userService, args);
                    }
                });
        //返回代理对象
        return proxy;
    }

　　　　b、CGLIB

    public static UserService getProxyByCglib(){
        //创建CGLIB核心类
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(UserServiceImpl.class);
        //设置回调函数
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                if("save".equals(method.getName())){
                    log.info("=============记录日志==============");
                    log.info("=============开启事务==============");
                }
                log.info("=============提交事务志==============");
                return methodProxy.invokeSuper(o, objects)
            }
        });
        //生成代理对象
        UserService proxy = (UserService) enhancer.create();
        return proxy;
    }

（二）基于AspectJ的AOP使用

 　　　　基于AspectJ的AOP使用，其实就是Spring对于AspectJ的整合，不过Spring已经将AspectJ整合到自身的框架种了，并且底层织入仍然采用的是动态织入的方式。

　　　　1、准备代码

　　（1）添加依赖

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>

　　　　（2）编写目标类和目标方法

package com.lcl.galaxy.spring.aop;

public interface UserService {
    public void insert();

    public void insert(String id);

    public void insert(String id, String name);

    public void userInsert();
}

package com.lcl.galaxy.spring.aop.service;

import com.lcl.galaxy.spring.aop.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class UserServiceImpl implements UserService {

    @Override
    public void insert() {
        log.info("=========================insert======================");
    }

    @Override
    public void insert(String id) {
        log.info("=========================insert111======================");
    }

    @Override
    public void insert(String id, String name) {
        log.info("=========================insert2222======================");
    }

    @Override
    public void userInsert() {
        log.info("=========================userInsert======================");
    }
}

　　　　2、Xml实现

　　　　（1）编写通知

package com.lcl.galaxy.spring.aop.advice;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class MyAdvice {
    public void log(){
      log.info("===================打印日志===================");
    }
}

　　　　（2）配置通知、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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.2.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="com.lcl.galaxy.spring.aop"/>
    <bean name="myAdvice" class="com.lcl.galaxy.spring.aop.advice.MyAdvice"/>
    <aop:config>
        <aop:aspect ref="myAdvice">
            <aop:before method="log" pointcut="execution(public void com.lcl.galaxy.spring.aop.service.UserServiceImpl.insert())"/>
        </aop:aspect>
    </aop:config>

</beans>

　　　　切入点表达式：

　　　　　　execution([修饰符] 返回值类型 包名.类名.方法名(参数)) 　　

　　　　表达式说明：

　　　　对于不同的写法如下代码所示：

<aop:config>
        <aop:aspect ref="myAdvice">
            <!-- 详细写法 -->
            <!--   <aop:before method="log" pointcut="execution(public void com.lcl.galaxy.spring.aop.service.UserServiceImpl.insert())"/>  -->
            <!-- 省略execution写法-->
            <!-- <aop:before method="log" pointcut="execution(void com.lcl.galaxy.spring.aop.service.UserServiceImpl.insert())"/> -->
            <!-- 一层包名使用*写法 -->
            <!--<aop:before method="log" pointcut="execution(void com.lcl.galaxy.spring.aop.*.UserServiceImpl.insert())"/>-->
            <!-- 多层包名省略写法-->
            <!-- <aop:before method="log" pointcut="execution(void com.lcl.galaxy..insert())"/>-->
            <!-- 类名使用*写法-->
            <!-- <aop:before method="log" pointcut="execution(void com.lcl.galaxy.spring.aop.service.*Impl.insert())"/>-->
            <!-- 方法名使用*写法-->
            <!-- <aop:before method="log" pointcut="execution(void com.lcl.galaxy.spring.aop.service.*Impl.insert*())"/>-->
            <!-- 方法名使用*写法-->
            <!-- <aop:before method="log" pointcut="execution(void com.lcl.galaxy.spring.aop.service.*Impl.insert*())"/>-->
            <!-- 方法名使用*写法-->
            <aop:before method="log" pointcut="execution(void com.lcl.galaxy.spring.aop.service.UserServiceImpl.insert(..))"/>
        </aop:aspect>
    </aop:config>

　　　　通知类型

<aop:before method="" pointcut=""/> 

<aop:after-running method="" pointcut=""/>

<aop:after method="" pointcut=""/>

<aop:around method="" pointcut=""/>

<aop:after-throwing method="" pointcut=""/>

　　　　3、注解 + xml 实现

　　　　（1）通知代码

package com.lcl.galaxy.spring.aop.advice;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Slf4j
@Aspect
@Component("myAdviceAuto")
public class MyAdviceAuto {

    @Before(value = "execution(void *..*Impl.insert(..))")
    public void log(){
      log.info("===================打印日志===================");
    }
}

　　　　（2）配置文件

　　　　目标类仍然使用上面的目标类，但是需要在配置文件添加注解扫描和开启AOP自动代理

    <context:component-scan base-package="com.lcl.galaxy.spring.aop"/>
    <aop:aspectj-autoproxy/>

　　　　（3）对于环绕通知的写法

    @Around(value = "execution(* *..*Impl.*(..))")
    public String trans(ProceedingJoinPoint proceedingJoinPoint){
        Object[] args = proceedingJoinPoint.getArgs();
        String proceed = null;
        try {
            proceed = "返回结果" + (String) proceedingJoinPoint.proceed(args) ;
        } catch (Throwable throwable) {
            return "================异常";
        }
        return proceed;
    }

　　　　（4）定义通用切入点

　　　　通用切入点指的是，再通知内设置value时，不再设置具体的拦截方案，会调用一个通用的拦截方案。

　　　　在通用

    @Before(value = "MyAdviceAuto.fn()" )
    public void logfn(){
        log.info("=========================logfn=============================");
    }

    @Before(value = "MyAdviceAuto.fn()" )
    public void killfn(){
        log.info("=========================killfn=============================");
    }

    @Pointcut(value = "execution(* *..*.*(..))")
    public void fn(){
        log.info("===================fn()====================");
    }

　　　　4、纯注解方式

　　　　纯注解和注解+xml的区别仅在于需要使用注解替换在xml中配置的，直接在配置类上加上@EnableAspectJAutoProxy注解即可，其余的都一致。

　　　　那么 注解+xml 的方式在xml里面主要做了两件事，注解扫描和开启AOP自动代理

package com.lcl.galaxy.spring.demo.config;

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.defaults.DefaultSqlSessionFactory;
import org.springframework.context.annotation.*;

@Configuration
@Slf4j
@ComponentScan(basePackages = "com.lcl.galaxy.spring")
@Import(JdbcConfig.class)
@EnableAspectJAutoProxy
public class SpringConfiguration {

    public SpringConfiguration(){
        log.info("spring容器启动");
    }

    @Bean
    @Scope("singletion")
    public DefaultSqlSessionFactory getSqlSession(){
        return new DefaultSqlSessionFactory(new org.apache.ibatis.session.Configuration());
    }

}

三、组件支撑

（一）整合Junit

　　　　在测试类中，每一个测试类都要有加载xml文件的代码

@Slf4j
public class LclSpringTest {

    @Test
    public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring-config4.xml");
        UserService userService = (UserService) context.getBean("userServiceImpl");
        String name = userService.around("lcl");
        log.info("=============={}", name);
    }
}

　　　　可以看到上面的测试代码，在测试方法中需要加载spring配置文件，同时需要获取对应的Bean，但是如果有很多测试方法，那么每个方法都需要去写这两行代码。

　　　　好的一点是，Junit提供了RunWith注解用来让我们替换他的执行器，同时，Spring也提供了一个运行器，可以读取配置文件来创建容器，我们只需要告诉它配置文件的地址就OK。

　　　　那么主要就需要调整三个点：

　　　　　　（1）使用Junit的@RunWith注解，向注解内传入Spring的Junit执行器

　　　　　　（2）使用@ContextConfiguration注解加载配置文件或配置类

　　　　　　（3）使用@Autowired注解直接获取Bean

package com.lcl.galaxy.mybatis;

import com.lcl.galaxy.spring.aop.UserService;
import com.lcl.galaxy.spring.demo.config.SpringConfiguration;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration(locations = "classpath:spring-config4.xml")
@ContextConfiguration(classes = SpringConfiguration.class)
public class LclSpringTest2 {

    @Autowired
    private UserService userService;

    @Test
    public void test(){
        String name = userService.around("lcl");
        log.info("=============={}", name);
    }
}

（二）事务支持

　　1、事务相关特性介绍

　　（1）事务的特性（ACID）

　　（2）事务的并发问题

　　（3）事务隔离级别

　　　　四种隔离级别

　　　　大多数数据库的默认隔离级别是ReadCommitted，例如Oracle、DB2等

　　　　MySql的默认隔离级别是可重复读（Repeatable Read）

　　　　这里有一点需要注意：隔离级别越高，越能保证数据的完整性和一致性，但是对于并发性能影响也越大

　　（4）Spring事务管理接口

　　　　Spring并不是直接操作事务，而是提供事务管理接口PlatformTransactionManager，通过这个接口，Spring为各个平台（JDBC、Hibernate等）都提供了对应的事务管理器。

　　　　这里有几个接口需要介绍一下

　　　　上述几个接口的关系：平台事务管理器（PlatformTransactionManager）真正管理事务对象，根据事务定义信息（TransactionDefination）进行事务管理，在管理事务中产生一些状态，将状态等信息记录在事务状态（TransactionStatus）中。

　　　　对于TransactionDefinition中对于事务隔离级别和传播行为有以下几种定义

　　　　a、事务隔离级别常量

　　　　b、事务传播行为（默认值为PROPAGATION_REQUIRED）

　　2、Spring框架事务管理的分类

　　主要分为编程式事务管理和声明式事务管理，且声明式事务管理可以使用xml编写方式、xml+注解编写方式和纯注解使用方式。

　　（1）编程式事务管理

　　　　编程式事务管理主要是使用了TransactionTemplate模板类，通过该模板类进行事务处理。

　　　　首先编写业务逻辑层代码，在业务逻辑层代码中，调用TransactionTemplate的execute方法，在该方法内的所有操作，都是一个事务。

package com.lcl.galaxy.spring.transaction.service.impl;

import com.lcl.galaxy.spring.transaction.dao.OrderInfoDao;
import com.lcl.galaxy.spring.transaction.dao.UserDao;
import com.lcl.galaxy.spring.transaction.domain.OrderInfoDo;
import com.lcl.galaxy.spring.transaction.service.UserService;
import com.lcl.galaxy.spring.transaction.domain.UserDo;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

@Slf4j
@Data
public class UserServiceImpl implements UserService {


    @Autowired
    private TransactionTemplate transactionTemplate;

    @Autowired
    private UserDao userDao;
    @Autowired
    private OrderInfoDao orderInfoDao;


    @Override
    public void transactionTest(UserDo userDo, OrderInfoDo orderInfoDo) {
        log.info("事务处理");
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
                log.info("=======================");
                userDao.insert(userDo);
                orderInfoDao.insert(orderInfoDo);
            }
        });
        log.info("事务结束");
    }
}

　　然后是对TransactionTemplate的配置

<?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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.2.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="****"></property>
        <property name="user" value="******"></property>
        <property name="password" value="5H5eLQsp6yO4"></property>
    </bean>

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

    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="transactionManager"/>
    </bean>

    <bean id="userDao" class="com.lcl.galaxy.spring.transaction.dao.impl.UserDaoImpl"/>
    <bean id="orderInfoDao" class="com.lcl.galaxy.spring.transaction.dao.impl.OrderInfoDaoImpl"/>

    <bean id="userService" class="com.lcl.galaxy.spring.transaction.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
        <property name="orderInfoDao" ref="orderInfoDao"/>
        <property name="transactionTemplate" ref="transactionTemplate"/>
    </bean>

</beans>

　　　　（2）声明式事务--xml实现方式

　　　　使用xml的方式实现声明式事务，主要需要做的就是使用AOP的配置，将事务增强到切面方法上。

    <aop:config>
        <aop:advisor advice-ref="txadvice" pointcut="execution(* *..*.save(..))"/>
    </aop:config>

　　　　对于事务增强，又需要事务管理器来处理

    <tx:advice id="txadvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*"/>
            <tx:method name="find*" read-only="true"/>
        </tx:attributes>
    </tx:advice>

　　　　事务管理器又需要DataSource数据源

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="*****"></property>
        <property name="user" value="******"></property>
        <property name="password" value="******"></property>
    </bean>

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

　　　　配置Service类

    <bean id="userService2" class="com.lcl.galaxy.spring.transaction.service.impl.UserService2Impl"/>

　　　　最后测试代码

package com.lcl.galaxy.spring;

@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-transaction-xml-config.xml")
public class LclSpringTransactionTest {


    @Autowired
    private UserService2 userService2;

    @Test
    public void test2(){
        UserDo userDo = UserDo.builder().address("beijing").username("lcl111").sex("男").build();
        OrderInfoDo orderInfoDo = OrderInfoDo.builder().orderId("1111").name("lcl").payMoney(new BigDecimal(String.valueOf("1.01"))).build();
        log.info("测试启动");
        userService2.saveInfo(userDo, orderInfoDo);
        log.info("测试完成");
    }
}

　　　　（3）声明式事务--注解 + xml实现方式

　　　　使用注解+xml实现声明式事务和纯xml实现声明式事务的主要差别就是我们不需要在xml里面配置事务增强和AOP配置，以及Bean的配置，但是仍然要配置dataSource和TransactionManager。同时需要配置 tx:annotation-driven 标签来开启事务注解

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="******"></property>
        <property name="user" value="******"></property>
        <property name="password" value="******"></property>
    </bean>


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

    <tx:annotation-driven transaction-manager="transactionManager"/>

    <context:component-scan base-package="com.lcl.galaxy.spring.transaction"/>

　　　　在使用事务时，使用@Transaction注解来处理，该注解可以使用在类上也可以使用在方法上

package com.lcl.galaxy.spring.transaction.service.impl;


@Slf4j
@Data
@Service
public class UserService3Impl implements UserService3 {

    @Transactional
    @Override
    public void saveInfo(UserDo userDo, OrderInfoDo orderInfoDo) {
        log.info("==================");
    }
}

　　　　（4）声明式事务--纯注解实现方式

　　　　纯注解的实现方式，在xml中只需要配置DataSource，然后在主类上使用@EnableTransactionManagement注解即可。

@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-transaction-xml-auto2-config.xml")
@EnableTransactionManagement
public class LclSpringAutoTransactionTest2 {

    @Autowired
    private UserService3 userService3;

    @Test
    public void test(){
        UserDo userDo = UserDo.builder().address("beijing").username("lcl111").sex("男").build();
        OrderInfoDo orderInfoDo = OrderInfoDo.builder().orderId("1111").name("lcl").payMoney(new BigDecimal(String.valueOf("1.01"))).build();
        log.info("测试启动");
        userService3.saveInfo(userDo, orderInfoDo);
        log.info("测试完成");
    }
}

标签：事务,spring,Spring,import,lcl,public,注解,核心
来源： https://www.cnblogs.com/liconglong/p/14100429.html