1-代理模式
代理（proxy）是一种设计模式。提供了对目标对象另外的访问方式，即通过代理对象访问目标对象，这样的优点是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。
编程思想：不随意去修改别人已经写好的代码或者方法，如果需要修改，通过代理的方式来拓展该方法。
例子：比如邀请一位明星，那么并不是直接连线邀请明星，而是联系明星的经纪人来达到同样的目的，明星就是一个目标对象，他只要负责活动中的节目，而其他琐碎的事情就交给他的代理人（经纪人）来解决，这就是生活中的一个代理的例子；
图例如下：
1.1静态代理
使用静态代理时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同的父类。
代码实例：
接口：targetinteface.java
|
1
2
3
4
5
6
7
8
|
/*** 接口类*/public interface targetinteface { void method1(); void method2(); int method3(integer i);} |
目标对象类：target.java，用来实现接口，实现接口，实现接口中的方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class target implements targetinteface { @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; }} |
代理对象类：targetproxy.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public class targetproxy implements targetinteface { @override public void method1() { system.out.println("执行方法前...");//在此处填写自己的业务需求 new target().method1(); system.out.println("执行方法后..."); } @override public void method2() { system.out.println("执行方法前..."); new target().method2(); system.out.println("执行方法后..."); } @override public int method3(integer i) { system.out.println("执行方法前..."); int method3 = new target().method3(i); system.out.println("执行方法后..."); return method3; }} |
测试类：targetuser.java
|
1
2
3
4
5
6
7
8
|
public static void main(string[] args) { targetinteface target = new targetproxy(); target.method1(); system.out.println("-----------------------------"); target.method2(); system.out.println("-----------------------------"); system.out.println(target.method3(3));} |
运行结果如下：
静态代理总结：
1-在不修改目标对象的前提下，对功能目标进行拓展
2-缺点：因为代理对象需要和目标对象实现一样的接口，所以会有很多代理类，导致类太多；同时一旦接口增加方法，目标对象与代理对象都需要增加维护，使用动态代理解决此缺点；
1.2 动态代理
特点：
1-代理对象，不需要实现接口；
2-代理对象的生成是利用jdk的api，动态的在内存中构建代理对象（需要我们指定创建代理对象/目标对象实现的接口的类型）
3-动态代理也叫作jdk代理，接口代理；
jdk中生成代理对象的api
代理对象坐在的包:java.lang.reflect.proxy
jdk实现代理只需要使用newproxyinstance方法,但是该方法需要接收三个参数,完整的写法是:
|
1
2
3
4
|
static object newproxyinstance( classloader loader,//指定当前目标对象使用类加载器,获取加载器的方法是固定的 class<?>[] interfaces,//目标对象实现的接口的类型,使用泛型方式确认类型 invocationhandler h )//事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入 |
代码示例：
接口类：targetinteface.java
|
1
2
3
4
5
|
public interface targetinteface { void method1(); void method2(); int method3(integer i);} |
接口实现类：target.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class target implements targetinteface { @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; }} |
代理工厂类：targetproxy.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class targetproxy { public static <t> object gettarget(t t) { return proxy.newproxyinstance(t.getclass().getclassloader(), t.getclass().getinterfaces(), new invocationhandler() { @override public object invoke(object proxy, method method, object[] args) throws throwable { // proxy就是目标对象t，method就是调用目标对象中方法，args就是调用目标对象中方法的参数。 //比如说：代理对象.method1(),这时proxy就是目标类，method1就是method,args就是method1方法参数。 system.out.println("执行方法前..."); object invoke = method.invoke(t, args);//执行目标对象方法 system.out.println("执行方法后..."); return invoke; } }); }} |
测试类：targetuser.java
|
1
2
3
4
5
6
7
8
|
public static void main(string[] args) { targetinteface target = (targetinteface) targetproxy.gettarget(new target()); target.method1(); system.out.println("-----------------------------"); target.method2(); system.out.println("-----------------------------"); system.out.println(target.method3(3));} |
运行结果：
总结： 代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理
1.2 cglib代理
前面说的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候就可以使用以目标对象子类的方式类实现代理，成为cglib代理；
cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.
- jdk的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用cglib实现.
- cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多aop的框架使用,例如spring aop和synaop,为他们提供方法的interception(拦截)
- cglib包的底层是通过使用一个小而块的字节码处理框架asm来转换字节码并生成新的类.不鼓励直接使用asm,因为它要求你必须对jvm内部结构包括class文件的格式和指令集都很熟悉.
cglib子类代理实现方法:
1.需要引入cglib的jar文件,但是spring的核心包中已经包括了cglib功能,所以直接引入pring-core-3.2.5.jar即可.
2.引入功能包后,就可以在内存中动态构建子类
3.代理的类不能为final,否则报错
4.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.
代码示例：
目标对象类：target.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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; }} |
cglib代理工厂:targetproxy.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public class targetproxy { 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; } }); return en.create(); }} |
测试类：targetuser.java
|
1
2
3
4
5
6
7
8
|
public class targetuser { public static void main(string[] args) { target target = (target) targetproxy.getproxy(new target()); target.method1(); }} |
运行结果：
在spring的aop编程中:
如果加入容器的目标对象有实现接口,用jdk代理
如果目标对象没有实现接口,用cglib代理
总结
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注服务器之家的更多内容！
原文链接：https://blog.csdn.net/qq_40604313/article/details/118662665
