第六章手写MyBatis实现笔记

悠悠 2024-04-19 10:31 90阅读 0赞

## **一、思路分析** ##

手写mybatis核心还是参考源码的设计，我们也从MyBatis核心流程三大阶段一步步开始实现。

### **1、配置文件解析** ###

读取XML配置文件和注解中的配置信息，创建配置对象，并完成各个模块的初始化的工作，读取XML配置文件和数据库配置文件中的信息加载到configuration对象中。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70][]

### **1、SqlSession说明：** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1][]

Sqlsession意味着创建数据库会话，代表了一次与数据库的连接；是MyBatis对外提供数据访问的主要API（来试试iBatis编程的方式吧）；实际上Sqlsession的功能都是基于Excutor来实现的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2][]

### **2、Executor组件分析** ###

Executor是MyBaits核心接口之一，定义了数据库操作最基本的方法；Executor对数据库的操作遵循什么样规范？答：遵守JDBC规范。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3][]

### **3、实现思路** ###

**MyBatis初始化阶段****：**

1）创建SqlSessionFactory实例；

2）实例化过程中，加载配置文件创建configuration对象；

3）通过factory创建SqlSession；

**代理阶段****：****封装iBatis的编程模型，使用mapper接口开发的初始化工作**

4）通过SqlSession获取mapper接口动态代理

5）动态代理回调sqlsession中某查询方法；

**数据读写阶段****：****完成SQL的解析，参数的映射、SQL的执行、结果的反射解析过程**

6）SqlSession将查询方法转发给Executor；

7）Executor基于JDBC访问数据库获取数据；

8）Executor通过反射将数据转换成POJO并返回；给SqlSession；

9）将数据返回给调用者；

## **二、手写代码实现过程** ##

### **1、首先准备基础配置** ###

1）引入需要依赖的jar包

<dependencies>
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.18</version>
        </dependency>
        
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
       <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
    </dependencies>

2）准备实体类TUser.java与对应的mapper文件以及db.properties

**public interface** TUserMapper \{   
    TUser selectByPrimaryKey(Integer id);  
    List<TUser> selectAll();  
\}

对应的TUserMapper.xml配置：

<select id="selectByPrimaryKey" resultType="TUser">
        select
        id, user_name, real_name, sex, mobile, email, note
        from t_user_test
        where id = #{id,jdbcType=INTEGER}
    </select>
    
    <select id="selectAll" resultType="TUser">
        select
        id, user_name, real_name, sex, mobile, email, note
        from t_user_test
    </select>

### **2、核心流程三大阶段—初始化阶段** ###

**按照mybatis核心流程三大阶段，我们先实现初始化阶段：**

读取XML配置文件和注解中的配置信息，创建配置对象，并完成各个模块的初始化的工作。

**public static void** main(String\[\] args) \{   
   *//--------------------第一阶段---------------------------*  
*   //1.实例化SqlSessionFactory，加载数据库配置文件以及mapper.xml文件到configuration对象*  
*   *SqlSessionFactory factory = **new** SqlSessionFactory();  
   *//2.获取sqlsession对象*  
*   *SqlSession session = factory.openSession();  
   System.***out***.println(session);  
   *//--------------------第二阶段---------------------------*  
*   //3.通过动态代理跨越面向接口编程和ibatis编程模型的鸿沟*  
*   *TUserMapper userMapper = session.getMapper(TUserMapper.**class**);  
   *//-------------------第三阶段---------------------------*  
*   //4.遵循jdbc规范，通过底层的四大对象的合作完成数据查询和数据转化*  
*   *TUser user = userMapper.selectByPrimaryKey(1);  
   System.***out***.println(user);  
 \}

**SqlSessionFactory类代码实现如下：1）生成sqlsession  2）在实例化的时候生成config：**

public class SqlSessionFactory {
        //记录mapper xml文件存放的位置
        public static final String MAPPER_CONFIG_LOCATION = "mappers";
        //记录数据库连接信息文件存放位置
        public static final String DB_CONFIG_FILE = "db.properties";
        private final Configuration conf = new Configuration();
        private final int i = 0;
        public SqlSessionFactory() {
            loadDbInfo(); // 加载数据库配置信息
            loadMappersInfo(); //加载指定文件夹下的所有mapper.xml
        }
        public SqlSession openSession(){
            return new DefaultSqlSession(conf);
        }
        // 加载数据库配置信息
        private void loadDbInfo() {
            // 加载数据库信息配置文件
            InputStream inputStream = SqlSessionFactory.class.getClassLoader().getResourceAsStream(DB_CONFIG_FILE);
            Properties properties = new Properties();
            try { // 将配置信息写入Properties对象
                properties.load(inputStream);
            } catch (IOException e) {
                e.printStackTrace();
            }
            conf.setJdbcDriver(properties.get("jdbc.driver").toString());
            conf.setJdbcPassword(properties.get("jdbc.password").toString());
            conf.setJdbcUrl(properties.get("jdbc.url").toString());
            conf.setJdbcUsername(properties.get("jdbc.username").toString());
        }
        /**
         * 加载指定文件夹下的所有mapper.xml
         */
        private void loadMappersInfo() {
            URL resources = SqlSessionFactory.class.getClassLoader().getResource(MAPPER_CONFIG_LOCATION);
            // 获取指定文件夹信息
            File mappers = new File(resources.getFile());
            if (mappers.isDirectory()){
                File[] files = mappers.listFiles();
                //遍历文件夹下所有的mapper.xml，解析信息后，注册至conf对象中
                for (File file : files) {
                    loadMapperInfo(file);
                }
            }
        }
        /**
         * 加载指定的mapper.xml文件
         */
        private void loadMapperInfo(File file) {
            SAXReader reader = new SAXReader();// 创建saxReader对象
            Document document=null;// 通过read方法读取一个文件 转换成Document对象
            try {
                document = reader.read(file);
            } catch (DocumentException e) {
                e.printStackTrace();
            }
            Element root = document.getRootElement(); //获取根节点元素对象  <mapper>
            String namespace = root.attribute("namespace").getData().toString();//获取命名空间
            List<Element> selects = root.elements("select");//获取select子节点列表
            //遍历select节点，将信息记录到MappedStatement对象，并登记到configuration对象中
            for (Element element : selects) {
                MappedStatement mappedStatement = new MappedStatement();//实例化mappedStatement
                String id = element.attribute("id").getData().toString();//读取id属性
                String resultType = element.attribute("resultType").getData().toString();//读取resultType属性
                String sql = element.getData().toString();//读取SQL语句信息
                String sourceId = namespace+"."+id;
                //给mappedStatement属性赋值
                mappedStatement.setSourceId(sourceId);
                mappedStatement.setResultType(resultType);
                mappedStatement.setSql(sql);
                mappedStatement.setNamespace(namespace);
                //注册到configuration对象中
                conf.getMappedStatements().put(sourceId, mappedStatement);
            }
        }
    }

**Configuration对象与MappedStatement对象实现如下：**

/**
     * 解析的配置参数分装对象（主要是mapper.xml里面的配置信息）
     */
    public class MappedStatement {
        private String  namespace;
        private String  sourceId;
        private String  resultType;
        private String  sql;
    
    /**
     * mybatis配置文件解析类
     */
    public class Configuration {
        private String jdbcDriver;
        private String jdbcUrl;
        private String jdbcUsername;
        private String jdbcPassword;
        private Map<String, MappedStatement> mappedStatements = new HashMap<String, MappedStatement>();
    
    SqlSession接口定义：
    
    /**
     * mybaitis暴露给外部的接口，实现增删改查的能力
     * 1.对外提供数据访问的api
     * 2.对内将请求转发给executor
     * 3.
     */
    public interface SqlSession {
        /**
         * 根据传入的条件查询单一结果
         * @param statement  方法对应的sql语句， namespace + id
         * @param parameter  要传入到sql语句中的查询参数
         * @return  返回指定的结果对象
         */
        <T> T selectOne(String statement, Object parameter);
        /**
         * 根据条件经过查询，返回泛型集合
         * @param statement  方法对应的sql语句， namespace + id
         * @param parameter  要传入到sql语句中的查询参数
         * @return  返回指定的结果对象的list
         */
        <E> List<E> selectList(String statement, Object parameter);
        /**
         *  根据mapper接口获取接口对应的动态代理实现
         * @param type 指定的mapper接口
         * @return
         */
        <T> T getMapper(Class<T> type);
    }

**DefaultSqlSession默认实现方法：**

public class DefaultSqlSession implements SqlSession {
        private final Configuration configuration;
        private Executor executor;
        public DefaultSqlSession(Configuration configuration) {
            super();
            this.configuration = configuration;
            this.executor = new DefaultExecutor(configuration);
        }
        @Override
        public <T> T selectOne(String statement, Object parameter) {
            List<Object> selectList = this.selectList(statement, parameter);
            if(selectList == null || selectList.size()==0){
                return null;
            }
            if(selectList.size()==1){
                return (T) selectList.get(0);
            }else{
                throw new RuntimeException("Too Many Results!");
            }
        }
        @Override
        public <E> List<E> selectList(String statement, Object parameter) {
            MappedStatement ms = configuration.getMappedStatements().get(statement);
            return executor.query(ms, parameter);
        }
        @Override
        public <T> T getMapper(Class<T> type) {
            MapperProxy mp = new MapperProxy(this);
            return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class[]{type}, mp);
        }
    }

### **3、核心流程三大阶段—代理阶段** ###

代理阶段：封装iBatis的编程模型，使用mapper接口开发的初始化工作。

*//--------------------第二阶段---------------------------*  
*//3.通过动态代理跨越面向接口编程和ibatis编程模型的鸿沟*  
TUserMapper userMapper = session.getMapper(TUserMapper.**class**);  
*//4.遵循jdbc规范，通过底层的四大对象的合作完成数据查询和数据转化*  
TUser user = userMapper.selectByPrimaryKey(1);

**该阶段的实现主要在banding模块实现，MapperProxy代理类实现如下：**

@Override
    public <T> T getMapper(Class<T> type) {
        MapperProxy mp = new MapperProxy(this);
        return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class[]{type}, mp);
    }
    
    /**
     * sql查询动态代理增加处理，根据method类型判断是调用查那个查询方法
     */
    public class MapperProxy implements InvocationHandler {
        private SqlSession session;
        public MapperProxy(SqlSession session) {
            super();
            this.session = session;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Class<?> returnType = method.getReturnType();
            // 判断是否为集合类型
            if (Collection.class.isAssignableFrom(returnType)){
                return session.selectList(method.getDeclaringClass().getName()+"."+method.getName(),args==null ? null:args[0]);
            }else{
                return session.selectOne(method.getDeclaringClass().getName()+"."+method.getName(), args==null?null:args[0]);
            }
        }
    }

### **4、核心流程三大阶段—数据读写阶段** ###

数据读写阶段：通过SqlSession完成SQL的解析，参数的映射、SQL的执行、结果的解析过程。

*//-------------------第三阶段---------------------------*  
*//4.遵循jdbc规范，通过底层的四大对象的合作完成数据查询和数据转化*  
TUser user = userMapper.selectByPrimaryKey(1);

**通过代理阶段将接口翻译成为ibtais方式查询，最终执行数据库查询操作通过执行器Executor完成：**

Override
    public <T> T selectOne(String statement, Object parameter) {
        List<Object> selectList = this.selectList(statement, parameter);
        if(selectList == null || selectList.size()==0){
            return null;
        }
        if(selectList.size()==1){
            return (T) selectList.get(0);
        }else{
            throw new RuntimeException("Too Many Results!");
        }
    }
    
    @Override
    public <E> List<E> selectList(String statement, Object parameter) {
        MappedStatement ms = configuration.getMappedStatements().get(statement);
        return executor.query(ms, parameter);
    }

**Executor执行器是MyBaits核心接口之一，定义了数据库操作最基本的方法，SqlSession的功能都是基于它来实现的。**

public interface Executor {
        /**
         * 查询接口
         * @param ms  封装sql语句的MappedStatement对象
         * @param parameter 传入sql的参数
         * @return  将数据转换成指定对象结果集返回
         */
        <E> List<E> query(MappedStatement ms, Object parameter);
    }

**Executor执行器的默认实现：**

public class DefaultExecutor implements Executor {
        private final Configuration conf;
        public DefaultExecutor(Configuration conf) {
            super();
            this.conf = conf;
        }
        /**
         * 查询接口
         * @param ms  封装sql语句的MappedStatement对象
         * @param parameter 传入sql的参数
         * @return  将数据转换成指定对象结果集返回
         */
        @Override
        public <E> List<E> query(MappedStatement ms, Object parameter) {
            List<E> ret = new ArrayList<E>();//定义返回结果集
            try {
                Class.forName(conf.getJdbcDriver());//加载驱动程序
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            Connection connection=null;
            PreparedStatement prepareStatement=null;
            ResultSet resultSet=null;
            try {
                //获取连接，从MappedStatement中获取数据库信息
                connection = DriverManager.getConnection(conf.getJdbcUrl(), conf.getJdbcUsername(), conf.getJdbcPassword());
                //创建prepareStatement，从MappedStatement中获取sql语句
                prepareStatement = connection.prepareStatement(ms.getSql());
                parameterize(prepareStatement,parameter); //处理sql语句中的占位符
                resultSet = prepareStatement.executeQuery();//执行查询操作获取resultSet
                handlerResultSet(resultSet,ret,ms.getResultType());//将结果集通过反射技术，填充到list中
            } catch (SQLException e) {
                e.printStackTrace();
            }finally{
                try {
                    resultSet.close();
                    prepareStatement.close();
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            return ret;
        }
        /**
         * 对prepareStatement中的占位符进行处理
         */
        private void parameterize(PreparedStatement prepareStatement,Object parameter) throws SQLException {
            if(parameter instanceof Integer){
                prepareStatement.setInt(1,(int)parameter);
            }else if(parameter instanceof Long){
                prepareStatement.setLong(1, (long)parameter);
            }else if(parameter instanceof String){
                prepareStatement.setString(1, (String)parameter);
            }
        }
        /**
         *  读取resultset中的数据，并转换成目标对象
         */
        private <E> void handlerResultSet(ResultSet resultSet,List<E> ret,String className){
            Class<E> clazz=null;
            try {//通过反射获取类对象
                clazz = (Class<E>) Class.forName(className);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            try {
                while(resultSet.next()){
                    Object entity = clazz.newInstance();//通过反射实例化对象
                    //使用反射工具将resultSet中的数据填充到entity中
                    ReflectionUtil.setPropToBeanFromResultSet(entity, resultSet);
                    ret.add((E) entity);//对象加入返回集合中
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/fd7e40032e98459c99b1b2037b251c1c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ece0d7e3d1cf488bb050dc97511ceaf3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/39129612db084e07bc07bc7e4956f80e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/efd9c79d9b6e4ccfa59ac52e91d22b4a.png