Java开发理论知识记录

Java高手马保国

已于 2024-03-06 23:35:07 修改

阅读量4.7w

点赞数 17

分类专栏：理论知识文章标签： java 开发语言中间件

于 2024-03-06 14:51:08 首次发布

本文链接：https://blog.csdn.net/Jactil/article/details/136505664

版权

理论知识专栏收录该内容

2 篇文章 0 订阅

订阅专栏

【JWT】

JWT是什么

JSON Web Token (JWT)，它是目前最流行的跨域身份验证解决方案
例：jwt就相当于学校的出入证，只有持有出入证的人才能进行出入

为什么使用JWT

JWT的精髓在于：“去中心化”，数据是保存在客户端的。
以session来举例，session是储存在服务器的，如果是按服务器来储存数据的话，那么服务器会占用很大的一个内存，而存储在客户端就解决了这个问题

jwt工作原理

用户登录时，输入账号密码，后端拿上账号密码去数据库里查是否正确并返回查询结果，在查询结果不为空（账号、密码正确）的前提下，将用户的id和账户名username拿上，
并用JWT工具生成指定的token（登录凭证，并设置了过期时间）返回给前端，前端拿到token后存到localstorage或sessionstorage中，当用户再次访问服务器中需要登录才可访问的资源时，
前端将存储的token设置在请求头中与前端请求一并发送到服务器，服务器通过设置的拦截器获得token并校验，若校验无误则放行；若校验发生异常则说明token有误，
响应给前端提醒用户登录，返回false，不执行controller。

【swagger】

什么是swagger

Swagger 是一个用于生成、描述、调用和可视化 RESTful 风格的 Web 服务接口的工具集。

【javaee什么时候改成 Jakarta EE了】

Java EE（Java Platform, Enterprise Edition）更名为 Jakarta EE 是在 2018 年底。这个改变是由于 Oracle 决定将 Java EE 转移到一个开源基金会，最终选择了 Eclipse 基金会。为了避免与 Oracle 的 Java 商标相关的问题，社区决定更改品牌名称，从 Java EE 更改为 Jakarta EE。
2018 年 8 月，Eclipse 基金会进行了一个公开的投票，以选择新的名称。最终，“Jakarta EE”被选为新的品牌名称。随后，Eclipse 基金会成立了 Jakarta EE 工作组，负责继续发展 Java EE 的后续版本。
第一个以 Jakarta EE 命名的版本是 Jakarta EE 8，它在 2019 年 9 月发布，与 Java EE 8 相兼容。随后，Jakarta EE 继续发展，推出了新的版本，引入了新的特性，并逐渐与传统的 Java EE 标准保持一致，同时拥抱更多的开源创新。
因此，从 Java EE 到 Jakarta EE 的转变标志着企业级 Java 技术的一个重要转折点，它不仅改变了品牌的名称，也象征着 Java 企业版技术的持续演化和社区驱动的开发模式。

【Handler和controller有什么区别】

在 Spring 框架中，Handler 和 Controller 通常是指处理 HTTP 请求的不同层面的组件，但它们经常被交替使用。下面是它们各自的定义和区别：

Controller:

Controller 是 Spring MVC（Model-View-Controller）架构的一部分。
它是一个组件，负责处理用户的请求，并返回相应的响应。
通常，Controller 类会包含多个方法，每个方法对应一个特定的请求处理逻辑。
Controller 通常会使用 @Controller 注解来标识，或者使用 @RestController 注解在 RESTful 风格的 Web 服务中。
Controller 类中的方法通常使用 @RequestMapping 或其他类似的注解来映射特定的 HTTP 请求。

Handler:

Handler 是一个更广泛的概念，它可以指任何处理请求的组件，不仅限于 Spring MVC。
在 Spring MVC 中，Handler 通常指的是 HandlerMethod，它代表了一个具体的请求处理方法。
Handler 可以是任何对象，只要它能处理请求并返回响应。
Handler 可以是实现了 HandlerInterceptor 接口的拦截器，用于在请求处理之前或之后执行特定的逻辑。
总结来说，Controller 是 Spring MVC 中的一个特定位组件，用于处理 HTTP 请求，而 Handler 是一个更通用的概念，可以指任何处理请求的对象或组件。
在 Spring MVC 的上下文中，Controller 中的每个处理方法都可以被视为一个 Handler。

【web接口怎么选择请求方式】

在设计和实现 Web 接口时，选择使用 GET 还是 POST 请求主要取决于操作的类型和安全性考虑。以下是使用 GET 和 POST 请求的一些常见准则：

GET 请求：
用于请求服务器发送资源。
请求的参数附加在 URL 上，因此它们对用户是可见的。
没有请求体，参数长度有限制（通常受限于 URL 的长度）。
应该是幂等的，意味着多次执行相同的 GET 请求应该返回相同的结果。
通常用于读取操作，如检索数据、搜索、查询等。
可以被缓存，可以被书签，可以通过历史记录或后退按钮重新执行。
POST 请求：
用于向服务器提交数据。
请求的参数包含在请求体中，对用户不可见。
没有长度限制（理论上受限于服务器配置）。
不一定是幂等的，多次执行相同的 POST 请求可能会每次都产生不同的结果。
通常用于写操作，如创建、更新、删除数据等。
不被缓存，不能被书签，不能通过历史记录或后退按钮重新执行。
使用场景示例：
检索用户信息：GET /users/123（幂等，只读操作）
创建新用户：POST /users（非幂等，写操作）
更新用户信息：POST /users/123 或 PUT /users/123（非幂等，写操作）
删除用户：DELETE /users/123（通常幂等，写操作）
执行搜索：GET /search?q=keyword（幂等，只读操作）
在选择 HTTP 方法时，还应该考虑 RESTful 设计原则，其中 GET 用于获取资源，POST 用于创建资源，PUT 用于更新资源，DELETE 用于删除资源。然而，实际应用中可能会根据具体需求和约定来选择合适的方法。
总之，选择 GET 还是 POST 请求应该基于操作的性质和安全性考虑。对于只读操作和幂等操作，通常使用 GET；对于写操作和非幂等操作，通常使用 POST。

【集合】

在 Java 开发中，集合类是用于存储对象组的框架类。Java 集合框架（Java Collections Framework，JCF）提供了一套广泛的接口、实现和算法，用于处理集合。以下是一些常用的集合类及其通常用途：

List（列表）:
ArrayList：可调整大小的数组实现，支持随机访问，适合频繁的查找和更新操作。
LinkedList：双向链表实现，适合频繁的插入、删除操作，但不适合随机访问。
Set（集）:
HashSet：基于哈希表的实现，提供快速的查找、添加和删除操作。元素无序且不重复。
LinkedHashSet：HashSet 的子类，维护了一个运行于所有条目的双重链接列表，元素插入顺序与迭代顺序相同。
TreeSet：基于红黑树的实现，元素按照自然顺序或者比较器顺序排序，适合需要有序集合的场景。
Queue（队列）:
ArrayDeque：基于数组的双端队列，可以作为栈使用，也可以作为队列使用。
PriorityQueue：基于优先堆的无界优先队列，元素根据其自然顺序或者比较器排序。
Map（映射）:
HashMap：基于哈希表的实现，提供快速的键值查找操作。键值对无序。
LinkedHashMap：HashMap 的子类，维护了插入顺序的链表。
TreeMap：基于红黑树的实现，键值对按照键的自然顺序或者比较器排序。
Deque（双端队列）:
ArrayDeque：基于数组的双端队列，可以作为栈使用，也可以作为队列使用。
Concurrent Collections（并发集合）:
ConcurrentHashMap：线程安全的哈希表，用于高并发场景。
CopyOnWriteArrayList：线程安全的列表实现，适用于读多写少的场景。
BlockingQueue：线程安全的队列，用于生产者-消费者模式。
选择合适的集合类通常取决于以下几个因素：
数据是否需要排序。
是否需要快速随机访问。
插入和删除操作的频率。
是否需要线程安全。
数据量的大小。
例如，如果您需要存储一个有序的集合，您可能会选择 TreeSet 或 TreeMap。如果您需要存储大量的数据并且需要快速的查找操作，您可能会选择 ArrayList 或 HashMap。如果您处于一个多线程环境，您可能会选择并发集合，如 ConcurrentHashMap 或 BlockingQueue。

【抽象方法所在的类必须是抽象类吗】

是的，抽象方法所在的类必须是抽象类。抽象类和抽象方法是Java中用于定义一个类应该具有的基本形式和行为，但不需要为这些基本形式和行为提供具体实现的概念。
一个类如果包含至少一个抽象方法，那么这个类必须声明为抽象类。抽象类不能被实例化，它主要用于定义子类应该实现的一组抽象方法。子类必须实现这些抽象方法，否则子类也必须声明为抽象类。
下面是一个简单的例子，展示了抽象类和抽象方法的概念：

// 抽象类
abstract class Animal {
    // 抽象方法
    abstract void makeSound();
    void eat() {
        System.out.println("Animal is eating");
    }
}
// 具体类
class Dog extends Animal {
    void makeSound() {
        System.out.println("Woof woof");
    }
}
// 另一个具体类
class Cat extends Animal {
    void makeSound() {
        System.out.println("Meow meow");
    }
}

在这个例子中，Animal 类是一个抽象类，它包含一个抽象方法 makeSound()。Dog 和 Cat 类是 Animal 类的子类，它们实现了 makeSound() 方法，因此它们是具体类。
总结来说，包含抽象方法的类必须声明为抽象类，这是Java中强制的要求。

【为什么接口不能用static private修饰】

在Java中，接口（Interface）是一种特殊的类，它定义了其他类应该实现的方法。接口中的方法默认是 public 和 abstract 的，这意味着接口中的方法不能有具体的方法体，并且可以被所有实现该接口的类访问。
Java 不允许在接口中使用 static 和 private 修饰符的原因如下：

静态方法（static）：
静态方法属于类本身，而不是类的实例。这意味着您不需要创建类的对象就可以调用静态方法。
接口的目的是定义一组方法，这些方法应该被实现类的所有实例共享。静态方法与这一理念不符，因为它们不依赖于类的实例。
由于接口不能被实例化，因此静态方法在接口中没有实际意义。
私有方法（private）：
私有方法只能被同一个类中的其他方法访问。
接口的目的是定义一组公共的、可重用的方法，这些方法可以被所有实现该接口的类访问。
如果一个方法在接口中是私有的，那么它就不能被外部类访问，这与接口的公共性原则相违背。
因此，Java 设计者决定不允许在接口中使用 static 和 private 修饰符，以确保接口的公共性和可重用性。接口中的方法应该是公共的（public），并且没有具体的方法体（abstract），这样它们就可以被所有实现该接口的类共享和使用。

【方法重写和重载】

方法重载（Overloading）和重写（Overriding）是Java中用于实现多态的两种机制，它们允许您以不同的方式实现相同或相似的功能。

方法重载：
发生在同一个类中。
方法名相同，但参数列表不同（参数类型、数量或顺序不同）。
返回类型可以相同或不同。
重载的方法可以有不同的访问修饰符。
重载发生在编译时，是静态的。
方法重写：
发生在子类和父类之间。
方法名和参数列表必须相同。
返回类型必须相同（或者子类返回类型是父类返回类型的子类型）。
访问修饰符可以不同，但子类方法的访问修饰符不能比父类方法的更严格。
重写发生在运行时，是动态的。
下面是两个简单的例子：
方法重载的例子：

class Calculator {
    int add(int a, int b) {
        return a + b;
    }
    int add(int a, int b, int c) {
        return a + b + c;
    }
}

方法重写的例子：

class Parent {
    void show() {
        System.out.println("Parent class show method");
    }
}
class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child class show method");
    }
}

在重载的情况下，根据不同的参数列表，编译器会识别出不同的方法。而在重写的情况下，当子类对象调用 show 方法时，会根据运行时对象的实际类型（Child 类）来决定调用哪个 show 方法。

【接口为什么不能用final修饰】

不能，接口不能使用 final 修饰符。在Java中，接口是抽象类型的集合，它们定义了其他类应该实现的方法。接口的目的是提供一种方法签名和默认方法的实现，允许类以一种可预测的方式交互。
final 修饰符用于限制类、方法和变量的继承、重写或重载。由于接口的目的是被多个类继承和实现，所以使用 final 修饰符没有任何意义。接口中的所有方法默认都是 public 和 abstract 的，而 final 方法则不能被重写。
下面是一个简单的例子，展示了如何声明一个接口：

public interface MyInterface {
    void myMethod();
}

在这个例子中，MyInterface 是一个接口，它包含一个名为 myMethod 的抽象方法。这个方法可以被任何实现 MyInterface 接口的类实现。
总结来说，接口不能使用 final 修饰符，因为这与接口的定义和用途相违背。接口的设计目的是为了提供一种公共的、可重用的方法集，而不是限制它们的使用。

【多个catch时高级别异常类的catch字句应该放前面吗】

在Java中，当您在同一个 try 块中捕获多个异常时，您可以按照任意顺序编写 catch 字句。但是，有一个最佳实践，那就是将高级别的异常类的 catch 字句放在前面，而将更具体的异常类的 catch 字句放在后面。
这是因为高级别的异常类通常包含了更多的子类，因此它们更通用。如果您的代码中有多个异常可能抛出，最好首先捕获最一般的异常，然后依次捕获更具体的异常。这样做的好处是，如果您不小心遗漏了一个异常，或者在处理异常时出现问题，高级别的异常类可以帮助您捕捉到这些错误。
下面是一个简单的例子，展示了如何按照这种最佳实践排列 catch 字句：

try {
    // 可能会抛出异常的代码
} catch (MoreSpecificException e) {
    // 处理更具体的异常
} catch (GeneralException e) {
    // 处理更一般的异常
}

在这个例子中，MoreSpecificException 是更具体的异常类，而 GeneralException 是更高级别的异常类。按照最佳实践，我们首先捕获 MoreSpecificException，然后捕获 GeneralException。
需要注意的是，这种实践并不是强制的，您可以根据具体的需求和上下文来决定 catch 字句的顺序。但是，按照这种顺序排列 catch 字句可以帮助您更有效地处理异常，并且使代码更加清晰和易于维护。

【在构造函数设置属性值原因是什么】

在Java中，构造函数用于在对象创建时初始化对象的状态。在User类中，public User(String name, String gender, Integer age)构造函数接受三个参数，分别对应User类的三个属性：name、gender和age。使用构造函数来设置属性值的原因包括：

明确性：通过构造函数，可以明确地指定对象创建时应具有的初始状态。这使得类的使用更加直观和易于理解。
一致性：构造函数提供了一种一致的方法来初始化对象，无论是在类的内部还是在外部。这有助于保持代码的一致性和可维护性。
安全性：通过在构造函数中设置属性值，可以确保对象在使用之前已经被正确地初始化。这有助于防止空指针异常或其他与未初始化对象相关的问题。
封装：构造函数允许对对象的初始化进行封装。这意味着可以在构造函数中添加额外的逻辑，例如验证输入值或执行特定的初始化操作，而不需要修改类的其他部分。
总之，使用构造函数来设置属性值是一种良好的编程实践，它有助于保持代码的清晰性、一致性和安全性。

【webflux 和mvc的区别】

WebFlux 是 Spring 框架的一个模块，它提供了用于构建异步和非阻塞的 Web 应用程序的功能。WebFlux 是基于 Reactor 库实现的，使用了响应式编程模型，这意味着它支持数据流的异步处理，能够处理高并发的请求。
WebFlux 与传统的 Spring MVC（Model-View-Controller）模型的主要区别在于：

非阻塞和异步：WebFlux 是非阻塞的，它允许应用程序异步处理请求和响应。这意味着在处理请求时，应用程序可以同时处理其他请求，从而提高了资源的利用率和应用程序的吞吐量。
响应式类型系统：WebFlux 使用响应式编程模型，它基于 Reactor 库，使用了 Java 8 的响应式类型系统。这意味着在编写代码时，可以使用响应式 Stream API 来处理数据流，而不是传统的同步处理方式。
没有视图解析器：在 MVC 中，控制器会返回一个视图名称，然后由视图解析器找到实际的视图模板进行渲染。而在 WebFlux 中，通常返回的是数据和响应式视图组件，而不是视图名称，因此不需要视图解析器。
函数式编程：WebFlux 倾向于使用函数式编程风格，这使得代码更加简洁和易于理解。例如，可以使用函数字面量来创建 REST 控制器，而不是传统的 Java 类和方法。
总的来说，WebFlux 提供了一种构建现代、高并发的 Web 应用程序的方式，它利用了响应式编程和异步处理的优势，与传统的同步 MVC 模型相比，可以提供更好的性能和可伸缩性。

【使用AtomicLong 来生成数据的id】

private ConcurrentMap<Long, City> repository = new ConcurrentHashMap<>();

private static final AtomicLong idGenerator = new AtomicLong(0);

public Long save(City city) {
    Long id = idGenerator.incrementAndGet();
    city.setId(id);
    repository.put(id, city);
    return id;
}

AtomicLong是Java中用于生成唯一递增ID的一种线程安全的方式。在以下情况下，使用AtomicLong来生成数据ID可能是合适的：

需要唯一ID：当需要确保每个生成的ID都是唯一的时，AtomicLong非常有用。由于它是一个原子操作，每次调用incrementAndGet都会确保返回的ID是当前最大ID加一，这保证了ID的唯一性。
多线程环境：在多线程环境中，使用AtomicLong可以避免同步问题，因为它提供了原子性的自增操作。这意味着即使在多个线程同时尝试生成ID的情况下，也不会发生竞争条件或数据不一致的问题。
高性能需求：AtomicLong的实现通常比使用锁或其他同步机制要快，因此在追求高性能的应用程序中，使用AtomicLong生成ID是一个好选择。
分布式系统：在分布式系统中，每个节点可能需要生成唯一的ID。AtomicLong可以在各个节点上独立地生成ID，而且由于其原子性，可以保证即使节点之间有通信延迟或者部分节点失败，也不会产生重复的ID。
ID生成策略：有时候，除了递增之外，ID生成策略可能还需要包含其他信息，比如时间戳或者机器标识。虽然AtomicLong只提供递增的功能，但是可以与其他机制结合使用，例如在ID的前面或后面拼接时间戳或机器ID，以满足特定的ID生成策略。
简单性：AtomicLong是一个非常简单的API，只需要几个方法就可以工作。如果不需要复杂的ID生成逻辑，那么使用AtomicLong可以让代码更加简洁明了。
总之，AtomicLong适用于需要线程安全、唯一递增ID的场景，特别是当应用程序是多线程的，或者在分布式环境中运行时。然而，如果你的ID生成策略需要更复杂的逻辑，可能需要考虑其他更高级的实现方式。

【什么情况下需要序列化实体类】

在Java中，一个实体类（POJO，Plain Old Java Object）通常需要实现序列化（Serializable）接口，以便能够在不同的JVM之间传输对象或者将对象持久化到文件系统、数据库等。以下是一些常见的情况，在这些情况下，创建的实体类POJO需要实现序列化：

跨网络传输对象：当你需要通过网络将一个对象从一个JVM发送到另一个JVM时，例如在分布式系统中传递消息时，对象需要被序列化。
持久化对象：当你需要将对象保存到文件系统或数据库中，以便以后可以恢复对象状态时，对象需要被序列化。
使用缓存机制：如果你在应用程序中使用缓存框架（如Ehcache、Guava Cache等），并且希望将对象缓存到磁盘，或者在多个JVM之间共享缓存，那么这些对象需要是可序列化的。
分布式缓存：在使用分布式缓存（如Redis）时，如果要在不同的节点之间存储和传输对象，对象需要实现序列化。
消息队列：在使用消息队列（如RabbitMQ、Kafka等）时，如果要在不同应用程序或服务之间传递消息，消息中的对象需要是可序列化的。
对象作为Java RMI的参数或返回值：当使用Java远程方法调用（RMI）时，如果要从一台机器上调用另一台机器上的方法并传递或接收对象，这些对象需要是可序列化的。
实现序列化的基本步骤是：
确保你的类实现了 java.io.Serializable 接口。
如果你想要在对象被反序列化时恢复其原始的类类型，确保在 Serializable 接口的实现类中定义一个 readResolve() 方法。
注意：从Java 8开始，所有的Java对象默认都是可序列化的，除非它们实现了 java.io.Externalizable 接口或声明了 @NonSerializable 注解。然而，为了保持向后兼容性，建议显式实现 Serializable 接口。

【Hbase和Mysql区别】

HBase和MySQL是两种不同类型的数据库管理系统，它们各自适用于不同的场景和需求。

HBase

HBase是一个分布式的、可伸缩的、面向列的存储系统，它是Apache软件基金会的一个开源项目，基于Google的Bigtable模型构建，并运行在Hadoop生态系统之上。HBase适合于非结构化数据存储，可以存储非常大量的数据，并且能够处理大量的数据读写操作。

HBase的特点：

面向列存储：HBase按列存储数据，这非常适合于只访问表中特定列的场景。
可伸缩性：HBase可以轻松地通过添加更多的服务器来水平扩展。
高吞吐量：适用于写操作远大于读操作的场景。
稀疏性：列可以动态添加，而且空列不占用空间，适合存储稀疏数据。
实时读写：HBase支持随机实时读写操作。

MySQL

MySQL是一个关系型数据库管理系统，由Oracle公司开发、发布和支持。它是一个流行的开源数据库，广泛用于各种Web应用程序、内容管理系统和企业级应用程序。MySQL使用SQL作为查询语言，并且支持事务、复杂查询和高级索引等功能。

MySQL的特点：

关系型数据库：数据以表格的形式存储，非常适合结构化数据。
事务支持：支持ACID事务，确保数据的一致性和完整性。
复杂查询：支持复杂的SQL查询，包括联结、子查询等。
索引：支持多种类型的索引，可以提高查询性能。
易用性：MySQL易于安装和使用，拥有大量的文档和社区支持。

使用场景

使用MySQL的情况：
当你需要一个结构化数据存储解决方案时。
当你需要支持复杂的交易和高级查询操作时。
当你的数据量不是特别大，或者当你需要高性能的SQL查询时。
当你需要成熟的生态系统和广泛的技术支持时。
使用HBase的情况：
当你需要存储和处理大量的非结构化或半结构化数据时。
当你需要高吞吐量的写入操作，尤其是键值对或列式数据访问模式时。
当你需要跨多个服务器动态扩展数据存储时。
当你已经在使用Hadoop生态系统，并且需要与Hadoop的其他组件（如HDFS、MapReduce、Spark等）集成时。
总结来说，MySQL更适合结构化数据、复杂的交易和关系型查询，而HBase更适合大数据场景、非结构化数据存储和高吞吐量写入操作。选择哪种数据库取决于你的具体需求和现有技术栈。

【H2 database】

H2 Database 是一个纯 Java 实现的轻量级关系型数据库。它被设计为内存数据库，但同时也支持将数据持久化到磁盘。H2 数据库通常被用作开发或测试环境中的数据库，因为它的启动快速，并且可以轻松地与其他 Java 应用程序集成。

H2 数据库的主要特点：

内存数据库：H2 数据库可以将所有数据存储在内存中，这使得它的读写速度非常快。
磁盘存储：虽然 H2 数据库是内存数据库，但它也支持将数据持久化到磁盘，这样即使重启数据库，数据也不会丢失。
多用户支持：H2 数据库支持多用户同时访问和写入，这使得它也适合用于需要多用户访问的环境。
SQL 兼容性：H2 数据库支持标准的 SQL 语法，这使得使用熟悉 SQL 的开发者可以轻松地使用它。
易于使用的图形界面：H2 数据库提供了一个内置的命令行工具和图形界面，方便用户管理数据库和执行 SQL 命令。
JDBC 驱动：H2 数据库提供了 JDBC 驱动，这意味着它可以轻松地与其他 Java 应用程序集成。
安全特性：H2 数据库支持用户管理和访问控制，可以设置用户密码，并为不同用户分配不同的权限。

使用场景：

开发和测试：由于其轻量级和快速的特点，H2 数据库非常适合用于开发和测试环境。
嵌入式数据库：对于需要将数据库嵌入到应用程序中的场景，H2 是一个很好的选择。
教学和培训：由于其简单性和易用性，H2 数据库常被用于数据库教学和培训。

限制：

数据量：尽管 H2 数据库支持磁盘存储，但当数据量非常大时，其性能可能不如大型关系型数据库。
事务：H2 数据库支持事务，但当数据量非常大时，事务可能不如大型数据库那样高效。
综上所述，H2 数据库是一个适合开发、测试和小型应用的数据库，它提供了快速的数据访问和方便的集成方式。

【innodb相比其他引擎有什么优点】

InnoDB 是 MySQL 中一个广泛使用的存储引擎，它提供了具有事务管理、行级锁定、外键约束等特性的关系数据库服务。与其他数据库引擎相比，InnoDB 具有以下优点：

支持事务：InnoDB 支持 ACID（原子性、一致性、隔离性、持久性）事务，这意味着它可以确保在多用户环境中数据的一致性和完整性。
行级锁定：InnoDB 使用行级锁定，这有助于在高并发环境中减少锁定冲突，提高数据库的并发性能。
外键约束：InnoDB 支持外键约束，这有助于保持数据库的参照完整性，确保相关联的表之间的数据一致性。
自适应哈希索引：InnoDB 能够自动选择使用 B-Tree 索引或哈希索引，这取决于查询模式和数据分布，从而优化查询性能。
数据持久性：InnoDB 将数据保存在磁盘上，并且支持崩溃恢复能力，这意味着即使数据库服务意外停止，也不会丢失数据。
空间效率：InnoDB 支持数据表空间，它允许表的物理存储被分布在多个文件中，这有助于提高空间利用率和数据库性能。
全文索引：InnoDB 支持全文索引，这对于处理需要全文搜索的应用程序非常有用。
视图和存储过程：InnoDB 支持视图和存储过程，这有助于复杂的数据操作和查询。
用户和权限管理：InnoDB 允许进行用户和权限的管理，支持基于角色的访问控制。
与 MySQL 服务整合：InnoDB 是 MySQL 的一部分，与 MySQL 服务紧密整合，使得配置和管理变得更加简单。
由于这些优点，InnoDB 通常被推荐用于需要事务支持、并发性能和数据一致性的应用场景。

【为什么开发中严禁使用实体entity做出入参对象】

在开发中严禁使用实体对象作为出入参对象的原因有几点：

耦合性高： 实体对象通常表示持久化层的数据模型，直接将其作为出入参对象会导致业务逻辑与持久化层耦合，违反了分层设计原则。
安全性差： 实体对象中通常包含数据库表的所有字段，将其直接暴露给外部接口可能会泄露敏感信息。
灵活性差： 实体对象的字段通常与数据库表字段一一对应，如果需要向外部接口返回不同的数据结构，可能需要对实体对象进行大量的修改。
业务需求变更困难： 如果业务需求发生变更，需要修改实体对象，可能会影响到其他模块的使用，增加了维护成本。

为了解决这些问题，通常建议使用专门设计的 DTO（Data Transfer Object）或 VO（View Object）作为出入参对象，这些对象根据业务需求设计，
可以包含实体对象的部分字段，也可以包含其他业务需要的字段，从而实现数据传输的灵活性、安全性和解耦。

【github的fork是什么意思】

在 GitHub 中，Fork 是指将别人的项目复制到自己的 GitHub 账户下，成为独立的项目。Fork 的操作会在你的 GitHub 账户下创建目标项目的一个副本，
你可以在这个副本上进行任何修改、提交和操作，而不会影响到原始项目。通过 Fork，你可以自由地修改和定制项目，然后可以选择是否将你的修改贡献回原始项目，
提出 Pull Request 请求，让原始项目的所有者考虑并接受你的修改。 Fork 在开源社区中被广泛使用，是一种推动开源协作和贡献的重要机制。

【Jason序列化时怎么排除掉值为null的字段】

在 Java 使用 Spring Boot 开发应用程序时，@JsonInclude(JsonInclude.Include.NON_NULL) 注解通常用于指定 Jackson 库在序列化（将对象转换为 JSON）时如何处理 null 值。
@JsonInclude 注解是 Jackson 数据格式化包中的一个注解，它有以下几个作用：

控制序列化：你可以使用这个注解来控制哪些字段应该被包含在序列化的 JSON 对象中，哪些字段不应该被包含。
过滤 null 值：当 @JsonInclude 注解的值为 NON_NULL 时，它告诉 Jackson 在序列化对象时不要包括 null 值的字段。这意味着如果一个字段的值为 null，那么这个字段不会被包含在生成的 JSON 字符串中。
提高性能：通过排除 null 值的字段，可以减少序列化后的 JSON 字符串的大小，从而提高性能。
提高可读性：在某些情况下，包含 null 值的字段可能会导致接收方误解数据，因为 null 值在 JSON 中没有直接对应的字符串表示。

【将常量定义在接口中有什么好处】

1.无需实例化：接口中的常量是隐式静态的，无需实例化即可使用。
2.清晰可见：将常量放在接口中可以清晰地展示这些常量的意图和用途，让其他开发者更容易理解和使用。
3.便于访问：其他类只需实现该接口或者直接访问接口中的常量即可使用，不需要继承或者创建实例。

【什么是saas】

SaaS（Software as a Service，软件即服务）是一种软件分发模型，在这种模型中，软件应用程序是通过互联网提供给用户的，用户通常通过订阅的方式支付使用费，而不是购买软件的许可证。SaaS 提供商托管、管理和维护应用程序，用户可以通过互联网从任何设备访问这些应用程序。
SaaS软件可以用来管理各种事物，包括但不限于：

客户关系管理（CRM）：帮助企业管理和自动化与客户之间的互动，提高销售和客户服务效率。
内容管理系统（CMS）：用于创建、编辑、发布和管理网站内容。
项目管理：帮助团队规划、执行和跟踪项目进度，确保项目按时按预算完成。
人力资源管理（HRM）：包括招聘、员工管理、薪酬和福利管理等功能。
财务管理：处理会计、报告、预算和资金管理等工作。
供应链管理：优化供应链流程，包括采购、库存管理、物流等。
协作工具：如电子邮件、文档共享、日历管理等，帮助团队成员高效协作。
数据库管理：提供数据存储、检索和管理功能。
业务智能（BI）工具：分析企业数据，提供洞察以支持决策制定。
教育工具：如在线学习管理系统（LMS），用于创建和分发课程内容。
SaaS软件的主要优势包括易于部署、可扩展性、灵活性和成本效益。由于SaaS提供商负责维护和更新软件，用户可以专注于他们的核心业务，而不必担心软件的维护和升级。此外，SaaS软件通常通过云平台提供，这意味着用户可以随时随地通过互联网访问它们。

【自定义的注解都必须指定@Target、@Retention吗】

在 Java 中，自定义注解并不一定非得指定 @Target 和 @Retention 注解，但是它们是两个非常有用的元注解，用于描述自定义注解的使用范围和生命周期。

@Target：这个注解用于指定自定义注解可以应用于 Java 代码的哪些元素，比如类、方法、字段、参数等。如果不显式指定 @Target，默认情况下，自定义注解可以应用于所有这些元素。
@Retention：这个注解用于指定自定义注解的生命周期，即它会在哪个阶段有效。如果不显式指定 @Retention，默认情况下，自定义注解在编译时（compilation phase）有效。
尽管不是强制性的，但是指定 @Target 和 @Retention 通常是一个好习惯，因为它：

提高了代码的可读性和可维护性。
限制了自定义注解的使用范围，防止它被错误地应用于不合适的元素。
明确了自定义注解的有效生命周期，有助于开发者理解它的用途。
总之，虽然自定义注解可以不指定 @Target 和 @Retention，但它们通常会提供更多的信息，帮助开发者更好地使用和理解这些注解。

【自定义异常类继承RuntimeException有什么好处】

在 Java 中，自定义异常类通常有两种方式：直接继承 Exception 类或继承其子类 RuntimeException 类。当你的自定义异常类继承 RuntimeException 时，会有以下好处：

更宽松的处理：RuntimeException 类型的异常通常不需要在代码中显式地捕获或处理。这是因为它们代表了编程错误或条件，应当由开发者负责修复。相比之下，Exception 类型的异常（如 IOException）通常需要在代码中进行处理。
性能优化：由于 RuntimeException 类型的异常不需要显式处理，因此编译器不会为这些异常生成额外的处理代码，这可能会带来一些性能上的优化。
更自然的异常链：如果你的自定义异常是另一个异常的更具体子类型，那么继承 RuntimeException 可能会更自然。例如，如果你有一个自定义的运行时异常，它代表了一个特定的编程错误，那么直接继承 RuntimeException 可能更合适。
然而，使用 RuntimeException 也有一些限制：

不能被捕获：由于 RuntimeException 类型的异常不需要显式处理，因此你无法在代码中捕获这些异常。
不能被声明抛出：在方法的签名中，你不能声明抛出 RuntimeException 类型的异常，因为这被认为是不良的编程实践。
总之，自定义异常类继承 RuntimeException 可以提供一些便利和性能优势，但它也限制了异常的处理方式和声明方式。你应该根据具体的应用场景和需求来决定是否以及如何使用 RuntimeException。

【spring.factories是干嘛的】

spring.factories 是 Spring Framework 中的一种机制，用于自动化配置和加载 Spring 应用程序的组件。在 Spring Boot 中，spring.factories 文件通常位于项目的 META-INF 目录下，
用于声明自动配置类、监听器、事件等。这个文件采用 Java 属性文件的格式，其中的键是要加载的自动配置类的全限定名，对应的值是一个或多个自动配置类的全限定名，以逗号分隔。
Spring Boot 在启动时会加载 spring.factories 文件，并根据文件中配置的内容来自动装配应用程序所需的各种组件。这样的设计使得 Spring Boot 应用程序的配置变得更加简单和自动化，
开发者无需手动配置大量的组件，而是通过引入相应的依赖和配置文件即可实现自动配置。
总之，spring.factories 文件提供了一种标准的扩展机制，允许开发者通过配置文件来声明和注册 Spring 应用程序中的各种组件，从而实现自动化配置和加载。

【RestTemplate用来干嘛】

RestTemplate 是 Spring 提供的用于访问 RESTful 服务的客户端工具，它封装了 HTTP 请求的发送和响应的处理，使得在 Java 应用中轻松地与 RESTful 服务进行交互。

具体来说，RestTemplate 可以用来完成以下任务：

发送 HTTP 请求: 可以发送 GET、POST、PUT、DELETE 等各种类型的 HTTP 请求到指定的 URL，与 RESTful 服务进行通信。
处理 HTTP 响应: 可以接收和处理来自 RESTful 服务的 HTTP 响应，包括获取响应状态码、响应头信息和响应体数据等。
支持各种数据格式: 支持处理多种数据格式，包括 JSON、XML、HTML 等，可以方便地将请求和响应数据转换为 Java 对象或其他格式。
集成各种 HTTP 客户端功能: 内置了连接池、请求重试、HTTP 链接超时、代理设置等功能，提供了丰富的配置选项，可以满足不同场景下的需求。
简化 RESTful 服务调用: 通过封装 HTTP 请求和响应的细节，提供了简洁易用的 API，使得调用 RESTful 服务变得更加方便和快捷。

总之，RestTemplate 是在 Java 应用中进行 RESTful 服务调用的常用工具，可以帮助开发人员轻松地实现与外部 RESTful 服务的通信，并且提供了丰富的功能和配置选项，以满足不同场景下的需求。

【RedisTemplate是用来干嘛】

RedisTemplate 是 Spring 提供的用于与 Redis 数据库进行交互的模板类，它封装了 Redis 的操作，简化了在 Spring 应用中使用 Redis 的过程。

具体来说，RedisTemplate 主要用于以下几个方面：

连接 Redis 数据库: RedisTemplate 可以创建与 Redis 数据库的连接，并管理连接的生命周期。它负责与 Redis 服务器建立连接、发送命令、接收响应等操作。
执行 Redis 命令: RedisTemplate 提供了一系列方法用于执行 Redis 命令，包括字符串操作、列表操作、哈希操作、集合操作、有序集合操作等。开发人员可以通过调用这些方法来操作 Redis 中的数据。
支持序列化与反序列化: RedisTemplate 支持将 Java 对象序列化为 Redis 数据格式存储到 Redis 中，也支持从 Redis 中读取数据并将其反序列化为 Java 对象。它提供了多种序列化器（Serializer）供开发人员选择，包括 JSON、Java 序列化、Jackson 等。
提供事务支持: RedisTemplate 支持事务操作，开发人员可以通过 multi()、exec()、discard() 等方法开启、提交或回滚 Redis 事务。
封装管道（Pipeline）操作: RedisTemplate 可以封装管道操作，将多个 Redis 命令一次性发送到服务器，并在服务器执行完所有命令后将结果一次性返回，从而提高了批量操作的效率。

总之，RedisTemplate 是 Spring 提供的与 Redis 数据库交互的核心组件，它简化了在 Spring 应用中使用 Redis 的过程，提供了丰富的功能和灵活的配置选项，能够满足不同场景下的需求。

【 @ConditionalOnMissingBean({ClientHttpRequestFactory.class})这个注解什么作用】

@ConditionalOnMissingBean 是 Spring Boot 提供的条件注解之一，它的作用是：当容器中不存在指定类型的 Bean 时，才会实例化被注解的 Bean。
在这个例子中，@ConditionalOnMissingBean({ClientHttpRequestFactory.class}) 表示如果容器中不存在类型为 ClientHttpRequestFactory 的 Bean，就会创建被注解的 Bean。

【@bean】

在 Spring Boot 应用程序中，当您在一个方法上使用 @Bean 注解时，这个方法将被视为一个 Bean 定义，并且 Spring Boot 能够扫描并注册这个 Bean。但是，这通常适用于 Spring Boot 的自动配置类，而不是普通的 Spring 组件类。
以下是一些关于在方法上使用 @Bean 注解的要点：

自动配置类：在 Spring Boot 的自动配置类上，您可以使用 @Bean 注解来定义 Bean。这些自动配置类通常以 @Configuration 注解标记，并且 Spring Boot 在启动时会扫描这些类。
Spring 组件类：如果您在一个普通的 Spring 组件类（即没有 @Configuration 注解的类）上的方法上使用 @Bean 注解，这个 Bean 定义可能不会被 Spring Boot 自动扫描和注册。为了使 Spring Boot 能够扫描这些 Bean，您需要将这个类标记为 @Component 或其他相应的 Spring 组件注解，如 @Service、@Repository 等。
条件化 Bean：在方法上使用 @Bean 注解时，您可以利用 @Conditional 注解来定义 Bean 的条件化逻辑。这样，只有在满足特定条件时，Bean 才会被创建。
启动类：在 Spring Boot 应用程序的启动类（带有 @SpringBootApplication 注解的类）中，您通常不需要使用 @Bean 注解来定义 Bean，因为 Spring Boot 已经在启动类上使用了 @ComponentScan 注解来扫描相关的组件。
总之，在方法上使用 @Bean 注解可以定义 Bean，但为了确保 Spring Boot 能够扫描和注册这些 Bean，您可能需要将相关的类标记为 Spring 组件，并考虑使用 @Conditional 注解来定义条件化逻辑。

在 Spring 应用程序中，如果您在一个普通类（即没有 @Configuration 注解的类）中的方法上使用 @Bean 注解，这个方法本身并不会被 Spring 容器自动注册为一个 Bean。这是因为在 Spring 中，@Bean 注解是 @Configuration 类的一部分，用于定义类中的方法作为 Bean 定义。
为了使 Spring 容器能够扫描和注册这些 Bean，您需要将类本身标记为 Spring 组件，例如使用 @Component、@Service、@Repository 等注解。这样，Spring 容器在启动时会扫描这些组件类，并将它们中的 @Bean 方法作为 Bean 定义注册到容器中。
以下是一些关键点：

@Configuration 类：在 @Configuration 类中，您可以使用 @Bean 注解来定义方法作为 Bean 定义。这些 Bean 定义会在应用程序启动时被 Spring 容器扫描和注册。
普通类：在一个普通的类中，即使您在方法上使用了 @Bean 注解，这个方法也不会自动被注册为一个 Bean。
标记为 Spring 组件：为了让 Spring 容器能够扫描和注册这些 Bean，您需要将类标记为 Spring 组件。例如，使用 @Component 注解。
自定义扫描：您还可以通过 @ComponentScan 注解来自定义 Spring 容器的扫描路径，以便容器能够找到这些组件类。
总之，为了使 Spring 容器能够扫描和注册 @Bean 方法，您需要将类标记为 Spring 组件，并在必要时自定义扫描路径。

【当集合类存储元素个数固定时，最好指定初始容量节省内存空间】

        XhzxUser xhzxUser = ((XhzxUser) authentication.getPrincipal());
        Map<String,Object> map = new HashMap<>(2);
        map.put(SecurityConstant.XHZX_USER_INFO,xhzxUser);
        map.put(SecurityConstant.AUTHOR,SecurityConstant.JWT_AUTHOR);
        defaultOAuth2AccessToken.setAdditionalInformation(map);

【 @SneakyThrows作用】

@SneakyThrows 是 Lombok 库中的一个注解，它用于简化 Java 中的异常处理。当你在一个方法上使用 @SneakyThrows 注解时，Lombok 会在编译时生成代码，
这个代码会捕获任何受检（checked）异常，并将其转换为一个未受检（unchecked）异常，通常是 RuntimeException。

【spring-cloud-starter-gateway、spring-cloud-starter-openfeign、spring-boot-starter-reactor-netty这三个作用】

在 Spring Cloud 和 Spring Boot 的生态系统中，以下是对 spring-cloud-starter-gateway、spring-cloud-starter-openfeign 和 spring-boot-starter-reactor-netty 这三个 starter 的作用的解释：

spring-cloud-starter-gateway：
- 这个 starter 提供了 Spring Cloud Gateway 的支持。
- Spring Cloud Gateway 是一个用于构建 API 网关的 Spring 框架项目。
- 它提供了动态路由、监控、弹性和安全等特性。
- 开发者可以使用 Spring Cloud Gateway 来处理外部请求，并将其转发到相应的微服务。
spring-cloud-starter-openfeign：
- 这个 starter 提供了对 OpenFeign 的支持。
- OpenFeign 是一个声明式的、模板化的 HTTP 客户端，用于简化微服务之间的 HTTP 请求调用。
- 它允许开发者通过简单的接口定义来调用其他服务，而不需要编写复杂的 HTTP 客户端代码。
- OpenFeign 集成了 Ribbon 和 Hystrix，提供了负载均衡和服务熔断等功能。
spring-boot-starter-reactor-netty：
- 这个 starter 提供了对 Reactor Netty 的支持。
- Reactor Netty 是一个基于 Netty 的反应式 HTTP 服务器和客户端实现。
- 它适用于构建高性能的 Web 应用程序和服务。
- 开发者可以使用 Reactor Netty 来创建反应式的 HTTP 服务器或客户端。
  总之，这三个 starter 分别提供了对 Spring Cloud Gateway、OpenFeign 和 Reactor Netty 的支持，有助于构建高度可扩展和反应式的微服务架构。

【启动类上加@EnableFeignClients的作用】

@EnableFeignClients 是 Spring Cloud 中的一个注解，用于启用 Feign 客户端的功能。Feign 是一个声明式、模板化的 HTTP 客户端，它使得编写 HTTP 客户端变得更加简单和优雅。
具体而言，@EnableFeignClients 的作用包括：

激活 Feign 客户端功能：通过在 Spring Boot 应用程序中添加 @EnableFeignClients 注解，可以启用 Feign 客户端功能，从而能够在应用程序中声明和使用 Feign 客户端。
扫描 Feign 客户端接口：在启用 Feign 客户端功能后，Spring Boot 会自动扫描应用程序中的 Feign 客户端接口，以便将它们注册为 Spring Bean，并为其创建代理实现。
集成 Ribbon 负载均衡：Feign 与 Ribbon 整合，可以利用 Ribbon 提供的负载均衡功能。在使用 Feign 调用服务时，Feign 将自动使用 Ribbon 提供的负载均衡策略，从而实现对服务的负载均衡调用。
简化 HTTP 客户端的使用：Feign 提供了一种声明式的方式来定义和调用 HTTP 客户端，相比传统的编程式调用方式更加简洁和易用。通过 @FeignClient 注解定义客户端接口，
并在接口中声明需要调用的远程服务的 HTTP 方法，Feign 将自动根据接口定义生成实现类。
总之，@EnableFeignClients 注解的作用是启用 Feign 客户端功能，并简化了在 Spring Boot 应用程序中调用远程服务的方式。

【什么是setting.xml、什么是pom.xml】

从 settings.xml 的文件名就可以看出，它是用来设置 maven 参数的配置文件。
settings.xml 是 maven 的全局配置文件。而 pom.xml 文件是所在项目的局部配置。
settings.xml 中包含类似本地仓储位置、修改远程仓储服务器、认证信息等配置。
POM是 “Project Object Model” 的简写，它是一个 XML 声明，在 Maven 项目中保存在一个名为 pom.xml 的文件里。
对于 Maven 项目来说，它不仅仅是一个包含代码文件的集合。一个项目包含配置文件，涉及的开发人员以及他们扮演的角色，缺陷跟踪系统，组织和许可证，项目所在位置的URL，项目的依赖关系，以及所有其他可以赋予代码生命的小部件。
事实上，在 Maven 的世界中，一个项目甚至可以不包含任何代码，只需要一个 pom.xml。

【spring-boot-starter-amqp】

spring-boot-starter-amqp是什么
spring-boot-starter-amqp 是 Spring Boot 的一个启动器（Starter），它用于简化在 Spring Boot 应用中集成 RabbitMQ 的过程。RabbitMQ 是一个开源的消息队列系统，它实现了高级消息队列协议（AMQP）。
spring-boot-starter-amqp 提供了哪些功能
自动配置：自动配置 RabbitMQ 的连接工厂、模板和监听器容器等，减少了手动配置的复杂性。
连接管理：提供了对 RabbitMQ 连接的自动管理，包括连接的创建和关闭。
消息发送：通过 RabbitTemplate，可以非常方便地发送消息到 RabbitMQ 队列。
消息接收：支持消息的自动接收，可以通过注解 @RabbitListener 来声明消息监听器。
异常处理：提供了对消息处理过程中可能出现的异常的处理机制。
消息转换：自动将 Java 对象转换为适合发送的消息格式，并在接收时将消息转换为 Java 对象。
声明队列、交换器和绑定：可以通过配置或注解的方式来声明 RabbitMQ 的队列、交换器和它们之间的绑定关系。
怎么使用

1.添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2.配置 RabbitMQ 连接
在 application.properties 或 application.yml 文件中配置 RabbitMQ 的连接信息：
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=user
spring.rabbitmq.password=password

3.使用 RabbitTemplate 发送消息

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MessageSender {

    private final RabbitTemplate rabbitTemplate;

    @Autowired
    public MessageSender(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void sendMessage(String exchange, String routingKey, String message) {
        rabbitTemplate.convertAndSend(exchange, routingKey, message);
        System.out.println("Message sent: " + message);
    }
}

接收消息

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class MessageReceiver {

    @RabbitListener(queues = "${spring.rabbitmq.queue}")
    public void receiveMessage(String message) {
        System.out.println("Message received: " + message);
        // 处理接收到的消息
    }
}

5.配置

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    @Bean
    public Queue queue() {
        return new Queue("myQueue");
    }
}

6.示例

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class ExampleRunner implements CommandLineRunner {

    private final MessageSender messageSender;

    @Autowired
    public ExampleRunner(MessageSender messageSender) {
        this.messageSender = messageSender;
    }

    @Override
    public void run(String... args) {
        messageSender.sendMessage("myExchange", "myRoutingKey", "Hello, RabbitMQ!");
    }
}

这样，当应用启动时，ExampleRunner会发送一条消息到RabbitMQ中，而MessageReceiver则会监听并接收到该消息。

【spring-boot-starter-amqp和rabbitmq、rocketmq、kafka有什么区别】

spring-boot-starter-amqp 是 Spring Boot 的一个启动器，它专门用于简化在 Spring Boot 应用中集成 RabbitMQ 的过程。RabbitMQ 是一个消息队列中间件，实现了高级消息队列协议（AMQP）。而 RabbitMQ、RocketMQ 和 Kafka 则是三种不同的消息队列系统，它们各自有自己的特点和用途。

RabbitMQ

协议：实现了 AMQP 协议，这是一个开放的国际标准。
特点：支持多种消息传递模式（如点对点、发布/订阅），提供可靠的消息传递、持久化、事务和消息排序等特性。
使用场景：适用于需要强大消息保证、灵活的路由和多样化的消息模式的场景。

RocketMQ

协议：是阿里巴巴开源的一个消息中间件，支持自定义协议。
特点：提供高吞吐量、高可用性，支持顺序消息、批量消息、定时消息和消息过滤等功能。
使用场景：适用于大规模分布式系统的场景，特别是需要处理大量消息的场景。

Kafka

协议：最初由 LinkedIn 开发，现在为 Apache 软件基金会的一部分，使用自己的协议。
特点：具有高吞吐量、可扩展性和持久性，适用于处理大量的实时数据。
使用场景：适用于构建实时数据管道和流式处理平台，也常用于日志收集、流式分析和事件源应用。

spring-boot-starter-amqp

作用：它是 Spring Boot 的一个组件，用于自动配置 RabbitMQ 客户端，简化 RabbitMQ 的集成。
特点：提供了自动配置、连接管理、模板和监听器容器等，使得在 Spring Boot 应用中集成 RabbitMQ 变得非常简单。

区别

协议和实现：RabbitMQ 实现了 AMQP 协议，而 RocketMQ 和 Kafka 使用自己的协议。
功能和特性：每个消息队列系统都有自己独特的功能和特性，比如 RabbitMQ 的消息保证和灵活的路由，RocketMQ 的顺序消息和定时消息，Kafka 的高吞吐量和持久性。
使用场景：不同的消息队列系统适用于不同的场景，根据应用的需求选择合适的消息队列系统。
集成方式：spring-boot-starter-amqp 是专门用于集成 RabbitMQ 的 Spring Boot 启动器，而 RocketMQ 和 Kafka 则需要使用其他 Spring Boot 启动器或第三方库来进行集成。
总结来说，spring-boot-starter-amqp 是一个工具，用于简化 RabbitMQ 的集成，而 RabbitMQ、RocketMQ 和 Kafka 是三种不同的消息队列系统，它们各自有不同的特点和用途。开发者需要根据应用的需求和场景选择合适的消息队列系统，并使用相应的工具或库进行集成。

【什么是Hystrix、什么是sentinel，springboot怎么快速集成这2个组件】

Hystrix 和 Sentinel 都是流行的容错和限流组件，用于提高微服务架构的可靠性和稳定性。它们可以防止因为服务间依赖关系的故障或者高负载而导致的整个系统的崩溃。

Hystrix
Hystrix 是 Netflix 提供的一个开源的容错框架，用于处理分布式系统之间的延迟和故障。它通过在服务之间添加断路器，超时机制，降级策略等来防止服务雪崩，保证系统的稳定性。

Sentinel
Sentinel 是阿里巴巴开源的一款面向分布式服务架构的轻量级流量控制组件，具备实时监控、控制台限流规则动态修改、熔断降级、系统负载保护等功能，能够在高并发的场景下保护服务的稳定性。

集成 Hystrix
1.添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

2.在启动类上加上 @EnableHystrix 注解来启用 Hystrix 功能。

3.在需要容错处理的方法上加上 @HystrixCommand 注解，指定处理超时和错误的回退方法。

集成 Sentinel
1.添加依赖

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

2.在 application.properties 或 application.yml 中配置 Sentinel 的规则、数据源等信息。

3.使用 @SentinelResource 注解来定义资源，并配置相应的流量控制、熔断降级等规则。

4.在启动类上加上 @EnableSentinel 注解来启用 Sentinel 功能。