看完此文你就学会了代理模式
1.什么是代理模式
一个委托类，一个代理类，实现相同的接口，通常是在代理类中有一个委托类的对象，代理类并不会真正的执行方法，只是在委托类执行方法之前或之后提供一些服务。比如账户验证，权限查看啥的。
代理模式主要分为静态代理和动态代理。
静态代理：在它在运行的时候，代理类的.class文件就存在了。
动态代理：利用反射，在运行时动态的加载类。
2.静态代理
以客户买车为例
// Car.java
public interface Car {
// 预订车
public void revCar();
// vip客户可以直接买车
public void buyCar();
}// CarImpl.java
/**
* 委托类
*/
public class CarImpl implements Car {
public void revCar() {
System.out.println("我要去预订一辆车咯");
}
public void buyCar() {
System.out.println("我要买车咯");
}
}// CarProxy.java
/**
* 代理类
*/
public class CarProxy implement Car {
private CarImpl ci;
public CarProxy(CarImpl ci) {
this.ci = ci;
}
public void revCar() {
System.out.println("该客户是否有足够的钱预订车");
ci.revCar();
System.out.println("该客户预订完成");
}
public void buyCar() {
System.out.println("该客户是否是vip客户");
ci.buyCar();
System.out.println("该客户买车完成");
}
}public class TestProxy {
public static void main(String[] args) {
CarImpl ci = new CarImpl();
CarProxy cp = new CarProxy(ci);
cp.revCar();
cp.buyCar();
}
}静态代理是一个代理类只能为一个委托类服务，如果有多个委托类实现了同一个接口，则就要有多个代理类，除了委托类调用的方法不一样，其他操作都一样，这样势必就会产生很多重复代码。这时就是动态代理类上场的时候了。
3.JDK动态代理
JDK动态代理要使用Java提供的InvocationHandler接口和Proxy类的newProxyInstance方法。
// InvocationHandler接口
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}InvocationHandler接口中只有一个invoke方法，所有动态代理类都要实现这个接口，并实现invoke方法。
关于该方法的三个参数 proxy表示被代理的对象 method表示被代理对象的方法 args表示方法的参数
// Proxy类的newProxyInstance方法
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)loader表示委托类的类加载器 interfaces表示委托类实现的接口（这就说明委托类一定要实现了接口才能使用） h表示InvocationHandler接口的子实例，也就是动态代理类的实例
为了说明动态代理类和静态代理类的不同，我定义了两个委托类
// Car.java
package com.codeliu.dao;
public interface Car {
// vip客户可以直接买车
public void buyCar();
}// CarImp1.java
/**
* 委托类1
*/
public class CarImp1 implements Car {
public void buyCar() {
System.out.println("我是vip1");
}
}// CarImp2.java
/**
* 委托类2
*/
public class CarImp2 implements Car {
public void buyCar() {
System.out.println("我是vip2");
}
}// CarProxy.java
/**
* 动态代理类
*/
public class CarProxy implements InvocationHandler {
private Object target;
/**
* 绑定一个委托对象并获得一个代理类对象
* @param target [description]
* @return [description]
*/
public Object bind(Object target) {
this.target = target;
// 取得代理对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
this);
}
@Override
//这个方法并不是我们自己去调用
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("该客户是否是vip客户");
// 执行委托类的方法
Object result = method.invoke(target,args);
System.out.println("该客户买车完成");
return result;
}
}public class TestProxy {
public static void main(String[] args) {
CarProxy cp = new CarProxy();
// 传入一个实现了该接口的实例就行
Car car = (Car)cp.bind(new CarImp1());
// Car car = (Car)cp.bind(new CarImp2());
car.buyCar();
}
}输出
该客户是否是vip客户
我是vip1
该客户买车完成以上就是一个JDK动态代理的例子，但我们可以看到，如果委托类没有实现接口的话，就不能使用newProxyInstance方法，进而不能使用JDK动态代理。这时候，Cglib动态代理上场了。
4.Cglib动态代理
Cglib是针对类来实现代理的，对指定的目标类生成一个子类，通过方法拦截技术拦截所有父类方法的调用。因为是生成子类，所以就不能用在final修饰的类上。
要使用Cglib，首先要下载jar包。
public class Train {
public void move() {
System.out.println("火车行驶中。。。。");
}
}public class CglibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
/**
* 获得代理类
* @return
*/
public Object getProxy(Class<?> c) {
// 设置创建子类的类
enhancer.setSuperclass(c);
// 回调方法
enhancer.setCallback(this);
// 返回代理对象
return enhancer.create();
}
@Override
/**
* 拦截所有目标方法的调用
* obj 目标类的实例
* m 目标方法的反射对象
* args 方法的参数
* proxy 代理类的实例
*/
public Object intercept(Object obj, Method m, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("火车启动啦！！");
// 代理类调用父类的方法
Object result = proxy.invokeSuper(obj, args);
System.out.println("火车停止啦！！");
return result;
}
}public class Test {
public static void main(String[] args) {
CglibProxy proxy = new CglibProxy();
Train t = (Train)proxy.getProxy(Train.class);
t.move();
}
}输出
火车启动啦！！
火车行驶中。。。。
火车停止啦！！本文参与 腾讯云自媒体分享计划，分享自微信公众号。
原始发表：2019-06-08，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录