学习内容》：

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

    《代码内容》：
    /** 代码思路 ：
    因为之前的封装在dao层需要两条代码就可以完成数据库的CURD ,但是现在我们想把他封装的更加完美，利用反射注解，动态代理的方式
    通过注解传SQL语句 让底层去读取注解的sql和他的类型去判断做什么操作，让代理去执行操作，这样dao层就成为了一个接口。

    实现思路：
    在SqlSession下设计一个方法 用来反射读取注解中的sql用动态代理的方式去执行对应的方法。
    **/
    //===================================================================================//

    SqlSession类 ——>
    添加了一个getMapper方法 用来读取注解的SQL通过动态代理的方式执行对应的CURD的方法

    1. package orm;
    2. import com.mysql.cj.jdbc.ParameterBindingsImpl;
    3. import com.sun.source.util.ParameterNameProvider;
    4. import domain.Atm;
    5. import domain.KeyAndSql;
    6. import orm.annotation.Delete;
    7. import orm.annotation.Insert;
    8. import orm.annotation.Select;
    9. import orm.annotation.Update;
    10. import java.lang.annotation.Annotation;
    11. import java.lang.reflect.*;
    12. import java.sql.Connection;
    13. import java.sql.DriverManager;
    14. import java.sql.PreparedStatement;
    15. import java.sql.ResultSet;
    16. import java.util.ArrayList;
    17. import java.util.List;
    18. import java.util.Map;
    19. @SuppressWarnings("all")
    20. public class SqlSession {
    22. /**
    23. *因为下面update方法的返回值是一个Atm对象 如果这里返回一个集合的话   整体用户体验不太好
    24. * 思考：我们需要把这个Query（查询） 让他的返回值也变成一个对象
    25. * 策略设计模式--->匿名内部类实现策略
    26. **/
    29. /**
    30.  * 由于新增一条记录  删除一条记录  修改一条记录 代码中除了sql语句和预处理？的值不同，其他的代码都一样
    31.  * 如果进行优化的话   参数问题？？--->因为只有sql不同，那么参数需要传一条sql  预处理用动态参数列表
    32.  * 若这样封装可以省2次的代码
    33.  * 返回值-->可有可无 可以是修改的行数 或者  无
    34.  * */
    37. /**来一个Handler小弟 给我解析 拼接**/
    39. private Handler handler = new Handler();
    41. /**写一些连接数据库时需要用到的参数**/
    42. //Driver类加载地址
    43. private String driver="com.mysql.cj.jdbc.Driver";
    44. //连接需要的参数url user password
    45. private String url = "jdbc:mysql://localhost:3306/atm?serverTimezone=CST&characterEncoding=utf-8";
    46. private String user = "root";
    47. private String password = "at123123";
    49. /**查询单表格一条记录**/  /**但是需要三个参数，一条SQL一个策略-->策略设计模式，按顺序给我sql中预处理?的值**/
    50. /**方法重载  另一个是给sql,预处理参数，存储的对象类型**/
    51. public <T>T queryOne(String sql, RowMapper rm, Object... objs){
    52.     return (T)this.queryList(sql,rm,objs).get(0);
    53. }
    54. public <T>T queryOne(String sql,Object obj,Class resultType){return (T)this.queryList(sql,obj,resultType).get(0);}
    56. /**查询单表格多条记录**/
    57. /**设计一个方法  之前的QueryList方法如果查询的话在Dao层用户需要去实现一个策略，这样体验感不太好*
    58.  * 我现在需要把他设计成  你只需要给我一个sql,给我sql中预处理的参数，再给我一个Class类型的类
    59.  * 我就帮你把查询到的数据，存储在你给我的这个类中去
    60.  * 参数问题？？---->Sql肯定需要给我，预处理sql的？值你需要给我，还肯定需要各位Class的类型
    61.  * */
    62. /**======查询单表格的多条记录======**/
    63. public <T> List<T> queryList(String sql, RowMapper rm, Object... objs){
    64.     ArrayList<T> lists = new ArrayList<>();
    65.     try {
    66.         Class.forName(driver);
    67.         Connection conn = DriverManager.getConnection(url, user, password);
    68.         PreparedStatement pstat = conn.prepareStatement(sql);
    69.         for (int i = 0; i <objs.length ; i++) {
    70.             pstat.setObject(i+1,objs[i]);
    71.         }
    72.         ResultSet rst = pstat.executeQuery();
    73.         while(rst.next()){
    74.             lists.add(rm.mapperRow(rst));
    75.         }
    76.         rst.close();
    77.         pstat.close();
    78.         conn.close();
    79.     } catch (Exception e) {
    80.         e.printStackTrace();
    81.     }
    82.     return lists;
    83. }
    84. public <T> List<T> queryList(String sql,Object obj,Class resultType){
    85.     ArrayList<T> lists = new ArrayList<>();
    86.     try {
    87.         /**JDBC基本操作**/
    88.         Class.forName(driver);
    89.         Connection conn = DriverManager.getConnection(url, user, password);
    90.         /**在给状态参数之前要把给的属性名提前的拿到，并存集合中字段名 然后再给他一条他认识的Sql**/
    91.         KeyAndSql keyAndSql = handler.parseSql(sql);
    92.         PreparedStatement pstat = conn.prepareStatement(keyAndSql.getNewSql());
    93.         /**给赋值**/
    94.         if (obj != null){handler.handlerParam(pstat,obj,keyAndSql.getColumnName());}
    95.         ResultSet rst = pstat.executeQuery();
    96.         while (rst.next()){
    97.             /**调用handler中的方法来往class里面赋值**/
    98.             lists.add((T)handler.handlerResult(rst,resultType));
    99.         }
    100.         rst.close();
    101.         pstat.close();
    102.         conn.close();
    103.     } catch (Exception e) {
    104.         e.printStackTrace();
    105.     }
    106.     return lists;
    107. }
    110. /**JDBC第三天的框架封装，之前的Update方法参数传的是一个对象
    111.  * 但是现在是Object... 这个东西看起来不太好--->而且需要你给我顺序才可以
    112.  * 我需要实现---->你给我一条按照我的格式来写的sql语句 和一个 =对象=，更新任意一条记录
    113.  * ==========================================================================
    114.  * 思考：--->是否需要返回值---->修改的行数 或 不需要
    115.  * ---->参数需要怎么给 ----> Sql肯定得给，然后我们不需要数组，  直接给我一个对象
    116.  * ==========================================================================
    117.  * 思路--->
    118.  * //1.按照 #{}这种格式给我一条sql
    119.  * //2.我把这条sql给拆开，然后把这里面给的表的字段的顺序和字段名 存在--->集合中
    120.  * //3.并且把他拼接回认识的？组成一条之前那种JDBC认识的SQL语句
    121.  * //4.将拿到的字段名通过反射domain实体类或Map或基本类型，各种类型的判断，不同分支的赋值到sql中
    122.  * **/
    123. /**例如SQL----    insert into user values(#{uname},#{upassword},#{ubal})    **/
    124. /**新增，删除，更新 各种表格一条记录**/
    125. /**构成方法重载，一个动态参数列表，一个是给对象**/
    126. public void update(String sql,Object... objs){
    127.     try {
    128.         Class.forName(driver);
    129.         Connection conn = DriverManager.getConnection(url, user, password);
    130.         PreparedStatement pstat = conn.prepareStatement(sql);
    131.         for (int i = 0; i <objs.length ; i++) {
    132.             pstat.setObject(i+1,objs[i]);
    133.         }
    134.         pstat.executeUpdate();
    135.         pstat.close();
    136.         conn.close();
    137.     } catch (Exception e) {
    138.         e.printStackTrace();
    139.     }
    140. }
    141. public void insert(String sql,Object... objs){this.update(sql,objs);}
    142. public void delete(String sql,Object... objs){this.update(sql,objs);}
    144. public void update(String sql,Object obj){
    145.     try {
    146.         Class.forName(driver);
    147.         Connection conn = DriverManager.getConnection(url, user, password);
    148.         //在这里 提前把这条sql给解析好  存在 集合中字段名和顺序
    149.         //并且 把用完的sql语句 再拼接回可以解析的带？的sql
    150.         KeyAndSql keyAndSql = handler.parseSql(sql);
    151.         PreparedStatement pstat = conn.prepareStatement(keyAndSql.getNewSql());
    152.         //如果你给我的Obj对象不是空的
    153.         if (obj != null){
    154.             //将sql中的？分别赋值 在执行类Handler里面再写一个 把参数赋值的方法
    155.             handler.handlerParam(pstat,obj,keyAndSql.getColumnName());
    156.         }
    157.         pstat.executeUpdate();
    158.         pstat.close();
    159.         conn.close();
    160.     } catch (Exception e) {
    161.         e.printStackTrace();
    162.     }
    163. }
    164. public void insert(String sql,Object obj){this.update(sql,obj);}
    165. public void delete(String sql,Object obj){this.update(sql,obj);}
    170. /**
    171.  * JDBC封装第五天  如果我想通过注解的方式去读取注解里面的Sql然后自动取执行对应的方法
    172.  * 利用 --->反射实现设计一个getMapper方法
    173.  * 动态代理---->
    174.  * **/
    175. public <T> T getMapper(Class clazz){
    176.     //第一个参数是类加载器
    177.     //第二个参数是被代理对象（dao类）
    178.     //第三个参数是这个代理的具体实现--->这里需要自己写策略实现
    179.     return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, new InvocationHandler() {
    180.         @Override
    181.         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    182.             //proxy就是这个代理对象
    183.             //method被代理的那个方法(要方法上面注解里的Sql)
    184.             //args被代理的那个方法的参数(存储的是Sql上的那些所需的值)
    185.             //获取方法上的sql
    186.             /**
    187.              * SqlSession需要的参数--One-->sql,对象
    188.              * **/
    189.             Annotation an = method.getAnnotations()[0];
    190.             //获取当前注解的类型（Insrt.class还是select.class）
    191.             Class anType = an.annotationType();
    192.             //获取当前注解内的Sql
    193.             Method anValue = anType.getDeclaredMethod("value");
    194.             String sql = (String)anValue.invoke(an);
    195.             //处理被代理对象中方法中的参数
    196.             Object param = args == null ? null : args[0];
    197.             //判断注解类型去分别执行SqlSession
    198.             if (anType == Insert.class){
    199.                 SqlSession.this.insert(sql,param);
    200.             }else  if (anType == Update.class){
    201.                 SqlSession.this.update(sql,param);
    202.             }else if (anType == Delete.class){
    203.                 SqlSession.this.delete(sql,param);
    204.             }else if (anType == Select.class){
    205.                 Class<?> methodReturnType = method.getReturnType();
    206.                 if (methodReturnType != List.class){
    207.                     return SqlSession.this.queryOne(sql,param,methodReturnType);
    208.                 }
    209.                 //获取方法的返回值具体类型
    210.                 System.out.println("执行了");
    211.                 Type listReturnType = method.getGenericReturnType();
    212.                 //向下多态转型
    213.                 if (listReturnType instanceof ParameterizedType) {
    214.                     ParameterizedType realReturnType = (ParameterizedType) listReturnType;
    215.                     //操作返回值类型中的泛型
    216.                     Class domain = (Class) realReturnType.getActualTypeArguments()[0];
    217.                     System.out.println("执行了查询多条");
    218.                     return SqlSession.this.queryList(sql, param, domain);
    219.                 }
    220.             }
    221.                 return  null;
    222.         }
    223.     });
    224.  }
    225. }

    学习总结：
    学懂的：
    思路可以跟的上，自己通过慢慢的想思路去实现了这个功能！
    有问题的地方：
    args[0]不晓得为啥要传这个参数
    在反射泛型向下转型ParameterizedType 这个类型的时候出现报错cast….
    image.png
    经过自己的摸索发现JDK版本可能不同，在JDK13版本可能需要在获取返回值内的泛型的时候，如果要向下转型获取到我们可以操作
    的那种类型，我们就必须判断一下获取到的返回值内的泛型是不是一个ParameterizedType类型，才可以继续进行反射操作