來源：oschina
my.oschina.net/liughDevelop/blog/1631006
繼上一篇手寫SpringMVC之后《從0開始手寫一個 SpringMVC 框架，向高手進階！》，我最近趁熱打鐵，研究了一下Mybatis，MyBatis框架的核心功能其實不難，無非就是動態代理和jdbc的操作，難的是寫出來可擴展，高內聚，低耦合的規范的代碼，
本文完成的Mybatis功能比較簡單，代碼還有許多需要改進的地方，大家可以結合Mybatis原始碼去動手完善，
1、Mybatis框架流程簡介
在手寫自己的Mybatis框架之前，我們先來了解一下Mybatis，它的原始碼中使用了大量的設計模式，閱讀原始碼并觀察設計模式在其中的應用，才能夠更深入的理解原始碼（ref：Mybatis原始碼解讀-設計模式總結），
我們對上圖進行分析總結：
1、mybatis的組態檔有2類
-
mybatisconfig.xml，組態檔的名稱不是固定的，配置了全域的引數的配置，全域只能有一個組態檔，
-
Mapper.xml 配置多個statemement，也就是多個sql，整個mybatis框架中可以有多個Mappe.xml組態檔，
2、通過mybatis組態檔得到SqlSessionFactory
3、通過SqlSessionFactory得到SqlSession，用SqlSession就可以操作資料了，
4、SqlSession通過底層的Executor（執行器），執行器有2類實作： 
-
基本實作
-
帶有快取功能的實作
5、MappedStatement是通過Mapper.xml中定義statement生成的物件，
6、引數輸入執行并輸出結果集，無需手動判斷引數型別和引數下標位置，且自動將結果集映射為Java物件
-
HashMap，KV格式的資料型別
-
Java的基本資料型別
-
POJO，java的物件
2、梳理自己的Mybatis的設計思路
根據上文Mybatis流程，我簡化了下，分為以下步驟：
**1.讀取xml檔案，建立連接
**
從圖中可以看出，MyConfiguration負責與人互動，待讀取xml后，將屬性和連接資料庫的操作封裝在MyConfiguration物件中供后面的組件呼叫，本文將使用dom4j來讀取xml檔案，它具有性能優異和非常方便使用的特點，推薦閱讀：Spring Boot 集成 Mybatis 實作雙資料源，
**2.創建SqlSession，搭建Configuration和Executor之間的橋梁
**
我們經常在使用框架時看到Session，Session到底是什么呢？一個Session僅擁有一個對應的資料庫連接，類似于一個前段請求Request，它可以直接呼叫exec(SQL)來執行SQL陳述句，
從流程圖中的箭頭可以看出，MySqlSession的成員變數中必須得有MyExecutor和MyConfiguration去集中做調配，箭頭就像是一種關聯關系，我們自己的MySqlSession將有一個getMapper方法，然后使用動態代理生成物件后，就可以做資料庫的操作了，推薦閱讀：Mybatis傳遞多個引數的4種方式，
3.創建Executor，封裝JDBC操作資料庫
Executor是一個執行器，負責SQL陳述句的生成和查詢快取（快取還沒完成）的維護，也就是jdbc的代碼將在這里完成，不過本文只實作了單表，有興趣的同學可以嘗試完成多表，
4.創建MapperProxy，使用動態代理生成Mapper物件
我們只是希望對指定的介面生成一個物件，使得執行它的時候能運行一句sql罷了，而介面無法直接呼叫方法，所以這里使用動態代理生成物件，在執行時還是回到MySqlSession中呼叫查詢，最終由MyExecutor做JDBC查詢，這樣設計是為了單一職責，可擴展性更強，推薦閱讀：從0 開始手寫一個Tomcat，7步搞定！
3、實作自己的Mybatis
工程檔案及目錄：
首先，新建一個maven專案，在pom.xml中匯入以下依賴：
<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.liugh</groupId>
<artifactId>liugh-mybatis</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- 讀取xml檔案 -->
<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.29</version>
</dependency>
</dependencies>
</project>
創建我們的資料庫xml組態檔：
<?xml version="1.0" encoding="UTF-8"?>
<database>
<property name="driverClassName">com.mysql.jdbc.Driver</property>
<property name="url">jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8</property>
<property name="username">root</property>
<property name="password">123456</property>
</database>
然后在資料庫創建test庫，執行如下SQL陳述句：
CREATE TABLE \`user\` (
`id\` varchar(64) NOT NULL,
`password\` varchar(255) DEFAULT NULL,
`username\` varchar(255) DEFAULT NULL,
PRIMARY KEY (\`id\`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
INSERT INTO \`test\`.\`user\` (\`id\`, \`password\`, \`username\`) VALUES ('1', '123456', 'liugh');
創建User物體類，和UserMapper介面和對應的xml檔案:
package com.liugh.bean;
public class User {
private String id;
private String username;
private String password;
//省略get set toString方法...
}
package com.liugh.mapper;
import com.liugh.bean.User;
public interface UserMapper {
public User getUserById(String id);
}
<?xml version="1.0" encoding="UTF-8"?>
<mapper nameSpace="com.liugh.mapper.UserMapper">
<select id="getUserById" resultType ="com.liugh.bean.User">
select * from user where id = ?
</select>
</mapper>
基本操作配置完成，接下來我們開始實作MyConfiguration：
package com.liugh.sqlSession;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import com.liugh.config.Function;
import com.liugh.config.MapperBean;
/**
* 讀取與決議配置資訊，并回傳處理后的Environment
*/
public class MyConfiguration {
private static ClassLoader loader = ClassLoader.getSystemClassLoader();
/**
* 讀取xml資訊并處理
*/
public Connection build(String resource){
try {
InputStream stream = loader.getResourceAsStream(resource);
SAXReader reader = new SAXReader();
Document document = reader.read(stream);
Element root = document.getRootElement();
return evalDataSource(root);
} catch (Exception e) {
throw new RuntimeException("error occured while evaling xml " \+ resource);
}
}
private Connection evalDataSource(Element node) throws ClassNotFoundException {
if (!node.getName().equals("database")) {
throw new RuntimeException("root should be <database>");
}
String driverClassName = null;
String url = null;
String username = null;
String password = null;
//獲取屬性節點
for (Object item : node.elements("property")) {
Element i = (Element) item;
String value = https://www.cnblogs.com/javastack/p/getValue(i);
String name = i.attributeValue("name");
if (name == null || value =https://www.cnblogs.com/javastack/p/= null) {
throw new RuntimeException("\[database\]: <property> should contain name and value");
}
//賦值
switch (name) {
case "url" : url = value; break;
case "username" : username = value; break;
case "password" : password = value; break;
case "driverClassName" : driverClassName = value; break;
default : throw new RuntimeException("\[database\]: <property> unknown name");
}
}
Class.forName(driverClassName);
Connection connection = null;
try {
//建立資料庫鏈接
connection = DriverManager.getConnection(url, username, password);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return connection;
}
//獲取property屬性的值,如果有value值,則讀取 沒有設定value,則讀取內容
private String getValue(Element node) {
return node.hasContent() ? node.getText() : node.attributeValue("value");
}
@SuppressWarnings("rawtypes")
public MapperBean readMapper(String path){
MapperBean mapper = new MapperBean();
try{
InputStream stream = loader.getResourceAsStream(path);
SAXReader reader = new SAXReader();
Document document = reader.read(stream);
Element root = document.getRootElement();
mapper.setInterfaceName(root.attributeValue("nameSpace").trim()); //把mapper節點的nameSpace值存為介面名
List<Function\> list = new ArrayList<Function>(); //用來存盤方法的List
for(Iterator rootIter = root.elementIterator();rootIter.hasNext();) {//遍歷根節點下所有子節點
Function fun = new Function(); //用來存盤一條方法的資訊
Element e = (Element) rootIter.next();
String sqltype = e.getName().trim();
String funcName = e.attributeValue("id").trim();
String sql = e.getText().trim();
String resultType = e.attributeValue("resultType").trim();
fun.setSqltype(sqltype);
fun.setFuncName(funcName);
Object newInstance=null;
try {
newInstance = Class.forName(resultType).newInstance();
} catch (InstantiationException e1) {
e1.printStackTrace();
} catch (IllegalAccessException e1) {
e1.printStackTrace();
} catch (ClassNotFoundException e1) {
e1.printStackTrace();
}
fun.setResultType(newInstance);
fun.setSql(sql);
list.add(fun);
}
mapper.setList(list);
} catch (DocumentException e) {
e.printStackTrace();
}
return mapper;
}
}
用面向物件的思想設計讀取xml配置后：
package com.liugh.config;
import java.util.List;
public class MapperBean {
private String interfaceName; //介面名
private List<Function> list; //介面下所有方法
//省略 get set方法...
}
Function物件包括sql的型別、方法名、sql陳述句、回傳型別和引數型別，
package com.liugh.config;
public class Function {
private String sqltype;
private String funcName;
private String sql;
private Object resultType;
private String parameterType;
//省略 get set方法
}
接下來實作我們的MySqlSession,首先的成員變數里得有Excutor和MyConfiguration，代碼的精髓就在getMapper的方法里，
package com.liugh.sqlSession;
import java.lang.reflect.Proxy;
public class MySqlsession {
private Excutor excutor= new MyExcutor();
private MyConfiguration myConfiguration = new MyConfiguration();
public <T> T selectOne(String statement,Object parameter){
return excutor.query(statement, parameter);
}
@SuppressWarnings("unchecked")
public <T> T getMapper(Class<T> clas){
//動態代理呼叫
return (T)Proxy.newProxyInstance(clas.getClassLoader(),new Class\[\]{clas},
new MyMapperProxy(myConfiguration,this));
}
}
緊接著創建Excutor和實作類：
package com.liugh.sqlSession;
public interface Excutor {
public <T> T query(String statement,Object parameter);
}
MyExcutor中封裝了JDBC的操作：
package com.liugh.sqlSession;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import com.liugh.bean.User;
public class MyExcutor implements Excutor{
private MyConfiguration xmlConfiguration = new MyConfiguration();
@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();
User u=new User();
//遍歷結果集
while(set.next()){
u.setId(set.getString(1));
u.setUsername(set.getString(2));
u.setPassword(set.getString(3));
}
return (T) u;
} catch (SQLException e) {
e.printStackTrace();
} finally{
try{
if(set!=null){
set.close();
}if(pre!=null){
pre.close();
}if(connection!=null){
connection.close();
}
}catch(Exception e2){
e2.printStackTrace();
}
}
return null;
}
private Connection getConnection() {
try {
Connection connection =xmlConfiguration.build("config.xml");
return connection;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
MyMapperProxy代理類完成xml方法和真實方法對應，執行查詢：
package com.liugh.sqlSession;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.List;
import com.liugh.config.Function;
import com.liugh.config.MapperBean;
public class MyMapperProxy implements InvocationHandler{
private MySqlsession mySqlsession;
private MyConfiguration myConfiguration;
public MyMapperProxy(MyConfiguration myConfiguration,MySqlsession mySqlsession) {
this.myConfiguration=myConfiguration;
this.mySqlsession=mySqlsession;
}
@Override
public Object invoke(Object proxy, Method method, Object\[\] args) throws Throwable {
MapperBean readMapper = myConfiguration.readMapper("UserMapper.xml");
//是否是xml檔案對應的介面
if(!method.getDeclaringClass().getName().equals(readMapper.getInterfaceName())){
return null;
}
List<Function\> list = readMapper.getList();
if(null != list || 0 != list.size()){
for (Function function : list) {
//id是否和介面方法名一樣
if(method.getName().equals(function.getFuncName())){
return mySqlsession.selectOne(function.getSql(), String.valueOf(args\[0\]));
}
}
}
return null;
}
}
到這里，就完成了自己的Mybatis框架，我們測驗一下：
package com.liugh;
import com.liugh.bean.User;
import com.liugh.mapper.UserMapper;
import com.liugh.sqlSession.MySqlsession;
public class TestMybatis {
public static void main(String\[\] args) {
MySqlsession sqlsession=new MySqlsession();
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
User user = mapper.getUserById("1");
System.out.println(user);
}
}
執行結果：
查詢一個不存在的用戶試試：
到這里我們就大功告成了！
關注公眾號Java技術堆疊回復"面試"獲取我整理的2020最全面試題及答案，
推薦去我的博客閱讀更多：
1.Java JVM、集合、多執行緒、新特性系列教程
2.Spring MVC、Spring Boot、Spring Cloud 系列教程
3.Maven、Git、Eclipse、Intellij IDEA 系列工具教程
4.Java、后端、架構、阿里巴巴等大廠最新面試題
覺得不錯，別忘了點贊+轉發哦！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/149324.html
標籤：Java