¿Puede Spring mvc recortar todas las cuerdas obtenidas de las formas?

Question

Sé que la configuración predeterminada de struts2 recortará todas las cadenas obtenidas de los formularios.

Por ejemplo:

tipo I

" whatever "

en un formulario y enviarlo, voy a tener

"whatever"

La cadena ha sido recortado de auto

¿Tiene MVC primavera tiene esta función también? GRACIAS.

Answer 1

utilizando Spring 3.2 o superior:

@ControllerAdvice 
public class ControllerSetup 
{ 
    @InitBinder 
    public void initBinder (WebDataBinder binder) 
    { 
     StringTrimmerEditor stringtrimmer = new StringTrimmerEditor(true); 
     binder.registerCustomEditor(String.class, stringtrimmer); 
    } 
} 

Prueba con un contexto de prueba MVC:

@RunWith(SpringJUnit4ClassRunner.class) 
@WebAppConfiguration 
@ContextConfiguration 
public class ControllerSetupTest 
{ 
    @Autowired 
    private WebApplicationContext wac; 
    private MockMvc     mockMvc; 

    @Before 
    public void setup () 
    { 
     this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build(); 
    } 

    @Test 
    public void stringFormatting () throws Exception 
    { 
     MockHttpServletRequestBuilder post = post("/test"); 
     // this should be trimmed, but only start and end of string 
     post.param("test", "  Hallo Welt "); 
     ResultActions result = mockMvc.perform(post); 
     result.andExpect(view().name("Hallo Welt")); 
    } 

    @Configuration 
    @EnableWebMvc 
    static class Config 
    { 
     @Bean 
     TestController testController () 
     { 
      return new TestController(); 
     } 

     @Bean 
     ControllerSetup controllerSetup () 
     { 
      return new ControllerSetup(); 
     } 
    } 
} 

/** 
* we are testing trimming of strings with it. 
* 
* @author janning 
* 
*/ 
@Controller 
class TestController 
{ 
    @RequestMapping("/test") 
    public String test (String test) 
    { 
     return test; 
    } 
} 

y - como se le preguntó por LppEdd - que funciona con contraseñas demasiado como en el lado del servidor no hay diferencia entre la entrada [tipo = contraseña] y la entrada [tipo = texto]

Answer 2

Puede usuario una propiedad Primavera-MVC Interceptor

public class TrimInterceptor extends HandlerInterceptorAdapter { 

    @Override 
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
     Enumeration<String> e = request.getParameterNames(); 
     while(e.hasMoreElements()) { 
      String parameterName = e.nextElement(); 

      request.setParameter(parameterName, request.getParameter(parameterName).trim()); 
     } 

     return true; 
    } 

y configurar su interceptores HandlerMapping

<bean id="interceptorTrim" class="br.com.view.interceptor.TrimInterceptor"/> 
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" p:interceptors-ref="interceptorTrim"/> 
} 

O utilizar un filtro de servlet

Answer 3

registro de este editor de la propiedad: org.springframework.beans.propertyeditors.StringTrimmerEditor

E jemplo para AnnotionHandlerAdapter:

<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> 
    ... 
    <property name="webBindingInitializer"> 
    <bean class="org.springframework.web.bind.support.ConfigurableWebBindingInitializer"> 
     <property name="propertyEditorRegistrar"> 
     <bean class="org.springframework.beans.propertyeditors.StringTrimmerEditor" /> 
     </property> 
    </bean> 
    </property> 
    ... 
</bean> 

Answer 4

También puede usar el servicio de conversión de Spring, que tiene el beneficio adicional de trabajar con <mvc:annotation-driven/> y con Spring Webflow. Al igual que con las otras respuestas, la principal desventaja es que se trata de un cambio global y no se puede desactivar para ciertas formas.

Usted necesitará un convertidor para hacer el recorte

public class StringTrimmingConverter implements Converter<String, String> { 

    @Override 
    public String convert(String source) { 
     return source.trim(); 
    } 

} 

a continuación, definir un servicio de conversión que se sabe acerca de su convertidor.

<bean id="applicationConversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean"> 
    <property name="converters"> 
    <list> 
     <bean class="mypackage.util.StringTrimmingConverter"/> 
    </list> 
    </property> 
</bean> 

y añada eso a mvc.

<mvc:annotation-driven conversion-service="applicationConversionService"/> 

Si utiliza primavera Webflow entonces se requiere un envoltorio

<bean id="defaultConversionService" class="org.springframework.binding.convert.service.DefaultConversionService"> 
    <constructor-arg ref="applicationConversionService"/> 
</bean> 

y un ajuste en su constructor flujo

<flow:flow-builder-services id="flowBuilderServices" conversion-service="defaultConversionService" development="true" validator="validator" />