JAVA反射机制与动态代理

简介: 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对象的三种方式

  1. 抛弃 new , 动态构建任意一个类的对象
  2. 获取一个类的任意成员变量和方法,不论是否被private修饰
  3. 调用任意一个对象的方法
  4. 跨越泛型检验
  5. 动态代理
  6. 反射&泛型


一: 获取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
}



四. 工具方法#


  • 很多框架底层都使用类似的方法,去配置文件里面读取我们的配置,然后把需要的截取出来,当作参数,传递到方法执行


  1. 对象+方法名+可变参数


/* @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);
}


  1. 如果本类无传递进来方法名,去父类中查找


//在 本类中查找 ,找不到,去父类中查找
    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");
相关文章
|
2天前
|
XML 安全 Java
Java反射机制:解锁代码的无限可能
Java 反射(Reflection)是Java 的特征之一,它允许程序在运行时动态地访问和操作类的信息,包括类的属性、方法和构造函数。 反射机制能够使程序具备更大的灵活性和扩展性
15 5
Java反射机制:解锁代码的无限可能
|
1天前
|
存储 缓存 安全
🌟Java零基础:深入解析Java序列化机制
【10月更文挑战第20天】本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
10 3
|
1天前
|
安全 Java UED
深入理解Java中的异常处理机制
【10月更文挑战第25天】在编程世界中,错误和意外是不可避免的。Java作为一种广泛使用的编程语言,其异常处理机制是确保程序健壮性和可靠性的关键。本文通过浅显易懂的语言和实际示例,引导读者了解Java异常处理的基本概念、分类以及如何有效地使用try-catch-finally语句来处理异常情况。我们将从一个简单的例子开始,逐步深入到异常处理的最佳实践,旨在帮助初学者和有经验的开发者更好地掌握这一重要技能。
7 2
|
3天前
|
Java 数据库连接 开发者
Java中的异常处理机制####
本文深入探讨了Java语言中异常处理的核心概念,通过实例解析了try-catch语句的工作原理,并讨论了finally块和throws关键字的使用场景。我们将了解如何在Java程序中有效地管理错误,提高代码的健壮性和可维护性。 ####
|
4天前
|
Java
Java中的反射机制与应用实例
【10月更文挑战第22天】Java作为一门面向对象的编程语言,提供了丰富的特性来支持对象的创建、操作和交互。其中,反射机制是Java的一项核心特性,它允许程序在运行时动态地获取类的信息、创建对象、调用方法、访问属性等。本文将从三个部分探讨Java中的反射机制及其应用实例:一是反射机制的基本概念和原理;二是反射机制在Java中的应用场景;三是通过实例深入理解反射机制的使用方法和技巧。
10 4
|
5天前
|
安全 Java 程序员
深入浅出Java中的异常处理机制
【10月更文挑战第20天】本文将带你一探Java的异常处理世界,通过浅显易懂的语言和生动的比喻,让你在轻松阅读中掌握Java异常处理的核心概念。我们将一起学习如何优雅地处理代码中不可预见的错误,确保程序的健壮性和稳定性。准备好了吗?让我们一起踏上这段旅程吧!
20 6
|
3天前
|
存储 运维 Java
💻Java零基础:深入了解Java内存机制
【10月更文挑战第18天】本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
15 1
|
6天前
|
存储 Java 程序员
Java面试加分点!一文读懂HashMap底层实现与扩容机制
本文详细解析了Java中经典的HashMap数据结构,包括其底层实现、扩容机制、put和查找过程、哈希函数以及JDK 1.7与1.8的差异。通过数组、链表和红黑树的组合,HashMap实现了高效的键值对存储与检索。文章还介绍了HashMap在不同版本中的优化,帮助读者更好地理解和应用这一重要工具。
20 5
|
5天前
|
设计模式 Java API
[Java]静态代理与动态代理(基于JDK1.8)
本文介绍了代理模式及其分类,包括静态代理和动态代理。静态代理分为面向接口和面向继承两种形式,分别通过手动创建代理类实现;动态代理则利用反射技术,在运行时动态创建代理对象,分为JDK动态代理和Cglib动态代理。文中通过具体代码示例详细讲解了各种代理模式的实现方式和应用场景。
[Java]静态代理与动态代理(基于JDK1.8)
|
6天前
|
Java
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件成立时被唤醒,从而有效解决数据一致性和同步问题。本文通过对比其他通信机制,展示了 `wait()` 和 `notify()` 的优势,并通过生产者-消费者模型的示例代码,详细说明了其使用方法和重要性。
14 1