结构型模式之适配器模式（Adapter）

适配器模式（Adapter）:

        将一个类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作的那些类一起工作了，其别名为包装器（wrapper）。通俗的讲，就是原来两个不兼容的两个功能代码，通过中间代码相结合。

适配器模式包括：
 目标角色Target(类或者接口)：定义Client使用的与特定领域相关的接口。
 Client：与符合Target接口的对象协同。
源角色Adaptee（类或者接口）：定义一个接口已经存在的接口，这个接口需要适配。
适配器角色Adapter（适配器类）：对Adaptee的接口和Target接口进行适配。

结构：
类适配器：使用多重继承对一个接口与另一个接口进行匹配。
对象适配器：对象匹配依赖于对象组合。

适配器模式使我们可以重用一个现有的类，以满足客户端的需要，当客户端通过接口表达其需求时，通常可以创建一个实现了该接口的新类，同时使该类继承现有的类，这种方式即类的适配器，它能够将客户端的调用转换成现有类方法的调用。
当客户端没有指定它所需接口时，就可以使用适配器模式，可能需要创建一个新的客户端子类，他将使用现有类的实例，这种方式通过创建一个对象适配器。将客户端的调用指向现有类的实例，如果不需要重写客户端可能调用的方法时，可能存在一定的危险性。

实例：鞋子生产商可以生产鞋子，服装生产商可以生产服装，某鞋子生产商决定将业务扩展到服装领域。

两种实现方式：
一，类适配器
目标类

public interface ProduceCompany
{
	public String getShoe();
	public String getDress();
}

适配器类

public class ProduceShoe extends ProduceDress implements ProduceCompany
{
	@Override
	public String getShoe() {
		System.out.println("-------鞋子--------");
		return "shoe";
	}
}

被适配器类

public class ProduceDress
{
	public String getDress()
	{
		System.out.println("-------服装--------");
		return "dress";
	}
}

客户端

public class testClient
{
	public static void main(String[] args)
	{
		ProduceShoe p = new ProduceShoe();
		System.out.println(p.getShoe() + p.getDress());
		
	}
}

二，对象适配器
目标类

public interface ProduceCompany
{
	public String getShoe();
	public String getDress();
}

适配器类

public class produceDress implements ProduceCompany
{
	private ProduceDress prod;
	public produceDress(ProduceDress prod)
	{
		this.prod=prod;
	}
	public String getDress()
	{
		return prod.getDress();
	}
	
}

被适配器类

public class ProduceDress
{
	public String getDress()
	{
		System.out.println("-------服装--------");
		return "dress";
	}
	@Override
	public String getShoe() {
		System.out.println("-------鞋子--------");
		return "shoe";
	}
}

客户端

<pre name="code" class="java">public class testClient
{
	public static void main(String[] args)
	{
		ProduceShoe p = new ProduceShoe(null);
		System.out.println(p.getShoe() + p.getDress());
		
	}

}

      推荐使用：对象适配器

适配器模式在ssh框架中的使用：在SSH框架中spring整合hibernate进行系统开发，对于spring而言，它提供了HibernateDaoSupport、HibernateTemplate、HibernateCallBack等工具类或接口来支撑DAO组件的实现。

spring 整合hibernate时，运用的适配器模式：父DAO接口

public interface FatherDAO
{
	public void saveInfo(Object obj1);
	public void delInfo(Object obj);
	public Object findByNO(String no);
	public List<Object> findAll();
}

通用DAO适配器

public abstract class FatherDAOAdapter extends HibernateDaoSupport implements FatherDAO
{
	protected FatherDAOAdapter(){}
	public void saveInfo(Object obj1)
	{
		getHibernateTemplate().saveOrUpdate(obj1);
	}
	public void delInfo(Object obj)
	{
		getHibernateTemplate().delete(obj);
	}
	public List<Object> findAll(String objName)
	{
		String searchName ="from "+ objName;
		return getHibernateTemplate().find(searchName);
	}
}

登陆DAO接口

public interface LoginDAO extends FatherDAO
{
	public List findByName(String userName);
	public List findByPassword(String password);
}

登陆DAO实现类

public class LoginDAOImpl extends FatherDAOAdapter implements LoginDAO
{
	public static final String userName ="name";
	public static final String password ="pwd";
	public List findAll()
	{
		return super.findAll(userName);
	}
}	

优势：
适配器类可以使任何两个无直接联系的类在一起运行。
目标角色（Target）可以通过被适配者（Adaptee）具体实现。
适配器类，大大提高了类的复用度和灵活性。
使用场景：
软件系统有使用已有类的要求，但是类的接口不适合。
需要设计一个可以多次使用的类，并且与其他没有直接关系或者不可知的类进行关联。
调用现有的某些子类，无须派生他们的每个接口。