模式的秘密---代理模式

第1章 代理模式概念介绍

本章讲述了代理模式的分类、应用场景及作用

第2章 常用代理模式原理

本章介绍静态代理、动态代理实现原理。并通过案例讲解 JDK 动态代理以及使用 cglib 实现动态代理

引入包快捷键

打印快捷键

继承的方式实现静态代理：调用父类的方法。

使用聚合的方式，通过把参数传入进来，调用move方法。

 

 

更正：第一个参数一般是指被代理类。

 创建被代理的类以及接口：被代理的类Car，被代理的接口Moveable

cglib-nodep-2.2.2.jar 下载地址

http://www.java2s.com/Code/Jar/c/Downloadcglibnodep213jar.htm

package com.imooc.proxy;

public interface Moveable {
    void move();
}

package com.imooc.proxy;

import java.util.Random;

public class Car implements Moveable {

    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶...");
        // 实现开车
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶...汽车行驶时间：" + (endtime - starttime) + "毫秒！");
    }

}

package com.imooc.proxy;

public class Client {
    /**
     * 测试类
     */
    public static void main(String[] args) {
        Car car = new Car();
        car.move();
    }
}

静态代理的实现

使用继承的方式实现静态代理

package com.imooc.proxy;

public interface Moveable {
    void move();
}

package com.imooc.proxy;

import java.util.Random;

public class Car implements Moveable {
    @Override
    public void move() {
        // 实现开车
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

package com.imooc.proxy;

public class Car2 extends Car {
    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶...");
        super.move();//使用继承的方式实现Car2对Car的代理
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶...汽车行驶时间：" + (endtime - starttime) + "毫秒！");
    }
}

package com.imooc.proxy;

public class Client {
    /**
     * 测试类
     */
    public static void main(String[] args) {
//        Car car = new Car();
//        car.move();
        
        Moveable m=new Car2();
        m.move();
    }
}

 使用聚合的方式实现静态代理

什么是聚合？

通过传进来的参数来调用move()方法

package com.imooc.proxy;

public interface Moveable {
    void move();
}

package com.imooc.proxy;

import java.util.Random;

public class Car implements Moveable {
    @Override
    public void move() {
        // 实现开车
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

package com.imooc.proxy;

public class Car3 implements Moveable {
    private Car car;

    public Car3(Car car) {
        super();
        this.car = car;
    }

    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶...");
        car.move();//使用聚合的方式实现Car3对Car的代理
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶...汽车行驶时间：" + (endtime - starttime) + "毫秒！");

    }

}

package com.imooc.proxy;

public class Client {
    /**
     * 测试类
     */
    public static void main(String[] args) {
//        Car car = new Car();
//        car.move();
        //使用继承方式
//        Moveable m=new Car2();
//        m.move();
        //使用聚合方式实现
        Car car = new Car();
        Moveable m=new Car3(car);
        m.move();
    }
}

 使用聚合的方式实现功能的叠加（对时间、日志的代理）

package com.imooc.proxy;

public interface Moveable {
    void move();
}

package com.imooc.proxy;

import java.util.Random;

public class Car implements Moveable {
    @Override
    public void move() {
        // 实现开车
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

package com.imooc.proxy;
//对时间的代理
public class CarTimeProxy implements Moveable {
    private Moveable m;

    public CarTimeProxy(Moveable m) {
        super();
        this.m = m;
    }

    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶...");
        m.move();//使用聚合的方式实现Car3对Car的代理
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶...汽车行驶时间：" + (endtime - starttime) + "毫秒！");

    }

}

package com.imooc.proxy;
//对日志的代理
public class CarLogProxy implements Moveable {
    private Moveable m;

    public CarLogProxy(Moveable m) {
        super();
        this.m = m;
    }

    @Override
    public void move() {
        System.out.println("日志开始...");
        m.move();
        System.out.println("日志结束..." );

    }

}

package com.imooc.proxy;
//使用聚合的方式，代理之间可以互相传递的
public class Client {
    /**
     * 测试类
     */
    public static void main(String[] args) {
        //创建子类对象，调用的方法为子类重写的方法或者继承的方法
        Car car=new Car();
        
        //先记录日志再记录时间
//        CarTimeProxy ctp = new CarTimeProxy(car);
//        CarLogProxy clp=new CarLogProxy(ctp);
//        clp.move();
        
        //先记录时间再记录日志
        CarLogProxy clp=new CarLogProxy(car);
        CarTimeProxy ctp = new CarTimeProxy(clp);
        ctp.move();
    }
}

动态代理实现

1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法

package com.imooc.jdkproxy;

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

public class TimeHandler implements InvocationHandler {

    private Object target;

    public TimeHandler(Object target) {
        super();
        this.target = target;
    }

    /**
     * 参数： 
     * proxy 被代理对象
     * method 被代理对象的方法 
     * args 方法的参数
     * 
     * 返回值：
     * Object 方法的返回值
     */

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶...");
        method.invoke(target);
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶...汽车行驶时间：" + (endtime - starttime) + "毫秒！");
        return null;
    }

}

2.创建被代理的类以及接口

package com.imooc.proxy;

public interface Moveable {
    void move();
}

package com.imooc.proxy;

import java.util.Random;

public class Car implements Moveable {
    @Override
    public void move() {
        // 实现开车
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

3.调用Proxy的静态方法，创建一个代理类

4.通过代理调用方法

package com.imooc.jdkproxy;

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

import com.imooc.proxy.Car;
import com.imooc.proxy.Moveable;

public class Test {

    /**
     * JDK动态代理测试类
     */
    public static void main(String[] args) {
        Car car = new Car();
        InvocationHandler h = new TimeHandler(car);
        Class<?> cls = car.getClass();
        /**
         * 动态创建代理类 
         * loader 类加载器 
         * interfaces 实现接口 
         * h InvocationHandler 事务处理器
         */
        // Proxy.newProxyInstance(loader, interfaces, h)
        // 对时间的动态代理
        Moveable m = (Moveable) Proxy.newProxyInstance(cls.getClassLoader(),
                cls.getInterfaces(), h);
        m.move();//相当于method.invoke(Object proxy,Object[] args)
                 //相当于move.invoke(m)
    }
}

第3章 自定义类模拟 JDK 动态代理的实现

本章通过编写自定义类，模拟 JDK 动态代理的实现，帮助大家深入理解 JDK 动态代理的实现原理与机制

commons-io-2.6.jar下载地址

https://mvnrepository.com/artifact/commons-io/commons-io/2.6

抛出异常快捷键

ctrl+1

第4章 代理模式总结

总结代理模式分类、应用场景、实现原理、实现方式及实现方式优缺点