博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
Java Spring中同时访问多种不同数据库
阅读量:5830 次
发布时间:2019-06-18

本文共 8610 字,大约阅读时间需要 28 分钟。

开发企业应用时我们常常遇到要同时访问多种不同数据库的问题,有时是必须把数据归档到某种数据仓库中,有时是要把数据变更推送到第三方数据库中。使用Spring框架时,使用单一数据库是非常容易的,但如果要同时访问多个数据库的话事件就变得复杂多了。

本文以在Spring框架下开发一个SpringMVC程序为例,示范了一种同时访问多种数据库的方法,而且尽量地简化配置改动。

搭建数据库

建议你也同时搭好两个数据库来跟进我们的示例。本文中我们用了PostgreSQL和MySQL。

下面的脚本内容是在两个数据库中建表和插入数据的命令。

PostgreSQL

 
  1. CREATE TABLE usermaster ( 
  2.    id integer, 
  3.    name character varying, 
  4.    emailid character varying, 
  5.    phoneno character varying(10), 
  6.    location character varying 
  7.  
  8. INSERT INTO usermaster(id, name, emailid, phoneno, location) 
  9. VALUES (1, 'name_postgres', 'email@email.com', '1234567890', 'IN'); 

MySQL

 
  1. CREATE TABLE `usermaster` ( 
  2.    `id` int(11) NOT NULL, 
  3.    `name` varchar(255) DEFAULT NULL, 
  4.    `emailid` varchar(20) DEFAULT NULL, 
  5.    `phoneno` varchar(20) DEFAULT NULL, 
  6.    `location` varchar(20) DEFAULT NULL, 
  7.    PRIMARY KEY (`id`) 
  8.  
  9. INSERT INTO `kode12`.`usermaster` 
  10.   (`id`, `name`, `emailid`, `phoneno`, `location`) 
  11. VALUES 
  12.   ('1', 'name_mysql', 'test@tset.com', '9876543210', 'IN'); 

搭建项目

我们用Spring Tool Suite (STS)来构建这个例子:

  • 点击File -> New -> Spring Starter Project。

  • 在对话框中输入项目名、Maven坐标、描述和包信息等,点击Next。

  • 在boot dependency中选择Web,点击Next。

  • 点击Finish。STS会自动按照项目依赖关系从Spring仓库中下载所需要的内容。

创建完的项目如下图所示:

接下来我们仔细研究一下项目中的各个相关文件内容。

pom.xml

pom中包含了所有需要的依赖和插件映射关系。

代码:

 
  1. <?xml version="1.0" encoding="UTF-8"?> 
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  4.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0  
  5.     http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
  6.     <modelVersion>4.0.0</modelVersion> 
  7.  
  8.     <groupId>com.aegis</groupId> 
  9.     <artifactId>MultipleDBConnect</artifactId> 
  10.     <version>0.0.1-SNAPSHOT</version> 
  11.     <packaging>jar</packaging> 
  12.  
  13.     <name>MultipleDB</name> 
  14.     <description>MultipleDB with Spring Boot</description> 
  15.  
  16.     <parent> 
  17.         <groupId>org.springframework.boot</groupId> 
  18.         <artifactId>spring-boot-starter-parent</artifactId> 
  19.         <version>1.3.5.RELEASE</version> 
  20.         <relativePath /> 
  21.     </parent> 
  22.  
  23.     <properties> 
  24.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 
  25.         <java.version>1.8</java.version> 
  26.     </properties> 
  27.  
  28.     <dependencies> 
  29.         <dependency> 
  30.             <groupId>org.springframework.boot</groupId> 
  31.             <artifactId>spring-boot-starter-web</artifactId> 
  32.         </dependency> 
  33.  
  34.         <dependency> 
  35.             <groupId>org.springframework.boot</groupId> 
  36.             <artifactId>spring-boot-starter-test</artifactId> 
  37.             <scope>test</scope> 
  38.         </dependency> 
  39.  
  40.         <dependency> 
  41.             <groupId>org.springframework.boot</groupId> 
  42.             <artifactId>spring-boot-starter-jdbc</artifactId> 
  43.         </dependency> 
  44.  
  45.         <dependency> 
  46.             <groupId>org.postgresql</groupId> 
  47.             <artifactId>postgresql</artifactId> 
  48.         </dependency> 
  49.  
  50.         <dependency> 
  51.             <groupId>mysql</groupId> 
  52.             <artifactId>mysql-connector-java</artifactId> 
  53.             <version>5.1.38</version> 
  54.         </dependency> 
  55.     </dependencies> 
  56.  
  57.     <build> 
  58.         <plugins> 
  59.             <plugin> 
  60.                 <groupId>org.springframework.boot</groupId> 
  61.                 <artifactId>spring-boot-maven-plugin</artifactId> 
  62.             </plugin> 
  63.         </plugins> 
  64.     </build> 
  65. </project> 

解释:

下面详细解释各种依赖关系的细节:

  • spring-boot-starter-web:为Web开发和MVC提供支持。

  • spring-boot-starter-test:提供JUnit、Mockito等测试依赖。

  • spring-boot-starter-jdbc:提供JDBC支持。

  • postgresql:PostgreSQL数据库的JDBC驱动。

  • mysql-connector-java:MySQL数据库的JDBC驱动。

application.properties

包含程序需要的所有配置信息。在旧版的Spring中我们要通过多个XML文件来提供这些配置信息。

 
  1. server.port=6060 
  2. spring.ds_post.url =jdbc:postgresql://localhost:5432/kode12 
  3. spring.ds_post.username =postgres 
  4. spring.ds_post.password =root 
  5. spring.ds_post.driverClassName=org.postgresql.Driver 
  6. spring.ds_mysql.url = jdbc:mysql://localhost:3306/kode12 
  7. spring.ds_mysql.username = root 
  8. spring.ds_mysql.password = root 
  9. spring.ds_mysql.driverClassName=com.mysql.jdbc.Driver 

解释:

“server.port=6060”声明你的嵌入式服务器启动后会使用6060端口(port.server.port是Boot默认的标准端口)。

其他属性中:

  • 以“spring.ds_*”为前缀的是用户定义属性。

  • 以“spring.ds_post.*”为前缀的是为PostgreSQL数据库定义的属性。

  • 以“spring.ds_mysql.*”为前缀的是为MySQL数据库定义的属性。

MultipleDbApplication.java

 
  1. package com.aegis; 
  2.  
  3. import org.springframework.boot.SpringApplication; 
  4. import org.springframework.boot.autoconfigure.SpringBootApplication; 
  5.  
  6. @SpringBootApplication 
  7. public MultipleDbApplication { 
  8.  
  9.     public static void main(String[] args) { 
  10.         SpringApplication.run(MultipleDbApplication.class, args); 
  11.     } 

这个文件包含了启动我们的Boot程序的主函数。注解“@SpringBootApplication”是所有其他Spring注解和Java注解的组合,包括:

 
  1. @Configuration 
  2. @EnableAutoConfiguration 
  3. @ComponentScan 
  4. @Target(value={TYPE}) 
  5. @Retention(value=RUNTIME) 
  6. @Documented 
  7. @Inherited 

其他注解:

@Configuration

@EnableAutoConfiguration
@ComponentScan

上述注解会让容器通过这个类来加载我们的配置。

MultipleDBConfig.java

 
  1. package com.aegis.config; 
  2. import javax.sql.DataSource; 
  3. import org.springframework.beans.factory.annotation.Qualifier; 
  4. import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder; 
  5. import org.springframework.boot.context.properties.ConfigurationProperties; 
  6. import org.springframework.context.annotation.Bean; 
  7. import org.springframework.context.annotation.Configuration; 
  8. import org.springframework.context.annotation.Primary; 
  9. import org.springframework.jdbc.core.JdbcTemplate; 
  10.  
  11. @Configuration 
  12. public class MultipleDBConfig { 
  13.     @Bean(name = "mysqlDb") 
  14.     @ConfigurationProperties(prefix = "spring.ds_mysql") 
  15.     public DataSource mysqlDataSource() { 
  16.         return DataSourceBuilder.create().build(); 
  17.     } 
  18.  
  19.     @Bean(name = "mysqlJdbcTemplate") 
  20.     public JdbcTemplate jdbcTemplate(@Qualifier("mysqlDb") DataSource dsMySQL) { 
  21.         return new JdbcTemplate(dsMySQL); 
  22.     } 
  23.  
  24.     @Bean(name = "postgresDb") 
  25.     @ConfigurationProperties(prefix = "spring.ds_post") 
  26.     public DataSource postgresDataSource() { 
  27.         return  DataSourceBuilder.create().build(); 
  28.     } 
  29.  
  30.     @Bean(name = "postgresJdbcTemplate") 
  31.     public JdbcTemplate postgresJdbcTemplate(@Qualifier("postgresDb")  
  32.                                               DataSource dsPostgres) { 
  33.         return new JdbcTemplate(dsPostgres); 
  34.     } 

解释:

这是加了注解的配置类,包含加载我们的PostgreSQL和MySQL数据库配置的函数和注解。这也会负责为每一种数据库创建JDBC模板类。

下面我们看一下这四个函数:

 
  1. @Bean(name = "mysqlDb") 
  2. @ConfigurationProperties(prefix = "spring.ds_mysql") 
  3. public DataSource mysqlDataSource() { 
  4. return DataSourceBuilder.create().build(); 

上面代码第一行创建了mysqlDb bean。

第二行帮助@Bean加载了所有有前缀spring.ds_mysql的属性。
第四行创建并初始化了DataSource类,并创建了mysqlDb DataSource对象。

 
  1. @Bean(name = "mysqlJdbcTemplate") 
  2. public JdbcTemplate jdbcTemplate(@Qualifier("mysqlDb") DataSource dsMySQL) { 
  3.      return new JdbcTemplate(dsMySQL); 

第一行以mysqlJdbcTemplate为名创建了一个JdbcTemplate类型的新Bean。

第二行将第一行中创建的DataSource类型新参数传入函数,并以mysqlDB为qualifier。
第三行用DataSource对象初始化JdbcTemplate实例。

 
  1. @Bean(name = "postgresDb") 
  2. @ConfigurationProperties(prefix = "spring.ds_post") 
  3. public DataSource postgresDataSource() { 
  4.    return  DataSourceBuilder.create().build(); 

第一行创建DataSource实例postgresDb。

第二行帮助@Bean加载所有以spring.ds_post为前缀的配置。
第四行创建并初始化DataSource实例postgresDb。

 
  1. @Bean(name = "postgresJdbcTemplate") 
  2. public JdbcTemplate postgresJdbcTemplate(@Qualifier("postgresDb") 
  3.                                           DataSource dsPostgres) { 
  4.   return new JdbcTemplate(dsPostgres); 

第一行以postgresJdbcTemplate为名创建JdbcTemplate类型的新bean。

第二行接受DataSource类型的参数,并以postgresDb为qualifier。
第三行用DataSource对象初始化JdbcTemplate实例。

DemoController.java

 
  1. package com.aegis.controller; 
  2. import java.util.HashMap; 
  3. import java.util.Map; 
  4. import org.springframework.beans.factory.annotation.Autowired; 
  5. import org.springframework.beans.factory.annotation.Qualifier; 
  6. import org.springframework.jdbc.core.JdbcTemplate; 
  7. import org.springframework.web.bind.annotation.PathVariable; 
  8. import org.springframework.web.bind.annotation.RequestMapping; 
  9. import org.springframework.web.bind.annotation.RestController; 
  10.  
  11. @RestController 
  12. public class DemoController { 
  13.  
  14.     @Autowired 
  15.     @Qualifier("postgresJdbcTemplate") 
  16.     private JdbcTemplate postgresTemplate; 
  17.  
  18.     @Autowired 
  19.     @Qualifier("mysqlJdbcTemplate") 
  20.     private JdbcTemplate mysqlTemplate; 
  21.  
  22.     @RequestMapping(value = "/getPGUser") 
  23.     public String getPGUser() { 
  24.         Map<String, Object> map = new HashMap<String, Object>(); 
  25.         String query = " select * from usermaster"; 
  26.         try { 
  27.             map = postgresTemplate.queryForMap(query); 
  28.         } catch (Exception e) { 
  29.             e.printStackTrace(); 
  30.         } 
  31.         return "PostgreSQL Data: " + map.toString(); 
  32.     } 
  33.  
  34.     @RequestMapping(value = "/getMYUser") 
  35.     public String getMYUser() { 
  36.         Map<String, Object> map = new HashMap<String, Object>(); 
  37.         String query = " select * from usermaster"; 
  38.         try { 
  39.             map = mysqlTemplate.queryForMap(query); 
  40.         } catch (Exception e) { 
  41.             e.printStackTrace(); 
  42.         } 
  43.         return "MySQL Data: " + map.toString(); 
  44.     } 

解释:

@RestController类注解表明这个类中定义的所有函数都被默认绑定到响应中。

上面代码段创建了一个JdbcTemplate实例。@Qualifier用于生成一个对应类型的模板。代码中提供的是postgresJdbcTemplate作为Qualifier参数,所以它会加载MultipleDBConfig实例的jdbcTemplate(…)函数创建的Bean。

这样Spring就会根据你的要求来调用合适的JDBC模板。在调用URL “/getPGUser”时Spring会用PostgreSQL模板,调用URL “/getMYUser”时Spring会用MySQL模板。

@Autowired

@Qualifier("postgresJdbcTemplate") private JdbcTemplate postgresTemplate;

这里我们用queryForMap(String query)函数来使用JDBC模板从数据库中获取数据,queryForMap(…)返回一个map,以字段名为Key,Value为实际字段值。

演示

执行类MultipleDbApplication中的main (…)函数就可以看到演示效果。在你常用的浏览器中点击下面URL:

URL: http://localhost:6060/getMYUser

上面的URL会查询MySQL数据库并以字符串形式返回数据。

Url: http://localhost:6060/getPGUser

上面的URL会查询PostgreSQL数据库并以字符串形式返回数据。

作者:Nicolas Frankel

来源:51CTO

转载地址:http://zbldx.baihongyu.com/

你可能感兴趣的文章
【PMP】Head First PMP 学习笔记 第一章 引言
查看>>
抓住云机遇编排工作 搞定复杂IT工作流
查看>>
MYSQL的longtext字段能放多少数据?
查看>>
MTK 平台上如何给 camera 添加一种 preview size
查看>>
云计算最大难处
查看>>
关于数据分析思路的4点心得
查看>>
Memcached安装与配置
查看>>
美团数据仓库的演进
查看>>
SAP被评为“大数据”预测分析领军企业
查看>>
联想企业网盘张跃华:让文件创造业务价值
查看>>
记录一次蚂蚁金服前端电话面试
查看>>
直播源码开发视频直播平台,不得不了解的流程
查看>>
Ubuntu上的pycrypto给出了编译器错误
查看>>
聊聊flink的RestClientConfiguration
查看>>
在CentOS上搭建git仓库服务器以及mac端进行克隆和提交到远程git仓库
查看>>
測試文章
查看>>
Flex很难?一文就足够了
查看>>
【BATJ面试必会】JAVA面试到底需要掌握什么?【上】
查看>>
CollabNet_Subversion小结
查看>>
mysql定时备份自动上传
查看>>