其他分享
首页 > 其他分享> > 23中设计模式之-代理模式(1)

23中设计模式之-代理模式(1)

作者:互联网

代理模式

  概念:

    1.真实对象:要被代理的对象

    2.代理对象

    3.代理模式 : 代理对象代理真实对象,达到增强真实对象功能的作用

  实现方式:

    1.静态代理:有一个类文件描述代理模式

    2.动态代理:在内存中形成代理类

      * 实现步骤

        1.创建真实对象

          Acer acer = new Acer();

        2.动态代理增强真实对象

          Proxy.newProxyInstance(真实对象的类加载器,真实对象的接口,处理器);

            三个参数:

              1.类加载器 真实对象.getClass().getClassLoader()

              2.接口数组:真实对象.getClass().getInterfaces()

              3.处理器: new InvocationHandler()

                处理器当中有一个invoke()方法,代理逻辑编写的方法,代理对象调用的所有方法都会触发该方法执行

                处理器当中的invoke方法:invoke(Object proxy,Method method,Object[] args)

                  三个参数:

                    1.proxy:代理对象

                    2.method:代理对象调用的方法,被封装为对象(反射)

                    3.args:代理对象调用方法时,传递的实际参数

      

/**
* 定义一个车的接口,行驶和耗油两个方法
*/
public interface Car {
int consume(int i);
int drive();
}

/**
* 一个真实对象
*/
public class BwmCar implements Car{
@Override
public int consume(int i) {
return 10*i;
}
@Override
public int drive(){
return 10;
}
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyTest {

    public static void main(String[] args) {
        Car car = new BwmCar();

        /**
         * 动态代理的三个参数分别为:
         *   真实对象的类加载器
         *   真实对象的接口
         *   处理器
         */
        Car proxy_car = (Car) Proxy.newProxyInstance(car.getClass().getClassLoader(), car.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //如果是调用的consume的方法
                if ("consume".equals(method.getName())) {
                    Integer value = (Integer) method.invoke(car, args);
                    value *= 2;
                    return value;
                }
                //如果不是consume方法,那么该返回什么就返回什么
                return method.invoke(car, args);
            }
        });
        int consume = proxy_car.consume(10);
        System.out.println(consume);
        car.drive();
        System.out.println("========");
        BwmCar bwm = new BwmCar();
        int bwmCon = bwm.consume(10);
        System.out.println(bwmCon);
    }
}

  总结:

    正常情况下,都是通过实例化一个类来进行方法的调用.

    模拟一个场景:

      创建了一个接口,然后写一个实现类,来实现这个接口当中的方法,正常情况,实例化这个实现类即可调用这个接口当中的方法.但是,当这个方法的实现效果无法满足要求的时候,可以考虑使用代理模式,增强这个实现类中已经实现的方法​

    【方法定义的三要素:返回值类型/参数列表/方法名】

    【方法执行的三核心:返回值类型/参数列表/方法体(方法执行的业务逻辑)】,增强就是从这三个方面进行增强的.

    增强方式:

      1.增强参数列表

      2.增强返回值类型

      3.增强方法体制性逻辑

 

  应用场景 : 过滤器等等

标签:consume,23,对象,car,代理,int,设计模式,方法
来源: https://www.cnblogs.com/le-papillion/p/12769973.html