Use Eclipse to create a standard Java class. Right-click on the project, and choose New > Class

Figure 2. New > Java Class

Add the following code to the new Java class. Please note that there's nothing specific to Spring in this code.

package org.customerapp.web;

import org.customerapp.dao.CustomerDAO;
import org.customerapp.service.CustomerService;

public class MyController {

   public CustomerService custService;

   public CustomerDAO custDAO;

   public String doSomethingOne(){
      return "";
   }

   public String doSomethingTwo(String xyz){
      return "";
   }
}

Use Eclipse to generate getters and setters for custService and custDAO. (Source-->Generate Getters and Setters...)

Figure 3. Generate Getters and Setters

While the MyController class is open in the Eclipse Java editor, switch to the Spring Annotator.

Figure 4. Switch to Spring Annotator

The Spring Annotator is implemented as an Eclipse View. If the View isn't visible, you can add it using the Window-->Show View option.

From the Spring Annotator specify how you would like to stereotype the new Java class. For this tutorial select Controller.

Figure 5. Switch to Spring Annotator

The moment you select Controller, the Java class is immediately annotated with the @Controller annotation.

The Spring annotator will now let you further configure the Java class with annotations that are relevant to Spring controllers. If you highlight the class name (MyController) in code or the annotator's outline view, the configuration panel will show you a list of available class-level annotations. Type MyNewController for the controller name, and select singleton for the scope. As you configure the Java class using the annotator, the Java code is immediately updated to reflect the configuration.

Figure 6. Class-level configuration

In this example the MyController class is being annotated as a Spring Controller. The bean name is MyNewController, and the scope of the controller is singleton. If desired, you can switch to the Transactional tab to configure and specify the transactional properties for the controller.

The Spring annotator will also let you further configure the class variables with annotations that are relevant to Spring controllers. If you highlight the custService variable declaration in code or the annotator's outline view, the configuration panel will show you a list of available variable-level annotations. Select @Resource and specify CustomerService as the name. As you configure the variable using the annotator, the Java code is immediately updated to reflect the configuration.

Figure 7. Variable-level configuration

In this example the variable is being configured to be injected by Spring with a bean that's named CustomerService, which is one of the originally scaffolded Spring Services (from scaffolding tutorial).

The Spring annotator will also let you further configure the class methods with annotations that are relevant to Spring controllers. If you highlight the doSomethingOne() method in code or the annotator's outline view, the configuration panel will show you a list of available method-level annotations. Select @RequestMapping, specify "/dosomething.html" for the URL, and select GET and POST as the methods. As you configure the method using the annotator, the Java code is immediately updated to reflect the configuration.

Figure 8. Method-level configuration

In this example the doSomethingOne() method is being configured as a request handler. It's being bound to the "/dosomething.html" URL, and specifically to GET and POST methods. If desired, you can switch to the Transactional tab to configure and specify the transactional properties for the request handler.

The Spring annotator will also let you further configure method parameters with annotations that are relevant to Spring controllers. If you highlight the doSomethingTwo() method in code or the annotator's outline view, the configuration panel will show you a list of available method-level annotations. Select @RequestMapping, specify "/dosomethingelse.html" for the URL, and select GET and POST as the methods. Next you can configure the individual method arguments, including how the method argument is mapped (@RequestParm or @ModelAttribute) and the parameter name (if different from the method argument name). As you configure the method using the annotator, the Java code is immediately updated to reflect the configuration.

Figure 9. Method parameter configuration

In this example the doSomethingTwo() method is being configured as a request handler. It's being bound to the "/dosomethingelse.html" URL, and specifically to GET and POST methods. The xyz method argument is configured as a request parameter (@RequestParam) and bound to the username request parameter.