JAVA【设计模式】依赖倒置原则

type

status

date

slug

summary

一、设计模式的规范

设计模式遵循六⼤原则；单⼀职责( ⼀个类和⽅法只做⼀件事 )、⾥⽒替换( 多态，⼦类可扩展⽗类 )、依赖倒置( 细节依赖抽象，下层依赖上层 )、接⼝隔离( 建⽴单⼀接⼝ )、迪⽶特原则( 最少知道，降低耦合 )、开闭原则( 抽象架构，扩展实现 )，会在具体的设计模式章节中，进⾏体现。

二、依赖倒置原则

定义：程序依赖接口，接口定义标准和规范，具体的实现按照场景，而不是使用对象硬编码的方式实现

三、示例

模拟场景： 1、例如：领导有事需要开部门例会，领导是不可能去每个工位，喊各位同事去参加会议。领导只会在工作群里面申明，今天什么时间段开会，各位收到消息后，自行去开会。。。

2：例如：用户抽奖有随机抽奖和权重抽奖两种方式，我们只需要定义出一套抽奖抽象标准。具体的实现，看随机和权重的不同实现。

非依赖倒置原则（硬编码）

投注用户：BetUser


package com.qf.principle.dependenceinverse.tradition;

/**
 * @description 投注用户
 */
public class BetUser {

    private String userName;  // 用户姓名
    private int userWeight;   // 用户权重

    public BetUser() {
    }

    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


package com.qf.principle.dependenceinverse.tradition;

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

/**
 * @description 抽奖控制
 */
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;
    }

}

测试：ApiTest


package com.qf.principle.dependenceinverse.tradition;

import com.alibaba.fastjson.JSON;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

public class ApiTest {

    private Logger logger = LoggerFactory.getLogger(ApiTest.class);

    @Test
    public void test_DrawControl(){
        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));
    }

}

依赖倒置原则

投注用户：BetUser


package com.qf.principle.dependenceinverse.design;

/**
 * @description 投注用户
 */
public class BetUser {

    private String userName;  // 用户姓名
    private int userWeight;   // 用户权重

    public BetUser() {
    }

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

定义接口抽奖：IDraw


package com.qf.principle.dependenceinverse.design;


import java.util.List;

public interface IDraw {
    List<BetUser> prize(List<BetUser> list, int count);
}

随机抽奖实现：RandomDraw


package com.qf.principle.dependenceinverse.design;

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

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

权重抽奖实现：WeightDraw


package com.qf.principle.dependenceinverse.design;

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

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

抽奖控制：DrawControl


package com.qf.principle.dependenceinverse.design;


import java.util.List;

/**
 * @description 抽奖控制
 */
public class DrawControl {

    private IDraw draw;

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

测试：ApiTest


package com.qf.principle.dependenceinverse.design;

import com.alibaba.fastjson.JSON;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

public class ApiTest {
    private Logger logger = LoggerFactory.getLogger(com.qf.principle.dependenceinverse.tradition.ApiTest.class);

    @Test
    public void test_DrawControl(){
        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.doDraw(new RandomDraw(),betUserList,3);
        logger.info("随机抽奖，中奖用户名单：{}", JSON.toJSON(prizeRandomUserList));

        List<BetUser> prizeWeightUserList=drawControl.doDraw(new WeightDraw(),betUserList,3);
        logger.info("权重抽奖，中奖用户名单：{}", JSON.toJSON(prizeWeightUserList));
    }
}

UML关系图

硬编码的方式：具体的实现都在此类里

依赖倒置方式：

总结：依赖倒置原则增加了代码的可维护性，利用多态的特性，上级只需要定义标准，下级负责实现，跟装饰者模式有点类似