|
昨天被人问及动态代理与CGlib的区别，赶紧回顾一下：
代理模式是Java中常见的一种模式，英文名字叫走Proxy或者Surrogate，代理的本意是一个人代表另一个人，或者一个机构代表另一个机构，采取行动，因而，代理和现实生活中的中介有很大的类似，你买房子、卖房子，可以自己去操作，但是需要了解和买卖房产无关的细节，如契税等，而找一个中介，则不用关心这些与买卖房产无直接关系的中间细节，只关心业务本身。 静态代理UML类图
模式中包含的角色及其职责 Subject：抽象主题角色，抽象主题类可以是抽象类，也可以是接口，是一个最普通的业务类型定义，无特殊要求。 RealSubject：具体主题角色，也叫被委托角色、被代理角色。是业务逻辑的具体执行者。 Proxy：代理主题角色，也叫委托类、代理类。它把所有抽象主题类定义的方法给具体主题角色实现，并且在具体主题角色处理完毕前后做预处理和善后工作。（最简单的比如打印日志）： Subject: /**
* 抽象主题，定义主要功能
*/
publicinterface Subject {
publicvoid operate();
}
RealSubject：
/**
* 具体主题
*/
publicclass RealSubject implements Subject{
@Override
publicvoid operate() {
System.out.println('realsubject operatestarted......');
}
} 代理类Proxy：
/**
* 代理类
*/
publicclass Proxy implements Subject{
private Subject subject;
public Proxy(Subject subject) {
this.subject = subject;
}
@Override
publicvoid operate() {
System.out.println('before operate......');
subject.operate();
System.out.println('after operate......');
}
} 客户端：
/**
* 客户
*/
publicclass Client {
/**
* @param args
*/
publicstaticvoid main(String[] args) {
Subject subject = new RealSubject();
Proxy proxy = new Proxy(subject);
proxy.operate();
}
}
代理模式的适用，总结为：代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等 代理模式的用途，可以分为如下几种（From GOF）: (1)远程代理(Remote Proxy) ---A remote proxy provides
a local representative for an object in a different address space.为远程对象提供一个本地的代理对象， 典型的例子如RMI， EJB，local bean 为remote 接口对象提供一个stub
(2)虚拟代理(Virtual Proxy) – A virtual proxy creates expensive objects on demand.允许内存开销较大的对象在需要的时候创建。只有我们真正需要这个对象的时候才创建。 虚拟代理模式(Virtual Proxy)是一种节省内存的技术，它建议创建那些占用大量内存或处理复杂的对象时，把创建这类对象推迟到使用它的时候。在特定的应用中，不同部分的功能由不同的对象组成，应用启动的时候，不会立即使用所有的对象。在这种情况下，虚拟代理模式建议推迟对象的创建直到应用程序需要它为止。对象被应用第一次引用时创建并且同一个实例可以被重用。这种方法优缺点并存。 (3)写入时复制代理(Copy-On-Write Proxy) – 用来控制对象的复制，方法是延迟对象的复制，直到客户真的需要为止。是虚拟代理的一个变体。 (4)保护代理(Protection (Access)Proxy) –
A protection proxy controls access to the original object. Protection proxies are useful when objects should have different access rights.为不同的客户提供不同级别的目标对象访问权限
(5)缓存代理(Cache Proxy) – 为开销大的运算结果提供暂时存储，它允许多个客户共享结果，以减少计算或网络延迟。 (6)防火墙代理(Firewall Proxy) – 控制网络资源的访问，保护主题免于恶意客户的侵害。 (7)同步代理(SynchronizationProxy) –在多线程的情况下为主题提供安全的访问。 (8)智能引用代理(Smart ReferenceProxy) - A smart reference is a replacement for a bare pointer that performs additional actions when an object is accessed。当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来等。 (9)复杂隐藏代理(Complexity HidingProxy) – 用来隐藏一个类的复杂集合的复杂度，并进行访问控制。有时候也称为外观代理(Fa?ade Proxy)，这不难理解。复杂隐藏代理和外观模式是不一样的，因为代理控制访问，而外观模式是不一样的，因为代理控制访问，而外观模式只提供另一组接口。
2.静态代理与动态代理 代理分为静态代理和动态代理 按照代理创建的时期，可以分为动态代理和静态代理： 静态代理：由程序员或者自动生成工具生成代理类，然后进行代理类的编译和运行。在代理类、委托类运行之前，代理类已经以.class的格式存在。 静态代理：在程序运行时，由反射机制动态创建而成。
3.静态代理实例 静态代理实例： 首先需要一个接口：
package net.battier.dao;
/**
* 定义一个账户接口
*
* @author Administrator
*
*/
public interface Count {
// 查看账户方法
public void queryCount();
// 修改账户方法
public void updateCount();
}
然后是委托类，也就是接口的真正实现类，内涵主要的业务逻辑：
package net.battier.dao.impl;
import net.battier.dao.Count;
/**
* 委托类(包含业务逻辑)
*
* @author Administrator
*
*/
public class CountImpl implements Count {
@Override
public void queryCount() {
System.out.println('查看账户方法...');
}
@Override
public void updateCount() {
System.out.println('修改账户方法...');
}
}
最后是代理类：
CountProxy.java
package net.battier.dao.impl;
import net.battier.dao.Count;
/**
* 这是一个代理类（增强CountImpl实现类）
*
* @author Administrator
*
*/
public class CountProxy implements Count {
private CountImpl countImpl;
/**
* 覆盖默认构造器
*
* @param countImpl
*/
public CountProxy(CountImpl countImpl) {
this.countImpl = countImpl;
}
@Override
public void queryCount() {
System.out.println('事务处理之前');
// 调用委托类的方法;
countImpl.queryCount();
System.out.println('事务处理之后');
}
@Override
public void updateCount() {
System.out.println('事务处理之前');
// 调用委托类的方法;
countImpl.updateCount();
System.out.println('事务处理之后');
}
}
运行：
package com.mahoutchina.pattern.proxy;
public class CountTest {
/**
* @param args
*/
public static void main(String[] args) {
CountImpl countImpl = new CountImpl();
CountProxy countProxy = new CountProxy(countImpl);
countProxy.updateCount();
countProxy.queryCount();
}
}
从静态代理中可以看出：
1.接口：代理类需要实现一个接口，这个接口和委托类的接口是一样的，这样proxy才能和委托类行为表现一致 2. 方法（Method）:由于接口限制，proxy类中也要有interface中的各个方法，这就造成了代码重复
4.动态代理实例
java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类：
在使用动态代理类时，我们必须实现InvocationHandler， 以上面的代码为例： Subject： public interface Subject {
abstract public void request();
} 具体Subject： // 具体角色RealSubject：
public class RealSubject implements Subject {
public RealSubject() {}
public void request() {
System.out.println( ' From real subject. ' );
}
} 代理处理器(ProxyHandler):import java.lang.reflect.Method;
import java.lang.reflect.InvocationHandler;
public class DynamicSubject implements InvocationHandler {
private Object sub;
public DynamicSubject() {}
public DynamicSubject(Object obj) {
sub = obj;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println( ' before calling ' method);
method.invoke(sub,args);
System.out.println( ' after calling ' method);
return null ;
}
}
该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值；此外，在该类还实现了invoke方法，该方法中的 method.invoke(sub,args); 其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，args为执 行被代理对象相应操作所需的参数。通过动态代理类，我们可以在调用之前或之后执行一些 相关操作。 // 客户端：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class Client {
static public void main(String[] args) throws Throwable {
RealSubject rs = new RealSubject(); // 在这里指定被代理类
InvocationHandler ds = new DynamicSubject(rs);
Class cls = rs.getClass();
// 以下是一次性生成代理
Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),ds );
subject.request();
}
} 通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口 (Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实 现了非常灵活的动态代理关系。
从JDK 1.3以来，Java 语言通过java.lang.reflex库提供的三个类直接支持代理： java.lang.reflect.Proxy,java.lang.reflect.InvocationHandler 和Method. Proxy类在运行时动态创建代理对象，这也是dynamic proxy的由来，下面是类图，其中最重要的是newProxyInstance,这个方法中，指明了将要代理的类的加载器，业务类接口，以及代理类要执行动作的调用处理器（InvokeHandler)
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
Ps:类加载器 当系统有了一个代理对象之后，对原方法的调用会首先被分派到一个调用处理器（Invocation Handler).InvocationHandler 接口如下图所示： 代码： 接口： package com.mahoutchina.pattern.proxy.dynamicproxy;
public interface BookFacade {
public void addBook();
public void deleteBook();
}
实际业务类：
package com.mahoutchina.pattern.proxy.dynamicproxy;
public class BookFacadeImpl implements BookFacade {
@Override
public void addBook() {
System.out.println('add book logic is running。。。');
}
@Override
public void deleteBook() {
System.out.println('delete book logic is running。。。');
}
}
动态代理类：
package com.mahoutchina.pattern.proxy.dynamicproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class BookFacadeProxy implements InvocationHandler {
private Object target;
/**
*
* @param target
* @return
*/
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 {
Object result=null;
System.out.println('Proxy start...');
System.out.println('method name:' method.getName());
result=method.invoke(target, args);
System.out.println('Proxy end...');
return result;
}
}
测试类：
package com.mahoutchina.pattern.proxy.dynamicproxy;
public class TestProxy {
/**
* @param args
*/
public static void main(String[] args) {
BookFacadeProxy proxy = new BookFacadeProxy();
BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());
bookProxy.addBook();
bookProxy.deleteBook();
}
}
对于JDK 的Proxy,有以下几点：
1）Interface：对于JDK proxy，业务类是需要一个Interface的，这也是一个缺陷 2）Proxy，Proxy 类是动态产生的，这个类在调用Proxy.newProxyInstance(targetCls.getClassLoader, targetCls.getInterface,InvocationHander)之后，会产生一个Proxy类的实例。实际上这个Proxy类也是存在的，不仅仅是类的实例。这个Proxy类可以保存到硬盘上。 3） Method:对于业务委托类的每个方法，现在Proxy类里面都不用静态显示出来 4） InvocationHandler: 这个类在业务委托类执行时，会先调用invoke方法。invoke方法再执行相应的代理操作，可以实现对业务方法的再包装 5 CGLib 简介 JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 业务类： package net.battier.dao;
public interface BookFacade {
public void addBook();
}
package net.battier.dao.impl;
/**
* 这个是没有实现接口的实现类
*
* @author student
*
*/
public class BookFacadeImpl1 {
public void addBook() {
System.out.println('增加图书的普通方法...');
}
}
代理：
package net.battier.proxy;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
* 使用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;
}
}
测试；
package net.battier.test;
import net.battier.dao.impl.BookFacadeImpl1;
import net.battier.proxy.BookFacadeCglib;
public class TestCglib {
public static void main(String[] args) {
BookFacadeCglib cglib=new BookFacadeCglib();
BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());
bookCglib.addBook();
}
}
|
|
|
来自： liang1234_ > 《java进阶》
