代理模式是:一对象代替另外的对象进行操作。需要代理类和被代理类实现同样的接口
/**
* 代理模式 代理类和被代理类需要实现的接口
*
*/
public interface Business {
void doAction();
}
被代理类
/**
* 被代理类 需要实现接口
*
*/
public class BusinessImpl implements Business{
@Override
public void doAction() {
System.out.println("被代理类进行 真实操作");
}
}
代理类
/**
* 代理类 需要现实被代理类相同的接口
*
*/
public class BusinessImplProxy implements Business{
private BusinessImpl businessImpl;
public BusinessImplProxy(){
businessImpl=new BusinessImpl();
}
@Override
public void doAction() {
doBefore();
businessImpl.doAction();
doAfter();
}
public void doBefore(){
System.out.println("真正操作之前");
}
public void doAfter(){
System.out.println("真正操作之后");
}
}
测试类
public class StaticTest {
public static void main(String[] args) {
BusinessImplProxy proxy = new BusinessImplProxy();
proxy.doAction();
}
}
传统代理用到的很少,用的最多的是动态代理
java最常用的两种动态代理方式
一.java提供基于Proxy、InvocationHandler的动态代理
只支持对接口的的实现。 其实现主要通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。 Proxy类主要用来获取动态代理对象,InvocationHandler接口用来约束调用者实现。
JDK的动态代理用起来非常简单,但它有一个限制,就是使用动态代理的对象必须实现一个或多个接口
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//抽象角色:java动态代理的实现目前只支持接口,不支持抽象类
interface BusinessFoo {
void foo();
}
interface BusinessBar {
String bar(String message);
}
// 真实角色:真正实现业务逻辑方法
class BusinessFooImpl implements BusinessFoo {
public void foo() {
System.out.println("BusinessFooImpl.foo()");
}
}
class BusinessBarImpl implements BusinessBar {
public String bar(String message) {
System.out.println("BusinessBarImpl.bar()");
return message;
}
}
// 动态角色:动态生成代理类
class BusinessDynamicProxy implements InvocationHandler {
private Object obj;
BusinessDynamicProxy() {
}
BusinessDynamicProxy(Object obj) {
this.obj = obj;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
doBefore();
result = method.invoke(obj, args);
doAfter();
return result;
}
public void doBefore() {
System.out.println("do something before Business Logic");
}
public void doAfter() {
System.out.println("do something after Business Logic");
}
/**
* 工厂方法
*/
public static Object factory(Object obj) {
Class<? extends Object> cls = obj.getClass();
return Proxy.newProxyInstance(cls.getClassLoader(),
cls.getInterfaces(), new BusinessDynamicProxy(obj));
}
}
public class DynamicProxy {
public static void main(String[] args) {
BusinessFooImpl bfoo = new BusinessFooImpl();
BusinessFoo bf = (BusinessFoo) BusinessDynamicProxy.factory(bfoo);
bf.foo();
System.out.println();
BusinessBarImpl bbar = new BusinessBarImpl();
BusinessBar bb = (BusinessBar) BusinessDynamicProxy.factory(bbar);
String message = bb.bar("Hello,World");
System.out.println(message);
}
}
二.基于第三方开源框架cglib
cglib官方网站:http://sourceforge.net/projects/cglib/files/
另外cglib依赖于asm(http://asm.ow2.org/)。
Cglib的原理是对指定的目标类动态生成一个子类,并覆盖其中方法实现增强,但因为采用的是继承,所以不能对final修饰的类和final方法进行代理。
参考:http://blog.csdn.net/zhoudaxia/article/details/30591941
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class MethodInterceptorImpl implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("Before invoke " + method);
Object result = proxy.invokeSuper(obj, args);
System.out.println("After invoke" + method);
return result;
}
public Object createProxy(Class<?> targetClass) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(targetClass);
enhancer.setCallback(this);
return enhancer.create();
}
}
public class HelloWorld {
public void sayHelloWorld() {
System.out.println("HelloWorld!");
}
}
public class Test {
public static void main(String[] args) {
MethodInterceptorImpl mImpl=new MethodInterceptorImpl();
HelloWorld helloWorld= (HelloWorld) mImpl.createProxy(HelloWorld.class);
helloWorld.sayHelloWorld();
}
}