使用cglib实现数据库框架的级联查询
写在前面的
这一章是以前写的 《手把手教你写一个Java的orm框架》 的追加内容。由于以前写的数据库框架不支持级联查询这个操做，对于有关联关系的表用起来仍是比较麻烦，因而就准备把这个功能给加上。这个功能是在我以前写的数据库框架基础上作的，有兴趣的同窗能够看一看。java
数据库框架
github：JdbcPlusgit
关于这个框架
手把手教你写个java的orm框架（1）github
手把手教你写个java的orm框架（2）spring
手把手教你写个java的orm框架（5）apache
大体的思路
对于级联查询这个操做，他用起来大体是这样的，好比：bash
//在这里使用数据库框架查询一个对象出来
User user = jdbcPuls.selectById(User.class, 1);
//user对象中有一个parent属性，关联的是另一个表，在数据库中是一个外键
//这时候咱们直接使用getParent()，就能够将关联对象查出来
Parent parent = user.getParent();复制代码
要实现这个功能，首要条件是须要在第一次查询的时候返回一个代理对象，这个代理对象会拦截到全部的get方法，而且须要在方法中判断：若是这个方法对应的属性是一个外键的话，就经过数据库将这个对象查出来（仍是个代理对象），而后返回出去。app
须要用到的技能
根据上面的思路来讲，主要使用到的就是动态代理。动态代理有不少种实现方式，好比java的动态代理，cglib的动态代理等等。这里我使用cglib的动态代理，缘由吗...是由于java的动态代理必需要基于一个接口，我又不想修改数据库对应的实体类，那就只能用cglib咯。框架
关于cglib呢，它是一个Java的字节码框架，官方描述是这样的：
Byte Code Generation Library is high level API to generate and transform JAVA byte code. It is used by AOP, testing, data access frameworks to generate dynamic proxy objects and intercept field access. github.com/cglib/cglib…
是否是很厉害的样子。cglib的动态代理是基于子类实现的（它是直接生成了一个子类的class文件，经过必定的配置能够获得生成的class文件），而后在子类中调用父类的方法这样的。具体原理这里就很少说了，咱们只须要知道怎么用就行了。
用cglb建立代理对象
使用cglib建立代理对象的方法大体是这样的：
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(User.class);
//设置方法回调
enhancer.setCallback(new MethodInterceptor() {
/**
* 被代理的对象方法执行前，会调用这个方法，用于方法的拦截
* @param o
* @param method
* @param objects
* @param methodProxy
* @return
* @throws Throwable
*/
@Override
public Object intercept(
Object o,
Method method,
Object[] objects,
MethodProxy methodProxy
) throws Throwable {
//原方法的执行结果
Object invokeResult = methodProxy.invokeSuper(o, objects);
//这里能够写一些别的东西
return invokeResult;
}
});
//建立代理对象
User proxyUser = (User) enhancer.create();复制代码
这样建立代理对象的这一部分就完成啦，接下来就是要想一下怎样实现级联查询这个功能了。
实现级联查询
写一个注解描述关联关系
以前我写的数据库框架：JdbcPlus 是经过注解来实现的，我要新增一个注解用来描述一个实体类的属性与另外一个实体类之间的关联关系。这里我自定义一个注解 @FK，代码以下
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 添加在外键字属性上，
* 属性类型是关联对象的Entity
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface FK {
/**
* 被关联的字段名称
*
* @return
*/
String value();
}复制代码
注解中的value表示被关联对象的字段名称。下面建立一个实体类来讲明一下：
/**
* 用户表
*
*/
@Getter
@Setter
@Table("user")
public class User {
/**
* 用户名
*/
@Column("name")
private String name;
/**
* 用户id
*/
@Id
@Column("id")
private int id;
/**
* parent_id
*/
@Column("parent_id")
@FK("id")
private User parentId;
}
复制代码
1：@Table("user")说明User对象对应数据库中的user表。
2：@Column("parent_id") 表示这个属性对应的是sql中的字段parent_id。
3：@FK("id")说明这个字段是一个外键，关联到user表中的字段id上。
4：@Getter和@Setter是lombok中的注解，用于生成对应的get/set方法，不重要。
修改框架查询方法，返回代理对象
这里要将以前写的数据库框架返回的查询结果修改成代理对象：
/**
* 把数据库查询的结果与对象进行转换
*
* @param resultSet
* @param rowNum
* @return
* @throws SQLException
*/
@Override
@SneakyThrows(SQLException.class)
public T mapRow(ResultSet resultSet, int rowNum) {
Map<String, Object> resultMap = columnMapRowMapper.mapRow(resultSet, rowNum);
//建立cglib代理对象
EntityProxy entityProxy = EntityProxy.entityProxy(tableClass, jdbcPlus);
Object proxy = entityProxy.getProxy();
for (Map.Entry<String, Object> entry : resultMap.entrySet()) {
//数据库字段名
String key = entry.getKey();
if (!columnFieldMapper.containsKey(key)) {
continue;
}
Field declaredField = columnFieldMapper.get(key);
if (declaredField == null) {
continue;
}
Object value = entry.getValue();
//若是属性添加了@FK注解，新建一个空对象占位
if (EntityUtils.isFK(declaredField)) {
Object fkObject = getJoinFieldObject(declaredField, value);
ClassUtils.setValue(proxy, declaredField, fkObject);
} else {
ClassUtils.setValue(proxy, declaredField, value);
}
}
return (T) proxy;
}
/**
* 用于填充查询对象，使其toString中外键值不显示null
*
* @param fkField 外键属性
* @param sqlValue sql中的结果
* @return
*/
Object getJoinFieldObject(Field fkField, Object sqlValue) {
if (sqlValue == null) {
return null;
}
Class fieldType = fkField.getType();
//找到对应的Class
EntityTableRowMapper mapper = EntityMapperFactory.getMapper(fieldType);
Map<String, Field> mapperColumnFieldMapper = mapper.getColumnFieldMapper();
FK FK = EntityUtils.getAnnotation(fkField, FK.class);
String fieldName = FK.value();
//实例化原始对象，与以后的代理对象作区分
Object entityValue = ClassUtils.getInstance(fieldType);
Field field = mapperColumnFieldMapper.get(fieldName);
ClassUtils.setValue(entityValue, field, sqlValue);
return entityValue;
}复制代码
这里是将数据库查询结果转换成一个实体类的方法，是SpringJDBC中接口RowMapper的一个实现类。这主要修改的部分是：
1：在遍历属性并赋值的部分添加了属性上有没有注解@FK的判断。
2：若是属性上添加了@FK，就根据属性的类型，实例化一个原始对象，并把查询结果的值放进这个原始对象的对应属性中。
3：将查询的返回结果修改为代理对象。这里建立代理对象的类是EntityProxy，这个在后面会说明。
方法拦截器
这里主要就是在说EntityProxy这个类，它主要作的事情就是建立代理对象，而且拦截对象中的方法。代码是这样的：
package com.hebaibai.jdbcplus;
import com.hebaibai.jdbcplus.util.ClassUtils;
import com.hebaibai.jdbcplus.util.EntityUtils;
import com.hebaibai.jdbcplus.util.StringUtils;
import lombok.Getter;
import lombok.SneakyThrows;
import lombok.extern.apachecommons.CommonsLog;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.util.Assert;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* entity的代理对象
*
* @author hjx
*/
@CommonsLog
public class EntityProxy implements MethodInterceptor {
/**
* 代理对象
*/
@Getter
private Object proxy;
/**
* 数据库操做工具
*/
private JdbcPlus jdbcPlus;
/**
* 建立代理对象
*
* @param entityClass
* @return
*/
public static EntityProxy entityProxy(Class entityClass, JdbcPlus jdbcPlus) {
log.debug("建立代理对象：" + entityClass.getName());
EntityProxy entityProxy = new EntityProxy();
Assert.isTrue(EntityUtils.isTable(entityClass), "代理对象不是一个@Table！");
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(entityClass);
//设置方法回调
enhancer.setCallback(entityProxy);
//建立代理对象
entityProxy.proxy = enhancer.create();
entityProxy.jdbcPlus = jdbcPlus;
return entityProxy;
}
/**
* 代理对象方法拦截器，用于实现几联查询
*
* @param entity
* @param method
* @param values
* @param methodProxy
* @return
*/
@Override
@SneakyThrows(Throwable.class)
public Object intercept(Object entity, Method method, Object[] values, MethodProxy methodProxy) {
//执行本来的方法
Object invokeResult = methodProxy.invokeSuper(proxy, values);
Class fkEntityClass = method.getReturnType();
String name = method.getName();
//返回值位null，直接返回
if (invokeResult == null) {
return invokeResult;
}
//若是是get方法, 或者 boolean 类型的is 开头
else if (name.startsWith("get") || name.startsWith("is")) {
Class invokeResultClass = invokeResult.getClass();
Class superclass = invokeResultClass.getSuperclass();
//若是父类等于字段类型而且添加了@Table注解，
// 说明是cglib生成的子类而且已经查询出来告终果，直接返回
if (fkEntityClass == superclass || !EntityUtils.isTable(fkEntityClass)) {
return invokeResult;
}
//经过方法名找到Entity的属性，以后找到该属性关联的Entity中的属性。
Field fkField = getFieldBy(method);
Field fkTargetField = EntityUtils.getEntityFkTargetField(fkField);
if (fkTargetField == null) {
return invokeResult;
}
Column column = EntityUtils.getAnnotation(fkTargetField, Column.class);
Object value = ClassUtils.getValue(invokeResult, fkTargetField);
//执行查询
log.debug("对外键属性进行数据库查询。。。");
Object fkEntityProxy = jdbcPlus.selectOneBy(fkEntityClass, column.value(), value);
//将查询结果赋值给原对象
ClassUtils.setValue(this.proxy, fkField, fkEntityProxy);
return fkEntityProxy;
} else {
return invokeResult;
}
}
/**
* 经过方法找到对应的属性
*
* @param method
* @return
*/
private Field getFieldBy(Method method) {
String fieldName = method.getName();
if (fieldName.startsWith("get")) {
fieldName = fieldName.substring(3);
fieldName = StringUtils.lowCase(fieldName, 0);
} else if (fieldName.startsWith("is")) {
fieldName = fieldName.substring(2);
fieldName = StringUtils.lowCase(fieldName, 0);
} else {
//没有以get 或者 is 开头的方法，直接返回null
return null;
}
//经过属性名找到class中对应的属性
Class<?> declaringClass = method.getDeclaringClass();
try {
Field field = declaringClass.getDeclaredField(fieldName);
//若是找到的属性字段类型与方法返回值不一样，返回null
if (field.getType() != method.getReturnType()) {
return null;
}
return field;
} catch (NoSuchFieldException e) {
return null;
}
}
/**
* 私有化构造器
*/
private EntityProxy() {
}
}复制代码
说一下其中的几个属性和方法。
1：private Object proxy; 建立出来的代理对象。
2：private JdbcPlus jdbcPlus; 操做数据库的类，就是这个框架自己主要的类。
3：public static EntityProxy entityProxy(Class entityClass, JdbcPlus jdbcPlus); 建立代理对象的方法，建立一个entityClass的代理对象。
4：public Object intercept(Object entity, Method method, Object[] values, MethodProxy methodProxy); 实现了cglib的接口MethodInterceptor后须要重写的方法，也是实现级联查询功能主要要写的方法。这里传入了五个参数：
entity：对象自己。
method：代理对象所拦截的方法自己。
values：方法中传入的参数。
methodProxy：拦截的方法的代理。
在进入这个方法的时候先作了一些校验，好比方法是否是一个get方法，返回值的类型是否是添加了@Table注解，返回值是否是null等等，在这些条件知足的状况下，取出这个方法的返回值invokeResultClass（此时这个对象是一个原始对象，是在上面的getJoinFieldObject中建立出来的）中保存的sql中查询出来的值，最后经过方法名找到对应的添加了@FK注解的属性找到所关联的表，执行查询并获得查询结果（这时结果是一个代理对象），最后吧查询结果设置到对应的属性上，并返回就行了。
最后
这里部分写的比较混乱（吃了没文化的亏/(ㄒoㄒ)/~~），可是代码上仍是比较清楚的，能够结合代码看一下。主要的部分就是EntityProxy.intercept和EntityTableRowMapper.mapRow两个方法，你们能够上github看一下。
完
- 1. 使用cglib实现数据库框架的级联查询
- 2. 0505-使用Apache Hive3实现跨数据库的联邦查询
- 3. beego:数据库的级联查询
- 4. jquery实现二级联动，实时查询数据库
- 5. 如何实现参数级联查询
- 6. 数据库查询服务框架
- 7. CI框架 数据库查询绑定
- 8. 使用MyBatis框架实现对数据库增删改查
- 9. 实现数据库的跨库join联表查询
- 10. 数据库关联查询
- 更多相关文章...
- • MyBatis级联查询 - MyBatis教程
- • 多对多关联查询 - MyBatis教程
- • TiDB 在摩拜单车在线数据业务的应用和实践
- • ☆基于Java Instrument的Agent实现
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 使用cglib实现数据库框架的级联查询
- 2. 0505-使用Apache Hive3实现跨数据库的联邦查询
- 3. beego:数据库的级联查询
- 4. jquery实现二级联动，实时查询数据库
- 5. 如何实现参数级联查询
- 6. 数据库查询服务框架
- 7. CI框架 数据库查询绑定
- 8. 使用MyBatis框架实现对数据库增删改查
- 9. 实现数据库的跨库join联表查询
- 10. 数据库关联查询