Spring基础详解

文章内容

  • 什么是Spring

  • Spring中Bean的配置

  • ApplicationContext

  • Spring支持四种依赖注入的方式

  • Spring中Bean的相互引用

  • Null值和级联属性

  • 集合属性赋值

  • Bean自动装配

  • Bean的作用域

  • Bean之间的关系

  • Bean的使用外部属性文件

  • Spring表达式语言SpEL

  • Bean的生命周期

  • Spring AOP面向切面编程​

  • Spring 支持JDBC操作数据库

  • Spring事务管理

 

 

一、什么是Spring

Spring是一个开源框架,是一个IOC(DI)(反转控制或依赖注入)和AOP容器框架

IOC:(反转控制)其思想是反转资源获取的方向,传统的资源查找方式要求组件向容器发起请求查找资源,作为回应,容器适时的返回资源。而应用了IOC之后,则是容器主动的将资源推送给它所管理的组件,组件所要做的仅是选择一种合适的方式来接受资源,这种行为也被称为查找的被动形式。

DI:IOC的另一种表述方式,即组件以一些预先定义好的方式接受来自如容器的资源注入,相对于IOC而言,这种表述更直接。

 

 

二、Spring中Bean的配置

创建HelloWorld类用于测试

public class HelloWorld {
    private String name;
    public void setName(String name){
        this.name = name;
    }
    public void sayHello(){
        System.out.println("Hello "+name);
    }
}

新建一个Bean的xml,在xml配置Bean




    
    
        
    

通过ApplicationContext获取Bean实例并调用方法

public class Main {
    public static void main(String[] args){
        //1.创建Spring的IOC容器对象
        ApplicationContext mContext = new ClassPathXmlApplicationContext("spring-config.xml");
        //2.从IOC容器中获取Bean实例
        HelloWorld helloWorld = (HelloWorld) mContext.getBean("helloWorld");//通过id读取Bean
        //通过类型获取Bean HelloWorld helloWorld = mContext.getBean(HelloWord.class);缺点就是当有多个相同类型的Bean时无法返回
        //3.调用方法
        helloWorld.sayHello();
    }
}

 

 

三、ApplicationContext是一个接口,其有两个主要的实现类:

       ClassPathXmlApplicationContext:从类路径下加载配置文件,去新增了两个主要方法 refresh()和close(),让ApplicationContext有了启动,刷新和关闭上下文的功能。

FileSystemXmlApplicationContext:从文件系统中加载配置文件

 

 

四、Spring支持四种依赖注入的方式

       属性注入:属性注入即通过setter方法注入Bean的属性值或依赖的对象 属性注入使用元素,使用name属性指定Bean中属性名称,value属性或者子节点指定属性值。

属性注释示例


    

       构造方法注入:通过构造方法注入Bean的属性值或依赖的对象,它保证了Bean示例在实例化后就可以使用,构造器注入在元素里声明属性,中没有name属性。

构造方法注入示例

public class Dog {
    private String name;
    private int age;
    private String sex;

    public Dog(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Dog{" +
        "name='" + name + '\'' +
        ", age=" + age +
        ", sex='" + sex + '\'' +
        '}';
    }
}

    
    
    
        ]]>
    

        以p命名空间为属性赋值:xmlns:p="http://www.springframework.org/schema/p"

p命名空间赋值示例



        工厂方法注入(很少使用,不推荐)

 

 

五、Spring中Bean的相互引用

       组成应用程序的Bean需要访问其他Bean时需要相互引用,我们可以通过元素或者ref属性来实现Bean之间的引用,也可以使用内部Bean的形式实现引用。

public class Person {
    private String name;
    private int age;
    private Dog dog;

    public Person(String name, int age, Dog dog) {
        this.name = name;
        this.age = age;
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    @Override
    public String toString() {
        return "Person{" +
        "name='" + name + '\'' +
        ", age=" + age +
        ", dog=" + dog +
        '}';
    }
}

ref属性实现Bean的引用


    
    
    

内部Bean实现引用(内部Bean不用指定Bean的Id,内部Bean不可被外部引用)


    
    
    
        
            
            
            
        
    

 

 

六、Null值和级联属性

通过给属性赋null值,其实也可以不写


    
    
    
        
            
            
            
        
    

为级联属性赋值


    
    
    
    

 

 

七、集合属性赋值

1、List集合属性


    
    
    
        
            
            
            
            
        
    

2.Map集合属性


    
    
    
        
            
            
            
        
    

3.配置Properties集合属性

public class DataSouce {
    private Properties properties;

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public String toString() {
        return "DataSouce{" +
        "properties=" + properties +
        '}';
    }
}


    
        
            DB
            21
        
    

4.配置单例的集合以便多个Bean引用(以list为例)


    
    
    
    



    
    
    

 

 

八、Bean自动装配

Spring IOC容器可以自动装配Bean,需要做的仅仅是在的autowire属性里指定自动装配的模式,自动装配不够灵活,很少使用。还可以通过扫描包,注解的方式来实现自动装配,后面会介绍到。

  • byType (根据类型自动装配):若容器中有多个与目标Bean类型相同的Bean。在这种情况下,Spring将无法装配。
  • byName(根据名称自动装配):必须将目标Bean的名称和属性名设置得完全相同。
  • constructor (通过构造器自动装配):当Bean中存在多个构造器时,此种自动装配方式将会很复杂,不推荐使用


<!--根据Bean的id 和setter中属性名字相同来配置,若有匹配则装配,若无匹配,则不装配-->


<!--根据Bean的类型和当前Bean属性的类型进行装配->

 

 

九、Bean之间的关系

1.Bean之间的继承

       Bean之间的继承通过parent属性来制定其父类,子类配置了的属性按照子类属性的值配置,没配置的属性则按照父类配置来配置(即子类可以覆盖来自父类的继承)。若Bean的class没有指定则必须是一个抽象Bean。



2.Bean之间的依赖

       Bean之间的依赖通过depends-on属性来设置,如果被依赖对象如果为设置,则程序会报错。前置依赖的Bean会在本Bean实例化之前创建好,如果需要依赖于多个Bean的话,则可以通过逗号或者空格隔开依赖Bean的Id即可。




 

十、Bean的作用域

       所有的Bean在不指定scope时都是单例的(即IOC只会为Bean对象创建一个实例对象,每次获取实例都为一个对象)。

 作用域类型:

  • prototype 原型的,每次获取实例都会产生一个新的实例对象

  • singleton 单例类型,默认类型

  • request

  • session

 

 

十一、Bean的使用外部属性文件

1.新建一个properties文件

Spring基础详解_第1张图片

user = root
password = 1230
driverclass = com.mysql.jdbc.briver
jdbcurl = jdbc:mysql://test

2.在xml文件中使用外部属性文件



    
    
    
    

注意:在使用context时添加命名空间的方法如下。

xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd"

 

 

十二、Spring表达式语言SpEL

       SpEL是一个支持运行时查询和操作对象图的强大的表达式语言,语法类似于EL,SpEL使用#{}作为界定符,所有在大括号中的字符都将认为是 SpEL。

SpEL作用:

  • 通过bean的id对bean进行引用
  • 调用方法以及引用对象的属性值
  • 计算表达式的值
  • 正则表达式的匹配













 

 

十三、Bean的生命周期

Spring IOC容器对Bean的生命周期进行管理的过程:

  • 通过构造器或工厂方法创建Bean实例
  • 为Bean的属性设置值和对其他Bean的引用
  • 调用Bean的初始化方法
  • 使用Bean
  • 当容器关闭时,调用Bean的销毁方法

在Bean的声明里设置init-method和destroy-method属性,为Bean指定初始化方法和销毁方法

public class Dog {
    private String name;
    private int age;
    private String sex;

    private void init(){
        System.out.println("Dog init"); //初始化方法
    }
    private void destroy(){
        System.out.println("Dog destroy");//销毁方法
    }
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

创建Bean后置处理器:

       它允许在调用初始化方法的前后对Bean进行额为的处理,Bean后置处理器对IOC容器里的所有Bean实例逐一处理,而非单一操作。其典型作用:检查Bean的属性的正确性或根据特定的标准更改Bean的属性。

public class MBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throw BeansException {
        System.out.println("postProcessBeforeInitialization:"+beanName);
    return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization:"+beanName);
    return bean;
    }
}

在xml中配置Bean的后置处理器


 

 

十四、配置Bean的多种方式

  • xml中配置Bean(前面已经用过很多次了不做讲解了)

  • 工厂方式配置Bean

  • FactoryBean配置Bean

  • 注解方式配置Bean

1.静态工厂方法配置Bean

public class StaticDogFactory {

    private static Map dogs = new HashMap<>();

    static {
        dogs.put("Test1",new Dog("Test1",3,"公"));
        dogs.put("Test2",new Dog("Test2",3,"公"));
        dogs.put("Test3",new Dog("Test3",3,"公"));
        dogs.put("Test4",new Dog("Test4",3,"公"));
    }
    //静态工厂方法
    public static Dog getDog(String name){
        return dogs.get(name);
    }
}



2.实例工厂方法配置Bean(需要先配置实例工厂对象本身)

public class InstanceDogFactory {
    //实例工厂方法
    private Map dogs = null;
    public InstanceDogFactory(){
        dogs = new HashMap<>();
        dogs.put("Test1",new Dog("Test1",3,"公"));
        dogs.put("Test2",new Dog("Test2",3,"公"));
        dogs.put("Test3",new Dog("Test3",3,"公"));
        dogs.put("Test4",new Dog("Test4",3,"公"));
    }

    public Dog getDog(String name){
    return dogs.get(name);
    }
}




3.通过FactoryBean

public class DogFactoryBean implements FactoryBean {
    private String name;

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

    @Override
    public Dog getObject() throws Exception {
        return new Dog(name,3,"公");
    }

    /**
    * 返回对象的类型
    */
    @Override
    public Class getObjectType() {
        return Dog.class;
    }

    /**
    * 是否为单实例
    */
    @Override
    public boolean isSingleton() {
        return true;
    }
}


 

4.通过注解的方式配置Bean(目前使用较为广泛)

当在组件类上使用了特定的注解之后,还需要在Spring的配置文件中声明:

  • base-package属性指定一个需要扫描的基类包,Spring容器将会扫描这个基类包里及其子包中的所有类

  • 当需要扫描多个包时,可以用逗号隔开

  • 如果仅需要扫描特定的类而非基包下的所有类,可使用resource-pattern属性过滤特定的类

  •  子节点表示要包含的目标类

  •  子节点表示要排除的目标类

  • 下可以包含多个

特定组件包括:

  • @Component:基本注解,标识了一个受Spring管理的组件

  • @Respository:标识持久层组件

  • @Service:标识服务层(业务层)组件

  • @Controller:标识表现层组件

tepy类型:

  • annotation通过注解判断是否包含(即不包含那种类型的注解)

  • assignable指定不包含具体类



resource-pattern="repository/*.class">
    
    

组件配置

       元素还会自动注册AutoWiredAnnotationBeanPostProcessor(Bean后置处理器)实例,该实例可以自动装配具有@Autowired和@Resource、@Inject注解的属性。@Resource和 @Inject与@Autowired作用类似,所以建议使用@Autowired。

       @Autowired:注解自动装配具有兼容类型的单个Bean属性构造器,普通字段,一切具有参数的方法都可以应用@Autowired注解(@Autowired注解的对象必须是一个允许自动装配的类,或者设置@Autowired的required值为false,允许装配不上,如果被装配的类有多个实现,就会根据其名字去查询装配对象,如果未指定名字则会报错,还可以通过在@Autowired注解下加@Qualifier("BeanClassName")来指定装配的Bean的类型)。

@Controller
public class UserController {

    //@Autowired(required = false)
    //@Qualifier("UserRepositoryIpml")
    private UserService userService;
    @Autowired(required = false) //即使装配不上也不报错,设置为null
    @Qualifier("UserRepositoryIpml") 
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    // public void setUserService(@Qualifier("UserRepositoryIpml") UserService userService) {
    // this.userService = userService;
    // }
    public void execute(){
        System.out.println("UserController execute...");
        userService.add();
    }
}
@Repository("userRepository")//为Bean指定id
public class UserRepositoryIpml implements UserRepository {
    @Override
    public void save() {
        System.out.println("UserRepositoryIpml save...");
    }
}

 

 

十五、Spring AOP面向切面编程

       AOP:是一种新的方法论,是对传统OOP(面向对象编程)的补充,在使用AOP编程时,仍然需要定义公共功能,并且不必修改影响的类。这样一来横切关注点就被模块化到特殊的对象(切面)里了。好处:1、每个事物逻辑位于一个位置,代码不分散,便于维护和升级。2、业务模块更简洁,只包含核心业务代码,实现了解耦合。 

示例需要用到的类

public interface ArithmeticCalculator {
    int add(int i,int j);
    int sub(int i,int j);
    int mul(int i,int j);
    int div(int i,int j);
}
@Component
public class ArithmeticCalculatorIpml implements ArithmeticCalculator {
    @Override
    public int add(int i,int j) {
        int result = i+j;
        return result;
    }

    @Override
    public int sub(int i,int j) {
        int result = i-j;
        return result;
    }

    @Override
    public int mul(int i,int j) {
        int result = i*j;
        return result;
    }

    @Override
    public int div(int i,int j) {
        int result = i/j;
        return result;
    }
}

1.动态代理方式实现日志(开发时不常使用)

/**
* 动态代理
*/
public class ArithmeticCalculatorLoggingProxy {
    //要代理的对象
    private ArithmeticCalculator target;

    public ArithmeticCalculatorLoggingProxy(ArithmeticCalculator target){
        this.target = target;
    }
    public ArithmeticCalculator getLoggingProxy(){
        ArithmeticCalculator proxy = null;
        //类加载器 用于加载被代理对象
        ClassLoader loader = target.getClass().getClassLoader();
        //被代理对象实现了哪些接口 具有哪些方法
        Class [] interfaces = new Class[]{ArithmeticCalculator.class};
        //当调用代理对象其中的方法时,该执行的具体方法
        InvocationHandler handler = new InvocationHandler() {
            /**
            * @param proxy 正在返回的那个代理对象,一般情况下,在invoke中都不实用该对象
            * @param method 正在被调用的方法
            * @param args 调用方法时传入的参数
            * @return
            */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                String methodName = method.getName();
                //日志
                System.out.println("The method:"+methodName+" begins with "+ Arrays.asList(args));
                //执行方法
                Object result = method.invoke(target,args);
                //日志
                System.out.println("The method:"+methodName+" ends with "+ result);
                return result;
            }
        };
        proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader,interfaces,handler);
        return proxy;
    }
}
//使用动态代理
ArithmeticCalculator target = new ArithmeticCalculatorIpml();
ArithmeticCalculator proxy = new ArithmeticCalculatorLoggingProxy(target).getLoggingProxy();
System.out.println(proxy.add(1,2));

2.Spring AOP通知

       AspectJ:java社区里最完整最流行的AOP框架,在Spring2.0以后可以使用。IDEA在使用AspectJ要先通过jar包的方式导入。

AspectJ支持5中类型的通知注解:

  • @Before 前置通知,在方法执行前调用

  • @After 后置通知,在方法区执行后调用

  • @AfterRunning 返回通知,在方法返回结果之后执行

  • @AfterThrowing 异常通知,在方法抛出异常后执行

  • @Around 环绕通知,围绕着方法执行

1.使用AspectJ创建切面

创建切面类

/**
* 日志切面
*/
@Aspect //声明其为一个切面
@Component
public class LoggingAspect {
    //申明该方法为一个前置通知
    @Before(value = "execution(public int Spring.aop.ArithmeticCalculatorIpml.*(..))")//匹配所有参数类型的方法
    //@Before(value = "execution(public int Spring.aop.ArithmeticCalculatorIpml.*(..))")//匹配指定参数类型的方法
    //@Before(value = "execution(public int Spring.aop.*.*(..))")//匹配包下的所有类的所有方法
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List args = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method "+methodName+" begins "+args);
    }
} 
  

在xml中启动Aspect


 

2.切面优先级

通过@Order注解给切面添加优先级,值越小优先级越高

@Order(1)
@Aspect //声明其为一个切面
@Component
public class LoggingAspect {
    //申明该方法为一个前置通知
    @Before(value = "execution(public int Spring.aop.ArithmeticCalculatorIpml.*(..))")//匹配所有参数类型的方法
    //@Before(value = "execution(public int Spring.aop.ArithmeticCalculatorIpml.*(..))")//匹配指定参数类型的方法
    //@Before(value = "execution(public int Spring.aop.*.*(..))")//匹配包下的所有类的所有方法
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List args = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method "+methodName+" begins "+args);
    }
} 
  

 

3.重用切点表达式

@Aspect //声明其为一个切面
@Component
public class LoggingAspect {

@Pointcut("execution(public int Spring.aop.ArithmeticCalculatorIpml.*(..))")
public void AspectPoint(){}
    //申明该方法为一个前置通知
    @Before(value = "AspectPoint()")//匹配所有参数类型的方法
    //@Before(value = "execution(public int Spring.aop.ArithmeticCalculatorIpml.*(..))")//匹配指定参数类型的方法
    //@Before(value = "execution(public int Spring.aop.*.*(..))")//匹配包下的所有类的所有方法
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List args = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method "+methodName+" begins "+args);
    }
    @After(value = "AspectPoint()")//匹配所有参数类型的方法
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method "+methodName+" ends");
    }
} 
  

 

 

十六、Spring 支持JDBC操作数据库

 

1.连接数据库

c3p0连接池 jar包c3p0下载地址

注意:c3p0下的mchange-commons-java.jar,c3p0-oracle-thin-extras.jar,c3p0.jar这三个jar包都需要导入

junit 单元测试 jar包junit下载地址

mysql-connector-java下载地址

创建外部文件存储连接数据库的相关数据

jdbc.user=你的用户名
jdbc.password=你的密码
jdbc.driverClass=com.mysql.cj.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://127.0.0.1:3306/spring4?serverTimezone=UTC //后面serverTimezone=UTC这个表示设置时区 spring4是我的数据库名称
jdbc.initPoolSize=5
jdbc.maxPoolSize=10

配置Bean文件





    
    
    
    
    
    

创建单元测试测试是否连通

public class JdbcTest {

    private ApplicationContext mContext = null;

    {
    mContext = new ClassPathXmlApplicationContext("beans-jdbc.xml");
    }

    @Test
    public void Test(){
        DataSource dataSource = mContext.getBean(DataSource.class);
        try {
            System.out.println(dataSource.getConnection());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

当控制面板输出com.mchange.v2.c3p0.impl.NewProxyConnection@48524010 [wrapping: com.mysql.cj.jdbc.ConnectionImpl@4b168fa9]类似这种信息时表示连接数据库成功。

 

2.使用jdbcTemplate操作数据库

会使用到的类

public class User {
    private String username;
    private int id;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

配置jdbcTemplate的Bean



    

使用jdbcTemplate更新数据库

public void testUpdate(){
    jdbcTemplate = (JdbcTemplate) mContext.getBean("jdbcTemplate");
    String sql = "UPDATE user SET username = ? WHERE id = ?";//问号表示需要传入的参数
    jdbcTemplate.update(sql,"name2",1);
}

使用jdbcTemplate插入数据

public void testInsert(){
    jdbcTemplate = (JdbcTemplate) mContext.getBean("jdbcTemplate");
    String sql = "INSERT INTO user(username,id) VALUES (?,?)";
    List batchArgs = new ArrayList<>();
    batchArgs.add(new Object[]{"name3",2});
    batchArgs.add(new Object[]{"name4",3});
    batchArgs.add(new Object[]{"name5",4});
    jdbcTemplate.batchUpdate(sql,batchArgs);
}

使用jdbcTemplate查询指定数据

public void testQueryForObject(){
    jdbcTemplate = (JdbcTemplate) mContext.getBean("jdbcTemplate");
    String sql = "SELECT * FROM user WHERE id = ?";
    RowMapper rowMapper = new BeanPropertyRowMapper<>(User.class);
    User user = jdbcTemplate.queryForObject(sql,rowMapper,1);
    System.out.println("username:"+user.getUsername());
}

使用jdbcTemplate查询所有表内所有信息

public void testQueryForAll(){
    jdbcTemplate = (JdbcTemplate) mContext.getBean("jdbcTemplate");
    String sql = "SELECT * FROM user";
    RowMapper rowMapper = new BeanPropertyRowMapper<>(User.class);
    List users = jdbcTemplate.query(sql,rowMapper);
    System.out.println("username:"+users.toString());
}

 

十七、Spring事务管理

事务就是一系列的动作,它们都被当作一个单独的工作单元,这些动作要么全部完成,要么全部不起作用,当某一任务出错后我们需要回滚数据。

基于注解方式声明事务

 1.配置事务管理器



    


 2.通过注解声明事务

通过@Transactional为方法添加上事物注解

3.事务的传播行为(即一个事物被另一个事物引用时的行为)

事务的传播行为

  • REQUIRED_NEW:表示当前方法必须在其自己的事务中运行,一个新的事务将会被启动。如果存在当前事务,在该方法执行期间,当前事务会被挂起。

  • REQUIRED:表示当前方法必须运行在事务中,如果当前事务存在,方法将会在该事物中运行。否则,会启动一个新的事务。

  • SUPPORTS:表示当前方法不需要事务上下文,但是如果存在当前事务的话,那么该方法会在这个事务中运行。

  • MANDATORY:表示该方法必须在事务中运行,但如果当前事务不存在,则会抛出一个异常。

  • NOT_SUPPORTED:表示该方法不应该运行在它自己的事务中。如果存在当前事务,在该方法运行期间,当前事务将被挂起。

  • NEVER:表示当前方法不应该运行在事务上下文中,如果当前正有一个事务在运行,则抛出异常。

  • NESTED:表示如果当前已经存在一个事务,那么该方法将会嵌套在事务中运行,嵌套事务可以独立于当前事务进行单独的提交或回滚,如果当前事务不存在,那么其行为与REQUIRED一样。

4.通过propagation指定事务的传播行为,其默认值为REQUIRED

@Transactional(propagation = Propagation.REQUIRED)

 

5.使用isolation指定事务的隔离级别,最常用的取值为READ_COMMITTED

默认情况下Spring的声明事务将对所有的运行时异常进行回滚,可以通过对应属性进行设置

你可能感兴趣的:(后端)