BeanCopier工具

复制工具类

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Supplier;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.core.Converter;

public class BeanCopierUtil {
    /**
     * BeanCopier的缓存
     */
    private static final ConcurrentHashMap<String, BeanCopier> BEAN_COPIER_CACHE = new ConcurrentHashMap<>();

    /**
     * 单个对象的复制
     *
     * @param source  源对象
     * @param target  目标对象
     * @param convert Converter
     * @param <S>     源类型
     * @param <T>     目标类型
     * @return T
     */
    public static <S, T> T copy(S source, Supplier<T> target, Converter convert) {
        T t = target.get();
        BeanCopier beanCopier;

        if (convert == null) {
            beanCopier = BeanCopier.create(source.getClass(), t.getClass(), false);
        } else {
            beanCopier = BeanCopier.create(source.getClass(), t.getClass(), true);
        }
        beanCopier.copy(source, t, convert);
        return t;
    }

    /**
     * Bean属性复制工具方法。
     *
     * @param sources   原始集合
     * @param supplier: 目标类::new(eg: UserVO::new)
     */
    public static <S, T> List<T> copyList(List<S> sources, Supplier<T> supplier) {
        List<T> list = new ArrayList<>(sources.size());
        BeanCopier beanCopier = null;
        for (S source : sources) {
            T t = supplier.get();
            if (beanCopier == null) {
                beanCopier = getBeanCopier(source.getClass(), t.getClass());
            }
            beanCopier.copy(source, t, null);
            list.add(t);
        }
        return list;
    }

    /**
     * 获取BeanCopier对象 如果缓存中有从缓存中获取 如果没有则新创建对象并加入缓存
     *
     * @param sourceClass 源对象
     * @param targetClass 目标对象
     * @return BeanCopier
     */
    private static BeanCopier getBeanCopier(Class<?> sourceClass, Class<?> targetClass) {
        String key = genKey(sourceClass, targetClass);
        BeanCopier beanCopier;
        beanCopier = BEAN_COPIER_CACHE.get(key);
        if (beanCopier == null) {
            beanCopier = BeanCopier.create(sourceClass, targetClass, false);
            BEAN_COPIER_CACHE.put(key, beanCopier);
        }
        return beanCopier;
    }

    /**
     * BeanCopier的copy
     *
     * @param source 源文件的
     * @param target 目标文件
     */
    public static void copy(Object source, Object target) {
        String key = genKey(source.getClass(), target.getClass());
        BeanCopier beanCopier;
        if (BEAN_COPIER_CACHE.containsKey(key)) {
            beanCopier = BEAN_COPIER_CACHE.get(key);
        } else {
            beanCopier = BeanCopier.create(source.getClass(), target.getClass(), false);
            BEAN_COPIER_CACHE.put(key, beanCopier);
        }
        beanCopier.copy(source, target, null);
    }

    /**
     * 生成key
     *
     * @param srcClazz 源文件的class
     * @param tgtClazz 目标文件的class
     * @return string
     */
    private static String genKey(Class<?> srcClazz, Class<?> tgtClazz) {
        return srcClazz.getName() + tgtClazz.getName();
    }

累加计算编号工具方法

    /**
     * @param number 上一个编号
     * @return java.lang.String
     * @Description: 自动生成下一个编号
     * @Author: hongjun.chen@lachesis-mh.com
     * @MethodName: increment
     * @Date: 2023/12/05 14:58
     */
    public static String increment(String number) {
        //后续要改成 AA0001 类似的，都可以兼容，字母会自动递增，当前一个是AA9999的时候，下一个会是AB0001
        if (StringUtils.isEmpty(number)) {
            return "0001";
        }
        Pattern compile = Pattern.compile("^(.*?)([0-9]*|[A-Z]*)$");
        Matcher matcher = compile.matcher(number);
        String remaining = number;
        String currentGroup;
        StringBuilder result = new StringBuilder();

        boolean continueToNext = true;
        while (matcher.matches() && continueToNext) {
            remaining = matcher.group(1);
            currentGroup = matcher.group(2);
            int currentGroupLength = currentGroup.length();
            int base = currentGroup.matches("[0-9]*") ? 10 : 36;
            currentGroup = Long.toString(Long.parseLong("1" + currentGroup, base) + 1, base);
            currentGroup = currentGroup.substring(currentGroup.length() - currentGroupLength);
            continueToNext = Long.valueOf(currentGroup, base) == 0;
            if (base == 36) {
                currentGroup = currentGroup.replace("0", "A");
            }
            //跳过全是0的情况，全是0的时候，自动+1
            if (Long.valueOf(currentGroup, base) == 0) {
                currentGroup = currentGroup.substring(0, currentGroup.length() - 1) + "1";
            }
            result.insert(0, currentGroup);
            matcher = compile.matcher(remaining);
        }
        result.insert(0, remaining);
        return result.toString().toUpperCase();
    }