spring boot 利用切面和反射进行自动关联查询

1.定义注解类：

QueryAuto:

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * ClassName: Query <br/>
 * Function: 模块关联查询注解<br/>
    用于返回list等方法上
 */
@Documented
@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface QueryAuto {
	
}

　QueryField:

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * ClassName: QueryField <br/>
 * Function: 模块关联查询注解<br/>
 * <p>比如字典数据，我们表里面都存的字典id，之前的开发模式是在业务模块的sql里各种left join去查询字典名称.</p> 
 * <p>现在的做法是在实体对象的字典id属性上加上此注解，并写上字典名称属性，会自动去查询数据库，赋值于字典名称属性上去.</p> 

 */
@Documented
@Inherited
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface QueryField {
	
	/**
	 * module:(业务模块编码，默认为Dic 字典模块，其他模块的话需要遵循一定的命名规则，
	 * 			详见com.talkweb.query.common.QueryConstant 模块定义常量). <br/>
	 * @author gavin
	 * @return
	 */
	public String module() default "Dic";
	
	/**
	 * nameField:(字典数据名称属性字段). <br/>
	 * @author gavin
	 * @return
	 */
	public String nameField();
}

2.定义自动查询的属性实体类

import java.io.Serializable;

/**
 * ClassName:QueryFieldEntity <br/>
 * Function: 需要自动查询的字段属性对象. <br/>
 */
public class QueryFieldEntity implements Serializable {
	private static final long serialVersionUID = 1L;
	
	private String idFieldName;		//id属性的字段名称
	private String nameFieldName;	//name属性字段名称
	private String module;			//需要查询的模块名称
	
	public String getIdFieldName() {
		return idFieldName;
	}
	public void setIdFieldName(String idFieldName) {
		this.idFieldName = idFieldName;
	}
	public String getNameFieldName() {
		return nameFieldName;
	}
	public void setNameFieldName(String nameFieldName) {
		this.nameFieldName = nameFieldName;
	}
	public String getModule() {
		return module;
	}
	public void setModule(String module) {
		this.module = module;
	}
}

3.定义查询工具类：用于获取需要查询的字段

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import com.annotation.QueryField;
import com.query.entity.QueryFieldEntity;

/**
 * ClassName:QueryUtil <br/>
 * Function: 自动查询工具类. <br/>
 */
public class QueryUtil {
	
	/**
	 * getQueryAutoField:(得到对象中需要自动查询的字段). <br/>
	 * @author gavin
	 * @param object
	 * @return
	 */
	public static List<QueryFieldEntity> getQueryAutoField(Object object){
		List<QueryFieldEntity> list = new ArrayList<QueryFieldEntity>();
		Class<?> cls = object.getClass();
	    Field[] fields = cls.getDeclaredFields();  
		List<Field> fieldList = new ArrayList<Field>(Arrays.asList(fields));
	    //获取父类字段
	    Class<?> supercls = cls.getSuperclass();
	    Field[] superfields = supercls.getDeclaredFields();  
	   
	    fieldList.addAll( new ArrayList<Field>(Arrays.asList(superfields)));
	    for (Field field : fieldList) {
	    	field.setAccessible(true);
	    	QueryField queryField = field.getAnnotation(QueryField.class);
	    	if(queryField != null){
	    		QueryFieldEntity entity = new QueryFieldEntity();
	    		entity.setIdFieldName(field.getName());
	    		entity.setNameFieldName(queryField.nameField());
	    		entity.setModule(queryField.module());
	    		list.add(entity);
	    	}
	    }
		return list;
	}
	
	/**
	 * getQueryAutoField:(得到对象中需要自动查询的字段). <br/>
	 * @author gavin
	 * @param object
	 * @return
	 */
	public static List<QueryFieldEntity> getSuperQueryAutoField(Object object){
		List<QueryFieldEntity> list = new ArrayList<QueryFieldEntity>();
		Class<?> supercls = object.getClass().getSuperclass();
	    Field[] fields = supercls.getDeclaredFields();  
	    for (Field field : fields) {
	    	field.setAccessible(true);
	    	QueryField queryField = field.getAnnotation(QueryField.class);
	    	if(queryField != null){
	    		QueryFieldEntity entity = new QueryFieldEntity();
	    		entity.setIdFieldName(field.getName());
	    		entity.setNameFieldName(queryField.nameField());
	    		entity.setModule(queryField.module());
	    		list.add(entity);
	    	}
	    }
		return list;
	}
}

4.定义查询接口：用于处理不同类型的数据

/**
 * ClassName:Query <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Date:     2017年6月27日 上午9:47:04 <br/>

 */
public interface Query {
	/**
	 * doPage:(处理分页数据). <br/>
	 * @author gavin
	 * @param object
	 */
	public void doPage(Object object);
	
	/**
	 * doList:(处理简单列表数据). <br/>
	 * @author gavin
	 * @param object
	 */
	public void doList(Object object);
	
	/**
	 * doObject:(处理简单实体对象数据). <br/>
	 * @author gavin
	 * @param object
	 */
	public void doObject(Object object);
}

　

package com.query.query.impl;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;

import com.common.Page;
import com.query.adapter.QueryAdapter;
import com.query.common.QueryUtil;
import com.query.entity.QueryFieldEntity;
import com.query.query.Query;

/**
 * ClassName:QueryImpl <br/>
 * Function: 自动查询实现类. <br/>
 * Date:     2017年6月27日 上午9:54:02 <br/>
 * @author   gavin
 * @since    JDK 1.6
 */
@Component
public class QueryImpl implements Query {
	@Resource(name="queryAdapter")
	private QueryAdapter queryAdapter;
	
	@Override
	public void doPage(Object object) {
		Page page = (Page)object;
		try {
			Method m = page.getClass().getMethod("getContent");
			List list = (List)m.invoke(page);
	    	if(list != null && list.size() > 0){
	    		Object o = list.get(0);
				List<QueryFieldEntity> fieldList = QueryUtil.getQueryAutoField(o);
				if(fieldList != null && fieldList.size() > 0){
					for(Object ob : list){
						for(QueryFieldEntity field : fieldList){
							queryAdapter.handle(ob, field);
						}
					}
				}
	    	}
		} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void doList(Object object) {
		List list = (List)object;
		if(list != null && list.size() > 0){
			Object o = list.get(0);
			List<QueryFieldEntity> fieldList = QueryUtil.getQueryAutoField(o);
			if(fieldList != null && fieldList.size() > 0){
				for(Object ob : list){
					for(QueryFieldEntity field : fieldList){
						queryAdapter.handle(ob, field);
					}
				}
			}
		}
	}

	@Override
	public void doObject(Object object) {
		List<QueryFieldEntity> fieldList = QueryUtil.getQueryAutoField(object);
		if(fieldList != null && fieldList.size() > 0){
			for(QueryFieldEntity field : fieldList){
				queryAdapter.handle(object, field);
			}
		}
	}
}

　　

5.定义查询适配器：用于使用不同的模块（关联表）

package com.talkweb.query.adapter;

import java.lang.reflect.Field;

import com.config.ApplicationContextRegister;
import org.springframework.stereotype.Component;
import org.springframework.web.context.ContextLoader;

import com.query.entity.QueryFieldEntity;
import com.query.query.QueryModule;

/**
 * ClassName:QueryAdapter <br/>
 * Function: 自动查询适配器. <br/>
 */
@Component("queryAdapter")
public class QueryAdapter {
	
	/**
	 * handle:(根据不同模块，适配不同的接口实现类处理查询). <br/>
	 * @author gavin
	 * @param object
	 * @param field
	 */
	public void handle(Object object,QueryFieldEntity field) {
		if(field.getModule() != null && !"".equals(field.getModule())){
			//这里必须注意，关于字段上的配置的Module属性，必须要和QueryModule接口实现类的后缀一致，
			//这里getBean的bean的名称就是queryModuleOf + Module属性！！！！
			QueryModule queryModule = (QueryModule) ApplicationContextRegister.getApplicationContext()
													.getBean("queryModuleOf"+field.getModule());
			if(queryModule != null){
				try {
					Field idField ;
					try{
						idField = object.getClass().getDeclaredField(field.getIdFieldName());
					} catch(NoSuchFieldException e){
						idField = object.getClass().getSuperclass().getDeclaredField(field.getIdFieldName());
					}
					idField.setAccessible(true);
					String id = (String)idField.get(object);
					if(id != null && !"".equals(id)){
						String name = queryModule.query(id,object, field);
						if(name != null ){	//这里只判断null，不做空判断，因为空可能是数据本身值
							Field nameField ;
							try{
								nameField =  object.getClass().getDeclaredField(field.getNameFieldName());
							} catch(NoSuchFieldException e){
								nameField = object.getClass().getSuperclass().getDeclaredField(field.getNameFieldName());
							}
							nameField.setAccessible(true);
							nameField.set(object, name);
						}
					}
				} catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

　　

6.定义模块处理类

package com.query.query;

import com.query.entity.QueryFieldEntity;

/**
 * ClassName:QueryModule <br/>
 * Function: 查询具体模块字段接口. <br/>
 * Date:     2017年6月27日 上午11:30:00 <br/>
 * @author   gavin
 * @since    JDK 1.6
 */
public interface QueryModule {
	
	/**
	 * query:(查询具体模块方法，可以直接拿到id去做相应查询，然后返回). <br/>
	 * @author gavin
	 * @param id		id属性的值
	 * @param object	具体的实体对象
	 * @param field		反射需要用到的相关属性
	 * @return
	 */
	public String query(String id, Object object, QueryFieldEntity field);
}

　　

package com.query.query.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.entity.pub.Dic;
import com.query.entity.QueryFieldEntity;
import com.query.query.QueryModule;
import com.service.pub.impl.DicService;

/**
 * ClassName:QueryModuleOfDic <br/>
 * Function: 字典模块查询服务. <br/>

 */
@Component("queryModuleOfDic") //用于适配器中上下文获取bean
public class QueryModuleOfDic implements QueryModule {
	@Autowired
	private DicService dicService;
	
	@Override
	public String query(String id, Object object, QueryFieldEntity fieldEntity) {
		String name = null;
		if(id != null && !"".equals(id)){
			Dic dic = dicService.get(id);	//根据id查询字典值
			if(dic != null){
				name = dic.getName();
			}
		}
		return name;
	}
}

　　

7.定义查询切面类　　

import org.apache.log4j.Logger;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.annotation.QueryAuto;
import com.query.query.Query;

/**
 * ClassName:QueryAop <br/>
 * Function: 自动查询切面类. <br/>
 */
@Aspect
@Component
public class QueryAop {
	@Autowired
	private Query query;
	
	private static final Logger LOG = Logger.getLogger(QueryAop.class);
	
	//execution为执行的意思，*代表任意返回值，然后是包名，.*意思是包下面的所有子包 *(..)代表各种方法.  &&  @annotation(queryAuto) 表示并且方法上有为queryAuto的注解
	@Pointcut(value="execution(* com.service..*.*(..)) && @annotation(queryAuto) " , argNames="queryAuto")
    private void queryAuto(QueryAuto queryAuto){}//定义流程切入点 
	
	/**
	 * queryAuto:(自动查询切面方法). <br/>
	 * @author gavin
	 * @param point
	 * @param queryAuto
	 * @return
	 * @throws Throwable
	 */
	@Around(value = "queryAuto(queryAuto)" , argNames="queryAuto")
    public Object queryAuto(ProceedingJoinPoint point,QueryAuto queryAuto) throws Throwable {
		long start = System.currentTimeMillis();
        System.out.println("QueryAuto--->进入自动查询AOP");
        LOG.info("QueryAuto--->进入自动查询AOP");
        
        Object object = point.proceed();//执行方法
        if(object != null){
        	if(object instanceof com.talkweb.common.Page){	//返回类型为page对象
        		query.doPage(object);
        	} else if(object instanceof java.util.List){	//返回类型为List
        		query.doList(object);
        	} else if(object instanceof java.util.Map){		//返回类型为Map
        		//map 不作处理
        	} else if(object.getClass().getName().indexOf("com.talkweb.entity") >=0 ){	//默认为系统业务实体对象，如果为其他的比如：String Integer...基础数据类型，不作处理
        		query.doObject(object);
        	}
        }
        System.out.println("QueryAuto--->退出自动查询AOP方法。方法执行时长: "+ (System.currentTimeMillis() - start) + "ms");
        LOG.info("QueryAuto--->退出自动查询AOP方法。方法执行时长: "+ (System.currentTimeMillis() - start) + "ms");
        return object;
	}
}

　　

8.使用

1.在实体类中定义查询字段

@QueryField(module=QueryConstant.MODULE_AssumeComPany,nameField="fill_park_name")
private String fill_park_pid;	//填报所在园区，当前填报人所在的园区
private String fill_park_name;

　　

2.在service类中添加自动查询注解

@QueryAuto
	@Override
	public Page<NatureMainEntity> list(int pageNum, int pageSize, Map<String, Object> parameter) {
		PageHelper.startPage(pageNum, pageSize, pageNum == 0 ? false : true);
		List<NatureMainEntity> reuslt = getDao().list(parameter);
		Page<NatureMainEntity> page = new Page<NatureMainEntity>(reuslt);
		return page;
	}