Spring使用

一、核心基础

（一）基于XML的使用

　　1、Ioc配置

　　　　（1）Bean标签介绍

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

　　　　　　bean标签属性：

标签	描述
id	给对象在容器中提供一个唯一的标识，用于获取对象。
class	指定类的全限定名。用于反射创建对象。默认下调用无参构造
init-method	指定类中的初始化方法名称
destory-method	指定类中的销毁方法，比如DataSource的配置中，一般需要配置destory-method="close"
scope	指定对象的作用范围： 　　（1）singleton：默认值，单例，生命周期： 　　　　　　a、创建：当应用加载，创建容器时，对象就被创建 　　　　　　b、存活：只要容器存在，一直存货 　　　　　　c、死亡：当应用卸载，容器销毁时，对象就被销毁 　　（2）prototype：多例，每次访问对象时，都会重新创建对象实例。生命周期如下： 　　　　　　a、创建：访问对象时 　　　　　　b、存活：只要对象还在使用 　　　　　　c、死亡：当对象长时间不使用，被垃圾回收器回收 　　（3）request：将Spring创建的Bean对象存入到request中 　　（4）session：将Spring创建的Bean对象存入Session中 　　（5）global session：全局Session

　　　　（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("无参构造被调用");
    }
}

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

分类	注解	作用	属性
Ioc注解 相当于： <bean id="" class=""/>	@Component	让spring来管理资源，相当于对xml中配置的一个bean	指定bean的id，如果不指定，默认bean的id是当前类名，首字母小写
	@Controller	对于@Component的衍生注解，一般用于表现层注解
	@Service	同上，主要用于业务层注解
	@Repository	同上，主要用于持久层注解
DI注解 依赖注入 相当于： <property name="" value=""/> <property name="" ref=""/>	@Autowired	1、默认按照类型装配 2、是由org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor实现的 3、是spring自带的注解 4、@Autowired注解默认情况下要求依赖对象必须存在，如果允许不存在，需要设置它的required属性为false 5、如果我们想按照名称装配（byName），可以结合@Qualifier注解进行使用
	@Qualifier	1、在自动按照类型注入的同时，在按照bean的id注入 2、它在给字段注入时不能独立使用，必须和@Autowired一起使用 3、给方法参数注入时，可以单独使用
	@Resource	1、默认按照名称装配，可以通过@Resource的name属性指定名称，如果没有指定name属性，当注解写到字段上时，默认取字段名并按照字段名查找，当找不到与字段名匹配的bean时才按照类型进行装配 2、如果name属性指定，则一定会按照名称进行装配
	@Inject	1、根据类型自动装配，如果需要按照名称进行装配，则需要配合@Name注解 2、@Inject可以作用在变量、setter方法、构造函数上
	@Value	给简单类型（8种基本类型+String）来注入值
	@Autowired、@Resoure、@Inject区别	1、@Autowired是spring自带的，@Inject是JSR330规范实现的，@Resource是JSR250规范实现的，需要导入不同的包 2、@Autowired和@Inject用发基本一致，但是@Autowired有一个request属性 3、@Autowired和@Inject默认按照类型匹配，@Resource默认按照名称匹配 4、@Autowired要是想按照名称匹配，需要@Qualifier注解配合；@Inject要是想按照名称匹配，需要@Name注解配合
	@Scope	作用域注解： 改变作用域，相当于下面的配置代码，value内容有：singletion、prototype、request、session、globalsession <bean id="" class="" scope=""/>
	@PostConstrust @PreDestory	生命周期注解： 相当于以下代码 <bean id="" class="" init-method="" destroy-method=""/>

　　　　xml配置和注解配置的对比

	Xml配置	注解配置
Bean定义	使用<bean id="" class=""/>来配置	使用@Component和其衍生注解@Controller、@Service、@Repository
Bean名称	通过id或name来设置	通过注解内加名称使用，例如：@Service("UserService")
Bean注入	使用<property>标签注入	使用@Autowired或@Inject或@Inject来注入 如果使用@Autowired注入，可以配合@Qualifier按名称注入等
生命过程和作用域	在bean标签中使用init-method、destory-method、scope来设置	使用@PostConstruct、@PreDestory、@Scope来设置
适用场景	Bean来自第三方	Bean是由我们自己写的

（三）基于纯注解的使用

　　　　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、相关术语

术语	说明
JoinPoint	连接点：指的是那些被拦截的点。在spring中，连接点指的是方法，因为spring只支持方法类型的连接点
PointCut	切入点：指我们要对哪些JointPoint进行拦截
Advice	通知/增强：指拦截到JointPoint后要做的事。通知分为前置通知、后置通知、异常通知、最终通知和环绕通知
Introduction	引介：是一种特殊的通知，在不修改代码的前提下，Introduction可以在运行期为类动态的添加一些方法或Field
Target	目标对象：代理的目标对象
Weaving	织入：是吧增强应用到目标对象来创建新的代理对象的过程
Proxy	代理：一个类被AOP织入增强后，就产生一个代理类
Aspect	切面：是切点和通知的结合
Advisor	通知器/顾问：和Aspect相似

　　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([修饰符] 返回值类型 包名.类名.方法名(参数)) 　　

　　　　表达式说明：

参数	说明
execution	必须
修饰符	可省略
返回值类型	必须
包名	1、多级包之间使用.分割 2、包可以使用*代替 3、多级包名可以使用多个*代替 4、如果想省略中间的包，可以使用..
类名	1、可以使用*代替 2、也可以使用*ServiceImpl
方法名	1、可以使用*代替 2、也可以写成save*
参数	1、参数使用*代替 2、如果有多个参数，可以使用..代替

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

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

事务缩写	名称	说明
A	原子性：Atomicty	事务是一个原子操作，只会成功或失败，不存在中间状态
C	一致性：Consistency	在一个事务内，要么全部成功，要么全部失败
I	隔离性：Isolation	各个事务相互隔离，一个事务没有提交之前，不会被其他事务看到
D	持久性：Durability	指一个事务一旦被提交，就是永久性的。

　　（2）事务的并发问题

问题	描述
脏读	一个事务读取到了另一个事务未提交的数据
不可重复读	一个事务因读取到了另一个事务已提交的数据，导致对同一条记录读取两次以上的结果不一致，主要针对update
幻读	一个事务因读取到了另一个事务已提交的数据，导致对同一条记录读取两次以上的结果不一致，主要针对delete和insert

　　（3）事务隔离级别

　　　　四种隔离级别

级别	描述
读未提交：Read uncommitted	最低级别，任何情况都无法保证
读已提交：Read committed	可以避免脏读
可重复读：Repeatable Read	可以避免脏读、不可重复读
串行化：Serializable	可以避免脏读、不可重复读、幻读

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

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

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

　　（4）Spring事务管理接口

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

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

接口名称	说明	实现类	常用方法
PlatformTransactionManager接口	平台事务管理器，是真正管理事务的类，该接口有具体的实现类，根据不同的持久层框架，需要选择不同的实现类。	JDBCMybatis：DataSourceTransactionManager Hibernate：HibernateTransactionManager	获取事务状态方法： TransactionStatus getTransaction(TransactionDefinition definition) 提交事务方法：void commit(TransactionStatus status) 回滚事务方法：void rollback(TransactionStatus status)
TransactionDefinition接口	事务定义信息，可以定义事务隔离级别、事务传播行为、超时时间、是否只读等信息
TransactionStatus接口	事务的状态：是否是新事务、是否已提交、是否有保存点、是否回滚

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

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

　　　　a、事务隔离级别常量

隔离级别常量	隔离级别描述
ISOLATION_DEFAULT	采用数据库默认的隔离级别
ISOLATION_READ_UNCOMMITTED	读未提交
ISOLATION_READ_COMMITTED	读已提交
ISOLATION_REPEATABLE_READ	可重复读
ISOLATION_SERIALIZABLE	串行化

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

传播行为	描述
PROPAGATION_REQUIRED	A中有事务，使用A中的事务；A中没有事务，B开启一个新的事务
PROPAGATION_SUPPORTS	A中有事务，使用A中的事务；A中没有事务，B也不使用事务
PROPAGATION_MANDATORY	A中有事务，使用A中的事务；A中没有事务，抛出异常
PROPAGATION_REQUIRED_NEW	A中有事务，将A的事务挂起，B创建一个新的事务
PROPAGATION_NOT_SUPPORTED	A中有事务，将A中的事务挂起
PROPAGATION_NEVER	A中有事务，抛出异常
PROPAGATION_NESTED	嵌套事务，当A执行后，就会在这个位置设置一个保存点，如果B没有问题，执行通过。如果B出现异常，根据需求回滚（回滚到保存点或者最初始状态）

　　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("测试完成");
    }
}