手写MyBatis底层机制

读取配置文件，得到数据库连接

思路

引入必要的依赖
需要写一个自己的config.xml文件，在里面配置一些信息，driver，url ，password，username
需要编写Configuration类，对自己的config.xml文件进行解析，得到一个数据库连接

实现

引入必要的依赖

<dependencies>
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.4</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

需要写一个自己的config.xml文件，在里面配置一些信息，driver，url ，password，username

<?xml version="1.0" encoding="UTF-8" ?>
<database>
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/hsp_mybatis?
        useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
    <property name="username" value="root"/>
    <property name="password" value="zy"/>
</database>

需要编写Configuration类，对自己的config.xml文件进行解析，得到一个数据库连接

public class ZyConfiguration {

    //属性 类加载器
    private ClassLoader classLoader =
            ClassLoader.getSystemClassLoader();

    //读取xml文件信息并处理
    public Connection build(String resource) {
        Connection connection = null;
        
        //加载配置文件，获取对应的InputStream流
        InputStream resourceAsStream =
                classLoader.getResourceAsStream(resource);

        //解析xml文件
        SAXReader reader = new SAXReader();
        try {
            Document document = reader.read(resourceAsStream);
            Element root = document.getRootElement();

            //解析rootElement
            System.out.println("root= "+root);
            return evalDataSource(root);

        } catch (DocumentException e) {
            throw new RuntimeException(e);
        }

    }


    //解析xml文件 并返回一个连接
    private Connection evalDataSource(Element node) {
        Iterator property = node.elementIterator("property");
        String driverClassName = null;
        String url = null;
        String username = null;
        String password = null;

        //遍历node子节点 获取属性值
        while(property.hasNext()){
            Element pro = (Element)property.next();
            String name = pro.attributeValue("name");
            String value = pro.attributeValue("value");

            //判断是否得到了name 和 value
            if (name == null || value == null){
                throw new RuntimeException("property 节点没有设置name 或 value属性");
            }
            switch (name){
                case "driverClassName":
                    driverClassName = value;
                    break;
                case "url":
                    url = value;
                    break;
                case "username":
                    username = value;
                    break;
                case "password":
                    password = value;
                    break;
                default:
                    throw new RuntimeException("属性名没有匹配到");
            }

        }
        Connection connection = null;
        try {
            Class.forName(driverClassName);
            connection = DriverManager.getConnection(url, username, password);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return connection;
    }

}

编写执行器，输入SQL语句，完成操作

思路

需要写一个实体类，对应monster表
编写接口executor
实现接口，编写自己的执行器
需要一个自己的Configuration类返回连接，通过连接对数据库进行操作

实现

需要写一个实体类，对应monster表

@Setter
@Getter
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class Monster {
    private Integer id;
    private Integer age;
    private String name;
    private String email;
    private Date birthday;
    private double salary;
    private Integer gender;
}

编写接口executor

public interface Executor {
    public <T> T query(String statement,Object parameter);
}

实现接口，编写自己的执行器

public class ZyExecutor implements Executor{

    private ZyConfiguration zyConfiguration = new ZyConfiguration();

    @Override
    public <T> T query(String sql, Object parameter) {
        Connection connection = getConnection();

        //查询返回的结果集
        ResultSet set = null;
        PreparedStatement pre = null;

        try {
            pre = connection.prepareStatement(sql);
            //设置参数，如果参数多，用数组处理
            pre.setString(1, parameter.toString());
            set = pre.executeQuery();

            //把set数据封装到对象 -- monster
            Monster monster = new Monster();//简化处理 认为返回的结果就是一个monster记录

            //遍历结果集
            while(set.next()){
                monster.setId(set.getInt("id"));
                monster.setName(set.getString("name"));
                monster.setEmail(set.getString("email"));
                monster.setAge(set.getInt("age"));
                monster.setGender(set.getInt("gender"));
                monster.setBirthday(set.getDate("birthday"));
                monster.setSalary(set.getDouble("salary"));
            }
            return (T)monster;

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                if (set != null) {
                    set.close();
                }
                if (pre != null) {
                    pre.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        
    }

    public Connection getConnection(){//Configuration类 返回连接，通过连接对数据库进行操作
       return zyConfiguration.build("zy_mybatis.xml");
    }
}

需要一个自己的Configuration类返回连接，通过连接对数据库进行操作

将Sqlsession封装到执行器

思路

需要写自己的Sqlsession类，它是搭建连接和执行器之间的桥梁，里面封装有执行器和配置文件以及操作DB 的具体方法
写一个selectOne方法，SelectOne() 返回一条记录，一条记录对应一个Monster对象

实现

需要写自己的Sqlsession类，它是搭建连接和执行器之间的桥梁，里面封装有执行器和配置文件以及操作DB 的具体方法

public class ZySqlSession {//搭建连接和执行器之间的桥梁

    //执行器
    private Executor executor = new ZyExecutor();

    //配置
    private ZyConfiguration zyConfiguration = new ZyConfiguration();

    //操作DB 的具体方法
    //SelectOne 返回一条记录-对象
    public <T> T selectOne(String statement,Object parameter){
        return executor.query(statement,parameter);
    }
}

写一个selectOne方法，SelectOne() 返回一条记录，一条记录对应一个Monster对象

//操作DB 的具体方法
    //SelectOne 返回一条记录-对象
    public <T> T selectOne(String statement,Object parameter){
        return executor.query(statement,parameter);
    }

开发Mapper接口和Mapper.xml

思路

编写MonsterMapper接口，里面有方法getMonsterById（Integer id）根据id返回一个monster对象
在resources下编写对应的monsterMapper.xml(简化：因为在resources 编译时会在类路径下比较好写)
monsterMapper.xml 编写具体的sql语句，并指定语句类型，id，resultType（和原生Mybatis一样）

实现

编写MonsterMapper接口，里面有方法getMonsterById（Integer id）根据id返回一个monster对象

public interface MonsterMapper {
    public Monster getMonsterById(Integer id);
}

在resources下编写对应的monsterMapper.xml(简化：因为在resources 编译时会在类路径下比较好写)
monsterMapper.xml 编写具体的sql语句，并指定语句类型，id，resultType（和原生Mybatis一样）

<?xml version="1.0" encoding="UTF-8" ?>
<mapper namespace="com.code_study.mapper.MonsterMapper">
    <!--    实现配置接口方法 getMonsterById-->
    <select id="getMonsterById" resultType="com.code_study.entity.Monster">
        SELECT * FROM monster WHERE id = ?
    </select>
</mapper>

开发MapperBean，可以和Mapper接口相映射

思路

开发 Function类，用于记录对应的Mapper的方法信息，比如sql类型，方法名，执行的sql语句，返回类型，入参类型
开发 MapperBean类，记录接口信息和接口下的所有方法
Function类对应 monsterMapper.xml中的信息
MapperBean类对应 MonsterMapper 接口中的信息

实现

开发 Function类，用于记录对应的Mapper的方法信息，比如sql类型，方法名，执行的sql语句，返回类型，入参类型

//对应 monsterMapper.xml中的信息
public class Function {
    private String sqlType;//sql类型，比如select，insert，update，delete
    private String funcName;//方法名
    private String sql;//执行的sql语句
    private Object resultType;//返回类型
    private String parameterType;//入参类型
}

开发 MapperBean类，记录接口信息和接口下的所有方法

//对应 MonsterMapper 接口中的信息
public class MapperBean {
    private String interfaceName;//接口名

    //    接口下的所有方法
    private List<Function> functions;
}

Function类对应 monsterMapper.xml中的信息
MapperBean类对应 MonsterMapper 接口中的信息

在Configuration中解析MapperXML获取MapperBean对象

思路

在Configuration 添加方法readMapper(String path)
通过 path 读取接口对应的Mapper方法
保存接口下所有的方法信息
封装成 MapperBean对象

实现

在Configuration 添加方法readMapper(String path)
通过 path 读取接口对应的Mapper方法
保存接口下所有的方法信息
封装成 MapperBean对象

 //解析MapperXML获取MapperBean对象
    //path = xml的路径+文件名 是从类的加载路径计算的(如果放在resource目录下 之间传xml文件名即可)
    public MapperBean readMapper(String path) {
        MapperBean mapperBean = new MapperBean();

        InputStream resourceAsStream = classLoader.getResourceAsStream(path);
        SAXReader reader = new SAXReader();
        try {
            Document document = reader.read(resourceAsStream);
            Element root = document.getRootElement();

            String namespace = root.attributeValue("namespace");
            mapperBean.setInterfaceName(namespace);

            List<Function> list = new ArrayList<>();//保存接口下所有的方法信息

            //得到root的迭代器
            Iterator iterator = root.elementIterator();
            while(iterator.hasNext()){
                Element e = (Element)iterator.next();
                String sqlType = e.getName().trim();
                String sql = e.getText().trim();
                String funcName = e.attributeValue("id");
                String resultType = e.attributeValue("resultType");

                //ResultType 返回的是一个Object对象 ->反射
                Object instance = Class.forName(resultType).newInstance();

                //封装 function 对象
                Function function = new Function();
                function.setSql(sql);
                function.setSqlType(sqlType);
                function.setFuncName(funcName);
                function.setResultType(instance);

                //将封装好的function对象 放入 list中
                list.add(function);


                mapperBean.setFunctions(list);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return mapperBean;
    }

动态代理Mapper方法

思路

在SqlSession中添加方法 getMapper 输入一个Class类型，返回mapper的动态代理对象
编写动态代理类实现 InvocationHandler 接口
取出mapperBean的functions 遍历
判断当前要执行的方法和function.getFunctionName是否一致
调用方法返回动态代理对象
编写SqlSessionFactory 会话工厂，可以返回SqlSession

实现

编写动态代理类实现 InvocationHandler 接口
在SqlSession中添加方法 getMapper 输入一个Class类型，返回mapper的动态代理对象

 //返回mapper的动态代理对象
    public <T> T getMapper(Class<T> clazz){
        return (T) Proxy.newProxyInstance(
                clazz.getClassLoader(),
                new Class[]{clazz},
                new ZyMapperProxy(zyConfiguration,clazz,this));
    }

取出mapperBean的functions 遍历
判断当前要执行的方法和function.getFunctionName是否一致
调用方法返回动态代理对象

public class ZyMapperProxy implements InvocationHandler {
    private ZySqlSession zySqlSession;
    private String mapperFile;
    private ZyConfiguration zyConfiguration;

    public ZyMapperProxy(ZySqlSession zySqlSession, Class clazz, ZyConfiguration zyConfiguration) {
        this.zySqlSession = zySqlSession;
        this.zyConfiguration = zyConfiguration;
        this.mapperFile = clazz.getSimpleName() + ".xml";
    }

    //当执行Mapper接口的代理对象方法时，会执行到invoke方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MapperBean mapperBean = zyConfiguration.readMapper(this.mapperFile);

        //判断是否为当前xml文件对应的接口
        if (!method.getDeclaringClass().getName().equals(mapperBean.getInterfaceName())){
            return null;
        }

        //取出mapperBean的functions
        List<Function> functions = mapperBean.getFunctions();
        //判断当前的mapperBean 解析对应的MapperXML后，有方法
        if (null != functions || 0 != functions.size()){
            for (Function function : functions) {
                //当前要执行的方法和function.getFunctionName
                if (method.getName().equals(function.getFuncName())){
                    if ("SELECT".equalsIgnoreCase(function.getSqlType())){
                        return zySqlSession.selectOne(function.getSql(),String.valueOf(args[0]));
                    }
                }
            }
        }

        return null;
    }
}

编写SqlSessionFactory 会话工厂，可以返回SqlSession

public class ZySqlSessionFactory {
    
    public static ZySqlSession open(){
        return new ZySqlSession();
    }
}

测试

@Test
public void openSession(){
    ZySqlSession zySqlSession = ZySqlSessionFactory.openSession();
    System.out.println("zySqlSession= "+zySqlSession);
    MonsterMapper mapper = zySqlSession.getMapper(MonsterMapper.class);
    Monster monster = mapper.getMonsterById(1);
    System.out.println("monster= "+monster);
}

posted @ 2024-05-07 09:49 zy2596 阅读(122) 评论(0) 编辑收藏举报

刷新页面返回顶部

zydevelop

手写MyBatis底层机制

手写MyBatis底层机制

读取配置文件，得到数据库连接

思路

实现

编写执行器，输入SQL语句，完成操作

思路

实现

将Sqlsession封装到执行器

思路

实现

开发Mapper接口和Mapper.xml

思路

实现

开发MapperBean，可以和Mapper接口相映射

思路

实现

在Configuration中解析MapperXML获取MapperBean对象

思路

实现

动态代理Mapper方法

思路

实现

测试

公告