自己封装模拟json全路径获取某个对象下某个变量的工具类

java

字数统计: 1k阅读时长: 5 min

 2020/05/15   Share

写在前面

最近需要写一个针对controller内参数的数据权限校验组件，所以需要想办法获取都某个对象的某个变量（可能跨层级）的值，所以研究和封装了一套可以使用的工具类

代码

废话不多说，直接上代码，注释也写得比较明白了，就不赘述了

/**
 * 权限相关工具类
 * @author yyt
 */
@Slf4j
public class AuthUtils {

    //auth数据原型key
    public static final String AUTH_DOMAIN_PROTOTYPE_KEY="domainPrototype";

  //设置到request的属性，如有
    public static void putToRequestAttributes(Object o){
        HttpServletRequest request= SpringRequestHolderUtil.getRequest();
        if(request!=null){
            request.setAttribute(AUTH_DOMAIN_PROTOTYPE_KEY,o);
        }
    }

    @Nullable
    public static Object findInRequestAttributes(){
        HttpServletRequest request= SpringRequestHolderUtil.getRequest();
        if(request!=null){
            return request.getAttribute(AUTH_DOMAIN_PROTOTYPE_KEY);
        }
        return null;
    }

    /**
     * 判断是否需要拦截
     * @param lookupPath
     * @return
     */
    public static boolean matches(String lookupPath, List<String> urlList) {
        if(urlList==null){
            return false;
        }
        for (String pattern : urlList) {
            if (pathMatcher.match(pattern, lookupPath)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 获取对象指定属性的类型为T值,嵌套类请使用.来表示（如datas.person.name），最底层只支持list<T> 、T、T[]
     * @param value
     * @param fieldName
     * @return
     * @throws IllegalAccessException
     */
    public  static <T> Set<T> getTValueByField(Object value, String fieldName,Class<T> clz) throws IllegalAccessException {
        if(value==null|| StringUtils.isEmpty(fieldName)){
            return Collections.emptySet();
        }


        //拆分.,递归获取有效资源值
        if(fieldName.contains(".")){
            String[] strings=spiltStrBySpot(fieldName);
            Object ob=getValueByFieldName(value,strings[0]);
            return getTValueByField(ob,strings[1],clz);
        }

        Set<T> result = new HashSet<>();
        if("_this_".equals(fieldName)){
            result.add((T)value);
            return result;
        }


        Object ob=getValueByFieldName(value,fieldName);
        if(ob==null){
            return Collections.emptySet();
        }
        Integer[] i=new Integer[]{};
        if(ob.getClass() == clz){
            //单个对象
            result.add((T)ob);
        }else if(ob.getClass().isArray()){
            //数组
            Object item=Arrays.asList((Object[])ob).get(0);
            if(item.getClass() == clz){
                result.addAll(Arrays.asList((T[])ob));
            }else{
                //TODO 按照规则不应该走到这里，走到这里是最后一层，只能强转为String
                //result.add(());
                throwException(item,clz);
            }
        }else if(ob instanceof Collection){
            //list
            Collection collection = (Collection) ob;
            for(Object item : collection){
                if(item.getClass() == clz){
                    result.add((T) item);
                }else{
                    //TODO 按照规则不应该走到这里，走到这里是最后一层，只能强转为String
                    //result.add(item.toString());
                    throwException(item,clz);
                }
            }
        }else{
            throwException(ob,clz);
        }
        return result;
    }
    private static void throwException(Object item,Class clz){
        log.error("class {} cannot cast to class {}",item.getClass(),clz.toString());
        throw new ClassCastException("classCast error");
    }

    public static Object  getValueByFieldName(Object value,String fieldName) throws IllegalAccessException {
        if(value==null|| StringUtils.isEmpty(fieldName)){
            return null;
        }

        //如果是字符串，则尝试转为JSON，再获取值
        if(value.getClass()==String.class){
            JSONObject jsonObject=JSONObject.parseObject((String)value);
            return getValueByFieldName(jsonObject,fieldName);

        }

        if(value instanceof Map){
            return ((Map) value).get(fieldName);
        }

        if(value instanceof Collection){
            Set<Object> resultObject=new HashSet<>();
            Collection collection = (Collection) value;
            int index = 0;
            for(Object item : collection){
                Object o=getValueByFieldName(item,fieldName);
                resultObject.add(o);
            }
            return resultObject;
        }

        if(value.getClass().isArray()){
            Object[] vs=(Object[])value;
            Set<Object> resultObject=new HashSet<>(vs.length);
            for(Object item:vs){
                Object o =getValueByFieldName(item,fieldName);
                resultObject.add(o);
            }
            return resultObject;
        }

        Field[] fields = value.getClass().getDeclaredFields();
        for(Field field: fields){
            String name = field.getName();
            if(!fieldName.equals(name)){
                continue;
            }
            field.setAccessible(true);
            Object resultValue = field.get(value);
            return resultValue;
        }
        return null;
    }



    /**
     * 对字符串中的.进行拆分返回第一段字符串和剩余字符串，如data.ls.name，返回data，ls.name
     * @param name
     * @return
     */
    public static final String[] spiltStrBySpot(String name){

        int i=name.indexOf(".");
        if(i==-1){
            return new String[]{name};
        }
        String name1=name.substring(0,i);
        String name2=name.substring(i+1);
        return new String[]{name1,name2};
    }

    //for quick test
    public static void main(String[] args) throws IllegalAccessException {
        /*String name="data.ls.name";
        spiltStrBySpot(name);

        List<Object> ls=new ArrayList<>();
        Boolean b=ls.getClass().isArray();

        Object[] os=new Object[]{};
        b=os.getClass().isArray();*/
        TestClass testClass=new TestClass();
        testClass.strings=new String[]{"1","2","3"};
        testClass.integers=new Integer[]{1,2,3};
        testClass.i=100;
        List<String> lists = new ArrayList<>();
        lists.add("4");
        lists.add("5");
        testClass.lists=lists;
        Set<String> strings2=getTValueByField(testClass,"strings",String.class);
        Set<Integer> integers2=getTValueByField(testClass,"integers",Integer.class);
        Set<String> lists2=getTValueByField(testClass,"lists",String.class);
        Set<Integer> i=getTValueByField(testClass,"i",Integer.class);


        log.error("Strings {}",strings2);
        log.error("integers2 {}",integers2);
        log.error("lists2 {}",lists2);
        log.error("i {}",i);
        //测试失败案例
        Set<String> i2=getTValueByField(testClass,"i",String.class);

        //JSONArray
        return;
    }

    @Data
    static class TestClass{
        String[] strings;
        Integer[] integers;
        List<String> lists;
        Integer i;
     }

    //路径是否拦截match类，出处：org.springframework.web.servlet.handler.AbstractHandlerMapping.getHandlerExecutionChain
    private static  PathMatcher pathMatcher = new AntPathMatcher();
}

原文作者：styytNOTstop

原文链接：https://styyt.github.io/2020/05/15/%E8%87%AA%E5%B7%B1%E5%86%99%E7%9A%84%E6%A0%B9%E6%8D%AE%E5%85%A8%E8%B7%AF%E5%BE%84%E8%8E%B7%E5%8F%96%E5%8F%98%E9%87%8F%E5%80%BC/

发表日期：May 15th 2020, 12:33:52 pm

更新日期：June 19th 2020, 8:36:01 pm

Next Post

解析springBean类的注解引发的一系列如AOP|cglib代理等问题一
Previous Post

macOS常用命令记录

CATALOG

1. 写在前面
2. 代码

