@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private String number;    

public class User {
    private String number;

    @JsonProperty("customNumber")
    private String getCustomNumber(){
        return "no"+number;
    }
}

public class DictSerializer extends JsonSerializer<String> {
    @Override
    public void serialize(String o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        // 当前字段名称
        String currentName = serializerProvider.getGenerator().getOutputContext().getCurrentName();

        jsonGenerator.writeStringField(currentName+"Ext", o+"扩展");
    }
}

@EnableConfigurationProperties(CacheProperties.class)
@EnableCaching
@Configuration
public class MyCacheConfig {
    /**
     * 将配置作为参数传入，从容器中自动获取
     *
     * @return
     */
    @Bean
    RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        // 设置键的序列化方式
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        // 设置值的序列化方式，将类名也序列化
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        // 将配置文件中的配置生效

        // 获取redis的配置
        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        // 设置过期时间
        if (redisProperties.getTimeToLive() != null) {
            System.out.println(redisProperties.getTimeToLive());
            config = config.entryTtl(redisProperties.getTimeToLive());
        }
        // 设置key前缀
        if (redisProperties.getKeyPrefix() != null) {
            config = config.prefixCacheNameWith(redisProperties.getKeyPrefix());
        }

//        if (!redisProperties.isCacheNullValues()) {
//            config = config.disableCachingNullValues();
//        }
//
//        if (!redisProperties.isUseKeyPrefix()) {
//            config = config.disableKeyPrefix();
//        }
        return config;
    }
}

package com.example;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class CorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("*")
                .allowedHeaders("*")
                .allowedMethods("*");
    }
}

@Configuration
public class CorsConfig {
    @Bean
    CorsWebFilter corsWebFilter(){
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        // 允许所有请求头
        config.addAllowedHeader("*");
        // 允许所有方式
        config.addAllowedMethod("*");
        // 允许所有来源
        config.addAllowedOrigin("*");
        // 允许附带cookie信息
        config.setAllowCredentials(true);

        // 适用于所有请求
        source.registerCorsConfiguration("/**", config);
        return new CorsWebFilter(source);
    }
}

package com.example.yunxiao_deploy_demo;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;

@Slf4j
@Aspect
@Component
public class LogAspect {



    /**
     * 定义切入点
     */
    @Pointcut("execution(* *(..)) && @within(org.springframework.web.bind.annotation.RestController)")
    public void pointcut(){

    }

    /**
     * @description  在连接点执行之前执行的通知
    */
    @Before("pointcut()")
    public void before(JoinPoint joinPoint){

    }

    /**
     * @description  在连接点执行之后执行的通知（返回通知）
     */
    @AfterReturning(pointcut = "pointcut()", returning = "object")
    public void afterReturning(JoinPoint joinPoint, Object object){
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = ((ServletRequestAttributes)requestAttributes).getRequest();
        log.info("请求地址 : " + request.getRequestURL().toString());
        log.info("请求参数 : " + Arrays.toString(joinPoint.getArgs()));
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            log.debug("请求结果 : " + objectMapper.writeValueAsString(object));
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @description  在连接点执行之后执行的通知（异常通知）
     */
    @AfterThrowing(pointcut = "pointcut()", throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Exception ex){
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = ((ServletRequestAttributes)requestAttributes).getRequest();
        log.error("请求地址 : " + request.getRequestURL().toString());
        log.error("请求参数 : " + Arrays.toString(joinPoint.getArgs()));
        if(ex.getStackTrace().length > 0){
            StackTraceElement stackTraceElement = ex.getStackTrace()[0];
            log.error("异常位置 : " + ex.getMessage() + " ：" +stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName() + "("+stackTraceElement.getLineNumber()+")", ex);
        } else {
            log.error("异常位置 : " + ex.getMessage());
        }
    }
}

public class Try {
    public Try() {
    }

    public static <T, R> Function<T, R> of(Try.UncheckedFunction<T, R> mapper) {
        Objects.requireNonNull(mapper);
        return (t) -> {
            try {
                return mapper.apply(t);
            } catch (Exception var3) {
                throw Exceptions.unchecked(var3);
            }
        };
    }

    public static <T> Consumer<T> of(Try.UncheckedConsumer<T> mapper) {
        Objects.requireNonNull(mapper);
        return (t) -> {
            try {
                mapper.accept(t);
            } catch (Exception var3) {
                throw Exceptions.unchecked(var3);
            }
        };
    }

    public static <T> Supplier<T> of(Try.UncheckedSupplier<T> mapper) {
        Objects.requireNonNull(mapper);
        return () -> {
            try {
                return mapper.get();
            } catch (Exception var2) {
                throw Exceptions.unchecked(var2);
            }
        };
    }

    @FunctionalInterface
    public interface UncheckedSupplier<T> {
        @Nullable
        T get() throws Exception;
    }

    @FunctionalInterface
    public interface UncheckedConsumer<T> {
        @Nullable
        void accept(@Nullable T t) throws Exception;
    }

    @FunctionalInterface
    public interface UncheckedFunction<T, R> {
        @Nullable
        R apply(@Nullable T t) throws Exception;
    }
}

User apply = Try.of((String userStr) -> {
  ObjectMapper objectMapper = new ObjectMapper();
  return objectMapper.readValue(userStr, User.class);
}).apply(s3);
System.out.println(apply);

User aaa = Try.of(() -> {
  System.out.println("走if");
  ObjectMapper objectMapper = new ObjectMapper();
  return objectMapper.readValue(s3, User.class);
}).get();

String s3 = "{\"name\":221, \"id\":1}";

Try.of((String str) -> {
  ObjectMapper objectMapper = new ObjectMapper();
  User user = objectMapper.readValue(str, User.class);
  System.out.println(user);
}).accept(s3);

User user2 = Optional.ofNullable(s3)
  .map(Try.of((String userStr) -> {
    ObjectMapper objectMapper = new ObjectMapper();
    return objectMapper.readValue(userStr, User.class);
  })).orElse(null);

objects.stream().filter(Try.predicate(user -> {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.readValue(s3, User.class);
    return user.getId().equals(1);
})).collect(Collectors.toList());

public static <T> Predicate<T> predicate(Try.UncheckedPredicate<T> mapper) {
    Objects.requireNonNull(mapper);
    return (t) -> {
        try {
            return mapper.test(t);
        } catch (Exception var3) {
            throw Exceptions.unchecked(var3);
        }
    };
}

@FunctionalInterface
public interface UncheckedPredicate<T> {
    @Nullable
    boolean test(T t) throws Exception;
}