java设计模式实际应用场景实例

╰半橙微兮° 2023-10-03 18:24 28阅读 0赞

## 常用设计模式 ##

策略模式、模板方法、工厂模式、单例模式

## 业务场景 ##

营销拉新活动。

## 实例一：工厂模式+抽象 ##

### 定义抽象业务接口 ###

public abstract class AwardAbstract {
        
        public abstract Boolean award(String userId);
    }

### 定义具体业务实现类 ###

// 头条渠道发放奖励业务
    public class TouTiaoAwardService extends AwardAbstract {
        
        @Override
        public Boolean award(String userId) {
        
            log.info("头条渠道用户{}奖励50元红包!", userId);
            return Boolean.TRUE;
        }
    }
    
    // 微信渠道发放奖励业务
    public class WeChatAwardService extends AwardAbstract {
        
        @Override
        public Boolean award(String userId) {
        
            log.info("微信渠道用户{}奖励100元红包!", userId);
            return Boolean.TRUE;
        }
    }

### 利用工厂模式获取实例对象 ###

public class AwardFactory {
        
        public static AwardAbstract getAwardInstance(String source) {
        
            if ("toutiao".equals(source)) {
        
                return new TouTiaoAwardService();
            } else if ("wx".equals(source)) {
        
                return new WeChatAwardService();
            }
            return null;
        }
    }

### 业务入口处根据不同渠道执行不同的发放逻辑 ###

@PostMapping("/reward2")
    public void reward2(String userId, String source) {
        
        AwardAbstract instance = AwardFactory.getAwardInstance(source);
        if (null != instance) {
        
            instance.award(userId);
        }
    }

## 实例二：模板方法 ##

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

#### 应用场景： ####

例如生成PDF模板，有固定的logo位置、固定的表格排版，不固定的就是数据的解析，可以将logo的位置、基础样式放置在父类，将数据的解析放置在子类。

#### 代码结构如下： ####

1.  定义抽象父类，在其中定义属性与方法，把不变的格式封装起来。
2.  定义子类，继承父类，重写某些方法，加入自己的逻辑，调用父类的总方法，完成处理。
3.  定义测试类，通过子类调用父类的方法完成逻辑

#### 定义模板类： ####

package designmodel.templeteModel;
     
    /**
     * @{NAME}
     * @Description TODO
     * @Author luocong
     * @Date
     * @Version 1.0
     * 模板类
     **/
    public abstract class TempleteClass {
        
        //基本方法
        protected abstract void doA();
        protected abstract void doB();
     
        //模板方法
        public void templeteMethod(){
        
            doA();
            if(isDoAnything()){
        
                doB();
            }
        }
        //返回布尔值
        public boolean isDoAnything(){
        
            return true;
        }
     
    }

#### 定义子类的方法实现： ####

package designmodel.templeteModel;
     
    /**
     * @{NAME}
     * @Description TODO
     * @Author luocong
     * @Date
     * @Version 1.0
     *子类
     **/
    public class TempleteChild extends TempleteClass{
        
     
        @Override
        protected void doA() {
        
            System.out.println("进入了A方法");
        }
     
        @Override
        protected void doB() {
        
            System.out.println("进入了B方法");
        }
     
        @Override
        public boolean isDoAnything() {
        
            return true;
        }
     
        public void doAllthings(){
        
            super.templeteMethod();
        }
    }

通过模板方法模式，可以把认为是不变部分的算法封装到父类实现，而可变部分的则可以通过继承来继续扩展，行为由父类控制，子类实现。基本方法是由子类实现的，因此子类可以通过扩展的方式增加相应的功能，符合开闭原则。

## 实例三：策略模式+模板方法+工厂模式+单例模式 ##

还是以营销拉新为业务场景来说明，这个业务流程再增加一些复杂度，比如发放奖励之前要进行身份验证、风控验证等一些列的校验，此时你的业务流程该如何实现更清晰简洁呢？

### 定义业务策略接口 ###

/** 策略业务接口 */
    public interface AwardStrategy {
        
        /**
         * 奖励发放接口
         */
        Map<String, Boolean> awardStrategy(String userId);
    
        /**
         * 获取策略标识,即不同渠道的来源标识
         */
        String getSource();
    }

### 定义奖励发放模板流程 ###

public abstract class BaseAwardTemplate {
        
        private static final Logger log = LoggerFactory.getLogger(BaseAwardTemplate.class);
    
        //奖励发放模板方法
        public Boolean awardTemplate(String userId) {
        
            this.authentication(userId);
            this.risk(userId);
            return this.awardRecord(userId);
        }
    
        //身份验证
        protected void authentication(String userId) {
        
            log.info("{} 执行身份验证!", userId);
        }
    
        //风控
        protected void risk(String userId) {
        
            log.info("{} 执行风控校验!", userId);
        }
    
        //执行奖励发放
        protected abstract Boolean awardRecord(String userId);
    }

### 实现不同渠道的奖励业务 ###

@Slf4j
    @Service
    public class ToutiaoAwardStrategyService extends BaseAwardTemplate implements AwardStrategy {
        
        /**
         * 奖励发放接口
         */
        @Override
        public Boolean awardStrategy(String userId) {
        
            return super.awardTemplate(userId);
        }
    
        @Override
        public String getSource() {
        
            return "toutiao";
        }
    
        /**
         * 具体的业务奖励发放实现
         */
        @Override
        protected Boolean awardRecord(String userId) {
        
            log.info("头条渠道用户{}奖励50元红包!", userId);
            return Boolean.TRUE;
        }
    }
    
    
    @Slf4j
    @Service
    public class WeChatAwardStrategyService extends BaseAwardTemplate implements AwardStrategy {
        
        /**
         * 奖励发放接口
         */
        @Override
        public Boolean awardStrategy(String userId) {
        
            return super.awardTemplate(userId);
        }
    
        @Override
        public String getSource() {
        
            return "wx";
        }
    
        /***
         * 具体的业务奖励发放实现
         */
        @Override
        protected Boolean awardRecord(String userId) {
        
            log.info("微信渠道用户{}奖励100元红包!", userId);
            return Boolean.TRUE;
        }
    }

### 定义工厂方法，对外统一暴露业务调用入口 ###

@Component
    public class AwardStrategyFactory implements ApplicationContextAware {
        
        private final static Map<String, AwardStrategy> MAP = new HashMap<>();
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        
            Map<String, AwardStrategy> beanTypeMap = applicationContext.getBeansOfType(AwardStrategy.class);
            beanTypeMap.values().forEach(strategyObj -> MAP.put(strategyObj.getSource(), strategyObj));
        }
    
        /**
         * 对外统一暴露的工厂方法
         */
        public Boolean getAwardResult(String userId, String source) {
        
            AwardStrategy strategy = MAP.get(source);
            if (Objects.isNull(strategy)) {
        
                throw new RuntimeException("渠道异常!");
            }
            return strategy.awardStrategy(userId);
        }
    
        /**
         * 静态内部类创建单例工厂对象
         */
        private static class CreateFactorySingleton {
        
            private static AwardStrategyFactory factory = new AwardStrategyFactory();
        }
    
        public static AwardStrategyFactory getInstance() {
        
            return CreateFactorySingleton.factory;
        }
    }

### 业务入口方法 ###

@RestController
    @RequestMapping("/activity")
    public class ActivityController {
        
    
        @PostMapping("/reward3")
        public void reward3(String userId, String source) {
        
            AwardStrategyFactory.getInstance().getAwardResult(userId, source);
        }
    }