디자인 모델 - 구조 형 모델 총화 사례 (2)

에이전트 모드
이 대상 에 대한 접근 을 제어 하기 위해 다른 대상 에 게 에이 전 트 를 제공 합 니 다.어떤 경우 에 한 대상 이 적합 하지 않 거나 다른 대상 을 직접 인용 할 수 없 으 며 대리 대상 은 클 라 이언 트 와 목표 대상 사이 에서 중개 역할 을 할 수 있다.
추상 적 인 역할: 실제 대상 과 대리 대상 의 공동 인 터 페 이 스 를 설명 합 니 다.
대리 역할: 대리 대상 역할 내부 에 실제 대상 에 대한 인용 이 포함 되 어 있어 실제 대상 을 조작 할 수 있 고 대리 대상 은 실제 대상 과 같은 인 터 페 이 스 를 제공 하여 언제든지 실제 대상 을 대체 할 수 있 습 니 다.또한 대리 대상 은 실제 대상 조작 을 수행 할 때 다른 조작 을 추가 할 수 있어 실제 대상 을 봉인 하 는 것 과 같다.
실제 역할: 대리 역할 이 대표 하 는 진실 한 대상 은 우리 가 최종 적 으로 인용 해 야 할 대상 이다.
인 스 턴 스 코드 - 정적 에이전트

package com.ruishenh.designPatter.structure.proxy;
 
public class ProxyClient {
   public static void main(String[] args) {
      ISell sell =new Proxy();
      Computer c=sell.sellComputer();
      System.out.println("            ："+c.getName());
   }
}
 
//    
interface ISell{
   Computer sellComputer();
}
//   
class Proxy implements ISell{
  
   Merchant merchant=new Merchant();
   @Override
   public Computer sellComputer() {
      return merchant.sellComputer();
   }
}
//  
class Merchant implements ISell{
   @Override
   public Computer sellComputer() {
      return new Computer("DELL     ");
   }
}
class Computer{
   String name;
   public Computer(String name) {
      super();
      this.name = name;
   }
   public String getName() {
      return name;
   }
}

대리 모드 의 핵심 임 무 는 대상 의 정 체 를 숨 기 고 하나의 대리 로 모든 작업 을 완성 하 는 것 이다.어떤 의미 에서 볼 때 매우 좋 은 확장 성 을 증가 시 킬 수 있다.
인 스 턴 스 코드 - 동적 에이전트

package com.ruishenh.designPatter.structure.dynamicProxy;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
public class DynamicProxyClient {
   public static void main(String[] args) {
      Merchant mc=new Merchant();
      DynamicProxy<ISell> proxy = new DynamicProxy<ISell>(mc); 
      ISell sell= proxy.getProxy();
      Computer c=sell.sellComputer();
      System.out.println("            ："+c.getName());
   }
}
 
//    
interface ISell{
   Computer sellComputer();
}
//    
class DynamicProxy<T> implements InvocationHandler{
  
    private T obj; 
    
       public DynamicProxy(T obj) { 
           this.obj = obj; 
       }
      
   @SuppressWarnings("unchecked")
   T getProxy(){
      return (T) Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
    }
  
   @Override
   public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
      before();
      Object ret=method.invoke(obj, args);
      after();
      return ret;
   }
 
   void before(){System.out.println("before....");};
   void after(){System.out.println("after....");};
  
}
//  
class Merchant implements ISell{
   @Override
   public Computer sellComputer() {
      return new Computer("DELL     ");
   }
}
class Computer{
   String name;
   public Computer(String name) {
      super();
      this.name = name;
   }
   public String getName() {
      return name;
   }
}

동적 에이 전 트 는 요청 에 대해 모든 처 리 를 할 수 있 습 니 다 (예 를 들 어 사무, 로그 등 입 니 다. 이것 은 모두 인터넷 에서 말 한 것 입 니 다. 저 는 당연히 모든 처 리 를 할 수 있 습 니 다). spring 에서 대량으로 응용 되 었 습 니 다.
어댑터 모드
하나의 인 터 페 이 스 를 고객 이 원 하 는 다른 인터페이스 로 전환 합 니 다. Adapter 모드 는 원래 인터페이스 가 호 환 되 지 않 아 함께 일 할 수 없 었 습 니 다.
목표 (Target) 캐릭터: 이것 이 바로 기대 하 는 인터페이스 입 니 다.
원본 (Adapee) 역할: 현재 적합 한 인터페이스 가 필요 합 니 다.
어댑터 (Adaper) 역할: 어댑터 류 는 이 모드 의 핵심 입 니 다.어댑터 가 원본 인 터 페 이 스 를 목표 인터페이스 로 변환 합 니 다.

package com.ruishenh.designPatter.structure.adapter;
 
public class AdapterClient {
   public static void main(String[] args) {
      Noodle target = new Adapter(new Thick());
      target.getNoodle();
   }
}
//  -    
interface Noodle {
   public void getNoodle();
}
//       adaptee   
interface NoodleMachine{
   void makeNoodle();
  
}
class Thick implements NoodleMachine {
   @Override
   public void makeNoodle() {
      System.out.println("       ");
   }
}
class Thin implements NoodleMachine {
   @Override
   public void makeNoodle() {
      System.out.println("       ");
   }
}
//   ，           
class Adapter implements Noodle{
   public Adapter(NoodleMachine machine) {
      this.machine = machine;
   }
   NoodleMachine machine;
   @Override
   public void getNoodle() {
      machine.makeNoodle();
     
   }
}

어댑터 모드 의 핵심 임 무 는 하나의 수요 인터페이스 와 다른 응답 인 터 페 이 스 를 연결 하 는 것 이다. 두 측 이 대응 하 는 프로그램 이 모두 변동 할 수 있 기 때문에 어댑터 모드 는 잘 확장 할 수 있다.