• Home
• com.holmos
• holmos-webtest
• 1.0.2u7
• source code
• HolmosAnnotationTool.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

holmos.webtest.basetools.HolmosAnnotationTool Maven / Gradle / Ivy

package holmos.webtest.basetools;

import holmos.webtest.exceptions.HolmosFailedError;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

/**操作注解的工具类
 * 
 * @author 吴银龙([email protected])
 * */
public class HolmosAnnotationTool {
	/**获得clazz类里面被annotation注解的所有的字段，并依据参数来判断是否包含所有的祖先类中的可见字段
	 * @param clazz 母体类，不能为null
	 * @param annotation 指定的注解,不能为null
	 * @param includeSuper true 处理祖先类，
false 不处理祖先类
	 * @return 在clazz类里面被annotation注解的字段
	 * */
	public static  Set getFieldsWithAnnotationBase(Class clazz,ClassannotationClass,boolean includeSuper){
		if(Object.class.equals(clazz)){
			//如果为Object类，那么不可能有被annotation注解的字段，返回空set
			return Collections.emptySet();
		}
		//deal with all the fields in current Class
		SetfieldsWithAnnotation=new HashSet();
		for(Field field:clazz.getDeclaredFields()){
			if(field.getAnnotation(annotationClass)!=null){
				fieldsWithAnnotation.add(field);
			}
		}
		//deal with all the visiable fields in super class
		if(includeSuper){
			fieldsWithAnnotation.addAll(getFieldsWithAnnotationBase(clazz.getSuperclass(), annotationClass,includeSuper));
		}
		return fieldsWithAnnotation;
	}

	/**获得clazz类里面被annotation注解的所有的字段,并获取祖先类的可见字段
	 * @param clazz 母体类，不能为null
	 * @param annotation 指定的注解,不能为null
	 * @return 在clazz类里面被annotation注解的字段
	 * */
	public static  Set getFieldsWithAnnotationIncludeSuper(Class clazz,ClassannotationClass){
		return getFieldsWithAnnotationBase(clazz, annotationClass, true);
	}
	/**获得clazz类里面被annotation注解的所有的字段,不获取祖先类的可见字段
	 * @param clazz 母体类，不能为null
	 * @param annotation 指定的注解,不能为null
	 * @return 在clazz类里面被annotation注解的字段
	 * */
	public static  Set getFieldsWithAnnotationNotIncludeSuper(Class clazz,ClassannotationClass){
		return getFieldsWithAnnotationBase(clazz, annotationClass, false);
	}
	/**获得clazz类里面被annotation注解的所有的方法,并依据参数来判断是否获取祖先类的可见方法
	 * @param clazz 母体类，不能为null
	 * @param annotation 指定的注解,不能为null
	 * @param includeSuper true 处理祖先类，
false 不处理祖先类
	 * @return 在clazz类里面被annotation注解的方法
	 * */
	public static  Set getMethodsWithAnnotationBase(Class clazz,ClassannotationClass,boolean includeSuper){
		if(Object.class.equals(clazz)){
			return Collections.emptySet();
		}
		//deal with all the methods in current Class
		Set methodsWithAnnotation=new HashSet();
		for(Method method:clazz.getDeclaredMethods()){
			if(method.getAnnotation(annotationClass)!=null){
				methodsWithAnnotation.add(method);
			}
		}
		//deal with all the visiable methods in super class
		if(includeSuper){
			getMethodsWithAnnotationBase(clazz.getSuperclass(), annotationClass, includeSuper);
		}
		return methodsWithAnnotation;
	}
	/**获得clazz类里面被annotation注解的所有的方法,并获取祖先类的可见方法
	 * @param clazz 母体类，不能为null
	 * @param annotation 指定的注解,不能为null
	 * @return 在clazz类里面被annotation注解的方法
	 * */
	public static  Set getMethodsWithAnnotationIncludeSuper(Class clazz,ClassannotationClass){
		return getMethodsWithAnnotationBase(clazz, annotationClass, true);
	}
	/**获得clazz类里面被annotation注解的所有的方法,不获取祖先类的可见方法
	 * @param clazz 母体类，不能为null
	 * @param annotation 指定的注解,不能为null
	 * @return 在clazz类里面被annotation注解的方法
	 * */
	public static  Set getMethodsWithAnnotationNotIncludeSuper(Class clazz,ClassannotationClass){
		return getMethodsWithAnnotationBase(clazz, annotationClass, false);
	}
	/**获取clazz类里面所有方法级别的annotation类型的注解，包含祖先类
	 * @param clazz 母体类
	 * @param annotation 要获取的注解类型
	 * @return 获取的所有注解对象
	 * */
	public static  ArrayList getMethodLevelAnnotations(Class clazz, Class annotationClass){
		ArrayListresult=new ArrayList();
		Set methods=getMethodsWithAnnotationIncludeSuper(clazz, annotationClass);
		for(Method method:methods){
			result.add(method.getAnnotation(annotationClass));
		}
		return result;
	}
	/**获取clazz类里面所有字段级别的annotation类型的注解，包含祖先类
	 * @param clazz 母体类
	 * @param annotation 要获取的注解类型
	 * @return 获取的所有注解对象
	 * */
	public static  Set getFieldLevelAnnotations(Classclazz,Class annotationClass){
		Setresult=new HashSet();
		Set fields=getFieldsWithAnnotationIncludeSuper(clazz, annotationClass);
		for(Field field:fields){
			result.add(field.getAnnotation(annotationClass));
		}
		return result;
	}
	/**获取clazz类里面method方法上annotation类型的注解,如果方法级别的注解存在，那么返回方法级别的，如果不存在，返回类级别的
	 * @param clazz 母体类
	 * @param method 方法对象
	 * @param annotation 要获取的注解类型
	 * @return 获取的注解对象
	 * */
	public static  T getMethodOrClassLevelAnnotation(Classclazz,Method method,ClassannotationClass){
		T annotation=getMethodLevelAnnotation(clazz,method,annotationClass);
		if(annotation!=null){
			return annotation;
		}
		annotation=getClassLevelAnnotation(clazz,annotationClass);
		return annotation;
	}
	/**
	 * 获取clazz类里面method方法上annotation类型的注解的属性名称为annotationPropertyName的属性值,

	 * 如果方法级别的注解存在，那么返回方法级别的，如果不存在，返回类级别的
	 * @param annotationClass 注解类型
	 * @param annotationPropertyName 注解的属性名称 
	 * @param defaultValue 默认值，在注解属性值获取失败的时候返回此值
	 * @param method 指定的方法
	 * @param clazz 指定的类
	 * */
	public static  T getMethodOrClassLevelAnnotationProperty(Class annotationClass,
            String annotationPropertyName, T defaultValue, Method method, Class clazz){
		S annotation=method.getAnnotation(annotationClass);
		if(annotation!=null){
			Method property=getPropertyByName(annotationPropertyName,annotationClass);
			@SuppressWarnings("unchecked")
			T propertyValue=(T) getAnnotationPropertyValue(property, annotation);
			if(!defaultValue.equals(propertyValue)){
				return propertyValue;
			}
		}
		return getClassLevelAnnotationPropertyValue(clazz.getSuperclass(), annotationPropertyName, annotationClass, defaultValue);
	}
	private static Method getPropertyByName(String annotationPropertyName,Class annotation){
		try {
			return annotation.getMethod(annotationPropertyName);
		} catch (SecurityException e) {
			throw new HolmosFailedError("注解"+annotation.getName()+"获取"+annotationPropertyName+"失败!");
		} catch (NoSuchMethodException e) {
			throw new HolmosFailedError("注解"+annotation.getName()+"获取"+annotationPropertyName+"失败!");
		}
	}
	/**获取clazz类里面method方法上annotation类型的注解,如果方法级别的注解存在，那么返回方法级别的，如果不存在，返回null
	 * @param clazz 母体类
	 * @param method 方法对象
	 * @param annotation 要获取的注解类型
	 * @return 获取的注解对象
	 * */
	public static  T getMethodLevelAnnotation(Classclazz,Method method,ClassannotationClass){
		if(Object.class.equals(clazz)){
			return null;
		}
		return (T) method.getAnnotation(annotationClass);
	}
	/**获取clazz类上annotation类型的注解,如果方法级别的注解存在，那么返回方法级别的，如果不存在，递归获取父类，直到Object
	 * @param clazz 母体类
	 * @param annotation 要获取的注解类型
	 * @return 获取的注解对象
	 * */
	public static  T getClassLevelAnnotation(Classclazz,ClassannotationClass){
		if(Object.class.equals(clazz)){
			return null;
		}
		T annotaion= clazz.getAnnotation(annotationClass);
		if(annotaion==null){
			annotaion=getClassLevelAnnotation(clazz.getSuperclass(), annotationClass);
		}
		return annotaion;
	}
	/**获取指定注解的指定属性
	 * @param annotation 指定的注解 不能为null
	 * @param propertyName 指定注解的属性名字 不能为null
	 * @return 指定属性,是一个方法
	 * */
	public static Method getAnnotationPropertyWithName(Classannotation,String propertyName){
		try{
			return annotation.getMethod(propertyName);
		}catch (NoSuchMethodException e) {
			throw new HolmosFailedError("在"+annotation.getName()+"注解里面没有找到属性"+propertyName);
		}
	}
	/**获得指定注解对象的指定属性(方法)的值
	 * @param annotationProperty 方法属性对象
	 * @param 指定的注解对象
	 * @return 属性的value
	 * */
	@SuppressWarnings("unchecked")
	public static  T getAnnotationPropertyValue(Method annotationProperty,Annotation annotation){
		try {
			return (T) annotationProperty.invoke(annotation);
		} catch (IllegalArgumentException e) {
			throw new HolmosFailedError("无法获得注解"+annotation.annotationType().getName()+"的"+annotationProperty.getName()+"属性信息!");
		} catch (IllegalAccessException e) {
			throw new HolmosFailedError("无法获得注解"+annotation.annotationType().getName()+"的"+annotationProperty.getName()+"属性信息!");
		} catch (InvocationTargetException e) {
			throw new HolmosFailedError("无法获得注解"+annotation.annotationType().getName()+"的"+annotationProperty.getName()+"属性信息!");
		}
	}
	/**判断在类clazz里面是否有字段，方法，类级别的注解annotationClass
	 * @param clazz 给定的类
	 * @param annotationClass 给定的注解类型
	 * @return true 字段，方法，类级别的注解都没有 
 false 至少有其中一个级别
	 * */
	public boolean hasFieldOrMethodOrClassLevelAnnotation(Classclazz,ClassannotationClass){
		return getFieldLevelAnnotations(clazz, annotationClass).isEmpty()&&
				getMethodLevelAnnotations(clazz, annotationClass).isEmpty()&&(getClassLevelAnnotation(clazz, annotationClass)!=null);
	}
	/**判断在类clazz里面是否有字段级别的注解annotationClass
	 * @param clazz 给定的类
	 * @param annotationClass 给定的注解类型
	 * @return true 没有 
 false 有
	 * */
	public boolean hasFieldLevelAnnotation(Classclazz,ClassannotationClass){
		return getFieldLevelAnnotations(clazz, annotationClass).isEmpty();
	}
	/**判断在类clazz里面是否有方法级别的注解annotationClass
	 * @param clazz 给定的类
	 * @param annotationClass 给定的注解类型
	 * @return true 没有 
 false 有
	 * */
	public boolean hasMethodLevelAnnotation(Classclazz,ClassannotationClass){
		return getMethodLevelAnnotations(clazz, annotationClass).isEmpty();
	}
	/**判断在类clazz里面是否有类级别的注解annotationClass
	 * @param clazz 给定的类
	 * @param annotationClass 给定的注解类型
	 * @return true 没有 
 false 有
	 * */
	public static boolean hasClassLevelAnnotation(Classclazz,ClassannotationClass){
		return getClassLevelAnnotation(clazz, annotationClass)!=null;
	}
	/**
	 * 判断在clazz是否有类级别的annotationClass类型注解或者在method上是否有方法级别的annotationClass注解
	 * 
如果clazz上有类级别的annotationClass类型注解，返回true
	 * 
在没有类级别annotationClass注解的情况下，检查在方法method上是否有annotationClass类型注解，如果有返回true，否则返回false
	 * */
	public static boolean hasClassOrMethodLevelAnnotation(Classclazz,Method method,ClassannotationClass){
		if(hasClassLevelAnnotation(clazz, annotationClass))
			return true;
		return getMethodLevelAnnotation(clazz, method, annotationClass)!=null;
	}
	/**根据给定的类,给定的注解,给定的注解的属性名字,返回类级别的注解属性值,如果值为null,返回给定的默认值defaultValue
	 * @param clazz 给定的类
	 * @param propertyName 注解里面属性名字
	 * @param annotationClass 给定的注解
	 * @param defaultValue 值为null 的时候的返回的默认值;当得到的值与defaultValue相同的时候寻找祖先类里的值
	 * @return 获得的类级别的注解的属性值
	 * */
	public static  T getClassLevelAnnotationPropertyValue(Classclazz,
			String propertyName,ClassannotationClass,T defaultValue){
		if (Object.class.equals(clazz)) {
            return defaultValue;
        }
		S annotation=clazz.getAnnotation(annotationClass);
		if(annotation!=null){
			Method annotationProperty=getAnnotationPropertyWithName(annotationClass, propertyName);
			T propertyValue=getAnnotationPropertyValue(annotationProperty, annotation);
			if(propertyValue.equals(defaultValue)){
				//如果相同的话，找寻父类
				return propertyValue;
			}
		}
		return getClassLevelAnnotationPropertyValue(clazz.getSuperclass(), propertyName, annotationClass, defaultValue);
	}
	/**根据给定的方法,给定的注解,给定的注解的属性名字,返回方法级别的注解属性值,如果值为null,返回给定的默认值defaultValue
	 * @param method 给定的方法
	 * @param propertyName 注解里面属性名字
	 * @param annotationClass 给定的注解
	 * @param defaultValue 值为null 的时候的返回的默认值;
	 * @return 获得的方法级别的注解的属性值
	 * */
	public static  T getMethodLevelAnnotationPropertyValue(Method method,
			String propertyName,ClassannotationClass,T defaultValue){
		S annotation = method.getAnnotation(annotationClass);
		Method annotationProperty= getAnnotationPropertyWithName(annotationClass, propertyName);
		T propertyValue=getAnnotationPropertyValue(annotationProperty, annotation);
		if(propertyValue==null)
			return defaultValue;
		return propertyValue;
	}
	/**根据给定的类,给定的方法,给定的注解,给定的注解的属性名字,优先返回方法级别的注解属性值,如果值为null或者为default,继续寻找类级别的注解,返回给定的默认值defaultValue
	 * @param clazz 给定的类
	 * @param method 给定的方法
	 * @param propertyName 注解里面属性名字
	 * @param annotationClass 给定的注解
	 * @param defaultValue 值为null 的时候的返回的默认值;当得到的值与defaultValue相同的时候寻找祖先类里的值
	 * @return 优先获得方法级别的注解值,如果为null或者为default获得的类级别的注解的属性值
	 * */
	public static  T getMethodOrClassLevelAnnotationPropertyValue(Classclazz,Method method,
			String propertyName,ClassannotationClass,T defaultValue){
		T propertyValue=getMethodLevelAnnotationPropertyValue(method, propertyName, annotationClass, defaultValue);
		if(propertyName==null||propertyValue.equals(defaultValue)){
			return getClassLevelAnnotationPropertyValue(clazz, propertyName, annotationClass, defaultValue);
		}
		return propertyValue;
	}
	/**
	 * 创建一个类型为T的实例
	 * @param type 创建实例的类型
	 * @param bypassAccessibility 当是true 的时候，如果此类型的无参构造函数不是public的时候不抛出异常
	 * @param argumentTypes 参数类型列表
	 * @param arguments 参数列表
	 * */
	public static  T createInstanceOfType(Classtype,boolean bypassAccessibility, @SuppressWarnings("rawtypes") Class[] argumentTypes,
            Object[] arguments){
		if(type.isMemberClass()||Modifier.isStatic(type.getModifiers())){
			throw new HolmosFailedError("成员类和静态类无法为其构造实例!");
		}
		try{
			Constructorconstructor=type.getConstructor(argumentTypes);
			if(bypassAccessibility){
				constructor.setAccessible(bypassAccessibility);
			}
			return constructor.newInstance(arguments);
		}catch (InvocationTargetException e) {
            throw new HolmosFailedError("构造" + type.getName()+"实例的时候发生错误!");

        } catch (Exception e) {
            throw new HolmosFailedError("构造" + type.getName()+"实例的时候发生错误!");
        }
	}
}