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 AnnotationAbstractPointcutAdvisor<OnLock>{
    @Override
    protected Object invoke(MethodInvocation invocation, OnLock onLock){
        //AOP处理等同于org.aspectj.lang.annotation.Around
    }

    @Override
    public Pointcut getPointcut(){
        //实现切入点
    }
}

public class LockInterceptor extends AnnotationAbstractPointcutTypeAdvisor<OnLock>{
    @Override
    protected Object invoke(MethodInvocation invocation, OnLock onLock){
        //
    }

    @Override
    protected AnnotationPointcutType pointcutType() {
        //默认实现
        return AnnotationAutoPointcut.auto();
    }
}

public class MyExpressionResolver extends AbstractExpressionResolver {
    @Override
    public <T> T evaluate(String value, Context context, Class<T> returnType) {
        //TODO:解析表达式
    }

    //重写此方法用于调整Context的解析
    public MyExpressionResolver(ContextFactory contextFactory){
    super(contextFactory);
    }

  //也可以使用默认
  public MyExpressionResolver(){

    }
}

public class MyExpressionResolver extends CacheExpressionResolver<Expression> {
  //将表达式转成不同组件的表达式类
    @Override
    protected Expression compile(String value) throws Throwable {
        return null;
    }

  //根据组件的表达式进行计算
    @Override
    protected <T> T calculate(Expression expression, Context context, Class<T> returnType) throws Throwable {
        return null;
    }

  //将上下文转成组件的上下文
    @Override
    protected EvaluationContext transform(Context context) {
        return null;
    }
}

@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());
}

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Main{
    public static void main(String[] args){
      AnnotationMetadataResolver resolver = new AnnotationMetadataResolver();
      resolver.find(MyAnnotation.class,"com.livk.resolver");
    }
}

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Main{
    public static void main(String[] args){
      String methodName = BeanLambda.methodName(Maker::getNo);
      Method method = BeanLambda.method(Maker::getNo);
      String fieldName = BeanLambda.fieldName(Maker::getNo);
      Field field = BeanLambda.field(Maker::getNo);
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public static void main(String[] args){
  ExecutorService service = Executors.newCachedThreadPool();
  ExecutorService wrap = ContextSnapshots.wrap(service);
  wrap.submit(()->{});
}

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Main{
    public static void main(String[] args){
      GenericWrapper<?> wrapper = GenericWrapper.of("123");
      wrapper.unwrap()
    }
}

private static <S extends RediSearchConnectionFactory> Class<? extends S> createFactoryClass(
            Class<? extends AbstractRedisClient> clientType) {
        TypeDescription definitions = TypeDescription.ForLoadedType.of(RediSearchConnectionFactory.class);
        try (DynamicType.Unloaded<S> unloaded = new GenericsByteBuddy().<S>subclass(definitions)
            .name(FactoryProxySupport.class.getPackageName() + "." + clientType.getSimpleName()
                    + "$ProxyConnectionFactory")
            .defineField("client", clientType, Modifier.PRIVATE | Modifier.FINAL)
            .defineConstructor(Modifier.PUBLIC)
            .withParameters(clientType)
            .intercept(MethodCall.invoke(Object.class.getConstructor())
                .andThen(FieldAccessor.ofField("client").setsArgumentAt(0)))
            .method(ElementMatchers.named("connect").and(ElementMatchers.takesArguments(1)))
            .intercept(MethodDelegation.to(ConnectWithCodecInterceptor.class))
            .method(ElementMatchers.named("close"))
            .intercept(MethodDelegation.to(CloseInterceptor.class))
            .make()) {
            return unloaded.load(ClassUtils.getDefaultClassLoader(), ClassLoadingStrategy.Default.INJECTION)
                .getLoaded();
        }
        catch (NoSuchMethodException ex) {
            throw new IllegalArgumentException(ex);
        }
    }

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Main{
    public static void main(String[] args){
      String str = "root=1,2,3&root=4&a=b&a=c";
            Map<String, List<String>> map = Map.of("root", List.of("1", "2", "3", "4"), "a", List.of("b", "c"));
            MultiValueMap<String, String> multiValueMap = MultiValueMapSplitter.of("&", "=").split(str, ",");
            assertEquals(CollectionUtils.toMultiValueMap(map), multiValueMap);
    }
}

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Main{
    public static void main(String[] args){
      Pair<String, String> pair = Pair.of("username", "password");
    }
}

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Main{
    public static void main(String[] args){
      SnowflakeIdGenerator generator = new SnowflakeIdGenerator(1, 2)；
      long id = generator.nextId();
    }
}

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 StringRediSearchTemplate stringRediSearchTemplate;

    public ArticleSearchService(StringRediSearchTemplate stringRediSearchTemplate) {
        this.stringRediSearchTemplate = stringRediSearchTemplate;
    }

}

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;
    }

}