Reflection反射

最新推荐文章于 2024-06-30 20:23:11 发布
最新推荐文章于 2024-06-30 20:23:11 发布
阅读量47 收藏 1
点赞数 1
文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64978052/article/details/131688366
版权

前言

在Java语言中，Java的反射机制是它的一个重要特性。

Java的反射机制是指在运行状态中，对于任意一个类都能够调用方法知道这个类的所有属性和方法；对于任意一个对象，都能调用它的任意方法和属性。这种在运行状态中获取类或对象的动态信息的功能被称为反射。

反射的功能

  • 获取类的各种信息：反射可以获取一个类中的各种信息，包括类名、父类、实现的接口、类中定义的属性、方法、构造方法等。
  • 创建对象：通过Class对象的newInstance()方法动态创建对象，而不需要在编写代码时事先知道创建的具体对象类型。
  • 调用方法：在运行状态时动态调用一个对象的方法，包括公有、私有、静态方法等。
  • 生成动态代理：在运行时创建代理类实例，由代理类来代理另外一个类的方法调用。

 反射机制获取对象信息

1、获取类型信息

在编译期间确定对象类型的代码如下

String str = new String();

在运行期间确定对象类型，反射机制中有三种方法

  • 通过Class类的静态方法forName得到

String str = Class.forName("String").newInstance();

  •  通过实例化访问

String str = "";
Class stringCls = str.getClass();

  •  通过类名访问

Class stringCls1 = String.class;

注：以上这三种方法在一个main中输出的哈希值相同，因为哈希值只会重复输出首次获取。

2、获取接口信息

//实现的接口
Class[] interfacecls = cls.getInterfaces();
System.out.println("当前类实现的接口：");
for (Class iclass : interfacecls) {
	System.out.println(iclass);
}

 3、获取构造方法

//此处Example为一个自己创建的类
Class cls = Example.class;
//只能访问公有的构造方法
System.out.println("所有的构造方法");
//Constructor[] constructors = cls.getConstructors();//不包括私有
Constructor[] constructors = cls.getDeclaredConstructors();
for (Constructor constructor : constructors) {
	System.out.println(constructor);
 }
		
//获取一个私有的构造方法
Constructor privateConstruct = cls.getDeclaredConstructor(String.class);
		
//调用私有的构造方法
privateConstruct.setAccessible(true);
Example ex = (Example) privateConstruct.newInstance("just");
System.out.println(ex);
System.out.println("---------");


//调用无参构造方法（根据数据类型、数据个数进行调用）
Constructor construct1 = cls.getConstructor();
Constructor construct2 = cls.getConstructor(int.class);
Constructor construct3 = cls.getConstructor(int.class,double.class);

 4、Instanceof运算符和isAssignableFrom运算符

Instanceof运算符：判断引用和类型之间的关系

isAssignableFrom运算符：判断两个类型之间的关系

实现代码如下：

//Instanceof运算符：判断引用和类型之间的关系
Object obj = Double.valueOf(324);
System.out.println("是否为Double类型？"+(obj instanceof Double));
System.out.println("是否为Integer类型？"+(obj instanceof Integer));
System.out.println("是否为Character类型？"+(obj instanceof Character));
System.out.println("是否为RandomAccess接口？"+(obj instanceof RandomAccess));
System.out.println("是否为Comparable接口？"+(obj instanceof Comparable));
		
//isAssignableFrom运算符：判断两个类型之间的关系
System.out.println("Intager <= Intager ?"+Integer.class.isAssignableFrom(Integer.class));
System.out.println("Intager <= Double ?"+Integer.class.isAssignableFrom(Double.class));
System.out.println("Intager <= RandomAccess ?"+Integer.class.isAssignableFrom(RandomAccess.class));
System.out.println("Serializable <= Intager ?"+Serializable.class.isAssignableFrom(Integer.class));
System.out.println("Intager <= Number ?"+Integer.class.isAssignableFrom(Number.class));
System.out.println("Number <= Intager ?"+Number.class.isAssignableFrom(Integer.class));

 输出结果如下： 78c5393d2f3146219f9c634f37f1a8cc.png

 5、访问成员变量

//Book为自己创建的类
Class c = Book.class;
//Field[] fields = c.getFields();//父类子类的公用成员变量都能拿到
Field[] fields = c.getDeclaredFields();//获取本类的所有成员变量
for (Field field : fields) {
   System.out.println("成员访问修饰符int："+field.getModifiers());
   System.out.println("成员访问修饰符："+Modifier.toString(field.getModifiers()));
   System.out.println("成员变量类型："+field.getType());
   System.out.println("成员变量名称："+field.getName());
   System.out.println("-------");
  }

 6、添加成员变量的值

//运行期
//使用反射的方式完成成员变量变值
Class cls = Book.class;//获取class类型的对象
Object obj = cls.newInstance();//通过反射创建Book类的对象
		
//按照字段名称，获取指定成员变量
Field field = cls.getDeclaredField("BookName");
//参数1：目标Book对象
//参数2：存入变量中的值
field.set(obj, "哈哈哈");
		
Field field2 = cls.getDeclaredField("stock");
field2.set(obj, 90);
		
Field field3 = cls.getDeclaredField("sale");
field3.setAccessible(true);//访问私有成员变量
field3.set(obj, 0.8);
System.out.println(obj);

7、获取类中所有方法

Class cls = Book.class;		
//获取所有Public方法（包括父类）
//Method[] methods = cls.getMethods();
//获取所有定义的方法
Method[] methods = cls.getDeclaredMethods();
for (Method method : methods) {
  System.out.println("方法的访问修饰符"+Modifier.toString(method.getModifiers()));
  System.out.println("方法的返回值类型"+method.getReturnType());
  System.out.println("方法的名称"+method.getName());
  //获取所有的参数类型
  //Class[] paramTypes = method.getParameterTypes();
  //获取所有参数对象
  Parameter[] params = method.getParameters();
  for (Parameter p : params) {
  System.out.println(p.getName());
  System.out.println(p.getType());
  System.out.println("--------------");
    }
  System.out.println();
  }

  •  获取方法对象

//反射获取class对象
Class cls = Base.class;
Object obj = cls.newInstance();
//按照方法名称和参数类型获取method方法对象
//create()
//Method method = cls.getMethod("create",int.class);
			
Method method = cls.getMethod("create", int.class);
//Method对象的invoke()作用
//以反射的方式执行create()方法
int r = (int) method.invoke(obj, 1000);
System.out.println(r);

//Base类
class Base{
	public int  create() {
		return create(100);
	}
	public int create(int x) {
		return (int) (Math.random()*x);
	}
}

 注：如果是调用一个类中的方法其中它的子类也覆写了这个方法，父类.class获取的Method，作用于Student实例时，调用的方法是子类的方法。实现代码如下：

//main
Method method = PersonS.class.getMethod("hello");
method.invoke(new Student());//目标对象调用方法归属

//类
class PersonS{
	public void hello() {
		System.out.println("hello");
	}
}
class Student extends PersonS{
	public void hello() {
		System.out.println("你好");
	}
}


//输出为>>你好

Class类中的主要方法有：

  • getName()：获取类的全限定名
  • getSimpleName()：获取类的简单类名
  • getFields()：获取类中的所有public属性
  • getDeclaredFields()：获取类声明中的所有属性，包括private属性、protect属性
  • getMethods()：获取类中所有public方法，包括从父类中继承来的方法
  • getDeclaredMethods()：获取类中声明的所有方法，包括private方法
  • getConstructors()：获取类中的所有public构造方法
  • getDeclaredConstructors()：获取类中声明的所有构造方法，包括private方法
  • newInstance()：通过Class对象动态创建对象
  • isAssignableFrom(Class<?> cls)：判断当前class对象是否可以从指定的Class对象进行赋值操作
  • getInterfaces()：获取当前类实现的接口
  • getSuperclass()：获取当前类的父类

 除此之外还有很多动态获取信息操作以及判断方法，上文只是列出来一部分内容。

最重要的静态代理：

代理模式有两种：静态代理、动态代理。是根据字节码的创建时机来分类的。

静态是指在程序运行之前我们就已经知道代理类和真实角色的关系

动态是指在运行期间由JVM根据反射等动态机制的生成，在运行之前不知道代理类和真实角色的关系。

代理角色有三种：

  • Subject（抽象主题角色）：定义代理类和真实主题的公告对外方法，通常类型是接口
  • RealSubject（真实主题校色）：真正实现业务逻辑的类
  • proxy（代理主题角色）：用来代理和封装真实主题

静态代理案例实现：

public class client {
	public static void main(String[] args) {
		subject subject = new subjectproxy();
		subject.request();

		UserService service = new UserServiceProxy();
		service.select();
		service.update();
	}
}
public class Realsubject implements subject{
	public void request() {
		System.out.println("逻辑1");
		System.out.println("逻辑2");
		System.out.println("逻辑3");
	}
}
public interface subject {
	void request();
}
public class subjectproxy implements subject{
	private subject target;
	public subjectproxy() {
		target = new Realsubject();
	}
	@Override
	public void request() {
		System.out.println("begin-----------");
		target.request();
		System.out.println("end-----------");
		
	}

}

静态代理案例详细实现2：

public interface UserService {
	void select();
	void update();
}
public class UserServiceImpl implements UserService {

	@Override
	public void select() {
		System.out.println("select * ..................");
		System.out.println("数据库中完成用户信息的查询执行!");
	}

	@Override
	public void update() {
		System.out.println("update ...................");
		System.out.println("数据库中用户状态的更新执行！");
	}

}
public class UserServiceProxy implements UserService{
	private UserService target;
	public UserServiceProxy() {
		target = new UserServiceImpl();
	}

	@Override
	public void select() {
		begin();
		target.select();
		end();
	}

	@Override
	public void update() {
		begin();
		target.update();
		end();
		
	}
	private void begin() {
		System.out.println("开始");
	}
	private void end() {
		System.out.println("结束");
	}
}


public class client {
	public static void main(String[] args) {
		UserService service = new UserServiceProxy();
		service.select();
		service.update();
	}
}

 动态代理案例实现：

public interface UserService {
	void select();
	void update();
}

public class UserServiceImpl implements UserService {

	@Override
	public void select() {
		System.out.println("select * ..................");
		System.out.println("数据库中完成用户信息的查询执行!");
	}

	@Override
	public void update() {
		System.out.println("update ...................");
		System.out.println("数据库中用户状态的更新执行！");
	}

}

//InvocationHandler接口实现类：代理类中扩展逻辑抽取封装
public class LogInvocationHandlerImpl implements InvocationHandler {
	private Object target;
	public LogInvocationHandlerImpl(Object target) {
		this.target = target;
	}
	
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

		System.out.printf("方法%s开始执行\n",method.getName());
		
		//执行目标对象的目标方法
		Object ReturnValue =method.invoke(target, args);
		
		System.out.printf("方法%s结束执行\n",method.getName());
		
		return ReturnValue;
	}

}

public class client {
	public static void main(String[] args) {
		LogInvocationHandlerImpl handler1 = new LogInvocationHandlerImpl(new UserServiceImpl());
		
		UserService proxy1 = (UserService) Proxy.newProxyInstance(UserService.class.getClassLoader(), 
				new Class[] {UserService.class},
				handler1);
		proxy1.select();
		proxy1.update();
   }
}

以上为部分方法实现案例 

 静态代理的优缺点：

  • 优点：

  1. 可以在不修改目标对象的情况下增强目标对象的功能，实现了业务的分离，降低了系统的耦合度。
  2. 可以让代理对象在不影响目标对象的前提下对目标对象进行扩展。
  3. 可以对目标对象进行访问控制，增加系统的安全性。

  • 缺点 

  1. 每一个代理类只能为一个接口服务，增加了系统中类的数量，复杂度增加。
  2. 代理类和目标对象实现了相同的接口，当接口发生改变时，代理类和目标对象都需要同时进行修改，增加了系统的维护成本。
  3. 如果目标对象的方法很多，那么代理类也需要实现相同数量的方法，代码量相当大，实现起来比较麻烦。

动态代理的优缺点：

  • 优点：

  1. 动态代理可以实现接口中所有方法的代理，不需要像静态代理一样手动为每个方法创建代理类。
  2. 动态代理可以在不修改源码的情况下，对目标对象进行增强，非常灵活。
  3. 动态代理可以通过使用 InvocationHandler 接口，在代理对象方法执行前后添加额外的逻辑。

  • 缺点： 

  1. 动态代理代理的接口必须是已知的，如果被代理的对象实现的接口不确定，则无法使用动态代理。
  2. 动态代理在运行期间生成代理类的过程比较消耗时间，如果实例化频繁，可能会影响系统性能。
  3. 动态代理只能代理接口，无法代理实现类的方法。

 

猿究院懒羊羊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
反射（Reflection）
Rooike
03-04 649
反射所对应的包 Class类位于java.lang包下，在java中反射所用到的包位于java.lang.reflect包下： Class类：代表一个类Field类：代表类的属性Method类：代表类的方法Constructor类：代表类的构造方法 反射的步骤 要想使用反射，第一步都需要获得该类或者对象所对应的Class对象。 注意：在java中无论一个类生成了多少个实例
反射（Reflect）
AlwaysZS的博客
09-02 217
反射（Reflect） 1· 什么是是反射 1.1 反射的介绍 ​ 不是正常编程中出现的机制 ​ 框架底层源码会经常使用 ​ 可以解决代码通用性问题 ​ 学习要求： ​ 1.什么是反射，为什么要有反射，它能解决的问题 ​ 2.反射中有常用的类，类中的方法的使用 ​ 3.使用反射封装一些通用性比较强的代码 ​ 反射机制： 通过java语言占用的反射机制，可以操作字节码文件 有点类似于黑客的技术（读写字节码文件） 通过反射机制可以操作代码片段
C# Reflection 反射
gubaofu的博客
12-29 128
参考：https://www.runoob.com/csharp/csharp-reflection.html 1、 定义： (1) 反射指程序可以访问、检测和修改它本身状态或行为的一种能力。 (2) 程序集包含模块，而模块包括类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。 2、 优缺点： (1) 优点： 01. 它允许程序创建和控制任何类的对象，无需提前硬编...
java reflection 反射
m0_60136629的博客
10-17 28
java反射以及Class类的详细介绍
Reflection反射、Attribute特性
kalvin_y_liu的博客
10-04 118
Reflection反射、Attribute特性
reflection反射
07-13
Object instance = constructor.newInstance("Hello, Reflection!"); ``` 这会创建一个带有给定参数的新实例。 ### 5. 调用方法 `Method`对象提供了`invoke(Object obj, Object... args)`方法，允许我们在运行时...
实例介绍PHP的Reflection反射机制
10-25
主要介绍了实例介绍PHP的Reflection反射机制,本文从使用Reflection获取一个类的信息角度来介绍PHP的Reflection反射机制,需要的朋友可以参考下
PHP中的reflection反射机制测试例子
10-25
主要介绍了PHP中的reflection反射机制测试例子,从本文可以学到一些反射的使用方法,需要的朋友可以参考下
Reflection反射.md
12-31
javase基础之反射
javaReflection反射机制.ppt
04-03
之前上课的时候老师总结的JavaReflection反射学习资料，内容简单易懂，浅显易懂，适合小白入手学习。。
北京小程序开发如何选择开发团队与开发语言？
EVANYONG的博客
06-28 576
通过详细的了解小程序开发语言的种类与不同，能够提高客户与开发团队的沟通效率，促进小程序开发的高效化、便捷化。同时，方便、快捷的小程序离不开专业开发团队的加持，了解相关小程序开发团队的人员构成、技术水平与报价等详细信息，能够帮助客户正确选择合适的开发团队进行开发，从而达到事半功倍的效果。在选择北京小程序开发团队时，要观察该开发团队的人员架构，如果该团队具有合理且完善的人员架构，则能够完善的开发小程序。在选择小程序的开发团队时，要考虑到小程序的难易程度与开发费用，从而选择最符合企业预算的开发团队。
配置系统PATH环境变量
weixin_44626980的博客
06-29 605
PATH环境变量在操作系统中起着非常重要的作用，特别是在命令行或脚本中执行程序时，系统会根据PATH环境变量中定义的路径查找可执行文件。当用户在命令行或脚本中输入一个命令时，系统会根据PATH环境变量中定义的路径依次查找对应的可执行文件，如果找到则执行。本文详细介绍了如何配置系统的PATH环境变量，包括在Windows和Linux系统中的操作步骤。在Linux系统中，可以通过编辑shell配置文件来配置PATH环境变量，常用的shell配置文件包括.bashrc、.bash_profile等。
【C#】找不到属性集方法。get只读属性用了反射设置setValue肯定报错
小5聊的博客
06-26 1780
找不到属性集方法。get只读属性用了反射设置setValue肯定报错
【C++】————string基础用法及部分函数底层实现
最新发布
bhbcdxb123的博客
06-30 1042
本文主要介绍STL容器之一 ---- string，在学习C++的过程中，我们要将C++视为一个语言联邦（摘录于Effective C++ 条款一）。如何理解这句话呢，我们学习C++，可将其分为四个板块；分别为C、Object-Oriented C++（面向对象的C++）、Template C++（模板）、STL。本文就介绍STL中的string；1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。
SpringBoot：集成机器学习模型进行预测和分析
Easonmax的博客
06-30 506
通过本文的介绍，我们了解了如何使用SpringBoot集成机器学习模型，实现预测和分析功能。从项目初始化、配置TensorFlow模型、创建预测接口，到前端页面开发和扩展功能，SpringBoot提供了一系列强大的工具和框架，帮助开发者高效地实现机器学习集成。SpringBoot作为一个强大的框架，能够方便地集成机器学习模型，并提供灵活的部署和管理方案。通过这种方式，可以确保应用的各个部分在开发过程中得到充分的测试，减少上线后的问题。在基本的机器学习集成功能基础上，可以进一步扩展功能，使其更加完善和实用。
基于weixin小程序智慧物业系统的设计
ing65768的博客
06-27 430
管理员账户功能包括：系统首页，个人中心，管理员管理，用户管理，员工管理，房屋管理，缴费管理，车位管理，报修管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。工作人员账号功能包括：系统首页，维修管理，维修指派，公告管理，轮播图信息。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
解决Java中的数组越界异常的技术
weixin_44627014的博客
06-26 792
通过本文的讨论，我们了解了如何有效地处理Java中的数组越界异常。预防异常的发生，合理使用异常处理机制以及考虑使用集合类来替代数组，是确保Java应用程序稳定性和可靠性的关键步骤。
Java的异常处理体系
落日的博客
06-28 1183
ControllerAdvice 注解用于定义全局控制器建议，在 Spring MVC 中，控制器建议由控制器中的 @ExceptionHandler 方法、@InitBinder 方法和 @ModelAttribute 方法组成。①、CheckedException （检查异常 必须在代码中显式处理 使用try catch捕获 或者 在方法上使用 throws 抛出 除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受检查异常 ）
编译正则表达式模式re.compile
liujingwei8610的专栏
06-27 307
print("【执行】pattern.findall('这里有123个苹果和45个橘子')")result = pattern.findall('这里有123个苹果和45个橘子')print(f"【显示】pattern={pattern}")print(f"【显示】result={result}")根据给定的Python代码，哪个选项是正确的？A选项：返回值可以进行search操作。B选项：返回值可以进行match操作。D选项：参数为要编译的正则表达式模式。C选项：参数为要搜索的字符串。
使用获取reflection反射一个包时，是包的根路径吗
05-15
是的，获取一个包的反射时需要提供包的根路径。在Java中，可以使用Class类的getResource()或getResourceAsStream()方法来获取指定资源（包括类）的URL或InputStream，这些资源通常位于类路径下。如果你想要获取一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猿究院懒羊羊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值