Java反射机制可恶问题NoSuchFieldException
-----解决方案--------------------
getDeclaredMethod(String name,Class...parameterType)第一个参数是函数名 字符串类型 第二个是一个可变参数 ，传入的是那个函数（如你所讲的“study”函数）的字节码 参数是String类型的话就得传入String.class int类型的就的是int.class
------解决方案--------------------
getDeclaredMethod(String name,Class...parameterType);
这个方法是接受一个String类型参数，一个或者任意多个class类型的参数
所以选择C int.class是正确的等价于Integer.TYPE;Integer.class;其实用第三种会更加容易理解
作为一种重要特性，Java反射机制在很多地方会用到。在此做一小结，供朋友们参考。
首先从一个问题开始着手。
如果把Person类的setName方法的访问权限设为私有
private void setName(String name){
this.name=name;
}
这是再运行程序，则会抛出NoSuchMethodException异常
Exception in thread "main" java.lang.NoSuchMethodException: com.anbo.reflect.classinfo.Person.setName(java.lang.String)
at java.lang.Class.getMethod(Class.java:1607)at com.anbo.reflect.classinfo.TestReflection4.main(TestReflection4.java:18)
为什么会出现该错误呢？
这是因为当通过Method的invoke()方法调用对应的方法时，Java会要求程序必须有调用该方法的权限。如果程序确实需要调用某个对象的private方法，可以先调用setAccessible(Boolean flag)方法。将Method对象的Accessible标志设置为指示的布尔值，值为true则表示该Method在使用时应该取消Java语言访问权限检查。值为false则表示该Method在使用时应该实施Java语言访问权限检查。
解决方案：
1. 将Person类中setName方法的访问权限设为public（在不需要调用某个对象的private方法）
2. 不改变私有访问权限，先调用setAccessible(true)方法取消Java语言访问权限检查，在调用需要调用的方法。（确实需要调用某个对象的private方法）
//获取cla对象的指定方法"setName“方法
Method m=cla.getDeclaredMethod("setName", String.class);
//取消Java语言访问权限检查
m.setAccessible(true);
//调用m方法，传入参数
m.invoke(p, "huahua");
//获取cla对象的指定方法"getName()"方法
Method method=cla.getMethod("getName", null);
//调用method方法，传入参数
Object o=method.invoke(p, null);
System.out.println(o);
控制台打印结果：
可恶的问题又来了，NoSuchFieldException，如下图所示：
完全不知道这个question是从哪里来的。以前也遇到过这样的问题，后来解决了，但是没有写文档，再次相遇这样的问题，傻了。
经过上网一番查找，发现遇到这个问题的小盆友还真不少，这个问题是属于java反射机制里的。
这是一个反射对象时候的异常，已经被捕获了的。这个报错代码是混淆了的，是不是这个question对象被混淆成其他名了。。
源代码如下：
public static
Class
//加载数据库驱动
new MysqlUtil();
//连接数据库
MysqlUtil.GetConnection();
// 构造一个初始容量为 10 的空列表。
List
// 表示占位符的第一个位置
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
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
名字被我改了，哈哈