springboot简化了我们构建应用的难度，把很多功能帮我们打包，然后我们
通过简单的注解或者引入依赖就能使用相关的功能，比如jdbc操作，缓存使用等等。
数据源是第三方机构基于jdbc规范实现的一套数据库操作功能，我们可以在
其基础上非常方便地实现数据查询和更新，而不必关心其底层实现，让我们把更多的经历投入到业务实现。常见数据源(连接池)有druid，tomcat，dbcp，c3p0和hikari等，此篇我们就基于流行的数据源实现springboot对数据库的操作。
Druid连接池
druid是阿里巴巴开源的数据库连接池，除了高性能之外，还提供了数据库
操作监控。
1.引入pom依赖
除了引入druid依赖之外，还要添加jdbc和mysql-connector-java依赖：
<!-- jdbcTemplate -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- druid数据库连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
</dependency>
<!-- mysql connector -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
2.添加数据库连接属性配置
数据库连接属性配置文件druid.properties:
#数据库设置
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=true
spring.datasource.username=username
spring.datasource.password=password
3.数据库连接配置类
使用@Configuration注解类替代传统的xml配置，DruidConfiguration：
@Configuration
@PropertySource(value = "classpath:druid.properties")
public class DruidConfiguration {
@Bean(destroyMethod = "close", initMethod = "init",name = "druidDataSource")
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource druidDataSource() {
DruidDataSource druidDataSource = new DruidDataSource();
return druidDataSource;
}
/**
* 注册一个StatViewServlet
* @return
*/
@Bean
public ServletRegistrationBean druidStatViewServlet(){
//org.springframework.boot.context.embedded.ServletRegistrationBean提供类的进行注册.
ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(),"/druid/*");
//添加初始化参数：initParams
//白名单：
servletRegistrationBean.addInitParameter("allow","127.0.0.1");
//IP黑名单 (存在共同时，deny优先于allow) : 如果满足deny的话提示:Sorry, you are not permitted to view this page.
servletRegistrationBean.addInitParameter("deny","192.168.1.73");
//登录查看信息的账号密码.
servletRegistrationBean.addInitParameter("loginUsername","admin");
servletRegistrationBean.addInitParameter("loginPassword","123456");
//是否能够重置数据.
servletRegistrationBean.addInitParameter("resetEnable","false");
return servletRegistrationBean;
}
/**
* 注册一个：filterRegistrationBean
* @return
*/
@Bean
public FilterRegistrationBean druidStatFilter(){
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
//添加过滤规则.
filterRegistrationBean.addUrlPatterns("/*");
//添加不需要忽略的格式信息.
filterRegistrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
return filterRegistrationBean;
}
}
后边的两个@Bean是提供监控的，暂时可以忽略。
4.增加配置暴露JdbcTemplate
我们此处为了测试方便，使用spring提供的jdbcTemplate：
@Configuration
public class CommonConfiguration {
@Bean
public JdbcTemplate jdbcTemplate(@Qualifier("druidDataSource") DataSource dataSource) {
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
return jdbcTemplate;
}
}
这样我们就可以基于jdbcTemplate直接操作数据库了。
5.编写测试代码&测试
为了测试方便不再写dao层和service层代码，直接controller操作jdbcTemplate：
@RestController
public class IndexController {
private static final Logger logger = LoggerFactory.getLogger(IndexController.class);
@Autowired
private JdbcTemplate jdbcTemplate;
@RequestMapping("hello")
public List<Map<String, Object>> hello() {
List<Map<String, Object>> list = jdbcTemplate.queryForList("SELECT * FROM User ", new Object[]{});
logger.info("size:{}",list.size());
return list;
}
}
运行门面类Demo1Application启动应用，然后浏览器输入localhost:8080/hello看到如下结果：
已经查到了数据，也就是我们实现了springboot使用druid数据库完成数据库操作。
Tomcat连接池
Tomcat除了可以作为应用容器之外，也提供了数据库连接池。
1.引入tomcat连接池依赖
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-jdbc</artifactId>
</dependency>
2.添加数据库连接属性配置
数据库连接属性配置文件tomcat.properties:
#数据库设置
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=true
spring.datasource.username=username
spring.datasource.password=password
3.数据库连接配置类
@Configuration
@PropertySource(value = "classpath:tomcat.properties")
public class TomcatJdbcConfiguration {
private static final Logger logger = LoggerFactory.getLogger(TomcatJdbcConfiguration.class);
@Bean("tomcatDataSource")
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource tomcatDataSource() {
logger.info("tomcat数据库连接池创建中.......");
org.apache.tomcat.jdbc.pool.DataSource ds = new org.apache.tomcat.jdbc.pool.DataSource();
return ds;
}
4.增加配置暴露JdbcTemplate
jdbcTemplate数据源切换成tomcatDataSource：
@Configuration
public class CommonConfiguration {
@Bean
public JdbcTemplate jdbcTemplate(@Qualifier("tomcatDataSource") DataSource dataSource) {
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
return jdbcTemplate;
}
}
5.编写测试代码&测试
重新运行门面类Demo1Application启动应用，调试jdbcTemplate注入DataSource依赖：
这里的DataSource确实已经变成了tomcat的数据源。然后浏览器输入localhost:8080/hello看到如下结果：
查到了数据，也就是我们实现了springboot使用tomcat连接池数据库完成数据库操作。
Dbcp连接池
1.引入dbcp连接池依赖
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
</dependency>
2.添加数据库连接属性配置
数据库连接属性配置文件dbcp.properties:
#数据库设置
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=true
spring.datasource.username=username
spring.datasource.password=password
3.数据库连接配置类
@Configuration
@PropertySource(value = "classpath:dbcp.properties")
public class DbcpConfiguration {
private static final Logger logger = LoggerFactory.getLogger(DbcpConfiguration.class);
@Bean(destroyMethod = "close",name = "dbcpDataSource")
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource tomcatDataSource() {
logger.info("dbcp数据库连接池创建中.......");
BasicDataSource ds = new BasicDataSource();
return ds;
}
}
4.增加配置暴露JdbcTemplate
jdbcTemplate数据源切换成dbcpDataSource：
@Configuration
public class CommonConfiguration {
@Bean
public JdbcTemplate jdbcTemplate(@Qualifier("dbcpDataSource") DataSource dataSource) {
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
return jdbcTemplate;
}
}
5.编写测试代码&测试
重新运行门面类Demo1Application启动应用，调试jdbcTemplate注入DataSource依赖：
这里的DataSource已经变成了dbcp的BasicDataSource。然后浏览器输入localhost:8080/hello看到如下结果：
查到了数据，也就是我们实现了springboot使用dbcp连接池数据库完成数据库操作。
C3p0连接池
C3p0也是我们常用的数据库连接池，也有不错的性能和处理并发能力。
1.引入dbcp连接池依赖
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
</dependency>
2.添加数据库连接属性配置
数据库连接属性配置文件c3p0.properties:
#数据库设置
spring.datasource.driverClass=com.mysql.jdbc.Driver
spring.datasource.jdbcUrl=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=true
spring.datasource.user=username
spring.datasource.password=password
3.数据库连接配置类
@Configuration
@PropertySource(value = "classpath:c3p0.properties")
public class C3p0Configuration {
private static final Logger logger = LoggerFactory.getLogger(C3p0Configuration.class);
@Bean(destroyMethod = "close",name = "c3p0DataSource")
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource tomcatDataSource() {
logger.info("c3p0数据库连接池创建中.......");
ComboPooledDataSource ds = new ComboPooledDataSource();
return ds;
}
}
4.增加配置暴露JdbcTemplate
jdbcTemplate数据源切换成c3p0DataSource：
@Configuration
public class CommonConfiguration {
@Bean
public JdbcTemplate jdbcTemplate(@Qualifier("c3p0DataSource") DataSource dataSource) {
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
return jdbcTemplate;
}
}
5.编写测试代码&测试
重新运行门面类Demo1Application启动应用，调试jdbcTemplate注入DataSource依赖：
这里的DataSource已经变成了c3p0的ComboPooledDataSource。然后浏览器输入localhost:8080/hello看到如下结果：
查到了数据，也就是我们实现了springboot使用c3p0连接池数据库完成数据库操作。
HikariCP连接池
HikariCP连接池号称是性能最好的连接池，druid作者温少与HikariCP作者的一次对话中温少说druid默认使用了公平锁，导致性能比HikariCP差那么一点点，但是druid扛住了双11的体量，而HikariCP没有那么大体量的真实场景验证。
1.引入HikariCP连接池依赖
在项目引入spring-boot-starter-jdbc依赖的时候，HikariCP依赖已经被带进来了，所以此处不许额外添加依赖。
2.添加数据库连接属性配置
数据库连接属性配置文件hikari.properties:
#数据库设置
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.jdbcUrl=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.username=username
spring.datasource.password=password
spring.jooq.sql-dialect=MYSQL
spring.datasource.initialize=false
spring.datasource.continueOnError=true
spring.datasource.hikari.idleTimeout=30000
spring.datasource.hikari.maximumPoolSize=10
3.数据库连接配置类
@Configuration
@PropertySource(value = "classpath:hikari.properties")
public class HikarIConfiguration {
private static final Logger logger = LoggerFactory.getLogger(HikarIConfiguration.class);
@Bean("hikariDataSource")
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource hikarDataSource() {
logger.info("hikari数据库连接池创建中.......");
HikariDataSource ds = new HikariDataSource();
return ds;
}
}
4.增加配置暴露JdbcTemplate
jdbcTemplate数据源切换成HikariDataSource：
@Configuration
public class CommonConfiguration {
@Bean
public JdbcTemplate jdbcTemplate(@Qualifier("hikariDataSource") DataSource dataSource) {
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
return jdbcTemplate;
}
}
5.编写测试代码&测试
重新运行门面类Demo1Application启动应用，调试jdbcTemplate注入DataSource依赖：
这里的DataSource已经变成了HikariCP的HikariDataSource。然后浏览器输入localhost:8080/hello看到如下结果：
查到了数据，也就是我们实现了springboot使用Hikari连接池数据库完成数据库操作。
总结
我们基于springboot实现了各种常见数据源的使用，性能最好的就是druid和HikariCP连接池，虽然后者号称比druid性能好，但是基于可靠性验证，推荐使用druid，也希望通过此篇给大家在springboot日常开发中带来帮助。
