设计模式-2 结构型模式

news2025/7/24 5:12:10

一、代理模式

1、举例

海外代购

2、代理基本结构图

3、静态代理

1、真实类实现一个接口，代理类也实现这个接口。

2、代理类通过真实对象调用真实类的方法。

4、静态代理和动态代理的区别

1、静态代理在编译时就已经实现了，编译完成后代理类是一个实际的class文件。

2、动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，再加载到JVM中。

5、JDK动态代理实现

核心：构造代理对象，按JDK要求获取参数，让JDK生成代理对象。
// 生成代理对象 - 核心
Dinner proxy = (Dinner) Proxy.newProxyInstance(classLoader, interfaces, h);

package allwe.testProxy;

/**
 * 定义一个晚餐接口
 */
public interface Dinner {

    void eat(String foodName);

    void drink(String juiceName);
}

package allwe.testProxy;

import lombok.Data;

/**
 * 定义人 - 实现晚餐接口
 */
@Data
public class Person implements Dinner {

    private String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public void eat(String foodName) {
        System.out.println(this.name + "吃" + foodName);
    }

    @Override
    public void drink(String juiceName) {
        System.out.println(this.name + "喝" + juiceName);
    }
}

package allwe.testProxy;

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

/**
 * 我的调用处理器 - 设定增强规则
 */
public class MyInvocationHandler implements InvocationHandler {

    private final Dinner dinner;

    public MyInvocationHandler(Dinner dinner) {
        this.dinner = dinner;
    }

    /**
     * 定义增强规则
     *
     * Object proxy     代理对象
     * Method method    被代理的方法
     * Object[] args    被代理方法运行时的实参
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        if (method.getName().equals("eat")) {
            System.out.println("前置增强===================饭前洗手");
            // 运行eat方法
            method.invoke(dinner, args);
            System.out.println("后置增强===================饭后洗碗");
        } else if (method.getName().equals("drink")) {
            System.out.println("前置增强===================打开瓶盖");
            // 运行eat方法
            method.invoke(dinner, args);
            System.out.println("后置增强===================关上瓶盖");
        } else {
            return method.invoke(dinner, args);
        }
        return null;
    }
}

package allwe.testProxy;

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

/**
 * 动态代理实现
 */
public class TestProxy {

    // 通过Proxy动态代理获取一个代理对象，在代理对象中，对某个方法增强
    public static void main(String[] args) {

        // 创建一个人 - 张三
        Dinner dinner = new Person("张三");

        // 被代理对象的类加载器
        ClassLoader classLoader = dinner.getClass().getClassLoader();
        // 被代理对象所实现的所有接口
        Class<?>[] interfaces = dinner.getClass().getInterfaces();
        // 执行处理器对象 - 专门用于定义增强的规则的
        InvocationHandler h = new MyInvocationHandler(dinner);

        // 生成代理对象 - 核心
        Dinner proxy = (Dinner) Proxy.newProxyInstance(classLoader, interfaces, h);

        // 使用代理对象调用Dinner接口的方法
        proxy.eat("馒头");
        proxy.drink("可乐");
    }
}

6、Cglib动态代理实现

核心：构造代理对象，按CGLIB要求获取参数，让CGLIB生成代理对象。

// 1.创建一个Enhancer对象
Enhancer enhancer = new Enhancer();
// 2.设置真实对象的类
enhancer.setSuperclass(personClass);
// 3.设置增强逻辑
enhancer.setCallback(methodInterceptor);
// 4.创建代理对象
Person personProxy = (Person) enhancer.create();

package allwe.testCGLib;

import lombok.Data;

/**
 * 定义人
 */
@Data
public class Person {

    private String name;

    // Cglib使用这个构造器创建真实对象
    public Person() {
        this.name = "张三";
    }

    public void eat(String foodName){
        System.out.println(this.name + "吃" + foodName);
    }
}

package allwe.testCGLib;

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

import java.lang.reflect.Method;

/**
 * 我的方法拦截器 - 定义方法拦截规则
 */
public class MyMethodInterceptor implements MethodInterceptor {

    /**
     * Object o                    生成之后的代理对象
     * Method method               父类中原本要执行的方法
     * Object[] objects            方法在被调用时接收的实参
     * MethodProxy methodProxy     子类中重写的  父类方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("==========前置增强==========");

        // 执行子类对象方法   -->  son.super.method(args)
        Object res = methodProxy.invokeSuper(o, objects);

        System.out.println("==========后置增强==========");
        return res;
    }
}

package allwe.testCGLib;

import org.junit.jupiter.api.Test;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;

public class TestCglib {

    @Test
    public void testCglib() {
        // 获取被代理的类
        Class<? extends Person> personClass = Person.class;
        // 定义增强规则
        MethodInterceptor methodInterceptor = new MyMethodInterceptor();

        // 获取一个Person的代理对象
        // 1.创建一个Enhancer对象
        Enhancer enhancer = new Enhancer();
        // 2.设置真实对象的类
        enhancer.setSuperclass(personClass);
        // 3.设置增强逻辑
        enhancer.setCallback(methodInterceptor);
        // 4.创建代理对象
        Person personProxy = (Person) enhancer.create();

        // 使用代理对象执行方法
        personProxy.eat("米饭");
    }
}