《Spring實戰》-第十章:Spring和JDBC

慢慢來比較快,虛心學技術

數據訪問操作:初始化數據訪問框架、打開連接、處理各種異常和關閉連接,任何一步出現異常都有可能導致損壞或刪除企業數據庫珍貴數據

詳細文章請移步: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);
}

總結

數據是應用程序的血液。

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章