设计模式之策略模式

设计模式之策略模式

1. 概括

如果定义了一系列的单独的算法，可以把每个算法封装起来，到一个类，或者方法函数，使每个算法之间可以相互替换
在实际的编写中，经常使用这种模式只是自己没有意识到，比如java中的lambda表达式，js 回调函数等
回调函数或lambda中内容就是我们自己独立的算法

2. 结构

• 抽象策略：策略的通用接口，声明了一个实现具体算法的方法
• 具体策略：实现策略接口，重写其中的方法，实现各种不同的”算法“
• 上下文环境：对于具体策略的引用，可以是一个单独的类，类中调用抽象策略接口；可以是一个方法，策略是方法参数

3. 使用场景

1. 当你想要在不同的代码运行中使用不同的算法变体时
2. 如果不是特别复杂的算法，建议使用lambda和回调函数的形式，使代码更加的简洁

4. 优缺点

• 优点：
  • 策略算法之间可以自由的切换
  • 开闭原则
  • 依赖倒转
• 缺点：
  • 每写一种算法，要引入新的类或接口
  • 客户端要知道每个策略的详情
  • 可以使用匿名函数，匿名类，lambad避免

5. 实现

• 声明一个策略接口

public interface Strategy {
    void show();
}

• 具体策略

public class StrategyA implements Strategy{
    @Override
    public void show() {
        System.out.println("策略A");
    }
}

public class StrategyB implements Strategy{
    @Override
    public void show() {
        System.out.println("策略B");
    }
}

• 上下文环境，可以是一个类，也可以是一个方法

public class Envir {

    public Strategy strategy;
    
    public Envir() {
    }
    
    public Envir(Strategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    // 环境方法，具体策略的调用
    public void showStrategy() {
        strategy.show();
    }
}

public static void staticShowStrategy(Strategy strategy) {
    // 回调
    strategy.show();
}

• 调用

public class Client {
    public static void main(String[] args) {
        Envir env = new Envir();
//        env.setStrategy(new StrategyA());
//        env.setStrategy(new StrategyB());
        env.setStrategy(new Strategy() {
            @Override
            public void show() {
                System.out.println("策略C");
            }
        });

        env.showStrategy();

        staticShowStrategy(new Strategy() {
            @Override
            public void show() {
                System.out.println("策略D");
            }
        });

        callback(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s.charAt(0));
            }
        });

    }

    public static void staticShowStrategy(Strategy strategy) {
        // 回调
        strategy.show();
    }

    public static void callback(Consumer<String> consumer) {
        consumer.accept("abcde");
    }
}

6. 回调函数

说到回调函数，就不得不说javascript，js可谓是把回调玩儿的炉火纯青， 因为js是弱数据类型，并且可以把函数以参数的形式传递，所以在js中使用 回调 是既简单又简洁
比如，在jQuery库中的ajax方法就用了回调函数
手工实现一个

// fn 就是传过来的策略方法
function get(url,fn,async) {
    var xhr = new XMLHttpRequest();
    xhr.open("GET",url,async);
    xhr.onreadystatechange = () => {
        if(xhr.readyState === 4 && xhr.status >= 200 && xhr.status < 300) {
            fn(JSON.parse(xhr.responseText));
        }
    }
    xhr.send()
}
function post(url,data,fn,async) {
    var xhr = new XMLHttpRequest();
    xhr.open("POST",url,async);
    xhr.onreadystatechange = () => {
        if(xhr.readyState === 4 && xhr.status >= 200 && xhr.status < 300) {
            fn(JSON.parse(xhr.responseText));
        }
    }
    xhr.setRequestHeader('Content-type','application/x-www-form-urlencoded');
    xhr.send(data)
}
// 其中 函数`function(data) { ... }`，就是具体的策略
get("http://wthrcdn.etouch.cn/weather_mini?city=beijing",function(data) {
    console.log(data);
},true)

post("http://www.nmc.cn/rest/weather","stationid=54616&_=1646997794950",function(data) {
    console.log(data);
},true)

在java中不能把方法以参数的形式传递，所以不得不用【接口 + 实现类】的方式，来实现回调，所以在java中使用回调还是不太方便的，好在lambda的出现使得代码简洁许多