We Keep Coding

405 Method not allowed in Spring Boot and Ajax

Hi I am having request mapping like this
#RequestMapping(value = "/pendodnp/{visitorId}/{content}")
public ResponseEntity<Object> setPendoDNP(#PathVariable String visitorId, #PathVariable String content, final HttpSession session, final HttpServletRequest request) throws PendoException {
LOGGER.info("### pendodnp");
_splitService.updateDNP(visitorId, content);
return ResponseEntity.ok().body(content);
}
but when I hit this URL from an angular function, it gives "405 method not allowed" error.
$http.get("pendodnp/"+visitorId+"/"+dnpValue, JSON.stringify(dnpValue))
.success(function(response) {
Here is screenshot of how the request is going, can someone tell me what i am missing here?

You haven't specified which HTTP method (GET, POST, PUT, DELETE, etc) the mapping should handle. To do that either use #GetMapping or change your #RequestMapping so it includes the method parameter.
#GetMapping("/pendodnp/{visitorId}/{content}")
Or
import static org.springframework.web.bind.annotation.RequestMethod.GET;
...
#RequestMapping(method = GET, path = "/pendodnp/{visitorId}/{content}")
Using #RequestMapping without a method parameter is usually only done at the class level, not individual methods. #GetMapping (or #PostMapping, #PutMapping, etc) are more common on controller methods.

how handler mapping works in spring mvc

I am new to spring mvc. I am debugging a mvc code as given below
#Controller
#RequestMapping("/register")
public class RegisterController extends BroadleafRegisterController {
#RequestMapping(method=RequestMethod.GET)
public String register(HttpServletRequest request, HttpServletResponse response, Model model,
#ModelAttribute("registrationForm") RegisterCustomerForm registerCustomerForm) {
return super.register(registerCustomerForm, request, response, model);
}
#RequestMapping(method=RequestMethod.POST)
public String processRegister(HttpServletRequest request, HttpServletResponse response, Model model,
#ModelAttribute("registrationForm") RegisterCustomerForm registerCustomerForm, BindingResult errors) throws ServiceException, PricingException {
return super.processRegister(registerCustomerForm, errors, request, response, model);
}
#ModelAttribute("registrationForm")
public RegisterCustomerForm initCustomerRegistrationForm() {
return super.initCustomerRegistrationForm();
}
}
above is a spring handler class. for /register request i was thinking regsister() method should called but before this method inintcustomerRegisterationForm() is called i do not know why and how this method is called. I searched this in google but not find any useful information. I think this is like a interceptor method as in struts2. Please tell us how this method is called
Thanks

The initCustomerRegistrationForm() is being called because it is the 'model' of your controller. The model is typically always need for a get and post request for a specific form and represents the data entered into the form.
If you want your form pre-populated with some data, then you would add that data to the 'model'. The 'model' is also what is submitted to the post request then submitting a form.

According to spring documentation
#ModelAttribute methods are used to populate the model with commonly needed attributes for example to fill a drop-down with states or with pet types, or to retrieve a command object like Account in order to use it to represent the data on an HTML form.
A controller can have any number of #ModelAttribute methods. All such methods are invoked before #RequestMapping methods of the same controller.
Which explains why the initCustomerRegistrationForm() method is called before request mapping methods.

Get hash parameters in request URL in spring controller

Suppose I have a URL like:
../search/?p1=value1&p2=value2#h1=value1&h2=value2
In a Spring controller, I can get the values of the parameters p1 and p2, using the controller method below...
#RequestMapping(value = "/search", method = RequestMethod.GET)
public ModelAndView searchSC(HttpServletRequest request,
HttpServletResponse response, #RequestParam String p1, #RequestParam String p2){
// my controller code
}
What is the best way to get the hashParam values h1 and h2 in the controller?

You can't because fragments should not be, and typically are not, sent to the server. They are a client side concept. They are meaningless to a server as they do not identify a resource, they identify a subcomponent of the resource.

Understanding the use of #ModelAttribute and #RequestAttribute annotations in Spring MVC

I am pretty new in Spring MVC. Currently I am studying the Spring MVC Showcase, that demonstrates the features of the Spring MVC web framework.
I have some problem to understand how Custom Resolvable Web Arguments are handled in this example.
In practice I have the following situation. In my home.jsp view I have the following link:
<a id="customArg" class="textLink" href="<c:url value="/data/custom" />">Custom</a>
This link generate an HTTP Request towards the URL: "/data/custom"
The controller class that contain the method that handles this request have the following code:
#Controller
public class CustomArgumentController {
#ModelAttribute
void beforeInvokingHandlerMethod(HttpServletRequest request) {
request.setAttribute("foo", "bar");
}
#RequestMapping(value="/data/custom", method=RequestMethod.GET)
public #ResponseBody String custom(#RequestAttribute("foo") String foo) {
return "Got 'foo' request attribute value '" + foo + "'";
}
}
The method that handles this HTTP Request is custom(). So when the previous link is clicked, the HTTP Request is handled by the custom method.
I have some problem to understand what exactly does the #RequestAttribute annotation do. I think that, in this case, it binds the request attribute named foo to a new String foo variable. But where this attribute is taken from? Is this variable taken by Spring?
OK, my idea is that this request attribute is taken from a HttpServletRequest object. I think so because, in this class, I also have the beforeInvokingHandlerMethod() method that have a speaking name, so it seems that this method sets an attribute, that have name=foo and value=bar, inside an HttpServletRequest object, and then so the custom() method can use this value.
In fact my output is:
Got 'foo' request attribute value 'bar'
Why the beforeInvokingHandlerMethod() is called before the custom() method?
And why the beforeInvokingHandlerMethod() is annotated by #ModelAttribute annotation? What does it mean in this case?

The RequestAttribute is nothing but the parameters which you have passed in the form submission. Lets understand with a sample example
Suppose I have the below form
<form action="...">
<input type=hidden name=param1 id=param1 value=test/>
</form>
Now, if I have the below controller which is mapped with the request url which is mapped with the form submission as below.
#Controller
public class CustomArgumentController {
#ModelAttribute
void beforeInvokingHandlerMethod(HttpServletRequest request) {
request.setAttribute("foo", "bar");
}
#RequestMapping(value="/data/custom", method=RequestMethod.GET)
public #ResponseBody String custom(#RequestAttribute("param1") String param1 ) {
// Here, I will have value of param1 as test in String object which will be mapped my Spring itself
}

Spring - Redirect after POST (even with validation errors)

I'm trying to figure out how to "preserve" the BindingResult so it can be used in a subsequent GET via the Spring <form:errors> tag. The reason I want to do this is because of Google App Engine's SSL limitations. I have a form which is displayed via HTTP and the post is to an HTTPS URL. If I only forward rather than redirect then the user would see the https://whatever.appspot.com/my/form URL. I'm trying to avoid this. Any ideas how to approach this?
Below is what I'd like to do, but I only see validation errors when I use return "create".
#RequestMapping(value = "/submit", method = RequestMethod.POST)
public final String submit(
#ModelAttribute("register") #Valid final Register register,
final BindingResult binding) {
if (binding.hasErrors()) {
return "redirect:/register/create";
}
return "redirect:/register/success";
}

Since Spring 3.1 you can use RedirectAttributes. Add the attributes that you want to have available before doing the redirect. Add both, the BindingResult and the object that you are using to validate, in this case Register.
For BindingResult you will use the name: "org.springframework.validation.BindingResult.[name of your ModelAttribute]".
For the object that you are using to validate you will use the name of ModelAttribute.
To use RedirectAttributes you have to add this in your config file. Among other things you are telling to Spring to use some newer classes:
<mvc:annotation-driven />
Now the errors will be displayed wherever you are redirecting
#RequestMapping(value = "/submit", method = RequestMethod.POST)
public final String submit(#ModelAttribute("register") #Valid final Register register, final BindingResult binding, RedirectAttributes attr, HttpSession session) {
if (binding.hasErrors()) {
attr.addFlashAttribute("org.springframework.validation.BindingResult.register", binding);
attr.addFlashAttribute("register", register);
return "redirect:/register/create";
}
return "redirect:/register/success";
}

In addition to Oscar's nice answer, if you are following that RedirectAttributes approach, do not forget that you are actually passing the modelAttribute to the redirected page. This means if you create a new instance of that modelAttribute for the redirected page (in a controller), you will lose the validation errors. So, if your POST controller method is something like this:
#RequestMapping(value = "/submit", method = RequestMethod.POST)
public final String submit(#ModelAttribute("register") #Valid final Register register, final BindingResult binding, RedirectAttributes attr, HttpSession session) {
if (binding.hasErrors()) {
attr.addFlashAttribute("org.springframework.validation.BindingResult.register", binding);
attr.addFlashAttribute("register", register);
return "redirect:/register/create";
}
return "redirect:/register/success";
}
Then you will probably need to do a modification in your register create page GET controller. From this:
#RequestMapping(value = "/register/create", method = RequestMethod.GET)
public String registerCreatePage(Model model) {
// some stuff
model.addAttribute("register", new Register());
// some more stuff
}
to
#RequestMapping(value = "/register/create", method = RequestMethod.GET)
public String registerCreatePage(Model model) {
// some stuff
if (!model.containsAttribute("register")) {
model.addAttribute("register", new Register());
}
// some more stuff
}
Source: http://gerrydevstory.com/2013/07/11/preserving-validation-error-messages-on-spring-mvc-form-post-redirect-get/

I would question why you need the redirect. Why not just submit to the same URL and have it respond differently to a POST? Nevertheless, if you really want to do this:
#RequestMapping(value = "/submit", method = RequestMethod.POST)
public final String submit(
#ModelAttribute("register") #Valid final Register register,
final BindingResult binding,
HttpSession session) {
if (binding.hasErrors()) {
session.setAttribute("register",register);
session.setAttribute("binding",binding);
return "redirect:/register/create";
}
return "redirect:/register/success";
}
Then in your "create" method:
model.put("register",session.getAttribute("register"));
model.put("org.springframework.validation.BindingResult.register",session.getAttribute("register"));

The problem is you're redirecting to a new controller, rather than rendering the view and returning the processed form page. You need to do something along the lines of:
String FORM_VIEW = wherever_your_form_page_resides
...
if (binding.hasErrors())
return FORM_VIEW;
I would keep the paths outside of any methods due to code duplication of strings.

The only way to persist objects between requests (ie a redirect) is to store the object in a session attribute. So you would include "HttpServletRequest request" in method parameters for both methods (ie, get and post) and retrieve the object via request.getAttribute("binding"). That said, and having not tried it myself you may need to figure out how to re-bind the binding to the object in the new request.
Another "un-nicer" way is to just change the browser URL using javascript

I don't know the exact issue with Google App Engine but using the ForwardedHeaderFilter may help to preserve the original scheme that the client used. This filter was added in Spring Framework 4.3 but some Servlet containers provide similar filters and the filter is self-sufficient so you can also just grab the source if needed.

Perhaps this is a bit simplistic, but have you tried adding it to your Model? I.e., include the Model in your method's arguments, then add the BindingResult to it, which is then available in your view.
model.addAttribute("binding",binding);
I think you may have to use a forward rather than a redirect (in my head I can't remember if a redirect loses the session or not — I could be wrong about this as I don't have any documentation handy, i.e., if you're not getting the BindingResult after adding it to the Model, try using a forward instead to confirm this).