学习笔记：java反射和动态代理

已于 2024-03-22 16:55:08 修改
阅读量661 收藏 15
点赞数 17
分类专栏： JAVA的学习笔记 文章标签： 学习 笔记 java
于 2024-03-22 16:52:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74785765/article/details/136946052
版权

文章目录

动态代理

直观的讲：

​ 比如需要增加功能，进入源代码进行修改叫：侵入式修改，可能会导致原有的代码无法运行

​ 在不修改原有的代码并添加新的功能，就需要寻找一个代理来执行添加的新功能：无侵入式修改代码，添加新的功能

最终，调用者需要调用对象中的方法时就要先去调用代理中的方法，代理再去调用对象

代理

  1. 一类对象执行一类方法，对象可以通过代理转移自身的部分职责
  2. 对象有什么方法想要被代理，代理就需要有相对的方法
  3. 需要代理的对象得提供相对应的接口，接口内带有需要被代理的方法，对象和代理需要实现同一个接口

创建一个代理对象

java.lanf.reflect.Proxy类：提供了为代理产生对象的方法


public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)  
// 参数1：用于指定用那个类加载器，来加载生成的代理类
// 参数2：指定接口，这些接口用于指定生成的代理存在那些方法
// 参数3：用于指定生成的代理需要干那些事情

类加载器：把当前类加载到内存的

动态代理的例子

  1. 创建一个需要被代理的类：一个大明星只需要唱歌跳舞，场地准备和收取门票的事情交给负责代理的经纪公司

    public class BigStar implements Star{
    private String name;

    public BigStar() {

    }

    public BigStar(String name) {
        this.name = name;
    }
    @Override
    public String sing(String name) {
        System.out.println("正在唱歌："+name);
        return "唱完了";
    }
    @Override
    public void dance() {
        System.out.println("正在跳舞");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

  2. 负责代理的经纪公司需要派出一名经纪人，这个经纪人要求一样会唱歌跳舞，所以需要一个有着唱歌跳舞方法的接口，这个接口是代理对象制作代理方法的依据

    public interface Star {
    public String sing(String name);
    public void dance();
}

  3. 代理公司给出了一个代理对象，对象内有一个静态方法，从此用户需要通过先调用代理对象的代理方法才能运行有新功能的 大明星对象

    import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 类的作用：
 *       创建一个代理
 */
public class ProxyUtil {
    // 方法的作用 给BigStar对象创建一个代理

    /**
     *
     * 形参：   被代理的对象
     * @return 方法的返回值是代理的对象，返回接口即可
     */

    // 1. 方法是获取代理的对象的，用户想要获取BigStar对象就要ProxyUtil.createProxy(BigStar),返回的值就是代理的对象：代理对象 = ProxyUtil.createProxy(BigStar);
    // 2. 再用代理的对象调用BigStar里的sing方法：代理对象.sing(“name");
    public static Star createProxy(BigStar bigStar) {
        Star star = (Star) Proxy.newProxyInstance
                // 参数1：用于指定用那个类加载器，来加载生成的代理类 :当前的类
                        (ProxyUtil.class.getClassLoader(),
                                // 参数2：指定接口，这些接口用于指定生成的代理存在那些方法
                                new Class[]{Star.class},
                                // 参数3：用于指定生成的代理需要干那些事情
                                //InvocationHandler 是一个接口，再形参中要写他的实现类（匿名内部类）
                                new InvocationHandler() {
                                    @Override
                                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                                        // 要添加的新的功能写再这里
                                        /**
                                         invoke方法的三个参数的作用分别是
                                         proxy： 被代理的对象
                                         method： 要运行的方法
                                         args： 调用要运行的方法时传递的实参
                                         */
 
                                        // 反射获取到的方法名是字符串，做一个判断，如果调用的sing方法
                                        if ("sing".equals(method.getName())) {
                                            System.out.println("这里是新增的方法1：准备话筒，收取门票");
                                        }else if ("dance".equals(method.getName())) {
                                            System.out.println("这里是新增的方法1：准备话筒，收取门票");
                                        }
                                        // 返回被代理对象BigDance的方法的输出结构
                                        return method.invoke(bigStar,args);
                                    }
                                }
                        );
        return star;
    }

}

  4. 用户调取 对象

    public class Text {
    public static void main(String[] args) {
        BigStar bigStar = new BigStar("cxk");
        Star proxy = ProxyUtil.createProxy(bigStar);
        proxy.sing("及你太忙");
        proxy.dance();
    }
}

#反射

反射允许对封装类的字段（成员变量 field）、方法（成员方法 method）和构造函数（构造方法 constructor）的信息进行编程访问

获取class 字节码对象

获取class对象一共有三种方法

1. Class.forName("全类名")； // 全类名：包名.类名  // 常用
2. 类名.class; // 多作为参数传递
3. 对象.getClass(); // 当已经创建了该类的对象时 使用

###获取构造方法Constructor

Class类中用于获取构造方法 的方法

Constructor<>[] getConstructors(); 返回所有 公共构造方法 的对象的数组 只能获取public
Constructor<>[] getDeclaredConstructors();	返回所有 构造方法 对象的数组 
Constructor<T> getConstructor(Class<?>...parameterTypes); 返回单个公共构造方法对象 只能获取public
Constructor<T> getDeclaredConstructor(Class<?>...parameterTypes); 返回单个构造方法对象
// 参数：和需要获取的构造方法的参数保持一致
比如我需要获取的类里面有构造方法 
public student(String name);
那获取就需要
Class clazz = Class.forName("student");
Constructor con = clazz.getDeclaredConstructor(String.class);

Constructor 类中用于创建对象的方法

T newInstance(Object... initargs): 根据指定的构造方法创建对象
setAccessible(boolean flag): 设置为true，表示取消访问检查(取消权限)

获取了构造方法后

获取权限修饰符
private student(String name);
///
Class clazz = Class.forName("student");
Constructor con = clazz.getDeclaredConstructor(String.class);
// 获取权限修饰符
int modifiers = con4.getModifi
获取名字

就是类名

获取形参
private student(String name);
///
Class clazz = Class.forName("student");
Constructor con = clazz.getDeclaredConstructor(String.class);
// 获取构造方法的参数（一般用在私有身上）
Parameter[] parameters = con.getParameters();
创建对象
private student(String name);
///
Class clazz = Class.forName("student");
Constructor con = clazz.getDeclaredConstructor(String.class);
// 利用构造方法创建对象(创建共有私有都可以用)
//创建私有要有额外步骤
con.setAccessible(true); // 暴力反射：临时取消权限检验
student student =(student)con.newInstance("zhangsan") // 传参要和构造方法一致

获取字段（成员变量）

Class类中用于获取成员变量的方法

Field[] getFields(): 返回所有公共成员变量对象的数组
Field[] getDeclaredFields(): 返回所有成员变量对象的数组
Field getField(String name): 返回单个公共成员变量对象
Field getDeclaredField(String name)：返回单个成员变量对象

Field 类中用于创建对象的方法

void set(Object obj,Object value):赋值
Object get(Object obj):获取值
获取名字
// 获取成员变量
class student {public String name; public int age; }
///
Class clazz = Class.forName("student");
// 获取全部
Field[] fields = clazz.getDeclaredFields();
// 获取单一的
Field field = clazz.getDeclaredField(age);
获取权限修饰符

class student {public String name; public int age; }
///
Class clazz = Class.forName("student");
Field field = clazz.getDeclaredField(age);

// 获取权限修饰符
int modifiers = field.getModifiers();
获取数据类型
class student {public String name; public int age; }
///
Class clazz = Class.forName("student");
Field field = clazz.getDeclaredField(age);

// 获取数据类型
Class<?> type = field.getType();
成员变量的值

获取值和对象有关(已经被创建并赋值了)

class student {public String name; public int age; } // 有构造方法
student s = new student("张三",19);
//
Class clazz = Class.forName("student");
Field field = clazz.getDeclaredField(age);
// 如果变量是私有的，则需要
field.setAccessible(true);
int value = (int)field.get(s); // 此处抛出一个异常
修改对象的值
class student {public String name; public int age; } // 有构造方法
student s = new student("张三",19);
//
Class clazz = Class.forName("student");
Field field = clazz.getDeclaredField(age);
// 修改对象的值
field.set(s,23); // 传入对象和要修改的值，这里19--> 23

获取成员方法

Class类中用于获取成员方法的方法

Method[] getMethods()；返回所有公共成员方法对象的数组
Method[] getDeclaredMethods()； 返回所有成员方法对象的数组
Method getMethod(String name,Class<?>...parameterTypes)；返回单个公共成员方法的对象
Method getDeclaredMethod(String name,Class<?>...parameterTypes)；返回单个成员方法的对象
// 参数1：方法的名字
// 参数2：方法的参数的类型(方法重载)

Method类中用于创建对象的方法

Object invoke(Object obj,Object...args):运行方法
/*
	参数1: 用obj对象调用该方法
	参数2: 调用方法的传递参数（如果没有就不写）
	返回值： 方法的返回值（没有则返回null）
*/
获取方法
class student{
    // get、set、tostring方法都有
    .....
    public void sleep() {
        System.out.println("睡觉");
    }

    public void eat (String something) {
        System.out.println("在吃"+ something);
    }
    .....
}

Class clazz = Class.forName("student");
// 获取所有方法(getMethods 会获取到父类的所有public方法)
Method[] methods= clazz.getDeclaredMethods(); // 不能获取父类的
// 获取单个方法
Method method= clazz.getDeclaredMethod("eat",String.class);
获取方法修饰符
class student{
    // get、set、tostring方法都有
    .....
    public void sleep() {
        System.out.println("睡觉");
    }

    public void eat (String something) {
        System.out.println("在吃"+ something);
    }
    .....
}

Class clazz = Class.forName("student");
Method method= clazz.getDeclaredMethod("eat",String.class);
// 获取方法的修饰符
int modifiers = method.getModifiers();
获取方法的名字
class student{
    // get、set、tostring方法都有
    .....
    public void sleep() {
        System.out.println("睡觉");
    }

    public void eat (String something) {
        System.out.println("在吃"+ something);
    }
    .....
}

Class clazz = Class.forName("student");
Method method= clazz.getDeclaredMethod("eat",String.class);
// 获取方法名字
String name = m.getName();
获取方法的形参
class student{
    // get、set、tostring方法都有
    .....
    public void sleep() {
        System.out.println("睡觉");
    }

    public void eat (String something) {
        System.out.println("在吃"+ something);
    }
    .....
}

Class clazz = Class.forName("student");
Method method= clazz.getDeclaredMethod("eat",String.class);
//获取方法的形参
Parameter[] parameters = method.getParameters();
// getParameterCount 获取参数数量
// getParameterTypes 获取参数类型
获取方法抛出的异常
class student{
    // get、set、tostring方法都有
    .....
    public void sleep() {
        System.out.println("睡觉");
    }

    public void eat (String something) throw IOException,NullPointException{
        System.out.println("在吃"+ something);
    }
    .....
}

Class clazz = Class.forName("student");
Method method= clazz.getDeclaredMethod("eat",String.class);
// 获取方法抛出的异常
Class<?>[] exceptionTypes = method.getExceptionTypes();
方法运行并获取返回值（有就获取到了）
class student{
    // get、set、tostring方法都有
    .....
    public void sleep() {
        System.out.println("睡觉");
    }

    public String eat (String something) {
        System.out.println("在吃"+ something);
        return "好吃";
    }
    .....
}

Class clazz = Class.forName("student");
Method method= clazz.getDeclaredMethod("eat",String.class);
// 运行方法
// 参数1: 用obj对象调用该方法
// 参数2: 调用方法的传递参数（如果没有就不写）
// 方法的返回值，void就不写

// 创建一个新对象
student s = new student();
// 调用eat 方法
// 参数1表示方法的调用者，参数2方法传入的实际参数
String result = (String)method.invoke(s,"汉堡")

反射的作用

  1. 获取一个类里的所有信息，获取后再执行其他的业务逻辑
  2. 结合配置文件，动态创建对象并调用方法
+cccc
关注
专栏目录
java语言反射与动态代理学习笔记2(动态代理部分)
05-24
这篇学习笔记主要关注动态代理部分，虽然没有提供具体的压缩包文件内容，但根据标题和描述，我们可以深入探讨这两个概念。 **反射（Reflection）** 反射是Java语言的一个强大工具，它允许程序在运行时检查类、接口...
java语言反射与动态代理学习笔记
06-02
### Java语言反射与动态代理深度解析 ...总之，Java反射和动态代理机制为开发提供了强大的工具，可以实现动态性、扩展性和框架级别的抽象，但同时也需要谨慎使用，避免过度依赖，以免影响性能和代码可读性。
Java笔记_22(反射和动态代理)
weixin_74155781的博客
05-17 685
什么是反射?反射允许对成员变量，成员方法和构造方法的信息进行编程访问。
Java学习笔记 14、反射与JDK动态代理
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
02-20 747
文章目录前言一、认识反射二、认识Class类Class类获取Class实例的四种方式哪些类型可以是class对象？三、反射的方法使用获取构造器、类属性及方法如何看待反射与封装性两个技术？四、类的加载与ClassLoader理解类的加载过程(含例子)ClassLoader理解(各个类加载器)认识各个类加载器ClassLoader双亲委派机制加载properties文件五、获取运行时类的完整结构六、调用运行时类的指定方法1、调用指定方法(invoke方法)2、调用指定属性setAccessible方法说明七、反
Java学习笔记：反射与代理机制（静态、动态）
lemonGuo的大脑皮层、小脑、海马体、杏仁核.....
05-26 1164
反射与代理机制是Java中比较高级的一种特性，它完全是站在Java虚拟机的角度去看待各种类的运行，特别是在Java EE中运用广泛。在学习之前，首先思考几个问题： - 给定一个类的名字（字符串形式），怎么创建该类的对象？ - 什么是反射机制？ - Java静态代理和动态代理的异同有哪些？ 接下来此篇博文来一一探索并解决以上问题，借此学习反射与代理机制~
JavaSE学习笔记(九)：Java反射机制
weixin_46476301的博客
05-02 516
一、反射的概述 二、Class类的理解与获取Class的实例 三、了解ClassLoader 四、反射应用1：创建运行时类的对象 五、反射应用2：获取运行时类的完整结构 六、反射应用3：调用运行时类的指定结构 七、反射应用4：动态代理 最后 附上我的学习视频：尚硅谷Java入门视频教程(在线答疑+Java面试真题) 本文只是博主的一点点Java学习笔记，往后可能会继续更新，谢谢大家的浏览支持！ ...
JAVA基础5-JAVA反射和代理学习笔记
代码还是得自己扣
07-04 482
JAVA反射和代理学习笔记反射原理结构反射获取方法反射调用方法流程图Spring的IOCSpring的IOC容器资源定位资源载入资源解析资源注册Spring依赖注入代理模式代理模式原理Java的代理模式JDK的静态代理JDK的动态代理Cglib代理 反射原理 结构 Class：对类的描述 Method：对方法的描述 Field：对属性的描述 Constructor：对构造方法描述 Reflecti......
Java反射学习笔记
luck_lsj的博客
04-10 675
Java反射的学习笔记
（Java笔记）JDK动态代理
张松的博客
06-14 845
动态代理是指代理类对象在程序运行时由JVM根据反射机制动态生成的。动态代理不需要定义代理类的.java源文件——>jdk运行期间动态创建class字节码并加载JVM——>代理对象在程序运行的过程中动态在内存构建，可以灵活的进行业务功能的切换。......
java学习笔记13--反射机制与动态代理
GarfieldEr007的专栏
03-22 1251
本文地址：http://www.cnblogs.com/archimedes/p/java-study-note13.html，转载请注明源地址。 Java的反射机制 在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。 这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Ref
Java学习笔记 - --反射
qq_59270298的博客
05-22 851
Java反射机制的核心在于能够在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。这本质上是通过JVM获取class对象后，再通过这个class对象来反编译，从而获取对象的各种信息。动态加载类：可以在运行时根据需要加载一个只知道名称的类，并且能够知道这个类的所有属性和方法等信息。获取类信息：可以获取类的名称、父类、接口、注解、构造器、字段和方法等信息。操作类成员：可以调用方法、设置和获取字段值，甚至可以调用私有方法或访问私有字段。创建对象实例。
Java学习笔记
Piglett的博客
12-30 1170
随着后续的学习还会不断地更新，并不仅仅包含Java基础，后续还会更新SSM，MySQL等内容。其记录了Java基础的学习内容，主要包括24集合到30动态代理（见语雀目录）。希望这篇笔记能够帮助到Java的学习，方便快速进行回顾复习。
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java基础学习笔记之反射
09-02
Java反射是Java编程语言的一个重要特性，它允许程序在运行时检查类的信息并动态地创建和操作类的对象。反射提供了一种方式，使得程序能够访问和修改私有成员（包括字段和方法），甚至调用私有构造器。这种能力使得...
Java::black_nib:Java 学习笔记
05-10
"Java::black_nib:Java 学习笔记"很显然是一份关于Java编程的学习资源，可能是由一位开发者或教师整理的教程或者笔记。在这个压缩包文件"Java-master"中，我们可能找到了一系列与Java学习相关的源代码、示例项目或者...
【人工智能学习之PaddleOCR快速上手】
Jiagym的博客
10-12 1168
在配置文件中，可以设置组建模型、优化器、损失函数、模型前后处理的参数，PaddleOCR从配置文件中读取到这些参数，进而组建出完整的训练流程，完成模型训练，在需要对模型进行优化的时，可以通过修改配置文件中的参数完成配置，使用简单且方便修改。而 L2 正则化中，添加正则化项的目的在于减少参数平方的总和。准确检测的标准是检测框与标注框的IOU大于某个阈值，正确识别的检测框中的文本与标注的文本相同。如果缺少带标注的数据，或者不想投入研发成本，建议直接调用开放的API，开放的API覆盖了目前比较常见的一些垂类。
MySQL数据库的详细学习步骤
2401_87352036的博客
10-11 1199
MySQL数据库的详细学习步骤可以归纳为以下几个阶段，每个阶段都包含了特定的学习内容和目标。
如何用3个月零基础入门网络安全？_网络安全零基础怎么学习
最新发布
2401_84466224的博客
10-15 723
我们知道计算机最早是在西方发明出来的，很多名词或者代码都是英文的，甚至现有的一些教程最初也是英文原版翻译过来的，而且一个漏洞被发现到翻译成中文一般需要一个星期的时间，在这个时间差上漏洞可能都修补了。”答案是否定的，黑客用的电脑,不需要什么高的配置,只要稳定就行.因为黑客所使用的一些程序,低端CPU也可以很好的运行,而且不占什么内存.还有一个,黑客是在DOS命令下对进行的,所以电脑能使用到最佳状态!观看学习近十年所有0day挖掘的帖，然后搭建环境，去复现漏洞，去思考学习笔者的挖洞思维，培养自己的渗透思维。
论文及其创新点学习cvpr2022 On the Integration of Self-Attention and Convolution
qq_53536373的博客
10-13 391
论文创新点，将注意力机制 和卷积 相结合。
Java学习笔记：从基础到实战详解
14. 反射机制：Java的反射API允许程序在运行时检查和修改类的信息，这对于动态代理和测试框架非常关键。 这些知识点涵盖了Java编程的基础架构，对于想要系统学习Java的读者来说，具有很高的参考价值。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值