设计模式---代理模式

代理模式

proxy pattern

定义：指为其他对象提供一种代理，以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介作用。

使用目的

1. 保护目标对象
2. 增强目标对象

解释

Subject是顶层接口，RealSubject是真实对象（被代理对象），proxy是代理对象，代理对象持有被代理对象的引用，客户端调用代理对象的方法，同时也调用被代理对象的方法，但是会在代理对象前后增加一些处理代码。一般代理会被理解为代码增强，实际上是在原代码逻辑前后增加一些代码逻辑。使调用者无感知。

静态代理

eg: 老子给儿子介绍对象案例

Person接口

/**
 * 顶层接口
 */
public interface Person {

    /**
     * 成家
     */
    void getMarried();
}
1
2
3
4
5
6
7
8
9
10

son类

/**
 * 子类
 */
public class Son implements Person{
    @Override
    public void getMarried() {
        System.out.println("儿子要成家===");
    }
}
1
2
3
4
5
6
7
8
9

Father类

package com.maggie.demo.proxy.quiet.proxy;

import com.maggie.demo.proxy.quiet.pojo.Son;
import lombok.Data;

@Data
public class Father {

    private Son son;

    public Father(Son son) {
        this.son = son;
    }

    public void getProxy() {
        System.out.println("===给介绍===");
        son.getMarried();
        System.out.println("===成家百年===");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Test

package com.maggie.demo.proxy.quiet.client;

import com.maggie.demo.proxy.quiet.pojo.Son;
import com.maggie.demo.proxy.quiet.proxy.Father;

public class DemoTest {

    public static void main(String[] args) {

        Father father = new Father(new Son());
        father.getProxy();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

结果

load mybatis-log agent success.
===给介绍===
儿子要成家===
===成家百年===

Process finished with exit code 0
1
2
3
4
5
6

动态代理

1，JDK实现方式

eg:婚介所案例

customer客户类

package com.maggie.demo.proxy.dynamic.pojo;

import com.maggie.demo.proxy.quiet.pojo.Person;

/**
 * 单身客户类
 */
public class Customer implements Person {

    @Override
    public void getMarried() {
        System.out.println("家里有钱");
        System.out.println("要白富美");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

动态代理类

package com.maggie.demo.proxy.dynamic.proxy;

import com.maggie.demo.proxy.quiet.pojo.Son;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JDKMeipo implements InvocationHandler {

    //被代理的对象，把引用保存下来
   private Object target;
   public Object  getInterFace (Object target) throws  Exception{
       this.target=target;
       Class<?> aClass = target.getClass();
       return Proxy.newProxyInstance(aClass.getClassLoader(),aClass.getInterfaces(),this);
   }


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

        before();
        Object invoke = method.invoke(this.target, args);
        after();

        return invoke;
    }


    //前置增强方法
    private void before(){
        System.out.println("婚介所开始介绍");
    }

    //后置增强方法
    private void after(){
        System.out.println("合适，开始结婚");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

测试类

package com.maggie.demo.proxy.dynamic.client;

import com.maggie.demo.proxy.dynamic.pojo.Customer;
import com.maggie.demo.proxy.dynamic.proxy.JDKMeipo;
import com.maggie.demo.proxy.quiet.pojo.Person;

public class DemoTest {
    public static void main(String[] args) throws Exception{
        Person person = (Person)new JDKMeipo().getInterFace(new Customer());
        person.getMarried();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

结果

load mybatis-log agent success.
婚介所开始介绍
家里有钱
要白富美
合适，开始结婚

Process finished with exit code 0
1
2
3
4
5
6
7

原理

jdk动态代理采用字节重组，重新生成对象来代替原始对象，以达到动态代理的目的。

jdk动态代理生成对象的步骤

1. 获取被代理对象的引用，并且获取它的所有接口，反射获取。
2. jdk动态代理类重新生成一个新的类，同时新的类要实现被代理类实现的所有接口。
3. 动态生成java代码，新加的业务逻辑方法由一定的逻辑代码调用。
4. 编译新生成的Java代码.class文件。
5. 重新加载到jvm中运行。

2，CGLIB实现动态代理

沿用以上实例，重新实现

客户类Customer

package com.maggie.demo.proxy.dynamic.waybycglib.pojo;

public class Customer {
    public void getMarried() {
        System.out.println("要白富美");
    }
}
1
2
3
4
5
6
7

CglibMeipo类

package com.maggie.demo.proxy.dynamic.waybycglib.proxy;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;


public class CglibMeipo implements MethodInterceptor {

    public Object  getInterFace (Class<?> clazz) throws  Exception{
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();

    }

    //前置增强方法
    private void before(){
        System.out.println("婚介所开始介绍");
    }

    //后置增强方法
    private void after(){
        System.out.println("合适，开始结婚");
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object invoke = methodProxy.invokeSuper(o, objects);
        after();
        return invoke;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

Test类

package com.maggie.demo.proxy.dynamic.waybycglib.client;

import com.maggie.demo.proxy.dynamic.waybycglib.pojo.Customer;
import com.maggie.demo.proxy.dynamic.waybycglib.proxy.CglibMeipo;

public class Test {
    public static void main(String[] args)throws Exception{
        Customer interFace =(Customer)new CglibMeipo().getInterFace(Customer.class);
        interFace.getMarried();
    }
}
1
2
3
4
5
6
7
8
9
10
11

结果

load mybatis-log agent success.
婚介所开始介绍
要白富美
合适，开始结婚

Process finished with exit code 0
1
2
3
4
5
6

总结一下

cgLib和jdk

1. jdk动态代理实现了被代理对象的接口，CGLib代理继承了被代理对象。
2. jdk动态代理和cGlib代理都在运行期生成字节码，jdk动态代理直接写Class字节码。CGLib代理使用ASM框架写Class字节码，实现更复杂，生成代理类效率更低。
3. jdk动态代理调用代理方法是通过反射机制调用的。
   cglib代理是通过FastClass机制直接调用方法的，执行效率更高。

静态代理和动态代理的本质区别

1. 静态代理只能通过手动完成代理操作，如果被代理类增加了新方法，代理类需要同步增加，违背开闭原则。
2. 动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则。
3. 若动态代理要对目标类的增强逻辑进行扩展，结合策略模式，只需要新增策略类便可完成，无需修改代理类的代码。

代理模式优缺点

优点：

1. 代理模式能将代理对象与真是被调用的目标对象分离。
2. 在一定程度上降低了系统耦合性，扩展性好。
3. 可以起到保护目标对象的作用。
4. 可以增强目标对象功能。

缺点：

1. 代理模式会造成系统设计中类的数量增加。
2. 在客户端和目标对象中增加一个代理对象，会导致请求处理速度变慢。
3. 增加了系统的复杂度。