慢慢来比较快,虚心学技术
数据访问操作:初始化数据访问框架、打开连接、处理各种异常和关闭连接,任何一步出现异常都有可能导致损坏或删除企业数据库珍贵数据
一、Spring 的数据访问哲学
①松耦合
为了避免持久化的逻辑分散到应用的各个组件中,最好将数据访问的功能放到一个或多个专注于此项任务的组件中。这样的组件通常称为数据访问对象( data access object , DAO )或 Repositor
为了避免应用与特定的数据访问策略耦合在一起,编写良好的 Repository 应该以接口的方式暴露功能。图 10.1 展现了设计数据访问层的合理方式
接口是实现松耦合代码的关键,并且应将其用于应用程序的各个层,而不仅仅是持久化层
②Spring 数据访问异常
JDBC对于所有的数据访问问题都会抛出 SQLException ,可能导致抛出 SQLException 的常见问题包括:
- 应用程序无法连接数据库
- 要执行的查询存在语法错误;
- 查询中所使用的表和 / 或列不存在;
- 试图插入或更新的数据违反了数据库约束
可见JDBC对于数据访问异常的处理十分粗糙,他并不会告诉你具体问题出现在哪里,而是讲所有问题都指向SQLException。所以很多持久化框架如Hibernate等都会提供自身的数据访问异常类,以供使用。但是如果我们在应用层次中引入了持久化框架的异常,很显然会紧紧的耦合在一起,违反了松耦合的约定。故而,Spring提供了自身一系列的异常类。
然而,Spring所提供的异常都是继承自非检查型异常,所以并不需要强制开发人员必须catch。
二、Spring 数据访问模板化
模板方法模式(设计模式):模板方法定义过程的主要框架,模板方法将过程中与特定实现相关的部分委托给接口,而这个接口的不同实现定义了过程中的具体行为
Spring将数据访问分为可变(模板)和不可变(固定)两部分:模板( template )和回调( callback )
- Spring 的模板类处理数据访问的固定部分 —— 事务控制、管理资源以及处理异常。
- 应用程序相关的数据访问 —— 语句、绑定参数以及整理结果集 —— 在回调的实现中处理。
模板:Spring为了兼容多个持久化框架,提供了一系列的模板类
jca.cci.core.CciTemplate |
JCA CCI 连接 |
jdbc.core.JdbcTemplate |
JDBC 连接 |
jdbc.core.namedparam.NamedParameterJdbcTemplate |
支持命名参数的 JDBC 连接 |
jdbc.core.simple.SimpleJdbcTemplate |
通过 Java 5 简化后的 JDBC 连接( Spring 3.1 中已经废弃) |
orm.hibernate3.HibernateTemplate |
Hibernate 3.x 以上的 Session |
orm.ibatis.SqlMapClientTemplate |
iBATIS SqlMap 客户端 |
orm.jdo.JdoTemplate |
Java 数据对象( Java Data Object )实现 |
orm.jpa.JpaTemplate |
Java 持久化 API 的实体管理器 |
三、Spring+JDBC
Ⅰ、配置数据源
Spring配置数据源依赖的第三方框架都提供了基本的DataSource接口。
使用数据库连接池:
- Apache Commons DBCP
- c3p0
- BoneCP
- Druid
DBCP连接池
DBCP是 apache 上的一个 java 连接池项目,也是 tomcat 使用的连接池组件。
依赖于BasicDataSource对象实现数据源配置
BasicDataSource部分属性如下:
属性名 |
属性描述 |
driverClassName |
数据库连接驱动名,如:com.mysql.jdbc.Driver |
url |
数据库连接地址,如:jdbc:mysql://localshot:3306/数据库名 |
username |
数据库连接用户名 |
passowrd |
数据库连接密码 |
defaultAutoCommit |
设置从数据源中返回的连接是否采用自动提交机制,默认值为 true; |
validationQuery |
用于验证连接是否成功的查询SQL语句,SQL语句必须至少要返回一行数据,如你可以简单地设置为:“select count(*) from user” |
initialSize |
池启动时创建的连接数量 |
maxActive |
同一时间可从池中分配的最多连接数。如果设置为 0 ,表示无限制 |
maxIdle |
池里不会被释放的最多空闲连接数。如果设置为 0 ,表示无限制 |
maxOpenPreparedStatements |
在同一时间能够从语句池中分配的预处理语句( prepared statement )的最大数量。如果设置为 0 ,表示无限制 |
maxWait |
在抛出异常之前,池等待连接回收的最大时间(当没有可用连接时)。如果设置为 -1 ,表示无限等待 |
minEvictableIdleTimeMillis |
连接在池中保持空闲而不被回收的最大时间 |
minIdle |
在不创建新连接的情况下,池中保持空闲的最小连接数 |
poolPreparedStatements |
是否对预处理语句( prepared statement )进行池管理(布尔值) |
removeAbandoned |
是否自我中断,默认是 false |
removeAbandonedTimeout |
几秒后数据连接会自动断开,在removeAbandoned为true,提供该值; |
logAbandoned |
是否记录中断事件, 默认为 false |
首先引入依赖包:commons-dbcp.jar和commons-pool.jar
<!-- https://mvnrepository.com/artifact/commons-dbcp/commons-dbcp -->
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-pool/commons-pool -->
<dependency>
<groupId>commons-pool</groupId>
<artifactId>commons-pool</artifactId>
<version>1.4</version>
</dependency>
<!--引入Spring-jdbc的支持-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<!--引入mysql数据连接驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
</dependencies>
两种方式配置DBCP连接池:
- 使用注解配置实现
①创建数据源配置类,定义数据源与JdbcTemplate操作模板
@Configuration
public class DataSourceConfig {
/**
* 数据源连接池
*/
@Bean
public DataSource dataSource(){
BasicDataSource basicDataSource = new BasicDataSource();
//设置驱动
basicDataSource.setDriverClassName("com.mysql.jdbc.Driver");
//设置数据库路径
basicDataSource.setUrl("jdbc:mysql://localhost:3306/spring");
//设置数据库登录名
basicDataSource.setUsername("spring");
//设置数据库登录密码
basicDataSource.setPassword("spring");
//是否自动提交事务(默认为true)
basicDataSource.setDefaultAutoCommit(true);
return basicDataSource;
}
/**
* Spring JdbcTemplate
*/
@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
}
②创建统一配置类,开启组件扫描,并将数据源配置类引入
@ComponentScan(basePackages = {"com.my.spring"})
@Configuration
@Import(DataSourceConfig.class)
public class SystemConfig {
}
③创建数据库操作的Object对象和相应的Dao和Service类
//BaseBean.java
@Data
public class BaseBean {
private Integer id;
private String name;
private Integer age;
}
//BaseDaoParent.java,系统内所有Dao的父类,继承自JdbcDaoSupport
@Component
public class BaseDaoParent extends JdbcDaoSupport {
//注入DataSource
@Autowired
private DataSource dataSource;
//因为JdbcDaoSupport的setDataSource方法是final修饰的,@Autowired注入失败,所以必须手动注入
@PostConstruct
private void initialize(){
setDataSource(dataSource);
}
}
//BaseDao.java
@Repository
public class BaseDao extends BaseDaoParent{
/**
* 保存一个记录
* @param baseBean
*/
public void save(BaseBean baseBean){
this.getJdbcTemplate().update("insert into basebean(name,age) values ('"+baseBean.getName()+"',"+baseBean.getAge()+")");
}
/**
* 获取所有bean记录
* @return
*/
public List<BaseBean> findAll(){
RowMapper<BaseBean> rowMapper = new BeanPropertyRowMapper<>(BaseBean.class);
return this.getJdbcTemplate().query("select * from basebean",rowMapper);
}
}
//BaseService.java
public interface BaseService{
/**
* 保存一个记录
* @param baseBean
*/
void save(BaseBean baseBean);
/**
* 获取所有bean记录
* @return
*/
List<BaseBean> findAll();
}
//BaseServiceImpl.java
@Component
public class BaseServiceImpl implements BaseService {
@Autowired
private BaseDao baseDao;
@Override
public void save(BaseBean baseBean) {
this.baseDao.save(baseBean);
}
@Override
public List<BaseBean> findAll() {
return this.baseDao.findAll();
}
}
④编写测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SystemConfig.class})
public class DataSourceTest {
@Autowired
private BaseService baseService;
/**
*调用service方法存入对象
*/
@Test
public void testSaveBean(){
BaseBean baseBean = new BaseBean();
baseBean.setName("test");
baseBean.setAge(15);
this.baseService.save(baseBean);
}
/**
*调用service方法获取所有记录
*/
@Test
public void testFindAll(){
List<BaseBean> list = this.baseService.findAll();
System.out.println(list.toString());
}
}
⑤创建数据库表
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for basebean
-- ----------------------------
DROP TABLE IF EXISTS `basebean`;
CREATE TABLE `basebean` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`age` int(10) NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
SET FOREIGN_KEY_CHECKS = 1;
⑥测试结果
调用存入BaseBean,同时获取列表:
[BaseBean(id=1, name=test, age=15)]
- 使用xml配置实现
创建datasource.properties文件
#指定数据库驱动
jdbc.driver = com.mysql.jdbc.Driver
#指定数据库url
jdbc.url = jdbc:mysql://localhost:3306/spring
#指定数据库用户
jdbc.username = spring
#指定数据库用户密码
jdbc.password = spring
创建application.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 导入数据库资源文件 -->
<context:property-placeholder location="classpath:datasource.properties"/>
<!--配置数据源-->
<bean class="org.apache.commons.dbcp.BasicDataSource" id="dataSource">
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--配置注入数据源-->
<bean id = "baseDaoParent" class="com.my.spring.dao.BaseDaoParent">
<property name="dataSource" ref="dataSource"></property>
</bean>
<bean id="baseDao" class="com.my.spring.dao.BaseDao" parent="baseDaoParent"></bean>
<bean id="baseService" class="com.my.spring.service.impl.BaseServiceImpl">
<property name="baseDao" ref="baseDao"></property>
</bean>
</beans>
关闭组件扫描,同时在全局配置中引入application.xml
@Configuration
//@Import(DataSourceConfig.class)
@ImportResource(value = {"classpath:application.xml"})
public class SystemConfig {}
测试结果:
[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15)]
C3P0连接池
C3P0是一个开源的JDBC连接池,它实现了数据源和JNDI绑定,支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate,Spring等。
依赖于ComboPooledDataSource 对象实现配置,其基本属性如下:
属性 |
描述 |
driverclass |
数据库驱动类,比如MySQL为“com.mysql.jdbc.Driver” |
jdbcUrl |
数据库连接 |
user |
登录数据库的账号 |
password |
登录数据库的密码 |
acquireIncrement |
当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 |
minPoolSize |
连接池中保留的最小连接数,默认为:3 |
maxPoolSize |
连接池中保留的最大连接数。默认值: 15 |
initialPoolSize |
初始化时获取连接数,取值应在minPoolSize与maxPoolSize之间。Default: 3 |
maxIdleTime |
最大空闲时间,多少秒内未使用则连接被丢弃。若为0则永不丢弃。默认值: 0 |
maxStatements |
c3p0全局的PreparedStatements缓存的大小。如果maxStatements与maxStatementsPerConnection均为0,则缓存不生效,只要有一个不为0,则语句的缓存就能生效。如果默认值: 0 |
numHelperThreads |
c3p0是异步操作的,缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能通过多线程实现多个操作同时被执行。Default: 3 |
acquireRetryAttempts |
定义在从数据库获取新连接失败后重复尝试的次数。默认值: 30 ;小于等于0表示无限次 |
acquireRetryDelay |
重新尝试的时间间隔,默认为:1000毫秒 |
checkoutTimeout |
获取一个connection超时时间,单位毫秒 |
idleConnectionTestPeriod |
每隔多少秒检查所有连接池中的空闲连接。Default: 0 |
automaticTestTable |
c3p0将建一张名为改配置项的空表,并使用其自带的查询语句进行测试。如果定义了这个参数那么属性preferredTestQuery将#被忽略。你不能在这张Test表上进行任何操作,它将只供c3p0测试使用。默认值: null。由于运营平台的数据库用户没有创建表的权限,故需要发sql创建表。 |
testConnectionOnCheckin |
如果设为true那么在取得连接的同时将校验连接的有效性。Default: false |
unreturnedConnectionTimeout=15 |
一个checkout连接的超时设置,一旦一个checkout连接超时,他将物理的关闭,而不是返回池中,主要是防止连接被长期使用不释放,这个设置也是比较危险的 |
使用注解方式配置C3P0
①引入jar包:
<!--引入c3p0支持-->
<!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
②创建数据源配置类,定义数据源与JdbcTemplate操作模板
@Configuration
@PropertySource(value = {"classpath:datasource.properties"})//引入资源文件
public class DataSourceConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String userName;
@Value("${jdbc.password}")
private String password;
/**
* 数据源连接池
*/
@Bean
public DataSource dataSource() throws PropertyVetoException {
ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
comboPooledDataSource.setDriverClass(driver);
comboPooledDataSource.setJdbcUrl(url);
comboPooledDataSource.setUser(userName);
comboPooledDataSource.setPassword(password);
return comboPooledDataSource;
}
/**
* Spring JbdcTemplate
*/
@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
}
执行测试:
[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15), BaseBean(id=3, name=test, age=15)
使用XML配置C3P0
依旧使用application.xml,将数据源改为c3p0
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 导入数据库资源文件 -->
<context:property-placeholder location="classpath:datasource.properties"/>
<!--配置数据源DBCP-->
<bean class="org.apache.commons.dbcp.BasicDataSource" id="dataSource">
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--配置数据源C3P0-->
<bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSourceC3P0">
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--配置注入数据源c3p0-->
<bean id = "baseDaoParent" class="com.my.spring.dao.BaseDaoParent">
<property name="dataSource" ref="dataSourceC3P0"></property>
</bean>
<bean id="baseDao" class="com.my.spring.dao.BaseDao" parent="baseDaoParent"></bean>
<bean id="baseService" class="com.my.spring.service.impl.BaseServiceImpl">
<property name="baseDao" ref="baseDao"></property>
</bean>
</beans>
将全局配置调整至读取xml模式,测试结果:
[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15), BaseBean(id=3, name=test, age=15), BaseBean(id=4, name=test, age=15)]
BoneCP连接池
一个快速,开源的数据库连接池。帮你管理数据连接让你的应用程序能更快速地访问数据库。比C3P0和DBCP快25倍
BoneCP依赖于com.jolbox.bonecp.BoneCPDataSource 类,其主要属性如下:
属性 |
描述 |
driveClass |
数据库驱动 |
jdbcUrl |
响应驱动的jdbcUrl |
username |
数据库的用户名 |
password |
数据库的密码 |
acquireIncrement: |
当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 |
idleConnectionTestPeriod |
捡查数据库连接池中控线连接的间隔时间,单位是分,默认值:240,如果要取消则设置为0 |
idleMaxAge |
连接池中未使用的链接最大存活时间,单位是分,默认值:60,如果要永远存活设置为0 |
maxConnectionsPerPartition |
每个分区最大的连接数 |
minConnectionsPerPartition |
每个分区最小的连接数 |
partitionCount |
分区数,默认值2,最小1,推荐3-4,视应用而定 |
acquireIncrement |
每次去拿数据库连接的时候一次性要拿几个,默认值:2 |
statementsCacheSize |
缓存prepared statements的大小,默认值:0 |
releaseHelperThreads |
每个分区释放链接助理进程的数量,默认值:3,除非你的一个数据库连接的时间内做了很多工作,不然过多的助理进程会影响你的性能 |
使用注解实现BoneCP配置
①引入依赖包
<!--引入BoneCP支持-->
<!-- https://mvnrepository.com/artifact/com.jolbox/bonecp -->
<dependency>
<groupId>com.jolbox</groupId>
<artifactId>bonecp</artifactId>
<version>0.8.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
②创建配置类:
@Configuration
@PropertySource(value = {"classpath:datasource.properties"})//引入资源文件
public class DataSourceConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String userName;
@Value("${jdbc.password}")
private String password;
/**
* 数据源连接池
*/
@Bean
public DataSource dataSource(){
BoneCPDataSource boneCPDataSource = new BoneCPDataSource();
boneCPDataSource.setDriverClass(driver);
boneCPDataSource.setJdbcUrl(url);
boneCPDataSource.setUser(userName);
boneCPDataSource.setPassword(password);
return boneCPDataSource;
}
/**
* Spring JbdcTemplate
*/
@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
}
③测试结果:
[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15), BaseBean(id=3, name=test, age=15), BaseBean(id=4, name=test, age=15), BaseBean(id=5, name=test, age=15)]
使用XML实现BoneCP配置
依旧使用application.xml,将数据源改为BoneCP
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 导入数据库资源文件 -->
<context:property-placeholder location="classpath:datasource.properties"/>
<!--配置数据源DBCP-->
<bean class="org.apache.commons.dbcp.BasicDataSource" id="dataSource">
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--配置数据源C3P0-->
<bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSourceC3P0">
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--配置数据源BoneCP-->
<bean class="com.jolbox.bonecp.BoneCPDataSource" id="dataSourceBoneCP">
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--配置注入数据源BonCP-->
<bean id = "baseDaoParent" class="com.my.spring.dao.BaseDaoParent">
<property name="dataSource" ref="dataSourceBoneCP"></property>
</bean>
<bean id="baseDao" class="com.my.spring.dao.BaseDao" parent="baseDaoParent"></bean>
<bean id="baseService" class="com.my.spring.service.impl.BaseServiceImpl">
<property name="baseDao" ref="baseDao"></property>
</bean>
</beans>
测试结果:
[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15), BaseBean(id=3, name=test, age=15), BaseBean(id=4, name=test, age=15), BaseBean(id=5, name=test, age=15), BaseBean(id=6, name=test, age=15)]
Druid连接池
阿里巴巴开源平台上一个数据库连接池实现,它结合了C3P0、DBCP、PROXOOL等DB池的优点,同时加入了日志监控,可以很好的监控DB池连接和SQL的执行情况,可以说是针对监控而生的DB连接池
Druid依赖于com.alibaba.druid.pool.DruidDataSource 实现,其主要属性如下:
属性 |
描述 |
name |
配置这个属性的意义在于,如果存在多个数据源,监控的时候可以通过名字来区分开来。 如果没有配置,将会生成一个名字,格式是:"DataSource-" + System.identityHashCode(this) |
driverClassName |
这一项可配可不配,如果不配置druid会根据url自动识别dbType,然后选择相应的driverClassName(建议配置下) |
jdbcUrl |
连接数据库的url,不同数据库不一样。例如: mysql : jdbc:mysql://10.20.153.104:3306/druid2 oracle : jdbc:oracle:thin:@10.20.149.85:1521:ocnauto |
username |
连接数据库的用户名 |
password |
连接数据库的密码。如果你不希望密码直接写在配置文件中,可以使用ConfigFilter。详细看这里:https://github.com/alibaba/druid/wiki/%E4%BD%BF%E7%94%A8ConfigFilter |
initialSize |
初始化时建立物理连接的个数。初始化发生在显示调用init方法,或者第一次getConnection时 |
maxActive |
最大连接池数量 |
maxIdle |
已经不再使用,配置了也没效果 |
minIdle |
最小连接池数量 |
maxWait |
获取连接时最大等待时间,单位毫秒。配置了maxWait之后,缺省启用公平锁,并发效率会有所下降,如果需要可以通过配置useUnfairLock属性为true使用非公平锁。 |
poolPreparedStatements |
是否缓存preparedStatement,也就是PSCache。PSCache对支持游标的数据库性能提升巨大,比如说oracle。在mysql下建议关闭。 |
maxOpenPreparedStatements |
要启用PSCache,必须配置大于0,当大于0时,poolPreparedStatements自动触发修改为true。在Druid中,不会存在Oracle下PSCache占用内存过多的问题,可以把这个数值配置大一些,比如说100 |
validationQuery |
用来检测连接是否有效的sql,要求是一个查询语句。如果validationQuery为null,testOnBorrow、testOnReturn、testWhileIdle都不会其作用。 |
testOnBorrow |
申请连接时执行validationQuery检测连接是否有效,做了这个配置会降低性能。 |
testOnReturn |
归还连接时执行validationQuery检测连接是否有效,做了这个配置会降低性能 |
testWhileIdle |
建议配置为true,不影响性能,并且保证安全性。申请连接的时候检测,如果空闲时间大于timeBetweenEvictionRunsMillis,执行validationQuery检测连接是否有效。 |
timeBetweenEvictionRunsMillis |
有两个含义: 1) Destroy线程会检测连接的间隔时间2) testWhileIdle的判断依据,详细看testWhileIdle属性的说明 |
numTestsPerEvictionRun |
不再使用,一个DruidDataSource只支持一个EvictionRun |
minEvictableIdleTimeMillis |
|
connectionInitSqls |
物理连接初始化的时候执行的sql |
exceptionSorter |
当数据库抛出一些不可恢复的异常时,抛弃连接 |
filters |
属性类型是字符串,通过别名的方式配置扩展插件,常用的插件有: 监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall |
proxyFilters |
类型是List<com.alibaba.druid.filter.Filter>,如果同时配置了filters和proxyFilters,是组合关系,并非替换关系 |
使用注解实现Druid配置
引入支持依赖
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
②创建配置类
@Configuration
@PropertySource(value = {"classpath:datasource.properties"})//引入资源文件
public class DataSourceConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String userName;
@Value("${jdbc.password}")
private String password;
/**
* 数据源连接池
*/
@Bean
public DataSource dataSource(){
DruidDataSource druidDataSource = new DruidDataSource();
druidDataSource.setDriverClassName(driver);
druidDataSource.setUrl(url);
druidDataSource.setUsername(userName);
druidDataSource.setPassword(password);
return druidDataSource;
}
/**
* Spring JbdcTemplate
*/
@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
}
测试结果:
[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15), BaseBean(id=3, name=test, age=15), BaseBean(id=4, name=test, age=15), BaseBean(id=5, name=test, age=15), BaseBean(id=6, name=test, age=15), BaseBean(id=7, name=test, age=15)]
使用XML实现Druid配置
使用application.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 导入数据库资源文件 -->
<context:property-placeholder location="classpath:datasource.properties"/>
<!--配置数据源DBCP-->
<bean class="org.apache.commons.dbcp.BasicDataSource" id="dataSource">
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--配置数据源C3P0-->
<bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSourceC3P0">
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--配置数据源BoneCP-->
<bean class="com.jolbox.bonecp.BoneCPDataSource" id="dataSourceBoneCP">
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--配置数据源Druid-->
<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSourceDruid">
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--配置注入数据源Druid-->
<bean id = "baseDaoParent" class="com.my.spring.dao.BaseDaoParent">
<property name="dataSource" ref="dataSourceDruid"></property>
</bean>
<bean id="baseDao" class="com.my.spring.dao.BaseDao" parent="baseDaoParent"></bean>
<bean id="baseService" class="com.my.spring.service.impl.BaseServiceImpl">
<property name="baseDao" ref="baseDao"></property>
</bean>
</beans>
测试结果:
[BaseBean(id=1, name=test, age=15), BaseBean(id=2, name=test, age=15), BaseBean(id=3, name=test, age=15), BaseBean(id=4, name=test, age=15), BaseBean(id=5, name=test, age=15), BaseBean(id=6, name=test, age=15), BaseBean(id=7, name=test, age=15), BaseBean(id=8, name=test, age=15)]
四、Spring+数据库操作
如同往常我们想要实现一个简单的数据库操作,可能都会需要需要编写很多不必要的重复性代码,比如打开数据库,连接数据库,关闭数据库等,Spring JDBC使用JdbcTemplate封装重复操作
上述代码已经展示了简单的JdbcTemplate操作。实际上我们有几种可能的方式去使用JdbcTemplate带给我们的便利
Ⅰ、继承JdbcDaoSupport类
如同上述代码中所使用的例子:
@Component
public class BaseDaoParent extends JdbcDaoSupport {
//注入DataSource
@Autowired
private DataSource dataSource;
//因为JdbcDaoSupport的setDataSource方法是final修饰的,@Autowired注入失败,所以必须手动注入
@PostConstruct
private void initialize(){
setDataSource(dataSource);
}
}
@Repository
public class BaseDao extends BaseDaoParent{
/**
* 保存一个记录
* @param baseBean
*/
public void save(BaseBean baseBean){
this.getJdbcTemplate().update("insert into basebean(name,age) values ('"+baseBean.getName()+"',"+baseBean.getAge()+")");
}
/**
* 获取所有bean记录
* @return
*/
public List<BaseBean> findAll(){
RowMapper<BaseBean> rowMapper = new BeanPropertyRowMapper<>(BaseBean.class);
return this.getJdbcTemplate().query("select * from basebean",rowMapper);
}
}
可以看到这种方式的限制是DataSource的注入过于繁琐,所以一般不使用这种方式
Ⅱ、直接引用JdbcTemplate
实际上,上述代码中的this.getJdbcTemplate()得到的也是上下文中的JdbcTemplate对象,我们可以选择直接注入JdbcTemplate进行使用,效果一样:
@Repository
public class BaseDao{
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 保存一个记录
* @param baseBean
*/
public void save(BaseBean baseBean){
this.jdbcTemplate.update("insert into basebean(name,age) values ('"+baseBean.getName()+"',"+baseBean.getAge()+")");
}
/**
* 获取所有bean记录
* @return
*/
public List<BaseBean> findAll(){
RowMapper<BaseBean> rowMapper = new BeanPropertyRowMapper<>(BaseBean.class);
return this.jdbcTemplate.query("select * from basebean",rowMapper);
}
}
这种做法的限制是应用代码与Spring JdbcTemplate的耦合性增强
Ⅲ、使用JdbcOperations类
JdbcOperations 是一个接口,定义了 JdbcTemplate 所实现的操作。通过注入 JdbcOperations ,而不是具体的 JdbcTemplate ,能够保证dao 通过 JdbcOperations 接口达到与 JdbcTemplate 保持松耦合
@Repository
public class BaseDao{
@Autowired
private JdbcOperations jdbcOperations;
/**
* 保存一个记录
* @param baseBean
*/
public void save(BaseBean baseBean){
this.jdbcOperations.update("insert into basebean(name,age) values ('"+baseBean.getName()+"',"+baseBean.getAge()+")");
}
/**
* 获取所有bean记录
* @return
*/
public List<BaseBean> findAll(){
RowMapper<BaseBean> rowMapper = new BeanPropertyRowMapper<>(BaseBean.class);
return this.jdbcOperations.query("select * from basebean",rowMapper);
}
}
五、Spring与JdbcTemplate
实际上,JdbcTemplate所能做的远不止上述代码所展示。Spring中,有如下三种JdbcTemplate:
- JdbcTemplate :最基本的 Spring JDBC 模板,这个模板支持简单的 JDBC 数据库访问功能以及基于索引参数的查询;
- NamedParameterJdbcTemplate :使用该模板类执行查询时可以将值以命名参数的形式绑定到 SQL 中,而不是使用简单的索引参
- 数;
- SimpleJdbcTemplate :该模板类利用 Java 5 的一些特性如自动装箱、泛型以及可变参数列表来简化 JDBC 模板的使用。
我们采用最合适的jdbcOperations来学习JdbcTemplate的功能
JdbcTemplate主要提供以下五类方法:
- execute方法:可以用于执行任何SQL语句,一般用于执行DDL语句;
- update方法及batchUpdate方法:update方法用于执行新增、修改、删除等语句;batchUpdate方法用于执行批处理相关语句;
- query方法及queryForXXX方法:用于执行查询相关语句;
- call方法:用于执行存储过程、函数相关语句。
其中较为常用的有以下方法:
①<T> T queryForObject(String sql, RowMapper<T> rowMapper, @Nullable Object... args) throws DataAccessException
根据语句和传参查询某个记录并将结果封装成对象
private final static String FIND_BASE_BEAN = "select * from basebean where id=?";
public BaseBean findOne(Integer id){
//目标对象映射
RowMapper<BaseBean> rowMapper = new BeanPropertyRowMapper<>(BaseBean.class);
//执行查询并返回目标对象
return this.jdbcOperations.queryForObject(FIND_BASE_BEAN,rowMapper,id);
}
②int update(String sql, @Nullable Object... args) throws DataAccessException;
更新或插入数据
private final static String INSERT_BASE_BEAN = "insert into basebean(name,age) values (?,?)";
public void save(BaseBean baseBean){
this.jdbcOperations.update(INSERT_BASE_BEAN,baseBean.getName(),baseBean.getAge());
}
③int update(String sql, @Nullable PreparedStatementSetter pss) throws DataAccessException;
使用预编译设置更新或插入数据
private final static String INSERT_BASE_BEAN = "insert into basebean(name,age) values (?,?)";
int count = this.jdbcOperations.update(INSERT_BASE_BEAN, new PreparedStatementSetter() {
@Override
public void setValues(PreparedStatement pstmt) throws SQLException {
pstmt.setObject(1, baseBean.getName());
pstmt.setObject(2, baseBean.getAge());
}});
使用命名参数Template实现功能,与使用简单的JdbcTemplate几乎完全相同:
@Bean
public NamedParameterJdbcTemplate jdbcTemplate(DataSource dataSource) {
return new NamedParameterJdbcTemplate(dataSource);
}
通过NamedParameterJdbcTemplate执行插入
//此处留下命名参数占位
private final static String INSERT_BASE_BEAN = "insert into basebean(name,age) values (:name,:age)";
public void save(BaseBean baseBean){
//封装命名参数值
Map<String,Object> paramMap=new HashMap();
paramMap.put("name",baseBean.getName()));
paramMap.put("age", baseBean.getAge());
this.jdbcOperations.update(INSERT_BASE_BEAN,paramMap);
}
总结
数据是应用程序的血液。