装饰器模式

参考 装饰者模式
【设计模式实战】装饰器模式

1. HistorySet的例子

HistorySet 可以在实现的Set的基础上，在remove时保留删除的元素。通过将方法委托给现有的Set，在remove时先保留被删除元素后委托给注入的set进行remove

public class HistorySet<E>  implements Set<E> {
    private final List<E> removeList=new ArrayList<>();
    private final Set<E> delegate;

    public HistorySet(Set<E> set){
        this.delegate=set;

    }

    @Override
    public int size() {
        return this.delegate.size();
    }

    @Override
    public boolean isEmpty() {
        return this.delegate.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        return this.delegate.contains(o);
    }

    @Override
    public Iterator<E> iterator() {
        return  this.delegate.iterator();
    }

    @Override
    public Object[] toArray() {
        return this.delegate.toArray();
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return this.delegate.toArray(a);
    }

    @Override
    public boolean add(E s) {
        return this.delegate.add(s);
    }

    @Override
    public boolean remove(Object o) {
        boolean result=false;
        if( this.delegate.contains(o)){
            this.removeList.add((E) o);
            this.delegate.remove(o);
        }
        return result;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return this.delegate.containsAll(c);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        return this.delegate.addAll(c);
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return this.delegate.retainAll(c);
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return this.delegate.removeAll(c);
    }

    @Override
    public void clear() {
        this.delegate.clear();

    }

    @Override
    public String toString() {
        return "HistorySet{" +
                "removeList=" + removeList +
                ", delegate=" + delegate +
                '}';
    }


    public static void main(String[] args) {
        HistorySet<String> historySet = new HistorySet<>(new HashSet<>());
        historySet.add("age");
        historySet.add("sex");
        historySet.add("interest");
        historySet.remove("sex");
        for (String s : historySet.removeList) {
            System.out.println(s);
        }


        System.out.println(historySet.toString());

        Collection<Object> objects = Collections.synchronizedCollection(new ArrayList<>());
        //不是原子操作
        if(objects.isEmpty()){
            objects.add(1);
        }


    }
}

2. BufferInputStream

2.1 原始的读取文件的代码

由于采用fileInputStream.read()一个一个字节读入，每次读入都要重新启动IO操作，费时费力。

public class MyFile {
    public static void main(String[] args) {
        File file = new File(MyFile.class.getClassLoader().getResource("test.pdf").getPath());
        long l = Instant.now().toEpochMilli();
        try (InputStream fileInputStream=new FileInputStream(file)){
            while (true){
                int read = fileInputStream.read();
                if(read== -1){
                    break;
                }
            }
            System.out.println("用时:"+(Instant.now().toEpochMilli()-l)+"毫秒");

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

2.2 增强后的代码

因此，可以采用装饰器模式，在原有的FileInputStream的read()方法上，为 FileInputStream 添加了缓冲功能，显著提升了读取效率

public class BufferInputStream extends InputStream {

    private final byte[] buffer = new byte[8192]; // 缓冲区
    private int position;       // 当前读取位置
    private int count;          // 缓冲区有效数据长度
    private final FileInputStream fileInputStream;

    public BufferInputStream(FileInputStream fileInputStream) {
        this.fileInputStream = fileInputStream;
    }

    @Override
    public int read() throws IOException {
        // 如果缓冲区已读完，尝试填充
        if (position >= count) {
            fillBuffer();
            if (count == -1) {
                return -1; // 流已结束
            }
        }
        // 返回缓冲区的下一个字节（转换为 0~255）
        return buffer[position++] & 0xFF;
    }

    /**
     * 从底层 FileInputStream 填充缓冲区
     */
    private void fillBuffer() throws IOException {
        count = fileInputStream.read(buffer); // 读取数据到缓冲区
        position = 0; // 重置读取位置
    }

    @Override
    public void close() throws IOException {
        fileInputStream.close(); // 关闭底层流
        super.close();
    }

    public static void main(String[] args) {
        String filePath = BufferInputStream.class.getClassLoader().getResource("a.txt").getPath(); // 替换为你的文件路径
        try (
                // 1. 创建底层文件流
                FileInputStream fis = new FileInputStream(filePath);
                // 2. 包装为缓冲流
                BufferInputStream bis = new BufferInputStream(fis)
        ) {
            int byteData;
            // 3. 逐字节读取文件内容
            while ((byteData = bis.read()) != -1) {
                // 处理字节数据（例如打印字符）
                System.out.print((char) byteData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. ReadCounterInputStream

通过装饰器模式，记录inputStream当前调用过多少次read(方法

public class ReadCounterInputStream extends InputStream {
    private final InputStream target;  // 被装饰的输入流
    private int readCount = 0;         // 记录 read() 调用次数

    public ReadCounterInputStream(InputStream target) {
        this.target = target;
    }

    // 获取当前 read() 方法调用次数
    public int getReadCount() {
        return readCount;
    }

    // 重写所有 read 方法，确保完整计数
    @Override
    public int read() throws IOException {
        readCount++;
        return target.read();
    }

    @Override
    public int read(byte[] b) throws IOException {
        readCount++;
        return target.read(b);
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        readCount++;
        return target.read(b, off, len);
    }

    @Override
    public void close() throws IOException {
        target.close();
    }

    // 可选：重写其他需要委托的方法（如 available()、skip() 等）
    @Override
    public int available() throws IOException {
        return target.available();
    }


    public static void main(String[] args) throws IOException {
        // 原始输入流（这里以字节数组流为例）
        InputStream rawStream = new ByteArrayInputStream("Hello World".getBytes());

        // 包装为计数装饰器
        ReadCounterInputStream counterStream = new ReadCounterInputStream(rawStream);

        // 读取操作
        counterStream.read();                   // 单字节读取
        counterStream.read(new byte[10], 0, 3); // 带偏移量的读取

        System.out.println("Total read() calls: " + counterStream.getReadCount()); // 输出 3
        counterStream.close();
    }
}

4. 自定义注解，Map 自动加入事件戳

4.1 map是在什么时候生成的

关键是要弄清楚map是在什么时候生成的。

@RestController
@RequestMapping("/")
public class WebController {

    @PostMapping
    public Map<String, String> test(@RequestResponseBody  Map<String,String> map){
        return map;
    }
}

在return map语句打断点进行调试。发现调用this.resolvers.resolveArgument后生成了Map对象.

查看this.resolvers的具体类型：发现this.resolvers是 HandlerMethodArgumentResolverComposite类对象，

其中，HandlerMethodArgumentResolverComposite实现了HandlerMethodArgumentResolver接口，并且有类成员List<HandlerMethodArgumentResolver>。毫无疑问，这里利用了装饰者模式，在增强代码的职责后，将底层的代码委托给这些List中类成员实现。（因此我们可以有这样一个印象，Composite中装入许多同类性的对象，必要时将方法委托给它们实现，而这些委托对象又层层委托给底下的委托对象实现，因此到看到某一层的委托就可以了）

进入 HandlerMethodArgumentResolver类的resolveArgument()方法体中

发现该方法首先先择合适的解析器resolver，然后委托其实现resolver.resolveArgument()后生成了args[i]。这个方法的核心就是如何先择合适的解析器resolver。
因此接下来我们主要分为两步骤，查看getArgumentResolve()和断点调试解析到的具体的resolver类型查看其是如何实现的。

4.11 查看getArgumentResolve()方法体

发现主要是利用resolver.supportsParameter(parameter)选择合适的解析器。

4.12 查看resolver的具体类型

在return result 打上断点，可以看见result解析器类型为RequestResponseBodyMethodProcessor。查看其源码：

由于 HandlerMethodArgumentResolver resolver = this.getArgumentResolver(parameter);使用HandlerMethodArgumentResolver 接收，因此只需查看HandlerMethodArgumentResolver接口中的方法。

会发现这里用到了RequestBody.class。点击进入该注解：

原来我们使用的@RequestBody注解在这里使用到了，因此，我们可以定义一个HandlerMethodArgumentResolve类, 在遇到自定义注解时，supportsParam()方法返回true,就可以调用自定义的解析器的resolve方法，只要我们在resolve()生成实例时加入时间戳就可以了。

因此我们可以自定义一个HandlerMethodArgumentResolver类,当遇到参数上有@TimestampResponseBody返回true,即可选中该解析对象，在调用解析对象resolve后在map中加入时间戳就可以了。最后只要可以将其放入HandlerMethodArgumentResolverComposite的List<HandlerMethodArgumentResolver>中就可以了。

模仿RequestResponseBodyMethodProcessor类，写出自定义的类。为了能够简化代码，可以利用装饰器模式定义自定义解析器

public class TimestampBodyMethodProcessor implements HandlerMethodArgumentResolver {

    private  RequestResponseBodyMethodProcessor processor;


    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return  parameter.hasParameterAnnotation(TimestampResponseBody.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        Object o = processor.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
        if(!(o instanceof Map<?,?>)){
            return o;
        }
        ((Map) o).put("timestamp","11233333");
        return o;
   }
}

模仿@RequestBody 自定义注解@TimestampResponseBody

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TimestampResponseBody {
}

4.2 在HandlerMethodArgumentResolverComposite中的List中放入自定义解析器

发现原始的argumentResolvers为空，调用addResolver()方法后才加入resolver。在addResolver()打上断点，看时哪个函数调用的。

发现在resolvers = this.getDefaultArgumentResolvers();生成resolvers。

进入resolvers = this.getDefaultArgumentResolvers();

发现在这里预留了加入在resolvers中加入自定义的resolvers的方法即this.getCustomArgumentResolvers()。

进入this.getCustomArgumentResolvers()方法

发现this.customArgumentResolvers通过setCustomArgumentResolvers()方法设置的。因此接下来给该方法打上断点，查看该方法是如何被调用的。

发现resolvers是this.getArgumentResolvers()产生的，进入该方法中

发现实际加入的自定义resolvers是由addArgumentResolvers()产生的。因此继续查看实现的方法。


发现该类也利用了装饰器模式，是调用this.configures的方法进行添加的，并且仔细查看发现该类中的configures是通过外部注入的方式。然后查看该类的addArgumentResolvers()方法，发现

发现addArgumentResolvers()是依次调用this.delegates中每个delegate.addArgumentResolvers(),并且使用该对象时时通过外部注入的方式为this.delegates赋值，
因此我们可以自定义类实现WebMvcConfigurationSupport接口中的
this.configurers.addArgumentResolvers(argumentResolvers)方法，并让该类注入到spring的容器，然后利用装饰器模式，在委托对象加入argumentResolvers之前拦截argumentResolvers,在其中加入自定义的解析器。

@Component
public class MyWebMvcConfigure implements WebMvcConfigurer {

    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(new TimestampBodyMethodProcessor());
    }
}

4.3 获取RequestResponseBodyMethodProcessor

在自定义 HandlerMethodArgumentResolver类中，发现processor没有办法获得。在查看解析器那一部分源码中，我们发现这些解析器都是有系统new出来的，没有交给容器管理，因此，必须采用其它方法获得。在浏览源码中，发现这些new出来的解析器都在 HandlerMethodArgumentResolverComposite的肚子里，因此可以首先获取容器，然后取出该对象，从肚子中获取就可以了。

public class TimestampBodyMethodProcessor implements HandlerMethodArgumentResolver {

    private  RequestResponseBodyMethodProcessor processor;

    private ApplicationContext applicationContext;
    public TimestampBodyMethodProcessor(ApplicationContext applicationContext){
        this.applicationContext=applicationContext;
    }

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return  parameter.hasParameterAnnotation(TimestampResponseBody.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        setupProcessor();
        Object o = processor.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
        if(!(o instanceof Map<?,?>)){
            return o;
        }
        ((Map) o).put("timestamp","11233333");
        return o;
    }

    private void setupProcessor() {
        if(this.processor ==null){
            RequestMappingHandlerAdapter bean = this.applicationContext.getBean(RequestMappingHandlerAdapter.class);
            List<HandlerMethodArgumentResolver> argumentResolvers = bean.getArgumentResolvers();
            for(HandlerMethodArgumentResolver argumentResolver:argumentResolvers){
                if(argumentResolver instanceof  RequestResponseBodyMethodProcessor){
                    this.processor= (RequestResponseBodyMethodProcessor) argumentResolver;
                    return;
                }
            }
        }

    }
}

@Component
public class MyWebMvcConfigure implements WebMvcConfigurer {
    @Resource
    private ApplicationContext applicationContext;


    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(new TimestampBodyMethodProcessor(applicationContext));
    }
}