spring项目上一些总结

Spring 控制反转一个应用

 /**
     * 将一个对象的非空值设置给另一个对象。需要指定设置的属性类型或者属性名称。
     *
     * @param target 被设置值的目标对象
     * @param source 值的来源对象
     * @param types 属性类型在types中包含，则进行设置
     * @param attributes 属性名称在types中包含，则进行设置
     * @param <T> 对象的类型
     */
    public static <T> void setNonNullAttributes(T target, T source, Set<Class<?>> types, Set<String> attributes) {
        Class<?> clazz = source.getClass();
        Field[] fields = clazz.getDeclaredFields();
        List<Field> allFields = new ArrayList<>();
        allFields.addAll(Arrays.asList(fields));

        Class<?> superClazz = clazz.getSuperclass();
        while (superClazz != null) {
            allFields.addAll(Arrays.asList(superClazz.getDeclaredFields()));
            superClazz = superClazz.getSuperclass();
        }
        allFields.stream().filter(field -> types.contains(field.getType()) || attributes.contains(field.getName()))
                .forEach(field -> {
                    String captureName = captureName(field.getName());
                    try {
                        Method method = clazz.getMethod("get" + captureName);
                        Object value = method.invoke(source);
                        if (value != null) {
                            Method setMethod = clazz.getMethod("set" + captureName, field.getType());
                            setMethod.invoke(target, value);
                        }
                    } catch (NoSuchMethodException e) {
                        LOG.warn("Can't find getter or setter of attribute " + captureName, e );
                    } catch (IllegalAccessException e) {
                        LOG.warn("Illegal access of attribute " + captureName, e );
                    } catch (InvocationTargetException e) {
                        LOG.warn("Invocation target exception of attribute " + captureName, e );
                    }
                });
    }

    /**
     * 将字符串首字母大写，并返回。
     *
     * @param string 需要转换的字符串
     * @return 转换后的字符串
     */
    public static String captureName(String string) {
        char[] cs = string.toCharArray();
        cs[0] -= 32;
        return String.valueOf(cs);
    }

JDK8新特性-java.util.function-Predicate接口

//唯一的抽象方法
boolean test(T t);

//且操作，既满足A也满足B条件
default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

//取反操作 为true则返回false
 default Predicate<T> negate() {
        return (t) -> !test(t);
    }

//或操作，满足A条件或者满足B条件
 default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

//静态方法，判定是否相等
  static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }

除了test()抽象方法以及一个静态方法以外，其他的都是默认方法，可以存在多个默认方法以及静态方法。
实践操作如下：

 public static void main(String[] args) {
        Predicate<Integer> biggerThan6 = x -> x > 6;
        Predicate<Integer> lessThan3 = x -> x < 3;
        Predicate<Integer> lessThan9 = x -> x < 9;
        //7比6大为true，为false
        System.out.println("negate value=" + biggerThan6.negate().test(7));
        //7比6大为true
        System.out.println("test() value=" + biggerThan6.test(7));
        //8比6大且比9小
        System.out.println("and value=" + biggerThan6.and(lessThan9).test(8));
        //1比3小，满足一种条件
        System.out.println("or value=" + biggerThan6.or(lessThan3).test(1));
        //静态方法，判定是否相等
        System.out.println("isEqual false value=" + Predicate.isEqual("test").test("num"));
        System.out.println("isEqual true value=" + Predicate.isEqual("num").test("num"));
    }

返回值：

negate value=false
test() value=true
and value=true
or value=true
isEqual false value=false
isEqual true value=true

项目中用到这一块的代码解析：

SecOrg currentTenantCompany = currentUser.getCompany();
  SecOrg secOrg = serial instanceof SecOrg ? (SecOrg) serial : null;
 return currentTenantCompany != null &&
currentTenantCompany.equals(CommonUtil.findUpward(secOrg, (node) -> node.getParent() == null));

其中CommonUtil.findUpward() 如下：

  /**
     * 查找符合条件的父级节点
     *
     * @param t 当前节点
     * @param predicate 条件函数
     * @return 符合条件的节点
     */
    public static <T extends BaseNodeEntity<T>> T findUpward(T t, Predicate<T> predicate) {
        boolean found = false;
        while (!(found = predicate.test(t))) {
            t = t.getParent();
            if (t == null) {
                break;
            }
        }
        return found ? t : null;
    }

以上：t作为predicate的传入的参数，predicate函数为(node) -> node.getParent() == null，所以最后equals()里的内容为return的东西，即secOrg的最上层的祖先。那么这俩是否相等呢，可知他们都是SecOrg类，

public class SecOrg extends BaseNodeEntity<SecOrg> implements Serializable {}
public abstract class BaseNodeEntity<T> extends BaseEntity {}
而在public abstract class BaseEntity{}
    @Override
    public boolean equals(Object o) {
        if (o == this) {
            return true;
        }
        if (o == null || o.getClass() != getClass()) {
            return false;
        }

        BaseEntity other = (BaseEntity) o;
        Object thisId = getId();
        Object otherId = other.getId();
        return thisId == null ? otherId == null : thisId.equals(otherId);
    }

instanceof
instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。