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