TL课堂- Java架构班第七期（已完结，视频+资料代码）

以下结合 Java 架构设计模式与实战落地场景，提供一些核心代码示例，涵盖设计模式、分布式场景及中间件应用等关键环节：

一、设计模式实战代码

1. 单例模式（线程安全懒加载）

java

运行

/**
 * 单例模式：保证全局唯一实例，适用于配置中心、连接池等场景
 */
public class ConfigCenter {
    // volatile 防止指令重排序
    private static volatile ConfigCenter instance;
    
    // 私有构造器阻止外部实例化
    private ConfigCenter() {
        // 初始化配置加载逻辑
    }
    
    // 双重校验锁实现线程安全懒加载
    public static ConfigCenter getInstance() {
        if (instance == null) {
            synchronized (ConfigCenter.class) {
                if (instance == null) {
                    instance = new ConfigCenter();
                }
            }
        }
        return instance;
    }
    
    // 加载配置示例
    public String getConfig(String key) {
        // 实际场景可能从本地文件或远程配置中心获取
        return "config_" + key;
    }
}

2. 工厂模式（产品实例化封装）

java

运行

/**
 * 工厂模式：封装对象创建逻辑，适用于多类型服务实例化场景
 */
// 支付接口
public interface Payment {
    void pay(double amount);
}

// 支付宝实现
public class Alipay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("支付宝支付：" + amount + "元");
    }
}

// 微信支付实现
public class WechatPay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("微信支付：" + amount + "元");
    }
}

// 支付工厂
public class PaymentFactory {
    public static Payment createPayment(String type) {
        switch (type) {
            case "alipay":
                return new Alipay();
            case "wechat":
                return new WechatPay();
            default:
                throw new IllegalArgumentException("不支持的支付类型");
        }
    }
    
    // 实战调用示例
    public static void main(String[] args) {
        Payment payment = PaymentFactory.createPayment("alipay");
        payment.pay(100.0);
    }
}

3. 观察者模式（事件通知机制）

java

运行

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

/**
 * 观察者模式：实现事件发布-订阅，适用于消息通知、状态同步场景
 */
// 被观察者（主题）
public class OrderSubject {
    private List<OrderObserver> observers = new ArrayList<>();
    
    // 注册观察者
    public void attach(OrderObserver observer) {
        observers.add(observer);
    }
    
    // 移除观察者
    public void detach(OrderObserver observer) {
        observers.remove(observer);
    }
    
    // 通知所有观察者
    public void notifyObservers(String orderId) {
        for (OrderObserver observer : observers) {
            observer.update(orderId);
        }
    }
    
    // 订单创建事件（触发通知）
    public void createOrder(String orderId) {
        System.out.println("订单创建：" + orderId);
        notifyObservers(orderId);
    }
}

// 观察者接口
public interface OrderObserver {
    void update(String orderId);
}

// 库存观察者（订单创建后减库存）
public class InventoryObserver implements OrderObserver {
    @Override
    public void update(String orderId) {
        System.out.println("订单" + orderId + "：库存减少");
    }
}

// 日志观察者（订单创建后记录日志）
public class LogObserver implements OrderObserver {
    @Override
    public void update(String orderId) {
        System.out.println("订单" + orderId + "：日志记录完成");
    }
}

// 实战调用
public class ObserverDemo {
    public static void main(String[] args) {
        OrderSubject orderSubject = new OrderSubject();
        orderSubject.attach(new InventoryObserver());
        orderSubject.attach(new LogObserver());
        orderSubject.createOrder("ORDER_123456");
    }
}

二、分布式场景实战代码

1. 分布式锁（基于 Redis 实现）

java

运行

import redis.clients.jedis.Jedis;
import java.util.Collections;

/**
 * 分布式锁：解决分布式环境下资源竞争问题
 */
public class RedisDistributedLock {
    private static final String LOCK_KEY = "distributed_lock";
    private static final String LOCK_VALUE = "unique_value"; // 唯一值，用于释放锁校验
    private static final int LOCK_EXPIRE = 30000; // 锁超时时间（30秒）
    private Jedis jedis;

    public RedisDistributedLock(Jedis jedis) {
        this.jedis = jedis;
    }

    // 获取锁
    public boolean tryLock() {
        // SET NX（不存在则设置）+ EX（过期时间）：原子操作
        String result = jedis.set(LOCK_KEY, LOCK_VALUE, "NX", "EX", LOCK_EXPIRE);
        return "OK".equals(result);
    }

    // 释放锁（Lua脚本保证原子性）
    public boolean unlock() {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        Object result = jedis.eval(script, Collections.singletonList(LOCK_KEY), Collections.singletonList(LOCK_VALUE));
        return Long.valueOf(1).equals(result);
    }

    // 实战使用示例
    public void doWithLock(Runnable task) {
        if (tryLock()) {
            try {
                task.run(); // 执行需要加锁的业务逻辑
            } finally {
                unlock(); // 确保锁释放
            }
        } else {
            throw new RuntimeException("获取分布式锁失败");
        }
    }
}

2. 服务降级（基于 Sentinel 实现）

java

运行

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;

/**
 * 服务降级：保障系统稳定性，适用于流量峰值或依赖服务故障场景
 */
public class OrderService {

    // 被保护的资源：订单查询
    @SentinelResource(value = "orderQuery", blockHandler = "orderQueryFallback")
    public String queryOrder(String orderId) {
        // 实际业务逻辑：调用订单查询接口
        return "订单信息：" + orderId;
    }

    // 降级兜底方法（限流/熔断时触发）
    public String orderQueryFallback(String orderId, BlockException e) {
        e.printStackTrace();
        return "当前查询人数过多，请稍后重试（orderId: " + orderId + "）";
    }

    // 实战调用
    public static void main(String[] args) {
        OrderService service = new OrderService();
        System.out.println(service.queryOrder("ORDER_123"));
    }
}

三、中间件集成代码

1. 消息队列（RabbitMQ 生产者 / 消费者）

java

运行

import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 消息队列：解耦服务、削峰填谷，适用于异步通信场景
 */
public class RabbitMQDemo {
    private static final String QUEUE_NAME = "order_queue";

    // 生产者：发送订单消息
    public static class Producer {
        public void sendMessage(String message) throws IOException, TimeoutException {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            try (Connection connection = factory.newConnection();
                 Channel channel = connection.createChannel()) {
                // 声明队列（持久化、非排他、非自动删除）
                channel.queueDeclare(QUEUE_NAME, true, false, false, null);
                // 发送消息（持久化消息）
                channel.basicPublish("", QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
                System.out.println("已发送消息：" + message);
            }
        }
    }

    // 消费者：处理订单消息
    public static class Consumer {
        public void startConsume() throws IOException, TimeoutException {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);
            
            // 消费消息
            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println("已接收消息：" + message);
                // 手动确认消息消费完成
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            };
            // 关闭自动确认，开启手动确认
            channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> {});
        }
    }

    // 实战调用
    public static void main(String[] args) throws IOException, TimeoutException {
        Producer producer = new Producer();
        producer.sendMessage("订单创建：ORDER_123456");
        
        Consumer consumer = new Consumer();
        consumer.startConsume();
    }
}

以上代码覆盖了架构设计中常见的设计模式（创建型、行为型）、分布式核心问题（分布式锁、服务降级）及中间件集成（消息队列），可根据实际业务场景扩展。实际架构落地中，需结合具体业务需求、性能要求及团队技术栈进行调整，并注重代码的可扩展性与可维护性。