## 项目结构

在Spring和Spring Boot项目中，项目结构通常遵循一定的分层设计原则，以保持代码的清晰和可维护性。常见的项目结构如下：

```
src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           ├── controller  // 控制层，处理HTTP请求
│   │           ├── service     // 服务层，处理业务逻辑
│   │           ├── mapper      // MyBatis Mapper接口
│   │           ├── entity      // 实体类，对应数据库表
│   │           ├── config      // 配置类，如Spring配置、MyBatis配置等
│   │           ├── interceptor // 拦截器
│   │           ├── filter      // 过滤器
│   │           └── Application.java // 程序入口
│   └── resources
│       ├── application.yml     // 配置文件
│       ├── mapper              // MyBatis XML映射文件
│       └── static              // 静态资源
└── test
    └── java
        └── com
            └── example
                └── test         // 测试类
```

## 配置文件

Spring Boot使用`application.yml`或`application.properties`作为主要的配置文件。常见的配置项包括：

- **服务器配置**：如端口号、上下文路径等。
- **数据库配置**：如数据库URL、用户名、密码等。
- **日志配置**：如日志级别、日志文件路径等。
- **缓存配置**：如Redis配置。

示例：

```yaml
server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root

logging:
  level:
    com.example: DEBUG
```

## 程序入口

Spring Boot项目的入口通常是一个带有`@SpringBootApplication`注解的类，该类会启动Spring Boot应用。

```java
package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
```

## 路由

在Spring Boot中，路由通常由控制器（Controller）类来处理。使用`@RequestMapping`、`@GetMapping`、`@PostMapping`等注解来定义路由。

```java
package com.example.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping("/users")
    public String getUsers() {
        return "List of users";
    }
}
```

## 传参

Spring Boot支持多种传参方式：

- **路径参数**：使用`@PathVariable`注解。
- **查询参数**：使用`@RequestParam`注解。
- **请求体参数**：使用`@RequestBody`注解。

示例：

```java
@GetMapping("/users/{id}")
public String getUserById(@PathVariable Long id) {
    return "User ID: " + id;
}

@GetMapping("/users")
public String getUsers(@RequestParam String name) {
    return "User name: " + name;
}

@PostMapping("/users")
public String createUser(@RequestBody User user) {
    return "Created user: " + user.getName();
}
```

## 拦截器

拦截器（Interceptor）用于在请求处理前后执行一些操作，如权限验证、日志记录等。通过实现`HandlerInterceptor`接口来创建拦截器。

```java
package com.example.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 请求处理前的逻辑
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 请求处理后的逻辑
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 请求完成后的逻辑
    }
}
```

在配置类中注册拦截器：

```java
package com.example.config;

import com.example.interceptor.MyInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/api/**");
    }
}
```

## 过滤器

过滤器（Filter）用于在请求到达Servlet之前或之后执行一些操作。通过实现`Filter`接口来创建过滤器。

```java
package com.example.filter;

import javax.servlet.*;
import java.io.IOException;

public class MyFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 请求处理前的逻辑
        chain.doFilter(request, response);
        // 请求处理后的逻辑
    }
}
```

在配置类中注册过滤器：

```java
package com.example.config;

import com.example.filter.MyFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<MyFilter> myFilter() {
        FilterRegistrationBean<MyFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new MyFilter());
        registrationBean.addUrlPatterns("/api/*");
        return registrationBean;
    }
}
```

## 数据库操作

### 基本增删查改

MyBatis-Plus提供了非常便捷的CRUD操作，通过继承`BaseMapper`接口即可实现。

```java
package com.example.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
}
```

在Service层中使用：

```java
package com.example.service;

import com.example.entity.User;
import com.example.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User getUserById(Long id) {
        return userMapper.selectById(id);
    }

    public void createUser(User user) {
        userMapper.insert(user);
    }

    public void updateUser(User user) {
        userMapper.updateById(user);
    }

    public void deleteUser(Long id) {
        userMapper.deleteById(id);
    }
}
```

### 条件查询

MyBatis-Plus提供了强大的条件构造器`QueryWrapper`，用于构建复杂的查询条件。

```java
package com.example.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.entity.User;
import com.example.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public List<User> getUsersByName(String name) {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", name);
        return userMapper.selectList(queryWrapper);
    }
}
```

### 事务

Spring提供了声明式事务管理，通过`@Transactional`注解来实现。

```java
package com.example.service;

import com.example.entity.User;
import com.example.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Transactional
    public void createUserWithTransaction(User user) {
        userMapper.insert(user);
        // 如果发生异常，事务会回滚
        if (true) {
            throw new RuntimeException("Transaction will rollback");
        }
    }
}
```

### 钩子

MyBatis-Plus提供了一些钩子方法，如`@TableField`注解中的`fill`属性，用于在插入或更新时自动填充字段。

```java
package com.example.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

@TableName("user")
public class User {

    @TableId
    private Long id;

    private String name;

    @TableField(fill = FieldFill.INSERT)
    private Date createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
}

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", Date.class, new Date());
        this.strictInsertFill(metaObject, "updateTime", Date.class, new Date());
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", Date.class, new Date());
    }
}
```

## 中间件集成

### Redis集成

Spring Boot提供了对Redis的集成支持，通过`spring-boot-starter-data-redis`依赖即可实现。

在`application.yml`中配置Redis：

```yaml
spring:
  redis:
    host: localhost
    port: 6379
```

使用RedisTemplate进行操作：

```java
package com.example.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class RedisService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public void setValue(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public String getValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }
}
```

通过以上配置和代码示例，你可以快速搭建一个基于Spring Boot和MyBatis-Plus的项目，并集成Redis等中间件。

Spring总结

这段时间硬件组同学一直在公司服务器上调试PLC,系统是ubuntu，今天跟我说服务器连接不上了，立即开始排查

先试试ssh，第一次连接不上，第二次连上了，非常卡顿，卡顿的要死

根据本人从入坑到现在拥有和管理的服务器已经有七八个（1G1C,0.5G1C,2G2C,2G4C,32G24C,320G144C都玩过）的经验，一般有至少三种常见情况

- 服务器内存沾满
- 服务器CPU沾满（有服务器被恶意攻击经验）
- 磁盘沾满
- 带宽低

公司服务器内存320G,磁盘3T,等了好久好不容易ssh上了

top一下
```sh
top - 18:20:33 up 30 days,  6:51,  3 users,  load average: 49.36, 49.18, 28.12
任务: 721 total,  24 running, 697 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.1 us, 71.8 sy,  0.0 ni, 17.5 id, 10.6 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem : 290049.6 total,    686.8 free, 289362.9 used,    233.7 buff/cache
MiB Swap:   8192.0 total,      0.1 free,   8191.9 used.    686.8 avail Mem

 进程号 USER      PR  NI    VIRT    RES    SHR    %CPU  %MEM     TIME+ COMMAND                                                   
   7402 tan       20   0 3528984   5376      0 S  1331   0.0  38:55.08 snap
   2044 mysql     20   0 3409784 359032    448 S 318.3   0.1 175:34.63 mysqld
   1928 root      20   0 2910072  16128   6272 S 231.9   0.0  50:27.93 containerd
   3084 root      20   0  671448 316908    448 S 210.7   0.1     17,50 ToDesk_Service
3803870 tan       20   0 8900700  18188   2688 S 182.0   0.0  30:49.55 rustdesk
   5451 tan       20   0  810640  96680   6032 R 162.9   0.0     23,40 ToDesk                                                    
3452403 tan       20   0  293.1g 277.8g   6272 R 141.7  98.1 142:33.20 python  // 罪魁祸首                         
    819 root      19  -1   51244  10740  10292 R 100.0   0.0  23:48.90 systemd-journal                                           
   4889 tan       20   0 9143912 328180  31640 R 104.6   0.1    14d+6h gnome-shell                                               
   6163 tan       20   0 3443540  19832  10304 R 104.3   0.0 187:36.24 gjs                     
```

一看不得了，负载和内存都高得不得了，特别是内存，罪魁祸首是python程序

想起下午开组会的时候中途突然相应很慢，还是重启了一下才好的，现在看来就是这个原因了

这个python程序是研究生用python写的，丢给我此时了下功能就直接用fastapi封装了一下就扔上面去了

我还确认了一下，因为PLC的代码也是用python写的
```
ps -p 3452403 -o pid,ppid,user,group,vsz,rss,cmd
```
展示信息
```
tan@changtai:~/sy$ ps -p 3452403 -o pid,ppid,user,group,vsz,rss,cmd
    PID    PPID USER     GROUP       VSZ   RSS CMD
3452403       1 tan      tan      307305120 291295520 python main.py
```

赶紧杀了，`kill 3452403`

瞬间变流畅了

服务器故障排查记录

Langchain复习总结

[Go语言面试](https://golang.design/go-questions/map/principal/)


[Go语言圣经](https://golang-china.github.io/gopl-zh/ch9/ch9-05.html)

[Go语言高级编程](https://chai2010.cn/advanced-go-programming-book/index.html)