In order to solve database bottlenecks and distribute database pressure, read-write separation is often used. Next, let's talk about how to use jpa to separate read and write in spring boot. This article provides sample source code .

When there is only one data source, we can easily use the automatic configuration of JPA to complete database operations. But when reading and writing are separated, obviously we need at least two DataSources, so these all need to be configured manually, because the automatic configuration code uses conditional annotations, and we will not automatically configure it for us after we manually configure it. This can be found by looking at the source code.

Multiple Repository Configuration

We can see the automatic configuration process and configuration key points of Repository through springboot, spring data's official website and spring boot source code. There are three key Beans are DataSource/EntityManager/TransactionManager, and then there is the package where the interface class of Repository is located. The configuration of this aspect can be easily searched on the Internet, or you can check the documentation and source code to complete it yourself, see the corresponding source code on github . Key code:

@Bean
@Primary
@ConfigurationProperties("spring.datasource.write")
public DataSourceProperties writeDataSourceProperties() {
return new DataSourceProperties();
}
@Bean
@Primary
@ConfigurationProperties("spring.datasource.write")
public DataSource writeDataSource() {
return writeDataSourceProperties().initializeDataSourceBuilder().build();
}
@Bean
@Primary
public LocalContainerEntityManagerFactoryBean writeEntityManagerFactory(
EntityManagerFactoryBuilder builder, @Qualifier("writeDataSource") DataSource dataSource) {
return builder
.dataSource(dataSource)
.packages(User.class)
.properties(getVendorProperties(dataSource))
.persistenceUnit("write")
.build();
}
@Bean
@Primary
public PlatformTransactionManager writeTransactionManager(@Qualifier("writeEntityManagerFactory") LocalContainerEntityManagerFactoryBean writeEntityManagerFactory) {
JpaTransactionManager transactionManager = new JpaTransactionManager(writeEntityManagerFactory.getObject());
return transactionManager;
}

first option

According to the principle of JPA multi-repository, we can know that we can configure multi-repository by configuring and scanning the packages where different Repository interface classes are located. At this point, the first solution is naturally conceivable. That is to add a sub-interface through interface inheritance, but we do not need to operate anything in the sub-interface, only maintain the original interface. In this way, we can easily achieve read-write separation by letting the read Repository scan the package where the other Repository is located. This solution is simple and easy to implement, the only step is to add one more interface.

The second option

如果是已经完成的项目，添加接口也有可能是非常庞大的一个工程。那么我们就可以利用第二种方案了。这是通过修改注册Bean时候的源码，让两次扫描到的Repository生成不同的名称注册到Spring容器当中，把原来的标记为Primary。通过源码我们可以发现生成Bean名称的类是 org.springframework.data.repository.config.RepositoryConfigurationDelegate.我们就拦截这个类中生成Bean名称的过程，把不同配置类扫描到的Repository使用不同的名称，虽然它们类型是一样的，我们可以通过名称限定来注入相应的Bean。我们可以添加一个自己的注解，用来给我们的配置类添加元信息。

自定义注解：

/**
* repository bean 名称的前缀
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface RepositoryBeanNamePrefix {
String value();
}

修改RepositoryConfigurationDelegate，添加对应的逻辑：

String beanName = configurationSource.generateBeanName(beanDefinition);
AnnotationMetadata metadata = (AnnotationMetadata) configurationSource.getSource();
//判断配置类是否使用primary进行了标注，如果有，就设为primary
if(metadata.hasAnnotation(Primary.class.getName())){
beanDefinition.setPrimary(true);
}else if(metadata.hasAnnotation(RepositoryBeanNamePrefix.class.getName())){
// 再判断是否使用了RepositoryBeanNamePrefix进行了标注，如果有，添加名称前缀
Map<String,Object> prefixData = metadata.getAnnotationAttributes(RepositoryBeanNamePrefix.class.getName());
String prefix = (String) prefixData.get("value");
beanName = prefix + beanName;
}

配置多个Repository扫描的配置类:

@EnableJpaRepositories(basePackageClasses = UserRepository.class,
entityManagerFactoryRef = "writeEntityManagerFactory", transactionManagerRef = "writeTransactionManager")
@Primary
public class WriteConfiguration {
}
@EnableJpaRepositories(basePackageClasses = UserRepository.class,
entityManagerFactoryRef = "readEntityManagerFactory", transactionManagerRef = "readTransactionManager")
@RepositoryBeanNamePrefix("second")
public class SameRepositoryWriteConfiguration {
}

使用时我们可以通过名称注入的方式，使用读Repository：

@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserRepository userRepository;
@Autowired
private UserReadRepository readRepository;
@Autowired
@Qualifier("seconduserRepository")
private UserRepository seconduserRepository;
}

这样就达到我们读写分离的目的了。

总结

本文提供了Jpa多Repository连接多数据源的实现方式，及两种读写分离方案。以上列出的只是关键代码，很难通过语言完整详细的描述整个过程。大家如果有什么疑问，欢迎讨论，最好还是下载示例代码自己看看代码也许会清楚很多。

示例代码下载完后可以直接运行。因为数据库使用的时内存数据库h2，可以换成自己使用的数据库。

互联网金融是当下非常流行的热点领域。

作为一个紧跟时代的程序员，如果你对互联网金融领域感兴趣却不知如何进入，那这门课程就是你入行的加速器，能让你积累实际项目经验，提供技术综合运用能力！

Spring Boot jpa multiple Repository (data source) and read-write separation

Multiple Repository Configuration

first option

The second option

总结

Guess you like