1.静态代理
静态代理，顾名思义，手动代码代理。通过代理类实现被代理类的接口，进而完成代理过程。其实就是才能重写了，原本的接口方法，手动去在目标方法执行前中后，进行切割，进而实现代理。
public class TestStaticProxy {
public static void main(String[] args) {
IRegisterService iRegisterService = new RegisterServiceImpl();
IRegisterService proxy = new RegisterServiceProxy(iRegisterService);
proxy.register("RyanLee", "123");
}
}
interface IRegisterService {
void register(String name, String pwd);
}
class RegisterServiceImpl implements IRegisterService {
@Override
public void register(String name, String pwd) {
System.out.println(String.format("【向数据库中插入数据】name：%s，pwd：%s", name, pwd));
}
}
class RegisterServiceProxy implements IRegisterService {
IRegisterService iRegisterService;
public RegisterServiceProxy(IRegisterService iRegisterService) {
this.iRegisterService = iRegisterService;
}
@Override
public void register(String name, String pwd) {
System.out.println("[Proxy]一些前置处理");
System.out.println(“开始执行被代理的方法”);
iRegisterService.register(name, pwd);
System.out.println("[Proxy]一些后置处理");
}
}
2.JDK代理
JDK代理，动态代理类和被代理类必须继承同一个接口。动态代理只能对接口中声明的方法进行代理，有一定限制。每一个动态代理实例都有一个关联的InvocationHandler。通过代理实例调用方法，方法调用请求会被转发给InvocationHandler的invoke方法。（这里就可以看出为啥在实例化代理类时，要传入目标类的接口，这样在代理类实现的invoke方法里可以直接执行接口方法实现了目标类被代理的过程）。实际上我们发现JDK的动态代理是基于反射的，而实现方式和静态代理很像，那为啥又说是动态代理呢？其实，细心的小伙伴就已经发现，JDK动态代理这种方式是一种对目标方法的增强，他不关心你目标方法，而是通过newProxyInstance方法来生成新的 的代理对象，只管代理执行，此处解耦。而对比静态代理就需要静态代理类知道目标类的信息，实现目标类的接口，限制很多。而动态代理在实现代理的时候,是传递需要代理类,的实现,无关接口 所以并不需要为每一种接口都写一个代理类了。
public static void main(String[] args) {
Target tar = new Target();
ProxyHandler handler = new ProxyHandler();
BBQ proxy = (BBQ) handler.getProxy(tar);
proxy.sayBBQ("LF");
}
static class Target implements BBQ {
@Override
public void sayBBQ(String s) {
System.out.println("这是原方法执行的 say bbq " + s);
}
}
interface BBQ {
void sayBBQ(String s);
}
static class ProxyHandler implements InvocationHandler {
Object obj;
public Object getProxy(Object obj) {
this.obj = obj;
Object o = Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
return o;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
doBefore();
Object result = method.invoke(obj, args);
doAfter();
return result;
}
private void doBefore() {
Thread thread = Thread.currentThread();
System.out.println("[Proxy]一些前置处理" + thread.getName() + " " + thread.getId());
}
private void doAfter() {
System.out.println("[Proxy]一些后置处理");
}
}
3.cglib代理
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
public static void main(String[] args) {
Target tar = new Target();
CGLIBProxyDemo handler = new CGLIBProxyDemo();
Target proxy = (Target) handler.getProxy(tar);
proxy.sayBBQ("cglib代理");
}
static class Target implements JDKProxyUtil.BBQ {
@Override
public void sayBBQ(String s) {
System.out.println("这是原方法执行的 say bbq " + s);
}
}
interface BBQ {
void sayBBQ(String s);
}
static class CGLIBProxyDemo implements MethodInterceptor {
private Object target;
public Object getProxy(Object obj) {
this.target = obj;
Enhancer enhancer = new Enhancer();
//生成子类
enhancer.setSuperclass(this.target.getClass());
// 回调方法
enhancer.setCallback(this);
// 创建代理对象
return enhancer.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] param, MethodProxy methodProxy) throws Throwable {
doBefore();
Object result = methodProxy.invokeSuper(obj, param);
doAfter();
return result;
}
private void doBefore() {
Thread thread = Thread.currentThread();
System.out.println("[Proxy]一些前置处理" + thread.getName() + " " + thread.getId());
}
private void doAfter() {
System.out.println("[Proxy]一些后置处理");
}
}
结语
仔细观察会发现：的原理依据，就是多态，要么实现接口生成代理类，要么继承目标类生成代理类，而
的手段就是反射，利用反射来获取被代理类的信息，进而才能实现不需要了解目标信息来构建多态，从而动态解耦。
