Java编程思想 - 第十四章、类型信息

package Chapter14;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.regex.Pattern;

public class ShowMethods {
	private static String usage = "usage:\n" +
			"ShowMethods qualified.class.name\n" +
			"To show all methods in class or:\n" +
			"ShowMethods qualified.class.name word\n" +
			"To search for methods involving 'word'";
	private static Pattern p = Pattern.compile("\\w+\\.");
	public static void main(String[] args) {
		if(args.length < 1) {
			System.out.println(usage);
			System.exit(0);
		}
		int lines = 0;
		try {
			Class<?> c = Class.forName(args[0]);
			Method[] methods = c.getMethods();
			Constructor[] ctors = c.getConstructors();
			if(args.length == 1) {
				for(Method method : methods) {
					System.out.println(p.matcher(method.toString()).replaceAll(""));
					System.out.println("#" + method.toString());
				}
				for(Constructor ctor : ctors) {
					System.out.println(p.matcher(ctor.toString()).replaceAll(""));
				}
			} else {
				for(Method method : methods) {
					if(method.toString().indexOf(args[1]) != -1) {
						System.out.println(p.matcher(method.toString()).replaceAll(""));
						lines++;
					}
				}
				for(Constructor ctor : ctors) {
					if(ctor.toString().indexOf(args[1]) != -1) {
						System.out.println(p.matcher(ctor.toString()).replaceAll(""));
						lines++;
					}
				}
			}
		} catch(ClassNotFoundException e) {
#			System.out.println("No such class: " + e);
		}
	}
}
/** output:
public static void main(String[])
#public static void Chapter14.ShowMethods.main(java.lang.String[])
public final void wait(long,int) throws InterruptedException
#public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void wait(long) throws InterruptedException
#public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void wait() throws InterruptedException
#public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean equals(Object)
#public boolean java.lang.Object.equals(java.lang.Object)
public String toString()
#public java.lang.String java.lang.Object.toString()
public native int hashCode()
#public native int java.lang.Object.hashCode()
public final native Class getClass()
#public final native java.lang.Class java.lang.Object.getClass()
public final native void notify()
#public final native void java.lang.Object.notify()
public final native void notifyAll()
#public final native void java.lang.Object.notifyAll()
public ShowMethods()
*/

package Chapter14;

interface Interface {
	void doSomething();
	void somethingElse(String arg);
}

class RealObject implements Interface {
	public void doSomething() {
		System.out.println("doSomething");
	}
	public void somethingElse(String arg) {
		System.out.println("somethingElse " + arg);
	}
}

//注意这里，代理实现了Interface接口，对每个代理方法都需要处理，如果这个类有20个方法，就必须重写20次
class SimpleProxy implements Interface {
	private Interface proxy;
	public SimpleProxy(Interface realInterface) {
		proxy = realInterface;
	}
	public void doSomething() {
		System.out.println("SimpleProxy doSomething");
		proxy.doSomething();
	}
	public void somethingElse(String arg) {
		System.out.println("SimpleProxy somethingElse");
		proxy.somethingElse(arg);
	}
}

public class SimpleProxyDemo {
	public static void consumer(Interface iface) {
		iface.doSomething();
		iface.somethingElse("bonobo");
	}
	public static void main(String[] args) {
		consumer(new RealObject());
		consumer(new SimpleProxy(new RealObject()));
	}
}
/** output:
*/
doSomething
somethingElse bonobo
SimpleProxy doSomething
doSomething
SimpleProxy somethingElse
somethingElse bonobo

package Chapter14;

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

//这里，我们不需要任何被代理对象的信息，耦合性完全为0.而且方法有一个统一的处理器，你有200个方法，我也只有1个处理方法
class DynamicProxyHandler implements InvocationHandler {
	private Object proxied;
	public DynamicProxyHandler(Object proxied) {
		this.proxied = proxied;
	}
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
		System.out.println("*** proxy: " + proxy.getClass() + ", method: " + method + ", args: " + args);
		if(args != null) {
			for(Object arg : args) {
				System.out.println(" " + arg);
			}
		}
		return method.invoke(proxied, args);
	}
}

public class SimpleDynamicProxy {
	public static void consumer(Interface iface) {
		iface.doSomething();
		iface.somethingElse("bonobo");
	}
	public static void main(String[] args) {
		RealObject real = new RealObject();
		consumer(real);
		
		Interface proxy = (Interface)Proxy.newProxyInstance(
				Interface.class.getClassLoader(), 
				new Class[]{ Interface.class }, 
				new DynamicProxyHandler(real)
		);
		consumer(proxy);
	}
}
/** output: 
doSomething
somethingElse bonobo
*** proxy: class Chapter14.$Proxy0, method: public abstract void Chapter14.Interface.doSomething(), args: null
doSomething
*** proxy: class Chapter14.$Proxy0, method: public abstract void Chapter14.Interface.somethingElse(java.lang.String), args: [Ljava.lang.Object;@6150818a
 bonobo
somethingElse bonobo
*/

package Chapter14;

import java.lang.reflect.*;

class MethodSelector implements InvocationHandler {
	private Object proxied;
	MethodSelector(Object proxied) {
		this.proxied = proxied;
	}

	//我们可以在这里动态提取方法的信息进而做出相应的逻辑，因为动态代理是用反射实现的，所以完全可以在运行时完成这类需求
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
		if(method.getName().equals("interesting")) {
			System.out.println("Proxy detected the interesting method");
		}
		return method.invoke(proxied, args);
	}
}

interface SomeMethods {
	void boring1();
	void boring2();
	void interesting(String arg);
	void boring3();
}

class Implementation implements SomeMethods {
	public void boring1() {
		System.out.println("boring1");
	}
	public void boring2() {
		System.out.println("boring2");
	}
	public void interesting(String arg) {
		System.out.println("interesting " + arg);
	}
	public void boring3() {
		System.out.println("boring3");
	}
}

public class SelectingMethods {
	public static void main(String[] args) {
		SomeMethods proxy = (SomeMethods)Proxy.newProxyInstance(
					SomeMethods.class.getClassLoader(),
					new Class[] { SomeMethods.class },
					new MethodSelector(new Implementation())
				);
		proxy.boring1();
		proxy.boring2();
		proxy.interesting("bonobo");
		proxy.boring3();
	}
}
/** output:
boring1
boring2
Proxy detected the interesting method
interesting bonobo
boring3
*/