Spring MVC配置双数据源实现一个java项目同时连接两个数据库的方法

要在Spring MVC中配置双数据源来连接两个数据库，需要以下步骤：

1. 添加数据库连接的相关依赖

需要在pom.xml文件中添加数据库的相关依赖，例如：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-dbcp2</artifactId>
</dependency>

其中，spring-boot-starter-jdbc是Spring Boot提供的JDBC模块，提供了访问关系数据库的基本功能；mysql-connector-java是链接MySQL数据库的驱动；commons-dbcp2是数据库连接池的实现库。

1. 在application.properties中配置数据源

需要在application.properties配置文件中添加两个数据源的相关配置，例如：

#primary datasource
spring.datasource.primary.url=jdbc:mysql://localhost:3306/db1
spring.datasource.primary.username=root
spring.datasource.primary.password=root
spring.datasource.primary.driver-class-name=com.mysql.jdbc.Driver

#secondary datasource
spring.datasource.secondary.url=jdbc:mysql://localhost:3306/db2
spring.datasource.secondary.username=root
spring.datasource.secondary.password=root
spring.datasource.secondary.driver-class-name=com.mysql.jdbc.Driver

其中，spring.datasource.primary和spring.datasource.secondary分别代表两个数据源的配置，url是数据库的访问路径，username和password是访问数据库的用户名和密码，driver-class-name是数据库的驱动。

1. 创建数据源配置类

我们需要在Spring MVC项目中创建两个数据源配置文件，分别对应于不同的数据库连接信息，例如：

@Configuration
public class PrimaryDataSourceConfiguration {

    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
}

@Configuration
public class SecondaryDataSourceConfiguration {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
}

在这里，我们向Spring MVC容器注册两个数据源配置添加了@Bean注解来表示它是一个Bean。@Primary注解表示这个是默认的数据源。@ConfigurationProperties(prefix = "spring.datasource.primary")表示我们使用的是application.properties中的spring.datasource.primary前缀的配置信息。

1. 创建两个JDBC模板

需要创建两个JdbcTemplate的Bean来分别对应两个数据源。例如：

@Configuration
public class JdbcTemplatesConfiguration {

    @Autowired
    @Qualifier("primaryDataSource")
    private DataSource primaryDataSource;

    @Autowired
    @Qualifier("secondaryDataSource")
    private DataSource secondaryDataSource;

    @Bean(name = "primaryJdbcTemplate")
    public JdbcTemplate primaryJdbcTemplate() {
        return new JdbcTemplate(primaryDataSource);
    }

    @Bean(name = "secondaryJdbcTemplate")
    public JdbcTemplate secondaryJdbcTemplate() {
        return new JdbcTemplate(secondaryDataSource);
    }
}

这里我们创建了两个JdbcTemplate的Bean，一个是默认的Bean，它会自动加载，一个是命名为secondaryJdbcTemplate的Bean，对应着第二个数据源。

1. 使用JdbcTemplates访问数据库

在访问数据库时，需要注意到使用不同的JdbcTemplate来对不同的数据源进行访问。例如：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    @Qualifier("primaryJdbcTemplate")
    JdbcTemplate primaryJdbcTemplate;

    @Autowired
    @Qualifier("secondaryJdbcTemplate")
    JdbcTemplate secondaryJdbcTemplate;

    @Override
    public List<User> getAllUsers() {
        String sql = "SELECT * FROM users";
        List<User> users = primaryJdbcTemplate.query(sql, BeanPropertyRowMapper.newInstance(User.class));
        users.addAll(secondaryJdbcTemplate.query(sql, BeanPropertyRowMapper.newInstance(User.class)));
        return users;
    }
}

在这里，我们向这个UserService实现类添加了两个JdbcTemplate属性，并使用@Qualifier注解的标签以指定注入的具体实例。在getAllUsers()方法中，我们分别使用两个JdbcTemplate对象对不同的数据源进行查询，在将结果合并后返回。

示例1：在这个项目中，让我们使用Spring MVC和两个不同的数据源实现多数据源事物管理，在第一个数据库中插入记录并在第二个数据库中更新记录。

伪代码：

// 在第一个数据源中插入数据
@Autowired
@Qualifier("primaryJdbcTemplate")
private JdbcTemplate primaryJdbcTemplate;

// 在第一个数据源中插入数据
String sql1 = "insert into user(name,age) values (?,?)";
primaryJdbcTemplate.update(sql1, "admin", 20);

// 在第二个数据源中更新数据
@Autowired
@Qualifier("secondaryJdbcTemplate")
private JdbcTemplate secondaryJdbcTemplate;

String sql2 = "update account set balance=? where id=?";
secondaryJdbcTemplate.update(sql2, 100, 1);

示例2：在一个Spring Boot应用程序中使用两个数据源

1.添加依赖：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<!-- MySQL 驱动 -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
</dependency>

<!-- H2 数据库驱动 -->
<dependency>
  <groupId>com.h2database</groupId>
  <artifactId>h2</artifactId>
  <scope>runtime</scope>
</dependency>

2.创建两个数据源的配置

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
  entityManagerFactoryRef = "primaryEntityManager",
  transactionManagerRef = "primaryTransactionManager",
  basePackages = {"com.example.demo.repository.primary"})
public class PrimaryDataSourceConfig {

  @Primary
  @Bean(name = "primaryDataSource")
  @ConfigurationProperties(prefix = "primary.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }

  @Primary
  @Bean(name = "primaryEntityManager")
  public LocalContainerEntityManagerFactoryBean 
  entityManagerFactory(
    EntityManagerFactoryBuilder builder,
    @Qualifier("primaryDataSource") DataSource dataSource
  ) {
    return builder
      .dataSource(dataSource)
      .packages("com.example.demo.model.primary")
      .persistenceUnit("primary")
      .build();
  }

  @Primary
  @Bean(name = "primaryTransactionManager")
  public PlatformTransactionManager transactionManager(
    @Qualifier("primaryEntityManager") EntityManagerFactory entityManagerFactory
  ) {
    return new JpaTransactionManager(entityManagerFactory);
  }
}

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
  entityManagerFactoryRef = "secondaryEntityManager",
  transactionManagerRef = "secondaryTransactionManager",
  basePackages = {"com.example.demo.repository.secondary"})
public class SecondaryDataSourceConfig {

  @Bean(name = "secondaryDataSource")
  @ConfigurationProperties(prefix = "secondary.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }

  @Bean(name = "secondaryEntityManager")
  public LocalContainerEntityManagerFactoryBean 
  entityManagerFactory(
    EntityManagerFactoryBuilder builder,
    @Qualifier("secondaryDataSource") DataSource dataSource
  ) {
    return builder
      .dataSource(dataSource)
      .packages("com.example.demo.model.secondary")
      .persistenceUnit("secondary")
      .build();
  }

  @Bean(name = "secondaryTransactionManager")
  public PlatformTransactionManager transactionManager(
    @Qualifier("secondaryEntityManager") EntityManagerFactory 
    entityManagerFactory
  ) {
    return new JpaTransactionManager(entityManagerFactory);
  }
}

3.创建两个实体类和持久化类

4.在Controller中使用数据源访问

@RequestMapping("/primary")
@RestController
public class PrimaryController {

  @Autowired
  private PrimaryJPARepository jpaRepository;

  @GetMapping("/")
  public List<Primary> getData() {
    return jpaRepository.findAll();
  }
}

@RequestMapping("/secondary")
@RestController
public class SecondaryController {

  @Autowired
  private SecondaryJPARepository jpaRepository;

  @GetMapping("/")
  public List<Secondary> getData() {
    return jpaRepository.findAll();
  }
}