java设计模式及实例

最新推荐文章于 2026-06-23 21:03:17 发布
原创 最新推荐文章于 2026-06-23 21:03:17 发布 · 822 阅读 · 11 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#java #设计模式 #开发语言

java设计模式及实例

一、创建型模式（5种）

目标：解耦对象的创建与使用。

1. 单例模式（Singleton）

定义：确保一个类只有一个实例，并提供全局访问点。
适用场景：

  • 需要全局唯一对象的场景（如配置管理器、线程池、数据库连接池）。
  • 需要频繁创建销毁但希望节省资源的场景。

代码示例（双重校验锁）：

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
2. 工厂方法模式（Factory Method）

定义：定义一个创建对象的接口，由子类决定实例化哪个类。
适用场景：

  • 需要将对象创建逻辑封装，客户端不依赖具体类。
  • 需要扩展新类型对象时（如日志记录器、数据库连接器）。

代码示例：

interface Product {
    void create();
}

class ConcreteProduct implements Product {
    @Override
    public void create() {
        System.out.println("生产具体产品");
    }
}

abstract class Factory {
    abstract Product createProduct();
}

class ConcreteFactory extends Factory {
    @Override
    Product createProduct() {
        return new ConcreteProduct();
    }
}
3. 抽象工厂模式（Abstract Factory）

定义：提供一个创建一系列相关或依赖对象的接口，无需指定具体类。
适用场景：

  • 需要创建一组相互关联的产品（如跨平台 UI 组件、不同风格的 GUI）。
  • 系统需要独立于产品的创建、组合和表示。

代码示例（跨平台 UI 组件）：

interface Button { void render(); }
interface Checkbox { void check(); }

// Windows 风格组件
class WinButton implements Button {
    public void render() { System.out.println("Windows 按钮"); }
}
class WinCheckbox implements Checkbox {
    public void check() { System.out.println("Windows 复选框"); }
}

// Mac 风格组件
class MacButton implements Button {
    public void render() { System.out.println("Mac 按钮"); }
}
class MacCheckbox implements Checkbox {
    public void check() { System.out.println("Mac 复选框"); }
}

// 抽象工厂接口
interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

class WinFactory implements GUIFactory {
    public Button createButton() { return new WinButton(); }
    public Checkbox createCheckbox() { return new WinCheckbox(); }
}

class MacFactory implements GUIFactory {
    public Button createButton() { return new MacButton(); }
    public Checkbox createCheckbox() { return new MacCheckbox(); }
}
4. 建造者模式（Builder）

定义：分步构建复杂对象，分离构建过程与表示。
适用场景：

  • 对象构造过程复杂（如包含多个可选参数）。
  • 需要生成不同表示的对象（如 HTML 和 PDF 报告）。

代码示例（构建计算机对象）：

class Computer {
    private String cpu;
    private String ram;
    // 其他属性...

    static class Builder {
        private Computer computer = new Computer();
        public Builder setCpu(String cpu) {
            computer.cpu = cpu;
            return this;
        }
        public Builder setRam(String ram) {
            computer.ram = ram;
            return this;
        }
        public Computer build() { return computer; }
    }
}

// 使用
Computer computer = new Computer.Builder()
    .setCpu("Intel i7")
    .setRam("16GB")
    .build();
5. 原型模式（Prototype）

定义：通过复制现有对象创建新对象，减少重复初始化开销。
适用场景：

  • 对象创建成本较高（如数据库查询结果缓存）。
  • 需要动态生成对象副本的场景（如游戏中的角色克隆）。

代码示例：

class Prototype implements Cloneable {
    private String data;
    public Prototype(String data) { this.data = data; }
    @Override
    public Prototype clone() {
        try {
            return (Prototype) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

// 使用
Prototype proto1 = new Prototype("原始数据");
Prototype proto2 = proto1.clone();

二、结构型模式（7种）

目标：处理类与对象的组合关系。

6. 适配器模式（Adapter）

定义：使不兼容接口的类协同工作。
适用场景：

  • 需要复用现有类，但其接口与系统不兼容（如旧系统升级）。
  • 需要统一多个类的接口（如第三方库适配）。

代码示例（对象适配器）：

class LegacyPrinter {
    void printDocument() { System.out.println("旧式打印"); }
}

interface ModernPrinter {
    void print();
}

class PrinterAdapter implements ModernPrinter {
    private LegacyPrinter legacyPrinter;
    public PrinterAdapter(LegacyPrinter printer) {
        this.legacyPrinter = printer;
    }
    public void print() {
        legacyPrinter.printDocument();
    }
}
7. 桥接模式（Bridge）

定义：将抽象与实现分离，使两者独立变化。
适用场景：

  • 需要在抽象和实现间建立动态绑定（如不同数据库驱动）。
  • 需要避免类爆炸（如形状与颜色的组合）。

代码示例（形状与颜色分离）：

interface Color { void applyColor(); }

abstract class Shape {
    protected Color color;
    public Shape(Color color) { this.color = color; }
    abstract void draw();
}

class Circle extends Shape {
    public Circle(Color color) { super(color); }
    void draw() {
        System.out.print("圆形：");
        color.applyColor();
    }
}

class RedColor implements Color {
    public void applyColor() { System.out.println("红色"); }
}
8. 组合模式（Composite）

定义：以树形结构处理对象的部分-整体关系。
适用场景：

  • 需要表示对象的层次结构（如文件系统、菜单树）。
  • 希望客户端统一处理单个对象和组合对象。

代码示例：

interface Component { void operation(); }

class Leaf implements Component {
    public void operation() {
        System.out.println("叶子节点操作");
    }
}

class Composite implements Component {
    private List<Component> children = new ArrayList<>();
    public void add(Component c) { children.add(c); }
    public void operation() {
        for (Component c : children) {
            c.operation();
        }
    }
}
9. 装饰器模式（Decorator）

定义：动态地为对象添加职责。
适用场景：

  • 需要在不修改代码的情况下扩展对象功能（如 Java IO 流）。
  • 需要动态组合多种功能（如咖啡加糖、加牛奶）。

代码示例（咖啡加料）：

interface Coffee {
    double getCost();
    String getDescription();
}

class SimpleCoffee implements Coffee {
    public double getCost() { return 10; }
    public String getDescription() { return "普通咖啡"; }
}

abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;
    public CoffeeDecorator(Coffee coffee) {
        this.decoratedCoffee = coffee;
    }
}

class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) { super(coffee); }
    public double getCost() { return super.getCost() + 2; }
    public String getDescription() {
        return super.getDescription() + ", 加牛奶";
    }
}
10. 外观模式（Facade）

定义：为复杂子系统提供统一入口。
适用场景：

  • 需要简化复杂系统的调用（如启动计算机、电商下单流程）。
  • 需要将子系统与客户端解耦。

代码示例（启动计算机）：

class CPU { void start() { System.out.println("启动CPU"); } }
class Memory { void load() { System.out.println("加载内存"); } }

class ComputerFacade {
    private CPU cpu = new CPU();
    private Memory memory = new Memory();
    void start() {
        cpu.start();
        memory.load();
    }
}

// 使用
ComputerFacade computer = new ComputerFacade();
computer.start();
11. 享元模式（Flyweight）

定义：共享大量细粒度对象，减少内存消耗。
适用场景：

  • 存在大量重复对象（如文本编辑器中的字符对象）。
  • 对象的大部分状态可以外部化。

代码示例（共享树类型）：

class TreeType {
    private String name;
    public TreeType(String name) { this.name = name; }
    void draw(int x, int y) {
        System.out.printf("绘制%s树在(%d,%d)\n", name, x, y);
    }
}

class TreeFactory {
    private static Map<String, TreeType> pool = new HashMap<>();
    public static TreeType getTreeType(String name) {
        if (!pool.containsKey(name)) {
            pool.put(name, new TreeType(name));
        }
        return pool.get(name);
    }
}
12. 代理模式（Proxy）

定义：控制对对象的访问，增强功能（如延迟加载、权限控制）。
适用场景：

  • 需要延迟加载大对象（如图片懒加载）。
  • 需要保护敏感对象（如权限控制代理）。

代码示例（图片代理）：

interface Image { void display(); }

class RealImage implements Image {
    private String filename;
    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk();
    }
    private void loadFromDisk() {
        System.out.println("加载图片：" + filename);
    }
    public void display() {
        System.out.println("显示图片：" + filename);
    }
}

class ProxyImage implements Image {
    private RealImage realImage;
    private String filename;
    public ProxyImage(String filename) { this.filename = filename; }
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

三、行为型模式（11种）

目标：处理对象间的交互与职责分配。

13. 责任链模式（Chain of Responsibility）

定义：将请求沿处理链传递，直到有对象处理它。
适用场景：

  • 需要动态指定请求处理者（如审批流程、异常处理）。
  • 需要解耦请求发送者和接收者。

代码示例（审批流程）：

abstract class Handler {
    protected Handler next;
    public void setNext(Handler next) { this.next = next; }
    abstract void handleRequest(int request);
}

class Manager extends Handler {
    public void handleRequest(int request) {
        if (request < 1000) {
            System.out.println("经理审批通过");
        } else if (next != null) {
            next.handleRequest(request);
        }
    }
}

class CEO extends Handler {
    public void handleRequest(int request) {
        if (request >= 1000) {
            System.out.println("CEO 审批通过");
        }
    }
}
14. 命令模式（Command）

定义：将请求封装为对象，支持撤销、队列等操作。
适用场景：

  • 需要实现请求的撤销/重做（如文本编辑器）。
  • 需要将请求排队或记录日志。

代码示例（遥控器控制灯）：

interface Command { void execute(); }

class LightOnCommand implements Command {
    private Light light;
    public LightOnCommand(Light light) { this.light = light; }
    public void execute() { light.on(); }
}

class RemoteControl {
    private Command command;
    public void setCommand(Command command) { this.command = command; }
    public void pressButton() { command.execute(); }
}
15. 解释器模式（Interpreter）

定义：定义语言的语法，并用解释器解析句子。
适用场景：

  • 需要解析特定语法（如 SQL 解析、数学表达式计算）。
  • 语法较简单且效率非关键因素。

代码示例（简单布尔表达式）：

interface Expression { boolean interpret(String context); }

class TerminalExpression implements Expression {
    private String data;
    public TerminalExpression(String data) { this.data = data; }
    public boolean interpret(String context) {
        return context.contains(data);
    }
}

class OrExpression implements Expression {
    private Expression expr1, expr2;
    public OrExpression(Expression e1, Expression e2) {
        this.expr1 = e1; this.expr2 = e2;
    }
    public boolean interpret(String context) {
        return expr1.interpret(context) || expr2.interpret(context);
    }
}
16. 迭代器模式（Iterator）

定义：提供顺序访问聚合对象元素的方法。
适用场景：

  • 需要统一遍历不同结构的集合（如列表、树、图）。
  • 需要隐藏集合的内部实现。

代码示例（自定义集合迭代器）：

interface Iterator<T> { boolean hasNext(); T next(); }

class NameRepository implements Iterable<String> {
    private String[] names = {"Alice", "Bob"};
    public Iterator<String> iterator() {
        return new NameIterator();
    }
    private class NameIterator implements Iterator<String> {
        int index = 0;
        public boolean hasNext() { return index < names.length; }
        public String next() { return names[index++]; }
    }
}
17. 中介者模式（Mediator）

定义：通过中介对象封装对象间的交互，降低耦合。
适用场景：

  • 对象间交互复杂（如聊天室、飞机调度系统）。
  • 需要集中管理对象间的通信。

代码示例（聊天室）：

class ChatRoom {
    public static void sendMessage(User user, String message) {
        System.out.printf("[%s]: %s\n", user.getName(), message);
    }
}

class User {
    private String name;
    public User(String name) { this.name = name; }
    public void sendMessage(String message) {
        ChatRoom.sendMessage(this, message);
    }
    public String getName() { return name; }
}
18. 备忘录模式（Memento）

定义：捕获对象状态并保存，以便后续恢复。
适用场景：

  • 需要实现撤销/重做功能（如文本编辑器、游戏存档）。
  • 需要保存对象历史状态。

代码示例（编辑器撤销）：

class Editor {
    private String content;
    public void setContent(String content) { this.content = content; }
    public String getContent() { return content; }
    public EditorMemento save() { return new EditorMemento(content); }
    public void restore(EditorMemento memento) { content = memento.getContent(); }
}

class EditorMemento {
    private final String content;
    public EditorMemento(String content) { this.content = content; }
    public String getContent() { return content; }
}
19. 观察者模式（Observer）

定义：定义对象间的一对多依赖，状态变化时自动通知。
适用场景：

  • 需要实现事件监听（如 GUI 按钮点击、股票价格变动）。
  • 一个对象状态变化需要通知其他对象。

代码示例（新闻订阅）：

interface Observer { void update(String message); }

class NewsSubscriber implements Observer {
    public void update(String message) {
        System.out.println("收到新闻：" + message);
    }
}

abstract class Subject {
    private List<Observer> observers = new ArrayList<>();
    public void attach(Observer o) { observers.add(o); }
    public void notifyObservers(String message) {
        for (Observer o : observers) {
            o.update(message);
        }
    }
}

class NewsPublisher extends Subject {
    public void publishNews(String news) {
        notifyObservers(news);
    }
}
20. 状态模式（State）

定义：允许对象在内部状态改变时改变行为。
适用场景：

  • 对象行为依赖于状态且状态转换复杂（如电梯控制、订单状态）。
  • 需要消除大量条件分支语句。

代码示例（电梯状态）：

interface ElevatorState {
    void handle(Elevator elevator);
}

class StoppedState implements ElevatorState {
    public void handle(Elevator elevator) {
        System.out.println("电梯已停止");
        elevator.setState(new RunningState());
    }
}

class RunningState implements ElevatorState {
    public void handle(Elevator elevator) {
        System.out.println("电梯运行中");
        elevator.setState(new StoppedState());
    }
}

class Elevator {
    private ElevatorState state;
    public Elevator() { state = new StoppedState(); }
    public void setState(ElevatorState state) { this.state = state; }
    public void request() { state.handle(this); }
}
21. 策略模式（Strategy）

定义：定义算法族，使其可互换。
适用场景：

  • 需要在运行时选择不同算法（如排序策略、支付方式）。
  • 需要隔离算法实现与使用代码。

代码示例（支付策略）：

interface PaymentStrategy { void pay(int amount); }

class CreditCardPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("信用卡支付：" + amount);
    }
}

class AlipayPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("支付宝支付：" + amount);
    }
}

class ShoppingCart {
    private PaymentStrategy strategy;
    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    public void checkout(int amount) {
        strategy.pay(amount);
    }
}
22. 模板方法模式（Template Method）

定义：定义算法骨架，允许子类重写特定步骤。
适用场景：

  • 需要固定算法流程但允许某些步骤灵活变化（如工作流、数据解析）。
  • 需要复用公共代码结构。

代码示例（游戏流程）：

abstract class Game {
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();
    
    public final void play() { // 模板方法
        initialize();
        startPlay();
        endPlay();
    }
}

class Cricket extends Game {
    void initialize() { System.out.println("板球初始化"); }
    void startPlay() { System.out.println("开始玩板球"); }
    void endPlay() { System.out.println("结束板球游戏"); }
}
23. 访问者模式（Visitor）

定义：在不修改类的前提下，为类添加新操作。
适用场景：

  • 需要对复杂对象结构执行多种不相关操作（如编译器语法树分析）。
  • 需要将数据结构与数据操作分离。

代码示例（计算机部件访问）：

interface ComputerPart { void accept(ComputerPartVisitor visitor); }

class Keyboard implements ComputerPart {
    public void accept(ComputerPartVisitor visitor) {
        visitor.visit(this);
    }
}

interface ComputerPartVisitor {
    void visit(Keyboard keyboard);
    void visit(Mouse mouse);
}

class DisplayVisitor implements ComputerPartVisitor {
    public void visit(Keyboard keyboard) {
        System.out.println("显示键盘");
    }
    public void visit(Mouse mouse) {
        System.out.println("显示鼠标");
    }
}

四、总结

设计模式的核心价值：

  1. 代码复用：通过模式化方案减少重复代码。
  2. 解耦与扩展：分离变化与不变部分，提升系统灵活性。
  3. 可维护性：规范化代码结构，降低维护成本。

注意：

  • 理解模式意图，而非死记硬背。
  • 结合项目实践，选择合适模式，避免过度设计。
  • 阅读开源框架源码（如 Spring、MyBatis），观察模式的应用。
Java中的设计模式应用实例
一碗黄焖鸡三碗米饭的博客
02-08 1047
单例模式是最简单也是最常用的设计模式之一，它确保某个类只有一个实例，并且提供全局访问点。通常用于需要全局共享的数据、配置或者资源管理类。工厂模式是一种创建型设计模式，用于创建对象。工厂模式将对象的创建过程封装到一个工厂类中，使得客户端无需知道如何创建对象，只需要通过工厂方法来获取对象。观察者模式是一种行为型设计模式，定义了对象之间一对多的依赖关系。当一个对象的状态发生改变时，它的所有依赖者（观察者）都会被自动通知并更新。
java的工厂设计模式实例
yyyfff43的专栏
02-19 704
/* *工厂类实例 *通过一个工厂类实现生产水果这个特征的对象 */ interface Fruit{//水果接口 public void eat(); } class Apple implements Fruit{//苹果类 public void eat(){ System.out.println("这个水果是个苹果!"); } } class Orange implements
Java 三种设计模式实例实现
qq_41753944的博客
05-05 3488
一． 题目分析 熟悉建模工具。 掌握简单工厂模式、工厂方法模式、抽象工厂模式，并进行设计应用。 ①．简单工厂模式 使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数 R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。 ※分析：简单工厂模...
Java设计模式--实例
IT利刃出鞘的博客
04-05 770
本文介绍Java设计模式的实例。
java多例设计模式是什么_Java多例设计模式实例详解
weixin_28984379的博客
02-25 192
本文实例讲述了java多例设计模式。分享给大家供大家参考，具体如下：一、多例设计模式定义多例设计模式就是存在多个对象实例，供外部应用裯用，比喻数据库连接池。二、多例模式静态类图三、多例模式代码实现1. 多例模式核心类package com.demo.multipleton;import java.util.arraylist;/*** 多例模式** @author**/public class m...
基于java Web 训练管理系统设计与实现 源码 论文
qq_251836457的博客
06-17 2563
用户信息实体，主要包括 用户编号,用户名,密码,姓名,性别,出生日期,证件号,民族,政治面貌,单位,入伍时间,照片,班级,排 等信息实体。1 用户( 用户编号,用户名,密码,姓名,性别,出生日期,证件号,民族,政治面貌,单位,入伍时间,照片,班级,排 )讨论信息实体，主要包括 讨论编号,疑问,说明,发布人,发布时间,状态,回答 等信息实体。系统主要用户实体,班级实体,排实体,科目实体,成绩实体,教学视频实体,教学理论实体,讨论实体，如图所示。班级信息实体，主要包括 班级编号,班级 等信息实体。
架构--数据库层面--读写分离
在技术领域里形成深刻，全面的认识，知道来龙去脉，深入浅出的讲到实用点。
06-21 587
快速入门/学习：推荐方案一 (+ AOP)，能让你深入理解原理，实现也直接。生产环境/复杂需求：推荐方案二 (ShardingSphere-JDBC)，它功能强大且对代码侵入小，能更好地应对未来扩展。大规模/运维主导：可考虑方案三 (独立中间件)，实现应用与数据库的解耦。另外要强调一下，springboot直接连mycat就可以了，在mycat的配置文件里做配置，实现主从分离。
Java项目版本自增+打包上传服务器部署脚本
蔡定努
06-22 197
摘要： 该Bash脚本实现了Java项目的自动化版本管理、打包和部署功能，主要特点包括： 自动读取Maven四段式版本号并智能进位（如1.0.0.99→1.0.1.0） 更新pom.xml版本后跳过测试打包，通过SCP上传至指定CentOS服务器 适配1Panel面板的Java项目部署场景，支持SSH免密登录 包含严格的错误校验机制（Maven环境检测、版本格式验证等） 提供彩色日志输出和详细使用说明，仅需修改顶部4个配置变量即可使用 前置要求：需配置好Maven环境、服务器SSH免密登录，且项目使用标准四
【Spring Cloud 微服务】——第一章 微服务入门与服务拆分
2403_88453964的博客
06-22 265
本文介绍了微服务架构的核心概念、拆分原则及实践方法。首先对比了单体架构与微服务架构的优缺点，指出微服务通过拆分功能模块为独立服务，解决了团队协作、发布效率和系统可用性问题。文章详细讲解了微服务的拆分时机（初创项目先单体后拆分，大型项目直接采用）和拆分原则（高内聚、低耦合），并以电商系统为例演示了商品和购物车服务的拆分过程。最后通过RestTemplate实现服务间HTTP调用，展示了微服务间通信的基本方式。文章还预告了后续将介绍服务注册发现和OpenFeign远程调用技术。
MyBatis-Plus 完整实际使用整理
m0_73837751的博客
06-18 379
数据库操作方式总览│├── 方式一：BaseMapper + Wrapper（大厂主流）│ ├── 基础 CRUD：selectById / insert / updateById / deleteById│ ├── 条件操作：selectList(LambdaQueryWrapper) / delete(wrapper) ...│ ├── 分页：selectPage(IPage, wrapper) + 分页插件。
Java数据库连接池学习
u011237796的博客
06-18 380
表示并发情况下最大可从连接池中获取的连接数。连接池基本的思想是在系统初始化的时候，将数据库连接作为对象存储在内存中，当用户需要访问数据库时，并非建立一个新的连接，而是从连接池中取出一个已建立的空闲连接对象。maxIdle对应的连接，实际上是连接池保持的长连接，这也是连接池发挥优势的部分，理论上讲保持较多的长连接，在应用请求时可以更快的响应，但是过多的连接保持，反而会消耗数据库大量的资源，因此maxIdle也并不是越大越好，同上例我们建议将 maxIdle设置成50-100中靠近50的数字，例如55。
JavaScript 类 Class 完整知识点讲解
妖精の羽翼的博客
06-23 314
js运行// 定义类// 构造函数：创建实例时自动执行，接收参数// 实例属性，绑定到每个实例// 实例方法：存在原型上，所有实例共享，节省内存sayHi() {console.log(`我是${this.name}，今年${this.age}`);// new 实例化const p1 = new Person("张三", 22);p1.sayHi();// 我是张三，今年22// 张三固定构造方法，一个类只能有一个 constructor，不写会自动生成空构造；必须用new。
内容社区UGC平台中的 Java 微服务与AI实践面试：从Spring全家桶到RAG搜索的连环拷问
最新发布
qq_57418183的博客
06-23 327
通过一场互联网大厂 Java 面试对话，把内容社区与UGC场景下的系统设计、微服务、缓存、消息队列、搜索与推荐、AI RAG 等知识串起来。面试官严肃专业，小Y搞笑又略显水，简单问题答得还行，复杂问题则含糊其辞。文章最后给出详细解析，适合 Java 小白系统学习。
1.1 douckr面试题
你是人间四月天
06-22 440
没问题！想在 Docker 面试中显得经验丰富，关键不是背概念，而是展现出你。下面我为你精选了 6 道高频实战题，并附上“高手回答思路”和“加分话术”，让你快速掌握精髓。
GPT-4o mini 轻量化落地实战指南
2503_91800161的博客
06-22 501
这篇文章将深入探讨十个具体的落地场景，从高频互动的客服系统到批量化的内容生成，再到教育领域的个性化应用，分享如何在实际工程中拆解难题。无论你是负责后端架构的技术负责人，还是正在寻找降本增效方案的全栈开发者，都能从中找到可复用的实践路径。我们将避开宏大的理论叙述，直接聚焦于代码逻辑、资源调度策略以及数据流转的优化细节，帮助你在真实的业务环境中快速落地智能应用。
【Java项目技术亮点】Saga模式长事务编排
我是一颗柠檬的博客
06-21 398
本文介绍了Saga模式在分布式长事务处理中的应用，对比了TCC与Saga的优缺点。Saga通过正向操作和补偿操作实现最终一致性，适用于电商下单等跨多个服务的场景。文章详细解析了编排式和协同式两种Saga实现方式，并提供了Seata Saga的状态机配置示例和Java代码实现。Saga相比TCC具有代码侵入性低、维护成本低的优势，是处理长流程事务的更优解。
【seata】整合分布式事务
weixin_44823875的博客
06-22 338
下单（order-service TM）→ 扣库存（stock-service RM）→ 扣余额（account-service RM），任意环节异常全部回滚。单机启动：startup.cmd -m standalone（Windows）/ sh startup.sh -m standalone（Linux）每个参与分布式事务的业务库，必须执行undo_log 表脚本（seata AT 模式核心，记录回滚快照）（3）库存 / 账户服务（RM，普通本地事务 @Transactional）
【leetcode】121.买卖股票的最佳时机js/c++
2402_83244812的博客
06-16 582
摘要：该问题采用贪心算法解决股票买卖最佳时机问题。通过维护当前最小买入价和计算当前卖出利润，更新最大利润值。JavaScript实现遍历数组时动态更新最小价格和最大利润。类似地，C++版本使用迭代器跟踪买入点和遍历卖出点，当发现更低价格时更新买入点，并始终记录最大利润值。两种实现均只需一次遍历，时间复杂度为O(n)。
Spring Boot 基础：自动装配原理与 @EnableXXX 详解
weixin_44551234的博客
06-17 547
理解了以上模式后，开发者也可以编写自己的@Enable注解。@Bean使用时只需要在主类上加上即可。本文系统地拆解了 Spring Boot 自动装配原理与@EnableXXX中的通过@Import导入。利用加载中预定义的自动配置类，并通过条件注解筛选。被筛选出的配置类会像普通一样被解析，其中的@Bean方法会为容器提供默认基础设施。@EnableXXX注解普遍基于@Import，可导入配置类、或，实现特定功能的模块化开关。
[LangChain&LangGraph]. LangChain和LangGraph介绍
Boop_wu的博客
06-21 576
模型切换成本高（耦合性）：一旦选定某个模型，代码往往与该模型的 API 强耦合。更换模型几乎等同于重写代码，缺乏灵活性非结构化输出难以解析（格式问题）：程序需要结构化数据（如 JSON）来驱动 UI 或逻辑，但 LLM 倾向于生成自然文本。强行用正则表达式提取不仅脆弱且易出错知识滞后与幻觉（时效性与准确性）：模型训练数据有截止日期（例如不知道最新的病毒变种），且可能产生“幻觉”。在医疗等严谨领域，必须结合外部实时数据或权威数据库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值