目录

环境准备与依赖

数据库 CRUD

默认数据源 HikariDataSource

JdbcTemplate CRUD 数据库

数据源自动配置原理

环境准备与依赖

1、本文介绍 Spring Boot 内部集成的 JDBC 模板访问 Mysql 数据库，环境：java jdk 1.8 + Spring boot 2.0.4 + Mysql 。

2、pom. xml 依赖如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>www.wmx.com.horse</groupId>
    <artifactId>horse</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>horse</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/>
        <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!-- 引入Spring封装的jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!-- 引入html模板引擎Thymeleaf-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

        <!-- 因为web项目启动模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 引入mysql数据库连接驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- 引入Spring Boot 测试模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- Spring Boot 打包插件-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>


mysql 数据库

1、此 Mysql 数据库是在 CentOS 7.2 中的 Docker 容器中，所以用了 CentOS 的 3307 端口映射了 Docker 容器的 3306 端口，CentOS 主机 ip 为 192.168.58.129

2、账号 root、密码 root。



数据库 CRUD

1、全局配置文件内容如下：

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://192.168.58.129:3307/horse?characterEncoding=UTF-8
    driver-class-name: com.mysql.jdbc.Driver

高版本的 spring boot 搭配 mysql 驱动版本较高时，如 mysql-connector-java:8.0.16，此时 driver-class-name 的值要带 cj;url 的值要带时区 serverTimezone，如：
url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=UTF-8&serverTimezone=UTC

			driver-class-name: com.mysql.cj.jdbc.Driver
		
1、配置的内容以及意义就如同以前在 Sping 核心配置文件 beans.xml 中配置时是一样的

2、到这里就已经可以操作数据库了，因为 Spring Boot 都已经自动配置好了，如 Spring Boot 默认已经提供了数据源

3、关于上面的数据源配置内容，都可以从 Spring Boot 官方文档 查看

# DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.continue-on-error=false # Whether to stop if an error occurs while initializing the database.
spring.datasource.data= # Data (DML) script resource references.
spring.datasource.data-username= # Username of the database to execute DML scripts (if different).
spring.datasource.data-password= # Password of the database to execute DML scripts (if different).
spring.datasource.dbcp2.*= # Commons DBCP2 specific settings
spring.datasource.driver-class-name= # Fully qualified name of the JDBC driver. Auto-detected based on the URL by default.
spring.datasource.generate-unique-name=false # Whether to generate a random datasource name.
spring.datasource.hikari.*= # Hikari specific settings
spring.datasource.initialization-mode=embedded # Initialize the datasource with available DDL and DML scripts.
spring.datasource.jmx-enabled=false # Whether to enable JMX support (if provided by the underlying pool).
spring.datasource.jndi-name= # JNDI location of the datasource. Class, url, username & password are ignored when set.
spring.datasource.name= # Name of the datasource. Default to "testdb" when using an embedded database.
spring.datasource.password= # Login password of the database.
spring.datasource.platform=all # Platform to use in the DDL or DML scripts (such as schema-${platform}.sql or data-${platform}.sql).
spring.datasource.schema= # Schema (DDL) script resource references.
spring.datasource.schema-username= # Username of the database to execute DDL scripts (if different).
spring.datasource.schema-password= # Password of the database to execute DDL scripts (if different).
spring.datasource.separator=; # Statement separator in SQL initialization scripts.
spring.datasource.sql-script-encoding= # SQL scripts encoding.
spring.datasource.tomcat.*= # Tomcat datasource specific settings
spring.datasource.type= # Fully qualified name of the connection pool implementation to use. By default, it is auto-detected from the classpath.
spring.datasource.url= # JDBC URL of the database.
spring.datasource.username= # Login username of the database.
spring.datasource.xa.data-source-class-name= # XA datasource fully qualified name.
spring.datasource.xa.properties= # Properties to pass to the XA data source.

4、也可以从 org.springframework.boot.autoconfigure.jdbc.DataSourceProperties 数据源配置文件类中进行查看

默认数据源 HikariDataSource

1、全局配置文件 application.yml 中 spring.datasource 下只配置了账号、密码、数据库地址、连接驱动，因为默认使用的是 class com.zaxxer.hikari.HikariDataSource 数据源

2、如果过是自定义数据源，比如 DruidDataSource，则可以使用 type 指定，如下所示：type: com.alibaba.druid.pool.DruidDataSource，可以参考《切换 Druid 数据源》

3、测试数据源如下：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;

@RunWith(SpringRunner.class)
@SpringBootTest
public class HorseApplicationTests {
    /**
     * Spring Boot 默认已经配置好了数据源，程序员可以直接 DI 注入然后使用即可
     */
    @Resource
    DataSource dataSource;
    @Test
    public void contextLoads() throws SQLException {
 Connection connection = dataSource.getConnection();
        DatabaseMetaData metaData = connection.getMetaData();

        //数据源>>>>>>class com.zaxxer.hikari.HikariDataSource
        System.out.println("数据源>>>>>>" + dataSource.getClass());
        System.out.println("连接>>>>>>>>" + connection);
        System.out.println("连接地址>>>>" + connection.getMetaData().getURL());
        System.out.println("驱动名称>>>>" + metaData.getDriverName());
        System.out.println("驱动版本>>>>" + metaData.getDriverVersion());
        System.out.println("数据库名称>>" + metaData.getDatabaseProductName());
        System.out.println("数据库版本>>" + metaData.getDatabaseProductVersion());
        System.out.println("连接用户名称>" + metaData.getUserName());

        connection.close();
    }
}


1、可以看出 Spring Boot 2.0.4 默认使用 com.zaxxer.hikari.HikariDataSource 数据源，而以前版本，如 Spring Boot 1.5 默认使用 org.apache.tomcat.jdbc.pool.DataSource 作为数据源；

2、HikariDataSource 号称 Java WEB 当前速度最快的数据源，相比于传统的 C3P0 、DBCP、Tomcat jdbc 等连接池更加优秀；

3、HikariDataSource 的内容本文暂时不做延伸，有了数据库连接，显然就可以 CRUD 操作数据库了。

JdbcTemplate CRUD 数据库

1、有了数据源(com.zaxxer.hikari.HikariDataSource)，然后拿到l了数据库连接(java.sql.Connection)，自然就可以使用连接和原生的 JDCB 语句来操作数据库

2、即使不使用第三方第数据库操作框架，如 MyBatis、Hibernate 、JDBC Utils 等，Spring 本身也对 原生的 JDBC 做了轻量级的封装，即 org.springframework.jdbc.core.JdbcTemplate。这原本是 Spring 的知识点！

3、数据库操作的所有 CRUD 方法都在 JdbcTemplate 中，有了 JdbcTemplate 就能更加轻松的操作数据库。

4、Spring Boot 不仅提供了默认的数据源，同时默认已经配置好了 JdbcTemplate 放在了容器中，程序员只需自己注入即可使用

5、JdbcTemplate  的自动配置原理是依赖 org.springframework.boot.autoconfigure.jdbc 包下的 org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration 类

PhoneController 控制层

1、为了尽可能符合实际开发，新建一个控制层，通过浏览器访问来进行 CRUD，但是不再进行细致的分层，如 dao、service、domain 等都省略

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
/**
 * Created by Administrator on 2018/8/19 0019.
 */
@Controller
public class PhoneController {
    /**
     * JdbcTemplate 是 core 包的核心类，用于简化 JDBC 操作，还能避免一些常见的错误，如忘记关闭数据库连接
     * Spring Boot 默认提供了数据源，默认提供了 org.springframework.jdbc.core.JdbcTemplate
     * JdbcTemplate 中会自己注入数据源，使用起来也不用再自己来关闭数据库连接
     */
    @Resource
    JdbcTemplate jdbcTemplate;
    /**
     * 查询 phone 表所有数据
     *
     * @return
     */
    @ResponseBody
    @GetMapping("phoneList")
    public List<Map<String, Object>> userList() {
        /**
         * 查询 phone 表所有数据
         * List 中的1个 Map 对应数据库的 1行数据
         * Map 中的 key 对应数据库的字段名，value 对应数据库的字段值
         */
        List<Map<String, Object>> mapList = jdbcTemplate.queryForList("SELECT * FROM phone");
        return mapList;
    }
    /**
     * 新增 phone 数据
     *
     * @return
     */
    @GetMapping("savePhone")
    public String savePhone() {
        String sql = "INSERT INTO phone(number,region) VALUES (?,?)";
        Object[] objects = new Object[2];
        objects[0] = "18673886425";
        objects[1] = "湖南";

        jdbcTemplate.update(sql, objects);
        return "forward:/phoneList";
    }
    /**
     * 修改 phone 数据
     *
     * @return
     */
    @GetMapping("updatePhone")
    public String updatePhone() {
        String sql = "UPDATE phone SET number=? WHERE pid=?";
        Object[] objects = new Object[2];
        objects[0] = "18666668888";
        objects[1] = "1";

        jdbcTemplate.update(sql, objects);
        return "forward:/phoneList";
    }
    /**
     * 删除 phone 数据
     * update 方法可以做查询以外的 增加、修改、删除操作
     *
     * @return
     */
    @GetMapping("deletePhone")
    public String deletePhone() {
        String sql = "DELETE FROM phone WHERE number=?";
        Object[] objects = new Object[1];
        objects[0] = "18673886425";

        jdbcTemplate.update(sql, objects);
        return "forward:/phoneList";
    }
}


1、浏览器访问测试


查询：http://localhost:8080/phoneList

添加：http://localhost:8080/savePhone

修改：http://localhost:8080/updatePhone

删除：http://localhost:8080/deletePhone








 



数据源自动配置原理

1、自动配置都在 org.springframework.boot.autoconfigure.jdbc 包下。

2、org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration 数据源配置类作用是根据逻辑判断之后，添加数据源

3、SpringBoot 默认支持如下数据源；

1、com.zaxxer.hikari.HikariDataSource （Spring Boot 2.0 以上，默认使用此数据源）

			2、org.apache.tomcat.jdbc.pool.DataSource

			3、org.apache.commons.dbcp2.BasicDataSource
		
4、可以使用 spring.datasource.type 指定自定义的数据源类型，值为 要使用的连接池实现的完全限定名。默认情况下，它是从类路径自动检测的。

    @ConditionalOnMissingBean({DataSource.class})
    @ConditionalOnProperty(
        name = {"spring.datasource.type"}
    )
    static class Generic {
        Generic() {
        }
        @Bean
        public DataSource dataSource(DataSourceProperties properties) {
            return properties.initializeDataSourceBuilder().build();
        }
    }

《Spring Boot 自定义数据源 DruidDataSource》

目录

默认数据源

添加依赖与配置

切换默认数据源

方式一

方式二 

第三方数据源

添加依赖与配置

定义数据源

默认数据源

Springboot默认支持4种数据源类型，定义在 org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration 中，分别是：

org.apache.tomcat.jdbc.pool.DataSource
	
com.zaxxer.hikari.HikariDataSource
	
org.apache.commons.dbcp.BasicDataSource
	
org.apache.commons.dbcp2.BasicDataSource
对于这4种数据源，当 classpath 下有相应的类存在时，Springboot 会通过自动配置为其生成DataSource Bean，DataSource Bean默认只会生成一个，四种数据源类型的生效先后顺序如下：Tomcat--> Hikari --> Dbcp --> Dbcp2 。 

添加依赖与配置

在Springboot 使用JDBC可直接添加官方提供的 spring-boot-start-jdbc 或者 spring-boot-start-data-jpa 依赖。 

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.4.1.RELEASE</version>
	</parent>
	<dependencies>
		<!-- 添加MySQL依赖 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		<!-- 添加JDBC依赖 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
	</dependencies>

在核心配置application.properties或者application.yml文件中添加数据源相关配置。 

# application.properties文件中添加如下配置：
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=123456

 

# application.yml文件中添加如下配置：
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
    driverClassName: com.mysql.jdbc.Driver
    username: root
    password: 123456

切换默认数据源

方式一 排除其他的数据源依赖，仅保留需要的数据源依赖； 

方式二 通过在核心配置中通过spring.datasource.type属性指定数据源的类型； 

方式一

Springboot默认支持的4种数据源Maven依赖如下：

		<!-- 添加Tomcat-JDBC依赖 -->
		<dependency>
			<groupId>org.apache.tomcat</groupId>
			<artifactId>tomcat-jdbc</artifactId>
		</dependency>
		<!-- 添加HikariCP依赖 -->
		<dependency>
			<groupId>com.zaxxer</groupId>
			<artifactId>HikariCP</artifactId>
		</dependency>
		<!-- 添加DBCP依赖 -->
		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
		</dependency>
		<!-- 添加DBCP2依赖 -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-dbcp2</artifactId>
		</dependency>

当我们引入spring-boot-start-jdbc依赖时，其实里面就包含了 Tomcat-JDBC 的依赖，如果想要切换为其他的数据源类型，需要先将Tomcat-JDBC 依赖排除，再添加上需要的数据源的依赖，以使用HikariCP数据源为例，依赖配置如下。

		<!-- 添加JDBC依赖 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
			<exclusions>
				<!-- 排除Tomcat-JDBC依赖 -->
				<exclusion>
					<groupId>org.apache.tomcat</groupId>
					<artifactId>tomcat-jdbc</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<!-- 添加HikariCP依赖 -->
		<dependency>
			<groupId>com.zaxxer</groupId>
			<artifactId>HikariCP</artifactId>
		</dependency>

方式二 

 此外，还可以通过在核心配置中通过添加spring.datasource.type = [数据源类型] 来指定数据源的类型； 

spring.datasource.type=com.zaxxer.hikari.HikariDataSource
# spring.datasource.type=org.apache.tomcat.jdbc.pool.DataSource
# spring.datasource.type=org.apache.commons.dbcp.BasicDataSource
# spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource

第三方数据源

如果不想使用Springboot默认支持的4种数据源，还可以选择使用其他第三方的数据源，例如：Druid、c3p0等。

以使用Druid数据源为例。 

添加依赖与配置

在pom文件中引入第三方数据源依赖。 

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.4.1.RELEASE</version>
	</parent>
	<dependencies>
		<!-- 添加MySQL依赖 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		<!-- 添加JDBC依赖 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
		<!-- 添加Druid依赖 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.6</version>
		</dependency>
	</dependencies>

核心配置文件中的添加数据源相关配置与使用默认数据源时的配置相同，此处不再重复贴出。  

定义数据源

使用注解@Bean 创建一个DataSource Bean并将其纳入到Spring容器中进行管理即可。 

@Configuration
public class DataSourceConfig {

	@Autowired
	private Environment env;

	@Bean
	public DataSource getDataSource() {
		DruidDataSource dataSource = new DruidDataSource();
		dataSource.setUrl(env.getProperty("spring.datasource.url"));
		dataSource.setUsername(env.getProperty("spring.datasource.username"));
		dataSource.setPassword(env.getProperty("spring.datasource.password"));
		return dataSource;
	}
}

或者： 

@Configuration
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSource2Config {

	private String url;
	private String username;
	private String password;

	@Bean
	public DataSource getDataSource() {
		DruidDataSource dataSource = new DruidDataSource();
		dataSource.setUrl(url);
		dataSource.setUsername(username);// 用户名
		dataSource.setPassword(password);// 密码
		return dataSource;
	}

	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
}

 

官方文档
多数据源配置

MP官网的文档写的很详细，这里不做累赘直接截图



从其特性可以看出MP对于常见的框架都有继承案例
特性12条是关于sharding-jdbc的集成， 我的sharding-jdbc专栏

集成案例

第一步、引入依赖
<!-- dynamic-datasource-spring-boot-starter -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
    <version>3.2.0</version>
</dependency>


第二步、添加多数据源配置
spring:
  datasource:
    dynamic:
      primary: master #设置默认的数据源或者数据源组,默认值即为master
      strict: false #设置严格模式,默认false不启动. 启动后在未匹配到指定数据源时候会抛出异常,不启动则使用默认数据源.
      datasource:
        master:
          url: jdbc:mysql://xx.xx.xx.xx:3306/dynamic
          username: root
          password: 123456
          driver-class-name: com.mysql.jdbc.Driver # 3.2.0开始支持SPI可省略此配置
        slave_1:
          url: jdbc:mysql://xx.xx.xx.xx:3307/dynamic
          username: root
          password: 123456
          driver-class-name: com.mysql.jdbc.Driver
        slave_2:
          url: ENC(xxxxx) # 内置加密,使用请查看详细文档
          username: ENC(xxxxx)
          password: ENC(xxxxx)
          driver-class-name: com.mysql.jdbc.Driver
          schema: db/schema.sql # 配置则生效,自动初始化表结构
          data: db/data.sql # 配置则生效,自动初始化数据
          continue-on-error: true # 默认true,初始化失败是否继续
          separator: ";" # sql默认分号分隔符
          
       #......省略
       #以上会配置一个默认库master，一个组slave下有两个子库slave_1,slave_2

第三步、通过注解指定操作的数据源
使用  @DS切换数据源。
@DS可以注解在方法上和类上，同时存在则 方法注解优先于类上注解。
强烈建议只注解在service实现上。




注解
结果




没有@DS
默认数据源


@DS(“dsName”)
dsName可以为组名也可以为具体某个库的名称


如下注解的使用案例
@Service
@DS("slave") //注解在类上
public class UserServiceImpl implements UserService {

  @Autowired
  private JdbcTemplate jdbcTemplate;

  public List selectAll() {
    return  jdbcTemplate.queryForList("select * from user");
  }
  
  @Override
  @DS("slave_1") //注解在方法上，指明使用数据源使用名字叫 slave_1 的数据源
  public List selectByCondition() {
    return  jdbcTemplate.queryForList("select * from user where age >10");
  }
}

DataSource数据源简单理解

因为热爱，所以拼搏。          –RuiDer

什么是数据源

JDBC2.0 提供了javax.sql.DataSource接口，它负责建立与数据库的连接，当在应用程序中访问数据库时

不必编写连接数据库的代码，直接引用DataSource获取数据库的连接对象即可。用于获取操作数据Connection对象。

数据源与数据库连接池
数据源建立多个数据库连接，这些数据库连接会保存在数据库连接池中，当需要访问数据库时，只需要从数据库连接池中
获取空闲的数据库连接，当程序访问数据库结束时，数据库连接会放回数据库连接池中。


数据源DataSource与JNDI
数据源DataSource是JNDI资源的一种，很简单，就是将“DataSource”字符串名称与真正的DataSource对象绑定起来，方便获取。


数据库连接池的优势
传统的JDBC访问数据库技术，每次访问数据库都需要通过数据库驱动器Driver和数据库名称以及密码等等资源建立数据库连接。
这样的连接存在两大问题：

1. 频繁的建立数据库连接与断开数据库，这样会消耗大量的资源和时间，降低性能。

2. 数据库的连接需要用户名和密码等等，这些需要一定的内存和CPU一定开销。


About Me
欢迎各位读者访问，大家一起相互学习。

带给你惊喜的不是我，也不是他，而是技术。

我的博客
我的GitHub