Java基础--反射

1==User类

package test.reflect;

public class User {

	Integer id = 22;
	String name;
	String[] teachers;

	public User() {
		super();
	}

	public User(Integer id, String name, String[] teachers) {
		super();
		this.id = id;
		this.name = name;
		this.teachers = teachers;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String[] getTeachers() {
		return teachers;
	}

	public void setTeachers(String[] teachers) {
		this.teachers = teachers;
	}

}

2反射

package test.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Iterator;

public class ReflectUtil {

	public static void main(String[] args) {
		/** 
         * Class--每个类加载之后都是生成一个对象的Class对象，通过该Class对象可以访问jvm虚拟机的这个类信息,构造函数，属性，方法，参数，注解。 
         * 类获取class对象的三种方式： 
         * 1:使用Class.forName(包名+类名) 
         * 2:某个类的.class属性来获取Class对象 
         * 3:调用某个对象的getClass() 方法获取Class对象 
         *  
         * 反射就是可以通过程序动态的去修改jvm虚拟机已经被加载好的方法区区域里面的属性，成员变量。赋值，调用方，传递参数. 
        */  
          
        /** 
         * 1:只有对象才能够调用方法和给成员属性赋值的能力 
         * 2:反射基础一定还是要创建对象--值注入，对象的转换（bean-map）(map-bean)(bean-xml)(xml-bean)(bean-json/map)(json-bean/map) 
         * 创建对象： 
         * 1:new 
         * 2:反射--spring ioc /struts2/mybatis等都是用反射区创建对象 
         * 3:ObjectInputStream 序列化和反序列  implements Serializable--Hibernate 
         * 4:clone implements Cloneable 
         * 5:Object创建对象 
         * 如果不理解反射，就把当做一种对象调用方法给成员变量赋值的方式 
         */  
		
		/*
		 * 类中：
			 * 成员变量
			 * 构造函数
			 * 成员方法
			 * 内部类
			 * 代码块
		 * */
		/*
		 * 反射操作---内部还是用对象
		 * 第一步：拿到当前类的class对象
		 * 第二步：还要实例化对象
		 * 第三步：开始动态解析class文件中的构造函数，成员变量，成员方法，内部类 (注解和参数)
		 * */
		
		try {
			//反射解析属性
			 //第一种创建方法  
//          Class clz1 = User.class;  
            //第二种创建方法  
//          User user = new User();  
//          Class clz2 = user.getClass();  
            //对象的创建(一般推荐)  
            Class clz = Class.forName("test.reflect.User");  
            User user = (User)clz.newInstance(); 
            
            //解析单个属性
            System.out.println("解析单个属性");
            Field field1 = clz.getDeclaredField("id");
            System.out.println("单个属性名称:"+field1.getName());
            System.out.println("单个属性的值:"+field1.get(user));
            System.out.println("===============================");
            
            //解析所有属性
            System.out.println("解析所有属性");
            Field[] fields = clz.getDeclaredFields(); // Declared 代表忽略访问修饰符, 如果不加的只能访问public修饰的成员属性(变量和方法)
            for (Field field : fields) {
				field.setAccessible(true); //可以访问私有 成员属性
				System.out.println("属性名称:"+field.getName());
				System.out.println("属性的数据类型:"+field.getType());
				System.out.println("属性的修饰符:"+field.getModifiers()); //System.out.println(Modifier.PUBLIC);//1
				System.out.println("属性的值:"+field.get(user));//从user对象中获取值
				System.out.println("-----------------------------");
			}
            System.out.println("===============================");
            
            //解析方法
            System.out.println("解析方法");
            Method setMethod = clz.getDeclaredMethod("setId", clz.getDeclaredField("id").getType()); //解析setId 方法
            setMethod.invoke(user, 11); //使用解析出的方法赋值
            System.out.println(user.getId());

            Method getMethod = clz.getMethod("getName"); // Declared 代表忽略访问修饰符, 如果不加的只能访问public修饰的成员属性(变量和方法)
            user.setName("fyl");
            Object obj = getMethod.invoke(user);
            System.out.println(obj);
            System.out.println("===============================");
            
            //解析构造函数
            System.out.println("解析构造函数");
            Constructor[] constructors = clz.getDeclaredConstructors();
            System.out.println("构造函数的个数是:===="+constructors.length);
            for (Constructor constructor : constructors) {
				System.out.println("构造函数的名称"+constructor.getName());
				System.out.println("访问修饰符:"+constructor.getModifiers());
				System.out.println("构造函数中参数的个数:"+constructor.getParameterCount());
				Class[] types = constructor.getParameterTypes();
				for (Class class1 : types) {
					System.out.print(class1.getName()+"\t");
				}
				System.out.println("\n"+"--------------------");
			}
            
            Constructor constructor1 = clz.getDeclaredConstructor(Integer.class,String.class,String[].class);
            String[] teachers = {"ff","yy","ll"};
            User obj2 = (User)constructor1.newInstance(123,"abcd",teachers);
            System.out.println("1======"+obj2);
            System.out.println(obj2.getId()+obj2.getName()+obj2.getTeachers());
            System.out.println("===============================");


		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

3执行结果

解析单个属性
单个属性名称:id
单个属性的值:22
===============================
解析所有属性
属性名称:id
属性的数据类型:class java.lang.Integer
属性的修饰符:0
属性的值:22
-----------------------------
属性名称:name
属性的数据类型:class java.lang.String
属性的修饰符:0
属性的值:null
-----------------------------
属性名称:teachers
属性的数据类型:class [Ljava.lang.String;
属性的修饰符:0
属性的值:null
-----------------------------
===============================
解析方法
11
fyl
===============================
解析构造函数
构造函数的个数是:====2
构造函数的名称test.reflect.User
访问修饰符:1
构造函数中参数的个数:0

--------------------
构造函数的名称test.reflect.User
访问修饰符:1
构造函数中参数的个数:3
java.lang.Integer	java.lang.String	[Ljava.lang.String;	
--------------------
2======test.reflect.User@6d06d69c
123abcd[Ljava.lang.String;@7852e922
===============================

二：

package com.jspwb.framework.test;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

import com.jspwb.sysmanage.bean.User;
import com.jspwb.sysmanage.bean.UserReflect;

public class reflectTest {

	public static void beanReflect(Object objFrom,Object objTo) {
		//取到类的Class对象
		Class objFromClass = objFrom.getClass();
		Class objToClass = objTo.getClass();
		
		//获取类的域，即获取类的属性
		Field[] objFromFields = objFromClass.getDeclaredFields();
		Field[] objToFields = objToClass.getDeclaredFields();
		
		
		for (int i = 0; i < objFromFields.length; i++) {
			//获取属性名
			String objFromFieldsName = objFromFields[i].getName();
			if (!objFromFieldsName.equals("serialVersionUID")) {
				for (int j = 0; j < objToFields.length; j++) {
					//获取属性名
					String objToFieldsName = objToFields[j].getName();
					//拼装方法名
					if (objFromFieldsName.equals(objToFieldsName)) {
						String getMethodFrom = "get" + objFromFieldsName.substring(0, 1).toUpperCase()+
												objFromFieldsName.substring(1);
						String setMethodTo = "set" + objToFieldsName.substring(0,1).toUpperCase() +
												objToFieldsName.substring(1);
//						System.out.println(getMethodFrom+"======"+setMethodTo);
						
						try {
							//获取方法
							@SuppressWarnings("unchecked")
							Method getMethod = objFromClass.getMethod(getMethodFrom, new Class[]{});
							@SuppressWarnings("unchecked")
							Method setMethod = objToClass.getMethod(setMethodTo, new Class[]{objToFields[j].getType()});
							
							//执行
							Object fromValue = getMethod.invoke(objFrom, new Object[]{});
							setMethod.invoke(objTo, new Object[]{fromValue});
						} catch (Exception e) {
							e.printStackTrace();
						} 
					}
				}
			}
		}
	}
	
	public static void main(String[] args) {
		User user = new User();
		user.setMobile("18618121212");
		user.setUserName("fyl");
		UserReflect userReflect = new UserReflect();
		
		beanReflect(user, userReflect);
		
		System.out.println(userReflect.getUserName()+"==="+userReflect.getMobile());
	}
}