Liste de tous déployés reste des points de terminaison (printemps-démarrage, jersey)

Probablement la meilleure façon de le faire est d'utiliser un ApplicationEventListener. De là, vous pouvez écouter de la "demande d'terminé l'initialisation de l'événement", et d'obtenir le ResourceModel de la ApplicationEvent. Le ResourceModel aurez toutes les initialisé Resources. Ensuite, vous pouvez parcourir la Resource comme d'autres l'ont mentionné. Ci-dessous est une mise en œuvre. Certains de la mise en œuvre a été prise à partir de la DropwizardResourceConfig mise en œuvre.

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

Ensuite, vous avez juste besoin d'enregistrer l'écouteur avec Jersey. Vous pouvez obtenir le chemin de l'application de la JerseyProperties. Vous aurez besoin de le fixer dans le Ressort de Démarrage application.properties en vertu de la propriété spring.jersey.applicationPath. Ce sera le chemin de la racine, comme si vous étiez à utiliser @ApplicationPath sur votre ResourceConfig sous-classe

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

Une chose à noter, c'est que le load-on-startup n'est pas définie par défaut sur le Maillot de servlet. Ce que cela signifie, c'est que ce Maillot ne se charge pas au démarrage jusqu'à la première demande. Vous ne voyez donc pas que l'auditeur a déclenché jusqu'à la première demande. J'ai ouvert un problème possible d'obtenir une propriété de configuration, mais en attendant, vous avez deux options:

1. Configurer Maillot de filtre, au lieu d'une servlet. Le filtre sera chargé au démarrage. À l'aide de Jersey comme un filtre, pour la plupart des post, vraiment ne se comporte pas différemment. Pour configurer cela, vous avez juste besoin d'ajouter un Ressort de Démarrage de la propriété dans le application.properties

   spring.jersey.type=filter

2. L'autre option est de remplacer le Maillot ServletRegistrationBean et définir sa loadOnStartup de la propriété. Voici un exemple de configuration. Certains de la mise en œuvre a été pris directement à partir de la 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());
   }
   }
   }

Mise à JOUR

De sorte qu'il ressemble le Printemps de Démarrage va ajouter le load-on-startup de la propriété, de sorte que nous n'avons pas à remplacer le Maillot ServletRegistrationBean. Seront ajoutés au Démarrage 1.4.0

OriginalL'auteur

Après l'application est complètement démarré, vous pouvez demander ServerConfig:

ResourceConfig instance; 
ServerConfig scfg = instance.getConfiguration();
Set<Class<?>> classes = scfg.getClasses();

classes contient toutes les mises en cache d'extrémité classes.

De l'API docs pour javax.ws.rs.core.Configuration:

Obtenir l'immuable ensemble des inscrits de JAX-RS composant (tels que le fournisseur ou la fonctionnalité des cours d'instanciation, injecté et utilisée dans le champ d'application de la configurables par exemple.

Cependant, vous ne pouvez pas le faire dans le code d'initialisation de votre application, les classes ne soient pas encore totalement chargé.

Avec les classes, vous pouvez les numériser pour les ressources:

public Map<String, List<InfoLine>> scan(Class baseClass) {
Builder builder = Resource.builder(baseClass);
if (null == builder)
return null;
Resource resource = builder.build();
String uriPrefix = "";
Map<String, List<InfoLine>> info = new TreeMap<>();
return process(uriPrefix, resource, info);
}
private Map<String, List<InfoLine>> process(String uriPrefix, Resource resource, Map<String, List<InfoLine>> info) {
String pathPrefix = uriPrefix;
List<Resource> resources = new ArrayList<>();
resources.addAll(resource.getChildResources());
if (resource.getPath() != null) {
pathPrefix = pathPrefix + resource.getPath();
}
for (ResourceMethod method : resource.getAllMethods()) {
if (method.getType().equals(ResourceMethod.JaxrsType.SUB_RESOURCE_LOCATOR)) {
resources.add(
Resource.from(
resource.getResourceLocator()
.getInvocable()
.getDefinitionMethod()
.getReturnType()
)
);
}
else {
List<InfoLine> paths = info.get(pathPrefix);
if (null == paths) {
paths = new ArrayList<>();
info.put(pathPrefix, paths);
}
InfoLine line = new InfoLine();
line.pathPrefix = pathPrefix;
line.httpMethod = method.getHttpMethod();
paths.add(line);
System.out.println(method.getHttpMethod() + "\t" + pathPrefix);
}
}
for (Resource childResource : resources) {
process(pathPrefix, childResource, info);
}
return info;
}
private class InfoLine {
public String pathPrefix;
public String httpMethod;
}

OriginalL'auteur