docs: private HttpClient getClient(MethodInvocationContext<Object, Object> context, AnnotationValue<Client> clientAnn) {
          String clientId = getClientId(clientAnn);
          String path = clientAnn.get("path", String.class).orElse(null);
          String clientKey = computeClientKey(clientId, path);
          if (clientKey == null) {
              return null;
          }
  
          return clients.computeIfAbsent(clientKey, integer -> {
              HttpClient clientBean = beanContext.findBean(HttpClient.class, Qualifiers.byName(clientId)).orElse(null);
              if (null != clientBean) {
                  return clientBean;
              }
  
              LoadBalancer loadBalancer = loadBalancerResolver.resolve(clientId)
                  .orElseThrow(() ->
                      new HttpClientException("Invalid service reference [" + clientId + "] specified to @Client")
                  );
  
              String contextPath = null;
              if (StringUtils.isNotEmpty(path)) {
                  contextPath = path;
              } else if (StringUtils.isNotEmpty(clientId) && clientId.startsWith("/")) {
                  contextPath = clientId;
              } else {
                  if (loadBalancer instanceof FixedLoadBalancer) {
                      contextPath = ((FixedLoadBalancer) loadBalancer).getUrl().getPath();
                  }
              }
  
              HttpClientConfiguration configuration;
              Optional<HttpClientConfiguration> clientSpecificConfig = beanContext.findBean(
                  HttpClientConfiguration.class,
                  Qualifiers.byName(clientId)
              );
              Class<HttpClientConfiguration> defaultConfiguration = clientAnn.get("configuration", Class.class).orElse(HttpClientConfiguration.class);
              configuration = clientSpecificConfig.orElseGet(() -> beanContext.getBean(defaultConfiguration));
              HttpClient client = beanContext.createBean(HttpClient.class, loadBalancer, configuration, contextPath);
              if (client instanceof DefaultHttpClient) {
                  DefaultHttpClient defaultClient = (DefaultHttpClient) client;
                  defaultClient.setClientIdentifiers(clientId);
                  AnnotationValue<JacksonFeatures> jacksonFeatures = context.findAnnotation(JacksonFeatures.class).orElse(null);
  
                  if (jacksonFeatures != null) {
                      Optional<MediaTypeCodec> existingCodec = defaultClient.getMediaTypeCodecRegistry().findCodec(MediaType.APPLICATION_JSON_TYPE);
                      ObjectMapper objectMapper = null;
                      if (existingCodec.isPresent()) {
                          MediaTypeCodec existing = existingCodec.get();
                          if (existing instanceof JsonMediaTypeCodec) {
                              objectMapper = ((JsonMediaTypeCodec) existing).getObjectMapper().copy();
                          }
                      }
                      if (objectMapper == null) {
                          objectMapper = new ObjectMapperFactory().objectMapper(null, null);
                      }
  
                      SerializationFeature[] enabledSerializationFeatures = jacksonFeatures.get("enabledSerializationFeatures", SerializationFeature[].class).orElse(null);
                      if (enabledSerializationFeatures != null) {
                          for (SerializationFeature serializationFeature : enabledSerializationFeatures) {
                              objectMapper.configure(serializationFeature, true);
                          }
                      }
  
                      DeserializationFeature[] enabledDeserializationFeatures = jacksonFeatures.get("enabledDeserializationFeatures", DeserializationFeature[].class).orElse(null);
  
                      if (enabledDeserializationFeatures != null) {
                          for (DeserializationFeature serializationFeature : enabledDeserializationFeatures) {
                              objectMapper.configure(serializationFeature, true);
                          }
                      }
  
                      SerializationFeature[] disabledSerializationFeatures = jacksonFeatures.get("disabledSerializationFeatures", SerializationFeature[].class).orElse(null);
                      if (disabledSerializationFeatures != null) {
                          for (SerializationFeature serializationFeature : disabledSerializationFeatures) {
                              objectMapper.configure(serializationFeature, false);
                          }
                      }
  
                      DeserializationFeature[] disabledDeserializationFeatures = jacksonFeatures.get("disabledDeserializationFeatures", DeserializationFeature[].class).orElse(null);
  
                      if (disabledDeserializationFeatures != null) {
                          for (DeserializationFeature feature : disabledDeserializationFeatures) {
                              objectMapper.configure(feature, false);
                          }
                      }
  
                      defaultClient.setMediaTypeCodecRegistry(
                              MediaTypeCodecRegistry.of(
                                      new JsonMediaTypeCodec(objectMapper,
                                              beanContext.getBean(ApplicationConfiguration.class),
                                              beanContext.findBean(CodecConfiguration.class, Qualifiers.byName(JsonMediaTypeCodec.CONFIGURATION_QUALIFIER)).orElse(null))));
                  }
              }
              return client;
          });
      }