java 反射机制
class Type{
public int pubIntField;
public String pubStringField;
private int prvIntField;
public Type(){
Log("Default Constructor");
}
Type(int arg1, String arg2){
pubIntField = arg1;
pubStringField = arg2;
Log("Constructor with parameters");
}
public void setIntField(int val) {
this.prvIntField = val;
}
public int getIntField() {
return prvIntField;
}
private void Log(String msg){
System.out.println("Type:" + msg);
}
}
class ExtendType extends Type{
public int pubIntExtendField;
public String pubStringExtendField;
private int prvIntExtendField;
public ExtendType(){
Log("Default Constructor");
}
ExtendType(int arg1, String arg2){
pubIntExtendField = arg1;
pubStringExtendField = arg2;
Log("Constructor with parameters");
}
public void setIntExtendField(int field7) {
this.prvIntExtendField = field7;
}
public int getIntExtendField() {
return prvIntExtendField;
}
private void Log(String msg){
System.out.println("ExtendType:" + msg);
}
}
1、获取类的Class对象
| 调用getClass |
Boolean var1 = true; Class<?> classType2 = var1.getClass(); System.out.println(classType2); 输出：class java.lang.Boolean |
| 运用.class 语法 |
Class<?> classType4 = Boolean.class; System.out.println(classType4); 输出：class java.lang.Boolean |
| 运用static method Class.forName() |
Class<?> classType5 = Class.forName("java.lang.Boolean"); System.out.println(classType5); 输出：class java.lang.Boolean |
|
运用primitive wrapper classes的TYPE 语法 这里返回的是原生类型，和Boolean.class返回的不同 |
Class<?> classType3 = Boolean.TYPE; System.out.println(classType3); 输出：boolean
|
2、获取类的Fields
| public Field getField(String name) | 返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段 |
| public Field[] getFields() | 返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段 |
| public FieldgetDeclaredField(Stringname) | 返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段 |
| public Field[] getDeclaredFields() | 返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段 |
可见getFields和getDeclaredFields区别：
getFields返回的是申明为public的属性，包括父类中定义，
getDeclaredFields返回的是指定类定义的所有定义的属性，不包括父类的。
3、获取类的Method
通过反射机制得到某个类的某个方法，然后调用对应于这个类的某个实例的该方法
Class<T>类提供了几个方法获取类的方法。
| public Methodget Method(String name,Class<?>... parameterTypes) |
返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法 |
| public Method[] getMethods() | 返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法 |
| public Method getDeclaredMethod(Stringname,Class<?>... parameterTypes) | 返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法 |
| public Method[] getDeclaredMethods() |
返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法 |
4、获取类的Constructor
通过反射机制得到某个类的构造器，然后调用该构造器创建该类的一个实例
Class<T>类提供了几个方法获取类的构造器。
| public Constructor<T> getConstructor(Class<?>... parameterTypes) | 返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法 |
| public Constructor<?>[] getConstructors() | 返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法 |
| public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) | 返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法 |
| public Constructor<?>[] getDeclaredConstructors() | 返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。它们是公共、保护、默认（包）访问和私有构造方法 |
5、新建类的实例
通过反射机制创建新类的实例，有几种方法可以创建
| 调用无自变量ctor |
1、调用类的Class对象的newInstance方法，该方法会调用对象的默认构造器，如果没有默认构造器，会调用失败. Class<?> classType = ExtendType.class; Object inst = classType.newInstance(); System.out.println(inst); 输出： Type:Default Constructor ExtendType:Default Constructor
2、调用默认Constructor对象的newInstance方法 Class<?> classType = ExtendType.class; Constructor<?> constructor1 = classType.getConstructor(); Object inst = constructor1.newInstance(); System.out.println(inst); 输出： Type:Default Constructor ExtendType:Default Constructor com.quincy.ExtendType@1006d75 |
| 调用带参数ctor |
3、调用带参数Constructor对象的newInstance方法 Constructor<?> constructor2 = classType.getDeclaredConstructor(int.class, String.class); Object inst = constructor2.newInstance(1, "123"); System.out.println(inst); 输出： Type:Default Constructor ExtendType:Constructor with parameters com.quincy.ExtendType@15e83f9 |
6、调用类的函数
通过反射获取类Method对象，调用Field的Invoke方法调用函数。
1 Class<?> classType = ExtendType.class; 2 Object inst = classType.newInstance(); 3 Method logMethod = classType.getDeclaredMethod("Log", String.class); 4 logMethod.invoke(inst, "test"); 5 6 输出： 7 Type:Default Constructor 8 ExtendType:Default Constructor 9 <font color="#ff0000">Class com.quincy.ClassT can not access a member of class com.quincy.ExtendType with modifiers "private"</font> 10 11 上面失败是由于没有权限调用private函数，这里需要设置Accessible为true; 12 Class<?>classType = ExtendType.class; 13 Object inst = classType.newInstance(); 14 Method logMethod = classType.getDeclaredMethod("Log", String.class); 15 logMethod.setAccessible(true); 16 logMethod.invoke(inst, "test");
7、设置/获取类的属性值
通过反射获取类的Field对象，调用Field方法设置或获取值
Class<?> classType = ExtendType.class; Object inst = classType.newInstance(); Field intField = classType.getField("pubIntExtendField"); intField.<strong>setInt</strong>(inst, 100); int value = intField.<strong>getInt</strong>(inst);
四、动态创建代理类
代理模式：代理模式的作用=为其他对象提供一种代理以控制对这个对象的访问。
代理模式的角色：
动态Proxy是这样的一种类:
它是在运行生成的类，在生成时你必须提供一组Interface给它，然后该class就宣称它实现了这些interface。你可以把该class的实例当作这些interface中的任何一个来用。当然，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。
在使用动态代理类时，我们必须实现InvocationHandler接口
抽象角色：声明真实对象和代理对象的共同接口
代理角色：代理角色内部包含有真实对象的引用，从而可以操作真实对象。
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。
步骤：
1、定义抽象角色
public interface Subject {
public void Request();
}
2、定义真实角色
public class RealSubject implements Subject {
@Override
public void Request() {
// TODO Auto-generated method stub
System.out.println("RealSubject");
}
}
3、定义代理角色
public class DynamicSubject implements InvocationHandler {
private Object sub;
public DynamicSubject(Object obj){
this.sub = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
System.out.println("Method:"+ method + ",Args:" + args);
method.invoke(sub, args);
return null;
}
}
4、通过Proxy.newProxyInstance构建代理对象
RealSubject realSub = new RealSubject();
InvocationHandler handler = new DynamicSubject(realSub);
Class<?> classType = handler.getClass();
Subject sub = (Subject)Proxy.newProxyInstance(classType.getClassLoader(),
realSub.getClass().getInterfaces(), handler);
System.out.println(sub.getClass());
5、通过调用代理对象的方法去调用真实角色的方法。
sub.Request();
输出：
class $Proxy0 新建的代理对象，它实现指定的接口
Method:public abstract void DynamicProxy.Subject.Request(),Args:null
RealSubject 调用的真实对象的方法
