Java高级之反射详解

72 阅读 0 评论 48 点赞

我是靠谱客的博主甜甜白羊，最近开发中收集的这篇文章主要介绍Java高级之反射详解，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

一，类的加载概述和加载时机　

1.1.1，类的加载概述:

　　 当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。　

加载
- 　就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。
连接
- 　验证是否有正确的内部结构，并和其他类协调一致
- 　准备负责为类的静态成员分配内存，并设置默认初始化值
- 　解析将类的二进制数据中的符号引用替换为直接引用
初始化
- 　就是我们以前讲过的初始化步骤

1.1.2，加载时机:

创建类的实例
- 访问类的静态变量，或者为静态变量赋值
- 调用类的静态方法
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
- 初始化某个类的子类
- 直接使用java.exe命令来运行某个主类

1.2.1，类加载器的概述和分类:

A.类加载器的概述:
- 　　负责将.class文件加载到内存中，并为之生成对应的Class对象。虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。　
B.类加载器的分类:
- 　　Bootstrap ClassLoader 根类加载器
- 　　Extension ClassLoader 扩展类加载器
- 　　Sysetm ClassLoader 系统类加载器
C.类加载器的作用:
- 　　Bootstrap ClassLoader 根类加载器
- 　　也被称为引导类加载器，负责Java核心类的加载
- 　　比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
- 　　Extension ClassLoader 扩展类加载器
- 　　负责JRE的扩展目录中jar包的加载。
- 　　在JDK中JRE的lib目录下ext目录
- 　　Sysetm ClassLoader 系统类加载器
- 　　负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径

二，什么是反射?

1.3.1，反射的概述：

　　 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
　　对于任意一个对象，都能够调用它的任意一个方法和属性；
　　这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
　　要想解剖一个类,必须先要获取到该类的字节码文件对象。
　　而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。

1.3.2，解剖获取字节码对象的三种方式：

Object类的getClass()方法,判断两个对象是否是同一个字节码文件
静态属性class,锁对象
Class类中静态方法forName(),读取配置文件

 1 package com.bgs.reflect;
 2 import com.bgs.pojo.Person;
 3 public class ExampleReflect_day01 {
 4
public static void main(String[] args) throws ClassNotFoundException {
 5
//第一种方式通过Class类中静态方法forName(),读取配置文件
 6
Class<?> clazz1 = Class.forName("com.bgs.pojo.Person");
 7
//静态属性class,锁对象
 8
Class clazz2 = Person.class;
 9
//第三种方式直接new对象通过对象.class来获取对象
10
Person person = new Person();
11
Class class3 = person.getClass();
12
//对比三个字节码对象是否一样
13
System.out.println(clazz1 == clazz2);
14
System.out.println(class3 == clazz2);
15 
}
16 }

执行结果:true，true（说明这三种获取字节码对象的方式获取的都是同一个字节码对象，所以我们可以选择其中一个使用.forName比较常用）

三，反射各种函数的使用：

1.4.1，通过反射获取带参构造方法并使用:

　　Class类的newInstance()方法是使用该类无参的构造函数创建对象, 如果一个类没有无参的构造函数, 就不能这样创建了,可以调用Class类的getConstructor(String.class,int.class)方法获取一个指定的构造函数然后再调用Constructor类的newInstance("张三",20)方法创建对象

先创建一个实体类Person

 1 package com.bgs.pojo;
 2
 3 public class Person {
 4
private int age;
 5
private String name;
 6
 7
 8
public Person(int age, String name) {
 9 
super();
10
this.age = age;
11
this.name = name;
12 
}
13
public int getAge() {
14
return age;
15 
}
16
public void setAge(int age) {
17
this.age = age;
18 
}
19
public String getName() {
20
return name;
21 
}
22
public void setName(String name) {
23
this.name = name;
24 
}
25 
@Override
26
public int hashCode() {
27
final int prime = 31;
28
int result = 1;
29
result = prime * result + age;
30
result = prime * result + ((name == null) ? 0 : name.hashCode());
31
return result;
32 
}
33 
@Override
34
public boolean equals(Object obj) {
35
if (this == obj)
36
return true;
37
if (obj == null)
38
return false;
39
if (getClass() != obj.getClass())
//判断调用对象和传入对象的字节码文件是否是同一个字节码文件
40
return false;
41
Person other = (Person) obj;
42
if (age != other.age)
43
return false;
44
if (name == null) {
45
if (other.name != null)
46
return false;
47
} else if (!name.equals(other.name))
48
return false;
49
return true;
50 
}
51 
@Override
52
public String toString() {
53
return "Person [age=" + age + ", name=" + name + "]";
54 
}
55
public void eat() {
56
System.out.println("Suppose one day you're gone");
57 
}
58
public void eat(int num) {
59
System.out.println("So does this world still have the meaning that I exist?"+num);
60
61 
}
62 }

然后在创建一个测试类，去或者实体类中的私有属性，并且为其赋值(没有通过封装的get，set方法就为其加上了属性是不是很好奇)

 1 package com.bgs.reflect;
 2
 3 import java.lang.reflect.Constructor;
 4
 5 import com.bgs.pojo.Person;
 6
 7 public class ExampleReflect_day03 {
 8
public static void main(String[] args) throws Exception {
 9
Class<?> clazz = Class.forName("com.bgs.pojo.Person");//获取包为com.bgs.pojo.Person的字节码对象
10 //
Person p = (Person) clazz.newInstance(); //通过无参构造创建对象(调用newInstance的方笔必须要有默认参数)假如没有则会报异常
11 //
System.out.println(p);
12
Constructor<?> constructor = clazz.getConstructor(int.class,String.class);//获取有参构造
13
Person person = (Person) constructor.newInstance(23,"张三");
//通过有参构造创建对象
14
System.out.println(person);
//执行结果为:Person [age=23, name=张三]
15 
}　　　　　　
16 }

1.4.2，通过反射获取成员变量并使用：

 1 ackage com.bgs.reflect;
 2
 3 import java.lang.reflect.Constructor;
 4 import java.lang.reflect.Field;
 5
 6 import com.bgs.pojo.Person;
 7
 8 /**
 9  * @author Administrator Field
10  *
Class.getField(String)方法可以获取类中的指定字段(可见的),
11  *
如果是私有的可以用getDeclaedField("name")方法获取,通过set(obj,
12  *
"李四")方法可以设置指定对象上该字段的值,
13  *
如果是私有的需要先调用setAccessible(true)设置访问权限,用获取的指定的字段调用get(obj)
14  *
可以获取指定对象中该字段的值
15  *
16
*/
17 public class ExampleReflect_day04 {
18
public static void main(String[] args) throws Exception {
19
Class<?> clazz = Class.forName("com.bgs.pojo.Person");//获取包为com.bgs.pojo.Person的字节码对象
20
Constructor<?> constructor = clazz.getConstructor(int.class,String.class);//获取有参构造
21
Person person = (Person) constructor.newInstance(23,"张三");
//通过有参构造创建对象
22 //
Field f = clazz.getField("name");
//反射获取姓名字段
23 //
f.set(person, "姜煜");//对姓名字段进行修改
//异常: Class com.example.reflect.ExampleReflect_day04 can not access a member of class com.example.reflect.Person with modifiers "private"
24
Field f = clazz.getDeclaredField("name");
//暴力反射获取姓名字段
25
f.setAccessible(true);
//去除私有权限
26
f.set(person, "姜煜");
27
System.out.println(person);　　
28 
}
29 }

执行结果为:Person [age=23, name=姜煜]　　原本用反射给这个对象的私有属性赋值赋的是23，张三，然后用暴力反射去给对象把name的属性李四换成姜煜

1.4.3，通过反射获取方法并使用

　　Class.getMethod(String, Class...) 和 Class.getDeclaredMethod(String, Class...)方法可以获取类中的指定方法,调用invoke(Object, Object...)可以调用该方法,Class.getMethod("eat") invoke(obj) 　　　　　　　　Class.getMethod("eat",int.class) invoke(obj,10)

 1 package com.bgs.reflect;
 2
 3 import java.lang.reflect.Constructor;
 4 import java.lang.reflect.Method;
 5
 6 import com.bgs.pojo.Person;
 7
 8 public class ExampleReflect_day05 {
 9
public static void main(String[] args) throws Exception {
10
Class<?> clazz = Class.forName("com.bgs.pojo.Person");//获取包为com.example.reflect.Person的字节码对象
11
Constructor<?> constructor = clazz.getConstructor(int.class, String.class);// 获取有参构造
12
Person person = (Person) constructor.newInstance(23, "张三"); // 通过有参构造创建对象
13
14
Method m = clazz.getMethod("eat"); //获取etc方法
15 
m.invoke(person);
16
17
Method m2 = clazz.getMethod("eat", int.class);//获取有参的eat方法
18
m2.invoke(person, 10);
19 
}
20 }

执行结果:Suppose one day you're gone　　So does this world still have the meaning that I exist?10 ，可能有的小白不知道为什么执行这个，因为我再实体类中添加的有这个eat方法

1.4.4，通过反射越过泛型检查:

　　案例演示：
　　　　ArrayList<Integer>的一个对象，在这个集合中添加一个字符串数据，如何实现呢？

 1 package com.bgs.reflect;
 2
 3 import java.lang.reflect.Method;
 4 import java.sql.Array;
 5 import java.util.ArrayList;
 6
 7 /**
 8  *
泛型只在编译器有效,在运行期会被擦除掉
 9
*/
10 public class ExampleReflect_day06 {
11
public static void main(String[] args) throws Exception {
12
ArrayList<Integer> list = new ArrayList<>();
13
list.add(111);
14
list.add(222);
15
Class<?> clazz = Class.forName("java.util.ArrayList");
//获取到字节码对象
16
Method m = clazz.getMethod("add", Object.class);
//获取add方法
17
m.invoke(list, "abc");
18
System.out.println(list);
19 
}
20 }

执行结果：[111, 222, abc] 是不是感觉反射特别神奇，竟然连集合的泛型都能无视

1.4.5，动态代理的概述和实现:

　　动态代理概述
　　　　代理：本来应该自己做的事情，请了别人来做，被请的人就是代理对象。
　　　　举例：春节回家买票让人代买
　　　　动态代理：在程序运行过程中产生的这个对象,而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

　　通过代理的过程:
　　　　在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。
　　　　我们有更强大的代理cglib，Proxy类中的方法创建动态代理类对象
　　　　public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
　　　　最终会调用InvocationHandler的方法
　　　　InvocationHandler Object invoke(Object proxy,Method method,Object[] args)

　　代码实现:

　　　　1.先创建一个接口类Student　

1 package com.bgs.动态代理;
2
3 public interface Student {
4
public void login();
5
6
public void submit();
7 }

　　　　2.再创建一个类去实现Student接口

 1 package com.bgs.动态代理;
 2
 3 public class StudentImp implements Student{
 4
 5 
@Override
 6
public void login() {
 7
//
System.out.println("校验管理功能");
 8
System.out.println("登陆");
 9
//
System.out.println("日志管理功能");
10
11 
}
12
13 
@Override
14
public void submit() {
15
//
System.out.println("校验管理功能");
16
System.out.println("提交");
17
//
System.out.println("日志管理功能");
18 
}
19
20 }

假如实现类中我们要加一个校验信息功能，和日志管理功能，我们要在每个实现功能的上面去添加校验管理功能，那个的下面添加日志管理功能，现在才两个功能还好，假如以后代码功能多了我们这样会造成代码耦合度高，代码复用性低，会造成程序执行缓慢，因为都是重复代码（这就是我们为什么要用动态代理的原因）

　　　　3.再创建一个动态代理类，去实现InvocationHandler接口实现invoke方法

 1 package com.bgs.动态代理;
 2
 3 import java.lang.reflect.InvocationHandler;
 4 import java.lang.reflect.Method;
 5
 6 public class MyInvocationHandler implements InvocationHandler {
 7
private Object target;
 8
 9
public
MyInvocationHandler(Object target) {
10
this.target = target;
11 
}
12 
@Override
13
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
14
System.out.println("校验管理功能");
15
method.invoke(target, args);
//执行被代理target对象的方法
16
System.out.println("日志管理功能");
17
return null;
18 
}
19 }

　　　　4.创建一个测试类,

 1 package com.bgs.动态代理;
 2
 3 import java.lang.reflect.InvocationHandler;
 4 import java.lang.reflect.Proxy;
 5
 6
 7
 8 public class Test {
 9
public static void main(String[] args) {
10
UserImp uImp = new UserImp();
11 
uImp.add();
12 
uImp.delete();
13
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
14
MyInvocationHandler m = new MyInvocationHandler(uImp);
15
////参数第一个是传的固定的 第二个参数也是固定的 第三个参数传的事MyInvocationHandler的子类对象
16
User user = (User) Proxy.newProxyInstance(uImp.getClass().getClassLoader(), uImp.getClass().getInterfaces(), m);
17 
user.add();
18 
user.delete();
19 
}
20 }

执行结果:

四，反射总结:

　　灵活使用反射能让我们代码更加灵活，这里比如JDBC原生代码注册驱动，hibernate 的实体类，Spring 的 AOP等等都有反射的实现。但是凡事都有两面性，反射也会消耗系统的性能，增加复杂性等，合理使用才是真！

转载于:https://www.cnblogs.com/joeyJss/p/10491807.html

最后

以上就是甜甜白羊为你收集整理的Java高级之反射详解的全部内容，希望文章能够帮你解决Java高级之反射详解所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：java
浏览次数：72 次浏览
发布日期：2024-01-12 09:25:24
本文链接：https://www.kaopuke.com/article/k-p-k_13_u_23_ogf1_14__23_g2.html

Java高级之反射详解

概述

一，类的加载概述和加载时机

1.1.1，类的加载概述:

1.1.2，加载时机:

1.2.1，类加载器的概述和分类:

二，什么是反射?

1.3.1，反射的概述：

1.3.2，解剖获取字节码对象的三种方式：

三，反射各种函数的使用：

1.4.1，通过反射获取带参构造方法并使用:

1.4.2，通过反射获取成员变量并使用：

1.4.3，通过反射获取方法并使用

1.4.4，通过反射越过泛型检查:

1.4.5，动态代理的概述和实现:

四，反射总结:

最后

评论列表共有 0 条评论

发表评论取消回复

Java高级之反射详解

概述

一，类的加载概述和加载时机

1.1.1，类的加载概述:

1.1.2，加载时机:

1.2.1，类加载器的概述和分类:

二，什么是反射?

1.3.1，反射的概述：

1.3.2，解剖获取字节码对象的三种方式：

三，反射各种函数的使用：

1.4.1，通过反射获取带参构造方法并使用:

1.4.2，通过反射获取成员变量并使用：

1.4.3，通过反射获取方法并使用

1.4.4，通过反射越过泛型检查:

1.4.5，动态代理的概述和实现:

四，反射总结:

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

一，类的加载概述和加载时机　

发表评论取消回复