0x01 介绍

在SpringBoot里面想要使用DataSource十分简单

0x02 环境搭配

如果还不会搭建环境的可以按照下面的文章跟着搭建

Mac版IDEA创建SpringBoot2.5.1项目-详细过程: https://www.yuque.com/pmiaowu/gpy1q8/art0tm

0x03 默认数据源

SpringBoot默认支持4种数据源类型分别是:

  • org.apache.tomcat.jdbc.pool.DataSource
  • com.zaxxer.hikari.HikariDataSource
  • org.apache.commons.dbcp.BasicDataSource
  • org.apache.commons.dbcp2.BasicDataSource

定义在org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration中

这四种数据源,当classpath下有相应的类存在时,SpringBoot会通过自动配置为其生成DataSource
Bean/DataSource Bean默认只会生成一个
四种数据源类型的生效先后顺序如下: Tomcat->Hikari->Dbcp->Dbcp2

注: SpringBoot1.0时数据源默认使用的是Tomcat, 2.0以后换成了Hikari
1.0时,只要导入jdbc、jpa或者mybatis三者依赖之一,默认就带上Tomcat数据源
2.0以后只要导入jdbc、jpa或者mybatis三者依赖之一,默认就带上Hikari数据源

0x03.1 添加依赖与配置

按照上面的搭建完环境以后,就找到pom.xml找到<dependencies>标签
然后如下使用maven自动添加包,我这里就连接MySQL数据库进行演示了

  1. <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
  2. <dependency>
  3.     <groupId>mysql</groupId>
  4.     <artifactId>mysql-connector-java</artifactId>
  5.     <version>5.1.41</version>
  6. </dependency>

image.png
接着打开application.properties文件或是application.yml文件配置数据库连接属性即可
配置如下:

  1. # application.properties文件中添加如下配置:
  2. spring.datasource.url = jdbc:mysql://192.168.24.135:3306/mysql?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
  3. spring.datasource.driver-class-name = com.mysql.jdbc.Driver
  4. spring.datasource.username = root
  5. spring.datasource.password = 123456
  1. # application.yml文件中添加如下配置:
  2. spring:
  3.   # 数据库配置
  4.   datasource:
  5.     # mysql连接地址
  6.     url: jdbc:mysql://192.168.24.135:3306/mysql?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
  7.     # 用户名
  8.     username: root
  9.     # 密码
  10.     password: 123456
  11.     # 数据库链接驱动
  12.     driver-class-name: com.mysql.jdbc.Driver

注意-1:application.properties文件或是application.yml文件,需要在resources目录创建
注意-2: 两个文件存在时application.properties优先级更高

0x03.2 普通使用

在./src/main/java/com/example/demo/controller目录创建DbTest1Controller.java

  1. // 文件名字: DbTest1Controller.java
  2. package com.example.demo.controller;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
  6. import org.springframework.context.ApplicationContext;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  8. import org.springframework.stereotype.Controller;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.ResponseBody;
  12. import javax.sql.DataSource;
  13. import java.util.List;
  14. import java.util.Map;
  16. @Controller
  17. public class DbTest1Controller {
  18.     @Autowired
  19.     DataSourceProperties dataSourceProperties;
  21.     @Autowired
  22.     ApplicationContext applicationContext;
  24.     @ResponseBody
  25.     @RequestMapping("/DbTest1/index")
  26.     public String index() {
  27.         // 获取配置的数据源
  28.         DataSource dataSource = applicationContext.getBean(DataSource.class);
  30.         //执行SQL,输出查到的数据
  31.         JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
  32.         List<?> resultList = jdbcTemplate.queryForList("select * from user");
  34.         // 要显示的结果
  35.         String s = "";
  37.         // 查看配置数据源信息
  38.         s += dataSource + "<br/>";
  39.         s += dataSource.getClass().getName() + "<br/>";
  40.         s += dataSourceProperties + "<br/>";
  41.         s += "<br/>";
  43.         // 数据展示
  44.         for (Object result : resultList) {
  45.             Map<String, Object> r = (Map<String, Object>) result;
  46.             s += "用户名: " + r.get("User") + "     ";
  47.             s += "密 码: " + r.get("Password") + "<br/>";
  48.         }
  50.         return s;
  51.     }
  52. }
  58. // 执行该文件
  59. // 例如: http://127.0.0.1:8081/DbTest1/index

image.png

0x03.3 通过注解配置数据源

通过注解配置DataSource会更灵活一些
而且可以根据项目需求配置多个不同的DataSource(用于项目中需要使用多个数据库)

这里的话,我延时配置两个DataSource来进行演示
创建一个datasource目录,新建DataSource1,DataSource2两个文件,通过注解来配置数据源

0x03.3.1 数据库配置

先打开application.yml文件中添加对应的配置
注意: SpringBoot 2.0中使用jdbc-url配置数据库URL, SpringBoot1.5中使用url,不然会导致一个错误,jdbcUrl is required with driverClassName

  1. # application.yml文件中添加如下配置:
  2. spring:
  3.   # 数据库配置
  4.   datasource:
  5.     # 主数据库的配置
  6.     # 默认数据库连接,都会使用它
  7.     data1:
  8.       jdbc-url: jdbc:mysql://192.168.24.135:3306/mysql?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
  9.       username: root
  10.       password: 123456
  11.       driver-class-name: com.mysql.jdbc.Driver
  13.     # 副数据库的配置
  14.     data2:
  15.       jdbc-url: jdbc:mysql://192.168.24.135:3306/mysql?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
  16.       username: root
  17.       password: 123456
  18.       driver-class-name: com.mysql.jdbc.Driver

image.png

0x03.3.2 创建数据源

接着在./src/main/java/com/example/demo创建个datasource目录

首先创建个DataSource1.java文件,这个文件是拿来当主数据库的数据源

  1. // 文件名字: DataSource1.java
  2. package com.example.demo.datasource;
  4. import org.apache.ibatis.session.SqlSessionFactory;
  5. import org.mybatis.spring.SqlSessionFactoryBean;
  6. import org.mybatis.spring.SqlSessionTemplate;
  7. import org.mybatis.spring.annotation.MapperScan;
  8. import org.springframework.beans.factory.annotation.Qualifier;
  9. import org.springframework.boot.jdbc.DataSourceBuilder;
  10. import org.springframework.boot.context.properties.ConfigurationProperties;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  13. import org.springframework.context.annotation.Primary;
  14. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  16. import javax.sql.DataSource;
  18. @Configuration
  19. @MapperScan(sqlSessionFactoryRef = "data1SqlSessionFactory")
  20. public class DataSource1 {
  21.     /**
  22.      * 返回data1数据库的数据源
  23.      *
  24.      * @return
  25.      */
  26.     @Bean(name = "data1Source")
  27.     @Primary
  28.     @ConfigurationProperties(prefix = "spring.datasource.data1")
  29.     public DataSource dataSource() {
  30.         return DataSourceBuilder.create().build();
  31.     }
  33.     /**
  34.      * 返回data1数据库的会话工厂
  35.      *
  36.      * @param ds
  37.      * @return
  38.      * @throws Exception
  39.      */
  40.     @Bean(name = "data1SqlSessionFactory")
  41.     @Primary
  42.     public SqlSessionFactory sqlSessionFactory(@Qualifier("data1Source") DataSource ds) throws Exception {
  43.         SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  44.         bean.setDataSource(ds);
  45.         return bean.getObject();
  46.     }
  48.     /**
  49.      * 返回data1数据库的会话模板
  50.      *
  51.      * @param sessionFactory
  52.      * @return
  53.      * @throws Exception
  54.      */
  55.     @Bean(name = "data1SqlSessionTemplate")
  56.     @Primary
  57.     public SqlSessionTemplate sqlSessionTemplate(@Qualifier("data1SqlSessionFactory") SqlSessionFactory sessionFactory) throws Exception {
  58.         return new SqlSessionTemplate(sessionFactory);
  59.     }
  61.     /**
  62.      * 返回data1数据库的事务
  63.      *
  64.      * @param ds
  65.      * @return
  66.      */
  67.     @Bean(name = "data1TransactionManager")
  68.     @Primary
  69.     public DataSourceTransactionManager transactionManager(@Qualifier("data1Source") DataSource ds) {
  70.         return new DataSourceTransactionManager(ds);
  71.     }
  72. }

然后创建个DataSource2.java文件,这个文件是拿来当副数据库的数据源

  1. // 文件名字: DataSource2.java
  2. package com.example.demo.datasource;
  4. import org.apache.ibatis.session.SqlSessionFactory;
  5. import org.mybatis.spring.SqlSessionFactoryBean;
  6. import org.mybatis.spring.SqlSessionTemplate;
  7. import org.mybatis.spring.annotation.MapperScan;
  8. import org.springframework.beans.factory.annotation.Qualifier;
  9. import org.springframework.boot.jdbc.DataSourceBuilder;
  10. import org.springframework.boot.context.properties.ConfigurationProperties;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  13. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  15. import javax.sql.DataSource;
  17. @Configuration
  18. @MapperScan(sqlSessionFactoryRef = "data2SqlSessionFactory")
  19. public class DataSource2 {
  20.     /**
  21.      * 返回data2数据库的数据源
  22.      *
  23.      * @return
  24.      */
  25.     @Bean(name = "data2Source")
  26.     @ConfigurationProperties(prefix = "spring.datasource.data2")
  27.     public DataSource dataSource() {
  28.         return DataSourceBuilder.create().build();
  29.     }
  31.     /**
  32.      * 返回data2数据库的会话工厂
  33.      *
  34.      * @param ds
  35.      * @return
  36.      * @throws Exception
  37.      */
  38.     @Bean(name = "data2SqlSessionFactory")
  39.     public SqlSessionFactory sqlSessionFactory(@Qualifier("data2Source") DataSource ds) throws Exception {
  40.         SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  41.         bean.setDataSource(ds);
  42.         return bean.getObject();
  43.     }
  45.     /**
  46.      * 返回data2数据库的会话模板
  47.      *
  48.      * @param sessionFactory
  49.      * @return
  50.      * @throws Exception
  51.      */
  52.     @Bean(name = "data2SqlSessionTemplate")
  53.     public SqlSessionTemplate sqlSessionTemplate(@Qualifier("data2SqlSessionFactory") SqlSessionFactory sessionFactory) throws Exception {
  54.         return new SqlSessionTemplate(sessionFactory);
  55.     }
  57.     /**
  58.      * 返回data2数据库的事务
  59.      *
  60.      * @param ds
  61.      * @return
  62.      */
  63.     @Bean(name = "data2TransactionManager")
  64.     public DataSourceTransactionManager transactionManager(@Qualifier("data2Source") DataSource ds) {
  65.         return new DataSourceTransactionManager(ds);
  66.     }
  67. }

DataSource1.java文件与DataSource2.java文件的核心不同就是在于
DataSource1.java文件,每个方法都带了个@Primary这表示它为主数据源
然后默认情况下的数据库连接操作就都会使用DataSource1.java文件进行数据库连接

0x03.3.3 创建测试控制器并测试

在./src/main/java/com/example/demo/controller目录创建DbTest2Controller.java

  1. // 文件名字: DbTest2Controller.java
  2. // DbTest2Controller使用的是主数据源
  3. package com.example.demo.controller;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
  7. import org.springframework.context.ApplicationContext;
  8. import org.springframework.jdbc.core.JdbcTemplate;
  9. import org.springframework.stereotype.Controller;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.ResponseBody;
  13. import javax.annotation.Resource;
  14. import javax.sql.DataSource;
  15. import java.util.List;
  16. import java.util.Map;
  18. @Controller
  19. public class DbTest2Controller {
  20.     @Autowired
  21.     DataSourceProperties dataSourceProperties;
  23.     @Autowired
  24.     ApplicationContext applicationContext;
  26.     @Resource(name = "data1Source")
  27.     private DataSource data1Source;
  29.     @ResponseBody
  30.     @RequestMapping("/DbTest2/index")
  31.     public String index() {
  32.         //执行SQL,输出查到的数据
  33.         JdbcTemplate jdbcTemplate = new JdbcTemplate(data1Source);
  34.         List<?> resultList = jdbcTemplate.queryForList("select * from user");
  36.         // 要显示的结果
  37.         String s = "";
  39.         // 查看配置数据源信息
  40.         s += data1Source + "<br/>";
  41.         s += data1Source.getClass().getName() + "<br/>";
  42.         s += dataSourceProperties + "<br/>";
  43.         s += "<br/>";
  45.         // 数据展示
  46.         for (Object result : resultList) {
  47.             Map<String, Object> r = (Map<String, Object>) result;
  48.             s += "用户名: " + r.get("User") + "     ";
  49.             s += "密 码: " + r.get("Password") + "<br/>";
  50.         }
  52.         return s;
  53.     }
  54. }
  60. // 执行该文件
  61. // 例如: http://127.0.0.1:8081/DbTest2/index
  1. // 文件名字: DbTest3Controller.java
  2. // DbTest3Controller使用的是副数据源
  3. package com.example.demo.controller;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
  7. import org.springframework.context.ApplicationContext;
  8. import org.springframework.jdbc.core.JdbcTemplate;
  9. import org.springframework.stereotype.Controller;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.ResponseBody;
  13. import javax.annotation.Resource;
  14. import javax.sql.DataSource;
  15. import java.util.List;
  16. import java.util.Map;
  18. @Controller
  19. public class DbTest3Controller {
  20.     @Autowired
  21.     DataSourceProperties dataSourceProperties;
  23.     @Autowired
  24.     ApplicationContext applicationContext;
  26.     @Resource(name = "data2Source")
  27.     private DataSource data2Source;
  29.     @ResponseBody
  30.     @RequestMapping("/DbTest3/index")
  31.     public String index() {
  32.         //执行SQL,输出查到的数据
  33.         JdbcTemplate jdbcTemplate = new JdbcTemplate(data2Source);
  34.         List<?> resultList = jdbcTemplate.queryForList("select * from user");
  36.         // 要显示的结果
  37.         String s = "";
  39.         // 查看配置数据源信息
  40.         s += data2Source + "<br/>";
  41.         s += data2Source.getClass().getName() + "<br/>";
  42.         s += dataSourceProperties + "<br/>";
  43.         s += "<br/>";
  45.         // 数据展示
  46.         for (Object result : resultList) {
  47.             Map<String, Object> r = (Map<String, Object>) result;
  48.             s += "用户名: " + r.get("User") + "     ";
  49.             s += "密 码: " + r.get("Password") + "<br/>";
  50.         }
  52.         return s;
  53.     }
  54. }
  60. // 执行该文件
  61. // 例如: http://127.0.0.1:8081/DbTest3/index

image.png
可以看的到http://127.0.0.1:8081/DbTest1/index 与 http://127.0.0.1:8081/DbTest2/index是一致的
表示现在默认情况下的数据库连接使用的都是datasource1.java作为,主数据源
而http://127.0.0.1:8081/DbTest3/index设置的是`datasource2.java`所以不受影响

0x04 第三方数据源

如果不想使用SpringBoot默认支持的4种数据源,还可以选择使用其他第三方的数据源
例如：Druid、C3P0等,这里我使用Druid数据源为例

0x04.1 添加依赖

按照上面的搭建完环境以后,就找到pom.xml找到<dependencies>标签
然后如下使用maven自动添加包

  1. <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
  2. <dependency>
  3.     <groupId>com.alibaba</groupId>
  4.     <artifactId>druid</artifactId>
  5.     <version>1.1.23</version>
  6. </dependency>

image.png

0x04.2 配置数据库

接着打开application.properties文件或是application.yml文件配置数据库连接属性即可
配置如下:

  1. # application.properties文件中添加如下配置:
  2. spring.datasource.data3.jdbc-url = jdbc:mysql://192.168.24.135:3306/mysql?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
  3. spring.datasource.data3.driver-class-name = com.mysql.jdbc.Driver
  4. spring.datasource.data3.username = root
  5. spring.datasource.data3.password = 123456
  1. # application.yml文件中添加如下配置:
  2. spring:
  3.   # 数据库配置
  4.   datasource:
  5.     # 副数据库的配置
  6.     data3:
  7.       jdbc-url: jdbc:mysql://192.168.24.135:3306/mysql?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
  8.       username: root
  9.       password: 123456
  10.       driver-class-name: com.mysql.jdbc.Driver

0x04.3 创建数据源

接着在./src/main/java/com/example/demo创建个datasource目录

首先创建个DataSource3.java文件,这个文件是使用拿来当副数据库的Druid数据源

  1. // 文件名字: DataSource3.java
  2. package com.example.demo.datasource;
  4. import com.alibaba.druid.pool.DruidDataSource;
  5. import org.apache.ibatis.session.SqlSessionFactory;
  6. import org.mybatis.spring.SqlSessionFactoryBean;
  7. import org.mybatis.spring.SqlSessionTemplate;
  8. import org.mybatis.spring.annotation.MapperScan;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.beans.factory.annotation.Qualifier;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  13. import org.springframework.core.env.Environment;
  14. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  16. import javax.sql.DataSource;
  18. @Configuration
  19. @MapperScan(sqlSessionFactoryRef = "data3SqlSessionFactory")
  20. public class DataSource3 {
  21.     @Autowired
  22.     private Environment env;
  24.     /**
  25.      * 返回data3数据库的数据源
  26.      *
  27.      * @return
  28.      */
  29.     @Bean(name = "data3Source")
  30.     public DataSource dataSource() {
  31.         DruidDataSource dataSource = new DruidDataSource();
  32.         dataSource.setUrl(env.getProperty("spring.datasource.data3.jdbc-url"));
  33.         dataSource.setUsername(env.getProperty("spring.datasource.data3.username"));
  34.         dataSource.setPassword(env.getProperty("spring.datasource.data3.password"));
  35.         dataSource.setDriverClassName(env.getProperty("spring.datasource.data3.driver-class-name"));
  36.         return dataSource;
  37.     }
  39.     /**
  40.      * 返回data3数据库的会话工厂
  41.      *
  42.      * @param ds
  43.      * @return
  44.      * @throws Exception
  45.      */
  46.     @Bean(name = "data3SqlSessionFactory")
  47.     public SqlSessionFactory sqlSessionFactory(@Qualifier("data3Source") DataSource ds) throws Exception {
  48.         SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  49.         bean.setDataSource(ds);
  50.         return bean.getObject();
  51.     }
  53.     /**
  54.      * 返回data3数据库的会话模板
  55.      *
  56.      * @param sessionFactory
  57.      * @return
  58.      * @throws Exception
  59.      */
  60.     @Bean(name = "data3SqlSessionTemplate")
  61.     public SqlSessionTemplate sqlSessionTemplate(@Qualifier("data3SqlSessionFactory") SqlSessionFactory sessionFactory) throws Exception {
  62.         return new SqlSessionTemplate(sessionFactory);
  63.     }
  65.     /**
  66.      * 返回data3数据库的事务
  67.      *
  68.      * @param ds
  69.      * @return
  70.      */
  71.     @Bean(name = "data3TransactionManager")
  72.     public DataSourceTransactionManager transactionManager(@Qualifier("data3Source") DataSource ds) {
  73.         return new DataSourceTransactionManager(ds);
  74.     }
  75. }

0x04.4 创建测试控制器并测试

在./src/main/java/com/example/demo/controller目录创建DbTest4Controller.java

  1. // 文件名字: DbTest4Controller.java
  2. // DbTest4Controller使用的是Druid作为数据源
  3. package com.example.demo.controller;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
  7. import org.springframework.context.ApplicationContext;
  8. import org.springframework.jdbc.core.JdbcTemplate;
  9. import org.springframework.stereotype.Controller;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.ResponseBody;
  13. import javax.annotation.Resource;
  14. import javax.sql.DataSource;
  15. import java.util.List;
  16. import java.util.Map;
  18. @Controller
  19. public class DbTest4Controller {
  20.     @Autowired
  21.     DataSourceProperties dataSourceProperties;
  23.     @Autowired
  24.     ApplicationContext applicationContext;
  26.     @Resource(name = "data3Source")
  27.     private DataSource data3Source;
  29.     @ResponseBody
  30.     @RequestMapping("/DbTest4/index")
  31.     public String index() {
  32.         //执行SQL,输出查到的数据
  33.         JdbcTemplate jdbcTemplate = new JdbcTemplate(data3Source);
  34.         List<?> resultList = jdbcTemplate.queryForList("select * from user");
  36.         // 要显示的结果
  37.         String s = "";
  39.         // 查看配置数据源信息
  40.         s += data3Source + "<br/>";
  41.         s += data3Source.getClass().getName() + "<br/>";
  42.         s += dataSourceProperties + "<br/>";
  43.         s += "<br/>";
  45.         // 数据展示
  46.         for (Object result : resultList) {
  47.             Map<String, Object> r = (Map<String, Object>) result;
  48.             s += "用户名: " + r.get("User") + "     ";
  49.             s += "密 码: " + r.get("Password") + "<br/>";
  50.         }
  52.         return s;
  53.     }
  54. }
  60. // 执行该文件
  61. // 例如: http://127.0.0.1:8081/DbTest4/index

image.png

0x05 小结

了解一些基础SpringBoot数据库操作,也是不错的
在实战中遇到SpringBoot项目的话,想找数据库配置
一般找项目的./src/main/resources/目录下即可查找到

0x06 参考文章

https://blog.csdn.net/tanga842428/article/details/79484753
https://blog.csdn.net/pengjunlee/article/details/80081231
https://blog.csdn.net/nizhengjia888/article/details/85063033
https://blog.csdn.net/qq_35760213/article/details/73863252
https://blog.csdn.net/qq_39016934/article/details/89892172
https://www.cnblogs.com/lijianda/p/11022892.html