【设计模式深度剖析】【2】【行为型】【命令模式】| 以打开文件按钮、宏命令、图形移动与撤销为例加深理解

浣花御劍2024-06-09 13:42

👈️上一篇:模板方法模式 | 下一篇:职责链模式👉️
设计模式-专栏👈️

文章目录

命令模式

命令模式（Command Pattern）又称为行动（Action）模式或交易（Transaction）模式。

命令模式就像是一个魔法卷轴。在这个奇幻的世界里，魔法师（请求者）不需要亲自施展复杂的法术（接收者），他们可以将法术的咒语和步骤记录在魔法卷轴上（命令对象）。

当魔法师需要施展某个法术时，他们只需挥动魔法卷轴，卷轴上的咒语就会自动激活，释放出强大的魔法力量。这样，魔法师就可以轻松地使用各种法术，而无需每次都记住复杂的咒语和步骤。

魔法卷轴的存在让魔法师的技能得以扩展和保存。他们可以将自己创造的独特法术记录在卷轴上，与他人分享或传授。此外，魔法卷轴还具有撤销和重做的能力，如果魔法师在施展法术时出现了错误，他们可以简单地收回卷轴并重新施展。

因此，命令模式就像是一个魔法卷轴，它让魔法的施展变得更加简单、高效和可控，为魔法师们带来了无尽的便利和乐趣。

++本文源码，点击查看++👈️

定义

英文原话

Encapsulate a request as an object, allowing you to parameterize clients with different requests, queue or log requests, and support undoable operations.

直译

将请求封装为一个对象，使得你可以使用不同的请求对客户端进行参数化；可以对请求进行排队或记录请求日志，并支持可撤销的操作。

在这个定义中，"Encapsulate a request as an object"指的是将请求（或操作）封装为对象的形式，

这样做的好处是可以将请求与其执行者解耦，提高系统的灵活性和可维护性。同时，通过封装请求为对象，还可以实现诸如请求队列、日志记录、撤销/重做等功能。

如何理解呢？

理解命令模式（Command Pattern）的关键 在于认识到它如何帮助我们将请求（或操作）封装为对象，并将请求的发送者和接收者解耦。以下是对命令模式的详细理解：

  1. 请求封装为对象 ：

    在命令模式中，一个请求被封装为一个对象，即命令对象。这个命令对象包含了执行特定操作的必要信息。通过封装请求为对象，我们可以将请求视为与其他对象一样的实体，并对其进行操作，如传递、存储和组合。

  2. 发送者与接收者解耦：

    命令模式允许我们将请求的发送者（客户端）与请求的接收者（执行者）解耦。发送者不需要直接调用接收者的方法 ，而是通过命令对象来间接地触发接收者的操作。这种解耦提高了系统的灵活性和可扩展性。

    例如，我们可以轻松地更换接收者（执行不同的操作）或添加新的命令对象（执行新的操作），而无需修改发送者的代码。

  3. 支持撤销、重做和日志记录 ：

    由于命令对象封装了请求的信息，我们可以轻松地实现撤销、重做和日志记录等功能。通过存储之前执行的命令对象，我们可以在需要时重新执行它们（实现重做）或反向执行它们（实现撤销）。此外，我们还可以记录命令的执行日志，以便后续的分析和调试。

  4. 排队和调度 ：

    由于命令对象是可存储和可传递的，我们可以将它们放入队列中并按顺序执行（如命令队列），或者根据一定的调度策略来执行它们（如时间调度器）。这允许我们更灵活地控制操作的执行顺序和频率。

  5. 简化客户端代码 ：

    通过引入命令对象作为中间层 ，我们可以简化客户端代码。客户端只需要知道如何创建和发送命令对象，而无需关心命令的具体执行细节。这使得客户端代码更加简洁和易于维护。

命令模式通过封装请求为对象并将发送者与接收者解耦，提供了一种灵活的方式来处理请求和操作。它支持撤销、重做、日志记录、排队和调度等功能，并简化了客户端代码。这些特性使得命令模式在许多场景中都非常有用，如GUI操作 、数据库事务 、游戏开发等。

四个角色

命令模式涉及以下几个主要角色：

1. Command（命令接口）

声明了一个执行操作的接口。

2. ConcreteCommand（具体命令类）

将一个接收者对象绑定于一个动作

通过调用接收者相应的操作，来实现Commond接口的抽象方法。

实现了Command 接口，持有接收者（Receiver）对象 ，并调用接收者的功能 来完成命令要执行的操作。

3. Client（客户端）

创建一个具体命令对象并设定它的接收者。

4. Invoker（调用者）

要求该命令执行这个请求。

5. Receiver（接收者）

知道如何实施与执行一个请求的相关的操作。

真正执行命令的对象 。任何类都可能成为一个接收者，只要它能够实现命令要求的功能。

类图

类图分析

从类图中可以分析出：

调用者Invoker持有命令对象，ConcreteCommand具体命令持有接收者Receiver对象。

因此，调用者Invoker对象就可以间接执行接收者Receiver对象的动作，通过调用具体命令的执行方法execute()，而该方法实现方式是通过调用接收者Receiver对象的动作action()方法。

通过Command接口将调用者与接收者解耦，发送者不需要直接调用接收者的方法 ，而是通过命令对象来间接地触发接收者的操作。这种解耦提高了系统的灵活性和可扩展性。

代码示例

命令接口Command

java 复制代码 
package com.polaris.designpattern.list3.behavioral.pattern02.command.proto;

/**
 * 命令接口Command：命令（Command）角色
 */
public interface Command {
    // 执行命令的方法
    void execute();
}

具体命令ConcreteCommand

java 复制代码 
package com.polaris.designpattern.list3.behavioral.pattern02.command.proto;

/**
 * 具体命令ConcreteCommand：具体命令（Concrete Command）角色
 */
public class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    // 执行方法
    @Override
    public void execute() {
        this.receiver.action();
    }
}

客户端Client

java 复制代码 
package com.polaris.designpattern.list3.behavioral.pattern02.command.proto;

/**
 * 创建一个具体命令对象并设定它的接收者
 */
public class Client {
    public static void main(String[] args) {
        // 接受者
        Receiver receiver = new Receiver();
        // 将一个接收者对象绑定于一个动作
        Command command = new ConcreteCommand(receiver);

        // 调用者：要求该命令执行这个请求
        Invoker invoker = new Invoker();
        invoker.setCommand(command);
        invoker.callCommand();
    }
}

调用者Invoker

java 复制代码 
package com.polaris.designpattern.list3.behavioral.pattern02.command.proto;

/**
 * 调用者Invoker
 */
public class Invoker {
    private Command command;

    // 构造函数初始化该命令
    public void setCommand(Command command) {
        this.command = command;
    }

    // 执行命令
    public void callCommand() {
        this.command.execute();
    }
}

接收者Receiver

java 复制代码 
package com.polaris.designpattern.list3.behavioral.pattern02.command.proto;

/**
 * 接收者Receiver
 */
public class Receiver {
    // 行动方法
    public void action() {
        System.out.println("Command executed.");
    }
}

输出打印

java 复制代码 
Command executed.

在这个示例中，

Receiver 是知道如何执行请求的对象，ConcreteCommand 是实现了 Command 接口的具体命令类，它持有一个 Receiver 对象并在 execute 方法中调用其 action 方法。

Invoker 是调用者，它持有 Command 对象并在需要时调用其 execute 方法。

Client 是客户端，负责创建和设置命令对象及其接收者。

应用

命令模式的应用

命令模式广泛应用于许多需要执行命令、撤销命令、记录命令历史或实现宏命令的系统中。以下是几个具体的应用场景：

  1. 图形用户界面 (GUI) 中的按钮：每个按钮可以关联一个命令对象，当按钮被点击时，执行该命令。
  2. 文本编辑器：撤销和重做功能可以通过命令模式实现，每个编辑操作（如插入、删除、剪切、粘贴等）都可以是一个命令。
  3. 请求队列：系统可以接收多个命令请求，并将它们存储在一个队列中，然后按照先进先出（FIFO）的顺序执行这些命令。
  4. 事务处理：在金融系统中，交易可以被封装为命令，从而可以轻松地回滚（撤销）事务。
  5. 宏录制：用户可以录制一系列命令，然后在需要时重新执行这些命令，以实现自动化操作。

命令模式的优点

  1. 解耦：命令模式将请求者与执行者解耦，使得请求者不需要知道如何执行命令，只需要知道如何发送命令。
  2. 易于扩展：由于请求者和执行者之间的解耦，可以在不修改现有代码的情况下添加新的命令。
  3. 支持撤销/重做：通过保存命令的历史记录，可以很容易地实现撤销和重做功能。
  4. 易于实现事务：可以将多个命令组合成一个事务，从而确保所有命令都成功执行或全部回滚。
  5. 易于记录日志和监控：可以轻松地记录每个命令的执行情况和结果，以便于后续的分析和监控。

命令模式的缺点

  1. 可能导致过多的具体命令类：对于复杂的系统，可能需要大量的具体命令类来实现各种功能，这可能会增加系统的复杂性。
  2. 可能增加系统的开销：由于命令对象通常包含对接收者的引用，并且在执行过程中可能需要额外的内存来存储命令历史记录，因此可能会增加系统的内存开销。

命令模式的使用场景

当需要满足以下条件时，可以考虑使用命令模式：

  1. 请求者和执行者需要解耦：当请求者不需要知道如何执行请求，或者执行者不需要知道请求的来源时，可以使用命令模式。
  2. 支持撤销/重做：如果系统需要支持撤销和重做功能，那么命令模式是一个很好的选择。
  3. 需要记录请求的历史：如果系统需要记录每个请求的执行情况和结果，以便于后续的分析和监控，那么可以使用命令模式。
  4. 需要实现事务：如果需要将多个操作组合成一个事务，以确保它们要么全部成功执行，要么全部回滚，那么命令模式是一个很好的选择。

示例解析1：菜单按钮（UI 控件）- 打开文件按钮

在这个示例中，我们有一个 UI 控件（比如一个按钮），当用户点击这个按钮时，它应该执行某个操作（打开文件）。

我们可以使用命令模式来解耦按钮和它所执行的操作。

类图

类图分析

这个类图可以对比之前的角色分析时候的类图，没错，可以发现是一致的结构，是一种场景的具化，为的是通过该具体示例进一步理解命令模式的各个角色。

  1. Button调用者角色，持有一个命令对象，至于什么具体的命令对象，看用户给他传入什么命令对象，这里是要给它的构造器传入OpenFileCommand，用来初始化持有的命令对象，即该按钮的意图是要打开文件。而如何打开，打开哪个文件，由命令决定，调用者只需要负责按照自己的需要传入相应的命令即可；
  2. OpenFileCommand具体命令，构造器初始化了它持有的接收者FileManager对象，以及要打开的文件名，即该命令的目的就是为了打开该指定的文件。该命令的操作方法execute()通过调用接收者打开文件的方法openFile(String)来实现的；
  3. 从上面两步分析，可知，接收者FileManager并不知道谁会用到它，不知道谁是调用者，而调用者Button它只持有命令，具体谁（哪个接收者）来处理这个命令，它不直接关心，或者说它并不关心，他只直接知道我使用这个命令能完成这个事情，而具体这个命令如何操作的，由具体命令进行了封装，调用相应的接收者处理调用者的需求。因此，通过命令接口，解耦了调用者与接收者。
  4. 客户端就是按照上面分析过程中，调用者需要持有一个具体命令对象，具体命令封装了调用哪个接收者的方法来处理调用者的需求，因此客户端Client实例化接收者，作为参数构造出具体命令，然后将具体命令对象作为参数构造出调用者对象，然后就是执行，调用者要求该命令执行这个请求。

代码示例

看完类图，然后把类图分析完，下面的代码就了然了。

java 复制代码 
package com.polaris.designpattern.list3.behavioral.pattern02.command.openfileuidemo;

// 命令接口
interface Command {  
    void execute();  
}  
  
// 打开文件的具体命令  
class OpenFileCommand implements Command {  
    private FileManager fileManager;  
    private String fileName;  
  
    public OpenFileCommand(FileManager fileManager, String fileName) {  
        this.fileManager = fileManager;  
        this.fileName = fileName;  
    }  
  
    @Override  
    public void execute() {  
        fileManager.openFile(fileName);  
    }  
}  
  
// 文件管理器（接收者）  
class FileManager {  
    public void openFile(String fileName) {  
        System.out.println("打开文件: " + fileName);  
    }  
    // ... 其他文件管理操作  
}  
  
// UI 控件（调用者）  
class Button {  
    private Command command;  
  
    public Button(Command command) {  
        this.command = command;  
    }  
  
    public void onClick() {  
        command.execute();  
    }  
}  
  
// 客户端代码  
public class Client {  
    public static void main(String[] args) {  
        FileManager fileManager = new FileManager();  
        Command openCommand = new OpenFileCommand(fileManager, "example.txt");  
        Button openButton = new Button(openCommand);  
  
        // 假设这是用户点击按钮的事件  
        openButton.onClick(); // 输出：打开文件: example.txt  
    }  
}

/* Output"
打开文件: example.txt
*///~

示例解析2：宏命令（组合多个命令）

在这个示例中，我们将展示如何使用命令模式来组合多个命令，形成一个宏命令。

注意一点即可，宏命令是组合了多个命令，它是要一次执行一组操作的。

类图

类图分析

除了接收者宏命令MacroCommand持有多个命令对象外，和示例1结构无差别。重点理解一组操作的概念，从类图也可以反映出来。

该示例与示例1的区别，我们模拟宏命令即组合多个命令，可以看到调用者MacroCommand持有一个命令列表 ，通过addCommand(Command)方法可以添加具体命令进去，它的需求就是一次将这一组命令依次执行，因此需要遍历执行每个命令。

代码示例

主要关注组合对象的实现即可，当然也可以再次重复理解一下命令模式的各个角色，及他们间的关系。

java 复制代码 
package com.polaris.designpattern.list3.behavioral.pattern02.command.macrocommand;


import com.polaris.designpattern.list3.behavioral.pattern02.command.proto.Command;

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

// 命令接口
interface Command {
    // 执行命令的方法
    void execute();
}

// 宏命令（组合多个命令）
// 宏命令（也是命令的一种，可以包含多个子命令）
class MacroCommand implements Command {
    private List<Command> commands = new ArrayList<>();

    public void addCommand(Command command) {
        commands.add(command);
    }

    @Override
    public void execute() {
        for (Command command : commands) {
            command.execute();
        }
    }
}

// 接收者 TextEditor 类，用于编辑文本
class TextEditor {
    private String text; // 假设这是编辑器中的文本内容

    public TextEditor() {
        this.text = "";
    }

    // 获取编辑器中的文本
    public String getText() {
        return text;
    }

    // 设置编辑器中的文本（通常这不会是一个直接设置的方法，但为了简化示例）
    public void setText(String text) {
        this.text = text;
    }

    // 调整字体大小的方法（这里只是模拟，实际上可能需要更复杂的逻辑）
    public void adjustFontSize(int size) {
        // 在真实应用中，这里可能会更新编辑器的UI或状态来反映新的字体大小
        // 但在这个示例中，我们只是简单地打印一条消息
        System.out.println("字体大小已调整为: " + size);
    }

    // 其他可能的文本编辑方法...
}

// 具体的命令（比如调整字体大小）  
class AdjustFontSizeCommand implements Command {
    private TextEditor textEditor;
    private int size;

    public AdjustFontSizeCommand(TextEditor textEditor, int size) {
        this.textEditor = textEditor;
        this.size = size;
    }

    @Override
    public void execute() {
        textEditor.adjustFontSize(size);
    }
}

// 客户端代码  
public class Client {
    public static void main(String[] args) {
        TextEditor textEditor = new TextEditor(); // 假设 TextEditor 是接收者，用于编辑文本  

        // 创建具体的命令  
        Command fontSizeUp = new AdjustFontSizeCommand(textEditor, 12); // 增大字体  
        Command fontSizeDown = new AdjustFontSizeCommand(textEditor, 10); // 减小字体  

        // 创建宏命令，并添加具体的命令  
        MacroCommand macroCommand = new MacroCommand();
        macroCommand.addCommand(fontSizeUp);
        macroCommand.addCommand(fontSizeDown); // 注意：这里只是示例，通常不会连续执行增大和减小字体  

        // 执行宏命令  
        macroCommand.execute(); // 首先执行 fontSizeUp，然后执行 fontSizeDown  
    }
}

/* Output:
字体大小已调整为: 12
字体大小已调整为: 10
*///~

示例解析3：图形移动/撤销(重做功能)（丐版）

命令模式也可以用来实现撤销和重做功能。每个命令对象都可以存储其执行前的状态，以便在需要时撤销操作。

这里是一个简化的示例，图形的状态信息，这里主要关注图形的位置，在这里给简化省略了，我们只是通过打印文字模拟了一下。因此省略掉了接收者角色，直接在具体命令的方法中进行打印。

带有图形位置状态信息，且由接收者处理请求的示例见示例解析4

在这个示例，适应一下一个简单的变体：缺少接收者。

类图

类图分析

撤销，重做需要记录之前的状态信息，在这个示例我们简化了状态信息的记录，执行命令，与撤销命令通过在具体命令中进行打印，因此省略了接收者处理请求逻辑，因此在类图就省略了接收者角色；

UndoManager调用者，持有一个命令执行记录栈，当需要撤销，从栈中弹出一个上一次操作的命令执行该命令的撤销方法。

这里的命令接口的定义，分了两层，一层是基础命令，用来执行命令，另外扩展的带撤销功能的命令接口，定义了撤销方法，具体命令实现接口，也就实现了执行/撤销的逻辑。

代码示例

java 复制代码 
package com.polaris.designpattern.list3.behavioral.pattern02.command.undodemo.simple;

import java.util.Stack;

// 基础的命令接口
interface Command {
    void execute(); // 执行命令  
}

// 带有撤销功能的命令接口  
interface UndoableCommand extends Command {
    void undo(); // 撤销操作  
}

// 具体命令：具体的撤销命令（比如移动图形）
class MoveShapeCommand implements UndoableCommand {
    // 假设这里包含移动图形所需的状态信息  
    // 例如：起始位置、目标位置等  

    @Override
    public void execute() {
        // 执行移动操作  
        System.out.println("执行移动操作");
        // ... 实际移动图形的代码 ...  
    }

    @Override
    public void undo() {
        // 撤销移动操作，将图形移回原来的位置  
        System.out.println("撤销移动操作");
        // ... 实际撤销移动的代码 ...  
    }
}

// 撤销管理器（调用者）  
class UndoManager {
    private Stack<UndoableCommand> undoStack = new Stack<>();

    public void executeCommand(UndoableCommand command) {
        command.execute();
        undoStack.push(command); // 将命令添加到撤销栈中  
    }

    public void undo() {
        if (!undoStack.isEmpty()) {
            UndoableCommand command = undoStack.pop();
            command.undo(); // 调用命令的撤销方法  
            System.out.println("撤销成功");
        } else {
            System.out.println("没有可撤销的命令");
        }
    }

    // 可能还需要一个检查是否有可撤销命令的方法  
    public boolean canUndo() {
        return !undoStack.isEmpty();
    }

    // 如果需要重做功能，可以添加相应的栈和逻辑  
}

// 示例使用  
public class Client {
    public static void main(String[] args) {
        UndoManager undoManager = new UndoManager();
        UndoableCommand moveCommand = new MoveShapeCommand();

        // 执行命令  
        undoManager.executeCommand(moveCommand);

        // 撤销命令  
        if (undoManager.canUndo()) {
            undoManager.undo();
        }
    }
}
/* Output:
执行移动操作
撤销移动操作
撤销成功
*///~

示例解析4：图形移动/撤销(重做功能)

相较于上一个示例（示例3 ），通过增加接收者Shape类用来处理图形移动逻辑与Point类用来记录图形的位置信息。

类图

类图分析

  1. UndoManager调用者在执行命令时候会将执行的命令压栈到栈中，当需要撤销操作时候，出栈弹出上一次的命令，执行撤销动作
  2. 由于需要支持撤销，因此调用者必须持有的具体命令必须带有可撤销能力，因此需要持有 UndoableCommand 类型对象
  3. 接收者 Shape 构造函数需要指定 Point对象，用来记录它的位置，它有一个获取图形当前所在位置的方法 getPositon() 和 移动到指定位置的方法 moveTo(Point)该方法需要传入一个目标位置
  4. 具体命令构造器需要参数接收者 Shape 对象用来完成移动/撤销移动操作，同时获取该图形的当前位置信息，即原始位置，记录下来 ，用于撤销时候使用
  5. 具体命令构造器需要参数接收者 Point 对象 targetPosition 用来表示需要移动到的位置

代码示例

java 复制代码 
package com.polaris.designpattern.list3.behavioral.pattern02.command.undodemo.complex;


import java.util.Stack;

// 基础的命令接口（如果不需要，可以省略）
interface Command {
    void execute(); // 执行命令  
}

// 带有撤销功能的命令接口  
interface UndoableCommand extends Command {
    void undo(); // 撤销操作  
}

// 图形类：用于记录移动图形所需的状态信息
class Shape {
    Point position; // 假设有一个Point类表示位置  

    Shape(Point position) {
        this.position = position;
        System.out.println("图形原位置：" + position);
    }

    // ... 其他图形相关的方法 ...  

    void moveTo(Point newPosition) {
        this.position = newPosition;
        System.out.println("图形移动到: " + newPosition);
    }

    Point getPosition() {
        return position;
    }
}

// 点类，表示位置：用于记录移动图形所需的状态信息
class Point {
    int x, y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "(" + x + ", " + y + ")";
    }
}

// 具体命令：具体的撤销命令（比如移动图形）
class MoveShapeCommand implements UndoableCommand {
    private Shape shape;
    private Point originalPosition; // 原始位置  
    private Point targetPosition; // 目标位置  

    public MoveShapeCommand(Shape shape, Point targetPosition) {
        this.shape = shape;
        this.originalPosition = new Point(shape.getPosition().x, shape.getPosition().y); // 保存原始位置  
        this.targetPosition = targetPosition;
    }

    @Override
    public void execute() {
        // 执行移动操作  
        System.out.println("执行移动操作");
        shape.moveTo(targetPosition); // 实际移动图形的代码  
    }

    @Override
    public void undo() {
        // 撤销移动操作，将图形移回原来的位置  
        System.out.println("撤销移动操作");
        shape.moveTo(originalPosition); // 实际撤销移动的代码  
    }
}

// 撤销管理器（调用者）
class UndoManager {
    private Stack<UndoableCommand> undoStack = new Stack<>();

    public void executeCommand(UndoableCommand command) {
        command.execute();
        undoStack.push(command); // 将命令添加到撤销栈中
    }

    public void undo() {
        if (!undoStack.isEmpty()) {
            UndoableCommand command = undoStack.pop();
            command.undo(); // 调用命令的撤销方法
            System.out.println("撤销成功");
        } else {
            System.out.println("没有可撤销的命令");
        }
    }

    // 可能还需要一个检查是否有可撤销命令的方法
    public boolean canUndo() {
        return !undoStack.isEmpty();
    }

    // 如果需要重做功能，可以添加相应的栈和逻辑
}

// 示例使用
public class Client {
    public static void main(String[] args) {
        UndoManager undoManager = new UndoManager();
        Shape shape = new Shape(new Point(0, 0)); // 创建一个在(0, 0)位置的图形  
        UndoableCommand moveCommand = new MoveShapeCommand(shape, new Point(10, 10)); // 移动到(10, 10)位置  

        // 执行命令
        undoManager.executeCommand(moveCommand);

        // 撤销命令
        if (undoManager.canUndo()) {
            undoManager.undo();
        }
    }
}
/* Output:
图形原位置：(0, 0)
执行移动操作
图形移动到: (10, 10)
撤销移动操作
图形移动到: (0, 0)
撤销成功
*///~

在这个示例中，我们添加了一个Shape类来表示图形，以及一个Point类来表示位置。MoveShapeCommand现在保存了图形的原始位置和目标位置，以便在execute和undo方法中使用。在Main类的示例中，我们创建了一个在(0, 0)位置的图形，并创建了一个命令来将其移动到(10, 10)位置。然后，我们通过UndoManager执行该命令并撤销它。

👈️上一篇:模板方法模式 | 下一篇:职责链模式👉️
设计模式-专栏👈️

相关推荐
捕鲸叉6 分钟前
C++软件设计模式之外观（Facade）模式
c++·设计模式·外观模式
小小小妮子~21 分钟前
框架专题：设计模式
设计模式·框架
先睡21 分钟前
MySQL的架构设计和设计模式
数据库·mysql·设计模式
wm104338 分钟前
java web springboot
java·spring boot·后端
smile-yan39 分钟前
Provides transitive vulnerable dependency maven 提示依赖存在漏洞问题的解决方法
java·maven
老马啸西风40 分钟前
NLP 中文拼写检测纠正论文-01-介绍了SIGHAN 2015 包括任务描述，数据准备， 绩效指标和评估结果
java
Earnest～43 分钟前
Maven极简安装&配置-241223
java·maven
皮蛋很白1 小时前
Maven 环境变量 MAVEN_HOME 和 M2_HOME 区别以及 IDEA 修改 Maven repository 路径全局
java·maven·intellij-idea
青年有志1 小时前
JavaWeb（一） | 基本概念（web服务器、Tomcat、HTTP、Maven）、Servlet 简介
java·web
上海研博数据1 小时前
flink+kafka实现流数据处理学习
java
热门推荐
01【一文读懂】NTN（非地面网络）技术介绍02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07组基轨迹建模 GBTM的介绍与实现（Stata 或 R）08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10ARM学习（31）编译器对overlay方式的支持