解析MyBatis源碼實現自定義持久層框架
自定義框架設計
使用端 ：
提供核⼼配置⽂件：
sqlMapConfig.xml : 存放數據源信息，引⼊mapper.xml
Mapper.xml : sql語句的配置⽂件信息
框架端：
1.讀取配置⽂件
讀取完成以後以流的形式存在，我們不能將讀取到的配置信息以流的形式存放在內存中，不好操作，可以創建JavaBean來存儲
（1）Configuration : 存放數據庫基本信息、Map<唯⼀標識，Mapper>， 唯⼀標識：namespace + "." + id
（2）MappedStatement：sql語句的id、sql語句、輸⼊參數java類型、輸出參數java類型
2.解析配置⽂件
創建SqlSessionFactoryBuilder類：
⽅法：返回值SqlSessionFactory，方法為build()：
第⼀：使⽤dom4j解析配置⽂件，將解析出來的內容封裝到Configuration和MappedStatement中
第⼆：創建SqlSessionFactory的實現類DefaultSqlSessionFactory
3.創建SqlSessionFactory：
⽅法：openSession() : 獲取SqlSession接⼝的實現類實例對象
4.創建SqlSession接⼝及實現類：主要封裝crud⽅法
⽅法：selectList(String mappedStatementId,Object... param)：查詢所有
selectOne(String mappedStatementId,Object... param)：查詢單個
具體實現：封裝JDBC完成對數據庫表的查詢操作
涉及到的設計模式 ：
Builder構建者模式、⼯⼚模式、代理模式
自定義框架實現
這裡隻做比較繁瑣的查詢單條和查詢多條的實現，添加、修改、刪除的參考自行實現。
使用端
創建sqlMapConfig.xml
<configuration>
<!--數據庫配置信息-->
<dataSource>
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///learning_db"></property>
<property name="username" value="root"></property>
<property name="password" value="123456"></property>
</dataSource>
<!--存放mapper.xml的全路徑-->
<mapper resource="UserMapper.xml"></mapper>
</configuration>
mapper.xml
<mapper namespace="com.snf.mapper.UserMapper">
<!--sql的唯一標識：namespace.id來組成 ： mappedStatementId-->
<select id="findAll" resultType="com.snf.domain.User" >
select * from user
</select>
<!--
User user = new User()
user.setId(1);
user.setUsername("zhangsan")
-->
<select id="findByCondition" resultType="com.snf.domain.User" parameterType="com.snf.domain.User">
select * from user where id = #{id} and username = #{username}
</select>
</mapper>
User實體類
public class User {
private Integer id;
private String username;
public User() {
}
public User(Integer id, String username) {
this.id = id;
this.username = username;
}
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;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
'}';
}
}
框架端
創建⼀個Maven⼦⼯程並且導⼊需要⽤到的依賴坐標
<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.encoding>UTF-8</maven.compiler.encoding> <java.version>1.8</java.version> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.17</version> </dependency> <dependency> <groupId>c3p0</groupId> <artifactId>c3p0</artifactId> <version>0.9.1.2</version> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.12</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.10</version> </dependency> <dependency> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> <version>1.6.1</version> </dependency> <dependency> <groupId>jaxen</groupId> <artifactId>jaxen</artifactId> <version>1.1.6</version> </dependency> </dependencies>
Configuration配置類
public class Configuration {
private DataSource dataSource;
/**
* key:statementId value:封裝好的mappedStatement對象
*/
private Map<String,MappedStatement> mappedStatementMap = new HashMap<>();
public DataSource getDataSource() {
return dataSource;
}
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public Map<String, MappedStatement> getMappedStatementMap() {
return mappedStatementMap;
}
public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) {
this.mappedStatementMap = mappedStatementMap;
}
}
MappedStatement類
public class MappedStatement {
//sql語句id
private String id;
//sql語句
private String sql;
//輸入參數類型
private String parameterType;
//返回參數類型
private String resultType;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getSql() {
return sql;
}
public void setSql(String sql) {
this.sql = sql;
}
public String getParameterType() {
return parameterType;
}
public void setParameterType(String parameterType) {
this.parameterType = parameterType;
}
public String getResultType() {
return resultType;
}
public void setResultType(String resultType) {
this.resultType = resultType;
}
}
Resources類
public class Resources {
//以流的形式讀取配置文件
public static InputStream getResourceAsStream(String path){
InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path);
return resourceAsStream;
}
}
SqlSessionFactoryBuilder類
public class SqlSessionFactoryBuilder {
public SqlSessionFactory build(InputStream inputStream) throws PropertyVetoException, DocumentException {
//使用dom4j解析配置文件,將解析出來的內容封裝到Configuration中
XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
Configuration configuration = xmlConfigBuilder.parseConfig(inputStream);
//創建sqlSessionFactory工廠對象：生產sqlSession
DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);
return defaultSqlSessionFactory;
}
}
XMLConfigBuilder類
public class XMLConfigBuilder {
private Configuration configuration;
public XMLConfigBuilder() {
this.configuration = new Configuration();
}
/**
* 使用dom4j對配置文件進行封裝,封裝Configuration
*/
public Configuration parseConfig(InputStream inputStream) throws DocumentException, PropertyVetoException {
Document document = new SAXReader().read(inputStream);
Element rootElement = document.getRootElement();
List<Element> list = rootElement.selectNodes("//property");
Properties properties = new Properties();
list.forEach(element -> {
String name = element.attributeValue("name");
String value = element.attributeValue("value");
properties.setProperty(name, value);
});
ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
comboPooledDataSource.setDriverClass(properties.getProperty("driverClass"));
comboPooledDataSource.setJdbcUrl(properties.getProperty("jdbcUrl"));
comboPooledDataSource.setUser(properties.getProperty("username"));
comboPooledDataSource.setPassword(properties.getProperty("password"));
configuration.setDataSource(comboPooledDataSource);
//解析<Mapper>標簽
List<Element> mapperList = rootElement.selectNodes("//mapper");
mapperList.stream()
.map(x -> x.attributeValue("resource"))
.map(Resources::getResourceAsStream)
.forEach(resourceAsStream -> {
XmlMapperBuilder xmlMapperBuilder = new XmlMapperBuilder(configuration);
try {
xmlMapperBuilder.parse(resourceAsStream);
} catch (DocumentException e) {
e.printStackTrace();
}
});
return configuration;
}
}
XMLMapperBuilder類
public class XmlMapperBuilder {
private Configuration configuration;
public XmlMapperBuilder(Configuration configuration) {
this.configuration = configuration;
}
public void parse(InputStream inputStream) throws DocumentException {
Document document = new SAXReader().read(inputStream);
Element rootElement = document.getRootElement();
String namespace = rootElement.attributeValue("namespace");
List<Element> list = rootElement.selectNodes("//select");
list.forEach(element -> {
String id = element.attributeValue("id");
String parameterType = element.attributeValue("parameterType");
String resultType = element.attributeValue("resultType");
String sqlText = element.getTextTrim();
MappedStatement mappedStatement = new MappedStatement();
mappedStatement.setId(id);
mappedStatement.setParameterType(parameterType);
mappedStatement.setResultType(resultType);
mappedStatement.setSql(sqlText);
String key = namespace.concat(".").concat(id);
configuration.getMappedStatementMap().put(key, mappedStatement);
});
}
}
SqlSessionFactory接口及DefaultSqlSessionFactory實現類
public interface SqlSessionFactory {
SqlSession openSession();
}
public class DefaultSqlSessionFactory implements SqlSessionFactory {
private Configuration configuration;
public DefaultSqlSessionFactory(Configuration configuration) {
this.configuration = configuration;
}
@Override
public SqlSession openSession() {
return new DefaultSqlSession(configuration);
}
}
SqlSession接口及DefaultSqlSession實現類
public interface SqlSession {
//查詢所有
<E> List<E> selectList(String mappedStatementId,Object... params) throws IllegalAccessException, IntrospectionException, InstantiationException, NoSuchFieldException, SQLException, InvocationTargetException, ClassNotFoundException;
//根據條件
<T> T selectOne(String mappedStatementId,Object... params) throws IllegalAccessException, ClassNotFoundException, IntrospectionException, InstantiationException, SQLException, InvocationTargetException, NoSuchFieldException;
//為Dao接口生成代理實現類
<T> T getMapper(Class<T> mapperClass);
}
public class DefaultSqlSession implements SqlSession {
private Configuration configuration;
public DefaultSqlSession(Configuration configuration) {
this.configuration = configuration;
}
@Override
public <E> List<E> selectList(String mappedStatementId, Object... params) throws IllegalAccessException, IntrospectionException, InstantiationException, NoSuchFieldException, SQLException, InvocationTargetException, ClassNotFoundException {
SimpleExecutor simpleExecutor = new SimpleExecutor();
MappedStatement mappedStatement = configuration.getMappedStatementMap().get(mappedStatementId);
List<Object> objectList = simpleExecutor.query(configuration, mappedStatement, params);
return (List<E>) objectList;
}
@Override
public <T> T selectOne(String mappedStatementId, Object... params) throws IllegalAccessException, ClassNotFoundException, IntrospectionException, InstantiationException, SQLException, InvocationTargetException, NoSuchFieldException {
List<Object> objectList = selectList(mappedStatementId, params);
if (objectList.size() == 1) {
return (T) objectList.get(0);
} else {
throw new RuntimeException("查詢結果為空或者返回結果過多！");
}
}
@Override
public <T> T getMapper(Class<T> mapperClass) {
//使用JDK動態代理來為Dao接口生成代理對象,並返回
return (T) Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{mapperClass}, ((proxy, method, args) -> {
String methodName = method.getName();
String className = method.getDeclaringClass().getName();
String mappedStatementId = className.concat(".").concat(methodName);
//獲取被調用方法的返回值類型
Type genericReturnType = method.getGenericReturnType();
//判斷是否進行瞭泛型類型參數化
if (genericReturnType instanceof ParameterizedType){
List<Object> objectList = selectList(mappedStatementId, args);
return objectList;
}
return selectOne(mappedStatementId,args);
}));
}
}
Executor接口及SimpleExecutor實現類
public interface Executor {
<E>List<E> query(Configuration configuration, MappedStatement mappedStatement,Object... params) throws SQLException, IntrospectionException, InvocationTargetException, IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchFieldException;
}
public class SimpleExecutor implements Executor {
@Override
public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws SQLException, IntrospectionException, InvocationTargetException, IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchFieldException {
//註冊驅動,獲取連接
Connection connection = configuration.getDataSource().getConnection();
//獲取sql語句：select * from user where id = #{id} and username = #{username}
//轉換sql語句：select * from user where id = ? and username = ?
//轉換的過程中,還需要對#{}裡面的參數名稱進行解析存儲
String sql = mappedStatement.getSql();
BoundSql boundSql = getBoundSql(sql);
//獲取預處理對象：preparedStatement
PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
//設置參數
//獲取到瞭參數的全路徑
String parameterType = mappedStatement.getParameterType();
Class<?> parameterTypeClass = getClassType(parameterType);
List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
for (int i = 0; i < parameterMappingList.size(); i++) {
ParameterMapping parameterMapping = parameterMappingList.get(i);
String content = parameterMapping.getContent();
//反射
Field declaredField = parameterTypeClass.getDeclaredField(content);
//暴力訪問
declaredField.setAccessible(true);
Object o = declaredField.get(params[0]);
preparedStatement.setObject(i + 1, o);
}
//執行sql
ResultSet resultSet = preparedStatement.executeQuery();
String resultType = mappedStatement.getResultType();
Class<?> resultTypeClass = getClassType(resultType);
List<Object> objectList = new ArrayList<>();
//封裝返回結果集
while (resultSet.next()) {
Object o = resultTypeClass.newInstance();
//元數據
ResultSetMetaData metaData = resultSet.getMetaData();
for (int i = 1; i <= metaData.getColumnCount(); i++) {
// 字段名
String columnName = metaData.getColumnName(i);
// 字段的值
Object value = resultSet.getObject(columnName);
//使用反射或者內省,根據數據庫表和實體的對應關系,完成封裝
PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass);
Method writeMethod = propertyDescriptor.getWriteMethod();
writeMethod.invoke(o, value);
}
objectList.add(o);
}
return (List<E>) objectList;
}
private Class<?> getClassType(String paramterType) throws ClassNotFoundException {
if (paramterType != null) {
Class<?> aClass = Class.forName(paramterType);
return aClass;
}
return null;
}
/**
* 完成對#{}的解析工作
* 1.將#{}使用?進行代替
* 2.解析出#{}裡面的字段名進行存儲
*
* @param sql
* @return
*/
private BoundSql getBoundSql(String sql) {
//標記處理類：配置標記解析器來完成對占位符的解析處理工作
ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
//解析出來的sql
String parseSql = genericTokenParser.parse(sql);
//#{}裡面解析出來的參數名稱
List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
BoundSql boundSql = new BoundSql(parseSql, parameterMappings);
return boundSql;
}
}
BoundSql類
public class BoundSql {
private String sqlText; //解析過後的sql
private List<ParameterMapping> parameterMappingList = new ArrayList<>();
public BoundSql(String sqlText, List<ParameterMapping> parameterMappingList) {
this.sqlText = sqlText;
this.parameterMappingList = parameterMappingList;
}
public String getSqlText() {
return sqlText;
}
public void setSqlText(String sqlText) {
this.sqlText = sqlText;
}
public List<ParameterMapping> getParameterMappingList() {
return parameterMappingList;
}
public void setParameterMappingList(List<ParameterMapping> parameterMappingList) {
this.parameterMappingList = parameterMappingList;
}
}
GenericTokenParser、ParameterMapping、TokenHandler、ParameterMappingTokenHandler工具類
-
GenericTokenParser：解析${}或#{}中的參數名稱
-
ParameterMapping：存儲${}或#{}中的參數名稱
-
TokenHandler：替換${}或#{}處理接口
-
ParameterMappingTokenHandler：替換${}或#{}處理接口的實現類
public class GenericTokenParser {
private final String openToken; //開始標記
private final String closeToken; //結束標記
private final TokenHandler handler; //標記處理器
public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
this.openToken = openToken;
this.closeToken = closeToken;
this.handler = handler;
}
/**
* 解析${}和#{}
* @param text
* @return
* 該方法主要實現瞭配置文件、腳本等片段中占位符的解析、處理工作，並返回最終需要的數據。
* 其中，解析工作由該方法完成，處理工作是由處理器handler的handleToken()方法來實現
*/
public String parse(String text) {
// 驗證參數問題，如果是null，就返回空字符串。
if (text == null || text.isEmpty()) {
return "";
}
// 下面繼續驗證是否包含開始標簽，如果不包含，默認不是占位符，直接原樣返回即可，否則繼續執行。
int start = text.indexOf(openToken, 0);
if (start == -1) {
return text;
}
// 把text轉成字符數組src，並且定義默認偏移量offset=0、存儲最終需要返回字符串的變量builder，
// text變量中占位符對應的變量名expression。判斷start是否大於-1(即text中是否存在openToken)，如果存在就執行下面代碼
char[] src = text.toCharArray();
int offset = 0;
final StringBuilder builder = new StringBuilder();
StringBuilder expression = null;
while (start > -1) {
// 判斷如果開始標記前如果有轉義字符，就不作為openToken進行處理，否則繼續處理
if (start > 0 && src[start - 1] == '\\') {
builder.append(src, offset, start - offset - 1).append(openToken);
offset = start + openToken.length();
} else {
//重置expression變量，避免空指針或者老數據幹擾。
if (expression == null) {
expression = new StringBuilder();
} else {
expression.setLength(0);
}
builder.append(src, offset, start - offset);
offset = start + openToken.length();
int end = text.indexOf(closeToken, offset);
while (end > -1) {////存在結束標記時
if (end > offset && src[end - 1] == '\\') {//如果結束標記前面有轉義字符時
// this close token is escaped. remove the backslash and continue.
expression.append(src, offset, end - offset - 1).append(closeToken);
offset = end + closeToken.length();
end = text.indexOf(closeToken, offset);
} else {//不存在轉義字符，即需要作為參數進行處理
expression.append(src, offset, end - offset);
offset = end + closeToken.length();
break;
}
}
if (end == -1) {
// close token was not found.
builder.append(src, start, src.length - start);
offset = src.length;
} else {
//首先根據參數的key（即expression）進行參數處理，返回?作為占位符
builder.append(handler.handleToken(expression.toString()));
offset = end + closeToken.length();
}
}
start = text.indexOf(openToken, offset);
}
if (offset < src.length) {
builder.append(src, offset, src.length - offset);
}
return builder.toString();
}
}
public class ParameterMapping {
private String content;
public ParameterMapping(String content) {
this.content = content;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
public interface TokenHandler {
String handleToken(String content);
}
public class ParameterMappingTokenHandler implements TokenHandler {
private List<ParameterMapping> parameterMappings = new ArrayList<>();
// context是參數名稱 #{id} #{username}
public String handleToken(String content) {
parameterMappings.add(buildParameterMapping(content));
return "?";
}
private ParameterMapping buildParameterMapping(String content) {
ParameterMapping parameterMapping = new ParameterMapping(content);
return parameterMapping;
}
public List<ParameterMapping> getParameterMappings() {
return parameterMappings;
}
public void setParameterMappings(List<ParameterMapping> parameterMappings) {
this.parameterMappings = parameterMappings;
}
}
到此這篇關於手撕MyBatis源碼實現自定義持久層框架的文章就介紹到這瞭,更多相關MyBatis自定義持久層框架內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！