为什么我需要在控制器中使用spring注释？

Question

I'm new to play and also to spring. Started to work in a project and if I just create my controller class like this:

package controllers;

import play.mvc.Controller;
import play.mvc.Result;

public class Users extends Controller {

    public Result login(){
        return ok(views.html.login.render());
    }

}

I got this exception:

[NoSuchBeanDefinitionException: No qualifying bean of type [controllers.Users] is defined]

But, if I insert this annoation from spring on the top level:

package controllers;

import play.mvc.Controller;
import play.mvc.Result;

@org.springframework.stereotype.Controller
public class Users extends Controller {

    public Result login(){
        return ok(views.html.login.render());
    }

}

The page is rendered. But I don't know why this is happening. I would like to use spring only when is necessary, work with play on its full capacity. So I wonder if I'm doing right using this annotation on my controller.

EDIT:

import configuration.WebAppConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import play.Application;
import play.GlobalSettings;

/**
 * Application wide behaviour. We establish a Spring application context for the dependency injection system and
 * configure Spring Data.
 */
public class Global extends GlobalSettings {

    /**
     * The name of the persistence unit we will be using.
     */
    static final String DEFAULT_PERSISTENCE_UNIT = "default";

    /**
     * Declare the application context to be used - a Java annotation based application context requiring no XML.
     */
    final private AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();

    /**
     * Sync the context lifecycle with Play's.
     */
    @Override
    public void onStart(final Application app) {
        super.onStart(app);

        // AnnotationConfigApplicationContext can only be refreshed once, but we do it here even though this method
        // can be called multiple times. The reason for doing during startup is so that the Play configuration is
        // entirely available to this application context.
        ctx.register(SpringDataJpaConfiguration.class);
        ctx.scan("controllers", "models");
        ctx.refresh();

        // This will construct the beans and call any construction lifecycle methods e.g. @PostConstruct
        ctx.start();

    }

    /**
     * Sync the context lifecycle with Play's.
     */
    @Override
    public void onStop(final Application app) {
        // This will call any destruction lifecycle methods and then release the beans e.g. @PreDestroy
        ctx.close();

        super.onStop(app);
    }

    /**
     * Controllers must be resolved through the application context. There is a special method of GlobalSettings that we
     * can override to resolve a given controller. This resolution is required by the Play router.
     */
    @Override
    public <A> A getControllerInstance(Class<A> aClass) {
        return ctx.getBean(aClass);
    }

    /**
     * This configuration establishes the Spring context which in our case is defined in the "other" project.
     */
    @Configuration
    @Import(WebAppConfig.class)
    public static class SpringDataJpaConfiguration {
        // At the moment this class is just a entry point for the "other project" Spring context config, AppContext
    }

}

EDIT 2: Guys, now I remember something in this project, we have 2 projects, one developed entirely on java and spring and this one, the webapp. We are importing the .jar built from the first project on this project with play. We are doing like these so we don't have to maintain two different models.

Answer 1

In your class Global you actually tell the Playframework to resolve controllers from the Spring application context:

@Override
public <A> A getControllerInstance(Class<A> aClass) {
    return ctx.getBean(aClass);
}

In this case it is clear, that you have to have Spring annotations on your controllers, otherwise they wouldn't be added to the application context. If you don't want to resolve controllers from the application context, remove that method. But keep in mind, that you will not be able to inject Spring components in your Play controllers then, since they are not managed by Spring.

Answer 2

Are you familiar with IoC (Inversion of Control) and DI (Dependency Injection)? Spring IoC has a container It need to know every component. You must to configure it with configuration files/configuration classes, and annotations can be useful to avoid have a extensive configuration.

Answer 3

If you want to retreive a bean instance from Spring's context that bean must be managed by Spring . Adding @Controller to your controller and enabling component scan pointing to its package (or superpackage) tells to Spring to create an instance of that class inside its context, an instance you could lately use.

Having said that, here is explained why you got that exception.