Spring學習筆記 Spring JDBC框架

阿新 • • 發佈：2019-01-15

Spring JDBC簡介

先來看看一個JDBC的例子。我們可以看到為了執行一條SQL語句，我們需要建立連線，建立語句物件，然後執行SQL，然後操縱結果集獲取資料。

try(Connection connection = DriverManager.getConnection(URL, USERNAME, PASSWORD)){
    List<User> users = new ArrayList<>();
    try (Statement statement = connection.createStatement()) {
        try (ResultSet rs = statement.executeQuery("SELECT *FROM user" 
)) {
            while (rs.next()) {
                User user = new User();
                user.setId(rs.getInt(1));
                user.setUsername(rs.getString(2));
                user.setPassword(rs.getString(3));
                user.setNickname(rs.getString(4));
                user.setBirthday(rs.getDate(5 
));
                users.add(user);
            }
        }
    }
}

其實這些步驟中有很多步驟都是固定的，Spring JDBC框架將這些操作封裝起來，我們只需要關注業務邏輯點即可。在Spring JDBC框架中，我們要做的事情如下：

定義連線字串引數。
指定SQL語句。
宣告引數和引數型別。
每次迭代結果集的操作。

Spring會幫我們完成以下事情：

開啟連線。
準備和執行SQL語句。
在需要的情況下迭代結果集。
處理異常。
操作事務。
關閉結果集、語句和資料庫連線。

使用JdbcTemplate

JdbcTemplate是Jdbc框架最重要的類，提供了較為底層的Jdbc操作。其它幾個類都是在JdbcTemplate基礎上封裝了相關功能。

新增依賴

要在Gradle專案中使用Spring JDBC框架，新增如下一段。由於Spring JDBC的主要類JdbcTemlate需要一個數據源用來初始化，所以還需要一個數據源的實現。

compile group: 'org.springframework', name: 'spring-jdbc', version: '4.3.5.RELEASE'
compile group: 'org.apache.commons', name: 'commons-dbcp2', version: '2.1.1'

如果要使用Spring框架的其他功能，可能還需要新增對應的依賴。

建立Jdbc Template Bean

首先需要建立一個數據源Bean。為了將配置分離，我們先新建一個jdbc.properties檔案。

jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=12345678

然後建立一個Spring配置檔案jdbc.xml。這裡用到了<context:property-placeholder>節點來匯入其它配置檔案。然後用這些屬性建立一個數據源Bean，然後再利用資料來源Bean來建立一個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"
       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="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <constructor-arg ref="dataSource"/>
    </bean>
    <context:property-placeholder location="jdbc.properties"/>
</beans>

JdbcTemplate操作

註冊了JdbcTemplate之後，就可以將它注入到任何地方來使用了。首先它可以使用execute方法，執行任何SQL語句。這裡建立了一個簡單的MySQL使用者表，只有主鍵和使用者名稱。

jdbcTemplate.execute("CREATE TABLE user(id INT AUTO_INCREMENT PRIMARY KEY,name VARCHAR(255) UNIQUE)");

它還可以使用update方法執行增加、更新和刪除操作。

jdbcTemplate.update("INSERT INTO user(name) VALUES(?)", "yitian");
jdbcTemplate.update("INSERT INTO user(name) VALUES(?)", "zhang2");
jdbcTemplate.update("UPDATE user SET name=? WHERE name=?", "zhang3", "zhang2");
jdbcTemplate.update("DELETE FROM user WHERE name=?", "zhang3");

查詢操作也很簡單，使用queryForObject方法，傳入SQL字串和結果型別即可。

int count = jdbcTemplate.queryForObject("SELECT count(*) FROM user", Integer.class);
System.out.println("記錄數目是:" + count);
String name = jdbcTemplate.queryForObject("SELECT name FROM user WHERE id=1", String.class);
System.out.println("姓名是:" + name);

如果要查詢整條記錄也可以。Spring提供了一個介面RowMapper，只需要實現該介面的mapRow方法，即可將結果集的一條記錄轉化為一個Java物件，該方法的第二個引數是當前行的行數。下面是一個RowMapper實現。

public class UserRowMapper implements RowMapper<User> {

    @Override
    public User mapRow(ResultSet rs, int rowNum) throws SQLException {
        return new User(rs.getInt(1), rs.getString(2));
    }
}

User實體類對應於上面建立表時簡單的使用者表（其他方法已省略）。

public class User {
    private int id;
    private String name;
}

實現了RowMapper介面之後，我們就可以查詢一條記錄並轉化為Java物件了。

User user = jdbcTemplate.queryForObject("SELECT id,name FROM user WHERE id=?", new UserRowMapper(), 1);
System.out.println(user);

查詢多條記錄也可以，這時候需要使用query方法。

List<User> users = jdbcTemplate.query("SELECT id,name FROM usr", new UserRowMapper());
System.out.println(users);

還有一個通用方法queryForList，返回一個List，每一個元素都是一個Map，在Map中存放著列名和值組成的鍵值對。

List<Map<String, Object>> results = jdbcTemplate.queryForList("SELECT id,name FROM user");
System.out.println(results);

使用NamedParameterJdbcTemplate

前面的JdbcTemplate提供了非常方便的JDBC操作封裝，但是在繫結引數的時候只能採用萬用字元?方式以順序方式繫結引數。如果SQL語句比較複雜，引數比較多，那麼這種方式顯得不太方便。因此Spring提供了一個更加方便的類NamedParameterJdbcTemplate，它可以以命名方式繫結SQL語句引數。NamedParameterJdbcTemplate在內部使用一個JdbcTemplate，你也可以呼叫getJdbcOperations方法獲取底層的JdbcTemplate物件，然後用前面的方法進行基本操作。

建立NamedParameterJdbcTemplate和JdbcTemplate相同，只需要傳入一個數據源即可。

<bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
    <constructor-arg ref="dataSource"/>
</bean>

NamedParameterJdbcTemplate和JdbcTemplate的大部分操作相同，這裡僅介紹繫結命名引數的部分。首先，SQL語句必須使用:引數名稱的形式作為引數。然後，我們建立一個MapSqlParameterSource物件，它的內部使用了一個Map儲存的命名引數的名稱和值。然後我們使用它的addValue方法傳遞需要的命名引數的名稱和值，這個方法還可以接受第三個引數指定引數型別，這個型別以java.sql.Types的一些公共欄位的形式給出。最後，將MapSqlParameterSource傳遞給相應的方法執行即可。

String sql = "SELECT id,name FROM user WHERE name=:name AND id<:user_id";
MapSqlParameterSource namedParameters = new MapSqlParameterSource();
namedParameters.addValue("name", "test");
namedParameters.addValue("user_id", 100, Types.INTEGER);
User user = namedParameterJdbcTemplate.queryForObject(sql, namedParameters, new UserRowMapper());
System.out.println(user);

如果不想建立MapSqlParameterSource物件，還可以直接使用一個Map傳遞命名引數的名稱和值。

Map<String, Object> map = new HashMap<>();
map.put("user_id", 100);
map.put("name", "test");
List<User> users = namedParameterJdbcTemplate.query(sql, map, new UserRowMapper());
System.out.println(users);

上面討論的MapSqlParameterSource實際上實現了SqlParameterSource介面，上面的幾個方法簽名也是接受SqlParameterSource介面。這個介面表示用來傳遞命名引數和值的集合。除了MapSqlParameterSource之外，還有另外一個常用的實現，BeanPropertySqlParameterSource，這個類接受一個Java Bean物件，然後使用Bean的屬性名和值作為命名引數的名稱和值。這一點需要注意。

User bean = new User(100, "test");
SqlParameterSource parameterSource = new BeanPropertySqlParameterSource(bean);
users = namedParameterJdbcTemplate.query(sql, parameterSource, new UserRowMapper());
System.out.println(users);

使用SimpleJdbc類

前面所說的JdbcTemplate封裝了一些功能，讓我們方便的使用JDBC。Spring還提供了幾個更高階、功能更具體的SimpleJdbc類。這些類會讀取JDBC的元資料Metadata，使用起來更加方便。

SimpleJdbcInsert

SimpleJdbcInsert類用來插入資料。簡單的使用方法如下。SimpleJdbcInsert需要一個數據源來建立，withTableName方法指定要插入的表名，usingGeneratedKeyColumns指定設定了主鍵自增的列名。其他使用方法和前面所說的類類似。executeAndReturnKey這個方法很特別，它會將資料插入資料庫並返回該條記錄對應的自增鍵。有時候我們可能希望使用自增主鍵來插入一條資料，由於主鍵是資料庫自動生成的，我們必須再次查詢資料庫才能獲得主鍵。這種情況下使用executeAndReturnKey非常方便。注意這個方法返回的是java.lang.Number型別，可以呼叫其XXXvalue方法轉換成各種數值。

SimpleJdbcInsert simpleJdbcInsert = new SimpleJdbcInsert(dataSource)
        .withTableName("user")
        .usingGeneratedKeyColumns("id");
User user = new User();
user.setName("test");
Map<String, Object> params = new HashMap<>();
params.put("names", user.getName());
int id = simpleJdbcInsert.executeAndReturnKey(params).intValue();
System.out.println("simpleJdbcInsert" + user);

SimpleJdbcCall

SimpleJdbcCall類用來呼叫儲存過程的。使用方法類似。這裡就直接給出Spring官方文件的示例程式碼了。

MySQL儲存過程。

CREATE FUNCTION get_actor_name (in_id INTEGER)
RETURNS VARCHAR(200) READS SQL DATA
BEGIN
    DECLARE out_name VARCHAR(200);
    SELECT concat(first_name, ' ', last_name)
        INTO out_name
        FROM t_actor where id = in_id;
    RETURN out_name;
END;

SimpleJdbcCall呼叫儲存過程。

public class JdbcActorDao implements ActorDao {

    private JdbcTemplate jdbcTemplate;
    private SimpleJdbcCall funcGetActorName;

    public void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        jdbcTemplate.setResultsMapCaseInsensitive(true);
        this.funcGetActorName = new SimpleJdbcCall(jdbcTemplate)
                .withFunctionName("get_actor_name");
    }

    public String getActorName(Long id) {
        SqlParameterSource in = new MapSqlParameterSource()
                .addValue("in_id", id);
        String name = funcGetActorName.executeFunction(String.class, in);
        return name;
    }

    // ... additional methods

}

如果要從儲存過程獲取記錄的話，可以這樣。以下是一個MySQL儲存過程。

CREATE PROCEDURE read_all_actors()
BEGIN
 SELECT a.id, a.first_name, a.last_name, a.birth_date FROM t_actor a;
END;

相對應的Java程式碼。

public class JdbcActorDao implements ActorDao {

    private SimpleJdbcCall procReadAllActors;

    public void setDataSource(DataSource dataSource) {
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        jdbcTemplate.setResultsMapCaseInsensitive(true);
        this.procReadAllActors = new SimpleJdbcCall(jdbcTemplate)
                .withProcedureName("read_all_actors")
                .returningResultSet("actors",
                BeanPropertyRowMapper.newInstance(Actor.class));
    }

    public List getActorsList() {
        Map m = procReadAllActors.execute(new HashMap<String, Object>(0));
        return (List) m.get("actors");
    }

    // ... additional methods

}

將JDBC操作轉化為Java物件

org.springframework.jdbc.object包下提供了一組類，讓我們用更加面向物件的方式來操作資料庫。我們可以將SQL查詢轉化為一組業務物件，也可以方便的進行查詢、更新和執行儲存過程的操作。

MappingSqlQuery

MappingSqlQuery是一個抽象類，繼承自SQLQuery。我們在使用這個類的時候需要建立一個自定義類，繼承自MappingSqlQuery，然後在其構造方法中初始化一個查詢字串，並在這裡設定查詢引數；然後需要實現該類的mapRow方法，將結果集的行轉化為實體類物件。下面是一個例子。構造方法中定義的查詢字串會被建立為PreparedStatement，因此可以在查詢字串中使用佔位符?。對於每個出現的佔位符，我們都必須呼叫declareParameter方法宣告引數，該方法接受一個SqlParameter物件，該物件需要引數名和型別兩個引數。最後需要呼叫compile方法編譯和準備查詢。該類是執行緒安全的，因此可以安全的在多個執行緒之間共享物件。

public class UserMappingSqlQuery extends MappingSqlQuery<User> {
    public UserMappingSqlQuery(DataSource ds) {
        super(ds, "SELECT id,name FROM user WHERE id=:id");
        super.declareParameter(new SqlParameter("id", Types.INTEGER));
        compile();
    }

    @Override
    protected User mapRow(ResultSet rs, int rowNum) throws SQLException {
        return new User(rs.getInt(1), rs.getString(2));
    }
}

然後我們建立一個物件，呼叫findObject方法並傳入查詢引數，即可獲得結果物件。

@Test
public void testMappingSqlQuery() {
    MappingSqlQuery<User> mappingSqlQuery = new UserMappingSqlQuery(dataSource);
    User user = mappingSqlQuery.findObject(1);
    logger.debug(user);
}

如果查詢要返回一組記錄並傳遞多個查詢引數。需要呼叫相應的execute方法。一下是另一個MappingSqlQuery，以及其測試程式碼。

public class UsersMappingSqlQuery extends MappingSqlQuery<User> {
    public UsersMappingSqlQuery(DataSource ds) {
        super(ds, "SELECT id,name FROM user WHERE id<? AND name LIKE ?");
        super.declareParameter(new SqlParameter("id", Types.INTEGER));
        super.declareParameter(new SqlParameter("name", Types.VARCHAR));
        compile();
    }

    @Override
    protected User mapRow(ResultSet rs, int rowNum) throws SQLException {
        return new User(rs.getInt(1), rs.getString(2));
    }
}

//獲取多個物件
mappingSqlQuery = new UsersMappingSqlQuery(dataSource);
List<User> users = mappingSqlQuery.execute(100, "test");
logger.debug(users);

使用SqlUpdate

這個類的使用方法和SqlQuery類似，但是由於它是一個具體類，因此不需要定義子類即可使用。下面是它的簡單使用方法。為了更新具體的資料（例如一個Java Bean物件），你也可以繼承該類，並提供自己的更新方法，就和上面一樣。

@Test
public void testSqlUpdate() {
    SqlUpdate sqlUpdate = new SqlUpdate(dataSource, "INSERT INTO user(name) VALUES(?)");
    sqlUpdate.declareParameter(new SqlParameter("name", Types.VARCHAR));
    sqlUpdate.compile();
    sqlUpdate.update("wang5");

    List<User> users = jdbcTemplate.query("SELECT id,name FROM user", new UserRowMapper());
    logger.debug(users);
}

使用StoredProcedure

StoredProcedure是關係資料庫中儲存過程概念的抽象類，提供了一組方便的受保護方法。因此在使用該類的時候需要我們建立一個子類，繼承該類。在使用這個類的時候我們需要使用setSql方法設定資料庫中儲存過程的名稱。在傳遞引數的時候，使用SqlParameter傳遞IN引數，使用SqlOutParameter傳遞OUT引數，使用SqlInOutParameter傳遞INOUT引數。

以下是Spring官方文件的一個例子。

class GetSysdateProcedure extends StoredProcedure {

    private static final String SQL = "sysdate";

    public GetSysdateProcedure(DataSource dataSource) {
        setDataSource(dataSource);
        setFunction(true);
        setSql(SQL);
        declareParameter(new SqlOutParameter("date", Types.DATE));
        compile();
    }

    public Date execute() {
        // the 'sysdate' sproc has no input parameters, so an empty Map is supplied...
        Map<String, Object> results = execute(new HashMap<String, Object>());
        Date sysdate = (Date) results.get("date");
        return sysdate;
    }
}

其他知識

提供SQL引數資訊

一般情況下Spring可以自行決定SQL引數的型別，但是有時候或者說最好由我們提供準確的SQL引數資訊。

JdbcTemplate的很多查詢和更新方法包含一個額外的引數，一個int陣列，該陣列應該是java.sql.Types指定的一些常量，表明SQL引數的型別。
可以使用SqlParameterValue來設定引數的值，在建立該物件的時候提供引數的值和型別。
如果使用具有命名引數功能的類時，使用SqlParameterSource類（BeanPropertySqlParameterSource或MapSqlParameterSource）來指定命名引數和其型別。

資料來源

我們在學習JDBC的時候，基本上都是從DriverManager類建立一個數據庫連線。在實際環境中，我們應該使用資料來源（DataSource）來建立資料庫連線。資料來源將建立資料庫的職責和應用程式碼分離，資料來源可以交給資料庫管理員來設定，程式設計師只需要獲取資料來源物件，然後開發相關程式碼。

在上面的例子中我們使用的是Apache的commons-dbcp2資料來源，Spring自己也實現了幾個資料來源方便我們開發和測試。

DriverManagerDataSource是一個簡單的資料來源，每次請求都會返回一個新的資料庫連線。它使用資料庫驅動來建立資料來源，就像我們使用DriverManager那樣。這是一個簡單的測試類，可以幫助我們在不借助任何Java EE容器的情況下獲取資料來源。但是由於使用commons-dbcp2這樣的成熟資料來源也很容易，所以其實我們只需要使用commons-dbcp2即可。

SingleConnectionDataSource也是一個數據源，它包裝了一個單獨的資料庫連線，在每次請求都會返回同一個資料庫連線物件。和DriverManagerDataSource相比它更輕量，因為沒有建立額外資料庫連線的開銷。

初始化資料來源

在建立資料來源的時候我們可以在Spring配置檔案中設定資料來源的初始化指令碼。

<jdbc:initialize-database data-source="dataSource">
    <jdbc:script location="classpath:com/foo/sql/db-schema.sql"/>
    <jdbc:script location="classpath:com/foo/sql/db-test-data.sql"/>
</jdbc:initialize-database>

有時候我們希望在初始化資料的時候刪除上一次的測試資料。但是如果資料庫不支援類似DROP TABLE IF EXISTS這樣的語法，那麼我們就必須在初始化指令碼中新增一些DROP語句。這些刪除語句可能會失敗（如果沒有測試資料的情況下執行刪除），這時候就可以忽略刪除失敗。當初始化指令碼出現錯誤的時候就會丟擲異常，但是如果設定了忽略刪除失敗，Spring就會直接忽略這些失敗而不丟擲異常。ignore-failures屬性還可以取另外兩個值NONE和ALL，分別表示不忽略失敗和忽略所有失敗。

<jdbc:initialize-database data-source="dataSource" ignore-failures="DROPS">
    <jdbc:script location="..."/>
</jdbc:initialize-database>

我們還可以設定初始化指令碼的間隔符。

<jdbc:initialize-database data-source="dataSource" separator="@@">
    <jdbc:script location="classpath:com/foo/sql/db-schema.sql" separator=";"/>
    <jdbc:script location="classpath:com/foo/sql/db-test-data-1.sql"/>
    <jdbc:script location="classpath:com/foo/sql/db-test-data-2.sql"/>
</jdbc:initialize-database>

工具類

org.springframework.jdbc.datasource.DataSourceUtils，這是一個方便的工具類，包含了一組和資料來源相關的工具方法。

org.springframework.jdbc.support.JdbcUtils類提供了一些方法來操作JDBC，在Spring內部使用，也可以用於自己的JDBC操作。

還有幾個工具類主要由Spring內部使用，這裡就不列舉了。

嵌入式資料庫支援

我們在開發資料庫應用的時候需要安裝某種型別的資料庫，比如MySQL等等。但是這樣就需要額外的專案依賴。這樣一個產品級的資料庫軟體動輒上G，安裝、測試都不方便。這時候我們可以使用嵌入式資料庫進行開發和測試。嵌入式資料庫具有佔用小、啟動快、配置簡單等特點，非常適合開發測試。而且由於嵌入式資料庫系統佔用低，在一些裝置上還可以直接作為儲存資料庫使用。例如輕量級嵌入式資料庫Sqlite，就安裝在每個安卓手機中，用於儲存資料。

在Spring中建立一個嵌入式資料庫，在XML中新增如下一段。這樣創建出來的資料庫可以直接作為javax.sql.DataSource型別的Spring Bean使用。最好設定generate-name="true"生成一個唯一名稱。預設情況下建立的是HSQL嵌入式資料庫。當然別忘了新增相應嵌入式資料庫的依賴項。

<jdbc:embedded-database id="dataSource" generate-name="true">
    <jdbc:script location="classpath:schema.sql"/>
    <jdbc:script location="classpath:test-data.sql"/>
</jdbc:embedded-database>

當然還可以以程式設計方式建立嵌入式資料庫。下面是上面等價的程式設計方式。

@Configuration
public class DataSourceConfig {

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
            .generateUniqueName(true)
            .setType(H2)
            .setScriptEncoding("UTF-8")
            .ignoreFailedDrops(true)
            .addScript("schema.sql")
            .addScripts("user_data.sql", "country_data.sql")
            .build();
    }
}

除了HSQL，Spring還支援H2和Derby兩種嵌入式資料庫（值得一提的是，現在的JDK分發包中附帶了一個Java DB資料庫，在安裝了JDK之後可以在JDK安裝目錄中看到db資料夾，這裡面存放的其實就是Derby資料庫）。要指定資料庫型別，在上面的XML片段中新增embedded-database屬性並設定HSQL、H2或Derby。如果使用程式設計方式，在EmbeddedDatabaseBuilder上呼叫setType(EmbeddedDatabaseType)方法，該方法的引數指定一個列舉，指定這三種類型。

上面的generate-name="true"或者generateUniqueName(true)挺重要的。如果不指定這個屬性。在多次呼叫嵌入式資料庫之後，可能會生成多個數據庫例項。為了避免這種情況發生，需要設定這個屬性。設定之後，如果已經存在了資料庫例項，就會使用這個已存在的例項，而不是設定新的例項。這個屬性是在Spring 4.2中增加的。使用以下幾個方法都可以設定該屬性。

EmbeddedDatabaseFactory.setGenerateUniqueDatabaseName()
EmbeddedDatabaseBuilder.generateUniqueName()
<jdbc:embedded-database generate-name="true" … >

參考資料

專案程式碼在Csdn程式碼庫，有興趣的同學可以看看。

最後祝大家新年快樂！