简单例子

package com.kfm.jdbc.day0328; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public interface Actor { void sing(double money); void jump(double money); } class Kun implements Actor{ @Override public void sing(double money) { System.out.println("收了" + money + "元    
    
    
，唱了一首《只因你太美》"); } @Override public void jump(double money) { System.out.println("收了" + money + "元     


     


     


  ，跳了一个舞"); } } class Agent implements Actor{ private Actor actor; public Agent(Actor actor){ this.actor = actor; } @Override public void sing(double money) { this.actor.sing(money * 0.8); } @Override public void jump(double money) { this.actor.jump(money * 0.9); } } class Main { public static void main(String[] args) { Kun kun = new Kun(); Actor o = (Actor) Proxy.newProxyInstance(Kun.class.getClassLoader(), new Class[]{Actor.class}, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String name = method.getName(); if ("sing".equals(name)){ System.out.println("请他唱歌先请我吃饭"); return method.invoke(kun, args); } else { System.out.println("做其他事得加钱"); return method.invoke(kun, args); } } } ); o.sing(1.1); o.jump(2.2); // Agent agent = new Agent(kun); // agent.sing(50000); } }

对例子进行分析：

有一个actor的接口




 




 




 
，有jump和sing两个方法 ikun实现了此接口 但是你能直接见到IKUN吗？？？ 因此需要一个agent也来实现actor接口
   

   

   

，但是     

     

     

 ，agent需要赚一点差价 现在在代码每次运行时 




  




  




  ，来一个agent

  


  


  


，因此就用到代理：

在 Main 类中     
     
     
，首先创建了一个 Kun 对象 kun  




   




   




   ，然后使用 Java 反射机制


 



 



 


，创建了一个代理对象 o               ，代理的是 Kun 类    
    
    
  。在代理对象的创建过程中   




    




    




   ，传入了 Kun 类的类加载器    
    
    
  、Actor 接口的 Class 对象和一个 InvocationHandler 对象


     


     


     
。这个 InvocationHandler 对象的作用是拦截代理对象方法的调用
















，对调用进行增强
 




 




 




。在 invoke 方法中               ，首先判断调用的方法是 sing 还是 jump    



     



     



   ，如果是 sing 方法
















，则输出一条信息“请他唱歌先请我吃饭    
    
    
  ”    
    
    
，然后再调用 kun 对象的 sing 方法   

   

   

 。如果是 jump 方法     


     


     


  ，则输出一条信息“做其他事得加钱


     


     


     
”




 




 




 
，然后再调用 kun 对象的 jump 方法 

     

     

     。最后
   

   

   

，通过代理对象 o 调用了 sing 和 jump 方法

  




  




  




。在这个示例中     

     

     

 ，代理对象 o 拦截了 sing 和 jump 方法的调用 




  




  




  ，对 sing 方法进行了增强

  


  


  


，输出了一条信息     
     
     
，而对 jump 方法没有进行增强  




   




   




   ，只是输出了一条提示信息  


  


  


。

Proxy.newProxyInstance 是 Java 动态代理的一个方法


 



 



 


，用于创建代理对象  
     
     
     。它有三个参数：

ClassLoader 类加载器               ，用于加载代理对象的 Class 文件


   




   




   



。

Class [] interfaces   




    




    




   ，被代理对象实现的接口列表
















，这些接口必须是非 final 类型 



 



 



。

InvocationHandler invocationHandler               ，实现了 InvocationHandler 接口的对象    



     



     



   ，用于拦截代理对象的方法调用并进行增强                 。

在这段代码中
















，Kun.class.getClassLoader() 表示使用 Kun 类的类加载器来加载代理对象的 Class 文件



    




    




    


。new Class[]{Actor.class} 表示要代理的接口列表    
    
    
，这里只有 Actor 接口














。new InvocationHandler() 表示实现了 InvocationHandler 接口的对象     


     


     


  ，这里使用了匿名内部类来实现                 。在这个匿名内部类中




 




 




 
，重写了 invoke 方法
   

   

   

，用于拦截代理对象的方法调用并进行增强



     



     



     

。

最后     

     

     

 ，将代理对象强制转换为 Actor 类型 




  




  




  ，并将其赋值给 o 变量

  


  


  


，o 可以调用 Actor 接口中的方法     
     
     
，实际上调用的是被代理对象 Kun 的对应方法  




   




   




   ，而 InvocationHandler 中的增强操作也会被执行














。

invoke() 方法是 InvocationHandler 接口中的一个方法


 



 



 


，用于拦截代理对象的方法调用并进行增强    
    
    
  。它有三个参数：

Object proxy               ，代理对象本身   




    




    




   ，通常在 invoke() 方法中不会使用到


     


     


     
。

Method method
















，代理对象被调用的方法对象
 




 




 




。

Object[] args               ，代理对象被调用的方法的参数列表   

   

   

 。

在这段代码中    



     



     



   ，invoke() 方法首先通过 Method 对象获取被调用方法的名字
















，然后判断被调用的方法是 sing 还是其他方法 

     

     

     。如果是 sing 方法    
    
    
，就输出一句话并调用被代理对象 Kun 的 sing() 方法     


     


     


  ，并将其返回值作为 invoke() 方法的返回值

  




  




  




。如果是其他方法




 




 




 
，就输出另一句话并调用被代理对象 Kun 的对应方法
   

   

   

，并将其返回值作为 invoke() 方法的返回值  


  


  


。

因此     

     

     

 ，当代理对象 o 调用 sing() 方法时 




  




  




  ，实际上会调用 invoke() 方法

  


  


  


，并在其中输出一句话     
     
     
，并调用被代理对象 Kun 的 sing() 方法  




   




   




   ，并将其返回值作为 o.sing() 的返回值  
     
     
     。当代理对象 o 调用 jump() 方法时


 



 



 


，实际上也会调用 invoke() 方法               ，并在其中输出另一句话   




    




    




   ，并调用被代理对象 Kun 的 jump() 方法
















，并将其返回值作为 o.jump() 的返回值


   




   




   



。