package javatest;
import java.util.*;
class Student {private String name;private int age;private int ID;public Student() {}public Student(String name, int age, int ID) {this.name = name;this.age = age;this.ID = ID;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}
public class javatest {public static void main(String[] args) {Student s1 = new Student("java", 20, 123);Class ss = s1.getClass();System.out.println("getName: " + ss.getName());System.out.println("getFields: " + ss.getFields());System.out.println("getDeclaredFields: " + ss.getDeclaredFields());System.out.println("getMethods: " + ss.getMethods());System.out.println("isInterface: " + ss.isInterface());System.out.println("isPrimitive: " + ss.isPrimitive());System.out.println("isArray: " + ss.isArray());System.out.println("SuperClass: " + ss.getSuperclass().getName());}
}

package javatest;
import java.util.*;class BaseUser {public int baseId;public int getBaseId() {return baseId;}public void setBaseId(int baseId) {this.baseId = baseId;}
}class User extends BaseUser {private int id;public String name;public User(){}public User(String name) {this.name = name;}private int getId() {return id;}private void serId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}public class javatest {public static void main(String[] args) {Class<?> userClass = User.class;try {User user = (User)userClass.newInstance();System.out.println("1.反射实例化(无参): " + user);User user2 = (User)userClass.getConstructor(new Class[]{}).newInstance(new Object[]{});System.out.println("2.反射实例化(无参): " + user2);User user3 = (User)userClass.getConstructor(new Class[]{String.class}).newInstance(new Object[]{"test"});System.out.println("反射实例化(带参): " + user3 + " 属性Name的值: " + user3.getName());User user4 = new User();System.out.println("正常实例化: " + user4);} catch(Exception e) {e.printStackTrace();}}
}

public class reflectMethodDemo {public static void main(String[] args) {User user = new User();Class<?> userClass = User.class;Method[] publicMethod = userClass.getMethods();for(Method method : publicMethod) {System.out.println("获得当前类以及超类的所有publicMethod: " + method);}Method[] currentMethod = userClass.getDeclaredMethods();for(Method method : currentMethod) {System.out.println("获得当前类自己声明的所有的Method: " + method);}try {Method setBaseIdMethod = userClass.getMethod("setBaseId", new Class[]{int.class});System.out.println("获得当前类或超类的public Method setBaseId: " + setBaseIdMethod);Method setIdMethod = userClass.getDeclaredMethod("setId", new Class[]{int.class});System.out.println("获得当前类的Method setId: " + setIdMethod);setIdMethod.setAccessible(true);setIdMethod.invoke(user, new Object[]{110});Method getIdMethod = userClass.getDeclaredMethod("getId", new Class[]{});getIdMethod.setAccessible(true);Integer getId = (Integer)getIdMethod.invoke(user, new Object[]{});System.out.println("调用getId方法获得: " + getId);} catch(Exception e) {e.printStackTrace();}}
}

public class reflectFieldDemo {public static void main(String[] args) {User1 user = new User1();Class<?> userClass = user.getClass();Field[] publicField = userClass.getFields();for(Field field : publicField) {System.out.println("获得该类及超类所有public Field: " + field);}Field[] currentField = userClass.getDeclaredFields();for(Field field : currentField) {System.out.println("获得该类自己声明的所有Field: " + field);}try {Field baseIdField = userClass.getField("baseId");System.out.println("获得该类或超类名为baseId的public Field: " + baseIdField);Field idField = userClass.getDeclaredField("id");System.out.println("获得该类自己声明的名为id的Field: " + idField);idField.setAccessible(true);idField.set(user, 110);Integer id = (Integer)idField.get(user);System.out.println("id的值为: " + id);} catch (Exception e) {e.printStackTrace();}}
}

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器
static InvocationHandler getInvocationHandler(Object proxy) // 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
static Class getProxyClass(ClassLoader loader, Class[] interfaces) // 方法 3：该方法用于判断指定类对象是否是一个动态代理类
static boolean isProxyClass(Class cl) // 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象
// 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行
Object invoke(Object proxy, Method method, Object[] args)

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); // 通过反射从生成的类对象获得构造函数对象
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); // 通过构造函数对象创建动态代理类实例
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 直接创建动态代理类实例
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader, new Class[] { Interface.class }, handler );

// 映射表：用于维护类装载器对象到其对应的代理类缓存
private static Map loaderToCache = new WeakHashMap(); // 标记：用于标记一个动态代理类正在被创建中
private static Object pendingGenerationMarker = new Object(); // 同步表：记录已经被创建的动态代理类类型，主要被方法 isProxyClass 进行相关的判断
private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap()); // 关联的调用处理器引用
protected InvocationHandler h;

// 由于 Proxy 内部从不直接调用构造函数，所以 private 类型意味着禁止任何调用
private Proxy() {} // 由于 Proxy 内部从不直接调用构造函数，所以 protected 意味着只有子类可以调用
protected Proxy(InvocationHandler h) {this.h = h;}

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException { // 检查 h 不为空，否则抛异常if (h == null) { throw new NullPointerException(); } // 获得与制定类装载器和一组接口相关的代理类类型对象Class cl = getProxyClass(loader, interfaces); // 通过反射获取构造函数对象并生成代理类实例try { Constructor cons = cl.getConstructor(constructorParams); return (Object) cons.newInstance(new Object[] { h }); } catch (NoSuchMethodException e) { throw new InternalError(e.toString()); } catch (IllegalAccessException e) { throw new InternalError(e.toString()); } catch (InstantiationException e) { throw new InternalError(e.toString()); } catch (InvocationTargetException e) { throw new InternalError(e.toString()); }
}

try { // 指定接口名字、类装载器对象，同时制定 initializeBoolean 为 false 表示无须初始化类// 如果方法返回正常这表示可见，否则会抛出 ClassNotFoundException 异常表示不可见interfaceClass = Class.forName(interfaceName, false, loader);
} catch (ClassNotFoundException e) {
}

do { // 以接口名字列表作为关键字获得对应 cache 值Object value = cache.get(key); if (value instanceof Reference) { proxyClass = (Class) ((Reference) value).get(); } if (proxyClass != null) { // 如果已经创建，直接返回return proxyClass; } else if (value == pendingGenerationMarker) { // 代理类正在被创建，保持等待try { cache.wait(); } catch (InterruptedException e) { } // 等待被唤醒，继续循环并通过二次检查以确保创建完成，否则重新等待continue; } else { // 标记代理类正在被创建
        cache.put(key, pendingGenerationMarker); // break 跳出循环已进入创建过程break;
} while (true);

// 动态地生成代理类的字节码数组
byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces);
try { // 动态地定义新生成的代理类proxyClass = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) { throw new IllegalArgumentException(e.toString());
} // 把生成的代理类的类对象记录进 proxyClasses 表
proxyClasses.put(proxyClass, null);

// 假设需代理接口 Simulator
public interface Simulator { short simulate(int arg1, long arg2, String arg3) throws ExceptionA, ExceptionB;
} // 假设代理类为 SimulatorProxy, 其类声明将如下
final public class SimulatorProxy implements Simulator { // 调用处理器对象的引用protected InvocationHandler handler; // 以调用处理器为参数的构造函数public SimulatorProxy(InvocationHandler handler){ this.handler = handler; } // 实现接口方法 simulate public short simulate(int arg1, long arg2, String arg3) throws ExceptionA, ExceptionB {// 第一步是获取 simulate 方法的 Method 对象java.lang.reflect.Method method = null; try{ method = Simulator.class.getMethod( "simulate", new Class[] {int.class, long.class, String.class} );} catch(Exception e) { // 异常处理 1（略）
        } // 第二步是调用 handler 的 invoke 方法分派转发方法调用Object r = null; try { r = handler.invoke(this, method, // 对于原始类型参数需要进行装箱操作new Object[] {new Integer(arg1), new Long(arg2), arg3});}catch(Throwable e) { // 异常处理 2（略）
        } // 第三步是返回结果（返回类型是原始类型则需要进行拆箱操作）return ((Short)r).shortValue();}
}

Object r = null; try { r = handler.invoke(this, method, new Object[] {new Integer(arg1), new Long(arg2), arg3}); } catch( ExceptionA e) { // 接口方法支持 ExceptionA，可以抛出throw e; } catch( ExceptionB e ) { // 接口方法支持 ExceptionB，可以抛出throw e; } catch(Throwable e) { // 其他不支持的异常，一律抛 UndeclaredThrowableException throw new UndeclaredThrowableException(e);
}