patrones de diseño Java ---- patrón de estrategia, pago móvil escritura a mano

Modo de estrategia

Es la definición de una familia de algoritmos, ellos encapsular, para que puedan ser sustituidos entre sí, este modo permite que los cambios en el algoritmo no afecta al algoritmo de usuario.

Evita múltiples puntos de si ... .. y demás instrucciones switch

 

escenarios

1. Si el sistema tiene mucha clase, y que sólo se diferencian en su comportamiento.

2. Un sistema de dinámicamente elegir uno de varios algoritmos.

Ejemplo, Jingdong ahora participar en promociones, requiere de varias promociones, podemos usar el patrón de estrategia de escritura.

/**
 * @Author Darker
 * @Descrption 京东促销活动优惠方式接口
 * @Date : Created in 13:54 2020-3-12
 */
public interface JDactivity {

    //促销方式
    /**
     * 1.原价
     * 2.现金返现
     * 3.优惠券减免
     * 4.赠送实物
     *
     */
    void activity();
}

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 13:57 2020-3-12
 */
public class EmptyActivity implements JDactivity{
    @Override
    public void activity() {
        System.out.println("原价");
    }
}

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 13:59 2020-3-12
 */
public class CashBackActivity implements JDactivity{
    @Override
    public void activity() {
        System.out.println("购物直接返现，返回现金到京东账号");
    }
}

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 13:57 2020-3-12
 */
public class CouponsActivity implements JDactivity{
    @Override
    public void activity() {
        System.out.println("领取优惠券，购物减免价格");
    }
}

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 14:00 2020-3-12
 */
public class GiftActivity implements JDactivity {
    @Override
    public void activity() {
        System.out.println("购物赠送礼品");
    }
}

/**
 * @Author Darker
 * @Descrption 活动策略规则
 * @Date : Created in 14:02 2020-3-12
 */
public class ActivityStrategy {

    //把优惠活动作为成员变量，new哪一种子类就是哪一种优惠
    JDactivity jDactivity;

    public ActivityStrategy(JDactivity jDactivity){
        this.jDactivity = jDactivity;
    }

    public void execute(){
        jDactivity.activity();
    }
}

Pruebe a ejecutar

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 14:04 2020-3-12
 */
public class StrategyTest {
    public static void main(String[] args) {
        //6.18购物活动
        ActivityStrategy activity618 = new ActivityStrategy(new CashBackActivity());
        activity618.execute();
        //双11购物优惠
        ActivityStrategy activity1111 = new ActivityStrategy(new CouponsActivity());
        activity1111.execute();
    }
}

Este es el más fácil de usar de los patrón de estrategia define una familia de algoritmos (descuento de familia), seleccione un algoritmo dinámico (descuento).

Pero! Pero! Pero! ! !

Para el nivel de llamada del usuario, usted encontrará que usted tiene que si ... .. otra cosa; como este, que desea generar promociones entró por el frente del campo, ya que el patrón de estrategia de evitar si había nadie más ... .., ahora no seguir utilizando la cosa, por supuesto, una obra de teatro no puede no vinculante, véase el siguiente código para verse como un simple patrón de fábrica bien, podemos cambiar el patrón de la fábrica, con una planta de producción de esta estrategia, la manera de convertirse en fábrica única forma de realización, sino también para mejorar la eficiencia.

Por lo tanto, le dimos añadir el código

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 14:40 2020-3-12
 */
public  class ActivityStrategyFactory {

    //构造方法私有化
    private  ActivityStrategyFactory(){};

    //饿汉式单例
    private static ActivityStrategyFactory activityStrategyFactory = new ActivityStrategyFactory();

    private static Map<String,JDactivity> iocMap = new HashMap<>();

    static {
        iocMap.put(ActivityKey.COUPON,new CouponsActivity());
        iocMap.put(ActivityKey.CASHBACK,new CashBackActivity());
        iocMap.put(ActivityKey.GIFT,new GiftActivity());
    }

    //无优惠
    private static final ActivityStrategy  NON_ACTIVITY_STRATEGY = new ActivityStrategy(new EmptyActivity());

    //全局唯一工厂路口
    public static ActivityStrategyFactory getInstance(){
        return activityStrategyFactory;
    }

    //工厂生成相应策略的活动
    public ActivityStrategy getActivityStrategy(String activity){
        ActivityStrategy activityStrategy = new ActivityStrategy(iocMap.get(activity));
        return activityStrategy == null ? NON_ACTIVITY_STRATEGY:activityStrategy;
    }

    //活动字符串，约定>配置
    private interface ActivityKey{
        String COUPON = "COUPON";
        String CASHBACK = "CASHBACK";
        String GIFT = "GIFT";
    }
}

 Mira la operación

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 14:04 2020-3-12
 */
public class StrategyTest {
    public static void main(String[] args) {

        //前端传来的活动key
        String activityKey = "CASHBACK";
        //生成策略工厂
        ActivityStrategyFactory strategyFactory = ActivityStrategyFactory.getInstance();
        ActivityStrategy activityStrategy = strategyFactory.getActivityStrategy(activityKey);
        activityStrategy.execute();

    }
}

Te ves muy amable a las llamadas de los clientes no es, pero cuando aumentamos la actividad cuando simplemente se va a añadir un poco de campos de configuración en la línea, cambiar pronto.

Nos fijamos en el diagrama de clases:

Esto es muy claro, tenemos cuatro políticas preferenciales para generar las políticas correspondientes a través de la política activa, y con fábricas para producir estrategias. 

No es lo suficientemente bueno, entonces llegamos a una característica recurrente de uso frecuente en todos los días, el pago móvil, un modo de estrategia muy clásico.

/**
 * @Author Darker
 * @Descrption 支付抽象类，包含公共判断逻辑
 * @Date : Created in 16:12 2020-3-12
 */
public abstract class Paymet {

    public  abstract String getKeyName();

    //查询余额
    protected abstract double queryBalance(String uid);

    //公用支付逻辑
    public MsgResult pay(String uid,double amount){
        if(queryBalance(uid)<amount){
            return new MsgResult(500,"支付失败","余额不足");
        }else{
            return new MsgResult(200,"支付成功","支付金额"+amount);
        }
    }
}

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 16:11 2020-3-12
 */
public class Alipay extends Paymet{
    @Override
    public String getKeyName() {
        return "支付宝";
    }

    @Override
    protected double queryBalance(String uid) {
        return 250;
    }
}

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 16:16 2020-3-12
 */
public class JDpay extends Paymet {
    @Override
    public String getKeyName() {
        return "京东白条";
    }

    @Override
    protected double queryBalance(String uid) {
        return 500;
    }
}

/**
 * @Author Darker
 * @Descrption
 * @Date : Created in 16:18 2020-3-12
 */
public class WechatPay extends Paymet {
    @Override
    public String getKeyName() {
        return "微信支付";
    }

    @Override
    protected double queryBalance(String uid) {
        return 700;
    }
}

/**
 * @Author Darker
 * @Descrption 订单
 * @Date : Created in 15:45 2020-3-12
 */
@Data
@AllArgsConstructor
public class Order {
    private String uid;
    private String orderId;
    private Double amount;

    public MsgResult pay(String payKey){
        Paymet paymet = PayStrategy.getInstance(payKey);
        MsgResult result = paymet.pay(orderId, amount);
        return result;
    }

}

/**
 * @Author Darker
 * @Descrption 返回包装类
 * @Date : Created in 16:07 2020-3-12
 */
@Data
@AllArgsConstructor
public class MsgResult {

    private int code;
    private Object data;
    private String msg;

    @Override
    public String toString() {
        return "支付状态：[" + code +"]," + msg +",交易详情"+ data;
    }
}


/**
 * @Author Darker
 * @Descrption 支付策略
 * @Date : Created in 16:25 2020-3-12
 */
public class PayStrategy {
    public static final String ALI_PAY = "Alipay";
    public static final String JD_PAY = "Jdpay";
    public static final String WECHAT_PAY = "Wechatpay";
    public static final String DEFAULT_PAY = ALI_PAY;

    private static Map<String, Paymet> payStrategy =new HashMap<>();

    static {
        payStrategy.put(ALI_PAY,new Alipay());
        payStrategy.put(JD_PAY,new JDpay());
        payStrategy.put(WECHAT_PAY,new WechatPay());
    }

    public static Paymet getInstance(String payKey){
        Paymet paymet = payStrategy.get(payKey) ;
        return paymet == null ? payStrategy.get(DEFAULT_PAY):paymet;
    }
}


/**
 * @Author Darker
 * @Descrption 测试
 * @Date : Created in 16:21 2020-3-12
 */
public class payStrategyTest {
    public static void main(String[] args) {
        String payKey = "Jdpay";
        String payKey2 = "Wechatpay";
        
        //用户提交了一个订单
        Order order = new Order("1", "2020031200000000", 570.00);

        //用户选择支付方式，京东白条
        MsgResult result = order.pay(payKey);
        System.out.println(result);

        //用户选择支付方式，微信支付
        MsgResult result2 = order.pay(payKey2);
        System.out.println(result2);
    }
}

 Echar un vistazo, esta no es la forma en que realmente pagar para usarlo.

Bueno, por fin, llegamos a hablar acerca de dónde JDK con el patrón de estrategia, la respuesta es Comparador, Comparador, a menudo una especie de comparación, este comparador hay una gran cantidad de algoritmos, somos libres de elegir sus estrategias favoritas Ordena, muy clásico.

Del mismo modo, en la primavera también se utiliza el patrón de estrategia en la inicialización de la clase cuando se selecciona manera jdk o forma cglib.

 

resumen:

ventajas:

1. Patrón Estrategia en consonancia con el principio de apertura y cierre

2. Evitar el uso de varias instrucciones de salto condicional, como si ... otra cosa .....

3. Utilice el patrón de estrategia puede mejorar la confidencialidad y seguridad del algoritmo

desventajas:

1. El cliente debe conocer todas las tácticas y estrategia para decidir qué clase de uso.

2. El código se genera una gran cantidad de la categoría de estrategia, el mantenimiento es más difícil.