手写开源ORM框架介绍
简介
前段时间利用空闲时间，参照mybatis的基本思路手写了一个ORM框架。一直没有时间去补充相应的文档，现在正好抽时间去整理下。通过思路历程和代码注释，一方面重温下知识，另一方面准备后期去完善这个框架。
传统JDBC连接
参照传统的JDBC连接数据库过程如下，框架所做的事情就是把这些步骤进行封装。
// 1. 注册 JDBC 驱动 Class.forName(JDBC_DRIVER); // 2. 打开链接 conn = DriverManager.getConnection(DB_URL,USER,PASS); // 3. 实例化statement stmt = conn.prepareStatement(sql); // 4. 填充数据 stmt.setString(1,id); // 5. 执行Sql连接 ResultSet rs = stmt.executeQuery(); // 6. 结果查询 while(rs.next()){ // 7. 通过字段检索 int id = rs.getInt("id"); String name = rs.getString("name"); String url = rs.getString("url"); }
思路历程
上述是执行Java连接数据库通用语句，ORM框架就是对象关系映射框架。我们需要做的重点是步骤4和7，将对象字段填充至数据库，将数据库的内容取出作为对象返回。了解了基本的方法后，开始动手写一个框架了。
数据库驱动
开始，需要构建一个驱动注册类，这个类主要用来对数据库驱动进行构造。详见代码块1
代码块1
数据库驱动类（com.simple.ibatis.dirver）
/** * @Author xiabing * @Desc 驱动注册中心，对数据库驱动进行注册的地方 **/ public class DriverRegister { /* * mysql的driver类 * */ private static final String MYSQLDRIVER = "com.mysql.jdbc.Driver"; /* * 构建driver缓存，存储已经注册了的driver的类型 * */ private static final Map<String,Driver> registerDrivers = new ConcurrentHashMap<>(); /* * 初始化，此处是将DriverManager中已经注册了驱动放入自己缓存中。当然，你也可以在这个方法内注册 常见的数据库驱动，这样后续就可以直接使用，不用自己手动注册了。 * */ static { Enumeration<Driver> driverEnumeration = DriverManager.getDrivers(); while (driverEnumeration.hasMoreElements()){ Driver driver = driverEnumeration.nextElement(); registerDrivers.put(driver.getClass().getName(),driver); } } /* * 加载mysql驱动，此个方法可以写在静态代码块内，代表项目启动时即注册mysql驱动 * */ public void loadMySql(){ if(! registerDrivers.containsKey(MYSQLDRIVER)){ loadDriver(MYSQLDRIVER); } } /* * 加载数据库驱动通用方法，并注册到registerDrivers缓存中，此处是注册数据库驱动的方法 * */ public void loadDriver(String driverName){ Class<?> driverType; try { // 注册驱动，返回驱动类 driverType = Class.forName(driverName); // 将驱动实例放入驱动缓存中 registerDrivers.put(driverType.getName(),(Driver)driverType.newInstance()); }catch (ClassNotFoundException e){ throw new RuntimeException(e); }catch (Exception e){ throw new RuntimeException(e); } } }
驱动注册后，需要建立数据库连接。但是框架如果一个请求建一个连接，那木势必耗费大量的资源。所以该框架引入池化的概念，对连接进行池化管理。详情见代码2
代码块2
数据源类（com.simple.ibatis.datasource）
PoolConnection
/** * @Author xiabing * @Desc 连接代理类，是对Connection的一个封装。除了提供基本的连接外，还想记录 这个连接的连接时间，因为有的连接如果一直连接不释放，那木我可以通过查看 这个连接已连接的时间，如果超时了，我可以主动释放。 **/ public class PoolConnection { // 真实的数据库连接 public Connection connection; // 数据开始连接时间 private Long CheckOutTime; // 连接的hashCode private int hashCode = 0; public PoolConnection(Connection connection) { this.connection = connection; this.hashCode = connection.hashCode(); } public Long getCheckOutTime() { return CheckOutTime; } public void setCheckOutTime(Long checkOutTime) { CheckOutTime = checkOutTime; } // 判断两个PoolConnection对象是否相等，其实是判断其中真实连接的hashCode是否相等 @Override public boolean equals(Object obj) { if(obj instanceof PoolConnection){ return connection.hashCode() == ((PoolConnection) obj).connection.hashCode(); }else if(obj instanceof Connection){ return obj.hashCode() == hashCode; }else { return false; } } @Override public int hashCode() { return hashCode; } }
NormalDataSource
/** * @Author xiabing * @Desc 普通数据源,这个数据源是用来产生数据库连接的。来一个请求就会建立一个数据库连接，没有池化的概念 **/ public class NormalDataSource implements DataSource{ // 驱动名称 private String driverClassName; // 数据库连接URL private String url; // 数据库用户名 private String userName; // 数据库密码 private String passWord; // 驱动注册中心 private DriverRegister driverRegister = new DriverRegister(); public NormalDataSource(String driverClassName, String url, String userName, String passWord) { // 初始化时将驱动进行注册 this.driverRegister.loadDriver(driverClassName); this.driverClassName = driverClassName; this.url = url; this.userName = userName; this.passWord = passWord; } // 获取数据库连接 @Override public Connection getConnection() throws SQLException { return DriverManager.getConnection(url,userName,passWord); } // 移除数据库连接，此方法没有真正移除，只是将连接中未提交的事务进行回滚操作。 public void removeConnection(Connection connection) throws SQLException{ if(!connection.getAutoCommit()){ connection.rollback(); } } // 获取数据库连接 @Override public Connection getConnection(String username, String password) throws SQLException { return DriverManager.getConnection(url,username,password); } // 后续方法因为没有用到，所有没有进行重写了 @Override public <T> T unwrap(Class<T> iface) throws SQLException { return null; } @Override public boolean isWrapperFor(Class<?> iface) throws SQLException { return false; } @Override public PrintWriter getLogWriter() throws SQLException { return null; } @Override public void setLogWriter(PrintWriter out) throws SQLException { } @Override public void setLoginTimeout(int seconds) throws SQLException { } @Override public int getLoginTimeout() throws SQLException { return 0; } @Override public Logger getParentLogger() throws SQLFeatureNotSupportedException { return null; } }
PoolDataSource
/** * @Author xiabing * @Desc 池化线程池,对连接进行管理 **/ public class PoolDataSource implements DataSource{ private Integer maxActiveConnectCount = 10; // 最大活跃线程数，此处可根据实际情况自行设置 private Integer maxIdleConnectCount = 10; // 最大空闲线程数，此处可根据实际情况自行设置 private Long maxConnectTime = 30*1000L; // 连接最长使用时间，在自定义连接中配置了连接开始时间，在这里来判断该连接是否超时 private Integer waitTime = 2000; // 线程wait等待时间 private NormalDataSource normalDataSource; // 使用normalDataSource来产生连接 private Queue<PoolConnection> activeConList = new LinkedList<>(); // 存放活跃连接的队列 private Queue<PoolConnection> idleConList = new LinkedList<>(); // 存放空闲连接的队列 public PoolDataSource(String driverClassName, String url, String userName, String passWord) { this(driverClassName,url,userName,passWord,10,10); } public PoolDataSource(String driverClassName, String url, String userName, String passWord,Integer maxActiveConnectCount,Integer maxIdleConnectCount) { // 初始化normalDataSource，因为normalDataSource已经封装了新建连接的方法 this.normalDataSource = new NormalDataSource(driverClassName,url,userName,passWord); this.maxActiveConnectCount = maxActiveConnectCount; this.maxIdleConnectCount = maxIdleConnectCount; } /** * @Desc 获取连接时先从空闲连接列表中获取。若没有，则判断现在活跃连接是否已超过设置的最大活跃连接数，没超过，new一个 * 若超过，则判断第一个连接是否已超时，若超时，则移除掉在新建。若未超时，则wait(）等待。 **/ @Override public Connection getConnection(){ Connection connection = null; try { connection = doGetPoolConnection().connection; }catch (SQLException e){ throw new RuntimeException(e); } return connection; } public void removeConnection(Connection connection){ PoolConnection poolConnection = new PoolConnection(connection); doRemovePoolConnection(poolConnection); } private PoolConnection doGetPoolConnection() throws SQLException{ PoolConnection connection = null; while (connection == null){ // 加锁 synchronized (this){ // 判断是否有空闲连接 if(idleConList.size() < 1){ // 判断活跃连接数是否已经超过预设的最大活跃连接数 if(activeConList.size() < maxActiveConnectCount){ // 如果还可以新建连接，就新建一个连接 connection = new PoolConnection(normalDataSource.getConnection()); }else { // 走到这一步，说明没有空闲连接，并且活跃连接已经满了，则只能看哪些连接超时，判断第一个连接是否超时 PoolConnection poolConnection = activeConList.peek(); // 这就是我为啥要给数据库连接加连接时间了 if(System.currentTimeMillis() - poolConnection.getCheckOutTime() > maxConnectTime){ // 若第一个连接已经超时了，移除第一个活跃连接 PoolConnection timeOutConnect = activeConList.poll(); if(!timeOutConnect.connection.getAutoCommit()){ // 如果该连接设的是非自动提交，则对事物进行回滚操作 timeOutConnect.connection.rollback(); } // 置为空，让垃圾收集器去收集 timeOutConnect.connection.close(); timeOutConnect = null; // 新建一个连接 connection = new PoolConnection(normalDataSource.getConnection()); }else { // 走到这一步，代表所有连接都没有超时，只能等了 try{ // 于是等一会 this.wait(waitTime); }catch (InterruptedException e){ // ignore错误，并退出 break; } } } }else { // 这一步代表空闲连接队列里面有连接，则直接取出 connection = idleConList.poll(); } if(connection != null){ // 设置这个连接的连接时间 connection.setCheckOutTime(System.currentTimeMillis()); // 然后放入活跃连接队列中 activeConList.add(connection); } } } return connection; } // 移除连接 private void doRemovePoolConnection(PoolConnection connection){ // 加锁 synchronized (this){ // 移除连接，这里需要重写PoolConnection的equal方法，因为只要真实连接相同，就可以代表这个封装的连接相等了 activeConList.remove(connection); if(idleConList.size() < maxIdleConnectCount){ // 加入空闲连接队列中 idleConList.add(connection); } // 通知其他等待线程，让他们继续获取连接 this.notifyAll(); } } @Override public Connection getConnection(String username, String password) throws SQLException { return getConnection(); } // 后面的方法没有用到就没有重写了 @Override public <T> T unwrap(Class<T> iface) throws SQLException { return null; } @Override public boolean isWrapperFor(Class<?> iface) throws SQLException { return false; } @Override public PrintWriter getLogWriter() throws SQLException { return null; } @Override public void setLogWriter(PrintWriter out) throws SQLException { } @Override public void setLoginTimeout(int seconds) throws SQLException { } @Override public int getLoginTimeout() throws SQLException { return 0; } @Override public Logger getParentLogger() throws SQLFeatureNotSupportedException { return null; } }
使用数据库连接池获取连接后，接下来就是关键了，生成SQL预处理语句，并进行数据填充。这让我想到了mybatis使用方法。
@Select("select * from users")
List<User> getUsers();
上面是mybatis基于注解的配置方式。除了注解，还支持xml。于是框架准备先使用基于注解的方式进行代码配置。首先，需要知道这些接口类的类名。于是提供一个配置，根据指定包名获取包下所有类的类名详情见代码3
代码块3
方法类（com.simple.ibatis.util）
PackageUtil
/** * @Author xiabing * @Desc 获取指定包下所有类的名称 **/ public class PackageUtil { private static final String CLASS_SUFFIX = ".class"; private static final String CLASS_FILE_PREFIX = "classes" + File.separator; private static final String PACKAGE_SEPARATOR = "."; /** * 查找包下的所有类的名字 * @param packageName * @param showChildPackageFlag 是否需要显示子包内容 * @return List集合，内容为类的全名 */ public static List<String> getClazzName(String packageName, boolean showChildPackageFlag){ List<String> classNames = new ArrayList<>(); String suffixPath = packageName.replaceAll("\.", "/"); // 获取类加载器 ClassLoader loader = Thread.currentThread().getContextClassLoader(); try{ Enumeration<URL> urls = loader.getResources(suffixPath); while(urls.hasMoreElements()) { URL url = urls.nextElement(); if(url != null){ if ("file".equals(url.getProtocol())) { String path = url.getPath(); classNames.addAll(getAllClassName(new File(path),showChildPackageFlag)); } } } }catch (IOException e){ throw new RuntimeException("load resource is error , resource is "+packageName); } return classNames; } // 获取所有类的名称 private static List<String> getAllClassName(File file,boolean flag){ List<String> classNames = new ArrayList<>(); if(!file.exists()){ return classNames; } if(file.isFile()){ String path = file.getPath(); if(path.endsWith(CLASS_SUFFIX)){ path = path.replace(CLASS_SUFFIX,""); String clazzName = path.substring(path.indexOf(CLASS_FILE_PREFIX) + CLASS_FILE_PREFIX.length()).replace(File.separator, PACKAGE_SEPARATOR); classNames.add(clazzName); } }else { File[] listFiles = file.listFiles(); if(listFiles != null && listFiles.length > 0){ for (File f : listFiles){ if(flag) { classNames.addAll(getAllClassName(f, flag)); }else { if(f.isFile()){ String path = f.getPath(); if(path.endsWith(CLASS_SUFFIX)) { path = path.replace(CLASS_SUFFIX, ""); String clazzName = path.substring(path.indexOf(CLASS_FILE_PREFIX) + CLASS_FILE_PREFIX.length()).replace(File.separator,PACKAGE_SEPARATOR); classNames.add(clazzName); } } } } } } return classNames; } }
在知道接口类存放在哪些类后，我需要解析这些类中的各个方法，包括每个方法的注解，入参，和返回值。同时，我需要使用一个全局配置类，用于存放我解析后生成的对象，并且一些数据源配置信息也可以放在这个全局类中。详情见代码4
代码块4
核心类（com.simple.ibatis.core）
Config
/** * @Author xiabing * @Desc 框架的核心配置类 **/ public class Config { // 数据源 private PoolDataSource dataSource; // mapper包地址（即待解析的包名），后续改为List<String>，能同时加载多个mapper包 todo private String daoSource; // mapper核心文件（存放类解析后的对象） private MapperCore mapperCore; // 是否启用事务 private boolean openTransaction; // 是否开启缓存 private boolean openCache; public Config(String mapperSource,PoolDataSource dataSource){ this.dataSource = dataSource; this.daoSource = mapperSource; this.mapperCore = new MapperCore(this); } // 生成SQL语句执行器 public SimpleExecutor getExecutor(){ return new SimpleExecutor(this,this.getDataSource(),openTransaction,openCache); } // 后文都是基本的get,set方法 public PoolDataSource getDataSource() { return dataSource; } public void setDataSource(PoolDataSource dataSource) { this.dataSource = dataSource; } public String getDaoSource() { return daoSource; } public void setDaoSource(String daoSource) { this.daoSource = daoSource; } public MapperCore getMapperCore() { return mapperCore; } public void setMapperCore(MapperCore mapperCore) { this.mapperCore = mapperCore; } public boolean isOpenTransaction() { return openTransaction; } public void setOpenTransaction(boolean openTransaction) { this.openTransaction = openTransaction; } public boolean isOpenCache() { return openCache; } public void setOpenCache(boolean openCache) { this.openCache = openCache; } }
SqlSource
/** * @Author xiabing5 * @Desc 将sql语句拆分为sql部分和参数部分,因为我们需要使用java对象对数据库预处理对象进行注入。具体看下面例子 * @example select * from users where id = {user.id} and name = {user.name} * -> sql = select * from users where id = ? and name = ? * -> paramResult = {user.id,user.name} **/ public class SqlSource { /**sql语句，待输入字段替换成?*/ private String sql; /**待输入字段*/ private List<String> param; /**select update insert delete*/ private Integer executeType; public SqlSource(String sql){ this.param = new ArrayList<>(); this.sql = sqlInject(this.param,sql); } /**sql注入，对要注入的属性，必须使用{} 包裹，并替换为？ 见例子 */ private String sqlInject(List<String> paramResult, String sql){ String labelPrefix = "{"; String labelSuffix = "}"; // 将语句的所有的{}全部都解析成？,并将{xxx}中的xxx提取出来。 while (sql.indexOf(labelPrefix) > 0 && sql.indexOf(labelSuffix) > 0){ String sqlParamName = sql.substring(sql.indexOf(labelPrefix),sql.indexOf(labelSuffix)+1); sql = sql.replace(sqlParamName,"?"); paramResult.add(sqlParamName.replace("{","").replace("}","")); } return sql; } public String getSql() { return sql; } public void setSql(String sql) { this.sql = sql; } public List<String> getParam() { return param; } public void setParam(List<String> param) { this.param = param; } public Integer getExecuteType() { return executeType; } public void setExecuteType(Integer executeType) { this.executeType = executeType; } }
MapperCore
/** * @Author xiabing5 * @Desc mapper方法解析核心类,此处是将接口中的方法进行解析的关键类 **/ public class MapperCore { // select方法 private static final Integer SELECT_TYPE = 1; // update方法 private static final Integer UPDATE_TYPE = 2; // delete方法 private static final Integer DELETE_TYPE = 3; // insert方法 private static final Integer INSERT_TYPE = 4; /**mapper文件解析类缓存，解析后都放在里面，避免重复对一个mapper文件进行解析*/ private static Map<String,MethodDetails> cacheMethodDetails = new ConcurrentHashMap<>(); /** * 全局配置 * */ private Config config; public MapperCore(Config config){ this.config = config; load(config.getDaoSource()); } /* * 加载，解析指定包名下的类 * */ private void load(String source){ /**加载mapper包下的文件*/ List<String> clazzNames = PackageUtil.getClazzName(source,true); try{ for(String clazz: clazzNames){ Class<?> nowClazz = java.lang.Class.forName(clazz); // 不是接口跳过，只能解析接口 if(!nowClazz.isInterface()){ continue; } /**接口上没有@Dao跳过。我们对接口类上加了@Dao后，就代表要解析*/ boolean skip = false; Annotation[] annotations = nowClazz.getDeclaredAnnotations(); for(Annotation annotation:annotations){ // 该接口中的注释中是否有带@Dao if(annotation instanceof Dao) { skip = true; break; } } if(!skip){ continue; } // 调用反射接口，获取所有接口中的方法 Method[] methods = nowClazz.getDeclaredMethods(); for( Method method : methods){ // 解析方法详情 MethodDetails methodDetails = handleParameter(method); // 解析@SELECT()等注解中的SQL内容 methodDetails.setSqlSource(handleAnnotation(method)); // 解析完成后放入缓存 cacheMethodDetails.put(generateStatementId(method),methodDetails); } } }catch (ClassNotFoundException e){ throw new RuntimeException(" class load error,class is not exist"); } } /** * 获得方法详情，从方法缓存池中获取，因为每个方法事先已经完成解析 * */ public MethodDetails getMethodDetails(Method method){ String statementId = generateStatementId(method); if(cacheMethodDetails.containsKey(statementId)){ return cacheMethodDetails.get(statementId); } return new MethodDetails(); } /** * 获得方法对应的sql语句 * */ public SqlSource getStatement(Method method){ String statementId = generateStatementId(method); if(cacheMethodDetails.containsKey(statementId)){ return cacheMethodDetails.get(statementId).getSqlSource(); } throw new RuntimeException(method + " is not sql"); } /** * 获得方法对应的参数名 * */ public List<String> getParameterName(Method method){ String statementId = generateStatementId(method); if(cacheMethodDetails.containsKey(statementId)){ return cacheMethodDetails.get(statementId).getParameterNames(); } return new ArrayList<>(); } /** * 获取方法返回类型 * */ public Class getReturnType(Method method){ String statementId = generateStatementId(method); if(cacheMethodDetails.containsKey(statementId)){ return cacheMethodDetails.get(statementId).getReturnType(); } return null; } /** * 获得方法对应的参数类型 * */ public Class<?>[] getParameterType(Method method) { String statementId = generateStatementId(method); if(cacheMethodDetails.containsKey(statementId)){ return cacheMethodDetails.get(statementId).getParameterTypes(); } return new Class<?>[]{}; } /** * 获得方法是SELECT UPDATE DELETE INSERT * */ public Integer getMethodType(Method method){ String statementId = generateStatementId(method); if(cacheMethodDetails.containsKey(statementId)){ return cacheMethodDetails.get(statementId).getSqlSource().getExecuteType(); } return null; } /** * 获得方法是否返回集合类型list * */ public boolean getHasSet(Method method){ String statementId = generateStatementId(method); if(cacheMethodDetails.containsKey(statementId)){ return cacheMethodDetails.get(statementId).isHasSet(); } return false; } /** * 解析方法内的注解 * */ private MethodDetails handleParameter(Method method){ MethodDetails methodDetails = new MethodDetails(); // 获取方法输入参数数量 int parameterCount = method.getParameterCount(); // 获取方法输入各参数类型 Class<?>[] parameterTypes = method.getParameterTypes(); // 获取方法输入各参数名称 List<String> parameterNames = new ArrayList<>(); Parameter[] params = method.getParameters(); for(Parameter parameter:params){ parameterNames.add(parameter.getName()); } /* * 获得方法参数的注解值替代默认值，如果使用了@Param注解，则默认使用注解中的值作为参数名 * */ for(int i = 0; i < parameterCount; i++){ parameterNames.set(i,getParamNameFromAnnotation(method,i,parameterNames.get(i))); } methodDetails.setParameterTypes(parameterTypes); methodDetails.setParameterNames(parameterNames); /** 获取方法返回类型*/ Type methodReturnType = method.getGenericReturnType(); Class<?> methodReturnClass = method.getReturnType(); if(methodReturnType instanceof ParameterizedType){ /** 返回是集合类 目前仅支持List todo*/ if(!List.class.equals(methodReturnClass)){ throw new RuntimeException("now ibatis only support list"); } Type type = ((ParameterizedType) methodReturnType).getActualTypeArguments()[0]; /** 设置 返回集合中的对象类型 */ methodDetails.setReturnType((Class<?>) type); /** 标注该方法返回类型是集合类型 */ methodDetails.setHasSet(true); }else { /** 不是集合类型，就直接设置返回类型 */ methodDetails.setReturnType(methodReturnClass); /** 标注该方法返回类型不是集合类型 */ methodDetails.setHasSet(false); } return methodDetails; } /** * 解析@select，@update等注解，获取SQL语句，并封装成对象 * */ private SqlSource handleAnnotation(Method method){ SqlSource sqlSource = null; String sql = null; /** 获取方法上所有注解 */ Annotation[] annotations = method.getDeclaredAnnotations(); for(Annotation annotation : annotations){ /** 如果有@select注解 */ if(Select.class.isInstance(annotation)){ Select selectAnnotation = (Select)annotation; sql = selectAnnotation.value(); /** 语句封装成sqlSource对象 */ sqlSource = new SqlSource(sql); /** 设置执行语句类型 */ sqlSource.setExecuteType(SELECT_TYPE); break; }else if(Update.class.isInstance(annotation)){ Update updateAnnotation = (Update)annotation; sql = updateAnnotation.value(); sqlSource = new SqlSource(sql); sqlSource.setExecuteType(UPDATE_TYPE); break; }else if(Delete.class.isInstance(annotation)){ Delete deleteAnnotation = (Delete) annotation; sql = deleteAnnotation.value(); sqlSource = new SqlSource(sql); sqlSource.setExecuteType(DELETE_TYPE); break; }else if(Insert.class.isInstance(annotation)){ Insert insertAnnotation = (Insert) annotation; sql = insertAnnotation.value(); sqlSource = new SqlSource(sql); sqlSource.setExecuteType(INSERT_TYPE); break; } } if(sqlSource == null){ throw new RuntimeException("method annotation not null"); } return sqlSource; } /** * 获取@Param注解内容 * */ private String getParamNameFromAnnotation(Method method, int i, String paramName) { final Object[] paramAnnos = method.getParameterAnnotations()[i]; for (Object paramAnno : paramAnnos) { if (paramAnno instanceof Param) { paramName = ((Param) paramAnno).value(); } } return paramName; } /** * 生成唯一的statementId * */ private static String generateStatementId(Method method){ return method.getDeclaringClass().getName() + "." + method.getName(); } /** * 每个mapper方法的封装类 * */ public static class MethodDetails{ /**方法返回类型,若是集合，则代表集合的对象类，目前集合类仅支持返回List */ private Class<?> returnType; /**方法返回类型是否是集合*/ private boolean HasSet; /**执行类型，SELECT,UPDATE,DELETE,INSERT*/ private Integer executeType; /**方法输入参数类型集合*/ private Class<?>[] parameterTypes; /**方法输入参数名集合*/ private List<String> parameterNames; /**sql语句集合*/ private SqlSource sqlSource; public Class<?> getReturnType() { return returnType; } public void setReturnType(Class<?> returnType) { this.returnType = returnType; } public boolean isHasSet() { return HasSet; } public void setHasSet(boolean hasSet) { HasSet = hasSet; } public Integer getExecuteType() { return executeType; } public void setExecuteType(Integer executeType) { this.executeType = executeType; } public Class<?>[] getParameterTypes() { return parameterTypes; } public void setParameterTypes(Class<?>[] parameterTypes) { this.parameterTypes = parameterTypes; } public List<String> getParameterNames() { return parameterNames; } public void setParameterNames(List<String> parameterNames) { this.parameterNames = parameterNames; } public SqlSource getSqlSource() { return sqlSource; } public void setSqlSource(SqlSource sqlSource) { this.sqlSource = sqlSource; } } }
SQL语句已经解析完毕，后面开始执行SQL语句。在之前，我想给执行SQL语句时加点功能，如提供select缓存，事务功能，详情见代码块5，代码块6
代码块5
缓存类（com.simple.ibatis.cache）
Cache
/** * @author xiabing * @description: 自定义缓存接口,主要提供增删改查功能 */ public interface Cache { /**放入缓存*/ void putCache(String key,Object val); /**获取缓存*/ Object getCache(String key); /**清空缓存*/ void cleanCache(); /**获取缓存健数量*/ int getSize(); /**移除key的缓存*/ void removeCache(String key); }
SimpleCache
/** * @author xiabing * @description: 缓存的简单实现 */ public class SimpleCache implements Cache{ /**用HashMap来实现缓存的增删改查*/ private static Map<String,Object> map = new HashMap<>(); @Override public void putCache(String key, Object val) { map.put(key,val); } @Override public Object getCache(String key) { return map.get(key); } @Override public void cleanCache() { map.clear(); } @Override public int getSize() { return map.size(); } @Override public void removeCache(String key) { map.remove(key); } }
LruCache
/** * @author xiabing * @description: 缓存包装类没，使缓存具有LRU功能 */ public class LruCache implements Cache{ /**缓存大小*/ private static Integer cacheSize = 2000; /**HashMap负载因子，可以自己指定*/ private static Float loadFactory = 0.75F; /**真实缓存*/ private Cache trueCache; /**使用LinkedHashMap来实现Lru功能*/ private Map<String,Object> linkedCache; /**待移除的元素*/ private static Map.Entry removeEntry; public LruCache(Cache trueCache){ this(cacheSize,loadFactory,trueCache); } public LruCache(Integer cacheSize, Float loadFactory, Cache trueCache) { this.trueCache = trueCache; /**初始化LinkedHashMap,并重写removeEldestEntry() 方法,不了解的可以看我之前的博客*/ this.linkedCache = new LinkedHashMap<String, Object>(cacheSize,loadFactory,true){ @Override protected boolean removeEldestEntry(Map.Entry eldest) { // 当缓存容量超过设置的容量时，返回true,并记录待删除的对象 if(getSize() > cacheSize){ removeEntry = eldest; return true; } return false; } }; } // 放入缓存，当待删除的元素不为空时，就在真实缓存中删除该元素 @Override public void putCache(String key, Object val) { // 真实缓存中放入 this.trueCache.putCache(key,val); // linkedHashMap中放入,此处放入会调用重写的removeEldestEntry()方法 this.linkedCache.put(key,val); // 当removeEldestEntry()执行后，如果有待删除元素，就开始执行删除操作 if(removeEntry != null){ removeCache((String)removeEntry.getKey()); removeEntry = null; } } @Override public Object getCache(String key) { // 因为调用linkedHashMap中的get()方法会对链表进行再一次排序。见之前关于缓存的博客 linkedCache.get(key); return trueCache.getCache(key); } @Override public void cleanCache() { trueCache.cleanCache(); linkedCache.clear(); } @Override public int getSize() { return trueCache.getSize(); } @Override public void removeCache(String key) { trueCache.removeCache(key); } }
代码块6
事务类（com.simple.ibatis.transaction）
Transaction
/** * @Author xiabing * @Desc 封装事务功能 **/ public interface Transaction { /**获取数据库连接*/ Connection getConnection() throws SQLException; /**事务提交*/ void commit() throws SQLException; /**事务回滚*/ void rollback() throws SQLException; /**关闭连接*/ void close() throws SQLException; }
SimpleTransaction
/** * @Author xiabing * @Desc 事务的简单实现，封装了数据库的事务功能 **/ public class SimpleTransaction implements Transaction{ private Connection connection; // 数据库连接 private PoolDataSource dataSource; // 数据源 private Integer level = Connection.TRANSACTION_REPEATABLE_READ; // 事务隔离级别 private Boolean autoCommmit = true; // 是否自动提交 public SimpleTransaction(PoolDataSource dataSource){ this(dataSource,null,null); } public SimpleTransaction(PoolDataSource dataSource, Integer level, Boolean autoCommmit) { this.dataSource = dataSource; if(level != null){ this.level = level; } if(autoCommmit != null){ this.autoCommmit = autoCommmit; } } /**获取数据库连接，并设置该连接的事务隔离级别，是否自动提交*/ @Override public Connection getConnection() throws SQLException{ if(connection != null){ return connection; } this.connection = dataSource.getConnection(); this.connection.setAutoCommit(autoCommmit); this.connection.setTransactionIsolation(level); return this.connection; } @Override public void commit() throws SQLException{ if(this.connection != null){ this.connection.commit(); } } @Override public void rollback() throws SQLException{ if(this.connection != null){ this.connection.rollback(); } } /**关闭连接*/ @Override public void close() throws SQLException{ /**如果该连接设置自动连接为false,则在关闭前进行事务回滚一下*/ if(autoCommmit != null && !autoCommmit){ connection.rollback(); } if(connection != null){ dataSource.removeConnection(connection); } this.connection = null; } }
TransactionFactory
/** * @Author xiabing * @Desc 事务工厂，封装获取事务的功能 **/ public class TransactionFactory { public static SimpleTransaction newTransaction(PoolDataSource poolDataSource, Integer level, Boolean autoCommmit){ return new SimpleTransaction(poolDataSource,level,autoCommmit); } }
代码真正执行SQL的地方，见代码块7
代码块7
语句执行类（com.simple.ibatis.execute）
Executor
/** * @Author xiabing * @Desc 执行接口类，后续执行器需要实现此接口 **/ public interface Executor { /**获取Mapper接口代理类，使用了动态代理技术，见实现类分析*/ <T> T getMapper(Class<T> type); void commit() throws SQLException; void rollback() throws SQLException; void close() throws SQLException; }
SimpleExecutor
/** * @Author xiabing * @Desc 简单执行器类，对于Sql的执行和处理都依赖此类 **/ public class SimpleExecutor implements Executor{ /**全局配置类*/ public Config config; /**mapper核心类，解析mapper接口类*/ public MapperCore mapperCore; /**数据库源*/ public PoolDataSource poolDataSource; /**事务*/ public Transaction transaction; /**缓存*/ public Cache cache; public SimpleExecutor(Config config,PoolDataSource poolDataSource){ this(config,poolDataSource,false,false); } public SimpleExecutor(Config config,PoolDataSource poolDataSource,boolean openTransaction,boolean openCache){ this.config = config; this.mapperCore = config.getMapperCore(); this.poolDataSource = poolDataSource; if(openCache){ // 设置缓存策略为LRU this.cache = new LruCache(new SimpleCache()); } if(openTransaction){ // 关闭自动提交 this.transaction = TransactionFactory.newTransaction(poolDataSource,Connection.TRANSACTION_REPEATABLE_READ,false); }else { // 开启自动提交 this.transaction = TransactionFactory.newTransaction(poolDataSource,null,null); } } /** * @Desc 获取mapper接口的代理类 为什么要使用代理类，因为我们写mapper接口类只写了接口，却没有提供它的实现。于是 使用动态代理机制对这些接口进行代理，在代理类中实现sql执行的方法。此处是参照 mybatis的设计。 **/ @Override public <T> T getMapper(Class<T> type){ /**MapperProxy代理类分析见详情8.1*/ MapperProxy mapperProxy = new MapperProxy(type,this); return (T)mapperProxy.initialization(); } /*select 语句执行流程分析**/ public <E> List<E> select(Method method,Object[] args) throws Exception{ /**PreparedStatementHandle 生成器见9.1 */ PreparedStatementHandle preparedStatementHandle = new PreparedStatementHandle(mapperCore,transaction,method,args); PreparedStatement preparedStatement = preparedStatementHandle.generateStatement(); /**执行查询接口，此处是真实调用sql语句的地方 */ preparedStatement.executeQuery(); ResultSet resultSet = preparedStatement.getResultSet(); /**查询方法的返回参数值，若是void类型，就不用返回任务东西 */ Class returnClass = mapperCore.getReturnType(method); if(returnClass == null || void.class.equals(returnClass)){ return null; }else { /**ResultSetHandle 结果处理器见9.2 */ ResultSetHandle resultSetHandle = new ResultSetHandle(returnClass,resultSet); return resultSetHandle.handle(); } } /*update 语句执行流程分析,update，delete,insert都是调用的这个方法**/ public int update(Method method,Object[] args)throws SQLException{ PreparedStatementHandle preparedStatementHandle = null; PreparedStatement preparedStatement = null; Integer count = null; try{ /**PreparedStatementHandle 生成器见9.1 */ preparedStatementHandle = new PreparedStatementHandle(mapperCore,transaction,method,args); preparedStatement = preparedStatementHandle.generateStatement(); /**返回受影响的行数 */ count = preparedStatement.executeUpdate(); }finally { if(preparedStatement != null){ preparedStatement.close(); } } return count; } /**后续方法直接调用transaction相关方法*/ @Override public void commit() throws SQLException{ transaction.commit(); } @Override public void rollback() throws SQLException{ transaction.rollback(); } @Override public void close() throws SQLException{ transaction.close(); } }
因为我们mapper接口类只有接口，没有实现。但为什么可以调用这些接口方法？此处参照mybatis源码，自己通过动态代理技术实现接口的动态代理，在代理方法里写我们自己执行Sql的逻辑。代理类见代码块8
代码块8
mapper接口代理类（com.simple.ibatis.execute）
MapperProxy
/** * @Author xiabing * @Desc mapper接口代理类 **/ public class MapperProxy<T> implements InvocationHandler{ /**要代理的mapper接口类*/ private Class<T> interfaces; /**具体的执行器，执行mapper中的一个方法相当于执行一条sql语句*/ private SimpleExecutor executor; public MapperProxy(Class<T> interfaces,SimpleExecutor executor) { this.interfaces = interfaces; this.executor = executor; } /**反射方法，该方法自定义需要代理的逻辑。不了解可以去看下JAVA动态代理技术*/ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result = null; /**object方法直接代理*/ if(Object.class.equals(method.getDeclaringClass())){ result = method.invoke(this,args); }else { // 获取方法是select还是非select方法 Integer methodType = executor.mapperCore.getMethodType(method); if(methodType == null){ throw new RuntimeException("method is normal sql method"); } if(methodType == 1){ /**调用执行器的select方法，返回集合类*/ List<Object> list = executor.select(method,args); result = list; /**查看接口的返回是List，还是单个对象*/ if(!executor.mapperCore.getHasSet(method)){ if(list.size() == 0){ result = null; }else { /**单个对象就直接取第一个*/ result = list.get(0); } } }else{ /**返回受影响的行数*/ Integer count = executor.update(method,args); result = count; } } return result; } /**构建代理类*/ public T initialization(){ return (T)Proxy.newProxyInstance(interfaces.getClassLoader(),new Class[] { interfaces },this); } }
代码块7中执行SQL其实包含3个过程，生成SQL预处理语句，执行SQL，将SQL结果转为JAVA对象。详情见代码块9
代码块9
各生成器类（com.simple.ibatis.statement）
PreparedStatementHandle
/** * @Author xiabing * @Desc PreparedStatement生成器 **/ public class PreparedStatementHandle { /** * 全局核心mapper解析类 */ private MapperCore mapperCore; /** * 待执行的方法 */ private Method method; private Transaction transaction; private Connection connection; /** * 方法输入参数 */ private Object[] args; public PreparedStatementHandle(MapperCore mapperCore, Transaction transaction,Method method, Object[] args)throws SQLException { this.mapperCore = mapperCore; this.method = method; this.transaction = transaction; this.args = args; connection = transaction.getConnection(); } /** * @Author xiabing5 * @Desc 参数处理核心方法 todo **/ public PreparedStatement generateStatement() throws SQLException{ // 获取已经解析方法的sqlSource类，已经将待注入字段变为？，后续直接填充就好 SqlSource sqlSource = mapperCore.getStatement(method); // 调用connection方法生成预处理语句 PreparedStatement preparedStatement = connection.prepareStatement(sqlSource.getSql()); // 获取方法输入参数的类型 Class<?>[] clazzes = mapperCore.getParameterType(method); List<String> paramNames = mapperCore.getParameterName(method); List<String> params = sqlSource.getParam(); // 详见typeInject方法，注入SQL参数 preparedStatement = typeInject(preparedStatement,clazzes,paramNames,params,args); return preparedStatement; } /** * @Author xiabing * @Desc preparedStatement构建，将参数注入到SQL语句中 * @Param preparedStatement 待构建的preparedStatement * @Param clazzes 该方法中参数类型数组 * @Param paramNames 该方法中参数名称列表,若有@Param注解，则为此注解的值，默认为类名首字母小写 * @Param params 待注入的参数名，如user.name或普通类型如name * @Param args 真实参数值 **/ private PreparedStatement typeInject(PreparedStatement preparedStatement,Class<?>[] clazzes,List<String> paramNames,List<String> params,Object[] args)throws SQLException{ for(int i = 0; i < paramNames.size(); i++){ // 第i个参数名称 String paramName = paramNames.get(i); // 第i个参数类型 Class type = clazzes[i]; if(String.class.equals(type)){ // 原始SQL中需要注入的参数名中是否有此参数名称 // example: select * from users where id = {id} and name = {name} 则{id}中的id和name就是如下的params里面内容 int injectIndex = params.indexOf(paramName); /**此处是判断sql中是否有待注入的名称({name})和方法内输入对象名(name)相同，若相同，则直接注入*/ if(injectIndex >= 0){ preparedStatement.setString(injectIndex+1,(String)args[i]); } }else if(Integer.class.equals(type) || int.class.equals(type)){ int injectIndex = params.indexOf(paramName); if(injectIndex >= 0){ preparedStatement.setInt(injectIndex+1,(Integer)args[i]); } }else if(Float.class.equals(type) || float.class.equals(type)){ int injectIndex = params.indexOf(paramName); if(injectIndex >= 0){ preparedStatement.setFloat(injectIndex+1,(Float)args[i]); } }else { /** 若待注入的是对象。example: @SELECT(select * from users where id = {user.id} and name = {user.name}) List<User> getUser(User user) */ // 对象工厂，获取对象包装实例，见代码块10 ObjectWrapper objectWrapper = ObjectWrapperFactory.getInstance(args[i]); for(int j = 0; j < params.size(); j++){ /**此处是判断对象的属性 如user.name，需要先获取user对象，在调用getName方法获取值*/ if((params.get(j).indexOf(paramName)) >= 0 ){ try{ String paramProperties = params.get(j).substring(params.get(j).indexOf(".")+1); Object object = objectWrapper.getVal(paramProperties); Class childClazz = object.getClass(); if(String.class.equals(childClazz)){ preparedStatement.setString(j+1,(String)object); }else if(Integer.class.equals(childClazz) || int.class.equals(childClazz)){ preparedStatement.setInt(j+1,(Integer)object); }else if(Float.class.equals(childClazz) || float.class.equals(childClazz)){ preparedStatement.setFloat(j+1,(Float)object); }else { /**目前不支持对象中包含对象，如dept.user.name todo*/ throw new RuntimeException("now not support object contain object"); } }catch (Exception e){ throw new RuntimeException(e.getMessage()); } } } } } return preparedStatement; } public void closeConnection() throws SQLException{ transaction.close(); } }
ResultSetHandle
/** * @Author xiabing * @Desc ResultSet结果处理器，执行之后返回的json对象，转为java对象的过程 **/ public class ResultSetHandle { /**转换的目标类型*/ Class<?> typeReturn; /**待转换的ResultSet*/ ResultSet resultSet; Boolean hasSet; public ResultSetHandle(Class<?> typeReturn,ResultSet resultSet){ this.resultSet = resultSet; this.typeReturn = typeReturn; } /** * ResultSet处理方法，目前仅支持String,int,Float,不支持属性是集合类 todo * */ public <T> List<T> handle() throws Exception{ List<T> res = new ArrayList<>(resultSet.getRow()); Object object = null; ObjectWrapper objectWrapper = null; Set<ClazzWrapper.FiledExpand> filedExpands = null; // 返回类型若不是基本数据类型 if(!TypeUtil.isBaseType(typeReturn)){ // 生成对象 object = generateObj(typeReturn); // 将对象封装成包装类 objectWrapper = ObjectWrapperFactory.getInstance(object); /** 获取对象属性 */ filedExpands = objectWrapper.getMapperFiledExpands(); } while (resultSet.next()){ /** 若返回是基础数据类型，则直接将结果放入List中并返回 */ if(String.class.equals(typeReturn)){ String val = resultSet.getString(1); if(val != null){ res.add((T)val); } }else if(Integer.class.equals(typeReturn) || int.class.equals(typeReturn)){ Integer val = resultSet.getInt(1); if(val != null){ res.add((T)val); } }else if(Float.class.equals(typeReturn) || float.class.equals(typeReturn)){ Float val = resultSet.getFloat(1); if(val != null){ res.add((T)val); } }else { // 若返回的是对象（如User这种） // 查找对象属性，一个个注入 for(ClazzWrapper.FiledExpand filedExpand:filedExpands){ // 如果对象属性是String类型，例如User.name是String类型 if(String.class.equals(filedExpand.getType())){ // resultSet中获取该属性 String val = resultSet.getString(filedExpand.getPropertiesName()); if(val != null){ // 填充到对象包装类中 objectWrapper.setVal(filedExpand.getPropertiesName(),val); } }else if(Integer.class.equals(filedExpand.getType()) || int.class.equals(filedExpand.getType())){ Integer val = resultSet.getInt(filedExpand.getPropertiesName()); if(val != null){ objectWrapper.setVal(filedExpand.getPropertiesName(),val); } }else if(Float.class.equals(filedExpand.getType()) || float.class.equals(filedExpand.getType())){ Float val = resultSet.getFloat(filedExpand.getPropertiesName()); if(val != null){ objectWrapper.setVal(filedExpand.getPropertiesName(),val); } }else { continue; } } // 后续将对象包装类转为真实对象，放入List中并返回。对象包装类见代码10 res.add((T)objectWrapper.getRealObject()); } } return res; } // 根据类型，根据反射，实例化对象 private Object generateObj(Class<?> clazz) throws Exception{ Constructor[] constructors = clazz.getConstructors(); Constructor usedConstructor = null; // 获取无参构造器，若对象没有无参构造方法，则失败 for(Constructor constructor:constructors){ if(constructor.getParameterCount() == 0){ usedConstructor = constructor; break; } } if(constructors == null) { throw new RuntimeException(typeReturn + " is not empty constructor"); } // 利用反射生成实例 return usedConstructor.newInstance(); } }
代码块9中大量用到了对象增强，类增强。使用这些原因是 在编写框架代码时，因为并不知道每个属性名，不可能把每个get或者set方法写死，只能通过将对象封装成包装类。然后利用反射，要填充某个对象，就调用setVal(属性名)，获取对象类似。详情见代码块10
代码块10
类增强（com.simple.ibatis.reflect）
ClazzWrapper
/** * @Author xiabing * @Desc clazz解析类 **/ public class ClazzWrapper { /** * 待解析类 * */ private Class<?> clazz; /** * 该类存储的属性名 * */ private Set<String> propertiesSet = new HashSet<>(); /** * 该类存储的属性名及属性类 * */ private Set<FiledExpand> filedExpandSet = new HashSet<>(); /** * 该类存储的get方法。key为属性名，value为getxxx方法 * */ private Map<String,Method> getterMethodMap = new HashMap<>(); /** * 该类存储的set方法。key为属性名，value为setxxx方法 * */ private Map<String,Method> setterMethodMap = new HashMap<>(); /** * 缓存，避免对同一个类多次解析 * */ private static Map<String,ClazzWrapper> clazzWrapperMap = new ConcurrentHashMap<>(); public ClazzWrapper(Class clazz){ this.clazz = clazz; // 对类进行解析，如果已经解析了，则不用二次解析 if(!clazzWrapperMap.containsKey(clazz.getName())){ // 获取该类的所有属性 Field[] fields = clazz.getDeclaredFields(); for(Field field : fields){ // 获取属性的名称，属性类型 FiledExpand filedExpand = new FiledExpand(field.getName(),field.getType()); filedExpandSet.add(filedExpand); propertiesSet.add(field.getName()); } // 获取该类的方法 Method[] methods = clazz.getMethods(); for(Method method:methods){ String name = method.getName(); // 如果是get方法 if(name.startsWith("get")){ name = name.substring(3); if (name.length() == 1 || (name.length() > 1 && !Character.isUpperCase(name.charAt(1)))) { name = name.substring(0, 1).toLowerCase(Locale.ENGLISH) + name.substring(1); } // 放入get方法缓存中 if(propertiesSet.contains(name)){ getterMethodMap.put(name,method); } }else if(name.startsWith("set")){ name = name.substring(3); if (name.length() == 1 || (name.length() > 1 && !Character.isUpperCase(name.charAt(1)))) { name = name.substring(0, 1).toLowerCase(Locale.ENGLISH) + name.substring(1); } if(propertiesSet.contains(name)){ setterMethodMap.put(name,method); } } else { continue; } } // 放入缓存，代表该类已经完成解析 clazzWrapperMap.put(clazz.getName(),this); } } // 查找该类是否包含指定属性的get方法 public boolean hasGetter(String properties){ ClazzWrapper clazzWrapper = clazzWrapperMap.get(clazz.getName()); return clazzWrapper.getterMethodMap.containsKey(properties); } // 查找该类是否包含指定属性的set方法 public boolean hasSetter(String properties){ ClazzWrapper clazzWrapper = clazzWrapperMap.get(clazz.getName()); return clazzWrapper.setterMethodMap.containsKey(properties); } // 获取该类指定属性的set方法 public Method getSetterMethod(String properties){ if(!hasSetter(properties)){ throw new RuntimeException("properties " + properties + " is not set method") ; } ClazzWrapper clazzWrapper = clazzWrapperMap.get(clazz.getName()); return clazzWrapper.setterMethodMap.get(properties); } // 获取该类指定属性的get方法 public Method getGetterMethod(String properties){ if(!hasGetter(properties)){ throw new RuntimeException("properties " + properties + " is not get method") ; } ClazzWrapper clazzWrapper = clazzWrapperMap.get(clazz.getName()); return clazzWrapper.getterMethodMap.get(properties); } // 获取该类所有属性 public Set<String> getProperties(){ ClazzWrapper clazzWrapper = clazzWrapperMap.get(clazz.getName()); return clazzWrapper.propertiesSet; } // 获取该类所有属性增强 public Set<FiledExpand> getFiledExpandSet(){ ClazzWrapper clazzWrapper = clazzWrapperMap.get(clazz.getName()); return clazzWrapper.filedExpandSet; } /** * 属性增强类 * */ public static class FiledExpand{ // 属性名称 String propertiesName; // 属性类型 Class type; public FiledExpand() { } public FiledExpand(String propertiesName, Class type) { this.propertiesName = propertiesName; this.type = type; } public String getPropertiesName() { return propertiesName; } public void setPropertiesName(String propertiesName) { this.propertiesName = propertiesName; } public Class getType() { return type; } public void setType(Class type) { this.type = type; } @Override public int hashCode() { return propertiesName.hashCode(); } @Override public boolean equals(Object obj) { if(obj instanceof FiledExpand){ return ((FiledExpand) obj).propertiesName.equals(propertiesName); } return false; } } }
ObjectWrapper
/** * @Author xiabing * @Desc 对象增强,封装了get,set方法 **/ public class ObjectWrapper { // 真实对象 private Object realObject; // 该对象的类的增强 private ClazzWrapper clazzWrapper; public ObjectWrapper(Object realObject){ this.realObject = realObject; this.clazzWrapper = new ClazzWrapper(realObject.getClass()); } // 调用对象指定属性的get方法 public Object getVal(String property) throws Exception{ return clazzWrapper.getGetterMethod(property).invoke(realObject,null); } // 调用对象指定属性的set方法 public void setVal(String property,Object value) throws Exception{ clazzWrapper.getSetterMethod(property).invoke(realObject,value); } public Set<String> getProperties(){ return clazzWrapper.getProperties(); } public Set<ClazzWrapper.FiledExpand> getMapperFiledExpands(){ return clazzWrapper.getFiledExpandSet(); } public Object getRealObject(){ return realObject; } }
ObjectWrapperFactory
/** * @Author xiabing5 * @Desc 对象增强类。使用对象增强是因为我们不知道每个对象的getXXX方法，只能利用反射获取对象的属性和方法，然后 统一提供getVal或者setVal来获取或者设置指定属性，这就是对象的增强的重要性 **/ public class ObjectWrapperFactory { public static ObjectWrapper getInstance(Object o){ return new ObjectWrapper(o); } }
总结感悟
上述是我在写这个框架时的一些思路历程，代码演示请见我github。通过自己手写源码,对mybatis也有了个深刻的见解。当然有很多问题，后面也会进一步去完善，如果你对这个开源项目感兴趣，不妨star一下呀！