简介
前段时间利用空闲时间，参照mybatis的基本思路手写了一个ORM框架。一直没有时间去补充相应的文档，现在正好抽时间去整理下。通过思路历程和代码注释，一方面重温下知识，另一方面准备后期去完善这个框架。
image
传统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一下呀！
网友评论