依赖倒置原则

定义：是指在设计代码的架构时，高层模块不应该依赖于底层模块，二者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

依赖倒置原则是实现开闭原则的重要途径之一，它降低了类之间的耦合，提高了系统的稳定性和可维护性，同样这样的代码更易读

模拟场景：

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

下面模拟出一个抽奖的系统服务

原始方法代码实现：

public class BetUser {
    /**
     * 这个类方便满足不同的抽奖方式
     */
    private String userName; //用户名
    private int userWeight; //用户权重

    public String getUserName() {
        return userName;
    }

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

    public int getUserWeight() {
        return userWeight;
    }

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

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;
    }
}

依赖导致原则代码实现：

public class DrawControl {
    private IDraw draw;

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

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

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

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;
    }
}

public class DrawWeight 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;
    }
}