代理模式的运用

/**
 * 卖火车票的接口
 */
public interface SellTickets {
    void sell();
}
/**
 * 火车站类
 */
public class TrainStation implements SellTickets {
    public void sell() {
        System.out.println("火车站卖票");
    }
}
/**
 * 代售点类
 */
public class ProxyPoint implements SellTickets {
    //声明火车站类对象
    private TrainStation trainStation  = new TrainStation();
    public void sell() {
        System.out.println("代售点收取一些服务费用");
        trainStation.sell();
    }
}
/**
 * 客户：Client
 */
public class Client {
    public static void main(String[] args) {
        //创建代售点类对象
        ProxyPoint proxyPoint = new ProxyPoint();
        //调用方法进行买票
        proxyPoint.sell();
    }
}

/**
 * 卖火车票的接口
 */
public interface SellTickets {
    void sell();
}
/**
 * 火车站类
 */
public class TrainStation implements SellTickets {
    public void sell() {
        System.out.println("火车站卖票");
    }
}
/**
 * 获取代理对象的工厂类
 * 代理类也实现了对应的接口
 */
public class ProxyFactory {
    // 声明目标对象
    private TrainStation station = new TrainStation();
    // 获取代理对象的方法,使用Proxy获取代理对象
    public SellTickets getProxyObject() {
        /*
            newProxyInstance()方法参数说明：
                ClassLoader loader ： 类加载器，用于加载代理类，使用真实对象的类加载器
                Class<?>[] interfaces ： 真实对象所实现的接口，代理模式真实对象和代理对象实现相同的接口
                InvocationHandler h ： 代理对象的调用处理程序
         */
        SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(
                station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                new InvocationHandler() {
                    /*
                        InvocationHandler中invoke方法参数说明：
                            proxy ： 代理对象
                            method ： 对应于在代理对象上调用的接口方法的 Method 实例
                            args ： 代理对象调用接口方法时传递的实际参数
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("代理点收取一些服务费用(JDK动态代理方式)");
                        //执行真实对象
                        Object result = method.invoke(station, args);
                        return result;
                    }
                });
        return sellTickets;
    }
}
/**
 * 客户： Client
 */
public class Client {
    public static void main(String[] args) {
        // 获取代理对象，创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        // 使用factory对象的方法获取代理对象
        SellTickets proxyObject = factory.getProxyObject();
        // 调用卖火车票的方法
        proxyObject.sell();
    }
}

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

/**
 * 火车站类
 */
public class TrainStation {
    public void sell() {
        System.out.println("火车站卖票");
    }
}
/**
 * 代理对象工厂，用来获取代理对象
 */
public class ProxyFactory implements MethodInterceptor {
    // 声明火车站对象
    private TrainStation station = new TrainStation();
    public TrainStation getProxyObject() {
        // 创建Enhancer对象，类似于JDK代理中的Proxy类
        Enhancer enhancer = new Enhancer();
        // 设置父类的字节码对象，指定TrainStation为父类
        enhancer.setSuperclass(TrainStation.class);
        // 设置回调函数
        enhancer.setCallback(this);
        // 创建代理对象
        TrainStation proxyObject = (TrainStation) enhancer.create();
        return proxyObject;
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("代售点收取一定的服务费用(CGLib代理)");
        // 要调用目标对象的方法
        Object obj = method.invoke(station, objects);
        return obj;
    }
}
/**
 * 客户： Client
 */
public class Client {
    public static void main(String[] args) {
        // 创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        // 获取代理对象
        TrainStation proxyObject = factory.getProxyObject();
        // 调用代理对象中的sell方法卖票
        proxyObject.sell();
    }
}