设计模式之---代理模式(AOP的原理)

最新推荐文章于 2022-11-06 13:00:15 发布

一朵风中摇曳的水仙花

最新推荐文章于 2022-11-06 13:00:15 发布

阅读量233

点赞数

分类专栏： Spring 文章标签： spring aop 动态代理

Spring 专栏收录该内容

53 篇文章 1 订阅

订阅专栏

代理模式有三种:静态代理，动态代理，Cglib代理。

代理模式的功能主要是起到增强方法和权限拦截的作用。

1.静态代理：

其实代理模式根据这个名字就很好理解，举个简单例子：小明要去租房，但他找不到的房东，只能去找中介，中介再帮他找房东，而这个中介就起到了代理的作用。

如图所示：小明的是用户类，调用者，中介就是代理类，房东就是目标类真正需要调用的类，这时代理类就可以在中间做点手脚，起到增强方法的作用。

但有个问题就是如果目标类有很多方法，代理类应该也有这么多方法，这时代理类和目标应该要有一种约定，所以代理类和目标类都应该实现同一个接口。下面是代码实现：

目标类和代理类实现的同一接口，约束规定。



/**

* Created by Ming on 2017/11/25.

*/

public interface LetOutService {

Integer letOut();

}

房东类（目标类）：

中介类（代理类）：


/**

* Created by Ming on 2017/11/25.

*/

public class Landlady implements LetOutService {



@Override

public Integer letOut() {

System.out.println("租房方法 running...");

return 100;

}

}


/**

* Created by Ming on 2017/11/25.

*/

public class Proxy implements LetOutService {


@Override

public Integer letOut() {

Landlady landlady = new Landlady();

Integer integer = landlady.letOut();

return integer + 100;

}

}

用户类：



public class User {


public static void main(String[] args) {

Proxy proxy = new Proxy();

Integer integer = proxy.letOut();

System.out.println(integer);



}

}

输出：

2.动态代理：

静态代理缺点：因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护。

解决办法动态代理：其实动态代理和静态代理的思想是不变的，动态代理和静态代理的区别就是，动态代理不用我们去手编写代理类，在运行时，动态的在内存中生产代理类。（字节码对象级别的代理对象）。

动态代理的API：

在java.lang.reflect包中有一个代理类。

java.lang.reflect.Proxy

static Object

newProxyInstance(ClassLoader loader,类<?>[] interfaces,InvocationHandler h)

返回指定的接口，将方法调用指定的调用处理程序的代理类的一个实例。

返回值：Object就是代理对象

参数：

loader：代表与目标对象相同的类加载器-------目标对象.getClass().getClassLoader()

interfaces：代表与目标对象实现的所有的接口字节码对象数组----数组因为目标类可以有多个接口

h：具体的代理的操作，InvocationHandler接口

注意：JDK的Proxy方式实现的动态代理目标对象必须有接口没有接口不能实现jdk版动态代理！

介绍完方法，我们还是以代码为例看看怎么实现吧：

统一接口：


/**

* Created by Ming on 2017/11/25.

*/

public interface TargetInterface {


void method1();

void method2();

int method3(Integer i);


}

目标类：


/**

* Created by Ming on 2017/11/25.

*/

public class Target implements TargetInterface {

@Override

public void method1() {

System.out.println("method1 running ...");

}


@Override

public void method2() {

System.out.println("method2 running ...");

}


@Override

public int method3(Integer i) {

System.out.println("method3 running ...");

return i;

}

}

代理工厂类：


/**

* Created by Ming on 2017/11/23.

*/

public class ProxyFactory {


static <T> Object getProxy(T t){


//返回一个代理对象

Object object = Proxy.newProxyInstance(t.getClass().getClassLoader(), t.getClass().getInterfaces(), new InvocationHandler() {

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

// proxy就是目标对象，method就是调用目标对象中方法，args就是调用目标对象中方法的参数。

//比如说：代理对象.method1(),这时proxy就是目标类，method1就是method,args就是method1方法参数。

System.out.println("执行方法前...");

Object invoke = method.invoke(t, args);

System.out.println("执行方法后...");

return invoke;

}

});


return object;

}


}

调用者：


/**

* Created by Ming on 2017/11/25.

*/

public class User {


public static void main(String[] args) {

Target target = new Target();


TargetInterface proxy = (TargetInterface)ProxyFactory.getProxy(target);


proxy.method1();

System.out.println("-------------------------");

proxy.method2();

System.out.println("-------------------------");

int i = proxy.method3(100);

System.out.println(i);


}

}

输出：

3.Cglib代理：

第三方代理技术,Cglib代理.可以对任何类生成代理.代理的原理是对目标对象进行继承代理。如果目标对象被final修饰.那么该类无法被Cglib代理。

需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入spring-core包

代码实现：

目标类（可以不用实现接口，因为生成的代理类是目标类的子类）：


/**

* Created by Ming on 2017/11/25.

*/

public class Target {

public void method1() {

System.out.println("method1 running ...");

}


public void method2() {

System.out.println("method2 running ...");

}


public int method3(Integer i) {

System.out.println("method3 running ...");

return i;

}

}

CglibFactory类：


/**

* Created by Ming on 2017/11/25.

*/

public class CglibFactory {


static <T> Object getProxy(T t){

Enhancer en = new Enhancer(); //帮我们生成代理对象

en.setSuperclass(t.getClass());//设置要代理的目标类

en.setCallback(new MethodInterceptor() {//代理要做什么

@Override

public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

System.out.println("执行方法前。。。");

//调用原有方法

Object invoke = methodProxy.invokeSuper(object, args);

// Object invoke = method.invoke(t,args); 作用等同与上面。

System.out.println("执行方法后。。。");

return invoke;

}

});

Object proxyObj = en.create();//生成代理对象

return proxyObj;

}


}

调用类:


/**

* Created by Ming on 2017/11/25.

*/

public class User {


public static void main(String[] args) {

Target target = new Target();



TargetInterface proxy = (TargetInterface) CglibFactory.getProxy(target);


System.out.println(proxy.method3(100));


}

}

输出：

案例：

使用动态代理设置全局编码：


public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {


resp.setContentType("text/html;charset=utf-8");

HttpServletRequest request = (HttpServletRequest) req;

//使用动态代理 设置全局编码

HttpServletRequest proxyRequest = (HttpServletRequest) Proxy.newProxyInstance(request.getClass().getClassLoader(),

request.getClass().getInterfaces(),

new InvocationHandler() {

@Override

public Object invoke(Object object, Method method, Object[] args) throws Throwable {

String name = method.getName();

if("getParameter".equals(name)){

String invoke = (String) method.invoke(request, args);

invoke = new String(invoke.getBytes("iso8859-1"),"UTF-8");

return invoke;

}

return method.invoke(request,args);

}

}

);

chain.doFilter(proxyRequest,resp);

}

重点：

Spring AOP 编程的实现原理就是动态代理和Cglib 代理，当目标类实现接口时使用动态代理，没有则Cglib代理。

总结：

静态代理需要自己手动编写代理类和目标方法。

动态代理就不需要自己手动实现代理类和目标方法，但动态代理的目标类要必须实现接口！

Cglib 代理的目标类就不需要实现接口！但目标类不能被final修饰！