JAVA反射机制与动态代理
承接上篇博客里面,类加载器把类加载把类加载进内存,同时创建出了一个唯一的Class对象,其实它本质上就是一个java类,只不过功能挺特殊的---说白了,就像当初,数据多了,用集合装,还多?写个类,用对象装, 类可以对一系列数据的描述,然后谁描述类呢-->Class里面有类的基本信息 1.类的属性:Field 2. 方法:Method 3 .构造器:Constructor(这三个属性都有自己的对应类)
都说java是一门动态语言,怎么着他就动态了呢? reflection反射! 通过反射,我们可以动态的获取类的实例,平时我们自己写东西,用到反射的几率几乎没有,但是像Spring,Hibernate,Mybatis等等等等这些框架的底层到处都是反射
初学spring时接触下面这个配置, Spring的控制反转,IOC,把对象交给Spring创建,依稀记得当初写一大堆xml配置文件,那时候很蒙!其中,把对象的创建权反转给Spring的时候,需要这样:
<bean id="小写类名" , class="带包名的全类名">
<property name="XXX" value="XXX"/>
</bean>
她其实就是在通过反射,帮我们创建对象
言归正传,下面分如下几步展开
1.获取class对象的三种方式
- 抛弃 new , 动态构建任意一个类的对象
- 获取一个类的任意成员变量和方法,不论是否被private修饰
- 调用任意一个对象的方法
- 跨越泛型检验
- 动态代理
- 反射&泛型
一: 获取class对象的三种方式
图1
- 源代码阶段(使用频率最多)
//1 注意,当我用ide 快捷生成 左半部分的时候, Class<?> forName 即便<?>是问号,他也是泛型的
//Class<?> forName = Class.forName("com.atGongDa.entity.person");
//2 然后我们可以这样
// Class<person> personClass = (Class<person>) Class.forName("com.atGongDa.entity.person");
//3 但是,在开发的时候,是不会写上泛型的,因为在开发框架的人们,在写它的时候,是不知道,程序员要传递进来什么类型
Class forName = Class.forName("com.atGongDa.entity.person");
/*
newInstance() 创建对象的实例, 注意这里获取的对象,和直接new 出来的对象是不一样的,不知直接调用类里面的方法
调用的是无参的 构造器, 这也是为什么要习惯性的写上一个无参的构造器,留着给反射用!!!
*/
Object o = forName.newInstance();
System.out.println(o);
- 字节码阶段
类名.class
- 对象阶段
对象.getClass()
这个意义不太大, 我们都拿到对象了, 它是啥类型,有什么,点进去看就行了,还getClass()干啥,南辕北辙
二. 抛弃 new , 动态构建任意一个类的对象,获取它的方法并执行
//获取Class对象,它里面它里面封装着类的属性和方法
Class clazz= Class.forName("com.atGongDa.entity.person");
// 创建类实例,不过直接使用它没意义(因为我最终的目的还是使用对象里面的方法和字段)
Object o = clazz.newInstance();
获取类中的方法(包含它父类的方法),不包括获取不到私有的
返回值: Method对象数组,里面的method对象是我们上面person中方法的抽象实体,类方法或实例方法（包括抽象方法）如果你去看它的API会发现它里面有一系列的方法,比如和它代表的方法执行
Method[] methods = clazz.getMethods();
获取所有的方法(包含私有的)
Method[] declaredMethods = clazz.getDeclaredMethods();
获取指定的方法
Method method = clazz.getDeclaredMethod("text");
暴力反射,执行方法
//执行方法: Method对象执行方法,
// 两个参数
// 谁的方法? 创建实例
// 获取method对象
// Method对象调用invoke()
Object o = clazz.newInstance();
method.setAccessible(true);
method.invoke(o,null); ///参数就是原方法的参数
三. 获取类的任意字段
- Field 也是个类,提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。
@Test
public void textField() throws NoSuchFieldException, IllegalAccessException {
//获取所有字段
Field[] fields = person.class.getDeclaredFields();
for (Field f:fields) {
System.out.println("字段=="+f.getName());
}
//获取指定名字的字段
Field field = person.class.getDeclaredField("neme");
System.out.println(field.getName());
/* Field neme = person.class.getField("neme");
System.out.println(neme.getName());*/
//获取指定对象的Field值
Object p = new person("张武",11);
//暴力反射
field.setAccessible(true);
Object o = field.get(p);
System.out.println(o);
//给指定对象的 当前字段设置值
field.set(p,"haha"); //filed 字段是上面的neme
}
四. 工具方法
- 很多框架底层都使用类似的方法,去配置文件里面读取我们的配置,然后把需要的截取出来,当作参数,传递到方法执行
- 对象+方法名+可变参数
/* @Param obj 对象
* @Param methodName 方法名
* @Param avgs 方法参数,可变参数
*
* 要求,执行执行指定对象的指定方法
* */
@Test
public Object invoke1(Object obj,String methodName,Object ... avgs) throws InvocationTargetException, IllegalAccessException {
//创建 长度为avgs 类型为Class 的数组, (可变参数可以看作一个数组)
Class[] classes = new Class[avgs.length];
//循环 avgs.length 次 , 把每个入参的Class映射,传递进 Class数组中 ,得到的这个Class类型数组,就是getDeclaredMethod需要的第二个入参
for (int i=0;i<avgs.length;i++){
classes[i] = avgs[i].getClass();
}
Class clazz = obj.getClass();
/*
@CallerSensitive
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
throws NoSuchMethodException, SecurityException {
可以看到他的第二个参数是Class类型的,但是具体是啥类型,不知道,所以使用上面啊那个for循环推到
* */
try {
Method method = clazz.getDeclaredMethod(methodName,classes);
//若 方法是私有的可访问
method.setAccessible(true);
return method.invoke(obj,avgs);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
return null;
}
2, 带包名的全路径+方法名+可变参数
/*
* 工具方法
* @Param String objName 对象
* @Param methodName 方法名
* @Param avgs 方法参数,可变参数
*
* 要求,执行执行指定对象的指定方法
* */
@Test
public Object invoke2(String objName,String methodName,Object ... avgs) throws Exception{
Object o1 = Class.forName(objName).newInstance();
// return invoke1(o1,methodName,avgs);
Class[] classes = new Class[avgs.length];
for(int i=0;i<avgs.length;i++){
classes[i]=avgs[i].getClass();
}
//获取Method 对象
Method declaredMethod = o1.getClass().getDeclaredMethod(methodName, classes);
System.out.println("方法名=="+declaredMethod.getName());
//暴力反射
declaredMethod.setAccessible(true);
return declaredMethod.invoke(o1, avgs);
}
- 如果本类无传递进来方法名,去父类中查找
//在 本类中查找 ,找不到,去父类中查找
public Method getMethod(Class clazz, String name, Class... avgs){
for(;clazz!=Object.class;clazz = clazz.getSuperclass()){
try {
return clazz.getDeclaredMethod(name,avgs);
} catch (Exception e) {
e.printStackTrace();
}
} return null;
}
五.动态代理
- 为啥要代理?
代理的目的就是给现有的类的对象的功能进行增强, 代理对象 = 原对象 + 增强方法
- 难道只有代理才能增强吗?
当然不是,如果这个类是我们自己写的,手上有整套源码,我们直接改源代码就好了,问题是,大多数情况下,类是我们继承来的,没有源码让咱改,想增强?只能代理
- 框架中的典型代表
Spring AOP 的面向切面编程就把它使用的淋漓尽致, 来多少对象我不关心,让他们排队站好.我可以在他们身上横切一刀, 给他们集体增强
注意点:
- 为谁代理? --> 我们自己创建被代理对象(这个被代理的对象必须是 一个接口的实现类)
下面看看如何玩转动态代理
API
/**
* @param loader the class loader to define the proxy class
* @param interfaces the list of interfaces for the proxy class
* to implement
* @param h the invocation handler to dispatch method invocations to
*/
Proxy.newProxyInstance (ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h) //根据传递进去的被代理类的信息,生成代理对象
-
参数1: 被代理的对象用到什么类加载器,编译的时候是不知道的,所以第一个参数我们要把被代理对象使用的类加载器告诉代理对象
-
参数2: 被代理的对象要至少要实现了一个接口,大家看上面newProxyInstance的第二个参数,是一个Class<?>[]未知类型的Class对象的数组,代理对象要通过它找到他所实现的接口中有什么方法, 换句话说,我们只能代理接口中的方法(进而增强它的实现类中的方法)
实例:
接口
public interface Calcullator {
public float add(Integer i,Integer j);
public float sub(Integer i,Integer j);
}
实现类
public class CalcullatorImpl implements Calcullator {
@Override
public float add(Integer i, Integer j) {
return i+j;
}
@Override
public float sub(Integer i, Integer j) {
return i*j;
}
}
代理
@Test
public void lastProxy(){
Calcullator calcullator = new CalcullatorImpl();
Calcullator c = (Calcullator) Proxy.newProxyInstance(calcullator.getClass().getClassLoader(), new Class[]{Calcullator.class},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
logger.info("开启事务");
// 执行方法
try {
Object result = method.invoke(calcullator, args);
logger.info("提交事务");
return result;
}catch (Exception e){
logger.info("回滚事务");
}
return null;
}
});
System.out.println(c.add(1,2));
}
划重点!这里有个坑
千万不要在 InvocationHander里面使用 proxy对象,不然就是个死循环
原因:
当我们执行完c.add(1,2)时,c是我们增强后的对象,调用add,触发的回调函数,下一步就会执行InvocationHandler的invoke方法,而它的参数Object类型的proxy就是它最终要返回的对象,我们如果在这里面使用它了,会重新触发invoke方法,方法里面有调用它,再触发invoke,无限循环
六. 泛型与反射
- 反射越过泛型检查
//反射越过泛型检验
@Test
public void text2() throws Exception {
//ArrayList<Integer>在这个集合中添加一个 String 字符串....
//思路:泛型只是在编译期才有,但是真正运行起来就被擦出了...反射ArrayList<Integer> 拿到他的字节码文件(运行期)再添加字符串
ArrayList <Integer> list = new ArrayList<>();
list.add(111); //无错
//list.add("abc"); //报错
Class clazz = Class.forName("java.util.ArrayList");
Method add = clazz.getMethod("add" , Object.class);
add.invoke(list,"abc"); //泛型反射
for (Object a: list) {
logger.info(a);
}
}
- 反射在框架中的使用
假设这样的情景 ,首先,我们拿着id去数据库中查询一个实体,我们的都知道,直接出来的数据肯定是 String字符串,但是我们使用的那些持久层的框架却能给我们返回一个 javaBean(查出来的数据封装在javaBean里面),模拟下它的实现
首先准备下面的javaBean以及持久层的Dao
@lombok
public class person {
@namePro(name="张三")
private String neme;
private Integer age;
public person() {
System.out.println("无参的构造器");
}
public person(String neme, Integer age) {
System.out.println("有参的构造器");
this.neme = neme;
this.age = age;
}
}
personDao
这里有个比较有意思的事,原来我记得看到下面的personDao的时候,想都没想为什么它会这么写? 现在看看,好套路啊! 突然想起来 SpringDataElasticsearch,SpringDataJpa里面的Repository,Mybatis里面的通用mapper,类似让我们这样写, 只不过他们哪里都是接口,而我们现在是class类型. 底层全是反射,智慧与套路并存
public class PersonDao extends Dao<person> { }
我的表演,从测试类入手
测试类
///泛型与反射组合,很多框架经常使用下面这个方法
@Test
public void text1() throws Exception {
PersonDao personDao = new PersonDao();
//根据id 问dao要 person
//从数据库中按照 i 把对象的信息找出来,但是这个时候, 从数据库里面拿出来是信息仅仅的一些字段的信息,
// 我们的要求是: 当service层调用get()方法的时候, 我返回给他的是一个包装好的对象, 也就是说, 我通过反射创建T类型 的对象,然后返回给他
person p = personDao.get(1);
logger.info("p=="+p);
}
get方法,主要做两件事 1. 创建实例 2. 查询数据库把数据添加到实例对象中
- 先看看上面的测试类,我们直接new的是personDao,而它继承了Dao,在继承的时候我们指定了它的类型是person类型,为什么这么设计? 因为设计框架的人,根本不知道你会传递进来一个person还是一个animal,所以他在写Dao时,一定会给它加上泛型
( Dao就在下面) - 思考一下,它是入给创建实例的
使用反射创建实例?我们知道一准是 通过Class.newInstance()方法,那么问题来了,1 .首先想想我们要谁的Class,person的class ,2. Class我咋整出来? 总不能使用T.class吧? 编译都过不去啊. 大家通过观察,发现person唯一出现的位置就是personDao的泛型的位置, 我们要做的就是把Dao的泛型取出来,赋给我们提前声明的Class clazz,这样一直全ok
具体怎么做的?
大家可以看下面的解决方法: 在Dao的构造方法中着手
持久层
public class Dao<T> {
public static final Logger logger = Logger.getLogger(Dao.class);
//目标就是获取 T 对应的Class 对象 , 为什么像下面那么写呢? 因为 T.class 不存在
private Class<T> clazz;
public Dao() {
logger.info("dao 的无参构造器");
//结果:10:52:37,546 INFO Dao:14 - Dao's Constructor 's this ==com.atGongDa.entity.PersonDao@56ef9176 全类名
//为啥是personDao 因为this是当前调用这个函数的对象,而当前对象是我 new PersonDao()
logger.info("打印this的全类名 =="+this);
logger.info("this的 Class对象"+this.getClass());
//获取Dao子类的父类
Class clazz1 = this.getClass().getSuperclass();
logger.info("this的父类的Class对象=="+clazz1);
//this的父类的Class对象==class com.atGongDa.entity.Dao 结果还是没有T 泛型
//获取Dao子类带泛型参数的父类,Dao<person>
Type type = this.getClass().getGenericSuperclass();
logger.info("type=="+type); //com.atGongDa.entity.Dao<com.atGongDa.entity.person>
//注意: Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型
//我们要使用的是他的子接口 ParameterizedType 里面的
/*Type[] getActualTypeArguments()返回表示此类型实际类型参数的 Type 对象的数组。
注意，在某些情况下，返回的数组为空。如果此类型表示嵌套在参数化类型中的非参数化类型，则会发生这种情况。
返回 :表示此类型的实际类型参数的 Type 对象的数组
* */
//获取具体的泛型参数
if(type instanceof ParameterizedType){ //这是
ParameterizedType parameterizedType = (ParameterizedType)type;
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
//这有个技巧,假如说我们仅仅想看看数组里面有什么,用工具Arrays.asList()
logger.info("T=="+ Arrays.asList(actualTypeArguments));//[class com.atGongDa.entity.person]
if(actualTypeArguments!=null&&actualTypeArguments.length>0){
Type arg = actualTypeArguments[0];
logger.info("arg=="+arg);
if (arg instanceof Class){
clazz= (Class<T>) arg;
}
}
}
}
//从数据库中按照 i 把对象的信息找出来,但是这个时候, 从数据库里面拿出来是信息仅仅的一些字段的信息,
// 我们的要求是: 当service层调用get()方法的时候, 我返回给他的是一个包装好的对象, 也就是说, 我通过反射创建T类型 的对象,然后返回给他
public T get(Integer i) throws Exception {
//问题是啥呢? 那么如何得到 Dao<T> T所对象的Class对象
// T.class 没有
logger.info("Dao get==>"+clazz);
//创建实例
T t1 = clazz.newInstance();
//这里直接手动写属性名, 获取它的属性,把查出来的值放进去
Field name = clazz.getDeclaredField("neme");
/**
* 当然框架的设计者肯定不会这么做,因为它根本不知道现在的clazz是个啥!
* 他们获取全部的属性,和结合数据库中查询出来的属性 封装clazz对象里面 (这也是为什么PO的属性名不能乱写,和数据表字段是有关联的)
* Field[] declaredFields = clazz.getDeclaredFields();
*/
name.setAccessible(true);
name.set(t1,"张三");
//返回Class对象
return t1;
}
Class的另一种用法
- 直接读取类路径下的配置文件
Object o = forName.newInstance();
InputStream resourceAsStream = o.getClass().getClassLoader().getResourceAsStream("123.properties");
