Springmvc框架--使用自定义编辑器来实现日期格式的转换

需求：使用自定义编辑器的方式来实现日期格式的转换

添加一个BaseController.java

package cn.smbms.controller;

import java.sql.Date;
import java.text.SimpleDateFormat;

import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;

public class BaseController {
	@InitBinder
	public void initBinder(WebDataBinder dataBinder){
	   System.out.println("initBinder==================");
	   dataBinder.registerCustomEditor(Date.class,  new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), true));
	}
}　





让UserController.java继承BaseController

package cn.smbms.controller;

import java.io.File;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.validation.Valid;

import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang.math.RandomUtils;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.mysql.jdbc.StringUtils;

import cn.smbms.pojo.Role;
import cn.smbms.pojo.User;
import cn.smbms.service.role.RoleService;
import cn.smbms.service.user.UserService;
import cn.smbms.tools.Constants;
import cn.smbms.tools.PageSupport;

@Controller
@RequestMapping("/user")
public class UserController extends BaseController{
    private Logger logger = Logger.getLogger(UserController.class);

    @Resource
    private UserService userService;
    @Resource
    private RoleService roleService;

    @RequestMapping(value = "/login.html")
    public String login() {
        logger.debug("UserController welcome SMBMS==================");
        return "login";
    }

    @RequestMapping(value = "/dologin.html", method = RequestMethod.POST)
    public String doLogin(@RequestParam String userCode,
            @RequestParam String userPassword, HttpServletRequest request,
            HttpSession session) {
        logger.debug("doLogin====================================");
        // 调用service方法，进行用户匹配
        User user = userService.login(userCode, userPassword);
        if (null != user) {// 登录成功
            // 放入session
            session.setAttribute(Constants.USER_SESSION, user);
            // 页面跳转（frame.jsp）
            return "redirect:/user/main.html";
            // response.sendRedirect("jsp/frame.jsp");
        } else {
            // 页面跳转（login.jsp）带出提示信息--转发
            request.setAttribute("error", "用户名或密码不正确");
            return "login";
        }
    }

    @RequestMapping(value = "/main.html")
    public String main(HttpSession session) {
        if (session.getAttribute(Constants.USER_SESSION) == null) {
            return "redirect:/user/login.html";
        }
        return "frame";
    }

    @RequestMapping(value = "/logout.html")
    public String logout(HttpSession session) {
        // 清除session
        session.removeAttribute(Constants.USER_SESSION);
        return "login";
    }

    @RequestMapping(value = "/exlogin.html", method = RequestMethod.GET)
    public String exLogin(@RequestParam String userCode,
            @RequestParam String userPassword) {
        logger.debug("exLogin====================================");
        // 调用service方法，进行用户匹配
        User user = userService.login(userCode, userPassword);
        if (null == user) {// 登录失败
            throw new RuntimeException("用户名或者密码不正确！");
        }
        return "redirect:/user/main.html";
    }

    /*
     * @ExceptionHandler(value={RuntimeException.class}) public String
     * handlerException(RuntimeException e,HttpServletRequest req){
     * req.setAttribute("e", e); return "error"; }
     */

    @RequestMapping(value = "/userlist.html")
    public String getUserList(
            Model model,
            @RequestParam(value = "queryname", required = false) String queryUserName,
            @RequestParam(value = "queryUserRole", required = false) String queryUserRole,
            @RequestParam(value = "pageIndex", required = false) String pageIndex) {
        logger.info("getUserList ---- > queryUserName: " + queryUserName);
        logger.info("getUserList ---- > queryUserRole: " + queryUserRole);
        logger.info("getUserList ---- > pageIndex: " + pageIndex);
        int _queryUserRole = 0;
        List<User> userList = null;
        // 设置页面容量
        int pageSize = Constants.pageSize;
        // 当前页码
        int currentPageNo = 1;

        if (queryUserName == null) {
            queryUserName = "";
        }
        if (queryUserRole != null && !queryUserRole.equals("")) {
            _queryUserRole = Integer.parseInt(queryUserRole);
        }

        if (pageIndex != null) {
            try {
                currentPageNo = Integer.valueOf(pageIndex);
            } catch (NumberFormatException e) {
                return "redirect:/user/syserror.html";
                // response.sendRedirect("syserror.jsp");
            }
        }
        // 总数量（表）
        int totalCount = userService
                .getUserCount(queryUserName, _queryUserRole);
        // 总页数
        PageSupport pages = new PageSupport();
        pages.setCurrentPageNo(currentPageNo);
        pages.setPageSize(pageSize);
        pages.setTotalCount(totalCount);
        int totalPageCount = pages.getTotalPageCount();
        // 控制首页和尾页
        if (currentPageNo < 1) {
            currentPageNo = 1;
        } else if (currentPageNo > totalPageCount) {
            currentPageNo = totalPageCount;
        }
        userList = userService.getUserList(queryUserName, _queryUserRole,
                currentPageNo, pageSize);
        model.addAttribute("userList", userList);
        List<Role> roleList = null;
        roleList = roleService.getRoleList();
        model.addAttribute("roleList", roleList);
        model.addAttribute("queryUserName", queryUserName);
        model.addAttribute("queryUserRole", queryUserRole);
        model.addAttribute("totalPageCount", totalPageCount);
        model.addAttribute("totalCount", totalCount);
        model.addAttribute("currentPageNo", currentPageNo);
        return "userlist";
    }

    @RequestMapping(value = "/syserror.html")
    public String sysError() {
        return "syserror";
    }

    @RequestMapping(value = "/useradd.html", method = RequestMethod.GET)
    public String addUser(@ModelAttribute("user") User user) {
        return "useradd";
    }

    /*
     * @RequestMapping(value="/useradd.html",method=RequestMethod.GET) public
     * String addUser(User user,Model model){ model.addAttribute("user", user);
     * return "useradd"; }
     */
    // 其中request对象主要用来存放错误信息，便于前台获取进行相应的提示,现在是多文件上传
    @RequestMapping(value = "/useraddsave.html", method = RequestMethod.POST)
    public String addUserSave(
            User user,
            HttpSession session,
            HttpServletRequest request,
            @RequestParam(value = "attachs", required = false) MultipartFile[] attachs) {
        // 编写文件上传的代码
        // 1.判断上传的文件是否为空
        String idPicPath = null;
        String workPicPath = null;
        String errorInfo = null;// 定义统一的错误信息提示
        boolean flag = true;
        String path = request.getSession().getServletContext()
                .getRealPath("statics" + File.separator + "uploadfiles");
        logger.info("uploadFile path ============== > " + path);

        // 现在传过来的是多文件，使用的是数组，要进行循环遍历
        for (int i = 0; i < attachs.length; i++) {
            MultipartFile attach = attachs[i];
            // 如果上传的文件不为空 与系统有关的默认名称分隔符。此字段被初始化为包含系统属性 file.separator 的值的第一个字符。在
            // UNIX 系统上，此字段的值为 '/'；在 Microsoft Windows 系统上，它为 '\'。
            if (i == 0) {
                errorInfo = "uploadFileError";
            } else if (i == 1) {
                errorInfo = "uploadwpFileError";
            }

            String oldFileName = attach.getOriginalFilename();// 原来你存在电脑盘符的文件名
            logger.info("原来的文件名 ============== > " + oldFileName);
            String prefix = FilenameUtils.getExtension(oldFileName);
            logger.info("上传文件的后缀：" + prefix);
            int filesize = 500000;// 表示文件大小是500k
            if (!attach.isEmpty()) {
                if (attach.getSize() > filesize) {
                    request.setAttribute("errorInfo", "上传的文件大小不得超过500k");
                    flag = false;
                    // 判断文件的上传文件的格式
                } else if (prefix.equalsIgnoreCase("jpg")
                        || prefix.equalsIgnoreCase("png")
                        || prefix.equalsIgnoreCase("pneg")) {
                    String fileName = System.currentTimeMillis()
                            + RandomUtils.nextInt(10000000) + "Personal.jpg";
                    logger.debug("new fileName======== " + attach.getName());
                    File targetFile = new File(path, fileName);
                    logger.info("上传到服务器的文件名是：" + targetFile.toString());
                    // 如果服务器的文件路径存在的话，就进行创建
                    if (!targetFile.exists()) {
                        /*
                         * mkdirs()可以建立多级文件夹， mkdir()只会建立一级的文件夹， 如下：
                         * new File("/tmp/one/two/three").mkdirs();
                         * 执行后， 会建立tmp/one/two/three四级目录
                         * new File("/tmp/one/two/three").mkdir();
                         * 则不会建立任何目录， 因为找不到/tmp/one/two目录， 结果返回false
                         */
                        targetFile.mkdirs();
                    }
                    try {
                        attach.transferTo(targetFile);
                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                        request.setAttribute("errorInfo", "上传文件失败");
                        flag = false;
                    }
                    // 文件路径
                    if (i == 0) {
                        idPicPath = path + File.separator + fileName;
                    } else if (i == 1) {
                        workPicPath = path + File.separator + fileName;
                    }
                    logger.debug("idPicPath: " + idPicPath);
                    logger.debug("workPicPath: " + workPicPath);
                } else {
                    request.setAttribute("errorInfo", " * 上传图片格式不正确");
                    flag = false;
                }
            }
        }

        if (flag) {
            user.setCreatedBy(((User) session
                    .getAttribute(Constants.USER_SESSION)).getId());
            user.setCreationDate(new Date());
            user.setIdPicPath(idPicPath);
            user.setWorkPicPath(workPicPath);
            if (userService.add(user)) {
                return "redirect:/user/userlist.html";
            }
        }
        return "useradd";
    }

    // 练习
    @RequestMapping(value = "/add.html", method = RequestMethod.GET)
    public String add(@ModelAttribute("user") User user) {
        return "user/useradd";
    }

    // 添加相应的保存方法
    @RequestMapping(value = "/add.html", method = RequestMethod.POST)
    // 添加相应的注解，调用验证框架，如果发现错误，会将错误保存在紧挨着的对象中bindingResult 或者是对应的error对象中
    public String addSave(@Valid User user, BindingResult bindingResult,
            HttpSession session) {
        // 对bindingResult对象进行验证
        if (bindingResult.hasErrors()) {
            logger.debug("数据验证的时候发生错误");
            return "user/useradd";
        }
        user.setCreatedBy(((User) session.getAttribute(Constants.USER_SESSION))
                .getId());
        user.setCreationDate(new Date());
        if (userService.add(user)) {
            return "redirect:/user/userlist.html";
        }
        return "user/useradd";
    }

    // 根据用户id获取用户信息，跳转到用户修改信息列表页面
    @RequestMapping(value = "/userModify.html", method = RequestMethod.GET)
    public String getUserById(@RequestParam String uid, Model model) {
        User user = userService.getUserById(uid);
        model.addAttribute("user", user);
        return "usermodify";
    }

    // 修改用户信息，提交表单的操作
    @RequestMapping(value = "/userModifySave.html", method = RequestMethod.POST)
    public String modifyUserSave(User user, HttpSession httpSession) {
        user.setModifyBy(((User) httpSession
                .getAttribute(Constants.USER_SESSION)).getId());
        user.setModifyDate(new Date());
        // 判断有没有添加成功
        if (userService.modify(user)) {
            // 想：添加成功了之后，要返回到用户列表页面中去，并且从新刷新页面，客户端从新发起请求，使用重定向
            return "redirect:/user/userlist.html";
        }
        return "usermodify";

    }

    // 根据用户id查询用户的详细信息
    @RequestMapping(value = "/view/{id}", method = RequestMethod.GET)
    public String view(@PathVariable String id, Model model) {
        User user = userService.getUserById(id);
        model.addAttribute("user", user);
        return "userview";

    }
    
    //添加相应验证控制器 ResponseBody的作用就是将异步请求返回来的结果绑定到ResponseBody对象上面
    @RequestMapping(value="ucexist.html")
    @ResponseBody
    public Object userCodeIsExist(@RequestParam String userCode){
        HashMap<String, String> resultMap=new HashMap<String, String>();
        if(StringUtils.isNullOrEmpty(userCode)){
            resultMap.put("userCode", "exist");
        }else{
            User user = userService.selectUserCodeExist(userCode);
            if(user!=null){
                resultMap.put("userCode","exist");
            }else{
                resultMap.put("userCode", "noexist");
            }
        }
        return JSONArray.toJSONString(resultMap);
    }
    
    //添加相应的控制器，实现异步请求  一开始是value="/view.html"会报406的错误
    @RequestMapping(value="/view",method= RequestMethod.GET/*,produces={"application/json;charset=UTF-8"}*/)
    @ResponseBody    
    public User view(@RequestParam String id){
        User user=new User();
            try {
                user=userService.getUserById(id);
                
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            
            }
        return user;
    }
    
}

 

修改springmvc-servlet.xml配置文件，将mvc:annotation-driven中引用的自定义的转换器去掉就可以了
　

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
        
    <context:component-scan base-package="cn.smbms.controller"/>    
    <!-- 指定mvc:annotation-driven的默认实现，现在使用的是自己自定义的转化器 -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <property name="supportedMediaTypes">
                    <list>
                        <value>application/json;charset=UTF-8</value>
                    </list>
                </property>
            </bean> 
            <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
                <property name="supportedMediaTypes">
                    <list>
                        <value>text/html;charset=UTF-8</value>
                        <value>application/json</value>
                    </list>
                </property>
                <property name="features">
                    <list>
                      <!--  Date的日期转换器 -->
                      <value>WriteDateUseDateFormat</value>
                    </list>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
    <!--创建conversionService实例  当我们在遇到前后台日期类型转换的问题的时候，其实有mvc:annotation-driven一键式配置好了，所以conversionService实例不用也是可以的-->
   <!--  <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean"></bean> -->
   
   <!-- 引用自己自定义的转化器 -->
   <bean id="myConversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
       <property name="converters">
           <list>
               <bean class="cn.smbms.tools.StringToDateConvertor">
                  <!-- 构造注入 -->
                  <constructor-arg type="java.lang.String" value="yyyy-MM-dd"></constructor-arg>
               
               </bean>
           
           
           
           </list>
       
       
       </property>
   </bean>
   
    <mvc:resources mapping="/statics/**" location="/statics/" />
    <!-- 完成视图的对应 -->
    <!-- 对转向页面的路径解析。prefix：前缀， suffix：后缀 -->
    <!-- <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" >
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean> -->
    
    <!-- 配置多视图解析器：允许同样的内容数据呈现不同的view -->
    <bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
        <property name="favorParameter" value="true"/>
        <property name="defaultContentType" value="text/html"/>
        <property name="mediaTypes">
            <map>
                <entry key="html" value="text/html;charset=UTF-8"/>
                <entry key="json" value="application/json;charset=UTF-8"/>
                <entry key="xml" value="application/xml;charset=UTF-8"/>
            </map>
        </property>
        <!--配置网页的视图解析器  -->
        <property name="viewResolvers">
            <list>
                <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" >
                    <property name="prefix" value="/WEB-INF/jsp/"/>
                    <property name="suffix" value=".jsp"/>
                </bean>        
            </list>
        </property>
    </bean>
    
    <!--  全局异常处理 -->
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <property name="exceptionMappings">
            <props>
                <prop key="java.lang.RuntimeException">error</prop>
            </props>
        </property>
    </bean>
    
    <!-- 配置MultipartResolver，用于上传文件，使用spring的CommonsMultipartResolver -->  
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
            <property name="maxUploadSize" value="5000000"/>
            <property name="defaultEncoding" value="UTF-8"/>
    </bean>
    
</beans>

 运行结果：