private void populateError (String field, Model model, BindingResult bindingResult) {
	if (bindingResult.hasFieldErrors(field)) {
		model.addAttribute(field + "Error", bindingResult.getFieldError(field)
				.getDefaultMessage());
	}
}

        

@RequestMapping("adicionaTarefa")
public String adiciona(@Valid Tarefa tarefa, BindingResult result) {

	if(result.hasFieldErrors("descricao")) {
		return "tarefa/formulario";
	}

	JdbcTarefaDao dao = new JdbcTarefaDao();
	dao.adiciona(tarefa);
	return "tarefa/adicionada";
}


        

if (bindingResult.hasErrors()) {
     // ignore field password
     if (!bindingResult.hasFieldErrors("password")) {
          // do something
     }
}

        

@RequestMapping(value = "/confirmarCadastro", method = RequestMethod.POST)
public String confirmarCadastro(@Valid Contato contato, BindingResult bindingResult, 
		RedirectAttributes redirectAttributes) {        

	if (bindingResult.hasFieldErrors()) {
		return "contatos/cadastro";
	}

	contatoService.save(contato);
	redirectAttributes.addFlashAttribute("mensagem", "Contato cadastrado com sucesso.");
	return "redirect:/contatos";
}

        

public void validate(Object target, Errors errors) { 
	ValidationUtils.rejectIfEmpty(errors, "username", "required", new Object[] { "Username" }); 
	ValidationUtils.rejectIfEmpty(errors, "password", "required", new Object[] { "Password" }); 
	ValidationUtils.rejectIfEmpty(errors, "emailAddress", "required", new Object[] { "Email address" }); 
	ValidationUtils.rejectIfEmpty(errors, "address.street", "required", new Object[] { "Street" }); 
	ValidationUtils.rejectIfEmpty(errors, "address.city", "required", new Object[] { "City" }); 
	ValidationUtils.rejectIfEmpty(errors, "address.country", "required", new Object[] { "Country" }); 

	if (!errors.hasFieldErrors("emailAddress")) { 
		Account account = (Account) target; 
		String email = account.getEmailAddress(); 
		if (!email.matches(EMAIL_PATTERN)) { 
			errors.rejectValue("emailAddress", "invalid"); 
		} 
	} 
}

        

@RequestMapping(value = "/produto/salvarProduto", method = RequestMethod.POST)
public String salvarProduto(@Valid Produto produto, BindingResult result, ModelMap model) {
    String mensagem = null;
    if (result.hasFieldErrors("nome") || result.hasFieldErrors("descricao") || result.hasFieldErrors("preco")) {
        mensagem = mensagensPadronizadas.erroAoCadastrarProduto;
        model.addAttribute("mensagemTitulo", mensagem);
        return "forward:/produto";
    } else {
        try {
            produtoService.salvarProduto(produto);
            mensagem = mensagensPadronizadas.produtoAdicionadoComSucesso;
        } catch (ValidationException e) {
            mensagem = e.getMessage();
        }
        model.addAttribute("mensagemTitulo", mensagem);
        return "forward:/produto";
    }
}

        

private ModelAndView processBindingResult(Exception exception, BindingResult bindingResult, HttpServletRequest request, HttpServletResponse response) throws IOException {
    if (request.getHeaders("X-Requested-With").hasMoreElements() && bindingResult.hasFieldErrors()) {
        //AJAX request;
        Map<String, List<String>> errorMap = validationManager.getErrorsAsMap(bindingResult);
        String content = validationManager.getMessageJSON(errorMap).toString();
        response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
        response.setContentLength(content.getBytes(Charset.forName(response.getCharacterEncoding())).length);
        response.getWriter().print(content);
        response.flushBuffer();
        return null;
    } else {
        //Non-AJAX request
        return MvcExceptionHandler.handle(exception, request, response);
    }
}

        

@Transactional
@RequestMapping("/save/{action}")
public ModelAndView save(@PathVariable String action, @Valid Curso curso, BindingResult bind) {
    Message msg = null;
    if (bind.hasFieldErrors()) {
        msg = new Message(MessageType.ERROR, "Curso informado é inválido para esta operação!");
    } else if ("add".equals(action)) {
        cursoJpaDAO.create(curso);
        msg = new Message(MessageType.INFO, "Curso incluido com sucesso!");
    } else if ("edit".equals(action)) {
        cursoJpaDAO.update(curso);
        msg = new Message(MessageType.INFO, "Curso alterado com sucesso!");
    } else if ("delete".equals(action)) {
        cursoJpaDAO.delete(curso);
        msg = new Message(MessageType.INFO, "Curso excluido com sucesso!");
    } else {
        msg = new Message(MessageType.ERROR, "Operação Inválida!");
    }
    ModelAndView mv = new ModelAndView("common/message");
    mv.addObject("msg", msg);
    mv.addObject("back", "/cursos/list");
    return mv;
}

        

public ResultMatcher attributeHasFieldErrorCode(final String name, final String fieldName, final String error) {
    return new ResultMatcher() {

        public void match(MvcResult mvcResult) throws Exception {
            ModelAndView mav = getModelAndView(mvcResult);
            BindingResult result = getBindingResult(mav, name);
            assertTrue("No errors for attribute: [" + name + "]", result.hasErrors());
            boolean hasFieldErrors = result.hasFieldErrors(fieldName);
            assertTrue("No errors for field: [" + fieldName + "] of attribute [" + name + "]", hasFieldErrors);
            String code = result.getFieldError(fieldName).getCode();
            assertTrue("Expected error code '" + error + "' but got '" + code + "'", code.equals(error));
        }
    };
}

        

@RequestMapping(value = "/add/link", method = POST)
public String createLinkPost(@Valid PostDTO postDTO, BindingResult result,
                             CurrentUser currentUser, RedirectAttributes attributes, Model model,
                             HttpServletRequest request) throws DuplicatePostNameException {
    PagePreviewDTO pagePreview =
            (PagePreviewDTO) WebUtils.getSessionAttribute(request, "pagePreview");

    model.addAttribute("postheader", webUI.getMessage(ADD_LINK_HEADER));
    model.addAttribute("postFormType", "link");

    if (!isDuplicatePost(postDTO, null)) {
        if (result.hasErrors()) {
            model.addAttribute("hasLink", true);
            model.addAttribute("hasCarousel", true);
            model.addAttribute("pagePreview", pagePreview);
            if (result.hasFieldErrors("postTitle")) {
                postDTO.setPostTitle(pagePreview.getTitle());
            }
            model.addAttribute("postDTO", postDTO);
            return ADMIN_LINK_ADD_VIEW;
        } else {

            if (postDTO.getHasImages()) {
                if (postDTO.getDisplayType() != PostDisplayType.LINK) {
                    postDTO.setPostImage(
                            pagePreview.getImages().get(postDTO.getImageIndex()).src);
                } else
                    postDTO.setPostImage(null);
            }

            postDTO.setPostSource(PostUtils.createPostSource(postDTO.getPostLink()));
            postDTO.setPostName(PostUtils.createSlug(postDTO.getPostTitle()));
            postDTO.setUserId(currentUser.getId());
            postDTO.setPostContent(cleanContentTailHtml(postDTO.getPostContent()));

            request.setAttribute("postTitle", postDTO.getPostTitle());
            Post post = postService.add(postDTO);

            postDTO.setPostId(post.getPostId());
            post.setPostMeta(jsoupService.createPostMeta(postDTO));

            // All links are saved as PUBLISHED so no _isPublished_ status check on new Links
            if (applicationSettings.getSolrEnabled())
                postDocService.addToIndex(post);

            // Links are included in Posts A-to-Z Listing
            fmService.createPostAtoZs();

            webUI.addFeedbackMessage(attributes, FEEDBACK_POST_LINK_ADDED);
            return "redirect:/admin/posts";
        }
    } else {
        result.reject("global.error.post.name.exists", new Object[]{postDTO.getPostTitle()}, "post name exists");
        model.addAttribute("hasLink", true);
        model.addAttribute("hasCarousel", true);
        model.addAttribute("pagePreview", pagePreview);
        return ADMIN_LINK_ADD_VIEW;
    }
}