基础框架 MyBatis持久层框架简单实现

柔光的暖阳◎ 2022-12-31 01:17 207阅读 0赞

## 基础框架 MyBatis持久层框架简单实现 ##

### 一、概念 ###

1、mybatis三种实现方式  
mybatis提供的API：这种方式不常用，比较原始的方式。  
通过配置xml方式：使用最多，功能相对比较完善。  
注解方式：减少很多配置，但是功能相较于xml没那么完善。

本篇要做的就是对mybatis的简单实现，并不是重复造轮子，为了更深入的理解mybatis原理机制，从作者角度去思考，才能更深如体会其中的思想。  
声明一下，大佬勿喷，只是为了学习，这只是仿照mybatis的简单实现，并不是mybatis，mybatis源码日后具体分析。

### 二、原理分析 ###

执行顺序，上个图，比较清晰。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70_pic_center]

### 三、实现验证 ###

1.  创建maven工程
2.  引入依赖，这里没有引用mybatis，需要手动自己实现，包括xml解析，封装jdbc，封装结果集等。

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.zrj.mybatis</groupId>
        <artifactId>mybatis_design</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <dependencies>
            
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.12</version>
            </dependency>
            
            <dependency>
                <groupId>dom4j</groupId>
                <artifactId>dom4j</artifactId>
                <version>1.6.1</version>
            </dependency>
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.6</version>
            </dependency>
            
            <dependency>
                <groupId>jaxen</groupId>
                <artifactId>jaxen</artifactId>
                <version>1.1.6</version>
            </dependency>
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13</version>
            </dependency>
    
        </dependencies>
    
    
    </project>

1.  创建各种接口实现类

package com.zrj.mybatis.cfg;
    
    import java.util.Map;
    
    /** * 核心配置类 * 1.数据库信息 * 2.sql 的 map 集合 */
    public class Configuration { 
        /** * 用户名 */
        private String username;
        /** * 密码 */
        private String password;
        /** * 地址 */
        private String url;
        /** * 驱动 */
        private String driver;
        /** * map 集合 Map<唯一标识， Mapper> 用于保存映射文件中的 sql 标识及 sql 语句 */
        private Map<String, Mapper> mappers;
    
        public String getUsername() { 
            return username;
        }
    
        public void setUsername(String username) { 
            this.username = username;
        }
    
        public String getPassword() { 
            return password;
        }
    
        public void setPassword(String password) { 
            this.password = password;
        }
    
        public String getUrl() { 
            return url;
        }
    
        public void setUrl(String url) { 
            this.url = url;
        }
    
        public String getDriver() { 
            return driver;
        }
    
        public void setDriver(String driver) { 
            this.driver = driver;
        }
    
        public Map<String, Mapper> getMappers() { 
            return mappers;
        }
    
        public void setMappers(Map<String, Mapper> mappers) { 
            this.mappers = mappers;
        }
    }

package com.zrj.mybatis.cfg;
    
    /** * 用于封装查询时的必要信息：要执行的 SQL 语句和实体类的全限定类名 * * @author zrj * @date 2020/12/27 * @since V1.0 **/
    public class Mapper { 
        /** * sql */
        private String queryString;
        /** * 结果类型的全限定类名 */
        private String resultType;
    
        public String getQueryString() { 
            return queryString;
        }
    
        public void setQueryString(String queryString) { 
            this.queryString = queryString;
        }
    
        public String getResultType() { 
            return resultType;
        }
    
        public void setResultType(String resultType) { 
            this.resultType = resultType;
        }
    }

package com.zrj.mybatis.cfg;
    
    import com.zrj.mybatis.utils.Executor;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.sql.Connection;
    import java.util.Map;
    
    /** * 用于创建代理对象是增强方法 * 注意调用不同的方式xml或者注解需要先修改SqlMapConfig.xml配置文件 * * @author zrj * @date 2020/12/27 * @since V1.0 **/
    public class MapperProxyFactory implements InvocationHandler { 
        private Map<String, Mapper> mappers;
        private Connection conn;
    
        public MapperProxyFactory(Map<String, Mapper> mappers, Connection conn) { 
            this.mappers = mappers;
            this.conn = conn;
        }
    
        /** * 对当前正在执行的方法进行增强 * 取出当前执行的方法名称 * 取出当前执行的方法所在类 * 拼接成 key * 去 Map 中获取 Value（Mapper) * 使用工具类 Executor 的 selectList 方法 */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            //1.取出方法名
            String methodName = method.getName();
            //2.取出方法所在类名
            String className = method.getDeclaringClass().getName();
            //3.拼接成 Key
            String key = className + "." + methodName;
            //4.使用 key 取出 mapper
            Mapper mapper = mappers.get( key );
            if (mapper == null) { 
                throw new IllegalArgumentException( "传入的参数有误，无法获取执行的必要条件" );
            }
            //5.创建 Executor 对象
            Executor executor = new Executor();
            return executor.selectList( mapper, conn );
        }
    
    }

/** * Copyright 2009-2020 the original author or authors. * <p> * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * <p> * http://www.apache.org/licenses/LICENSE-2.0 * <p> * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */
    package com.zrj.mybatis.annotations;
    
    import java.lang.annotation.*;
    
    /** * 这是从源码复制过来的，改了一下value返回值，源码返回String[],给为String * The annotation that specify an SQL for retrieving record(s). * * <p> * <b>How to use:</b> * * <pre> * public interface UserMapper { * @Select("SELECT id, name FROM users WHERE id = #{id}") * User selectById(int id); * } * </pre> * * @author Clinton Begin */
    @Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @Repeatable(Select.List.class)
    public @interface Select { 
        /** * Returns an SQL for retrieving record(s). * * @return an SQL for retrieving record(s) */
        String value();
    
        /** * @return A database id that correspond this statement * @since 3.5.5 */
        String databaseId() default "";
    
        /** * The container annotation for {@link Select}. * @author Kazuki Shimizu * @since 3.5.5 */
        @Documented
        @Retention(RetentionPolicy.RUNTIME)
        @Target(ElementType.METHOD)
        @interface List { 
            Select[] value();
        }
    
    }

package com.zrj.mybatis.io;
    
    import java.io.InputStream;
    
    /** * 用于读取配置文件的类 * * @author zrj * @date 2020/12/27 * @since V1.0 **/
    public class Resources { 
        /** * 用于加载 xml 文件，并且得到一个流对象 * * @param xmlPath * @return 在实际开发中读取配置文件: * 第一：使用类加载器。但是有要求： a 文件不能过大。 b 文件必须在类路径下(classpath) * 第二：使用 ServletContext 的 getRealPath() */
        public static InputStream getResourceAsStream(String xmlPath) { 
            return Resources.class.getClassLoader().getResourceAsStream( xmlPath );
        }
    }

package com.zrj.mybatis.utils;
    
    import com.zrj.mybatis.cfg.Configuration;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    
    /** * 工具类 * 获取数据库连接 * * @author zrj * @date 2020/12/27 * @since V1.0 **/
    public class DataSourceUtil { 
        /** * 获取连接 * * @param cfg * @return */
        public static Connection getConnection(Configuration cfg) { 
            try { 
                Class.forName( cfg.getDriver() );
                Connection conn = DriverManager.getConnection( cfg.getUrl(), cfg.getUsername(), cfg.getPassword() );
                return conn;
            } catch (Exception e) { 
                throw new RuntimeException( e );
            }
        }
    }

package com.zrj.mybatis.utils;
    
    import com.zrj.mybatis.annotations.Select;
    import com.zrj.mybatis.cfg.Configuration;
    import com.zrj.mybatis.cfg.Mapper;
    import com.zrj.mybatis.io.Resources;
    import com.zrj.mybatis.sqlsession.DefaultSqlSession;
    import org.dom4j.Attribute;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.lang.reflect.Method;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /** * 工具类 * 用于解析配置文件 * * @author zrj * @date 2020/12/27 * @since V1.0 **/
    public class XMLConfigBuilder { 
    
    
        /** * 解析主配置文件，把里面的内容填充到DefaultSqlSession所需要的地方 * 使用的技术： * dom4j+xpath */
        public static void loadConfiguration(DefaultSqlSession session, InputStream config) { 
            try { 
                //定义封装连接信息的配置对象（mybatis的配置对象）
                Configuration cfg = new Configuration();
    
                //1.获取SAXReader对象
                SAXReader reader = new SAXReader();
                //2.根据字节输入流获取Document对象
                Document document = reader.read( config );
                //3.获取根节点
                Element root = document.getRootElement();
                //4.使用xpath中选择指定节点的方式，获取所有property节点
                List<Element> propertyElements = root.selectNodes( "//property" );
                //5.遍历节点
                for (Element propertyElement : propertyElements) { 
                    //判断节点是连接数据库的哪部分信息
                    //取出name属性的值
                    String name = propertyElement.attributeValue( "name" );
                    if ("driver".equals( name )) { 
                        //表示驱动
                        //获取property标签value属性的值
                        String driver = propertyElement.attributeValue( "value" );
                        cfg.setDriver( driver );
                    }
                    if ("url".equals( name )) { 
                        //表示连接字符串
                        //获取property标签value属性的值
                        String url = propertyElement.attributeValue( "value" );
                        cfg.setUrl( url );
                    }
                    if ("username".equals( name )) { 
                        //表示用户名
                        //获取property标签value属性的值
                        String username = propertyElement.attributeValue( "value" );
                        cfg.setUsername( username );
                    }
                    if ("password".equals( name )) { 
                        //表示密码
                        //获取property标签value属性的值
                        String password = propertyElement.attributeValue( "value" );
                        cfg.setPassword( password );
                    }
                }
                //取出mappers中的所有mapper标签，判断他们使用了resource还是class属性
                List<Element> mapperElements = root.selectNodes( "//mappers/mapper" );
                //遍历集合
                for (Element mapperElement : mapperElements) { 
                    //判断mapperElement使用的是哪个属性
                    Attribute attribute = mapperElement.attribute( "resource" );
                    if (attribute != null) { 
                        System.out.println( "使用的是XML" );
                        //表示有resource属性，用的是XML
                        //取出属性的值
                        //获取属性的值"com/itheima/dao/IUserDao.xml"
                        String mapperPath = attribute.getValue();
                        //把映射配置文件的内容获取出来，封装成一个map
                        Map<String, Mapper> mappers = loadMapperConfiguration( mapperPath );
                        //给configuration中的mappers赋值
                        cfg.setMappers( mappers );
                    } else { 
                        System.out.println( "使用的是注解" );
                        //表示没有resource属性，用的是注解
                        //获取class属性的值
                        String daoClassPath = mapperElement.attributeValue( "class" );
                        //根据daoClassPath获取封装的必要信息
                        Map<String, Mapper> mappers = loadMapperAnnotation( daoClassPath );
                        //给configuration中的mappers赋值
                        cfg.setMappers( mappers );
                    }
                }
                //把配置对象传递给 DefaultSqlSession
                session.setCfg( cfg );
            } catch (Exception e) { 
                throw new RuntimeException( e );
            } finally { 
                try { 
                    config.close();
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            }
    
        }
    
        /** * 根据传入的参数，解析XML，并且封装到Map中 * * @param mapperPath 映射配置文件的位置 * @return map中包含了获取的唯一标识（key是由dao的全限定类名和方法名组成） * 以及执行所需的必要信息（value是一个Mapper对象，里面存放的是执行的SQL语句和要封装的实体类全限定类名） */
        private static Map<String, Mapper> loadMapperConfiguration(String mapperPath) throws IOException { 
            InputStream in = null;
            try { 
                //定义返回值对象
                Map<String, Mapper> mappers = new HashMap<String, Mapper>();
                //1.根据路径获取字节输入流
                in = Resources.getResourceAsStream( mapperPath );
                //2.根据字节输入流获取Document对象
                SAXReader reader = new SAXReader();
                Document document = reader.read( in );
                //3.获取根节点
                Element root = document.getRootElement();
                //4.获取根节点的namespace属性取值
                //是组成map中key的部分
                String namespace = root.attributeValue( "namespace" );
                //5.获取所有的select节点
                List<Element> selectElements = root.selectNodes( "//select" );
                //6.遍历select节点集合
                for (Element selectElement : selectElements) { 
                    //取出id属性的值 组成map中key的部分
                    String id = selectElement.attributeValue( "id" );
                    //取出resultType属性的值 组成map中value的部分
                    String resultType = selectElement.attributeValue( "resultType" );
                    //取出文本内容 组成map中value的部分
                    String queryString = selectElement.getText();
                    //创建Key
                    String key = namespace + "." + id;
                    //创建Value
                    Mapper mapper = new Mapper();
                    mapper.setQueryString( queryString );
                    mapper.setResultType( resultType );
                    //把key和value存入mappers中
                    mappers.put( key, mapper );
                }
                return mappers;
            } catch (Exception e) { 
                throw new RuntimeException( e );
            } finally { 
                in.close();
            }
        }
    
        /** * 根据传入的参数，得到dao中所有被select注解标注的方法。 * 根据方法名称和类名，以及方法上注解value属性的值，组成Mapper的必要信息 * * @param daoClassPath * @return */
        private static Map<String, Mapper> loadMapperAnnotation(String daoClassPath) throws Exception { 
            //定义返回值对象
            Map<String, Mapper> mappers = new HashMap<String, Mapper>();
    
            //1.得到dao接口的字节码对象
            Class daoClass = Class.forName( daoClassPath );
            //2.得到dao接口中的方法数组
            Method[] methods = daoClass.getMethods();
            //3.遍历Method数组
            for (Method method : methods) { 
                //取出每一个方法，判断是否有select注解
                boolean isAnnotated = method.isAnnotationPresent( Select.class );
                if (isAnnotated) { 
                    //创建Mapper对象
                    Mapper mapper = new Mapper();
                    //取出注解的value属性值
                    Select selectAnno = method.getAnnotation( Select.class );
                    String queryString = selectAnno.value();
                    mapper.setQueryString( queryString );
                    //获取当前方法的返回值，还要求必须带有泛型信息
                    Type type = method.getGenericReturnType();//List<User>
                    //判断type是不是参数化的类型
                    if (type instanceof ParameterizedType) { 
                        //强转
                        ParameterizedType ptype = (ParameterizedType) type;
                        //得到参数化类型中的实际类型参数
                        Type[] types = ptype.getActualTypeArguments();
                        //取出第一个
                        Class domainClass = (Class) types[0];
                        //获取domainClass的类名
                        String resultType = domainClass.getName();
                        //给Mapper赋值
                        mapper.setResultType( resultType );
                    }
                    //组装key的信息
                    //获取方法的名称
                    String methodName = method.getName();
                    String className = method.getDeclaringClass().getName();
                    String key = className + "." + methodName;
                    //给map赋值
                    mappers.put( key, mapper );
                }
            }
            return mappers;
        }
    
    
    }

package com.zrj.mybatis.utils;
    
    import com.zrj.mybatis.cfg.Mapper;
    
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.Method;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    import java.util.ArrayList;
    import java.util.List;
    
    /** * 工具类 * 执行器，负责执行 SQL 语句，并且封装结果集 * * @author zrj * @date 2020/12/27 * @since V1.0 **/
    public class Executor { 
        public <E> List<E> selectList(Mapper mapper, Connection conn) { 
            PreparedStatement pstm = null;
            ResultSet rs = null;
            try { 
                //1.取出 mapper 中的数据
                //select * from user
                String queryString = mapper.getQueryString();
                String resultType = mapper.getResultType();
                Class domainClass = Class.forName( resultType );
                //2.获取 PreparedStatement 对象
                pstm = conn.prepareStatement( queryString );
                //3.执行 SQL 语句，获取结果集
                rs = pstm.executeQuery();
                //4.封装结果集
                //定义返回值
                List<E> list = new ArrayList<E>();
                while (rs.next()) { 
                    //实例化要封装的实体类对象
                    //User 对象
                    E obj = (E) domainClass.newInstance();
                    //取出结果集的元信息： ResultSetMetaData
                    ResultSetMetaData rsmd = rs.getMetaData();
                    //取出总列数
                    int columnCount = rsmd.getColumnCount();
                    //遍历总列数
                    for (int i = 1; i <= columnCount; i++) { 
                        //获取每列的名称，列名的序号是从 1 开始的
                        String columnName = rsmd.getColumnName( i );
                        //根据得到列名，获取每列的值
                        Object columnValue = rs.getObject( columnName );
                        //给 obj 赋值：使用 Java 内省机制（借助 PropertyDescriptor 实现属性的封装）
                        //要求：实体类的属性和数据库表的列名保持一种
                        PropertyDescriptor pd = new PropertyDescriptor( columnName, domainClass );
                        //获取它的写入方
                        Method writeMethod = pd.getWriteMethod();
                        // setUsername(String username);
                        //把获取的列的值，给对象赋值
                        writeMethod.invoke( obj, columnValue );
                    }
                    //把赋好值的对象加入到集合中
                    list.add( obj );
                }
                return list;
            } catch (Exception e) { 
                throw new RuntimeException( e );
            } finally { 
                release( pstm, rs );
            }
        }
    
        /** * 释放连接 * * @param pstm * @param rs */
        private void release(PreparedStatement pstm, ResultSet rs) { 
            if (rs != null) { 
                try { 
                    rs.close();
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            }
            if (pstm != null) { 
                try { 
                    pstm.close();
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            }
        }
    
    }

package com.zrj.mybatis.sqlsession;
    
    import java.io.InputStream;
    
    /** * 用于构建 SqlSessionFactory * * @author zrj * @date 2020/12/27 * @since V1.0 **/
    public class SqlSessionFactoryBuilder { 
        /** * 根据传入的流，实现对 SqlSessionFactory 的创建 * * @param in 它就是 SqlMapConfig.xml 的配置以及里面包含的 IUserDao.xml 的配置 * @return */
        public SqlSessionFactory build(InputStream in) { 
            DefaultSqlSessionFactory factory = new DefaultSqlSessionFactory();
            //给 factory 中 config 赋值
            factory.setConfig( in );
            return factory;
        }
    }

package com.zrj.mybatis.sqlsession;
    
    /** * SqlSessionFactory * * @author zrj * @date 2020/12/27 * @since V1.0 **/
    public interface SqlSessionFactory { 
        /** * 创建一个新的 SqlSession 对象 * * @return */
        SqlSession openSession();
    }

package com.zrj.mybatis.sqlsession;
    
    import com.zrj.mybatis.utils.XMLConfigBuilder;
    
    import java.io.InputStream;
    
    /** * 默认sqlSessionFactory * * @author zrj * @date 2020/12/27 * @since V1.0 **/
    public class DefaultSqlSessionFactory implements SqlSessionFactory { 
        private InputStream config = null;
    
        public void setConfig(InputStream config) { 
            this.config = config;
        }
    
        @Override
        public SqlSession openSession() { 
            DefaultSqlSession session = new DefaultSqlSession();
            //调用工具类解析 xml 文件
            XMLConfigBuilder.loadConfiguration( session, config );
            return session;
        }
    }

package com.zrj.mybatis.sqlsession;
    
    /** * 定义SqlSession * * @author zrj * @date 2020/12/27 * @since V1.0 **/
    public interface SqlSession { 
        /** * 创建 Dao 接口的代理对象 * * @param daoClass * @return */
        <T> T getMapper(Class<T> daoClass);
    
        /** * 释放资源 */
        void close();
    }

package com.zrj.mybatis.sqlsession;
    
    import com.zrj.mybatis.cfg.Configuration;
    import com.zrj.mybatis.cfg.Mapper;
    import com.zrj.mybatis.cfg.MapperProxyFactory;
    import com.zrj.mybatis.utils.DataSourceUtil;
    import com.zrj.mybatis.utils.Executor;
    
    import java.lang.reflect.Proxy;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.List;
    
    /** * 默认DefaultSqlSession * * @author zrj * @date 2020/12/27 * @since V1.0 **/
    public class DefaultSqlSession implements SqlSession { 
        /** * 核心配置对象 */
        private Configuration cfg;
    
        public void setCfg(Configuration cfg) { 
            this.cfg = cfg;
        }
    
        /** * 连接对象 */
        private Connection conn;
    
        /** * 调用 DataSourceUtils 工具类获取连接 * * @return */
        public Connection getConn() { 
            try { 
                conn = DataSourceUtil.getConnection( cfg );
                return conn;
            } catch (Exception e) { 
                throw new RuntimeException( e );
            }
        }
    
        /** * 动态代理： * 涉及的类： Proxy * 使用的方法： newProxyInstance * 方法的参数： * ClassLoader：和被代理对象使用相同的类加载器,通常都是固定的 * Class[]：代理对象和被代理对象要求有相同的行为。（具有相同的方法） * InvocationHandler：如何代理。需要我们自己提供的增强部分的代码 */
        @Override
        public <T> T getMapper(Class<T> daoClass) { 
            conn = getConn();
            System.out.println( conn );
            T daoProxy = (T) Proxy.newProxyInstance(
                    daoClass.getClassLoader(),
                    new Class[]{ daoClass},
                    new MapperProxyFactory( cfg.getMappers(), conn )
            );
            return daoProxy;
        }
    
        /** * 释放资源 */
        @Override
        public void close() { 
            try { 
                System.out.println( conn );
                conn.close();
            } catch (SQLException e) { 
                e.printStackTrace();
            }
        }
    
        //查询所有方法
        public <E> List<E> selectList(String statement) { 
            Mapper mapper = cfg.getMappers().get( statement );
            return new Executor().selectList( mapper, conn );
        }
    
    }

<?xml version="1.0" encoding="UTF-8"?>
    
    
    <configuration>
        
        <environments default="mysql">
            
            <environment id="mysql">
                
                <transactionManager type="JDBC"></transactionManager>
                
                <dataSource type="POOLED">
                    
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://localhost:3306/test_db"/>
                    <property name="username" value="root"/>
                    <property name="password" value="123456"/>
                </dataSource>
            </environment>
        </environments>
    
        
    
        
        
        
        
    
        
        <mappers>
            <mapper class="com.zrj.dao.BookDao"></mapper>
        </mappers>
    </configuration>

<?xml version="1.0" encoding="UTF-8"?>
    
    <mapper namespace="com.zrj.dao.UserDao">
        
        <select id="findAll" resultType="com.zrj.domain.User">
            select * from user
        </select>
    
    </mapper>

# Set root category priority to INFO and its only appender to CONSOLE.
    #log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
    log4j.rootCategory=debug, CONSOLE, LOGFILE
    # Set the enterprise logger category to FATAL and its only appender to CONSOLE.
    log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
    # CONSOLE is set to be a ConsoleAppender using a PatternLayout.
    log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
    log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
    log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
    # LOGFILE is set to be a File appender using a PatternLayout.
    log4j.appender.LOGFILE=org.apache.log4j.FileAppender
    log4j.appender.LOGFILE.File=d:/axis.log
    log4j.appender.LOGFILE.Append=true
    log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
    log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

User及UserDao，Book及BookDao参照上期不变，包括数据库表结构都与上期相同，类太多了就不重复列举了。  
[对象及dao接口参照地址][dao]

测试类只是调整了引用包路径，原来引用的是mybatis下，现在是自定义。

package com.mybatis.test;
    
    
    import com.zrj.dao.BookDao;
    import com.zrj.dao.UserDao;
    import com.zrj.domain.Book;
    import com.zrj.domain.User;
    import com.zrj.mybatis.io.Resources;
    import com.zrj.mybatis.sqlsession.SqlSession;
    import com.zrj.mybatis.sqlsession.SqlSessionFactory;
    import com.zrj.mybatis.sqlsession.SqlSessionFactoryBuilder;
    import org.junit.Test;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.List;
    
    /** * myBatis测试类 * * @author zrj * @date 2020/12/23 * @since V1.0 **/
    public class MyBatisTest { 
    
        /** * mybatis测试 * 基于配置文件 * * @throws IOException */
        @Test
        public void myBatisTest() throws IOException { 
            // 1.读取配置文件
            InputStream in = Resources.getResourceAsStream( "SqlMapConfig.xml" );
    
            // 2.创建SqlSessionFactory工厂，初始化xml配置文件，转换为Configuration对象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            SqlSessionFactory factory = builder.build( in );
    
            // 3.使用工厂生产SQLSession对象，创建连接，事务等
            SqlSession session = factory.openSession();
    
            // 4.使用SQLSession创建Dao接口的代理对象，通过反射获取都太代理对象
            UserDao userDao = session.getMapper( UserDao.class );
    
            // 5.使用代理对象执行方法，执行动态sql，封装结果集ResultSet
            List<User> userList = userDao.findAll();
            System.out.println( "-----------mybatis查询---------" );
            userList.forEach( System.out::println );
    
            // 6.释放资源
            session.close();
            in.close();
        }
    
    
        /** * mybatis测试 * 基于注解 * * @throws IOException */
        @Test
        public void myBatisAnnoTest() throws IOException { 
            // 1.读取配置文件
            InputStream in = Resources.getResourceAsStream( "SqlMapConfig.xml" );
    
            // 2.创建SqlSessionFactory工厂
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            SqlSessionFactory factory = builder.build( in );
    
            // 3.使用工厂生产SQLSession对象
            SqlSession session = factory.openSession();
    
            // 4.使用SQLSession创建Dao接口的代理对象
            BookDao bookDao = session.getMapper( BookDao.class );
    
            // 5.使用代理对象执行方法
            List<Book> bookList = bookDao.findAll();
            System.out.println( "-----------mybatis查询---------" );
            bookList.forEach( System.out::println );
    
            // 6.释放资源
            session.close();
            in.close();
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/aa34491a6e5c4ce2b9bd9be8e8416913.png
[dao]: https://blog.csdn.net/m0_37583655/article/details/111602492