设计模式大总结（四）：适配器模式

前言

今天准备聊聊适配器模式，适配器模式相比之前的观察者模式或者是代理模式，我觉得思路的复杂度差不多，但是实现起来会稍微复杂一点。

适配器是什么呢？

很简单，就以我现在身边的东西：电脑的适配器，手机的适配器，我们习惯的叫他们电源。

大家都知道实际上电压都不是非常标准的220V，因为要把电输送到很远的地方，发电站提供的电压是非常高的，传输过程中还会损耗，所以我们平时使用的电压都是经过电压的转换的（例如变压器），有些对电压要求比较高的设备，例如电脑，手机，他们的电源都会有简单的电压适配。

我们就是要把这个原理带到程序中去。

正文

说到Android的适配模式，那肯定就是典型的ListView，RecyclerView的使用，你只要实现最重要的几个方法，保证转换过程的执行就OK了。如果你还没弄清楚适配模式，先继承往下看。

那么我们就来模拟一下电源从传输到使用的过程，我先画了一张原型图：



里面的描述我们每一个环节需要实现的重要功能和作用，这里就不再啰嗦了。但是从开发的角度还是要简单分析一下：

1、适配器模式，最好是以SDK开发的角度来分析，因为最终暴露给使用者的，只有基础适配器和适配器的使用者。

2、当电压发生了变化，需要通知使用做相应的调整，这里我们使用观察者模式。

接下来我们按照原型图，开始创建需要使用的类：

电压提供者类和标准的电压类：

/**
* Created by li.zhipeng on 2017/8/22.
* <p>
*   超高电压类, 不能被耗电器直接使用
*/

public class Voltage1000 {

private int voltage;

public Voltage1000(int voltage){
this.voltage = voltage;
}

public int getVoltage(){
return this.voltage;
}

public void output() {
Log.e("lzp", "输出了" + voltage + "V的电压, 危险请勿直接使用");
}

}

/**
* Created by li.zhipeng on 2017/8/22.
* <p>
* 标准的电压类，voltage可以随意设置
*/

public class Voltage {

private int voltage;

public Voltage(int voltage) {
this.voltage = voltage;
}

public void output() {
Log.e("lzp", "输出了" + voltage + "V的电压，可以供家庭使用");
}
}

适配器接口类：

/**
* Created by li.zhipeng on 2017/8/22.
*
*      电压的被观察者，用于通知电压发生了变化
*/
public class VoltageObservable extends Observable {

/**
* 通知观察者，已经发生了变化
* */
public void notifyVoltageChanged(){
setChanged();
notifyObservers();
}
}

/**
* Created by li.zhipeng on 2017/8/22.
* <p>
* 这是电压的基本接口
*/

public interface VoltageImpl {

/**
* 输出电压，负责转换的过程
*/
Voltage convertVoltage(Voltage1000 voltage);
}

基础的电压适配器：

/**
* Created by li.zhipeng on 2017/8/22.
*
*      电压的基础适配器
*/

public abstract class BaseVoltageAdapter implements VoltageImpl {

/**
*
* 要输出的电压
*/
private int voltage;

/**
* 通知的回调，这里可以使用观察者模式，模仿BaseAdapter
* */
private VoltageObservable observable;

/**
* 获取当前的电压
* */
public int getVoltage() {
return voltage;
}

/**
* 设置电压
* */
public void setVoltage(int voltage) {
this.voltage = voltage;
}

/**
* 构造方法
* */
public BaseVoltageAdapter(int voltage){
this.voltage = voltage;
observable = new VoltageObservable();
}

/**
* 当电压发生了变化，通知使用者
* */
public void notifiVoltageChanged(){
observable.notifyVoltageChanged();
}

/**
* 获取被观察者
* */
public VoltageObservable getVoltageObservable(){
return this.observable;
}

}

耗电器类：

/**
* Created by li.zhipeng on 2017/8/22.
* <p>
* 耗电设备类
*/

public class VoltageMachine {

/**
* 初始电压
*/
private Voltage1000 voltage1000;

/**
* 要输出电压的次数
*/
private int outputCount;

/**
* 电压的适配器
*/
private BaseVoltageAdapter baseVoltageAdapter;

/**
* 构造方法
* */
public VoltageMachine(Voltage1000 voltage1000, int outputCount){
this.voltage1000 = voltage1000;
this.outputCount = outputCount;
}

/**
* 循环输出电压
*/
public void outputVotalge() {
for (int i = 0; i < outputCount; i++) {
Voltage voltage = baseVoltageAdapter.convertVoltage(voltage1000);
voltage.output();
}
}

/**
* 设置适配器
*/
public BaseVoltageAdapter getAdapter() {
return baseVoltageAdapter;
}

/**
* 获取适配器
*/
public void setAdapter(BaseVoltageAdapter baseVoltageAdapter) {
// 先解绑之前的的被观察者
unregisterVoltageObserable();
// 设置适配器
this.baseVoltageAdapter = baseVoltageAdapter;
// 注册新的被观察者
registerVoltageObserable();

// 开始输出电压
outputVotalge();
}

/**
* 获取输出次数
*/
public int getOutputCount() {
return outputCount;
}

/**
* 设置输出次数
*/
public void setOutputCount(int outputCount) {
this.outputCount = outputCount;
}

/**
* 定义当电压发生变化的
*/
private Observer observer = new Observer() {
@Override
public void update(Observable o, Object arg) {
outputVotalge();
}
};

/**
* 注册适配器的观察者
*/
private void registerVoltageObserable() {
if (baseVoltageAdapter != null) {
baseVoltageAdapter.getVoltageObservable().addObserver(observer);
}
}

/**
* 解绑适配器的观察者
*/
private void unregisterVoltageObserable() {
if (baseVoltageAdapter != null) {
baseVoltageAdapter.getVoltageObservable().deleteObserver(observer);
}
}
}

基础的类我们已经都贴出来了，主要有以下几点需要注意以下：

1、在setAdapter时，要保证只注册了一个被观察者，否则可能会发生无用的更新，甚至程序运行的异常。

2、当耗电器使用结束，setAdapter（null），解除耦合，并且解绑被观察者。真正的开发中，防止内存泄漏这里要尤其注意。

3、个别方法使用了private，注意sdk开发时有些方法不要开放，这个尺度根据自己的需求来权衡。

ok，现在终于到了应用层的开发，这个就简单多了：

为了让打印结果好区分，我简单的重写了output方法，增加一条分隔线

/**
* Created by li.zhipeng on 2017/8/22.
*
*      这是一个大型的耗电机器
*/

public class LargePowerMachine extends VoltageMachine{

/**
* 构造方法
*
* @param voltage1000
* @param outputCount
*/
public LargePowerMachine(Voltage1000 voltage1000, int outputCount) {
super(voltage1000, outputCount);
}

/**
*  自定义输出的逻辑
* */
@Override
public void outputVotalge() {
super.outputVotalge();
// 输出结束的时候，再输出一条分界线
Log.e("lzp", "-------------------");
}
}

实现自定义的适配器：

/**
* Created by li.zhipeng on 2017/8/22.
*
*      自定义适配器类
*/

public class MyVoltageAdapter extends BaseVoltageAdapter {

/**
* 构造方法
*
* @param voltage
*/
public MyVoltageAdapter(int voltage) {
super(voltage);
}

/**
* 重写电压的转换方法
* */
@Override
public Voltage convertVoltage(Voltage1000 voltage) {
// 这里进行了电压之间的转换
// 假设这里有很多很复杂的操作
// 我这里啥也没写
return new Voltage(getVoltage());
}
}

最后是MainActivity的代码：

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

// 创建一个耗电器, 初始电压是1000,需要输出5次电压
LargePowerMachine largePowerMachine = new LargePowerMachine(new Voltage1000(1000), 5);
// 添加一个适配器,这里我们需要220V的电压
final MyVoltageAdapter myVoltageAdapter = new MyVoltageAdapter(220);
largePowerMachine.setAdapter(myVoltageAdapter);

//
findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 需求发生变化，这里突然要输出100V的电压
myVoltageAdapter.setVoltage(110);
myVoltageAdapter.notifiVoltageChanged();
}
});
}
}

输出结果：

探讨适配器模式的使用场景

经过一个小demo，我们对适配器的理解又提升了一个档次，首先我们对他进行一个综合评价：

1、开发的成本比较高，为了完成适配模式，我们定义了比较多的类。

2、可以通过泛型适当的较少适配器工作量。

3、适配器模式只关心转换结果，不关心转换过程，处于整个使用过程的中间。

那么他应该在什么样的场景使用呢？我个人有以下几种理解：

1、转换源和转换结果的类型长期稳定，不能发生大的变动，通过适配器模式，为提供者提供不同的解决方案。

2、对于转换的结果比较敏感，当结果发生改变时，要及时的应对。

3、只关心转换的结果，不关心来源和如何使用。

要说平时到底哪里用的多，我现在只能想起来模块开发，其实模块开发也是SDK开发的一种，只负责提供服务，具体要什么样的结果，让使用者自己来定义，例如我提供的User信息，你想要怎么处理User都可以，与我无关。

总之，当你要开发一个稳定的模块，并且要为其他人提供相同类型的服务，我希望你能够先思考适配模式。

总结

适配模式就是这样了，应用开发这个模式我确实用的不多，如果有一天你要开发SDK了，千万别忘了他。