为什么程序员喜欢用大量的if... ...else if ；不喜欢用设计模式+反射+自定义注解

面向过程设计和面向对象设计的主要区别是：

是否在业务逻辑层使用冗长的if else判断。如果你的代码还在大量使用if else，当然，界面表现层除外，即使你使用Java/C#这样完全面向对象的语言，也只能说明你的思维停留在传统的面向过程语言上。

传统思维设计

业务逻辑层为什么会使用大量的if else呢？其实目的也是为了重用，但是这是面向过程编程的重用，程序员只看到代码重用，因为他看到if else几种情况下大部分代码都是重复的，只有部分不同，因此使用if else可以避免重复代码。

好了，废话不多说！

假定有这样的一种情况，需要根据传入的参数类型，选择不同的短信服务商来发送相应的短信操作。

传统的if...else来实现的话，就类似如下代码：

首先，SMSTypeEnum是一个枚举类，这个没啥可讲的，有问题自行百度一下

/**
 * 短信类型枚举类
 *
 * @author somnus
 * @date 2019年09月10日
 */
public enum SMSTypeEnum {
    TENGXUNYUN_SMS("txy","腾讯云短信"),
    SI_XUN_TONG_SMS("sxt","思迅通"),
    ALIYUN_SMS("aliyun","阿里云短信"),
    ZHONG_YU_WEI_XIN_SMS("zywx","中昱维信");
    String type;
    String name;
    SMSEnum(String type,String name){
        this.type=type;
        this.name=name;
    }
｝

执行的main方法，可以看出来这里臃肿。

public static void main(String[] args) {
        String type="aliyun";//阿里云短信
        if(type.equals(SMSTypeEnum.ALIYUN_SMS.getType())){
            //处理阿里云短信...
            System.out.println("执行："+SMSTypeEnum.ALIYUN_SMS.getName());
        }else if(type.equals(SMSTypeEnum.TENGXUNYUN_SMS.getType())){
            //处理腾讯云短信短信...
        }else if(type.equals(SMSTypeEnum.SI_XUN_TONG_SMS.getType())){
            //处理思迅通短信...
        }else if(type.equals(SMSTypeEnum.ZHONG_YU_WEI_XIN_SMS.getType())){
            //处理中昱维信短信...
        }else{
            //...
        }
    }

最后的返回结果：

设计模式

经常有人说用设计模式，设计模式是不错，但是很难用到，其实如果你使用if else来写代码时，就直接在写业务逻辑，只不过使用简单的判断语句来作为现实情况的替代者。设计模式我们就说一下策略模式，想到策略模式就想到了《三国演义》中的锦囊妙计。我们下面就开始通过设计模式

首先我们来建一个消息实体类：

/**
 * 短信消息封装
 *
 * @author somnus
 * @date 2019年09月10日
 */
public class SMSInfo {
    /**
     * 主键
     */
    private Integer id;
    /**
     * 平台信息
     */
    private String appId;
    /**
     * 短信类型1，发送2，校验
     */
    private Integer msgType;
    /**
     * 类型名称
     */
    private String msgName;
    /**
     * 短信验证码
     */
    private String code;
    /**
     * 模版id
     */
    private String templateId;
    /**
     * 短信内容
     */
    private String content;
    /**
     * 创建时间
     */
    private String createTime;

    //省略get，set方法
}

我们先建一个策略接口

/**
 * 短信发送策略接口类
 *
 * @author somnus
 * @date 2019年09月10日
 */
public interface SMSStrategyInterface {
    /**
     * 短信发送
     * @param smsInfo
     * @return
     */
    public BaseResponse sendSms(SMSInfo smsInfo);
}

然后是各短信服务商的实现：

/**
 * 阿里云短信发送策略处理
 *
 * @author somnus
 * @date 2019年09月10日
 */
public class AliyunSmsStrategy implements SMSStrategyInterface {
    /**
     * 短信发送
     * @param smsInfo
     * @return
     */
    public BaseResponse sendSms(SMSInfo smsInfo) {
        //以上处理发送短信逻辑这里就不处理了
        return BaseResponse.ok();
    }
}

好了，剩下的就是我们的核心部分了

新建一个ManagerStrategy管理类

/**
 * 短信管理策略类
 *
 * @author somnus
 * @date 2019年09月10日
 */
public class ManagerStrategy {
    //短信策略接口
    SMSStrategyInterface smsStrategyInterface;
    
    ManagerStrategy(SMSStrategyInterface smsStrategyInterface){
        this.smsStrategyInterface=smsStrategyInterface;
    }

    /**
     * 执行短信发送
     * @param smsInfo
     * @return
     */
    public BaseResponse executeSendSMS(SMSInfo smsInfo){
        return smsStrategyInterface.sendSms(smsInfo);
    }
}

下面我们下个main方法测试一下，这个是可以优化的，我们可以结合下面的反射以及自定义注解的方式进行优化

    public static void main(String[] args) {
        ManagerStrategy managerStrategy=new ManagerStrategy(new AliyunSmsStrategy());
        SMSInfo smsInfo=new SMSInfo();
        //省略短信信息处理逻辑
        System.out.println(managerStrategy.executeSendSMS(smsInfo));
    }

我们可以看到返回结果：

反射

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

我们先来新建一个短信反射枚举类：

/**
 * 反射短信枚举类
 *
 * @author somnus
 * @date 2019年09月10日
 */
public enum  RefelSMSEnum {

    ALIYUN_TYPE_SMS("aliyun","com.yunyi.common.service.reflect.AliyunSMS");
    public String type;
    public String clazz;
    RefelSMSEnum(String type,String clazz){
        this.type=type;
        this.clazz=clazz;
    }
    //省略get，set方法
}

通过修改ManagerStrategy管理类来处理

/**
 * 短信管理反射类
 *
 * @author somnus
 * @date 2019年09月10日
 */
public class ManagerStrategy {
    //通过map方式管理类型以及包名
    private static Map<String,String> strategyMap = new HashMap<String, String>();
    static {
        for(RefelSMSEnum refelSMSEnum:RefelSMSEnum.values()){
            strategyMap.put(refelSMSEnum.type,refelSMSEnum.clazz);
        }
    }

    /**
     * 执行短信发送
     * @param type
     * @return
     */
    public static void executeSendSMS(String type){
        String classPath=strategyMap.get(type);
        if(null==classPath){
            throw new NullPointerException("获取短信类型不存在");
        }
        try{
            /*
             * 通过反射将RefelSMSEnum中映射的类实例化
             * */
            Class clazz=Class.forName(classPath);
            Method excute =clazz.getDeclaredMethod("sendSms");
            excute.invoke(clazz.newInstance());
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

我们建一个main方法来测试一下

 public static void main(String[] args) {
        String type="aliyun";
        ManagerStrategy.executeSendSMS(type);
    }

执行结果：

自定义注解

从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。

我们新建建一个SMSAnnotation注解类：

/**
 * 短信发送自定义注解
 *
 * @author somnus
 * @date 2019年09月10日
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface SMSAnnotation {
    //短信类型
    String type() default "aliyun";
    //短信类型名称
    String name();
}

我们可以通过以下的方式来为这个 value 传值：

@Target(value = {ElementType.FIELD})

被这个 @Target 注解修饰的注解将只能作用在成员字段上，不能用于修饰方法或者类。其中，ElementType 是一个枚举类型，有以下一些值：

ElementType.TYPE：允许被修饰的注解作用在类、接口和枚举上
ElementType.FIELD：允许作用在属性字段上
ElementType.METHOD：允许作用在方法上
ElementType.PARAMETER：允许作用在方法参数上
ElementType.CONSTRUCTOR：允许作用在构造器上
ElementType.LOCAL_VARIABLE：允许作用在本地局部变量上
ElementType.ANNOTATION_TYPE：允许作用在注解上
ElementType.PACKAGE：允许作用在包上

@Retention 用于指明当前注解的生命周期，它的基本定义如下：

同样的，它也有一个 value 属性：

@Retention(value = RetentionPolicy.RUNTIME

这里的 RetentionPolicy 依然是一个枚举类型，它有以下几个枚举值可取：

RetentionPolicy.SOURCE：当前注解编译期可见，不会写入 class 文件
RetentionPolicy.CLASS：类加载阶段丢弃，会写入 class 文件
RetentionPolicy.RUNTIME：永久保存，可以反射获取

在实现类上加上我们的自定义注解：

/**
 * 阿里云短信实现类
 *
 * @author somnus
 * @date 2019年09月10日
 */
@SMSAnnotation(type = "aliyun",name="阿里云短信")
public class AliyunSMS implements SMSStrategyInterface {
    /**
     * 短信发送
     * @param smsInfo
     * @return
     */
    public BaseResponse sendSms(SMSInfo smsInfo) {
        //省略短信逻辑处理
        return BaseResponse.ok();
    }

   
}

以上操作执行完毕后，继续通过修改ManagerStrategy管理类来处理，唯一变的需要指定扫描的包，通过扫描包的方式去查找我们的自定义注解，自定义注解执行方式和反射执行差不多，所以这里就不做过多的操作。

本片文章是受网上一个恶搞的图片整理的，知道有更好的处理问题的方式，为什么还要选择用最笨的和最麻烦的方式去处理呢？火车，动车，飞机，到达的目的地是一样。只是速度不一样，火车不是照样有人做吗？看完这篇文章，你有什么想说的，欢迎留言交流。

somnus_小凯

发布了71 篇原创文章 · 获赞 178 · 访问量 60万+

私信关注