Java反射入门

　　Java这么多高灵活性,非常多都是利用反射来实现的，所谓的反射是指，编译期间全然未知的classes，执行时，对任一个类（依据类名－字符串），可以知道这个类的全部属性和方法；对于任一个对象，都可以调用它的随意一个方法和属性。

     简而言之，Java反射机制主要提供了下面功能：

　　Ø  在执行时推断随意一个对象所属的类；obj.getClass()

　　Ø  在执行时构造随意一个类的对象；

　　Ø  在执行时推断随意一个类所具有的成员变量和方法；

　　Ø  在执行时调用随意一个对象的方法。

　　以下我们先用一个简单小例体现一下Java Reflect上述的功能，然后模拟一下Java Reflect应用之中的一个Hibernate的 ORMapping的实现。

 

Java反射功能測试

 

　　首先定义一个User.java类，代码例如以下：

package reflect;

/**
 *  @author--zhipeng 
 */
public class User {

	private String name;
	
	//构造方法1（默认构造方法）***********************
	public User(){
		
	}
	//构造方法2
	public User(String name){
		this.name=name;
	}
	//******自己定义方法*************
	public void getMessage(){
		System.out.print("kobe bryant never stop trying");
	}
	//******重写toString方法，在測试的时候会用到*****
	@Override
	public String toString() {
		return "name:"+this.name;
	}
	//**************************
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

}

　　以下我将在ReflectTest.java类中,首先获得User的类名，然后依据类名来获得类的方法、属性、注解等，并调用方法，代码例如以下：

package reflect;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import reflect.User;

/**
 *  @author--zhipeng 
 */
public class ReflectTest {

	public static void main(String[] args) throws Exception {
		Class clazz = User.class;//获得User的类名，返回reflect.User
		Object obj = create(clazz);//创建User的一个对象
		System.out.println(obj);//输出对象，会调用对象的toString方法
		System.out.println("---------");
		invoke1(obj, "getMessage");//调用User对象的getMessage方法
	}
	/*
	**依据类名，new一个对象，并返回*/
	static Object create(Class clazz) throws Exception {
		//假设clazz含有无參数的构造方法，能够例如以下方式实例化
		//clazz.newInstance();
		//依据类名和參数（类型、个数），找到对应的构造方法-以下创建构造方法參数为String的构造方法
		Constructor con=clazz.getConstructor(String.class);
		//实例化对象
		Object obj=con.newInstance("myName is zhipeng");
		//返回对象
		return obj;
	}
	/*
	**依据对象，方法名（字符串），来调用方法*/
	static void invoke1(Object obj, String methodName)throws Exception{
		//getDeclaredMethods能够获取类本身（不包含父类）全部方法的名字（包含私有方法）**一般不用这样的方法，私有的属性一般不能改动
		Method[] ms = obj.getClass().getDeclaredMethods();
		//getMethods能够获取类本身，以及父类的方法的名字，但不包含私有的方法
		ms = obj.getClass().getMethods();
		for (Method m : ms) {
			//假设方法名字匹配，则反射调用方法
			if (methodName.equals(m.getName()))
				m.invoke(obj, null);
		}
		/*
		**防止方法重载，可用以下的方式（能够指明參数）--与上面的for循环（无法防止方法重载）一个效果
		**Method m = obj.getClass().getMethod(methodName, null);
		**m.invoke(obj, null);
		*/
	}
	
	/*
	**依据类名获取类的属性（一般不直接操作属性）*/
	static void field(Class clazz) throws Exception {
		Field[] fs = clazz.getDeclaredFields();
		//fs = clazz.getFields();
		for (Field f : fs)
			System.out.println(f.getName());
	}
	/*
	**依据类名获取类的注解*/
	static void annon(Class clazz) throws Exception {
		Annotation[] as = clazz.getAnnotations();
		for (Annotation a : as)
			System.out.println(a.getName());
	}

}

　　执行结果：   

 

简单模拟ORMapping

 

　　上面我们測试了Java反射所提供的基本功能，以下简单模拟Hibernate的OR映射，基本思路就是传入sql语句，将结果集包装为object，并将结果集的字段与object的属性映射好，代码例如以下：

package reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 *  @author--zhipeng 
 */
public class ORMTest {

	public static void main(String[] args)throws Exception{
		//将select结果集（这里为一条）包装为User对象，并将结果集的字段，与User对象的属性映射
		User user = (User) getObject(
				"select id as Id, name as Name, birthday as Birthday, money as Money  from user where id=1",
				User.class);
		System.out.println(user);
	}
	//获取一个ResultSet的字段（列）名
	private static String[] getColNames(ResultSet rs) throws SQLException {
		ResultSetMetaData rsmd = rs.getMetaData();
		int count = rsmd.getColumnCount();
		String[] colNames = new String[count];
		for (int i = 1; i <= count; i++) {
			colNames[i - 1] = rsmd.getColumnLabel(i);
		}
		return colNames;
	}
	//传入一个sql语句与类名，返回一个对应类的对象
	static Object getObject(String sql, Class clazz) throws SQLException,Exception,
	 IllegalAccessException, InvocationTargetException
	{
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			//JdbcUtils为自己定义类-这里不多介绍
			conn = JdbcUtils.getConnection();
			ps = conn.prepareStatement(sql);
			rs = ps.executeQuery();
			//获取sql语句运行结果集的列名
			String[] colNames = getColNames(rs);
			Object obj=null;
			//获取clazz的全部方法名
			Method[] ms = clazz.getMethods();
			while (rs.next()) {
				obj = clazz.newInstance();//要求类必须有參数为空的构造方法，相似Hibernate
				for (int i = 0; i < colNames.length; i++) {
				//用set+"字段名"来匹配，实体类中字段的set方法
					String colName = colNames[i];
					String methodName = "set" + colName;
					//OR映射
					for (Method m : ms) {
						if (methodName.equals(m.getName())) {
							m.invoke(obj, rs.getObject(colName));
							break;
						}
					}
				}
			}
			return obj;
		} finally {
			JdbcUtils.free(rs, ps, conn);
		}
	}
}

　　上面的getObject(String sql, Class clazz)方法为映射一条数据，假设映射多条数据可改方法为：

	static List<Object> getObjects(String sql, Class clazz)
			throws SQLException, Exception, IllegalAccessException,
			InvocationTargetException {
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			conn = JdbcUtils.getConnection();
			ps = conn.prepareStatement(sql);
			rs = ps.executeQuery();
			String[] colNames = getColNames(rs);

			List<Object> objects = new ArrayList<Object>();
			Method[] ms = clazz.getMethods();
			while (rs.next()) {
				Object object = clazz.newInstance();
				for (int i = 0; i < colNames.length; i++) {
					String colName = colNames[i];
					String methodName = "set" + colName;
					for (Method m : ms) {
						if (methodName.equals(m.getName())) {
							m.invoke(object, rs.getObject(colName));
							break;
						}
					}
					objects.add(object);
				}
			}
			return objects;
		} finally {
			JdbcUtils.free(rs, ps, conn);
		}
	}

 

总结

 

　　Java反射这么灵活，无非是将曾经“编译时”必须做的事推迟到了“执行时”，而方式也就是由原先的对象到了灵活可配的“字符串”。

　　上面的映射方式是用构造字符串方式，set+”字段名”映射类的属性，Hibernate的映射当然要灵活复杂的多，通过配置文件来配置。可是实现原理差点儿相同，Java映射为Java灵活性做了非常好的支持。