日日操夜夜添-日日操影院-日日草夜夜操-日日干干-精品一区二区三区波多野结衣-精品一区二区三区高清免费不卡

1 簡介

裝飾器模式是一種結(jié)構(gòu)型設(shè)計(jì)模式，它允許在運(yùn)行時(shí)動(dòng)態(tài)地?cái)U(kuò)展對象的行為，不用修改原始對象的代碼。它通過將對象包裝在一個(gè)包裝器類中來實(shí)現(xiàn)這一點(diǎn)，該包裝器類具有與原始對象相同的接口，并且在委托給原始對象之前或之后添加額外的行為。

裝飾器模式通常用于以下兩種情況：

• 當(dāng)需要在不修改現(xiàn)有代碼的情況下添加新功能或修改現(xiàn)有功能時(shí)。
• 當(dāng)需要使用許多獨(dú)立的擴(kuò)展來實(shí)現(xiàn)不同的組合時(shí)。

2 裝飾器模式的實(shí)現(xiàn)

我們通過一個(gè)示例來看看它是如何實(shí)現(xiàn)的。在下面的示例中，我們將實(shí)現(xiàn)一個(gè)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啟發(fā)而來的。這個(gè)集合只是將其所有方法調(diào)用委托給底層委托對象，這是一種組合關(guān)系。委托是指我們將所有的調(diào)用都派發(fā)到底層對象進(jìn)行處理，而在處理之前可以修改其行為。現(xiàn)在，我們可以繼承這個(gè)類并覆蓋任何方法以修改它們的行為，就像我們在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方法的行為。對于每個(gè)add，我們從信號量中獲取一個(gè)許可。對于每個(gè)remove，我們添加一個(gè)許可。由于在這里使用的是不可擴(kuò)展的同步集合，因此實(shí)現(xiàn)有點(diǎn)簡單，但是您可以理解其思想。要使用這個(gè)類，請執(zhí)行以下操作：

Set<Integer> set = new BoundedSet<>(10);

3 在Spring中使用裝飾器的例子

在Spring中，裝飾器大量用于在進(jìn)入對象之前攔截對它們的調(diào)用。在我們的情況下，我們必須解決Java中線程切換時(shí)在兩個(gè)線程之間傳輸MDC的棘手問題。MDC是一種在日志記錄期間傳輸上下文信息的機(jī)制，例如請求ID或用戶ID等信息。我們通過裝飾相應(yīng)執(zhí)行器服務(wù)的submit方法來解決這個(gè)問題，以獲取調(diào)用線程的MDC，將其復(fù)制到當(dāng)前線程的MDC（在runnable內(nèi)部），然后將調(diào)用派發(fā)到底層委托。以下是代碼：

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) {
        //獲取當(dāng)前線程的MDC
        Map<String, String> mdc = MDC.METADATA.get();
        return () -> {
            MDC.METADATA.set(mdc);
            return task.call();
        };
    }

    private Runnable decorateTask(Runnable task) {
        //獲取當(dāng)前線程的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);
    }
}