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

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

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

 

1.静态代理:

 

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

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

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

 

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

 

 

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

  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;

}

}
  1.  

用户类:



public class User {


public static void main(String[] args) {

Proxy proxy = new Proxy();

Integer integer = proxy.letOut();

System.out.println(integer);



}

}
  1.  

输出:

 

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

 

 

 

 

2.动态代理:

 

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

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

 

动态代理的API:

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

  • java.lang.reflect.Proxy     

 

 

static ObjectnewProxyInstance(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);


}
  1.  

目标类:


/**

* 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;

}

}
  1.  

 

 

代理工厂类:


/**

* 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);


}

}
输出:

 

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

 

 

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));


}

}


输出:

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

 

案例:

 

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

 


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修饰!

    原文作者:AOP
    原文地址: https://blog.csdn.net/u012045045/article/details/82993959
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞