```java
package com.reservoir.core.utils;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.fasterxml.jackson.databind.ser.Serializers;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;

public class Min<T, M extends BaseMapper<T>> {

 private final QueryWrapper<T> queryWrapper;
 private final UpdateWrapper<T> updateWrapper;
 private boolean orderByCalled = false;
 private boolean limitCalled = false;
 private T entity;
 private List<T> entityList;

 private Min() {
 this.queryWrapper = new QueryWrapper<>();
 this.updateWrapper = new UpdateWrapper<>();
 }

 public static <T, M extends BaseMapper<T>> Min<T, M> select(String... columns) {
 Min<T, M> min = new Min<>();
 if (columns != null && columns.length > 0) {
 min.queryWrapper.select(columns);
 }
 return min;
 }

 public static <T, M extends BaseMapper<T>> Min<T, M> insert(T entity) {
 Min<T, M> min = new Min<>();
 min.entity = entity;
 return min;
 }

 public static <T, M extends BaseMapper<T>> Min<T, M> update() {
 return new Min<>();
 }

 public static <T, M extends BaseMapper<T>> Min<T, M> delete() {
 return new Min<>();
 }

 // Query Methods
 public Min<T, M> innerJoin(String joinTable, String onClause) {
 Objects.requireNonNull(joinTable, "joinTable must not be null");
 Objects.requireNonNull(onClause, "onClause must not be null");
 this.queryWrapper.last("INNER JOIN " + joinTable + " ON " + onClause);
 return this;
 }

 public Min<T, M> leftJoin(String joinTable, String onClause) {
 Objects.requireNonNull(joinTable, "joinTable must not be null");
 Objects.requireNonNull(onClause, "onClause must not be null");
 this.queryWrapper.last("LEFT JOIN " + joinTable + " ON " + onClause);
 return this;
 }

 public Min<T, M> rightJoin(String joinTable, String onClause) {
 Objects.requireNonNull(joinTable, "joinTable must not be null");
 Objects.requireNonNull(onClause, "onClause must not be null");
 this.queryWrapper.last("RIGHT JOIN " + joinTable + " ON " + onClause);
 return this;
 }

 public Min<T, M> where(String column, Object value) {
 Objects.requireNonNull(column, "column must not be null");
 Objects.requireNonNull(value, "value must not be null");
 this.queryWrapper.eq(column, value);
 this.updateWrapper.eq(column, value);
 return this;
 }

 public Min<T, M> and(String column, Object value) {
 return where(column, value); // Alias for where
 }

 public Min<T, M> or(String column, Object value) {
 Objects.requireNonNull(column, "column must not be null");
 Objects.requireNonNull(value, "value must not be null");
 this.queryWrapper.or().eq(column, value);
 this.updateWrapper.or().eq(column, value);
 return this;
 }

 public Min<T, M> like(String column, Object value) {
 Objects.requireNonNull(column, "column must not be null");
 Objects.requireNonNull(value, "value must not be null");
 this.queryWrapper.like(column, value);
 this.updateWrapper.like(column, value);
 return this;
 }

 public Min<T, M> between(String column, Object value1, Object value2) {
 Objects.requireNonNull(column, "column must not be null");
 Objects.requireNonNull(value1, "value1 must not be null");
 Objects.requireNonNull(value2, "value2 must not be null");
 this.queryWrapper.between(column, value1, value2);
 this.updateWrapper.between(column, value1, value2);
 return this;
 }

 public Min<T, M> in(String column, List<?> values) {
 Objects.requireNonNull(column, "column must not be null");
 Objects.requireNonNull(values, "values must not be null");
 if (values.isEmpty()) {
 throw new IllegalArgumentException("values must not be empty");
 }
 this.queryWrapper.in(column, values);
 this.updateWrapper.in(column, values);
 return this;
 }

 public Min<T, M> orderBy(boolean isAsc, String... columns) {
 if (orderByCalled) {
 throw new IllegalStateException("orderBy has already been called");
 }
 orderByCalled = true;
 if (columns != null && columns.length > 0) {
 this.queryWrapper.orderBy(true, isAsc, Arrays.asList(columns));
 }
 return this;
 }

 public Min<T, M> groupBy(String... columns) {
 if (columns != null && columns.length > 0) {
 this.queryWrapper.groupBy(Arrays.asList(columns));
 }
 return this;
 }

 public Min<T, M> limit(int offset, int size) {
 if (limitCalled) {
 throw new IllegalStateException("limit has already been called");
 }
 limitCalled = true;
 if (offset < 0 || size <= 0) {
 throw new IllegalArgumentException("Offset must be >= 0 and size must be > 0");
 }
 this.queryWrapper.last("LIMIT " + offset + ", " + size);
 return this;
 }

 public Min<T, M> having(String column, Object value) {
 Objects.requireNonNull(column, "column must not be null");
 Objects.requireNonNull(value, "value must not be null");
 this.queryWrapper.having(column, value);
 return this;
 }

 public Min<T, M> isNull(String column) {
 Objects.requireNonNull(column, "column must not be null");
 this.queryWrapper.isNull(column);
 this.updateWrapper.isNull(column);
 return this;
 }

 public Min<T, M> isNotNull(String column) {
 Objects.requireNonNull(column, "column must not be null");
 this.queryWrapper.isNotNull(column);
 this.updateWrapper.isNotNull(column);
 return this;
 }

 public <T> T first(BaseMapper mapper) {
 Objects.requireNonNull(mapper, "mapper must not be null");
 return (T) mapper.selectOne((Wrapper<T>) this.queryWrapper);
 }

 public List<T> list(BaseMapper mapper) {
 Objects.requireNonNull(mapper, "mapper must not be null");
 return mapper.selectList((Wrapper<T>) this.queryWrapper);
 }

 // Insert Methods
 public Min<T, M> one() {
 Objects.requireNonNull(this.entity, "entity must not be null");
 return this;
 }

 public Min<T, M> list(List<T> entities) {
 Objects.requireNonNull(entities, "entities must not be null");
 if (entities.isEmpty()) {
 throw new IllegalArgumentException("entities must not be empty");
 }
 this.entityList = entities;
 return this;
 }

 public int executeInsert(BaseMapper mapper) {
 Objects.requireNonNull(mapper, "mapper must not be null");
 if (this.entity != null) {
 return mapper.insert(this.entity);
 } else if (this.entityList != null) {
 int count = 0;
 for (T e : this.entityList) {
 count += mapper.insert(e);
 }
 return count;
 } else {
 throw new IllegalStateException("No entity or entityList provided for insert");
 }
 }

 // Update Methods
 public Min<T, M> set(String column, Object value) {
 Objects.requireNonNull(column, "column must not be null");
 Objects.requireNonNull(value, "value must not be null");
 this.updateWrapper.set(column, value);
 return this;
 }

 public int executeUpdate(BaseMapper mapper) {
 Objects.requireNonNull(mapper, "mapper must not be null");
 if (this.updateWrapper.isEmptyOfWhere()) {
 throw new IllegalStateException("Update operation must contain at least one where clause");
 }
 return mapper.update(null, this.updateWrapper);
 }

// public <M extends BaseMapper<?>> int UpdateRows(M mapper) {
// return this.executeUpdate((BaseMapper)mapper);
// }

 // Delete Methods
 public int executeDelete(BaseMapper mapper) {
 Objects.requireNonNull(mapper, "mapper must not be null");
 if (this.queryWrapper.isEmptyOfWhere()) {
 throw new IllegalStateException("Delete operation must contain at least one where clause");
 }
 return mapper.delete((Wrapper<T>) this.queryWrapper);
 }

 // Utility Methods
 public Min<T, M> setFields(Map<String, Object> fieldValues) {
 Objects.requireNonNull(fieldValues, "fieldValues must not be null");
 fieldValues.forEach((key, value) -> {
 Objects.requireNonNull(key, "field key must not be null");
 Objects.requireNonNull(value, "field value must not be null");
 this.updateWrapper.set(key, value);
 });
 return this;
 }
}

```

封装Mybatis-Plus

ApiResult
```kotlin
package com.example.demokt.core.entity

import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

data class ApiResult<T>(
 val code: Int,
 val message: String,
 val data: T?,
 val timestamp: String
) {
 companion object {
 // 创建成功的响应
 fun <T> success(data: T?): ApiResult<T> {
 return ApiResult(ResultCode.SUCCESS.code, ResultCode.SUCCESS.message, data, getCurrentTimestamp())
 }

 // 创建成功的响应，并自定义消息
 fun <T> success(message: String, data: T?): ApiResult<T> {
 return ApiResult(ResultCode.SUCCESS.code, message, data, getCurrentTimestamp())
 }

 // 创建自定义状态码的响应
 fun <T> of(resultCode: ResultCode, data: T?): ApiResult<T> {
 return ApiResult(resultCode.code, resultCode.message, data, getCurrentTimestamp())
 }

 // 创建失败的响应
 fun <T> error(code: Int, message: String): ApiResult<T> {
 return ApiResult(code, message, null, getCurrentTimestamp())
 }

 // 创建失败的响应，并包含数据
 fun <T> error(code: Int, message: String, data: T?): ApiResult<T> {
 return ApiResult(code, message, data, getCurrentTimestamp())
 }

 // 获取当前时间戳
 private fun getCurrentTimestamp(): String {
 val now = LocalDateTime.now()
 val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
 return now.format(formatter)
 }
 }
}
```
ResultCode
```kotlin
package com.example.demokt.core.entity

enum class ResultCode(val code: Int, val message: String) {
 SUCCESS(200, "Success"),
 ADD_USER_SUCCESS(1001, "添加用户成功"),
 USER_NOT_EXISTS(1002, "用户不存在"),
 USER_ALREADY_EXISTS(1003, "用户已存在"),
 INVALID_CREDENTIALS(1004, "无效的凭证"),
 LOGIN_SUCCESS(1005, "登录成功"),
 LOGIN_FAILED(1006, "登录失败"),
 LOGOUT_SUCCESS(1007, "登出成功"),
 PERMISSION_DENIED(1008, "权限不足"),
 RESOURCE_NOT_FOUND(1009, "资源未找到"),
 RESOURCE_ALREADY_EXISTS(1010, "资源已存在"),
 INVALID_PARAMETERS(1011, "无效的参数"),
 OPERATION_SUCCESS(1012, "操作成功"),
 OPERATION_FAILED(1013, "操作失败"),
 // 用户操作
 USER_ALREADY_BLOCKED(1014, "用户已被封禁"),
 USER_ALREADY_VERIFIED(1015, "用户已验证"),
 USER_VERIFICATION_FAILED(1016, "用户验证失败"),

 SERVER_ERROR(500, "服务器错误"),
 UNKNOWN_ERROR(501, "未知错误"),

 // 注册相关
 REGISTER_SUCCESS(2001, "注册成功"),
 REGISTER_FAILED(2002, "注册失败"),
 EMAIL_ALREADY_EXISTS(2003, "邮箱已存在"),
 USERNAME_ALREADY_EXISTS(2004, "用户名已存在"),
 // 登录/注册
 INVALID_VERIFICATION_CODE(2005, "验证码错误"),
 REGISTRATION_CODE_EXPIRED(2006, "注册码已过期"),
 INVALID_LOGIN_ATTEMPTS(1017, "登录尝试过多，请稍后再试"),

 // 支付相关
 PAYMENT_SUCCESS(3001, "支付成功"),
 PAYMENT_FAILED(3002, "支付失败"),
 INSUFFICIENT_FUNDS(3003, "余额不足"),
 PAYMENT_CANCELED(3004, "支付已取消"),
 // 支付
 PAYMENT_AMOUNT_EXCEEDS_LIMIT(3005, "支付金额超出限制"),
 PAYMENT_METHOD_NOT_SUPPORTED(3006, "不支持的支付方式"),
 PAYMENT_AUTHENTICATION_REQUIRED(3007, "需要支付认证"),

 // 数据库相关
 DATABASE_CONNECTION_SUCCESS(4001, "数据库连接成功"),
 DATABASE_CONNECTION_FAILED(4002, "数据库连接失败"),
 DATABASE_OPERATION_SUCCESS(4003, "数据库操作成功"),
 DATABASE_OPERATION_FAILED(4004, "数据库操作失败"),
 // 数据库操作
 DATABASE_QUERY_FAILED(4005, "数据库查询失败"),
 DATABASE_UPDATE_FAILED(4006, "数据库更新失败"),
 DATABASE_DELETE_FAILED(4007, "数据库删除失败"),


 // 超时相关
 REQUEST_TIMEOUT(5001, "请求超时"),
 SESSION_TIMEOUT(5002, "会话超时"),
 // 超时
 API_TIMEOUT(5003, "API调用超时"),
 IMAGE_UPLOAD_TIMEOUT(5004, "图片上传超时"),

 // 限流相关
 RATE_LIMIT_EXCEEDED(6001, "请求过于频繁，请稍后再试"),
 // 限流
 RATE_LIMIT_EXCEEDED_PER_USER(6002, "用户请求过于频繁，请稍后再试"),
 RATE_LIMIT_EXCEEDED_PER_IP(6003, "IP请求过于频繁，请稍后再试"),

 // 其他
 SERVICE_UNAVAILABLE(7001, "服务不可用"),
 GATEWAY_TIMEOUT(7002, "网关超时"),
 // 其他
 INTERNAL_SERVER_ERROR(7003, "内部服务器错误"),
 CONFIGURATION_ERROR(7004, "配置错误"),
 DEPENDENCY_SERVICE_UNAVAILABLE(7005, "依赖服务不可用"),

 // 文件操作
 FILE_NOT_FOUND(8001, "文件未找到"),
 FILE_UPLOAD_FAILED(8002, "文件上传失败"),
 FILE_DOWNLOAD_FAILED(8003, "文件下载失败"),


 // 网络问题
 CONNECTION_TIMEOUT(9001, "连接超时"),
 REQUEST_FAILED(9002, "请求失败"),
 HOST_UNAVAILABLE(9003, "主机不可用"),

 // 安全问题
 SECURITY_VIOLATION(10001, "安全违规"),
 ENCRYPTION_FAILED(10002, "加密失败"),
 DECRYPTION_FAILED(10003, "解密失败");


 companion object {
 fun fromCode(code: Int): ResultCode {
 return values().find { it.code == code } ?: UNKNOWN_ERROR
 }
 }
}
```

kotlin响应体

```sh
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<EOF
{
 "registry-mirrors": [
 "https://hub.uuuadc.top",
 "https://docker.anyhub.us.kg",
 "https://dockerhub.jobcher.com",
 "https://dockerhub.icu",
 "https://docker.ckyl.me",
 "https://docker.awsl9527.cn"
 ]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
```

直接复制执行


https://cloud.tencent.com/developer/article/2459822

Docker镜像最新镜像源（亲测有用）

# 空间解析几何与向量代数
## 例一
例题一.求过点 $P(1,-1,0)$且与两向量$a=(-2,-2,1)$，$b=(-1,0,2)$平行的平面方程


①根据a,b求出对应的平面法向量

$n(i, j,k) =a×b$得到$n(-4,3,-2)$

②将法向量分量代入一般方程



$Ax+By+Cz+D=0 \text{得到}-4x+3y+-2z+D=0$

把P点代入得到$D=7$

∴ 平面方程是$-4x+3y-2z+7=0$

知识点总结：
#### 向量叉乘
向量的叉乘（Cross Product），也称为向量积，是三维空间中两个向量的一种特殊乘法运算。它产生第三个与前两个向量都垂直的向量，并且结果向量的长度和方向与原向量构成平行四边形的面积有关。以下是向量叉乘的主要性质和计算方法：

#### 定义
设有两个向量 **A** 和 **B**，它们的叉乘表示为 **A × B**，结果是一个向量。

#### 计算方法
设向量 **A = (a1, a2, a3)** 和向量 **B = (b1, b2, b3)**，它们的叉乘计算如下：

$ A \times B = \left| \begin{array}{ccc}
\mathbf{i} & \mathbf{j} & \mathbf{k} \\
a_1 & a_2 & a_3 \\
b_1 & b_2 & b_3 \\
\end{array} \right| $

其中，**i**, **j**, **k** 分别是沿 x、y、z 轴的单位向量。根据行列式的定义，计算结果为：

$ A \times B = (a_2b_3 - a_3b_2)\mathbf{i} - (a_1b_3 - a_3b_1)\mathbf{j} + (a_1b_2 - a_2b_1)\mathbf{k} $

#### 平面方程
一般式:$Ax+By+Cz+D=0$

截距式:$\frac x a + \frac y b + \frac z c = 1$


点法式:$(x−x 
0
​
 )A+(y−y 
0
​
 )B+(z−z 
0
​
 )C=0$
## 例二
例题二.设向量$a=2i-4j+k,b=i-j-3k$,则$a·b$=3.

知识点：
a · b = $(a_1*b_1)+(a_2*b_2)+(a_3*b_3)=(2*1)+(-4*-1)+(1*-3)=3$

## 例三
例题三.球面$x^2+y^2+z^2=14在点(1,2,3)$处的法线方程为 

![image.png](/static/img/c0313792376d7dc04c00adc844038927.image.webp)

总结：

①求偏导把点带进去
②用对称式方程得出结果

## 例题四
例题四.求解一条直线的方程，该直线通过点 (0,2,4) 并且与两个平面 x+2z=1 和 y-3z=2 平行。

![image.png](/static/img/200052987f8008f75dcec87ee929f8dc.image.webp)



## 例题五

![image.png](/static/img/7dcf9d64c496ab5465943af265f525c8.image.webp)

![image.png](/static/img/4de43d1660d8ecaf7537df7144eaa5c4.image.webp)


![image.png](/static/img/136a18898bd34914001910fc539dde13.image.webp)

# 函数与积分
## 例题一.极大极小值

![image.png](/static/img/aa82e51fa7828028fa14af24ae2e0332.image.webp)


![image.png](/static/img/e575fe6c88b149c7535c30bcdc97d7ca.image.webp)

![image.png](/static/img/068a4e4428865090a816dac1e28af626.image.webp)

![image.png](/static/img/0cc59af070978993530215a98bf38bc8.image.webp)


![image.png](/static/img/b1967caa265d39ebb1655d8be48a2d62.image.webp)


![image.png](/static/img/87c608c270b0e02c420dd127870bfd7d.image.webp)

![image.png](/static/img/78964ebc84d161536d78a01c5343f38e.image.webp)

![image.png](/static/img/bc54d9272f4f58b3f7eaff1aa3552e95.image.webp)


# 曲线积分
## 拉格朗日乘数法
第一题
![image.png](/static/img/667c30f1033d6b56cbc8fcf41f44cbca.image.webp)


![image.png](/static/img/2c496bfe9d8e7e164463ca81fd0abdb7.image.webp)

第二题

![image.png](/static/img/899e1dcb8eada9e5f8bb34bd00c83538.image.webp)
![image.png](/static/img/c0df95ab644365443a5342ceebf03103.image.webp)