Spring【DAO模組】就是這麼簡單

Java3y發表於2018-03-15
Spring

前言

上一篇Spring博文主要講解了如何使用Spring來實現AOP程式設計，本博文主要講解Spring的DAO模組對JDBC的支援，以及Spring對事務的控制...

對於JDBC而言，我們肯定不會陌生，我們在初學的時候肯定寫過非常非常多的JDBC模板程式碼！

回顧對模版程式碼優化過程

我們來回憶一下我們怎麼對模板程式碼進行優化的！

  • 首先來看一下我們原生的JDBC：需要手動去資料庫的驅動從而拿到對應的連線..

		try {
			String sql = "insert into t_dept(deptName) values('test');";
			Connection con = null;
			Statement stmt = null;
			Class.forName("com.mysql.jdbc.Driver");
			// 連線物件
			con = DriverManager.getConnection("jdbc:mysql:///hib_demo", "root", "root");
			// 執行命令物件
			stmt =  con.createStatement();
			// 執行
			stmt.execute(sql);
			
			// 關閉
			stmt.close();
			con.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

複製程式碼
  • 因為JDBC是面向介面程式設計的，因此資料庫的驅動都是由資料庫的廠商給做到好了，我們只要載入對應的資料庫驅動，便可以獲取對應的資料庫連線....因此，我們寫了一個工具類，專門來獲取與資料庫的連線(Connection),當然啦，為了更加靈活，我們的工具類是讀取配置檔案的方式來做的。


    /*
    * 連線資料庫的driver，url，username，password通過配置檔案來配置，可以增加靈活性
    * 當我們需要切換資料庫的時候，只需要在配置檔案中改以上的資訊即可
    *
    * */

    private static String  driver = null;
    private static String  url = null;
    private static String  username = null;
    private static String password = null;

    static {
        try {

            //獲取配置檔案的讀入流
            InputStream inputStream = UtilsDemo.class.getClassLoader().getResourceAsStream("db.properties");

            Properties properties = new Properties();
            properties.load(inputStream);

            //獲取配置檔案的資訊
            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");

            //載入驅動類
            Class.forName(driver);


        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url,username,password);
    }
    public static void release(Connection connection, Statement statement, ResultSet resultSet) {

        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
複製程式碼
  • 經過上面一層的封裝，我們可以**在使用的地方直接使用工具類來得到與資料庫的連線...那麼比原來就方便很多了！**但是呢，每次還是需要使用Connection去建立一個Statement物件。並且無論是什麼方法，其實就是SQL語句和傳遞進來的引數不同！
  • 於是，我們就自定義了一個JDBC的工具類，詳情可以看blog.csdn.net/hon_3y/arti…
  • 我們自定義的工具類其實就是以DbUtils元件為模板來寫的，因此我們在開發的時候就一直使用DbUtils元件了。

使用Spring的JDBC

上面已經回顧了一下以前我們的JDBC開發了，那麼看看Spring對JDBC又是怎麼優化的

首先，想要使用Spring的JDBC模組，就必須引入兩個jar檔案：

  • 引入jar檔案

    • spring-jdbc-3.2.5.RELEASE.jar
    • spring-tx-3.2.5.RELEASE.jar

  • 首先還是看一下我們原生的JDBC程式碼：獲取Connection是可以抽取出來的，直接使用dataSource來得到Connection就行了。


	public void save() {
		try {
			String sql = "insert into t_dept(deptName) values('test');";
			Connection con = null;
			Statement stmt = null;
			Class.forName("com.mysql.jdbc.Driver");
			// 連線物件
			con = DriverManager.getConnection("jdbc:mysql:///hib_demo", "root", "root");
			// 執行命令物件
			stmt =  con.createStatement();
			// 執行
			stmt.execute(sql);
			
			// 關閉
			stmt.close();
			con.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
複製程式碼
  • 值得注意的是，JDBC對C3P0資料庫連線池是有很好的支援的。因此我們直接可以使用Spring的依賴注入，在配置檔案中配置dataSource就行了！

	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
		<property name="initialPoolSize" value="3"></property>
		<property name="maxPoolSize" value="10"></property>
		<property name="maxStatements" value="100"></property>
		<property name="acquireIncrement" value="2"></property>
	</bean>
複製程式碼

	// IOC容器注入
	private DataSource dataSource;
	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}

	
	public void save() {
		try {
			String sql = "insert into t_dept(deptName) values('test');";
			Connection con = null;
			Statement stmt = null;
			// 連線物件
			con = dataSource.getConnection();
			// 執行命令物件
			stmt =  con.createStatement();
			// 執行
			stmt.execute(sql);
			
			// 關閉
			stmt.close();
			con.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
複製程式碼

  • Spring來提供了JdbcTemplate這麼一個類給我們使用！它封裝了DataSource，也就是說我們可以在Dao中使用JdbcTemplate就行了。

  • 建立dataSource，建立jdbcTemplate物件


<?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"
       xmlns:c="http://www.springframework.org/schema/c"
       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">

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///zhongfucheng"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
        <property name="initialPoolSize" value="3"></property>
        <property name="maxPoolSize" value="10"></property>
        <property name="maxStatements" value="100"></property>
        <property name="acquireIncrement" value="2"></property>
    </bean>

    <!--掃描註解-->
    <context:component-scan base-package="bb"/>

    <!-- 2. 建立JdbcTemplate物件 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
</beans>

複製程式碼
  • userDao
package bb;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

/**
 * Created by ozc on 2017/5/10.
 */


@Component
public class UserDao implements IUser {

    //使用Spring的自動裝配
    @Autowired
    private JdbcTemplate template;

    @Override
    public void save() {
        String sql = "insert into user(name,password) values('zhoggucheng','123')";
        template.update(sql);
    }

}


複製程式碼
  • 測試：

    @Test
    public void test33() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");

        UserDao userDao = (UserDao) ac.getBean("userDao");
        userDao.save();
    }
複製程式碼

這裡寫圖片描述

JdbcTemplate查詢

我們要是使用JdbcTemplate查詢會發現有很多過載了query()方法

這裡寫圖片描述

一般地，如果我們使用queryForMap()，那麼只能封裝一行的資料，如果封裝多行的資料、那麼就會報錯！並且，Spring是不知道我們想把一行資料封裝成是什麼樣的，因此返回值是Map集合...我們得到Map集合的話還需要我們自己去轉換成自己需要的型別。

我們一般使用下面這個方法：

這裡寫圖片描述

我們可以實現RowMapper，告訴Spriing我們將每行記錄封裝成怎麼樣的。


    public void query(String id) {
        String sql = "select * from USER where password=?";

        List<User> query = template.query(sql, new RowMapper<User>() {


            //將每行記錄封裝成User物件
            @Override
            public User mapRow(ResultSet resultSet, int i) throws SQLException {
                User user = new User();
                user.setName(resultSet.getString("name"));
                user.setPassword(resultSet.getString("password"));

                return user;
            }

        },id);


        System.out.println(query);
    }

複製程式碼

這裡寫圖片描述

當然了，一般我們都是將每行記錄封裝成一個JavaBean物件的，因此直接實現RowMapper，在使用的時候建立就好了。

	class MyResult implements RowMapper<Dept>{

		// 如何封裝一行記錄
		@Override
		public Dept mapRow(ResultSet rs, int index) throws SQLException {
			Dept dept = new Dept();
			dept.setDeptId(rs.getInt("deptId"));
			dept.setDeptName(rs.getString("deptName"));
			return dept;
		}
		
	}
複製程式碼

事務控制概述

下面主要講解Spring的事務控制，如何使用Spring來對程式進行事務控制....

  • Spring的事務控制是屬於Spring Dao模組的。

一般地，我們事務控制都是在service層做的。。為什麼是在service層而不是在dao層呢？？有沒有這樣的疑問...

service層是業務邏輯層，service的方法一旦執行成功，那麼說明該功能沒有出錯。

一個service方法可能要呼叫dao層的多個方法...如果在dao層做事務控制的話，一個dao方法出錯了，僅僅把事務回滾到當前dao的功能，這樣是不合適的[因為我們的業務由多個dao方法組成]。如果沒有出錯，呼叫完dao方法就commit了事務，這也是不合適的[導致太多的commit操作]。

事務控制分為兩種：

  • 程式設計式事務控制
  • 宣告式事務控制

程式設計式事務控制

自己手動控制事務，就叫做程式設計式事務控制。

  • Jdbc程式碼： 
    •   Conn.setAutoCommite(false);  // 設定手動控制事務
複製程式碼
  • Hibernate程式碼： 
    •   Session.beginTransaction();    // 開啟一個事務
複製程式碼
  • 【細粒度的事務控制： 可以對指定的方法、指定的方法的某幾行新增事務控制】
  • (比較靈活，但開發起來比較繁瑣： 每次都要開啟、提交、回滾.)

宣告式事務控制

Spring提供對事務的控制管理就叫做宣告式事務控制

Spring提供了對事務控制的實現。

  • 如果使用者想要使用Spring的事務控制，只需要配置就行了。
  • 當不用Spring事務的時候，直接移除就行了。
  • Spring的事務控制是基於AOP實現的。因此它的耦合度是非常低的。
  • 【粗粒度的事務控制： 只能給整個方法應用事務，不可以對方法的某幾行應用事務。】
    • (因為aop攔截的是方法。)

Spring給我們提供了事務的管理器類，事務管理器類又分為兩種，因為JDBC的事務和Hibernate的事務是不一樣的。

  • Spring宣告式事務管理器類： 
    •   Jdbc技術：DataSourceTransactionManager
複製程式碼
    •   Hibernate技術：HibernateTransactionManager
複製程式碼

宣告式事務控制

我們基於Spring的JDBC來做例子吧

引入相關jar包

  • AOP相關的jar包【因為Spring的宣告式事務控制是基於AOP的，那麼就需要引入AOP的jar包。】
  • 引入tx名稱空間
  • 引入AOP名稱空間
  • 引入jdbcjar包【jdbc.jar包和tx.jar包】

搭建配置環境

  • 編寫一個介面
public interface IUser {
    void save();
}

複製程式碼
  • UserDao實現類，使用JdbcTemplate對資料庫進行操作！

@Repository
public class UserDao implements IUser {

    //使用Spring的自動裝配
    @Autowired
    private JdbcTemplate template;

    @Override
    public void save() {
        String sql = "insert into user(name,password) values('zhong','222')";
        template.update(sql);
    }

}
複製程式碼
  • userService

@Service
public class UserService {

    @Autowired
    private UserDao userDao;
    public void save() {

        userDao.save();
    }
}
複製程式碼
  • bean.xml配置：配置資料庫連線池、jdbcTemplate物件、掃描註解

<?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"
       xmlns:c="http://www.springframework.org/schema/c"
       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">


    <!--資料連線池配置-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///zhongfucheng"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
        <property name="initialPoolSize" value="3"></property>
        <property name="maxPoolSize" value="10"></property>
        <property name="maxStatements" value="100"></property>
        <property name="acquireIncrement" value="2"></property>
    </bean>

    <!--掃描註解-->
    <context:component-scan base-package="bb"/>

    <!-- 2. 建立JdbcTemplate物件 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>
複製程式碼

前面搭建環境的的時候，是沒有任何的事務控制的。

也就是說，當我在service中呼叫兩次userDao.save()，即時在中途中有異常丟擲，還是可以在資料庫插入一條記錄的。

  • Service程式碼：

@Service
public class UserService {

    @Autowired
    private UserDao userDao;
    public void save() {

        userDao.save();

        int i = 1 / 0;
        userDao.save();
    }
}

複製程式碼
  • 測試程式碼：

public class Test2 {

    @Test
    public void test33() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");

        UserService userService = (UserService) ac.getBean("userService");
        userService.save();
    }
}

複製程式碼

這裡寫圖片描述

XML方式實現宣告式事務控制

首先，我們要配置事務的管理器類：因為JDBC和Hibernate的事務控制是不同的。

    <!--1.配置事務的管理器類:JDBC-->
    <bean id="txManage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <!--引用資料庫連線池-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

複製程式碼

再而，配置事務管理器類如何管理事務


    <!--2.配置如何管理事務-->
    <tx:advice id="txAdvice" transaction-manager="txManage">
        
        <!--配置事務的屬性-->
        <tx:attributes>
            <!--所有的方法，並不是只讀-->
            <tx:method name="*" read-only="false"/>
        </tx:attributes>
    </tx:advice>
    
複製程式碼

最後，配置攔截哪些方法，


    <!--3.配置攔截哪些方法+事務的屬性-->
    <aop:config>
        <aop:pointcut id="pt" expression="execution(* bb.UserService.*(..) )"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"></aop:advisor>
    </aop:config>
複製程式碼

配置完成之後，service中的方法都應該被Spring的宣告式事務控制了。因此我們再次測試一下：


    @Test
    public void test33() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");

        UserService userService = (UserService) ac.getBean("userService");
        userService.save();
    }
複製程式碼

這裡寫圖片描述

使用註解的方法實現事務控制

當然了，有的人可能覺得到XML檔案上配置太多東西了。Spring也提供了使用註解的方式來實現對事務控制

第一步和XML的是一樣的，必須配置事務管理器類：


    <!--1.配置事務的管理器類:JDBC-->
    <bean id="txManage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <!--引用資料庫連線池-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    

複製程式碼

第二步：開啟以註解的方式來實現事務控制


    <!--開啟以註解的方式實現事務控制-->
    <tx:annotation-driven transaction-manager="txManage"/>
    
複製程式碼

最後，**想要控制哪個方法事務，在其前面新增@Transactional這個註解就行了！**如果想要控制整個類的事務，那麼在類上面新增就行了。


    @Transactional
    public void save() {

        userDao.save();

        int i = 1 / 0;
        userDao.save();
    }
複製程式碼

這裡寫圖片描述

事務屬性

其實我們**在XML配置管理器類如何管理事務，就是在指定事務的屬性！**我們來看一下事務的屬性有什麼：

這裡寫圖片描述

對於事務的隔離級別，不清楚的朋友可參考我之前的博文：blog.csdn.net/hon_3y/arti…

事務傳播行為:

看了上面的事務屬性，沒有接觸過的其實就這麼一個：propagation = Propagation.REQUIRED事務的傳播行為。

事務傳播行為的屬性有以下這麼多個，常用的就只有兩個：

  • Propagation.REQUIRED【如果當前方法已經有事務了，加入當前方法事務】
  • Propagation.REQUIRED_NEW【如果當前方法有事務了，當前方法事務會掛起。始終開啟一個新的事務，直到新的事務執行完、當前方法的事務才開始】

這裡寫圖片描述

###當事務傳播行為是Propagation.REQUIRED###

  • 現在有一個日誌類，它的事務傳播行為是Propagation.REQUIRED

	Class Log{
			Propagation.REQUIRED  
			insertLog();  
	}
複製程式碼
  • 現在，我要在儲存之前記錄日誌

	Propagation.REQUIRED
	Void  saveDept(){
		insertLog();   
		saveDept();
	}
複製程式碼

saveDept()本身就存在著一個事務，當呼叫insertLog()的時候，insertLog()的事務會加入到saveDept()事務中

也就是說，saveDept()方法內始終是一個事務，如果在途中出現了異常，那麼insertLog()的資料是會被回滾的【因為在同一事務內】


	Void  saveDept(){
		insertLog();    // 加入當前事務
		.. 異常, 會回滾
		saveDept();
	}
複製程式碼

###當事務傳播行為是Propagation.REQUIRED_NEW###

  • 現在有一個日誌類，它的事務傳播行為是Propagation.REQUIRED_NEW

	Class Log{
			Propagation.REQUIRED  
			insertLog();  
	}
複製程式碼
  • 現在，我要在儲存之前記錄日誌

	Propagation.REQUIRED
	Void  saveDept(){
		insertLog();   
		saveDept();
	}
複製程式碼

當執行到saveDept()中的insertLog()方法時，insertLog()方法發現 saveDept()已經存在事務了，insertLog()會獨自新開一個事務，直到事務關閉之後，再執行下面的方法

如果在中途中丟擲了異常，insertLog()是不會回滾的，因為它的事務是自己的，已經提交了


	Void  saveDept(){
		insertLog();    // 始終開啟事務
		.. 異常, 日誌不會回滾
		saveDept();
	}
複製程式碼

如果文章有錯的地方歡迎指正，大家互相交流。習慣在微信看技術文章，想要獲取更多的Java資源的同學，可以關注微信公眾號:Java3y

相關文章