7种结构型模式之：代理模式、JDK动态代理、cglib动态代理

来源：互联网发布：调用接口获取json数据编辑：程序博客网时间：2024/04/25 11:59

其实每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。先来看看关系图：

根据上文的阐述，代理模式就比较容易的理解了，我们看下代码：

[java] view plain copy

public interface Sourceable {
public void method();
}

[java] view plain copy

public class Source implements Sourceable {
@Override
public void method() {
System.out.println("the original method!");
}
}

[java] view plain copy

public class Proxy implements Sourceable {
private Source source;
public Proxy(){
super();
this.source = new Source();
}
@Override
public void method() {
before();
source.method();
atfer();
}
private void atfer() {
System.out.println("after proxy!");
}
private void before() {
System.out.println("before proxy!");
}
}

测试类：

[java] view plain copy

public class ProxyTest {
public static void main(String[] args) {
Sourceable source = new Proxy();
source.method();
}
}

输出：

before proxy!
the original method!
after proxy!

代理模式的应用场景：

如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。

2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

--------------------------------------------------------------------------------------------------------------------------------------------------------

jdk动态代理

特点：只能对实现了接口的类生产代理，不能针对类

定义接口

[java] view plain copy
 
/** 
 * 创建业务接口，包含业务可以提供对外的接口 
 *  
 * @author Fighter 
 * @date 2016-04-19 
 * 
 */  
public interface UserService{  
      
    /** 
     * 目标方法  
     */  
    public void add();  
}  

定义实现类

[java] view plain copy
 
/** 
 * 创建业务接口实现类 
 *  
 * @author Fighter 
 * @date 2016-04-19 
 * 
 */  
public class UserServiceImpl implements UserService{  
    @Override  
    public void add() {  
     System.out.println("----------add----------");  
          
    }  
}  

定义代理

[java] view plain copy
 
/** 
 * 自定义简单的Invocation，对接口提供的方法进行增强 
 *  
 * @author Fighter 
 * @date 2016-04-19 
 */  
public class MyInvocationHandler implements InvocationHandler {  
      
      
    //目标对象  
    private Object target;  
      
    /** 
     * 构造方法 
     * @param target 目标对象 
     */  
    public MyInvocationHandler(Object target) {  
        super();  
        this.target=target;  
    }  
       
     * 执行目标对象的方法  
     */  
    public Object invoke(Object proxy, Method method, Object[] args)  
            throws Throwable {  
          
         //在目标方法执行前简单打印一下  
         System.out.println("----------before----------");  
           
         //执行目标方法对象  
         Object result=method.invoke(target, args);  
           
         //在目标方法执行之后简单打印一下  
         System.out.println("----------after----------");  
          
         return result;  
    }  
      
      
    /** 
     * 获取目标对象的代理对象 
     * @return 代理对象 
     * this.target.getClass().getInterfaces()//获取被代理对象实现的所有接口
     */  
    public Object getProxy(){  
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),   
                this.target.getClass().getInterfaces(),this);  
    }  
      
      
}  

jdk动态代理测试

[java] view plain copy
 
public class ProxyTest{  
      
    @Test  
    public void testProxy() throws Throwable{  
        //实例化目标对象  
        UserService userService=new UserServiceImpl();  
          
        //实例化Invocation  
        MyInvocationHandler invocationHandler=new MyInvocationHandler(userService);  
          
        //根据目标生成代理对象  
        UserService proxy=(UserService)invocationHandler.getProxy();  
          
        //调用代理对象方法  
        proxy.add();  
    }  
}  

CGLIB动态代理示例

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

CGLIB是一个强大的高性能的代码生成包。被广泛的许多AOP框架使用，如Spring的AOP和dynaop，为他们提供方法的interceptor(拦截)，最流行的是OR Mapping工具hibernate也是使用CGLIB来代理单端的single-ended（多对一和一对一）关联（对集合的延迟抓取是采用其他机制实现）。EsayMock和jMock是通过模仿（moke）对象来测试java代码的包。他们都是通过使用CGLIB来为那些没有接口的类创建模仿（moke）对象。

我们先通过demo来快速了解CGLIB的使用示例。

定义实现类

[java] view plain copy
 
/**  
 * 这个是没有实现接口的实现类  
 *   
 * @author student  
 *   
 */    
public class BookFacadeImpl {    
    public void addBook() {    
        System.out.println("增加图书的普通方法...");    
    }    
}   

定义代理

[java] view plain copy
 
/**  
 * 使用cglib动态代理  
 *   
 * @author student  
 *   
 */    
public class BookFacadeCglib implements MethodInterceptor {    
    private Object target;    
    
    /**  
     * 创建代理对象  
     *   
     * @param target  
     * @return  
     */    
    public Object getInstance(Object target) {    
        this.target = target;    
        Enhancer enhancer = new Enhancer();    
        enhancer.setSuperclass(this.target.getClass());    
        // 回调方法    
        enhancer.setCallback(this);    
        // 创建代理对象    
        return enhancer.create();    
    }    
    
    @Override    
    // 回调方法    
    public Object intercept(Object obj, Method method, Object[] args,    
            MethodProxy proxy) throws Throwable {    
        System.out.println("事物开始");    
        proxy.invokeSuper(obj, args);    
        System.out.println("事物结束");    
        return null;    
    
    
    }    
    
}    

编写Cglib测试

[java] view plain copy
 
public class TestCglib {    
        
    public static void main(String[] args) {    
        BookFacadeCglib cglib=new BookFacadeCglib();    
        BookFacadeImpl bookCglib=(BookFacadeImpl)cglib.getInstance(new BookFacadeImpl());    
        bookCglib.addBook();    
    }    
}    

总结

CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少，但是CGLib在创建代理对象时所花费的时间却比JDK多得多，所以对于单例的对象，因为无需频繁创建对象，用CGLib合适，反之，使用JDK方式要更为合适一些。同时，由于CGLib由于是采用动态创建子类的方法，对于final方法，无法进行代理。

1 0

7种结构型模式之：代理模式 、JDK动态代理、cglib动态代理

定义接口

定义实现类

定义代理

jdk动态代理测试

CGLIB动态代理示例

定义实现类

定义代理

编写Cglib测试

总结

7种结构型模式之：代理模式、JDK动态代理、cglib动态代理