接口学习应用

**

使用接口抽象思想实现服务检查功能

**
功能实现预期：
①实现解耦，后期添加系统，或者增加某种检查方法，不需要更改代码，只需增加类实现接口。
②实现服务检查，通过调用接口http、curl等方法来检查服务是否正常。

接口定义
SystemCheck 用来定义最顶层的检查接口

public interface SystemCheck {

    Responese serviceCheck(ServiceCheck serviceCheck, String checkType);

    Responese processCheck(ProcessCheck processCheck, String processCheckWay);

    Responese portCheck(PortCheck portCheck, String portCheckWay);

}

PortCheck 定义检查的方法

public interface PortCheck {

    Responese httpCheck();

    Responese telnetCheck();

    Responese curlCheck();

}

ServiceCheck 定义检查的方法

public interface ServiceCheck {

    Responese httpCheck();

    Responese shellCheck();

    Responese curlCheck();

    Responese telnetCheck();

}

ProcessCheck 定义检查的方法

public interface ProcessCheck {

    Responese shellCheck();

}

Analysis 定义解析的方法，解析检查后的返回体，构造成规范的返回前端的格式

public interface Analysis {

    String analysisResponse();
}

Response 实体类

public class Responese<T> {

    private String msg;

    public void parseInfo(T t){
        this.msg = "t===" + t;
    }
}

常量定义，其余也类似此类定义

public class ServiceCheckWay {
    //    TELNET,PROCESS,HTTP,CURL
    public static final String TELNET = "TELNET";
    public static final String PROCESS = "PROCESS";
    public static final String HTTP = "HTTP";
    public static final String CURL = "CURL";

}

设置一个basic类作为抽象类，去实现接口，作为规范。所有继承该类的子类都需要实现basic实现的接口，以此来约定规范。

public abstract class BasicSystem  implements PortCheck, ServiceCheck, ProcessCheck , Analysis {

    private String sys_name;

    public String getSys_name() {
        return sys_name;
    }

    public void setSys_name(String sys_name) {
        this.sys_name = sys_name;
    }
}

这个类为重写方法的类，实际上的检查逻辑在此实现。增加新的系统也只需要增加此类（和这个一样继承basicSystem），重写方法即可。

@Component("样板系统1")
public class SystemTemplate extends BasicSystem implements PortCheck, ServiceCheck, ProcessCheck, Analysis {

    public Responese httpCheck() {
        Responese<Integer> responese = new Responese<Integer>();
        responese.parseInfo(200);
        return responese;
    }

    public Responese shellCheck() {
        Responese<String> responese = new Responese<String>();
        responese.parseInfo("shell check finished!");
        return responese;
    }

    public Responese telnetCheck() {
        Responese<String> responese = new Responese<String>();
        responese.parseInfo("telnet check finished!");
        return responese;
    }

    public Responese curlCheck() {
        Responese<String> responese = new Responese<String>();
        responese.parseInfo("curl check finished!");
        return responese;
    }

    @Override
    public String analysisResponse() {
        return null;
    }
}

spring的BeanFactoryAware 接口来获取类的实例

@Component
public class BeanFactoryUtil implements BeanFactoryAware {

    private static Logger logger = LoggerFactory.getLogger(BeanFactoryUtil.class);

    private static DefaultListableBeanFactory beanFactory;

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = (DefaultListableBeanFactory) beanFactory;
    }

    public static DefaultListableBeanFactory getBeanFactory() {
        return beanFactory;
    }

    public static Object getSystemByName(String name){
        return beanFactory.getBean(name);
    }

}

实现SystemCheck 接口，完成顶层检查服务实现

@Component
public class DefaultChecker implements SystemCheck {

    public Responese serviceCheck(ServiceCheck serviceCheck, String checkType) {
        if (checkType.equals(ServiceCheckWay.CURL)){
            return serviceCheck.curlCheck();
        }else if (checkType.equals(ServiceCheckWay.HTTP)){
            return serviceCheck.httpCheck();
        }else if (checkType.equals(ServiceCheckWay.TELNET)){
            return serviceCheck.telnetCheck();
        }else if (checkType.equals(ServiceCheckWay.PROCESS)){
            return serviceCheck.shellCheck();
        }else{
            Responese resq = new Responese();
            resq.parseInfo("不支持这种检查方式");
            return resq;
        }
    }

    public Responese processCheck(ProcessCheck processCheck, String processCheckWay) {
       
    }

    public Responese portCheck(PortCheck portCheck, String portCheckWay) {

    }

    public Responese doCheck(BasicSystem basicSystem,String checkType, String checkWay){
        if (checkType.equals("PORT")){
            return portCheck(basicSystem,checkWay);
        }else if (checkType.equals("PROCESS")){
            return processCheck(basicSystem,checkWay);
        }else if (checkType.equals("SERVICE")){
            return serviceCheck(basicSystem,checkWay);
        }else{
            Responese<String> responese = new Responese<String>();
            responese.parseInfo("不支持这种查询信息");
            return responese;
        }
    }

}

Controller 层代码

@Controller
public class SystemCheckController {

    @Autowired
    private DefaultChecker checker;
    @GetMapping("/check")
    @ResponseBody
    public String check(@RequestParam String sys_name, @RequestParam  String check_type, @RequestParam  String check_way){
        BasicSystem basicSystem = (BasicSystem) BeanFactoryUtil.getSystemByName(sys_name);
        Responese responese = checker.doCheck(basicSystem,check_type,check_way);
        return new Gson().toJson(responese);
    }

}

注意
①接口作为参数传递，所有实现了此接口的类都可作为参数传递。
②父类可代替子类，子类不可代替父类
③继承了父类，需实现父类实现的所有接口，其实也就是实现了父类的所有方法。

菜鸟理解！！！！！！