spring boot extension doc

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的解析
    @Override
    protected ContextFactory getContextFactory() {
        return super.getContextFactory();
    }
}

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

public class MyExpressionResolver extends ConverterExpressionResolver<EvaluationContext, Expression> {
  //将上下文转成组件的上下文
    @Override
    protected EvaluationContext transform(Context context) {
        return null;
    }
}

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

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

}

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.lang.reflect.Field;
import java.lang.reflect.Method;

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

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

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

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

}

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

@RestController
public class InfoController {

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

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

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

@RestController
@RequiredArgsConstructor
public class InfoController {

    @ExcelReturn(fileName = "outFile")
    @ExcelImport(parse = InfoExcelListener.class, paramName = "dataExcels")
    @PostMapping("uploadDownLoad")
    public List<Info> uploadDownLoadMono(List<Info> dataExcels) {
        return dataExcels;
    }

    @ExcelReturn(fileName = "outFile")
    @ExcelImport(parse = InfoExcelListener.class, paramName = "dataExcels")
    @PostMapping("uploadDownLoadMono")
    public Mono<List<Info>> uploadDownLoadMono(Mono<List<Info>> dataExcels) {
        return dataExcels;
    }

    @ExcelReturn(fileName = "outFile")
    @ExcelImport(parse = InfoExcelListener.class, paramName = "dataExcels")
    @PostMapping("uploadDownLoadFlux")
    public Flux<Info> uploadDownLoadFlux(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) {

    }
}