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

2. 自定义框架原理介绍

3. 准备工作：

1) 创建maven工程

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

2) 添加pom依赖：

    mysql
    mysql-connector-java
    8.0.15


    log4j
    log4j
    1.2.12


    junit
    junit
    4.12


    dom4j
    dom4j
    1.6.1


    jaxen
    jaxen
    1.1.6


    org.projectlombok
    lombok
    1.18.12

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 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 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 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 
     * @return
     */
    public  List 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 list = new ArrayList();//定义返回值
            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 
     * @return
     */
    public  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 
     * @return
     * @throws Exception
     */
    private  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 
     * @return
     */
     T getMapper(Class 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 
     * @return
     */
    public  T getMapper(Class 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 users = userDao.findAll();
        for(User user : users){
            System.out.println(user);
        }
        //6.释放资源
        session.close();
        in.close();
    }