策略模式和工厂模式搭配使用

策略模式和工厂模式的搭配使用可以很好地消除代码if-else的多层嵌套

需求

针对店下商铺，有这样一个需求，对用户客户分为了普通客户、vip客户、超级vip用户、专属vip用户4个等级，每当用户购买商品时，针对不同的用户等级和消费金额采取不同的打折优惠策略。在平常的开发当中，必然会出现多层的if-else嵌套判断，先判断用户的等级再判断用户购买商品的消费金额。

弊端

以上的情况出现了多层的if-else嵌套，除此之外，以后如果需求再有变动，需要再增加一个用户等级，那么又会再次添加if-else的嵌套判断，那么如何解决上述的弊端呢，采用策略模式和工厂模式的搭配使用，可以很好地优化多层if-else的多层嵌套

实现

编写用户等级枚举类

package com.zbiti.ifelse.UserType;

/**
 * 用户类型枚举类
 */
public enum UserPayServiceEnum {

    VIP(1,"Vip"),

    SUPERVIP(2,"SuperVip"),

    PARTICULALYVIP(3,"ParticularlyVip"),

    NORMAL(4,"NormalPayService");

    /**
     * 状态值
     */
    private int code;

    /**
     * 类型描述
     */
    private String value;

    private UserPayServiceEnum(int code, String value) {
        this.code = code;
        this.value = value;
    }
    public int getCode() {
        return code;
    }

    public String getValue() {
        return value;
    }

    public static UserPayServiceEnum valueOf(int code) {
        for (UserPayServiceEnum type : UserPayServiceEnum.values()) {
            if (type.getCode()==code) {
                return type;
            }
        }
        return null;
    }
    public static void main(String[] args) {
        System.out.println(UserPayServiceEnum.VIP.getValue());
    }

}

编写不同的用户等级策略类

以下需要注意的是每个策略类实现了InitializingBean接口的作用是每当策略类被spring容器启动初始化后会调用afterPropertiesSet方法，而在这个方法里面的作用是会往工厂里针对不同用户等级保存其对应的用户策略引用

编写打折接口

不同的用户等级策略类实现该接口，该接口包含了打折方法

package com.zbiti.ifelse.UserType;

import java.math.BigDecimal;

public interface UserPayService {
    /**
     * 计算应付价格
     */
    public BigDecimal quote(BigDecimal orderPrice);
}

编写普通用户策略类

package com.zbiti.ifelse.UserType;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;

/**
 * 普通会员不打折原价
 */

//实现InitializingBean接口，容器启动后会调用afterPropertiesSet()方法，往工厂里写入打折策略
@Service
public class NormalPayService implements UserPayService, InitializingBean {
    @Override
    public BigDecimal quote(BigDecimal orderPrice) {
        return new BigDecimal("10");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        UserPayServiceStrategyFactory.register(UserPayServiceEnum.NORMAL.getValue(), this);
    }

}

编写vip用户策略类

package com.zbiti.ifelse.UserType;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;

/**
 * 普通会员打9折，消费超100打8折
 */

//实现InitializingBean接口，容器启动后会调用afterPropertiesSet()方法，往工厂里写入打折策略
@Service
public class VipPayService implements UserPayService, InitializingBean {
    @Override
    public BigDecimal quote(BigDecimal orderPrice) {
        if (orderPrice.compareTo(new BigDecimal("100")) > 1) {
            return new BigDecimal("8");
        }
        return new BigDecimal("9");
    }

    public void myShow(){
        System.out.println("myShow method invoke----->");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        UserPayServiceStrategyFactory.register(UserPayServiceEnum.VIP.getValue(), this);
    }

}

编写超级vip用户策略类

package com.zbiti.ifelse.UserType;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;

/**
 * 超级会员打8折
 */
@Service
public class SuperVipPayService implements UserPayService , InitializingBean {
    @Override
    public BigDecimal quote(BigDecimal orderPrice) {
        return new BigDecimal("8");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        UserPayServiceStrategyFactory.register(UserPayServiceEnum.SUPERVIP.getValue(),this);
    }
}

编写专属用户vip策略类

package com.zbiti.ifelse.UserType;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;

/**
 * 专属会员 下单消费超30打七折
 */
@Service
public class ParticularlyVipPayService implements UserPayService, InitializingBean {
    @Override
    public BigDecimal quote(BigDecimal orderPrice) {
        if (orderPrice.compareTo(new BigDecimal("30"))>0) {
            return new BigDecimal("7");
        }
        return new BigDecimal("8");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        UserPayServiceStrategyFactory.register(UserPayServiceEnum.PARTICULALYVIP.getValue(),this);
    }
}

编写工厂类

注意这里工厂的register方法，该方法会在spring容器启动初始化bean即各个不同等级的用户策略类完成后调用afterPropertiesSet方法里调用register方法，当容器启动完成后，我们的spring容器中即有了一个键为用户等级，值为用户等级策略类的map，在对不同用户进行优惠打折的时候，可以根据用户等级来取得当前用户的策略类

package com.zbiti.ifelse.UserType;

import org.springframework.util.Assert;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 版本二：工厂使用(高级版)
 */
//@Service
public class UserPayServiceStrategyFactory {

    private static Map<String,UserPayService> services = new ConcurrentHashMap<String,UserPayService>();

    public  static UserPayService getByUserType(String type){
        return services.get(type);
    }

    public static void register(String userType,UserPayService userPayService){
        Assert.notNull(userType,"userType can't be null");
        services.put(userType,userPayService);
    }
}

编写测试类

package com.zbiti.ifelse;

import com.zbiti.ifelse.UserType.UserPayService;
import com.zbiti.ifelse.UserType.UserPayServiceStrategyFactory;
import com.zbiti.ifelse.UserType.VipPayService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.math.BigDecimal;

@SpringBootTest
@Slf4j
class IfElseApplicationTests {

    @Test
    void contextLoads() {
        calPrice();
    }

    public  void calPrice() {
        BigDecimal orderPrice = new BigDecimal("100");
        String vipType = "Vip";
        //指定用户类型，获得相对应的策略
        UserPayService strategy = UserPayServiceStrategyFactory.getByUserType(vipType);

//        UserPayService strategy2 = UserPayServiceStrategyFactory2.getByUserType(vipType);

        System.out.println(strategy);
//        System.out.println(strategy2);
        BigDecimal quote = strategy.quote(orderPrice);
        if(strategy instanceof VipPayService){
           ((VipPayService) strategy).myShow();
        }
        System.out.println(quote);
    }

}

结果

可以看到vip用户打9折，在这个不同用户等级购买商品时采取的不同打折策略里，我们没有出现了多层的if-else的嵌套

tips

编写工厂类的实现方式上面是其中一种实现（比较推荐），另外也有其它的方式，可以参考如下

提前将策略写入到map，但是这里需要手动new策略对象

package com.zbiti.ifelse.UserType;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 版本一：工厂使用
 */
public class UserPayServiceStrategyFactory2 {

    private static Map<String,UserPayService> services = new ConcurrentHashMap<String,UserPayService>();

    public  static UserPayService getByUserType(String type){
        return services.get(type);
    }

    static{
        services.put(UserPayServiceEnum.VIP.getValue(), new VipPayService());
        services.put(UserPayServiceEnum.SUPERVIP.getValue(), new SuperVipPayService());
        services.put(UserPayServiceEnum.PARTICULALYVIP.getValue(), new ParticularlyVipPayService());
        services.put(UserPayServiceEnum.NORMAL.getValue(), new NormalPayService());
    }

}

也可以通过反射，编写工厂类

package com.zbiti.ifelse.UserType;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 版本一：工厂使用
 */
public class UserPayServiceStrategyFactory3 {

    private static Map<String, Class<? extends UserPayService>> services = new ConcurrentHashMap<>();

    //初始化map，存放策略
    static {
        services.put(UserPayServiceEnum.VIP.getValue(), VipPayService.class);
        services.put(UserPayServiceEnum.SUPERVIP.getValue(), SuperVipPayService.class);
        services.put(UserPayServiceEnum.PARTICULALYVIP.getValue(), ParticularlyVipPayService.class);
        services.put(UserPayServiceEnum.NORMAL.getValue(), NormalPayService.class);
    }

    //获取策略
    public static UserPayService getByUserType(String type) {
        try {
            Class<? extends UserPayService> userPayServiceClass = services.get(type);
            return userPayServiceClass.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return new NormalPayService();
        }

    }

}

其实也可以搭配注解的使用，自定义一个注解类，在策略类上标识上注解（值为不同的用户等级），容器启动的时候通过扫描我们的自定义注解，写入map中也是可以的。

参考

if-else

if-else2

if-else3

本文由博客一文多发平台 OpenWrite 发布！

原文地址：https://www.cnblogs.com/lisingshen/p/11782250.html

时间： 2024-10-12 03:51:04

策略模式和工厂模式搭配使用的相关文章

策略模式和工厂模式的区别

工厂模式和策略模式看着很像,经常让人混淆不清; 它们的区别在哪里,需要细细体味: 相似点 在模式结构上,两者很相似: 差异 用途不一样 工厂是创建型模式,它的作用就是创建对象: 策略是行为型模式,它的作用是让一个对象在许多行为中选择一种行为; 关注点不一样 一个关注对象创建 一个关注行为的封装 解决不同的问题 工厂模式是创建型的设计模式,它接受指令,创建出符合要求的实例:它主要解决的是资源的统一分发,将对象的创建完全独立出来,让对象的创建和具体的使用客户无关.主要应用在多数据库选择,类库文件加载

Java中的GOF23（23中设计模式）--------- 工厂模式（Factory）

Java中的GOF23(23中设计模式)--------- 工厂模式(Factory) 在给大家介绍工厂模式之前,我想和大家聊聊面向对象的那点事,在这里,引入三个概念. 开闭原则(Open Closed Principle)是Java世界里最基础的设计原则,它指导我们如何建立一个稳定的.灵活的系统:一个软件实体如类.模块和函数应该对扩展开放,对修改关闭.说白了就是在这里我的项目写完了,你到改某些功能,就只能添加新的类,不能修改其他的类,在这里也许会有很多的人会说,为什么呀,我举个例子,你做的版本

【一起学设计模式】状态模式+装饰器模式+简单工厂模式实战：（一）提交个订单我到底经历了什么鬼？

前言 之前在我的博客(一枝花算不算浪漫)中已经更新过两篇设计模式相关的内容 [一起学设计模式]策略模式实战一:基于消息发送的策略模式实战 [一起学习设计模式]策略模式实战二:配合注解 干掉业务代码中冗余的if else... [一起学设计模式]访问者模式实战:权限管理树删节点操作 [一起学设计模式]命令模式+模板方法+工厂方法实战: 如何优雅的更新商品库存... 上面内容都是基于真实业务场景精简后的设计(工作中真实场景使用到的). 之前为了学习设计模式,看过网上很多相关博客讲解,大都是画下UML

Java设计模式—工厂方法模式&amp;抽象工厂模式

工厂方法模式与抽象工厂模式都是设计模式中重要而且常见的模式.       工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 通用类图如下: 在工厂方法模式中,抽象产品类Product负责定义产品的共性,实现对事物最抽象的定义:Creator为抽象创建 类,也就是抽象工厂,具体如何创建产品类是由具体的实现工厂ConcreteCreator完成的. 工厂方法模式的扩展方式有很多种,下边是工厂方法模式一个比较实用的源代码: 抽象产品类: pub

简单工厂模式 工厂模式 抽象工厂模式

其实这个三个C++的设计模式已经学习很长时间了,今晚才想起来要写这三个设计模式,为什么要用C++中的设计模式呢?for example,你已经会开车了,正着开,倒着开,转弯,这些都是开车基本的,但是你并没有很高的车技,并不会炫酷.漂移,就好像C++中的设计模式一样,在你学好C++的基础上,娴熟的应用出的新技能,能让你的车开的更好. 为什么要用简单工厂模式,记得上一次,我虽然敲完了代码,但是当别人突然问一句,你为什么要用简单工厂模式,我突然就愣住了,代码很简单,一看就懂了.重要的还是思想.专门定义

工厂模式 抽象工厂模式

昨天我们说到了简单工厂模式,今天我们来说说工厂模式,还有抽象工厂模式. 工厂模式,顾名思义,就是在简单工厂模式的基础上继续优化,前面的简单模式当数量多时要改的地方很多,而且比较分散,修改起来比较麻烦,那么我们可以继续封装下. var BookShop=function(type,content){ if(type in BookShop.types){ return new BookShop.types[type](content); }else{ alert("未找到对象"+type

工厂模式——简单工厂模式

工厂模式分三类:简单工厂模式.工厂方法模式.抽象工厂模式. 首先介绍比较简单一种工厂模式——简单工厂模式. 我们以计算器作为一个例子来说明工厂模式到底是什么.作为一个几年前大一从C语言起步的初级程序员,到现在写代码的思维还是停留在结构化编程,虽然Java学了有几年了,总是说面向对象面向对象.但是让实现一个计算器的程序,估计大部分人都会以C语言式的结构化编程来写,几个if语句或者一个switch来搞定.我也同样不例外,为了提高自己的编程水平,所以一点点开始学设计模式.其实在很多开源代码里也有很多经

Java模式—简单工厂模式

简单工厂模式:是由一个工厂对象决定创建出哪一种产品类的实例,简单工厂模式是工厂模式家族中最简单实用的模式. 目的:为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的. 它的组成: 1) 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑.在java中它往往由一个具体类实现. 2) 抽象产品角色:它一般是具体产品继承的父类或者实现的接口.在java中由接口或者抽象类来实现. 3) 具体产品角色:工厂类所创建的对象就是此角色的实例.在java中由一个具体类实现

23中设计模式----------抽象工厂模式

抽象工厂模式: 在上一篇中讲到通过各个具体球类(如:足球,篮球等)来继承总球类(Ball),来实现通过BallFactory对具体球类的生产. 不过,当时只是能造出不同球类,而在每种球类中肯定也有颜色,大小等不同的属性.所以,为了实现在工厂中添加属性.将抽象的Ball球类,修改成Bll接口,在该接口中添加所需要的方法: 这种模式是抽象工厂模式,抽象工厂模式是抽象方法模式的升级.在有多个业务品种,业务分级时,采用抽象工厂模式生产需要的对象是一种非常好的解决房还是.(比如,在生产球类的时候,不仅要分