自定义Mybatis框架

Posted 2021-02-17 萌胖胖

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了自定义Mybatis框架相关的知识，希望对你有一定的参考价值。

项目结构:

https://files-cdn.cnblogs.com/files/mkl7/ownMybatis.zip

1. 创建maven工程并引入坐标:

<?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.mkl</groupId>
    <artifactId>ownMybatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
        <!--dom4j是一个Java的XML API，是jdom的升级品，用来读写XML文件的。-->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <!--Jaxen是一个Java编写的开源的XPath库。
        这是适应多种不同的对象模型，包括DOM，XOM，dom4j和JDOM。
        也可以作为适配器，转换Java字节代码或XML的Java bean为xml，
        从而使您可以使用XPath查询这些树了。-->
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>
    </dependencies>

</project>

2. 创建实体类User

package com.mkl.domain;

import java.io.Serializable;
import java.util.Date;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:12:34
 */

public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    public Integer getId () {
        return id;
    }

    public void setId (Integer id) {
        this.id = id;
    }

    public String getUsername () {
        return username;
    }

    public void setUsername (String username) {
        this.username = username;
    }

    public Date getBirthday () {
        return birthday;
    }

    public void setBirthday (Date birthday) {
        this.birthday = birthday;
    }

    public String getSex () {
        return sex;
    }

    public void setSex (String sex) {
        this.sex = sex;
    }

    public String getAddress () {
        return address;
    }

    public void setAddress (String address) {
        this.address = address;
    }

    @Override
    public String toString () {
        return "User{" +
                "id=" + id +
                ", username=\'" + username + \'\\\'\' +
                ", birthday=" + birthday +
                ", sex=\'" + sex + \'\\\'\' +
                ", address=\'" + address + \'\\\'\' +
                \'}\';
    }
}

3. 编写DAO层接口

package com.mkl.dao;

import com.mkl.domain.User;

import java.util.List;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:12:48
 * 用户的持久层接口
 */

public interface IUserDao {

    /**
     * 查询所有用户
     */
    List<User> findAll();
}

4.编写主配置文件SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <environments default="MySql">
        <environment default="MySql">
            <transactionManager type="JDBC">
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver" />
                    <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatisdb" />
                    <property name="username" value="root" />
                    <property name="password" value="root" />
                </dataSource>
            </transactionManager>
        </environment>
    </environments>

    <mappers>
        <mapper resource="com/mkl/dao/IUserDao.xml"></mapper>
    </mappers>
</configuration>

5. 编写映射配置文件, 注意目录 IUserDao.xml

<?xml version="1.0" encoding="utf-8" ?>
<mapper namespace="com.mkl.dao.IUserDao">
    <selsect id="findAll" resultType="com.mkl.domain.User">
        select * from user
    </selsect>
</mapper>

6. 编写映射配置文件对应的实体类

package com.mkl.config;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:01
 */

public class Mapper {
    private String SQL;  //sql语句
    private String resultType; //返回值类型

    public String getSQL () {
        return SQL;
    }

    public void setSQL (String SQL) {
        this.SQL = SQL;
    }

    public String getResultType () {
        return resultType;
    }

    public void setResultType (String resultType) {
        this.resultType = resultType;
    }
}

7. 编写主配置文件对应的实体类

package com.mkl.config;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:01
 */

public class Configuration {
    private  String driver;
    private  String url;
    private String username;
    private String password;

    private Map<String,Mapper> mappers=new HashMap<String, Mapper> ();

    public String getDriver () {
        return driver;
    }

    public void setDriver (String driver) {
        this.driver = driver;
    }

    public String getUrl () {
        return url;
    }

    public void setUrl (String url) {
        this.url = url;
    }

    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 Map<String, Mapper> getMappers () {
        return mappers;
    }

    public void setMappers (Map<String, Mapper> mappers) {
        this.mappers = mappers;
    }
}

8. 编写Resources用于读取配置文件使用类加载器读取配置文件的类

　　根据传入的filePath参数,读取文件,获取字节输入流,并返回

package com.mkl.mybatis.io;

import java.io.InputStream;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:08
 * 使用类加载器读取配置文件的类
 */

public class Resources {

    /**
     * 根据传入的参数,读取文件,获取字节输入流
     * @param filePath
     * @return
     */
    public  static InputStream getResourceAsStream(String filePath){
        return Resources.class.getClassLoader ().getResourceAsStream (filePath);
    }
}

9. 创建与数据库交互的核心接口 : SqlSession 它里面可以创建DAO接口的代理对象

package com.mkl.mybatis.sqlsession;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:17
 * 自定义Mybatis中与数据库交互的核心类
 * 它里面可以创建DAO接口的代理对象
 */

public interface SqlSession {

    /**
     * 根据参数创建dao接口的代理对象
     * @param daoInterfaceClass
     * @param <T>
     * @return
     */
    <T> T getMapper(Class<T> daoInterfaceClass);

    /**
     * 释放资源
     */
    void close();
}

9.1 编写SqlSession的实现类DefaultSqlSession

　　实现类DefaultSqlSession中的类成员变量:

　　　　private Configuration cfg;

　　　　　　cfg通过构造方法传入

　　　　private Connection connection;

　　　　　　connection通过在构造方法中, 使用创建数据源的工具类来获取一个连接

　　在实现类中获取dao接口的实现类,使用Proxy.newProxyInstance 动态代理

　　其参数:

　　　　类加载器使用和被代理对象相同的类加载器 daoInterfaceClass.getClassLoader()

　　　　代理类的接口列表字节码数组 new Class[]{daoInterfaceClass}

　　　　InvocationHandler : 用于提供增强的代码 new MapperProxy(cfg.getMappers(),connection)

　　　　　　此处自己编写实现类MapperProxy实现InvocationHandler接口

　　　　　　该实现类就是用于对方法进行增强的，我们的增强其实就是调用Executor执行器的selectList方法

　　　　　　　　 (Executor: 用于实现 SQL 语句的执行，主要是调用 JDBC 来实现 SQL 语句的执行)

　　　　　　在增强(invoke方法)中:

　　　　　　　　需要获取代理类调用的方法名称和方法所在类的全限定类名

　　　　　　　　　　method.getName();

　　　　　　　　　　method.getDeclaringClass().getName();

　　　　　　　　对以上两者进行组合得到 key

　　　　　　　　　key =　className+"."+methodName

　　　　　　　　然后从主配置文件对应的实体类(Configuration)中存贮的映射配置文件的实体类的Map(mappers)中

　　　　　　　　　　(该Configuration的一个实例cfg存储在DefaultSqlSession中,为类成员变量, 通过DefaultSqlSession类的构造方法传入,

　　　　　　　　　　cfg.getMappers()作为参数,将获取到的mappers传给MapperProxy的实例)

　　　　　　　　根据key 获取dao层接口的对应的映射文件的实体类mapper , mapper中封装着执行的SQL语句和结果类型的全限定类名

　　　　　　　　然后调用工具类执行查询所有将获取到的mapper和数据库连接conn 做参数传进去并将结果返回

　　　　　　　　return new Executor().selectList(mapper,conn);

9.1.1编写DefaultSqlSession

package com.mkl.mybatis.sqlsession.defaults;

import com.mkl.config.Configuration;
import com.mkl.mybatis.Utils.DataSourceUtil;
import com.mkl.mybatis.proxy.MapperProxy;
import com.mkl.mybatis.sqlsession.SqlSession;

import java.lang.reflect.Proxy;
import java.sql.Connection;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:28
 */

public class DefaultSqlSession implements SqlSession {
    private Configuration cfg;
    private Connection conn;

    public DefaultSqlSession (Configuration cfg) {
        this.cfg =
        conn= DataSourceUtil.getConnection (cfg);
    }

    /**
     * 根据参数创建代理对象
     * @param daoInterfaceClass
     * @param <T>
     * @return
     */
    public <T> T getMapper (Class<T> daoInterfaceClass) {
        return (T)Proxy.newProxyInstance (daoInterfaceClass.getClassLoader (),
                new Class[]{daoInterfaceClass},new MapperProxy (cfg.getMappers (),conn));
    }

    public void close () {
　　　　　if(conn!=null){
　　　　　　try{
　　　　　　　　conn.close();
　　　　　　}catch(Exeception e){
　　　　　　　　e.printStackTrace();
　　　　　　}
　　　　　}
}

9.1.2编写MapperProxy

package com.mkl.mybatis.proxy;

import com.mkl.config.Mapper;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.util.Map;
import java.util.concurrent.Executor;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:15:17
 */

public class MapperProxy implements InvocationHandler {
    private Connection conn;
    private Map<String, Mapper> mappers;

    public MapperProxy (Map<String, Mapper> mappers, Connection conn) {
            this.conn = conn;
            this.mappers = mappers;
    }

    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获取mappers中的mapper对象
        Mapper mapper = mappers.get (key);
        //5. 判断是否有mapper
        if (mapper==null){
            throw  new IllegalArgumentException ("参数有误,为获取到对应的mapper");
        }
        //6. 调用工具类执行查询所有
        return new Executor ().selectList(mapper,conn);
    }
}

9.1. 3编写用于创建数据源的工具类,用于获取连接

package com.mkl.mybatis.Utils;

import com.mkl.config.Configuration;

import java.sql.Connection;
import java.sql.DriverManager;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:52
 * 用于创建数据源的工具类
 */

public class DataSourceUtil {

    /**
     * 用于获取一个连接
     * @param config
     * @return
     */
    public static Connection getConnection (Configuration config){
        try {
            Class.forName (config.getDriver ());//加载驱动
            //获取连接并返回
            return DriverManager.getConnection (config.getUrl (),config.getUsername (),config.getPassword ());
        }catch (Exception e){
            throw  new RuntimeException (e);
        }
    }
}

9.1.4 编写Executor 负责执行SQL语句，并且封装结果集

package com.mkl.mybatis.Utils;

import com.mkl.config.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;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:15:28
 */

public class Executor {
    public <E>List<E> selectList(Mapper mapper, Connection conn){
        PreparedStatement pstm=null;
        ResultSet rs=null;
        try {
            //1. 取出mapper中的数据
            String SQL=mapper.getSQL (); //select *from user
            String resultType=mapper.getResultType ();//com.mlk.domain.User
            Class domainClass=Class.forName (resultType);
            //2. 获取PreparedStatement对象
            pstm= conn.prepareStatement (SQL);
            //3. 执行SQL语句 获取结果集
            rs= pstm.executeQuery ();
            //4. 封装结果集
            List<E> list=new ArrayList<E> ();//定义返回值
            while (rs.next ()){
                //实例化要封装的实体类对象
                E obj= (E)domainClass.newInstance ();

                //取出结果集的元信息
                ResultSetMetaData resultSetMetaData= rs.getMetaData ();
                //取出总列数
                int columnCount= resultSetMetaData.getColumnCount ();
                //遍历
                for (int i=1;i<=columnCount;i++) {
                    //获取每列的名称, 列名的序号是从1开始的
                    String columnName=resultSetMetaData.getColumnName (i);
                    //根据得到的列名获取每列的值
                    Object columnValue = rs.getObject (columnName);
                    //给obj赋值: 使用java内省机制(借助PropertyDescriptor实现属性的封装)
                    PropertyDescriptor pd=new PropertyDescriptor (columnName,domainClass);//要求: 实体类的属性和数据库表的列名保持一致
                    //获取他的写入方法
                    Method writeMethod = pd.getWriteMethod ();
                    //把获取的列的的 给对象赋值
                    writeMethod.invoke (obj,columnValue);
                }
                //把赋好值的对象加到集合中
                list.add (obj);
            }
            return  list;
        }catch (Exception e){
            throw  new RuntimeException (e);
        }finally {
            release (pstm,rs);
        }
    }

    private void release(PreparedStatement pstm, ResultSet rs){
        if (rs!=null){
            try {
                rs.close ();
            }catch (Exception e){
                e.printStackTrace ();
            }
        }
    }
}

10. 编写工厂接口: SqlSessionFactory 创建SqlSession对象

提供返回值SqlSession 的openSession方法

package com.mkl.mybatis.sqlsession;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:17
 */

public interface SqlSessionFactory {

    /**
     * 用于打开一个新的SqlSession对象
     */
    SqlSession openSession();
}

10.1 编写工厂接口 SqlSessionFactory的实现类 DefaultSqlSessionFactory

package com.mkl.mybatis.sqlsession.defaults;

import com.mkl.config.Configuration;
import com.mkl.mybatis.sqlsession.SqlSession;
import com.mkl.mybatis.sqlsession.SqlSessionFactory;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:29
 */

public class DefaultSqlSessionFactory implements SqlSessionFactory {

    private Configuration configuration;

    public DefaultSqlSessionFactory (Configuration configuration) {
        this.configuration = configuration;
    }

    /**
     *  用于打开一个新的SqlSession对象
     * @return
     */
    public SqlSession openSession () {
        return new DefaultSqlSession (configuration);
    }
}

11. 编写SqlSessionFactoryBuilder 用于构建SqlSessionFactory工厂

　　根据传入的字节输入流参数, 读取主配置文件, 并返回主配置文件对应的实体类
　　根据此主配置文件的实体类, 创建SqlSessionFactory工厂并返回

package com.mkl.mybatis.sqlsession;

import com.mkl.config.Configuration;
import com.mkl.mybatis.Utils.XMLConfigBuilder;
import com.mkl.mybatis.sqlsession.defaults.DefaultSqlSessionFactory;

import java.io.InputStream;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:16
 * 用于创建一个SqlSessionFactory对象
 */

public class SqlSessionFactoryBuilder {

    /**
     * 根据传入的字节输入流, 读取主配置文件, 并返回主配置文件对应的实体类
     * 根据此主配置文件的实体类, 创建SqlSessionFactory工厂并返回
     * @param config
     * @return
     */
    public SqlSessionFactory build(InputStream config){
        Configuration configuration= XMLConfigBuilder.loadConfiguration (config);
        return  new DefaultSqlSessionFactory(coniguration);
    }
}

11.1XMLConfigBuilder用于解析配置文件

package com.mkl.mybatis.Utils;

import com.mkl.config.Configuration;
import com.mkl.config.Mapper;
import com.mkl.mybatis.io.Resources;
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.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 *  用于解析配置文件
 */
public class XMLConfigBuilder {

    /**
     * 解析主配置文件，把里面的内容填充到DefaultSqlSession所需要的地方
     * 使用的技术：
     *      dom4j+xpath
     */
    public static Configuration loadConfiguration(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)){
                    //表示密码
                    MyBatis进阶之自定义MyBatis框架
 如何自定义MyBatis框架
 阶段3 1.Mybatis_04.自定义Mybatis框架基于注解开发_2 回顾自定义mybatis的流程分析
 自定义 Mybatis 框架
 《Java手写系列》-手写MyBatis框架
 [mybatis]动态sql_sql_抽取可重用的sql片段