总览
这篇文章我们简单讲一讲Java语言中代理模式的几种实现方式。这篇文章仅仅是在代码上的实现。原理篇会在后面分开来阐述。
什么是代理模式
要用Java实现代理，首先要知道什么是代理。
下面是在百度百科上关于代理模式的定义：
为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
怎么使用代理模式
具体在Java里的实现，我们在下面三个模块代码中来阐述。这里就简单介绍一下一个代理模式的组成，它在一定程度上表现了代理模式的基本使用。
抽象角色：通过接口或抽象类声明真实角色实现的业务方法。
代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。
使用代理模式的好处
- 职责清晰
真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件完成事务，附带的结果就是编程简洁清晰。 - 代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了中介的作用和保护了目标对象的作用。
- 高扩展性
- 降低了耦合
在代理类中，我们可以添加自己的动作，不在真实角色业务逻辑中的操作我们可以在代理类中进行添加。保证了业务逻辑的正确性。用一个烂大街的例子。现在我们有四个角色，一个是房东，一个是房子，一个是租客，一个是中介。处理租客，其他三个对应的代理模式中的角色想必非常清楚。如果租客和房东直接沟通，也就是看房->付定金->入住这样一个逻辑，但是看房和入住跟房东都没有太大的直接关系。这个时候，如果看房、入住都让房东亲自来处理，那我们的房东必然会忙的不可开交，并且不利于我们可爱的房东从复杂的租房活动中清闲起来，这个时候，我们使用代理模式，也就是说房东找一个中介公司，把自己提供租房这个服务交给中介来代理，让他们完成租房的工作。我们的房东只要负责收钱就好，看房啊、入住办理啊、这种事情就交给中介（代理）去处理就好。这样，我们实现了，职责清晰、保护了目标对象、高扩展度、降低了耦合的优良形态。
静态代理
静态代理的实现
到这里已经读了挺多字了。这里我们上几段代码来简单讲Java中静态代理的实现。
首先是一个接口。也就是所谓的接口角色。我们通过接口角色声明真实角色的业务。
public interface Hello {
void say(String name);
}然后是一个实现类。也就是所谓的真实角色，在这个类中，我们定义所要实现的业务逻辑。
public class HelloImp implements Hello{
@Override
public void say(String name) {
System.out.println("Hello! " + name);
}
}最后是一个代理类。我们使用代理类来代理真实类，通过真实类对应方法中的业务逻辑来实现接口中的抽象方法。特别的是，我们可以在代理类中添加自己的操作。
public class Proxy implements Hello {
private Hello realObject;
public Proxy(Hello realObject) {
this.realObject = realObject;
}
public void say() {
System.out.println("proxy do");
realObject.say();
}
}
动态代理
静态代理未免有点太死板了、这么直接固定的代理方式，会导致我们每有一个新的Hello接口的实现，就需要编写一个新的代理类。这未免也有点太臃肿了。Java待我们很好，给我提供了两种动态代理的实现方式，一种是JDK动态代理，一种是CGLib动态代理。JDK动态代理是Java原生的，而CGLib则是一个开源项目。（点击下载CGLib jar包）
jdk动态代理
我们首先来讲Jdk动态代理的实现，然后通过和CGLib的不同引入CGLib动态代理。老套路，直接粘贴代码。
动态代理代码：
package com.blaze.study.aop.dynamic;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class DynamicProxyDemo06 implements InvocationHandler{
private Object target;
public DynamicProxyDemo06(Object target){
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
operator1();
Object result = method.invoke(target,args);
operator2();
return result;
}
public void operator1(){
System.out.println("添加的操作1");
}
public void operator2(){
System.out.println("添加的操作2");
}
}这里我们通过实现InvocationHandler接口，并且提供其invoke方法的实现，就可以为所欲为，动态代理任何我们想要代理的类。
接下面，通过一段使用者来阐述一些动态代理代码上的优化。
package com.blaze.study.aop.dynamic;
import com.blaze.study.aop.proxy.Hello;
import com.blaze.study.aop.proxy.HelloImp;
import java.lang.reflect.Proxy;
public class DynamicProxyTestDemo06 {
public static void main(String[] args) {
Hello h = new HelloImp();
DynamicProxyDemo06 dy = new DynamicProxyDemo06(h);
Hello hello = (Hello)Proxy.newProxyInstance(h.getClass().getClassLoader(),
h.getClass().getInterfaces(),
dy);
hello.say("Sherlock");
}
}我们通过Proxy.newProxyInstance来生成Hello的引用并且使用通过类型转换最后来调用say方法。
根据在使用层面代码越简单越好的原则，我们通过可以通过在DynamicProxyDemo06类中添加这样的方法来改造我们的动态代理类。
@SuppressWarnings("unchecked")
public <T> T getProxy() {
return (T) Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
this);
}我们通过范型来完成类型的匹配，而不需要在调用者中使用强制方式的来进行类型转换。
这个时候，我们就可以在调用者中通过下面的简单代码来调用被调用的方法。
package com.blaze.study.aop.dynamic;
import com.blaze.study.aop.proxy.Hello;
import com.blaze.study.aop.proxy.HelloImp;
public class DynamicProxyTestDemo06 {
public static void main(String[] args) {
Hello h = new DynamicProxyDemo06(new HelloImp()).getProxy();
h.say("Sherlock");
}
}动态代理跟静态代理的区别就是在动态代理中我们不需要为每一个类写一个代理类。我们仅仅通过DynamicProxyDemo06这一个类来代理我们想要代理的任何类。比如我们有一个World接口、和World实现类。
World.java
package com.blaze.study.aop.proxy;
public interface World {
void say(String word);
}WorldImpl.java
package com.blaze.study.aop.proxy;
public class WorldImpl implements World{
@Override
public void say(String word) {
System.out.println(word + "\tWorld!");
}
}这样我们通过代码调用代理的服务，并且添加我们的操作，简单轻松。
package com.blaze.study.aop.dynamic;
import com.blaze.study.aop.proxy.Hello;
import com.blaze.study.aop.proxy.HelloImp;
import com.blaze.study.aop.proxy.World;
import com.blaze.study.aop.proxy.WorldImpl;
public class DynamicProxyTestDemo06 {
public static void main(String[] args) {
Hello h = new DynamicProxyDemo06(new HelloImp()).getProxy();
h.say("Sherlock");
/**新的被代理类*/
World w = new DynamicProxyDemo06(new WorldImpl()).getProxy();
w.say("Blaze");
}
}CGLib动态代理
接下面要讲的动态代理实现的方式就是CGLib，CGLib博大精深，这篇文章里我们就完成一个简单的实现。JDK动态代理必须要我们的被代理类有一个接口，如果没有接口，就会报类型转化错误。
我们仅简单的删除掉了WorldImpl类实现的接口。就爆出这样严重的错误。假如我们不想要实现任何接口呢，不想用接口来描述所要代理的方法。
这个时候，我们最好使用CGLib动态代理，它可以代理没有任何接口的类。接下来我们就来写这样的一个动态代理。
代理类 –> CGLibProxyDemo05
package com.blaze.study.aop.cglib;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CGLibProxyDemo05 implements MethodInterceptor{
@SuppressWarnings("unchecked")
public <T> T getProxy(Class<?> cls){
return (T) Enhancer.create(cls,this);
}
@Override
public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy)throws Throwable{
operator1();
Object result = proxy.invokeSuper(target,args);
operator2();
return result;
}
public void operator1(){
System.out.println("Operator1");
}
public void operator2(){
System.out.println("Operator2");
}
}我们通过提供的接口，调用invokeSuper方法，来完成CGLib的动态代理。我们通过这样的方式来调用服务。
使用者 –> CGLibProxyTestDemo05
package com.blaze.study.aop.cglib;
import com.blaze.study.aop.proxy.Hello;
import com.blaze.study.aop.proxy.HelloImp;
import com.blaze.study.aop.proxy.WorldImpl;
public class CGLibProxyTestDemo05 {
public static void main(String[] args) {
Hello h = new CGLibProxyDemo05().getProxy(HelloImp.class);
h.say("Sherlock");
WorldImpl w = new CGLibProxyDemo05().getProxy(WorldImpl.class);
w.say("Blaze");
}
}结果
在上面的代码中，我们已WorldImpl实现接口的声明删除掉了。通过程序执行的结果，我们可以清楚的看到CGLib动态代理不仅可以代理动态的有接口的HelloImp类，也可以代理没有实现任何接口的WorldImpl类。这是比JDk动态代理进步的地方。而关于这一块的原理，我们也会用相应的几篇博客一起探索其中的原理。Flag立在这里。