java温故笔记（三）java的反射机制和场景应用

前言

java反射机制指的是在java运行过程中，对于任意的类都可以知道他的所有属性以及方法，对于任意一个对象都可以任意的调用他的属性和方法，这种动态获取对象信息和动态调用对象方法的功能称为java反射机制，但是反射使用不当会造成很高的成本。

简单实例

反射获取类名称

package top.crosssoverjie.study;
public class Reflect {
public static void main(String[] args) {
Class<Reflect> c1 = Reflect.class;
System.out.println(c1.getName());

Reflect r1 = new Reflect() ;
Class<Reflect> c2 = (Class<Reflect>) r1.getClass() ;
System.out.println(c2.getName());

try {
Class<Reflect> c3 = (Class<Reflect>) Class.forName("top.crosssoverjie.study.Reflect");
System.out.println(c3.getName());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}

输出结果：

top.crosssoverjie.study.Reflect
top.crosssoverjie.study.Reflect
top.crosssoverjie.study.Reflect

以上的 c1,c2,c3是完全一样的，他们都有一个统一的名称：叫做Reflect类的类类型。

反射的用处

获取成员方法

public Method getDeclaredMethod(String name,Class<?>...parameterTypes)//得到该类的所有方法，但是不包括父类的方法。
public Method getMethod(String name,Class<?>...parameterTypes)//获得该类的所有public方法，包括父类的。

通过反射获取成员方法调用的实例:

package top.crosssoverjie.study;

import java.lang.reflect.Method;

public class Person {
private String name="crossover" ;
private String msg ;

public Person(String name, String msg) {
this.name = name;
this.msg = msg;
System.out.println(name+"的描述是"+msg);
}

public Person() {
super();
}

public void say(String name ,String msg){
System.out.println(name+"说："+msg);
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}

public static void main(String[] args) {
try {
//首先获取类类型
Class c1 = Class.forName("top.crosssoverjie.study.Person") ;

//通过newInstance()方法生成一个实例
Object o1 = c1.newInstance() ;

//获取该类的say方法
Method m1 = c1.getMethod("say", String.class,String.class) ;

//通过invoke方法调用该方法
//            m1.invoke(o1, "张三","你好啊") ;

Method[] methods = c1.getDeclaredMethods() ;
//            for(Method m : methods){
//                System.out.println(m.getName());
//            }

Method[] methods2 = c1.getMethods() ;
for (Method method : methods2) {
System.out.println(method.getName());
}

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

3ff1

}
}

输出结果：

张三说：你好啊

所以我们只要知道类的全限定名就可以任意的调用里面的方法。

Method[] methods = c1.getDeclaredMethods() ;
for(Method m : methods){
System.out.println(m.getName());
}

输出结果：

main
getName
setName
say
getMsg
setMsg

使用的还是之前那个Person类，所以这里只写了关键代码。这里输出的是Person的所有public方法。

如果我们调用

getMethods()

方法会是什么结果呢？

Method[] methods2 = c1.getMethods() ;
for (Method method : methods2) {
System.out.println(method.getName());
}

输出结果:

main
getName
setName
say
getMsg
setMsgwait
wait
wait
hashCode
getClass
equals
toString
notify
notifyAll

这时我们会发现这里输出的结果会比刚才多得多，这时因为

getMethods()

方法返回的是包括父类的所有方法。

获取成员变量

我们还可以通过反射来获取类包括父类的成员变量，主要方法如下：

public Field getDeclaredFiled(String name)//获得该类所有的成员变量，但不包括父类的。
public Filed getFiled(String name)//获得该类的所有的public变量，包括其父类的。

还是按照之前例子中的Person类举例，他具有两个成员变量：

private String name="crossover" ;
private String msg ;

我们可以通过以下方法来获取其中的成员变量：

Class c1 = Class.forName("top.crosssoverjie.study.Person") ;
Field field = c1.getDeclaredField("name");//获取该类所有的成员属性

通过以下例子可以获取指定对象上此field的值：

package top.crosssoverjie.study;

import java.io.File;
import java.lang.reflect.Field;

public class Reflect {
public static void main(String[] args) {
try {
Class c1 = Class.forName("top.crosssoverjie.study.Person");
Field field = c1.getDeclaredField("name") ;
Object o1 = c1.newInstance() ;
/**
* 由于Person类中的name变量是private修饰的，
* 所以需要手动开启允许访问，是public修饰的就不需要设置了
*/
field.setAccessible(true);
Object name = field.get(o1) ;
System.out.println(name);
} catch (Exception e) {
e.printStackTrace() ;
}
//        Class<Reflect> c1 = Reflect.class;
//        System.out.println(c1.getName());
//
//        Reflect r1 = new Reflect() ;
//        Class<Reflect> c2 = (Class<Reflect>) r1.getClass() ;
//        System.out.println(c2.getName());
//
//        try {
//            Class<Reflect> c3 = (Class<Reflect>) Class.forName("top.crosssoverjie.study.Reflect");
//            System.out.println(c3.getName());
//        } catch (ClassNotFoundException e) {
//            e.printStackTrace();
//        }
}
}

输出结果：

crossover

我们也可以通过方法

getDeclaredFieds()

方法来获取所有的成员变量，返回是是一个

Field[]

数组，只需要遍历这个数组即可获所有的成员变量。例子如下：

Field[] fields = c1.getDeclaredFields() ;
for(Field f :fields){
System.out.println(f.getName());
}

输出结果如下：

name
msg

获取构造方法

可以通过以下两个方法来获取构造方法：

public Constructor getDeclaredConstructor(Class<?>...parameterTypes)//获取该类的所有构造方法，不包括父类的。
public Constructor getConstructor(Class<?>...parameterTypes)//获取该类的所有public修饰的构造方法，包括父类的。

在之前的Person类中有以下的构造方法：

public Person(String name, String msg) {
this.name = name;
this.msg = msg;
}

我们可以通过以下方法来获取Person类的构造方法：

Constructor dc1 = c1.getDeclaredConstructor(String.class,String.class) ;

具体代码如下：

    Constructor dc1 = c1.getDeclaredConstructor(String.class,String.class) ;dc1.setAccessible(true);
dc1.newInstance("小明","很帅") ;

dc1.newInstance("小明","很帅");

方法调用了Person类中的：

public Person(String name, String msg) {
this.name = name;
this.msg = msg;
System.out.println(name+"的描述是"+msg);
}

这个构造方法，如果不传参数的话，那么调用的就是无参的构造方法。输出结果为:

小明的描述是很帅

通过反射了解集合泛型的本质

通过以下例子程序可以看出：

package top.crosssoverjie.study;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class GenericEssence {
public static void main(String[] args) {
//声明两个list，一个有泛型，一个没有泛型
List list1 = new ArrayList() ;
List<String> list2 = new ArrayList<String>() ;

list2.add("你好") ;
//        list2.add(11) ;加上泛型之后在编译期间只能添加String，不然会报错。
System.out.println("list2的长度是："+list2.size());

Class c1 = list1.getClass();
Class c2 = list2.getClass() ;
System.out.print("c1,c2是否相等:");
System.out.println(c1==c2);

try {
//通过反射绕过编译器动态调用add方法，可能否加入非String类型的元素
Method method = c2.getDeclaredMethod("add", Object.class) ;
method.invoke(list2, 123) ;//在这里加入int类型，在上面如果加入int会出现编译报错。

//list2的长度增加了，说明添加成功了
System.out.println("现在list2的长度是:"+list2.size());

/**
* 所以可以看出，泛型只是在编译期间起作用，在经过编译进入运行期间是不起作用的。
* 就算是不是泛型要求的类型也是可以插入的。
*/

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

}
}

所以可以看出，泛型只是在编译期间起作用，在经过编译进入运行期间是不起作用的。就算是不是泛型要求的类型也是可以插入的。

反射知识点

泛型

总结

泛型的应用比较多：

spring的IOC/DI。

JDBC中的中的加载驱动

参考

java中的反射机制

反射机制是什么

---------------------------------------------------------------------------

应用

相信做Java的童鞋或多或少都听过反射，这也应该是Java从入门到进阶的必经之路。

但是在我们的实际开发中直接使用它们的几率貌似还是比较少的，（

除了造轮子或者是Spring Mybatis这些框架外

）。

所以这里介绍一个在实际开发中还是小有用处的反射实例。

传统日志

有关反射的一些基本知识就不说了，可以自行

Google

，也可以看下反射入门。

日志相信大家都不陌生，在实际开发中一些比较敏感的数据表我们需要对它的每一次操作都记录下来。

先来看看传统的写法：

@Test
public void insertSelective() throws Exception {

Content content = new Content() ;
content.setContent("asdsf");
content.setCreatedate("2016-12-09");
contentService.insertSelective(content) ;

ContentLog log = new ContentLog();
log.setContentid(content.getContentid());
log.setContent("asdsf");
log.setCreatedate("2016-12-09");
contentLogService.insertSelective(log);
}

非常简单，就是在保存完数据表之后再把相同的数据保存到日志表中。

但是这样有以下几个问题：

如果数据表的字段较多的话，比如几百个。那么日志表的

setter()

方法就得写几百次，还得是都写对的情况下。

如果哪天数据表的字段发生了增加，那么每个写日志的地方都得增加该字段，提高了维护的成本。

针对以上的情况就得需要反射这个主角来解决了。

利用反射构建日志

我们先来先来看下使用反射之后对代码所带来的改变：

@Test
public void insertSelective2() throws Exception {
Content content = new Content();
content.setContent("你好");
content.setContentname("1");
content.setCreatedate("2016-09-23");

contentService.insertSelective(content);

ContentLog log = new ContentLog();
CommonUtil.setLogValueModelToModel(content, log);
contentLogService.insertSelective(log);
}

同样的保存日志，不管多少字段，只需要三行代码即可解决。
而且就算之后字段发生改变写日志这段代码仍然不需要改动。

其实这里最主要的一个方法就是

CommonUtil.setLogValueModelToModel(content, log);

来看下是如何实现的;

/**
* 生成日志实体工具
*
* @param objectFrom
* @param objectTo
*/
public static void setLogValueModelToModel(Object objectFrom, Object objectTo) {
Class<? extends Object> clazzFrom = objectFrom.getClass();
Class<? extends Object> clazzTo = objectTo.getClass();

for (Method toSetMethod : clazzTo.getMethods()) {
String mName = toSetMethod.getName();
if (mName.startsWith("set")) {
//字段名
String field = mName.substring(3);

//获取from 值
Object value;
try {
if ("LogId".equals(field)) {
continue;
}
Method fromGetMethod = clazzFrom.getMethod("get" + field);
value = fromGetMethod.invoke(objectFrom);

//设置值
toSetMethod.invoke(objectTo, value);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
}

再使用之前我们首先需要构建好主的数据表，然后

new

一个日志表的对象。

在

setLogValueModelToModel()

方法中：

分别获得数据表和日志表对象的类类型。

获取到日志对象的所有方法集合。

遍历该集合，并拿到该方法的名称。

只取其中set开头的方法，也就是set方法。因为我们需要在循环中为日志对象的每一个字段赋值。

之后截取方法名称获得具体的字段名称。

用之前截取的字段名称，通过

getMethod()

方法返回数据表中的该字段的

getter

方法。

相当于执行了

String content = content.getContent();

执行该方法获得该字段具体的值。

利用当前循环的

setter

方法为日志对象的每一个字段赋值。

相当于执行了

log.setContent("asdsf");

其中字段名称为

LogId

时跳出了当前循环，因为LogId是日志表的主键，是不需要赋值的。

当循环结束时，日志对象也就构建完成了。之后只需要保存到数据库中即可。

总结

反射其实是非常耗资源的，再使用过程中还是要慎用。
其中对method、field、constructor等对象做缓存也是很有必要的。