其他
详解Java中的装饰器
本文介绍装饰器模式，并通过示例来阐述装饰器模式的实现方法和在Spring中使用装饰器，希望对读者了解装饰器有所帮助。
1 简介
装饰器模式是一种结构型设计模式，它允许在运行时动态地扩展对象的行为，不用修改原始对象的代码。它通过将对象包装在一个包装器类中来实现这一点，该包装器类具有与原始对象相同的接口，并且在委托给原始对象之前或之后添加额外的行为。
装饰器模式通常用于以下两种情况：
当需要在不修改现有代码的情况下添加新功能或修改现有功能时。 当需要使用许多独立的扩展来实现不同的组合时。
2 装饰器模式的实现
我们通过一个示例来看看它是如何实现的。在下面的示例中，我们将实现一个BoundedSet——Java中大小限制的集合。
public abstract class ForwardingSet<T> implements Set<T> {
public abstract Set<T> delegate();
@Override
public int size() {
return delegate().size();
}
@Override
public boolean isEmpty() {
return delegate().isEmpty();
}
@Override
public boolean contains(Object o) {
return delegate().contains(o);
}
@Override
public Iterator<T> iterator() {
return delegate().iterator();
}
@Override
public Object[] toArray() {
return delegate().toArray();
}
@Override
public <T1> T1[] toArray(T1[] a) {
return delegate().toArray(a);
}
@Override
public boolean add(T t) {
return delegate().add(t);
}
@Override
public boolean remove(Object o) {
return delegate().remove(o);
}
@Override
public boolean containsAll(Collection<?> c) {
return delegate().containsAll(c);
}
@Override
public boolean addAll(Collection<? extends T> c) {
return delegate().addAll(c);
}
@Override
public boolean retainAll(Collection<?> c) {
return delegate().retainAll(c);
}
@Override
public boolean removeAll(Collection<?> c) {
return delegate().removeAll(c);
}
@Override
public void clear() {
delegate().clear();
}
}
ForwardingSet是受Google Guava库中的ForwardingSet启发而来的。这个集合只是将其所有方法调用委托给底层委托对象，这是一种组合关系。委托是指我们将所有的调用都派发到底层对象进行处理，而在处理之前可以修改其行为。现在，我们可以继承这个类并覆盖任何方法以修改它们的行为，就像我们在BoundedSet中所做的那样。
@ThreadSafe
public class BoundedSet<T> extends ForwardingSet<T> {
private Set<T> set;
private Semaphore semaphore;
public BoundedSet(int bound) {
this.semaphore = new Semaphore(bound);
this.set = Collections.synchronizedSet(new HashSet<>());
}
@Override
public boolean add(T t) {
try {
semaphore.acquire();
boolean wasAdded = super.add(t);
if (!wasAdded) {
semaphore.release();
}
return wasAdded;
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
@Override
public boolean remove(Object o) {
boolean wasRemoved = super.remove(o);
if (wasRemoved) {
semaphore.release();
}
return wasRemoved;
}
@Override
public boolean addAll(Collection<? extends T> c) {
try {
boolean setChanged = false;
for(var e : c) {
semaphore.acquire();
boolean wasAdded = super.add(e);
if(!wasAdded) {
semaphore.release();
}
setChanged |= wasAdded;
}
return setChanged;
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
@Override
public boolean removeAll(Collection<?> c) {
boolean setChanged = false;
for(var e : c) {
boolean wasRemoved = super.remove(e);
if(wasRemoved) {
semaphore.release();
}
setChanged |= wasRemoved;
}
return setChanged;
}
@Override
public Set<T> delegate() {
return this.set;
}
}
在这里，我们修改了add、remove、addAll和removeAll方法的行为。对于每个add，我们从信号量中获取一个许可。对于每个remove，我们添加一个许可。由于在这里使用的是不可扩展的同步集合，因此实现有点简单，但是您可以理解其思想。要使用这个类，请执行以下操作：
Set<Integer> set = new BoundedSet<>(10);
3 在Spring中使用装饰器的例子
在Spring中，装饰器大量用于在进入对象之前拦截对它们的调用。在我们的情况下，我们必须解决Java中线程切换时在两个线程之间传输MDC的棘手问题。MDC是一种在日志记录期间传输上下文信息的机制，例如请求ID或用户ID等信息。我们通过装饰相应执行器服务的submit方法来解决这个问题，以获取调用线程的MDC，将其复制到当前线程的MDC（在runnable内部），然后将调用派发到底层委托。以下是代码：
ForwardedExecutorService.java
public abstract class ForwardedExecutorService implements ExecutorService {
public abstract ExecutorService delegate();
@Override
public void shutdown() {
delegate().shutdown();
}
@Override
public List<Runnable> shutdownNow() {
return delegate().shutdownNow();
}
@Override
public boolean isShutdown() {
return delegate().isShutdown();
}
@Override
public boolean isTerminated() {
return delegate().isTerminated();
}
@Override
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
return delegate().awaitTermination(timeout, unit);
}
@Override
public <T> Future<T> submit(Callable<T> task) {
return delegate().submit(task);
}
@Override
public <T> Future<T> submit(Runnable task, T result) {
return delegate().submit(task, result);
}
@Override
public Future<?> submit(Runnable task) {
return delegate().submit(task);
}
@Override
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
return delegate().invokeAll(tasks);
}
@Override
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException {
return delegate().invokeAll(tasks, timeout, unit);
}
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
return delegate().invokeAny(tasks);
}
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
return delegate().invokeAny(tasks, timeout, unit);
}
@Override
public void execute(Runnable command) {
delegate().execute(command);
}
}
MDCAwareExecutorService.java
public class MDCAwareExecutorService extends ForwardedExecutorService {
private ExecutorService es;
public MDCAwareExecutorService() {
this.es = Executors.newCachedThreadPool();
}
@Override
public ExecutorService delegate() {
return this.es;
}
@Override
public <T> Future<T> submit(Callable<T> task) {
return super.submit(decorateTask(task));
}
@Override
public <T> Future<T> submit(Runnable task, T result) {
return super.submit(decorateTask(task), result);
}
@Override
public Future<?> submit(Runnable task) {
return super.submit(decorateTask(task));
}
@Override
public void execute(Runnable command) {
super.execute(decorateTask(command));
}
private <V> Callable<V> decorateTask(Callable<V> task) {
//获取当前线程的MDC
Map<String, String> mdc = MDC.METADATA.get();
return () -> {
MDC.METADATA.set(mdc);
return task.call();
};
}
private Runnable decorateTask(Runnable task) {
//获取当前线程的MDC
Map<String, String> mdc = MDC.METADATA.get();
return () -> {
MDC.METADATA.set(mdc);
task.run();
};
}
}
MDC.java
public class MDC {
public static ThreadLocal<Map<String, String>> METADATA = new ThreadLocal<>();
}
Driver.java
public class Driver {
public static void main(String[] args) throws InterruptedException {
MDC.METADATA.set(Map.of("k1","v1","k2","v2"));
var es = new MDCAwareExecutorService();
es.submit(() -> {
System.out.println("Thread: " + Thread.currentThread().getName() + ", MDC: " + MDC.METADATA.get());;
});
Thread.sleep(Integer.MAX_VALUE);
}
}
推荐书单
《Java编程讲义》
《Java编程讲义》根据目前Java开发领域的实际需求，从初学者角度出发，详细讲解了Java技术的基础知识。全书共15章，包括Java开发入门，Java语言基础，Java控制结构，数组，面向对象编程，继承和多态，抽象类、接口和内部类，异常处理，Java常用类库，集合与泛型，Lambda表达式，输入-输出流，多线程，JDBC数据库技术，网络编程等内容。内容全面覆盖．1ava开发必备的基础知识点，结合生活化案例展开讲解，程序代码给出了详细的注释，能够使初学者轻松领会Java技术精髓，快速掌握Java开发技能。 《Java编程讲义》适合作为高等院校相关专业的教材及教学参考书，也适合作为Java开发入门者的自学用书，还可供开发人员查阅、参考。
购买链接：https://item.jd.com/13495830.html
精彩回顾
用好这10个Spring Cloud功能，使用Java轻松开发微服务
长按关注《Java学研大本营》 长按访问【IT今日热榜】，发现每日技术热点