背景
写了一个简易的mybatis，实现了通过mybatis代理增强Dao层的基本逻辑，这里梳理一下这个Demo的执行流程
核心流程
1.用户通过加载核心配置文件获得输入流，放在内存中
2.通过流信息构建工厂
3.通过工厂打开SqlSession对象
4.SqlSession对象通过getMapper方法获得被代理的接口对象
5.那个被代理的接口对象有增强的方法，通过这个对象操作数据库
实现细节
包结构
1.自定义mybatis包结构
config
BoundSql ：存储解析过的SQL文本；成员变量->sqlText(解析过后的sql)，parameterMappingList(参数)
XMLConfigBuilder ：解析xml的类；成员变量->Configuration
XMLMapperBuilder ：解析xml中mapper的类，调用时机是在XMLConfigBuilder.build() 执行时；成员变量->Configuration
io
Resources ：根据配置文件的路径，将配置文件加载成字节输入流，存储在内存中
pojo
Configuration ：核心配置对象会把sqlMapConfig.xml中的信息解析在这个对象里；成员变量->dataSource(数据源信息)，Map<String,MappedStatement>(key: statementid value:封装好的mappedStatement对象)
MappedStatement ：Mapper中的SQL解析对象，会把用户定义的Mapper里的信息放在这里面；成员变量->id(id表识)，resultType(返回值类型)，parameterType(参数类型)，sql(sql语句) {以上成员变量类型都是String
}
sqlSession
SqlSessionFactory：规定了SqlSessionFactory的基本功能openSession()
DefaultSqlSessionFactory：实现了SqlSessionFactory的基本功能openSession()
SqlSessionFactoryBuilder：通过build方法通过流对象创建出DefaultSqlSessionFactory对象
SqlSession：规定了SqlSession的基本功能getMapper()
DefaultSqlSession：实现了SqlSession的基本功能getMapper()。其getMapper核心是用执行器Executor完成的。
Executor：与数据库交互的对象。规定了基本功能(Configuration configuration, MappedStatement mappedStatement, Object... params)
simpleExecutor：通过前面构建出来的configuration，MappedStatement ，params实现了基本功能query。2.用户包结构
和Mybatis的结构一样~
几处核心流程分析
1.读取配置文件里的信息到configuration对象中
1.用户调用SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsSteam);创建对象
public SqlSessionFactory build(InputStream in) throws DocumentException, PropertyVetoException {
// 第一：使用dom4j解析配置文件，将解析出来的内容封装到Configuration中
XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
Configuration configuration = xmlConfigBuilder.parseConfig(in);
// 第二：创建sqlSessionFactory对象：工厂类：生产sqlSession:会话对象
DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);
return defaultSqlSessionFactory;
}2.Configuration configuration = xmlConfigBuilder.parseConfig(in);
/**
* 该方法就是使用dom4j对配置文件进行解析，封装Configuration
*/
public Configuration parseConfig(InputStream inputStream) throws DocumentException, PropertyVetoException {
Document document = new SAXReader().read(inputStream);
//<configuration>
Element rootElement = document.getRootElement();
//读取property节点
List<Element> list = rootElement.selectNodes("//property");
Properties properties = new Properties();
//读取property节点下的Element信息
for (Element element : list) {
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.xml解析: 拿到路径--字节输入流---dom4j进行解析
List<Element> mapperList = rootElement.selectNodes("//mapper");
//对于每一个mapper标签下
for (Element element : mapperList) {
String mapperPath = element.attributeValue("resource");
InputStream resourceAsSteam = Resources.getResourceAsSteam(mapperPath);
//新建一个XMLMapperBuilder对象来解析，用的是一个configuration对象
XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
xmlMapperBuilder.parse(resourceAsSteam);
}
3.xmlMapperBuilder.parse(resourceAsSteam);
public void parse(InputStream inputStream) throws DocumentException {
Document document = new SAXReader().read(inputStream);
Element rootElement = document.getRootElement();
//分别添加增删改查节点，让其可以解析这些节点信息
addNode(rootElement,"select");
addNode(rootElement,"insert");
addNode(rootElement,"update");
addNode(rootElement,"delete");
}
public void addNode(Element rootElement,String nodeName){
String namespace = rootElement.attributeValue("namespace");
List<Element> list = rootElement.selectNodes("//"+nodeName);
for (Element element : list) {
String id = element.attributeValue("id");
String resultType = element.attributeValue("resultType");
String paramterType = element.attributeValue("paramterType");
String sqlText = element.getTextTrim();
MappedStatement mappedStatement = new MappedStatement();
mappedStatement.setId(id);
mappedStatement.setResultType(resultType);
mappedStatement.setParamterType(paramterType);
mappedStatement.setSql(sqlText);
String key = namespace+"."+id;
//放到configuration里
configuration.getMappedStatementMap().put(key,mappedStatement);
System.out.println("put " + key + " : " + mappedStatement.toString());
}
}至此，Configuration里的两个对象已经填充完毕。
2.通过getMapper获得代理对象
1.用户调用SqlSession的getMapper方法为Dao接口生成代理类（MyBatis是提前就生成好代理类了）。
public class DefaultSqlSession implements SqlSession {
private Configuration configuration;
public DefaultSqlSession(Configuration configuration) {
this.configuration = configuration;
}
public <E> List<E> selectList(String statementid, Object... params) throws Exception {
//将要去完成对simpleExecutor里的query方法的调用
simpleExecutor simpleExecutor = new simpleExecutor();
MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementid);
//有可能执行insert方法
List<Object> list = simpleExecutor.query(configuration, mappedStatement, params);
return (List<E>) list;
}
public <T> T selectOne(String statementid, Object... params) throws Exception {
List<Object> objects = selectList(statementid, params);
if(objects.size()==1){
return (T) objects.get(0);
}else {
throw new RuntimeException("查询结果为空或者返回结果过多");
}
}
@Override
public <T> T getMapper(Class<?> mapperClass) {
// 使用JDK动态代理来为Dao接口生成代理对象，并返回
Object proxyInstance = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{mapperClass}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 底层都还是去执行JDBC代码 //根据不同情况，来调用selctList或者selectOne
// 准备参数 1：statmentid :sql语句的唯一标识：namespace.id= 接口全限定名.方法名
// 方法名：findAll
String methodName = method.getName();
String className = method.getDeclaringClass().getName();
String statementId = className+"."+methodName;
// 准备参数2：params:args
// 获取被调用方法的返回值类型
Type genericReturnType = method.getGenericReturnType();
// 判断是否进行了 泛型类型参数化
if(genericReturnType instanceof ParameterizedType){
List<Object> objects = selectList(statementId, args);
return objects;
}
return selectOne(statementId,args);
}
});
return (T) proxyInstance;
}
}2.这其中的simpleExecutor.query(configuration, mappedStatement, params);方法与通过之前生成的configuration和mappedStatement和params与数据库交互。
public class simpleExecutor implements Executor {
@Override //user
public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception {
// 1. 注册驱动，获取连接
Connection connection = configuration.getDataSource().getConnection();
// 2. 获取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);
// 3.获取预处理对象：preparedStatement
PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
// 4. 设置参数
//获取到了参数的全路径
String paramterType = mappedStatement.getParamterType();
Class<?> paramtertypeClass = getClassType(paramterType);
List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
for (int i = 0; i < parameterMappingList.size(); i++) {
ParameterMapping parameterMapping = parameterMappingList.get(i);
String content = parameterMapping.getContent();
//反射
Field declaredField = paramtertypeClass.getDeclaredField(content);
//暴力访问
declaredField.setAccessible(true);
Object o = declaredField.get(params[0]);
preparedStatement.setObject(i+1,o);
}
//增加，删除，修改
if("insert".equals(sql.trim().split(" ")[0]) ||
"delete".equals(sql.trim().split(" ")[0]) ||
"update".equals(sql.trim().split(" ")[0])){
int i = preparedStatement.executeUpdate();
if(i == 0){
throw new RuntimeException("操作失败，影响条数为0条");
}
else {
System.out.println("操作成功！");
List<Integer> list = new ArrayList<>();
list.add(i);
return (List<E>)list;
}
}
// 5. 执行sql
ResultSet resultSet = preparedStatement.executeQuery();
String resultType = mappedStatement.getResultType();
Class<?> resultTypeClass = getClassType(resultType);
ArrayList<Object> objects = new ArrayList<>();
// 6. 封装返回结果集
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);
}
objects.add(o);
}
return (List<E>) objects;
}
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;
}
}关于MyBatis其他的一点小说明
关于SqlSession对象selectList和getMapper两种方法的差别：
selectList，selectOne等都是通过StatmentMapper直接对象直接进行查询的。
getMapper则是把Dao对象代理了一下在执行selectList
结束
扫一扫
363
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
