装饰器模式

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

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;}@Overridepublic int size() {return this.delegate.size();}@Overridepublic boolean isEmpty() {return this.delegate.isEmpty();}@Overridepublic boolean contains(Object o) {return this.delegate.contains(o);}@Overridepublic Iterator<E> iterator() {return  this.delegate.iterator();}@Overridepublic Object[] toArray() {return this.delegate.toArray();}@Overridepublic <T> T[] toArray(T[] a) {return this.delegate.toArray(a);}@Overridepublic boolean add(E s) {return this.delegate.add(s);}@Overridepublic boolean remove(Object o) {boolean result=false;if( this.delegate.contains(o)){this.removeList.add((E) o);this.delegate.remove(o);}return result;}@Overridepublic boolean containsAll(Collection<?> c) {return this.delegate.containsAll(c);}@Overridepublic boolean addAll(Collection<? extends E> c) {return this.delegate.addAll(c);}@Overridepublic boolean retainAll(Collection<?> c) {return this.delegate.retainAll(c);}@Overridepublic boolean removeAll(Collection<?> c) {return this.delegate.removeAll(c);}@Overridepublic void clear() {this.delegate.clear();}@Overridepublic 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;}@Overridepublic 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; // 重置读取位置}@Overridepublic 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 方法，确保完整计数@Overridepublic int read() throws IOException {readCount++;return target.read();}@Overridepublic int read(byte[] b) throws IOException {readCount++;return target.read(b);}@Overridepublic int read(byte[] b, int off, int len) throws IOException {readCount++;return target.read(b, off, len);}@Overridepublic void close() throws IOException {target.close();}// 可选：重写其他需要委托的方法（如 available()、skip() 等）@Overridepublic 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()); // 输出 3counterStream.close();}
}

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

4.1 map是在什么时候生成的

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

@RestController
@RequestMapping("/")
public class WebController {@PostMappingpublic 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;@Overridepublic boolean supportsParameter(MethodParameter parameter) {return  parameter.hasParameterAnnotation(TimestampResponseBody.class);}@Overridepublic 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.configurers提供的方法，查看this.configurers的具体类型。

发现DelegatingWebMvcConfiguration利用了装饰器模式，并且仔细查看发现该类中的configures是通过外部注入的方式(可以作为突破口，自定义这个WebMvcConfigurers并注入容器中)。然后查看configurers的addArgumentResolvers()方法
在这里插入图片描述

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

@Component
public class MyWebMvcConfigure implements WebMvcConfigurer {@Overridepublic 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;}@Overridepublic boolean supportsParameter(MethodParameter parameter) {return  parameter.hasParameterAnnotation(TimestampResponseBody.class);}@Overridepublic 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 {@Resourceprivate ApplicationContext applicationContext;@Overridepublic void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {resolvers.add(new TimestampBodyMethodProcessor(applicationContext));}
}