docs: public static @Nonnull <T> Optional<T> tryInstantiate(@Nonnull Class<T> type) {
          ArgumentUtils.requireNonNull("type", type);
          final Supplier<T> reflectionFallback = () -> {
              final Logger logger = ClassUtils.REFLECTION_LOGGER;
              if (logger.isDebugEnabled()) {
                  logger.debug("Cannot instantiate type [{}] without reflection. Attempting reflective instantiation", type);
              }
              try {
                  T bean = type.newInstance();
                  if (type.isInstance(bean)) {
                      return bean;
                  }
                  return null;
              } catch (Throwable e) {
                  try {
                      Constructor<T> defaultConstructor = type.getDeclaredConstructor();
                      defaultConstructor.setAccessible(true);
                      return tryInstantiate(defaultConstructor).orElse(null);
                  } catch (Throwable e1) {
                      Logger log = LoggerFactory.getLogger(InstantiationUtils.class);
                      if (log.isDebugEnabled()) {
                          log.debug("Tried, but could not instantiate type: " + type, e);
                      }
                      return null;
                  }
              }
          };
          final T result = BeanIntrospector.SHARED.findIntrospection(type).map(introspection -> {
              try {
                  return introspection.instantiate();
              } catch (InstantiationException e) {
                  return reflectionFallback.get();
              }
          }).orElseGet(reflectionFallback);
  
          return Optional.ofNullable(result);
      }