MyBatis进阶之自定义MyBatis框架

妖狐艹你老母 2024-04-01 10:13 73阅读 0赞

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

![e91db037b06b45d187a04130509a961a.png][]

### 2. 自定义框架原理介绍 ###

![5a24c95d5a2b4339bbbaf6fe00248b8b.png][]

![1a3747ae51fc4fedb4c1ad766d19319d.png][]

### 3. 准备工作： ###

#### 1) 创建maven工程 ####

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

#### 2) 添加pom依赖： ####

```xml
    <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的核心代码；

\*\***包结构参考：**\*\*

![c810b7e1d5034e568b7d8948de39a07a.png][]

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

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

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

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

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

```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\` ####

```java
    /**
     *  用于解析配置文件:
     *      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\` ####

```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\` ####

```java
    /**
     * 用于创建数据源的工具类
     */
    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`**
    
    ```java
    public interface SqlSession {
    
        /**
         * 获取mapper代理对象
         * @param clzz
         * @param <T>
         * @return
         */
        <T> T getMapper(Class<T> clzz) ;
    
        /**
         * 释放资源
         */
        void close();
    
    }
    ```
    
    **实现类`DefaultSqlSession.java`**
    
    ```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\` ####

```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`**
    
    ```java
    /**
     * SqlSession工厂
     */
    public interface SqlSessionFactory {
    
        /**
         * 创建session
         * @return
         */
        public SqlSession openSession();
    }
    ```
    
    **实现类`DefaultSqlSessionFactory.java`**
    
    ```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工厂的构建者类 ####

```java
    /**
     * 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的！
    
    **测试代码：**
    
    ```java
        /**
         * 测试代码
         */
        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();
        }
    ```

[e91db037b06b45d187a04130509a961a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/eb6723844fe147daa9b4ef31292011f2.png
[5a24c95d5a2b4339bbbaf6fe00248b8b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/12b87f58d7f3400e8dbb277f911024af.png
[1a3747ae51fc4fedb4c1ad766d19319d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/53ddba72802b4fd29484e713fe08db2f.png
[c810b7e1d5034e568b7d8948de39a07a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c154b2ed27334d63ab6b308438b8d79c.png