package com.example.designpattern.proxy; 
 public interface Subject {
 void request();
 }

package com.example.designpattern.proxy;
public class RealSubject implements Subject {
//真是角色實現(xiàn)了
public void request() {
System.out.println("From real subject");
}
}

package com.example.designpattern.proxy;

public class ProxySubject implements Subject {

private RealSubject realSubject; //代理角色內(nèi)部引用了真實角色

//代理角色實現(xiàn)目標(biāo)動作
public void request() {

this.preRequest(); //在真實角色操作之前所附加的操作
if (realSubject == null){
realSubject = new RealSubject();
}
realSubject.request(); // 真實角色所完成的事情
this.afterRequet(); //在真實角色操作之后附加的操作
}
//代理角色之前完成的動作
private void preRequest(){
System.out.println("pre request");
}
//代理角色之后完成的動作
private void afterRequet(){
System.out.println("after request");
}
}

package com.example.designpattern.proxy;

public class Client {
public static void main(String[] args) {
ProxySubject proxy = new ProxySubject();
//通過代理對象來調(diào)用方法
proxy.request(); 
}
}

 Proxy.newProxyInstance(
 ClassLoader loader, // 傳入ClassLoader
 Class<?>[] interfaces, // 傳入要調(diào)用的接口的方法數(shù)組
 InvocationHandler h); //傳入InvocationHandler 的實例

package design.dynamicproxy;
public interface Subject {
void request(String str);
}

package design.dynamicproxy;
public class RealSubject implements Subject {
@Override
public void request(String str) {
System.out.println("From Real Subject!" + " args:" + str );
}
}

package design.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
* 該代理類的內(nèi)部屬性時Object類型，實際使用時，使用該類的構(gòu)造方法傳遞一個對象
* 此外該類還實現(xiàn)了invoke() 方法，該方法中的method.invoke() 其實就是要調(diào)用被代理對象的要執(zhí)行的方法
* 方法參數(shù)是object，表示該方法從屬于object對象，通過動態(tài)代理類，我們可以在執(zhí)行真是對象的
* 方法前后可以加入一些額外的方法
*/
public class DynamicSubject implements InvocationHandler {

//引入的類型是Object的，可以隨便傳入任何一個對象
private Object object;

public DynamicSubject(Object object){
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before calling:" + method);
//等價于realSubject的request() 方法，如果這里不調(diào)用的話，不會調(diào)用Method 對象中的方法
method.invoke(object, args);
System.out.println("after calling:" + method);
return null;
}
}

package design.dynamicproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Client {
	public static void main(String[] args) {
		RealSubject realSubject = new RealSubject();
		InvocationHandler handler = new DynamicSubject(realSubject);
		Class<?> classType = handler.getClass();
		//下面的代碼一次性生成代理
		// 動態(tài)生成了class com.sun.proxy.$Proxy0 的實例，
		Subject subject = (Subject) Proxy.newProxyInstance(classType.getClassLoader(), realSubject.getClass().getInterfaces(),handler);
		subject.request("eather");
		System.out.println(subject.getClass());
		//輸出class com.sun.proxy.$Proxy0，可以看到Proxy.newProxyInstance() 是系統(tǒng)自動生成的實例
	}
}

public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
	Objects.requireNonNull(h);
	final Class<?>[] intfs = interfaces.clone();
	final SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
		checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
	}
	/*
* Look up or generate the designated proxy class.
生成一個代理類對象
*/
	Class<?> cl = getProxyClass0(loader, intfs);
	/*
* Invoke its constructor with the designated invocation handler.
使用指定的調(diào)用處理程序調(diào)用其構(gòu)造函數(shù)。就是使用InvocationHandler 實例調(diào)用【要調(diào)用方法的那個類】的構(gòu)造方法
*/
	try {
		if (sm != null) {
			checkNewProxyPermission(Reflection.getCallerClass(), cl);
		}
		final Constructor<?> cons = cl.getConstructor(constructorParams);
		final InvocationHandler ih = h;
		if (!Modifier.isPublic(cl.getModifiers())) {
			AccessController.doPrivileged(new PrivilegedAction<Void>() {
				public Void run() {
					cons.setAccessible(true);
					return null;
				}
			}
			);
		}
		return cons.newInstance(new Object[]{
			h
		}
		);
	}
	catch (IllegalAccessException|InstantiationException e) {
		throw new InternalError(e.toString(), e);
	}
	catch (InvocationTargetException e) {
		Throwable t = e.getCause();
		if (t instanceof RuntimeException) {
			throw (RuntimeException) t;
		} else {
			throw new InternalError(t.toString(), t);
		}
	}
	catch (NoSuchMethodException e) {
		throw new InternalError(e.toString(), e);
	}
}