springboot 多数据源jpa、mybatis、jdbcTemplate
阅读数:50 评论数:0
跳转到新版页面分类
python/Java
正文
一、概述
1、读写分离
数据库主节点压力比较大，需要增加从节点提供读操作，以减少压力。
2、多数据源
一个复杂发项目，因为没有拆分服务，需要连接多个业务的数据源。
这些场景都需要使用springboot的多数据源方案。除了以下四种方案外，还可以使用分库分表的中间件，例如ShardingSphere、mycat等。
二、基于Spring的AbstractRoutingDataSource
通过继承AbstractRoutingDataSource抽象类，实现管理项目中多个DataSource。
我们可以自定义一个@DS注解，可以添加到Service方法、Dao方法上，表示其实际对应的DataSource。
开源项目中，比较好的是baomidou提供的dynamic-datasource-spring-boot-starter。
这种方式要留意事务的问题。
1、baomidou多数据源案例
（1）pom文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>boot-start</artifactId>
<groupId>com.yyds</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>baomidou-multiple-db</artifactId>
<dependencies>
<!-- 实现对数据库连接池的自动化配置 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.48</version>
</dependency>
<!-- 实现对 MyBatis 的自动化配置 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.1</version>
</dependency>
<!-- 实现对 dynamic-datasource 的自动化配置 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
<version>2.5.7</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-actuator</artifactId>
</dependency>
<!-- 方便写单元测试 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--小辣椒-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
</project>
（2）yml文件
server:
port: 6789
spring:
datasource:
# dynamic-datasource-spring-boot-starter 动态数据源的配置内容
dynamic:
primary: users # 设置默认的数据源或者数据源组，默认值即为 master
datasource:
# 订单 orders 数据源配置
orders:
url: jdbc:mysql://127.0.0.1:3306/test_orders?useSSL=false&useUnicode=true&characterEncoding=UTF-8
driver-class-name: com.mysql.jdbc.Driver
username: root
password: root
# 用户 users 数据源配置
users:
url: jdbc:mysql://127.0.0.1:3306/test_users?useSSL=false&useUnicode=true&characterEncoding=UTF-8
driver-class-name: com.mysql.jdbc.Driver
username: root
password: root
# mybatis 配置内容
mybatis:
config-location: classpath:mybatis-config.xml # 配置 MyBatis 配置文件路径
mapper-locations: classpath:mapper/*.xml # 配置 Mapper XML 地址
type-aliases-package: com.yyds.springboot.domain # 配置数据库实体包路径
（3）mbatis-config.xml
<?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>
<!-- 使用驼峰命名法转换字段。 -->
<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>
（4）主启动类
package com.yyds.springboot;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@SpringBootApplication
@MapperScan(basePackages = "com.yyds.springboot.mapper")
@EnableAspectJAutoProxy(exposeProxy = true) // http://www.voidcn.com/article/p-zddcuyii-bpt.html
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
System.out.println("***********Application***************");
}
}
（5）mapper层
package com.yyds.springboot.mapper;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.yyds.springboot.commons.DBConstants;
import com.yyds.springboot.domain.OrderDO;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
@Repository
@DS(DBConstants.DATASOURCE_ORDERS)
public interface OrderMapper {
OrderDO selectById(@Param("id") Integer id);
}
@DS注解，是dynamic-datasource-spring-boot-starter提供的，可以添加在Service或Mapper的类或接口上，value属性填写数据源的名字。
package com.yyds.springboot.commons;
public class DBConstants {
public static final String DATASOURCE_ORDERS = "orders";
public static final String DATASOURCE_USERS = "users";
}
三、基于SqlSessionTemplate分包
以Mybatis为例，假设有orders和users两个数据源，我们可以创建两个SqlSessionTemplate，然后配置不同的Mapper不同的SqlSessionTemplate。
整个过程就变成，执行数据操作时，通过Mapper可以外对应到其SqlSessionTemplate，使用SqlSessionTemplate获得对应的实际 DataSource，之后 ，通过该DataSource获得Connection连接，最后发起数据库操作。
1、mybatis案例
（1）pom文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>boot-start</artifactId>
<groupId>com.yyds</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>mybatis-multiple-db</artifactId>
<dependencies>
<!-- 实现对数据库连接池的自动化配置 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.49</version>
</dependency>
<!-- MyBatis 相关依赖 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.1</version>
</dependency>
<!-- 保证 Spring AOP 相关的依赖包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
</dependency>
<!-- 单元测试 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
</project>
（2）yml配置
spring:
# datasource 数据源配置内容
datasource:
# 订单数据源配置
orders:
jdbc-url: jdbc:mysql://127.0.0.1:3306/test_orders?useSSL=false&useUnicode=true&characterEncoding=UTF-8
driver-class-name: com.mysql.jdbc.Driver
username: root
password: root
# 用户数据源配置
users:
jdbc-url: jdbc:mysql://127.0.0.1:3306/test_users?useSSL=false&useUnicode=true&characterEncoding=UTF-8
driver-class-name: com.mysql.jdbc.Driver
username: root
password: root
# 注意此时并不使用它实现对 MyBatis 的自动化配置。这么引入，只是单纯方便，实际只要引入 mybatis 和 mybatis-spring 即可。
（3）Mapper
package com.yyds.springboot.mapper.orders;
import com.yyds.springboot.domain.OrderDO;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
@Repository
public interface OrderMapper {
OrderDO selectById(@Param("id") Integer id);
}
（4）MybatisOrderConfig
package com.yyds.springboot.config;
import com.yyds.springboot.commons.DBConstants;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;
@Configuration
@MapperScan(basePackages = "com.yyds.springboot.mapper.orders", sqlSessionTemplateRef = "ordersSqlSessionTemplate")
public class MyBatisOrdersConfig {
/**
* 创建 orders 数据源
*/
@Bean(name = "ordersDataSource")
@ConfigurationProperties(prefix = "spring.datasource.orders")
public DataSource dataSource() {
return DataSourceBuilder.create().build();
}
/**
* 创建 MyBatis SqlSessionFactory
*/
@Bean(name = "ordersSqlSessionFactory")
public SqlSessionFactory sqlSessionFactory() throws Exception {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
// <2.1> 设置 orders 数据源
bean.setDataSource(this.dataSource());
// <2.2> 设置 entity 所在包
bean.setTypeAliasesPackage("com.yyds.springboot.domain");
// <2.3> 设置 config 路径
bean.setConfigLocation(new PathMatchingResourcePatternResolver().getResource("classpath:mybatis-config.xml"));
// <2.4> 设置 mapper 路径
bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
return bean.getObject();
}
/**
* 创建 MyBatis SqlSessionTemplate
*/
@Bean(name = "ordersSqlSessionTemplate")
public SqlSessionTemplate sqlSessionTemplate() throws Exception {
return new SqlSessionTemplate(this.sqlSessionFactory());
}
/**
* 创建 orders 数据源的 TransactionManager 事务管理器
*/
@Bean(name = DBConstants.TX_MANAGER_ORDERS)
public PlatformTransactionManager transactionManager() {
return new DataSourceTransactionManager(this.dataSource());
}
}
（5）使用
@Transactional(transactionManager = DBConstants.TX_MANAGER_ORDERS)
public void method04() {
// 查询订单
OrderDO order = orderMapper.selectById(1);
System.out.println(order);
// 查询用户
self().method041();
}
@Transactional(transactionManager = DBConstants.TX_MANAGER_USERS,
propagation = Propagation.REQUIRES_NEW)
public void method041() {
UserDO user = userMapper.selectById(1);
System.out.println(user);
}
四、SpringData JPA方案
1、案例
（1）pom文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>boot-start</artifactId>
<groupId>com.yyds</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>jpa-multiple-db</artifactId>
<dependencies>
<!-- 实现对数据库连接池的自动化配置 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.49</version>
</dependency>
<!-- JPA 相关依赖 -->
<!--对于 spring-boot-starter-data-jpa 依赖，这里并不使用它实现对 JPA 的自动化配置。
这么引入，只是单纯方便，不然需要引入 spring-data-jpa 和 hibernate-core 等依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- 单元测试 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--小辣椒-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
</project>
（2）yml配置
spring:
# datasource 数据源配置内容
datasource:
# 订单数据源配置
orders:
jdbc-url: jdbc:mysql://127.0.0.1:3306/test_orders?useSSL=false&useUnicode=true&characterEncoding=UTF-8
driver-class-name: com.mysql.jdbc.Driver
username: root
password: root
# 用户数据源配置
users:
jdbc-url: jdbc:mysql://127.0.0.1:3306/test_users?useSSL=false&useUnicode=true&characterEncoding=UTF-8
driver-class-name: com.mysql.jdbc.Driver
username: root
password: root
jpa:
show-sql: true # 打印 SQL
# Hibernate 配置内容，对应 HibernateProperties 类
hibernate:
ddl-auto: none
（3）Dao层
package com.yyds.springboot.repository.orders;
import com.yyds.springboot.domain.OrderDO;
import org.springframework.data.repository.CrudRepository;
public interface OrderRepository extends CrudRepository<OrderDO, Integer> {
}
（4）常量
package com.yyds.springboot.common;
public class DBConstants {
/**
* 事务管理器 - 订单库
*/
public static final String TX_MANAGER_ORDERS = "ordersTransactionManager";
/**
* 事务管理器 - 用户库
*/
public static final String TX_MANAGER_USERS = "usersTransactionManager";
/**
* 实体管理器工厂 - 订单库
*/
public static final String ENTITY_MANAGER_FACTORY_ORDERS = "ordersEntityManagerFactory";
/**
* 实体管理器工厂 - 用户库
*/
public static final String ENTITY_MANAGER_FACTORY_USERS = "usersEntityManagerFactory";
}
（5）HibernateConfig
package com.yyds.springboot.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;
import java.util.Map;
@Configuration
public class HibernateConfig {
@Resource
private JpaProperties jpaProperties;
@Resource
private HibernateProperties hibernateProperties;
/**
* 获取 Hibernate Vendor 相关配置
*/
@Bean(name = "hibernateVendorProperties")
public Map<String, Object> hibernateVendorProperties() {
return hibernateProperties.determineHibernateProperties(
jpaProperties.getProperties(), new HibernateSettings()
);
}
}
(6)JpaOrderConfig
配置使用 orders 数据源的 Spring Data JPA 配置。
package com.yyds.springboot.config;
import com.yyds.springboot.common.DBConstants;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.Map;
@Configuration
@EnableJpaRepositories(
entityManagerFactoryRef = DBConstants.ENTITY_MANAGER_FACTORY_ORDERS,
transactionManagerRef = DBConstants.TX_MANAGER_ORDERS,
basePackages = {"com.yyds.springboot.repository.orders"}) // 设置接口所在包
public class JpaOrdersConfig {
@Resource(name = "hibernateVendorProperties")
private Map<String, Object> hibernateVendorProperties;
/**
* 创建 orders 数据源
*/
@Bean(name = "ordersDataSource")
@ConfigurationProperties(prefix = "spring.datasource.orders")
@Primary // 需要特殊添加，否则初始化会有问题
public DataSource dataSource() {
return DataSourceBuilder.create().build();
}
/**
* 创建 LocalContainerEntityManagerFactoryBean
*/
@Bean(name = DBConstants.ENTITY_MANAGER_FACTORY_ORDERS)
public LocalContainerEntityManagerFactoryBean entityManagerFactory(EntityManagerFactoryBuilder builder) {
return builder
.dataSource(this.dataSource()) // 数据源
.properties(hibernateVendorProperties) // 获取并注入 Hibernate Vendor 相关配置
.packages("com.yyds.springboot.domain") // 数据库实体 domain 所在包
.persistenceUnit("ordersPersistenceUnit") // 设置持久单元的名字，需要唯一
.build();
}
/**
* 创建 PlatformTransactionManager
*/
@Bean(name = DBConstants.TX_MANAGER_ORDERS)
public PlatformTransactionManager transactionManager(EntityManagerFactoryBuilder builder) {
return new JpaTransactionManager(entityManagerFactory(builder).getObject());
}
}
五、JdbcTemplate多数据方案
1、案例
（1）pom文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>boot-start</artifactId>
<groupId>com.yyds</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>jdbctemplate-multiple-db</artifactId>
<dependencies>
<!-- 实现对数据库连接池的自动化配置 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.49</version>
</dependency>
<!-- 保证 Spring AOP 相关的依赖包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
</dependency>
<!-- 方便等会写单元测试 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</project>
（2）yml配置文件
spring:
# datasource 数据源配置内容
datasource:
# 订单数据源配置
orders:
jdbc-url: jdbc:mysql://127.0.0.1:3306/test_orders?useSSL=false&useUnicode=true&characterEncoding=UTF-8
driver-class-name: com.mysql.jdbc.Driver
username: root
password: root
# 用户数据源配置
users:
jdbc-url: jdbc:mysql://127.0.0.1:3306/test_users?useSSL=false&useUnicode=true&characterEncoding=UTF-8
driver-class-name: com.mysql.jdbc.Driver
username: root
password: root
（3）dao层
package com.yyds.springboot.dao;
import com.yyds.springboot.constant.DBConstants;
import com.yyds.springboot.dataobject.OrderDO;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import javax.annotation.Resource;
@Repository
public class OrderDao {
@Resource(name = DBConstants.JDBC_TEMPLATE_ORDERS)
private JdbcTemplate template;
public OrderDO selectById(Integer id) {
return template.queryForObject("SELECT id, user_id FROM orders WHERE id = ?",
new BeanPropertyRowMapper<>(OrderDO.class), // 结果转换成对应的对象
id);
}
}
（4）jdbcTemplateConfig
package com.yyds.springboot.config;
import com.yyds.springboot.constant.DBConstants;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;
@Configuration
public class JdbcTemplateOrdersConfig {
/**
* 创建 orders 数据源
*/
@Bean(name = "ordersDataSource")
@ConfigurationProperties(prefix = "spring.datasource.orders")
public DataSource dataSource() {
return DataSourceBuilder.create().build();
}
/**
* 创建 orders JdbcTemplate
*/
@Bean(name = DBConstants.JDBC_TEMPLATE_ORDERS)
public JdbcTemplate jdbcTemplate() {
return new JdbcTemplate(this.dataSource());
}
/**
* 创建 orders 数据源的 TransactionManager 事务管理器
*/
@Bean(name = DBConstants.TX_MANAGER_ORDERS)
public PlatformTransactionManager transactionManager() {
return new DataSourceTransactionManager(this.dataSource());
}
}
（5）测试
package com.yyds.springboot.service;
import com.yyds.springboot.constant.DBConstants;
import com.yyds.springboot.dao.OrderDao;
import com.yyds.springboot.dao.UserDao;
import com.yyds.springboot.dataobject.OrderDO;
import com.yyds.springboot.dataobject.UserDO;
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@Service
public class OrderService {
@Autowired
private OrderDao orderDao;
@Autowired
private UserDao userDao;
private OrderService self() {
return (OrderService) AopContext.currentProxy();
}
public void method01() {
// 查询订单
OrderDO order = orderDao.selectById(1);
System.out.println(order);
// 查询用户
UserDO user = userDao.selectById(1);
System.out.println(user);
}
@Transactional // 报错，找不到事务管理器
public void method02() {
// 查询订单
OrderDO order = orderDao.selectById(1);
System.out.println(order);
// 查询用户
UserDO user = userDao.selectById(1);
System.out.println(user);
}
public void method03() {
// 查询订单
self().method031();
// 查询用户
self().method032();
}
@Transactional(transactionManager = DBConstants.TX_MANAGER_ORDERS)
public void method031() {
OrderDO order = orderDao.selectById(1);
System.out.println(order);
}
@Transactional(transactionManager = DBConstants.TX_MANAGER_USERS)
public void method032() {
UserDO user = userDao.selectById(1);
System.out.println(user);
}
@Transactional(transactionManager = DBConstants.TX_MANAGER_ORDERS)
public void method04() {
// 查询订单
OrderDO order = orderDao.selectById(1);
System.out.println(order);
// 查询用户
self().method041();
}
@Transactional(transactionManager = DBConstants.TX_MANAGER_USERS,
propagation = Propagation.REQUIRES_NEW)
public void method041() {
UserDO user = userDao.selectById(1);
System.out.println(user);
}
}
相关推荐
一、概述
1、spring容器
spring中有三种bean容器：BeanFactory、ApplicationContext、WebApplicationContext。
（1）BeanFactor
一、概述
一个项目使用多个数据库（无论是主从复制--读写分离还是分布式数据库结构）的重要性变得越来越明显，整合的多数据源有两种方式：分包和aop。
1、SqlSessionTemplate
SqlSe
一、概述
二、SqlSessionFactory
SqlSessionFactory由Mybatis配置文件和映射文件，使用SqlSessionFactoryBuilder进行创建，它是用于获取Sq