java反射复习（一）

   反射本身并不是一个新概念，尽管计算机科学赋予了反射概念新的含义。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。
  java.lang.reflection中的主要类 主要如下：
    1、Constructor<T> 提供关于类的单个构造方法的信息以及对它的访问权限。 Constructor      允许在将实参与带有基础构造方法的形参的 newInstance() 匹配时进行扩展转换，但是如果发生收缩转换，则抛出 IllegalArgumentException。newInstance(Object... initargs) 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
    2、Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。
    3、Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。 Method 允许在匹配要调用的实参与基础方法的形参时进行扩展转换；但如果要进行收缩转换，则会抛出 IllegalArgumentException。
    4、Modifier 类提供了 static 方法和常量，对类和成员访问修饰符进行解码。修饰符集被表示为整数，用不同的位位置 (bit position) 表示不同的修饰符。
    5、Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。 创建某一接口 Foo 的代理：
   

 InvocationHandler handler = new MyInvocationHandler(...);
     Class proxyClass = Proxy.getProxyClass(
         Foo.class.getClassLoader(), new Class[] { Foo.class });
     Foo f = (Foo) proxyClass.
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler });

或使用以下更简单的方法：
   

 Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class[] { Foo.class },
                                          handler);

动态代理类（以下简称为代理类）是一个实现在创建类时在运行时指定的接口列表的类，该类具有下面描述的行为。 代理接口 是代理类实现的一个接口。 代理实例 是代理类的一个实例。 每个代理实例都有一个关联的调用处理程序 对象，它可以实现接口 InvocationHandler。通过其中一个代理接口的代理实例上的方法调用将被指派到实例的调用处理程序的 Invoke 方法，并传递代理实例、识别调用方法的 java.lang.reflect.Method 对象以及包含参数的 Object 类型的数组。调用处理程序以适当的方式处理编码的方法调用，并且它返回的结果将作为代理实例上方法调用的结果返回。
   6、Array 类提供了动态创建和访问 Java 数组的方法。Array 允许在执行 get 或 set 操作期间进行扩展转换，但如果发生收缩转换，则抛出 IllegalArgumentException。

取得类名（接口）、方法名、属性名

 package taobao.com;

import java.lang.reflect.Field;

public class ReflectionTest {
    
	public static void main(String arg[]){
		Class<A> c = A.class;
		System.out.println(c.getName());
	    Field [] fields =	c.getFields();
	    Field [] declaredFields =	c.getDeclaredFields();
	    //只有public属性在Field[]中
	    for(Field f : fields){
	    	System.out.println(f.getName());
	    }
	    //私有变得都会在数组中
	    for(Field f:declaredFields)	{
	    	System.out.println(f.getName());
	    }
	}
}

class A {
	
	private int x;
	private String y;
	
	public String z;
	
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public String getZ() {
		return z;
	}
	public void setZ(String z) {
		this.z = z;
	}
	public String getY() {
		return y;
	}
	public void setY(String y) {
		this.y = y;
	}
    public int add(int t){
    	return x + t;
    }
}
  

反射重写tosring方法

public String toString(){
		StringBuffer bufferStr = new StringBuffer();
		Class<? extends A> c = this.getClass();
		int m = c.getModifiers();
		Field [] fields = c.getDeclaredFields();
		for(Field f : fields){
			Object o = null ;
			try {
				o = f.get(this);
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
			if( Modifier.isStatic(m) || Modifier.isFinal(m) ){
				continue;
			}else if(o != null ){
				bufferStr.append(f.getName()+":" +o.toString());
				bufferStr.append("     ");
			}
		}	
		return bufferStr.toString();
	}

显示类中的所有方法代码

		Class<A> c = A.class;
		Method[] m = c.getDeclaredMethods();
		for (int i = 0; i < m.length; i++) {
			// 输出方法的返回类型
			System.out.print(m[i].getReturnType().getName());
			// 输出方法名
			System.out.print(" " + m[i].getName() + "(");
			// 获取方法的参数
			Class[] parameterTypes = m[i].getParameterTypes();
			for (int j = 0; j < parameterTypes.length; j++) {
				System.out.print(parameterTypes[j].getName());
				if (parameterTypes.length > j + 1) {
					System.out.print(",");
				}
			}
			System.out.println(")");
		}

把DO转化成map

public Map<String, String> toMap(String[] ignoreFiled) {
		Map<String, String> map = new HashMap<String, String>();
		try {
			Class f = this.getClass();
			Field[] fields = f.getDeclaredFields();
			for(int i=0,len=fields.length;i<len;i++){
				String name = fields[i].getName();
				Object o = fields[i].get(this);
				
				//排除静态常量
				if(null != o 
						&& !Modifier.isFinal(fields[i].getModifiers()) 
						&& !Modifier.isStatic(fields[i].getModifiers())
						&& !ArrayUtil.contains(ignoreFiled, name)){
					String property = BeanUtils.getProperty(this, name);
					if(StringUtil.isBlank(property)) {						
						continue ;
					}
					
					map.put(name, property);
				}
			}
		} catch (Exception e) {
		}
		
		return map;
	}