设计模式之适配器模式

时间  2020-06-09
标签 设计 模式 适配器 繁體版
原文   原文链接

适配器模式

1.基本介绍

  • 适配器模式（Adapter Pattern）将某个类的接口转换成客户端指望的另外一个接口表示，主要目的是兼容性，让本来因接口不匹配不能工做的两个类能够协同工做，其别名为包装器（Wrapper）
  • 适配器模式属于结构型模式
  • 分为三类：类配置器模式、对象配置器模式、接口适配器模式

2.工做原理

  • 适配器模式：将一个类的接口转换为另外一个接口，让本来接口不兼容的类能够兼容
  • 从用户的角度看不到被适配者，是解耦的
  • 用户调用适配器转化出来的目标接口方法，适配器再调用被适配者的相关接口方法
  • 用户收到反馈结果，感受只是和目标接口交互

3.类适配器

1.介绍

  • Adapter类，经过继承src类，实现dst类接口，完成src->dst的适配java

  • 做用：将本来不兼容的接口融合在一块儿工做spring

2. 工做原理图

3.代码实现示例

定义Voltage220Vmvc

//被适配对象：模拟220V的插座
public class Voltage220V {
	private int src = 220;
	//输出220V电压
	public int output220V() {
		System.out.println("电压="+src+"伏");
		return src;
	}
}

定义一个适合用户使用的接口app

public interface IVoltage5V {
	public int output5V();
}

由一个适配器来继承被适配的对象Voltage220V，同时实现用户适合的接口，在这之中进行转换框架

public class VoltageAdapter extends Voltage220V implements IVoltage5V {
	@Override
	public int output5V() {
		// TODO Auto-generated method stub
		int src = output220V();
		//模拟src->dst的适配
		int dst =src/44;
		return dst;
	}
}

定义一个phone，这里充当适配器模式中的使用者，所以在这里聚合接口IVoltage5V，遵照ide

依赖倒置原则this

public class Phone {
    //定义手机的充电功能，聚合一个充电器接口
	public void charging(IVoltage5V iVoltage5V) {
		int src = iVoltage5V.output5V();
		System.out.println("输出"+src+"V");
	}
}

最后由用户来决定用哪一个适配器来对手机进行充电spa

public class client {
	public static void main(String[] args) {
		Phone phone = new Phone();
        //使用VoltageAdapter充电器对手机进行充电
		phone.charging(new VoltageAdapter());
	}
}

以上为对工做原理图的实现，参考该例子的实现思想和结构code

4.类配置器小结

  • java是单继承机制，因此类适配器须要继承src类这一点是一个缺点，并且这要求dst必须是一个接口，有必定局限性
  • src类的方法都在Adapter中暴露出来
  • 优势：Adapter继承了src类，因此它能够根据需求重写src类的方法，使得Adapter的灵活性增长了

4.对象适配器

1.介绍

  • 与类适配器的思想相同，不一样的是它对Adapter类作修改，不是继承src类，而是聚合src对象，持有他的实例，以解决兼容性的问题
  • 根据"合成复用原则"，在系统中尽可能使用关联关系来替代继承关系
  • 适配器模式中比较经常使用的一种

2.工做原理图

3.代码示例

VoltageAdapter再也不继承Voltage220V，而是直接聚合对象

public class VoltageAdapter implements IVoltage5V {

    //聚合Voltage220V对象
	private Voltage220V voltage;
	public VoltageAdapter(Voltage220V voltage) {
		// TODO Auto-generated constructor stub
		this.voltage = voltage;
	}
	
	@Override
	public int output5V() {
		// TODO Auto-generated method stub
        int dst=0;
        if(voltage!=null){
            int src = voltage.output220V();
            //模拟src->dst 
            dst =src/44;
        }
        	return dst;
	}
}

使用上

public class client {
	public static void main(String[] args) {
		Phone phone = new Phone();
        //构造时须要传入被适配对象
		phone.charging(new VoltageAdapter(new Voltage220V()));
	}
}

4.对象适配器小结

  • 使用聚合代替了继承，解决了类适配器必须继承src的局限性问题，也再也不要求dst必须是接口
  • 使得更加灵活

5.接口适配器（缺省适配器）

1.定义

  • 当不须要实现接口中的所有方法时，只要定义一个抽象类继承接口，给每个方法默认实现（空方法），以后该抽象类的子类只须要有选择性的重写某些方法来实现需求
  • 适用于一个接口不想使用其全部的方法

2.工做图解

3.代码示例

定义接口

public interface Interface2 {
	public void m1();
	public void m2();
	public void m3();	
}

默认实现接口中的方法

public class AbsA implements Interface2{
	@Override
	public void m1() {
		// TODO Auto-generated method stub
	}
	@Override
	public void m2() {
		// TODO Auto-generated method stub	
	}
	@Override
	public void m3() {
		// TODO Auto-generated method stub
	}
}

使用适配器时继承AbsA或者在建立AbsA的时候能够选择性的重写某些方法

//建立对象的时候重写
AbsA a = new AbsA() {
    @Override
    public void m2() {
        // TODO Auto-generated method stub
        //进行方法实现
        super.m2();
    }
};

6.适配器模式在springMVC框架中的分析

模拟适配器调用流程

1.类图分析以下

DispatchServlet中首先获得一个Controller类型，咱们经过该Controller类型来获取HandlerAdapter的对应适配器类型，获得这个适配器以后咱们就能够调用对应的Controller的doHandler()方法

2.本身编写代码模拟实现

  1. 定义HandlerAdapter
//定义一个Adapter接口
public interface HandlerAdapter {
    //判断是否为对应的Controller类型
	public boolean supports(Object handler);
    //执行对应的控制器方法
	public void handler(Object handler);
}

//实现多种适配器类
class SimpleHandlerAdapter implements HandlerAdapter{
	@Override
	public boolean supports(Object handler) {
		return (handler instanceof SimpleController);
	}
	@Override
	public void handler(Object handler) {	
		((SimpleController)handler).doSimpleHandler();
	}
}
class HttpHandlerAdapter implements HandlerAdapter{

	//判断是否为对应的Controller类型
	@Override
	public boolean supports(Object handler) {
		return (handler instanceof HttpController);
	}
	@Override
	public void handler(Object handler) {
		//执行对应的控制器方法
		((HttpController)handler).doHttpHandler();
	}
}

class AnnotationHandlerAdapter implements HandlerAdapter{

	//判断是否为对应的Controller类型
	@Override
	public boolean supports(Object handler) {
		return (handler instanceof AnnotationController);
	}
	@Override
	public void handler(Object handler) {
		//执行对应的控制器方法
		((AnnotationController)handler).doAnnotationHandler();
	}
}
  1. 定义Controller
//模拟Controller的实现和各自的doHandler()方法
public interface Controller {

}

class HttpController implements Controller{
	public void doHttpHandler() {
		System.out.println("HttpHandler....");
	}
}
class AnnotationController implements Controller{
	public void doAnnotationHandler() {
		System.out.println("AnnotationHandler....");
	}
}
class SimpleController implements Controller{
	public void doSimpleHandler() {
		System.out.println("SimpleHandler....");
	}
}
  1. DispatchServlet类，这里先用list来模拟SpringMVC中配置的全部适配器，doDispatch中模拟SpringMVC从request中获取handler对象
public class DispatchServlet {
	//模拟配置适配器
	public static List<HandlerAdapter> handlerAdapters= new ArrayList<>();
	static {
		handlerAdapters.add(new AnnotationHandlerAdapter());
		handlerAdapters.add(new HttpHandlerAdapter());
		handlerAdapters.add(new SimpleHandlerAdapter());
	}
	
	public void doDispatch() {
		//模拟SpringMVC从request中获取handler的对象
		
		//适配器在这里能够获取匹配的Controller
		AnnotationController controller = new AnnotationController();
//		SimpleController controller = new SimpleController();
//		HttpController controller = new HttpController();
		
		//经过controller获取适配器
		HandlerAdapter adapter = getHandler(controller);
		
		//经过适配器执行对应的Controller方法
		adapter.handler(controller);
		
	}

	private HandlerAdapter getHandler(Controller controller) {
		// 模拟源码：经过遍历的方式来匹配适配与controller类型
		for(HandlerAdapter handler : this.handlerAdapters) {
			if(handler.supports(controller)) {
				return handler;
			}
		}
		return null;
	}
	
	public static void main(String[] args) {
        //模拟调用
		new DispatchServlet().doDispatch();   //输出AnnotationHandler......
	}
}

小结

能够发如今doDispatch中咱们获取适配器的时候传入了什么类型的Controller就可以获取对应的适配器，也自动的去调用对应的Controller执行Handler，在这一步彻底能够适应传入的Controller，不会由于传入不一样的Controller代码失去做用，增长了灵活性，并且**扩展功能时只须要增长对应的适配器模块和Controller模块，配置在SpringMVC中，就同样能够被使用，代码不用进行改动，这就是适配器模式的关键做用

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程