解析MyBatis源码实现自定义持久层框架

解析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

mapper.xml

select * from user

select * from user where id = #{id} and username = #{username}

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⼦⼯程并且导⼊需要⽤到的依赖坐标

UTF-8

UTF-8

1.8

1.8

1.8

mysql

mysql-connector-java

5.1.17

c3p0

c3p0

0.9.1.2

log4j

log4j

1.2.12

junit

junit

4.10

BgvTYyzdom4j

dom4j

1.6.1

jaxen

jaxen

1.1.6

Configuration配置类

public class Configuration {

private DataSource dataSource;

/**

* key:statementId value:封装好的mappedStatement对象

*/

private Map mappedStatementMap = new HashMap<>();

public DataSource getDataSource() {

return dataSource;

}

public void setDataSource(DataSource dataSource) {

this.dataSource = dataSource;

}

public Map getMappedStatementMap() {

return mappedStatementMap;

}

public void setMappedStatementMap(Map 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 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);

//解析标签

List 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 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 {

//查询所有

List selectList(String mappedStatementId,Object... params) throws IllegalAccessException, IntrospectionException, InstantiationException, NoSuchFieldException, SQLException, InvocationTargetException, ClassNotFoundException;

//根据条件

T selectOne(String mappedStatementId,Object... params) throws IllegalAccessException, ClassNotFoundException, IntrospectionException, InstantiationException, SQLException, InvocationTargetException, NoSuchFieldException;

//为Dao接口生成代理实现类

T getMapper(Class mapperClass);

}

public class DefaultSqlSession implements SqlSession {

private Configuration configuration;

public DefaultSqlSession(Configuration configuration) {

this.configuration = configuration;

}

@Override

public List selectList(String mappedStatementId, Object... params) throws IllegalAccessException, IntrospectionException, InstantiationException, NoSuchFieldException, SQLException, InvocationTargetException, ClassNotFoundException {

SimpleExecutor simpleExecutor = new SimpleExecutor();

MappedStatement mappedStatement = configuration.getMappedStatementMap().get(mappedStatementId);

List

return (List) objectList;

}

@Override

public T selectOne(String mappedStatementId, Object... params) throws IllegalAccessException, ClassNotFoundException, IntrospectionException, InstantiationException, SQLException, InvocationTargetException, NoSuchFieldException {

List

if (objectList.size() == 1) {

return (T) objectList.get(0);

} else {

throw new RuntimeException("查询结果为空或者返回结果过多！");

}

}

@Override

public T getMapper(Class 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

return objectList;

}

return selectOne(mappedStatementId,args);

}));

}

}

Executor接口及SimpleExecutor实现类

public interface Executor {

List query(Configuration configuration, MappedStatement mappedStatement,Object... params) throws SQLException, IntrospectionException, InvocationTargetException, IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchFieldException;

}

public class SimpleExecutor implements Executor {

@Override

public List 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 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

//封装返回结果集

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) 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 parameterMappings = parameterMappingTokenHandler.getParameterMappings();

BoundSql boundSql = new BoundSql(parseSql, parameterMappings);

return boundSql;

}

}

BoundSql类

public class BoundSql {

private String sqlText; //解析过后的sql

private List parameterMappingList = new ArrayList<>();

public BoundSql(String sqlText, List parameterMappingList) {

this.sqlText = sqlText;

this.parameterMappingList = parameterMappingList;

}

public String getSqlText() {

return sqlText;

}

public void setSqlText(String sqlText) {

this.sqlText = sqlText;

}

public List getParameterMappingList() {

return parameterMappingList;

}

public void setParameterMappingList(List 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 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 getParameterMappings() {

return parameterMappings;

}

public void setParameterMappings(List parameterMappings) {

this.parameterMappings = parameterMappings;

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。