Java 设计模式 适配器模式

        当现有的某个类的接口不能满足客户所需要的接口，需要将这个类的接口转换为客户想要的接口，可以使用适配器模式。这相当于给接口做了一个适配，使这个接口可以在现有的模块内可以使用。

       举一个简单的例子，我们国家家用电网提供的是220V交流电，对于台式机而言，主板需要12V直流电，当然不能直接拿交流电来使用啦。所以主机都有一个电源适配器，将220V 交流电 转换成 12V直流电。这个电源适配器就是从中间起到了一个转换的作用。

看一下类图：

 

package com.lou.adapter.instance;

public interface AbstractComputerPower {

	/*
	 * 直流电电源 提供直流电
	 */
	public String provideDirectCurrent();
}

 

package com.lou.adapter.instance;

public interface AbstractNationalPower {

	/*
	 * 国家电网提供交流电
	 */
	public String provideAlternatableCurrent();
}

 

package com.lou.adapter.instance;

public class ComputerPowerAdapter implements AbstractComputerPower {

	private AbstractNationalPower power = new ChinesePower();
	@Override
	public String provideDirectCurrent() {
		
		String nationalPower = power.provideAlternatableCurrent();
		return transfer(nationalPower);
	}

	private String transfer(String nationalPower)
	{
		System.out.println( "对交流电整流，变压，输出直流电");
		return "12V 直流电";
	}
}

 

package com.lou.adapter.instance;

public class Client {

	public static void main(String[] args) {
		AbstractComputerPower  computerPower = new ComputerPowerAdapter();
		computerPower.provideDirectCurrent();
	}
}

 

package com.lou.adapter.instance;

public class ChinesePower implements AbstractNationalPower {

	@Override
	public String provideAlternatableCurrent() {
		return "220V 交流电。";
	}
}

综上，适配器模式是指：

         将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不 兼容 而不能一起工作的那些类可以一起工作。——Gang of Four

适配器的通用模型为：

 

 

 适配器模式最后真正完成业务的还是靠原来的接口，adapter从中间起到了转换，代理的作用。

 

再举一个更实际的例子：

在 项目中会涉及到查询用户信息的相关操作，在当前系统内，既有的底层提供的用户信息接口如下：

package com.lou.patterns.adapter;

public interface UserInfo {

	public String getUserName();
	
	public String getUserId();
	
	public Integer getUserAge();
	
	public String getUserProvince();
	
	public String getUserCity();
	
	public String getUserStreet();
	
}

当前系统内，用户查询接口 可以查询 用户名，用户id,年龄 ,用户所在的省份，所在的城市，所在的街道。

但是现在系统的另外一个模块定义的用户查询 接口如下：

package com.lou.patterns.adapter;

public interface UserInformation {

	public String getUserName();
	
	public String getUserId();
	
	public Integer getUserAge();
         //UserAddredss = province + city + street;	
         public String getUserAddress();
    
}

即：这个模块定义的用户查询接口应该为 查询用户名，用户id,用户年龄，用户的地址
现在就会存在问题：因为这个模块定义的接口和底层定义的接口不兼容，无法将底层的UserInfo 实现类直接拿来使用，现在要在这两个接口之间架起一道桥梁，使我们可以是两个模块兼容起来，所以，我们构造一个适配器，这个适配器要能完成 UserInformation 定义的功能:

 

package com.lou.patterns.adapter;

public class UserInfoAdapter implements UserInformation{

	private UserInfo userInfo;

	@Override
	public String getUserName() {
		return userInfo.getUserName();
	}

	@Override
	public String getUserId() {
		return userInfo.getUserId();
	}

	@Override
	public Integer getUserAge() {
		return userInfo.getUserAge();
	}

	@Override
	public String getUserAddress() {
		return userInfo.getUserProvince()+" " + userInfo.getUserCity()+ " " +userInfo.getUserStreet();
	}
}

 

 

package com.lou.patterns.adapter;

public class UserInfoImpl implements UserInfo{

	UserBean userBean = new UserBean();
	@Override
	public String getUserName() {
		return userBean.getName();
	}

	@Override
	public String getUserId() {
		return userBean.getId();
	}

	@Override
	public Integer getUserAge() {
		return userBean.getAge();
	}

	@Override
	public String getUserProvince() {
		return userBean.getProvince();
	}

	@Override
	public String getUserCity() {
		return userBean.getCity();
	}

	@Override
	public String getUserStreet() {
		return userBean.getStreet();
	}

}

 

package com.lou.patterns.adapter;

public class UserBean {

	private String name;
	private String id;
	private Integer age;
	private String province;
	private String city;
	private String street;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getProvince() {
		return province;
	}
	public void setProvince(String province) {
		this.province = province;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public String getStreet() {
		return street;
	}
	public void setStreet(String street) {
		this.street = street;
	}
}

这样，两个模块就可以兼容起来使用了。

总结：

适配器模式在于，adaptee在系统中的不可代替性，一般为模块的底层或者是基础部分，当遇到不兼容的情况时，不方便或者对于当前系统稳定性和拓展性的考虑，应当遵循 “对修改关闭，对拓展开放”的原则，使用适配器模式可以很好地满足这一点。

这里的适配器模式，有一定程度的代理模式的意味在里面，真正业务的实现偏重在adaptee实现，adapter再对其进行转换，满足另外一个模块的要求。

 

个人观点，欢迎拍砖。