학습 노트 - 대리 모델

디자인 모드
프 록 시 모드: 다른 대상 에 게 대역 이나 자리 표시 자 를 제공 하여 이 대상 에 대한 접근 을 제어 합 니 다.
프 록 시 모드 를 사용 하여 대표 대상 을 만 들 고 대상 이 특정한 대상 의 방문 을 제어 하도록 합 니 다. 프 록 시 대상 은 원 격 대상 (원 격 에이전트), 비용 이 많이 드 는 대상 (가상 에이전트) 을 만 들 거나 안전 제어 대상 (보호 에이전트) 을 만 들 수 있 습 니 다.
원 격 에이전트: 다른 JVM 대상 의 로 컬 대표 가 될 수 있 습 니 다.프 록 시 를 호출 하 는 방법 은 프 록 시 에 의 해 네트워크 를 이용 하여 원 격 으로 전송 되 고 결 과 는 네트워크 를 통 해 프 록 시 에 게 되 돌아 간 다음 에 프 록 시 에서 결 과 를 고객 에 게 되 돌려 줍 니 다.
가상 에이전트: 비용 이 많이 드 는 대상 을 만 드 는 대표 입 니 다.가상 에이 전 트 는 우리 가 진정 으로 대상 이 필요 할 때 까지 만 듭 니 다.대상 이 생 성 전과 생 성 중 일 때 가상 에이전트 가 대상 의 대역 을 맡 습 니 다.대상 이 생 성 되면 대 리 는 요청 을 대상 에 게 직접 의뢰 합 니 다.
동적 에이전트: 자바 는 자바. lang. reflect 패키지 에 자신의 프 록 시 지원 이 있 습 니 다. 이 패 키 지 를 이용 하여 실행 할 때 동적 으로 프 록 시 클래스 를 만 들 고 하나 이상 의 인 터 페 이 스 를 실현 하 며 방법 을 지정 한 클래스 로 전송 할 수 있 습 니 다.실제 프 록 시 클래스 는 실행 할 때 만 든 것 입 니 다. 자바 에서 우 리 는 이 기술 을 동적 에이전트 라 고 부 릅 니 다.자바 의 동적 대 리 를 이용 하여 보호 대 리 를 실현 할 수 있 습 니 다.
방화벽 에이전트: 네트워크 자원 의 방문 을 통제 하고 주 제 를 '나 쁜 고객' 의 침해 로부터 보호 합 니 다.
스마트 참조 에이전트: 테마 가 인 용 될 때 대상 이 인 용 된 횟수 를 계산 하 는 등 추가 동작 을 합 니 다.
캐 시 에이전트: 비용 이 많이 드 는 연산 결 과 를 일시 적 으로 저장 하고 여러 고객 이 결 과 를 공유 하여 계산 이나 네트워크 지연 을 줄 입 니 다.
동기 화 에이전트: 다 중 스 레 드 의 경우 테마 에 안전 한 접근 을 제공 합 니 다.
복잡 한 숨겨 진 에이전트: 복잡 한 집합의 복잡 도 를 숨 기 고 접근 제 어 를 하 는 데 사 용 됩 니 다.때로는 외관 에이전트 가 되 기도 한다.복잡 한 숨겨 진 프 록 시 와 외관 모드 는 다 릅 니 다. 프 록 시 접근 을 제어 하기 때문에 외관 모드 는 다른 인터페이스 만 제공 합 니 다.
기록 할 때 복사 에이전트: 대상 의 복 제 를 제어 하 는 방법 은 지연 대상 의 복사 입 니 다. 고객 이 진정 으로 필요 하 다 는 것 을 알 때 까지 가상 에이전트 의 변형 입 니 다.
원 격 서비스 만 들 기
(1) 원 격 인터페이스 만 들 기
(2) 제작 원 격 실현
(3) rmic 를 이용 하여 stub 와 skeleton 생 성
(4) RMI 레 지 스 트 리 시작
(5) 원 격 서비스 시작
설계 원칙
패 키 징 변화
조합 을 많이 쓰 고 계승 을 적 게 쓰다.
인터페이스 프로 그래 밍
대화 대상 간 의 전송 결합 디자인 을 위해 노력 하 다.
클래스 는 확장 개발, 수정 에 대해 닫 아야 합 니 다.
추상 에 의존 하고 구체 적 인 유형 에 의존 하지 않 는 다.
친구 와 만 이야기 하 다
나 를 찾 지 마라, 내 가 너 를 찾 을 것 이다
클래스 는 변 하 는 이유 가 하나 밖 에 없어 야 한다.
요점
대 리 는 구조 적 으로 장식 자 와 유사 하지만 목적 은 다르다.장식 자 모델 은 대상 에 행 위 를 더 하고 대 리 는 통제 행위 이다.
다른 포장 자 와 마찬가지 로 대 리 는 당신 의 디자인 중의 수량 을 증가 시 킬 것 입 니 다.
원 격 에이전트

import java.rmi.Remote;//   rmiregistry lookup naming  java.rmi  
import java.rmi.RemoteException;

//extends Remote               
public interface GumballMachineRemote extends Remote {
	//       ，      RemoteException
	//                “    ”
	public int getCount() throws RemoteException;
	public String getLocation() throws RemoteException;

	//                ，                
	public State getState() throws RemoteException;
}

//  Serializable  ，  State    
public interface State extends Serializable {
	public void insertQuarter();
	public void ejectQuarter();
	public void turnCrank();
	public void dispense();
}


public class HasQuarterState implements State {
	private static final long serialVersionUID = 768887299984514010L;
	Random randomWinner = new Random(System.currentTimeMillis());
	
	//  State     ，    GumballMachine        transient   ，       JVM         
	transient GumballMachine gumballMachine;

	//    
}

//GumballMachine    UnicastRemoteObject        
//GumballMachine      GumballMachineRemote      
public class GumballMachine extends UnicastRemoteObject implements
		GumballMachineRemote {
	/**
	 * 
	 */
	private static final long serialVersionUID = -2838970117227273571L;
	State soldOutState;
	State noQuarterState;
	State hasQuarterState;
	State soldState;
	State winnerState;
	State state = soldOutState;
	int count = 0;
	String location;

	//       RemoteException，         
	public GumballMachine(String location, int numberGumballs)
			throws RemoteException {
		soldOutState = new SoldOutState(this);
		noQuarterState = new NoQuarterState(this);
		hasQuarterState = new HasQuarterState(this);
		soldState = new SoldState(this);
		winnerState = new WinnerState(this);

		this.count = numberGumballs;
		if (numberGumballs > 0)
			state = noQuarterState;
		this.location = location;
	}

	public void insertQuarter() {
		state.insertQuarter();
	}

	public void ejectQuarter() {
		state.ejectQuarter();
	}

	public void turnCrank() {
		state.turnCrank();
		state.dispense();
	}

	void setState(State state) {
		this.state = state;
	}

	void releaseBall() {
		System.out.println("A gumball comes rolling out the slot...");
		if (count != 0) {
			count = count - 1;
		}
	}

	public void refill(int count) {
		this.count = count;
		state = noQuarterState;
	}

	public int getCount() {
		return count;
	}

	public State getState() {
		return state;
	}

	public String getLocation() {
		return location;
	}
	
	//    
}

// RMI register   
public class GumballMachineTestDrive {

	public static void main(String[] args) {
		GumballMachineRemote gumballMachine = null;
		int count;

		if (args.length < 2) {
			System.out.println("GumballMachine  ");
			System.exit(1);
		}

		try {//           try/catch，               
			count = Integer.parseInt(args[1]);

			gumballMachine = new GumballMachine(args[0], count);
			
			//       Naming.rebind   ， gumballmachine     GumballMachine stub
			Naming.rebind("//" + args[0] + "/gumballmachine", gumballMachine);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

//GumballMonitor   
public class GumballMonitor {
	//   GumballMachineRemote    ，       
	GumballMachineRemote machine;

	public GumballMonitor(GumballMachineRemote machine) {
		this.machine = machine;
	}

	public void report() {
		//                       ，                 
		try {
			System.out.println("Gumball Machine: " + machine.getLocation());
			System.out.println("Current inventory: " + machine.getCount()
					+ " gumballs");
			System.out.println("Current state: " + machine.getState());
		} catch (RemoteException e) {
			e.printStackTrace();
		}
	}
}

//      
public class GumballMonitorTestDrive {

	public static void main(String[] args) {
		String[] location = { "rmi://santafe.mightygumball.com/gumballmachine",
				"rmi://boulder.mightygumball.com/gumballmachine",
				"rmi://seattle.mightygumball.com/gumballmachine" };

		GumballMonitor[] monitor = new GumballMonitor[location.length];

		for (int i = 0; i < location.length; i++) {
			try {
				//             ，   Register     ，   stub  
				GumballMachineRemote machine = (GumballMachineRemote) Naming
						.lookup(location[i]);
				monitor[i] = new GumballMonitor(machine);
				System.out.println(monitor[i]);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		//      ，    
		for (int i = 0; i < monitor.length; i++) {
			monitor[i].report();
		}
	}
}

가상 에이전트

class ImageProxy implements Icon {
	ImageIcon imageIcon;
	URL imageURL;
	Thread retrievalThread;
	boolean retrieving = false;
    
	//      url      ，                
	public ImageProxy(URL url) { imageURL = url; }
     
	public int getIconWidth() {
		if (imageIcon != null) {
            return imageIcon.getIconWidth();
        } else {
			//       ，       
			return 800;
		}
	}
 
	public int getIconHeight() {
		if (imageIcon != null) {
            return imageIcon.getIconHeight();
        } else {
			return 600;
		}
	}
     
	public void paintIcon(final Component c, Graphics  g, int x,  int y) {
		if (imageIcon != null) {
			//      icon，        
			imageIcon.paintIcon(c, g, x, y);
		} else {
			g.drawString("Loading CD cover, please wait...", x+300, y+190);
			if (!retrieving) {//            
				retrieving = true;

				//              ，            
				retrievalThread = new Thread(new Runnable() {
					public void run() {
						try {
							//         icon  ，                
							imageIcon = new ImageIcon(imageURL, "CD Cover");
							//       ，    Swing    
							c.repaint();
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				});
				retrievalThread.start();
			}
		}
	}
}

public class ImageProxyTestDrive {
	ImageComponent imageComponent;
	JFrame frame = new JFrame("CD Cover Viewer");
	JMenuBar menuBar;
	JMenu menu;
	Hashtable cds = new Hashtable();

	public static void main(String[] args) throws Exception {
		ImageProxyTestDrive testDrive = new ImageProxyTestDrive();
	}

	public ImageProxyTestDrive() throws Exception {
		//       

		//        ，     URL
		Icon icon = new ImageProxy(initialURL);
		//         
		imageComponent = new ImageComponent(icon);
		frame.getContentPane().add(imageComponent);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(800, 600);
		frame.setVisible(true);

	}

	URL getCDUrl(String name) {
		try {
			return new URL((String) cds.get(name));
		} catch (MalformedURLException e) {
			e.printStackTrace();
			return null;
		}
	}
}