Java-day11-Reflect和动态代理

最新推荐文章于 2023-10-08 15:23:47 发布
最新推荐文章于 2023-10-08 15:23:47 发布
阅读量132 收藏
点赞数
分类专栏： Java 文章标签： Java-day11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/so1125so/article/details/98725010
版权

  •  反射

  •  定义：动态获取类的字节码文件，并对其成员进行抽象

        整体含义：就是通过字节码文件直接创建对象

  •  过程：

         1.获取字节码文件对象

         2.通过字节码文件对象获取对应的实例对象

         3.给属性赋值(通过从属性中提取出来的类---Field)

         4.调用方法(通过从方法中提取的类--Method）

  • 原理

  •  获取字节码文件对象

         1.通过Object提供的getClass()方法。（首先必须要有一个对象  XXX）

         2.通过每种数据类型都有的一个class属性  （在使用的位置必须当前类是可见的，因为这里要显示的使用这个类名，对类的依赖性太强，使用不方便 XXX）

         3.Class类提供的一个静态方法static Class forName(String str)  str是包名加类名(我们只需要提供一个当前类的字符串形式即可)  eg:要保证至少字符串对应的类是存在的

  •  代码
package com.qf.test;

public class Demo1 {
	public static void main(String[] args) throws ClassNotFoundException {
		//1.通过Object提供的getClass()方法
		 fun1();
		//2.通过每种数据类型都有的一个class属性
		 fun2();
		//3.Class类提供的一个静态方法forName(字符串)   字符串:包名+类名
		 fun3();
	}
	public static void fun1() {
		Person person = new Person();
		Class<?> class1 = person.getClass();
		Class<?> class2 = person.getClass();
		System.out.println(class1 == class2);//true  
	}
	public static void fun2() {
		Class<?> class1 = Person.class;
		System.out.println(class1.getName());
	}
	public static void fun3() throws ClassNotFoundException {
		//注意:要保证至少字符串对应的类是存在的
		Class<?> class1 = Class.forName("com.qf.test.Person");
	}
}
  •  通过字节码文件对象获取对应的实例对象

         1.通过无参的构造方法创建实例对象   

         2.通过有参的构造方法创建实例对象

  •   代码
package com.qf.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

//2.通过字节码文件对象获取对应的实例对象
public class Demo2 {
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		//普通方式
		//Person person = new Person();
		
		//通过反射创建普通对象
		Class<?> class1 = Class.forName("com.qf.test.Person");
		//方法一:通过无参的构造方法创建实例对象
		fun1(class1);
		//方法二:通过有参的构造方法创建实例对象
		fun2(class1);
	}
	//方法一:通过无参的构造方法创建实例对象
	public static void fun1(Class<?> cls) throws InstantiationException, IllegalAccessException {
		//创建实例对象
		//这里相当于在newInstance方法的内部调用了无参的构造方法
		Object object = cls.newInstance();
		Person person = (Person)object;
		person.setName("bingbing");
		System.out.println(person.getName());
	}
	//方法二:通过有参的构造方法创建实例对象
	public static void fun2(Class<?> cls) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//先得到有参的构造方法
		//这里要写参数的字节码文件对象形式        所有的类型都有字节码文件对象
		//相当于  public Person(String name, int age)
		Constructor constructor = cls.getConstructor(String.class,int.class);
		Object object = constructor.newInstance("bingbing",18);
		System.out.println(object);
	}
}
  • 给属性赋值(通过从属性中提取出来的类---Filed)
package com.qf.test;

import java.lang.reflect.Field;

public class Demo3 {
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException {
		Person person = new Person();
		//person.name = "bingbing";
		
		//使用反射实现
		//1.获取字节码文件对象
		Class<?> class1 = Class.forName("com.qf.test.Person");
		
		//2.获取实例对象
		Object object = class1.newInstance();
		
		//3.调用属性
		//注意:如果想使用getField,name属性必须是public的
		//Field field1 = class1.getField("name");
		//如果name是私有的,我们可以这样做   ,忽略权限
		Field field1 = class1.getDeclaredField("name");
		field1.setAccessible(true);
		//赋值
		//第一个参数:关联的具体对象
		//第二个参数:赋的值
		field1.set(object, "bing");
		
		System.out.println(field1.get(object));
	}
}
  •    调用方法(通过从方法中提取出来的类----Method)

           1.调用非静态无参 

           2.调用非静态有参

           3.调用静态有参

package com.qf.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo4 {
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		//使用反射实现
		//1.获取字节码文件对象
		Class<?> class1 = Class.forName("com.qf.test.Person");
		
		//调用非静态无参
		fun1(class1);
		//调用非静态有参
		fun2(class1);
		//调用静态有参
		fun3(class1);
	}
	//调用非静态无参
	public static void fun1(Class<?> cla) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		//2.获取实例对象
		Object object = cla.newInstance();
		//3.通过反射得到方法
		Method method = cla.getMethod("show");
		//4.调用方法,通过调用invoke方法实现
		method.invoke(object);
	}
	//调用非静态有参
	public static void fun2(Class<?> cla) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//2.先得到有参的构造方法
		Constructor<?> constructor = cla.getConstructor(String.class,int.class);
		Object object = constructor.newInstance("bingibn",10);
		
		//3.通过反射得到方法
		Method method = cla.getMethod("callPhone",String.class);
		//4.调用方法,通过调用invoke方法实现
		method.invoke(object,"110");
	}
	//调用静态有参
	public static void fun3(Class<?> cla) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//3.通过反射得到方法
		Method method = cla.getMethod("run",int.class);
		//4.调用方法,通过调用invoke方法实现
		method.invoke(null,11);
	}
}

           作用：根据OCP(对扩展开放，对修改关闭)的原则，在不改变原来类的基础上，给这个类增加额外的功能

           缺点：代理对象要保证跟目标对象实现同样的接口，在维护的时候两个对象都要维护，而且代理对象实现的接口是死的，这时如果要给想实现不同功能的多个目标对象添加代理对象的话，要添加很多个类

  •  动态代理

      动态生成代理对象的方法--通过JDK内置的java.lang.reflect.Proxy动态代理类完成代理对象的创建
      参数一:这里代表类加载器,代理类的类加载器要与目标类的类加载器一致,类加载器用来装载内存中的字节码文件
      参数二:代理类与目标类实现的接口必须有相同的,即指定给代理类的接口,目标类必须实现了
      参数三:代理类的构造方法生成的对象--注意:指定给构造方法的参数要使用Object

       public static Object newProxyInstance(ClassLoader loader,  Class<?>[] interfaces,  InvocationHandler h)

       代理对象调动方法的时候，invoke方法会自动被调用

package com.qf.invocation1;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//使用动态代理
public class Test {
	//模拟功能:bingbing和chenchen找房住
	public static void main(String[] args) {
		//静态代理
//		Bingbing bingbing = new Bingbing();
//		//bingbing.findHouse();
//		Agent agent = new Agent(bingbing);
//		agent.findHouse();
		
		//动态代理
		TestInter testInter = new Bingbing();
		//调用动态代理的方法实现功能
		/**
		 *动态生成代理对象的方法--通过JDK内置的java.lang.reflect.Proxy动态代理类完成代理对象的创建
		 *参数一:这里代表类加载器,代理类的类加载器要与目标类的类加载器一致,类加载器用来装载内存中的字节码文件
		 *参数二:代理类与目标类实现的接口必须有相同的,即指定给代理类的接口,目标类必须实现了
		 *参数三:代理类的构造方法生成的对象--注意:指定给构造方法的参数要使用Object
		 * 
		 */
//		TestInter object = (TestInter)Proxy.newProxyInstance(testInter.getClass().getClassLoader(), new Class[] {TestInter.class}, new Agent(testInter));
		//代理对象调动方法的时候,invoke方法会自动被调用
//		object.findHouse();
//		
//		TestEat testEat = new Langlang();
//		TestEat object1 = (TestEat)Proxy.newProxyInstance(testEat.getClass().getClassLoader(), new Class[] {TestInter.class,TestEat.class}, new Agent(testEat));
//		object1.eat();
		
		//进一步优化----直接使用InvocationHandler创建匿名内部类干活儿,不再需要Agent类
		TestInter object2 = (TestInter)Proxy.newProxyInstance(testInter.getClass().getClassLoader(), new Class[] {TestInter.class}, 
			new InvocationHandler() {
				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
					System.out.println("扣一个月的房租作为中介费");
					Object object = method.invoke(testInter, args);
					System.out.println("哈哈大笑");
					return object;
				}
		   }
		);
		object2.findHouse();
		
		TestEat testEat = new Langlang();
		TestEat object3 = (TestEat)Proxy.newProxyInstance(testEat.getClass().getClassLoader(), new Class[] {TestInter.class,TestEat.class}, new InvocationHandler() {
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				System.out.println("先洗后");
				Object object = method.invoke(testEat, args);
				System.out.println("哈哈大笑");
				return object;
			}
	   });
		object3.eat();
		
		//使用工厂方法
		TestInter testInter3 = TestFactory.getAgentFactory(testInter);
		testInter3.findHouse();
	}
}

       代理类实现InvocationHandler接口并实现它的invoke方法

       public Object invoke(Object proxy, Method method, Object[] args)

       eg:这个方法在调用接口方法的时候会被自动调用

       参数一：代理对象的引用

       参数二：目标对象的方法

       参数三：目标对象的方法参数

package com.qf.invocation1;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class Agent implements InvocationHandler{
	//先给他个人
	//注意:指定给构造方法的参数要使用Object
	Object person;
	public Agent(Object person) {
		super();
		this.person = person;
	}
//	public void findHouse() {
//		System.out.println("扣一个月的房租作为中介费");
//		person.findHouse();
//		System.out.println("哈哈大笑");
//	}
	/**
	 * 接口中的方法
	 * 主要:这个方法在调用接口方法的时候,会被自动调动
	 * 参数一:代理对象的引用
	 * 参数二:目标对象的方法
	 * 参数三:目标对象的方法参数
	 * 
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {		
		System.out.println("扣一个月的房租作为中介费");
		Object object = method.invoke(person, args);
		System.out.println("哈哈大笑");
		return object;
	}
}

   目标代理对象

package com.qf.invocation1;

public class Bingbing implements TestInter {
	public void findHouse() {
		System.out.println("冰冰来西三旗找房");
	}
}

 

package com.qf.invocation1;

public class ChenChen implements TestInter {
	public void findHouse() {
		System.out.println("晨晨去日本找房");
	}
}

 

package com.qf.invocation1;

public class Langlang implements TestEat{
	@Override
	public void eat() {
		System.out.println("郎朗吃饭");
		
	}
}

   目标对象的接口

package com.qf.invocation1;

public interface TestInter {
	public void findHouse();
}

 

package com.qf.invocation1;

public interface TestEat {
	public void eat();
}
  •  创建一个工厂类--------用于创建代理对象
package com.qf.invocation1;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//创建一个工厂类---用于创建代理对象
public class TestFactory {
	//工厂方法
	public static TestInter getAgentFactory( final TestInter test) {
  //final TestInter test = new Bingbing();
		
		TestInter agent = (TestInter)Proxy.newProxyInstance(test.getClass().getClassLoader(), new Class[]{TestInter.class}, new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				// TODO Auto-generated method stub
				System.out.println("扣一半房租做中介费");
				// TODO Auto-generated method stub
				//通过反射的方法调用具体对象的方法
				Object object = method.invoke(test, args);
				
				System.out.println("哈哈大笑");
				
				return object;
			}
		});
		
		return agent;
	}

}

 

so1125so
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jdk11的class反射机制，将newInstance（）方法设置为了不建议使用了，怎么通过反射创建新的对象
极客栈
11-05 5727
下面是jdk11的源代码，看到有个方法 @CallerSensitive @Deprecated(since="9") public T newInstance(){ 。。。。。。 } 这里就意味着，newInstance（）不建议使用 这里看到jdk9就不建议使用了。那么应该用哪个代替呢？ 我们知道创建对象有几种方式 1. new 关键字 ，默认或者显示地调用构造方法实现。 2.反射newInstance。 3.反射方式显示调用构造函数 4.深度拷贝copy 下面是C...
JVM注解@CallSensitive
HEL_WOR的博客
12-06 1万+
转载请注明 http://blog.csdn.net/HEL_WOR/article/details/50199797 @CallSensitive是JVM中专用的注解，在类加载过过程中是可以常常看到这个注解的身影的。 这是在Sun.reflect中的定义：@Retention(RetentionPolicy.RUNTIME) @Target({ java.lang.annotation.Elem
day22Java-Reflect-动态代理
ginger_mr的博客
04-09 95
动态代理 1．什么是代理(中介) 目标对象/被代理对象 ------ 房主：真正的租房的方法 代理对象 ------- 黑中介:有租房子的方法（调用房主的租房的方法） 执行代理对象方法的对象 ---- 租房的人 流程：我们要租房----->中介（租房的方法）------>房主（租房的方法） 抽象：调用对象----->代理对象------>目标对象 静态代理图解...
java动态代理-实现
qq_48991741的博客
08-13 102
java动态代理day-02 动态代理 动态代理的分类 jdk动态代理 使用java发射包中的类和接口实现动态代理的功能 反射包java.lang.reflect中的三个类：InvocationHandler、Method、Proxy 目标类必须实现接口，否则只能使用cglib动态代理 cglib动态代理 cglib是第三方的工具库，创建代理对象 cglib的原理是继承， cglib通过继承目标类，创建它的子类，在子类中重写父类中同名的方法， 实现功能的修改。 因为是继承重写方法，所以要求目标
java-day13 JDBC
Jtyazs的博客
10-08 39
功能:1，注册驱动，告诉程序使用哪个数据库驱动jar包,mysql5版本之后，可以省略这一步2，获取数据库连接Connection:static Connection getConnection(String url, String user, String password)尝试建立与给定数据库URL的连接。参数:url表示连接数据库的地址mysql地址: jdbc:mysql://主机ip:3306/数据库名。
【JAVA-Day24】静态代理和动态代理：究竟代理了什么秘密？
热门推荐
沉淀、分享、成长，让自己和他人都能有所收获！
09-20 3万+
本博客深入研究了Java的代理模式，特别是静态代理和动态代理。我们了解了代理模式的概念和应用场景，并通过示例代码演示了如何在Java中实现这两种代理方式。静态代理适用于固定的代理对象，而动态代理更加灵活，可以代理多个对象并添加通用逻辑。代理模式在实际开发中有着广泛的应用，从AOP（面向切面编程）到RPC（远程过程调用），代理都扮演着重要的角色。理解代理模式的原理和实现方式，可以帮助我们更好地设计和构建复杂的软件系统。
Java JDK动态代理
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
09-25 925
本篇文章主要讲解的是什么是JAVA JDK版本的动态代理，如何使用JAVA JDK版本的动态代理。对于JAVA JDK版本的动态代理的原理不会过多的描述。本篇文章旨在如果使用JDK动态代理。例如：由于客户端不想活着不能直接访问一个对象，此时可以通过一个称为代理的第三者来实现简介访问对象，这个过程为一个代理。更加生活化的实例是：例如：代购，如：在当地买不到某件商品，又或者因为当地的这件商品的价格比其他地区的贵，所以托人或者机构在其他地区购买该商品，并携带回来。/**
第三阶段----day04
weixin_61747318的博客
03-17 91
1.spring层级代码结构 1.1 层级的划分 1.Controller层 @Controller 2.Service层 @Service 3.Dao/Mapper层 @Repository 4.POJO 根据数据表定义的实体对象 1.1.1 编辑pojo package com.jt.demo10.pojo; import java.io.Serializable; public class User implements Serializable { //1.属性都是私有的
最新Java基础系列课程--Day13-高级特性
软件开发实战项目分享
07-29 1759
本章节主要讲解注解、内部类、反射、Lambda表达式、方法引用、动态代理的学习，本章节知识是难点知识，希望大家认真学习
Java-Dynamic-Proxy:动态代理实现
07-14
在Java中，动态代理主要通过两个类来实现：`java.lang.reflect.Proxy` 和 `java.lang.reflect.InvocationHandler`。`Proxy` 类用于创建动态代理实例，而 `InvocationHandler` 接口则定义了当调用代理对象的方法时应...
java-jdk动态代理的实现demo
09-18
在Java中，JDK提供了一个`java.lang.reflect.Proxy`类和一个`java.lang.reflect.InvocationHandler`接口，它们是实现动态代理的关键。Proxy类用于创建代理对象，而InvocationHandler接口定义了处理方法调用的逻辑。 ...
Java 反射-动态代理
04-26
Java反射和动态代理是Java编程中的重要特性，它们在实现高度灵活...在提供的压缩包文件"JavaReflect"中，可能包含了关于Java反射和动态代理的示例代码和教程，通过学习和实践这些内容，你可以更深入地掌握这两种技术。
java-reflect:反射
05-16
这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型...
CSS3 Notes: -webkit-box-reflect实现倒影的实例
09-24
在CSS3中，`-webkit-box-reflect` 是一个非标准的Webkit私有属性，用于在特定元素的下方、上方、右侧或左侧创建倒影效果。这个属性主要用于基于WebKit的浏览器，比如Chrome和Safari，以及一些移动端浏览器。由于它是...
xxxxdfgfdgfdgd
07-14
xxxxdfgfdgfdgd
SQL语句基础教程.pdf
最新发布
07-14
SQL语句基础教程.pdf
站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用
07-14
站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断
亲测好用的Mac arm64版本的终端
07-14
亲测好用的Mac arm64版本的终端
Java反射机制与动态代理
04-20
Java反射机制是指在Java运行时环境中，通过获取类的信息并能够动态调用对象的方法的一种机制。...通过深入学习和掌握Java反射机制和动态代理，我们可以编写更加优雅和高效的代码，提升自身在Java开发中的技术水平。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值