慢慢來比較快,虛心學技術
數據訪問操作:初始化數據訪問框架、打開連接、處理各種異常和關閉連接,任何一步出現異常都有可能導致損壞或刪除企業數據庫珍貴數據
詳細文章請移步:CSDN-《Spring實戰》-第十章:Spring和JDBC
一、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:數據庫連接密碼
首先引入依賴包: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:登錄數據庫的密碼
使用註解方式配置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:數據庫的密碼
使用註解實現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。
使用註解實現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);
}
總結
數據是應用程序的血液。