策略模式+工厂解决冗余代码

作者: 圆企鹅i | 来源:发表于2020-12-12 14:05 被阅读0次

策略模式

策略模式其实就是把方法抽取出来
让代码里面的重复代码少一点看着舒服点单独用的话有点丑陋

接口类继承那个暂时忽略

extends InitializingBean 必须重写第一个方法会在bean初始化执行

/**
 * @Desciption: 策略模式实现方式   InitializingBean（初始化bean的时候都会执行该接口的afterPropertiesSet方法）
 *              比 @Bean (initMethod = "方法")初始化方法执行更早
 * @Auther: ZhangXueCheng4441
 * @Date:2020/12/12/012 15:11
 */
public interface Handler extends InitializingBean {
    void method1();
    void method2();
    void method3();
    void method4();
}

接口类具体接口类

public interface Strategy2Handler extends Handler {
    //可以写上你特有的方法哟 //但是工厂那边会无法调用

}

具体功能实现

暂时忽略注册方法
afterPropertiesSet这个方法就是能够在初始化这个bean的时候把这个策略注册进去

@Component
public class Strategy2_demo implements Strategy2Handler {

    private static Logger LOG = LoggerFactory.getLogger(Strategy2_demo.class);

    @Override
    public void method1() {
        LOG.info(GuiHuaFu.横线 +"策略方法2：AAAAAAAAAA");
    }

    @Override
    public void method2() {
        LOG.info(GuiHuaFu.横线 +"策略方法2：BBBBBBBBBB");
    }

    @Override
    public void method3() {
        LOG.info(GuiHuaFu.横线 +"策略方法2：CCCCCCCCCCC");
    }

    @Override
    public void method4() {
        LOG.info(GuiHuaFu.横线 +"策略方法2：DDDDDDDDDDD");
    }
    /**
     * 把此方法注册到工厂中去
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        Factory1.register("strategy2",this);
    }
}

在你要用对应的策略方法
就调对应的接口然后进行实现就可以了但是策略多起来就会很不爽所以就加入工厂丝滑一丢丢

工厂设计模式

工厂设计模式呢其实就是整一个工厂
你需要什么东西叫一声工厂就吧唧把一个东西给你生产出来
没有工厂的话你使用策略得写if else 去实现
工厂定义得好那么用户直接输入需要的东西工厂直接收到就能吐回去不用我们加工if else了

工厂类

设置一个容器初始化bean的时候就把策略方法放进去
在要使用的时候直接用工厂方法根据名字调用方法

/**
 * @Desciption:
 * @Auther: ZhangXueCheng4441
 * @Date:2020/12/12/012 16:28
 */
public class Factory1 {

    /**
     * 服务启动时 就生成一个存放策略方法的map （会一直占据内存，但是调用确实很快）
     */
    private static Map<String, Handler> strategyMap = MapUtil.newHashMap();

    /**
     * @param str map-key 策略方法名字
     * @return map-value 对应名字的策略方法
     */
    public static Handler getInvokeStategy(String str) {
        return strategyMap.get(str);
    }

    /**
     * 把策略方法 注册到工厂里面
     * @param str map-key 策略方法名字
     * @param handler map-value 对应名字的策略方法
     */
    public static void register(String str, Handler handler) {
        if (StrUtil.isEmpty(str) || null == handler) {
            return;
        }
        strategyMap.put(str, handler);
    }

}

核心测试

能够解决我们大部分冗余的问题
但是有一点点不爽的就是因为handler是个接口里面方法全部要重写
不然 Factory1多态返回就不能调用子类一些方法了
每个策略里面都要重写接口的所有方法当然也可以返回空源码里面也很多这样做的
见仁见智吧
源码里面也有用模板设计方法的使用抽象类来解决
（小声bb 但是我觉得继承抽象类就把我们难得的一次继承机会用掉了很可惜
设计上就只能在父类里面去继承别的功能类了有点小难受

    /**
     * 测试简单的策略方法+简单的工厂模式
     * 适合场景：
     *        出现大量冗余的代码 可以抽取成策略 （其实就是简单的抽取方法）
     *        增加工厂模式 方便在大量的方法中 准确找出你需要的方法群
     * 举个栗子：
     *        现在有 处理面条的流程 过程及其复杂  要做一万碗面条（策略模式抽取 每次调用策略）
     *        现在有二十种不同的面条 每个操作都不一样 要每种做一万碗（工厂模式选择面条 做面方法放在策略模式）
     */
    @Test
    public void doStrategy123(){
        try {
            Handler handler = Factory1.getInvokeStategy("strategy1");//选择面条种类
            handler.method1();//揉面
            handler.method2();//做面条
            handler.method3();//下面/doge
        } catch (Exception e) {
            e.printStackTrace();//很容易空指针
        }
    }

模板设计模式

其实也就是用抽象类
可以要求出子类必须实现的方法
也可以定义子类爱重写不重写干爷屁事的方法
工厂调用的时候就可以调用所有子类的方法了只不过调不到就抛异常而已

抽象类定义规则


/**
 * @Desciption: 模板设计方法
 * @Auther: ZhangXueCheng4441
 * @Date:2020/12/12/012 16:32
 */
public abstract class AbstractHandler implements InitializingBean {
    public abstract void method1();

    public abstract void method2();
    //抽象方法 子类必须重写 比较面条必须得揉面呀
    public abstract void method3();

    public abstract void method4();

    //可以写上你特有的方法哟
    public void method5() {
        throw new UnsupportedOperationException();
    }

    //子类可以选择重写 也可以选择不重写 不重写就调用我给你写到的异常（不支持操作）
    public void method6() {
        throw new UnsupportedOperationException();
    }

    //就是为了在多态的时候 我可以正常调用方法1-8
    public void method7() {
        throw new UnsupportedOperationException();
    }

    public void method8() {
        throw new UnsupportedOperationException();
    }
}

子类抽象类再次定义规则

/**
 * @Desciption: 策略模式实现方式   InitializingBean（初始化bean的时候都会执行该接口的afterPropertiesSet方法）
 *              比 @Bean (initMethod = "方法")初始化方法执行更早
 * @Auther: ZhangXueCheng4441
 * @Date:2020/12/12/012 15:11
 */
public abstract class Strategy5AbstractHandler extends AbstractHandler {
    public abstract void method1();

    public abstract void method2();

    public abstract void method3();

    public abstract void method4();

    public abstract void method7();

    public abstract void method8();
}

配置类

这里我换了一种方式本来这个是抽象的map 我换spring容器托管的map 发现有也顶用

@Configuration
public class Config {
    @Bean("factoryHandlerMap")
    public HashMap<String, AbstractHandler> handlerHashMap(){
        HashMap<String, AbstractHandler> handlerHashMap = MapUtil.newHashMap();
        return handlerHashMap;
    }
}

实际业务类

/**
 * @Desciption: 类似于servic的写法
 * @Auther: ZhangXueCheng4441
 * @Date:2020/12/12/012 15:16
 */
@Component
public class Strategy5_demo extends Strategy5AbstractHandler {

    private static Logger LOG = LoggerFactory.getLogger(Strategy5_demo.class);
    @Resource(name = "factoryHandlerMap")
    private HashMap factoryHandlerMap;

    @Override
    public void method1() {
        LOG.info(GuiHuaFu.横线 +"策略方法5：AAAAAAAAAA");
    }

    @Override
    public void method2() {
        LOG.info(GuiHuaFu.横线 +"策略方法5：BBBBBBBBBB");
    }

    @Override
    public void method3() {
        LOG.info(GuiHuaFu.横线 +"策略方法5：CCCCCCCCCCC");
    }

    @Override
    public void method4() {
        LOG.info(GuiHuaFu.横线 +"策略方法5：DDDDDDDDDDD");
    }

    @Override
    public void method7() {
        LOG.info(GuiHuaFu.横线 +"策略方法5：EEEEEEEEEEE");
    }

    @Override
    public void method8() {
        LOG.info(GuiHuaFu.横线 +"策略方法5：FFFFFFFFFFF");
    }

    /**
     * 把此方法注册到工厂中去
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
       // Factory2.register("strategy5",this);
        factoryHandlerMap.put("strategy5",this);
    }
}

跑测试


    @Test
    public void doStrategy4(){
        try {
            AbstractHandler handler = Factory2.getInvokeStategy("strategy4");//选择面条种类
            handler.method1();//揉面
            handler.method2();//做面条
            handler.method3();//下面/doge
            handler.method5();//辣椒
            handler.method6();//胡椒
            handler.method7();//盐//没有这个方法 报错
        } catch (Exception e) {
            e.printStackTrace();//很容易空指针
        }
    }

    @Resource
    private HashMap factoryHandlerMap;
    @Test
    public void doStrategy5InBeanMap(){
        try {
            AbstractHandler handler = (AbstractHandler) factoryHandlerMap.get("strategy5");//选择面条种类
            handler.method1();//揉面
            handler.method2();//做面条
            handler.method3();//下面/doge
            handler.method7();//胡椒
            handler.method8();//热油
            handler.method6();//辣椒//子类没有这个方法 报错
        } catch (Exception e) {
            e.printStackTrace();//很容易空指针
        }
    }

其实这个操作还是有的粗糙都是用原生的api进行操作

b站有老哥说这种方法也能实现注册这样估计就不用实现 InitializingBean 的接口了
@postconstruct顺序好像在InitializingBean 之后毕竟叫构造后注解

    /**
     * 把此方法注册到工厂中去
     *  todo @autowire list<handler> list
     *  todo  @postconstruct 用初始化bean执行的注解 也可以实现
     * @throws Exception
     */

或者其实解决冗余代码更优秀的解决方案应该还是spring的AOP
直接根据方法名就可以直接织入对应的策略方法

代码
https://github.com/opop32165455/zeroBeginning.git
里面有个初始化的空项目用来从零开始开发已经搭好了mybatis-plus+sql监视器的架子了开箱即用

网友评论

设计模式

本文标题：策略模式+工厂解决冗余代码

本文链接：https://www.haomeiwen.com/subject/sugegktx.html

延伸阅读

深度阅读

您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

策略模式+工厂解决冗余代码

策略模式

接口类继承那个暂时忽略

接口类具体接口类

具体功能实现

工厂设计模式

工厂类

核心测试

模板设计模式

抽象类定义规则

子类抽象类再次定义规则

配置类

实际业务类

跑测试

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

设计模式

策略模式+工厂 解决冗余代码

策略模式

接口类 继承那个暂时忽略

接口类具体接口类

具体功能实现

工厂设计模式

工厂类

核心测试

模板设计模式

抽象类定义规则

子类抽象类再次定义规则

配置类

实际业务类

跑测试

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

设计模式

策略模式+工厂解决冗余代码

接口类继承那个暂时忽略