Java设计模式之外观模式示例详解
292
2022-07-27
解析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⼦⼯程并且导⼊需要⽤到的依赖坐标
Configuration配置类
public class Configuration {
private DataSource dataSource;
/**
* key:statementId value:封装好的mappedStatement对象
*/
private Map
public DataSource getDataSource() {
return dataSource;
}
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public Map
return mappedStatementMap;
}
public void setMappedStatementMap(Map
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
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.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.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 {
//查询所有
//根据条件
//为Dao接口生成代理实现类
}
public class DefaultSqlSession implements SqlSession {
private Configuration configuration;
public DefaultSqlSession(Configuration configuration) {
this.configuration = configuration;
}
@Override
public
SimpleExecutor simpleExecutor = new SimpleExecutor();
MappedStatement mappedStatement = configuration.getMappedStatementMap().get(mappedStatementId);
List
return (List
}
@Override
public
List
if (objectList.size() == 1) {
return (T) objectList.get(0);
} else {
throw new RuntimeException("查询结果为空或者返回结果过多！");
}
}
@Override
public
//使用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 {
}
public class SimpleExecutor implements Executor {
@Override
public
//注册驱动,获取连接
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
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
}
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
BoundSql boundSql = new BoundSql(parseSql, parameterMappings);
return boundSql;
}
}
BoundSql类
public class BoundSql {
private String sqlText; //解析过后的sql
private List
public BoundSql(String sqlText, List
this.sqlText = sqlText;
this.parameterMappingList = parameterMappingList;
}
public String getSqlText() {
return sqlText;
}
public void setSqlText(String sqlText) {
this.sqlText = sqlText;
}
public List
return parameterMappingList;
}
public void setParameterMappingList(List
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
// 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
return parameterMappings;
}
public void setParameterMappings(List
this.parameterMappings = parameterMappings;
}
}
版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。
相关文章
发表评论
暂时没有评论，来抢沙发吧~