BeanUtils工具详解

什么是BeanUtils工具

BeanUtils工具是一种方便我们对JavaBean进行操作的工具，是Apache组织下的产品。

BeanUtils工具一般可以方便javaBean的哪些操作？

1）beanUtils可以便于对javaBean的属性进行赋值。

2）beanUtils可以便于对javaBean的对象进行赋值。

3）beanUtils可以将一个MAP集合的数据拷贝到一个javabean对象中。

BeanUtils的使用

使用beanUtils按照以下步骤~

前提：约定前提：参数名称需要和javabean的属性名称保持一致！！！！

步骤一

导包：导入commons-beanutils-1.8.3包

与commons-logging-1.1.3包

步骤二

写代码使用~下面就来演示下常见的用法

1）设置javaBean的参数

@Test
    public void test1() throws Exception
    {
        //先演示一下不用工具时的做法
        //1.生成对象
        Student s = new Student();
        
        /*2.通过set方法赋值
        s.setId(1);
        s.setName("VN");
        s.setAge(19);
        s.setClassID(5);
        s.setBirthday(new Date());
        用以上这种方法来给对象的属性赋值实在是太麻烦了，下面我们用BeanUtils来进行赋值
        */
        
        //1.得到javaBean的一个字节码对象
        Class clazz = Class.forName("com.vmaxtam.beanutiltest.Student");
        
        //2.生成该字节码的一个对象
        Object obj = clazz.newInstance();
        
        //4.注册一个日期格式转换器
        ConvertUtils.register(new DateLocaleConverter(), java.util.Date.class);
        
        //3.使用工具对该对象进行赋值
        //注意： 对于基本数据类型，beanutils工具进行自动类型转换。把String自动转成Integer,Double,Float
        BeanUtils.setProperty(obj, "id", "1");
        BeanUtils.setProperty(obj, "name", "VN");
        BeanUtils.setProperty(obj, "age", "19");
        BeanUtils.setProperty(obj, "classID", "5");
        //如果要使用特殊的日期类型，则String->Date 不能自动转换,这时候就要注册一个转换器
        BeanUtils.setProperty(obj, "birthday", "1996-06-06");
        
        System.out.println(obj);        
    }

对比一下，我们发现，使用BeanUtils里赋值好像更麻烦。。。但这只是在这段代码中而已，运用BeanUtils上面代码的这个功能，

我们可以写出一个通用的方法，可以把请求中的参数拷贝到javaBean对象中！

约定前提： 请求中的参数名称 需要和javabean的属性名称保持一致！！！！
public static <T>T requestToBean(HttpServletRequest request , Class<T> clazz)
    {
        //创建javaBean对象    
        Object obj=null;
        try {
            obj=clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
        
        //得到请求中的每个参数
        Enumeration<String> enu = request.getParameterNames();
        while(enu.hasMoreElements())
        {
            //获得参数名
            String name = enu.nextElement();
            //获得参数值
            String value = request.getParameter(name);
            //然后把参数拷贝到javaBean对象中
            try {
                BeanUtils.setProperty(obj, name, value);
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
        return (T)obj;
    }

上面这个方法是一个泛型方法，传不同的javaBean进去都可以从request中获取参数值。在一个工程较大的项目中，如果使用这个通用的方法，就能节省很多代码。

2）把一个javaBean的属性拷贝到另一个javaBean对象中

@Test
    public void test2() throws Exception
    {
        //1.生成对象
        Student s1 = new Student();
        Student s2 = new Student();
        
        //2.通过set方法赋值
        s1.setId(1);
        s1.setName("VN");
        //s1.setAge(19);//基本数据类型可以为null，null也能拷贝
        s1.setClassID(5);
        s1.setBirthday(new Date());//特殊类型不能为null

        //需求：把s1的属性值拷贝到S2中，注意参数的顺序
        BeanUtils.copyProperties(s2, s1);
        
        System.out.println(s1);
        System.out.println(s2);    
    }

一句代码就完成拷贝了，不用像以前那样先用get()方法把s1的属性值拿出来，再用set()方法供给s2属性赋值

3)把一个map集合中的数据拷贝到javaBean中

@Test
    public void test3() throws Exception
    {
        //1.生成对象
        Map<String,Object> map = new HashMap<String,Object>();
    
        //2.给一些参数
        map.put("id", 2);
        map.put("name", "EZ");
        map.put("age", 22);
        map.put("classID", 3);
        map.put("birthday", new Date());
        
        //需求：把map的属性值拷贝到S中
        Student s = new Student();
        BeanUtils.copyProperties(s, map);
        
        System.out.println(s);
    }

上面这个也是一步到位，也是使用copyProperties()这个方法来完成，这样减少了我们很多的操作了,十分简便。

下面介绍一个新的概念，学会这个东西后，它能够和beanUtils组合写出更多的通用代码！方便我们的项目！

元数据（MetaData）

什么是数据库的元数据

数据库中的元数据有三种：

1）数据库元数据（DatabaseMetaData）：可以从connection对象中获取。

这些元数据的信息包括：当前使用什么数据库，数据库的版本，数据库驱动的版本

2）参数元数据(ParameterMetaData):可以从PreparedStatement中获取，指sql语句中的参数

元数据的信息：参数的个数，以及每个参数的类型

3)结果集元数据(ResultSetMetaData)：可以从ResultSet对象中获取

元数据信息：结果集的列数，以及每列的名称

下面就来显示下怎么获取这些信息吧~

获取数据库的元数据

@Test
    public void Test1()
    {
        //获取连接池
        ComboPooledDataSource pool = new ComboPooledDataSource();
        try {
            //获取连接
            Connection conn = pool.getConnection();
            //获取数据库元数据
            DatabaseMetaData md =     conn.getMetaData();
            
            //获得数据库的主版本和副版本
            int mj = md.getDatabaseMajorVersion();
            int mi =md.getDatabaseMinorVersion();
            System.out.println(mj + "."+ mi);
            
            //获得驱动版本
            int dmj = md.getDriverMajorVersion();
            int dmi = md.getDriverMinorVersion();
            System.out.println(dmj + "."+dmi);
            
            //当前使用什么数据库
            String b =md.getDatabaseProductName();
            System.out.println(b);
                            
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }    
    }

这个和beanutils没什么关系，所以不是重点。

获取参数元数据

PreparedStatement sta=null;
    Connection conn=null;
    @Test
    public void Test2()
    {
        //获取连接池
        ComboPooledDataSource pool = new ComboPooledDataSource();
        try {
            //获取连接
             conn = pool.getConnection();
            //准备SQL语句
            String sql ="insert into student(sid,sname) values(?,?)";
            //获得Statement
             sta = conn.prepareStatement(sql);
            
            //获取元数据
            ParameterMetaData md = sta.getParameterMetaData();
            //获取参数的一些信息:参数的个数
            int count = md.getParameterCount();
            //然后利用这个数来给参数赋值
            //方便参数赋值
            Object value[] = new Object[]{17,"VN"};
            for(int i = 0;i<count ;i++)
            {
                sta.setObject(i+1, value[i]);
            }
            //执行
            sta.executeUpdate();
            
            //有可能具体数据库厂商不支持下面方法
            //System.out.println("第一个参数的类型："+md.getParameterTypeName(1));
                        
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            //关闭资源
            if(sta!=null){
                try {
                    sta.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }if(conn!=null)
                {
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
    }

以上就是使用元数据来对预编译的SQL语句来进行方便的参数赋值的方法~当参数比较多的时候，我们就不必一个一个地自己赋值，可以利用循环来给它赋值。

获取结果集的元数据

我们先发送一个查询语句获得一个结果集，然后可以利用元数据来很方便地封装结果集返回的结果~

@Test
    public void Test3()
    {

        try {
            //获取连接池
            ComboPooledDataSource pool = new ComboPooledDataSource();
            //获取连接
            conn = pool.getConnection();
            //准备SQL语句
            String sql="select * from student";
            //获得statement对象
            sta = conn.prepareStatement(sql);
            
            //执行，返回结果集
            ResultSet res = sta.executeQuery();
            //获取结果集的元素据
            ResultSetMetaData rd = res.getMetaData();
            
            //利用元数据来封装对象
            List<Students> list = new ArrayList<Students>();
            //获得结果集的列数
            int colcount = rd.getColumnCount();
            //循环结果集来封装对象
            while(res.next())
            {
                Students s = new Students();
                for(int i = 1; i <= colcount ; i++)
                {
                    
                    //得到列名
                    String colname = rd.getColumnName(i);
                    //得到列值
                    Object value = res.getObject(colname);
                    //利用BeanUtils，放入对象中
                    BeanUtils.setProperty(s, colname, value);
                }
                //把封装好的对象放入集合
                list.add(s);
            }
            //然后可以对List其他操作~        
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
        //关闭资源
    }

这就是利用元数据和BeanUtil结合方便我们封装结果集数据的一个例子了~利用这个特点，我们可以写出更多的通用的方法。

利用元数据和BeanUtil 编写通用的 更新方法 和 查询方法

以下就是一个通用的查询方法

参数说明：

　　　　sql:要预编译的查询语句

　　　　values:把sql语句的参数放到这个数组中

　　　　clazz：最后集合中返回的javaBean的类型

public static <T> List<T> query(String sql,Object[] values,Class<T> clazz)
    {
        Connection conn = null;
        PreparedStatement sta = null;
        ResultSet res = null;
        
        try {
            //获取连接池
            ComboPooledDataSource pool = new ComboPooledDataSource();
            //获取连接
            conn = pool.getConnection();
            //获取statement对象,预编译
            sta = conn.prepareStatement(sql);    
            
            //利用参数的元数据给预编译的SQL语句赋值
            ParameterMetaData pmd = sta.getParameterMetaData();
            //获得参数个数
            int pcount = pmd.getParameterCount();
            
            //赋值
            if(values != null)
            {
                for(int i=1 ;i<=pcount;i++)
                {
                    sta.setObject(i, values[i-1]);
                }
            }
            
            //执行
            res = sta.executeQuery();
            
            //获得结果集元数据
            ResultSetMetaData rsmd = res.getMetaData();
            //创建存储对象的集合
            List<T> list = new ArrayList<T>();
            //获取列的数量
            int colcount = rsmd.getColumnCount();
            //封装对象
            while(res.next())
            {
                //生成要封装的对象的实例
                Object obj = clazz.newInstance();
                for(int i=1;i<=colcount;i++)
                {
                    //获得列名
                    String colname = rsmd.getColumnName(i);
                    //获得列值
                    Object colvalue = res.getObject(i);
                    //封装
                    BeanUtils.setProperty(obj, colname, colvalue);
                }
                //把封装好的对象放入集合
                list.add((T) obj);
            }
            return (List<T>)list;            
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }finally{
            //释放资源
            if(res!=null){
            try {
                res.close();
            } catch (SQLException e1) {
                e1.printStackTrace();
                }}
            if(sta!=null){
            try {
                sta.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }}
            if(conn!=null){
            try {
                conn.close();//放回连接池
            } catch (SQLException e) {
                e.printStackTrace();
            }}
        }    
    }

以上就是一个通用的查询方法啦~下面来看一个通用的更新方法，比上面的简单~

通用的更新方法

public static void update(String sql,Object[] values)
    {
        Connection conn =null;
        PreparedStatement sta = null;

        try {
            
            //获取连接池
            ComboPooledDataSource pool = new ComboPooledDataSource();
            //获取连接
            conn = pool.getConnection();
            //预编译
            sta= conn.prepareStatement(sql);
            
            //获取参数的元数据
            ParameterMetaData pmt = sta.getParameterMetaData();
            
            //获取参数的个数
            int pcount = pmt.getParameterCount();
            //参数赋值
            for(int i = 1; i<=pcount;i++)
            {
                sta.setObject(i, values[i-1]);
            }
            
            //执行更新
            sta.executeUpdate();
            
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

这就完成了~

优缺点

优点：比较通用

缺点：就是每次调用这两个方法都要在内部生产一个连接池，这样一个连接池来完成一条语句是十分浪费的，所以这一点可以改进~改进方法也比较简单~这里就不演示了~

转自：点击打开链接