Java – Spring MVC – how to return 404 on missing parameters

javaspring-mvc

I want to trigger 404 page whenever I wasn't passed all of the parameters. Lets say I have the following URI:

/myapp/op?param1=1&param2=2@param3=3

In case on of the parameters wasn;t invoked I want to return 404 page. I tried doing:

@ResponseStatus(HttpStatus.NOT_FOUND)
@RequestMapping(value = "op", params = { "!param1" })
public void missingArg() {
}

but then I get an exception telling me there is ambiguity between methods that handle missing second and third parameter.

How can I accomplish this, then?

Best Answer

If you're using Spring 3.1 you can define an exception class like so:

@ResponseStatus(value = HttpStatus.NOT_FOUND)
public final class ResourceNotFoundException extends RuntimeException {
   //  class definition
}

Now whenever you throw that exception, Spring will return the http status defined in your @ResponseStatus annotation. For example:

@RequestMapping(value = "/op")
public void methodWithRequestParams(@RequestParam(value = "param1", required = false) String param1, 
        @RequestParam(value = "param2", required = false) String param2) {
  if (param1 == null || param2 == null) {
    throw new ResourceNotFoundException();
  }
}

will return a 404 whenever param1 or param2 is null.

Related Solutions

Java – Trigger 404 in Spring-MVC controller

Since Spring 3.0 you also can throw an Exception declared with @ResponseStatus annotation:

@ResponseStatus(value = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {
    ...
}

@Controller
public class SomeController {
    @RequestMapping.....
    public void handleCall() {
        if (isFound()) {
            // whatever
        }
        else {
            throw new ResourceNotFoundException(); 
        }
    }
}

Java – How does autowiring work in Spring

First, and most important - all Spring beans are managed - they "live" inside a container, called "application context".

Second, each application has an entry point to that context. Web applications have a Servlet, JSF uses a el-resolver, etc. Also, there is a place where the application context is bootstrapped and all beans - autowired. In web applications this can be a startup listener.

Autowiring happens by placing an instance of one bean into the desired field in an instance of another bean. Both classes should be beans, i.e. they should be defined to live in the application context.

What is "living" in the application context? This means that the context instantiates the objects, not you. I.e. - you never make new UserServiceImpl() - the container finds each injection point and sets an instance there.

In your controllers, you just have the following:

@Controller // Defines that this class is a spring bean
@RequestMapping("/users")
public class SomeController {

    // Tells the application context to inject an instance of UserService here
    @Autowired
    private UserService userService;

    @RequestMapping("/login")
    public void login(@RequestParam("username") String username,
           @RequestParam("password") String password) {

        // The UserServiceImpl is already injected and you can use it
        userService.login(username, password);

    }
}

A few notes:

In your applicationContext.xml you should enable the <context:component-scan> so that classes are scanned for the @Controller, @Service, etc. annotations.
The entry point for a Spring-MVC application is the DispatcherServlet, but it is hidden from you, and hence the direct interaction and bootstrapping of the application context happens behind the scene.
UserServiceImpl should also be defined as bean - either using <bean id=".." class=".."> or using the @Service annotation. Since it will be the only implementor of UserService, it will be injected.
Apart from the @Autowired annotation, Spring can use XML-configurable autowiring. In that case all fields that have a name or type that matches with an existing bean automatically get a bean injected. In fact, that was the initial idea of autowiring - to have fields injected with dependencies without any configuration. Other annotations like @Inject, @Resource can also be used.

Best Answer

Related Solutions

Java – Trigger 404 in Spring-MVC controller

Java – How does autowiring work in Spring

Related Topic