JDK动态代理

最新推荐文章于 2024-04-02 14:45:49 发布
最新推荐文章于 2024-04-02 14:45:49 发布
阅读量89 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40831381/article/details/94487721
版权

目录

代理模式（Proxy Pattern）

静态代理

动态代理-----JDK动态代理

输出JDK动态代理产生的class文件 

 

代理模式（Proxy Pattern）

代理模式是一种软件设计模式，为某个实现类（也称目标类或委托类）对象提供一个代理类，代理类通过控制该对象的访问可以为该对象中的方法增加额外的功能。

静态代理

静态代理由一个接口、实现类（也称目标类或委托类）、代理类三部分组成，实现类和代理类均须实现接口中定义的抽象方法，不同之处在于，实现类负责实现主要的业务方法，代理类负责对实现类中的业务方法作“加强”处理：在调用的业务方法前后增加额外的处理。调用业务时，通过代理类对象调用代理类中接口实现方法，进而间接调用实现类中业务方法。 

注意：
    1、所谓静态是指程序运行前代理类对应字节码文件已经存在，且代理类和委托类的关系已经确定了。
    2、代理类和委托类有共同的父类或父接口。
    3、实现类和代理类实现同一个接口，所以实现类和代理类拥有相同的方法。 

定义一个接口： 

public interface ICalculatorService {
	int add(int a,int b);
	int sub(int a,int b);
	int mul(int a,int b);
	int div(int a,int b);
}

接口实现类代码如下： 

public class CalculatorService implements ICalculatorService {

	@Override
	public int add(int a, int b) {
		int result = a+b;
		return result;
	}

	@Override
	public int sub(int a, int b) {
		int result = a-b;
		return result;
	}

	@Override
	public int mul(int a, int b) {
		int result = a*b;
		return result;
	}

	@Override
	public int div(int a, int b) {
		int result = a/b;
		return result;
	}
}

创建静态代理类，该类实现ICalculatorService接口 

public class Proxy implements ICalculatorService{

	private CalculatorService target;  
	
	public Proxy(CalculatorService target) {  
        this.target = target;  
    }
	
	@Override
	public int add(int a, int b) {
		System.out.println(this.getClass().getName()+"：The add method begins.");
		System.out.println(this.getClass().getName()+"：Parameters of the add method： ["+a+","+b+"]");
		int result = target.add(a, b);
		System.out.println(this.getClass().getName()+"：Result of the add method："+result);
		System.out.println(this.getClass().getName()+"：The add method ends.");
		return result;
	}

	@Override
	public int sub(int a, int b) {
		System.out.println(this.getClass().getName()+"：The sub method begins.");
		System.out.println(this.getClass().getName()+"：Parameters of the sub method： ["+a+","+b+"]");
		int result = target.sub(a, b);
		System.out.println(this.getClass().getName()+"：Result of the sub method："+result);
		System.out.println(this.getClass().getName()+"：The sub method ends.");
		return result;
	}

	@Override
	public int mul(int a, int b) {
		System.out.println(this.getClass().getName()+"：The mul method begins.");
		System.out.println(this.getClass().getName()+"：Parameters of the mul method： ["+a+","+b+"]");
		int result = target.mul(a, b);
		System.out.println(this.getClass().getName()+"：Result of the mul method："+result);
		System.out.println(this.getClass().getName()+"：The mul method ends.");
		return result;
	}

	@Override
	public int div(int a, int b) {
		System.out.println(this.getClass().getName()+"：The div method begins.");
		System.out.println(this.getClass().getName()+"：Parameters of the div method： ["+a+","+b+"]");
		int result = target.div(a, b);
		System.out.println(this.getClass().getName()+"：Result of the div method："+result);
		System.out.println(this.getClass().getName()+"：The div method ends.");
		return result;
	}
}
import com.jd.calculator.CalculatorService;
import com.jd.calculator.ICalculatorService;
import com.jd.calculator.Proxy;

public class Test {

	public static void main(String[] args) {
		ICalculatorService proxy = new Proxy(new CalculatorService());
		int result = proxy.add(1, 2);
		System.out.println("-->"+result);
		
		result = proxy.div(1, 1);
		System.out.println("-->"+result);
	}
}

CalculatorService类中代码可以通过代理模式进行优化，Java中代理模式分为静态代理和动态代理

 动态代理-----JDK动态代理

动态代理-是在程序运行期间JVM根据需要通过反射等机制动态地创建代理类及其代理对象。

JDK动态代理-程序执行时使用java.lang.reflect包中Proxy类与InvocationHandler接口动态地生成一个实现代理接口的匿名代理类及其对象，无论调用代理对象哪个方法，最终都会执行invoke方法。

注意：
1、代理类是在程序运行期间创建，可以在classpath目录（在Eclipse中，Java工程中的bin目录；Web工程中的build目录）中看到该文件，
2、代理类和委托类的关系是在程序运行时确定的。

定义一个接口

public interface ICalculatorService {
	int add(int a,int b);
	int sub(int a,int b);
	int mul(int a,int b);
	int div(int a,int b);
}

接口实现类如下：

public class CalculatorService implements ICalculatorService {

	@Override
	public int add(int a, int b) {
		int result = a+b;
		return result;
	}

	@Override
	public int sub(int a, int b) {
		int result = a-b;
		return result;
	}

	@Override
	public int mul(int a, int b) {
		int result = a*b;
		return result;
	}

	@Override
	public int div(int a, int b) {
		int result = a/b;
		return result;
	}
}

动态代理：

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

public class Add {

	public static void main(String[] args) {
		//最终目标：调用CalculatorService类中的add方法
		ICalculatorService calculatorService=new CalculatorService();
		System.out.println("calculatorService------->"+calculatorService);
		System.out.println("----------"+calculatorService.getClass().getName());
		//匿名内部类
		InvocationHandler handler =new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				System.out.println("proxy.getClass().getName()----->"+proxy.getClass().getName());
				String name=method.getName();
				System.out.println(calculatorService.getClass().getName()+"：The "+name+" method begins.");
				System.out.println(calculatorService.getClass().getName()+"：Parameters of the "+name+" method： ["+args[0]+","+args[1]+"]");
				Object result = method.invoke(calculatorService, args); //反射中方法的调用，调用目标方法，也就是调用CalculatorService中的 add方法
				System.out.println(calculatorService.getClass().getName()+"：Result of the "+name+" method："+result);
				System.out.println(calculatorService.getClass().getName()+"：The "+name+" method ends.");
				return result;
			}
		};
		//用JDK的方式创建动态代理对象，这个对象的特点：和CalculatorService类实现的接口相同
		ClassLoader classLoader =calculatorService.getClass().getClassLoader();
		// Proxy.newProxyInstance创建此对象的类是不存在的 ，只有执行的时候才能确定对象
		ICalculatorService cService= (ICalculatorService) Proxy.newProxyInstance(classLoader, new Class[] {ICalculatorService.class}, handler);
		System.out.println("cService--------->"+cService.getClass().getName());
		int result=cService.add(1, 2); //cService存放的是由Proxy创建的实现的ICalculatorService的一个匿名内部类
		//cService.add(1, 2);方法调用的是由proxy类创建的匿名内部类对象中的add方法
		System.out.println(result);
	}
}

将动态代理类进行封装：

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

public class ProxyFactory  {

	static ICalculatorService target;//目标对象
	// 匿名内部类
	static InvocationHandler handler = new InvocationHandler() {

		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			System.out.println("proxy.getClass().getName()----->" + proxy.getClass().getName());
			String name = method.getName();
			System.out.println(target.getClass().getName() + "：The " + name + " method begins.");
			System.out.println(target.getClass().getName() + "：Parameters of the " + name + " method： ["
					+ args[0] + "," + args[1] + "]");
			Object result = method.invoke(target, args); // 反射中方法的调用，调用目标方法，也就是调用CalculatorService中的 add方法
			System.out.println(target.getClass().getName() + "：Result of the " + name + " method：" + result);
			System.out.println(target.getClass().getName() + "：The " + name + " method ends.");
			return result;
		}
	};

	public static Object getProxy(ICalculatorService target) {
		ProxyFactory.target=target;
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), CalculatorService.class.getInterfaces(), handler);
		
	}	
}

 测试类：

public class Test {

	public static void main(String[] args) {
		
		ICalculatorService cService= (ICalculatorService) ProxyFactory.getProxy(new CalculatorService() );
		System.out.println("cService--------->"+cService.getClass().getName());
		int result=cService.add(1, 2); //cService存放的是由Proxy创建的实现的ICalculatorService的一个匿名内部类
		System.out.println(result);
	}
}

注意：

1.Proxy.newProxyInstance的这个对象所实现的接口和CalculatorService类所实现的接口相同，所以interface是CalculatorService.class.getInterfaces()

2.handler 告诉对象做什么，只有在执行的时候对象才能确定，所以是动态的

3.cService.add(1, 2)方法的执行过程：先执行代理对象里的方法，然后到达目标对象中的方法，最后在回到代理对象中的方法，返回结果

输出JDK动态代理产生的class文件 

生成使用JDK创建动态代理对象的class文件。注意：该行代码必须放在代理对象产生之前

public class Test {

	public static void main(String[] args) {
		// 生成使用JDK创建动态代理对象的class文件。注意：该行代码必须放在代理对象产生之前
		System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
		ICalculatorService cService = (ICalculatorService) ProxyFactory.getProxy(new CalculatorService());
		System.out.println("cService--------->" + cService.getClass().getName());
		int result = cService.add(1, 2); // cService存放的是由Proxy创建的实现的ICalculatorService的一个匿名内部类
		// cService.add(1, 2);调用的是由proxy类创建的匿名内部类对象中的add方法
		System.out.println(result);
	}
}

用反编译器将生成的.class文件还原成.java文件：

package com.sun.proxy;

import fuxiTest.java.jdk.calculator.ICalculatorService;
import java.lang.reflect.*;

public final class $Proxy0 extends Proxy
    implements ICalculatorService
{

    public $Proxy0(InvocationHandler invocationhandler)
    {
        super(invocationhandler);
    }

    public final boolean equals(Object obj)
    {
        try
        {
            return ((Boolean)super.h.invoke(this, m1, new Object[] {
                obj
            })).booleanValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final String toString()
    {
        try
        {
            return (String)super.h.invoke(this, m2, null);
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final int mul(int i, int j)
    {
        try
        {
            return ((Integer)super.h.invoke(this, m5, new Object[] {
                Integer.valueOf(i), Integer.valueOf(j)
            })).intValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final int add(int i, int j)
    {
        try
        {
            return ((Integer)super.h.invoke(this, m3, new Object[] {
                Integer.valueOf(i), Integer.valueOf(j)
            })).intValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final int sub(int i, int j)
    {
        try
        {
            return ((Integer)super.h.invoke(this, m4, new Object[] {
                Integer.valueOf(i), Integer.valueOf(j)
            })).intValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final int div(int i, int j)
    {
        try
        {
            return ((Integer)super.h.invoke(this, m6, new Object[] {
                Integer.valueOf(i), Integer.valueOf(j)
            })).intValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final int hashCode()
    {
        try
        {
            return ((Integer)super.h.invoke(this, m0, null)).intValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    private static Method m1;
    private static Method m2;
    private static Method m5;
    private static Method m3;
    private static Method m4;
    private static Method m6;
    private static Method m0;

    static 
    {
        try
        {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
                Class.forName("java.lang.Object")
            });
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m5 = Class.forName("fuxiTest.java.jdk.calculator.ICalculatorService").getMethod("mul", new Class[] {
                Integer.TYPE, Integer.TYPE
            });
            m3 = Class.forName("fuxiTest.java.jdk.calculator.ICalculatorService").getMethod("add", new Class[] {
                Integer.TYPE, Integer.TYPE
            });
            m4 = Class.forName("fuxiTest.java.jdk.calculator.ICalculatorService").getMethod("sub", new Class[] {
                Integer.TYPE, Integer.TYPE
            });
            m6 = Class.forName("fuxiTest.java.jdk.calculator.ICalculatorService").getMethod("div", new Class[] {
                Integer.TYPE, Integer.TYPE
            });
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        }
        catch(NoSuchMethodException nosuchmethodexception)
        {
            throw new NoSuchMethodError(nosuchmethodexception.getMessage());
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new NoClassDefFoundError(classnotfoundexception.getMessage());
        }
    }
}

 return ((Integer)super.h.invoke(this, m3, new Object[] {
                Integer.valueOf(i), Integer.valueOf(j)
            })).intValue();
执行h就是传入的handler匿名内部类对象的重写的invoke方法

余生为莹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDK动态代理之代理对象与目标对象
清风阁
04-14 2464
问题的引出 下述所有类均定义在包structure.proxy.dynamicproxy中。 定义一个接口AbstractUserDAO public interface AbstractUserDAO { Boolean findUserById(String userId); } 定义一个接口AbstractUserDAO的实现类UserDAO public class Us...
Java两种动态代理JDK动态代理和CGLIB动态代理
热门推荐
Java相关领域
08-07 14万+
目录 代理模式 JDK动态代理 cglib动态代理 测试 代理模式 代理模式是23种设计模式的一种，他是指一个对象A通过持有另一个对象B，可以具有B同样的行为的模式。为了对外开放协议，B往往实现了一个接口，A也会去实现接口。但是B是“真正”实现类，A则比较“虚”，他借用了B的方法去实现接口的方法。A虽然是“伪军”，但它可以增强B，在调用B的方法前后都做些其他的事情。Spring AOP...
jdk动态代理
m0_67486569的博客
10-30 1261
代理模式与jdk动态代理
jdk动态代理使用详解
congge
06-18 2万+
jdk动态代理和cglib静态代理使用详解
彻底搞懂JDK动态代理
最新发布
Tan_xiong的博客
04-02 443
本文介绍了JDK动态代理的基本原理、创建步骤及其原理。动态代理提供了在运行时动态改变目标对象行为的能力，广泛应用于AOP编程、远程方法调用和测试框架等领域。虽然性能开销较大，但其简单易用
JDK 动态代理
AdamShyly的博客
05-13 637
代理的应用场景就是当一个实体类不能直接访问目标类中的方法，而此时就需要一个中间代理类帮助该实体类访问该目标类的方法，实现控制访问、功能增强。 在JDK的代理模式中分为静态代理和动态代理两种模式，对于静态代理而言对于每一个中间代理类都需要我们手动创建，其中不乏业务逻辑相同的代码，造成代码冗余；而且每次当代理类实现接口的抽象方法发生变化时，目标类和代理类都需要手动修改源码，不利于代码维护。而动态代理便对该缺陷进行了优化，将代理类对象的创建交由JDK的反射机制处理，重复的业务逻辑代码可以被全部封装到一个实现了I
Java JDK动态代理
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
09-25 924
本篇文章主要讲解的是什么是JAVA JDK版本的动态代理，如何使用JAVA JDK版本的动态代理。对于JAVA JDK版本的动态代理的原理不会过多的描述。本篇文章旨在如果使用JDK动态代理。例如：由于客户端不想活着不能直接访问一个对象，此时可以通过一个称为代理的第三者来实现简介访问对象，这个过程为一个代理。更加生活化的实例是：例如：代购，如：在当地买不到某件商品，又或者因为当地的这件商品的价格比其他地区的贵，所以托人或者机构在其他地区购买该商品，并携带回来。/**
JDK动态代理详解
StoNENee的博客
03-02 3089
可能很多小伙伴首次接触动态代理这个名词的时候，或者是在面试过程中被问到动态代理的时候，不能很好的描述出来，动态代理到底是个什么高大上的技术。不方，其实动态代理的使用非常广泛，例如我们平常使用的Spring中的注解，其依赖于AOP，而AOP的底层实现便是动态代理，看到这里，是不是更有兴趣去了解动态代理了呢？动态代理：可以分解为“动态”+“代理”。所以，静态代理存在一定的局限性，不能很好的满足需求的千变万化，动态代理的出现，就是为了解决这些局限性。
Java-JDK动态代理
zhxingqi的博客
10-19 6044
介绍:我们需要掌握的程度动态代理(理解) 基于反射机制掌握的程度:1.什么是动态代理?2.动态代理能够做什么?后面我们在用Spirng和Mybatis的时候,要理解怎么使用的.代理,在我们日常生活之中就有体现,代购,中介,换ip,商家等等.比如有一家美国的大学,可以对全世界招生.留学中介(代理 )留学中介(代理):帮助这家美国的学校招生,中介是学校的代理中介是代替学校完成招生功能代理特点中介和代理他们要做的事情是一致的:招生中介是学校代理,学校是目标。
JDK动态代理源码
11-30
在Java编程领域，JDK动态代理是一个非常重要的概念，它允许我们在运行时动态地创建一个实现了特定接口的代理对象，以此来拦截并扩展原有对象的行为。动态代理在很多场景下都有应用，比如AOP（面向切面编程）、事件...
jdk动态代理课程代码.rar
08-02
在这个“jdk动态代理课程代码”中，我们很可能会看到如何利用这些工具来实现动态代理的示例。 首先，我们需要理解静态代理和动态代理的基本概念。静态代理是我们在编译时期就已经知道了代理类的实现，通过创建一个...
Jdk动态代理 底层
01-20
java动态代理主要有2种，Jdk动态代理、Cglib动态代理，本文主要讲解Jdk动态代理的使用、运行机制、以及源码分析。当spring没有手动开启Cglib动态代理，即：或@EnableAspectJAutoProxy(proxyTargetClass = true)，...
MySQL事务隔离级别----Read committed（读已提交）
My_liuying0901
07-14 1万+
根据实际需求，通过设置数据库的事务隔离级别可以解决多个事务并发情况下出现的脏读、不可重复读和幻读问题，数据库事务隔离级别由低到高依次为Read uncommitted、Read committed、Repeatable read和Serializable等四种。数据库不同，其支持的事务隔离级别亦不相同：MySQL数据库支持上面四种事务隔离级别，默认为Repeatable read；Oracle 数...
数组的定义，声明实例化
My_liuying0901
04-16 9945
数组的定义：数组是相同数据类型的数据按顺序组成的一种引用数据类型。   这里的“相同数据类型”是指数据在内存中的数据类型。基本数据类型元素构成的数组也是引用类型。为什么要定义数组：  方法不能返回多个值  将欲返回的多个值放在数组中，就可以间接实现返回多个值的效果数组的声明实例化通过数组名加数组下标，来使用数组中的数据。下标从 0 开始排序。声明一维数组：数组元素类型[ ] <数组名>...
MySQL事务隔离级别----Repeatable read（重复读）
My_liuying0901
07-14 7813
根据实际需求，通过设置数据库的事务隔离级别可以解决多个事务并发情况下出现的脏读、不可重复读和幻读问题，数据库事务隔离级别由低到高依次为Read uncommitted、Read committed、Repeatable read和Serializable等四种。数据库不同，其支持的事务隔离级别亦不相同：MySQL数据库支持上面四种事务隔离级别，默认为Repeatable read；Oracle 数...
instanceof 运算符
My_liuying0901
07-30 7042
instanceof 运算符 用于：判断 该运算符前面引用类型变量指向的对象是否是后面类，或者其子类、接口实现类创建的对象。如果是则返回true，否则返回false， 其使用格式如下：     引用类型变量 instanceof （类、抽象类或接口）   public class Test { public static void main(String[] args) { ...
jdk动态代理final
03-06
JDK动态代理是Java中一种实现代理模式的方式，它允许在运行时动态地创建代理类和代理对象。在JDK动态代理中，代理类是在运行时通过反射机制动态生成的，而不是在编译时就确定的。 关于final关键字，它可以用来修饰...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值