Java框架基础 静态代理和动态代理

本文转自:
http://blog.csdn.net/code_my_dream/article/details/75145583

首先我想说一下, 类加载器和反射一个类的区别

class类加载器

xxx.getClass().getClassLoader();
先通过反射获得一个类, 通过类加载器来加载一个类的同时, 创建出一个类, 而getClass一个类只可以获得这个类中的方法和属性.

1、代理模式的分类：

代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
代理分为“静态代理”和“动态代理”：静态代理需要我们自己创建代理对象（需要创建代理类），而动态代理的代理对象是自动生成的，我们不需要关心代理对象的生成过程。

2、代理模式中有“抽象角色（接口）”、“代理角色”、“真实角色(目标角色)”这三个角色

代理对象和真实对象都会去实现“抽象角色”这个接口， 也就是说代理模式是基于接口来实现的。

3、对代理对象的理解和代码的实现

静态代理

package com.my.proxy;  
    
/* 
 * 抽象角色(接口) 
 */  
public interface IProduct {  
    public int product();  
}  
  
package com.my.proxy;  
  
// 目标对象,真实对象  
public class LiLingFactory implements IProduct {  
  
    @Override  
    public int product() {  
        int product = 100;  
        System.out.println("我要买鞋子,价格要低于" + product);  
        return product;  
    }  
  
}  
  
package com.my.proxy;  
  
// 代理对象, 作为直接对象的代理, 静态代理  
public class LiLingStore implements IProduct {  
  
    @Override  
    public int product() {  
        LiLingFactory lf = new LiLingFactory(); 
        
        int product = lf.product();  
        return product * 3;  
    }  
  
}  
    
package com.my.proxy;  
  

// 这种方式是静态代理  
public class Mytest {  
  
    public static void main(String[] args) {  
          
        // 直接通过工厂, 直接对象来获得  
        LiLingFactory lf = new LiLingFactory();  
        int product = lf.product();  
        System.out.println(product+"最低价");  
          
        // 通过代理对象来获得值      
        LiLingStore store = new LiLingStore();  
        int product2 = store.product();  
        System.out.println(product2);  
    }  
}  

动态代理

// 定义一个房东和租房者相同的方法  
public interface HousePrice {     
    public int price();  
}  
  
// 目标对象  
package com.my.proxy01;  
  
public class HouseOwner implements HousePrice{  
  
    @Override  
    public int price() {  
        int price=100;  
        System.out.println("房价又涨了,房东又要涨房租了");  
        return price;  
    }  
}  
  

package com.my.proxy01;  
  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
  
public class MyHouse {  
    public static void main(String[] args) {  
        /* 
         * loader是类加载器, 通过反射来加载类 
         */  
          
        // 获取直接对象(目标对象)  
        HouseOwner houseOwner = new HouseOwner();  
          
        // 获得类加载器  
        ClassLoader houseOwnerLoader = houseOwner.getClass().getClassLoader();  
        // 获得对象中接口方法的一个数组  
        Class[] houseOwnerinterface = houseOwner.getClass().getInterfaces();  
          
        // 其实newProxyInstance方法相当于动态地创建了一个类, 通过传类加载器, 获取中间的接口, 创建出来了一个动态代理的类  
        HousePrice proxyInstance = (HousePrice) Proxy.newProxyInstance(houseOwnerLoader, houseOwnerinterface, new InvocationHandler() {  
              
            // new InvocationHandler()相当于是一个监听器来监听了直接对象  
              
            /* 
             * proxy是获取当前直接对象 
             * method是获取直接对象中的方法 
             * args中的值 
             * 返回值: 代理对象代用方法的返回值 
             */  
            @Override  
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
                Object invoke = method.invoke(houseOwner, args);  
                System.out.println(method);  
                System.out.println("我一定会调用的");  
                return invoke;  
            }  
        });  
        
        // 调用代理对象的方法  
        int price = proxyInstance.price();  
        System.out.println(price);  
    }  
  
}  

动态代理中的原理,代码注释中已经讲的很清楚了,大家自己看看哈!