Java 阿里巴巴数据源_springboot整合阿里druid数据源

全配置在application配置文件(方式1)

maven依赖

com.alibaba

druid-spring-boot-starter

1.1.17

org.springframework.boot

spring-boot-starter-jdbc

log4j

log4j

1.2.17

application.yml

#项目服务

server:

port: 80

address: localhost

spring:

#数据源设置

datasource:

url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&useSSL=false&serverTimezone=UTC

username: root

password: xxx

type: com.alibaba.druid.pool.DruidDataSource

druid:

# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙

filters: stat,wall,slf4j

#最大连接池数量 maxIdle已经不再使用

maxActive: 20

#初始化时建立物理连接的个数

initialSize: 1

#获取连接时最大等待时间，单位毫秒

maxWait: 60000

#最小连接池数量

minIdle: 1

#既作为检测的间隔时间又作为testWhileIdel执行的依据

timeBetweenEvictionRunsMillis: 60000

#销毁线程时检测当前连接的最后活动时间和当前时间差大于该值时，关闭当前连接

minEvictableIdleTimeMillis: 300000

#用来检测连接是否有效的sql 必须是一个查询语句

#mysql中为 select 'x'

#oracle中为 select 1 from dual

validationQuery: select 'x'

#申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。

testWhileIdle: true

#申请连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true

testOnBorrow: false

#归还连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true

testOnReturn: false

# 是否缓存preparedStatement，也就是PSCache 官方建议MySQL下建议关闭 个人建议如果想用SQL防火墙 建议打开

poolPreparedStatements: true

maxOpenPreparedStatements: 20

#当值大于0时poolPreparedStatements会自动修改为true

maxPoolPreparedStatementPerConnectionSize: 20

# 通过connectProperties属性来打开mergeSql功能；慢SQL记录

connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

# 合并多个DruidDataSource的监控数据

useGlobalDataSourceStat: true

#基础监控配置

web-stat-filter:

enabled: true

url-pattern: /*

#设置不统计哪些URL

exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"

session-stat-enable: true

session-stat-max-count: 100

#设置视图拦截,访问druid监控页的账号和密码,默认没有

stat-view-servlet:

enabled: true

url-pattern: /druid/*

reset-enable: true

#设置监控页面的登录名和密码

login-username: admin

login-password: 123

#白名单ip

allow: 127.0.0.1

#黑名单

#deny: 192.168.1.100

测试使用localhost/druid/login.html访问即可，页面是源项目给的，用户密码为上面设置的  #设置监控页面的登录名和密码 admin 和 123

使用到部分java配置类(方式2)

只做基本配置，其余到java类中设置

server.port=80

#数据源1

spring.datasource.druid.name=druidDataSource

spring.datasource.druid.type=com.alibaba.druid.pool.DruidDataSource

spring.datasource.druid.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&autoReconnect=true&characterEncoding=utf-8&failOverReadOnly=false&useSSL=false&serverTimezone=UTC

spring.datasource.druid.username=root

spring.datasource.druid.password=xxx

#spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver

# 初始化大小，最小，最大

spring.datasource.druid.initialSize=1

spring.datasource.druid.minIdle=3

spring.datasource.druid.maxActive=20

# 配置获取连接等待超时的时间

spring.datasource.druid.maxWait=60000

# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒

spring.datasource.druid.timeBetweenEvictionRunsMillis=60000

# 配置一个连接在池中最小生存的时间，单位是毫秒

spring.datasource.druid.minEvictableIdleTimeMillis=30000

spring.datasource.druid.validationQuery=select 'x'

spring.datasource.druid.testWhileIdle=true

spring.datasource.druid.testOnBorrow=false

spring.datasource.druid.testOnReturn=false

# 打开PSCache，并且指定每个连接上PSCache的大小

spring.datasource.druid.poolPreparedStatements=true

spring.datasource.druid.max-open-prepared-statements=50

spring.datasource.druid.maxPoolPreparedStatementPerConnectionSize=20

# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙

spring.datasource.druid.filters=stat,wall,slf4j

# 通过connectProperties属性来打开mergeSql功能；慢SQL记录

spring.datasource.druid.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

DruidConfig.java

import java.sql.SQLException;

import javax.servlet.Filter;

import javax.servlet.Servlet;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;

import org.springframework.boot.context.properties.EnableConfigurationProperties;

import org.springframework.boot.web.servlet.FilterRegistrationBean;

import org.springframework.boot.web.servlet.ServletRegistrationBean;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import com.alibaba.druid.pool.DruidDataSource;

import com.alibaba.druid.support.http.StatViewServlet;

import com.alibaba.druid.support.http.WebStatFilter;

@Configuration

@EnableConfigurationProperties({DruidDataSourceProperties.class})

public class DruidConfig {

@Autowired

private DruidDataSourceProperties properties;

@Bean

@ConditionalOnMissingBean

public DataSource druidDataSource() {

DruidDataSource druidDataSource = new DruidDataSource();

druidDataSource.setDriverClassName(properties.getDriverClassName());

druidDataSource.setUrl(properties.getUrl());

druidDataSource.setUsername(properties.getUsername());

druidDataSource.setPassword(properties.getPassword());

druidDataSource.setInitialSize(properties.getInitialSize());

druidDataSource.setMinIdle(properties.getMinIdle());

druidDataSource.setMaxActive(properties.getMaxActive());

druidDataSource.setMaxWait(properties.getMaxWait());

druidDataSource.setTimeBetweenEvictionRunsMillis(properties.getTimeBetweenEvictionRunsMillis());

druidDataSource.setMinEvictableIdleTimeMillis(properties.getMinEvictableIdleTimeMillis());

druidDataSource.setValidationQuery(properties.getValidationQuery());

druidDataSource.setTestWhileIdle(properties.isTestWhileIdle());

druidDataSource.setTestOnBorrow(properties.isTestOnBorrow());

druidDataSource.setTestOnReturn(properties.isTestOnReturn());

druidDataSource.setPoolPreparedStatements(properties.isPoolPreparedStatements());

druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(properties.getMaxPoolPreparedStatementPerConnectionSize());

try {

druidDataSource.setFilters(properties.getFilters());

druidDataSource.init();

} catch (SQLException e) {

e.printStackTrace();

}

return druidDataSource;

}

/**

* 注册Servlet信息， 配置监控视图

* @return

*/

@Bean

@ConditionalOnMissingBean

public ServletRegistrationBean druidServlet() {

ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");

//白名单：

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.119");

//登录查看信息的账号密码, 用于登录Druid监控后台

servletRegistrationBean.addInitParameter("loginUsername", "admin");

servletRegistrationBean.addInitParameter("loginPassword", "admin");

//是否能够重置数据.

servletRegistrationBean.addInitParameter("resetEnable", "true");

return servletRegistrationBean;

}

/**

* 注册Filter信息, 监控拦截器

* @return

*/

@Bean

@ConditionalOnMissingBean

public FilterRegistrationBean filterRegistrationBean() {

FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();

filterRegistrationBean.setFilter(new WebStatFilter());

filterRegistrationBean.addUrlPatterns("/*");

filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");

return filterRegistrationBean;

}

}

DruidDataSourceProperties.java

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "spring.datasource.druid")

public class DruidDataSourceProperties {

// jdbc

private String driverClassName;

private String url;

private String username;

private String password;

// jdbc connection pool

private int initialSize;

private int minIdle;

private int maxActive = 100;

private long maxWait;

private long timeBetweenEvictionRunsMillis;

private long minEvictableIdleTimeMillis;

private String validationQuery;

private boolean testWhileIdle;

private boolean testOnBorrow;

private boolean testOnReturn;

private boolean poolPreparedStatements;

private int maxPoolPreparedStatementPerConnectionSize;

// filter

private String filters;

public int getInitialSize() {

return initialSize;

}

public void setInitialSize(int initialSize) {

this.initialSize = initialSize;

}

public int getMinIdle() {

return minIdle;

}

public void setMinIdle(int minIdle) {

this.minIdle = minIdle;

}

public int getMaxActive() {

return maxActive;

}

public void setMaxActive(int maxActive) {

this.maxActive = maxActive;

}

public long getMaxWait() {

return maxWait;

}

public void setMaxWait(long maxWait) {

this.maxWait = maxWait;

}

public long getTimeBetweenEvictionRunsMillis() {

return timeBetweenEvictionRunsMillis;

}

public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis) {

this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;

}

public long getMinEvictableIdleTimeMillis() {

return minEvictableIdleTimeMillis;

}

public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {

this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;

}

public String getValidationQuery() {

return validationQuery;

}

public void setValidationQuery(String validationQuery) {

this.validationQuery = validationQuery;

}

public boolean isTestWhileIdle() {

return testWhileIdle;

}

public void setTestWhileIdle(boolean testWhileIdle) {

this.testWhileIdle = testWhileIdle;

}

public boolean isTestOnBorrow() {

return testOnBorrow;

}

public void setTestOnBorrow(boolean testOnBorrow) {

this.testOnBorrow = testOnBorrow;

}

public boolean isTestOnReturn() {

return testOnReturn;

}

public void setTestOnReturn(boolean testOnReturn) {

this.testOnReturn = testOnReturn;

}

public boolean isPoolPreparedStatements() {

return poolPreparedStatements;

}

public void setPoolPreparedStatements(boolean poolPreparedStatements) {

this.poolPreparedStatements = poolPreparedStatements;

}

public int getMaxPoolPreparedStatementPerConnectionSize() {

return maxPoolPreparedStatementPerConnectionSize;

}

public void setMaxPoolPreparedStatementPerConnectionSize(int maxPoolPreparedStatementPerConnectionSize) {

this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;

}

public String getFilters() {

return filters;

}

public void setFilters(String filters) {

this.filters = filters;

}

public String getDriverClassName() {

return driverClassName;

}

public void setDriverClassName(String driverClassName) {

this.driverClassName = driverClassName;

}

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;

}

}

同上访问即可，到此完成了。