java 动态性之反射机制 详解 案例,java架构师技术图谱
1.2 反射机制的常见作用
1.2.1):动态加载类、动态获取类的信息(属性、方法、构造器)
1.2.2):动态构造对象
1.2.3):动态调用类和对象的任意方法、构造器
1.2.4):动态调用和处理属性
1.2.5):获取泛型信息
1.2.6):处理注解
1.3 Class类的对象如何获取?
1.3.1):运用 getClass()
1.3.2):运用Class.forName()(最常被使用)
1.3.3):运用 .class语法
测试各种类型(class、interface、enum、annotaion,primitive type void void) 测试java.lang.Class对应的获取方式
package com.lyy.test;
/**
测试各种类型(class、interface、enum、annotaion,primitive type void void) 测试java.lang.Class对应的获取方式
@author lyy
*/
@SuppressWarnings(“all”)
public class Demo1 {
public static void main(String[] args) {
try {
String path = “com.lyy.test.bean.User”;
Class<?> cls = Class.forName(path);
//对象用来表示或封装一些数据 一个类加载后,JVM会创建一个对应该类的class对象,类的机构信息会放到对应的class对象中
//class对象就像一面镜子一样,通过这面镜子可以看到对应的全部信息
Class<?> clss = Class.forName(path);
System.out.println(cls.hashCode());//一个类只对应一个Class对象
System.out.println(clss.hashCode());
Class strcls = String.class;
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.printStackT
【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】浏览器打开:qq.cn.hn/FTf 免费领取
race();
}
}
}
通过反射动态的操作 构造器、方法、属性
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 {
//相当于Java和Js脚本语言的一个中介
//获得脚本引擎对应
ScriptEngineManager sem = new ScriptEngineManager();
ScriptEngine engine = sem.getEngineByName(“javascript”);
//定义变量 存储到引擎的上下文中
engine.put(“msg”, “lyy is good man!”);
String str = “var user = {name:‘lyy’,age:18,schools:[‘清华大学’,‘湖北大学’]};”;
str +=“println(user.age)”;
//执行脚本
engine.eval(str);
engine.eval(“msg=‘lyy is goods !!!’”);
System.out.println(engine.get(“msg”));
System.out.println("==============================================");
//定义函数
engine.eval(“function add(a,b){var sum = a+b; return sum;}”);
//取得调用接口
Invocable jsInvoke = (Invocable)engine;
//执行脚本中定义的方法!
Object obj=jsInvoke.invokeFunction(“add”, new Object[]{13,20});
System.out.println(obj);
//导入其他的Java包,使用其他包中的java类,如果需要了解,可以详细学习了解Rhino的语法
String jsCode = “importPackage(java.util); var list = Arrays.asList([“清华大学”,“湖北工程学院”,“湖北职业技术学院”]);”;
engine.eval(jsCode);
List list2 = (List)engine.get(“list”);
for (String temp :list2) {
System.out.println(temp);
}
//执行一个js文件
URL url = Demo1.class.getClassLoader().getResource(“in.js”);
FileReader fr = new FileReader(url.getPath());
engine.eval(fr);
fr.close();
}
}
in.js
//定义test方法
function test(){
var a = 3;
var b = 4;
println(“invoke js file:”+(a+b));
}
//执行test方法
test();
**4、动态字节码操作
**
java 动态性之反射机制 详解 案例,java架构师技术图谱相关推荐
- JAVA基础--JAVA中的反射机制详解
JAVA反射机制 JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法:这种动态获取的信息以及动态调用对象的方法的功能 ...
- java反射机制详解_JAVA反射机制详解_JSP/Java编程_互联网开发技术网_传播最新的编程技术_php361.com...
今天,下午在和朋友聊天的时候,聊起了反射这个话题. 我们就从下面这个段简单的代码开始吧. 这个代码输出什么,想必大部分的读者跟我一样,会很快地知道答案:0 1 2 3 4 5 6 7 8 9.事实也是 ...
- 反射 数据类型_Java基础:反射机制详解
一.什么是反射: (1)Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息,从而操作类或对象的属性和方法.本质是JVM得到class对象之后,再通过class对象进行反编译,从而获取t对 ...
- Java类加载机制详解【java面试题】
Java类加载机制详解[java面试题] (1)问题分析: Class文件由类装载器装载后,在JVM中将形成一份描述Class结构的元信息对象,通过该元信息对象可以获知Class的结构信息:如构造函数 ...
- java的动态代理机制详解
2019独角兽企业重金招聘Python工程师标准>>> 参考资料 1.java的动态代理机制详解 转载于:https://my.oschina.net/Howard2016/blog ...
- php 反射原理,PHP反射机制详解
本文主要和大家分享PHP反射机制详解,内容包括1.自动生成文档2.实现 MVC 架构3.实现单元测试4.配合 DI 容器解决依赖,希望能帮助到大家. 1.自动生成文档 根据反射的分析类,接口,函数和方 ...
- Java中的反射机制详讲
Java中的反射机制详讲 1.反射机制_介绍_Class对象获取 2.反射机制_动态操作_构造器_方法_属性 3.动态编译_DanamicCompile_反射调用main方法问题 好文推荐:排序.查找 ...
- Java虚拟机中类加载机制详解
Java虚拟机中类加载机制详解 1,什么是java类加载机制 **首先在java中,是通过编译来生成.class文件(可能在本地,或者网页下载),java的类加载机制就是 将这些.class文件加载到 ...
- JAVA classpath设置方式启动详解:java class名、java -jar
java classpath设置方式启动详解:java className.java -jar 文章目录 java classpath设置方式启动详解:java className.java -jar ...
- java反射机制详解篇一(基础)
反射基础 首先来看一下最常规的创建对象的方式: ObjectClass clazz = new ObjectClass(); 当程序执行到new ObjectClass的时候,java虚拟机会加载Ob ...
最新文章
- 如何写优雅的SQL原生语句?
- BufferedReader和BufferedWriter读写文件
- 某公司有一台打印、复印一体机,需要将购买成本分年均摊到隔年的费用中。请编写一个程序,根据用户输入的购买金额和预计使用年限计算每年的分摊费用。要求对输入异常进行适当的处理。
- SMTP协议原始命令码和工作原理
- vs如何显示arcgis 二次开发工具控件
- Citrix 客户端登录出现wfshell.exe - 应用程序错误的解决方法
- python dll load failed_python安装MySQLdb的问题 ImportError: DLL load failed
- GIMP用Path作画了解一下
- 在Windows Mobile上隐藏你的应用程序
- Java打印26个字母
- 人才管理是什么意思_人力资源的HRM、HRD、CHO分别是什么意思?
- 包引入中,在包名前使用下划线“_”
- 数据库perl脚本:创建SDB各表,并导入数据
- 码云 注册 注册个性域名报错---已经解决
- 2018.8.盛夏,
- android_button onclick点击事件的5种写法
- 非常棒的开源协同办公OA项目,收藏了!
- 蓝牙架构(6)—— 3 数据传输架构(3.1 核心传输载体)
- 路缘石成型机对着项目质量加强的方向努力
- Android系统---Settings