代理模式

最新推荐文章于 2025-12-08 07:26:58 发布

转载最新推荐文章于 2025-12-08 07:26:58 发布 · 244 阅读

文章标签：

#object #class #classloader #list #float #string

java 专栏收录该内容

252 篇文章

订阅专栏

本文通过具体实例介绍了Java代理模式的基本概念及应用方式，包括普通代理模式和动态代理模式，并探讨了其在屏蔽对象真实方法实现方面的用途。

学习spring 之前java中的几个模式是很重要的其中一个就是代理模式。下面用几个简单的例子来理解一下这个模式。以及它的应用。

1.基础讲解
java.lang.reflect
提供类和接口，以获得关于类和对象的反射信息。

Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有

动态代理类的超类。

java.lang.reflect.InvocationHandler 是代理实例的调用处理程序实现的接口。

返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程

序。Proxy.newProxyInstance (ClassLoader loader, Class<?>[] interfaces,

InvocationHandler h)
此方法相当于：
     Proxy.getProxyClass(loader, interfaces).
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler });

设置class实例的代理处理程序(ArrayListProxy()来) ;代理pro;
ArrayListProxy();是接口为InvocationHandler的类
Object pro=Proxy.newProxyInstance(class.getClassLoader(),class.getInterfaces

(),new ArrayListProxy(o));
2.实例研究
//通过代理我们可以屏蔽掉对象的真实方法的实现。来添加自己相关的业务逻辑。
2.1普通的代理模式//下面的中介商就是代理,通过中介商屏蔽了房东的出租方法.

class House{
private float price=200f;

    public float getPrice(){
        return price;
    }

    public void setPrice(){
        this.price = price;
    }
}
//房东
class HouseOwner{
    House house = null;

    HouseOwner(House house){
        this.house = house;
    }

    public void rent(){
        System.out.println ("房东出租房子价格是:"+house.getPrice());
    }
}

//中介商
class HouseProxy {
    //20% 的中介费
    float centPricePoint = 0.2f;

    HouseOwner own = null;


    HouseProxy (HouseOwner own){
         this.own = own;
    }

    public void rent(){

        //调用真实的方法前做一些事
        System.out.println ("收取中介费"+own.house.getPrice()*centPricePoint);

        own.rent();

        //调用真实的方法后做一些事
        System.out.println ("交易成功。");

    }



}
//客户
class Rentor {
    public static void main(String[] args){
        House h = new House();

        //客户找房东
        HouseOwner o = new HouseOwner(h);
        o.rent();


        System.out.println ("*******************");

        //客户找代理
        HouseProxy hp = new HouseProxy(o);
        hp.rent();
    }
}

2.2动态代理模式。
//假设做一个ArrayList 的添加提示的功能。就是在调用它的add方法的时候输出一句请检查类型.
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.*;
import java.util.*;
class ArrayListProxy implements InvocationHandler{
    Object list ;

    ArrayListProxy(Object list ){
        this.list = list;
    }


    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable{

        if(method.getName().equals("add")){
            //对特定方法代理
            System.out.println ("请检查类型.befor:"+method.getName());
        }

        //对所有方法代理
        //System.out.println ("请检查类型.befor:"+method.getName());
        Object o = method.invoke(list,args);

        return o ;

    }


    public static Object factory(Object o ){
        Class c = o.getClass();

        //用真实的对象来构造代理对象
        return Proxy.newProxyInstance(c.getClassLoader(),c.getInterfaces(),new ArrayListProxy(o));
    }
}

class TestDProxy{
    public static void main(String[] args){
        ArrayList al = new ArrayList();
        List pro = (List)ArrayListProxy.factory(al);


        pro.add("aaa");
        System.out.println (pro.size());



    }
}
通过代理我们屏蔽了真实对象的实现。理解这个模式后才能更好的理解 AOP

http://blog.youkuaiyun.com/caoyinghui1986/archive/2008/05/16/2450221.aspx