德扑圈伙牌怎么打 当前位置:首页>德扑圈伙牌怎么打>正文

德扑圈伙牌怎么打

发布时间:2018-11-19

原标题:通过对DAO层的封装减少数据库操作的代码量

如遇【线上娱乐站】不能自动打开,请复制 http://da8.us 到浏览器,注册自动送8-88试 ̶̶̶̶̶̶̶̶̶̶玩 ̷̷̷̷̷̷̷̷̷̷金。体验各种类的线上PT/DT/MG/PNG ̶̶̶̶̶̶̶̶̶̶老 ̷̷̷̷̷̷̷̷̷̷虎 ̷̷̷̷̷̷̷̷̷̷机、 ̷̷̷̷̷̷̷̷̷̷真* ̷̷̷̷̷̷̷̷̷̷人* ̶̶̶̶̶̶̶̶̶̶百* ̶̶̶̶̶̶̶̶̶̶家 ̷̷̷̷̷̷̷̷̷̷*乐*游戏等免费试玩、优惠活动,7*24小时专业服务

小童恢复理智,回到适才惊恐害怕的状态,活了十二岁,哪一天不是顶多两餐,每餐还得偷偷摸摸,像干什么见不得人勾当似的,能让他嗑上半个青稞馒头,就算是优渥了,哪还敢奢望有半口肉吃。

百赢棋牌有app吗

就在黄三叉戟飞出的瞬间,唐三的身体仿佛像是被惯性带动一般,滴溜溜地旋转起来,两边的身体都做出了一模一样的动作,在那急速旋转之中,竟然避让开了比比东的第一记攻击。
朱允?勺?恚?裉斓拇蟪?推饺詹煌??幌伦佣喑霾簧偃耍?渲胁环σ恍┬旅婵祝?驹谄胩┖竺妗

相思断肠红在没有认主之前就不是靠外力能够摘取的,认小舞为主后,更是有着金刚不坏的特性。比起任何东西来都要坚韧。人面魔蛛的攻击虽然强横,但扎在这朵奇异的仙品鲜花上,却也没能破坏。否则的话,小舞的身体就不是飞出去,而是直接被那蛛矛贯穿。她手中的幽香绮罗仙品也自然会到人面魔蛛手中。

   在学框架之前,写项目时总是要花大量的时间去写数据库操作层代码,这样会大大降低我们的效率,为了解决这个问题,我花了两天时间利用反射机制和泛型将DAO层进行了封装,这样我们只需要写sql语句,不需要再写繁琐的数据库操作语句,增强代码的复用性,让我们把主要精力放在业务逻辑上。

  以下就是我写的代码(我是用连接池操作,普通的jdbc操作和连接池道理相同,主要思想是将结果集设置到对象的属性中)

 1     /**
 2      * 预处理通用查询对象集合
 3      *
 4      * @param cla 操作类型
 5      * @param params 预处理参数
 6      * @param sql 要执行的sql语句
 7      * @return 返回的对象集合
 8      * @throws SQLException 抛出异常
 9      */
10     @SuppressWarnings("deprecation")
11     public static <T> List<T> commonPreparedQueryList(final Class<T> cla,Object params[],String sql) throws SQLException{
12                //获得连接池(这里使用的是阿里巴巴开源的jar包)
13         QueryRunner qr = new QueryRunner(DBUtil.getDruid());
14         /*
15          * 声明一个List存放返回对象
16          */    
17                 List<T> tList = new ArrayList<T>(); 
18                 /*
19                  * 执行查询操作并返回对应集合,传入sql和预处理参数并进行结果集处理(这里要实现handle方法)
20                  */
21                 tList = qr.query(sql, params,new ResultSetHandler<List<T>>(){
22 
23                 public List<T> handle(ResultSet rs) throws SQLException {
24                     /*
25                      * 这里要用到ResultSetMetaData来获取数据库表的字段名和数量
26                      */
27                     ResultSetMetaData ms = rs.getMetaData();
2              T t = null;//声明一个泛型,此处类型和传入一致
29                     List<T> list = new ArrayList<T>();
30                     /*
31                      * 通过循环获得表中所有的字段名,并通过反射的方式把字段名内容
32                      * 设置到我们要查询的集合中,并将结果返回
33                      * 注意:这里需要用到循环的嵌套,我们需要先循环表中所有数据,
34                      * 然后再循环表的所有字段名
35                      */
36                     while(rs.next()){
37                         try {
38                             t = cla.newInstance();//创建一个实例化对象
39                             //获得所有字段名,并将其转换为驼峰式命名规则  eg:guest_id转化为guestId
40                             for(int i = 0; i <ms.getColumnCount(); i++){
41                                 String columnName = ms.getColumnName(i+1);//获得字段名
42                                 /*
43                                  * 以下操作是将下划线形式转化为驼峰式的实现
44                                  * 现将字段名以下划线分割到字符串数组中,将第一个数组元素复制到StringBuffer中
45                                  * 然后将后面的数组元素第一个首字母转化为大写形式,最后将他们拼接到一起,将所得结果转化为字符串
46                                  */
47                                 String[] strName = columnName.split("_");
48                                 StringBuffer sb = new StringBuffer(strName[0]);
49                                 for(int i1 = 1;i1<strName.length;i1++){
50                                     strName[i1] = strName[i1].substring(0, 1).toUpperCase().concat(strName[i1].substring(1));
51                                     sb.append(strName[i1]);
52                                 }
53                                 String property = sb.toString();
54                                 /*
55                                  * 获得对象的所有属性,并将结果集中的内容通过反射赋值到对象的属性中
56                                  */
57                                 Field field = cla.getDeclaredField(property);
58                                 field.setAccessible(true);
59                                 field.set(t, rs.getObject(columnName));
60                             }
61                         } catch (InstantiationException e) {
62                             e.printStackTrace();
63                         } catch (IllegalAccessException e) {
64                             e.printStackTrace();
65                         } catch (NoSuchFieldException e) {
66                             e.printStackTrace();
67                         } catch (SecurityException e) {
68                             e.printStackTrace();
69                         }
70                         //将对象添加到List中
71                         list.add(t);
72                     }
73                     //循环结束后返回对象集合
74                     return list;
75                 }
76                 
77             });
78         return tList;
79     }

测试代码:

1 public void Test() throws SQLException{
2         List<Book> bookList = new LinkedList<Book>();
3         Object params[] = new Object[]{"%三%"};
4         String sql = "select * from book where book_name like ? ";
5         bookList = CommonDao.commonPreparedQueryList(Book.class,params ,sql);
6         System.out.println(bookList);
7     }

一共两条数据

查询一条数据(这个和查询集合的区别只有集合需要循环结果集,而这个只需要用if语句判断一下即可,其余代码完全相同):

 1 /**
 2      * 通用预处理查询对象
 3      *
 4      * @param cla
 5      * @param params
 6      * @param sql
 7      * @return 对象
 8      * @throws SQLException
 9      * @throws InstantiationException
10      * @throws IllegalAccessException
11      */
12     @SuppressWarnings("deprecation")
13     public static <T> T commonPreparedQuery(final Class<T> cla,Object params[],String sql) throws SQLException, InstantiationException, IllegalAccessException{
14         QueryRunner qr = new QueryRunner(DBUtil.getDruid());
15             T m = cla.newInstance();
16             m = qr.query(sql,params ,new ResultSetHandler<T>(){
17 
18             public T handle(ResultSet rs) throws SQLException {
19                 ResultSetMetaData rm = rs.getMetaData();
20                 T t = null;
21                 try {
22                     if(rs.next()){             //这里用if,是与查询集合代码的唯一区别
23                         t = cla.newInstance();
24                         for(int i = 0; i<rm.getColumnCount(); i++){
25                             String columnName = rm.getColumnName(i+1);
26                             String str[] = columnName.split("_");
27                             StringBuffer sb = new StringBuffer(str[0]);
28                             for(int j = 1; j<str.length; j++){
29                                 str[j] = str[j].substring(0, 1).toUpperCase().concat(str[j].substring(1));
30                                 sb.append(str[j]);
31                             }
32                             String property = sb.toString();
33                             Field field = cla.getDeclaredField(property);
34                             field.setAccessible(true);
35                             field.set(t, rs.getObject(columnName));
36                         }
37                     }else{
38                         System.out.println("sql语句错误或对象不存在");
39                     }
40                 } catch (InstantiationException e) {
41                     e.printStackTrace();
42                 } catch (IllegalAccessException e) {
43                     e.printStackTrace();
44                 } catch (SecurityException e) {
45                     e.printStackTrace();
46                 } catch (NoSuchFieldException e) {
47                     e.printStackTrace();
48                 }
49                 return t;
50             }
51             
52         });
53     return m;
54 }

测试:

    public void Test() throws SQLException, InstantiationException, IllegalAccessException{
        Book book = new Book();
        Object params[] = new Object[]{10001};
        String sql = "select * from book where book_id = ? ";
        book = CommonDao.commonPreparedQuery(Book.class, params, sql);
        System.out.println(book);
    }

 

还有普通查询操作(不通过预处理)

这种方式和预处理查询的唯一区别只是不需要传递参数params,其余和上面代码完全一致

 1 /**
 2      * 通用类查询集合
 3      *
 4      * @param cla
 5      * @param sql
 6      * @return 
 7      * @throws SQLException
 8      */
 9     public static <T> List<T> commonQueryList(final Class<T> cla,String sql) throws SQLException{
10         QueryRunner qr = new QueryRunner(DBUtil.getDruid());
11                 List<T> tList = new ArrayList<T>(); 
12                 tList = qr.query(sql, new ResultSetHandler<List<T>>(){
13 
14                 public List<T> handle(ResultSet rs) throws SQLException {
15                     ResultSetMetaData ms = rs.getMetaData();
16                     T t = null;
17                     List<T> list = new ArrayList<T>();
18                     while(rs.next()){
19                         try {
20                             t = cla.newInstance();
21                             for(int i = 0; i <ms.getColumnCount(); i++){
22                                 String columnName = ms.getColumnName(i+1);
23                                 String[] strName = columnName.split("_");
24                                 StringBuffer sb = new StringBuffer(strName[0]);
25                                 for(int i1 = 1;i1<strName.length;i1++){
26                                     strName[i1] = strName[i1].substring(0, 1).toUpperCase().concat(strName[i1].substring(1));
27                                     sb.append(strName[i1]);
28                                 } 
29                                 String property = sb.toString();
30                                 Field field = cla.getDeclaredField(property);
31                                 field.setAccessible(true);
32                                 field.set(t, rs.getObject(columnName));
33                             }
34                         } catch (InstantiationException e) {
35                             e.printStackTrace();
36                         } catch (IllegalAccessException e) {
37                             e.printStackTrace();
38                         } catch (NoSuchFieldException e) {
39                             e.printStackTrace();
40                         } catch (SecurityException e) {
41                             e.printStackTrace();
42                         }
43                         list.add(t);
44                     }
45                     return list;
46                 }
47                 
48             });
49         return tList;
50     }

测试:

public void Test() throws SQLException{
        List<Book> bookList = new LinkedList<Book>();
        String sql = "select * from book ";
        bookList = CommonDao.commonQueryList(Book.class,sql);
        System.out.println(bookList);
    }

同样有两条数据

 

查询一个对象:

 1 /**
 2      * 查询一个数据库类操作
 3      *
 4      * @param cla
 5      * @param sql
 6      * @return 一个数据库类对象
 7      * @throws SQLException
 8      * @throws InstantiationException
 9      * @throws IllegalAccessException
10      */
11     public static <T> T commonQuery(final Class<T> cla,String sql) throws SQLException, InstantiationException, IllegalAccessException{
12             QueryRunner qr = new QueryRunner(DBUtil.getDruid());
13                 T m = cla.newInstance();
14                 m = qr.query(sql, new ResultSetHandler<T>(){
15 
16                 public T handle(ResultSet rs) throws SQLException {
17                     ResultSetMetaData rm = rs.getMetaData();
18                     T t = null;
19                     try {
20                         if(rs.next()){
21                             t = cla.newInstance();
22                             for(int i = 0; i<rm.getColumnCount(); i++){
23                                 String columnName = rm.getColumnName(i+1);
24                                 String str[] = columnName.split("_");
25                                 StringBuffer sb = new StringBuffer(str[0]);
26                                 for(int j = 1; j<str.length; j++){
27                                     str[j] = str[j].substring(0, 1).toUpperCase().concat(str[j].substring(1));
28                                     sb.append(str[j]);
29                                 }
30                                 String property = sb.toString();
31                                 Field field = cla.getDeclaredField(property);
32                                 field.setAccessible(true);
33                                 field.set(t, rs.getObject(columnName));
34                             }
35                         }else{
36                             System.out.println("sql语句错误或对象不存在");
37                         }
38                     } catch (InstantiationException e) {
39                         e.printStackTrace();
40                     } catch (IllegalAccessException e) {
41                         e.printStackTrace();
42                     } catch (SecurityException e) {
43                         e.printStackTrace();
44                     } catch (NoSuchFieldException e) {
45                         e.printStackTrace();
46                     }
47                     return t;
48                 }
49                 
50             });
51         return m;
52     }

测试:

@Test
    public void Test() throws SQLException, InstantiationException, IllegalAccessException{
        Book book = new Book();
        String sql = "select * from book where book_id = 10002";
        book = CommonDao.commonQuery(Book.class,sql);
        System.out.println(book);
    }

 

接下来是增删改操作,这个操作比较简单,不需要用到泛型和反射,只需要传入sql语句即可:

1 public static boolean updateSql(String sql) throws SQLException{
2         boolean flag = false;
3         QueryRunner qr = new QueryRunner(DBUtil.getDruid());
//执行修改操作
4 if(qr.update(sql)>0) 5 flag = true; 6 return flag; 7 }

还有预处理形式

1 public static boolean updatePreparedSql(String sql,Object params[]) throws SQLException{
2         boolean flag = false;
3         QueryRunner qr = new QueryRunner(DBUtil.getDruid());
4         if(qr.update(sql,params)>0)
5             flag = true;
6         return flag;
7     }

还有批量处理形式

/**
     * 通过预处理解决批量增删改操作
     *
     * @param sql
     * @param params params[rows][cols],rows代表sql语句执行次数,cols表示替换占位符的参数个数
     * @return boolean
     * @throws SQLException
     */
    public static boolean batchProcessing(String sql,Object params[][]) throws SQLException{
        boolean flag = false;
        QueryRunner qr = new QueryRunner(DBUtil.getDruid());
        if(qr.batch(sql, params).length == params.length)
            flag = true;
        return flag;
    }

 

编辑:建开北

发布时间:2018-11-19 03:43:44

当前文章:http://www.sjzhaiyuan.cn/2017/1020/900422139.html

打游戏赚钱的平台 大菠萝扑克现金 大晋棋牌手机版 大赢家体育 单机四川麻将血战到底 德扑圈客服电话 德上高速舒城最新消息 德友圈视频

31769 50804 21789 14905 51266 2569346586 99502 33232

责任编辑:辛开开

随机推荐