day02-自己实现Mybatis底层机制-01

自己实现Mybatis底层机制-01

主要实现：封装SqlSession到执行器+Mapper接口和Mapper.xml+MapperBean+动态代理Mapper的方法

1.Mybatis整体架构分析

对上图的解读：

1）mybatis 的核心配置文件

​ mybatis-config.xml：进行全局配置，全局只能有一个这样的配置文件

​ XxxMapper.xml 配置多个SQL，可以有多个 XxxMapper.xml 配置文件

2）通过 mybatis-config.xml 配置文件得到 SqlSessionFactory

3）通过 SqlSessionFactory 得到 SqlSession，用 SqlSession 就可以操作数据了

4）SqlSession 底层是 Executor(执行器)，有两个重要的实现类

5）MappedStatement 是通过 XxxMapper.xml 来定义的，用来生成 statement 对象

6）参数输入执行并输出结果集，无需动手判断参数类型和参数下标位置，且自动将结果集映射为Java对象

2.搭建开发环境

（1）创建maven项目

（2）在pom.xml 中引入必要的依赖

<!--指定编译器/source/target的版本-->
<properties>
    <project.build.sourdeEncoding>UTF-8</project.build.sourdeEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <java.version>1.8</java.version>
</properties>
 
<!--引入必要的依赖-->
<dependencies>
    <!--dom4j-->
    <dependency>
        <groupId>dom4j</groupId>
        <artifactId>dom4j</artifactId>
        <version>1.6.1</version>
    </dependency>
    <!--mysql-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.49</version>
    </dependency>
    <!--lombok-简化entity/javabean/pojo 的开发-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.4</version>
    </dependency>
    <!--junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

（3）创建数据库和表

-- 创建数据库
CREATE DATABASE `li_mybatis`;
USE `li_mybatis`;
-- 创建monster表
CREATE TABLE `monster`(
`id` INT NOT NULL AUTO_INCREMENT,
`age` INT NOT NULL,
`birthday` DATE DEFAULT NULL,
`email` VARCHAR(255) NOT NULL,
`gender` TINYINT NOT NULL,-- 1 male，0 female
`name` VARCHAR(255) NOT NULL,
`salary` DOUBLE NOT NULL,
PRIMARY KEY(`id`)
)CHARSET=utf8
-- insert
INSERT INTO `monster` VALUES(NULL,200,'2000-11-11','nmw@qq.com',1,'牛魔王',8888);

3.设计思路

解读：

1. 传统的方式操作数据库
   1）得到 MySession 对象
   2）调用 MyExecutor 的方法完成操作
   3）MyExecutor 的连接是从 MyConfiguration 获取

2. Mybatis 操作数据库的方式
   1）得到 MySession 对象
   2）不直接调用 MyExecutor 的方法
   3）而是通过 MyMapperProxy 获取 Mapper 对象
   4）调用 Mapper 的方法，完成对数据库的操作
   5）Mapper 最终还是动态代理方式，使用 MyExecutor 的方法完成操作
   6）这里比较麻烦的就是 MyMapperProxy 的动态代理机制如何实现

4.任务阶段1

阶段1任务：通过配置文件，获取数据库连接

4.1分析

4.2代码实现

（1）在src 的 resources目录下创建 my-config.xml，模拟原生的 mybatis 配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<database>
    <!--配置连接数据库的信息-->
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/li_mybatis?
    useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</database>

（2）创建 MyConfiguration 类，用来读取xml文件，建立连接

因为这里重点是实现 Mybatis 的底层机制，为了简化操作，就不使用数据库连接池了，直接使用原生的connection 连接

package com.li.limybatis.sqlsession;
 
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
 
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
 
/**
 * @author 李
 * @version 1.0
 * 用来读取xml文件，建立连接
 */
public class MyConfiguration {
    //属性-类的加载器
    private static ClassLoader loader = ClassLoader.getSystemClassLoader();
 
    //读取xml文件并处理
    public Connection build(String resource) {
        Connection connection = null;
        try {
            //先加载配置文件 my-config.xml，获取对应的InputStream
            InputStream stream = loader.getResourceAsStream(resource);
            //解析 my-config.xml文件
            SAXReader reader = new SAXReader();
            Document document = reader.read(stream);
            //获取 xml文件的根元素 <database>
            Element root = document.getRootElement();
            System.out.println("root=" + root);
            //根据root解析，获取Connection
            connection = evalDataSource(root);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }
 
    //解析 my-config.xml 的信息，并返回 Connection
    private Connection evalDataSource(Element node) {
        if (!"database".equals(node.getName())) {
            throw new RuntimeException("root节点应该是<database>");
        }
 
        //连接DB的必要参数
        String driverClassName = null;
        String url = null;
        String username = null;
        String password = null;
 
        //遍历node下的子节点，获取其属性值
        for (Object item : node.elements("property")) {
            //i就是对应的 property节点
            Element i = (Element) item;
            //property节点的 name属性的值
            String name = i.attributeValue("name");
            //property节点的 value属性的值
            String value = i.attributeValue("value");
 
            //判断值是否为空
            if (name == null || value == null) {
                throw new RuntimeException("property节点没有设置name或value属性！");
            }
            switch (name) {
                case "url":
                    url = value;
                    break;
                case "username":
                    username = value;
                    break;
                case "driverClassName":
                    driverClassName = 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) {
            e.printStackTrace();
        }
        return connection;
    }
}

5.任务阶段2

阶段2任务：通过实现执行器机制，对数据表进行操作

5.1分析

我们把对数据库的操作封装到一套Executor机制中，程序具有更好的拓展性，结构更加清晰。这里我们先实现传统的方式连接数据库，即通过MyExecutor直接操作数据库。

5.2代码实现

（1）生成 entity 类 Monster.java

package com.li.entity;
 
import lombok.*;
 
import java.util.Date;
 
/**
 * @author 李
 * @version 1.0
 * Monster类和 monster有映射关系
 *
 * 注解说明：
 * @Getter 给所有属性生成 getter方法
 * @Setter 给所有属性生成 setter方法
 * @ToString 生成toString方法
 * @NoArgsConstructor 生成一个无参构造器
 * @AllArgsConstructor 生成一个全参构造器
 * @Data 会生成上述除了无参/全参构造器的所有方法，此外还会生成equals,hashCode等方法
 */
@Getter
@Setter
@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;
}

（2）Executor 接口

package com.li.limybatis.sqlsession;
 
/**
 * @author 李
 * @version 1.0
 */
public interface Executor {
    //泛型方法
    public <T> T query(String statement, Object parameter);
}

（3）执行器实现类 MyExecutor.java

package com.li.limybatis.sqlsession;
 
import com.li.entity.Monster;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
 
/**
 * @author 李
 * @version 1.0
 */
public class MyExecutor implements Executor {
    private MyConfiguration myConfiguration = new MyConfiguration();
 
    /**
     * 根据sql，返回查询结果
     *
     * @param sql
     * @param parameter
     * @param <T>
     * @return
     */
    @Override
    public <T> T query(String sql, Object parameter) {
        //获取连接对象
        Connection connection = getConnection();
        //查询返回的结果集
        ResultSet set = null;
        PreparedStatement pre = null;
        try {
            //构建PreparedStatement对象
            pre = connection.prepareStatement(sql);
            //设置参数，如果参数多，可以使用数组处理
            pre.setString(1, parameter.toString());
            //查询返回的结果集
            set = pre.executeQuery();
            //把结果集的数据封装到对象中-monster
            //说明：这里做了简化处理，认为返回的结果就是一个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 (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (set != null) {
                    set.close();
                }
                if (pre != null) {
                    pre.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }
 
    //编写方法，通过myConfiguration对象返回连接
    private Connection getConnection() {
        Connection connection = myConfiguration.build("my-config.xml");
        return connection;
    }
}

（4）进行测试

@Test
public void query() {
    Executor executor = new MyExecutor();
    Monster monster =
            (Monster) executor.query("select * from monster where id = ?", 1);
    System.out.println("monster--" + monster);
}

测试结果：

6.任务阶段3

阶段3任务：将执行器封装到SqlSession

6.1代码实现

（1）创建 MySqlSession 类，将执行器封装到SqlSession中。

package com.li.limybatis.sqlsession;
 
/**
 * @author 李
 * @version 1.0
 * MySqlSession：搭建Configuration(连接)和Executor之间的桥梁
 */
public class MySqlSession {
    //执行器
    private Executor executor = new MyExecutor();
    //配置
    private MyConfiguration myConfiguration = new MyConfiguration();
 
    //编写方法selectOne，返回一条记录
    public <T> T selectOne(String statement,Object parameter){
        return executor.query(statement, parameter);
    }
}

（2）测试

@Test
public void selectOne() {
    MySqlSession mySqlSession = new MySqlSession();
    Monster monster =
            (Monster) mySqlSession.selectOne("select * from monster where id=?", 1);
    System.out.println("monster=" + monster);
}

测试结果：