spring jdbcTemplate使用

阅读更多

一、使用示例
(1)springJdbcContext.xml

"1.0" encoding="UTF-8"?>
 "http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:context="http://www.springframework.org/schema/context"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    springApp

     "dataSource"
         class="org.apache.commons.dbcp.BasicDataSource"
         destroy-method="close">
         "driverClassName"
             value="com.mysql.jdbc.Driver" />
         "url"
             value="jdbc:mysql://localhost:3306/springapp" />
         "username" value="root" />
         "password" value="****" />


     "TransactionManager"
          class = "org.springframework.jdbc.datasource.DataSourceTransactionManager">
          "dataSource" ref="dataSource"/>



     "jdbcTemplate"
          class = "org.springframework.jdbc.core.JdbcTemplate">
          "dataSource" ref="dataSource"/>


     "actorJdbcTemplateDao"
          class = "com.logcd.bo.dao.impl.ActorJdbcTemplateDaoImpl">
          "jdbcTemplate" ref="jdbcTemplate"/>



     "actorEventDao"
          class = "com.logcd.bo.dao.impl.ActorEventDaoImpl">
          "dataSource" ref="dataSource"/>



    "transactionInterceptor"
          class="org.springframework.transaction.interceptor.TransactionInterceptor">
         "transactionManager">
                   "transactionManager" />


    "transactionAttributes">

             "delete*">PROPAGATION_REQUIRED
             "operate*">PROPAGATION_REQUIRED,-Exception
             "insert*">PROPAGATION_REQUIRED,-Exception
             "update*">PROPAGATION_REQUIRED,-Exception
             "save*">PROPAGATION_REQUIRED
             "find*">PROPAGATION_REQUIRED,readOnly



    "txProxy"
          class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
         "beanNames">

             *Dao*


         "interceptorNames">

             transactionInterceptor

	springApp	
	
	
		
		
		
		
		

	 
          
    
    
    
     
          
    

     
          
    
    
    
     
          
    

       
      
            
                     
           
    
      
           
            PROPAGATION_REQUIRED
            PROPAGATION_REQUIRED,-Exception   
            PROPAGATION_REQUIRED,-Exception   
            PROPAGATION_REQUIRED,-Exception   
            PROPAGATION_REQUIRED   
            PROPAGATION_REQUIRED,readOnly   
          
      
      
      
           
             
             *Dao*
             
           
           
             
             transactionInterceptor   
             
           
     

(2)接口：(以第二种方式定义DAO)

package com.logcd.bo.dao;

 import java.util.List;

 import org.springframework.jdbc.support.KeyHolder;

 import com.logcd.bo.Actor;

 public interface ActorEventDao {
     /**
     * 根据SQL建表
     * @param sql
     */
     public void createTableBySQL(String sql);

     /**
     * 统计firstName相同的总数
     * @param firstName
     * @return
     */
     public int findCountOfActorsByFirstName(String firstName);

     /**
     * 插入记录并返回自动生成的主键Id
     * @param ps
     * @return
     */
     public KeyHolder insertActor(final Actor actor);

     /**
     * 用SimpleJdbcInsert插入一条记录:mysql测试成功
     */
     public long inserOneActor(Actor actor);

     /**
     * 插入/更新/删除数据
     * @param sql 有参数语句
     * @param obj 参数值数组
     */
     public int operateActor(String sql,Object[] obj);

     /**
     * 根据SQL查询记录总数
     * @param sql
     * @return
     */
     public int findRowCountBySQL(String sql);

     /**
     * 根据Id查找指定对象
     * @param id
     * @return
     */
     public Actor findActorById(long id);

     /**
     * 根据Id查找指定对象
     * @param id
     * @return
     */
     public Actor findActorByIdSimple(long id);

     /**
     * 返回所有对象
     * @return
     */
     public List findAllActors();

             /**
     * 批量更新
     * @param actors
     * @return
     */
     public int[] updateBatchActors(final List actors);

     /**
     * 批量更新
     * @param actors
     * @return
     */
     public int[] updateBatchActorsSimple(final List actors);

}

package com.logcd.bo.dao;

import java.util.List;

import org.springframework.jdbc.support.KeyHolder;

import com.logcd.bo.Actor;

public interface ActorEventDao {
	/**
	 * 根据SQL建表
	 * @param sql
	 */
	public void createTableBySQL(String sql);

	/**
	 * 统计firstName相同的总数
	 * @param firstName
	 * @return
	 */
	public int findCountOfActorsByFirstName(String firstName);

	/**
	 * 插入记录并返回自动生成的主键Id
	 * @param ps
	 * @return
	 */
	public KeyHolder insertActor(final Actor actor);

	/**
	 * 用SimpleJdbcInsert插入一条记录:mysql测试成功
	 */
	public long inserOneActor(Actor actor);
	
	/**
	 * 插入/更新/删除数据
	 * @param sql 有参数语句
	 * @param obj 参数值数组
	 */
	public int operateActor(String sql,Object[] obj);

	/**
	 * 根据SQL查询记录总数
	 * @param sql
	 * @return
	 */
	public int findRowCountBySQL(String sql);

	/**
	 * 根据Id查找指定对象
	 * @param id
	 * @return
	 */
	public Actor findActorById(long id);

	/**
	 * 根据Id查找指定对象
	 * @param id
	 * @return
	 */
	public Actor findActorByIdSimple(long id);

	/**
	 * 返回所有对象
	 * @return
	 */
	public List findAllActors();

         	/**
	 * 批量更新
	 * @param actors
	 * @return
	 */
	public int[] updateBatchActors(final List actors);

	/**
	 * 批量更新
	 * @param actors
	 * @return
	 */
	public int[] updateBatchActorsSimple(final List actors);

}

(3)接口实现

package com.logcd.bo.dao.impl;

 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.List;

 import javax.sql.DataSource;

 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.core.PreparedStatementCreator;
 import org.springframework.jdbc.core.RowMapper;
 import org.springframework.jdbc.support.GeneratedKeyHolder;
 import org.springframework.jdbc.support.KeyHolder;

 import com.logcd.bo.Actor;
 import com.logcd.bo.dao.ActorEventDao;

 public class ActorEventDaoImpl implements ActorEventDao{

     private JdbcTemplate jdbcTemplate;

     //NamedParameterJdbcTemplate对JdbcTemplate封装，增加了命名参数特性
     private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

     //SimpleJdbcTemplate对JdbcTemplate封装,某些特性要在java5以上才工作
     private SimpleJdbcTemplate simpleJdbcTemplate;

     //简化插入数据操作
     private SimpleJdbcInsert inserActor;

     public void setDataSource(DataSource dataSource){
         this.jdbcTemplate = new JdbcTemplate(dataSource);
         this.namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(dataSource);
         this.simpleJdbcTemplate = new SimpleJdbcTemplate(dataSource);
         this.inserActor = new SimpleJdbcInsert(dataSource)
         .withTableName("actors")
         .usingColumns("first_name","last_name")//插入这些字段
         .usingGeneratedKeyColumns("id");//带回生成的id
    }

     /**
     * 用SimpleJdbcInsert插入一条记录
     */
     public long inserOneActor(Actor actor){
         Map parameters = new HashMap();
         parameters.put("first_name",actor.getFirstName());
         parameters.put("last_name",actor.getLastName());
         return inserActor.executeAndReturnKey(parameters).longValue();
    }

     /**
     * 统计firstName相同的总数
     * @param firstName
     * @return
     */
     public int findCountOfActorsByFirstName(String firstName){
         String sql="select count(0) from actors where first_name = :first_name";
         SqlParameterSource namedParameters = new MapSqlParameterSource("first_name",firstName);
         //Map namedParameter = Collections.singletonMap("first_name",firstName);
         //还有一种Bean封装的方式
         //SqlParameterSource namedParameters = new BeanPropertySqlParameterSource(exampleActor);
         return this.namedParameterJdbcTemplate.queryForInt(sql, namedParameters);
    }

     /**
     * 根据SQL建表
     * @param sql
     */
     public void createTableBySQL(String sql) {
         this.jdbcTemplate.execute(sql);
    }

     /**
     * 插入记录并返回自动生成的主键Id(MySQL中不行，Oracle可以)
     * @param ps
     * @return
     */
     public KeyHolder insertActor(final Actor actor){
         final String addSql = "insert into actors(first_name,last_name) values (?,?)";
         KeyHolder keyHolder = new GeneratedKeyHolder();
         this.jdbcTemplate.update(new PreparedStatementCreator(){
             public PreparedStatement createPreparedStatement(Connection conn) throws SQLException {
                PreparedStatement ps =
                     conn.prepareStatement(addSql, new String[]{"id"});//返回id
                 ps.setString(1, actor.getFirstName());
                 ps.setString(2, actor.getLastName());
                 return ps;
            }

        });
        System.out.println(keyHolder.getKey());
         return keyHolder;
    }

     /**
     * 插入/更新/删除数据
     * @param sql 有参数语句
     * @param obj 参数值数组
     */
     public int operateActor(String sql,Object[] obj){
         return this.jdbcTemplate.update(sql, obj);
    }

     /**
     * 根据SQL查询记录总数
     * @param sql
     * @return
     */
     public int findRowCountBySQL(String sql){
         return this.jdbcTemplate.queryForInt(sql);
    }

     /**
     * 根据Id查找指定对象
     * @param id
     * @return
     */
     public Actor findActorById(long id){
         Actor actor = (Actor) this.jdbcTemplate.queryForObject(
                 "select id,first_name,last_name from actors where id = ?",
                 new Object[]{new Long(id)},
                 new RowMapper(){

                     public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
                         Actor act = new Actor();
                         act.setId(rs.getLong("id"));
                         act.setFirstName(rs.getString("first_name"));
                         act.setLastName(rs.getString("last_Name"));
                         return act;
                    }

                });
         return actor;
    }


     /**
     * 根据Id查找指定对象
     * @param id
     * @return
     */
     public Actor findActorByIdSimple(long id){
         String sql = "select id,first_name,last_name from actors where id = ?";

         ParameterizedRowMapper mapper = new ParameterizedRowMapper(){
             //notice the return type with respect to java 5 covariant return types
             public Actor mapRow(ResultSet rs, int rowNum) throws SQLException {
                 Actor act = new Actor();
                 act.setId(rs.getLong("id"));
                 act.setFirstName(rs.getString("first_name"));
                 act.setLastName(rs.getString("last_Name"));
                 return act;
            }
        };

         return this.simpleJdbcTemplate.queryForObject(sql, mapper, id);
    }

     /**
     * 返回所有对象
     * @return
     */
     public List findAllActors(){
         return this.jdbcTemplate.query(
                 "select id,first_name,last_name from actors",
                 new ActorMapper());
    }

     /**
     * 定义一个静态内部类，在Dao的方法中被共享
     * @author logcd
     */
     private static final class ActorMapper implements RowMapper{

         public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
             Actor act = new Actor();
             act.setId(rs.getLong("id"));
             act.setFirstName(rs.getString("first_name"));
             act.setLastName(rs.getString("last_Name"));
             return act;
        }

    }
}

     /**
     * 批量更新
     * @param actors
     * @return
     */
     public int[] updateBatchActors(final List actors){
         int[] updateCounts =this.jdbcTemplate.batchUpdate(
                 "update actors set first_name = ?, last_name = ? where id =? ",
                 new BatchPreparedStatementSetter(){

                     public int getBatchSize() {
                         return actors.size();
                    }

                     public void setValues(PreparedStatement ps, int i) throws SQLException {
                         ps.setString(1, ((Actor)actors.get(i)).getFirstName());
                         ps.setString(2, ((Actor)actors.get(i)).getLastName());
                         ps.setLong(3, ((Actor)actors.get(i)).getId());
                    }

                });
         return updateCounts;
    }

     /**
     * 批量更新
     * @param actors
     * @return
     */
     public int[] updateBatchActorsSimple(final List actors){
         //如果对象数组与占位符出现位置一一对应
         //SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(actors.toArray());
         List batch = new ArrayList();
         for(Actor actor:actors){
             Object[] values = new Object[]{//注意顺序
                    actor.getFirstName(),
                    actor.getLastName(),
                    actor.getId()};
            batch.add(values);
        }
         int[] updateCounts = this.simpleJdbcTemplate.batchUpdate(
                 "update actors set first_name = ?, last_name = ? where id =? ",
                batch);
         return updateCounts;
    }

package com.logcd.bo.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;

import com.logcd.bo.Actor;
import com.logcd.bo.dao.ActorEventDao;

public class ActorEventDaoImpl implements ActorEventDao{
	
	private JdbcTemplate jdbcTemplate;
	
	//NamedParameterJdbcTemplate对JdbcTemplate封装，增加了命名参数特性
	private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

	//SimpleJdbcTemplate对JdbcTemplate封装,某些特性要在java5以上才工作
	private SimpleJdbcTemplate simpleJdbcTemplate;
	
	//简化插入数据操作
	private SimpleJdbcInsert inserActor;
	
	public void setDataSource(DataSource dataSource){
		this.jdbcTemplate = new JdbcTemplate(dataSource);
		this.namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(dataSource);
		this.simpleJdbcTemplate = new SimpleJdbcTemplate(dataSource);
		this.inserActor = new SimpleJdbcInsert(dataSource)
		.withTableName("actors")
		.usingColumns("first_name","last_name")//插入这些字段
		.usingGeneratedKeyColumns("id");//带回生成的id
	}

	/**
	 * 用SimpleJdbcInsert插入一条记录
	 */
	public long inserOneActor(Actor actor){
		Map parameters = new HashMap();
		parameters.put("first_name",actor.getFirstName());
		parameters.put("last_name",actor.getLastName());
		return inserActor.executeAndReturnKey(parameters).longValue();
	}
	
	/**
	 * 统计firstName相同的总数
	 * @param firstName
	 * @return
	 */
	public int findCountOfActorsByFirstName(String firstName){
		String sql="select count(0) from actors where first_name = :first_name";
		SqlParameterSource namedParameters = new MapSqlParameterSource("first_name",firstName);
		//Map namedParameter = Collections.singletonMap("first_name",firstName);
		//还有一种Bean封装的方式
		//SqlParameterSource namedParameters = new BeanPropertySqlParameterSource(exampleActor);
		return this.namedParameterJdbcTemplate.queryForInt(sql, namedParameters);
	}

	/**
	 * 根据SQL建表
	 * @param sql
	 */
	public void createTableBySQL(String sql) {
		this.jdbcTemplate.execute(sql);
	}
	
	/**
	 * 插入记录并返回自动生成的主键Id(MySQL中不行，Oracle可以)
	 * @param ps
	 * @return
	 */
	public KeyHolder insertActor(final Actor actor){
		final String addSql = "insert into actors(first_name,last_name) values (?,?)";
		KeyHolder keyHolder = new GeneratedKeyHolder();
		this.jdbcTemplate.update(new PreparedStatementCreator(){
			public PreparedStatement createPreparedStatement(Connection conn) throws SQLException {
				PreparedStatement ps =
					conn.prepareStatement(addSql, new String[]{"id"});//返回id
				ps.setString(1, actor.getFirstName());
				ps.setString(2, actor.getLastName());
				return ps;
			}
			
		});
		System.out.println(keyHolder.getKey());
		return keyHolder;
	}
	
	/**
	 * 插入/更新/删除数据
	 * @param sql 有参数语句
	 * @param obj 参数值数组
	 */
	public int operateActor(String sql,Object[] obj){
		return this.jdbcTemplate.update(sql, obj);
	}

	/**
	 * 根据SQL查询记录总数
	 * @param sql
	 * @return
	 */
	public int findRowCountBySQL(String sql){
		return this.jdbcTemplate.queryForInt(sql);
	}
	
	/**
	 * 根据Id查找指定对象
	 * @param id
	 * @return
	 */
	public Actor findActorById(long id){
		Actor actor = (Actor) this.jdbcTemplate.queryForObject(
				"select id,first_name,last_name from actors where id = ?",
				new Object[]{new Long(id)}, 
				new RowMapper(){

					public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
						Actor act = new Actor();
						act.setId(rs.getLong("id"));
						act.setFirstName(rs.getString("first_name"));
						act.setLastName(rs.getString("last_Name"));
						return act;
					}
					
				});
		return actor;
	}


	/**
	 * 根据Id查找指定对象
	 * @param id
	 * @return
	 */
	public Actor findActorByIdSimple(long id){
		String sql = "select id,first_name,last_name from actors where id = ?";
		
		ParameterizedRowMapper mapper = new ParameterizedRowMapper(){
			//notice the return type with respect to java 5 covariant return types
			public Actor mapRow(ResultSet rs, int rowNum) throws SQLException {
				Actor act = new Actor();
				act.setId(rs.getLong("id"));
				act.setFirstName(rs.getString("first_name"));
				act.setLastName(rs.getString("last_Name"));
				return act;
			}
		};
		
		return this.simpleJdbcTemplate.queryForObject(sql, mapper, id);
	}
	
	/**
	 * 返回所有对象
	 * @return
	 */
	public List findAllActors(){
		return this.jdbcTemplate.query(
				"select id,first_name,last_name from actors",
				new ActorMapper());
	}
	
	/**
	 * 定义一个静态内部类，在Dao的方法中被共享
	 * @author logcd
	 */
	private static final class ActorMapper implements RowMapper{

		public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
			Actor act = new Actor();
			act.setId(rs.getLong("id"));
			act.setFirstName(rs.getString("first_name"));
			act.setLastName(rs.getString("last_Name"));
			return act;
		}
		
	}
}

	/**
	 * 批量更新
	 * @param actors
	 * @return
	 */
	public int[] updateBatchActors(final List actors){
		int[] updateCounts =this.jdbcTemplate.batchUpdate(
				"update actors set first_name = ?, last_name = ? where id =? ", 
				new BatchPreparedStatementSetter(){

					public int getBatchSize() {
						return actors.size();
					}

					public void setValues(PreparedStatement ps, int i) throws SQLException {
						ps.setString(1, ((Actor)actors.get(i)).getFirstName());
						ps.setString(2, ((Actor)actors.get(i)).getLastName());
						ps.setLong(3, ((Actor)actors.get(i)).getId());
					}
					
				});
		return updateCounts;
	}

	/**
	 * 批量更新
	 * @param actors
	 * @return
	 */
	public int[] updateBatchActorsSimple(final List actors){
		//如果对象数组与占位符出现位置一一对应
		//SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(actors.toArray());
		List batch = new ArrayList();
		for(Actor actor:actors){
			Object[] values = new Object[]{//注意顺序
					actor.getFirstName(),
					actor.getLastName(),
					actor.getId()};
			batch.add(values);
		}
		int[] updateCounts = this.simpleJdbcTemplate.batchUpdate(
				"update actors set first_name = ?, last_name = ? where id =? ",
				batch);
		return updateCounts;
	}

(4)测试

/**
 *
 */
 package com.logcd.test;

 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 import org.springframework.jdbc.support.KeyHolder;

 import com.logcd.bo.Actor;
 import com.logcd.bo.dao.ActorEventDao;
 import com.logcd.bo.dao.ActorJdbcTemplateDao;

 import junit.framework.TestCase;

 /**
 * @author logcd
 */
 public class SpringJdbcTest extends TestCase {

     private ActorEventDao actorEventDao;
     private ActorJdbcTemplateDao actorJdbcTemplateDao;

     protected void setUp() throws Exception {
         super.setUp();
         ApplicationContext context = new ClassPathXmlApplicationContext("springJdbcContext.xml");
         actorEventDao = (ActorEventDao)context.getBean("actorEventDao");
         actorJdbcTemplateDao = (ActorJdbcTemplateDao)context.getBean("actorJdbcTemplateDao");
    }

     protected void tearDown() throws Exception {
         super.tearDown();
    }

     public void testActorEventDao(){
         String creatSql = "create table ACTORS(" +
         "ID int not null auto_increment," +
         "FIRST_NAME varchar(15)," +
         "LAST_NAME varchar(15)," +
         "primary key (ID)" +
         ");" ;
         //建表
        actorEventDao.createTableBySQL(creatSql);

         String addSql = "insert into actors(first_name,last_name) values(?,?);";
         Object[] obj = new Object[]{"wang","jinming"};
         //新增
        System.out.println(actorEventDao.operateActor(addSql, obj));

         String countSql = "select count(0) from actors";
         System.out.println("Count:"+actorEventDao.findRowCountBySQL(countSql));
         System.out.println("Count:"+actorJdbcTemplateDao.findRowCountBySQL(countSql));
         //根据id查找
         Actor actor = actorEventDao.findActorById(1);
         System.out.println("id:"+actor.getId()+"  first_name:"+actor.getFirstName()+"  last_name:"+actor.getLastName());
         //输出所有
         for(Object o:actorEventDao.findAllActors()){
            Actor act = (Actor) o;
             System.out.println("id:"+act.getId()+"  first_name:"+act.getFirstName()+"  last_name:"+act.getLastName());
        }

         Actor newAct=new Actor();
         newAct.setFirstName("jin");
         newAct.setLastName("ming");
        KeyHolder keyHold =actorEventDao.insertActor(newAct);
         System.out.println(keyHold.getKey());//mysql得不到id

         List list = new ArrayList();
         for(Object o:actorEventDao.findAllActors()){
            Actor act = (Actor) o;
             System.out.println("id:"+act.getId()+"  first_name:"+act.getFirstName()+"  last_name:"+act.getLastName());
             act.setLastName("www");
            list.add(act);
        }
        actorEventDao.batchUpdateActors(list);
         for(Object o:actorEventDao.findAllActors()){
            Actor act = (Actor) o;
             System.out.println("id:"+act.getId()+"  first_name:"+act.getFirstName()+"  last_name:"+act.getLastName());
        }
    }
}

/**
 * 
 */
package com.logcd.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.support.KeyHolder;

import com.logcd.bo.Actor;
import com.logcd.bo.dao.ActorEventDao;
import com.logcd.bo.dao.ActorJdbcTemplateDao;

import junit.framework.TestCase;

/**
 * @author logcd
 */
public class SpringJdbcTest extends TestCase {

	private ActorEventDao actorEventDao; 
	private ActorJdbcTemplateDao actorJdbcTemplateDao;
	
	protected void setUp() throws Exception {
		super.setUp();
		ApplicationContext context = new ClassPathXmlApplicationContext("springJdbcContext.xml");
		actorEventDao = (ActorEventDao)context.getBean("actorEventDao");
		actorJdbcTemplateDao = (ActorJdbcTemplateDao)context.getBean("actorJdbcTemplateDao");
	}

	protected void tearDown() throws Exception {
		super.tearDown();
	}

	public void testActorEventDao(){
		String creatSql = "create table ACTORS(" +
		"ID int not null auto_increment," +
		"FIRST_NAME varchar(15)," +
		"LAST_NAME varchar(15)," +
		"primary key (ID)" +
		");" ;
		//建表
		actorEventDao.createTableBySQL(creatSql);
		
		String addSql = "insert into actors(first_name,last_name) values(?,?);";
		Object[] obj = new Object[]{"wang","jinming"};
		//新增
		System.out.println(actorEventDao.operateActor(addSql, obj));
	
		String countSql = "select count(0) from actors";
		System.out.println("Count:"+actorEventDao.findRowCountBySQL(countSql));
		System.out.println("Count:"+actorJdbcTemplateDao.findRowCountBySQL(countSql));
		//根据id查找
		Actor actor = actorEventDao.findActorById(1);
		System.out.println("id:"+actor.getId()+"  first_name:"+actor.getFirstName()+"  last_name:"+actor.getLastName());
		//输出所有
		for(Object o:actorEventDao.findAllActors()){
			Actor act = (Actor) o;
			System.out.println("id:"+act.getId()+"  first_name:"+act.getFirstName()+"  last_name:"+act.getLastName());
		}
		
		Actor newAct=new Actor();
		newAct.setFirstName("jin");
		newAct.setLastName("ming");
		KeyHolder keyHold =actorEventDao.insertActor(newAct);
		System.out.println(keyHold.getKey());//mysql得不到id

		List list = new ArrayList();
		for(Object o:actorEventDao.findAllActors()){
			Actor act = (Actor) o;
			System.out.println("id:"+act.getId()+"  first_name:"+act.getFirstName()+"  last_name:"+act.getLastName());
			act.setLastName("www");
			list.add(act);
		}
		actorEventDao.batchUpdateActors(list);
		for(Object o:actorEventDao.findAllActors()){
			Actor act = (Actor) o;
			System.out.println("id:"+act.getId()+"  first_name:"+act.getFirstName()+"  last_name:"+act.getLastName());
		}
	}
}

二、关于操作Blob和Clob问题
     spring定义了一个以统一的方式操作各种数据库的Lob类型数据的LobCreator(保存的时候用),同时提供了一个LobHandler为操作二进制字段和大文本字段提供统一接口访问。
(1)配置文件

<bean id="nativeJdbcExtractor"
  class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor"
       lazy-init="true"/>

 <bean id="lobHandler"
  class="org.springframework.jdbc.support.lob.OracleLobHandler"
         lazy-init="true"
         p:nativeJdbcExtractor-ref="nativeJdbcExtractor"/>

 <bean id="defaultLobHandler"
    class="org.springframework.jdbc.support.lob.DefaultLobHandler"
    lazy-init="true" />

 <bean id="jdbcTemplate"
 class="org.springframework.jdbc.core.JdbcTemplate"
         p:dataSource-ref="appDS"
         p:nativeJdbcExtractor-ref="nativeJdbcExtractor"/>

 <bean id="txMangager"
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
         p:dataSource-ref="appDS"/>

 <tx:annotation-driven transaction-manager="txMangager" proxy-target-class="true"/>

(2)读写

@Resource(name = "lobHandler")
 private LobHandler lobHandler;

 @Resource(name = "jdbcTemplate")
 private  JdbcTemplate jdbcTemplate;

 public void savePost(final Post post) {
    String sql = " INSERT INTO t_post(post_id,user_id,post_text,post_attach)"
      + " VALUES(?,?,?,?)";
   jdbcTemplate().execute(sql,
      new AbstractLobCreatingPreparedStatementCallback(this.lobHandler) {
          protected void setValues(PreparedStatement ps,
               LobCreator lobCreator) throws SQLException {
                   ps.setInt(1, incre.nextIntValue());
                   ps.setInt(2, post.getUserId());
                   lobCreator.setClobAsString(ps, 3, post.getPostText());
                   lobCreator.setBlobAsBytes(ps, 4, post.getPostAttach());
        }
     });
}

 public List findAttachs(final int userId){
    String sql = "SELECT post_id,post_attach FROM t_post where user_id =? and post_attach is not null";
    return jdbcTemplate().query( sql, new Object[] {userId},
       new RowMapper() {
           public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
           Post post = new Post();
           int postId = rs.getInt(1);
           byte[] attach = lobHandler.getBlobAsBytes(rs, 2);
          post.setPostId(postId);
          post.setPostAttach(attach);
           return post;
      }
   });
}