Java培训：MyBatis进阶之自定义MyBatis框架

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

　　2. 自定义框架原理介绍

　　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的核心代码;

　　包结构参考：

　　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();
    }