星辰狂澜's Blog

import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.ReflectUtil;
import com.baomidou.mybatisplus.annotation.IEnum;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.swagger.v3.core.converter.AnnotatedType;
import io.swagger.v3.core.converter.ModelConverter;
import io.swagger.v3.core.converter.ModelConverterContext;
import io.swagger.v3.oas.models.media.Schema;
import lombok.RequiredArgsConstructor;
import org.springdoc.core.providers.ObjectMapperProvider;
import org.springframework.stereotype.Component;

import java.util.Iterator;

@Component
@RequiredArgsConstructor
public class EnumConverter implements ModelConverter {

    private final ObjectMapperProvider objectMapperProvider;

    @SuppressWarnings({"unchecked", "rawtypes"})
    @Override
    public Schema<?> resolve(AnnotatedType type, ModelConverterContext context, Iterator<ModelConverter> chain) {
        Schema<?> nextSchema = chain.hasNext() ? chain.next().resolve(type, context, chain) : null;
        ObjectMapper objectMapper = objectMapperProvider.jsonMapper();
        JavaType javaType = objectMapper.constructType(type.getType());
        if (javaType != null && javaType.isEnumType()) {
            Class<Enum> enumClass = (Class<Enum>) javaType.getRawClass();
            Enum[] enums = enumClass.getEnumConstants();
            StringBuilder builder = new StringBuilder();
            for (Enum en : enums) {
                if (en instanceof IEnum) {
                    var value = ReflectUtil.getFieldValue(en, "value");
                    var description = ReflectUtil.getFieldValue(en, "description");
                    builder.append(String.format("- %s: %s\n", Convert.toStr(value), Convert.toStr(description)));
                }
            }
            if (nextSchema != null && !builder.isEmpty()) {
                nextSchema.setTitle(nextSchema.getDescription());
                nextSchema.setDescription(builder.toString());
            }
        }
        return nextSchema;
    }

}

import cn.hutool.core.util.ReflectUtil;
import com.baomidou.mybatisplus.core.conditions.AbstractWrapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

@Slf4j
@Aspect
@Component
@RequiredArgsConstructor
public class MybatisMetaAspect {

    private final ConcurrentMap<Class<?>, Object> entityMap = new ConcurrentHashMap<>();

    @Pointcut("execution(* com.baomidou.mybatisplus.core.mapper.BaseMapper.update(com.baomidou.mybatisplus.core.conditions.Wrapper))")
    public void update() {
    }

    @Around("update()")
    public Object aroundUpdate(ProceedingJoinPoint pjp) {
        try {
            Object result = invoke(pjp);
            if (result != null) {
                return result;
            }
            return pjp.proceed(pjp.getArgs());
        } catch (Throwable e) {
            log.error("mybatis around update error", e);
        }
        return null;
    }

    private Object invoke(ProceedingJoinPoint pjp) {
        Object[] args = pjp.getArgs();
        if (args == null || args.length != 1) {
            return null;
        }
        Object arg = args[0];
        if (arg instanceof AbstractWrapper<?, ?, ?> wrapper) {
            Class<?> entityClass = wrapper.getEntityClass();
            if (entityClass == null) {
                log.warn("Detected that the entity is empty, which will cause automatic filling to fail. Please use `new UpdateWrapper<>(new T())` or `new UpdateWrapper<>(T.class)` instead.");
                return null;
            }
            Object entity = entityMap.get(entityClass);
            if (entity == null) {
                entity = ReflectUtil.newInstance(entityClass);
                entityMap.put(entityClass, entity);
            }
            return ReflectUtil.invoke(pjp.getThis(), "update", entity, arg);
        }
        return null;
    }

}

import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.classic.spi.IThrowableProxy;
import ch.qos.logback.classic.spi.ThrowableProxyUtil;
import ch.qos.logback.core.UnsynchronizedAppenderBase;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.api.async.RedisAsyncCommands;
import lombok.Getter;
import lombok.Setter;

import java.time.Duration;
import java.util.Date;

@Getter
@Setter
public class RedisAppender extends UnsynchronizedAppenderBase<ILoggingEvent> {

    private String host;
    private Integer port;
    private String password;
    private String key;

    private RedisClient redisClient;
    private RedisAsyncCommands<String, String> async;

    @Override
    protected void append(ILoggingEvent event) {
        if (redisClient == null) {
            return;
        }
        LoggerEntity entity = new LoggerEntity();
        entity.setTimestamp(new Date(event.getTimeStamp()));
        entity.setLevel(event.getLevel().toString());
        entity.setCaller(event.getLoggerName());
        entity.setThread(event.getThreadName());
        entity.setMessage(event.getFormattedMessage());
        IThrowableProxy throwableProxy = event.getThrowableProxy();
        if (throwableProxy != null) {
            entity.setThrowable(ThrowableProxyUtil.asString(throwableProxy));
        }
        async.rpush(key, JSONUtil.toJsonStr(entity));
    }

    @Override
    public void start() {
        super.start();
        initRedis();
    }

    private void initRedis() {
        if (StrUtil.isEmpty(host) || StrUtil.isEmpty(key)) {
            return;
        }
        try {
            RedisURI uri = RedisURI
                .builder()
                .withHost(host)
                .withPort(port)
                .withPassword(password.toCharArray())
                .withTimeout(Duration.ofSeconds(10))
                .build();
            redisClient = RedisClient.create(uri);
            async = redisClient.connect().async();
        } catch (Exception e) {
            System.out.printf("Initialize Logger Redis Exception: %s\n", e.getMessage());
        }
    }

    @Override
    public void stop() {
        closeRedis();
        super.stop();
    }

    private void closeRedis() {
        if (redisClient != null) {
            redisClient.close();
        }
    }

}