多个switch-case分支替代

等彩票中奖

已于 2024-06-20 16:03:43 修改

阅读量467

点赞数 7

分类专栏： java 文章标签： java

于 2024-06-12 10:15:30 首次发布

本文链接：https://blog.youkuaiyun.com/Blessing_L/article/details/139618735

版权

java 专栏收录该内容

4 篇文章

订阅专栏

1.对于多个switch-case的分支，不同分支调用不用方法

 if (2 == taskSign.getReportType()) {
            switch (taskSign.getOperateType()) {
                //1:虚拟电厂聚合运行数据变更上送
                case 1:
                    return vppRealDataService.vppRealDataUp(objData);
                //代理用户运行数据变更上送
                case 2:
                    return vppConsRealDataService.vppConsRealDataUp(objData);
                //聚合单元（分路）运行变更上送
                case 3:
                    return vppShuntRealDataService.vppShuntRealDataUp(objData);
                //设备运行数据变更上送
                case 4:
                    return vppDevRealDataService.vppDevRealDataUp(objData);
            }
            //4表示模型
        } else if (4 == taskSign.getReportType()) {
            switch (taskSign.getOperateType()) {
                // 0：虚拟电厂档案新增
                case 0:
                    return vppDataService.addVppData(objData);
                //1：虚拟电厂档案修改
                case 1:
                    return vppDataService.updateVppData(objData);
                //  2：虚拟电厂档案删除
                case 2:
                    return vppDataService.deleteVppData(objData);
                // 3：代理用户档案新增
                case 3:
                    return vppConsDataService.addConsData(objData);
                //4：代理用户档案修改
                case 4:
                    return vppConsDataService.updateConsData(objData);
                //5：代理用户档案删除
                case 5:
                    return vppConsDataService.deleteConsData(objData);
                //6：聚合单元（分路）档案新增
                case 6:
                    return vppConsShuntDataService.addConsShuntData(objData);
                //7：聚合单元（分路）档案修改
                case 7:
                    return vppConsShuntDataService.updateConsShuntData(objData);
                // 8：聚合单元（分路）档案删除
                case 8:
                    return vppConsShuntDataService.deleteConsShuntData(objData);
                //9：设备档案新增
                case 9:
                    return vppShuntDevDataService.addVppShuntDevData(objData);
                //10：设备档案修改
                case 10:
                    return vppShuntDevDataService.updateVppShuntDevData(objData);
                //11：设备档案删除
                case 11:
                    return vppShuntDevDataService.deleteVppShuntDevData(objData);
            }

1.创建一个获取bean对象的类

package com.cqlvc.vpp.utils;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringContextUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        applicationContext = context;
    }

    /**
     * 静态加载applicationContext
     */

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * 通过反射获取Bean
     *
     * @param requiredType
     * @param <T>
     * @return
     */
    public static <T> T getBean(Class<T> requiredType) {
        return getApplicationContext().getBean(requiredType);
    }

    /**
     * 通过id名获取bean
     *
     * @param name
     * @param <T>
     * @return
     */
    public static <T> T getBean(String name) {
        return (T) getApplicationContext().getBean(name);
    }


}

2.j创建一个类来将if (2 == taskSign.getReportType())下的分支放入map中

package com.cqlvc.vpp.utils;

import com.cqlvc.process.common.core.domain.R;
import com.cqlvc.vpp.domain.dto.record.ObjDataDTO;
import com.cqlvc.vpp.service.record.*;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

@Component
public class VppRealDataUtil {

    Map<Integer, Function<ObjDataDTO, R>> map = new HashMap<>();
    private static VppRealDataUtil vppRealDataUtil;

    private static final VppRealDataService vppRealDataService = SpringContextUtil.getBean(VppRealDataService.class);
    private static final VppConsRealDataService vppConsRealDataService = SpringContextUtil.getBean(VppConsRealDataService.class);
    private static final VppShuntRealDataService vppShuntRealDataService = SpringContextUtil.getBean(VppShuntRealDataService.class);
    private static final VppDevRealDataService vppDevRealDataService = SpringContextUtil.getBean(VppDevRealDataService.class);

    // 使用单例模式实例化当前工厂类实例
    public static VppRealDataUtil getVppRealDataUtil() {
        if (vppRealDataUtil == null) {
            synchronized (VppRealDataUtil.class) {
                if (vppRealDataUtil == null) {
                    vppRealDataUtil = new VppRealDataUtil();
                }
            }
        }
        return vppRealDataUtil;
    }

    VppRealDataUtil() {
        // 初始化定义
        map.put(1, this::function1);
        map.put(2, this::function2);
        map.put(3, this::function3);
        map.put(4, this::function4);
    }

    // 传入type来获取需要执行的方法，type可以使用枚举类的方式来代替
    public Function<ObjDataDTO, R> getFunction(int type) {
        return map.get(type);
    }

    private R function1(ObjDataDTO objData) {
        return vppRealDataService.vppRealDataUp(objData);
    }

    private R function2(ObjDataDTO objData) {
        return vppConsRealDataService.vppConsRealDataUp(objData);
    }

    private R function3(ObjDataDTO objData) {
        return vppShuntRealDataService.vppShuntRealDataUp(objData);
    }

    private R function4(ObjDataDTO objData) {
        return vppDevRealDataService.vppDevRealDataUp(objData);
    }

}

再创建一个类将if (4 == taskSign.getReportType())下的分支放入map中

package com.cqlvc.vpp.utils;

import com.cqlvc.process.common.core.domain.R;
import com.cqlvc.vpp.domain.dto.record.ObjDataDTO;
import com.cqlvc.vpp.service.record.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

@Component
public class VppDataUtil {

    Map<Integer, Function<ObjDataDTO, R>> map = new HashMap<>();
    private static VppDataUtil vppDataUtil;

    private static final VppDataService vppDataService = SpringContextUtil.getBean(VppDataService.class);
    private static final VppConsDataService vppConsDataService = SpringContextUtil.getBean(VppConsDataService.class);
    private static final VppConsShuntDataService vppConsShuntDataService = SpringContextUtil.getBean(VppConsShuntDataService.class);
    private static final VppShuntDevDataService vppShuntDevDataService = SpringContextUtil.getBean(VppShuntDevDataService.class);

    // 使用单例模式实例化当前工厂类实例
    public static VppDataUtil getVppDataUtil() {
        if (vppDataUtil == null) {
            synchronized (VppDataUtil.class) {
                if (vppDataUtil == null) {
                    vppDataUtil = new VppDataUtil();
                }
            }
        }
        return vppDataUtil;
    }

    VppDataUtil() {
        // 初始化定义
        map.put(0, this::function1);
        map.put(1, this::function2);
        map.put(2, this::function3);
        map.put(3, this::function4);
        map.put(4, this::function5);
        map.put(5, this::function6);
        map.put(6, this::function7);
        map.put(7, this::function8);
        map.put(8, this::function9);
        map.put(9, this::function10);
        map.put(10, this::function11);
        map.put(11, this::function12);

    }

    // 传入type来获取需要执行的方法，type可以使用枚举类的方式来代替
    public Function<ObjDataDTO, R> getFunction(int type) {
        return map.get(type);
    }

    private R function1(ObjDataDTO objData) {
        return vppDataService.addVppData(objData);

    }

    private R function2(ObjDataDTO objData) {
        return vppDataService.updateVppData(objData);

    }

    private R function3(ObjDataDTO objData) {
        return vppDataService.deleteVppData(objData);

    }

    private R function4(ObjDataDTO objData) {
        return vppConsDataService.addConsData(objData);
    }

    private R function5(ObjDataDTO objData) {
        return vppConsDataService.updateConsData(objData);
    }

    private R function6(ObjDataDTO objData) {
        return vppConsDataService.deleteConsData(objData);
    }

    private R function7(ObjDataDTO objData) {
        return vppConsShuntDataService.addConsShuntData(objData);
    }

    private R function8(ObjDataDTO objData) {
        return vppConsShuntDataService.updateConsShuntData(objData);
    }

    private R function9(ObjDataDTO objData) {
        return vppConsShuntDataService.deleteConsShuntData(objData);
    }

    private R function10(ObjDataDTO objData) {
        return vppShuntDevDataService.addVppShuntDevData(objData);
    }

    private R function11(ObjDataDTO objData) {
        return vppConsDataService.updateConsData(objData);
    }

    private R function12(ObjDataDTO objData) {
        return vppConsDataService.deleteConsData(objData);
    }


}

最后修改调用方法的类

VppDataUtil vppDataUtil = VppDataUtil.getInstance();
        VppRealDataUtil vppRealDataUtil = VppRealDataUtil.getVppRealDataUtil();
        //2.表示实时数据
        if (2 == taskSign.getReportType()) {
            return vppRealDataUtil.getFunction(taskSign.getOperateType()).apply(objData);
        } else if (4 == taskSign.getReportType()) {
            return vppDataUtil.getFunction(taskSign.getOperateType()).apply(objData);
        }