java 动态性之反射机制 详解 案例

蜂信物联FastBee平台https://gitee.com/beecue/fastbee

阿里资料开源项目https://gitee.com/vip204888

百度低代码前端框架https://gitee.com/baidu/amis

OpenHarmony开源项目https://gitcode.com/openharmony

仓颉编程语言开放项目https://gitcode.com/Cangjie

Class strclass = path.getClass();

System.out.println(strcls.equals(strclass));

Class incls = int.class;

int[] arr1 = new int[10];

int[][] arr2 = new int[30][3];

int[] arr3 = new int[30];

double[] arr4 = new double[10];

System.out.println(arr1.getClass().hashCode());

System.out.println(arr2.getClass().hashCode());

System.out.println(arr3.getClass().hashCode());

System.out.println(arr4.getClass().hashCode());

} catch (Exception e) {

e.printStackTrace();

}

}

}

package com.lyy.test.bean;

public class User {

private int id;

private int age;

private String uname;

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getUname() {

return uname;

}

public void setUname(String uname) {

this.uname = uname;

}

public void setUname() {

this.uname = “lyy”;

}

public User(int id, int age, String uname) {

super();

this.id = id;

this.age = age;

this.uname = uname;

}

//javabean必须要有无参构造方法

public User() {

super();

}

}

应用反射API，获取类的信息（类的名字、属性、方法、构造器等）

package com.lyy.test;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

/**

• 应用反射API，获取类的信息（类的名字、属性、方法、构造器等）

• @author lyy

*/

public class Demo2 {

public static void main(String[] args) {

String path = “com.lyy.test.bean.User”;

try {

Class<?> cls = Class.forName(path);

//获取类的名字

System.out.println(cls.getName());//获得包名+类名

System.out.println(cls.getSimpleName());// 类名 User

//获取属性信息

// Field[] field = cls.getFields(); //只能获取public下的field

Field[] field = cls.getDeclaredFields();//获取所有的field

Field f = cls.getDeclaredField(“uname”);

System.out.println(field.length);

for (Field temp : field) {

System.out.println(“属性：”+temp);

}

//获取方法信息

Method[] method = cls.getDeclaredMethods();

Method method1= cls.getDeclaredMethod(“getUname”,null);

//如果方法有参数，则必须传递参数类型对应的Class对象

Method method2= cls.getDeclaredMethod(“setUname”,String.class);

for(Method m:method){

System.out.println(“方法：”+m);

}

//获取构造信息

Constructor[] con = cls.getDeclaredConstructors();

Constructor c =cls.getDeclaredConstructor(int.class,int.class,String.class);

System.out.println(“获取构造器：”+c);

for(Constructor m:con){

System.out.println(“构造器：”+m);

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

通过反射动态的操作 构造器、方法、属性

package com.lyy.test;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import com.lyy.test.bean.User;

/**

• 通过反射动态的操作 构造器、方法、属性

• @author lyy

*/

@SuppressWarnings(“all”)

public class Demo3 {

public static void main(String[] args) {

String path = “com.lyy.test.bean.User”;

try {

Class cls = (Class) Class.forName(path);

//通过反射API动态调用构造方法，构造对象

User u = cls.newInstance(); //其实是调用了User的无参构造方法

System.out.println(u);

Constructor c = cls.getDeclaredConstructor(int.class,int.class,String.class);

User u1 = c.newInstance(1001,18,“lyy666”);

System.out.println(u1.getUname());

//通过反射API 调用普通方法

User u2 = cls.newInstance();

Method method = cls.getDeclaredMethod(“setUname”,String.class);

method.invoke(u2, “lyy而”);//u2.setUname(“lyy3”);

System.out.println(u2.getUname());

//通过反射API操作属性

User u4 = cls.newInstance();

Field f = cls.getDeclaredField(“uname”);

f.setAccessible(true);//这个属性不需要安全检查了，可以直接访问

f.set(u4, “lyy4”);//通过反射直接写属性

System.out.println(u4.getUname());//通过反射直接读属性的值

System.out.println(f.get(u4));

} catch (Exception e) {

e.printStackTrace();

}

}

}

1.4 反射机制性能问题

1.4.1):启用和禁用访问安全检查的开关，值为true 则指示反射的对象在使用时应该取消java语言访问检查，值为false这指示反射的对象应该实施java语言的访问检查，并不是为true就能访问false就不能访问。

1.4.2):禁止安全检查，可以提高反射的运行速度

1.4.3):可以考虑使用：cglib/javaassist字节码操作

package com.lyy.test;

import java.lang.reflect.Method;

import com.lyy.test.bean.User;

/**

• 普通类调用 反射调用进行安全检查 反射调用不进行安全检查

• @author lyy

*/

public class Demo6 {

public static void test01(){

User u = new User();

long startTime = System.currentTimeMillis();

for (int i = 0; i < 1000000000L; i++) {

u.getUname();

}

long endTime = System.currentTimeMillis();

System.out.println(“普通方法调用 ，执行10亿次，耗时为：”+(endTime-startTime)+“ms”);

}

public static void test02() throws Exception{

User u = new User();

Class clazz = u.getClass();

Method m = clazz.getDeclaredMethod(“getUname”, null);

// m.setAccessible(true);

long startTime = System.currentTimeMillis();

for (int i = 0; i < 1000000000L; i++) {

m.invoke(u, null);

}

long endTime = System.currentTimeMillis();

System.out.println(“反射动态方法调用 ，执行10亿次，耗时为：”+(endTime-startTime)+“ms”);

}

public static void test03() throws Exception{

User u = new User();

Class clazz = u.getClass();

Method m = clazz.getDeclaredMethod(“getUname”, null);

m.setAccessible(true); //不需要执行访问安全检查

long startTime = System.currentTimeMillis();

for (int i = 0; i < 1000000000L; i++) {

m.invoke(u, null);

}

long endTime = System.currentTimeMillis();

System.out.println(“反射方法调用，跳过安全检查 ，执行10亿次，耗时为：”+(endTime-startTime)+“ms”);

}

public static void main(String[] args) throws Exception {

test01();

test02();

test03();

}

}

1.5 反射操作泛型（Generic）

1.5.1):java采用泛型擦除的机制引入泛型。java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型装换的麻烦。但是，一旦编译完成，所有和泛型有关的类型全部擦除

1.5.2):为了通过反射操作这些类型已迎合实际开发的需要，java就新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardTyoe几种类型代表不能被归一到Class类中的类型但是又和原始类型齐名的类型

ParameterizedType：表示一种参数化的类型，比如Collection

GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型

TypeVariable：是各种类型变量的公共父接口

WildcardTyoe：代表一种通配符类型表达式，比如：?,? extends Number ,? super Inter

package com.lyy.test;

import java.lang.reflect.Method;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.util.List;

import java.util.Map;

import com.lyy.test.bean.User;

/**

• 通过反射获取泛型信息

• @author lyy

*/

public class Demo4 {

public void test01(Map<String,User> map,List list){

System.out.println(“Demo04.test01()”);

}

public Map<Integer,User> test02(){

System.out.println(“Demo04.test02()”);

return null;

}

public static void main(String[] args) {

try {

//获得指定方法参数泛型信息

Method m = Demo4.class.getMethod(“test01”, Map.class,List.class);

Type[] t = m.getGenericParameterTypes();//获取泛型信息

for (Type paramType : t) {

System.out.println(“#”+paramType);

if(paramType instanceof ParameterizedType){

Type[] genericTypes = ((ParameterizedType) paramType).getActualTypeArguments();

for (Type genericType : genericTypes) {

System.out.println(“泛型类型：”+genericType);

}

}

}

//获取指定方法返回值泛型信息

Method m2 = Demo4.class.getMethod(“test02”, null);

Type returnType = m2.getGenericReturnType();

if(returnType instanceof ParameterizedType){

Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();

for (Type genericType : genericTypes) {

System.out.println(“返回值，泛型类型”+genericType);

}

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

package com.lyy.test.bean;

public class User {

private int id;

private int age;

private String uname;

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getUname() {

return uname;

}

public void setUname(String uname) {

this.uname = uname;

}

public void setUname() {

this.uname = “lyy”;

}

public User(int id, int age, String uname) {

super();

this.id = id;

this.age = age;

this.uname = uname;

}

//javabean必须要有无参构造方法

public User() {

super();

}

}

1.6 反射操作注解（annotation）

1.6.1):可以通过反射API:getAnnotations、getAnnotation获取相关的注解信息

package com.lyy.test;

import java.lang.annotation.Annotation;

import java.lang.reflect.Field;

import com.lyy.test.annotation.SxtField;

import com.lyy.test.annotation.SxtTable;

/**

*通过反射获取注解信息

• @authorlyy

*/

public class Demo5 {

public static void main(String[] args) {

try {

Class clazz = Class.forName(“com.lyy.test.annotation.SxtStudent”);

//获取所有类的所有有效注解

Annotation[] annotations=clazz.getAnnotations();

for (Annotation a : annotations) {

System.out.println(a);

}

//获取类的指定的注解

SxtTable st = (SxtTable) clazz.getAnnotation(SxtTable.class);

System.out.println(st.value());

//获得类的属性的注解

Field f = clazz.getDeclaredField(“studentName”);

SxtField sxtField = f.getAnnotation(SxtField.class);

System.out.println(sxtField.columnName()+“–”+sxtField.type()+“–”+sxtField.length());

//根据获取的表名、字段的信息、拼出DDL语句、然后，使用JDBC执行这个SQL，在数据库中生成相关的表

} catch (Exception e) {

e.printStackTrace();

}

}

}

package com.lyy.test.annotation;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Target(value={ElementType.TYPE})

@Retention(RetentionPolicy.RUNTIME)

public @interface SxtTable {

String value();

}

package com.lyy.test.annotation;

@SxtTable(“tb_student”)

public class SxtStudent {

@SxtField(columnName=“id”,type=“int”,length=10)

private int id;

@SxtField(columnName=“sname”,type=“varchar”,length=10)

private String studentName;

@SxtField(columnName=“age”,type=“int”,length=3)

private int age;

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getStudentName() {

return studentName;

}

public void setStudentName(String studentName) {

this.studentName = studentName;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

}

package com.lyy.test.annotation;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Target(value={ElementType.FIELD})

@Retention(RetentionPolicy.RUNTIME)

public @interface SxtField {

String columnName();

String type();

int length();

}

反射的核心是class ，反射降低了运行效率，但是提高了开发效率

2、动态编译

2.1):JAVA 6.0 引入了动态编译机制

2.1.2):动态编译的应用场景：

2.1.2.1):可以做一个浏览器端编写Java代码，上传服务器编译和运行的在线评测系统

2.1.2.2):服务器动态加载某些类进行进行编译

2.1.3)：动态编译的两种做法：

2.1.3.1):通过Rruntime调用javac,启动新的进程去操作

Runtime tun = Runtime.getRuntime();

Process process = run.exec(“java -cp g:/myjava/ HelloWorld.java”);

2.2):通过JavaCompiler动态编译

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

int result = compiler.run(null, null, null, “E:/myjava/HelloWorld.java”);

System.out.println(result==0?“编译成功！”:“编译失败！”);

第一个参数：为Java编译器提供参数

第二个参数：得到java编译器的输出信息

第三个参数：接收编译器的错误信息

第四个参数：可变参数（是一个String数组）能传入一个或多个Java源文件

返回值：0表示编译成功，非0表示编译失败

package com.lyy.test;

import java.lang.reflect.Method;

import java.net.URL;

import java.net.URLClassLoader;

import javax.tools.JavaCompiler;

import javax.tools.ToolProvider;

public class Demo1 {

public static void main(String[] args) throws Exception {

//通过IO操作，将字符串存储成一个临时文件(Hi.java)，然后调用动态编译方法！

String str = “public class Hi{public static void main(String[] args){”

• “System.out.println(“haha lyy”);}}”;

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

int result = compiler.run(null, null, null, “E:/myjava/HelloWorld.java”);

System.out.println(result==0?“编译成功！”:“编译失败！”);

//通过Runtime调用执行类

// Runtime run = Runtime.getRuntime();

// Process pro = run.exec(“java -cp E:/myjava HelloWorld”);

//

// InputStream in = pro.getInputStream();

// BufferedReader reader = new BufferedReader(new InputStreamReader(in));

// String info = “”;

// while((info=reader.readLine()) != null){

// System.out.println(info);

// }

URL[] urls = new URL[]{new URL(“file:/”+“E:/myjava/”)};

URLClassLoader loader = new URLClassLoader(urls);

Class c = loader.loadClass(“HelloWorld”);

//调用加载类的main方法

Method method = c.getMethod(“main”,String[].class);

method.invoke(null,(Object)new String[]{“aa”,“bb”});

//由于可变参数是5.0之后才有 method.invoke(null,“aa”,“bb”) 会发生参数个数不匹配的问题

//因此，必须要加上(Object)转型，避免这个问题

//public static void main(String[] a,String[] b)

}

}

3、动态执行javassript代码

3.1):JAVA脚本引擎是从JDK6.0之后添加的新功能

3.2):脚本引擎介绍：

使得java应用程序可以通过一套固定的接口与各种脚本引擎交互，从而达到在Java平台上调用各种脚本语言的目的。

java脚本API是连通java平台和脚本语言的桥梁。

可以把一些复杂异变的业务逻辑交给脚本语言处理，这又大大提高了开发效率

3.3):获取脚本引擎对象

//获得脚本引擎对应

ScriptEngineManager sem = new ScriptEngineManager();

ScriptEngine engine = sem.getEngineByName(“javascript”);

3.4):java脚本API为开发者提供了如些功能：

获取本程序输入，通过脚本引擎运行脚本并返回运行结果，这是最核心的接口。

注意是：接口 。java可以使用各种不同的实现，从而通用的调用js、groovy、python等脚本

Rhino 是一种使用Java语言编写的javaScript的开源实现，原先由Mozilla开发，现在被集成进入JDK 6.0

通过脚本引擎的运行上下文在脚本和Java平台间交换数据

通过Java应用程序调用脚本函数

package com.lyy.test;

import java.io.FileReader;

import java.net.URL;

import java.util.List;

import javax.script.Invocable;

import javax.script.ScriptEngine;

import javax.script.ScriptEngineManager;

/**

• 测试脚本引擎执行javascript代码

• @author lyy

*/

public class Demo1 {

public static void main(String[] args) throws Exception {

总结

三个工作日收到了offer，头条面试体验还是很棒的，这次的头条面试好像每面技术都问了我算法，然后就是中间件、MySQL、Redis、Kafka、网络等等。

• 第一个是算法

关于算法，我觉得最好的是刷题，作死的刷的，多做多练习，加上自己的理解，还是比较容易拿下的。

而且，我貌似是将《算法刷题LeetCode中文版》、《算法的乐趣》大概都过了一遍，尤其是这本

《算法刷题LeetCode中文版》总共有15个章节：编程技巧、线性表、字符串、栈和队列、树、排序、查找、暴力枚举法、广度优先搜索、深度优先搜索、分治法、贪心法、动态规划、图、细节实现题

《算法的乐趣》共有23个章节：

• 第二个是Redis、MySQL、kafka（给大家看下我都有哪些复习笔记）

基本上都是面试真题解析、笔记和学习大纲图，感觉复习也就需要这些吧（个人意见）

• 第三个是网络（给大家看一本我之前得到的《JAVA核心知识整理》包括30个章节分类，这本283页的JAVA核心知识整理还是很不错的，一次性总结了30个分享的大知识点）

EngineManager();

ScriptEngine engine = sem.getEngineByName(“javascript”);

3.4):java脚本API为开发者提供了如些功能：

获取本程序输入，通过脚本引擎运行脚本并返回运行结果，这是最核心的接口。

注意是：接口 。java可以使用各种不同的实现，从而通用的调用js、groovy、python等脚本

Rhino 是一种使用Java语言编写的javaScript的开源实现，原先由Mozilla开发，现在被集成进入JDK 6.0

通过脚本引擎的运行上下文在脚本和Java平台间交换数据

通过Java应用程序调用脚本函数

package com.lyy.test;

import java.io.FileReader;

import java.net.URL;

import java.util.List;

import javax.script.Invocable;

import javax.script.ScriptEngine;

import javax.script.ScriptEngineManager;

/**

• 测试脚本引擎执行javascript代码

• @author lyy

*/

public class Demo1 {

public static void main(String[] args) throws Exception {

总结

三个工作日收到了offer，头条面试体验还是很棒的，这次的头条面试好像每面技术都问了我算法，然后就是中间件、MySQL、Redis、Kafka、网络等等。

• 第一个是算法

关于算法，我觉得最好的是刷题，作死的刷的，多做多练习，加上自己的理解，还是比较容易拿下的。

而且，我貌似是将《算法刷题LeetCode中文版》、《算法的乐趣》大概都过了一遍，尤其是这本

《算法刷题LeetCode中文版》总共有15个章节：编程技巧、线性表、字符串、栈和队列、树、排序、查找、暴力枚举法、广度优先搜索、深度优先搜索、分治法、贪心法、动态规划、图、细节实现题

[外链图片转存中…(img-luuPrIIm-1725144879343)]

《算法的乐趣》共有23个章节：

[外链图片转存中…(img-e8aftaGP-1725144879344)]

[外链图片转存中…(img-retMtEi2-1725144879345)]

• 第二个是Redis、MySQL、kafka（给大家看下我都有哪些复习笔记）

基本上都是面试真题解析、笔记和学习大纲图，感觉复习也就需要这些吧（个人意见）

[外链图片转存中…(img-8XbwCWJt-1725144879345)]

• 第三个是网络（给大家看一本我之前得到的《JAVA核心知识整理》包括30个章节分类，这本283页的JAVA核心知识整理还是很不错的，一次性总结了30个分享的大知识点）

[外链图片转存中…(img-75oRJaaA-1725144879345)]