mybatis学习笔记（一）自定义JDBC
JDBC
mybatis的底层用的依旧是 JDBC 去获取数据库连接进行数据库访问的。
JDBC基础代码
// An highlighted block
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null; try
// 加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
// 通过驱动管理类获取数据库链接
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis? characterEncoding=utf-8", "root", "root");
// 定义sql语句？表示占位符
String sql = "select * from user where username = ?";
// 获取预处理
statement preparedStatement = connection.prepareStatement(sql);
// 设置参数，第一个参数为sql语句中参数的序号(从1开始)，第二个参数为设置的参数值
preparedStatement.setString(1, "tom");
// 向数据库发出sql执行查询，查询出结果集
resultSet = preparedStatement.executeQuery();
// 遍历查询结果集
while (resultSet.next()) {
int id = resultSet.getInt("id"); String username = resultSet.getString("username");
// 封装User
user.setId(id); user.setUsername(username);
}
System.out.println(user);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 释放资源
if (resultSet != null) {
try {resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (preparedStatement != null) {
try {
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
}
原生JDBC中存在的问题
从以上代码中不难看出，JDBC连接数据库查询存在以下问题：
1、 每次查询都需要做数据库连接，并释放连接，浪费资源。
2、 Sql语句在代码中硬编码（连接参数，sql执行语句，传入参数）。
3、 结果集中解析结果同样存在硬编码
解决方案
根据以上的问题所在，给予对应的解决方法：
1、使用数据库连接池初始化数据库连接，并将连接参数放入xml文件中
2、将sql语句放入xml文件中
3、使用反射、内省自动实现ORM，ORM一般指对象关系映射，即数据库表与实体对应，表中字段对应实体中的属性。
进行自定义持久层框架
创建核心的配置文件
sqlMapConfig.xml:存放连接数据库的参数，以及相关配置信息，即引入mapper.xml，等。
mapper.xml：存放sql语句，以及入参和出参等配置信息。
框架整体流程
1、读取配置文件
读取配置文件，将配置文件信息以inputstream的形式存在内存中，对该inputstream进行解析，同时将解析出来的信息，存入到对应的类中。
Resources
该类提供方法传入getRsourceAsSteam，入参为inputstream。
Configuration
该类用来存放数据库连接信息，以及一个map集合，其中map集合为MappedStatement的一个map集合。
MappedStatement
该类用来存放sql语句的配置信息，所执行的sql类型，入参类型，出参类型
2.解析配置文件
使用dom4j来解析配置文件，需要创建SqlSessionFactoryBuilder类，SqlSessionFactory接口
SqlSessionFactoryBuilder
该类中的build方法中执行dom4j解析，并将解析内容封装到configuration类中
SqlSessionFactory
主要作用就是生产sqlSession。
3. 创建SqlSessionFactory的实现类
DefaultSqlSessionFactory
其主要作用就是实现SqlSessionFactory中的openSession方法进行sqlSession生产。
4.创建SqlSession接口以及其实现类DefaultSqlSession
DefaultSqlSession
定义数据库操作CRDU 。
5.创建Executor 接口以及其实现类SimpleExecutor
SimpleExecutor
其作用来执行底层的JDBC代码
设计者模式
构建者模式、工厂模式、代理模式
代码实现
sqlMapConfig.xml
<configuration>
<dataSource>
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///test"></property>
<property name="userName" value="root"></property>
<property name="password" value="root"></property>
</dataSource>
<!--存放mapper的路径-->
<mapper resource="UserMapper.xml"></mapper>
</configuration>
UserMapper.xml
<mapper nameSpace="com.lagou.test.dao.IUserDao">
<!--sql的唯一标示：nameSpace.id组成-->
<select id="findAll" resultType="com.lagou.test.pojo.User" >
select * from user
</select>
<select id="findByCondition" resultType="com.lagou.test.pojo.User" paramterType="com.lagou.test.pojo.User">
select * from user where id=#{id} and username=#{username}
</select>
<insert id="insert" paramterType="com.lagou.test.pojo.User">
insert into user (id,username) values (#{id},#{username})
</insert>
<update id="updateUser" paramterType="com.lagou.test.pojo.User">
update user set username =#{username} where id=#{id}
</update>
<delete id="deleteUser" paramterType="java.lang.Integer">
delete from user where id =#{id}
</delete>
<delete id="deleteUser1" paramterType="com.lagou.test.pojo.User">
delete from user where id =#{id}
</delete>
</mapper>
User类
public class User {
private Integer id;
private String username;
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
'}';
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
}
Configuration
public class Configuration {
private DataSource dataSource;
/**
* key用statement.id来构成
*/
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 {
//id标示
private String id;
//返回值类型
private String resultType;
//参数类型
private String paramterType;
//sql语句
private String sql;
//sql类型
private String sqlType;
public String getSqlType() {
return sqlType;
}
public void setSqlType(String sqlType) {
this.sqlType = sqlType;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getResultType() {
return resultType;
}
public void setResultType(String resultType) {
this.resultType = resultType;
}
public String getParamterType() {
return paramterType;
}
public void setParamterType(String paramterType) {
this.paramterType = paramterType;
}
public String getSql() {
return sql;
}
public void setSql(String sql) {
this.sql = sql;
}
}
Resources
public class Resource {
//根据配置文件的路径，将配置文件加载成字节输入流，存入内存
public static InputStream getResourceAsStream(String path){
InputStream resourceAsStream = Resource.class.getClassLoader().getResourceAsStream(path);
return resourceAsStream;
}
}
SqlSessionFactoryBuilder
public class SqlSessionFactoryBuilder {
public SqlSessionFactory bulid(InputStream in) throws DocumentException, PropertyVetoException {
//1、使用dom4j解析配置文件，将解析出来的内容封装成configuration中
XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
Configuration configuration = xmlConfigBuilder.parseConfig(in);
//2、创建SqlSessionFactory
DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);
return defaultSqlSessionFactory;
}
}
DefaultSqlSessionFactory
public class DefaultSqlSessionFactory implements SqlSessionFactory {
private Configuration configuration;
public DefaultSqlSessionFactory(Configuration configuration) {
this.configuration=configuration;
}
@Override
public SqlSession openSession(){
return new DefaultSqlSession(configuration);
}
}
DefaultSqlSession
public class DefaultSqlSession implements SqlSession {
private Configuration configuration;
public DefaultSqlSession(Configuration configuration) {
this.configuration = configuration;
}
@Override
public <E> List<E> selectList(String statementid, Object... params) throws Exception {
SimpleExecutor simpleExecutor = new SimpleExecutor();
List<Object> list = simpleExecutor.query(configuration, configuration.getMappedStatementMap().get(statementid), params);
return (List<E>) list;
}
@Override
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 int update(String statementid, Object... params) throws Exception {
SimpleExecutor simpleExecutor = new SimpleExecutor();
int update = simpleExecutor.update(configuration, configuration.getMappedStatementMap().get(statementid), params);
return update;
}
@Override
public <T> T getMapper(Class<T> 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， 根据不同情况来调用selectList或者selectOne
//准备参数1、statementid 组成是namespce.id
String methodName = method.getName();
String className = method.getDeclaringClass().getName();
String statementId=className+"."+methodName;
MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
String sqlType = mappedStatement.getSqlType();
if(sqlType.equals("select")){
Type genericReturnType = method.getGenericReturnType();
//是否进行了泛型类型参数换
if(genericReturnType instanceof ParameterizedType){
List<Object> list = selectList(statementId, args);
return list;
}
return selectOne(statementId,args);
}else if(sqlType.equals("insert")||sqlType.equals("update")||sqlType.equals("delete")){
int update = update(statementId, args);
return update;
}else{
return "类型错误";
}
}
});
return (T) proxyInstance;
}
}
SimpleExecutor
public class SimpleExecutor implements Executor {
void parseParameterMappingList(List<ParameterMapping> parameterMappingList, Class<?> paramterTypeClass, PreparedStatement preparedStatement, Object[] params) throws Exception{
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);
}
}
@Override
public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception {
//1、注册驱动，获取链接
Connection connection = configuration.getDataSource().getConnection();
//2、获取sql语句
//转换sql语句，替换其中的#占位符为?,转换的过程中需要对#{}中的值进行解析储存;
String sql = mappedStatement.getSql();
BoundSql boundSql=getBoundSql(sql);
//获取参数全路径
String paramterType = mappedStatement.getParamterType();
Class<?> paramterTypeClass=getClassType(paramterType);
PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
parseParameterMappingList(parameterMappingList,paramterTypeClass,preparedStatement,params);
//执行sql
ResultSet resultSet = preparedStatement.executeQuery();
String resultType = mappedStatement.getResultType();
Class<?> resultTypeClass = getClassType(resultType);
ArrayList<Object> objects = new ArrayList<>();
//封装返回结果集
while (resultSet.next()){
ResultSetMetaData metaData = resultSet.getMetaData();
Object o = resultTypeClass.newInstance();
int columnCount = metaData.getColumnCount();
for (int i = 1; i <=columnCount; 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;
}
/**
* 转换sql语句，替换其中的#占位符为?,转换的过程中需要对#{}中的值进行解析储存;
*/
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;
}
public int update(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception{
//1、注册驱动，获取链接
Connection connection = configuration.getDataSource().getConnection();
//2、获取sql语句
//转换sql语句，替换其中的#占位符为?,转换的过程中需要对#{}中的值进行解析储存;
String sql = mappedStatement.getSql();
BoundSql boundSql=getBoundSql(sql);
//获取参数全路径
String paramterType = mappedStatement.getParamterType();
Class<?> paramterTypeClass=getClassType(paramterType);
PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
if(parameterMappingList.size()==1){
Object param = params[0];
String canonicalName = param.getClass().getCanonicalName();
if(canonicalName.equals("com.lagou.test.pojo.User")){
parseParameterMappingList(parameterMappingList,paramterTypeClass,preparedStatement,params);
}else {
preparedStatement.setObject(1,params[0]);
}
}else{
parseParameterMappingList(parameterMappingList,paramterTypeClass,preparedStatement,params);
}
//执行sql并返回
return preparedStatement.executeUpdate();
}
}
结语
至此，自定义mybatis持久层框架以及基本完成。其中对应的boundsql类以及xml解析类，没有做列出。通过自定义该持久层框架，为我们阅读mybatis源码打下基础。
417
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
