六大设计原则之依赖倒置原则07

最新推荐文章于 2024-07-18 19:45:44 发布

窗台绿萝

最新推荐文章于 2024-07-18 19:45:44 发布

阅读量98

点赞数

分类专栏：读书笔记文章标签：依赖倒置原则

本文链接：https://blog.csdn.net/weixin_67727883/article/details/125091994

版权

读书笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.概述

依赖倒置原则（Dependence Inversion Principle,DIP），是Robert C.Martin于1996年在C++Report上发表的文章中提出的。是指在设计代码架构时，高层模块不应该依赖于底层模块，二者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。依赖倒置原则是实现开闭原则的重要途径之一，它降低了类之间的耦合，提高了系统的稳定性和可维护性，同时这样的代码一般更易读，且便于传承。

2.业务场景

在互联网的营销活动中，经常为了拉新和促活，会做一些抽奖活动。这些抽奖活动的规则会随着业务的不断发展而调整，如随机抽奖、权重抽奖等。其中，权重是指用户在当前系统中的一个综合排名，比如活跃度、贡献度等。

3.运用设计原则前代码实现

3.1.代码实现

抽奖用户类BetUser.java

package chapter02.dip;

public class BetUser {
    //用户姓名
    private String userName;
    // 用户权重
    private int userWeight;

    public BetUser(String userName, int userWeight) {
        this.userName = userName;
        this.userWeight = userWeight;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getUserWeight() {
        return userWeight;
    }

    public void setUserWeight(int userWeight) {
        this.userWeight = userWeight;
    }
}

抽奖逻辑类 DrawControl.java

package chapter02.dip;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class DrawControl {
    //随机抽取指定数量的用户，作为中奖用户
    public List<BetUser> doDrawRandom(List<BetUser> list,int count){
        //集合数量很小，直接返回
        if(list.size() <= count) return list;
        //乱序集合
        Collections.shuffle(list);
        //取出指定数量的中奖用户
        List<BetUser> prizeList = new ArrayList<>(count);
        for(int i = 0; i< count; i++){
            prizeList.add(list.get(i));
        }
        return prizeList;
    }

    //按权重排序获取指定数量的用户，作为中奖用户
    public List<BetUser> doDrawWeight(List<BetUser> list,int count){
        //按照权重排序
        list.sort((o1,o2)->{
            int e = o2.getUserWeight() - o1.getUserWeight();
            if(0 == e) return 0;
            return e > 0 ? 1 : -1;
        });
        //取出指定数量的中奖用户
        List<BetUser> prizeList = new ArrayList<>(count);
        for(int i = 0; i < count; i++){
            prizeList.add(list.get(i));
        }
        return prizeList;
    }
}

测试用例

 @Test
    public void testDrawControl() {
        List<BetUser> betUserList = new ArrayList<>();
        betUserList.add(new BetUser("花花", 65));
        betUserList.add(new BetUser("豆豆", 43));
        betUserList.add(new BetUser("小白", 72));
        betUserList.add(new BetUser("笨笨", 89));
        betUserList.add(new BetUser("丑蛋", 10));
        DrawControl drawControl = new DrawControl();
        List<BetUser> prizeRandomUserList = drawControl.doDrawRandom(betUserList, 3);
        logger.info("随机抽奖，中奖用户名单:{}", JSON.toJSON(prizeRandomUserList));
        List<BetUser> prizeWeightUserList = drawControl.doDrawWeight(betUserList, 3);
        logger.info("权重抽奖，中奖用户名单：{}", JSON.toJSON(prizeWeightUserList));
    }

3.2.总结

1.这样的实现方式扩展起来很麻烦，每次扩展都需要新增接口，同时对于调用方来说需要新增调用接口的代码。其次，对于这个服务类来说，随着接口数量的增加，代码行数会不断地暴增，最后难以维护。

4.运用设计原则后代码实现

首先定义抽奖功能的接口，任何一个实现方都可以实现自己的抽奖逻辑。

4.1.代码实现

抽奖接口 IDraw.java

package chapter02.dip;

import java.util.List;

public interface IDraw {

    //获取中奖用户接口
    List<BetUser> prize(List<BetUser> list, int count);
}

随机抽奖实现 DrawRandom.java

package chapter02.dip;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 随机抽取指定数量的用户，作为中奖用户
 */
public class DrawRandom implements IDraw {
    @Override
    public List<BetUser> prize(List<BetUser> list, int count) {
        //集合数量很小，直接返回
        if (list.size() <= count) return list;
        //乱序集合
        Collections.shuffle(list);
        //取出指定数量的中奖用户
        List<BetUser> prizeList = new ArrayList<>(count);
        for (int i = 0; i < count; i++) {
            prizeList.add(list.get(i));
        }
        return prizeList;
    }
}

权重抽奖实现 DrawWeightRank.java

package chapter02.dip;

import java.util.ArrayList;
import java.util.List;

/**
 * 按照权重排序获取指定数量的用户作为中奖名单
 */
public class DrawWeightRank implements IDraw{
    @Override
    public List<BetUser> prize(List<BetUser> list, int count) {
        //按照权重排序
        list.sort((o1,o2)->{
            int e = o2.getUserWeight() - o1.getUserWeight();
            if(0==e) return 0;
            return e > 0 ? 1:-1;
        });
        //取出指定数量的中奖用户
        List<BetUser> prizeList = new ArrayList<>(count);
        for(int i = 0; i < count; i++){
            prizeList.add(list.get(i));
        }
        return prizeList;
    }
}

创建抽奖服务 DrawControlExt.java

package chapter02.dip;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class DrawControlExt {
   private IDraw draw;
   public List<BetUser> doDraw(IDraw draw,List<BetUser> betUserList, int count){
       return draw.prize(betUserList,count);
   }
}

在这个类中体现了依赖倒置的重要性，可以把任何一种抽奖逻辑传递给这个类。这样实现的好处是可以不断地扩展，但是不需要在外部新增调用接口，降低了一套代码的维护成本，并提高了可扩展性及可维护性。另外，这里的重点是把实现逻辑的接口作为参数传递，在一些框架源码中经常会有这种做法。

测试用例

  @Test
    public void testDrawControl2() {
        List<BetUser> betUserList = new ArrayList<>();
        betUserList.add(new BetUser("花花", 65));
        betUserList.add(new BetUser("豆豆", 43));
        betUserList.add(new BetUser("小白", 72));
        betUserList.add(new BetUser("笨笨", 89));
        betUserList.add(new BetUser("丑蛋", 10));
        DrawControlExt drawControl = new DrawControlExt();
        List<BetUser> prizeRandomUserList = drawControl.doDraw(new DrawRandom(),betUserList, 3);
        logger.info("随机抽奖，中奖用户名单:{}", JSON.toJSON(prizeRandomUserList));
        List<BetUser> prizeWeightUserList = drawControl.doDraw(new DrawWeightRank(),betUserList, 3);
        logger.info("权重抽奖，中奖用户名单：{}", JSON.toJSON(prizeWeightUserList));

    }