Spring中JDBC操作简单总结-蒲公英云

[b]引言[/b]
　　Spring版本：4.2.5，代码编写时间：2016-03-16。
　　本人原创，转载请保留本人信息：http://wallimn.iteye.com。

　　简单起见，没有使用接口，整个示例仅涉及4个文件。代码逻辑很简单，基本不用解释。

[b]一、Spring配置文件applicationContext.xml[/b]

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
         http://www.springframework.org/schema/beans 
         http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 简单起见，使用Spring自带的数据源 -->
    <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="org.h2.Driver"></property>
        <property name="url" value="jdbc:h2:tcp://localhost/C:/h2-201510/jdbc"></property>
        <property name="username" value="sa"></property>
        <property name="password" value=""></property>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 
    注意：由于要使用NamedParameterJdbcTemplate，
    UserDaoImpl要从NamedParameterJdbcDaoSupport类派生 
    -->
    <bean id="userDao" class="com.wallimn.study.UserDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
</beans>

[b]二、用户类User.class[/b]

package com.wallimn.study;
public class User {
    private String id;
    private String username;
    private String password;
    public void setId(String id){
        this.id = id;
    }
    public String getId() {
        return id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        //return super.toString();
        return String.format("ID：%s\t\t\t用户名：%s\t\t密码：%s", id,username,password);
    }
}

[b]三、数据操作类UserDaoImpl.class[/b]

package com.wallimn.study;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.ParameterizedPreparedStatementSetter;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcDaoSupport;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils;
/**
 * 用户管理类，演示jdbc模板使用。
 * 使用JdbcTemplate模板（不支持命令参数等高级特性），需继承JdbcDaoSupport，
 * 使用NamedParameterJdbcTemplate，需继承NamedParameterJdbcDaoSupport，
 * 两个模板和Dao是有对应关系的。
 * @author Administrator
 *
 */
public class UserDaoImpl extends NamedParameterJdbcDaoSupport {
    /**
     * 创建测试用表，后面的测试以这个表为基础 <br/>
     * 时间：2016-3-15，作者：http://wallimn.iteye.com
     */
    public void createUserTable() {
        String sql = null;
        try {
            sql = "drop table user";
            this.getJdbcTemplate().execute(sql);
        } catch (Exception e) {
            e.printStackTrace();
        }
        sql = "create table user(id varchar(32) primary key,username varchar(32),password varchar(256))";
        this.getJdbcTemplate().execute(sql);
    }
    /**
     * 使用匿名参数
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @param user
     */
    public void addUser(User user) {
        String sql = "insert into user values(?,?,?)";
        this.getJdbcTemplate().update(sql, user.getId(), user.getUsername(),
                user.getPassword());
    }
    /**
     * 使用命名参数、Bean
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @param user
     */
    public void addUserBean(User user) {
        String sql = "insert into user values(:id,:username,:password)";
        this.getNamedParameterJdbcTemplate().update(sql,
                new BeanPropertySqlParameterSource(user));
    }
    /**
     * 使用命名参数、Map
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @param user
     */
    public void addUserMap(Map<String,Object> user) {
        String sql = "insert into user values(:id,:username,:password)";
        this.getNamedParameterJdbcTemplate().update(sql,
                new MapSqlParameterSource(user));
    }
    /**
     * 批量操作，一次性增加多个用户
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @param user
     */
    public void addUser1(final List<User> users) {
        if(users==null || users.size()==0)return;
        String sql = "insert into user values(?,?,?)";
        //使用匿名类
        BatchPreparedStatementSetter setter = new BatchPreparedStatementSetter(){
            @Override
            public int getBatchSize() {
                return users.size();
            }
            @Override
            public void setValues(PreparedStatement stat, int idx)
                    throws SQLException {
                stat.setString(1, users.get(idx).getId());
                stat.setString(2, users.get(idx).getUsername());
                stat.setString(3, users.get(idx).getPassword());
            }
        };
        this.getJdbcTemplate().batchUpdate(sql, setter);
    }
    /**
     * 批量操作，一次性增加多个用户
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @param user
     */
    public void addUsers2(final List<User> users) {
        if(users==null || users.size()==0)return;
        String sql = "insert into user values(?,?,?)";
        //使用匿名类
        ParameterizedPreparedStatementSetter<User> setter = new ParameterizedPreparedStatementSetter<User>(){
            @Override
            public void setValues(PreparedStatement stat, User user)
                    throws SQLException {
                stat.setString(1, user.getId());
                stat.setString(2, user.getUsername());
                stat.setString(3, user.getPassword());
            }
        };
        this.getJdbcTemplate().batchUpdate(sql,users,users.size(), setter);
    }
    /**
     * 批量操作，一次性增加多个用户
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @param user
     */
    public void addUsers3(final List<User> users) {
        if(users==null || users.size()==0)return;
        String sql = "insert into user values(:id,:username,:password)";
        //使用匿名类
        SqlParameterSource[] source = SqlParameterSourceUtils.createBatch(users.toArray());
        this.getNamedParameterJdbcTemplate().batchUpdate(sql, source);
    }
    /**
     * 删除指定ID的用户
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @param id
     */
    public void deleteUser(String id) {
        String sql = "delete from user where id=?";
        this.getJdbcTemplate().update(sql, id);
    }
    /**
     * 删除所有用户
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     */
    public void deleteAllUser() {
        String sql = "delete from user";
        this.getJdbcTemplate().update(sql);
    }
    /**
     * 修改用户信息
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @param user
     */
    public void updateUser(User user) {
        String sql = "update user set username=?,password=? where id=?";
        this.getJdbcTemplate().update(sql, user.getUsername(),
                user.getPassword(), user.getId());
    }
    /**
     * 根据ID查询用户名
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @param id
     * @return
     */
    public String queryUserName(String id) {// 简单查询，按照ID查询，返回字符串
        String sql = "select username from user where id=?";
        // 返回类型为String(String.class)
        return this.getJdbcTemplate().queryForObject(sql, String.class, id);
    }
    /**
     * 查询结果以List形式返回
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @return
     */
    public List<Map<String,Object>> queryForList() {
        String sql = "select * from user";
        return this.getJdbcTemplate().queryForList(sql);
    }
    /**
     * 查询结果不多于一条记录，以Map形式返回
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @param id
     * @return
     */
    public Map<String,Object> queryForMap(String id) {
        String sql = "select * from user where id=?";
        return this.getJdbcTemplate().queryForMap(sql,id);
    }
    /**
     * 查询结果不多于一条记录，以Map形式返回
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @param id
     * @return
     */
    public String queryForObject(String id) {
        String sql = "select username from user where id=?";
        return this.getJdbcTemplate().queryForObject(sql,new Object[]{id},String.class);
    }
    /**
     * 统计用户数量
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @return
     */
    public String queryUserCount() {
        String sql = "select count(*) from user";
        return this.getJdbcTemplate().queryForObject(sql,String.class);
    }
    /**
     * 查找指定ID的用户，使用RowMapper将结果转化为User类型
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @param id
     * @return
     */
    public User queryUser(String id) {
        String sql = "select * from user where id=?";
        return this.getJdbcTemplate().queryForObject(sql, new UserRowMapper(),
                id);
    }
    /**
     * 返回所有用户，使用RowMapper将结果转化为User类型
     * <br/>
     * 时间：2016-3-16，作者：http://wallimn.iteye.com
     * @return
     */
    public List<User> findAll() {// 复杂查询返回List集合
        String sql = "select * from user";
        return this.getJdbcTemplate().query(sql, new UserRowMapper());
    }
    /**
     * 将ResultSet转化为Bean的类。
     * @author Administrator
     *
     */
    class UserRowMapper implements RowMapper<User> {
        public User mapRow(ResultSet rs, int rowNum) throws SQLException {
            User user = new User();
            user.setId(rs.getString("id"));
            user.setUsername(rs.getString("username"));
            user.setPassword(rs.getString("password"));
            return user;
        }
    }
}

[b]四、测试类UserDaoTest.java[/b]

package com.wallimn.study;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class UserDaoTest {
    private ApplicationContext applicationContext = null;
    public UserDaoTest(){
        applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    }
    /**
     * DAO，简单起见，不使用接口。
     */
    private UserDaoImpl userDao;
    private UserDaoImpl getUserDao(){
        if(userDao==null){
            userDao = (UserDaoImpl)applicationContext.getBean("userDao");
        }
        return userDao;
    }
    /**
     * 返回GUID，用作主键
     * <br/>
     * 时间：2016-3-16，作者：wallimn@sohu.com
     * @return
     */
    private String getUUID(){
        return UUID.randomUUID().toString().replace("-", "").toLowerCase();
    }
    /**
     * 创建测试用表
     * <br/>
     * 时间：2016-3-16，作者：wallimn@sohu.com
     */
     @Test
     public void testCreateTable(){
         this.getUserDao().createUserTable();
     }
     /**
      * 插入、删除用户测试
      * <br/>
      * 时间：2016-3-16，作者：wallimn@sohu.com
      */
     @Test
     public void testAddAndDeleteUser(){
         String id1 = this.getUUID();
         String id2 = this.getUUID();
         String id3 = this.getUUID();
         String id4 = this.getUUID();
         this.getUserDao().deleteAllUser();
         User user=new User();
         user.setId(id1);
         user.setUsername("wallimn");
         user.setPassword("wallimn@sohu.com");
         this.getUserDao().addUser(user);
         user.setId(id2);
         this.getUserDao().addUserBean(user);
         user.setId(id3);
         this.getUserDao().addUserBean(user);
         Map<String,Object> m = new HashMap<String,Object>();
         m.put("id", id4);
         m.put("username", "张三");
         m.put("password", "mypwd");
         this.getUserDao().addUserMap(m);
         System.out.println("==插入四个用户，结果如下==");
         this.showUsers();
         this.getUserDao().deleteUser(id1);
         System.out.println("==删除一个用户，结果如下==");
         this.showUsers();
         System.out.println("==查询测试，结果为List==");
         List<Map<String,Object>> list = this.getUserDao().queryForList();
         for(Map<String,Object> map :list){
             System.out.println(map.get("username"));
         }
         System.out.println("==查询测试，结果为Map==");
         Map<String,Object> map = this.getUserDao().queryForMap(id3);
         System.out.println(map.get("username"));
         //如果没有查到数据，会报异常
         //map = this.getUserDao().queryForMap("notexist");
         //System.out.println(map.get("username"));
         System.out.println("==查询测试，结果为String==");
         String username = this.getUserDao().queryForObject(id3);
         System.out.println(username);
         //如果没有查到数据，会报异常
         //username = this.getUserDao().queryForObject("notexist");
         //System.out.println(username);
     }
     @Test
     public void testBatchInsert(){
         this.getUserDao().deleteAllUser();
         List<User> users = new LinkedList<User>();
         for(int i=0; i <1000; i ++){
             User u = new User();
             u.setId(String.format("%04d", i));
             u.setUsername("姓名"+i);
             u.setPassword("密码"+i);
             users.add(u);
         }
         this.getUserDao().addUsers3(users);
         System.out.println("用户数量："+this.getUserDao().queryUserCount());
     }
     /**
      * 显示所有用户，查看SQL执行情况。
      * <br/>
      * 时间：2016-3-16，作者：wallimn@sohu.com
      */
     private void showUsers(){
         List<User> users=this.getUserDao().findAll();
         for(User user : users){
             System.out.println(user);
         }
     }
}