【04自定义Mybatis框架】判断用XML还是注解方式

谢谢点赞与关注

---

前言

在入门案例的前提下增加注解模式。
本章将会用之前的工厂模式、构造者模式、代理模式、自定义注解、注解的反射、xml解析来构建一个属于自己的持久层框架。

---

提示：需要数据库信息可以私信问我拿

一、前期准备

1.创建Maven工程并导入相关坐标

在SqlMapConfig下添加dom4j、jaxen依赖
代码如下（示例）：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--配置环境-->
    <environments default="mysql">
<!--        配置mysql环境-->
        <environment id="mysql">
<!--            配置事务类型-->
            <transactionManager type="JDBC"></transactionManager>
<!--            配置数据源（连接池）-->
            <dataSource type="POOLED">
<!--            配置连接数据库的四个基本信息-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test?characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
<!--    指定映射配置文件位置，映射配置文件指的是每个dao独立的配置文件-->
    <mappers>
<!--        <mapper resource="com/gzlg/dao/IUserDao.xml"></mapper>-->
<!--        注解-->
<!--        注解方式用class属性-->
        <mapper class="com.gzlg.dao.IUserDao"></mapper>
    </mappers>
</configuration>

2.将工具类导入项目中

2.1.解析主配置文件(XMLConfigBuilder)

代码如下（示例）：

package com.gzlg.mybatis.utils;

import com.gzlg.mybatis.annotations.Select;
import com.gzlg.mybatis.cfg.Configuration;
import com.gzlg.mybatis.cfg.Mapper;
import com.gzlg.mybatis.io.Resources;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class XMLConfigBuilder {
//    解析主配置文件，把里面的内容填充到DefaultSqlSession所需要的地方
//使用技术：dom4j+path
    public static Configuration loadConfiguration(InputStream config){
        try {
//        定义封装连接信息的配置对象（mybatis的配置对象）
            Configuration cfg = new Configuration();
            //        1.获取SAReader对象
            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)) {
                    //                密码
                    //                获取property标签value属性的值
                    String password = propertyElement.attributeValue("value");
                    cfg.setPassword(password);
                }
            }
            //        去除mappers中所有mappper标签，判断他们使用了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");
                    //                表示resource属性，使用的是XMl,取出属性值“com/gzlg/dao/IUserDao.xml
                    String mapperPath = attribute.getValue();
                    //                把映射配置文件的内容获取出来，封装成一个map
                    Map<String, Mapper> mappers = loadMapperConfiguration(mapperPath);
                    //                给configuration中的mappers赋值
                    cfg.setMappers(mappers);
                } else {
                        System.out.println("使用的是注解");
                    //                表示没有resource属性，用的是注解
                    //                获取class属性的值
                        String daoClassPath=mapperElement.attributeValue("class");
                    //                根据daoClassPath获取封装的必要信息
                        Map<String,Mapper>mappers=loadMapperAnnotation(daoClassPath);
                    //                给configuration中的mappers赋值
                        cfg.setMappers(mappers);
                }
            }
            //        返回configuration
            return cfg;
        }catch (Exception e){
            throw new RuntimeException(e);
        }finally {
            try {
                config.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }



    /**
     * 根据传入的参数，解析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比list查找速度快）
            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中key部分
                String resultType=selectElement.attributeValue("resultType");
//                取出文本内容sql语句
                String queryString=selectElement.getText();
//                创建key
                String key=namespace+"."+id;
//                创建value
                Mapper mapper=new Mapper();
                mapper.setQueryString(queryString);
                mapper.setResultType(resultType);
//                把key和value存入mapper中
                mappers.put(key,mapper);
            }
            return mappers;
        } catch(Exception e){
            throw new RuntimeException(e);
        }finally{
            in.close();
        }
    }

    /**
     * 根据传入的参数得到dao中所有被select注解标注的方法
     * 根据方法名称和类名，以及方法上注解value属性的值，组成Mapper的必要信息
     */
    private static Map<String, Mapper> loadMapperAnnotation(String daoClassPath) throws Exception {
//        定义返回值对象
        Map<String,Mapper> mappers=new HashMap<String, Mapper>();
//        1.得到dao接口的字节码对象
        Class daoClass=Class.forName(daoClassPath);
//        2.得到dao接口中的方法数组
        Method[] methods=daoClass.getMethods();
//        3.遍历Method数组
        for (Method method:methods){
//            取出每一个方法，判断是否有select注解
            boolean isAnnotated=method.isAnnotationPresent(Select.class);
            if (isAnnotated){
//                创建Mapper对象
                Mapper mapper=new Mapper();
//                取出注解的Value属性值
                Select selectAnno=method.getAnnotation(Select.class);
                String queryString=selectAnno.value();
                mapper.setQueryString(queryString);
//                获取当前方法的返回值，还要求必须带有泛型信息
                Type type=method.getGenericReturnType();//list<User>
//                判断type是不是参数化的类型
                if (type instanceof ParameterizedType){
//                    强转
                    ParameterizedType ptype=(ParameterizedType)type;
//                    得到参数化类型中的实际类型参数
                    Type[] types=ptype.getActualTypeArguments();//
//                    取出第一个
                    Class domainClass=(Class)types[0];
//                    获取domainClass的类名
                    String resultType=domainClass.getName();
//                    给Mapper赋值
                    mapper.setResultType(resultType);
                }
//                组装key的信息，获取方法的名称
                String methodName=method.getName();
                String className=method.getDeclaringClass().getName();
                String key=className+"."+methodName;
//                给map赋值
                mappers.put(key,mapper);
            }
        }
        return mappers;
    }
}

该处需要将所有的mybatis依赖删除。

---

2.2数据源工具类DataSourceUtil

package com.gzlg.mybatis.utils;

import com.gzlg.mybatis.cfg.Configuration;

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

//用于创建数据源工具类
public class DataSourceUtil {
//    获取一个连接
    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);
        }

    }
}

2.3执行sql工具

package com.gzlg.mybatis.utils;
//负责执行sql语句，并且封装结果集

import com.gzlg.mybatis.cfg.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;

public class Executor {
    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.gzlg.damain.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=(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);
                }
                //把赋好值的对象加入到集合中
                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();
            }
        }

        if (pstm != null) {
            try {
                pstm.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

3.编写读取配置文件类(Resource)

package com.gzlg.mybatis.io;

import java.io.InputStream;
//使用类加载器读取配置文件的类
public class Resources {
//根据传入的参数，获取一个字节输入流
    public static InputStream getResourceAsStream(String filePath){
//        三步：拿到当前字节码，拿到类加载器，读取配置filePath
        return Resources.class.getClassLoader().getResourceAsStream(filePath);
    }
}

4.编写封装查询类（Mapper）

package com.gzlg.mybatis.cfg;

public class Mapper {
//    用于封装执行的SQL语句和结果类型的全限类名
    private String queryString;
//    实体类的全限定类名
    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;
    }
}

5.编写核心配置类自定义mybatis（Configuration）

package com.gzlg.mybatis.cfg;

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

public class Configuration {
//    自定义mybatis配置类
    private String driver;
    private String url;
    private String username;
    private String password;

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

6.实体类（User）

package com.gzlg.daomin;

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

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 + '\'' +
                '}';
    }
}

二、基于XML的自定义mybatis框架

1.编写持久层接口和IUserDao.xml

1.1接口IUserDao

package com.gzlg.dao;

import com.gzlg.mybatis.annotations.Select;
import com.gzlg.daomin.User;

import java.util.List;


/*用户持久层接口*/
public interface IUserDao {
//查询所有
//     @Select("select * from user")
     List<User> findAll();
}

1.2IUseDao.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--dao接口全名称-->
<mapper namespace="com.gzlg.dao.IUserDao">
<!--    配置查询所有（id为User文件的方法）-->
    <select id="findAll" resultType="com.gzlg.daomin.User">
        select * from user
    </select>
</mapper>

需将mybatis的配置文件和约束删除

2.编写构建者（SqlSessionFactoryBuilder ）

package com.gzlg.mybatis.sqlSession;

import com.gzlg.mybatis.cfg.Configuration;
import com.gzlg.mybatis.sqlSession.defaults.DefaultSqlSessionFactory;
import com.gzlg.mybatis.utils.XMLConfigBuilder;

import java.io.InputStream;

public class SqlSessionFactoryBuilder {
//    创建一个SqlSessionFactory对象
//    根据参数的字节输入流来构建一个sqlSessionFactory工厂
    public SqlSessionFactory build(InputStream config){
        Configuration cfg= XMLConfigBuilder.loadConfiguration(config);
        return new DefaultSqlSessionFactory(cfg);
    }
}

3.编写SqlSessionFactory接口和实现(DefaultSqlSessionFactory)

3.1SqlSessionFactory

package com.gzlg.mybatis.sqlSession;

public interface SqlSessionFactory {
//    用于打开一个新的sqlsession对象
    SqlSession openSession();
}

3.2DefaultSqlSessionFactory`

package com.gzlg.mybatis.sqlSession.defaults;

import com.gzlg.mybatis.cfg.Configuration;
import com.gzlg.mybatis.sqlSession.SqlSession;
import com.gzlg.mybatis.sqlSession.SqlSessionFactory;

/*
 * SqlSessionFactory接口的实现类
 * */
public class DefaultSqlSessionFactory implements SqlSessionFactory {
    private Configuration cfg;

    public DefaultSqlSessionFactory(Configuration cfg) {
        this.cfg=cfg;
    }
    /*
* 用于创建一个新的操作数据库对象
* */
    public SqlSession openSession() {
        return new DefaultSqlSession(cfg);
    }
}

4.编写SqlSession接口和实现(DefaultSqlSession)

4.1SqlSession

package com.gzlg.mybatis.sqlSession;
//自定义Mybatis中的数据库交互的核心类，其中可以创建dao接口的代理对象
public interface SqlSession {
//    根据参数创建一个代理对象，daoInterfaceClass dao的接口字节码
    <T> T getMapper(Class<T> daoInterfaceClass);
//    释放资源
    void close();
}

```r
在这里插入代码片

4.2DefaultSqlSession

package com.gzlg.mybatis.sqlSession.defaults;

import com.gzlg.mybatis.cfg.Configuration;
import com.gzlg.mybatis.sqlSession.SqlSession;
import com.gzlg.mybatis.sqlSession.proxy.MapperProxy;
import com.gzlg.mybatis.utils.DataSourceUtil;

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

/*
* SqlSession接口的实现类
* */
public class DefaultSqlSession implements SqlSession {
    private Configuration cfg;
    private Connection connection;

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

    //    创建代理对象.daoInterfaceClass  dao接口字节码
    public <T> T getMapper(Class<T> daoInterfaceClass) {
//        类加载器（用代理的），实现相同 的接口传入Class数组中，如何代理

        return (T) Proxy.newProxyInstance(daoInterfaceClass.getClassLoader(),
                new  Class[]{daoInterfaceClass},new MapperProxy(cfg.getMappers(),connection));
    }
//释放资源
    @Override
    public void close() {
        if (connection!=null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

5.编写用于创建Dao接口代理对象的类(MapperProxyFactory)

package com.gzlg.mybatis.sqlSession.proxy;

import com.gzlg.mybatis.cfg.Mapper;
import com.gzlg.mybatis.utils.Executor;

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

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

    //    map的key是全限定类名+方法名
    public MapperProxy(Map<String, Mapper> mappers,Connection conn) {
        this.mappers=mappers;
        this.conn=conn;
    }

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

6.SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--配置环境-->
    <environments default="mysql">
<!--        配置mysql环境-->
        <environment id="mysql">
<!--            配置事务类型-->
            <transactionManager type="JDBC"></transactionManager>
<!--            配置数据源（连接池）-->
            <dataSource type="POOLED">
<!--            配置连接数据库的四个基本信息-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test?characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
<!--    指定映射配置文件位置，映射配置文件指的是每个dao独立的配置文件-->
    <mappers>
        <mapper resource="com/gzlg/dao/IUserDao.xml"></mapper>
<!--        注解-->
<!--        注解方式用class属性-->
<!--        <mapper class="com.gzlg.dao.IUserDao"></mapper>-->
    </mappers>
</configuration>

7.运行测试类

package com.gzlg.test;



import com.gzlg.dao.IUserDao;
import com.gzlg.daomin.User;
import com.gzlg.mybatis.io.Resources;
import com.gzlg.mybatis.sqlSession.SqlSession;
import com.gzlg.mybatis.sqlSession.SqlSessionFactory;
import com.gzlg.mybatis.sqlSession.SqlSessionFactoryBuilder;

import java.io.InputStream;
import java.util.List;

public class MybatisTest {
//    psvm补全
    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){
            //            输入sout可以快捷输出以下语句
            System.out.println(user);
        }
//6、释放资源
        session.close();
        in.close();
    }
}

三.基于注解模式(@Select)自定义框架

需要修改以下两个文件

1、自定义@Select注解

package com.gzlg.mybatis.annotations;

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语句
   String value();
}

2、修改SqlMapConfig.xml下的mapper

四、总结

XML注解需要通过xml文件，并且mapper属性使用resource,用“/”区分路径

注解需要自定义@Select类,
在IUserDao接口中加入注解
修改SqlMapConfig.xml下的mapper（使用class属性，用“.”区分路径）

package com.gzlg.mybatis.annotations;

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语句
   String value();
}