在Java架构中，设计模式是解决特定问题的成熟解决方案，它们可以帮助设计更加清晰、灵活和可维护的代码。以下是五种常用的设计模式，它们在不同的架构场景中的应用：

1. 单例模式（Singleton）

使用场景：当系统中需要确保某个类有且只有一个实例，并且需要全局访问点时，例如，配置管理类或连接池。

架构应用：在多数应用程序中，特别是Web应用中，用于数据库连接池、线程池的管理或配置设置等。

代码示例：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2. 工厂方法模式（Factory Method）

使用场景：当存在一个超类，并有多个子类，并且在运行时想决定使用哪个子类时。例如，不同类型的支付方式处理。

架构应用：在需要灵活地加入新类型对象而不影响客户端的系统中。如在电商系统中，根据不同的支付方式生成不同的支付处理对象。

代码示例：

public interface Payment {
    void pay();
}

public class CreditCardPayment implements Payment {
    @Override
    public void pay() {
        System.out.println("Paying with credit card.");
    }
}

public class PaymentFactory {
    public static Payment getPayment(String paymentType){
        if ("CREDIT".equals(paymentType)) {
            return new CreditCardPayment();
        } else {
            throw new IllegalArgumentException("Unknown payment type");
        }
    }
}

3. 建造者模式（Builder）

使用场景：用于构造一个复杂对象，同时避免构造函数过多。例如，创建一个包含多个可选参数的对象。

架构应用：在需要生成复杂对象的系统中，如文档编辑器中构建复杂文档，或者在RESTful API中构造复杂的响应对象。

代码示例：

public class Product {
    private final String partA;
    private final String partB;

    private Product(Builder builder) {
        this.partA = builder.partA;
        this.partB = builder.partB;
    }

    public static class Builder {
        private String partA;
        private String partB;

        public Builder partA(String partA) {
            this.partA = partA;
            return this;
        }

        public Builder partB(String partB) {
            this.partB = partB;
            return this;
        }

        public Product build() {
            return new Product(this);
        }
    }
}

4. 观察者模式（Observer）

使用场景：当一个对象状态的改变需要自动通知其他对象时。例如，用户界面元素自动更新。

架构应用：在事件驱动系统中，如GUI工具包或消息处理系统。

代码示例：

import java.util.ArrayList;
import java.util.List;

public class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

public interface Observer {
    void update();
}

public class ConcreteObserver implements Observer {
    @Override
    public void update() {
        System.out.println("Observer notified");
    }
}

5. 策略模式（Strategy）

使用场景：当你想使用不同的算法或策略来完成某个特定任务，同时希望能够在运行时更改算法或策略时。例如，不同的排序或压缩算法。

架构应用：在需要根据不同条件执行不同逻辑的系统中，如文本渲染器中根据用户的选择使用不同的渲染策略。

代码示例：

public interface Strategy {
    void execute();
}

public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy A");
    }
}

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

对于图片解释，由于当前环境不支持图形化内容直接显示，建议查阅相关设计模式的文献或在线资源，这些通常包含各种设计模式的UML类图和序列图，这些图形化内容能帮助更好地理解各个设计模式的结构和工作原理。