本文深入探讨了Java反射机制，包括其功能、主要API以及在运行时操作对象的示例。通过反射，可以在运行时动态地获取类的信息、创建对象、调用方法和访问私有成员。此外，还介绍了Class类的获取方式、反射与封装性的关系，以及动态代理的概念和应用。动态代理在调试、远程方法调用等方面具有优势，可以灵活地创建代理对象来实现特定功能。
1、Java反射机制概述
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
1.1 Java反射机制提供的功能
-
在运行时判断任意一个对象所属的类
-
在运行时构造任意一个类的对象
-
在运行时判断任意一个类所具有的成员变量和方法
-
在运行时获取泛型信息
-
在运行时调用任意一个对象的成员变量和方法
-
在运行时处理注解
-
生成动态代理
1.2 反射相关的主要API
java.lang.Class:代表一个类java.lang.reflect.Method:代表类的方法java.lang.reflect.Field:代表类的成员变量java.lang.reflect.Constructor:代表类的构造器
测试类
import org.junit.Test;
public class ReflectionTest {
//反射之前，对于Person的操作
@Test
public void test(){
//1.创建类的对象
Person p1 = new Person("jay",21);
//2.调用对象,调用其内部的属性和方法
p1.age = 15;
System.out.println(p1.toString());
p1.show();
//在Person类的外部，不可以通过Person类的对象调用其内部私有的结构。
//比如：name、showNation以及私有的构造器。
}
}
Person类
package github;
public class Person {
private String name;
public int 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;
}
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
private Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public void show(){
System.out.println("你好，我是🔔");
}
private String showNation(String nation){
System.out.println("喷子实在太多了！！！" + nation);
return nation;
}
}
1.3 使用反射，实现同上的操作
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectionTest {
//反射之后 ，堆与Person的操作
@Test
public void test2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
Class clazz = Person.class;
//1.通过反射，创建Person类的对象
Constructor cons = clazz.getConstructor(String.class,int.class);
Object obj = cons.newInstance("Jon",18);
Person p = (Person) obj;
System.out.println(p.toString());
//2.通过反射，调用对象指定的属性和方法
//调用属性
Field age = clazz.getDeclaredField("age");
age.set(p,10);
System.out.println(p.toString());
//调用方法
Method show = clazz.getDeclaredMethod("show");
show.invoke(p);
}
}
1.4 反射的强大：调用类的私有结构
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectionTest {
//反射之后 ，堆与Person的操作
@Test
public void test2() throws Exception{
Class clazz = Person.class;
//1.通过反射，创建Person类的对象
Constructor cons = clazz.getConstructor(String.class,int.class);
Object obj = cons.newInstance("Jon",18);
Person p = (Person) obj;
System.out.println(p.toString());
//2.通过反射，调用对象指定的属性和方法
//调用属性
Field age = clazz.getDeclaredField("age");
age.set(p,10);
System.out.println(p.toString());
//调用方法
Method show = clazz.getDeclaredMethod("show");
show.invoke(p);
System.out.println("+++++++++++++++++++++++++");
//通过反射，是可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
//调用私有的构造器
Constructor cons2 = clazz.getDeclaredConstructor(String.class);
cons2.setAccessible(true);
Person p1 = (Person) cons2.newInstance("kalo");
System.out.println(p1);
//调用私有的属性
Field name = clazz.getDeclaredField("name");
name.setAccessible(true);
name.set(p1,"Taoyao");
System.out.println(p1);
//调用私有的方法
Method showNation = clazz.getDeclaredMethod("LiNin", String.class);
showNation.setAccessible(true);
String nation = (String) showNation.invoke(p1,"FaceBook");
//相当于String nation = p1.showNation("FaceBook")
System.out.println(nation);
}
/**
* 疑问1：通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用那个？
* 建议：直接new的方式。
* 什么时候会使用：反射的方式。 反射的特征：动态性
* 疑问2：反射机制与面向对象中的封装性是不是矛盾的？如何看待两个技术？
* 不矛盾。
*/
}
2、理解Class类并获取Class实例
2.1 Class类的理解
/**
* 关于java.lang.Class类的理解
* 1.类的加载过程：
* 程序经过Javac.exe命令后，会生成一个或多个字节码文件(.class结尾)。
* 接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件
* 加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此
* 运行时类，就作为Class的一个实例。
*
* 2.换句话说，Class的实例就对应着一个运行时类。
*/
Class类的常用方法
2.2 获取Class实例的4种方式
import org.junit.Test;
import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectionTest {
/**
* 2.换句话说，Class的实例就对应着一个运行时类。
* 3.加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式
* 来获取此运行时类。
*/
@Test
public void test3() throws ClassNotFoundException {
//方式一：
Class c1 = Person.class;
System.out.println(c1);
//方式二：通过运行时类的对象,调用getClass()
Person p1 = new Person();
Class c2 = p1.getClass();
System.out.println(c2);
//方式三：调用Class的静态方法：forName(String classPath)
Class c3 = Class.forName("www.gh110.com");
// c3 = Class.forName("www.123.com");
System.out.println(c3);
System.out.println(c1 == c2);
System.out.println(c1 == c3);
//方式四：使用类的加载器：ClassLoader (了解)
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class c4 = classLoader.loadClass("www.gh110.com");
System.out.println(c4);
System.out.println(c1 == c4);
}
}
2.3 Class实例对应的结构的说明
（1）class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
（2）interface：接口
（3）[]：数组
（4）enum：枚举
（5）annotation：注解@interface
（6）primitivetype：基本数据类型
（7）void
import org.junit.Test;
import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectionTest {
//万事万物皆对象？对象.xxx,File,URL,反射,前端、数据库操作
/**
* Class实例可以是哪些结构的说明：
*/
@Test
public void test4() {
Class s1 = Object.class;
Class s2 = Comparable.class;
Class s3 = String[].class;
Class s4 = int[][].class;
Class s5 = ElementType.class;
Class s6 = Override.class;
Class s7 = int.class;
Class s8 = void.class;
Class s9 = Class.class;
int[] a = new int[10];
int[] b = new int[100];
Class s10 = a.getClass();
Class s11 = b.getClass();
// 只要数组的元素类型与维度一样，就是同一个Class
System.out.println(s10 == s11);
}
}
3、类的加载与ClassLoader的理解
3.1 了解：类的加载过程
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。
4、通过反射，创建运行时类的对象
import org.junit.Test;
/**
* 通过发射创建对应的运行时类的对象
*/
public class NewInstanceTest {
@Test
public void test() throws Exception {
Class<Person> clazz = Person.class;
/**
* newInstance():调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。
*
* 要想调用此方法正常的创建运行时类的对象，要求：
* 1.运行时类必须提供空参的构造器
* 2.空参的构造器的访问权限得够。通常，设置为public。
*
* 在javabean中要求提供一个public的空参构造器。原因：
* 1.便于通过反射，创建运行时类的对象
* 2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
*/
Person obj = clazz.newInstance();
System.out.println(obj);
}
}
4.1 反射的动态性
public class NewInstanceTest {
/**
* 使用反射创建对象，体现反射的动态性
*
* @throws ClassNotFoundException
* @throws InstantiationException
* @throws IllegalAccessException
*/
@Test
public void test2() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
for (int i = 0; i < 100; i++) {
int num = new Random().nextInt(3);
String classPath = "";
switch (num) {
case 0:
classPath = "java.util.Date";
break;
case 1:
classPath = "java.lang.Object";
break;
case 2:
classPath = "com.atguigu.redis_springboot.reflection.Person";
break;
}
Object instance = getInstance(classPath);
System.out.println(instance);
}
}
/**
* 创建一个指定类的对象
*
* @param classPath 指定类的全类名
* @return
* @throws ClassNotFoundException
* @throws InstantiationException
* @throws IllegalAccessException
*/
public Object getInstance(String classPath) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class<?> clazz = Class.forName(classPath);
return clazz.newInstance();
}
}
5、反射的应用：动态代理
5.1 代理模式与动态代理
-
代理设计模式的原理:
使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
-
之前为大家讲解过代理机制的操作，属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。
-
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
-
动态代理使用场合:
- 调试
- 远程方法调用
-
动态代理相比于静态代理的优点：
抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。
5.2 静态代理举例
/**
* 静态代理举例
*
* 特点：代理类和被代理类在编译期间，就确定下来了。
*/
interface ClothFactory{
void produceCloth();
}
//代理类
class PersonTest implements ClothFactory{
private ClothFactory factory;//用被代理类对象进行实例化
public PersonTest(ClothFactory factory){
this.factory = factory;
}
@Override
public void produceCloth() {
System.out.println("造纸厂开始做一些准备工作");
factory.produceCloth();
System.out.println("造纸厂做一些后续收尾工作");
}
}
//被代理类
class NeckTest implements ClothFactory{
@Override
public void produceCloth() {
System.out.println("造纸厂计划生产一批卫生纸");
}
}
public class StaticProxyTest {
public static void main(String[] args) {
//创建被代理类的对象
ClothFactory word = new NeckTest();
//创建代理类的对象
ClothFactory proxyPaperFactory = new PersonTest(word);
proxyPaperFactory.produceCloth();
}
}
5.3 动态代理举例（掌握）
/**
* 动态代理举例
*
* @author chenlei
* @date 2022-04-07 21:05
* @description
*/
interface Human {
String getBelief();
void eat(String food);
}
/**
* 被代理类
*/
class SuperMan implements Human {
@Override
public String getBelief() {
return "I believe I can fly!";
}
@Override
public void eat(String food) {
System.out.println("超人喜欢吃：" + food);
}
}
class HumanUtil {
public void method1(){
System.out.println("===============通用方法一===============");
}
public void method2(){
System.out.println("===============通用方法二===============");
}
}
class ProxyFactory {
public static Object getProxyInstance(Object obj) {
MyInvocationHandler handler = new MyInvocationHandler();
handler.bind(obj);
// Proxy类，就是动态代理实现所用到的代理类，newProxyInstance()方法是用来创建代理对象
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
}
}
class MyInvocationHandler implements InvocationHandler{
// 需要使用被代理类的对象进行赋值
private Object obj;
public void bind(Object obj){
this.obj = obj;
}
/**
* 当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()方法
* 将被代理类要执行的方法a的功能就声明在invoke()中
* @param proxy
* @param method
* @param args
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
HumanUtil humanUtil = new HumanUtil();
humanUtil.method1();
/**
* method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
* obj:被代理类的对象
* method.invoke(目标对象，方法的参数)：就是用来执行目标方法的
*/
Object res = method.invoke(obj, args);
/**
* 上述方法的返回值就作为当前类中的invoke()的返回值
*/
humanUtil.method2();
// System.out.println("代理对象：" + proxy);
return res;
}
}
public class ProxyTest {
public static void main(String[] args) {
// 被代理类
SuperMan superMan = new SuperMan();
/**
* instance：代理类的对象
* 这里的返回值是Human,不是SuperMan
*/
Human instance = (Human) ProxyFactory.getProxyInstance(superMan);
System.out.println("代理对象：" + instance); // com.atguigu.redis_springboot.reflection1.SuperMan@17a7cec2
// 当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
String belief = instance.getBelief();
System.out.println(belief);
instance.eat("火锅");
}
}
打印结果：
6、JDK动态代理
jdk动态代理:
1.反射, Method类,表示方法。类中的方法。通过Method可以执行某个方法
2.jdk动态代理的实现
反射包java.lang. reflect,里面有三个类：InvocationHandler，Method，Proxy
6.1 Interface InvocationHandler
public interface InvocationHandler
InvocationHandler是由代理实例的调用处理程序实现的接口 。
每个代理实例都有一个关联的调用处理程序。 当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。
1) InvocationHandler接口(调用处理器):就一个方法 invoke()
invoke():表示代理对象要执行的功能代码。你的代理类要完成的功能就写在invoke()方法中。
代理类完成的功能
1.调用目标方法,执行目标方法的功能
2.功能增强,在目标方法调用时,增加功能
方法原型
参数：object proxy：jdk创建的代理对象，无需赋值。
Method method:目标类中的方法，jdk提供method对象的
object[]args:目标类中方法的参数，jdk提供的。
Object invoke(Object proxy,方法 method,Object[] args)throws
Throwable处理代理实例上的方法调用并返回结果。
6.2 Method
- Method类:表示方法的,确切的说就是目标类中的方法。
作用:通过 Method可以执行某个目标类的方法, Method. invoke();
method. invoke(目标对象,方法的参数)
object ret= method. invoke(service22,"李四")
6.3 Proxy类
1）proxy类：核心的对象，创建代理对象。之前创建对象都是new类的构造方法（）
现在我们是使用proxy类的方法，代替new的使用。
方法：静态方法 newProxyInstance(）
作用是：创建代理对象，等同于静态代理中的TaoBao taoBao=new TaoBao()
我们来观察方法原型
public static Object newProxyInstance( ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException
参数:
-
ClassLoader loader 类加载器,负责向内存中加载对象的,使用反射机制获取对象的classLoader,
如何获取? 类 a, a.getCalss().getClassLoader(),目标对象的类加载器这里我们细分:每一个类都继承Object类,在Object中有一个getClass方法,表示 类对象的运行时类的Class对象。 而Class类里面有一个public ClassLoader getClassLoader()方法
-
Class<?>[] interfaces: 接口,目标对象实现的接口,也是反射获取的
-
InvocationHandler h : 我们自己写的,代理类要完成的功能
返回值也就是代理对象
7、实现动态代理的步骤
1、创建接口,定义目标类要完成的功能
2、创建目标类实现接口
3、创建InvocationHandler接口的实现类,在invoke方法中完成代理类的功能
调用目标方法
增强功能
4、使用Proxy类的静态方法,创建代理对象,并把返回值转换成接口类型
扫一扫
1227
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
