Java进阶 六 Java反射机制可恶问题NoSuchFieldException

作为一种重要特性，Java反射机制在很多地方会用到。在此做一小结，供朋友们参考。

首先从一个问题开始着手。

 

可恶的问题又来了，NoSuchFieldException，如下图所示：

 

完全不知道这个question是从哪里来的。以前也遇到过这样的问题，后来解决了，但是没有写文档，再次相遇这样的问题，傻了。

经过上网一番查找，发现遇到这个问题的小盆友还真不少，这个问题是属于java反射机制里的。

这是一个反射对象时候的异常，已经被捕获了的。这个报错代码是混淆了的，是不是这个question对象被混淆成其他名了。。

源代码如下：

public static <T> List<T> findMoreRefResult(String sql, List<Object> params,

Class<T> cls) throws Exception {

 

//加载数据库驱动

new MysqlUtil();

 

//连接数据库

MysqlUtil.GetConnection();

 

// 构造一个初始容量为 10 的空列表。

List<T> list = new ArrayList<T>();

 

// 表示占位符的第一个位置

int index = 1;

 

pstmt = connection.prepareStatement(sql);

 

System.out.println("MysqlUtil:" + params);

 

// 判断所填充的占位符是否有值；判断集合的标准方式

if (params != null && !params.isEmpty()) {

for (int i = 0; i < params.size(); i++) {

 

// 使用给定对象设置指定参数的值。第二个参数必须是Object类型

pstmt.setObject(index++, params.get(i));

 

}

}

 

// 返回查询结果

resultset = pstmt.executeQuery();

 

// 获取列的相关信息

java.sql.ResultSetMetaData metdata = resultset.getMetaData();

 

// 获取列数

int col_lenth = metdata.getColumnCount();

while (resultset.next()) {

 

// 通过反射机制创建一个实例(生成对象)

T resultObject = cls.newInstance();

for (int i = 0; i < col_lenth; i++) {

String cols_name = metdata.getColumnName(i + 1);

Object cols_value = resultset.getObject(cols_name);

if (cols_value == null) {

cols_value = "";

}

 

// 通过字段名获得反射(返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段)

Field field = cls.getDeclaredField(cols_name);

 

// 打开javabean的私有访问权限

field.setAccessible(true);

field.set(resultObject, cols_value);

}

list.add(resultObject);

}

 

//关闭数据库

MysqlUtil.releaseConn();

 

return list;

}

调用以上方法的方法如下：

public static void main(String[] args) {

 

//Question question = new Question();

//

//Field property = null;

//try {

//property = question.getClass().getDeclaredField("description");

//} catch (NoSuchFieldException e1) {

//e1.printStackTrace();

//} catch (SecurityException e1) {

//e1.printStackTrace();

//}

//        System.out.println(property);

 

List<Object> params = new ArrayList<Object>();

 

String sql = "SELECT * FROM question ";

 

try {

System.out.println(MysqlUtil.findMoreRefResult(sql, params, Question.class));

} catch (Exception e) {

e.printStackTrace();

} 

}

在调用findMoreRefResult()方法的时候，请注意红色背景部分，先获取数据库表中字段名，然后依据该字段名来反射此 Class 对象所表示的类或接口的指定已声明字段。也就是说数据库中的字段名应该与类中的属性字段名一一对应才对，这是符合“建数据表时应与类一一对应”原则的。

下面，我们来深入学习一下Java的反射机制，只有做到深入了解某件事情，当这件事情发生问题时，我们自然就会懂得解决之道。

注：下面的内容只了解基本的原理就行，代码可忽略。

 

一、反射的基础---Class

Class是所有java类的一个总称，就好像各式各样的人都可以用Person来称呼，每一个类被加载之后都会在内存中生存一个Class对象，这个对象我们通常称之为字节码，而我们通过调用一个类创造的对象其实都是字节码搞出来的，一个类只会产生一份字节码。

 那么我们怎么获得一个类的Class呢？有三种方式：

    1.调用某个类的class属性  

    2.使用Class的forName()静态方法  

    3.调用某个对象的getClass()方法。

 

下面我们通过一个实例来展示下上面两点：

ClassDemo1.java

 

package com.lyl.exercise;  

  

public class ClassDemo1 {  

    public static void main(String[] args) throws ClassNotFoundException{  

        String str="iteye";  

        Class cl1=String.class;  

        Class cl2=str.getClass();  

        Class cl3=Class.forName("java.lang.String");  

        System.out.println("str对象与String是同一份字节码吗？"+(cl1==cl2));  

        System.out.println("通过Class.forName()获得的字节码与String.class一样吗？"+(cl1==cl3));  

    }  

}  

 

通过查看JDK文档，我们可以发现，Class有许多方法，通过这些方法我们可以得到java类的相关信息，Constructor,Method,Field等，具体的大家可以参考JDK文档。

 

二、反射的应用

那么什么是反射呢？曾经有人说过，反射就是把java类中的各种成分映射成相应的java类。为什么呢？从上一个讲解中大家是否发现，通过Class我们可以解析出一个java类的各种成分，他们返回的也是一个类，所以这句话还是很有道理的。

下面让我们来看看反射的一些应用：

    1.使用反射生成对象

     通过反射来生成对象有两种方式：

        a.使用Class对象的newInstance()方法

        b.使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建Class对应类的实例。

 

实例： ClassDemo3.java

 

package com.lyl.exercise;  

  

import java.lang.reflect.Constructor;  

  

public class ClassDemo3 {  

    public static void main(String[] args) throws Exception{  

        //使用Class对象的newInstance()方法  

        String str=(String)Class.forName("java.lang.String").newInstance();  

        //使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建Class对应类的实例。  

        Constructor constructor=String.class.getConstructor(StringBuffer.class);  

        String str2=(String)constructor.newInstance(new StringBuffer("abc"));  

    }  

}  

 

     2.成员变量的反射

 

     接上实例大家看看：

 

ReflectDemo1.java

 

package com.lyl.exercise;  

  

import java.lang.reflect.Field;  

  

public class ReflectDemo1 {  

    public static void main(String[] args) throws Exception {  

        ReflectHelper rh=new ReflectHelper("iteye", "javaeye");  

        Field fieldb=rh.getClass().getField("b");  

        //fieldb只是类的字段，不是对象的，所以要想获得对象上的值，要使用get()方法  

        System.out.println(fieldb.get(rh));  

        //如果我们使用上面方法来访问a的值呢？抛出java.lang.NoSuchFieldException  

        /*Field fielda=rh.getClass().getField("a"); 

        System.out.println(fieldb.get(rh)); 

        因为a是私有成员变量 

        */  

        //我们可以通过暴力反射来获取它的值  

        Field fielda=rh.getClass().getDeclaredField("a");  

        //设置为可以访问  

        fielda.setAccessible(true);  

        System.out.println(fielda.get(rh));  

    }  

}  

 

ReflectHelper.java

 

package com.lyl.exercise;  

 

public class ReflectHelper {  

    private String a;  

    public String b;  

    public ReflectHelper(String a,String b){  

        this.a=a;  

        this.b=b;  

    }  

}  

 

如果将上面的搞懂，那么我们不妨来做一道经典的题目：将一个类中所有String类型的成员变量，其中含有的‘a’替换为‘b’。

这个题目很明显通过反射可以轻易的完成，大家不妨来看看。

 

package com.lyl.exercise;  

  

import java.lang.reflect.Field;  

  

public class ReflectDemo2 {  

    public static void main(String[] args) throws Exception {  

        ReflectHelper rh=new ReflectHelper("abc", "basketball");  

        changeStringValue(rh);  

        System.out.println(rh);  

    }  

  

    private static void changeStringValue(Object object) throws Exception{  

        Field[] fields=object.getClass().getFields();  

        for(Field field:fields){  

            if(field.getType()==String.class){  

                String oldValue=(String)field.get(object);  

                String newValue=oldValue.replace(‘a‘,‘b‘);  

                //将object的String类型的变量替换为newValue  

                field.set(object, newValue);  

            }  

        }  

    }  

}  

 

这样就搞定了，是不是很简单？

 

一、ClassLoader初步

类加载器负责加载所有的类，系统为所有被载入内存中的类生成一个java.lang.Class实例。一旦一个类被载入到JVM中，同一个类就不会再次被载入了，这是针对同一个加载器，不同的加载器还是可以加载同一个类的，不同加载器加载同一个类在JVM中是不同的。因为在JVM中用类的全限定类名加类加载器作为其唯一标识。

    在JVM启动时，会形成有三个类加载器组成的初始类加载器层次结构：

    -->Bootstrap ClassLoader:根类加载器

    -->Extension ClassLoader:扩展类加载器

    -->System ClassLoader:系统类加载器

 

Bootstrap ClassLoader是使用C++写的，我们是无法得到它的源码，它是java的核心Loader，比如我们通过String.class.getClassLoader()是获得不到它的名字的，返回的是空值。

如果父类加载器加载了某个类，子类就不会加载了。

   ClassLoader动态加载：

    a.并非一次性加载

    b.需要运行时才加载

    c.可以观察类的具体加载过程：java -verbose:class  在eclipse中只要配置后面的-verbose:class

    d.static语句块在加载后执行一次。

    e.dynamic语句块每次new新的对象都会执行

        等同于构造方法中的语句。

        用的比较少。

具体看参见：http://gzcj.iteye.com/blog/394644

 

二、使用反射实现JDK动态代理

在java中提供了Proxy类和一个InvocationHandler接口，通过他们俩我们就可以创建JDK动态代理，下面让我们通过一个实例来看看如何使用吧：

Person接口

  

package com.lyl.reflect;  

  

public interface Person {  

    void walk();  

    void sayHello(String name);  

}  

 

MyInvocationHandler.java  

  

package com.lyl.reflect;  

  

import java.lang.reflect.InvocationHandler;  

import java.lang.reflect.Method;  

  

public class MyInvocationHandler implements InvocationHandler {  

  

    @Override  

    public Object invoke(Object proxy, Method method, Object[] args)  

            throws Throwable {  

        System.out.println("正在运行的方法："+method);  

        if(args!=null){  

            System.out.println("执行该方法传入的参数：");  

            for(Object arg:args){  

                System.out.println(arg);  

            }  

        }else {  

            System.out.println("该方法没有传入参数！");  

        }  

        return null;  

    }  

  

}  

 

ProxyTest.java  

  

package com.lyl.reflect;  

  

import java.lang.reflect.InvocationHandler;  

import java.lang.reflect.Proxy;  

  

public class ProxyTest {  

    public static void main(String[] args) {  

        InvocationHandler handler=new MyInvocationHandler();  

        //返回Person接口的代理类实例  

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

        person.walk();  

        person.sayHello("ITEYE");  

    }  

}  

 通过Proxy类的newProxyInstance()方法我们可以获得一个指定接口的代理类实例，在MyInvocationHandler中会自动执行invoke方法，执行结果如下：

正在运行的方法：public abstract void com.lyl.reflect.Person.walk()  

该方法没有传入参数！  

正在运行的方法：public abstract void com.lyl.reflect.Person.sayHello(java.lang.String)  

执行该方法传入的参数：  

ITEYE  

 

首先必须明一点 Field类主要是用来辅助获取和操作类的属性的！

 

1.怎么通过反射获取类的属性

 

 先来看JDK提供的方法有如下几种：

 

  a)Class.getDeclaredField(String name);

 

返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。

 

  b)Class.getDeclaredFields();

 

返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。

 

  c)Class.getField(String name);

 

返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。

 

  d)Class.getField();

 

返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。

 

来一个例子来说明一下 ：

实体类：

import java.util.Date;

/**

 * @ClassName: Student

 * @Description: 学生实体

 * @author  ***  

 * @date 2014-3-18 下午5:17:35

 * @version V1.0 

 */

public class Student

{

  private Long id;

  private String name;

  private Date createdate;

  private String no;

  public String nickname;

public Long getId()

{

    return id;

}

public void setId(Long id)

{

    this.id = id;

}

public String getName()

{

    return name;

}

public void setName(String name)

{

    this.name = name;

}

................   

} 

测试类：

 

import java.lang.reflect.Field;

import java.util.Date;

/**

 * @ClassName: ReflectFieldTest

 * @Description: 反射Field测试。

 * @author  ***  

 * @date 2014-3-18 下午5:16:17

 * @version V1.0 

 */

public class ReflectFieldTest

{

  

   public static void main(String[] args)

{    

Student stu=new Student();

      stu.setId(1L);

      stu.setName("Josean");

      stu.setNo("201403185203344");

      stu.setCreatedate(new Date());

     try

     {

         Field property1=stu.getClass().getDeclaredField("name");

//private java.lang.String com.cx.test.Student.name

        System.out.println(property1);

        Field property3=stu.getClass().getField("nickname");

//public java.lang.String com.cx.test.Student.nickname

        System.out.println(property3);

        //错误方法 getField系列方法只能获取公共字段

        //Field property2=stu.getClass().getField("name");

        //System.out.println(property2);

        //会抛java.lang.NoSuchFieldException

        

     } catch (SecurityException e)

     {

         e.printStackTrace();

     } catch (NoSuchFieldException e)

     {

         e.printStackTrace();

     }

}   

}

 

2.进行属性获取、更改

得到这个Field之后你就可以获取他的值或者设置他的值了。

 

获取它的值用get类型方法，针对常见类型提供了对应get方法，这里就不一一列举了。

 

值得注意的是获取私有属性的时候必须先设置Accessible为true，然后才能获取。

 

同理设置的时候调用set类型方法，这里也不一一列举了，下面放代码。

 

import java.lang.reflect.Field;

import java.util.Date;

/**

 * @ClassName: ReflectFieldTest

 * @Description: 反射Field测试。

 * @author JoseanLuo  

 * @date 2014-3-18 下午5:16:17

 * @version V1.0 

 */

public class ReflectFieldTest

{

  

    public static void main(String[] args) throws Exception

{    Student stu=new Student();

     stu.setId(1L);

     stu.setName("Josean");

     stu.setNo("201403185203344");

     stu.setCreatedate(new Date());

     stu.setNickname("copyman");

        Field property1=stu.getClass().getDeclaredField("name");

        //System.out.println(property1);

//out:private java.lang.String com.cx.test.Student.name

        Field property3=stu.getClass().getField("nickname");

        System.out.println(property3.get(stu));

        //System.out.println(property3);

//out:public java.lang.String com.cx.test.Student.nickname

        //错误方法 getField系列方法只能获取公共字段

        //Field property2=stu.getClass().getField("name");

        //System.out.println(property2);

        //会抛java.lang.NoSuchFieldException

        Field [] prFields4=stu.getClass().getDeclaredFields();

        for(Field field:prFields4)

        {

            System.out.println(field);

            System.out.println(field.equals(property1));

            //私有变量必须先设置Accessible为true

            field.setAccessible(true);

            //获取用get类方法。

            System.out.println(field.get(stu));

        }

        //设置用set类方法

        property3.set(stu, "名字被我改了，哈哈");

          

        System.out.println(stu.getNickname());        

}

     

}

这个是控制台输出：

copyman

private java.lang.Long com.cx.test.Student.id

false

1

private java.lang.String com.cx.test.Student.name

true

Josean

private java.util.Date com.cx.test.Student.createdate

false

Tue Mar 18 18:19:39 CST 2014

private java.lang.String com.cx.test.Student.no

false

201403185203344

public java.lang.String com.cx.test.Student.nickname

false

copyman

名字被我改了，哈哈