# MyWiki

**Repository Path**: suddenlyyo/MyWiki

## Basic Information

- **Project Name**: MyWiki
- **Description**: maven 模块化工程，Java 代码demo， 包含Mq整合 ，事务处理
- **Primary Language**: Java
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-12-18
- **Last Updated**: 2025-07-24

## Categories & Tags

**Categories**: Uncategorized

**Tags**: Spring, SpringBoot, Socket, MyBatis, mq

## README

# java代码demo
:toc:
## Java 项目中包 domain、entity、model 的区别

Entity 一般情况下此结构与数据库结构一一对应，作为程序与数据库的映射桥梁。

Model 针对某一个业务需求，组合或是过滤一组数据。

Domain 一般是一组数据组合，包含某一个大业务逻辑的所有数据集合。

ps：model 和 domain 概念比较重合，都是对业务的数据抽象，主要区别是 model 更多用在传统的MVC结构中，domain 更多的使用在微服务架构或是DDD原则设计的项目中。也可以按照domain比model范围更大的角度来理解。实际使用中，如果项目不是特别大，可以model或domain二选一。

## junit4和junit5 对比

|===
| 特征               | JUNIT 4        | JUNIT 5

| 声明一种测试方法
| @Test
| @Test

| 在当前类中的所有测试方法之前执行
| @BeforeClass
| @BeforeAll

| 在当前类中的所有测试方法之后执行
| @AfterClass
| @AfterAll

| 在每个测试方法之前执行
| @Before
| @BeforeEach

| 每种测试方法后执行
| @After
| @AfterEach

| 禁用测试方法/类
| @Ignore
| @Disabled

| 测试工厂进行动态测试
| NA
| @TestFactory

| 嵌套测试
| NA
| @Nested

| 标记和过滤
| @Category
| @Tag

| 注册自定义扩展
| NA
| @ExtendWith
|===

## 注解式事务

在以下情况下，注解式事务可能会失效：

1. 当一个未被捕获的异常抛出时，事务将自动回滚。但是，如果异常被捕获并在try-catch块中处理，那么事务将不会回滚。
2. 当使用@Transactional注解的方法被另一个没有使用@Transactional注解的方法调用时，事务将失效。
3. 当在同一类中调用带有@Transactional注解和不带有@Transactional注解的方法时，事务将失效。
4. 当使用PROPAGATION\_REQUIRES\_NEW事务传播类型时，在嵌套事务内部调用外部事务也会导致事务失效。
5. 当使用基于AspectJ的声明式事务而不是基于Spring AOP的声明式事务时，事务可能会失效。

原因：

1. 当异常被捕获并处理时，相当于告诉事务管理器不需要回滚，因此事务不会回滚。
2. 未使用@Transactional注解的方法没有启动事务，因此调用它的方法也无法使用事务。
3. 在同一个类中调用带有和不带有@Transactional注解的方法，Spring将不知道哪个方法应该启动或参与事务，从而导致事务失效。
4. 使用PROPAGATION\_REQUIRES\_NEW事务传播类型时，每个方法都会启动自己的事务，内部事务的提交或回滚不会影响外部事务，因此事务失效。
5. 基于AspectJ的声明式事务是通过编译时织入实现的，而不是运行时代理。如果应用程序中的类没有被编译时织入，则事务可能会失效。

### 事务传播类型

java 中的事务传播类型包括：

1. Propagation.REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。默认传播特性。
2. Propagation.SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。
3. Propagation.MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常。
4. Propagation.REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。
5. Propagation.NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
6. Propagation.NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
7. Propagation.NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 REQUIRED 类似的操作。

### AspectJ通知类型

AspectJ Java有以下通知类型：

1. Before：在目标方法执行之前执行通知。
2. After：在目标方法执行之后执行通知，无论目标方法是否抛出异常。
3. AfterReturning：在目标方法正常返回之后执行通知。
4. AfterThrowing：在目标方法抛出异常之后执行通知。
5. Around：包围目标方法的通知，可以在目标方法执行前后进行操作。

这些通知类型可用于不同的场景，例如：

1. Before和After通知类型可用于日志记录、权限控制等方面。
2. AfterReturning和AfterThrowing通知类型可用于事务管理、异常处理等方面。
3. Around通知类型可用于性能监测、缓存管理等方面。

它们的作用是在目标方法执行前、执行后或者异常抛出时，插入一段额外的代码逻辑。它们可以与其他 Java 框架结合使用，如 Spring AOP 和 Hibernate

## 编程式事务示例

```Java

@Service
public class UserService {

    @Autowired
    private TransactionTemplate transactionTemplate;

    @Autowired
    private UserMapper userMapper;

    public void createUser(User user) {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                try {
                    userMapper.insert(user);
                } catch (Exception e) {
                    status.setRollbackOnly();
                    throw new RuntimeException("Failed to create user", e);
                }
            }
        });
    }
}

```

## AIO、BIO和NIO是三种不同的输入/输出（I/O）模型的区别

```text
AIO、BIO和NIO是三种不同的输入/输出（I/O）模型，它们在实现方式和性能上有一些区别:
BIO:这是同步且阻塞的通信模式，使用比较传统，模式简单，但并发处理能力低，通信耗时，并依赖网速。在一个连接请求到达服务器时，需要启动一个线程进行处理，直到IO操作完成，用户进程才能运行。如果在这个连接过程中没有任何事情发生，会导致不必要的线程开销。

NIO:这是一种非阻塞同步的通信模式。线程发起io请求后，立即返回（非阻塞io）。用户线程不阻塞等待，但是需要定时轮询检查数据是否就绪。当数据就绪后，用户线程将数据从用户空间写入socket空间，或从socket空间读取数据到用户空间（同步）。由于不停地轮询，会造成不必要的CPU资源的浪费。

AIO:这是异步非阻塞的IO。客户端的I/O请求都是由OS先完成了再通知服务器启动一个线程进行处理。在此之前，需要了解一下同步和异步，阻塞与非阻塞。阻塞与非阻塞是针对进程在访问数据的时候，根据IO操作的就绪状态采取的不同方式。阻塞方式下IO函数将一直等待；非阻塞方式下，IO函数会立即返回一个状态值。
```

## 什么是线程？什么是进程？

```text
线程是程序执行的最小单位，它是进程的一个执行流。
线程是进程内的一个执行路径，每个线程拥有独立的运行栈和程序计数器（PC），线程切换开销小。
同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC）。
一个进程可以包含多个线程，这些线程可以并发执行。

进程是资源（如CPU、内存等）分配的基本单位，它是程序执行时的一个实例。
当程序运行时，系统会为它创建一个进程，并分配资源。
进程拥有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销。
每个进程都包含1-n个线程，这些线程共享进程所拥有的全部资源。
```

## @SuppressWarnings 中的属性介绍以及属性说明

```
all，抑制所有警告
boxing，抑制与封装/拆装作业相关的警告
cast，抑制与强制转型作业相关的警告
dep-ann，抑制与淘汰注释相关的警告
deprecation，抑制与淘汰的相关警告
fallthrough，抑制与switch陈述式中遗漏break相关的警告
finally，抑制与未传回finally区块相关的警告
hiding，抑制与隐藏变数的区域变数相关的警告
incomplete-switch，抑制与switch陈述式(enum case)中遗漏项目相关的警告
javadoc，抑制与javadoc相关的警告
nls，抑制与非nls字串文字相关的警告
null，抑制与空值分析相关的警告
rawtypes，抑制与使用raw类型相关的警告
resource，抑制与使用Closeable类型的资源相关的警告
restriction，抑制与使用不建议或禁止参照相关的警告
serial，抑制与可序列化的类别遗漏serialVersionUID栏位相关的警告
static-access，抑制与静态存取不正确相关的警告
static-method，抑制与可能宣告为static的方法相关的警告
super，抑制与置换方法相关但不含super呼叫的警告
synthetic-access，抑制与内部类别的存取未最佳化相关的警告
sync-override，抑制因为置换同步方法而遗漏同步化的警告
unchecked，抑制与未检查的作业相关的警告
unqualified-field-access，抑制与栏位存取不合格相关的警告
unused，抑制与未用的程式码及停用的程式码相关的警告
版权声明：本文为CSDN博主「兮动人」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41684621/article/details/123807986
```

## java Doc

|===
|标签  |描述 |示例

|@author
|标识一个类的作者
|@author xxx

|@deprecated
|指名一个过期的类或成员
|@deprecated xxx

|{@docRoot}
|在生成的 HTML 文档中插入一个指向整个文档根目录的链接。这通常用于创建指向其他文档或外部资源的链接。
|{@docRoot} /other-document.html 有更多的信息。

|@exception
|标志一个类抛出的异常
|@exception 异常名称 xxx

|{@inheritDoc}
|从直接父类继承的注释
|Inherits a comment from the immediate surperclass.

|{@link}
|插入一个到另一个主题的链接
|{@link name text}

|{@linkplain}
|插入一个到另一个主题的链接，但是该链接显示纯文本字体
|{@linkplain OtherClass} 是另一个类。

|@param
|说明一个方法的参数
|@param 参数名称 xx

|@return
|说明返回值类型
|@return xxx

|@see
|指定一个到另一个主题的链接
|@see xxx

|@serial
|说明一个序列化属性
|@serial xxx

|@serialData
|说明通过writeObject( ) 和 writeExternal( )方法写的数据
|@serialData xxx

|@serialField
|说明一个ObjectStreamField组件
|@serialField xxxx

|@since
|标记当引入一个特定的变化时
|@since xx

|@throws
|和 @exception标签一样.
|@throws 标记与@exception标记具有相同的含义。
|===

### Java doc 标签使用示例

```
/**
 * 这是一个示例类，用于展示Javadoc标签的用法。
 *
 * @author YourName
 * @deprecated 该类已过时，请使用NewExampleClass代替
 * @since 1.0
 */
public class ExampleClass implements Serializable {

    /**
     * 一个序列化的字段
     *
     * @serial 这是一个序列化的字段
     */
    private String serializedField;

    /**
     * 示例方法的说明
     *
     * @param param1 第一个参数
     * @param param2 第二个参数
     * @return 返回结果的描述
     * @throws IllegalArgumentException 如果参数无效
     * @see OtherClass 对于相关类的更多信息
     * @deprecated 该方法已过时，请使用newMethod代替
     */
    @Deprecated
    public String exampleMethod(String param1, int param2) throws IllegalArgumentException {
        // 方法实现
        if (param1 == null || param2 < 0) {
            throw new IllegalArgumentException("Invalid parameters");
        }
        return "Example result";
    }

    /**
     * 从父类继承的说明（通常不需要显式添加，除非父类没有注释）
     * {@inheritDoc}
     */
    @Override
    public String toString() {
        return "ExampleClass [serializedField=" + serializedField + "]";
    }

    /**
     * 一个简单的链接到另一个类的示例
     * {@link OtherClass} 是另一个类。
     * {@linkplain OtherClass} 是以纯文本形式链接到另一个类的。
     */
    public void linkToOtherClass() {
        // 方法实现
    }

    // ... 其他方法和字段

    /**
     * 序列化方法的说明（通常不需要为标准的序列化方法添加注释）
     *
     * @serialData 序列化的数据包括serializedField字段的值
     */
    private void writeObject(java.io.ObjectOutputStream out)
            throws java.io.IOException {
        out.defaultWriteObject();
        // 序列化自定义字段（如果需要）
    }

    /**
     * 反序列化方法的说明（通常不需要为标准的反序列化方法添加注释）
     *
     * @throws IOException 如果发生I/O错误
     * @throws ClassNotFoundException 如果找不到类
     */
    private void readObject(java.io.ObjectInputStream in)
            throws java.io.IOException, ClassNotFoundException {
        in.defaultReadObject();
        // 反序列化自定义字段（如果需要）
    }
}

/**
 * 这是另一个类的示例，用于{@link}和{@linkplain}标签
 */
class OtherClass {
    // ... 类的实现
}
```

## maven scope 说明

|===
|scope  |说明 |是否包含在最终构建产物中
|compile
|编译依赖，对于项目来说是必需的。在项目的所有阶段都可用。
|是

|test
|测试依赖，仅用于测试阶段。在编译和运行时可用，但不会被包含在最终的构建产物中。
|否

|runtime
|运行时依赖，对于运行项目来说是必需的，但在编译时可能不是必需的。在编译和运行时可用，但不会被包含在最终的构建产物中。
|否

|provided
|已提供依赖，在编译和运行时都需要，但假设在运行环境中已经提供。在编译和运行时可用，但不会被包含在最终的构建产物中。
|否

|system
|系统依赖，与provided类似，但必须显式提供包含依赖的JAR文件。在编译和运行时可用，但不会被包含在最终的构建产物中。
|否
|===