模版方法模式--实践

模版方法模式介绍：https://www.jianshu.com/p/19e099e2828b

定义
定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

应用场景

• 多个子类有公共方法，逻辑基本相同，可以把重要的、复杂的、核心算法设计为模板方法，周边的相关细节功能则由各个子类实现。

实践：

对某个对象及对象的集合属性中的对象列表中符合某个条件的属性做处理/或者根据该符合条件的属性做一系列处理

实现如下：

图片.png

使用一个抽象类来表示模版，将判断与处理两个步骤延迟到子类

/**
 * 指定字段处理抽象
 *
 * @author Jenson
 */
@Slf4j
public abstract class BaseSpecificFieldHandler {

    /**
     * 需要处理的对象
     */
    private Object processObject;

    BaseSpecificFieldHandler(Object processObject) {
        this.processObject = processObject;
    }

    /**
     * 处理符合条件的字段
     */
    public void process() {
        Object result = this.processObject;
        if (result instanceof Collection) {
            if (!CollectionUtils.isEmpty((Collection) result)) {
                this.processCollection((Collection) result);
            } else {
                log.info("Collection Is Empty!");
            }
        } else {
            this.processObject(result);
        }
    }

    /**
     * 处理集合
     *
     * @param collection 集合
     */
    private void processCollection(Collection collection) {
        for (Object obj : collection) {
            this.processObject(obj);
        }
    }

    /**
     * 处理对象里的字段
     *
     * @param object 需要翻译的对象
     */
    private void processObject(Object object) {
        Field[] fields = FieldUtils.getAllFields(object.getClass());
        for (Field field : fields) {
            try {
                field.setAccessible(Boolean.TRUE);
                Object fieldObj = field.get(object);
                if (fieldObj instanceof Collection && !CollectionUtils.isEmpty((Collection) fieldObj)) {
                    // 递归去处理
                    this.processCollection((Collection) fieldObj);
                } else {
                    if (needProcessField(field)) {
                        this.processField(field, object);
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 判断字段是否需要被处理
     * <p>
     * 留给子类去实现
     *
     * @param field 字段
     * @return 字段是否需要被处理
     */
    protected abstract boolean needProcessField(Field field);

    /**
     * 字段处理
     * <p>
     * 处理逻辑，留给子类去实现
     *
     * @param field  字段
     * @param object 字段所处对象
     */
    protected abstract void processField(Field field, Object object);
}

实现，使用模板：

/**
 * 具体的模板实现
 * @author Jenson
 */
@Slf4j
public class ConcreteFieldHandler extends BaseSpecificFieldHandler {
    public TranslateRemoteFieldHandler(Object processObject) {
        super(processObject);
    }

    @Override
    protected boolean needProcessField(Field field) {
        // 判断，使用了以下注解的字段需要处理
        RemoteField remoteField = field.getAnnotation(RemoteField.class);
        return remoteField != null;
    }

    @Override
    protected void processField(Field field, Object object) {
        Object fieldObj;
        try {
            fieldObj = field.get(object);
            // 有注解的（处理逻辑写在这）
            field.set(object, fieldObj + ";我要改变它");
            log.info("有  注解的（处理逻辑写在这）  字段名 : {} , 字段值 : {}", field.getName(), fieldObj);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

调用：

// result 为需要处理的对象
new ConcreteFieldHandler(result).process();