ProxyingHandlerMethodArgumentResolver interfering with data binding - spring

Question

I have a web handler working with validation. When I add data-jpa dependencies, the validations stop working.
The problem is with the ProxyingHandlerMethodArgumentResolver. The data-jpa starter adds the resolver to the head of the resolver list and again later in the list. A proxy is created that does not update the model attribute object referenced in the model attribute annotation on the parameter.
My solution is to remove the resolver from the head of the resolver list, but keep it later in the list. The resolver can still be referenced, but after my custom resolvers.
I assume that this solution will cause problems later when I use more features from data-jpa. Can you suggest another way to get the original code working?
Details:
The following code works before adding the data-dependencies. I use an interface for the model attribute. As I understand, the model attribute parameter is used to bind to a model property with that name, if it exists, and create a new instance if the name does not exist in the model. Since "dataBad" is in the model, I do not expect the data binding to create a new instance, so I am able to use an interface.
#Controller
#RequestMapping("/ControllerBad")
#SessionAttributes("dataBad")
public class ControllerBad {
#ModelAttribute("dataBad")
public RequestDataRequired modelData() {
return new RequestDataRequiredSingle();
}
#PostMapping(params="confirmButton")
public String confirmMethod(
#Valid #ModelAttribute("dataBad") RequestDataRequired dataBad,
BindingResult errors
)
{
if (errors.hasErrors()) {
return "edit";
}
return "redirect:ControllerBad?confirmButton=Confirm";
}
This worked correctly. The request parameters were copied into the model attribute "dataBad".
Next, I wanted to add persistence, so I added spring-boot-starter-data-jpa and mysql-connector-java to the pom file
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
I added properties for the database to application properties
spring.datasource.url=jdbc:mysql://localhost:3306/baz
spring.datasource.username=foo
spring.datasource.password=bar
I have not created any entity classes. I have the class that binds to the form, but I have not added the annotations for an entity. At this point, I just want to get the data from the form into my bean that is in the model. Here is the interface for the form data object.
public interface RequestDataRequired {
#NotNull(message = "cannot be empty")
#Pattern(regexp = "(?i)red|green|blue",
message = "must be red, green, or blue")
public String getColor();
public void setColor(String color);
}
Nothing else was changed. When I ran the new version the validation failed, because the color property was null.
If I use an implementation of the interface, then it works. I would like to make it work with an interface, as the name of the implementation class would appear in may locations in the controller, not just in the model attribute method.
#Valid #ModelAttribute("dataBad") RequestDataRequiredSingle dataBad
I can get it working with a session attribute interface and a model attribute interface, but this entails duplicate work for copying request parameters and errors.
#PostMapping(params="confirmSessionModelButton")
public String confirmSessionModelMethod(
Model model,
#SessionAttribute RequestDataRequired dataBad,
#Valid #ModelAttribute RequestDataRequired dataModel,
BindingResult errors
)
{
BeanUtils.copyProperties(dataModel, dataBad);
if (errors.hasErrors()) {
model.addAttribute(BindingResult.class.getName() + ".dataBad", errors);
return viewLocation("edit");
}
return "redirect:ControllerBad?confirmButton=Confirm";
}
After some experimenting, I found that data-jpa added four new argument
resolvers. The ProxyingHandlerMethodArgumentResolver was included twice: once at the head of the resolver list and again after my own custom resolvers.
A proxy object is created for an interface and the request parameters are copied into the proxy. The proxy will not update the model attribute object referenced in the model attribute annotation on the parameter. The proxied object is available in the request handler with the request data, but the session attribute is not updated.
Since the proxying resolver is first in the list, any custom resolvers are not called.
If I remove the proxying resolver from the head of the argument resolver list, but leave it later in the list, I can get the code running as it did before.
public class WebConfig implements WebMvcConfigurer {
#Autowired
private RequestMappingHandlerAdapter requestMappingHandlerAdapter;
#PostConstruct
public void init() {
List<HandlerMethodArgumentResolver> argumentResolvers =
requestMappingHandlerAdapter.getArgumentResolvers();
List<HandlerMethodArgumentResolver> newList = argumentResolvers.subList(1, argumentResolvers.size());
requestMappingHandlerAdapter.setArgumentResolvers(newList);
}
}
I am content with this solution for now but I assume that I will break something in the data-jpa that I will need later on.
Can anyone suggest a different way to get the former behavior of updating the model attribute with the request data and only creating a new instance of the model attribute when it is not already in the model?

Answer 1

I have found a simple solution for the problem. Data-jpa uses projections that create proxies for interfaces, and that is the problem I have. However,
data-jpa also supports DTOs, which are classes that look like the interface.
#Component
public class RequestDataRequiredDTO implements RequestDataRequired {
private String color;
#Override
public String getColor() {
return color;
}
#Override
public void setColor(String color) {
this.color = color;
}
}
I have to do two things. First I have to use a reference to the DTO in the model attribute parameter and data-jpa will project into it without using a proxy. I still use the normal interface everywhere else, I even extended the DTO from the interface.
#PostMapping(params="confirmButton")
public String confirmMethod(
#Valid #ModelAttribute("dataBad") RequestDataRequiredDTO dataBad,
BindingResult errors
)
{
if (errors.hasErrors()) {
return viewLocation("edit");
}
return "redirect:ControllerBad?confirmButton=Confirm";
}
Second, I have to define a converter from the actual class in the model to the DTO type.
#Component
public class ClassToDTOConverter
implements Converter<RequestDataRequiredSingle, RequestDataRequiredDTO> {
#Override
public RequestDataRequiredDTO convert(RequestDataRequiredSingle source) {
RequestDataRequiredDTO target = new RequestDataRequiredDTO();
target.setColor(source.getColor());
return target;
}
}