A Guide To Spring Redirects

1. Overview

This tutorial will focus on implementing a Redirect in Spring and will discuss the reasoning behind each strategy.

2. Why Do a Redirect?

Let’s first consider the reasons why we may need to do a redirect in a Spring application.

There are many possible examples and reasons of course. For example, we might need to POST form data, work around the double submission problem or just delegate the execution flow to another controller method.

A quick side note here: The typical Post/Redirect/Get pattern doesn’t adequately address double submission issues, and problems such as refreshing the page before the initial submission has completed may still result in a double submission.

3. Redirect With the RedirectView

Let’s start with this simple approach and go straight to an example:

@Controller
@RequestMapping("/")
public class RedirectController {
    
    @GetMapping("/redirectWithRedirectView")
    public RedirectView redirectWithUsingRedirectView(
        RedirectAttributes attributes) {
            attributes.addFlashAttribute("flashAttribute", "redirectWithRedirectView");
            attributes.addAttribute("attribute", "redirectWithRedirectView");
            return new RedirectView("redirectedUrl");
    }
}

Behind the scenes, RedirectView will trigger an HttpServletResponse.sendRedirect(), which will perform the actual redirect.

Notice here how we’re injecting the redirect attributes into the method. The framework will do the heavy lifting and allow us to interact with these attributes.

We’re adding the model attribute attribute, which will be exposed as HTTP query parameter. The model must contain only objects — generally Strings or objects that can be converted to Strings.

Let’s now test our redirect with the help of a simple curl command:

curl -i http://localhost:8080/spring-rest/redirectWithRedirectView

And here’s our result:

HTTP/1.1 302 Found
Server: Apache-Coyote/1.1
Location: 
  http://localhost:8080/spring-rest/redirectedUrl?attribute=redirectWithRedirectView

4. Redirect With the Prefix redirect:

The previous approach — using RedirectView — is suboptimal for a few reasons.

First, we’re now coupled to the Spring API because we’re using the RedirectView directly in our code.

Second, we now need to know from the start, when implementing that controller operation, that the result will always be a redirect, which may not always be the case.

A better option is using the prefix redirect:. The redirect view name is injected into the controller like any other logical view name. The controller is not even aware that redirection is happening.

Here’s what that looks like:

@Controller
@RequestMapping("/")
public class RedirectController {
    
    @GetMapping("/redirectWithRedirectPrefix")
    public ModelAndView redirectWithUsingRedirectPrefix(ModelMap model) {
        model.addAttribute("attribute", "redirectWithRedirectPrefix");
        return new ModelAndView("redirect:/redirectedUrl", model);
    }
}

When a view name is returned with the prefix redirect:, the UrlBasedViewResolver (and all its subclasses) will recognize this as a special indication that a redirect needs to happen. The rest of the view name will be used as the redirect URL.

A quick but important note is that when we use this logical view name here — redirect:/redirectedUrl — we’re doing a redirect relative to the current Servlet context.

We can use a name such as a redirect: http://localhost:8080/spring-redirect-and-forward/redirectedUrl if we need to redirect to an absolute URL.

So, now when we execute the curl command:

curl -i http://localhost:8080/spring-rest/redirectWithRedirectPrefix

we’ll immediately get redirected:

HTTP/1.1 302 Found
Server: Apache-Coyote/1.1
Location: 
  http://localhost:8080/spring-rest/redirectedUrl?attribute=redirectWithRedirectPrefix

5. Forward With the Prefix forward:

Let’s now see how to do something slightly different: a forward.

Before the code, let’s go over a quick, high-level overview of the semantics of forward vs redirect:

• redirect will respond with a 302 and the new URL in the Location header; the browser/client will then make another request to the new URL.
• forward happens entirely on a server side. The Servlet container forwards the same request to the target URL; the URL won’t change in the browser.

Now let’s look at the code:

@Controller
@RequestMapping("/")
public class RedirectController {
    
    @GetMapping("/forwardWithForwardPrefix")
    public ModelAndView redirectWithUsingForwardPrefix(ModelMap model) {
        model.addAttribute("attribute", "forwardWithForwardPrefix");
        return new ModelAndView("forward:/redirectedUrl", model);
    }
}

Same as redirect:, the forward: prefix will be resolved by UrlBasedViewResolver and its subclasses. Internally, this will create an InternalResourceView, which does a RequestDispatcher.forward() to the new view.

When we execute the command with curl:

curl -I http://localhost:8080/spring-rest/forwardWithForwardPrefix

we will get HTTP 405 (Method not allowed):

HTTP/1.1 405 Method Not Allowed
Server: Apache-Coyote/1.1
Allow: GET
Content-Type: text/html;charset=utf-8

To wrap up, compared to the two requests that we had in the case of the redirect solution, in this case, we only have a single request going out from the browser/client to the server side. The attribute that was previously added by the redirect is, of course, missing as well.

6. Attributes With the RedirectAttributes

Next, let’s look closer at passing attributes in a redirect, making full use of the framework with RedirectAttributes:

@GetMapping("/redirectWithRedirectAttributes")
public RedirectView redirectWithRedirectAttributes(RedirectAttributes attributes) {
    attributes.addFlashAttribute("flashAttribute", "redirectWithRedirectAttributes");
    attributes.addAttribute("attribute", "redirectWithRedirectAttributes");
    return new RedirectView("redirectedUrl");
}

As we saw before, we can inject the attributes object in the method directly, which makes this mechanism very easy to use.

Notice also that we are adding a flash attribute as well. This is an attribute that won’t make it into the URL.

With this kind of attribute, we can later access the flash attribute using @ModelAttribute(“flashAttribute”) only in the method that is the final target of the redirect:

@GetMapping("/redirectedUrl")
public ModelAndView redirection(
  ModelMap model, 
  @ModelAttribute("flashAttribute") Object flashAttribute) {
     model.addAttribute("redirectionAttribute", flashAttribute);
     return new ModelAndView("redirection", model);
 }

So, to wrap up, if we test the functionality with curl:

curl -i http://localhost:8080/spring-rest/redirectWithRedirectAttributes

we will be redirected to the new location:

HTTP/1.1 302 Found
Server: Apache-Coyote/1.1
Set-Cookie: JSESSIONID=4B70D8FADA2FD6C22E73312C2B57E381; Path=/spring-rest/; HttpOnly
Location: http://localhost:8080/spring-rest/redirectedUrl;
  jsessionid=4B70D8FADA2FD6C22E73312C2B57E381?attribute=redirectWithRedirectAttributes

That way, using RedirectAttributes instead of a ModelMap gives us the ability only to share some attributes between the two methods that are involved in the redirect operation.

7. An Alternative Configuration Without the Prefix

Let’s now explore an alternative configuration: a redirect without using the prefix.

To achieve this, we need to use an org.springframework.web.servlet.view.XmlViewResolver:

<bean class="org.springframework.web.servlet.view.XmlViewResolver">
    <property name="location">
        <value>/WEB-INF/spring-views.xml</value>
    </property>
    <property name="order" value="0" />
</bean>

This is instead of org.springframework.web.servlet.view.InternalResourceViewResolver we used in the previous configuration:

<bean 
  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
</bean>

We also need to define a RedirectView bean in the configuration:

<bean id="RedirectedUrl" class="org.springframework.web.servlet.view.RedirectView">
    <property name="url" value="redirectedUrl" />
</bean>

Now we can trigger the redirect by referencing this new bean by id:

@Controller
@RequestMapping("/")
public class RedirectController {
    
    @GetMapping("/redirectWithXMLConfig")
    public ModelAndView redirectWithUsingXMLConfig(ModelMap model) {
        model.addAttribute("attribute", "redirectWithXMLConfig");
        return new ModelAndView("RedirectedUrl", model);
    }
}

And to test it, we’ll again use the curl command:

curl -i http://localhost:8080/spring-rest/redirectWithRedirectView

And here’s our result:

HTTP/1.1 302 Found
Server: Apache-Coyote/1.1
Location: 
  http://localhost:8080/spring-rest/redirectedUrl?attribute=redirectWithRedirectView

8. Redirecting an HTTP POST Request

For use cases like bank payments, we might need to redirect an HTTP POST request. Depending on the HTTP status code returned, POST request can be redirected to an HTTP GET or POST.

As per HTTP 1.1 protocol reference, status codes 301 (Moved Permanently) and 302 (Found) allow the request method to be changed from POST to GET. The specification also defines the corresponding 307 (Temporary Redirect) and 308 (Permanent Redirect) status codes that don’t allow the request method to be changed from POST to GET.

Let’s look at the code for redirecting a post request to another post request:

@PostMapping("/redirectPostToPost")
public ModelAndView redirectPostToPost(HttpServletRequest request) {
    request.setAttribute(
      View.RESPONSE_STATUS_ATTRIBUTE, HttpStatus.TEMPORARY_REDIRECT);
    return new ModelAndView("redirect:/redirectedPostToPost");
}

@PostMapping("/redirectedPostToPost")
public ModelAndView redirectedPostToPost() {
    return new ModelAndView("redirection");
}

Now we’ll test the redirect of POST using the curl command:

curl -L --verbose -X POST http://localhost:8080/spring-rest/redirectPostToPost

We get redirected to the destined location:

> POST /redirectedPostToPost HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.49.0
> Accept: */*
> 
< HTTP/1.1 200 
< Content-Type: application/json;charset=UTF-8
< Transfer-Encoding: chunked
< Date: Tue, 08 Aug 2017 07:33:00 GMT

{"id":1,"content":"redirect completed"}

9. Forward With Parameters

Now let’s consider a scenario where we would want to send some parameters across to another RequestMapping with a forward prefix.

In that case, we can use an HttpServletRequest to pass in parameters between calls.

Here’s a method forwardWithParams that needs to send param1 and param2 to another mapping forwardedWithParams:

@RequestMapping(value="/forwardWithParams", method = RequestMethod.GET)
public ModelAndView forwardWithParams(HttpServletRequest request) {
    request.setAttribute("param1", "one");
    request.setAttribute("param2", "two");
    return new ModelAndView("forward:/forwardedWithParams");
}

In fact, the mapping forwardedWithParams can exist in an entirely new controller and need not be in the same one:

@RequestMapping(value="/forwardWithParams", method = RequestMethod.GET)
@Controller
@RequestMapping("/")
public class RedirectParamController {

    @RequestMapping(value = "/forwardedWithParams", method = RequestMethod.GET)
    public RedirectView forwardedWithParams(
      final RedirectAttributes redirectAttributes, HttpServletRequest request) {
        redirectAttributes.addAttribute("param1", request.getAttribute("param1"));
        redirectAttributes.addAttribute("param2", request.getAttribute("param2"));

        redirectAttributes.addAttribute("attribute", "forwardedWithParams");
        return new RedirectView("redirectedUrl");
    }
}

To illustrate, let’s try this curl command:

curl -i http://localhost:8080/spring-rest/forwardWithParams

Here’s the result:

HTTP/1.1 302 Found
Date: Fri, 19 Feb 2021 05:37:14 GMT
Content-Language: en-IN
Location: http://localhost:8080/spring-rest/redirectedUrl?param1=one&param2=two&attribute=forwardedWithParams
Content-Length: 0

As we can see, param1 and param2 traveled from the first controller to the second one. Finally, they showed up in the redirect named redirectedUrl that forwardedWithParams points to.

10. Conclusion

This article illustrated three different approaches to implementing a redirect in Spring, how to handle/pass attributes when doing these redirects and how to handle redirects of HTTP POST requests.