原型模式

……

package org.sang.plugins.shejimoshi;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.cglib.beans.BeanCopier;

public class RiskMapConvert{
    private static BeanCopier mapATOToVOCopier = BeanCopier.create(RiskMapATO.class,
            RiskMapVO.class, false);

    /**
     * RiskMapATO -> RiskMapVO
     */

    public static RiskMapVO atoToVo(RiskMapATO ato) {
        RiskMapVO vo = new RiskMapVO();
        mapATOToVOCopier.copy(ato, vo, (value, target, context) -> value);
        return vo;
    }

    public static void main(String[] args) {
        RiskMapATO r = new RiskMapATO(5);
        RiskMapVO riskMapVO = atoToVo(r);
        System.out.println(riskMapVO.getRiskScore());

    }
}
@Data
@AllArgsConstructor
@NoArgsConstructor
class RiskMapATO{
    private Integer riskScore;
};
@Data
@AllArgsConstructor
@NoArgsConstructor
class RiskMapVO{
    private Integer riskScore;
}

package org.sang.plugins.shejimoshi;


/**
 *
 * Java语言提供的Cloneable接口和Serializable接口的代码非常简单，
 * 它们都是空接口，这种空接口也称为标识接口，
 * 标识接口中没有任何方法的定义，其作用是告诉JRE这些接口的实现类是否具有某个功能，
 * 如是否支持克隆、是否支持序列化等
 *
 */
public class Clone{
    public static void main(String[] args) {
         // 实例化新对象
         Base base = new CloneA();
         // 客户端可以根据情况需要对不同的具体原型类实现克隆
         Base base2 = (Base) base.clone();
         Base base3 = base;

         System.out.println(base == base2 ? "原型对象与克隆对象相同" : "原型对象与克隆对象不同");
         System.out.println(base == base3 ? "原型对象与克隆对象相同" : "原型对象与克隆对象不同");
         // 显示克隆结果
         base2.show();
     }
}


//用于被克隆的原型类，对外提供克隆的方法，需实现允许克隆的接口Cloneable
abstract class Base implements Cloneable {

 // 用于显示克隆信息
abstract void show();

  // 克隆方法实现
 @Override
 public Object clone() {
  Base cloneBase = null;
         try {
             cloneBase = (Base) super.clone();
         } catch (CloneNotSupportedException e) {
             e.printStackTrace();
         }
         return cloneBase;
     }

 }
 class CloneA extends Base {

     @Override
     void show() {
         System.out.println("克隆对象A");
     }


 }
 class CloneB extends Base {

     @Override
     void show() {
         System.out.println("克隆对象B");
     }


 }

package org.sang.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cglib.beans.BeanCopier;

import java.util.concurrent.ConcurrentHashMap;

@Slf4j
public class CGlibCopier {

    //使用缓存提高效率
    private static final ConcurrentHashMap<String, BeanCopier> mapCaches = new ConcurrentHashMap<>();

    public static <O, T> T copy(O source, Class<T> target) {
        T instance = baseCopy(source, target);
        return instance;
    }

    public static <O, T> T copy(O source, Class<T> target, IAction<T> action) {
        T instance = baseCopy(source, target);
        action.run(instance);
        return instance;
    }

    public static <O, T> T copyObject(O source, T target) {
        String baseKey = generateKey(source.getClass(), target.getClass());
        BeanCopier copier;
        if (!mapCaches.containsKey(baseKey)) {
            copier = BeanCopier.create(source.getClass(), target.getClass(), false);
            mapCaches.put(baseKey, copier);
        } else {
            copier = mapCaches.get(baseKey);
        }
        copier.copy(source, target, null);
        return target;
    }

    public static <O, T> T copyObject(O source, T target, IAction<T> action) {
        String baseKey = generateKey(source.getClass(), target.getClass());
        BeanCopier copier;
        if (!mapCaches.containsKey(baseKey)) {
            copier = BeanCopier.create(source.getClass(), target.getClass(), false);
            mapCaches.put(baseKey, copier);
        } else {
            copier = mapCaches.get(baseKey);
        }
        copier.copy(source, target, null);
        action.run(target);
        return target;
    }

    private static <O, T> T baseCopy(O source, Class<T> target) {
        String baseKey = generateKey(source.getClass(), target);
        BeanCopier copier;
        if (!mapCaches.containsKey(baseKey)) {
            copier = BeanCopier.create(source.getClass(), target, false);
            mapCaches.put(baseKey, copier);
        } else {
            copier = mapCaches.get(baseKey);
        }
        T instance = null;
        try {
            instance = target.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            log.error("baseCopy 创建对象异常" + e.getMessage());
        }
        copier.copy(source, instance, null);
        return instance;
    }

    private static String generateKey(Class<?> class1, Class<?> class2) {
        return class1.toString() + class2.toString();
    }
    
}
@FunctionalInterface
interface IAction<T>{
    void run(T target);
}