目录
2.加入依赖(mysql dom4j junit lombok)
3.2实现任务阶段 2- 编写执行器，输入 SQL 语句，完成操作
3.3实现任务阶段 3- 将 Sqlsession 封装到执行器
一.原生mybits框架图分析
我们从mybatis的jar包中看到其中有个Executor执行器的包，里面封装了很多操作数据库的方法
CachingExecutor类实现了Executor接口：
很多关于DB的原生方法都在此类进行一个实现：比如query / select / update / delete 方法等
5) MappedStatement 是通过 XxxMapper.xml 中定义, 生成的 statement 对象
6) 参数输入执行并输出结果集, 无需手动判断参数类型和参数下标位置, 且自动将结果集
映射为 Java 对象
自己实现Mybatis框架的分析
引用老韩博主的图
两种框架操作数据库的方法：
@1： 首先我们不通过代理对象操作DB的方法。而是直接通过执行器去操作DB
我们首先会自定义核心配置文件(XML文件)：1.这里面包括数据库的连接 ，我们会用一个snConfigration配置类，去读取properties文件，并建立与数据库的连接。
然后 通过snExecutor执行器类，直接去执行DB的查找方法，并自动返回一个Monster对象。
这里面，我们会定义一个Executor接口，里面定义关于操作数据库的CRUD方法，这里只采用query方法。执行器得到snConfiguration建立的与数据库的连接，然后采用query方法操作数据库，并返回一个对象。
@2：其次就是采用mybatis的代理对象去操作DB数据库。
我们之前直接用执行器的方法，并没有使用到我们的Mapper.xml文件。总所周知
Monster类对应的就是数据库中的一个Monster表，MonsterMapper接口就是对这个表进行操作的方法的定义，MonsterMapper.xml文件就是对这个接口的方法具体的实现。
那我们怎么将两者结合在一起呢，他们之间有个MapperBean类，这个类可以将XML文件中的SQL语句的方法进行封装这里我们用Functions进行，以及封装属性：XML文件所对应的这个接口的名字。 这个类的作用就是在之后的动态代理对象中，我们调用该对象的query()方法
二.搭建开发环境
1.先创建一个maven项目
2.加入依赖(mysql dom4j junit lombok)
lombok:可以用来简化javabean/pojo的开发（包括getter和setter方法以及构造器等）
如图进行比较
<?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.sn</groupId>
<artifactId>sn-mybatis</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</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>
</project>三.mybatis框架的设计思路
具体实现过程
3.1实现任务阶段 1- 完成读取配置文件，得到数据库连
sn_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/mybatis?useSSL=trueuseUnicode=truecharacterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="ygd"/>
</database>snConfiguration
package com.sn.sqlsession;
import com.mysql.jdbc.Connection;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.InputStream;
import java.sql.DriverManager;
/**
* @author ygd
* 读取xml文件，建立连接
*/
public class snConfiguration {
//定义类的加载器(将xml文件进行加载，得到一个文件流)
private static ClassLoader loader = ClassLoader.getSystemClassLoader();
//读取xml文件，并进行处理
public Connection build(String resource)
{
Connection connection = null;
try {
//先加载配置文件，获取到对应的inputStream
InputStream stream = loader.getResourceAsStream(resource);
//dom4j=>用来解析xml文件的
SAXReader reader = new SAXReader();
//返回一个文档类型
Document document = reader.read(stream);
//获取到配置文件的根元素
Element root = document.getRootElement();
//根据解析的root的元素返回一个connecton
System.out.println("root=="+root);
connection = evalDataSource(root);
return connection;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
//这个方法会解析sn_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")) {
Element i = (Element) item;//i 就是 对应property节点
String name = i.attributeValue("name");
String value = i.attributeValue("value");
//判断是否得到name 和 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("属性名没有匹配到...");
}
}
java.sql.Connection connection = null;
try {
//使用原生的JDBC来连接数据库
//建立驱动
Class.forName(driverClassName);
//建立连接
connection = DriverManager.getConnection(url,username,password);
} catch (Exception e) {
e.printStackTrace();
}
return (Connection) connection; //返回Connection
}
}
3.2实现任务阶段 2- 编写执行器，输入 SQL 语句，完成操作
在通过自己配置的mybaties-config.xml文件获取到与数据库的连接之后，接下来的操作：通过获取的连接，让执行器Executor执行对应的sql语句，操作DB。
Executor接口
package com.sn.sqlsession;
/**
* @version 1.0
*/
public interface Executor {
//泛型方法
//statement就是sql语句
//parameter就是参数
public <T> T query(String statement, Object parameter);
}
SnExecutor类
package com.sn.sqlsession;
import com.sn.entity.Monster;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/**
* @author sn
* 这里是实现对数据库DB的直接操作
*/
public class SnExecutor implements Executor{
//这里的Statement就是sql语句，parameter就是传入的参数
private snConfiguration snConfiguration =
new snConfiguration();
/**
* 根据 sql 查找结果
*
* @param sql
* @param parameter
* @param <T>
* @return
*/
@Override
//这里只用query操作来对数据库进行相应的处理。
public <T> T query(String sql, Object parameter) {
//得到连接Connection,采用的是自定义的方法
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 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 throwables) {
throwables.printStackTrace();
} finally {
try {
if (set != null) {
set.close();
}
if (pre != null) {
pre.close();
}
if (connection != null) {
connection.close();
}
} catch (Exception throwables) {
throwables.printStackTrace();
}
}
return null;
}
//编写方法,通过snConfiguration对象，返回连接
private Connection getConnection() {
Connection connection =
snConfiguration.build("sn_mybatis.xml");
return connection;
}
}
3.3实现任务阶段 3- 将 Sqlsession 封装到执行器
瞧瞧SqlSession自己的方法：
可以看出DefaultSqlSession封装了执行器以及和XML中的配置信息相关的类。
以及DefaultsqlSession自己对数据库操作的方法。
DefaultsqlSession实际上是实现了SqlSession的这个接口
SnSqlSession
package com.sn.sqlsession;
/**
* @author sn
* sqlsession主要封装数据的链接Configuration和Executor执行器
* 以及操作DB的一些自己的方法
*/
public class SnSqlSession {
//封装执行器
private Executor executor = new SnExecutor();
//配置
private snConfiguration snConfiguration = new snConfiguration();
//编写selectOne方法，并且返回一条记录
public <T> T selectOne(String statement,Object parameter)
{
return executor.query(statement,parameter);
}
}
执行一个测试方法
如图底层是调用的Executor的方法进行一个调用。
实现方法二：用动态代理来实现
接下来就是对mybatis框架中Mapper接口方法的声明。XXMapper.xml文件实现的接口方法，框架中是如何去实现这些方法的呢？
如上图所示
以前的接口方法的实现，是通过实现该接口的类进行实现的。 而mybatis框架中：
一个类------数据库中的一个表。
类Mapper接口 -------- 操作这个表的方法的声明。
类Mapper.xml -------- 对操作表方法的实现。
其实在接口和XML文件之间有一个MapperBean对象。现在只需知道这个MapperBean对象对后面动态代理生成对象起作用。在这个MapperBean对象中有
Function类：主要是记录XML文件中方法的各种信息，比如select，delete，update等以及返回的类型，参数的类型等。
List<Function>集合，用户来存放不同的方法
String interfaceName:用来存放对应Mapper接口的名称
Function方法：
package com.sn.config;
import lombok.Getter;
import lombok.Setter;
/**
* @author sn
* 记录对应的mapper的方法信息
*/
@Getter
@Setter
public class Function {
//属性
private String sqlType; //sql类型，比如crud
private String funcName; //记录的方法名
private String sql;//记录对应的sql语句
private Object resultType;//记录一个返回类型
private String parameter;//这个是我们的参数类型
}
MapperBean方法
package com.sn.config;
import lombok.Getter;
import lombok.Setter;
import java.util.List;
/**
* @author sn
* MapperBean对象就是封装Mapper的信息。
* 1：对应相应的接口信息
* 2:封装对应mapper.xml的信息，这些信息用Function来抽象。
*/
@Setter
@Getter
public class MapperBean {
private String interfaceName; //接口名
//接口下的所有的方法
private List<Function> functions;
}
MonsterMapper
package com.sn.mapper;
import com.sn.entity.Monster;
/**
* @author sn
* MonsterMapper：声明DB的crud方法
*/
public interface MonsterMapper {
//查询方法
public Monster getMonsterById(Integer id);
}
代理对象类
package com.sn.sqlsession;
import com.sn.config.Function;
import com.sn.config.MapperBean;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.nio.file.WatchService;
import java.util.List;
/**
* @author sn
* 动态代理生成Mapper对象,并调用snExecutor方法
*/
public class snMapperProxy implements InvocationHandler {
//属性
private SnSqlSession sqlSession;
private String mapperFile;
private snConfiguration snConfiguration;
//构造器
//最后一个参数传进来的是一个接口
public snMapperProxy(snConfiguration snConfiguration
, SnSqlSession sqlSession, Class clazz) {
this.snConfiguration = snConfiguration;
this.sqlSession = sqlSession;
this.mapperFile = clazz.getSimpleName() + ".xml";
}
//实现一个动态代理的机制
//当执行到Mapper接口的代理对象的方法的时候,会执行invoke方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//首先通过XML文件获取MapperBean对象(接口名。接口下面的方法)
MapperBean mapperBean = snConfiguration.readMapper(mapperFile);
//判断是否是XMl文件对应的接口
//通过method方法得到声明这个方法的接口的名字
if (!method.getDeclaringClass().getName().equals(mapperBean.getInterfaceName())) {
return null;
}
//取出mapperBean的functions
List<Function> functions = mapperBean.getFunctions();
//先判断当前的这个mapperBean解析对应的XML文件中有方法
if(null != functions functions.size())
{
for (Function function : functions) {
//当前要执行的方法和Function的方法一致,说明我们可以
//去当前遍历的function对象中，取出相应的信息，并执行相应的方法
if(method.getName().equals(function.getFuncName()))
{
//如果我们当前的function执行的sqlType是select
//我们就去执行selectOne()等~
if("select".equalsIgnoreCase(function.getSqlType()))
{
return sqlSession.selectOne(function.getSql(),String.valueOf(args[0]));
}
}
}
}
return null;
}
}
测试
@Test
public void test2()
{
SnSqlSessionFactor snSqlSessionFactor = new SnSqlSessionFactor();
SnSqlSession snSqlSession = snSqlSessionFactor.openSession();
MonsterMapper mapper = snSqlSession.getMapper(MonsterMapper.class);
Monster monster = mapper.getMonsterById(2);
System.out.println("monster"+monster);
}
这个后序的用动态代理着实有点不明白，但是代码都是对的，大佬们可以自行理解