一分钟了解JAVA代理模式

最新推荐文章于 2024-11-12 21:14:07 发布

x329357842

最新推荐文章于 2024-11-12 21:14:07 发布

阅读量349

点赞数 1

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/x329357842/article/details/71556064

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

代理模式定义: 为其他对象提供一种代理以控制对这个对象的访问.

远程代理:为不同地理的对象提供局域网代表对象

虚拟代理: 根据需要将资源消耗很大的对象进行延迟加载当我们正真需要这个对象的时候再进行创建.

保护代理:控制对一个对象的权限

智能引用代理: 对代理对象提供一些额外的服务.

下面我来使用静态代理和动态代理分别实现智能引用代理功能

静态代理: 代理和被代理对象在代理之前是确定的他们都实现了相同的接口或者继承了相同的抽象类。

场景1: 我们有一辆汽车汽车有行驶的功能而我们现在需要给汽车增加一个记录行驶时间下面是具体实现:

package com.zs.spring.demo1;
//汽车行驶接口
public interface Moveable {
    public void move();
}

下面是我们传统的做法没有使用到代理类

package com.zs.spring.demo1;

import java.util.Random;

public class Car implements Moveable {

    public Car() {
        // TODO Auto-generated constructor stub
    }
    //行驶方法
    @Override
    public void move() {
        long begen= System.currentTimeMillis();
        // TODO Auto-generated method stub
        System.out.println("汽车开始行驶");
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("汽车结束用时"+(end-begen)+"毫秒");
    }

    public static void main(String[] args) {
        Car c =new Car();
        c.move();
    }
}

控制台:
汽车开始行驶
汽车行驶中
汽车结束用时701毫秒

下面是静态代理实现:

package com.zs.spring.demo1;

import java.util.Random;

public class Car2  extends Car{

        @Override
        public void move() {
            long begen= System.currentTimeMillis();
            // TODO Auto-generated method stub
            System.out.println("汽车开始行驶");
            super.move();
            long end = System.currentTimeMillis();
            System.out.println("汽车结束用时"+(end-begen)+"毫秒");
        }

}

上面我们使用了继承来实现代理新建Car2这个类并且继承Car
重写move()方法在子类中调用父类的行驶方法而记录行驶时间就放到了Car2子类来做了。

下面我们来使用聚合方式做代理所谓聚合方式就是一个类中调用了另外一个类就叫聚合.

package com.zs.spring.demo1;

public class Car3 implements Moveable{
    private Car car;

    public Car3(Car car){
        this.car=car;
    }
    @Override
    public void move() {
        long begen= System.currentTimeMillis();
        System.out.println("汽车开始行驶");
        car.move();
        long end = System.currentTimeMillis();
        System.out.println("汽车结束用时"+(end-begen)+"毫秒");

    }

  public static void main(String[] args) {
      Car c =new Car();
      Car3 car3 =new Car3(c);
      car3.move();
}
}

上面这种代理就是把Car类和代理类Car3同样的实现了Moveable 接口
在代理类中定义一个Car类对象在使用的时候先将Car类交给Car3代理类
增加记录时间的特性.

诚然继承的方式也有缺陷:比如我们不光需要加时间代理还要加日志代理和权限代理那么是不是又要重新建立日志代理类和权限代理类呢如果我们要先记录日志–时间–权限那么就得日志代理类继承Car 时间代理类继承日志类权限代理类继承时间代理类一层层的继承做代理,并且如果我们可能先记录时间-日志-权限那么是不是我们又要重新写一套扩展性太低.

下面我们使用聚合代理方式模拟实现日志和时间代理

//日志代理类
package com.zs.spring.demo1;

public class CarLogProxy implements Moveable{
    private Moveable car;

    public CarLogProxy(Moveable car){
        this.car=car;
    }
    @Override
    public void move() {
        System.out.println("日志开始......");
        car.move();
        System.out.println("日志结束......");

    }
}

时间代理类

package com.zs.spring.demo1;

public class CarTimeProxy implements Moveable{
    //因为日志类还是car类还是时间类都实现了Moveable接口所以定义接口
    使用多态
    private Moveable car;
    public CarTimeProxy(Moveable car){
        this.car=car;
    }
    @Override
    public void move() {
        long begen= System.currentTimeMillis();
        System.out.println("汽车开始行驶");
        car.move();
        long end = System.currentTimeMillis();
        System.out.println("汽车结束用时"+(end-begen)+"毫秒");

    }

  public static void main(String[] args) {
      Car c =new Car();
      CarTimeProxy car3 =new CarTimeProxy(c);
      CarLogProxy  clp = new CarLogProxy(car3);
      clp.move();
}


}
控制台输出:
日志开始......
汽车开始行驶
汽车行驶中
汽车结束用时606毫秒
日志结束......

那么现在是先开始记录日志在记录时间我现在想先记录时间再记录日志怎么做不用像继承一样再写一套代理类继承

  public static void main(String[] args) {
      Car c =new Car();
      CarLogProxy  clp = new CarLogProxy(c);
      CarTimeProxy car3 =new CarTimeProxy(clp);
      car3.move();
}
控制台输出:
汽车开始行驶
日志开始......
汽车行驶中
日志结束......
汽车结束用时852毫秒

所以我们尽量使用聚合代理扩展性高

动态代理:
所谓动态代理是在运行时生成class 该class需要实现一组接口(interface) 使用动态代理类时必须实现
InvocationHandler接口

package com.zs.spring.demo1;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


public class CarHandle implements InvocationHandler{
    private Object target;
    public CarHandle(Object target) {
        this.target=target;
    }
    /**
     * 参数:
     * proxy：被代理的对象
     * method：被代理对象的方法
     * args[] 方法的参数
     * 返回值:object
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        long begen= System.currentTimeMillis();
        System.out.println("开始行驶");
        method.invoke(target);
        long end = System.currentTimeMillis();
        System.out.println("结束行驶"+(end-begen)+"毫秒");
        return null;
    }


    public static void main(String[] args) {
        //创建被代理对象
        Car c =new Car();
        //要代理的对象给事件代理类CarHandle
        InvocationHandler invo = new CarHandle(c);
        //获取class对象
        Class<?> invoCalss =c.getClass();
        /**
         * loader 被代理类
         * interface 被代理类实现接口
         * h 代理类 CarHandle
         */
    Moveable m =(Moveable) Proxy.newProxyInstance(invoCalss.getClassLoader(),invoCalss.getInterfaces(),invo);
    m.move();
    }

}
控制台输出
汽车开始行驶
汽车行驶中
汽车结束用时133毫秒