MyBatis--03自定义MyBatis的实现

以下操作在MyBatis–01入门案例的基础上修改。

在原案例基础上修改

修改的地方有：

(1)删除mybatis依赖

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.5</version>
</dependency>

(2)新增dom4j和jaxen依赖

<!--        dom4j依赖-->
<dependency>
    <groupId>dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>1.6</version>
</dependency>
<!--        xpath依赖-->
<dependency>
    <groupId>jaxen</groupId>
    <artifactId>jaxen</artifactId>
    <version>1.2.0</version>
</dependency>

(3)删除SqlMapConfig.xml中头部约束，因为不使用原生mybatis了

删除的内容

<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

(4)删除IUserMapper.xml中头部约束

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

自定义MyBatis实现的主要需求

(1)读取SqlMapConfig.xml文件，获取数据库连接信息。通过连接信息创建Connection对象；获取mappers标签，并判断其中mapper标签的属性是resource还是class，如果是resource，代表着自定义mybatis是通过读取xml文件的方式获取映射配置信息（具体的方式是通过dom4j技术），如果是class，则代表映射信息配置是用注解的方式实现。

(2)创建SqlSessionFactoryBuilder类，构建SqlSessionFactory工厂

(3)创建SqlSessionFactory接口，打开一个新的SqlSession对象

(4)创建DefaultSqlSessionFactory类，作为SqlSessionFactory接口的实现类

分析测试代码

//1.读取mybatis核心配置文件
InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.创建工厂对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory sessionFactory = builder.build(in);
//3.通过工厂对象构建SqlSession对象
SqlSession sqlSession = sessionFactory.openSession();
//4.通过SqlSession对象创建代理对象
IUserDao userDao = sqlSession.getMapper(IUserDao.class);
//5.执行代理对象的方法
List<User> userList = userDao.findAll();
System.out.println(userList);
//6.释放资源
sqlSession.close();
in.close();

运行mybatis需要涉及到类包括

• Class Resources

• Class SqlSessionFactoryBuilder

• Interface SqlSessionFactory

• Interface SqlSession

自定义MyBatis代码实现

新建类Resources，读取mybatis核心配置

package com.cncs.mybatis.io;

import java.io.InputStream;

/**
 * 使用类加载器读取mybatis核心配置文件
 */
public class Resources {
    /**
     * 根据文件名，获取一个字节输入流
     * @param filePath
     * @return
     */
    public static InputStream getResourceAsStream(String filePath){
        //通过类的字节码获取字节码加载器，然后获取字节输入流
        return Resources.class.getClassLoader().getResourceAsStream(filePath);
    }
}

新建类SqlSessionFactoryBuilder作为构建者，构建一个SqlSessionFactory工厂

package com.cncs.mybatis.session;

import com.cncs.mybatis.cfg.Configuration;
import com.cncs.mybatis.session.defaults.DefaultSqlSessionFactory;
import com.cncs.mybatis.utils.XMLConfigBuilder;

import java.io.InputStream;
/**
 * 构建SqlSessionFactory工厂
 */
public class SqlSessionFactoryBuilder {

    /**
     * 根据参数创建SqlSessionFactory工厂
     * @param cfg 字节输入流
     * @return SqlSessionFactory工厂
     */
    public SqlSessionFactory build(InputStream cfg){
        Configuration configuration = XMLConfigBuilder.loadConfiguration(cfg);
        return new DefaultSqlSessionFactory(configuration);
    }
}

利用提供的工具类XMLConfigBuilder读取xml配置信息，获取数据库连接信息，mapper映射配置信息，并将信息填充到Configuration对象中，在实例化SqlSessionFactory工厂时作为参数传入。

新建Configuration对象，记录数据库连接信息，Mappers映射配置信息

package com.cncs.mybatis.cfg;

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

/**
 * 自定义mybatis的配置类
 */
public class Configuration {
    private String username;
    private String password;
    private String url;
    private String driver;
    private Map<String,Mapper> mappers = new HashMap<String, Mapper>();

    public Map<String, Mapper> getMappers() {
        return mappers;
    }

    public void setMappers(Map<String, Mapper> mappers) {
        this.mappers.putAll(mappers);//从指定映射中将所有映射关系复制到此映射中
    }

    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 String getUrl() {
        return url;
    }

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

    public String getDriver() {
        return driver;
    }

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

新建Mapper类，记录从IUserMapper.xml读取的sql语句，方法id，返回类型。

package com.cncs.mybatis.cfg;

/**
 * 封装要执行的sql语句和封装结果的全限定类名
 */
public class Mapper {
    private String queryString;//sql
    private String resultType;//封装结果的全限定类名

    public String getQueryString() {
        return queryString;
    }

    public void setQueryString(String queryString) {
        this.queryString = queryString;
    }

    public String getResultType() {
        return resultType;
    }

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

新建接口SqlSessionFactory，用于生产SqlSession

package com.cncs.mybatis.session;

public interface SqlSessionFactory {
    /**
     * 打开一个新的SqlSession对象
     * @return
     */
    public SqlSession openSession();
}

新建SqlSessionFactory实现类DefaultSqlSessionFactory，用于生产SqlSession

package com.cncs.mybatis.session.defaults;

import com.cncs.mybatis.cfg.Configuration;
import com.cncs.mybatis.session.SqlSession;
import com.cncs.mybatis.session.SqlSessionFactory;

/**
 * SqlSessionFactory的实现类
 */
public class DefaultSqlSessionFactory implements SqlSessionFactory {

    private Configuration configuration;

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

    /**
     * 创建一个与数据库交互的核心对象
     * @return
     */
    public SqlSession openSession() {
        try{
            return new DefaultSqlSession(configuration);
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

新建接口SqlSession，和数据库交互

package com.cncs.mybatis.session;

/**
 * 自定义mybatis中和数据库交互的核心类
 * 可以创建dao的代理对象
 */
public interface SqlSession {

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

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

新建接口SqlSession的实现类，和数据库交互

package com.cncs.mybatis.session.defaults;

import com.cncs.mybatis.cfg.Configuration;
import com.cncs.mybatis.cfg.Mapper;
import com.cncs.mybatis.proxy.MapperProxy;
import com.cncs.mybatis.session.SqlSession;
import com.cncs.mybatis.utils.DataSourceUtil;

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

/**
 * SqlSession的实现类
 */
public class DefaultSqlSession implements SqlSession {

    private Map<String, Mapper> mappers;
    private Connection connection;

    public DefaultSqlSession(Configuration configuration) throws Exception {
        this.connection = DataSourceUtil.getConnection(configuration);
        this.mappers = configuration.getMappers();
    }

    /**
     * 创建代理对象
     * @param daoInterfaceClass dao接口的字节码
     * @param <T> 代理对象
     * @return
     */
    public <T> T getMapper(Class<T> daoInterfaceClass) {
        return (T) Proxy.newProxyInstance(daoInterfaceClass.getClassLoader(), new Class[]{daoInterfaceClass}, new MapperProxy(mappers,connection));
    }

    /**
     * 释放资源
     */
    public void close() {
        if(connection!=null){
            try{
                connection.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

新建DataSourceUtil类，获取Connection对象

package com.cncs.mybatis.utils;

import com.cncs.mybatis.cfg.Configuration;

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

public class DataSourceUtil {

    public static Connection getConnection(Configuration cfg) throws Exception{
        //注册驱动
        Class.forName(cfg.getDriver());
        //获取连接
        return DriverManager.getConnection(cfg.getUrl(), cfg.getUsername(), cfg.getPassword());
    }

}

新建InvocationHandler接口的实现类MapperProxy，它是用于代理对象方法代码的增强

package com.cncs.mybatis.proxy;

import com.cncs.mybatis.cfg.Configuration;
import com.cncs.mybatis.cfg.Mapper;
import com.cncs.mybatis.utils.Executor;

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

/**
 * 方法增强的实现类
 */
public class MapperProxy implements InvocationHandler {

    private Connection connection;
    private Map<String, Mapper> mappers;

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

    /**
     * 代码增强，实现selectList()
     *
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //获取方法名
        String methodName = method.getName();
        //获取全限定类名
        String className = method.getDeclaringClass().getName();
        //组合key
        String key = className + "." + methodName;
        //查找mapper
        Mapper mapper = mappers.get(key);
        //判断mapper是否为空
        if(mapper == null){
            throw new IllegalArgumentException("传入的参数有误");
        }
        //调用工具类查询所有
        return new Executor().selectList(mapper, connection);
    }
}

通过Executor类提供的selectList方法实现对数据的查找。

使用注解的方式实现

在上面代码的基础上修改。

修改SqlMapConfig.xml中mappers标签中内容

<!--        <mapper resource="com/cncs/dao/IUserMapper.xml"/>-->
<mapper class="com.cncs.dao.IUserDao"/>

添加注释IUserDao接口中的findAll方法添加注解

@Select("select * from user")

新建Select接口

package com.cncs.mybatis.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 查询的注解
 */
@Retention(RetentionPolicy.RUNTIME)//生命周期：运行时可用
@Target(ElementType.METHOD)//作用范围：方法上可用
public @interface Select {

    /**
     * sql语句
     * @return
     */
    String value();
}