devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java项目:客户管理系统(java+SpringBoot+JSP+LayUI+jQ+mysql)_简单的jsp管理系统

作者：花生_TL007 | 2024-02-27 20:01:11

赞

踩

简单的jsp管理系统

源码获取：博客首页 "资源" 里下载！

项目介绍

本项目为后管系统，主要功能包括：

登录、修改密码、客户模块、充值模块、消费模块、对账单模块等功能。

环境需要

1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;
3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可
4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS；
5.数据库：MySql 5.7版本；

6.是否Maven项目：是；

技术栈

1. 后端：SpringBoot+Mybatis

2. 前端：JSP+LayUI+jQuery

使用说明

1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件；

2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;

若为maven项目，导入成功后请执行maven clean;maven install命令，然后运行；

3. 将项目中application.yml配置文件中的数据库配置改为自己的配置;
4. 修改logback-spring.xml文件中，第16行
5. 运行项目，输入http://localhost:8081/ 登录

 

 

 

 

客户管理控制层：

  1. @Controller
  2. @RequestMapping("customer")
  3. public class CustomerController {
  4.     @Autowired
  5.     private ICustomerService customerService;
  6.     
  7.     private User user = null;
  8.  
  9.     private User getUser(HttpServletRequest request) {
  10.         HttpSession session = request.getSession();
  11.         user = (User)session.getAttribute("user");
  12.         return user;
  13.     }
  14.     
  15.  
  16.     /**
  17.      * 
  18.      * 描述：分页查询客户
  19.      * @author huangwanzong
  20.      * @date 2018/07/06
  21.      * @version 1.0
  22.      * @param page 可选参数，查询的页数，默认值 1
  23.      * @param limit 可选参数，分页的大小，默认值 10
  24.      * @param customer 可选参数，查询的条件
  25.      * @param findtype 可选参数，该参数值为 all 时不执行分页查询，返回全部符合条件的客户
  26.      * @param request
  27.      * @return Map<String,Object>
  28.      * @since 1.8
  29.      *
  30.      */
  31.     
  32.     @RequiresPermissions("5001")
  33.     @Operation(name="分页查询客户")
  34.     @RequestMapping("list")
  35.     @ResponseBody
  36.     public Map<String, Object> listCustomer(Integer page,Integer limit,Customer customer,String findtype,HttpServletRequest request){
  37.         Map<String, Object> map = new HashMap<String,Object>(16);
  38.         
  39.         //获取用户
  40.         user = this.getUser(request);
  41.         //检验用户正确性
  42.         if(user == null || user.getId() == null) {
  43.             map.put("code", -1);
  44.             map.put("msg", "用户不存在，无法执行操作.");
  45.             return map;
  46.         }
  47.         
  48.         CustomerExample example = new CustomerExample();
  49.         Criteria criteria = example.createCriteria();
  50.         
  51.         //设置分页参数
  52.         if(page == null || page <= 0) {
  53.             page = 1;
  54.         }
  55.         if(limit == null || limit <= 0) {
  56.             limit = 10;
  57.         }
  58.         String all = "all";
  59.         if(!all.equals(findtype)) {
  60.             example.setLimit(limit);
  61.             Long offset = new Long((page-1)*limit);
  62.             example.setOffset(offset);
  63.         }
  64.  
  65.         //设置管理者ID
  66.         criteria.andManagerIdEqualTo(user.getId());
  67.         //只查询未删除的客户
  68.         criteria.andDeleteStatusEqualTo(0);
  69.         System.out.println(customer);
  70.         //检测属性是否存在，存在则进行条件查询
  71.         if(customer != null) {
  72.             if(customer.getName() != null) {
  73.                 criteria.andNameLike("%" + customer.getName() + "%");
  74.             }
  75.             
  76.             if(customer.getType() != null && !"".equals(customer.getType())) {
  77.                 criteria.andTypeEqualTo(customer.getType()); 
  78.             }
  79.             if(customer.getStatus() != null && !"".equals(customer.getStatus())) {
  80.                 criteria.andStatusEqualTo(customer.getStatus());
  81.             }
  82.             if(customer.getSource() != null && !"".equals(customer.getSource())) {
  83.                 criteria.andSourceEqualTo(customer.getSource());
  84.             }
  85.             if(customer.getLevel() != null && !"".equals(customer.getLevel())) {
  86.                 criteria.andLevelEqualTo(customer.getLevel());
  87.             }
  88.             if(customer.getCredit() != null && !"".equals(customer.getCredit())) {
  89.                 criteria.andCreditEqualTo(customer.getCredit());
  90.             }
  91.             if(customer.getMaturity() != null && !"".equals(customer.getMaturity())) {
  92.                 criteria.andMaturityEqualTo(customer.getMaturity());
  93.             }
  94.         }
  95.         
  96.         Long count = customerService.countByCustomerExample(example);
  97.         List<Customer> customers = customerService.selectByCustomerExample(example);
  98.         
  99.         map.put("data", customers);
  100.         map.put("count", count);
  101.         map.put("code", 0);
  102.         
  103.         return map;
  104.     }
  105.     
  106.     
  107.     /**
  108.      * 
  109.      * 描述：添加一个客户
  110.      * @author huangwanzong
  111.      * @date 2018/07/17
  112.      * @version 1.0
  113.      * @param customer 客户信息
  114.      * @param linkman 联系人信息
  115.      * @param customerName 客户名称
  116.      * @param linkmanName 联系人名称
  117.      * @param customerLevel 客户等级
  118.      * @param request
  119.      * @return Map<String,Object>
  120.      * @since 1.8
  121.      *
  122.      */
  123.     @RequiresPermissions("5002")
  124.     @Operation(name="添加客户")
  125.     @RequestMapping("add")
  126.     @ResponseBody
  127.     public Map<String, Object> addCustomer(Customer customer,Linkman linkman,String customerName,String linkmanName,String customerLevel,HttpServletRequest request){
  128.         Map<String, Object> map = new HashMap<String,Object>(16);
  129.         
  130.         this.getUser(request);
  131.         
  132.         //检测是否存在customer对象
  133.         if(customer == null || linkman == null) {
  134.             map.put("msg", "参数为空");
  135.             map.put("success", false);
  136.             return map;
  137.         }
  138.         
  139.         //检测客户名是否存在
  140.         if(customerName == null || "".equals(customerName)) {
  141.             map.put("msg", "用户名称参数不能为空");
  142.             map.put("success", false);
  143.             return map;
  144.         }
  145.         
  146.         //检测联系人姓名是否存在
  147.         if(linkmanName == null || "".equals(linkmanName)) {
  148.             map.put("msg", "联系人名称参数不能为空");
  149.             map.put("success", false);
  150.             return map;
  151.         }
  152.         
  153.         //客户所属者默认为创建者
  154.         customer.setManagerId(user.getId());
  155.         //设置创建者id
  156.         customer.setCreater(user.getId());
  157.         //设置创建时间
  158.         customer.setCreateTime(LocalDateTime.now());
  159.         //设置客户名称
  160.         customer.setName(customerName);
  161.         //设置客户等级
  162.         customer.setLevel(customerLevel);
  163.         //设置未删除
  164.         customer.setDeleteStatus(0);
  165.         
  166.         //设置联系人名称
  167.         linkman.setName(linkmanName);
  168.      
  169.         
  170.         //进行数据插入
  171.         if(customerService.insertSelective(customer,linkman)) {
  172.             map.put("msg", "添加成功");
  173.             map.put("success", true);
  174.         }else {
  175.             map.put("msg", "添加失败");
  176.             map.put("success", false);
  177.         }
  178.         
  179.         return map;
  180.     }
  181.     
  182.     @RequiresPermissions("7009")
  183.     @Operation(name="检测客户名称是否存在")
  184.     @RequestMapping("checkname")
  185.     @ResponseBody
  186.     public boolean checkCustomerName(String name){
  187.         
  188.         CustomerExample example = new CustomerExample();
  189.         example.createCriteria().andNameEqualTo(name);
  190.         
  191.         List<Customer> list = customerService.selectByCustomerExample(example);
  192.         if(list.size()>0) {
  193.             return true;
  194.         }
  195.         return false;
  196.     }
  197.     
  198.     @RequiresPermissions("5003")
  199.     @Operation(name="更新客户信息")
  200.     @RequestMapping("update")
  201.     @ResponseBody
  202.     public Map<String, Object> updateCustomer(Customer customer){
  203.         Map<String, Object> map = new HashMap<String,Object>(16);
  204.  
  205.         if(customerService.updateCustomerByPrimaryKeySelective(customer)) {
  206.             map.put("msg", "更新成功");
  207.             map.put("success", true);
  208.         }else {
  209.             map.put("msg", "更新失败");
  210.             map.put("success", false); 
  211.         }
  212.         return map;
  213.     }
  214.     
  215.     @RequiresPermissions("5004")
  216.     @Operation(name="删除客户")
  217.     @RequestMapping("delete")
  218.     @ResponseBody
  219.     public Map<String, Object> deleteCustomer(int[] ids){
  220.         Map<String, Object> map = new HashMap<String,Object>(16);
  221.         List<Integer> success = new ArrayList<Integer>();
  222.         List<Integer> fail = new ArrayList<Integer>();
  223.         for(int id : ids) {
  224.             if(customerService.deleteByPrimaryKey(id)) {
  225.                 success.add(id);
  226.             }else {
  227.                 fail.add(id);
  228.             }
  229.         }
  230.         
  231.         map.put("msg", "删除完成");
  232.         map.put("status", true);
  233.         map.put("success", success);
  234.         map.put("fail", fail);
  235.         
  236.         return map;
  237.     }
  238.     
  239.     @RequiresPermissions("7010")
  240.     @Operation(name="id查找客户")
  241.     @RequestMapping("find")
  242.     @ResponseBody
  243.     public Map<String, Object> findCustomer(Integer id){
  244.         Map<String, Object> map = new HashMap<String,Object>(16);
  245.         Customer customer = null;
  246.         
  247.         if(id == null) {
  248.             map.put("msg", "非法操作");
  249.             map.put("success", false); 
  250.             return map;
  251.         }
  252.         
  253.         customer = customerService.selectCustomerByPrimaryKey(id);
  254.         
  255.         if(customer != null) {
  256.             map.put("msg", "查找成功");
  257.             map.put("success", true);
  258.             map.put("data", customer);
  259.         }else {
  260.             map.put("msg", "查找失败");
  261.             map.put("success", false); 
  262.         }
  263.         return map;
  264.     }
  265.     
  266.     
  267. }

登录管理控制层：

  1. @Controller
  2. @RequestMapping("/user")
  3. public class LoginController {
  4.     
  5.     @Autowired
  6.     private IUserService userService;
  7.     
  8.     private Logger logger = LoggerFactory.getLogger(LoginController.class);
  9.     
  10.     /**
  11.      * 
  12.      * 描述：登陆
  13.      * @author wanghaoyu
  14.      * @version 1.0
  15.      * @param user 用户
  16.      * @param verifyCode 验证码
  17.      * @param request 请求
  18.      * @return Map<String,Object> map封装要返回到前端的信息
  19.      * @exception Nothing
  20.      * @since 1.8
  21.      *
  22.      */
  23.     @Operation(name="登陆")
  24.     @RequestMapping("/login")
  25.     @ResponseBody
  26.     public Map<String, Object> login(User user, String verifyCode, 
  27.             HttpServletRequest request){
  28.  
  29.     	Map<String, Object> maps = new HashMap<String, Object>(16);
  30.     	
  31.     	//1. 验证验证码
  32.     	if(verifyCode == null || "".equals(verifyCode) ) {
  33.     		maps.put("code", 200);
  34.     		maps.put("msg", "请输入验证码");
  35.     		return maps;
  36.     	}
  37.     	verifyCode = verifyCode.toLowerCase();
  38.     	String sessionCode = (String) request.getSession().getAttribute("verifyCode");
  39.     	if( sessionCode == null || "".equals(sessionCode)){
  40.     		maps.put("code", 200);
  41.     		maps.put("msg", "验证码获取失败! 请刷新页面!");
  42.     		return maps;
  43.     	}
  44.     	sessionCode = sessionCode.toLowerCase();
  45.     	
  46.     	if(!sessionCode.equals(verifyCode)) {
  47.     		maps.put("code", 200);
  48.     		maps.put("msg", "验证码不正确!");
  49.     		return maps;
  50.     	}
  51.     	
  52.     	//2.判断用户账号密码
  53.         Subject subject = SecurityUtils.getSubject();
  54.         
  55.         System.err.println("==============================" +subject.isAuthenticated());
  56.         
  57.         //判断用户是否已经登陆
  58.         if(!subject.isAuthenticated()) {
  59.             UsernamePasswordToken token = new UsernamePasswordToken(user.getAccount(),user.getPassword());
  60.             try {
  61.                 subject.login(token);
  62.                 //验证成功
  63.                 //登陆成功后的用户账号信息
  64.                 String account =  (String)subject.getPrincipal();
  65.                 
  66.                 //根据用户账号，查询用户，并保存到session域中
  67.                 User loginUser = userService.findByAccount(account);
  68.   
  69.                 LocalDateTime now = LocalDateTime.now();
  70.                 
  71.                 //如果上次登陆的时间为空，则说明这次是首次登陆，前台应该跳转到修改密码界面
  72.                 if(loginUser.getLastLoginTime() == null) {
  73.                     maps.put("firstLogin", true);
  74.                 }
  75.                 //修改最后一次登录的时间,并保存到数据库
  76.                 loginUser.setLastLoginTime(now);
  77.                 loginUser.setPassword(null);
  78.                 
  79.                 //新创建对象用来更新user的最后一次登录时间
  80.                 User updateUser = new User();
  81.                 updateUser.setId(loginUser.getId());
  82.                 updateUser.setLastLoginTime(now);
  83.                 userService.edit(updateUser);
  84.                 
  85.                 request.getSession().setAttribute("user", loginUser);
  86.                 logger.info("登陆的用户信息:" + loginUser.toString());
  87.  
  88.                 request.getSession().setAttribute("user", loginUser);
  89.                 maps.put("code", 0); 
  90.               //账号被锁定
  91.             } catch(LockedAccountException e){
  92.                 maps.put("code",200);
  93.                 maps.put("msg","账号已被锁定，请联系管理员进行处理！");
  94.               //不存在的账号
  95.             } catch(UnknownAccountException e) {
  96.                 maps.put("code",200);
  97.                 maps.put("msg","账号或密码错误!");
  98.               //密码错误
  99.             } catch(IncorrectCredentialsException e) {
  100.                 maps.put("code",200);
  101.                 maps.put("msg","账号或密码错误!");
  102.             }catch (Exception e) {
  103.                 e.printStackTrace();
  104.                 maps.put("code", 200);
  105.                 maps.put("msg", "系统出了小差，请稍等...");
  106.             }
  107.         }else {
  108.         	maps.put("code", 0);
  109.         }
  110.         return maps;
  111.     }
  112.     
  113.     /**
  114.      * 
  115.      * 描述：
  116.      * @author wanghaoyu
  117.      * @version 1.0
  118.      * @param request request请求
  119.      * @return ModelAndView
  120.      * @exception Nothing
  121.      * @since 1.8
  122.      *
  123.      */
  124.     @Operation(name="注销")
  125.     @RequestMapping("/logout")
  126.     public ModelAndView logout(HttpServletRequest request) {
  127.         ModelAndView view = new ModelAndView();
  128.         //获取shiro中的用户
  129.         Subject subject = SecurityUtils.getSubject();
  130.         //获取用户账号信息
  131.         String account = (String) subject.getPrincipal();
  132.         if(account != null) {
  133.             //登出
  134.             subject.logout();
  135.             //同时删除session中的用户信息
  136.             request.getSession().removeAttribute("user");
  137.             request.getSession().invalidate();
  138.         }
  139.         //重定向到登陆页面
  140.         view.setViewName("redirect:/pages/login.jsp");
  141.         return view;
  142.     }
  143.     
  144.     
  145.     
  146.     
  147. }

系统用户管理控制层：

  1. @Controller
  2. @RequestMapping("/user")
  3. public class UserController {
  4.     
  5.     @Autowired
  6.     IUserService userService;
  7.     
  8.     @Autowired
  9.     IRoleService roleService;
  10.     
  11.     @Autowired
  12.     RedisUtil redisUtil;
  13.     
  14.     @Autowired
  15.     MailUtil mailUtil;
  16.     
  17.     Logger logger = LoggerFactory.getLogger(UserController.class);
  18.     
  19.     /**
  20.      * 描述：查找用户
  21.      * @param page
  22.      * @param limit
  23.      * @param user
  24.      * @return
  25.      */
  26.     @Operation(name="查找用户")
  27.     @RequiresPermissions("1001")
  28.     @RequestMapping("/findUser")
  29.     @ResponseBody
  30.     public Map<String, Object> findUser(Integer page,Integer limit, User user){
  31.         
  32.         Map<String, Object> map = new HashMap<String,Object>(16);
  33.         
  34.         //创建用户模板类
  35.         UserExample userExample = new UserExample();
  36.         //创建查询准则
  37.         Criteria criteria = userExample.createCriteria();
  38.         if(page == null || page <= 0) {
  39.             page = 1;
  40.         }
  41.         if(limit == null || limit <= 0) {
  42.             limit = 10;
  43.         }
  44.         
  45.         //判断user类的条件是否为空
  46.         if(user.getRealName() != null) {
  47.              criteria.andRealNameLike("%"+user.getRealName()+"%");
  48.         }
  49.         
  50.         if(user.getRoleId() != null) {
  51.             logger.info("获得到的角色编号为：" + user.getRoleId());
  52.             criteria.andRoleIdEqualTo(user.getRoleId());
  53.         }
  54.         
  55.         if(user.getAccount() != null) {
  56.             criteria.andAccountLike("%"+user.getAccount()+"%");
  57.         }
  58.         
  59.         Long offset = new Long((page - 1) * limit);
  60.         
  61.         Long count = userService.countByExample(userExample);
  62.         
  63.         userExample.setLimit(limit);
  64.         userExample.setOffset(offset);
  65.         
  66.         List<User> list = userService.findByExample(userExample);
  67.         
  68.         logger.info(list.toString());
  69.         
  70.         map.put("data", list);
  71.         map.put("code", 0);
  72.         map.put("msg", "success");
  73.         map.put("count", count);
  74.         return map;
  75.     }
  76.     
  77.     /**
  78.      * 
  79.      * 描述：根据编号查找用户
  80.      * @author wanghaoyu
  81.      * @version 1.0
  82.      * @param id
  83.      * @return 
  84.      * @exception Nothing
  85.      * @since 1.8
  86.      *
  87.      */
  88.     @Operation(name="根据编号查找用户")
  89.     @RequiresAuthentication
  90.     @RequestMapping("/findUserById")
  91.     @ResponseBody
  92.     public Map<String, Object> findUserById(Integer id){
  93.         Map<String, Object> map = new HashMap<String, Object>(16);
  94.         boolean success = false;
  95.         String msg = "";
  96.         User user = userService.findById(id);
  97.         if(user != null){
  98.              user.setPassword(null);
  99.              user.setSalt(null);
  100.             success = true;
  101.         }else{
  102.             msg = "读取用户数据出错，请稍后再试！";
  103.         }
  104.         map.put("success", success);
  105.         map.put("user", user);
  106.         map.put("msg",msg);
  107.         map.put("code", 0);
  108.         return map;
  109.     }
  110.     
  111.     /**
  112.      * 
  113.      * 描述：根据用户ID删除用户
  114.      * @author wanghaoyu
  115.      * @version 1.0
  116.      * @param id 用户编号
  117.      * @return Map<String,Object>
  118.      * @exception Nothing
  119.      * @since 1.8
  120.      *
  121.      */
  122.     @Operation(name="删除用户")
  123.     @RequiresPermissions("1004")
  124.     @RequestMapping("/deleteUser")
  125.     @ResponseBody
  126.     public Map<String, Object> deleteUser(Integer id){
  127.         Map<String, Object> map = new HashMap<String, Object>(16);
  128.         boolean success = false;
  129.         //删除成功
  130.         if(userService.deleteById(id) == true) {
  131.             success = true;
  132.         }
  133.         map.put("success", success);
  134.         map.put("code", 0);
  135.         return map;
  136.     }
  137.     
  138.     /**
  139.      * 
  140.      * 描述：编辑用户
  141.      * @author wanghaoyu
  142.      * @version 1.0
  143.      * @param user 要编辑的用户信息
  144.      * @return Map<String,Object>
  145.      * @exception Nothing
  146.      * @since 1.8
  147.      *
  148.      */
  149.     @Operation(name="修改用户")
  150.     @RequiresPermissions(value={"1002","13002"}, logical=Logical.OR)
  151.     @RequestMapping("/editUser")
  152.     @ResponseBody
  153.     public Map<String, Object> editUser(User user){
  154.         Map<String, Object> map = new HashMap<String, Object>(16);
  155.         boolean success = false;
  156.         String msg = "";
  157.         //修改成功
  158.         if(userService.edit(user) == true) {
  159.             success = true;
  160.             msg = "修改成功！";
  161.         }else {
  162.             msg = "修改失败！";
  163.         }
  164.         map.put("success", success);
  165.         map.put("msg", msg);
  166.         map.put("code", 0);
  167.         return map;
  168.     }
  169.     
  170.     /**
  171.      * 
  172.      * 描述：添加用户
  173.      * @author wanghaoyu
  174.      * @version 1.0
  175.      * @param user 要添加的用户信息
  176.      * @return Map<String,Object>
  177.      * @exception Nothing
  178.      * @since 1.8
  179.      *
  180.      */
  181.     @Operation(name="添加用户")
  182.     @RequiresPermissions("1003")
  183.     @RequestMapping("/addUser")
  184.     @ResponseBody
  185.     public Map<String, Object> addUser(User user){
  186.         Map<String, Object> map = new HashMap<String, Object>(16);
  187.         boolean success = false;
  188.         
  189.         //设置user的初始密码为123456
  190.         user.setPassword("123456");
  191.         
  192.         //添加
  193.         if(userService.save(user) == true) {
  194.             success = true;
  195.         }
  196.         map.put("success", success);
  197.         map.put("code", 0);
  198.         return map;
  199.     }
  200.     
  201.     /**
  202.      * 
  203.      * 描述：查找所有的角色
  204.      * @author wanghaoyu
  205.      * @version 1.0
  206.      * @return Map<String,Object>
  207.      * @exception Nothing
  208.      * @since 1.8
  209.      *
  210.      */
  211.     @Operation(name="后台查找角色列表")
  212.     @RequiresAuthentication
  213.     @RequestMapping("/findRoles")
  214.     @ResponseBody
  215.     public Map<String, Object> findRoles(){
  216.         Map<String, Object> map = new HashMap<String, Object>(16);
  217.         List<Role> roles = roleService.selectByRoleExample(new RoleExample());
  218.         map.put("success", true);
  219.         map.put("list", roles);
  220.         logger.info(roles.toString());
  221.         return map;
  222.     }
  223.     
  224.     /**
  225.      * 
  226.      * 描述：查找除当前登录的客户经理外的所有的客户经理
  227.      * @author wanghaoyu
  228.      * @version 1.0
  229.      * @param request
  230.      * @return Map<String,Object>
  231.      * @exception Nothing
  232.      * @since 1.8
  233.      *
  234.      */
  235.     @Operation(name="后台查找其他客户经理角色")
  236.     @RequiresAuthentication
  237.     @RequestMapping("/findOthersManager")
  238.     @ResponseBody
  239.     public Map<String, Object> findOthersManager(HttpServletRequest request){
  240.         Map<String, Object> map = new HashMap<String, Object>(16);
  241.         boolean success = false;
  242.         //获取当前登录用户
  243.         User user = (User)request.getSession().getAttribute("user");
  244.         //创建用户模块
  245.         UserExample userExample = new UserExample();
  246.         //创建查询准则
  247.         Criteria criteria =  userExample.createCriteria();
  248.         //如果当前用户为客户经理
  249.         if(user.getRoleId() == 1) {
  250.             criteria.andIdNotEqualTo(user.getId());
  251.         }
  252.         criteria.andRoleIdEqualTo(1);
  253.         List<User> users = userService.findByExample(userExample);
  254.         success = true; 
  255.         
  256.         map.put("success", success);
  257.         map.put("list", users);
  258.         map.put("code", 0);
  259.         return map;
  260.     }
  261.     
  262.     /**
  263.      * 
  264.      * 描述：检查用户账号是否可用
  265.      * @author wanghaoyu
  266.      * @version 1.0
  267.      * @param account
  268.      * @return Map<String,Object>
  269.      * @exception Nothing
  270.      * @since 1.8
  271.      *
  272.      */
  273.     @Operation(name="检查用户账号")
  274.     @RequestMapping("/checkUserAccount")
  275.     @ResponseBody
  276.     public Map<String, Object> checkUserAccount(String account){
  277.         Map<String, Object> map = new HashMap<String, Object>(16);
  278.         boolean success = false;
  279.         //没有找到该账号名，说明账号可用
  280.         if(userService.findByAccount(account) == null) {
  281.             success = true;
  282.         }
  283.         map.put("success", success);
  284.         map.put("code", 0);
  285.         return map;
  286.     }
  287.     
  288.     /**
  289.      * 
  290.      * 描述：检查用户邮箱是否可用
  291.      * @author wanghaoyu
  292.      * @version 1.0
  293.      * @param email
  294.      * @return Map<String,Object>
  295.      * @exception Nothing
  296.      * @since 1.8
  297.      *
  298.      */
  299.     @Operation(name="检查用户邮箱")
  300.     @RequestMapping("/checkUserEmail")
  301.     @ResponseBody
  302.     public Map<String, Object> checkUserEmail(String email){
  303.         Map<String, Object> map = new HashMap<String, Object>(16);
  304.         boolean success = false;
  305.         //没有找到该账号名，说明邮箱可用
  306.         if(userService.findByEmail(email) == null) {
  307.             success = true;
  308.         }
  309.         map.put("success", success);
  310.         map.put("code", 0);
  311.         return map;
  312.     }
  313.     
  314.     /**
  315.      * 
  316.      * 描述：根据session域里面的用户编号查找当前登录的用户
  317.      * @author wanghaoyu
  318.      * @version 1.0
  319.      * @param id
  320.      * @return Map<String,Object>
  321.      * @exception Nothing
  322.      * @since 1.8
  323.      *
  324.      */
  325.     @Operation(name="查找当前登录的用户")
  326.     @RequiresPermissions("13001")
  327.     @RequestMapping("/findCurrentUser")
  328.     @ResponseBody
  329.     public Map<String, Object> findCurrentUser(Integer id){
  330.         Map<String, Object> map = new HashMap<String, Object>(16);
  331.         boolean success = false;
  332.         String msg = "";
  333.         //根据ID查找用户
  334.         User user = userService.findById(id);
  335.         if(user != null){
  336.             user.setPassword(null);
  337.             user.setSalt(null);
  338.             success = true;
  339.             msg = "查找成功！";
  340.         }else{
  341.             success = false;
  342.             msg = "查找失败！";
  343.         }
  344.         map.put("success", success);
  345.         map.put("code",0);
  346.         map.put("data", user);
  347.         map.put("msg", msg);
  348.         return map;
  349.     }
  350.     
  351.     
  352.     /**
  353.      * 
  354.      * 描述：用户修改密码
  355.      * @author wanghaoyu
  356.      * @version 1.0
  357.      * @param user
  358.      * @return Map<String,Object>
  359.      * @exception Nothing
  360.      * @since 1.8
  361.      *
  362.      */
  363.     @Operation(name="修改用户密码")
  364.     @RequiresPermissions("14001")
  365.     @RequestMapping("/editUserPasswd")
  366.     @ResponseBody
  367.     public Map<String, Object> editUserPasswd(User user,String oldPassword){
  368.         Map<String, Object> map = new HashMap<String, Object>(16);
  369.         boolean success = false;
  370.         String msg = "";
  371.         if(userService.editPasswd(user,oldPassword)) {
  372.             success = true;
  373.             msg = "修改成功！";
  374.         }else {
  375.             success = false;
  376.             msg = "修改失败！";
  377.         }
  378.         map.put("success", success);
  379.         map.put("msg", msg);
  380.         map.put("code", 0);
  381.         return map;
  382.     }
  383.     
  384.     /**
  385.      * 
  386.      * 描述：获取忘记密码时的验证码
  387.      * @author wanghaoyu
  388.      * @version 1.0
  389.      * @param email
  390.      * @return 
  391.      * @exception Nothing
  392.      * @since 1.8
  393.      *
  394.      */
  395.     @Operation(name="获取找回密码所需的验证码")
  396.     @RequestMapping("/getForgotPasswdCode")
  397.     @ResponseBody
  398.     public Map<String, Object> getForgotPasswdCode(String email){
  399.         Map<String, Object> map = new HashMap<String, Object>(16);
  400.         boolean success = false;
  401.         String msg = "";
  402.         if(userService.findByEmail(email) == null){
  403.             //找不到该邮箱的账号
  404.             msg = "不存在的账号！";
  405.         }else{
  406.             try {
  407.                 //生成长度为4的随机数字
  408.                 String code = RandomStringUtil.getRandomCode(4, 0);
  409.                 //存到redis缓存中，有效时间为5分钟
  410.                 //先删除原来已存在的验证码
  411.                 redisUtil.remove(email);
  412.                 redisUtil.set(email, code, 300L);
  413.                 //发送邮件
  414.                 mailUtil.send(email, "找回密码", "验证码：" + code + "(验证码有效期为5分钟)");
  415.                 success = true;
  416.                 msg = "发送验证码成功！";
  417.             } catch (Exception e) {
  418.                 e.printStackTrace();
  419.                 msg = "获取验证码失败!";
  420.             }
  421.         }
  422.         map.put("success", success);
  423.         map.put("code", 0);
  424.         map.put("msg", msg);
  425.         return map;
  426.     }
  427.     
  428.     /**
  429.      * 
  430.      * 描述： 重设密码
  431.      * @author wanghaoyu
  432.      * @version 1.0
  433.      * @param email
  434.      * @return 
  435.      * @exception Nothing
  436.      * @since 1.8
  437.      *
  438.      */
  439.     @Operation(name="重设密码")
  440.     @RequestMapping("/resetPasswd")
  441.     @ResponseBody
  442.     public Map<String, Object> resetPasswd(String email, String code, String password){
  443.         Map<String, Object> map = new HashMap<String, Object>(16);
  444.         boolean success = false;
  445.         String msg = "";
  446.         try {
  447.             //先根据邮箱获取相应用户的信息
  448.             User user = userService.findByEmail(email);
  449.             if(user == null){
  450.                 msg = "不存在的账号！";
  451.             }else{
  452.                 //从redis缓存中获取验证码
  453.                 if(redisUtil.exists(email)){
  454.                     String redisCode = (String) redisUtil.get(email);
  455.                     if(redisCode.equals(code)){
  456.                         //验证码正确，修改密码
  457.                         User editUser = new User();
  458.                         editUser.setId(user.getId());
  459.                         editUser.setPassword(password);
  460.                         if(userService.edit(editUser)){
  461.                             msg = "修改成功！";
  462.                             success = true;
  463.                         }else{
  464.                             msg = "修改失败！";
  465.                         }
  466.                     }else{
  467.                         msg = "验证码错误！";
  468.                     }
  469.                 }else{
  470.                     msg = "验证码已过期，请重新获取！";
  471.                 }
  472.             }
  473.         } catch (Exception e) {
  474.             e.printStackTrace();
  475.             msg = "服务器出了小差，请稍等...";
  476.         }
  477.         map.put("success", success);
  478.         map.put("code", 0);
  479.         map.put("msg", msg);
  480.         return map;
  481.     }
  482.     
  483.     
  484. }

源码获取：博客首页 "资源" 里下载！ 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/155656
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号