结构模式之适配器

1. 分类

   分类	结构
   单向适配器结构	目标抽象类Target.、适配器类Adapter、适配者类Adeptee
   双向适配器结构	目标抽象类Target.、适配器类Adapter、适配者类Adeptee
   缺省适配器结构	适配器接口ServiceInterface、缺省适配器类AbstractServiceClass、具体业务类ConcreteServiceClass

2. 模式适用环境：
   1. 系统需要使用一些现有的类，而这些类的接口不符合系统的需要，甚至没有这些类的源码。
   2. 想创建一个可以重复使用的类，用于和一些彼此之间没有太大关联得类一起工作。
3. 类适配器
   1. 实例结构:目标类只能是接口，适配者一般是具体类。
   2. 实现：

      public interface Target {
          public void request();
      }
      
      public class Adaptee {
          public void specificRequest(){
              System.out.println("调用适配者请求方法");
          }
      }
      
      public class Adapter extends Adaptee implements Target {
          @Override
          public void request() {
              System.out.print("执行目标类请求方法：");
              super.specificRequest();
          }
      }
      
      public class Client {
          public static void main(String[] args) {
              Adapter adapter = (Adapter) XMLUtils.getBean("adapterPatternClass");
              adapter.request();
          }
      }
      
      控制台输出：
      执行目标类请求方法：调用适配者请求方法

      <?xml version="1.0" encoding="UTF-8"?>
      <config>
          <adapterPatternClass>structuralPattern.adapterPattern.type.Adapter</adapterPatternClass>
          
      </config>

       

4. 对象适配器
   1. 实例结构:目标类一般是抽象类，适配者一般都是具体类，使用频率较高。
   2. 实现：

      public abstract class Target {
          public abstract void request();
      }
      
      public class Adaptee {
          public Adaptee() {
          }
      
          public void specificRequest(){
              System.out.println("调用适配者请求方法");
          }
      }
      
      public class Adapter extends Target {
      
          private Adaptee adaptee;
      
          public Adapter() {
          }
      
          public Adapter(Adaptee adaptee) {
              this.adaptee = adaptee;
          }
      
          public void setAdaptee(Adaptee adaptee) {
              this.adaptee = adaptee;
          }
      
          public void request() {
              System.out.print("目标类转发请求，");
              this.adaptee.specificRequest();
          }
      }
      
      public class Client {
          public static void main(String[] args) {
              Adapter adapter = (Adapter) XMLUtils.getBean("adapterPatternObject");
              Adaptee adaptee = (Adaptee) XMLUtils.getBean("adapterPatternAdaptee");
              adapter.setAdaptee(adaptee);
              adapter.request();
          }
      }
      
      控制台输出：
      目标类转发请求，调用适配者请求方法

      <?xml version="1.0" encoding="UTF-8"?>
      <config>
          <adapterPatternObject>structuralPattern.adapterPattern.object.Adapter</adapterPatternObject>
          <adapterPatternAdaptee>structuralPattern.adapterPattern.object.Adaptee</adapterPatternAdaptee>
      
      </config>

       

5. 双向适配器
   1. 实例背景：使用java语言实现一个双向适配器实例，使得猫可以学狗叫，狗可以学猫抓老鼠。
   2. 实现：

      public interface CatTarget {
          public abstract void catchMouse();
      }
      public class ConcreteCatTarget implements CatTarget {
          @Override
          public void catchMouse() {
              System.out.println("抓老鼠");
          }
      }
      
      public interface DogAdaptee {
          public abstract void cry();
      }
      public class ConcreteDogAdaptee implements DogAdaptee {
          @Override
          public void cry() {
              System.out.println("汪汪叫");
          }
      }
      
      public class Adapter implements CatTarget,DogAdaptee {
      
          private CatTarget catTarget;
          private DogAdaptee dogAdaptee;
      
          public Adapter() {
          }
      
          public void setCatTarget(CatTarget catTarget) {
              this.catTarget = catTarget;
          }
      
          public void setDogAdaptee(DogAdaptee dogAdaptee) {
              this.dogAdaptee = dogAdaptee;
          }
      
          public void catchMouse() {
              System.out.print("猫学狗叫，即目标类调用适配者中的方法:");
              dogAdaptee.cry();
      
          }
      
          public void cry(){
              System.out.print("狗学猫抓老鼠,即适配者调用目标类中的方法：");
              catTarget.catchMouse();
          }
      
      }
      
      public class Client {
          public static void main(String[] args) {
              //适配器
              Adapter adapter = (Adapter) XMLUtils.getBean("adapterPattern");
      
              //目标类通过适配器调用适配者方法
              CatTarget concreteCatTarget = (ConcreteCatTarget) XMLUtils.getBean("adapterPatternTarger");
              adapter.setCatTarget(concreteCatTarget);
              adapter.cry();
      
              //适配者通过适配器调用目标类方法
              DogAdaptee concreteDogAdaptee = (ConcreteDogAdaptee) XMLUtils.getBean("adapterPatternAdaptee");
              adapter.setDogAdaptee(concreteDogAdaptee);
              adapter.catchMouse();
          }
      }
      
      控制台输出：
      狗学猫抓老鼠,即适配者调用目标类中的方法：抓老鼠
      猫学狗叫，即目标类调用适配者中的方法:汪汪叫

      <?xml version="1.0" encoding="UTF-8"?>
      <config>
          <adapterPattern>structuralPattern.adapterPattern.Adapter</adapterPattern>
      
      <adapterPatternTarger>structuralPattern.adapterPattern.ConcreteCatTarget</adapterPatternTarger>
      
      <adapterPatternAdaptee>structuralPattern.adapterPattern.ConcreteDogAdaptee</adapterPatternAdaptee>
      </config>