spring boot extension doc

public @interface Http{

}

public class HttpImportSelector extends SpringAbstractImportSelector<Http>{

}

@AutoImport
public @interface Http{

}

META-INF/spring/com.example.Http.imports

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DisruptorScan {

    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};

}

public class LockInterceptor extends AbstractAnnotationAdvisor<OnLock> {
    @Override
    protected Object doInvoke(MethodInvocation invocation, OnLock onLock) throws Throwable {
        // AOP 处理，等同于 @Around
        return invocation.proceed();
    }

    @Override
    public Pointcut getPointcut() {
        // 实现切入点
        return AnnotationPointcutFactory.forMethod().create(annotationType);
    }
}

public class LockInterceptor extends AbstractAnnotationPointcutStrategyAdvisor<OnLock> {
    @Override
    protected Object doInvoke(MethodInvocation invocation, OnLock onLock) throws Throwable {
        // 拦截处理
        return invocation.proceed();
    }

    @Override
    protected AnnotationPointcutFactory pointcutStrategy() {
        // 默认实现为 AnnotationPointcutFactory.forTarget()
        return AnnotationPointcutFactory.forTarget();
    }
}

ExpressionResolver resolver = new SpringExpressionResolver();

// 方式一：通过 Method 参数构建上下文
String result = resolver.resolve("#username")
    .method(method, args)
    .evaluate();

// 方式二：直接传入 Map 作为上下文
String result = resolver.resolve("#name")
    .context(Map.of("name", "livk"))
    .evaluate();

// 方式三：指定返回类型
Integer count = resolver.resolve("#count")
    .context(Map.of("count", 10))
    .evaluate(Integer.class);

public class MyExpressionResolver extends CacheExpressionResolver<MyContext, MyExpression> {

    // 将表达式字符串编译成引擎特定的表达式对象
    @Override
    protected MyExpression compile(String expression) {
        return MyEngine.parse(expression);
    }

    // 将通用 Context 转换为引擎特定的上下文
    @Override
    protected MyContext transform(Context context) {
        return new MyContext(context.asMap());
    }

    // 使用编译后的表达式和引擎上下文进行计算
    @Override
    protected <T> T calculate(MyExpression expression, MyContext context, Class<T> returnType) {
        return expression.evaluate(context, returnType);
    }
}

Context context = Context.create()
    .put("username", "livk")
    .put("count", 10);

Map<String, Object> map = context.asMap();

Context context = Context.create(Map.of("key", "value"));

ContextFactory factory = ContextFactory.DEFAULT_FACTORY;
Context context = factory.create(method, args);
// context 中包含方法参数名到实际值的映射

resolver.resolve("#param")
    .contextFactory(myCustomFactory)
    .method(method, args)
    .evaluate();

@Slf4j
@EnableHttpClient({
    HttpClientType.WEB_CLIENT,
    HttpClientType.REST_CLIENT
})
public class App {

    @Bean
    public ApplicationRunner applicationRunner(WebClient webClient,
                                             RestClient restClient) {
        return args -> {
            log.info("webClient:{}", webClient);
            log.info("restClient:{}", restClient);
        };
    }

}

@EnableWebClient
@Configuration
public class WebClientConfig {

}

public static void main(String[] args){
  JacksonSupport json = new JacksonSupport(new JsonMapper());
}

AnnotationMetadataResolver resolver = new AnnotationMetadataResolver();
resolver.find(MyAnnotation.class, "com.livk.resolver");

String methodName = BeanLambda.methodName(Maker::getNo);
Method method = BeanLambda.method(Maker::getNo);
String fieldName = BeanLambda.fieldName(Maker::getNo);
Field field = BeanLambda.field(Maker::getNo);

// Bean 转 Map
Map<String, Object> map = BeanConverter.toMap(myBean);

ExecutorService service = Executors.newCachedThreadPool();
ExecutorService wrap = ContextSnapshots.wrap(service);
wrap.submit(() -> {
    // 此处可获取到父线程的 Observation 上下文
});

GenericWrapper<?> wrapper = GenericWrapper.of("123");
Object value = wrapper.unwrap();

// Enumeration 转 Stream
Stream<String> stream = StreamUtils.of(enumeration);
// 带索引遍历
StreamUtils.forEachWithIndex(list, (index, item) -> {});

// 解析类的第一个泛型参数类型
Class<?> argType = TypeUtils.resolveTypeArgument(MyService.class, BaseService.class);

String str = "root=1,2,3&root=4&a=b&a=c";
MultiValueMap<String, String> multiValueMap = MultiValueMapSplitter.of("&", "=").split(str, ",");
// {root=[1, 2, 3, 4], a=[b, c]}

Pair<String, String> pair = Pair.of("username", "password");

SnowflakeIdGenerator generator = new SnowflakeIdGenerator(1, 2);
long id = generator.nextId();

// Flux<DataBuffer> 转 Mono<InputStream>
Mono<InputStream> inputStreamMono = DataBufferConverter.transform(dataBufferFlux);

// byte[] 转 Flux<DataBuffer>
Flux<DataBuffer> flux = DataBufferConverter.transform(bytes);

// Flux<DataBuffer> 转 Mono<byte[]>
Mono<byte[]> bytesMono = DataBufferConverter.transformByte(dataBufferFlux);

// InputStream 转 Flux<DataBuffer>
Flux<DataBuffer> flux = DataBufferConverter.transform(inputStream);

// 获取单个资源
Resource resource = ResourceScanner.getResource("classpath:config/app.yml");

// 获取匹配模式的多个资源
Resource[] resources = ResourceScanner.getResources("classpath*:META-INF/spring/*.imports");

// 压缩
ByteArrayOutputStream out = new ByteArrayOutputStream();
GzipUtils.compress(data, out);

// 解压
byte[] decompressed = GzipUtils.decompress(inputStream);

// 从 InputStream 下载写入文件（自动创建目录）
FileUtils.download(inputStream, "/path/to/file.txt");

// 创建文件（自动创建父目录）
boolean success = FileUtils.createNewFile(new File("/path/to/file.txt"));

public class Main{
    public static void main(String[] args){
        MockHttpServletRequest request = new MockHttpServletRequest();
            request.addParameter("username", "livk", "root", "admin");
            request.addParameter("password", "123456");
            MultiValueMap<String, String> params = WebUtils.params(request);
            HttpParameters parameters = new HttpParameters(params);
    }
}

public class Main{
    public static void main(String[] args){
        MockHttpServletRequest request = new MockHttpServletRequest();
            RequestWrapper wrapper = new RequestWrapper(request);
        wrapper.body(JsonMapperUtils.writeValueAsBytes(Map.of("root", "root")));
        wrapper.addHeader("Content-Type", "application/json");
        wrapper.addParameter("username", "livk");
        wrapper.addParameter("username", new String[]{"root", "admin"});
    }
}

public class Main{
    public static void main(String[] args){
        MockHttpServletResponse response = new MockHttpServletResponse();
        ResponseWrapper wrapper = new ResponseWrapper(response);
        wrapper.replaceBody(JsonMapperUtils.writeValueAsBytes(Map.of("root", "root")));
    }
}

public static void main(String[] args){
  CuratorFramework framework = createFramework();
  framework.start();
  CuratorTemplate template = new CuratorTemplate(framework);
}

spring:
  zookeeper:
    curator:
      connect-string: localhost:2181
      base-sleep-time-ms: 50
      max-retries: 10
      max-sleep-ms: 500
      block-until-connected-wait: 10
      block-until-connected-unit: seconds
      session-timeout: 60s
      connection-timeout: 15s

@DisruptorScan("com.livk.disruptor")
public class Config{

}

@SpringBootApplication
@DisruptorScan(basePackages = "com.example.disruptor")
public class DisruptorApplication {

}

@org.springframework.stereotype.Component
public class DisruptorMqServiceImpl implements DisruptorMqService {

    private final DisruptorEventProducer<MessageModel> producer;

    public DisruptorMqServiceImpl(SpringDisruptor<MessageModel> disruptor) {
        producer = new DisruptorEventProducer<>(disruptor);
    }

    @Override
    public void send(String message) {
        log.info("record the message: {}", message);
        producer.send(toMessageModel(message));
    }

    @Override
    public void batch(List<String> messages) {
        List<MessageModel> messageModels = messages.stream().map(this::toMessageModel).toList();
        producer.sendBatch(messageModels);
    }

    private MessageModel toMessageModel(String message) {
        return MessageModel.builder().message(message).build();
    }

}

@org.springframework.stereotype.Component
public class Consumer implements DisruptorEventConsumer<MessageModel> {

    private final ApplicationContext applicationContext;

    @Override
    public void onEvent(MessageModel wrapper, long sequence, boolean endOfBatch) {
        log.info("消费者消费的信息是：{} :{} :{} id:{}", wrapper, sequence, endOfBatch, applicationContext.getId());
    }

}

@DynamicSource("mysql")
public class UserService{

}

@Configuration
public class Config {
  @Bean
    public DynamicDatasource dynamicDatasource() {
        DynamicDatasource dynamicDatasource = new DynamicDatasource();
        dynamicDatasource.setTargetDataSources(datasourceMap);
        dynamicDatasource.setDefaultTargetDataSource(datasourcePrimary);
        return dynamicDatasource;
    }
}

spring:
  dynamic:
    primary: mysql
    datasource:
      mysql:
        url: jdbc:mysql://localhost:3306/demo
        username: root
        password: 123456
        driver-class-name: com.mysql.cj.jdbc.Driver
      pgsql:
        url: jdbc:postgresql://localhost:5432/demo
        username: postgres
        password: 123456
        driver-class-name: org.postgresql.Driver

@EnableDynamicDatasource
@SpringBootApplication
public class DynamicApplication {

}

@RestController
public class InfoController {

    @RequestExcel(parse = InfoExcelListener.class)
    @PostMapping("uploadList")
    public HttpEntity<List<Info>> uploadList(@ExcelParam List<Info> dataExcels) {
        return ResponseEntity.ok(dataExcels);
    }


    @RequestExcel(parse = InfoExcelListener.class)
    @PostMapping("upload")
    public HttpEntity<List<Info>> upload(@ExcelParam List<Info> dataExcels) {
        return ResponseEntity.ok(dataExcels);
    }

    @RequestExcel(parse = InfoExcelListener.class)
    @PostMapping("uploadMono")
    public Mono<HttpEntity<List<Info>>> uploadMono(@ExcelParam Mono<List<Info>> dataExcels) {
        return dataExcels.map(ResponseEntity::ok);
    }
}

@RestController
@RequiredArgsConstructor
public class InfoController {

  @ResponseExcel(fileName = "outFile")
    @RequestExcel(parse = InfoExcelListener.class)
    @PostMapping("uploadDownLoad")
    public List<Info> uploadDownLoadMono(@ExcelParam List<Info> dataExcels) {
        return dataExcels;
    }

    @ResponseExcel(fileName = "outFile")
    @RequestExcel(parse = InfoExcelListener.class)
    @PostMapping("uploadDownLoadMono")
    public Mono<List<Info>> uploadDownLoadMono(@ExcelParam Mono<List<Info>> dataExcels) {
        return dataExcels;
    }

    @ResponseExcel(fileName = "outFile")
    @RequestExcel(parse = InfoExcelListener.class)
    @PostMapping("uploadDownLoadFlux")
    public Flux<Info> uploadDownLoadFlux(@ExcelParam Mono<List<Info>> dataExcels) {
        return dataExcels.flatMapMany(Flux::fromIterable);
    }
}

@ExcelController
public class Info2Controller {

    @PostMapping("download")
    public Map<String, List<Info>> download(@RequestBody List<Info> dataExcels) {
        return dataExcels.stream()
                .collect(Collectors.groupingBy(info -> String.valueOf(Long.parseLong(info.getPhone()) % 10)));
    }
}

public class UserService {

  @Limit(key = "livk:user", rate = 2, rateInterval = 30)
  public void save(User user) {

  }
}

public class UserService {
  @PostMapping("/buy/distributed")
    @DistLock(key = "shop")
    public void buyLocal(@RequestParam(defaultValue = "2") Integer count) {

    }
}

import javax.sql.DataSource;

@Data
public class User implements Serializable {

    @Serial
    private static final long serialVersionUID = 1L;

    private Integer id;

    private String username;

    @JsonIgnore
    @SqlInject(fill = SqlFill.INSERT, supplier = VersionInject.class)
    private Integer version;

    @JsonFormat(pattern = DateUtils.YMD_HMS, timezone = "GMT+8")
    @SqlInject(fill = SqlFill.INSERT, time = InjectType.DATE)
    private Date insertTime;

    @JsonFormat(pattern = DateUtils.YMD_HMS, timezone = "GMT+8")
    @SqlInject(fill = SqlFill.INSERT_UPDATE, time = InjectType.DATE)
    private Date updateTime;

}

mybatis:
  log:
    monitor:
      time-out: 1s

@RestController
@RequestMapping("qrcode")
public class QRCodeController {

    @PostMapping
    public Mono<String> textCode(@RequestQrCodeText(fileName = "file") Mono<String> text) {
        return text.log();
    }

}

@RestController
@RequestMapping("qrcode")
public class QRCodeController {

    @ResponseQrCode
    @GetMapping
    public String text(String text) {
        return text;
    }

    @ResponseQrCode
    @GetMapping("mono")
    public Mono<String> textMono(String text) {
        return Mono.just(text);
    }
}

@ResponseQrCode(width = 300, height = 300, type = PicType.PNG)
@GetMapping("png")
public String png(String text) {
    return text;
}

spring:
  redisearch:
    host: localhost
    port: 6379
    database: 0
    username:
    password:
    ssl: false
    timeout: 3s
    client-name: redisearch-client
    pool:
      enabled: true
      max-active: 8
      max-idle: 8
      min-idle: 0
      max-wait: -1ms

spring:
  redisearch:
    cluster:
      enabled: true
      nodes:
        - 127.0.0.1:6379
        - 127.0.0.1:6380
      max-redirects: 3

@Service
public class ArticleSearchService {

    private final StringRedisSearchTemplate StringRedisSearchTemplate;

    public ArticleSearchService(StringRedisSearchTemplate StringRedisSearchTemplate) {
        this.StringRedisSearchTemplate = StringRedisSearchTemplate;
    }

}

spring:
  redis:
    host: localhost
    port: 6379
    password:
  redisson:
    config:
      single-server-config:
        address: redis://127.0.0.1:6379
        database: 0
        connection-pool-size: 64
        connection-minimum-idle-size: 24

spring:
  redisson:
    config:
      cluster-servers-config:
        node-addresses:
          - redis://127.0.0.1:6379
          - redis://127.0.0.1:6380
        scan-interval: 2000

@Service
public class LockService {

    private final RedissonClient redissonClient;

    public LockService(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    public void lock() {
        RLock lock = redissonClient.getLock("demo:lock");
        lock.lock();
        try {
            // business
        }
        finally {
            lock.unlock();
        }
    }

}

import javax.sql.DataSource;

@Configuration
public class Config{

   @Bean
   public Sequence dbSequence(DataSource dataSource) {
     Sequence sequence = SequenceBuilder.builder(new DbRangeManager(dataSource)).bizName("test-sequence").build();
     return sequence;
   }

   @Bean
   public Sequence lettuceSequence(RedisClient redisClient) {
     LettuceSequenceRedisHelper helper = new LettuceSequenceRedisHelper(redisClient);
         Sequence sequence = SequenceBuilder.builder(new RedisRangeManager(helper)).bizName("test-sequence").build();
     return sequence;
   }

    @Bean
   public Sequence redisSequence(RedisConnectionFactory factory) {
     SpringSequenceRedisHelper helper = new SpringSequenceRedisHelper(factory);
         Sequence sequence = SequenceBuilder.builder(new RedisRangeManager(helper)).bizName("test-sequence").build();
     return sequence;
   }

   @Bean
   public Sequence snowflakeSequence() {
     Sequence sequence = Sequence.snowflake(1, 2);
     return sequence;
   }
}

@RestController
@RequestMapping("user-agent")
public class UserAgentController {

    @GetMapping
    public HttpEntity<Map<String, UserAgent>> get(@UserAgentInfo UserAgent userAgent) {
        Map<String, UserAgent> map = Map.of("argument", userAgent,
                "context", UserAgentContextHolder.getUserAgentContext());
        return ResponseEntity.ok(map);
    }

}

@RestController
@RequestMapping("user-agent")
public class ReactiveUserAgentController {

    @GetMapping
    public Mono<UserAgent> get(@UserAgentInfo Mono<UserAgent> userAgent) {
        return userAgent;
    }

}