策略模式
策略模式 其实就是把方法抽取出来
让代码里面的重复代码少一点 看着舒服点 单独用的话有点丑陋
接口类 继承那个暂时忽略
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监视器的架子了 开箱即用
