java - 列出所有已部署的 REST 端点(spring-boot、jersey)

Question

是否可以使用 spring boot 列出我所有配置的 rest-endpoints？执行器在启动时列出了所有现有路径，我希望我的自定义服务有类似的东西，所以我可以在启动时检查所有路径是否配置正确，并将此信息用于客户端调用。

我该怎么做？我在我的服务 bean 上使用 @Path/@GET 注释并通过 ResourceConfig#registerClasses 注册它们。

有没有办法查询所有路径的配置？

更新:我通过

注册了 REST Controller

@Bean
public ResourceConfig resourceConfig() {
   return new ResourceConfig() {
    {  
      register(MyRestController.class);
    }
   };
}

Update2:我想要类似的东西

GET /rest/mycontroller/info
POST /res/mycontroller/update
...

动机:当 spring-boot 应用程序启动时，我想打印出所有注册的 Controller 及其路径，这样我就可以停止猜测要使用哪些端点。

Answer 1

可能最好的方法是使用 ApplicationEventListener .从那里您可以监听“应用程序完成初始化”事件，并从 ApplicationEvent 获取 ResourceModel。 ResourceModel 将包含所有已初始化的 Resource。然后您可以像其他人提到的那样遍历 Resource 。下面是一个实现。部分实现取自 DropwizardResourceConfig实现。

import com.fasterxml.classmate.ResolvedType;
import com.fasterxml.classmate.TypeResolver;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
import org.glassfish.jersey.server.model.Resource;
import org.glassfish.jersey.server.model.ResourceMethod;
import org.glassfish.jersey.server.model.ResourceModel;
import org.glassfish.jersey.server.monitoring.ApplicationEvent;
import org.glassfish.jersey.server.monitoring.ApplicationEventListener;
import org.glassfish.jersey.server.monitoring.RequestEvent;
import org.glassfish.jersey.server.monitoring.RequestEventListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class EndpointLoggingListener implements ApplicationEventListener {

    private static final TypeResolver TYPE_RESOLVER = new TypeResolver();

    private final String applicationPath;

    private boolean withOptions = false;
    private boolean withWadl = false;

    public EndpointLoggingListener(String applicationPath) {
        this.applicationPath = applicationPath;
    }

    @Override
    public void onEvent(ApplicationEvent event) {
        if (event.getType() == ApplicationEvent.Type.INITIALIZATION_APP_FINISHED) {
            final ResourceModel resourceModel = event.getResourceModel();
            final ResourceLogDetails logDetails = new ResourceLogDetails();
            resourceModel.getResources().stream().forEach((resource) -> {
                logDetails.addEndpointLogLines(getLinesFromResource(resource));
            });
            logDetails.log();
        }
    }

    @Override
    public RequestEventListener onRequest(RequestEvent requestEvent) {
        return null;
    }

    public EndpointLoggingListener withOptions() {
        this.withOptions = true;
        return this;
    }

    public EndpointLoggingListener withWadl() {
        this.withWadl = true;
        return this;
    }

    private Set<EndpointLogLine> getLinesFromResource(Resource resource) {
        Set<EndpointLogLine> logLines = new HashSet<>();
        populate(this.applicationPath, false, resource, logLines);
        return logLines;
    }

    private void populate(String basePath, Class<?> klass, boolean isLocator,
            Set<EndpointLogLine> endpointLogLines) {
        populate(basePath, isLocator, Resource.from(klass), endpointLogLines);
    }

    private void populate(String basePath, boolean isLocator, Resource resource,
            Set<EndpointLogLine> endpointLogLines) {
        if (!isLocator) {
            basePath = normalizePath(basePath, resource.getPath());
        }

        for (ResourceMethod method : resource.getResourceMethods()) {
            if (!withOptions && method.getHttpMethod().equalsIgnoreCase("OPTIONS")) {
                continue;
            }
            if (!withWadl && basePath.contains(".wadl")) {
                continue;
            }
            endpointLogLines.add(new EndpointLogLine(method.getHttpMethod(), basePath, null));
        }

        for (Resource childResource : resource.getChildResources()) {
            for (ResourceMethod method : childResource.getAllMethods()) {
                if (method.getType() == ResourceMethod.JaxrsType.RESOURCE_METHOD) {
                    final String path = normalizePath(basePath, childResource.getPath());
                    if (!withOptions && method.getHttpMethod().equalsIgnoreCase("OPTIONS")) {
                        continue;
                    }
                    if (!withWadl && path.contains(".wadl")) {
                        continue;
                    }
                    endpointLogLines.add(new EndpointLogLine(method.getHttpMethod(), path, null));
                } else if (method.getType() == ResourceMethod.JaxrsType.SUB_RESOURCE_LOCATOR) {
                    final String path = normalizePath(basePath, childResource.getPath());
                    final ResolvedType responseType = TYPE_RESOLVER
                            .resolve(method.getInvocable().getResponseType());
                    final Class<?> erasedType = !responseType.getTypeBindings().isEmpty()
                            ? responseType.getTypeBindings().getBoundType(0).getErasedType()
                            : responseType.getErasedType();
                    populate(path, erasedType, true, endpointLogLines);
                }
            }
        }
    }

    private static String normalizePath(String basePath, String path) {
        if (path == null) {
            return basePath;
        }
        if (basePath.endsWith("/")) {
            return path.startsWith("/") ? basePath + path.substring(1) : basePath + path;
        }
        return path.startsWith("/") ? basePath + path : basePath + "/" + path;
    }

    private static class ResourceLogDetails {

        private static final Logger logger = LoggerFactory.getLogger(ResourceLogDetails.class);

        private static final Comparator<EndpointLogLine> COMPARATOR
                = Comparator.comparing((EndpointLogLine e) -> e.path)
                .thenComparing((EndpointLogLine e) -> e.httpMethod);

        private final Set<EndpointLogLine> logLines = new TreeSet<>(COMPARATOR);

        private void log() {
            StringBuilder sb = new StringBuilder("\nAll endpoints for Jersey application\n");
            logLines.stream().forEach((line) -> {
                sb.append(line).append("\n");
            });
            logger.info(sb.toString());
        }

        private void addEndpointLogLines(Set<EndpointLogLine> logLines) {
            this.logLines.addAll(logLines);
        }
    }

    private static class EndpointLogLine {

        private static final String DEFAULT_FORMAT = "   %-7s %s";
        final String httpMethod;
        final String path;
        final String format;

        private EndpointLogLine(String httpMethod, String path, String format) {
            this.httpMethod = httpMethod;
            this.path = path;
            this.format = format == null ? DEFAULT_FORMAT : format;
        }

        @Override
        public String toString() {
            return String.format(format, httpMethod, path);
        }
    }
}

然后你只需要在 Jersey 注册监听器。您可以从 JerseyProperties 获取应用程序路径。您需要在属性 spring.jersey.applicationPath 下的 Spring Boot application.properties 中设置它。这将是根路径，就像您要在 ResourceConfig 子类上使用 @ApplicationPath 一样

@Bean
public ResourceConfig getResourceConfig(JerseyProperties jerseyProperties) {
    return new JerseyConfig(jerseyProperties);
}
...
public class JerseyConfig extends ResourceConfig {

    public JerseyConfig(JerseyProperties jerseyProperties) {
        register(HelloResource.class);
        register(new EndpointLoggingListener(jerseyProperties.getApplicationPath()));
    }
}

需要注意的一点是，Jersey servlet 上默认未设置启动时加载。这意味着 Jersey 在第一个请求之前不会在启动时加载。所以在第一个请求之前你不会看到监听器被触发。我打开了an issue可能获得配置属性，但与此同时，您有几个选择:

1. 将 Jersey 设置为过滤器，而不是 servlet。过滤器将在启动时加载。使用 Jersey 作为过滤器，对于大多数帖子来说，实际上并没有什么不同。要配置它，您只需在 application.properties

   中添加一个 Spring Boot 属性

   spring.jersey.type=filter
   

2. 另一个选项是覆盖 Jersey ServletRegistrationBean 并设置其 loadOnStartup 属性。这是一个示例配置。一些实现直接取自 JerseyAutoConfiguration

   @SpringBootApplication
   public class JerseyApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(JerseyApplication.class, args);
       }
   
       @Bean
       public ResourceConfig getResourceConfig(JerseyProperties jerseyProperties) {
           return new JerseyConfig(jerseyProperties);
       }
   
       @Bean
       public ServletRegistrationBean jerseyServletRegistration(
           JerseyProperties jerseyProperties, ResourceConfig config) {
           ServletRegistrationBean registration = new ServletRegistrationBean(
                   new ServletContainer(config), 
                   parseApplicationPath(jerseyProperties.getApplicationPath())
           );
           addInitParameters(registration, jerseyProperties);
           registration.setName(JerseyConfig.class.getName());
           registration.setLoadOnStartup(1);
           return registration;
       }
   
       private static String parseApplicationPath(String applicationPath) {
           if (!applicationPath.startsWith("/")) {
               applicationPath = "/" + applicationPath;
           }
           return applicationPath.equals("/") ? "/*" : applicationPath + "/*";
       }
   
       private void addInitParameters(RegistrationBean registration, JerseyProperties jersey) {
           for (Entry<String, String> entry : jersey.getInit().entrySet()) {
               registration.addInitParameter(entry.getKey(), entry.getValue());
           }
       }
   }
   

---

更新

所以看起来 Spring Boot 将进入 add the load-on-startup property ，所以我们不必重写 Jersey ServletRegistrationBean。将在 Boot 1.4.0 中添加