CRUD后台的处理

                                                                       controller层的处理:

package com.go.crud.controller;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.validation.annotation.Validated;
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 com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.go.crud.bean.Employee;
import com.go.crud.bean.Msg;
import com.go.crud.service.EmployeeService;
/***
 * 直接发送put请求需要封装请求体的数据       配置上：HttpPutFormContentFilter
 * 它的作用将请求体的数据解析包装成一个map,request会被重新包装，request.getParameter被重写，
 * 就会从自己封装的map取数据
 * @author Administrator
 *
 */

/*
 * 处理员工CURD请求
 */
@Controller
public class EmployeeController {
    /*
     * 分页查询员工数据
     */
    @Autowired
    EmployeeService employeeService;
    
    /***
     * 单条删除
     */
    @RequestMapping(value="/emp/{ids}",method=RequestMethod.DELETE)
    @ResponseBody
      public Msg empDelete(@PathVariable("ids") String ids){
        if(ids.contains("-")){
            
            //组装id的集合
            List<Integer> del_ids  = new ArrayList<Integer>(); 
            //把传进来的数组id一个个用“-”分开
            String[] str_ids = ids.split("-");
            for (String string : str_ids) {
                del_ids.add(Integer.parseInt(string));
            }
            employeeService.deleteBatch(del_ids);
        }else{
            Integer id = Integer.parseInt(ids);
         employeeService.empDelete(id);
        }
        return Msg.Success();
          
      }
    /***
     * 
     * 修改：保存已修改的员工数据
     */
    @RequestMapping(value ="/emp/{empId}", method = RequestMethod.PUT)
    @ResponseBody
    public Msg saveEmp(Employee employee ,HttpServletRequest request) {
        System.out.println("请求体中的值："+request.getParameter("gender"));
        System.out.println("将要更新员工数据："+employee);
        employeeService.updateEmp(employee);
        return Msg.Success();

    }

    /***
     * 修改：查员工信息
     * 
     * @param empName
     * @return
     */
    @RequestMapping(value ="/emp/{id}", method = RequestMethod.GET)
    @ResponseBody
    public Msg getEmp(@PathVariable("id") Integer id) {
        Employee employee = employeeService.getEmp(id);
        return Msg.Success().add("emp", employee);

    }

    /***
     * 验证用户名是否可用
     * 
     * @param empName
     * @return
     */
    @RequestMapping("/checkuser")
    @ResponseBody
    public Msg checkUser(@RequestParam("empName") String empName) {
        // 先判断用户名合法的表达式
        String regx = "(^[a-zA-Z0-9_-]{6,16}$)|(^[\u2E80-\u9FFF]{2,5})";
        if (!empName.matches(regx)) {
            return Msg.fail().add("va_msg", "用户名必须是6-16字母或者2到5位中文！");
        }
        Boolean user = employeeService.checkUser(empName);
        if (user == true) {
            return Msg.Success();
        } else {
            return Msg.fail().add("va_msg", "用户名不可用！");
        }

    }

    @RequestMapping("/emps")
    @ResponseBody
    public Msg getEmpsWithJson(@RequestParam(value = "pn", defaultValue = "1") Integer pn, Model model) {
        // 1.引入pageHelper 分页插件
        // 2.在查询之前调用startPage,传入页码，以及它的大小
        PageHelper.startPage(pn, 10);
        List<Employee> emps = employeeService.getAll();
        // 3.使用PageInfo包装查询后的结果,只需要将pageinfo返回给页面
        // 封装了分页的详细信息，包括我们查询出来的数据,连续显示的页面数
        PageInfo page = new PageInfo(emps, 10);

        // model.addAttribute("pageInfo", page);

        return Msg.Success().add("pageInfo", page);

    }

    // @RequestMapping("/emps")
    public String getEmps(@RequestParam(value = "pn", defaultValue = "1") Integer pn, Model model) {
        // 1.引入pageHelper 分页插件
        // 2.在查询之前调用startPage,传入页码，以及它的大小
        PageHelper.startPage(pn, 5);
        List<Employee> emps = employeeService.getAll();
        // 3.使用PageInfo包装查询后的结果,只需要将pageinfo返回给页面
        // 封装了分页的详细信息，包括我们查询出来的数据,连续显示的页面数
        PageInfo page = new PageInfo(emps, 10);

        model.addAttribute("pageInfo", page);

        return "list";

    }

    /***
     * 新增
     * 
     * @return
     */
    @RequestMapping(value = "/saveEmps", method = RequestMethod.POST)
    @ResponseBody
    public Msg saveEmps(@Valid Employee employee, BindingResult result) {
        Map<String, Object> map = new HashMap<String, Object>();
        if (result.hasErrors()) {
            // 校验失败
            List<FieldError> error = result.getFieldErrors();
            for (FieldError fieldError : error) {
                System.out.println("错误的字段名！" + fieldError.getField());
                System.out.println("错误信息！" + fieldError.getDefaultMessage());
                map.put(fieldError.getField(), fieldError.getDefaultMessage());
            }
            return Msg.fail().add("errorFields", map);
        } else {
            employeeService.saveEmps(employee);
            return Msg.Success();
        }

    }

}
                                                                                               Service层的处理：

package com.go.crud.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.go.crud.bean.Employee;
import com.go.crud.bean.EmployeeExample;
import com.go.crud.bean.EmployeeExample.Criteria;
import com.go.crud.dao.EmployeeMapper;
@Service
public class EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;
    /*
     * 查询全部员工
     */
    public List<Employee> getAll() {
        // TODO Auto-generated method stub
        return employeeMapper.selectByExampleWithDept(null);
    }
    /***
     * 新增
     * @return
     */
    public void saveEmps(Employee employee) {
        
        employeeMapper.insertSelective(employee);
    }
    /***
     * 验证用户名是否可用   true 可用     flase为不可用
     * @param empName     
     * @return
     */
    public Boolean checkUser(String empName) {
        //方法构建一个实例
        EmployeeExample example = new EmployeeExample();
        Criteria criteria = example.createCriteria();
        //查询出来比较是否相同
        criteria.andEmpNameEqualTo(empName);
        //根据条件查询对应的字段
        long count = employeeMapper.countByExample(example);
        return count==0;
    }
    /***
     * 修改：查员工信息
     * @param empName
     * @return
     */
    public Employee getEmp(Integer id) {
        Employee employee = employeeMapper.selectByPrimaryKeyWithDept(id);
        return employee;
    }
    /***
     * 修改
     * @param empName
     * @return
     */
    public void updateEmp(Employee employee) {
        employeeMapper.updateByPrimaryKeySelective(employee);
        
    }
    /***
     * 单条删除
     * @param id 
     */
    public void empDelete(Integer id) {
        employeeMapper.deleteByPrimaryKey(id);
        
    }
    public void deleteBatch(List<Integer> ids) {
        // TODO Auto-generated method stub
        EmployeeExample example =new EmployeeExample();
        Criteria criteria = example.createCriteria();
        criteria.andEmpIdIn(ids);
        //并出来的：delete form  *** where emp_id in(1,2,3,,,,)
        employeeMapper.deleteByExample(example);
    }
}
 

                                                                          DAO的处理：

package com.go.crud.dao;

import com.go.crud.bean.Employee;
import com.go.crud.bean.EmployeeExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;

public interface EmployeeMapper {
    long countByExample(EmployeeExample example);

    int deleteByExample(EmployeeExample example);

    int deleteByPrimaryKey(Integer empId);

    int insert(Employee record);

    int insertSelective(Employee record);

    List<Employee> selectByExample(EmployeeExample example);

    Employee selectByPrimaryKey(Integer empId);
    
    List<Employee> selectByExampleWithDept(EmployeeExample example);

    Employee selectByPrimaryKeyWithDept(Integer empId);

    int updateByExampleSelective(@Param("record") Employee record, @Param("example") EmployeeExample example);

    int updateByExample(@Param("record") Employee record, @Param("example") EmployeeExample example);

    int updateByPrimaryKeySelective(Employee record);

    int updateByPrimaryKey(Employee record);
}