SpringBoot事务开启设置

springboot项目如何开启事务?

针对这个问题,一部分小伙伴肯定回答的比较迅速,启动类上加上@EnableTransactionManagement注解,在需要事务支持的方法或者类或者接口的抽象方法或者接口类上加上@Transactional注解。这个回答没什么大问题,项目可以正常启动,事务支持也正常。但针对springboot项目,其实正常情况下是不需要在启动类上面加上@EnableTransactionManagement注解的。

原理

springboot项目可以不加@EnableTransactionManagement注解,是归功于springboot的自动配置功能。springboot旨在简化spring项目的配置,不管是基于注解的配置,还是以前的基于xml的配置,所以springboot项目在启动的时候会自动给我们加载很多的配置类,其中就有一个跟事务相关的自动配置类:

org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration

代码展示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
/*
* Copyright 2012-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package org.springframework.boot.autoconfigure.transaction;

import java.util.stream.Collectors;

import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
import org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.ReactiveTransactionManager;
import org.springframework.transaction.TransactionManager;
import org.springframework.transaction.annotation.AbstractTransactionManagementConfiguration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.reactive.TransactionalOperator;
import org.springframework.transaction.support.TransactionOperations;
import org.springframework.transaction.support.TransactionTemplate;

/**
* {@link org.springframework.boot.autoconfigure.EnableAutoConfiguration
* Auto-configuration} for Spring transaction.
*
* @author Stephane Nicoll
* @since 1.3.0
*/
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(PlatformTransactionManager.class)
@AutoConfigureAfter({ JtaAutoConfiguration.class, HibernateJpaAutoConfiguration.class,
DataSourceTransactionManagerAutoConfiguration.class, Neo4jDataAutoConfiguration.class })
@EnableConfigurationProperties(TransactionProperties.class)
public class TransactionAutoConfiguration {

@Bean
@ConditionalOnMissingBean
public TransactionManagerCustomizers platformTransactionManagerCustomizers(
ObjectProvider<PlatformTransactionManagerCustomizer<?>> customizers) {
return new TransactionManagerCustomizers(customizers.orderedStream().collect(Collectors.toList()));
}

@Bean
@ConditionalOnMissingBean
@ConditionalOnSingleCandidate(ReactiveTransactionManager.class)
public TransactionalOperator transactionalOperator(ReactiveTransactionManager transactionManager) {
return TransactionalOperator.create(transactionManager);
}

@Configuration(proxyBeanMethods = false)
@ConditionalOnSingleCandidate(PlatformTransactionManager.class)
public static class TransactionTemplateConfiguration {

@Bean
@ConditionalOnMissingBean(TransactionOperations.class)
public TransactionTemplate transactionTemplate(PlatformTransactionManager transactionManager) {
return new TransactionTemplate(transactionManager);
}

}

@Configuration(proxyBeanMethods = false)
@ConditionalOnBean(TransactionManager.class)
@ConditionalOnMissingBean(AbstractTransactionManagementConfiguration.class)
public static class EnableTransactionManagementConfiguration {

@Configuration(proxyBeanMethods = false)
@EnableTransactionManagement(proxyTargetClass = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
matchIfMissing = false)
public static class JdkDynamicAutoProxyConfiguration {

}

@Configuration(proxyBeanMethods = false)
@EnableTransactionManagement(proxyTargetClass = true)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
matchIfMissing = true)
public static class CglibAutoProxyConfiguration {

}

}

}

通过上述代码可以看到,org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration.EnableTransactionManagementConfiguration.CglibAutoProxyConfiguration配置类默认会生效,且该类上有@EnableTransactionManagement(proxyTargetClass = true)注解修饰,使得对事务的支持生效。

总结

  1. springboot项目不需要手动在启动类上加@EnableTransactionManagement注解,TransactionAutoConfiguration自动配置类中已有事务自动配置功能。

  2. @EnableTransactionManagement + @Transactional组合对更适用于纯spring项目。


SpringBoot配置Mybatis的两种方式

通过XML的方式配置Mybatis

  1. 在 /src/main/resource下创建Mybatis配置文件 mybatis-config.xml 和 映射文件目录mapper
  2. 在application.yml指定Mybatis配置文件、映射文件的位置:
  • mybatis.config-location:配置 mybatis-config.xml 路径mybatis-config.xml 中配置 MyBatis 基础属性

  • mybatis.mapper-locations:配置 Mapper 对应的 XML 文件路径

  • mybatis.type-aliases-package:配置项目中实体类包路径

application.yml

1
2
3
4
5
6
7
mybatis:
#标注mybatis配置文件的位置
config-location: classpath:mybatis-config.xml
#标注待解析的mapper的xml文件位置
mapper-locations: classpath:mapper/*.xml
#标注实体类位置
type-aliases-package: com.gzu.photo.entity

mybatis-config.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<settings>
<!-- #开启mybatis驼峰式命名规则自动转换 -->
<setting name="mapUnderscoreToCamelCase" value="true" />
</settings>
<typeAliases>
<typeAlias alias="Integer" type="java.lang.Integer" />
<typeAlias alias="Long" type="java.lang.Long" />
<typeAlias alias="HashMap" type="java.util.HashMap" />
<typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
<typeAlias alias="ArrayList" type="java.util.ArrayList" />
<typeAlias alias="LinkedList" type="java.util.LinkedList" />
</typeAliases>
</configuration>

appllication.properties中直接配置Mybatis

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#配置mysql数据源
spring.datasource.url=jdbc:mysql://your-mysql-url/database-name?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true
spring.datasource.username=username
spring.datasource.password=password
spring.datasource.driverClassName=com.mysql.jdbc.Driver

#security.basic.enabled=false

mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl


## Mybatis 配置
mybatis.type-aliases-package=com.xfind.core.entity.xianyu
mybatis.mapper-locations=classpath:mapper/*.xml
#使全局的映射器启用或禁用缓存。
mybatis.configuration.cache-enabled=true
#全局启用或禁用延迟加载。当禁用时,所有关联对象都会即时加载。
mybatis.configuration.lazy-loading-enabled=true
#当启用时,有延迟加载属性的对象在被调用时将会完全加载任意属性。否则,每种属性将会按需要加载。
mybatis.configuration.aggressive-lazy-loading=true
#是否允许单条sql 返回多个数据集 (取决于驱动的兼容性) default:true
mybatis.configuration.multiple-result-sets-enabled=true
#是否可以使用列的别名 (取决于驱动的兼容性) default:true
mybatis.configuration.use-column-label=true
#允许JDBC 生成主键。需要驱动器支持。如果设为了true,这个设置将强制使用被生成的主键,有一些驱动器不兼容不过仍然可以执行。 default:false
mybatis.configuration.use-generated-keys=true
#指定 MyBatis 如何自动映射 数据基表的列 NONE:不隐射\u3000PARTIAL:部分 FULL:全部
mybatis.configuration.auto-mapping-behavior=partial
#这是默认的执行类型 (SIMPLE: 简单; REUSE: 执行器可能重复使用prepared statements语句;BATCH: 执行器可以重复执行语句和批量更新)
mybatis.configuration.default-executor-type=simple
#使用驼峰命名法转换字段。
mybatis.configuration.map-underscore-to-camel-case=true
#设置本地缓存范围 session:就会有数据的共享 statement:语句范围 (这样就不会有数据的共享 ) defalut:session
mybatis.configuration.local-cache-scope=session
#设置但JDBC类型为空时,某些驱动程序 要指定值,default:OTHER,插入空值时不需要指定类型
mybatis.configuration.jdbc-type-for-null=null
#如果数据为空的字段,则该字段省略不显示,可以通过添加配置文件,规定查询数据为空是则返回null。
mybatis.configuration.call-setters-on-nulls=true

.yml文件示意如下:

1
2
3
4
5
mybatis:
configuration:
#开启mybatis驼峰式命名规则自动转换
map-underscore-to-camel-case: true
....

⚠️注意
两种配置方式只能二选一,不能同时使用application.yml中的configuration和mybatis-config.xml文件配置mybabis。即: application.yml中configuration 和 configLocation 两个属性不能同时存在,否则会报错。


Mybatis注解之@Mapper和@MapperScan的使用

首先,我们要使用@Mapper和@MapperScan注解的话,我们首先需要在对应的项目里面导入相关的依赖或者jar包。

1
2
3
4
5
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.2</version>
</dependency>

@Mapper注解

前言:从mybatis3.4.0开始加入了@Mapper注解,目的就是为了不再写mapper映射文件。

  • 优点:粒度更细
  • 缺点:直接在Mapper接口类中加@Mapper注解,需要在每一个mapper接口类中都需要添加@Mapper注解,较为繁琐
  • 作用:在接口类上添加了@Mapper,在编译之后会生成相应的实现类
  • 添加位置:接口类上面
  • 注意:在这个接口类里面的方法不能重载,因为他们在XML里面的ID不能一样
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Mapper
public interface StudentMapper {

//查询所有学生
List<Student> selectall();

//新增学生
int addstudent(Student student);

//删除学生
int delstudent(Integer sid);

//修改学生
int updatestudent(String sname,Integer sid);

}

@MapperScan注解

上面刚刚讲述了@Mapper注解可以把接口要变成实现类,如果项目有几个接口,你肯定会在对应的接口上写@Mapper注解,但是如果有一百个,上千个,你还会愿意去写吗,这个时候我们就可以使用@MapperScan注解来解决我们的问题。

  • 作用:指定要变成实现类的接口所在的包,然后在指定包下面的所有接口在SpringBoot启动编译完成之后生成相应的实现类

  • 添加位置:在Springboot启动类上面添加

方式一:通过@MapperScan可以指定要扫描的Mapper接口类的包路径

1
2
3
4
5
6
7
8
@MapperScan(basePackages = {"com.study.mapper"})
@SpringBootApplication
public class DemocsApplication {

public static void main(String[] args) {
SpringApplication.run(DemocsApplication.class, args);
}
}

方式二:使用@MapperScan注解对多个包进行扫描

1
2
3
4
5
6
7
8
@MapperScan(basePackages = {"com.study.mapper1","com.study.mapper2"})
@SpringBootApplication
public class DemocsApplication {

public static void main(String[] args) {
SpringApplication.run(DemocsApplication.class, args);
}
}

方式三:这里的.*代表的是扫描study下面下面任何带有子包

1
2
3
4
5
6
7
8
@MapperScan(basePackages {"com.study.*.mapper"})
@SpringBootApplication
public class DemocsApplication {

public static void main(String[] args) {
SpringApplication.run(DemocsApplication.class, args);
}
}