DButils+dbcp数据源+spring实现增删改查小例子

左手的ㄟ右手 2022-04-12 06:38 242阅读 0赞

\[b\]\[color=green\]\[size=large\]本篇主要介绍DButils工具类的使用跟Spring的JDBCTemplate框架非常类似，比我们纯手写JDBC的sql语句，会方便许多，如果加上了连接池的配置，那么效果就会更加完美，  
首先我们来看下DButils的简介：  
Common Dbutils是操作数据库的组件，对传统操作数据库的类进行二次封装，可以把结果集转化成List。它是对JDBC的一个轻量级的封装，简化了很多重复的一些操作。  
  
Dbutils的一些注意事项：  
  
1、DBUtils是JDBC的简单封装，可以和JDBC混合使用。  
  
2、DBUtils对结果集自动封装为JavaBean是有着苛刻要求的：必须满足JavaBean的规范，其次Bean的getter与setter方法的名字与结果集的列名一一对应，而不要求JavaBean的私有成员与表结果集列名一一对应。  
比如：  
person表中有个字段叫：address，那么对应的JavaBean的Person类中必须有getAddress和setAddress两个方法，而Person类中可以将address属性命名为add，这是没问题的。  
  
3、DBUtils可以将结果集封装为各种类型，主要有：Bean/List<Bean>，Map/List<Map>/Map<Map>，数组/List<数组>，列/List<列>，这些类型。  
对于Map<Map>的类型使用KeyedHandler作为结果集处理器，内层的Map是“列名-值"对，外层的Map是“主键-内层Map的引用”，但此处的主键不一定就是数据库的主键，可以随意指定  
  
\[/size\]\[/color\]\[/b\]  
\[b\]\[color=olive\]\[size=large\]4、DBUtils执行插入操作的时候，无法返回自增主键，这是一个很严重的问题，当然不能怪DBUtils，可以通过变通的方法来实现，比如在MySQL中，执行完了一个插入SQL后，接着执行SELECT LAST\_INSERT\_ID()语句，就可以获取到自增主键。  
  
5、DBUtils的性能和JDBC性能是一样，测试过程中没发现性能损失，拥有了很高性能的同时，而不失JDBC的灵活性。\[/size\]\[/color\]\[/b\]  
  
\[b\]\[color=olive\]\[size=large\]  
  
下面散仙介绍一下，本次例子中使用的技术：  
  
连接池：dbcp，也是common家族里面的包  
bean注入和管理： 使用的是spring  
轻量级的工具库：dbutils  
  
  
数据源是在，spring的配置文件配置的：  
  
\[/size\]\[/color\]\[/b\]

\[b\]\[color=olive\]\[size=large\]当然，上面的这个数据源，我们可以配置多个，也可配置不同的库，这样设计比较方便灵活，利于我们动态切换我们的库。  
  
由于是java项目，并没有采用Web容器的方式启动，所以需要我们定义一个bean的加载器，来获取连接池，代码如下：  
\[/size\]\[/color\]\[/b\]

package com.dhgate.dbutils.opera;
    
    import javax.sql.DataSource;
    
    import org.apache.commons.dbcp.BasicDataSource;
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    import org.springframework.beans.factory.support.DefaultListableBeanFactory;
    import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
    import org.springframework.core.io.ClassPathResource;
    
    /**
     * 
     * 加载Spring的xml的bean配置
     * */
    public class XmlBeanLoad {
       
    
    
    	/**
    	 * 
    	 * 根据连接池的名
    	 * 得到一个连接池对象
    	 * 
    	 * @param datasourceName 数据源名字
    	 * @return 数据连接池对象
    	 * */
    	public static BasicDataSource getDataSource(String datasourceName){
       
    		BeanFactory bean=new DefaultListableBeanFactory();
    		XmlBeanDefinitionReader reader=new XmlBeanDefinitionReader((BeanDefinitionRegistry)bean);
    		reader.loadBeanDefinitions(new ClassPathResource("datasource.xml"));
    		BasicDataSource data=(BasicDataSource) bean.getBean(datasourceName);
    		return data;
    	}
    
    
    
    
    	/***
    	 * 测试连接信息
    	 * 
    	 * **/
    	public static void main(String[] args) throws Exception{
       
    
    		BeanFactory bean=new DefaultListableBeanFactory();
    		XmlBeanDefinitionReader reader=new XmlBeanDefinitionReader((BeanDefinitionRegistry)bean);
    		reader.loadBeanDefinitions(new ClassPathResource("datasource.xml"));
    //		BasicDataSource data=(BasicDataSource) bean.getBean("common2");
    		BasicDataSource data=(BasicDataSource) bean.getBean("local");
    		System.out.println(data.getConnection());
    
    
    	}
    
    }

\[b\]\[color=olive\]\[size=large\]增删改查代码示例：\[/size\]\[/color\]\[/b\]

package com.dhgate.dbutils.opera;
    
    
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.Arrays;
    import java.util.List;
    
    import javax.sql.DataSource;
    
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.ResultSetHandler;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    import org.apache.commons.dbutils.handlers.BeanListHandler;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import com.dhgate.m2b.entity.Student;
    /**
     * 
     * dbutils+datasource
     * 实现轻量级的增删改查
     * @author qindongliang
     * 
     *  * */
    public class DataQuery<T> {
       
    
    	private static Logger logger = LoggerFactory.getLogger(DataQuery.class);
    
    
    	private Class clazz;
    	public DataQuery(Class clazz) {
       
    		this.clazz=clazz;
    	}
    
    	public DataQuery() {
       
    		// TODO Auto-generated constructor stub
    	}
    
    
    	public T query(String sql,Object[] params,String name)throws Exception{
       
    		log(sql, params, name);
    		DataSource datasource=XmlBeanLoad.getDataSource(name);
    		System.out.println(datasource.getConnection().toString());
    		QueryRunner runner=new QueryRunner(datasource);
    		System.out.println(runner);
    		return (T) runner.query(sql, new BeanHandler(clazz),params);
    	}
    
    	/**
    	 * 查询集合
    	 * @param sql 添加的sql语句
    	 * @param params 数据的参数
    	 * @param name 连接池的名字
    	 * */
    	public List<T> queryList(String sql,Object[] params,String name)throws Exception{
       
    		log(sql, params, name);
    		DataSource datasource=XmlBeanLoad.getDataSource(name);
    		QueryRunner runner=new QueryRunner(datasource);
    
    		return (List<T>) runner.query(sql, new BeanListHandler(clazz),params);
    	}
    
    	/**
    	 * 添加一条数据
    	 * @param sql 添加的sql语句
    	 * @param params 数据的参数
    	 * @param name 连接池的名字
    	 * */
    	public void add(String sql,Object[] params,String name)throws Exception{
       
    		log(sql, params, name);
    		DataSource datasource=XmlBeanLoad.getDataSource(name);
    		QueryRunner runner=new QueryRunner(datasource);
    		int i=runner.update(datasource.getConnection(),sql, params);
    		if(i>0){
       
    			System.out.println("添加成功！");
    		}
    	}
    
    	/**
    	 * 更新一条数据
    	 * @param sql 添加的sql语句
    	 * @param params 数据的参数
    	 * @param name 连接池的名字
    	 * */
    	public void update(String sql,Object[] params,String name)throws Exception{
       
    		log(sql, params, name);
    		DataSource datasource=XmlBeanLoad.getDataSource(name);
    		QueryRunner runner=new QueryRunner(datasource);
    		int i=runner.update(datasource.getConnection(),sql, params);
    		if(i>0){
       
    			System.out.println("更新成功！");
    		}
    	}
    
    	/**
    	 * 删除一条数据
    	 * @param sql 添加的sql语句
    	 * @param params 数据的参数
    	 * @param name 连接池的名字
    	 * */
    	public void delete(String sql,Object[] params,String name)throws Exception{
       
    		log(sql, params, name);
    		DataSource datasource=XmlBeanLoad.getDataSource(name);
    		QueryRunner runner=new QueryRunner(datasource);
    		int i=runner.update(datasource.getConnection(),sql, params);
    		if(i>0){
       
    			System.out.println("删除成功！");
    		}
    	}
    
    
    	/**
    	 * 统计某个表的count
    	 * @param sql sql语句
    	 * @param params 条件参数
    	 * @param name  数据源名字
    	 * @return 返回检索的数量
    	 * **/
    	public int count(String sql,Object[] params,String name)throws Exception{
       
    
    		log(sql, params, name);
    		DataSource datasource=XmlBeanLoad.getDataSource(name);
    		QueryRunner runner=new QueryRunner(datasource);
    
    		int count=runner.query(sql, new ResultSetHandler<Integer>() {
       
    			@Override
    			public Integer handle(ResultSet rs) throws SQLException {
       
    				if(rs.next()){
       
    					return rs.getInt(1);
    				}
    				return 0;
    			}
    		},params);
    
    		return count;
    	}
    
    
    
    
    
    
    	private void log(String sql,Object[] params,String name){
       
    		logger.info("SQL语句："+sql+" 检索参数： "+Arrays.toString(params)+" 连接池名字： "+name);
    	}
    
    
    
    	public static void main(String[] args)throws Exception {
       
    
    //	  String sql="select * from person where name like ? ";
    	  String datasourceName="local";
    	  DataQuery<Student> sq=new DataQuery<Student>(Student.class);
    	  //添加测试
    	  //sq.add("insert into person (name,sex) values(?,?)", new Object[]{"散仙","女"},datasourceName);
    	  //更新测试
    	  //sq.update("update person set name=? , sex=? where id = ? ", new Object[]{"三劫散仙","男",5}, datasourceName);
    	  //删除测试
    	  sq.delete("delete from person where id = ? ", new Object[]{1}, datasourceName);
    //	  
    
    	  //单条查询测试
    //	  Student st= sq.query(sql, new Object[]{"王晶"}, datasourceName);
    //	  System.out.println(st); 
    //	 System.out.println("================================");
    	  //批量查询测试
    //	  List<Student> queryList = sq.queryList(sql, new Object[]{"%天%"}, datasourceName);
    //	  System.out.println("查询数量: "+queryList.size());
    //	  for(Student stt:queryList){
       
    //		  System.out.println(stt);
    //	  }
    	 //System.out.println(st);
    	//	testLimit();
    
    	}
    
    	public static void testLimit()throws Exception{
       
    		  String sql="select * from person  order by id desc  limit ? , ?   ";
    		  String datasourceName="local";
    		  DataQuery<Student> sq=new DataQuery<Student>(Student.class);
    		  List<Student> queryList = sq.queryList(sql, new Object[]{2,3}, datasourceName);
    		  System.out.println("查询数量: "+queryList.size());
    		  for(Student stt:queryList){
       
    			  System.out.println(stt);
    		  }
    	}
    
    
    
    
    }

\[b\]\[color=olive\]\[size=large\]以上代码，就是简化了封装操作数据库增删改查的过程，当然我们也可以扩展它，使它成为一个轻量级的ORM框架，这样更方便操作，另外注意一点，如果注意数据库的编码问题，如果编码不一致，可能会导致，中文查询有问题，而且程序不会报异常，只是查询的结果为空或null，所以这一点需要格外注意，最好在连接数据库的配置里，加上指定的数据库编码，如散仙上面的xml的写法。  
  
最后看一下DButils一些Handler的封装：  
\[/size\]\[/color\]\[/b\]

ArrayHandler：把结果集中的第一行数据转成对象数组。
    ArrayListHandler：把结果集中的每一行数据都转成一个对象数组，再存放到List中。
    BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
    BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
    ColumnListHandler：将结果集中某一列的数据存放到List中。
     KeyedHandler：将结果集中的每一行数据都封装到一个Map里，然后再根据指定的key把每个Map再存放到一个Map里。
     MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
     MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List。
     ScalarHandler：将结果集中某一条记录的其中某一列的数据存成Object。

\[b\]\[color=olive\]\[size=large\]使用的主要jar包有：\[/size\]\[/color\]\[/b\]

commons-dbutils-1.6.jar dbutis的主要包
    mysql的驱动包
    spring的核心包