学习内容》：

    //========Java学习内容=========
    1.直播课—-JDBC封装第四天

    《代码内容》：
    /**设计一个方法 之前的QueryList方法如果查询的话在Dao层用户需要去实现一个策略，这样体验感不太好*
     我现在需要把他设计成 你只需要给我一个sql,给我sql中预处理的参数，再给我一个Class类型的类
     __     我就帮你把查询到的数据，存储在你给我的这个类中去
     * 参数问题？？——>Sql肯定需要给我，预处理sql的？值你需要给我，还肯定需要各位Class的类型
    /_
    //===================================================================================//

    SqlSession类

    1. package orm;
    2. import domain.Atm;
    3. import domain.KeyAndSql;
    4. import java.sql.Connection;
    5. import java.sql.DriverManager;
    6. import java.sql.PreparedStatement;
    7. import java.sql.ResultSet;
    8. import java.util.ArrayList;
    9. import java.util.List;
    10. import java.util.Map;
    11. public class SqlSession {
    12. /**
    13. *因为下面update方法的返回值是一个Atm对象 如果这里返回一个集合的话   整体用户体验不太好
    14. * 思考：我们需要把这个Query（查询） 让他的返回值也变成一个对象
    15. * 策略设计模式--->匿名内部类实现策略
    16.  /
    18. /**
    19.  * 由于新增一条记录  删除一条记录  修改一条记录 代码中除了sql语句和预处理？的值不同，其他的代码都一样
    20.  * 如果进行优化的话   参数问题？？--->因为只有sql不同，那么参数需要传一条sql  预处理用动态参数列表
    21.  * 若这样封装可以省2次的代码
    22.  * 返回值-->可有可无 可以是修改的行数 或者  无
    23.  * */
    26. /**来一个Handler小弟 给我解析 拼接**/
    28. private Handler handler = new Handler();
    30. /**写一些连接数据库时需要用到的参数**/
    31. //Driver类加载地址
    32. private String driver="com.mysql.cj.jdbc.Driver";
    33. //连接需要的参数url user password
    34. private String url = "jdbc:mysql://localhost:3306/atm?serverTimezone=CST&characterEncoding=utf-8";
    35. private String user = "root";
    36. private String password = "at123123";
    38. /**查询单表格一条记录**/  /**但是需要三个参数，一条SQL一个策略-->策略设计模式，按顺序给我sql中预处理?的值**/
    39. /**方法重载  另一个是给sql,预处理参数，存储的对象类型**/
    40. public <T>T queryOne(String sql, RowMapper rm, Object... objs){
    41.     return (T)this.queryList(sql,rm,objs).get(0);
    42. }
    43. public <T>T queryOne(String sql,Object obj,Class resultType){return (T)this.queryList(sql,obj,resultType).get(0);}
    45. /**查询单表格多条记录**/
    46. /**设计一个方法  之前的QueryList方法如果查询的话在Dao层用户需要去实现一个策略，这样体验感不太好*
    47.  * 我现在需要把他设计成  你只需要给我一个sql,给我sql中预处理的参数，再给我一个Class类型的类
    48.  * 我就帮你把查询到的数据，存储在你给我的这个类中去
    49.  * 参数问题？？---->Sql肯定需要给我，预处理sql的？值你需要给我，还肯定需要各位Class的类型
    50.  * */
    51. /**======查询单表格的多条记录======**/
    52. public <T> List<T> queryList(String sql, RowMapper rm, Object... objs){
    53.     ArrayList<T> lists = new ArrayList<>();
    54.     try {
    55.         Class.forName(driver);
    56.         Connection conn = DriverManager.getConnection(url, user, password);
    57.         PreparedStatement pstat = conn.prepareStatement(sql);
    58.         for (int i = 0; i <objs.length ; i++) {
    59.             pstat.setObject(i+1,objs[i]);
    60.         }
    61.         ResultSet rst = pstat.executeQuery();
    62.         while(rst.next()){
    63.             lists.add(rm.mapperRow(rst));
    64.         }
    65.         rst.close();
    66.         pstat.close();
    67.         conn.close();
    68.     } catch (Exception e) {
    69.         e.printStackTrace();
    70.     }
    71.     return lists;
    72. }
    73. public <T> List<T> queryList(String sql,Object obj,Class resultType){
    74.     ArrayList<T> lists = new ArrayList<>();
    75.     try {
    76.         /**JDBC基本操作**/
    77.         Class.forName(driver);
    78.         Connection conn = DriverManager.getConnection(url, user, password);
    79.         /**在给状态参数之前要把给的属性名提前的拿到，并存集合中字段名 然后再给他一条他认识的Sql**/
    80.         KeyAndSql keyAndSql = handler.parseSql(sql);
    81.         PreparedStatement pstat = conn.prepareStatement(keyAndSql.getNewSql());
    82.         /**给赋值**/
    83.         if (obj != null){handler.handlerParam(pstat,obj,keyAndSql.getColumnName());}
    84.         ResultSet rst = pstat.executeQuery();
    85.         while (rst.next()){
    86.             /**调用handler中的方法来往class里面赋值**/
    87.             lists.add((T)handler.handlerResult(rst,resultType));
    88.         }
    89.         rst.close();
    90.         pstat.close();
    91.         conn.close();
    92.     } catch (Exception e) {
    93.         e.printStackTrace();
    94.     }
    95.     return lists;
    96. }
    99. /**JDBC第三天的框架封装，之前的Update方法参数传的是一个对象
    100.  * 但是现在是Object... 这个东西看起来不太好--->而且需要你给我顺序才可以
    101.  * 我需要实现---->你给我一条按照我的格式来写的sql语句 和一个 =对象=，更新任意一条记录
    102.  * ==========================================================================
    103.  * 思考：--->是否需要返回值---->修改的行数 或 不需要
    104.  * ---->参数需要怎么给 ----> Sql肯定得给，然后我们不需要数组，  直接给我一个对象
    105.  * ==========================================================================
    106.  * 思路--->
    107.  * //1.按照 #{}这种格式给我一条sql
    108.  * //2.我把这条sql给拆开，然后把这里面给的表的字段的顺序和字段名 存在--->集合中
    109.  * //3.并且把他拼接回认识的？组成一条之前那种JDBC认识的SQL语句
    110.  * //4.将拿到的字段名通过反射domain实体类或Map或基本类型，各种类型的判断，不同分支的赋值到sql中
    111.  * **/
    112. /**例如SQL----    insert into user values(#{uname},#{upassword},#{ubal})    **/
    113. /**新增，删除，更新 各种表格一条记录**/
    114. /**构成方法重载，一个动态参数列表，一个是给对象**/
    115. public void update(String sql,Object... objs){
    116.     try {
    117.         Class.forName(driver);
    118.         Connection conn = DriverManager.getConnection(url, user, password);
    119.         PreparedStatement pstat = conn.prepareStatement(sql);
    120.         for (int i = 0; i <objs.length ; i++) {
    121.             pstat.setObject(i+1,objs[i]);
    122.         }
    123.         pstat.executeUpdate();
    124.         pstat.close();
    125.         conn.close();
    126.     } catch (Exception e) {
    127.         e.printStackTrace();
    128.     }
    129. }
    130. public void insert(String sql,Object... objs){this.update(sql,objs);}
    131. public void delete(String sql,Object... objs){this.update(sql,objs);}
    133. public void update(String sql,Object obj){
    134.     try {
    135.         Class.forName(driver);
    136.         Connection conn = DriverManager.getConnection(url, user, password);
    137.         //在这里 提前把这条sql给解析好  存在 集合中字段名和顺序
    138.         //并且 把用完的sql语句 再拼接回可以解析的带？的sql
    139.         KeyAndSql keyAndSql = handler.parseSql(sql);
    140.         PreparedStatement pstat = conn.prepareStatement(keyAndSql.getNewSql());
    141.         //如果你给我的Obj对象不是空的
    142.         if (obj != null){
    143.             //将sql中的？分别赋值 在执行类Handler里面再写一个 把参数赋值的方法
    144.             handler.handlerParam(pstat,obj,keyAndSql.getColumnName());
    145.         }
    146.         pstat.executeUpdate();
    147.         pstat.close();
    148.         conn.close();
    149.     } catch (Exception e) {
    150.         e.printStackTrace();
    151.     }
    152. }
    153. public void insert(String sql,Object obj){this.update(sql,obj);}
    154. public void delete(String sql,Object obj){this.update(sql,obj);}
    155. }

    Handler类

    1. package orm;
    2. import domain.KeyAndSql;
    3. import java.lang.reflect.Field;
    4. import java.sql.PreparedStatement;
    5. import java.sql.ResultSet;
    6. import java.sql.ResultSetMetaData;
    7. import java.sql.SQLException;
    8. import java.util.ArrayList;
    9. import java.util.HashMap;
    10. import java.util.Map;
    11. public class Handler {
    12. /**如果给定的容器是一个Map， 那么通过查询的结果集  把值和字段名 存入Map集合中**/
    13. private Map resultMap(ResultSet rst) throws SQLException {
    14.     Map map = new HashMap();
    15.     ResultSetMetaData rstmd = rst.getMetaData();
    16.     for (int i = 1; i <= rstmd.getColumnCount(); i++) {
    17.         String columnName = rstmd.getColumnName(i);
    18.         Object object = rst.getObject(columnName);
    19.         map.put(columnName,object);
    20.     }
    21.     return map;
    22. }
    24. /**如果给定的是一个 domain实体类，那么需要通过反射来往里面注入值**/
    25. private Object resultObj(ResultSet rst,Class resultType) throws SQLException {
    26.     /**通过结果集  获取数据库的字段名  去匹配class的属性**/
    27.     Object obj = null;
    28.     try {
    29.         //创建一个给定类型的对象
    30.         obj = resultType.newInstance();
    31.         /**拿到数据集中每一个字段的值和字段名**/
    32.         ResultSetMetaData rstmd = rst.getMetaData();
    33.         for (int i = 1; i <=rstmd.getColumnCount(); i++) {
    34.             String columnName = rstmd.getColumnName(i);
    35.             Object fieldValue = rst.getObject(columnName);
    36.             /**通过反射去注入到属性中对应的值**/
    37.             System.out.println(columnName);
    38.             Field field = resultType.getDeclaredField(columnName);
    39.             field.setAccessible(true);
    40.             field.set(obj,fieldValue);
    41.         }
    42.     } catch (InstantiationException e) {
    43.         e.printStackTrace();
    44.     } catch (IllegalAccessException e) {
    45.         e.printStackTrace();
    46.     } catch (NoSuchFieldException e) {
    47.         e.printStackTrace();
    48.     }
    49.     return obj;
    50. }
    53. /**如果给定的是一个map类型  那么我需要给这个map值取出来，然后赋值到?里面**/
    54. private void parseMap(PreparedStatement pstat,Object obj,ArrayList<String> keys) throws SQLException {
    55.     Map map = (Map)obj;
    56.     for (int i = 0; i < keys.size(); i++) {
    57.         //通过读取参数后的List集合中的字段名  进行获取map的值
    58.         Object value = map.get(keys.get(i));
    59.         pstat.setObject(i+1,value);
    60.     }
    61. }
    63. /**最正常的情况，你给了我一个domain实体类对象  那么我需要把这个对象通过反射把属性值取出来，然后赋值到?里面**/
    64. private void parseObj(PreparedStatement pstat,Object obj,ArrayList<String> keys) throws SQLException {
    65.         try {
    66.             Class clazz = obj.getClass();
    67.             for (int i = 0; i < keys.size(); i++) {
    68.                 System.out.println(keys.get(i));
    69.                 Field field = clazz.getDeclaredField(keys.get(i));
    70.                 field.setAccessible(true);
    71.                 pstat.setObject(i+1, field.get(obj));
    72.             }
    73.         } catch (IllegalAccessException e) {
    74.             e.printStackTrace();
    75.         }catch (NoSuchFieldException e){
    76.             e.printStackTrace();
    77.         }
    78. }
    80. /**这个方法是用来拆解传进来的SQL然后获取列名存到集合中，并且重新拼接带？的SQL**/
    81. KeyAndSql parseSql(String sql){
    82.     /**先把两个容器给创建出来，最后把他俩装满后，返回到KeyAndSql实体类中**/
    83.     ArrayList<String> keys = new ArrayList<>();
    84.     StringBuilder newSql = new StringBuilder();
    85.     /**先处理传进来的Sql**/
    86.     /**例如SQL----    insert into user values(#{uname},#{upassword},#{ubal})    **/
    87.     while (true) {
    88.         int left = sql.indexOf("#{");
    89.         int right = sql.indexOf("}");
    90.         if (left != -1 && right != -1 && left<right ) {
    91.             newSql.append(sql.substring(0, left));
    92.             newSql.append("?");
    93.             keys.add(sql.substring(left+2,right));
    94.         }else {
    95.             newSql.append(sql);
    96.             break;
    97.         }
    98.         sql = sql.substring(right+1);
    99.     }
    100.     return new KeyAndSql(newSql.toString(),keys);
    101. }
    103. /**这个方法用来将给定的Object 给?赋值**/
    104. void handlerParam(PreparedStatement pstat,Object obj,ArrayList<String> keys) throws SQLException {
    105.     Class<?> clazz = obj.getClass();
    106.     /**先判断一些---- 基本类型  ---- 如果基本是基本类型 说明只查到了一条信息 只需要给赋值一次**/
    107.     if (clazz == int.class || clazz == Integer.class){
    108.         pstat.setInt(1,(Integer) obj);
    109.     }else if(clazz == float.class || clazz == Float.class){
    110.         pstat.setFloat(1,(Float)obj);
    111.     }else if (clazz == double.class || clazz == Double.class){
    112.         pstat.setDouble(1,(Double) obj);
    113.     }else if(clazz == String.class){
    114.         pstat.setString(1,(String)obj);
    115.     }else {
    116.         if (clazz == Map.class){
    117.             /**如果给的对象是一个 Map类型----- 那么需要单独的给他进行赋值操作**/
    118.             this.parseMap(pstat,obj,keys);
    119.         }else {
    120.             /**那么经过前几个判断如果可以走到这里 说明肯定是给的一个 domain 对象类型 单独出去反射操作赋值**/
    121.             this.parseObj(pstat,obj,keys);
    122.         }
    123.     }
    124. }
    126. /**这个方法给一个ResultSet 给往obj里面赋值**/
    127. Object handlerResult(ResultSet rst,Class resultType) throws SQLException {
    128.     Object obj = null;
    129.     /**先判断  一些基本类型  Map集合 **/
    130.     if (resultType == int.class || resultType == Integer.class){
    131.         obj = rst.getInt(1);
    132.     }else if (resultType == float.class || resultType == Float.class){
    133.         obj = rst.getFloat(1);
    134.     }else if (resultType == double.class || resultType == Double.class){
    135.         obj = rst.getDouble(1);
    136.     }else if (resultType == String.class){
    137.         obj  = rst.getString(1);
    138.     }else {
    139.         if (resultType == Map.class){
    140.             obj = this.resultMap(rst);
    141.         }else{
    142.           obj = this.resultObj(rst,resultType);
    143.         }
    144.     }
    145.     return obj;
    146. }
    147. }

    学习总结：
    学懂的：
    今天晚上的直播课程自己可以听懂，今天主要是把代码给写了一下，写完之后感觉哇~~小细节~
    我熟练学会了DeBug调试和插入输出语句进行辅助调试代码
    有问题的地方：
    那个查询方法,报了一下午的NoSuchFieldException,调了一下午，最后DeBug都没发现什么问题，
    结果是我数据库列名是大写，实体类是小写
    再最后我改了实体类后，报了一个无法实例化异常,**然后最后我发现我实体类改了之后没写无参构造方法


    以后记住上面今天发生的问题，下次绝对不会出错啦~纪点小细节