To provide some runtime generated API documentation I want to iterate over all Spring MVC controllers. All controllers are annotated with the Spring @Controller annotation. Currently I do it like this:
for (final Object bean: this.context.getBeansWithAnnotation(
Controller.class).values())
{
...Generate controller documentation for the bean...
}
But the first call of this code is EXTREMELY slow. I wonder if Spring iterates over ALL classes in the classpath instead of just checking the defined beans. The controllers are already loaded when the above code is run, the log displays all of them with their request mappings so Spring MVC must already know them all and there must be a faster way to get a list of them. But how?
Controller - A controller contains the business logic of an application. Here, the @Controller annotation is used to mark the class as the controller. View - A view represents the provided information in a particular format. Generally, JSP+JSTL is used to create a view page.
In Spring MVC, we can create multiple controllers at a time. It is required to map each controller class with @Controller annotation.
The default handler is based on the @Controller and @RequestMapping annotations, offering a wide range of flexible handling methods. With the introduction of Spring 3.0, the @Controller mechanism also allows you to create RESTful Web sites and applications, through the @PathVariable annotation and other features.
It finds the right controllers by using handler mappings like SimpleUrlHandlerMapping or BeanNameUrlHandlerMapping, which check if the bean name is the same as the view name and the bean implements the View interface.
I like the approach suggested by @Japs, but would also like to recommend an alternate approach.
This is based on your observation that the classpath has already been scanned by Spring, and the controllers and the request mapped methods configured, this mapping is maintained in a handlerMapping
component. If you are using Spring 3.1 this handlerMapping
component is an instance of RequestMappingHandlerMapping, which you can query to find the handlerMappedMethods and the associated controllers, along these lines(if you are on an older version of Spring, you should be able to use a similar approach):
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
@Controller
public class EndpointDocController {
private final RequestMappingHandlerMapping handlerMapping;
@Autowired
public EndpointDocController(RequestMappingHandlerMapping handlerMapping) {
this.handlerMapping = handlerMapping;
}
@RequestMapping(value="/endpointdoc", method=RequestMethod.GET)
public void show(Model model) {
model.addAttribute("handlerMethods", this.handlerMapping.getHandlerMethods());
}
}
I have provided more details on this at this url http://biju-allandsundry.blogspot.com/2012/03/endpoint-documentation-controller-for.html
This is based on a presentation on Spring 3.1 by Rossen Stoyanchev of Spring Source.
I have also came across such requirement before some months and I have achieved it using the following code snippet.
ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
scanner.addIncludeFilter(new AnnotationTypeFilter(Controller.class));
for (BeanDefinition beanDefinition : scanner.findCandidateComponents("com.xxx.yyy.controllers")){
System.out.println(beanDefinition.getBeanClassName());
}
You can also do something like this with your controllers.
Updated the code snippet. Removed the not necessary code and just displaying the class name of the controllers for better understanding. Hope this helps you. Cheers.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With