Spring MVC – My Shitty Code

Spring MVC: Failed to convert value of type ‘java.lang.String’ to required type ‘java.time.LocalDateTime’

Shitty Author — Thu, 22 Jun 2017 23:07:57 +0000

PROBLEM

Given the following controller …

@RestController
@RequestMapping(value = '/controller')
class MyController {

    @RequestMapping(method = RequestMethod.GET)
    ResponseEntity main(@RequestParam(name = 'dateTime') LocalDateTime dateTime) {
        // ...

        return ResponseEntity.noContent().build()
    }
}

When executing …

GET https://localhost:8443/controller?dateTime=2017-06-22T17:38

… the web service call returns 400 Bad Request with the following error in the console log:-

Failed to bind request element: org.springframework.web.method.annotation.MethodArgumentTypeMismatchException:
Failed to convert value of type 'java.lang.String' to required type 'java.time.LocalDateTime'; nested exception
is org.springframework.core.convert.ConversionFailedException: Failed to convert from type [java.lang.String]
to type [@org.springframework.web.bind.annotation.RequestParam java.time.LocalDateTime] for value '2017-06-22T17:38';
nested exception is java.lang.IllegalArgumentException: Parse attempt failed for value [2017-06-22T17:38]

SOLUTION

One solution is to change the data type from java.time.LocalDateTime to java.lang.String before parsing it to java.time.LocalDateTime. However, it is a little more verbose than I like.

A better way is to leverage @DateTimeFormat:-

@RestController
@RequestMapping(value = '/controller')
class MyController {

    @RequestMapping(method = RequestMethod.GET)
    ResponseEntity main(@RequestParam(name = 'dateTime') @DateTimeFormat(pattern = "yyyy-MM-dd'T'HH:mm") LocalDateTime dateTime) {
        // ...

        return ResponseEntity.noContent().build()
    }
}

The post Spring MVC: Failed to convert value of type ‘java.lang.String’ to required type ‘java.time.LocalDateTime’ appeared first on My Shitty Code.

Spring MVC: Handling Joda Data Types as JSON

Shitty Author — Sat, 28 Mar 2015 23:49:18 +0000

PROBLEM

Let’s assume we have the following bean that contains Joda’s LocalDate and LocalDateTime objects:-

public class MyBean {
    private LocalDate date;
    private LocalDateTime dateTime;

    public LocalDate getDate() {
        return date;
    }

    public void setDate(LocalDate date) {
        this.date = date;
    }

    public LocalDateTime getDateTime() {
        return dateTime;
    }

    public void setDateTime(LocalDateTime dateTime) {
        this.dateTime = dateTime;
    }
}

This simple Spring MVC rest controller creates this bean and returns the JSON data back to the client:-

@RequestMapping(value = "/joda", method = RequestMethod.GET)
public ResponseEntity joda() {
    MyBean myBean = new MyBean();
    myBean.setDate(LocalDate.now());
    myBean.setDateTime(LocalDateTime.now());

    return new ResponseEntity(myBean, HttpStatus.OK);
}

By default, the generated JSON looks like this:-

{
   "date":
   [
       2015,
       3,
       28
   ],
   "dateTime":
   [
       2015,
       3,
       28,
       18,
       12,
       58,
       992
   ]
}

How do we nicely format these values and still retain the correct data types (LocalDate and LocalDateTime) in MyBean instead of writing our custom formatter and store the values as String?

SOLUTION

First, add a dependency for jackson-datatype-joda.


    com.fasterxml.jackson.core
    jackson-core
    2.5.1


    com.fasterxml.jackson.core
    jackson-databind
    2.5.1


    com.fasterxml.jackson.core
    jackson-annotations
    2.5.1


    com.fasterxml.jackson.datatype
    jackson-datatype-joda
    2.5.1

Next, instruct MappingJackson2HttpMessageConverter to accept a custom ObjectMapper.

The generated JSON output now looks like this:-

{
   "date": "2015-03-28",
   "dateTime": "2015-03-28T18:11:16.348"
}

The post Spring MVC: Handling Joda Data Types as JSON appeared first on My Shitty Code.

Spring Security: Handling 403 Error Page

Shitty Author — Fri, 11 Apr 2014 14:58:31 +0000

If you are already using Spring, then you might want to use Spring Security to secure your web resources.

To do that, we specify the URI to be secured with tag:-

...

When users without role ROLE_TOPSECRET access /top-secrets/kfc-secret, they will see this default error page:-

This proves that Spring Security is doing its job. However, the default error page looks rather F.U.G.L.Y. Further, the error page may reveal too much information about the application server. The above error page shows the application runs on Jetty. If I’m a motherhacker, I would research all the possible vulnerabilities on this particular application server in attempt to hack it.

A better solution is to provide a friendly error page when the user access is denied. This can be done by specifying tag:-

...

Then, we create a simple error controller that returns the error page:-

@Controller
@RequestMapping(value = "/error")
public class ErrorController {
    @RequestMapping(value = "/access-denied", method = RequestMethod.GET)
    public String accessDenied() {
        return "error-access-denied";
    }
}

Now, the user will see this custom error page:-

This solution is better than the previous one. However, SiteMesh doesn’t have the opportunity to decorate this error page before it gets rendered.

To fix this, we can create a simple redirect to allow the request to make a full-round trip to the server so that SiteMesh can decorate the error page:-

@Controller
@RequestMapping(value = "/error")
public class ErrorController {
    @RequestMapping(value = "/router", method = RequestMethod.GET)
    public String errorRouter(@RequestParam("q") String resource) {
        return "redirect:/error/" + resource;
    }


    @RequestMapping(value = "/access-denied", method = RequestMethod.GET)
    public String accessDenied() {
        return "error-access-denied";
    }
}




Then, we tweak the Spring Security to use the error router URI:-

...




Now, the user will see this nice beautiful error page:-




The post Spring Security: Handling 403 Error Page appeared first on My Shitty Code.



Spring MVC: Centralizing Common Configurations using @ControllerAdvice
Shitty Author — Fri, 14 Mar 2014 17:45:53 +0000

Handling Exceptions using HandlerExceptionResolver



Once upon a time, Spring 2.0 introduced HandlerExceptionResolver to handle thrown exceptions. While this approach works, it is like throwing a big net to catch all types of fish. If we are only interested in catching piranhas and clownfish, this approach becomes a little tedious because we need to weed out the types of fish we don’t care.


@Controller
public class ErrorController implements HandlerExceptionResolver {

    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest,
                                         HttpServletResponse httpServletResponse,
                                         Object o,
                                         Exception e) {

        ModelAndView modelAndView = new ModelAndView("error");

        if (e instanceof PiranhaException) {
            // stir fry it
        }
        else if (e instanceof ClownfishException) {
            // make me laugh first
        }
        else {
            // don't care...
        }

        return modelAndView;
    }

    @RequestMapping(value = "/error", method = RequestMethod.GET)
    public String error() {
        return "error";
    }
}



Handling Exceptions using @ExceptionHandler



Then, Spring 3.0 introduced a more elegant way to handle exceptions using @ExceptionHandler. Now, we can easily catch the types of fish we need and handle accordingly.


@Controller
@RequestMapping(value = "/fish")
public class FishController {

    @ExceptionHandler(PiranhaException.class)
    public String piranhaException(Exception e) {
        // stir fry it
        return "error";
    }

    @ExceptionHandler(ClownfishException.class)
    public String clownfishException(Exception e) {
        // make me laugh first
        return "error";
    }

    @RequestMapping(method = RequestMethod.GET)
    public String home() {
        return "home";
    }
}



While this is a more elegant solution than the previous approach, @ExceptionHandler has to be defined within the Controller class. If we want to apply the same exception handling across multiple controllers, we either have to define @ExceptionHandler in every Controller class or create something “clever” such as extending a parent controller that contains the common configurations.



Handling Exceptions using @ControllerAdvice



Then, Spring 3.2 introduced an even better approach to centralize common configurations using @ControllerAdvice. Instead of defining @ExceptionHandler all over places or extending a parent controller, we can create a separate class that contains these common configurations and annotate it with @ControllerAdvice.


@ControllerAdvice
public class FishControllerAdvice {

    @ExceptionHandler(PiranhaException.class)
    public String piranhaException(Exception e) {
        // stir fry it
        return "error";
    }

    @ExceptionHandler(ClownfishException.class)
    public String clownfishException(Exception e) {
        // make me laugh first
        return "error";
    }
}



… and now, the controller will look as simple as this:-


@Controller
@RequestMapping(value = "/fish")
public class FishController {

    @RequestMapping(method = RequestMethod.GET)
    public String home() {
        return "home";
    }
}



In fact, @ControllerAdvice can be used to define @ExceptionHandler, @ModelAttribute and @InitBinder that apply to all @RequestMapping methods.



Here’s an example:-


@ControllerAdvice
public class MyAdviceToAllFish {

    @ExceptionHandler(PiranhaException.class)
    public String piranhaException(Exception e) {
        // stir fry it
        return "error";
    }

    @ExceptionHandler(ClownfishException.class)
    public String clownfishException(Exception e) {
        // make me laugh first
        return "error";
    }

    // Catch all other exceptions
    @ExceptionHandler(Exception.class)
    public String exception(Exception e) {
        // when shit happens
        return "error";
    }

    // Return a list of tech support emails
    @ModelAttribute("techSupportEmails")
    public List<String> getTechSupportEmails() {
        return Arrays.asList("generaltso@chicken.com", "bat@man.com");
    }

    // Handles `String` and Joda Time's `LocalDate` object
    @InitBinder
    private void initBinder(WebDataBinder binder) {
        // Trim string and set empty string as `null` value
        binder.registerCustomEditor(String.class, new StringTrimmerEditor(true));

        // Convert Joda Time's `LocalDate` object to text, vice versa
        binder.registerCustomEditor(LocalDate.class, new PropertyEditorSupport() {
            private final DateTimeFormatter pattern = DateTimeFormat.forPattern("MM/dd/yyyy");

            @Override
            public void setAsText(String text) throws IllegalArgumentException {
                setValue(StringUtils.isBlank(text) ? null : pattern.parseLocalDate(text));
            }

            @Override
            public String getAsText() throws IllegalArgumentException {
                LocalDate localDate = (LocalDate) getValue();
                return localDate != null ? pattern.print(localDate) : "";
            }
        });
    }
}
The post Spring MVC: Centralizing Common Configurations using @ControllerAdvice appeared first on My Shitty Code.



MockMvc : Circular view path [view]: would dispatch back to the current handler URL [/view] again
Shitty Author — Fri, 17 Jan 2014 12:13:19 +0000

PROBLEM



Let’s assume we want to test this controller:-


@Controller
@RequestMapping(value = "/help")
public class HelpController {

    @RequestMapping(method = RequestMethod.GET)
    public String main() {
        return "help";
    }
}



Here’s the test file:-


public class HelpControllerTest {

    private MockMvc mockMvc;

    @Before
    public void setup() {
        mockMvc = MockMvcBuilders.standaloneSetup(new HelpController()).build();
    }

    @Test
    public void main() throws Exception {
        mockMvc.perform(get("/help"))
                .andExpect(status().isOk())
                .andExpect(view().name("help"));
    }
}



When executing this test, we get the following error:-


javax.servlet.ServletException: Circular view path [help]: would dispatch
back to the current handler URL [/help] again. Check your ViewResolver
setup! (Hint: This may be the result of an unspecified view, due to default
view name generation.)
	at org.springframework.web.servlet.view.InternalResourceView.prepareForRendering(InternalResourceView.java:263)
	at org.springframework.web.servlet.view.InternalResourceView.renderMergedOutputModel(InternalResourceView.java:186)
	at org.springframework.web.servlet.view.AbstractView.render(AbstractView.java:266)



SOLUTION



The reason this is happening is because the uri “/help” matches the returned view name “help” and we didn’t set a ViewResolver when constructing the standalone MockMvc. Since MockMvcBuilders.standaloneSetup(...) doesn’t load Spring configuration, the Spring MVC configuration under WEB-INF/spring-servlet.xml will not get loaded too.



A typical WEB-INF/spring-servlet.xml looks something like this:-





    

    

    

    
        
        
    

    
        
    




To fix this, we need to defined a ViewResolver that mimics the configuration defined under WEB-INF/spring-servlet.xml in the test file:-


public class HelpControllerTest {

    private MockMvc mockMvc;

    @Before
    public void setup() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/jsp/view/");
        viewResolver.setSuffix(".jsp");

        mockMvc = MockMvcBuilders.standaloneSetup(new HelpController())
                                 .setViewResolvers(viewResolver)
                                 .build();
    }

    @Test
    public void main() throws Exception {
        mockMvc.perform(get("/help"))
                .andExpect(status().isOk())
                .andExpect(view().name("help"));
    }
}
The post MockMvc : Circular view path [view]: would dispatch back to the current handler URL [/view] again appeared first on My Shitty Code.

Spring MVC – My Shitty Code

Spring MVC: Failed to convert value of type ‘java.lang.String’ to required type ‘java.time.LocalDateTime’

PROBLEM

SOLUTION

Spring MVC: Handling Joda Data Types as JSON

PROBLEM

SOLUTION

Spring Security: Handling 403 Error Page

Spring MVC: Centralizing Common Configurations using @ControllerAdvice

Handling Exceptions using `HandlerExceptionResolver`

Handling Exceptions using `@ExceptionHandler`

Handling Exceptions using `@ControllerAdvice`

MockMvc : Circular view path [view]: would dispatch back to the current handler URL [/view] again

PROBLEM

SOLUTION