设计模式之:策略模式,解决if...else,以及ase--688IT编程网

设计模式之：策略模式，解决if...else，以及ase

设计模式中的六⼤原则：

1、单⼀职责原则（Single Responsibility Principle，简称SRP ）

2、⾥⽒替换原则（Liskov Substitution Principle，简称LSP）

3、依赖倒置原则（Dependence Inversion Principle，简称DIP）

4、接⼝隔离原则（Interface Segregation Principle，简称ISP）

5、迪⽶特法则（Law of Demeter，简称LoD）

6、开放封闭原则（Open Close Principle，简称OCP）

在23中设计模式中，策略模式相对来说，还是很实⽤的，⼀般我们会碰到各种的if...else，或者ase，写这个时候⼀般情况下可以会写很多层的if..else，或者ase。这样写法能实现基本功能，但是如果碰到需要添加就很痛苦了，⽐如例⼦：

public void judgmentType(String type) {

switch (type) {

case "1500":

System.out.println("");

break;

case "1888":

System.out.println("");

break;

case "2100":

System.out.println("");

break;

case "5100":

System.out.println("");

break;

case "2200":

System.out.println("");

break;

case "2280":

System.out.println("");

break;

default:

break;

}

这种情况下，如果要添加业务，就得继续添加ase，⾮常不灵活。所以我们通过策略模式来实现对ase的处理。

下⾯代码，就是针对上⾯的ase 进⾏使⽤策略模式。

⾸先不管三七⼆⼗⼀，你先定义⼀个接⼝，这个接⼝就是策略类接⼝。出共同的⽅法，这⾥定义了⼀个策略类接⼝，⽤来处理具体类的业务功能。

/**

* 创建策略类接⼝

* @author Kevin Luo

public interface DeviceStatusStrategy {

/**

* 处理状态接⼝

* @param message

* @param deviceInfo

* @param data

* @return

public boolean processingStatus(String message, String deviceInfo, byte[] data);

}

下⾯定义具体的实现类，⽤于处理业务，封装了具体的算法或⾏我。同时，实现策略类接⼝。

package sule;

import com.device.state.DeviceStatusStrategy;

/**

* 具体类，实现测试接⼝

* @author Kevin Luo

public class resultDID1500 implements DeviceStatusStrategy {

/**

* 实现业务接⼝

@Override

public boolean processingStatus(String message, String deviceInfo, byte[] data) {

// TODO Auto-generated method stub

System.out.println(message + "1500业务处理......" + deviceInfo);

return true;

}

另外⼀个具体实现类也是⼀样的事情，定⼀个具体实现类，⽤于处理业务。同时，实现策略类接⼝。其他的也都是⼀样的，只是类名不同⽽已，其他就不⼀⼀列举了。

import com.device.state.DeviceStatusStrategy;

/**

* 具体类，实现测试接⼝

* @author Kevin Luo

public class saveDeviceState2100 implements DeviceStatusStrategy {

/**

* 实现业务接⼝

@Override

public boolean processingStatus(String message, String deviceInfo, byte[] data) { // TODO Auto-generated method stub

System.out.println("2100业务处理......");

return true;

}

我们来在创建⼀个Context上下⽂类，维护⼀个对Strategy对象的引⽤。package com.device.state;

/**

* Context上下⽂类，维护⼀个对Strategy对象的引⽤。

* @author Kevin Luo

public class DeviceStatusContext {

/**

* 声明⼀个策略类接⼝，⽤于调⽤具体的实现类

private DeviceStatusStrategy deviceStatusStrategy;

public DeviceStatusContext(DeviceStatusStrategy deviceStatusStrategy) {

this.deviceStatusStrategy = deviceStatusStrategy;

}

/**

* 执⾏策略类接⼝，会调⽤具体的实现类中的⽅法

* @param message

* @param deviceInfo

* @param data

* @return

public boolean executeStrategy(String message, String deviceInfo, byte[] data) { return deviceStatusStrategy.processingStatus(message, deviceInfo, data);

}

最后，做了⼀个⽤于初始化上下⽂的⼀个类，⽤于外部调⽤。

这⾥⾯包含了两种实现⽅式

第⼀种⽅式：获取对应的状态码，进⾏map查询，查询出对应的具体类对象

第⼆种⽅式：通过配置⽂件的形式，获取对应的具体实现类，通过反射获取上下⽂对象，在进⾏调⽤

这种⽅式，更加的灵活，当需要添加状态的时候，只需要添加对应的状态类，然后在配置⽂件中添加状态类地址就可以实现增加，⾮常的灵活，不需要修改内部代码，符合开闭原则。

package com.device.state;

import flect.Constructor;

import flect.InvocationTargetException;

import java.util.HashMap;

import java.util.Map;

import sultDID1500;

import sule.saveDevcieStateInfo1888;

import sule.saveDeviceState2100;

import sule.saveWifiInfo5100;

import sule.saveWifiState2200;

import sule.seeWifiStateResult2280;

import com.device.utils.PropertyUtils;

/**

* 具体的调⽤类

* @author Kevin Luo

public class ResultHandle {

/创建⼀个关系型map，⽤来存储对象，value值为策略类

private static Map<String, DeviceStatusStrategy> mapStrategy = new HashMap<String, DeviceStatusStrategy>();;

//初始化map对象，存储各个需要使⽤的具体类

static {

mapStrategy.put("1500", new resultDID1500());

mapStrategy.put("2100", new saveDeviceState2100());

mapStrategy.put("5100", new saveWifiInfo5100());

mapStrategy.put("2200", new saveWifiState2200());

mapStrategy.put("2280", new seeWifiStateResult2280());

mapStrategy.put("1888", new saveDevcieStateInfo1888());

}

private DeviceStatusContext deviceStatusContext;

/**

* 第⼀种⽅式：获取对应的状态码，进⾏map查询，查询出对应的具体类对象

* @param message

* @param type

* @param data

* @return

public boolean handleDeviceStatusStrategy(String message, String type, byte[] data) {

deviceStatusContext = new (type));

uteStrategy(message, type, data);

}

/**

* 第⼆种⽅式：通过配置⽂件形式，获取对应的具体实现类，通过反射获取上下⽂对象，在进⾏调⽤

* 这种⽅式，更加的灵活，当需要添加状态的时候，只需要添加类型，然后在配置⽂件中添加类地址就可以实现增加

* @param message

* @param type

* @param data

* @return

public boolean handleStrategy(String message, String type, byte[] data) {

String value = Value("device" + type);

this.CreateDeviceStateStrategy(value);

uteStrategy(message, "123123123", data);

}

/**

* 将具体类的对象地址通过反射⽣成上下⽂对象

* @param type

public void CreateDeviceStateStrategy(String type) {

Class clz;

try {

clz = Class.forName(type);

Constructor<?> constructor = Constructor();

DeviceStatusStrategy deviceStatusStrategy = (DeviceStatusStrategy) wInstance(null);

deviceStatusContext = new DeviceStatusContext(deviceStatusStrategy);

} catch (ClassNotFoundException e) {