深入理解JAVA JDK动态代理机制

最新推荐文章于 2021-12-25 09:33:23 发布
最新推荐文章于 2021-12-25 09:33:23 发布
阅读量1.1k 收藏 2
点赞数 1
分类专栏： Java 文章标签： JAVA JDK 动态代理 类

 

 

一、现实生活中的代理？

        在现实生活中，我们常见的有服务器代理商、联想PC代理商、百事可乐、火车票、机票等代理商，为什么会有这些个代理商呢？设想以买火车票为场景，如果我要买一张从广州去长沙的火车票，就必须去火车站排队购票，如果排队的人比较多的话，非常的耽误时间。但有了火车票代理商之后，我就可以直接去找个离我最近的代理商买票，因为这样的代理商不止一个二个，遍布全市各地。 所以代理商的出现不但减轻了火车站售票员的工作压力，同时也为市民购票提供了许多方便。只是代理商会收5块的手续费。从这个示例中可以发现和买票有关的一些名词：火车站、售票、代理商？解释这些名词在程序中代理的含义：火车站：称为目标，售票：目标的最终行为，代理商：和火车站具有同样售票行为的代理商，不过代理商在售票前和售票后会做一些操作，比如查询余票、售票后收取手续费等操作。

二、JDK中的代理

1、特征：
      1）、jdk中代理的一个很重要的特征：代理类和目标类都拥有相同的接口，所以它们都拥有相同的行为。代理类的对象本身并不真正提供服务，而是调用目标类对象的相关方法，来提供特定的服务。如：火车票代理商自己并不提供火车票销售的服务，而是调用火车站的售票服务。为顾客提供查询余票信息、火车的运营时间、火车票的销售等服务，这些服务都是来自火车站（目标类）。代理类主要负责为目标类预处理消息（如：身份证信息是否正确）、过滤消息（如：该顾客是否为通缉犯，是否公安监视的人），并把这些消息转发给目标类，以及事后处理消息（收取顾客的手续费）等。
      2）、必须实现一个或多个接口

2、代理种类：

1）、静态代理，示例：以销售火车票为例

a、定义一个火车站售票的接口
[java] view plain copy print ?
  1. package proxy; 
  2.  
  3. public interface Ticket { 
  4.  
  5.     public void ticket(); 
  6. }  
package proxy;

public interface Ticket {

	public void ticket();
}
b、售票接口的实现类
[java] view plain copy print ?
  1. package proxy; 
  2.  
  3. public class TicketImpl implements Ticket { 
  4.  
  5.     @Override 
  6.     public void ticket() { 
  7.         System.out.println("成功售出一张火车票！"); 
  8.     } 
  9. }  
package proxy;

public class TicketImpl implements Ticket {

	@Override
	public void ticket() {
		System.out.println("成功售出一张火车票！");
	}
}
c、火车票销售的代理类，与目标类实现了相同的接口
[java] view plain copy print ?
  1. package proxy; 
  2.  
  3. /**
  4. * 火车票销售代理类
  5. */ 
  6. public class TicketImplProxy implements Ticket { 
  7.      
  8.     private TicketImpl ticketImpl;  //目标类 
  9.      
  10.     public TicketImplProxy(TicketImpl ticketImpl) { 
  11.         this.ticketImpl = ticketImpl; 
  12.     } 
  13.  
  14.     @Override 
  15.     public void ticket() { 
  16.         System.out.println("售票前验证顾客的身份信息…………"); 
  17.         ticketImpl.ticket(); 
  18.         System.out.println("售票后收取顾客的手续费…………"); 
  19.     } 
  20.  
  21. }  
package proxy;

/**
 * 火车票销售代理类
 */
public class TicketImplProxy implements Ticket {
	
	private TicketImpl ticketImpl;	//目标类
	
	public TicketImplProxy(TicketImpl ticketImpl) {
		this.ticketImpl = ticketImpl;
	}

	@Override
	public void ticket() {
		System.out.println("售票前验证顾客的身份信息…………");
		ticketImpl.ticket();
		System.out.println("售票后收取顾客的手续费…………");
	}

}
d、测试类：
[java] view plain copy print ?
  1. package proxy; 
  2.  
  3. public class StaticProxyTest { 
  4.  
  5.     public static void main(String[] args) throws Exception { 
  6.         TicketImpl ticketImpl = new TicketImpl();   //要代理的目标 
  7.         TicketImplProxy staticProxy = new TicketImplProxy(ticketImpl); 
  8.         staticProxy.ticket(); 
  9.     } 
  10. }  
package proxy;

public class StaticProxyTest {

	public static void main(String[] args) throws Exception {
		TicketImpl ticketImpl = new TicketImpl();	//要代理的目标
		TicketImplProxy staticProxy = new TicketImplProxy(ticketImpl);
		staticProxy.ticket();
	}
}

运行结果：


静态代理的缺陷：
    一个代理类只能代理一个目标类，如果在一个系统中想代理多个目标类的话，就得写多个代理类，这将是一件很繁琐的工作。所以在JDK1.3之后，引出了动态代理的概念，动态代理可以在程序运行的时候，通过反射机制动态的生成一个类的字节码文件，并实现目标类相同的接口。
2）、动态代理
1）、介绍：
    jdk中的动态代理，主要用到了java.lang.reflect包中的两个类：Proxy类和InvocationHandler接口，Proxy类用于生成代理类，InvocationHandler接口用于调用目标类的方法之前或之后，做一些处理。比如：记录日志、事务处理、效率测试等，均在该接口的invoke方法中实现。传说中AOP思想的原理就是从这里开始扩展的。



2）、动态代理机制深入分析（以ArrayList为代理目标类为例）：
1、使用Proxy类的getProxyClass方法，获得ArrayList代理类的字节码文件
[java] view plain copy print ?
  1. Class clazzProxy = Proxy.getProxyClass(ArrayList.class.getClassLoader(), ArrayList.class.getInterfaces());  
Class clazzProxy = Proxy.getProxyClass(ArrayList.class.getClassLoader(), ArrayList.class.getInterfaces());
2、打印代理类的结构信息
获得这个Class对象的字节码文件之后，我们打印出来看看这个类的名字叫什么？
[java] view plain copy print ?
  1. System.out.println("代理类名称：" + clazzProxy.getName());  
System.out.println("代理类名称：" + clazzProxy.getName());
代理类名称：$Proxy0
通过JDK反射机制，获代理类的结构，比如：它的父类是谁？实现了哪些接口？有哪些个构造方法？有哪些个成员方法？等。。。
下面将通反射机制，获取这个代理类的组织结构信息：
[java] view plain copy print ?
  1. System.out.println("代理类" + clazzProxy.getName() + "的父类：" + clazzProxy.getSuperclass().getName());  
System.out.println("代理类" + clazzProxy.getName() + "的父类：" + clazzProxy.getSuperclass().getName());
代理类$Proxy0的父类：java.lang.reflect.Proxy
[java] view plain copy print ?
  1. Class[] clazzInterfaces = clazzProxy.getInterfaces(); 
  2. StringBuilder sbInterfaces = new StringBuilder(); 
  3. for (Class clazzInterface : clazzInterfaces) { 
  4.     sbInterfaces.append(clazzInterface.getName()).append(","); 
  5. } 
  6. sbInterfaces.deleteCharAt(sbInterfaces.length()-1); 
  7. System.out.println("代理类" + clazzProxy.getName() + "所实现的接口：" + sbInterfaces);  
Class[] clazzInterfaces = clazzProxy.getInterfaces();
StringBuilder sbInterfaces = new StringBuilder();
for (Class clazzInterface : clazzInterfaces) {
	sbInterfaces.append(clazzInterface.getName()).append(",");
}
sbInterfaces.deleteCharAt(sbInterfaces.length()-1);
System.out.println("代理类" + clazzProxy.getName() + "所实现的接口：" + sbInterfaces);
代理类$Proxy0所实现的接口：java.util.List,java.util.RandomAccess,java.lang.Cloneable,java.io.Serializable
[java] view plain copy print ?
  1. System.out.println("代理类" + clazzProxy.getName() + "的访问修饰符：" + clazzProxy.getModifiers());  
System.out.println("代理类" + clazzProxy.getName() + "的访问修饰符：" + clazzProxy.getModifiers());
代理类$Proxy0的访问修饰符：17
由访问修饰符的值可得知代理类的修饰符为：代理类的访问修饰符为：public final，由clazzProxy.getModifiers();得知为17，其中public代表1，final代表16，相加得17。参考java.lang.reflect.Modifier
[java] view plain copy print ?
  1. System.out.println("\n-------------打印代理类" + clazzProxy.getName() + "的构造方法列表-------------"); 
  2. Constructor[] constructors = clazzProxy.getConstructors(); 
  3. for (Constructor constructor : constructors) { 
  4. System.out.println("访问修饰符：" + constructor.getModifiers()); 
  5. String name = constructor.getName(); 
  6.     int modifiers = constructor.getModifiers(); 
  7.     StringBuilder sb = new StringBuilder(name); 
  8.     sb.append('('); 
  9.     Class[] clazzParameters = constructor.getParameterTypes(); 
  10.     for (Class clazzParameter : clazzParameters) { 
  11.         sb.append(clazzParameter.getName()).append(","); 
  12.     } 
  13.     if (clazzParameters != null && clazzParameters.length != 0) { 
  14.         sb.deleteCharAt(sb.length()-1); 
  15.     } 
  16.     sb.append(')'); 
  17.     System.out.println(sb.toString()); 
  18. }  
System.out.println("\n-------------打印代理类" + clazzProxy.getName() + "的构造方法列表-------------");
Constructor[] constructors = clazzProxy.getConstructors();
for (Constructor constructor : constructors) {
System.out.println("访问修饰符：" + constructor.getModifiers());
String name = constructor.getName();
	int modifiers = constructor.getModifiers();
	StringBuilder sb = new StringBuilder(name);
	sb.append('(');
	Class[] clazzParameters = constructor.getParameterTypes();
	for (Class clazzParameter : clazzParameters) {
		sb.append(clazzParameter.getName()).append(",");
	}
	if (clazzParameters != null && clazzParameters.length != 0) {
		sb.deleteCharAt(sb.length()-1);
	}
	sb.append(')');
	System.out.println(sb.toString());
}
-------------打印代理类$Proxy0的构造方法列表-------------
访问修饰符： 1
$Proxy0(java.lang.reflect.InvocationHandler)
[java] view plain copy print ?
  1. System.out.println("\n-------------打印代理类" + clazzProxy.getName() + "的方法列表-------------"); 
  2. Method[] methods = clazzProxy.getMethods(); 
  3. for (Method method : methods) { 
  4.     String name = method.getName(); 
  5.     StringBuilder sb = new StringBuilder(name); 
  6.     sb.append('('); 
  7.     Class[] clazzParameters = method.getParameterTypes(); 
  8.     for (Class clazzParameter : clazzParameters) { 
  9.         sb.append(clazzParameter.getName()).append(","); 
  10.     } 
  11.     if (clazzParameters != null && clazzParameters.length != 0) { 
  12.         sb.deleteCharAt(sb.length()-1); 
  13.     } 
  14.     sb.append(')'); 
  15.     System.out.println(sb.toString()); 
  16. }  
System.out.println("\n-------------打印代理类" + clazzProxy.getName() + "的方法列表-------------");
Method[] methods = clazzProxy.getMethods();
for (Method method : methods) {
	String name = method.getName();
	StringBuilder sb = new StringBuilder(name);
	sb.append('(');
	Class[] clazzParameters = method.getParameterTypes();
	for (Class clazzParameter : clazzParameters) {
		sb.append(clazzParameter.getName()).append(",");
	}
	if (clazzParameters != null && clazzParameters.length != 0) {
		sb.deleteCharAt(sb.length()-1);
	}
	sb.append(')');
	System.out.println(sb.toString());
}
打印结果：
[java] view plain copy print ?
  1. -------------打印代理类$Proxy0的方法列表------------- 
  2. add(java.lang.Object) 
  3. add(int,java.lang.Object) 
  4. get(int) 
  5. equals(java.lang.Object) 
  6. toString() 
  7. hashCode() 
  8. indexOf(java.lang.Object) 
  9. clear() 
  10. contains(java.lang.Object) 
  11. isEmpty() 
  12. lastIndexOf(java.lang.Object) 
  13. addAll(java.util.Collection) 
  14. addAll(int,java.util.Collection) 
  15. iterator() 
  16. size() 
  17. toArray() 
  18. toArray([Ljava.lang.Object;) 
  19. remove(java.lang.Object) 
  20. remove(int) 
  21. set(int,java.lang.Object) 
  22. containsAll(java.util.Collection) 
  23. removeAll(java.util.Collection) 
  24. retainAll(java.util.Collection) 
  25. subList(int,int) 
  26. listIterator() 
  27. listIterator(int) 
  28. isProxyClass(java.lang.Class) 
  29. getProxyClass(java.lang.ClassLoader,[Ljava.lang.Class;) 
  30. getInvocationHandler(java.lang.Object) 
  31. newProxyInstance(java.lang.ClassLoader,[Ljava.lang.Class;,java.lang.reflect.InvocationHandler) 
  32. wait(long) 
  33. wait() 
  34. wait(long,int) 
  35. getClass() 
  36. notify() 
  37. notifyAll()  
-------------打印代理类$Proxy0的方法列表-------------
add(java.lang.Object)
add(int,java.lang.Object)
get(int)
equals(java.lang.Object)
toString()
hashCode()
indexOf(java.lang.Object)
clear()
contains(java.lang.Object)
isEmpty()
lastIndexOf(java.lang.Object)
addAll(java.util.Collection)
addAll(int,java.util.Collection)
iterator()
size()
toArray()
toArray([Ljava.lang.Object;)
remove(java.lang.Object)
remove(int)
set(int,java.lang.Object)
containsAll(java.util.Collection)
removeAll(java.util.Collection)
retainAll(java.util.Collection)
subList(int,int)
listIterator()
listIterator(int)
isProxyClass(java.lang.Class)
getProxyClass(java.lang.ClassLoader,[Ljava.lang.Class;)
getInvocationHandler(java.lang.Object)
newProxyInstance(java.lang.ClassLoader,[Ljava.lang.Class;,java.lang.reflect.InvocationHandler)
wait(long)
wait()
wait(long,int)
getClass()
notify()
notifyAll()
这些方法分别来自List接口、Proxy和Object类，因为代理类会自动实现目标类相同的接口。
[java] view plain copy print ?
  1. //由上述信息可推断出代理类的文件结构（程序中只实现打印代理类的声明部份） 
  2. StringBuilder sbProxyClassStruct = new StringBuilder("public final class "); 
  3. sbProxyClassStruct.append(clazzProxy.getName()) 
  4.           .append(" extends ").append(clazzProxy.getSuperclass().getName()) 
  5.           .append(" implements ").append(sbInterfaces).append(" { } "); 
  6. System.out.println("代理类的结构：" + sbProxyClassStruct);  
//由上述信息可推断出代理类的文件结构（程序中只实现打印代理类的声明部份）
StringBuilder sbProxyClassStruct = new StringBuilder("public final class ");
sbProxyClassStruct.append(clazzProxy.getName())
		  .append(" extends ").append(clazzProxy.getSuperclass().getName())
		  .append(" implements ").append(sbInterfaces).append(" { } ");
System.out.println("代理类的结构：" + sbProxyClassStruct);
程序中只打印了代理类的声明部份，结果：
代理类声明部份的结构：public final class $Proxy0 extends java.lang.reflect.Proxy implements java.util.List,java.util.RandomAccess,java.lang.Cloneable,java.io.Serializable { }

由上述信息可推断出代理类的文件结构：
[java] view plain copy print ?
  1. package proxy; 
  2.  
  3. import java.lang.reflect.InvocationHandler; 
  4. import java.util.Collection; 
  5. import java.util.Iterator; 
  6. import java.util.List; 
  7. import java.util.ListIterator; 
  8.  
  9. public final class $Proxy0 extends java.lang.reflect.Proxy implements java.util.List, 
  10.         java.util.RandomAccess, java.lang.Cloneable, java.io.Serializable { 
  11.  
  12.     public $Proxy0(InvocationHandler h) { 
  13.         super(h); 
  14.         // TODO Auto-generated constructor stub 
  15.     } 
  16.  
  17.     @Override 
  18.     public boolean add(Object e) { 
  19.         // TODO Auto-generated method stub 
  20.         return false; 
  21.     } 
  22.  
  23.     @Override 
  24.     public void add(int index, Object element) { 
  25.         // TODO Auto-generated method stub 
  26.          
  27.     } 
  28.  
  29.     @Override 
  30.     public boolean addAll(Collection c) { 
  31.         // TODO Auto-generated method stub 
  32.         return false; 
  33.     } 
  34.  
  35.     @Override 
  36.     public boolean addAll(int index, Collection c) { 
  37.         // TODO Auto-generated method stub 
  38.         return false; 
  39.     } 
  40.  
  41.     @Override 
  42.     public void clear() { 
  43.         // TODO Auto-generated method stub 
  44.          
  45.     } 
  46.  
  47.     @Override 
  48.     public boolean contains(Object o) { 
  49.         // TODO Auto-generated method stub 
  50.         return false; 
  51.     } 
  52.  
  53.     @Override 
  54.     public boolean containsAll(Collection c) { 
  55.         // TODO Auto-generated method stub 
  56.         return false; 
  57.     } 
  58.  
  59.     @Override 
  60.     public Object get(int index) { 
  61.         // TODO Auto-generated method stub 
  62.         return null; 
  63.     } 
  64.  
  65.     @Override 
  66.     public int indexOf(Object o) { 
  67.         // TODO Auto-generated method stub 
  68.         return 0; 
  69.     } 
  70.  
  71.     @Override 
  72.     public boolean isEmpty() { 
  73.         // TODO Auto-generated method stub 
  74.         return false; 
  75.     } 
  76.  
  77.     @Override 
  78.     public Iterator iterator() { 
  79.         // TODO Auto-generated method stub 
  80.         return null; 
  81.     } 
  82.  
  83.     @Override 
  84.     public int lastIndexOf(Object o) { 
  85.         // TODO Auto-generated method stub 
  86.         return 0; 
  87.     } 
  88.  
  89.     @Override 
  90.     public ListIterator listIterator() { 
  91.         // TODO Auto-generated method stub 
  92.         return null; 
  93.     } 
  94.  
  95.     @Override 
  96.     public ListIterator listIterator(int index) { 
  97.         // TODO Auto-generated method stub 
  98.         return null; 
  99.     } 
  100.  
  101.     @Override 
  102.     public boolean remove(Object o) { 
  103.         // TODO Auto-generated method stub 
  104.         return false; 
  105.     } 
  106.  
  107.     @Override 
  108.     public Object remove(int index) { 
  109.         // TODO Auto-generated method stub 
  110.         return null; 
  111.     } 
  112.  
  113.     @Override 
  114.     public boolean removeAll(Collection c) { 
  115.         // TODO Auto-generated method stub 
  116.         return false; 
  117.     } 
  118.  
  119.     @Override 
  120.     public boolean retainAll(Collection c) { 
  121.         // TODO Auto-generated method stub 
  122.         return false; 
  123.     } 
  124.  
  125.     @Override 
  126.     public Object set(int index, Object element) { 
  127.         // TODO Auto-generated method stub 
  128.         return null; 
  129.     } 
  130.  
  131.     @Override 
  132.     public int size() { 
  133.         // TODO Auto-generated method stub 
  134.         return 0; 
  135.     } 
  136.  
  137.     @Override 
  138.     public List subList(int fromIndex, int toIndex) { 
  139.         // TODO Auto-generated method stub 
  140.         return null; 
  141.     } 
  142.  
  143.     @Override 
  144.     public Object[] toArray() { 
  145.         // TODO Auto-generated method stub 
  146.         return null; 
  147.     } 
  148.  
  149.     @Override 
  150.     public Object[] toArray(Object[] a) { 
  151.         // TODO Auto-generated method stub 
  152.         return null; 
  153.     } 
  154. }  
package proxy;

import java.lang.reflect.InvocationHandler;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public final class $Proxy0 extends java.lang.reflect.Proxy implements java.util.List,
		java.util.RandomAccess, java.lang.Cloneable, java.io.Serializable {

	public $Proxy0(InvocationHandler h) {
		super(h);
		// TODO Auto-generated constructor stub
	}

	@Override
	public boolean add(Object e) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void add(int index, Object element) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public boolean addAll(Collection c) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public boolean addAll(int index, Collection c) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void clear() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public boolean contains(Object o) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public boolean containsAll(Collection c) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public Object get(int index) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public int indexOf(Object o) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public Iterator iterator() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public int lastIndexOf(Object o) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public ListIterator listIterator() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public ListIterator listIterator(int index) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public boolean remove(Object o) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public Object remove(int index) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public boolean removeAll(Collection c) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public boolean retainAll(Collection c) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public Object set(int index, Object element) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public int size() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public List subList(int fromIndex, int toIndex) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Object[] toArray() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Object[] toArray(Object[] a) {
		// TODO Auto-generated method stub
		return null;
	}
}
由上述信息得知该代理类只有一个带InvocationHandler参数的构造方法，现在我们来生成这个代理类的实例对象：
[java] view plain copy print ?
  1. //方式1，创建一个内部类，并实现InvocationHandler接口 
  2. Constructor proxy1 = clazzProxy.getConstructor(InvocationHandler.class); 
  3. System.out.println("------------创建代理类实例，方式1--------------------"); 
  4. class MyInvocationHandler implements InvocationHandler { 
  5.     ArrayList target = new ArrayList(); 
  6.     @Override 
  7.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  8.         String name = method.getName(); 
  9.         System.out.println(name + "方法调用前..."); 
  10.         Object retVal = method.invoke(target, args); 
  11.         System.out.println(name + "方法调用后的返回结果为：" + retVal); 
  12.         System.out.println(name + "方法调用后...\n"); 
  13.         return retVal; 
  14.     } 
  15.              
  16. } 
  17. List list1 = (List)proxy1.newInstance(new MyInvocationHandler()); 
  18. list1.add("zhangsan"); 
  19. list1.add("lisi"); 
  20. System.out.println(list1.size());  
//方式1，创建一个内部类，并实现InvocationHandler接口
Constructor proxy1 = clazzProxy.getConstructor(InvocationHandler.class);
System.out.println("------------创建代理类实例，方式1--------------------");
class MyInvocationHandler implements InvocationHandler {
	ArrayList target = new ArrayList();
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		String name = method.getName();
		System.out.println(name + "方法调用前...");
		Object retVal = method.invoke(target, args);
		System.out.println(name + "方法调用后的返回结果为：" + retVal);
		System.out.println(name + "方法调用后...\n");
		return retVal;
	}
			
}
List list1 = (List)proxy1.newInstance(new MyInvocationHandler());
list1.add("zhangsan");
list1.add("lisi");
System.out.println(list1.size());
调用List接口的add方法和size方法后的输出结果：
---------------------创建代理类$Proxy0的实例对象----------------------
------------创建代理类实例，方式1--------------------
add方法调用前...
add方法调用后的返回结果为：true
add方法调用后...

add方法调用前...
add方法调用后的返回结果为：true
add方法调用后...

size方法调用前...
size方法调用后的返回结果为：2
size方法调用后...
2
[java] view plain copy print ?
  1. //方式2 
  2. Constructor prox2 = clazzProxy.getConstructor(InvocationHandler.class); 
  3. List list2 = (List)prox2.newInstance(new InvocationHandler() { 
  4.     List target = new ArrayList(); 
  5.     @Override 
  6.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  7.         Object retVal = method.invoke(target, args); 
  8.         return retVal; 
  9.     }} 
  10. );  
//方式2
Constructor prox2 = clazzProxy.getConstructor(InvocationHandler.class);
List list2 = (List)prox2.newInstance(new InvocationHandler() {
	List target = new ArrayList();
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Object retVal = method.invoke(target, args);
		return retVal;
	}}
);
[java] view plain copy print ?
  1. //方式3(匿名类)，将创建代理类和创建代理类实例对象的步聚合二为一 
  2. System.out.println("------------创建代理类实例，方式3--------------------"); 
  3. List list3 = (List)Proxy.newProxyInstance( 
  4.     ArrayList.class.getClassLoader(),  
  5.     ArrayList.class.getInterfaces(), 
  6.         new InvocationHandler() { 
  7.             ArrayList target = new ArrayList(); 
  8.             @Override 
  9.             public Object invoke(Object proxy, Method method, 
  10.                     Object[] args) throws Throwable { 
  11.                 //测试方法的运行效率 
  12.                 long beginTime = System.currentTimeMillis(); 
  13.                 Object retVal = method.invoke(target, args); 
  14.                 long endTime = System.currentTimeMillis(); 
  15.                 System.out.println(method.getName() + " 方法运行时长为：" + (endTime - beginTime)); 
  16.                 return retVal; 
  17.             }} 
  18.         ); 
  19.         list3.add("hy"); 
  20.         list3.add("yangxin"); 
  21.         System.out.println(list3.size());  
//方式3(匿名类)，将创建代理类和创建代理类实例对象的步聚合二为一
System.out.println("------------创建代理类实例，方式3--------------------");
List list3 = (List)Proxy.newProxyInstance(
	ArrayList.class.getClassLoader(), 
	ArrayList.class.getInterfaces(),
		new InvocationHandler() {
			ArrayList target = new ArrayList();
			@Override
			public Object invoke(Object proxy, Method method,
					Object[] args) throws Throwable {
				//测试方法的运行效率
				long beginTime = System.currentTimeMillis();
				Object retVal = method.invoke(target, args);
				long endTime = System.currentTimeMillis();
				System.out.println(method.getName() + " 方法运行时长为：" + (endTime - beginTime));
				return retVal;
			}}
		);
		list3.add("hy");
		list3.add("yangxin");
		System.out.println(list3.size());
输出结果：
------------创建代理类实例，方式3--------------------
add 方法运行时长为：0
add 方法运行时长为：0
size 方法运行时长为：0
2

*通过以上代码的分析，可将生成代理类的代码，抽取成一个生成代理的通用方法，并将功能代码用一个对象封装起来（如：测试方法的运行时间，方法运行前或运行后需要做的事情）
[java] view plain copy print ?
  1. /**
  2. * 获得代理对象
  3. * @param target 目标（被代理的对象）
  4. * @param advice 目标对象中的方法被调用前要执行的功能
  5. * @return 目标的代理对象
  6. */ 
  7. private static Object getProxy(final Object target,final Advice advice) { 
  8.     return Proxy.newProxyInstance( 
  9.             target.getClass().getClassLoader(),  
  10.             target.getClass().getInterfaces(), 
  11.             new InvocationHandler() { 
  12.                 @Override 
  13.                 public Object invoke(Object proxy, Method method, 
  14.                         Object[] args) throws Throwable { 
  15.                     Object retVal = null; 
  16.                     try { 
  17.                         advice.doBefore(target, method, args);//方法执行前 
  18.                         retVal = method.invoke(target, args); 
  19.                         advice.doAfter(target, method, args, retVal);//方法执行后 
  20.                     } catch (Exception e) { 
  21.                         advice.doThrow(target, method, args, e);//方法抛出异常 
  22.                     } finally { 
  23.                         advice.doFinally(target, method, args);//方法最终执行代码(用于释放数据资源、关闭IO流等操作) 
  24.                     } 
  25.                     return retVal; 
  26.                     }} 
  27.                 ); 
  28.     }  
/**
 * 获得代理对象
 * @param target 目标（被代理的对象）
 * @param advice 目标对象中的方法被调用前要执行的功能
 * @return 目标的代理对象
*/
private static Object getProxy(final Object target,final Advice advice) {
	return Proxy.newProxyInstance(
			target.getClass().getClassLoader(), 
			target.getClass().getInterfaces(),
			new InvocationHandler() {
				@Override
				public Object invoke(Object proxy, Method method,
						Object[] args) throws Throwable {
					Object retVal = null;
					try {
						advice.doBefore(target, method, args);//方法执行前
						retVal = method.invoke(target, args);
						advice.doAfter(target, method, args, retVal);//方法执行后
					} catch (Exception e) {
						advice.doThrow(target, method, args, e);//方法抛出异常
					} finally {
						advice.doFinally(target, method, args);//方法最终执行代码(用于释放数据资源、关闭IO流等操作)
					}
					return retVal;
					}}
				);
	}
封装功能的对象：
[java] view plain copy print ?
  1. package proxy; 
  2.  
  3. import java.lang.reflect.Method; 
  4.  
  5. /**
  6. * aop接口，提供方法运行前、方法运行后、方法运行中产生Exception、方法最终运行代码
  7. *
  8. */ 
  9. public interface Advice { 
  10.      
  11.     /**
  12.      * 方法运行前
  13.      * @param target 被代理的目标对象
  14.      * @param method 被调用的方法
  15.      * @param args 方法的参数
  16.      */ 
  17.     public void doBefore(Object target, Method method, Object[] args); 
  18.      
  19.     /**
  20.      * 方法运行后
  21.      * @param target 被代理的目标对象
  22.      * @param method 被调用的方法对象
  23.      * @param args 方法的参数
  24.      * @param retVal 方法的返回值
  25.      */ 
  26.     public void doAfter(Object target, Method method, Object[] args, Object retVal); 
  27.      
  28.     /**
  29.      * 方法运行时产生的异常
  30.      * @param target 被代理的目标对象
  31.      * @param method 被调用的方法
  32.      * @param args 方法参数
  33.      * @param e 运行时的异常对象
  34.      */ 
  35.     public void doThrow(Object target, Method method, Object[] args, Exception e); 
  36.      
  37.     /**
  38.      * 最终要执行的功能(如释放数据库连接的资源、关闭IO流等)
  39.      * @param target 被代理的目标对象
  40.      * @param method 被调用的方法
  41.      * @param args 方法参数
  42.      */ 
  43.     public void doFinally(Object target, Method method, Object[] args); 
  44. }  
package proxy;

import java.lang.reflect.Method;

/**
 * aop接口，提供方法运行前、方法运行后、方法运行中产生Exception、方法最终运行代码
 *
 */
public interface Advice {
	
	/**
	 * 方法运行前
	 * @param target 被代理的目标对象
	 * @param method 被调用的方法
	 * @param args 方法的参数
	 */
	public void doBefore(Object target, Method method, Object[] args);
	
	/**
	 * 方法运行后
	 * @param target 被代理的目标对象
	 * @param method 被调用的方法对象
	 * @param args 方法的参数
	 * @param retVal 方法的返回值
	 */
	public void doAfter(Object target, Method method, Object[] args, Object retVal);
	
	/**
	 * 方法运行时产生的异常
	 * @param target 被代理的目标对象
	 * @param method 被调用的方法
	 * @param args 方法参数
	 * @param e 运行时的异常对象
	 */
	public void doThrow(Object target, Method method, Object[] args, Exception e);
	
	/**
	 * 最终要执行的功能(如释放数据库连接的资源、关闭IO流等)
	 * @param target 被代理的目标对象
	 * @param method 被调用的方法
	 * @param args 方法参数
	 */
	public void doFinally(Object target, Method method, Object[] args);
}
再建一个日志功能的实现类LogAdvice，用于测试：
[java] view plain copy print ?
  1. package proxy; 
  2.  
  3. import java.lang.reflect.Method; 
  4. import java.util.Arrays; 
  5.  
  6. /**
  7. * 日志功能切入类
  8. * @author 杨信
  9. *
  10. */ 
  11. public class LogAdvice implements Advice { 
  12.  
  13.     long beginTime = System.currentTimeMillis(); 
  14.      
  15.     @Override 
  16.     public void doBefore(Object target, Method method, Object[] args) { 
  17.         System.out.println(target.getClass().getSimpleName() + 
  18.                 "." + method.getName() + "方法被调用，参数值：" + Arrays.toString(args)); 
  19.  
  20.     } 
  21.      
  22.     @Override 
  23.     public void doAfter(Object target, Method method, Object[] args, Object retVal) { 
  24.         long endTime = System.currentTimeMillis(); 
  25.         System.out.println(target.getClass().getSimpleName() + 
  26.                 "." + method.getName() + "方法运行结束，返回值：" + retVal + "，耗时" + (endTime - beginTime) + "毫秒。"); 
  27.  
  28.     } 
  29.  
  30.     @Override 
  31.     public void doThrow(Object target, Method method, Object[] args, 
  32.             Exception e) { 
  33.         System.out.println("调用" + target.getClass().getSimpleName() + 
  34.                 "." + method.getName() + "方法发生异常，异常消息："); 
  35.         e.printStackTrace(); 
  36.     } 
  37.  
  38.     @Override 
  39.     public void doFinally(Object target, Method method, Object[] args) { 
  40.         System.out.println("doFinally..."); 
  41.          
  42.     } 
  43.  
  44. }  
package proxy;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * 日志功能切入类
 * @author 杨信
 *
 */
public class LogAdvice implements Advice {

	long beginTime = System.currentTimeMillis();
	
	@Override
	public void doBefore(Object target, Method method, Object[] args) {
		System.out.println(target.getClass().getSimpleName() +
				"." + method.getName() + "方法被调用，参数值：" + Arrays.toString(args));

	}
	
	@Override
	public void doAfter(Object target, Method method, Object[] args, Object retVal) {
		long endTime = System.currentTimeMillis();
		System.out.println(target.getClass().getSimpleName() +
				"." + method.getName() + "方法运行结束，返回值：" + retVal + "，耗时" + (endTime - beginTime) + "毫秒。");

	}

	@Override
	public void doThrow(Object target, Method method, Object[] args,
			Exception e) {
		System.out.println("调用" + target.getClass().getSimpleName() +
				"." + method.getName() + "方法发生异常，异常消息：");
		e.printStackTrace();
	}

	@Override
	public void doFinally(Object target, Method method, Object[] args) {
		System.out.println("doFinally...");
		
	}

}
测试生成代理的通用方法：
[java] view plain copy print ?
  1. ArrayList target = new ArrayList(); 
  2. List list4 = (List)getProxy(target,new LogAdvice()); 
  3. list4.add("张三"); 
  4. list4.add("李四"); 
  5. list4.add("王五"); 
  6. System.out.println(list4.size()); 
  7. list4.get(3);   //演示异常advice  
ArrayList target = new ArrayList();
List list4 = (List)getProxy(target,new LogAdvice());
list4.add("张三");
list4.add("李四");
list4.add("王五");
System.out.println(list4.size());
list4.get(3);	//演示异常advice
输出结果：
[java] view plain copy print ?
  1. ArrayList.add方法被调用，参数值：[张三] 
  2. ArrayList.add方法运行结束，返回值：true，耗时0毫秒。 
  3. doFinally... 
  4. ArrayList.add方法被调用，参数值：[李四] 
  5. ArrayList.add方法运行结束，返回值：true，耗时0毫秒。 
  6. doFinally... 
  7. ArrayList.add方法被调用，参数值：[王五] 
  8. ArrayList.add方法运行结束，返回值：true，耗时0毫秒。 
  9. doFinally... 
  10. ArrayList.size方法被调用，参数值：null 
  11. ArrayList.size方法运行结束，返回值：3，耗时0毫秒。 
  12. doFinally... 
  13. 3 
  14. ArrayList.get方法被调用，参数值：[3] 
  15. 调用ArrayList.get方法发生异常，异常消息： 
  16. java.lang.reflect.InvocationTargetException 
  17.     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 
  18.     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) 
  19.     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) 
  20.     at java.lang.reflect.Method.invoke(Method.java:597) 
  21.     at proxy.DynamicProxyTest$3.invoke(DynamicProxyTest.java:163) 
  22.     at $Proxy0.get(Unknown Source) 
  23.     at proxy.DynamicProxyTest.main(DynamicProxyTest.java:143) 
  24. Caused by: java.lang.IndexOutOfBoundsException: Index: 3, Size: 3 
  25.     at java.util.ArrayList.RangeCheck(ArrayList.java:547) 
  26.     at java.util.ArrayList.get(ArrayList.java:322) 
  27.     ... 7 more 
  28. doFinally...  
ArrayList.add方法被调用，参数值：[张三]
ArrayList.add方法运行结束，返回值：true，耗时0毫秒。
doFinally...
ArrayList.add方法被调用，参数值：[李四]
ArrayList.add方法运行结束，返回值：true，耗时0毫秒。
doFinally...
ArrayList.add方法被调用，参数值：[王五]
ArrayList.add方法运行结束，返回值：true，耗时0毫秒。
doFinally...
ArrayList.size方法被调用，参数值：null
ArrayList.size方法运行结束，返回值：3，耗时0毫秒。
doFinally...
3
ArrayList.get方法被调用，参数值：[3]
调用ArrayList.get方法发生异常，异常消息：
java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
	at java.lang.reflect.Method.invoke(Method.java:597)
	at proxy.DynamicProxyTest$3.invoke(DynamicProxyTest.java:163)
	at $Proxy0.get(Unknown Source)
	at proxy.DynamicProxyTest.main(DynamicProxyTest.java:143)
Caused by: java.lang.IndexOutOfBoundsException: Index: 3, Size: 3
	at java.util.ArrayList.RangeCheck(ArrayList.java:547)
	at java.util.ArrayList.get(ArrayList.java:322)
	... 7 more
doFinally...
完毕，通过动态代理机制，实现了传说中的AOP思想。

 

hiping_cao
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解Java的动态代理
07-26
NULL 博文链接：https://kingxt.iteye.com/blog/666105
深入理解JDK动态代理机制
weixin_30649859的博客
02-20 196
一、现实生活中的代理？ 在现实生活中，我们常见的有服务器代理商、联想PC代理商、百事可乐、火车票、机票等代理商，为什么会有这些个代理商呢？设想以买火车票为场景，如果我要买一张从广州去长沙的火车票，就必须去火车站排队购票，如果排队的人比较多的话，非常的耽误时间。但有了火车票代理商之后，我就可以直接去找个离我最近的代理商买票，因为这样的代理商不止一个二个，遍布全市各地...
深度剖析JDK动态代理机制
weixin_30437337的博客
06-19 128
摘要 相比于静态代理，动态代理避免了开发人员编写各个繁锁的静态代理类，只需简单地指定一组接口及目标类对象就能动态的获得代理对象。 代理模式 使用代理模式必须要让代理类和目标类实现相同的接口，客户端通过代理类来调用目标方法，代理类会将所有的方法调用分派到目标对象上反射执行，还可以在分派过程中添加"前置通知"和后置处理（如在调用目标方法前校验权限，在调用完目标方法后打印日志等）等功能...
JDK动态代理的深入理解
舞鹤白沙编码日志
12-25 261
引入代理模式 代理模式是框架中经常使用的一种模式，动态代理是AOP（面向切面编程）思想的一种重要的实现方式，在我们常用的框架中也经常遇见代理模式的身影，例如在Spring中事务管理就运用了动态代理，它将Service层原先应该进行的事务管理交给了Spring框架，大大简化了开发流程。在Hibernate中对象的懒加载模式，也运用了JDK的动态代理以及cglib代理。 静态代理 在说动态代理之前，我们需要先了解...
java动态代理(JDK和cglib)共10页.pdf.zip
10-28
Java动态代理是Java编程中一个重要的特性，它允许我们在运行时创建代理类，这些代理类可以作为原有类的增强，通常用于实现AOP（面向切面编程）或为...了解和熟练掌握这两种动态代理机制对于提升Java开发能力至关重要。
JDK动态代理和Cglib动态代理实例源码
最新发布
01-04
首先，JDK动态代理是Java内置的一种机制，它依赖于`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口。`Proxy`类用于创建代理对象，而`InvocationHandler`接口定义了处理代理对象方法调用的...
关于jdk动态代理的源码剖析
06-18
本文将深入分析JDK动态代理的工作原理及其内部实现机制。 #### 二、为什么需要JDK动态代理？ 在实际开发中，经常会遇到需要为已有的类添加新功能的需求，但又不能直接修改这些类的源码。此时，动态代理技术就显得...
浅谈JDK动态代理与CGLIB代理去区别
03-01
了解这两种代理机制的差异，并掌握如何在实际项目中灵活运用，能够提升我们的编程能力和解决复杂问题的能力。无论是JDK动态代理还是CGLIB代理，都是Java开发中不可或缺的工具，它们为我们的代码带来了强大的扩展性...
JDK动态代理简单示例
11-21
JDK动态代理是Java编程中一个非常重要的特性，它允许我们在运行时创建具有特定接口的代理类实例。这种技术在很多场景下都非常有用，比如在AOP（面向切面编程）中实现方法拦截、日志记录、事务管理等。下面我们将深入...
深入理解JDK动态代理？
龚小帅的博客
06-15 319
简单理解动态代理 动态代理其实可以看成两部分组成，动态和代理，动态体现在自动生成，不用我们自己操心，代理则是找个人帮你做完事，也不用自己操心。 在日常开发程序中，其实存在大部分类是不能够轻易修改，也不敢改，但该类确实已无法满足现在的功能，那么怎么样进行功能增强呢？这里我们使用到动态代理模式，降低代码耦合度。 什么是静态代理？ 有动态代理自然而然少不了静态代理，这里我们先演示下什么静态代理，对于动态代理就非常的好理解了。 场景演示： 先编写对库存进行减少操作的实现类 public interface ISto
深入理解jdk动态代理
csdn问鼎
12-27 222
1.接口public interface World { public void sayHello(int age); } 2.实现接口public class HelloWorld implements World { public void sayHello(int age) { System.out.println(age); } }3.实现Invocat
深入理解JDK动态代理
珍惜
01-09 350
执行结果如下： ------------------before------------------ --------------------add--------------- -------------------after------------------
深度解析JDK动态代理
Damon__Wang的博客
05-06 266
动态代理模式，就是在内存中动态生成$Proxy0对象，该对象实现了要被代理对象的接口。如下图，$Proxy0就是在内存中生成的。1. 首先需要写一个class，实现InvocationHandler接口。重写invoke方法。invoke方法有3个参数：    1.第一个参数是Proxy的一个动态实例。只有Proxy实例在InvocationHandler实现类里加载才可以产生第二个参数metho...
深入理解系列之JAVA动态代理机制
站在人文与技术的交汇点
04-15 702
代理的作用，就是生成代理对象使得真实对象的某些方法执行被代理对象拦截，从而在真实方法执行前、执行后添加额外的“动作”！动态代理则是指不需要修改原来的对象方法，在程序运行的过程中动态的生成代理对象，从而动态的生成这些“额外的”动作，主要从两个方面来深入理解动态代理机制！ 问题一、动态代理的基本实现是什么？ 动态代理本质上还是java中的“代理设计模式”，所以启UML图如下所示 ...
java中的动态代理深入理解例子
lxs的博客
05-02 194
        先看下代理类是怎么产生的，传目标类的加载器是为了使用该加载器加载代理类（个人理解），传目标类的实现接口时为了让代理类知道目标类有哪些方法，然后去实现这些方法，这也是为什么jdk动态代理要求目标类要实现接口(再深入的理解就是想要代理类去执行目标类的某个方法，那么这个方法必须在器实现的接口中。),后面的invocationHandler 匿名类 是为了当 代理类调用刚才实现的方法时，调...
深入理解--java的动态代理机制
xiaofeng66666的博客
04-30 203
本文原址：http://www.cnblogs.com/xiaoluo501395377/p/3383130.html一、概述1. 什么是代理我们大家都知道微商代理，简单地说就是代替厂家卖商品，厂家“委托”代理为其销售商品。关于微商代理，首先我们从他们那里买东西时通常不知道背后的厂家究竟是谁，也就是说，“委托者”对我们来说是不可见的;其次，微商代理主要以朋友圈的人为目标客户，这就相当于为厂家做了一...
深入理解：Java动态代理
qq_38001359的博客
05-10 142
动态代理是java中非常重要的一种技术，很多框架的底层实现都使用到了动态代理，例如dubbo、spring、jdbc的事务控制等，因此掌握动态代理的使用并深入理解是非常必要的。 动态代理，顾名思义，来自于Java设计模式中的代理模式： 代理模式：给某一个对象提供一个代理，并由代理对象来控制对真实对象的访问。代理模式是一种结构型设计模式。 代理模式的结构比较简单，其核心是代理类，为了让客户端能够一致性地对待真实对象和代理对象，在代理模式中引入了抽象层。 代理模式根据字节码文件的创建时机可以分为静态代理和动
代理模式
weixin_30474613的博客
07-02 90
代理模式 在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。 在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。 介绍 意图：为其他对象提供一种代理以控制对这个对象的访问。 主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操...
深入解析JDK动态代理机制
"JDK动态代理的底层实现原理" 在Java编程中，JDK动态代理是一种强大的工具，常用于创建具有额外功能的对象，如在AOP（面向切面编程...了解并掌握JDK动态代理的实现原理，能够帮助我们更好地理解和利用这个强大的工具。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值