• 深度自定义mybatis

    > 回顾mybatis的操作的核心步骤

    　　>

    　　> 编写核心类SqlSessionFacotryBuild进行解析配置文件

    　　> 深度分析解析SqlSessionFacotryBuild干的核心工作

    　　>

    　　> 编写核心类SqlSessionFacotry

    　　> 深度分析解析SqlSessionFacotry干的核心工作

    　　> 编写核心类SqlSession

    　　> 深度分析解析SqlSession干的核心工作

    　　> 总结自定义mybatis用的技术点
     

    　　一. 回顾mybatis的操作的核心步骤
     

    　　声明一点我们本篇主要探讨的是mybatis的注解方式的操作, 完全从头开始都是小编从头开搞的, 如果与其他大神的代码思维有出入请多指教。

    　　我们首先需要准备mybatis的核心配置文件(当然导入相关的坐标这里不在啰嗦)

    1. "1.0" encoding="UTF-8" ?>
    2. configuration
    3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
    5. <configuration>
    6.     <environments default="development">
    7.         <environment id="development">
    8.             <transactionManager type="JDBC"/>
    9.             <dataSource type="POOLED">
    10.                 
    11.                 <property name="driver" value="com.mysql.jdbc.Driver"/>
    12.                 <property name="url" value="jdbc:mysql:///db6?useSSL=false"/>
    13.                 <property name="username" value="root"/>
    14.                 <property name="password" value="root"/>
    15.             dataSource>
    16.         environment>
    17.  
    18.     environments>
    19.     <mappers>
    20.         
    21.         <package name="cn.itcast.mapper"/>
    22.     mappers>
    23. configuration>

    　　准备好结果的实体类以及在mapper接口上编写需要执行的sql语句

    1. public class User {
    2.     private Integer uid;
    3.     private String username;
    4.     private String password;
    5.     private String nickname;
    6. }
    1. package cn.itcast.mapper;
    2.  
    3. import cn.itcast.pojo.User;
    4. import org.apache.ibatis.annotations.Select;
    5. import java.util.List;
    6.  
    7. public interface UserMapper {
    8.     @Select("select * from users")
    9.     List findAll();
    10. }

    　　使用mybatis的api来帮助我们完成sql语句的执行以及结果集的封装

    1. //1.关联主配置文件
    2. InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
    3. //2.解析配置文件
    4. SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    5. SqlSessionFactory sqlSessionFactory = builder.build(in);
    6. //3.创建会话对象
    7. SqlSession sqlSession = sqlSessionFactory.openSession();
    8. //4.可以采用接口代理的方式
    9. UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    10. List<User> all = mapper.findAll();
    11. System.out.println(all);
    12. //5.释放资源
    13. sqlSession.close();

    　　思考: mybatis大致是如何帮我们完成相关操作的 ?
     

    　　我们通过Resources的getResourceAsStream告诉了mybatis我们编写的核心配置文件的位置, mybatis就可以找到我们数据库的连接信息, 也同时找到我们编写的sql语句的地方, 然后可以将其解析按照某种规则存放起来, 我们通过调用接口代理的方式执行方法时, 可以找到对应方法上的sql语句然后执行将结果封装返回给我们
     

    　　二. 编写核心类SqlSessionFacotryBuild进行解析配置文件
     

    　　那么我们废话不多说开始我们自定义mybatis的旅程,
     

    　　1.首先我们需要用户编写配置文件, 然后通过我们自己的Resources来告诉我们配置文件所在位置。

    1. package com.itheima.ibatis.configuration;
    2.  
    3. import java.io.InputStream;
    4.  
    5. public class Resources {
    6.  
    7.     public static InputStream getResourceAsStream(String path) {
    8.         return ClassLoader.getSystemClassLoader().getResourceAsStream(path);
    9.     }
    10. }

    　　2. 然后需要定义SqlSessionFacotryBuild来对配置文件进行解析分发

    1. package com.itheima.ibatis.configuration;
    2.  
    3. import com.itheima.ibatis.core.session.SqlSessionFactory;
    4. import com.itheima.ibatis.core.session.impl.DefaultSqlSessionFactory;
    5. import org.dom4j.Document;
    6. import org.dom4j.DocumentException;
    7. import org.dom4j.Element;
    8. import org.dom4j.Node;
    9. import org.dom4j.io.SAXReader;
    10.  
    11. import javax.sql.DataSource;
    12. import java.io.File;
    13. import java.io.InputStream;
    14. import java.lang.reflect.Method;
    15. import java.util.List;
    16. import java.util.Properties;
    17.  
    18. public class SqlSessionFactoryBuilder {
    19.     private Configuration configuration = new Configuration();
    20.  
    21.     public SqlSessionFactory build(InputStream in) {
    22.         SAXReader saxReader = new SAXReader();
    23.         Document document = null;
    24.         try {
    25.             document = saxReader.read(in);
    26.         } catch (DocumentException e) {
    27.             e.printStackTrace();
    28.         }
    29.         Element rootElement = document.getRootElement();
    30.         parseEnvironment(rootElement.element("environments"));
    31.         parseMapper(rootElement.element("mappers"));
    32.         return new DefaultSqlSessionFactory(configuration);
    33.     }
    34.  
    35.     private void parseMapper(Element mapper) {
    36.         String pack = mapper.element("package").attributeValue("name");
    37.  
    38.         String directory = pack.replace(".", "/");
    39.         String path = ClassLoader.getSystemClassLoader().getResource("").getPath();
    40.         File mapperDir = new File(path, directory);
    41.         if (!mapperDir.exists()) {
    42.             throw new RuntimeException("找不到mapper映射");
    43.         }
    44.         findMapper(mapperDir, pack);
    45.         // System.out.println(configuration.getSql());
    46.  
    47.     }
    48.  
    49.     private void findMapper(File mapperDir, String base) {
    50.         File[] files = mapperDir.listFiles();
    51.         if (files != null) {
    52.             for (File file : files) {
    53.                 if (file.isFile()) {
    54.                     if (file.getName().endsWith(".class")) {
    55.                         String name = file.getName();
    56.                         name = name.substring(0, name.lastIndexOf("."));
    57.                         String className = base + "." + name;
    58.                         initMapper(className);
    59.                     }
    60.                 } else {
    61.                     findMapper(file, base + "." + file.getName());
    62.                 }
    63.             }
    64.         }
    65.     }
    66.  
    67.     private void initMapper(String className) {
    68.         try {
    69.             Class<?> clazz = Class.forName(className);
    70.             Method[] methods = clazz.getMethods();
    71.             for (Method method : methods) {
    72.                 if(method.getAnnotations().length>0){
    73.                     Mapper mapper = ParseMapper.parse(method);
    74.                     this.configuration.getMappers().put(className + "." + method.getName(), mapper);
    75.                 }
    76.             }
    77.         } catch (Exception e) {
    78.             e.printStackTrace();
    79.         }
    80.     }
    81.  
    82.     private void parseEnvironment(Element environments) {
    83.         String defEnv = environments.attributeValue("default");
    84.         Node node = environments.selectSingleNode("//environment[@id='" + defEnv + "']");
    85.         List<Element> list = node.selectNodes("//property");
    86.         Properties properties = new Properties();
    87.         for (Element element : list) {
    88.             String name = element.attributeValue("name");
    89.             String value = element.attributeValue("value");
    90.             properties.put(name, value);
    91.         }
    92.         DataSource dataSource = new DefaultDataSource().getDataSource(properties);
    93.         configuration.setDataSource(dataSource);
    94.     }
    95. }

    　　三. 深度分析解析SqlSessionFacotryBuild干的核心工作
     

          1.build(InputStream in) 方法做的工作
     

    　　①借助Dom4j的来解析了xml文件, 将environments解析工作分发给了parseEnvironment(Element environments)
     

    　　②将mappers的解析工作分发给了parseMapper(Element mapper)
     

    　　2. parseEnvironment(Element environments)方法做的工作
     

    　　①主要解析了连接数据库的参数们, 并且创建了数据库连接池
     

    　　自定义连接池非本章节的重点,所以这里内部本质采用的Druid连接池来做了简化

    1. package com.itheima.ibatis.configuration;
    2.  
    3. import com.alibaba.druid.pool.DruidDataSourceFactory;
    4.  
    5. import javax.sql.DataSource;
    6. import java.util.Properties;
    7.  
    8. public class DefaultDataSource {
    9.    
    10.     public DataSource getDataSource(Properties properties) {
    11.         try {
    12.             return DruidDataSourceFactory.createDataSource(properties);
    13.         } catch (Exception e) {
    14.             e.printStackTrace();
    15.         }
    16.         return null;
    17.     }
    18. }

    　　
           ②将解析好的连接池放入configuration对象中,mappers成员变量先别纠结下一章节会讲解

    1. package com.itheima.ibatis.configuration;
    2.  
    3. import lombok.Data;
    4.  
    5. import javax.sql.DataSource;
    6. import java.util.HashMap;
    7. import java.util.Map;
    8.  
    9. @Data
    10. public class Configuration {
    11.     private Map mappers = new HashMap<>();
    12.     private DataSource dataSource;
    13. }

    　　详细图解如下图

    　　

    　　3.parseMapper(Element mapper) 方法做的工作
     

    　　①解析出用户配置的package找到sql语句所在接口的文件夹, 交给initMapper来处理

    　　

    　　②递归找到这个包下所有的.class文件,并且获取到接口的全类名, 然后交给initMapper来处理

    　　

    　　③initMapper通过反射获取类中的每一个方法,将方法交给一个专门解析方法上的注解的工具类ParseMapper的parse方法处理,处理完后将其放到configuration中的mappers的集合中

    　　

    　　④ParseMapper的parse方法做的工作, 这是解析配置的核心地方

    1. package com.itheima.ibatis.configuration;
    2.  
    3. import java.lang.annotation.Annotation;
    4. import java.lang.reflect.InvocationTargetException;
    5. import java.lang.reflect.Method;
    6. import java.lang.reflect.ParameterizedType;
    7. import java.lang.reflect.Type;
    8. import java.util.ArrayList;
    9. import java.util.List;
    10. import java.util.regex.Matcher;
    11. import java.util.regex.Pattern;
    12.  
    13. public class ParseMapper {
    14.  
    15.  
    16.     public static Mapper parse(Method method) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    17.         Annotation[] annotations = method.getAnnotations();
    18.         Object value = annotations[0].getClass().getMethod("value").invoke(annotations[0]);
    19.         Mapper mapper = new Mapper();
    20.         Class<?> resultType = method.getReturnType();
    21.         String val = (String) value;
    22.         Pattern pattern = Pattern.compile("\\#\\{\\s*\\w+\\s*\\}");
    23.         Matcher matcher = pattern.matcher(val);
    24.         List<String> paramNames = new ArrayList<>();
    25.         while (matcher.find()) {
    26.             String group = matcher.group();
    27.             String fieldName = group.substring(2, group.length() - 1).trim();
    28.             paramNames.add(fieldName);
    29.         }
    30.         String sql = val.replaceAll("\\#\\{\\s*\\w+\\s*\\}", "?");
    31.         mapper.setSql(sql);
    32.         mapper.setParameterNames(paramNames);
    33.         mapper.setSql(sql);
    34.         if (resultType == List.class) {
    35.             mapper.setSelectList(true);
    36.             Type genericReturnType = method.getGenericReturnType();
    37.             ParameterizedType parameterizedType = (ParameterizedType) genericReturnType;
    38.             Type actualTypeArgument = parameterizedType.getActualTypeArguments()[0];
    39.             mapper.setResultType(actualTypeArgument.getTypeName());
    40.             mapper.setType("SELECT");
    41.         } else if (resultType == Integer.class || resultType == int.class) {
    42.             mapper.setType("UPDATE");
    43.         } else {
    44.             mapper.setType("SELECT");
    45.             mapper.setResultType(resultType.getName());
    46.         }
    47.         return mapper;
    48.     }
    49. }

    　　首先拿到方法上的注解,得到用户填入的sql语句

    　　

    　　然后处理sql语句#{参数}的这些数据, 然后将参数的顺序保存起来, 用来后期设置参数的数据做准备, 一个方法对应一个Mapper对象

    　　

    　　然后再根据结果类型, 判断是什么类型相关的操作,方便后期执行对应的sql语句

    　　

    　　四. 编写核心类SqlSessionFacotry
     

            1.回顾那个地方创建的SqlSessionFacotry对象
     

    　　经过SqlSessionFacotryBuilder的努力, 我们成功的将配置文件中核心的信息解析出来并放入了configuration对象中了, 然后我们此时将解析好的configuration传入到SqlSessionFacotry中

    　　

    　　SqlSessionFactory的实现类如下:

    1. public class DefaultSqlSessionFactory implements SqlSessionFactory {
    2.     private final Configuration configuration;
    3.     private TransactionManagement defaultTransactionManagement;
    4.  
    5.     public DefaultSqlSessionFactory(Configuration configuration) {
    6.         this.configuration =configuration;
    7.         defaultTransactionManagement = new DefaultTransactionManagement(configuration.getDataSource());
    8.     }
    9.     @Override
    10.     public SqlSession openSession() {
    11.         return new DefaultSqlSession(configuration,defaultTransactionManagement,false);
    12.     }
    13. }

    　　2.添加事务管理器
     

    　　事务管理是一个小的功能, 里面希望使用ThreadLocal集合来保证一个用户拿到的链接是同一个

    　　

    　　事务管理的代码如下:

    1. public class DefaultTransactionManagement implements TransactionManagement {
    2.     private ThreadLocal threadLocal = new ThreadLocal<>();
    3.     private DataSource dataSource;
    4.  
    5.     public DefaultTransactionManagement(DataSource dataSource) {
    6.         this.dataSource = dataSource;
    7.     }
    8.  
    9.     public Connection getConnection() {
    10.         Connection connection = threadLocal.get();
    11.         if (connection == null) {
    12.             try {
    13.                 connection = dataSource.getConnection();
    14.             } catch (SQLException e) {
    15.                 e.printStackTrace();
    16.             }
    17.             threadLocal.set(connection);
    18.         }
    19.         return connection;
    20.     }
    21.  
    22.     @Override
    23.     public void commit() {
    24.         Connection connection = threadLocal.get();
    25.         if (connection != null ) {
    26.             try {
    27.                 connection.commit();
    28.             } catch (Exception e) {
    29.                 e.printStackTrace();
    30.             }
    31.         }
    32.  
    33.     }
    34.  
    35.     @Override
    36.     public void rollback() {
    37.         Connection connection = threadLocal.get();
    38.         if (connection != null) {
    39.             try {
    40.                 connection.rollback();
    41.             } catch (SQLException e) {
    42.                 e.printStackTrace();
    43.             }
    44.         }
    45.     }
    46.  
    47.  
    48.     public void close() {
    49.         Connection connection = threadLocal.get();
    50.         if (connection != null) {
    51.             try {
    52.                 connection.close();
    53.                 threadLocal.remove();
    54.             } catch (SQLException e) {
    55.                 e.printStackTrace();
    56.             }
    57.         }
    58.     }
    59.  
    60.     @Override
    61.     public void begin() {
    62.         Connection connection = threadLocal.get();
    63.         if (connection != null) {
    64.             try {
    65.                 connection.setAutoCommit(false);
    66.             } catch (SQLException e) {
    67.                 e.printStackTrace();
    68.             }
    69.         }
    70.     }
    71. }

    　　五. 深度分析解析SqlSessionFacotry干的核心工作
     

          1.SqlSession openSession() 方法做的工作
     

    　　可以看的出来我们在这个方法创建了DefaultSqlSession对象,并传入封装好的configuration,默认的事务管理器
     

    　　默认通过openSession事务是开启的等等相关的参数

    　　

    　　六.编写核心类SqlSession
     

    　　其实有SqlSession的接口,我们使用的实现类是DefaultSession, 这里记录了解析的配置对象configuration
     

    　　默认事务管理器对象transactionManagement, 默认事务开启的状态tx标记

    1. package com.itheima.ibatis.core.session.impl;
    2.  
    3. import com.itheima.ibatis.configuration.Configuration;
    4. import com.itheima.ibatis.configuration.Mapper;
    5. import com.itheima.ibatis.core.BaseExecutor;
    6. import com.itheima.ibatis.core.annotation.Param;
    7. import com.itheima.ibatis.core.session.SqlSession;
    8. import com.itheima.ibatis.core.transaction.TransactionManagement;
    9. import java.lang.reflect.*;
    10. import java.util.HashMap;
    11. import java.util.List;
    12. import java.util.Map;
    13.  
    14. public class DefaultSqlSession implements SqlSession {
    15.     private final Configuration configuration;
    16.     private final boolean tx;
    17.     private TransactionManagement transactionManagement;
    18.  
    19.     public DefaultSqlSession(Configuration configuration, TransactionManagement transactionManagement, boolean tx) {
    20.         this.configuration = configuration;
    21.         this.transactionManagement = transactionManagement;
    22.         this.tx = tx;
    23.     }
    24.     public void close() {
    25.         transactionManagement.close();
    26.     }
    27.     @Override
    28.     public void commit() {
    29.         transactionManagement.commit();
    30.     }
    31.     @Override
    32.     public void rollback() {
    33.         transactionManagement.rollback();
    34.     }
    35.  
    36.     @Override
    37.     public <T> List<T> selectList(String sqlId) {
    38.         return selectList(sqlId, null);
    39.     }
    40.  
    41.     @Override
    42.     public <T> List<T> selectList(String sqlId, Object param) {
    43.         List<Object> list = new BaseExecutor(transactionManagement, tx).queryList(getMapper(sqlId), param);
    44.         return (List<T>) list;
    45.     }
    46.  
    47.     @Override
    48.     public <T> T selectOne(String sqlId) {
    49.         return selectOne(sqlId, null);
    50.     }
    51.  
    52.     @Override
    53.     public <T> T selectOne(String sqlId, Object param) {
    54.         return new BaseExecutor(transactionManagement, tx).query(getMapper(sqlId), param);
    55.     }
    56.  
    57.     @Override
    58.     public int delete(String sqlId) {
    59.         return update0(sqlId, null);
    60.     }
    61.  
    62.     @Override
    63.     public int delete(String sqlId, Object param) {
    64.         return update0(sqlId, param);
    65.     }
    66.  
    67.     @Override
    68.     public int update(String sqlId) {
    69.         return update0(sqlId, null);
    70.     }
    71.  
    72.     @Override
    73.     public int update(String sqlId, Object param) {
    74.         return update0(sqlId, param);
    75.     }
    76.  
    77.     @Override
    78.     public int insert(String sqlId) {
    79.         return update0(sqlId, null);
    80.     }
    81.  
    82.     @Override
    83.     public int insert(String sqlId, Object param) {
    84.         return update0(sqlId, param);
    85.     }
    86.  
    87.     @Override
    88.     public <T> T getMapper(Class<T> clazz) {
    89.         Object o = Proxy.newProxyInstance(
    90.                 clazz.getClassLoader(),
    91.                 new Class[]{clazz}, new InvocationHandler() {
    92.                     @Override
    93.                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    94.                         String sqlId = clazz.getName() + "." + method.getName();
    95.                         Mapper mapper = configuration.getMappers().get(sqlId);
    96.                         String type = mapper.getType();
    97.                         Object findParam = null;
    98.                         if (args != null) {
    99.                             if (args.length == 1) {
    100.                                 Object param = args[0];
    101.                                 boolean isArray = param.getClass().isArray();
    102.                                 if (!isArray) {
    103.                                     findParam = param;
    104.                                 }
    105.                             } else {
    106.                                 Map<String, Object> map = new HashMap<>();
    107.                                 Parameter[] parameters = method.getParameters();
    108.                                 for (int i = 0; i < parameters.length; i++) {
    109.                                     Param param = parameters[i].getAnnotation(Param.class);
    110.                                     String key = "arg"+i;
    111.                                     if(param !=null){
    112.                                         key = param.value();
    113.                                     }
    114.                                     map.put(key, args[i]);
    115.                                 }
    116.                                 findParam = map;
    117.                             }
    118.                         }
    119.  
    120.                         if (type.equals("SELECT")) {
    121.                             boolean selectList = mapper.isSelectList();
    122.                             if (selectList)
    123.                                 return selectList(sqlId, findParam);
    124.                             else
    125.                                 return selectOne(sqlId, findParam);
    126.                         } else {
    127.                             return update0(sqlId, findParam);
    128.                         }
    129.                     }
    130.                 });
    131.         return (T) o;
    132.     }
    133.  
    134.     private int update0(String sqlId, Object param) {
    135.         return new BaseExecutor(transactionManagement, tx).update(getMapper(sqlId), param);
    136.     }
    137.  
    138.     public Mapper getMapper(String sqlId) {
    139.         Mapper mapper = configuration.getMappers().get(sqlId);
    140.         if (mapper == null) {
    141.             throw new RuntimeException("没有找到sql映射,请检查");
    142.         }
    143.         return mapper;
    144.     }
    145. }

    　　七.深度分析解析SqlSession干的核心工作
     

           1.selectOne & selectList做的工作
     

    　　主要是分发了下功能, 执行sql语句避免不了有参数和无参数的, 都让调用有参数的方便管理

    　　

    　　在执行前, 考虑还有一种情况, 用户不是通过接口代理的方式来执行以上方法, 这样手动输入sqlId容易造成错误
     

    　　这里做一个健壮性判断

    　　

    　　BaseExecutor中的query以及queryList做的核心工作
     

    　　首先这两个方法的特点都是查询, 其步骤基本类似, 所以这里可以合并一起转调query0功能

    　　

    　　这里需要对参数进行设定, 还根据最后isOne的参数决定返回值是否是单个

    　　

    　　参数设置这里比较复杂我们通过图解的方式来解释, (注: 参数是List集合类型的和数组类型的没有做!!!)

    　　

    　　对结果的封装主要用到内省技术和数据库元数据等等知识点

    　　

    　　2.update&delete&insert做的工作

    　　

    　　BaseExecutor中的update做的核心工作
     

    　　还是和query&queryList一样需要设置参数, 不管是增删改其本质其结果都是一致

    　　

    　　3.getMapper代理模式开发的原理
     

    　　主要使用的动态代理的技术创建接口的实现类, 内部主要整合了sqlId和参数, 省去用户自己拼sqlId拼错的风险
     

    　　也同时解决用户手动合参数的麻烦, 但是最终工作的还是selectOne,selectList以及update0这些方法

    　　

    　　

    　　

    　　总结自定义mybatis用的技术点

    　　一款框架的诞生肯定不是一蹴而就的, 随着时间慢慢推进逐步更新出来, 所以一款好的框架肯定要经过很多考验才能够稳定靠谱, 但是纵观整篇用的技术点, 不难发现框架也是由基础代码编写而来,解决大量重复的工作, 提供扩展性等等机制,比如本篇用核心的技术点有。

    　　① 反射

    　　② 内省

    　　③ 解析xml

    　　④ 动态代理

    　　⑤ 工厂设计模式
     

  • 相关阅读:
    Hadoop 2.0：主流开源云架构（四）
    spring的一些了解和使用maven确定目录结构
    【完整解析】2024电工杯数学建模A题论文与代码
    【Mysql】Lock wait timeout exceeded； try restarting transaction
    【Seata】分布式事务框架原理解析
    Docker Dockerfile 文件中设置时区的命令解析
    【二叉树-困难】124. 二叉树中的最大路径和
    【iOS-知乎日报第四周总结】
    怎么设置代理IP进行网络爬取呢？代理访问网络如何设置？
    进阶JAVA篇-如何理解作为参数使用的匿名内部类与 Arrays 类的常用API（九）
  • 原文地址：https://blog.csdn.net/Blue92120/article/details/127801641