其他分享
首页 > 其他分享> > Spring核心

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接口 平台事务管理器,是真正管理事务的类,该接口有具体的实现类,根据不同的持久层框架,需要选择不同的实现类。

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

 

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