MyBatis进阶之自定义MyBatis框架

水深无声 2023-10-10 15:12 73阅读 0赞

1. 自定义MyBatis框架流程分析

![f168255bcead371a2517bacbd666a3f7.jpeg][]

2. 自定义框架原理介绍

![507bd9c734f5dca7e5cbc720638e775c.jpeg][]

![047cc7b4665f065e17f74425d47da8c2.jpeg][]

3. 准备工作：

1) 创建maven工程

Groupid:com.itheima
    ArtifactId:custom-mybatis
    Packing:jar

2) 添加pom依赖：

<dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.15</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>dom4j</groupId>
        <artifactId>dom4j</artifactId>
        <version>1.6.1</version>
    </dependency>
    <dependency>
        <groupId>jaxen</groupId>
        <artifactId>jaxen</artifactId>
        <version>1.1.6</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>

4. 自定义MyBatis框架的实现步骤

需要定义的类的分析：

1.加载类加载目录下的资源文件 \`Resources.java\`

2. 映射文件解析后信息类 \`Mapper.java\`

3. 保存配置文件的配置信息 \`Configuration.java\`

4. 配置文件解析的工具类\`XMLConfigBuilder.java\`

5. SQL语句的执行对象\`Executor.java\`

6. 获取数据源的工具类\`JdbcUtil.java\`

7. \`SqlSession\`接口及实现类

8. \`SqlSessionFactory\`接口及实现类

9. \`SqlSessionFactory\`的构建者类\`SqlSessionFactoryBuilder.java\`

10. 动态代理的处理类\`MapperProxyFactory.java\`

两大步：

> 1-4 : 是我们前面提到的 解析xml,封装对象;

> 5-10： 是得到sqlsession，获取代理对象，执行sql的核心代码;

包结构参考：

![1f1917e1447f05a09ba13ec54f66f843.jpeg][]

1)定义加载资源类\`Resources.java\`

/**
     * 加载资源的工具类
     */
    public class Resources {
    
        /**
         * 加载类加载目录下的资源
         * @param path
         * @return
         */
        public static  InputStream getResourceAsStream(String path){
            return Resources.class.getClassLoader().getResourceAsStream(path);
        }
    }

2)定义mybatis映射配置信息类 \`Mapper.java\`

/**
     * 映射的配置信息类
     */
    @Data
    public class Mapper {
    
        private String queryString;// SQL语句
    
        private String resultType;// 实体类全限定名
    
       
    }

3)定义mybatis核心配置信息类 \`Configuration.java\`

/**
     * mybatis配置的实体类
     * 用来保存mybatis.xml解析过程中的节点属性
     */
    @Data
    public class Configuration {
    
        private String driver;      //jdbc驱动类
        private String url;         //jdbc连接字符串
        private String username;    //数据库连接用户名
        private String password;    //数据库连接密码
    
        private Map<String, Mapper> mappers = new HashMap<String, Mapper>();//映射文件
       
        public void setMappers(Map<String, Mapper> mappers) {
            this.mappers.putAll(mappers);//此处需要使用追加的方式
        }
     
    }

4)配置文件解析的工具类\`XMLConfigBuilder\`

/**
     *  用于解析配置文件:
     *      sqlmapconfig.xml
     *      xxxMapper.xml
     */
    public class XMLConfigBuilder {
    
        //定义封装连接信息的配置对象（mybatis的配置对象）
        private static Configuration cfg = new Configuration();
    
        /**
         * 解析主配置文件，把里面的内容填充到DefaultSqlSession所需要的地方
         * 使用的技术：dom4j+xpath
         */
        public static Configuration loadConfiguration(InputStream config){
            try{
    
                //1.获取SAXReader对象
                SAXReader reader = new SAXReader();
                //2.根据字节输入流获取Document对象
                Document document = reader.read(config);
                //3.获取根节点
                Element root = document.getRootElement();
    
                //4. 解析数据源信息
                loadDataSourceElement(root);
    
                //5. 加载mapper
                loadMapperElement(root);
    
                //6. 返回Configuration
                return cfg;
    
            }catch(Exception e){
                throw new RuntimeException(e);
            }finally{
                try {
                    config.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
    
        }
    
        /**
         * 解析数据源信息
         */
        public static void loadDataSourceElement(Element root) {
            //1.使用xpath中选择指定节点的方式，获取所有property节点
            List<Element> propertyElements = root.selectNodes("//property");
            //2.遍历节点
            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);
                }
            }
        }
    
    
        /**
         * 加载mapper
         */
        public static void loadMapperElement(Element root) throws Exception {
            //取出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方式mapper----");
                    //表示有resource属性，用的是XML
                    //取出属性的值
                    String mapperPath = attribute.getValue();//获取属性的值"com/itheima/dao/IUserDao.xml"
                    //把映射配置文件的内容获取出来，封装成一个map
                    Map<String,Mapper> mappers = loadMapperConfiguration(mapperPath);
                    //给configuration中的mappers赋值
                    cfg.setMappers(mappers);
                }
            }
        }
    
    
    
        /**
         * 根据传入的参数，解析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属性取值
                String namespace = root.attributeValue("namespace");//是组成map中key的部分
                //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();
            }
        }
    
    }

5)SQL语句的执行对象\`Executor.java\`

/**
     * 负责执行SQL语句，并且封装结果集
     */
    public class Executor {
    
        /**
         * 根据mapper查询多条数据
         * @param mapper
         * @param conn
         * @param <E>
         * @return
         */
        public <E> List<E> selectList(Mapper mapper, Connection conn) {
            PreparedStatement pstm = null;
            ResultSet rs = null;
            try {
                //1.取出mapper中的数据
                String queryString = mapper.getQueryString();//select * from user
                String resultType = mapper.getResultType();//com.itheima.domain.User
                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()) {
                    //将结果集中的数据封装到实体中
                    E obj = extraction(rs, domainClass);
                    //把赋好值的对象加入到集合中
                    list.add(obj);
                }
                return list;
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                release(conn, pstm, rs);
            }
        }
    
        /**
         * 根据mapper查询数据,查询一条数据,如果结果集中有多条数据,返回第一条数据封装的实体对象
         * @param mapper
         * @param conn
         * @param <E>
         * @return
         */
        public <E> E selectOne(Mapper mapper, Connection conn) {
            PreparedStatement pstm = null;
            ResultSet rs = null;
            try {
                //1.取出mapper中的数据
                String queryString = mapper.getQueryString();//select * from user where id = ?
                String resultType = mapper.getResultType();//com.itheima.domain.User
                Class domainClass = Class.forName(resultType);
                //2.获取PreparedStatement对象
                pstm = conn.prepareStatement(queryString);
                //3.执行SQL语句，获取结果集
                rs = pstm.executeQuery();
                //4.封装结果集
                if (rs.next()) {
                    //将结果集中的数据封装到实体中
                    E obj = extraction(rs, domainClass);
                    return obj;
                }
                return null;
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                release(conn, pstm, rs);
            }
        }
    
        /**
         * 将结果集中的一条数据封装到实体对象中
         * @param rs
         * @param domainClass
         * @param <E>
         * @return
         * @throws Exception
         */
        private <E> E extraction(ResultSet rs,Class domainClass) throws Exception{
            //实例化要封装的实体类对象
            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();
                //把获取的列的值，给对象赋值
                writeMethod.invoke(obj, columnValue);
            }
    
            return  obj;
        }
    
        private void release(Connection conn, 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();
                }
            }
    
            if (conn != null) {
                try {
                    conn.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

6)编写获取数据源的工具类\`JdbcUtil\`

/**
     * 用于创建数据源的工具类
     */
    public class JdbcUtil {
    
        /**
         * 用于获取一个连接
         * @param cfg
         * @return
         */
        public static Connection getConnection(Configuration cfg){
            try {
                Class.forName(cfg.getDriver());
                return DriverManager.getConnection(cfg.getUrl(), cfg.getUsername(), cfg.getPassword());
            }catch(Exception e){
                throw new RuntimeException(e);
            }
        }
    }

7) 定义SqlSession的接口及实现类

接口\`SqlSession.java\`

public interface SqlSession {
    
        /**
         * 获取mapper代理对象
         * @param clzz
         * @param <T>
         * @return
         */
        <T> T getMapper(Class<T> clzz) ;
    
        /**
         * 释放资源
         */
        void close();
    
    }

实现类\`DefaultSqlSession.java\`

public class DefaultSqlSession implements SqlSession {
    
        private  Connection connection;
        private  Map<String, Mapper> mappers;
    
    
        /**
         * 创建SqlSession对象时,初始化执行器对象
         * @param mappers
         * @param connection
         */
        public DefaultSqlSession(Map<String, Mapper> mappers, Connection connection) {
            this.mappers = mappers ;
            this.connection = connection ;
        }
    
        /**
         * 获取持久层对象的代理对象
         *
         * @param clzz
         * @param <T>
         * @return
         */
        public <T> T getMapper(Class<T> clzz) {
            return (T) Proxy.newProxyInstance(clzz.getClassLoader(), new Class[]{clzz}, new MapperProxyFactory(connection,mappers));
        }
    
        @Override
        public void close() {
            if(connection!=null){
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    
    }

8) 编写动态代理的处理类\`MapperProxyFactory.java\`

/**
     * 创建代理对象的InvocationHandler的实现类
     */
    public class MapperProxyFactory implements InvocationHandler {
    
    
        private  Connection connection;
        private  Map<String, Mapper> mappers;
    
        public MapperProxyFactory(Connection connection, Map<String, Mapper> mappers) {
            this.connection = connection ;
            this.mappers = mappers ;
        }
    
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //1. 获取需要执行的sql语句
            //1.1 获取执行的方法名称----需要根据方法名称找到对应的需要执行的sql语句
            String methodName = method.getName();
            //1.2 获取方法所在类的全路径名称
            String className = method.getDeclaringClass().getName();
            //1.3 获取需要执行的statement
            String statment = className+"."+methodName;
            //1.4 获取返回值类型
            Class<?> type = method.getReturnType();
    
            //1.5 根据查询结果调用查询方法
            if(type == List.class){
                return new Executor().selectList(mappers.get(statment),connection);
            }
            if(type != List.class){
                return new Executor().selectOne(mappers.get(statment),connection);
            }
    
            return method.invoke(new Object(),args) ;
        }
    }

9) 创建SqlSessionFactory的接口及实现类

接口\`SqlSessionFactory.java\`

/**
     * SqlSession工厂
     */
    public interface SqlSessionFactory {
    
        /**
         * 创建session
         * @return
         */
        public SqlSession openSession();
    }

实现类\`DefaultSqlSessionFactory.java\`

/**
     * SqlSession工厂的实现类
     */
    public class DefaultSqlSessionFactory implements  SqlSessionFactory {
    
        /**
         * 配置文件的输入流
         */
        private  Configuration configuration;
    
        public DefaultSqlSessionFactory(Configuration configuration){
            this.configuration = configuration;
        }
    
        /**
         * 创建sqlSession
         * @return
         */
        public SqlSession openSession() {
            DefaultSqlSession sqlSession = new DefaultSqlSession(configuration.getMappers(), JdbcUtil.getConnection(configuration));
            return sqlSession;
        }
    }

10)定义SqlSession工厂的构建者类

/**
     * SqlSession工厂的构建者
     */
    public class SqlSessionFactoryBuilder {
    
        /**
         * 构建session工厂
         * @param is
         * @return
         */
        public SqlSessionFactory build(InputStream is){
            Configuration configuration = XMLConfigBuilder.loadConfiguration(is);
            DefaultSqlSessionFactory factory = new DefaultSqlSessionFactory(configuration);
            return factory;
        }
    
    }

11) 把自定义的mybatis打成jar：install

12) 测试自定义框架

\`\`\`

创建maven测试工程

引入依赖

打成jar文件的自定义MyBatis框架

mysql驱动

junit测试

引入配置文件:自定义mybatis一样,将resource中的文件复制一份

创建User实体类

\`\`\`

> 需求：

> 之前导入mybatis依赖能运行的项目，去掉mybatis，引入我们自定义的这个jar的依赖，如果能够成功运行，就代表自定义框架是OK的!

测试代码：

/**
         * 测试代码
         */
        public static void main(String[] args)throws Exception {
            //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接口的代理对象
            IUserDao userDao = session.getMapper(IUserDao.class);
            //5.使用代理对象执行方法
            List<User> users = userDao.findAll();
            for(User user : users){
                System.out.println(user);
            }
            //6.释放资源
            session.close();
            in.close();
        }

[f168255bcead371a2517bacbd666a3f7.jpeg]: https://img-blog.csdnimg.cn/img_convert/f168255bcead371a2517bacbd666a3f7.jpeg
[507bd9c734f5dca7e5cbc720638e775c.jpeg]: https://img-blog.csdnimg.cn/img_convert/507bd9c734f5dca7e5cbc720638e775c.jpeg
[047cc7b4665f065e17f74425d47da8c2.jpeg]: https://img-blog.csdnimg.cn/img_convert/047cc7b4665f065e17f74425d47da8c2.jpeg
[1f1917e1447f05a09ba13ec54f66f843.jpeg]: https://img-blog.csdnimg.cn/img_convert/1f1917e1447f05a09ba13ec54f66f843.jpeg