zoukankan      html  css  js  c++  java
  • util(泛型工具类GenericsUtils)

    package com.guwenren.util;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.ArrayList;
    import java.util.List;
    
    import com.guwenren.bean.privilege.SystemPrivilege;
    import com.guwenren.bean.privilege.SystemPrivilegePK;
    import com.guwenren.web.action.privilege.Permission;
    import com.sun.swing.internal.plaf.metal.resources.metal;
    /**
     * 泛型工具类
     * @author guwenren
     *
     */
    public class GenericsUtils {
        /**  
         * 通过反射,获得指定类的父类的泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport<Buyer>  
         *  
         * @param clazz clazz 需要反射的类,该类必须继承范型父类
         * @param index 泛型参数所在索引,从0开始.  
         * @return 范型参数的实际类型, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回<code>Object.class</code>
         */  
        @SuppressWarnings({ "rawtypes" })
        public static Class getSuperClassGenricType(Class clazz, int index) {    
            Type genType = clazz.getGenericSuperclass();//得到泛型父类  
            //如果没有实现ParameterizedType接口,即不支持泛型,直接返回Object.class   
            if (!(genType instanceof ParameterizedType)) {
                return Object.class;   
            }  
            //返回表示此类型实际类型参数的Type对象的数组,数组里放的都是对应类型的Class, 如BuyerServiceBean extends DaoSupport<Buyer,Contact>就返回Buyer和Contact类型   
            Type[] params = ((ParameterizedType) genType).getActualTypeArguments();                   
            if (index >= params.length || index < 0) { 
                 throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
            }      
            if (!(params[index] instanceof Class)) {
                return Object.class;   
            }   
            return (Class) params[index];
        }
        /**  
         * 通过反射,获得指定类的父类的第一个泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport<Buyer>  
         *  
         * @param clazz clazz 需要反射的类,该类必须继承泛型父类
         * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回<code>Object.class</code>
         */  
        @SuppressWarnings({ "rawtypes" })
        public static Class getSuperClassGenricType(Class clazz) {
            return getSuperClassGenricType(clazz,0);
        }
        /**  
         * 通过反射,获得方法返回值泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){}
         *  
         * @param Method method 方法
         * @param int index 泛型参数所在索引,从0开始.
         * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回<code>Object.class</code>
         */ 
        @SuppressWarnings("rawtypes")
        public static Class getMethodGenericReturnType(Method method, int index) {
            Type returnType = method.getGenericReturnType();
            if(returnType instanceof ParameterizedType){
                ParameterizedType type = (ParameterizedType) returnType;
                Type[] typeArguments = type.getActualTypeArguments();
                if (index >= typeArguments.length || index < 0) { 
                     throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
                } 
                return (Class)typeArguments[index];
            }
            return Object.class;
        }
        /**  
         * 通过反射,获得方法返回值第一个泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){}
         *  
         * @param Method method 方法
         * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回<code>Object.class</code>
         */ 
        @SuppressWarnings("rawtypes")
        public static Class getMethodGenericReturnType(Method method) {
            return getMethodGenericReturnType(method, 0);
        }
        
        /**  
         * 通过反射,获得方法输入参数第index个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, Buyer> maps, List<String> names){}
         *  
         * @param Method method 方法
         * @param int index 第几个输入参数
         * @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回空集合
         */ 
        @SuppressWarnings("rawtypes")
        public static List<Class> getMethodGenericParameterTypes(Method method, int index) {
            List<Class> results = new ArrayList<Class>();
            Type[] genericParameterTypes = method.getGenericParameterTypes();
            if (index >= genericParameterTypes.length ||index < 0) {
                 throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
            } 
            Type genericParameterType = genericParameterTypes[index];
            if(genericParameterType instanceof ParameterizedType){
                 ParameterizedType aType = (ParameterizedType) genericParameterType;
                 Type[] parameterArgTypes = aType.getActualTypeArguments();
                 for(Type parameterArgType : parameterArgTypes){
                     Class parameterArgClass = (Class) parameterArgType;
                     results.add(parameterArgClass);
                 }
                 return results;
            }
            return results;
        }
        /**  
         * 通过反射,获得方法输入参数第一个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, Buyer> maps, List<String> names){}
         *  
         * @param Method method 方法
         * @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回空集合
         */ 
        @SuppressWarnings("rawtypes")
        public static List<Class> getMethodGenericParameterTypes(Method method) {
            return getMethodGenericParameterTypes(method, 0);
        }
        /**  
         * 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names;
         *  
         * @param Field field 字段
         * @param int index 泛型参数所在索引,从0开始.
         * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回<code>Object.class</code>
         */ 
        @SuppressWarnings("rawtypes")
        public static Class getFieldGenericType(Field field, int index) {
            Type genericFieldType = field.getGenericType();
            
            if(genericFieldType instanceof ParameterizedType){
                ParameterizedType aType = (ParameterizedType) genericFieldType;
                Type[] fieldArgTypes = aType.getActualTypeArguments();
                if (index >= fieldArgTypes.length || index < 0) { 
                    throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
                } 
                return (Class)fieldArgTypes[index];
            }
            return Object.class;
        }
        /**  
         * 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names;
         *  
         * @param Field field 字段
         * @param int index 泛型参数所在索引,从0开始.
         * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口,即不支持泛型,所以直接返回<code>Object.class</code>
         */ 
        @SuppressWarnings("rawtypes")
        public static Class getFieldGenericType(Field field) {
            return getFieldGenericType(field, 0);
        }
        @SuppressWarnings("rawtypes")
        public static SystemPrivilege getMethodPermission(Class clazz, String methodName) {
            Method[] methods=clazz.getMethods();
            SystemPrivilege systemPrivilege=null;
            for(Method method : methods){
                if(methodName.equals(method.getName())){
                    if(method.isAnnotationPresent(Permission.class)){
                        Permission permission=method.getAnnotation(Permission.class);
                        systemPrivilege=new SystemPrivilege(new SystemPrivilegePK(permission.module(), permission.privilege()));
                        break;
                    }
                }
            }
            return systemPrivilege;
        }
    }
  • 相关阅读:
    POJ 3672 水题......
    POJ 3279 枚举?
    STL
    241. Different Ways to Add Parentheses
    282. Expression Add Operators
    169. Majority Element
    Weekly Contest 121
    927. Three Equal Parts
    910. Smallest Range II
    921. Minimum Add to Make Parentheses Valid
  • 原文地址:https://www.cnblogs.com/guwenren/p/2994826.html
Copyright © 2011-2022 走看看