问题描述

Java服务使用openjdk:17-jdk-alpine为基础镜像进行构建的存在两个问题：
1.openjdk不包括sum.awt的字体控件
2.alpine linux的基础镜像也未安装有fontconfig和ttf-dejavu字体。

openjdk明确表示只适用于预发布，非生产环境

解决方法

切换其他发行商生产环境镜像，我目前使用的是亚马逊的

FROM amazoncorretto:17.0.15

生产环境镜像推荐

Docker部署PGSQL

docker run -d --name pgsql -e POSTGRES_PASSWORD=12345678 -p 5432:5432 postgres:17.4

连接数据库后自动创建数据库和用户名，默认用户名密码postgres:postgres

MVN包配置

        <!--  JPA 依赖  -->        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-data-jpa</artifactId>        </dependency>        <!-- https://mvnrepository.com/artifact/org.postgresql/postgresql -->        <!--  postgresql 依赖  -->        <dependency>            <groupId>org.postgresql</groupId>            <artifactId>postgresql</artifactId>            <version>42.5.6</version>        </dependency>        <!-- Model数据验证 -->        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-validation</artifactId>        </dependency>

数据库配置

spring:  datasource:    url: jdbc:postgresql://localhost:5432/ai # 这里改成自己的表    username: ai_root # 改成自己的用户名    password: 12345678  jpa:    show-sql: true # 打印sql语句    hibernate:      ddl-auto: create # 服务启动后自动读取@Entity类，删除并创建新的数据库表，update为更新    defer-datasource-initialization: true  # 启动后执行sql语句关键配置：延迟数据源初始化，确保先建表    properties:      hibernate:        format_sql: true # sql 语句格式化输出  sql:    init:      mode: always # 始终执行初始化脚本（即使是非嵌入式数据库）      schema-locations: classpath:init.sql # 需要执行的sql脚本

服务启动时自动删除、新建表用于测试环境（生产环境建议关闭）

启动类添加注解@EntityScan确定需要扫描的实例类(@Entity)所在位置

import org.springframework.boot.autoconfigure.domain.EntityScan;import org.springframework.cache.annotation.EnableCaching;import org.springframework.scheduling.annotation.EnableAsync;@EnableAsync@EnableCaching@EntityScan("com.jagger.ai.api")public abstract class BaseSpringApplication {    // 可以在此处定义公共的 Bean 或配置方法}

User Model 实例类，添加@Entity、@Table、@Id、@Column等注解用于关联数据库表

import com.fasterxml.jackson.annotation.JsonFormat;import com.fasterxml.jackson.annotation.JsonIgnore;import io.swagger.v3.oas.annotations.media.Schema;import jakarta.persistence.Column;import jakarta.persistence.Entity;import jakarta.persistence.Id;import jakarta.persistence.Table;import lombok.Data;import lombok.experimental.Accessors;import org.hibernate.annotations.Comment;import java.io.Serializable;import java.util.Date;@Data@Accessors(chain = true)@Schema(description = "用户信息")@Entity @Table(name = "users") // 表名public class User implements Serializable {    @Id // 主键    @JsonFormat(shape = JsonFormat.Shape.STRING) // 强制以字符串解析    @Schema(description = "ID，Snowflake算法生成")    @Comment("ID，Snowflake算法生成")    private long id;    @Column(length = 20, nullable = false)    @Schema(description = "登录用户名")    private String username;    @Column(length = 20, nullable = false)    @JsonIgnore    @Schema(description = "登录密码，这里用密文加密")    private String password;    @Column(length = 20, nullable = false)    @Schema(description = "昵称")    private String nickname;    @Column(length = 20)    @Schema(description = "手机号")    private String phoneNumber;    @Column(nullable = false)    @Schema(description = "头像，这里存储的是地址")    private String avatarUrl;    @Column(length = 30)    @Schema(description = "邮箱")    private String email;    @Column(nullable = false)    @JsonIgnore    @Schema(description = "创建时间")    private Date createTime;}

添加SQL语句脚本，服务启动时自动执行SQL脚本

存放位置: resources/init.sql，配置内容见： 数据库配置

INSERT INTO users (id, username, password, nickname, avatar_url, create_time)VALUES (1, 'username', 'password', '管理员', '123.image', NOW());

JpaRepository 自动创建CRUD方法

UserRepository

import org.springframework.data.jpa.repository.JpaRepository;import org.springframework.data.jpa.repository.Query;import org.springframework.stereotype.Repository;import java.util.List;import java.util.Optional;// 继承 JpaRepository 即可自动获得 CRUD 方法@Repositorypublic interface UserRepository extends JpaRepository<User, Long> {    // 自动生成查询（方法名约定）    Optional<User> findByUsernameAndPassword(String name, String password);    // 自定义 JPQL 查询    @Query("SELECT u FROM User u WHERE u.username LIKE %?1%")    List<User> searchByUsername(String username);}

UserService

import com.jagger.ai.services.auth.repository.UserRepository;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.stereotype.Service;@Service@Slf4j@RequiredArgsConstructorpublic class UserService {    private final UserRepository userRepository;    public User findByUsernameAndPassword(String username, String password) {        return userRepository.findByUsernameAndPassword(username, password).orElse(null);    }}

SQL语句参数明文输出

logging:  level:    org.hibernate.orm.jdbc.extract: TRACE # SQL响应参数    org.hibernate.orm.jdbc.bind: TRACE # SQL请求参数

Docker部署Redis

# docker部署redis，密码 12345678docker run -d --name redis --network ai_network -p 6379:6379 redis:7.4.2 --requirepass "12345678"

Mvn配置

        <!-- 集成redis依赖  -->        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-data-redis</artifactId>        </dependency>

Redis配置文件

最新Spring Boot多了个Data字段，如果配置不生效检查下版本

spring:  data: # 多出来的字段    redis:      host: localhost      port: 6379      password: 12345678      database: 0

代码

自定义customRedisTemplate序列化方法

这样通过工具访问redis查看的时候就不是乱码的了。

import com.fasterxml.jackson.annotation.JsonAutoDetect;import com.fasterxml.jackson.annotation.PropertyAccessor;import com.fasterxml.jackson.databind.ObjectMapper;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.data.redis.connection.RedisConnectionFactory;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;import org.springframework.data.redis.serializer.StringRedisSerializer;@Configurationpublic class RedisConfig {    @Bean    public RedisTemplate<String, Object> customRedisTemplate(RedisConnectionFactory factory) {        RedisTemplate<String, Object> template = new RedisTemplate<>();        template.setConnectionFactory(factory);        // 使用 StringRedisSerializer 序列化键（Key）        template.setKeySerializer(new StringRedisSerializer());        template.setHashKeySerializer(new StringRedisSerializer());        ObjectMapper objectMapper = new ObjectMapper();        //序列化包括类型描述 否则反向序列化实体会报错，一律都为JsonObject        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);        objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);        // 使用 Jackson2JsonRedisSerializer 序列化值（Value）        Jackson2JsonRedisSerializer<Object> valueSerializer = new Jackson2JsonRedisSerializer<>(objectMapper, Object.class);        template.setValueSerializer(valueSerializer);        template.setHashValueSerializer(valueSerializer);        template.afterPropertiesSet();        return template;    }}

RedisService代理服务类，封装一层Redis操作方法

import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.dao.DataAccessException;import org.springframework.data.redis.core.*;import org.springframework.stereotype.Component;import java.util.*;import java.util.concurrent.TimeUnit;/** * spring redis 工具类 **/@SuppressWarnings(value = {"unchecked", "rawtypes"}) // 无视泛型的Idea代码警告@Componentpublic class RedisService {    private final RedisTemplate redisTemplate;    public RedisService(@Qualifier("customRedisTemplate") RedisTemplate redisTemplate) {        this.redisTemplate = redisTemplate;    }    /**     * 缓存基本的对象，Integer、String、实体类等     *     * @param key   缓存的键值     * @param value 缓存的值     */    public <T> void setCacheObject(final String key, final T value) {        redisTemplate.opsForValue().set(key, value);    }    /**     * 缓存基本的对象，Integer、String、实体类等     *     * @param key      缓存的键值     * @param value    缓存的值     * @param timeout  时间     * @param timeUnit 时间颗粒度     */    public <T> void setCacheObject(final String key, final T value, final Long timeout, final TimeUnit timeUnit) {        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);    }    /**     * 设置有效时间     *     * @param key     Redis键     * @param timeout 超时时间     * @return true=设置成功；false=设置失败     */    public boolean expire(final String key, final long timeout) {        return expire(key, timeout, TimeUnit.SECONDS);    }    /**     * 设置有效时间     *     * @param key     Redis键     * @param timeout 超时时间     * @param unit    时间单位     * @return true=设置成功；false=设置失败     */    public boolean expire(final String key, final long timeout, final TimeUnit unit) {        return redisTemplate.expire(key, timeout, unit);    }    /**     * 获取有效时间     *     * @param key Redis键     * @return 有效时间     */    public long getExpire(final String key) {        return redisTemplate.getExpire(key);    }    /**     * 判断 key是否存在     *     * @param key 键     * @return true 存在 false不存在     */    public Boolean hasKey(String key) {        return redisTemplate.hasKey(key);    }    /**     * 获得缓存的基本对象。     *     * @param key 缓存键值     * @return 缓存键值对应的数据     */    public <T> T getCacheObject(final String key) {        ValueOperations<String, T> operation = redisTemplate.opsForValue();        return operation.get(key);    }    /**     * 删除单个对象     *     * @param key     */    public boolean deleteObject(final String key) {        return redisTemplate.delete(key);    }    /**     * 删除集合对象     *     * @param collection 多个对象     * @return     */    public boolean deleteObject(final Collection collection) {        return redisTemplate.delete(collection) > 0;    }    /**     * 缓存List数据     *     * @param key      缓存的键值     * @param dataList 待缓存的List数据     * @return 缓存的对象     */    public <T> long setCacheList(final String key, final List<T> dataList) {        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);        return count == null ? 0 : count;    }    /**     * 缓存List数据，单个增加     *     * @param key  缓存的键值     * @param data 待缓存的List数据     * @return 缓存的对象     */    public <T> long setCacheList(final String key, final T data) {        Long count = redisTemplate.opsForList().rightPush(key, data);        return count == null ? 0 : count;    }    /**     * 获得缓存的list对象：指定范围     * 下标数值如果为负数则表示倒数，如需提取倒数2位：start = -2、 end = -1     *     * @param key   缓存的键值     * @param start 开始下标     * @param end   结束下标     * @return 缓存键值对应的数据     */    public <T> List<T> getCacheList(final String key, final long start, final long end) {        return redisTemplate.opsForList().range(key, start, end);    }    /**     * 获得缓存的list对象：根据参数 num 的值，获取特定数量的值     *     * @param key 缓存的键值     * @param num 获取的数量     *            num > 0，表示获取前几位     *            num < 0，表示获取到倒数第几位     *            num == 0，表示获取全部     * @return 缓存键值对应的数据     */    public <T> List<T> getCacheList(final String key, final long num) {        return this.getCacheList(key, 0, num < 1 ? num : num - 1);    }    /**     * 获得缓存的list对象：所有对象     *     * @param key 缓存的键值     * @return 缓存键值对应的数据     */    public <T> List<T> getCacheList(final String key) {        return this.getCacheList(key, 0, -1);    }    /**     * 获得缓存的list对象：获取并移除指定范围内的数据。     *     * @param key   缓存的键值     * @param start 开始下标     * @param end   结束下标     * @return 缓存键值对应的数据     */    public <T> List<T> removeGetCacheList(final String key, final long start, final long end) {        List<T> l = (List<T>) redisTemplate.execute(new SessionCallback<List<Object>>() {            public List<T> execute(RedisOperations operations) throws DataAccessException {                /*                  通过事务保证redis原子性操作                  1. 提取指定范围内数据                  2. 剪切保留 end 到 最后一位数据（注：此时会少移除左侧一条数据，不一步到位原因：移除数据时`trim([超过list最大值], -1)`会保留一条数据）                  3. 再从左移除一条多余数据                 */                operations.multi();                operations.opsForList().range(key, start, end);                operations.opsForList().trim(key, end, -1);                operations.opsForList().rightPop(key);                return operations.exec();            }        });        return (List<T>) l.get(0);    }    /**     * 获得缓存的list对象：根据参数 num 的值，移除并获取list特定数量的数据。     *     * @param key 缓存的键值     * @param num 获取的数量     *            num > 0，表示获取前几位     *            num < 0，表示获取到倒数第几位     *            num == 0，表示获取全部     * @return 缓存键值对应的数据     */    public <T> List<T> removeGetCacheList(final String key, final long num) {        return this.removeGetCacheList(key, 0, num < 1 ? num : num - 1);    }    /**     * 获得缓存的list对象：移除并获取list所有的数据     *     * @param key 缓存的键值     * @return 缓存键值对应的数据     */    public <T> List<T> removeGetCacheList(final String key) {        return this.removeGetCacheList(key, 0, -1);    }    /**     * 移除缓存的list对象     *     * @param key   缓存的键值     * @param count 开始下标     *              count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。     *              count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。     *              count = 0 : 移除表中所有与 VALUE 相等的值。     * @param value 匹配的值     * @return 缓存键值对应的数据     */    public Long removeCacheList(final String key, final long count, final Object value) {        return redisTemplate.opsForList().remove(key, count, value);    }    /**     * 移除缓存的list对象: 移除表中所有与 VALUE 相等的值。     *     * @param key   缓存的键值     * @param value 匹配的值     * @return 缓存键值对应的数据     */    public Long removeCacheList(final String key, final Object value) {        return removeCacheList(key, 0, value);    }    /**     * 缓存Set     *     * @param key     缓存键值     * @param dataSet 缓存的数据     * @return 缓存数据的对象     */    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);        Iterator<T> it = dataSet.iterator();        while (it.hasNext()) {            setOperation.add(it.next());        }        return setOperation;    }    /**     * 获得缓存的set     *     * @param key     * @return     */    public <T> Set<T> getCacheSet(final String key) {        return redisTemplate.opsForSet().members(key);    }    /**     * 缓存Map     *     * @param key     * @param dataMap     */    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {        if (dataMap != null) {            redisTemplate.opsForHash().putAll(key, dataMap);        }    }    /**     * 获得缓存的Map     *     * @param key     * @return     */    public <T> Map<String, T> getCacheMap(final String key) {        return redisTemplate.opsForHash().entries(key);    }    /**     * 往Hash中存入数据     *     * @param key   Redis键     * @param hKey  Hash键     * @param value 值     */    public <T> void setCacheMapValue(final String key, final String hKey, final T value) {        redisTemplate.opsForHash().put(key, hKey, value);    }    /**     * 获取Hash中的数据     *     * @param key  Redis键     * @param hKey Hash键     * @return Hash中的对象     */    public <T> T getCacheMapValue(final String key, final String hKey) {        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();        return opsForHash.get(key, hKey);    }    /**     * 获取多个Hash中的数据     *     * @param key   Redis键     * @param hKeys Hash键集合     * @return Hash对象集合     */    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {        return redisTemplate.opsForHash().multiGet(key, hKeys);    }    /**     * 删除Hash中的某条数据     *     * @param key  Redis键     * @param hKey Hash键     * @return 是否成功     */    public boolean deleteCacheMapValue(final String key, final String hKey) {        return redisTemplate.opsForHash().delete(key, hKey) > 0;    }    /**     * 获得缓存的基本对象列表     *     * @param pattern 字符串前缀     * @return 对象列表     */    public Collection<String> keys(final String pattern) {        return redisTemplate.keys(pattern);    }}

Mvn包配置

    <dependencies>        <!--  只需要网关服务需要  -->        <dependency>            <groupId>org.springframework.cloud</groupId>            <artifactId>spring-cloud-starter-gateway</artifactId>        </dependency>                <!-- SpringCloud Alibaba Nacos 服务注册 -->        <dependency>            <groupId>com.alibaba.cloud</groupId>            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>        </dependency>        <!-- SpringCloud Alibaba Nacos 配置中心 -->        <dependency>            <groupId>com.alibaba.cloud</groupId>            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>        </dependency>        <!-- spring boot 2.4之后默认禁用bootstrap.yml配置文件，生效需要引入 -->        <dependency>            <groupId>org.springframework.cloud</groupId>            <artifactId>spring-cloud-starter-bootstrap</artifactId>        </dependency>    </dependencies>

配置文件

Gateway服务配置文件: bootstrap.yml

server:  port: 8080spring:  application:    name: gateway  profiles:    active: @profiles.active@  cloud:    nacos:      discovery: # 服务注册        server-addr: @nacos.server@        username: @nacos.username@        password: @nacos.password@        namespace: @nacos.namespace-id@        service: ${spring.application.name}-${spring.profiles.active}      config: # 配置管理        server-addr: @nacos.server@        username: @nacos.username@        password: @nacos.password@        namespace: @nacos.namespace-id@        file-extension: yml        shared-configs: # 指定额外的配置文件          - data-id: application.yml          - data-id: redis.yml    loadbalancer:      nacos:        enabled: true # 开启nacos负载均衡策略    gateway:      routes: # 网关路由配置        - id: auth-service # 路由id，自定义，只要唯一即可          #uri: http://127.0.0.1:8088 # 路由的目标地址 http就是固定地址          uri: lb://auth-${spring.profiles.active} # 路由的目标地址 lb就是负载均衡，后面跟Nacos服务发现名称          predicates: # 路由断言，也就是判断请求是否符合路由规则的条件            - Path=/auth/** # 这个是按照路径匹配，只要以 /auth/ 开头就符合要求          filters: # 路由过滤器，对请求或者响应做出处理            - StripPrefix=1 # 去掉路径一条前缀，这里是: /auth          metadata:            auth-white-list:              - /login/**              - /logout/**              - /v3/api-docs/**        - id: chat-service # 路由id，自定义，只要唯一即可          #uri: http://127.0.0.1:8088 # 路由的目标地址 http就是固定地址          uri: lb://chat-${spring.profiles.active} # 路由的目标地址 lb就是负载均衡，后面跟Nacos服务发现名称          predicates: # 路由断言，也就是判断请求是否符合路由规则的条件            - Path=/chat/** # 这个是按照路径匹配，只要以 /chat/ 开头就符合要求          filters: # 路由过滤器，对请求或者响应做出处理            - StripPrefix=1 # 去掉路径一条前缀，这里是: /chat          metadata:            auth-white-list:              - /v3/api-docs/**

代码

路由管理器，主要用于获取metadata.auth-white-list 的白名单列表数据，用于跳过鉴权。

import jakarta.annotation.PostConstruct;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.cloud.gateway.route.Route;import org.springframework.cloud.gateway.route.RouteLocator;import org.springframework.stereotype.Component;import reactor.core.publisher.Flux;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Optional;import java.util.stream.Collectors;/*** * 路由管理 */@Component@RequiredArgsConstructor@Slf4jpublic class RouteMetadataService {    private final RouteLocator routeLocator;    private final Map<String, List<String>> routeExcludePaths = new HashMap<>();    /**     * 加载所有路由的元数据     */    public void loadMetadata() {        Flux<Route> routes = routeLocator.getRoutes();        routes.subscribe(route -> {            // 从元数据获取鉴权白名单，路径在白名单中，无需鉴权            List<String> authWhiteList = Optional.ofNullable(route.getMetadata().get("auth-white-list"))                    .map(obj -> {                        if (obj instanceof List) {                            // 直接转换为List<String>                            return (List<String>) obj;                        } else if (obj instanceof Map) {                            // 如果是Map，提取所有值组成List                            Map<?, ?> map = (Map<?, ?>) obj;                            return map.values().stream()                                    .filter(String.class::isInstance)                                    .map(String.class::cast)                                    .collect(Collectors.toList());                        } else {                            log.warn("auth-white-list 类型不匹配: {}", obj.getClass().getName());                            return List.<String>of();                        }                    })                    .orElse(List.of());  // 默认返回空列表            routeExcludePaths.put(route.getId(), authWhiteList);        });    }    /**     * 获取指定路由的白名单路径列表     */    public List<String> getauthWhiteList(String routeId) {        return routeExcludePaths.getOrDefault(routeId, List.of());    }    /**     * 动态路由更新时调用此方法刷新缓存     */    @PostConstruct    public void refreshMetadata() {        routeExcludePaths.clear();        loadMetadata();    }}

AuthFilter鉴权过滤器

import com.fasterxml.jackson.core.JsonProcessingException;import com.jagger.ai.services.gateway.service.RouteMetadataService;import com.fasterxml.jackson.databind.ObjectMapper;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.cloud.gateway.filter.GatewayFilterChain;import org.springframework.cloud.gateway.filter.GlobalFilter;import org.springframework.cloud.gateway.route.Route;import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;import org.springframework.core.annotation.Order;import org.springframework.http.HttpHeaders;import org.springframework.http.server.reactive.ServerHttpRequest;import org.springframework.stereotype.Component;import org.springframework.util.AntPathMatcher;import org.springframework.util.PathMatcher;import org.springframework.web.server.ServerWebExchange;import reactor.core.publisher.Mono;import java.util.List;@Slf4j@Component@RequiredArgsConstructor// 设置优先级高于WebsocketRoutingFilter的等级(Integer.MAX_VALUE - 1)，否则不会过滤Websocket请求，// 要大于等于2，否则影响 StripPrefix 截取路由获取path（不影响后续转发）@Order(Integer.MAX_VALUE - 2)public class AuthFilter implements GlobalFilter {    private final RouteMetadataService routeMetadataService; // gateway路由元数据    private final PathMatcher pathMatcher = new AntPathMatcher();  // Spring内置的路径匹配器    private final ObjectMapper objectMapper; // JSON 序列化工具    private final RedisService redisService;    @Override    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {        log.debug("全局鉴权开始");        HttpHeaders headers = exchange.getRequest().getHeaders();        // 检查是否包含 WebSocket 升级头        boolean isWebSocket = headers.containsKey(HttpHeaders.UPGRADE) &&                headers.getConnection().contains("Upgrade") &&                "websocket".equalsIgnoreCase(headers.getFirst(HttpHeaders.UPGRADE));        String token;        if (isWebSocket) {            // WebSocket 请求处理            log.debug("检测到 WebSocket 请求");            token = exchange.getRequest().getQueryParams().getFirst("token");            log.debug("WebSocket token: {}", token);        } else {            log.info("开始鉴权Http");            Route route = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);            if (route != null) {                // 过滤白名单路由鉴权                List<String> authWhiteList = routeMetadataService.getauthWhiteList(route.getId());                String path = exchange.getRequest().getURI().getPath();                if (authWhiteList.stream().anyMatch(pattern -> pathMatcher.match(pattern, path))) {                    log.debug("白名单路由: {}", path);                    return chain.filter(exchange);                }            }            // 从请求头获取Token            token = exchange.getRequest().getHeaders().getFirst("Authorization");        }        // 验证Token逻辑（如调用Auth服务）        User user = isValidToken(token);        if (user == null) {            return Result.error(HttpStatus.UNAUTHORIZED).toMono(exchange.getResponse(), objectMapper);        }        // 鉴权通过，添加用户信息到请求头        try {            objectMapper.writeValueAsString(user);            ServerHttpRequest request = exchange.getRequest()                    .mutate()                    .header(HttpHeaderKeys.USER_INFO, objectMapper.writeValueAsString(user)) // 添加完整用户 JSON                    .build();            // 构建新的 ServerWebExchange 并继续传递            ServerWebExchange newExchange = exchange.mutate().request(request).build();            return chain.filter(newExchange);        } catch (JsonProcessingException e) {            throw new RuntimeException(e);        }    }    /***     * 鉴权判断     */    private User isValidToken(String token) {        log.debug("鉴权token: {}", token);        return redisService.getCacheObject(RedisPath.USER_TOKEN + token);    }}

调用示例

Http调用，获取token对应用户信息

curl --location --request GET '127.0.0.1:8080/auth/get_user_by_token' \--header 'Authorization: e49d0fd1-5248-4f5a-bc49-ebaf5cb1ce68'

Websocket因为js不能带有Header信息，所以放在请求地址上

// 创建WebSocket连接（替换为你的WebSocket服务器地址）const socket = new WebSocket('ws://127.0.0.1:8080/chat/im?token=e49d0fd1-5248-4f5a-bc49-ebaf5cb1ce68');

1. 检查是否登录
2. 检查仓库是否存在
3. Mac检查钥匙串是否有异常

push命令

docker push <docke hub 地址（可以省略）>/<dockerhub的用户名>/<自己的仓库名称>:<镜像名称>docker push docker.io/jagger133609/jagger:gateway-0.0.1

检查是否登录

重复登录一次

docker logindocker logout

检查仓库是否存在

登录: https://hub.docker.com/repository/docker，检查是否有仓库，仓库名是否正确

MAC检查钥匙串是否有异常

MAC会使用钥匙串管理docker登录鉴权信息，如果出现异常就会这样。
进入目录~/Library/Keychains。
删除文件夹类似2210E2CA-FE29-50A3-B274-AC1BFCF0C27F，每个人的都不一样，但是这个格式差不多。
重启电脑会重新创建一个新的类似文件夹。

# 进入钥匙串目录cd ~/Library/Keychains# 删除文件夹rm -rf 2210E2CA-FE29-50A3-B274-AC1BFCF0C27F# 重启电脑

com.jagger├── common          <- 公共模块│   └── im          <- IM 组件└── services        <- 微服务模块    └── chat        <- Chat 微服务

因为im不属于chat子包层级，spring boot启动时不会默认扫描。这时就需要在im包对外主动暴露自动配置类，chat服务导入时根据配置类进行扫描。

添加IMAutoConfiguration类

import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;@Configuration@ComponentScan("com.jagger.common.im") // 指定扫描路径public class IMAutoConfiguration {}

添加AutoConfiguration文件

如果是spring boot2.7以下创建文件：resources/META-INF/spring.factories，并写入

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\com.jagger.common.im.IMAutoConfiguration

如果是spring boot2.7以上，特别是3.x创建文件：/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports，注意这里目录结构不一样是：/resources/META-INF/spring

com.jagger.common.im.IMAutoConfiguration

添加相关配置

pom.xml文件添加mvn包

        <!-- SpringCloud Alibaba Nacos 服务注册 -->        <dependency>            <groupId>com.alibaba.cloud</groupId>            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>        </dependency>        <!-- SpringCloud Alibaba Nacos 配置中心 -->        <dependency>            <groupId>com.alibaba.cloud</groupId>            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>        </dependency>        <!-- spring gateway 网关 --><dependencies><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-gateway</artifactId></dependency></dependencies>

bootstrap.yml添加配置

server:  port: 8080spring:  application:    name: gateway  profiles:    active: dev  cloud:    nacos:      discovery: # 服务注册、发现        server-addr: 127.0.0.1:8848        username: nacos        password: nacos        service: ${spring.application.name}-${spring.profiles.active}      config:        server-addr: 127.0.0.1:8848        username: nacos        password: nacos        file-extension: yml        shared-configs: # 指定额外的配置文件          - data-id: application.yml    loadbalancer:      nacos:        enabled: true # 开启nacos负载均衡策略    gateway:      routes: # 网关路由配置        - id: auth-service # 路由id，自定义，只要唯一即可          #uri: http://127.0.0.1:8088 # 路由的目标地址 http就是固定地址          uri: lb://auth-${spring.profiles.active} # 路由的目标地址 lb就是负载均衡，后面跟服务名称          predicates: # 路由断言，也就是判断请求是否符合路由规则的条件            - Path=/auth/** # 这个是按照路径匹配，只要以 /auth/ 开头就符合要求          filters: # 路由过滤器，对请求或者响应做出处理            - StripPrefix=1 # 去掉路径一条前缀，这里是: /auth          metadata:            auth-white-list: # 过滤器白名单列表，目前只配置login路由白名单              - /login/**

此时启动gateway、auth服务，访问http://127.0.0.1:8080/auth/login服务就会自动转发到http://auth-dev/login，auth-dev就是Nacos注册的鉴权服务。
auth服务路由代码可以参考这篇文章最后一段Controller代码: https://halo.ljdzsk.com/archives/springbootswagger3-tong-yi-jie-kou-xiang-ying

添加过滤器，路由管理器配置，针对路由进行鉴权、服务转发

import com.fasterxml.jackson.databind.ObjectMapper;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.cloud.gateway.filter.GatewayFilterChain;import org.springframework.cloud.gateway.filter.GlobalFilter;import org.springframework.cloud.gateway.route.Route;import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;import org.springframework.stereotype.Component;import org.springframework.util.AntPathMatcher;import org.springframework.util.PathMatcher;import org.springframework.web.server.ServerWebExchange;import reactor.core.publisher.Mono;import java.util.List;@Slf4j@Component@RequiredArgsConstructorpublic class AuthFilter implements GlobalFilter {    private final RouteMetadataService routeMetadataService;    private final ObjectMapper objectMapper; // JSON 序列化工具    private final PathMatcher pathMatcher = new AntPathMatcher();  // Spring内置的路径匹配器    @Override    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {        log.info("开始鉴权");        Route route = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);        if (route != null) {            // 过滤白名单路由鉴权            List<String> authWhiteList = routeMetadataService.getauthWhiteList(route.getId());            String path = exchange.getRequest().getURI().getPath();            if (authWhiteList.stream().anyMatch(pattern -> pathMatcher.match(pattern, path))) {                return chain.filter(exchange);            }        }        // 从请求头或参数中获取Token        String token = exchange.getRequest().getHeaders().getFirst("Authorization");        // 验证Token逻辑（如调用Auth服务）        if (!isValidToken(token)) {            return Result.error(HttpStatus.UNAUTHORIZED).toMono(exchange.getResponse(), objectMapper);        }        return chain.filter(exchange);    }    /***     * 鉴权判断     */    private boolean isValidToken(String token) {        return false;    }}

路由管理服务

import jakarta.annotation.PostConstruct;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.cloud.gateway.route.Route;import org.springframework.cloud.gateway.route.RouteLocator;import org.springframework.stereotype.Component;import reactor.core.publisher.Flux;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Optional;import java.util.stream.Collectors;/*** * 路由管理 */@Component@RequiredArgsConstructor@Slf4jpublic class RouteMetadataService {    private final RouteLocator routeLocator;    private final Map<String, List<String>> routeExcludePaths = new HashMap<>();    /**     * 加载所有路由的元数据     */    public void loadMetadata() {        Flux<Route> routes = routeLocator.getRoutes();        routes.subscribe(route -> {            // 从元数据获取鉴权白名单，路径在白名单中，无需鉴权            List<String> authWhiteList = Optional.ofNullable(route.getMetadata().get("auth-white-list"))                    .map(obj -> {                        if (obj instanceof List) {                            // 直接转换为List<String>                            return (List<String>) obj;                        } else if (obj instanceof Map) {                            // 如果是Map，提取所有值组成List                            Map<?, ?> map = (Map<?, ?>) obj;                            return map.values().stream()                                    .filter(String.class::isInstance)                                    .map(String.class::cast)                                    .collect(Collectors.toList());                        } else {                            log.warn("auth-white-list 类型不匹配: {}", obj.getClass().getName());                            return List.<String>of();                        }                    })                    .orElse(List.of());  // 默认返回空列表            routeExcludePaths.put(route.getId(), authWhiteList);        });    }    /**     * 获取指定路由的白名单路径列表     */    public List<String> getauthWhiteList(String routeId) {        return routeExcludePaths.getOrDefault(routeId, List.of());    }    /**     * 动态路由更新时调用此方法刷新缓存     */    @PostConstruct    public void refreshMetadata() {        routeExcludePaths.clear();        loadMetadata();    }}

此时启动gateway、auth服务，访问：http://127.0.0.1:8080/auth/login可以正常转发，http://127.0.0.1:8080/auth/login1 会提示没有权限。

spring-boot-starter-web 替换 spring-boot-starter-webflux导致

1. spring-boot-starter-web对应使用springdoc-openapi-starter-webmvc-ui，spring-boot-starter-webflux对应使用springdoc-openapi-starter-webflux-ui，需要一起还

配置文件path正确配置

检查配置文件path是否正确
注：webmvc-ui会带有前缀，/swagger-ui，此时访问http://localhost:8080/swagger-ui/index.html#/,才是正确路径
webflux-ui会带有前缀，/webjars/swagger-ui，此时访问http://localhost:8080/webjars/swagger-ui/index.html#/,才是正确路径

springdoc:  api-docs:    enabled: true    # 是否开启 OpenAPI JSON 接口    path: /v3/api-docs # 默认路径  swagger-ui:    enabled: true    path: /index.html # 自定义 Swagger UI 路径，访问此路径会重定向到/swagger-ui/index.html    disable-swagger-default-url: true # 禁用 swagger 默认自带的示例 ui  webjars:    prefix: # 禁用默认的 /webjars 路径，webflux 会访问到 /webjars/swagger-ui/index.html

WebMvcConfigurer、WebFluxConfigurer配置问题

检查是否实现WebMvcConfigurer，实现是否有问题，WebFluxConfigurer同理只是继承改成WebFluxConfigurer。

@Configurationpublic class WebConfig implements WebMvcConfigurer {    @Override    public void addResourceHandlers(ResourceHandlerRegistry registry) {        registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");        registry.addResourceHandler("swagger-ui.html")            .addResourceLocations("classpath:/META-INF/resources/");        registry.addResourceHandler("/webjars/**")            .addResourceLocations("classpath:/META-INF/resources/webjars/");    }}

Netty是什么？

（抄的）Netty是一个高性能、异步的网络应用程序框架，可以轻松地开发基于TCP、UDP和HTTP等协议的网络应用程序。它是基于Java NIO技术实现的，具有较高的性能和可扩展性。Netty不仅可以用于开发网络客户端和服务器端，还可以用于开发其他类型的网络应用程序，如网络代理、网关和中间件等。
Netty的主要作用是为开发人员提供一个高效、可靠和可扩展的网络通信框架，从而降低网络应用程序的开发难度和维护成本。它提供了一系列的编解码器、处理器和协议支持，使得开发人员可以更加专注于业务逻辑的实现，而不必关心底层网络通信细节。

Netty核心组件

Channel（通道）

• 作用：抽象了网络连接（如 Socket），提供统一的 API 操作（读、写、绑定、连接等），支持多种传输类型（NIO、Epoll、OIO 等）。
• 关键实现：NioSocketChannel（TCP 客户端）、NioServerSocketChannel（TCP 服务端）。

EventLoop & EventLoopGroup（事件循环和线程组）

• EventLoop：
  • 每个 EventLoop 绑定一个线程，负责处理多个 Channel 的 I/O 事件和异步任务。
  • 遵循 单线程模型，确保线程安全。
• EventLoopGroup：
  • 管理一组 EventLoop，通常分为 bossGroup（接收连接）和 workerGroup（处理 I/O）。
  • 示例：NioEventLoopGroup。

ChannelHandler & ChannelPipeline（处理器和处理链）

• ChannelHandler：
  • 处理入站/出站事件和数据，用户自定义逻辑的核心扩展点。
  • 分类：
    • ChannelInboundHandler（处理连接建立、数据读取等入站事件）。
    • ChannelOutboundHandler（处理连接关闭、数据写入等出站操作）。
    • ChannelDuplexHandler（继承以上两个类，出、入站都会处理）。
    • ChannelInitializer (继承ChannelInboundHandler，在连接建立时初始化)。
• ChannelPipeline：
  • 由多个 ChannelHandler 组成的责任链，数据按顺序流经各个处理器。
  • 支持动态增删处理器。

ByteBuf（数据容器）

• 作用：替代 Java NIO 的 ByteBuffer，提供更高效灵活的数据存储（如池化内存、零拷贝优化）。
• 特性：支持读写索引分离、引用计数、复合缓冲区等。

Bootstrap & ServerBootstrap（启动引导类）

• Bootstrap：
  • 客户端启动类，配置线程组、Channel 类型、处理器等。
• ServerBootstrap：
  • 服务端启动类，额外绑定端口并管理 bossGroup 和 workerGroup。

ChannelFuture（异步结果）

• 作用：表示异步 I/O 操作的结果（如连接、写入），通过添加监听器 (ChannelFutureListener) 实现回调逻辑。
• 示例：channel.writeAndFlush(data).addListener(...)。

编解码器（Codec）

• 作用：将原始字节流与业务对象相互转换（如 HTTP 协议解析、Protobuf 序列化）。
• 常见实现：
  • MessageToByteEncoder（编码器）、ByteToMessageDecoder（解码器）。
  • 内置编解码器：StringEncoder/Decoder、ObjectEncoder/Decoder 等。

ChannelHandlerContext（处理器上下文）

• 作用：关联 ChannelHandler 与 ChannelPipeline，提供方法触发事件传播（如 ctx.write()）或获取 Channel 信息。

组件协作流程

1. 通过 Bootstrap、ServerBootstrap 配置并启动服务端、客户端。
2. ChannelInitializer 添加连接建立时初始化内容。
3. 通过添加ChannelInboundHandler、ChannelOutboundHandler 配置数据出、入站处理。
4. 操作 ByteBuf 数据类或 ChannelFuture 异步回调控制业务逻辑。

实战代码Demo

Spring boot 添加Netty包

        <!-- 通过注解，添加语法糖-->        <dependency>            <groupId>org.projectlombok</groupId>            <artifactId>lombok</artifactId>        </dependency>        <!-- json解析-->        <dependency>            <groupId>com.alibaba.fastjson2</groupId>            <artifactId>fastjson2</artifactId>            <version>2.0.54</version>        </dependency>            <!-- NIO框架，主要用于IM实时通讯  -->            <!-- https://mvnrepository.com/artifact/io.netty/netty-all -->            <dependency>                <groupId>io.netty</groupId>                <artifactId>netty-all</artifactId>                <version>4.1.118.Final</version>            </dependency>                    <!-- 如果使用 webflux 默认集成Netty，就不需要上面的 netty-all 包 -->        <!-- 使用 webflux 响应式流（Reactive Streams）默认通过 Netty 启动排除 Tomcat -->        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-webflux</artifactId>            <exclusions>                <exclusion>                    <groupId>org.springframework.boot</groupId>                    <artifactId>spring-boot-starter-tomcat</artifactId>                </exclusion>            </exclusions>        </dependency>

自定义配置项，方便bootstrap.yml配置

import lombok.Data;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.context.annotation.Configuration;@Configuration@ConfigurationProperties(prefix = "netty")@Datapublic class NettyProperties {    /**     * boss线程数量     */    private Integer bossThread = 1;    /**     * worker线程数量     */    private Integer workerThread = 1;    /**     * 连接超时时间     */    private Integer timeout = 30000;    /**     * 服务器主端口     */    private Integer port = 9000;    /**     * 服务器地址 默认为本地     *///    private String host = "127.0.0.1";}

编写消息类，用于传输数据

目前暂定只有默认String数据类，ChatMessagsIM聊天数据类（可以自行添加model进行编写序列化代码）

import com.alibaba.fastjson2.JSONObject;import com.jagger.model.ChatMessage;import lombok.Data;import lombok.Getter;import lombok.extern.slf4j.Slf4j;@Slf4j@Datapublic class Message {    // 消息类型，占用 2 字节    private short type;    // 消息长度，占用 4 字节    private int length;    // 消息内容    private byte[] body;    /***     * {@link Object} 转 {@link Message} 类型     * @return {@link Message}     */    public static Message objectToMessage(Object body) {        Message message = new Message();        message.setType(Message.MessageType.getType(body).getValue());        if (message.getType() == Message.MessageType.STRING.getValue()) {            message.setBody(((String) body).getBytes());        } else {            String bodyJsonStr = JSONObject.toJSONString(body);            message.setBody(bodyJsonStr.getBytes());            message.setLength(message.getBody().length);        }        return message;    }    /***     * {@link Message} 转 {@link Object} 类型     * @return {@link Object}     */    public static Object messageToObject(Message message) {        String bodyStr = new String(message.getBody());        if (message.getType() == Message.MessageType.STRING.getValue()) {            return bodyStr;        } else if (message.getType() == MessageType.CHAT_MESSAGE.getValue()) {            return JSONObject.parseObject(bodyStr, ChatMessage.class);        } else {            throw new RuntimeException("Message 转 Object 错误，未定义对象类型。");        }    }    /***     * {@link Message} 转 {@link Object} 类型     * @return {@link Object}     */    public Object toObject() {        return messageToObject(this);    }    /***     * 消息类型     */    @Getter    public enum MessageType {        STRING((short) 0),        CHAT_MESSAGE((short) 1); // 聊天消息        private final short value;        private MessageType(short value) {            this.value = value;        }        public static MessageType getType(Object o) {            if (o instanceof String) {                return STRING;            } else if (o instanceof ChatMessage) {                return CHAT_MESSAGE;            } else {                throw new RuntimeException("不存在消息类型: " + o);            }        }    }}

定义数据出、入站处理类

• 入站类数据处理，继承实现ChannelInboundHandlerAdapter
  • MessageDecodeHandlerMessage数据解码，继承实现ByteToMessageDecoder
  • BusinessHandler业务数据处理
• 出站类数据处理，继承实现ChannelOutboundHandlerAdapter
  • ObjectToMessageHandler对象封装，Object转Message
  • MessageEncoderHandler数据编码
  • PushHandler数据推送前最后操作
• 出、入站数据处理统一处理，继承实现ChannelDuplexHandler
  • ExceptionHandler异常数据处理

MessageDecodeHandlerMessage数据解码

import io.netty.buffer.ByteBuf;import io.netty.channel.ChannelHandlerContext;import io.netty.handler.codec.ByteToMessageDecoder;import lombok.extern.slf4j.Slf4j;import java.util.List;/*** * 消息解码器 */@Slf4jpublic class MessageDecodeHandler extends ByteToMessageDecoder {    @Override    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {        log.debug("开始解码");        Message message = new Message();        message.setType(byteBuf.readShort());        //如果byteBuf剩下的长度还有大于4个字节，说明body不为空        if (byteBuf.readableBytes() > 4) {            message.setLength(byteBuf.readInt());            byte[] contents = new byte[message.getLength()];            byteBuf.readBytes(contents, 0, message.getLength());            message.setBody(contents);            list.add(message);            log.debug("成功解码，接收消息类型: {}", message.getType());        } else {            log.warn("解码失败: 消息内容为空");        }    }}

BusinessHandler业务数据处理

import io.netty.channel.ChannelHandlerContext;import io.netty.channel.ChannelInboundHandlerAdapter;import lombok.extern.slf4j.Slf4j;/*** * 业务处理 */@Slf4jpublic class BusinessHandler extends ChannelInboundHandlerAdapter {    @Override    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {        log.debug("开始业务处理");        log.debug("业务数据: {}", ((Message) msg).toObject());    }}

ObjectToMessageHandler对象封装

import io.netty.channel.ChannelHandlerContext;import io.netty.channel.ChannelOutboundHandlerAdapter;import io.netty.channel.ChannelPromise;import lombok.extern.slf4j.Slf4j;@Slf4jpublic class ObjectToMessageHandler extends ChannelOutboundHandlerAdapter {    @Override    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {        log.debug("分析数据类型");        super.write(ctx, Message.objectToMessage(msg), promise);    }}

MessageEncoderHandlerMessage数据编码

import io.netty.buffer.ByteBuf;import io.netty.channel.ChannelHandlerContext;import io.netty.handler.codec.MessageToByteEncoder;import lombok.extern.slf4j.Slf4j;/*** * 消息编码器 */@Slf4jpublic class MessageEncoderHandler extends MessageToByteEncoder<Message> {    @Override    protected void encode(ChannelHandlerContext channelHandlerContext, Message message, ByteBuf byteBuf) throws Exception {        log.debug("开始编码");        byteBuf.writeShort(message.getType());        if (message.getBody() != null) {            byteBuf.writeInt(message.getBody().length);            byteBuf.writeBytes(message.getBody());        }        log.debug("成功编码");    }}

PushHandler数据推送前最后操作

import io.netty.channel.ChannelHandlerContext;import io.netty.channel.ChannelOutboundHandlerAdapter;import io.netty.channel.ChannelPromise;import lombok.extern.slf4j.Slf4j;/*** * 推送消息时处理 */@Slf4jpublic class PushHandler extends ChannelOutboundHandlerAdapter {    @Override    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {        log.debug("分析数据类型");        super.write(ctx, msg, promise);    }}

ExceptionHandler异常数据处理

/*** * ChannelDuplexHandler 它同时实现了 ChannelInboundHandler 和 ChannelOutboundHandler 接口 * ChannelInboundHandler 所有异常会再最后统一处理 * ChannelOutboundHandler 所有异常需要通过 addListener 监听事件才能处理，需要放在第一位先添加监听 * ExceptionHandler 作为全局异常处理，放在最后正好 in 最后处理，out 最先处理 * */@Slf4jpublic class ExceptionHandler extends ChannelDuplexHandler {    /***     * 接收数据异常处理     * @param ctx     * @param cause     * @throws Exception     */    @Override    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {        log.error("接收消息处理异常: ", cause);    }    /***     * 出站数据异常处理     * @param ctx     * @param msg     * @param promise     */    @Override    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {        ctx.write(msg, promise.addListener(future -> {            if (!future.isSuccess()) {                // 处理异常                log.error("推送消息异常", future.cause());            }        }));    }}

编写服务端类NettyServer，服务端连接初始化类NettyServerInit

初始化添加Handler实现要注意顺序，ChannelInboundHandler先添加先调用，ChannelOutboundHandler后添加先调用。

import io.netty.bootstrap.ServerBootstrap;import io.netty.channel.*;import io.netty.channel.nio.NioEventLoopGroup;import io.netty.channel.socket.SocketChannel;import io.netty.channel.socket.nio.NioServerSocketChannel;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.stereotype.Component;@Slf4j@Component@RequiredArgsConstructorpublic class NettyServer {    private final NettyProperties nettyProperties;    private EventLoopGroup bossGroup; // 负责处理连接请求的线程组（NIO 事件循环组）    private EventLoopGroup workerGroup; // 负责处理 I/O 事件的线程组（NIO 事件循环组）    private ChannelFuture channelFuture; // 代表异步操作的结果    public void start() throws InterruptedException {        log.info("NettyServer 启动");        bossGroup = new NioEventLoopGroup(nettyProperties.getBossThread()); // 创建 boss 线程组，用于处理连接请求        workerGroup = new NioEventLoopGroup(nettyProperties.getWorkerThread()); // 创建 worker 线程组，用于处理 I/O 事件        ServerBootstrap serverBootstrap = new ServerBootstrap();        serverBootstrap                // 设置线程组                .group(bossGroup, workerGroup)                // 设置为NIO模式                .channel(NioServerSocketChannel.class)                // 设置TCP sync队列大小, 防止洪泛攻击                .childOption(ChannelOption.SO_BACKLOG, 1024)                // 设置初始化类                .childHandler(new NettyServerInit());        channelFuture = serverBootstrap.bind(nettyProperties.getPort()).addListener(future -> {            if (future.isSuccess()) {                log.info("Netty 服务启动，端口: {}", nettyProperties.getPort());            } else {                log.error("启动失败，请检查端口是否被占用: {}", nettyProperties.getPort(), future.cause());            }        }).sync();    }    /***     * 停止服务     */    public void stop() {        channelFuture.channel().close();        log.info("Netty 服务端停止");    }    /**     * 通过 Channel 发送数据     *     * @param body 文本数据     */    public void send(Object body) {        log.debug("服务端发送数据");        channelFuture.channel().writeAndFlush(body);    }    /***     * 初始化类     */    private static class NettyServerInit extends ChannelInitializer<SocketChannel> {        @Override        protected void initChannel(SocketChannel socketChannel) throws Exception {            log.info("新 Netty 连接: {}", socketChannel.remoteAddress());            // ChannelInboundHandlerAdapter 输入数据Handler实现调用顺序，先 addLast() 先处理            socketChannel.pipeline()                    .addLast(new MessageDecodeHandler())  // 数据解码                    .addLast(new BusinessHandler()) // 业务处理            ;            // ChannelOutboundHandlerAdapter 输出数据Handler实现调用顺序, 后 addLast() 先处理            socketChannel.pipeline()                    .addLast(new PushHandler())  // 数据推送前操作                    .addLast(new MessageEncoderHandler())  // 数据编码                    .addLast(new ObjectToMessageHandler())  // 数据编码            ;            // ChannelDuplexHandler 它同时实现了 ChannelInboundHandler 和 ChannelOutboundHandler 接口            // ChannelInboundHandler 所有异常会再最后统一处理            // ChannelOutboundHandler 所有异常需要通过 addListener 监听事件才能处理，需要放在第一位先添加监听            // ExceptionHandler 作为全局异常处理，放在最后正好 in 最后处理，out 最先处理            socketChannel.pipeline().addLast(new ExceptionHandler()); // 消息接收异常        }    }}

编写客户端类NettyClient，服务端连接初始化类NettyClientInit

注意点同服务端。

import io.netty.bootstrap.Bootstrap;import io.netty.channel.*;import io.netty.channel.nio.NioEventLoopGroup;import io.netty.channel.socket.SocketChannel;import io.netty.channel.socket.nio.NioSocketChannel;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.stereotype.Component;@Component@RequiredArgsConstructor@Slf4jpublic class NettyClient {    private final NettyProperties nettyProperties;    private ChannelFuture channelFuture;    Bootstrap bootstrap;    public void start() throws InterruptedException {        log.info("NettyClient 启动");        NioEventLoopGroup eventExecutors = new NioEventLoopGroup(nettyProperties.getWorkerThread());        bootstrap = new Bootstrap();        bootstrap.group(eventExecutors)   // 指定线程组                .option(ChannelOption.SO_KEEPALIVE, true)                .channel(NioSocketChannel.class) // 指定通道                .handler(new NettyClientInit()); // 指定处理器        channelFuture = bootstrap.connect("127.0.0.1", nettyProperties.getPort()).addListener(future -> {            log.info("客户端启动成功，并监听端口：{} ", nettyProperties.getPort());        });    }    /**     * 客户端通过 Channel 对象向服务器端发送数据     *     * @param body 文本数据     */    public void send(Object body) {        log.debug("客户端发送数据");        channelFuture.channel().writeAndFlush(body);    }    /***     * 停止服务     */    public void stop() {        channelFuture.channel().close();        log.info("Netty 客户端服务停止");    }    /***     * 客户端初始化     */    public static class NettyClientInit extends ChannelInitializer<SocketChannel> {        @Override        protected void initChannel(SocketChannel socketChannel) throws Exception {            log.debug("初始化 Netty 客户端");            socketChannel.pipeline()                    .addLast(new MessageDecodeHandler())  // 数据解码                    .addLast(new ClientHandler()) // 客户端handler            ;            socketChannel.pipeline()                    .addLast(new PushHandler())  // 数据推送前操作                    .addLast(new MessageEncoderHandler())  // 数据编码                    .addLast(new ObjectToMessageHandler())  // 对象转Message            ;            socketChannel.pipeline().addLast(new ExceptionHandler()); // 消息接收异常        }    }}

编写ImRunner实现ApplicationRunner

在Spring boot启动时统一启动服务端、客户端，这里客户端、服务端都统一放到一个项目里好方便测试

import jakarta.annotation.PreDestroy;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.boot.ApplicationArguments;import org.springframework.boot.ApplicationRunner;import org.springframework.stereotype.Component;@Slf4j@Component@RequiredArgsConstructorpublic class ImRunner implements ApplicationRunner {    private final NettyServer nettyServer;    private final NettyClient nettyClient;    @Override    public void run(ApplicationArguments args) throws Exception {        log.debug("启动IM服务");        nettyServer.start();        log.debug("启动 netty 客户端");        nettyClient.start();    }    @PreDestroy    public void destroy() {        log.debug("退出IM服务");        nettyServer.stop();        nettyClient.stop();    }}

添加Controller测试

这里通过调用NettyClient模拟客户端发送数据，测试数据ChatMessage为自定义model

@Slf4j@RestController@RequiredArgsConstructorpublic class ChatController implements ChatApi {    private final NettyClient nettyClient;        @Override    public List<ChatMessage> getMessages(int chatRoomId, int serialNumber, int messagesNumber) {        nettyClient.send("测试数据");        nettyClient.send(new ChatMessage());        return null;    }}

可以看到后台日志正常输出。

1. 安装依赖

<!-- 通过注解，添加语法糖--><dependency>    <groupId>org.projectlombok</groupId>    <artifactId>lombok</artifactId></dependency>

添加配置到bootstrap.yml

springdoc:  api-docs:    enabled: true    # 是否开启 OpenAPI JSON 接口    path: /v3/api-docs # 默认路径  swagger-ui:    enabled: true    path: /index.html # 自定义 Swagger UI 路径，访问此路径会重定向到/swagger-ui/index.html    disable-swagger-default-url: true # 禁用 swagger 默认自带的示例 ui  webjars:    prefix: # 修改默认的 /webjars 路径为空  

此时启动服务可以访问http://127.0.0.1:8080/swagger-ui/index.html

2. 定义统一响应类 Result<T>，http状态HttpStatus

坑点：Schema 泛型不能使用name属性，swagger-ui通过name区分唯一，会导致多个不同泛型api文档一样

import com.fasterxml.jackson.core.JsonProcessingException;import com.fasterxml.jackson.databind.ObjectMapper;import com.jagger.ai.common.core.constant.HttpStatus;import io.swagger.v3.oas.annotations.media.Schema;import lombok.Data;import lombok.extern.slf4j.Slf4j;import org.springframework.core.io.buffer.DataBuffer;import org.springframework.http.HttpStatusCode;import org.springframework.http.MediaType;import org.springframework.http.server.reactive.ServerHttpResponse;import reactor.core.publisher.Mono;@Slf4j@Data@Schema(description = "Http统一响应") // 统一响应类(泛型) 不能使用 @Schema(name = "")，swagger-ui通过name区分，导致多个泛型api文档一样public class Result<T> {    @Schema(description = "状态码")    private int code;    @Schema(description = "消息")    private String msg;    @Schema(description = "数据")    private T data;    public Result(HttpStatus httpStatus, String msg, T data) {        this.code = httpStatus.value();        this.msg = msg;        this.data = data;    }    // 成功响应（无数据）    public static <T> Result<T> success() {        return Result.success(null);    }    // 成功响应（带数据）    public static <T> Result<T> success(T data) {        return new Result<>(HttpStatus.OK, HttpStatus.OK.getReasonPhrase(), data);    }    // 错误响应    public static <T> Result<T> error(HttpStatus httpStatus) {        return Result.error(httpStatus, httpStatus.getReasonPhrase());    }    public static <T> Result<T> error(HttpStatus httpStatus, String msg) {        return Result.error(httpStatus, msg, null);    }    public static <T> Result<T> error(HttpStatus httpStatus, String msg, T data) {        return new Result<>(httpStatus, msg, data);    }    /***     * webflux 专用     */    public Mono<Void> toMono(ServerHttpResponse response, ObjectMapper objectMapper) {        response.setStatusCode(HttpStatusCode.valueOf(code));        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);        byte[] bytes = null;        try {            bytes = objectMapper.writeValueAsBytes(this);        } catch (JsonProcessingException e) {            log.error(e.getMessage(), e);            throw new RuntimeException(e);        }        DataBuffer buffer = response.bufferFactory().wrap(bytes);        return response.writeWith(Mono.just(buffer));    }}

HttpStatus 定义返回值

import org.springframework.lang.Nullable;/*** * 抄 {@link org.springframework.http.HttpStatus}，改汉化的 */public enum HttpStatus {    CONTINUE(100, HttpStatus.Series.INFORMATIONAL, "继续"),    SWITCHING_PROTOCOLS(101, HttpStatus.Series.INFORMATIONAL, "切换协议"),    PROCESSING(102, HttpStatus.Series.INFORMATIONAL, "处理中"),    EARLY_HINTS(103, HttpStatus.Series.INFORMATIONAL, "早期提示"),    OK(200, HttpStatus.Series.SUCCESSFUL, "成功"),    CREATED(201, HttpStatus.Series.SUCCESSFUL, "已创建"),    ACCEPTED(202, HttpStatus.Series.SUCCESSFUL, "已接受"),    NON_AUTHORITATIVE_INFORMATION(203, HttpStatus.Series.SUCCESSFUL, "非权威信息"),    NO_CONTENT(204, HttpStatus.Series.SUCCESSFUL, "无内容"),    RESET_CONTENT(205, HttpStatus.Series.SUCCESSFUL, "重置内容"),    PARTIAL_CONTENT(206, HttpStatus.Series.SUCCESSFUL, "部分内容"),    MULTI_STATUS(207, HttpStatus.Series.SUCCESSFUL, "多状态"),    ALREADY_REPORTED(208, HttpStatus.Series.SUCCESSFUL, "已报告"),    IM_USED(226, HttpStatus.Series.SUCCESSFUL, "IM 已使用"),    MULTIPLE_CHOICES(300, HttpStatus.Series.REDIRECTION, "多种选择"),    MOVED_PERMANENTLY(301, HttpStatus.Series.REDIRECTION, "永久移动"),    FOUND(302, HttpStatus.Series.REDIRECTION, "已找到"),    /** @deprecated */    @Deprecated    MOVED_TEMPORARILY(302, HttpStatus.Series.REDIRECTION, "临时移动"),    SEE_OTHER(303, HttpStatus.Series.REDIRECTION, "查看其他"),    NOT_MODIFIED(304, HttpStatus.Series.REDIRECTION, "未修改"),    /** @deprecated */    @Deprecated    USE_PROXY(305, HttpStatus.Series.REDIRECTION, "使用代理"),    TEMPORARY_REDIRECT(307, HttpStatus.Series.REDIRECTION, "临时重定向"),    PERMANENT_REDIRECT(308, HttpStatus.Series.REDIRECTION, "永久重定向"),    BAD_REQUEST(400, HttpStatus.Series.CLIENT_ERROR, "错误请求"),    UNAUTHORIZED(401, HttpStatus.Series.CLIENT_ERROR, "鉴权不通过"),    PAYMENT_REQUIRED(402, HttpStatus.Series.CLIENT_ERROR, "需要付款"),    FORBIDDEN(403, HttpStatus.Series.CLIENT_ERROR, "禁止访问"),    NOT_FOUND(404, HttpStatus.Series.CLIENT_ERROR, "未找到"),    METHOD_NOT_ALLOWED(405, HttpStatus.Series.CLIENT_ERROR, "方法不允许"),    NOT_ACCEPTABLE(406, HttpStatus.Series.CLIENT_ERROR, "不可接受"),    PROXY_AUTHENTICATION_REQUIRED(407, HttpStatus.Series.CLIENT_ERROR, "需要代理认证"),    REQUEST_TIMEOUT(408, HttpStatus.Series.CLIENT_ERROR, "请求超时"),    CONFLICT(409, HttpStatus.Series.CLIENT_ERROR, "冲突"),    GONE(410, HttpStatus.Series.CLIENT_ERROR, "已删除"),    LENGTH_REQUIRED(411, HttpStatus.Series.CLIENT_ERROR, "需要长度"),    PRECONDITION_FAILED(412, HttpStatus.Series.CLIENT_ERROR, "前提条件失败"),    PAYLOAD_TOO_LARGE(413, HttpStatus.Series.CLIENT_ERROR, "负载过大"),    /** @deprecated */    @Deprecated    REQUEST_ENTITY_TOO_LARGE(413, HttpStatus.Series.CLIENT_ERROR, "请求实体过大"),    URI_TOO_LONG(414, HttpStatus.Series.CLIENT_ERROR, "URI 过长"),    /** @deprecated */    @Deprecated    REQUEST_URI_TOO_LONG(414, HttpStatus.Series.CLIENT_ERROR, "请求 URI 过长"),    UNSUPPORTED_MEDIA_TYPE(415, HttpStatus.Series.CLIENT_ERROR, "不支持的媒体类型"),    REQUESTED_RANGE_NOT_SATISFIABLE(416, HttpStatus.Series.CLIENT_ERROR, "请求范围无法满足"),    EXPECTATION_FAILED(417, HttpStatus.Series.CLIENT_ERROR, "期望失败"),    I_AM_A_TEAPOT(418, HttpStatus.Series.CLIENT_ERROR, "我是一个茶壶"),    /** @deprecated */    @Deprecated    INSUFFICIENT_SPACE_ON_RESOURCE(419, HttpStatus.Series.CLIENT_ERROR, "资源空间不足"),    /** @deprecated */    @Deprecated    METHOD_FAILURE(420, HttpStatus.Series.CLIENT_ERROR, "方法失败"),    /** @deprecated */    @Deprecated    DESTINATION_LOCKED(421, HttpStatus.Series.CLIENT_ERROR, "目标锁定"),    UNPROCESSABLE_ENTITY(422, HttpStatus.Series.CLIENT_ERROR, "无法处理的实体"),    LOCKED(423, HttpStatus.Series.CLIENT_ERROR, "锁定"),    FAILED_DEPENDENCY(424, HttpStatus.Series.CLIENT_ERROR, "依赖失败"),    TOO_EARLY(425, HttpStatus.Series.CLIENT_ERROR, "过早"),    UPGRADE_REQUIRED(426, HttpStatus.Series.CLIENT_ERROR, "需要升级"),    PRECONDITION_REQUIRED(428, HttpStatus.Series.CLIENT_ERROR, "需要前提条件"),    TOO_MANY_REQUESTS(429, HttpStatus.Series.CLIENT_ERROR, "请求过多"),    REQUEST_HEADER_FIELDS_TOO_LARGE(431, HttpStatus.Series.CLIENT_ERROR, "请求头字段过大"),    UNAVAILABLE_FOR_LEGAL_REASONS(451, HttpStatus.Series.CLIENT_ERROR, "因法律原因不可用"),    INTERNAL_SERVER_ERROR(500, HttpStatus.Series.SERVER_ERROR, "服务器错误"),    NOT_IMPLEMENTED(501, HttpStatus.Series.SERVER_ERROR, "未实现"),    BAD_GATEWAY(502, HttpStatus.Series.SERVER_ERROR, "网关错误"),    SERVICE_UNAVAILABLE(503, HttpStatus.Series.SERVER_ERROR, "服务不可用"),    GATEWAY_TIMEOUT(504, HttpStatus.Series.SERVER_ERROR, "网关超时"),    HTTP_VERSION_NOT_SUPPORTED(505, HttpStatus.Series.SERVER_ERROR, "HTTP 版本不支持"),    VARIANT_ALSO_NEGOTIATES(506, HttpStatus.Series.SERVER_ERROR, "变体也协商"),    INSUFFICIENT_STORAGE(507, HttpStatus.Series.SERVER_ERROR, "存储不足"),    LOOP_DETECTED(508, HttpStatus.Series.SERVER_ERROR, "检测到循环"),    BANDWIDTH_LIMIT_EXCEEDED(509, HttpStatus.Series.SERVER_ERROR, "带宽限制超出"),    NOT_EXTENDED(510, HttpStatus.Series.SERVER_ERROR, "未扩展"),    NETWORK_AUTHENTICATION_REQUIRED(511, HttpStatus.Series.SERVER_ERROR, "需要网络认证");    private static final HttpStatus[] VALUES = values();    private final int value;    private final HttpStatus.Series series;    private final String reasonPhrase;    private HttpStatus(int value, HttpStatus.Series series, String reasonPhrase) {        this.value = value;        this.series = series;        this.reasonPhrase = reasonPhrase;    }    public int value() {        return this.value;    }    public HttpStatus.Series series() {        return this.series;    }    public String getReasonPhrase() {        return this.reasonPhrase;    }    /***     * 转 org.springframework.http.HttpStatus     * @return     */    public org.springframework.http.HttpStatus toSpringHttpStatus(){        return org.springframework.http.HttpStatus.valueOf(this.value);    }    public boolean is1xxInformational() {        return this.series() == HttpStatus.Series.INFORMATIONAL;    }    public boolean is2xxSuccessful() {        return this.series() == HttpStatus.Series.SUCCESSFUL;    }    public boolean is3xxRedirection() {        return this.series() == HttpStatus.Series.REDIRECTION;    }    public boolean is4xxClientError() {        return this.series() == HttpStatus.Series.CLIENT_ERROR;    }    public boolean is5xxServerError() {        return this.series() == HttpStatus.Series.SERVER_ERROR;    }    public boolean isError() {        return this.is4xxClientError() || this.is5xxServerError();    }    public String toString() {        int var10000 = this.value;        return var10000 + " " + this.name();    }    public static HttpStatus valueOf(int statusCode) {        HttpStatus status = resolve(statusCode);        if (status == null) {            throw new IllegalArgumentException("No matching constant for [" + statusCode + "]");        } else {            return status;        }    }    @Nullable    public static HttpStatus resolve(int statusCode) {        for(HttpStatus status : VALUES) {            if (status.value == statusCode) {                return status;            }        }        return null;    }    public static enum Series {        INFORMATIONAL(1),        SUCCESSFUL(2),        REDIRECTION(3),        CLIENT_ERROR(4),        SERVER_ERROR(5);        private final int value;        private Series(int value) {            this.value = value;        }        public int value() {            return this.value;        }        /** @deprecated */        @Deprecated        public static HttpStatus.Series valueOf(HttpStatus status) {            return status.series;        }        public static HttpStatus.Series valueOf(int statusCode) {            HttpStatus.Series series = resolve(statusCode);            if (series == null) {                throw new IllegalArgumentException("No matching constant for [" + statusCode + "]");            } else {                return series;            }        }        @Nullable        public static HttpStatus.Series resolve(int statusCode) {            int seriesCode = statusCode / 100;            for(HttpStatus.Series series : values()) {                if (series.value == seriesCode) {                    return series;                }            }            return null;        }    }}

3. WebMvc配置

3.1 添加 WebMvc 所需mvn 包

<!-- webmvc 依赖于 spring-boot-starter-web --><dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-web</artifactId></dependency><!-- springboot 官方 api 文档，集成Swagger v3 --><!-- https://mvnrepository.com/artifact/org.springdoc/springdoc-openapi-ui --><dependency>    <groupId>org.springdoc</groupId>    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>    <version>2.8.3</version></dependency>

3.2 自定义@RestControllerAdvice自动使用Result<T>包装返回值

注: 使用RestControllerAdvice封装返回值不会修改swagger-ui显示，需要而外添加swagger ui api封装，参考文章后续方案

如果未生效，启动类添加注解@ComponentScan(basePackages = {"com.xxx.xxx"})确定扫描包范围（但是会导致spring扫描bean注入有问题，idea报错一些spring类无法找到注入，要把需要扫描的所有包都加进去）

@SpringBootApplication@ComponentScan(basePackages = {       "com.xxx.xxx",    // 主模块包路径})public class AuthApplication {    public static void main(String[] args) {        SpringApplication.run(AuthApplication.class, args);    }}

封装正常返回

import com.fasterxml.jackson.core.JsonProcessingException;import com.fasterxml.jackson.databind.ObjectMapper;import com.jagger.ai.common.core.domain.Result;import org.springframework.core.MethodParameter;import org.springframework.http.MediaType;import org.springframework.http.server.ServerHttpRequest;import org.springframework.http.server.ServerHttpResponse;import org.springframework.web.bind.annotation.RestControllerAdvice;import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;/*** * 所有返回值统一封装{@link Result} */@RestControllerAdvice(basePackages = "com.xx.xx") // 扫描包范围public class GlobalResponseHandler implements ResponseBodyAdvice<Object> {    /***     * 判断是否需要处理返回值     */    @Override    public boolean supports(MethodParameter returnType, Class converterType) {        // 排除已包装的 Result 类型        return !returnType.getParameterType().isAssignableFrom(Result.class);    }    /***     * 统一包装返回值     */    @Override    public Object beforeBodyWrite(Object body, MethodParameter returnType,                                  MediaType mediaType, Class converterType,                                  ServerHttpRequest request, ServerHttpResponse response) {        // 如果返回值是 String 类型，手动转为 JSON 字符串        // 在 Spring 的 统一响应处理中，只有 String 类型需要单独处理，而其他类型（如 int、对象、集合等）不需要特殊处理。        // 这是因为 Spring 对 String 类型的返回值有特殊的 StringHttpMessageConverter 默认行为，而其他类型会通过 JSON 序列化正常处理。        Result<?> result = Result.success(body);        if (body instanceof String) {            try {                return new ObjectMapper().writeValueAsString(result);            } catch (JsonProcessingException e) {                throw new RuntimeException(e);            }        }        return Result.success(body);    }}

4. WebFlux配置

4.1. 安装依赖，添加配置

<!-- 使用 webflux 响应式流（Reactive Streams）默认通过 Netty 启动排除 Tomcat --><dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-webflux</artifactId></dependency><!-- springboot 官方 api 文档，支持集成Swagger --><!-- https://mvnrepository.com/artifact/org.springdoc/springdoc-openapi-ui --><dependency>    <groupId>org.springdoc</groupId>    <artifactId>springdoc-openapi-starter-webflux-ui</artifactId></dependency>

自定义WebProperties配置控制全局封装过滤路由

import lombok.Data;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.stereotype.Component;import java.util.ArrayList;import java.util.List;@Component@ConfigurationProperties(prefix = "jagger.web")@Datapublic class WebProperties {    // 需要无视的路由    private List<String> ignoreRoute = new ArrayList<>();    // 统一封装所有响应返回    private Boolean unifiedResponse = true;}

application.yml文件添加配置

jagger:  web:    ignore-route:    # 过滤 swagger api 路由      - ${springdoc.api-docs.path}/** 

4.2. 自定义GlobalResponseHandler自动Result<T>包装返回值

import org.springframework.core.MethodParameter;import org.springframework.core.ResolvableType;import org.springframework.http.codec.HttpMessageWriter;import org.springframework.util.AntPathMatcher;import org.springframework.util.PathMatcher;import org.springframework.web.reactive.HandlerResult;import org.springframework.web.reactive.accept.RequestedContentTypeResolver;import org.springframework.web.reactive.result.method.annotation.ResponseBodyResultHandler;import org.springframework.web.server.ServerWebExchange;import reactor.core.publisher.Flux;import reactor.core.publisher.Mono;import java.lang.reflect.Method;import java.util.ArrayList;import java.util.List;/*** * 所有返回值统一封装{@link Result} */public class GlobalResponseHandler extends ResponseBodyResultHandler {    // 需要无视的路由配置，避免封装导致api返回异常，例如: swagger api的路径    private final List<String> ignoreRoute;    public GlobalResponseHandler(List<String> ignoreRoute, List<HttpMessageWriter<?>> writers, RequestedContentTypeResolver resolver) {        super(writers, resolver);        this.ignoreRoute = ignoreRoute;        setOrder(getOrder() - 1); // 修改调用优先级使其高于 ResponseBodyResultHandler。    }    private static MethodParameter param;    static {        try {            Method method = GlobalResponseHandler.class.getDeclaredMethod("methodForParams");            param = new MethodParameter(method, -1);            param = param.nestedIfOptional();        } catch (NoSuchMethodException e) {            throw new IllegalStateException("Failed to find methodForParams method", e);        }    }    // 虚拟方法用于初始化MethodParameter    private static Result<?> methodForParams() {        return null;    }    private final PathMatcher pathMatcher = new AntPathMatcher();  // Spring内置的路径匹配器    /***     * 判断是否是需要忽视的路由     */    private boolean isIgnoreRoute(String route) {        return ignoreRoute.stream()                .anyMatch(pattern -> pathMatcher.match(pattern, route));    }    /***     * 判断是否需要执行封装操作     */    @Override    public boolean supports(HandlerResult result) {        // 使用 ResolvableType 解析返回值类型        ResolvableType returnType = result.getReturnType();        // 检查是否包含泛型参数        if (returnType.getGenerics().length == 0) {            // 无泛型参数，需要封装            return true;        }        Class<?> rawClass = returnType.getRawClass();        if (rawClass == null) {            return true;        }        // 判断泛型是否是 Result 类型        return !Result.class.isAssignableFrom(rawClass);    }    @Override    public Mono<Void> handleResult(ServerWebExchange exchange, HandlerResult result) {        // 跳过需要忽视路由，避免第三方包api调用异常，例如：Swagger Api        if (isIgnoreRoute(exchange.getRequest().getURI().getPath())) {            return super.handleResult(exchange, result);        }        Object returnValue = result.getReturnValue();        if (returnValue instanceof Mono) {            // 处理Mono<T>，将其映射为Mono<Result<T>>            return ((Mono<?>) returnValue)                    .map(item -> {                        ResolvableType resolvableType = ResolvableType.forType(item.getClass());                        Class<?> rawClass = resolvableType.getRawClass();                        // 非Result类型，包装成Result                        if (rawClass != null && Result.class.isAssignableFrom(rawClass)) {                            // 已经是Result类型，直接返回                            return (Result<?>) item;                        } else {                            // 非Result类型，包装成Result                            return Result.success(item);                        }                    })                    .defaultIfEmpty(Result.success(null))   // 处理空 Mono（如 Mono.empty()）                    .flatMap(body -> writeBody(body, param, exchange));        } else if (returnValue instanceof Flux) {            // 处理Flux<T>，转换为Mono<Result<List<T>>>            return ((Flux<?>) returnValue).collectList()                    .map(items -> {                        if (items.isEmpty()) {                            return Result.success(items);                        } else {                            List<Object> resultList = new ArrayList<>();                            for (Object item : items) {                                ResolvableType resolvableType = ResolvableType.forType(item.getClass());                                Class<?> rawClass = resolvableType.getRawClass();                                if (rawClass != null && Result.class.isAssignableFrom(rawClass)) {                                    resultList.add(((Result<?>) item).getData());                                } else {                                    resultList.add(item);                                }                            }                            return Result.success(resultList);                        }                    })                    .defaultIfEmpty(Result.success(null))                    .flatMap(body -> writeBody(body, param, exchange));        } else {            // 调用父类方法处理包装后的返回值            return writeBody(Result.success(returnValue), param, exchange);        }    }}

4.3. 自定义WebFluxConfiguration并注入GlobalResponseHandler

import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.http.codec.ServerCodecConfigurer;import org.springframework.web.reactive.accept.RequestedContentTypeResolver;import org.springframework.web.reactive.config.WebFluxConfigurer;@Configuration@RequiredArgsConstructor@Slf4jpublic class WebFluxConfiguration implements WebFluxConfigurer {    private final WebProperties webProperties;    @Bean    public GlobalResponseHandler responseWrapper(ServerCodecConfigurer serverCodecConfigurer,                                                 RequestedContentTypeResolver requestedContentTypeResolver) {        if (webProperties.getUnifiedResponse()) {            log.info("全局响应自动封装，忽略路由: {}", webProperties.getIgnoreRoute());            return new GlobalResponseHandler(webProperties.getIgnoreRoute(), serverCodecConfigurer.getWriters(), requestedContentTypeResolver);        }        return null;    }}

5. 自定义GlobalExceptionHandler监听全局异常WebMvc、WebFlux通用

定义异常

import lombok.Getter;@Getterpublic class AuthException extends RuntimeException {    private final HttpStatus httpStatus;    public AuthException(HttpStatus httpStatus) {        super(httpStatus.getReasonPhrase());        this.httpStatus = httpStatus;    }}

异常处理统一返回

import lombok.extern.slf4j.Slf4j;import org.springframework.http.ResponseEntity;import org.springframework.web.bind.annotation.ExceptionHandler;import org.springframework.web.bind.annotation.RestControllerAdvice;@Slf4j@RestControllerAdvice(basePackages = "com.jagger.ai")public class GlobalExceptionHandler {    @ExceptionHandler(AuthException.class)    public ResponseEntity<Result<Void>> authException(AuthException e) {        // 从异常中动态获取HTTP状态码        return ResponseEntity                .status(e.getHttpStatus().toSpringHttpStatus())                .body(Result.error(e.getHttpStatus(), e.getMessage()));    }    // 处理其他未捕获异常    @ExceptionHandler(Exception.class)    public ResponseEntity<Result<Void>> handleException(Exception e) {        log.error(e.getMessage(), e);        return ResponseEntity                .status(HttpStatus.INTERNAL_SERVER_ERROR.toSpringHttpStatus())                .body(Result.error(HttpStatus.INTERNAL_SERVER_ERROR,e.getMessage()));    }}

此时定义的一个Controller，返回String会自动加一层封装返回Result<T>，以下是测试路由

public interface LoginApi {@Slf4j@RestController@RequiredArgsConstructorpublic class LoginController implements LoginApi {    @Override    public String login() {        throw new AuthException(HttpStatus.INTERNAL_SERVER_ERROR);    }    @GetMapping("/login2")    public Mono<Result<String>> login2() {        return Mono.create(sink -> sink.success(Result.success("success")));    }    @GetMapping("/login3")    public Mono<Result<Result<String>>> login3() {        return Mono.create(sink -> sink.success(Result.success(Result.success("success"))));    }    @GetMapping("/login4")    public Flux<Result<String>> login4() {        return Flux.create((t) -> {            t.next(Result.success("1"));            t.next(Result.success("2"));            t.complete();        });    }    @GetMapping("/login5")    public List<String> login5() {        return List.of("1", "2", "3");    }}}

所有响应都会返回Result<T>，但是swagger-ui接口文档显示不正确

接口 /login 返回文档

string

接口 /login2 返回文档

{  "code": 200,  "msg": "Success",  "data": "string"}

6. 自定义ResultWrapperCustomizer修改Swagger Ui 显示Api文档，使其匹配Result<T>包装的返回值

import io.swagger.v3.oas.models.OpenAPI;import io.swagger.v3.oas.models.media.*;import io.swagger.v3.oas.models.responses.ApiResponse;import io.swagger.v3.oas.models.responses.ApiResponses;import lombok.extern.slf4j.Slf4j;import org.springframework.stereotype.Component;import org.springdoc.core.customizers.OpenApiCustomizer;/*** * swagger ui api显示所有返回值封装一层{@link Result} */@Slf4j@Componentpublic class ResultWrapperCustomizer implements OpenApiCustomizer {    @Override    public void customise(OpenAPI openApi) {        openApi.getPaths().forEach((path, pathItem) -> {            log.debug(path);            pathItem.readOperations().forEach(operation -> {                ApiResponses responses = operation.getResponses();                responses.values().forEach(apiResponse -> processApiResponse(apiResponse));            });        });    }    /***     * 处理api docs返回值显示内容     * @param apiResponse     */    private void processApiResponse(ApiResponse apiResponse) {        Content content = apiResponse.getContent();        if (content == null) {            // 针对无响应体的接口（如返回 void），创建默认的 content 和 schema            content = new Content();            MediaType mediaType = new MediaType();            mediaType.setSchema(createWrappedSchema(null)); // 传入 null 表示 data 为 null            content.addMediaType("application/json", mediaType);            apiResponse.setContent(content);            return;        }        content.forEach((mediaType, mediaTypeItem) -> {            Schema originalSchema = mediaTypeItem.getSchema();            if (originalSchema != null && !isResultWrapper(originalSchema)) {                Schema<?> wrappedSchema = createWrappedSchema(originalSchema);                mediaTypeItem.setSchema(wrappedSchema);            }        });    }    /***     * 判断返回类型是否是Result     */    private boolean isResultWrapper(Schema<?> schema) {        if (schema.get$ref() != null) {            return schema.get$ref().startsWith("#/components/schemas/" + Result.class.getSimpleName());        }        return false;    }    /***     * 封装一层Result     */    private Schema<?> createWrappedSchema(Schema<?> originalSchema) {        return new ObjectSchema()                .addProperty("code", new IntegerSchema().example(200))                .addProperty("msg", new StringSchema().example("Success"))                .addProperty("data", originalSchema);    }}

至此swagger-ui显示的接口文档，返回值也是正确的
接口 /login 返回文档

{  "code": 200,  "msg": "Success",  "data": "string"}

接口 /login2 返回文档

{  "code": 200,  "msg": "Success",  "data": "string"}

7. 同步Spring Boot和Swagger Ui的ObjectMapper，统一修改返回值驼峰格式为蛇形格式（下划线）

application.yml 添加配置

spring:  jackson:    property-naming-strategy: SNAKE_CASE

添加ModelResolver子类通过@Component注入 Spring

/*** * 通过 @Component 注入 CustomModelResolver 覆盖 ModelResolver，将spring ObjectMapper注入CustomModelResolver。 * 否则ModelResolver会使用自定义的ObjectMapper，无法与spring ObjectMapper保持同步配置，例如：swagger ui 返回值格式修改 SNAKE_CASE * 注：这里不能使用@bean注入ModelResolver实现，否则ModelResolver不会加载自定义ModelConverter，具体原因未知。 */@Componentpublic class CustomModelResolver extends ModelResolver {    public CustomModelResolver(ObjectMapper mapper) {        super(mapper);    }}

此时返回值都会是下划线格式

就算代理设置了全局代理，git上传时走的也是hosts文件配置。因此就会出现网页可以访问github，但是git push到github就会提示链接失败。

代理配置

我们这里假设本地代理为http://127.0.0.1:1080。

全局配置

全局配置会影响所有的git地址，这里建议针对网址进行局部配置

git config --global http.proxy http://127.0.0.1:1080git config --global https.proxy https://127.0.0.1:1080

局部配置

针对github.com单独进行代理配置

git config --global http.https://github.com.proxy https://127.0.0.1:1080git config --global https.https://github.com.proxy https://127.0.0.1:1080

如果在配置局部代理之前已经配置了全局代理，我们可以取消全局代理的配置

git config --global --unset http.proxygit config --global --unset https.proxy

http和sock5配置区别

如果是sock5也是一样的配置，我们在这里找到sock5的端口为1086（windows一般是1080,mac是1086）

然后进行局部配置

git config --global http.https://github.com.proxy socks5://127.0.0.1:1086git config --global https.https://github.com.proxy socks5://127.0.0.1:1086

Mac 免密登录

Mac的坑点：多了个ssh-add命令需要执行，否则还是无法进行免密登录

# 更换目录到 ~/.sshcd ~/.ssh  # ssh-keygen -t rsa -f [秘钥文件名称]# 创建秘钥文件，我这里直接使用服务器ip作为秘钥文件名称，如果不写默认名称为：id_rsa# 执行命令后会生成公钥和私钥2个文件： [秘钥文件名称]  和  [秘钥文件名称].pubssh-keygen -t rsa -f 192.168.31.128# ssh-copy-id -i [秘钥文件名称].pub root@[服务器IP]# 上传公钥到服务器中，此时会在服务器的authorized_keys文件后追加公钥内容ssh-copy-id -i 192.168.31.128.pub root@192.168.31.128# Mac的坑点# ssh-add -K [你的私钥文件，就是那个不加.pub结尾的文件] ssh-add -K 192.168.31.128

Linux服务器免密登录

# 更换目录到 ~/.sshcd ~/.ssh  # ssh-keygen -t rsa -f [秘钥文件名称]# 创建秘钥文件，我这里直接使用服务器ip作为秘钥文件名称，如果不写默认名称为：id_rsa# 执行命令后会生成公钥和私钥2个文件： [秘钥文件名称]  和  [秘钥文件名称].pubssh-keygen -t rsa -f 192.168.31.128# ssh-copy-id -i [秘钥文件名称].pub root@[服务器IP]# 上传公钥到服务器中，此时会在服务器的authorized_keys文件后追加公钥内容ssh-copy-id -i 192.168.31.128.pub root@192.168.31.128

String类型

• set、setex修改值（覆盖）会重置过期时间为永久不过期（-1），需要在覆盖修改后重新设定过期时间。
• append、incr、decr等命令在原有值上修改的操作，不会重置过期时间。

Hash、Set、Zset、List类型

• 单纯修改所属值不会重置过期时间，但是如果提取出所有值导致值为空移除了指定key，再次重新写入新的值，过期时间就会变成永不过期（-1）

Docker部署: https://hub.docker.com/r/minio/minio
Java官方教程: https://min.io/docs/minio/linux/developers/java/minio-java.html
其他语言访问教程: https://min.io/docs/minio/linux/developers/minio-drivers.html?ref=docs
Minio Nginx转发配置：https://min.io/docs/minio/linux/integrations/setup-nginx-proxy-with-minio.html
Minio 可视化控制台配置：https://min.io/docs/minio/linux/administration/minio-console.html

遇到的坑

Minio的API接口，不能使用Nginx二级目录转发（只能配置转发控制台的9001端口）

这里使用Java代码访问，如图直接报错地址格式错误。

docker部署

命令行部署

docker run -p 9000:9000 -p 9001:9001 --name minio \  -d --restart=always \  -e "MINIO_ACCESS_KEY=admin" \  -e "MINIO_SECRET_KEY=admin" \      # 如果要配置Nginx二级域名转发，必须要写清楚Minio控制台域名路径。  -e "MINIO_BROWSER_REDIRECT_URL=https://domain.com/minio/" \  -v /data/minio/data:/data \  -v /data/minio/config:/root/.minio \  minio/minio:RELEASE.2023-11-01T18-37-25Z.fips \  server /data --console-address ":9090"

docker-compose.yml文件部署

docker-compose -f .\docker-compose.yml up -d

version : '3.8'services:  minio:    container_name: minio    image: minio/minio:RELEASE.2023-11-01T18-37-25Z.fips    ports:      - "9000:9000"      - "9001:9001"    environment:      - MINIO_ACCESS_KEY=admin      - MINIO_SECRET_KEY=admin      # 如果要配置Nginx二级域名转发，必须要写清楚Minio控制台域名路径。      - MINIO_BROWSER_REDIRECT_URL=https://domain.com/minio/    volumes:      - ./minio/data:/data      - ./minio/config:/root/.minio    command: server /data --console-address ":9001"

9000和9001端口作用

9000: 提供API访问
9001: 提供可视化页面使用

Minio控制台，可视化界面访问

1. 访问http://IP:9001。
2. 创建Access Key提供API进行访问。
   

配置Nginx转发可视化界面

# 需要转发的二级目录   location /minio/ {      rewrite ^/minio/(.*) /$1 break;      proxy_set_header Host $http_host;      proxy_set_header X-Real-IP $remote_addr;      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;      proxy_set_header X-Forwarded-Proto $scheme;      proxy_set_header X-NginX-Proxy true;      # This is necessary to pass the correct IP to be hashed      real_ip_header X-Real-IP;      proxy_connect_timeout 300;      # To support websockets in MinIO versions released after January 2023      proxy_http_version 1.1;      proxy_set_header Upgrade $http_upgrade;      proxy_set_header Connection "upgrade";      # Some environments may encounter CORS errors (Kubernetes + Nginx Ingress)      # Uncomment the following line to set the Origin request to an empty string      # proxy_set_header Origin '';      chunked_transfer_encoding off; # 对应的docker容器名称与域名      proxy_pass http://minio:9001;   }

代码访问

Java代码访问

import io.minio.BucketExistsArgs;import io.minio.MakeBucketArgs;import io.minio.MinioClient;import io.minio.UploadObjectArgs;import io.minio.errors.*;import org.testng.annotations.Test;import java.io.IOException;import java.security.InvalidKeyException;import java.security.NoSuchAlgorithmException;public class MinioTest {    @Test()    public void test2() throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {        // 使用MinIO服务的URL，端口，Access key和Secret key创建一个MinioClient对象        MinioClient minioClient = MinioClient.builder()                .endpoint("http://ip:9000")                // 这里写之前可视化页面创建的 Access Key                .credentials("wrYc3jGugGwhJn8sOkdK",                        "8mByhjkpOmP1LC0NLyN8Yccvohwdd7E9kb4gGeDs")                .build();        // 如果桶不存在就新建        boolean found = minioClient.bucketExists(BucketExistsArgs.builder().bucket("asiatrip").build());        if (!found) {            minioClient.makeBucket(MakeBucketArgs.builder().bucket("asiatrip").build());        } else {            System.out.println("'asiatrip桶已存在");        }        // 上传文件        minioClient.uploadObject(                UploadObjectArgs.builder()                        .bucket("asiatrip")                        .object("test.zip")                        .filename("D:\\下载\\test.zip")                        .build());        System.out.println("上传成功");    }}

@EnableScheduling // 在spring容器中启用定时任务的执行public class GameApplication {    public static void main(String[] args) {        SpringApplication.run(GameApplication.class, args);    }}

编写定时任务类，通过注解@Scheduled设定触发时间

import com.alibaba.fastjson2.JSONArray;import com.douyin.game.dto.DouyinMsgDto;import com.douyin.game.service.DouyinApiService;import com.douyin.game.service.DouyinGameCacheService;import com.ruoyi.common.core.constant.DouyinConstants;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.cloud.context.config.annotation.RefreshScope;import org.springframework.scheduling.annotation.Scheduled;import org.springframework.stereotype.Component;import java.util.List;@Component@Slf4j// 定时任务 @Scheduled 不能与 @RefreshScope 同时使用，当属性刷新时会导致定时任务失效（可以解决：需要触发刷新的时候重新装载定时任务）// @RefreshScopepublic class DouyinTask {    /**     * cron配置每30分钟执行一次     */    @Scheduled(cron = "* */30 * * * ?")    // 上一次任务开始触发，进入倒计时5000毫秒后再次触发任务    // @Scheduled(fixedRate = 5000)    // 上一次任务执行完毕，进入倒计时5000毫秒后再次触发任务    // @Scheduled(fixedDelay = 5000)    public void updateAccessToken() {        log.info("定时任务：更新access_token");    }}

配置conf

    # 限制IP访问,只允许域名访问    server {        listen  80  default_server;        listen  443 default_server;        #SSL相关配置，请勿删除或修改，必须带有证书才能配置443        ssl_certificate     /etc/letsencrypt/live/test/fullchain.pem; // 这里要改成自己不用的证书        ssl_certificate_key /etc/letsencrypt/live/test/privkey.pem; // 这里要改成自己不用的证书        #SSL-END        server_name _;        location / {            # 专制恶意扫描，所有请求跳转到10GB大文件慢慢下去            rewrite \.*$ http://lg-hkg.fdcservers.net/10GBtest.zip;            # 只匹配扫描对应文件后缀才下载            # rewrite \.(rar|zip|tar|sql|gz|7z)/?$ http://lg-hkg.fdcservers.net/10GBtest.zip;            return  403;        }    }

日志分析

访问者IP请求次数排名

awk '{print $1}' /usr/local/nginx/log/access.log |sort |uniq -c|sort -n

带有指定字段的IP，请求次数排名，这里是过滤尝试代理访问百度的请求。

cat access.log | grep 'baidu' | awk '{print $1}'  | sort | uniq -c | sort -nr -k1 | head -n 10

访问IP的请求次数

awk '{print $1}'  access.log|sort | uniq -c |wc -l

查询访问最频繁的URL

awk '{print $7}' access.log|sort | uniq -c |sort -n -k 1 -r|more

配置Ningx，屏蔽IP

将以下配置写入conf中，可应用作用域： http / server / location / limit_except

http {# 全局屏蔽单个 IPdeny IP;     server {        # 特定服务屏蔽单个IP        deny IP;                  location /api {            # 特定路由屏蔽单个IP            deny IP;          }    }    # 允许单个ip访问    allow IP;     # 屏蔽所有ip访问    deny all;     # 允许所有ip访问    allow all;     # 屏蔽整个段即从123.0.0.1到123.255.255.254访问的命令    deny 123.0.0.0/8    # 屏蔽IP段即从123.45.0.1到123.45.255.254访问的命令    deny 124.45.0.0/16    # 屏蔽IP段即从123.45.6.1到123.45.6.254访问的命令    deny 123.45.6.0/24    # 如果你想实现这样的应用，除了几个IP外，其他全部拒绝，    # 那需要你在guolv_ip.conf中这样写    allow 1.1.1.1;     allow 1.1.1.2;    deny all;}

配置优先级

作用范围和配置的顺序有关系,先配置的优先级高，会覆盖和后一个配置重合的部分,
可以添加多个allow和多个deny：

# 这个配置127.0.0.1可以通过访问。allow 127.0.0.1;deny all;# 这个配置127.0.0.1无法通过访问。deny all;allow 127.0.0.1;# 这个配置127.0.0.1无法通过访问。deny 127.0.0.1;allow all;# 这个配置127.0.0.1可以通过访问。allow all;deny 127.0.0.1;

Delegate特性

Delegate官方翻译是委托 。delegate 本质上是一个用来存放函数的容器。众所周知，在面向对象的语言中，变量可以是值类型，也可以是引用类型。而 C# 则用 delegate 的机制将函数引用存储起来，并且可以在运行时被改变。delegate 特别用于实现事件和回调方法，一种委托将提前约定好存放的函数的返回类型和参数列表。

delegate 可以被初始化成一个函数的引用，也可以通过 +=，-= 等运算符进行存放多个函数引用。存放多个函数时，调用 delegate 将会调用所有的函数引用，这种行为叫做 multicast delegate，即委托的多播。

=会取消所有订阅，只保留=之后的订阅

//定义一个无返回值的，带一个int参数的委托public delegate void myDelegate(int num);// 定义一个委托，并添加订阅public myDelegate m_delegate;m_delegate += MyFun;public void MyFun(int num){  Debug.Log("my func: " + num);}// 此时 如果再使用 `=` 会取消前面所有的订阅，只保留 `=` 后的新订阅m_delegate = MyFun1;  //MyFun订阅被取消，只有MyFun1在订阅中

Event特性

Event外部调用只能使用+=、-=增减委托，而不能直接使用=，避免出现委托因为误操作(或恶意)取消所有订阅。发布者是可以是用=。

public class A{    public delegate void ActionTest();    public event ActionTest m_event;    public void T()    {        m_event = MyFun; // 不报错    }    private void MyFun()    {        throw new NotImplementedException();    }}public class B{    public A a;    public void T()    {        a.m_event = MyFun; // 报错        a.m_event += MyFun; // 不报错        a.m_event -= MyFun; // 不报错    }    private void MyFun()    {        throw new NotImplementedException();    }}

很多动画做出来，朝向方向不是统一的，特别是使用第三方资源时。此时我们将动画放置子GameObject中，通过修正Transform.Rotation角度指向x方位。后续通过修改父 GameObject Transform.Rotation 调整角色转向、拐弯等方向时可用有效避免而外角度换算。

常用切重复的对象可以通过对象池管理进行复用，减少重复创建。
例：同一个技能释放每次使用的都是预制体，只是技能伤害可能有所变化。技能每次释放结束通过gameObject.SetActive(false)隐藏对象，再次释放同一技能修改其伤害数值并gameObject.SetActive(true)展示对象。就可以避免大量的重复技能创建节约CPU运算性能。

示例代码

对象池代码

using System.Collections.Generic;using UnityEngine;public class GameObjectPool{    public GameObject gameObjectPool;    private Dictionary<string, Queue<GameObject>> _pool;    public GameObjectPool(string name)    {        _pool = new Dictionary<string, Queue<GameObject>>();        gameObjectPool = new GameObject(name);    }    // 获取对象，通过预制体资源地址，分别获取、存储不同的队列中。    public GameObject GetGameObject(string key)    {        if (!_pool.ContainsKey(key))        {            return null;        }        if (_pool[key].Count > 0)        {            return _pool[key].Dequeue();        }        else        {            return null;        }    }    // 回收对象    public void RecoveryGameObject(string key, GameObject gameObject)    {        if (!_pool.ContainsKey(key))        {            _pool[key] = new Queue<GameObject>();        }        gameObject.SetActive(false);        gameObject.transform.SetParent(gameObjectPool.transform);        _pool[key].Enqueue(gameObject);    }}

对象池的使用

using System.Collections.Generic;using System.Linq;using UnityEngine;using UnityEngine.AddressableAssets;using UnityEngine.ResourceManagement.AsyncOperations;public class SkillManager : MonoBehaviour{    public SkillEventSO skillManagerSO;    private AsyncOperationHandle<GameObject> _gameObjectHandle;    private GameObjectPool _bulletPool;    #region Unity生命周期    private void Awake()    {        _bulletPool = new GameObjectPool("BulletGameObjectPool");        _bulletPool.gameObjectPool.transform.SetParent(transform);    }    #endregion    // 释放技能    public void CastSkill(SkillDTO skillDTO)    {        string prefabAddress = skillDTO.prefabAddress;        // 对象池获取对象，如果池中存在对象就直接拿来用，如果没有就是实例化一个新的        GameObject bullet = _bulletPool.GetGameObject(prefabAddress);        if (bullet != null)        {            bullet.transform.SetParent(transform);            bullet.GetComponent<BulletController>().skillDTO = skillDTO;            bullet.SetActive(true);        }        else        {            _gameObjectHandle = Addressables.LoadAssetAsync<GameObject>(prefabAddress);            _gameObjectHandle.Completed += (handle) =>            {                if (handle.Status == AsyncOperationStatus.Succeeded)                {                    bullet = Instantiate(handle.Result, transform);                    bullet.transform.SetParent(transform);                    bullet.GetComponent<BulletController>().skillDTO = skillDTO;                    bullet.GetComponent<BulletController>().skillManager = this;                }                else                {                    Debug.LogError("Asset load failed: " + prefabAddress);                }            };        }    }    // 回收技能    public void RecoveryBulletGameObject(GameObject bulletGameObject)    {        _bulletPool.RecoveryGameObject(bulletGameObject.GetComponent<BulletController>().skillDTO.prefabAddress, bulletGameObject);    }}