设计模式4-工厂模式&策略模式

目录

[一 工厂模式](#一 工厂模式)

[1.1 思想](#1.1 思想)

[1.2 案例](#1.2 案例)

[1.2.1 接口](#1.2.1 接口)

[1.2.2 实现类](#1.2.2 实现类)

[1.2.3 工厂类](#1.2.3 工厂类)

[1.2.4 调用](#1.2.4 调用)

[二 策略模式](#二 策略模式)

[2.1 思想](#2.1 思想)

[2.2 案例](#2.2 案例)

[2.2.1 接口](#2.2.1 接口)

[2.2.2 实现类](#2.2.2 实现类)

[2.2.3 策略类](#2.2.3 策略类)

[2.2.4 调用](#2.2.4 调用)

[三 工厂模式+策略模式](#三 工厂模式+策略模式)

[3.1 思想](#3.1 思想)

[3.2 案例](#3.2 案例)

[3.2.1 接口](#3.2.1 接口)

[3.2.2 实现类](#3.2.2 实现类)

[3.2.3 定义Factory](#3.2.3 定义Factory)

[3.2.4 调试](#3.2.4 调试)

一 工厂模式

1.1 思想

* 1.定义一个接口

* 2.定义一个实现类

* 3.定义一个根据传入参数，产生对象的工厂类

* 4.通过工厂类调用具体对象的方法

1.2 案例

1.2.1 接口

public interface BankInfo {
    public  void payMoney();
}

1.2.2 实现类

public class BocBank implements BankInfo{
    @Override
    public void payMoney() {
        System.out.println("中国银行取钱50元");
    }
}

public class IcbcBank implements BankInfo{
    @Override
    public void payMoney() {
        System.out.println("工商银行银行取钱50元");
    }
}

1.2.3 工厂类

public class ObjectFactory {
    public BankInfo buildObjectInfo(String str){
        if (str == null){
            return null;
        }
        else if ("boc".equals(str)) {
            return new BocBank();
        }
        else if ("icbc".equals(str)) {
            return new IcbcBank();
        }
        else {
            return null;
        }
    }
}

1.2.4 调用

/**
 * @ClassName: TestFt
 * @Description: TODO
 * @Author: admin
 * 1.定义一个接口
 * 2.定义一个实现类
 * 3.定义一个根据传入参数，产生对象的工厂类
 * 4.通过工厂类调用具体对象的方法
 *
 *
 * @Date: 2024/08/01 20:56:05 
 * @Version: V1.0
 **/
public class TestFt {
    public static void main(String[] args) {
        ObjectFactory objectFactory = new ObjectFactory();
        BankInfo bankInfoBank =  objectFactory.buildObjectInfo("icbc");
        bankInfoBank.payMoney();
    }
}

二 策略模式

2.1 思想

1.定义一个策略接口，在接口中声明一个行为方法

* 2.定义多个策略实现类，并实现策略接口，重写行为方法，实现各自逻辑

* 3.定义一个context上下文，用于调用具体的策略方法，供客户端使用；通过new context的构造函数传入策略对象，然后通过此对象调用策略行为方法。

2.2 案例

2.2.1 接口

public interface BankInfo {
    public void payMoney(int a,int b);
}

2.2.2 实现类

public class BocBank implements BankInfo{
    @Override
    public void payMoney(int a,int b) {
       System.out.println("中国银行，累加："+(a+b));
    }
}

public class IcbcBank implements BankInfo{
    @Override
    public void payMoney(int a, int b) {
        System.out.println("中国工商银行，扣减："+(a-b));
    }
}

2.2.3 策略类

public class StaragePattern {
    private BankInfo bankInfo;
    public StaragePattern(BankInfo bankInfo) {
       this. bankInfo = bankInfo;
    }
    public  void  contextInfo(int a,int b){
        bankInfo.payMoney(a,b);
    }
}

2.2.4 调用

/**
 * @ClassName: TestS
 * @Description: TODO
 * 1.定义一个策略接口，在接口中声明一个行为方法
 * 2.定义多个策略实现类，并实现策略接口，重写行为方法，实现各自逻辑
 * 3.定义一个context上下文，用于调用具体的策略方法，供客户端使用；通过new context的构造函数传入策略对象，然后通过此对象调用策略行为方法。
 * https://zhuanlan.zhihu.com/p/680317010
 * @Author: admin
 * @Date: 2024/08/02 11:28:34 
 * @Version: V1.0
 **/
public class TestS {
    public static void main(String[] args) {
//        StaragePattern staragePattern = new StaragePattern(new BocBank());
//        staragePattern.contextInfo(30,20);
    }
}

三 工厂模式+策略模式

3.1 思想

1.定义接口实现InitializingBean，重写 void afterPropertiesSet()，在服务启动时候，自动执行子类中的afterPropertiesSet()方法。

3.2 案例

3.2.1 接口

public interface HandlerStrategyFactory  extends InitializingBean {
    void getCoca(String parameter);
}

3.2.2 实现类

@Component
public class CocaHandlerV2 implements HandlerStrategyFactory{
    @Override
    public void getCoca(String parameter)
    {
        System.out.println("我是可口可乐-策略+工厂 "+parameter);
    }

    @Override
    public void afterPropertiesSet() throws Exception
    {
        //K          //V
        Factory.register("Coca",this);
    }
}

@Component
public class PepsiHandlerV2 implements HandlerStrategyFactory{
    @Override
    public void getCoca(String parameter)
    {
        System.out.println("我是百事可乐-策略+工厂 "+parameter);
    }

    @Override
    public void afterPropertiesSet() throws Exception
    {
        Factory.register("Pepsi",this);
    }
}

3.2.3 定义Factory

public class Factory {
    private static Map<String, HandlerStrategyFactory> strategyMap = new ConcurrentHashMap<>();

    public static HandlerStrategyFactory getInvokeStrategy(String str)
    {
        return strategyMap.get(str);
    }

    public static void register(String str ,HandlerStrategyFactory handler)
    {
        System.out.println("str: "+str+"\t handler: "+handler);
        if (null == str || null == handler)
        {
            return;
        }
        strategyMap.put(str,handler);
    }
}

3.2.4 调试

@SpringBootTest
public class DesignPatternTest
{
    /**
     * 策略+工厂V2
     */
    @Test
    public void methodV2()
    {
        String parameter = "Coca";

        HandlerStrategyFactory invokeStrategy = Factory.getInvokeStrategy(parameter);

        invokeStrategy.getCoca(parameter);
    }
}

结果图：