java 非常好用的反射框架Reflections介绍
更新时间：2021年04月08日 10:08:17 作者：wei906
这篇文章主要介绍了java 反射框架Reflections的使用，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Reflections通过扫描classpath，索引元数据，并且允许在运行时查询这些元数据。
使用Reflections可以很轻松的获取以下元数据信息：
1）获取某个类型的所有子类；比如，有一个父类是TestInterface，可以获取到TestInterface的所有子类。
2）获取某个注解的所有类型/字段变量，支持注解参数匹配。
3）使用正则表达式获取所有匹配的资源文件
4）获取特定签名方法。
通常的用法有：
引入依赖jar
<dependency>
<groupId>org.reflections</groupId>
<artifactId>reflections</artifactId>
<version>0.9.10</version>
</dependency>
项目中使用：
// 初始化工具类
Reflections reflections = new Reflections(new ConfigurationBuilder().forPackages(basePackages).addScanners(new SubTypesScanner()).addScanners(new FieldAnnotationsScanner()));
// 获取某个包下类型注解对应的类
Set<Class<?>> typeClass = reflections.getTypesAnnotatedWith(RpcInterface.class, true);
// 获取子类
Set<Class<? extends SomeType>> subTypes = reflections.getSubTypesOf(SomeType.class);
// 获取注解对应的方法
Set<Method> resources =reflections.getMethodsAnnotatedWith(SomeAnnotation.class);
// 获取注解对应的字段
Set<Field> ids = reflections.getFieldsAnnotatedWith(javax.persistence.Id.class);
// 获取特定参数对应的方法
Set<Method> someMethods = reflections.getMethodsMatchParams(long.class, int.class);
Set<Method> voidMethods = reflections.getMethodsReturn(void.class);
Set<Method> pathParamMethods =reflections.getMethodsWithAnyParamAnnotated(PathParam.class);
// 获取资源文件
Set<String> properties = reflections.getResources(Pattern.compile(".*\\.properties"));
具体也可以参见官方文档
补充：Java中的反射：框架设计的灵魂
反射：框架设计的灵魂
框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
反射：将类的各个组成部分封装为其他对象，这就是反射机制
好处：
1.可以在程序运行过程中，操作这些对象。
2.可以解耦，提高程序的可扩展性。
获取Class对象的方式：
1.Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象
多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2.类名.class：通过类名的属性class获取
多用于参数的传递
3.对象.getClass()：getClass()方法在Object类中定义着。
多用于对象的获取字节码的方式
结论：
同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
例如我们有一个Person类
public class Person {
private String name;
private int age;
public Person(){
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
我们写一个Demo用三种方式来获取Class对象
public class Demo1 {
public static void main(String [] args) throws Exception {
//1、Class.forName("类名")
Class cls1 = Class.forName("man.Person");
System.out.println(cls1);
//2、类名。class
Class cls2= Person.class;
System.out.println(cls2);
//3、对象.getClass()
Person p = new Person();
Class cls3=p.getClass();
System.out.println(cls3);
}
}
Class对象功能：
获取功能：
1.获取成员变量们
Field[] getFields() ：获取所有public修饰的成员变量
Field getField(String name) 获取指定名称的 public修饰的成员变量
Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name)
2.获取构造方法们
Constructor<?>[] getConstructors() Constructor getConstructor(类<?>… parameterTypes) Constructor getDeclaredConstructor(类<?>… parameterTypes) Constructor<?>[] getDeclaredConstructors()
3.获取成员方法们：
Method[] getMethods() Method getMethod(String name, 类<?>… parameterTypes) Method[] getDeclaredMethods() Method getDeclaredMethod(String name, 类<?>… parameterTypes)
4.获取全类名
String getName() * Field：成员变量
操作：
5.设置值
void set(Object obj, Object value)
6.获取值
get(Object obj)
7.忽略访问权限修饰符的安全检查
setAccessible(true):暴力反射
Constructor:构造方法
创建对象：
T newInstance(Object… initargs)
如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法* Method：方法对象
执行方法：
Object invoke(Object obj, Object… args)
获取方法名称：
String getName:获取方法名
同样对于上面的Person类我们对其新增带参数和不带参数的sleep方法并且写一个Demo来获取这些成员变量，构造方法以及成员方法
Person.java
public class Person {
private String name;
private int age;
public String a;
protected String b;
String c;
private String d;
public Person(){
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("eat...");
}
public void eat(String food){
System.out.println("eat..."+food);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", a='" + a + '\'' +
", b='" + b + '\'' +
", c='" + c + '\'' +
", d='" + d + '\'' +
'}';
}
}
Demo2.java代码如下：
public class Demo2 {
public static void main(String [] args) throws Exception {
Class<Person> personClass = Person.class;
//获取成员变量
Field[] fields = personClass.getFields();
for(Field field:fields) {
System.out.println(field);
}
System.out.println("--------------");
Field a = personClass.getField("a");//获取a的值
Person p = new Person();
Object value=a.get(p);
System.out.println(value);
a.set(p, "zhangsan");//设置a的值
System.out.println(p);
System.out.println("=============");
//获取所有成员变量
Field[] declaredFields = personClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
Field d = personClass.getDeclaredField("d");
d.setAccessible(true);//暴力反射
Object value2 = d.get(p);
System.out.println(value2);
//获取构造方法
Constructor<Person> constructor = personClass.getConstructor(String.class, int.class);
System.out.println(constructor);
Object person = constructor.newInstance("张三", 23);
System.out.println(person);
System.out.println("=======");
Constructor<Person> constructor1 = personClass.getConstructor();
System.out.println(constructor1);
Object person1 = constructor1.newInstance();
System.out.println(person1);
//获取成员方法
Method eat_method = personClass.getMethod("eat");
Person p1 = new Person();
eat_method.invoke(p1);
Method eat_method1 = personClass.getMethod("eat",String.class);
eat_method1.invoke(p1,"饭");
System.out.println("---------");
Method[] methods = personClass.getMethods();
for (Method method : methods) {
System.out.println(method);
}
}
}
运行结果如下：
public java.lang.String man.Person.a
-------------- null Person{name=‘null', age=0, a=‘zhangsan', b=‘null', c=‘null', d=‘null'}
============= private java.lang.String man.Person.name private int man.Person.age public java.lang.String man.Person.a protected
java.lang.String man.Person.b java.lang.String man.Person.c private
java.lang.String man.Person.d null public
man.Person(java.lang.String,int) Person{name=‘张三', age=23, a=‘null',
b=‘null', c=‘null', d=‘null'}
======= public man.Person() Person{name=‘null', age=0, a=‘null', b=‘null', c=‘null', d=‘null'} eat… eat…饭
--------- public java.lang.String man.Person.toString() public java.lang.String man.Person.getName() public void
man.Person.setName(java.lang.String) public void
man.Person.eat(java.lang.String) public void man.Person.eat() public
void man.Person.setAge(int) public int man.Person.getAge() public
final void java.lang.Object.wait() throws
java.lang.InterruptedException public final void
java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws
java.lang.InterruptedException public boolean
java.lang.Object.equals(java.lang.Object) public native int
java.lang.Object.hashCode() public final native java.lang.Class
java.lang.Object.getClass() public final native void
java.lang.Object.notify() public final native void
java.lang.Object.notifyAll()
案例
需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
实现：
1. 配置文件
2. 反射
步骤：
1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2. 在程序中加载读取配置文件
3. 使用反射技术来加载类文件进内存
4. 创建对象
5. 执行方法
为了实现创建任意类的对象，并且执行其中任意方法，我们再原有Person.java文件基础上新增Student.java,代码如下：
public class Student {
public void sleep(){
System.out.println("sleep...");
}
}
那么我们需要在src目录下添加pro.properties文件并写入以下配置信息
className=man.Student methodName=sleep
接着我们来写这个案例ReflectTest.java,代码如下
public class ReflectTest {
public static void main(String [] args) throws Exception {
//加载配置文件
Properties pro = new Properties();
ClassLoader classLoader = ReflectTest.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("pro.properties");
pro.load(is);
//获取配置文件中定义的数据
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//加载该类进内存
Class cls = Class.forName(className);
Object obj = cls.newInstance();
Method method = cls.getMethod(methodName);
method.invoke(obj);
}
}
这样我们只需改变配置文件中的信息而不需要去改变任何代码就可以实现类以及类中的方法,整个目录结构如下
以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。如有错误或未考虑完全的地方，望不吝赐教。
相关文章
详解Spring关于@Resource注入为null解决办法
这篇文章主要介绍了详解Spring关于@Resource注入为null解决办法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2019-05-05
这篇文章主要介绍了Spring @Profile注解实现多环境配置,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2020-04-04
mybatis如何在一个update标签中写多条update语句
这篇文章主要介绍了mybatis如何在一个update标签中写多条update语句问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-08-08
这篇文章主要介绍了Spring Security自定义失败处理器问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-08-08
这篇文章主要介绍了Mybatis 如何处理clob类型数据的操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2021-06-06
如何在java文件中设置文字颜色:setTextColor()
这篇文章主要介绍了如何在java文件中设置文字颜色:setTextColor(),文末补充介绍了在java代码中设置字体颜色方法总结,结合实例代码介绍的非常详细,需要的朋友可以参考下2023-09-09
这篇文章主要介绍了SpringCloud的Eureka模块详解,Spring Cloud 封装了 Netflix 公司开发的 Eureka 模块来实现服务治理,就是提供了微服务架构中各微服务实例的快速上线或下线且保持各服务能正常通信的能力的方案总称,需要的朋友可以参考下2023-07-07
本文主要介绍了过滤器的基本概念,过滤器的生命周期,以及如何通过注解方式和非注解方式实现过滤器,过滤器是客户端与服务器资源文件之间的一道过滤网,能够帮助我们过滤不符合要求的请求,通常用作Session校验2024-10-10
这篇文章主要介绍了java分布式事务seata的使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-04-04
这篇文章主要介绍了Java中的final关键字和抽象类详解,当不希望 类被继承时，可以用final修饰比如不希望子类重写父类时,当不希望某个局部变量被修改时，对参数进行修饰,需要的朋友可以参考下2023-07-07
最新评论