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数据库进行演示了

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.41</version>
</dependency>

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

# application.properties文件中添加如下配置:
spring.datasource.url = jdbc:mysql://192.168.24.135:3306/mysql?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
spring.datasource.driver-class-name = com.mysql.jdbc.Driver
spring.datasource.username = root
spring.datasource.password = 123456

# application.yml文件中添加如下配置:
spring:
  # 数据库配置
  datasource:
    # mysql连接地址
    url: jdbc:mysql://192.168.24.135:3306/mysql?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
    # 用户名
    username: root
    # 密码
    password: 123456
    # 数据库链接驱动
    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

// 文件名字: DbTest1Controller.java
package com.example.demo.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.sql.DataSource;
import java.util.List;
import java.util.Map;
@Controller
public class DbTest1Controller {
    @Autowired
    DataSourceProperties dataSourceProperties;
    @Autowired
    ApplicationContext applicationContext;
    @ResponseBody
    @RequestMapping("/DbTest1/index")
    public String index() {
        // 获取配置的数据源
        DataSource dataSource = applicationContext.getBean(DataSource.class);
        //执行SQL,输出查到的数据
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        List<?> resultList = jdbcTemplate.queryForList("select * from user");
        // 要显示的结果
        String s = "";
        // 查看配置数据源信息
        s += dataSource + "<br/>";
        s += dataSource.getClass().getName() + "<br/>";
        s += dataSourceProperties + "<br/>";
        s += "<br/>";
        // 数据展示
        for (Object result : resultList) {
            Map<String, Object> r = (Map<String, Object>) result;
            s += "用户名: " + r.get("User") + "     ";
            s += "密 码: " + r.get("Password") + "<br/>";
        }
        return s;
    }
}
// 执行该文件
// 例如: http://127.0.0.1:8081/DbTest1/index

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

# application.yml文件中添加如下配置:
spring:
  # 数据库配置
  datasource:
    # 主数据库的配置
    # 默认数据库连接,都会使用它
    data1:
      jdbc-url: jdbc:mysql://192.168.24.135:3306/mysql?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
    # 副数据库的配置
    data2:
      jdbc-url: jdbc:mysql://192.168.24.135:3306/mysql?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver

0x03.3.2 创建数据源

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

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

// 文件名字: DataSource1.java
package com.example.demo.datasource;
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.beans.factory.annotation.Qualifier;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import javax.sql.DataSource;
@Configuration
@MapperScan(sqlSessionFactoryRef = "data1SqlSessionFactory")
public class DataSource1 {
    /**
     * 返回data1数据库的数据源
     *
     * @return
     */
    @Bean(name = "data1Source")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.data1")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
    /**
     * 返回data1数据库的会话工厂
     *
     * @param ds
     * @return
     * @throws Exception
     */
    @Bean(name = "data1SqlSessionFactory")
    @Primary
    public SqlSessionFactory sqlSessionFactory(@Qualifier("data1Source") DataSource ds) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(ds);
        return bean.getObject();
    }
    /**
     * 返回data1数据库的会话模板
     *
     * @param sessionFactory
     * @return
     * @throws Exception
     */
    @Bean(name = "data1SqlSessionTemplate")
    @Primary
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("data1SqlSessionFactory") SqlSessionFactory sessionFactory) throws Exception {
        return new SqlSessionTemplate(sessionFactory);
    }
    /**
     * 返回data1数据库的事务
     *
     * @param ds
     * @return
     */
    @Bean(name = "data1TransactionManager")
    @Primary
    public DataSourceTransactionManager transactionManager(@Qualifier("data1Source") DataSource ds) {
        return new DataSourceTransactionManager(ds);
    }
}

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

// 文件名字: DataSource2.java
package com.example.demo.datasource;
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.beans.factory.annotation.Qualifier;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import javax.sql.DataSource;
@Configuration
@MapperScan(sqlSessionFactoryRef = "data2SqlSessionFactory")
public class DataSource2 {
    /**
     * 返回data2数据库的数据源
     *
     * @return
     */
    @Bean(name = "data2Source")
    @ConfigurationProperties(prefix = "spring.datasource.data2")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
    /**
     * 返回data2数据库的会话工厂
     *
     * @param ds
     * @return
     * @throws Exception
     */
    @Bean(name = "data2SqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("data2Source") DataSource ds) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(ds);
        return bean.getObject();
    }
    /**
     * 返回data2数据库的会话模板
     *
     * @param sessionFactory
     * @return
     * @throws Exception
     */
    @Bean(name = "data2SqlSessionTemplate")
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("data2SqlSessionFactory") SqlSessionFactory sessionFactory) throws Exception {
        return new SqlSessionTemplate(sessionFactory);
    }
    /**
     * 返回data2数据库的事务
     *
     * @param ds
     * @return
     */
    @Bean(name = "data2TransactionManager")
    public DataSourceTransactionManager transactionManager(@Qualifier("data2Source") DataSource ds) {
        return new DataSourceTransactionManager(ds);
    }
}

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

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

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

// 文件名字: DbTest2Controller.java
// DbTest2Controller使用的是主数据源
package com.example.demo.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.List;
import java.util.Map;
@Controller
public class DbTest2Controller {
    @Autowired
    DataSourceProperties dataSourceProperties;
    @Autowired
    ApplicationContext applicationContext;
    @Resource(name = "data1Source")
    private DataSource data1Source;
    @ResponseBody
    @RequestMapping("/DbTest2/index")
    public String index() {
        //执行SQL,输出查到的数据
        JdbcTemplate jdbcTemplate = new JdbcTemplate(data1Source);
        List<?> resultList = jdbcTemplate.queryForList("select * from user");
        // 要显示的结果
        String s = "";
        // 查看配置数据源信息
        s += data1Source + "<br/>";
        s += data1Source.getClass().getName() + "<br/>";
        s += dataSourceProperties + "<br/>";
        s += "<br/>";
        // 数据展示
        for (Object result : resultList) {
            Map<String, Object> r = (Map<String, Object>) result;
            s += "用户名: " + r.get("User") + "     ";
            s += "密 码: " + r.get("Password") + "<br/>";
        }
        return s;
    }
}
// 执行该文件
// 例如: http://127.0.0.1:8081/DbTest2/index

// 文件名字: DbTest3Controller.java
// DbTest3Controller使用的是副数据源
package com.example.demo.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.List;
import java.util.Map;
@Controller
public class DbTest3Controller {
    @Autowired
    DataSourceProperties dataSourceProperties;
    @Autowired
    ApplicationContext applicationContext;
    @Resource(name = "data2Source")
    private DataSource data2Source;
    @ResponseBody
    @RequestMapping("/DbTest3/index")
    public String index() {
        //执行SQL,输出查到的数据
        JdbcTemplate jdbcTemplate = new JdbcTemplate(data2Source);
        List<?> resultList = jdbcTemplate.queryForList("select * from user");
        // 要显示的结果
        String s = "";
        // 查看配置数据源信息
        s += data2Source + "<br/>";
        s += data2Source.getClass().getName() + "<br/>";
        s += dataSourceProperties + "<br/>";
        s += "<br/>";
        // 数据展示
        for (Object result : resultList) {
            Map<String, Object> r = (Map<String, Object>) result;
            s += "用户名: " + r.get("User") + "     ";
            s += "密 码: " + r.get("Password") + "<br/>";
        }
        return s;
    }
}
// 执行该文件
// 例如: http://127.0.0.1:8081/DbTest3/index

可以看的到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自动添加包

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.23</version>
</dependency>

0x04.2 配置数据库

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

# application.properties文件中添加如下配置:
spring.datasource.data3.jdbc-url = jdbc:mysql://192.168.24.135:3306/mysql?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
spring.datasource.data3.driver-class-name = com.mysql.jdbc.Driver
spring.datasource.data3.username = root
spring.datasource.data3.password = 123456

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

0x04.3 创建数据源

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

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

// 文件名字: DataSource3.java
package com.example.demo.datasource;
import com.alibaba.druid.pool.DruidDataSource;
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.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import javax.sql.DataSource;
@Configuration
@MapperScan(sqlSessionFactoryRef = "data3SqlSessionFactory")
public class DataSource3 {
    @Autowired
    private Environment env;
    /**
     * 返回data3数据库的数据源
     *
     * @return
     */
    @Bean(name = "data3Source")
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(env.getProperty("spring.datasource.data3.jdbc-url"));
        dataSource.setUsername(env.getProperty("spring.datasource.data3.username"));
        dataSource.setPassword(env.getProperty("spring.datasource.data3.password"));
        dataSource.setDriverClassName(env.getProperty("spring.datasource.data3.driver-class-name"));
        return dataSource;
    }
    /**
     * 返回data3数据库的会话工厂
     *
     * @param ds
     * @return
     * @throws Exception
     */
    @Bean(name = "data3SqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("data3Source") DataSource ds) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(ds);
        return bean.getObject();
    }
    /**
     * 返回data3数据库的会话模板
     *
     * @param sessionFactory
     * @return
     * @throws Exception
     */
    @Bean(name = "data3SqlSessionTemplate")
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("data3SqlSessionFactory") SqlSessionFactory sessionFactory) throws Exception {
        return new SqlSessionTemplate(sessionFactory);
    }
    /**
     * 返回data3数据库的事务
     *
     * @param ds
     * @return
     */
    @Bean(name = "data3TransactionManager")
    public DataSourceTransactionManager transactionManager(@Qualifier("data3Source") DataSource ds) {
        return new DataSourceTransactionManager(ds);
    }
}

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

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

// 文件名字: DbTest4Controller.java
// DbTest4Controller使用的是Druid作为数据源
package com.example.demo.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.List;
import java.util.Map;
@Controller
public class DbTest4Controller {
    @Autowired
    DataSourceProperties dataSourceProperties;
    @Autowired
    ApplicationContext applicationContext;
    @Resource(name = "data3Source")
    private DataSource data3Source;
    @ResponseBody
    @RequestMapping("/DbTest4/index")
    public String index() {
        //执行SQL,输出查到的数据
        JdbcTemplate jdbcTemplate = new JdbcTemplate(data3Source);
        List<?> resultList = jdbcTemplate.queryForList("select * from user");
        // 要显示的结果
        String s = "";
        // 查看配置数据源信息
        s += data3Source + "<br/>";
        s += data3Source.getClass().getName() + "<br/>";
        s += dataSourceProperties + "<br/>";
        s += "<br/>";
        // 数据展示
        for (Object result : resultList) {
            Map<String, Object> r = (Map<String, Object>) result;
            s += "用户名: " + r.get("User") + "     ";
            s += "密 码: " + r.get("Password") + "<br/>";
        }
        return s;
    }
}
// 执行该文件
// 例如: http://127.0.0.1:8081/DbTest4/index

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

Java 安全漫游记

3. SpringBoot DataSource使用