动态代理和代理的区别？如何创建动态代理？（简要明了哦，有demo有注释哦。。）谢谢了哦。。。

首先来说静态代理：静态代理，是要为每一个需要代理的类生成一个对象，假如有一万个类，那么就要写1万个代理，这是非常恐怖的。下面是静态代理的实现；
代理和目标都要实现相同的接口：

1. /**
   
2. * 代理和目标类都要实现的接口
   
3. * @author real
   
4. *
   
5. */
   
6. public interface PersonInterface {
   
7. 
   
8.         void getName();
   
9. }
   

复制代码

目标类：

1. /**
   
2. * 需要被代理的类，目标类
   
3. * @author real
   
4. *
   
5. */
   
6. public class Person implements PersonInterface{
   
7. 
   
8.         @Override
   
9.         public void getName() {
   
10.                 System.out.println("Person getName 执行");        
    
11.         }
    
12. }
    

复制代码

代理类：

1. public class PersonProxy implements PersonInterface{
   
2. 
   
3.         private PersonInterface person;
   
4.         
   
5.         public PersonProxy(PersonInterface person) {
   
6.                 this.person = person;
   
7.         }
   
8.         
   
9.         @Override
   
10.         public void getName() {
    
11.                 //在执行目标的真实方法之前，可以做其他事情，例如记录日志等。
    
12.                 System.out.println("PersonProxy 的getName方法执行");
    
13.                 //执行真实的目标类方法
    
14.                 person.getName();
    
15.         }
    
16. 
    
17. }

复制代码

测试类：

1. public class PersonTest {
   
2.         
   
3.         public static void main(String[] args) {
   
4.                 //真实的Person
   
5.                 PersonInterface person = new Person();
   
6.                 //Person的代理，需要把Person穿进去
   
7.                 PersonInterface personProxy = new PersonProxy(person);
   
8.                
   
9.                 //直接调用person的方法
   
10.                 person.getName();
    
11.                 //通过代理调用person的方法
    
12.                 personProxy.getName();
    
13. 
    
14.         }
    
15. }

复制代码

以上代码就是实现静态代理的方法，上面的问题就是如果需要代理的类太多，就得用到了动态代理。在jdk中可以动态的生成代理类。
下面是一个动态代理类：

1. 
   
2. public class Proxy1 {
   
3. 
   
4.         private Object target;
   
5.         
   
6.         //将需要被代理的类通过对象传入进来
   
7.         public Proxy1(Object target) {
   
8.                 this.target = target;
   
9.         }
   
10.         
    
11.         /**
    
12.          * 通过jdk的Proxy动态的生成target的代理类。
    
13.          * @return
    
14.          */
    
15.         public Object getProxy() {
    
16.                
    
17.                 /**
    
18.                  * Proxy.newProxyInstance()方法需要的三个参数分别问，这个代理类的ClassLoader，
    
19.                  * 这个类所有实现的接口，还有一个InvocationHandler,所有的代理方法都要通过里面的invoke方法，
    
20.                  * 然后我们可以在invoke方法内部调用target的真实方法，还可以执行其他代码
    
21.                  */
    
22.                 return Proxy.newProxyInstance(target.getClass().getClassLoader(),
    
23.                                 target.getClass().getInterfaces(),
    
24.                                 new InvocationHandler() {                        
    
25.                         
    
26.                                         @Override
    
27.                                         public Object invoke(Object proxy, Method method, Object[] args)
    
28.                                                         throws Throwable {
    
29.                                                 //retVal就是目标对象方法执行后的返回值
    
30.                                                 System.out.println("动态代理类。记录日志");
    
31.                                                 Object retVal = method.invoke(target, args);
    
32.                                                 return retVal;
    
33.                                         }
    
34.                                 });               
    
35.         }
    
36. }

复制代码

测试代理类：

1.                 Proxy1 p1 = new Proxy1(person);
   
2.                 PersonInterface personProxy1 = (PersonInterface) p1.getProxy();
   
3.                 personProxy1.getName();

复制代码

有了动态代理，就可以代理任何你传入的对象了。不会像静态代理一样限制类型了。

房建斌 发表于 2014-3-18 13:08
首先来说静态代理：静态代理，是要为每一个需要代理的类生成一个对象，假如有一万个类，那么就要写1万个代 ...

谢谢啊，很简洁，好！