简单例子

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() 的返回值


   




   




   




  。