瑞吉外卖实现

packagecom.zhi.reggie.controller;
importcom.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
importcom.baomidou.mybatisplus.extension.plugins.pagination.Page;
importcom.zhi.reggie.common.R;
importcom.zhi.reggie.entity.Employee;
importcom.zhi.reggie.service.EmployeeService;
importlombok.extern.slf4j.Slf4j;
importorg.apache.commons.lang.StringUtils;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.util.DigestUtils;
importorg.springframework.web.bind.annotation.*;
importjavax.servlet.http.HttpServletRequest;
@Slf4j//日志@RestController@RequestMapping("/employee")
publicclassEmployeeController {
@AutowiredprivateEmployeeServiceemployeeService;
//员工登陆@PostMapping("/login")
publicR<Employee>login(HttpServletRequestrequest, @RequestBodyEmployeeemployee){
//注意这里传的request方便把登陆者的id存到session当中//后一个参数传入的是json格式//1.密码md5加密处理Stringpassword=employee.getPassword();
password=DigestUtils.md5DigestAsHex(password.getBytes());
//2.根据username查询数据库LambdaQueryWrapper<Employee>queryWrapper=newLambdaQueryWrapper<>();
queryWrapper.eq(Employee::getUsername,employee.getUsername());
Employeeemp=employeeService.getOne(queryWrapper);
//3.如果没有查到就返回登陆失败结果if(emp==null) {
returnR.error("登陆失败");
        }
//密码比对if(!emp.getPassword().equals(password)){
returnR.error("登陆失败");
        }
//查看员工状态if(emp.getStatus() ==0){
returnR.error("用户已经被禁用");
        }
//登陆成功，把员工id存入session并返回登陆成功结果request.getSession().setAttribute("employee",emp.getId());
returnR.success(emp);
    }
//员工退出@PostMapping("/logout")
publicR<String>logout(HttpServletRequestrequest){
//清理session中保存的当前员工idrequest.getSession().removeAttribute("employee");
returnR.success(" 退出成功");
    }
@PostMappingpublicR<String>save(HttpServletRequestrequest, @RequestBodyEmployeeemployee){
log.info("新增员工，员工信息:{}",employee.toString());
//设置初始密码123456，md5加密employee.setPassword(DigestUtils.md5DigestAsHex("123456".getBytes()));
//employee.setCreateTime(LocalDateTime.now());//employee.setUpdateTime(LocalDateTime.now());//获得当前登陆用户的id//Long empId = (Long)request.getSession().getAttribute("employee");//employee.setCreateUser(empId);//创建人信息//employee.setUpdateUser(empId);employeeService.save(employee);
returnR.success("新增员工成功");
    }
//员工信息的分页@GetMapping("/page")
publicR<Page>page(intpage,intpageSize,Stringname){
log.info("page ={},pagesize = {}, name ={}",page,pageSize,name);
//构造分页构造器PagepageInfo=newPage(page,pageSize);
//构造条件构造器LambdaQueryWrapper<Employee>queryWrapper=newLambdaQueryWrapper();
//添加过滤条件queryWrapper.like(StringUtils.isNotEmpty(name),Employee::getName,name);
//添加排序条件queryWrapper.orderByDesc(Employee::getUpdateTime);
employeeService.page(pageInfo,queryWrapper);
returnR.success(pageInfo);
    }
//根据id修改员工信息@PutMappingpublicR<String>update(HttpServletRequestrequest,@RequestBodyEmployeeemployee){
LongempId= (Long) request.getSession().getAttribute("employee");
//employee.setUpdateTime(LocalDateTime.now());//employee.setUpdateUser(empId);employeeService.updateById(employee);
returnR.success("员工信息修改成功");
    }
//根据id查询员工信息@GetMapping("/{id}")
publicR<Employee>getById(@PathVariablelongid){
log.info("根据id查询员工信息");
Employeeemployee=employeeService.getById(id);
if(employee!=null){
returnR.success(employee);
        }
returnR.error("没有查询到员工信息");
    }
}

packagecom.zhi.reggie.common;
importlombok.Data;
importjava.io.Serializable;
importjava.util.HashMap;
importjava.util.Map;
//通用返回结果，服务器端响应得数据最终都会封装成此类@DatapublicclassR<T>implementsSerializable {
privateIntegercode; //编码：1成功，0和其它数字为失败privateStringmsg; //错误信息privateTdata; //数据privateMapmap=newHashMap(); //动态数据publicstatic<T>R<T>success(Tobject) {
R<T>r=newR<T>();
r.data=object;
r.code=1;
returnr;
    }
publicstatic<T>R<T>error(Stringmsg) {
Rr=newR();
r.msg=msg;
r.code=0;
returnr;
    }
publicR<T>add(Stringkey, Objectvalue) {
this.map.put(key, value);
returnthis;
    }
}

packagecom.zhi.reggie.filter;
importcom.alibaba.fastjson.JSON;
importcom.zhi.reggie.common.BaseContext;
importcom.zhi.reggie.common.R;
importlombok.extern.slf4j.Slf4j;
importorg.springframework.stereotype.Component;
importorg.springframework.util.AntPathMatcher;
importjavax.servlet.*;
importjavax.servlet.annotation.WebFilter;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
importjava.io.IOException;
@Slf4j@Component@WebFilter(filterName="LoginCheckFilter",urlPatterns="/*")
publicclassLoginCheckFilterimplementsFilter {
publicstaticfinalAntPathMatcherPATH_MATCHER=newAntPathMatcher();
@OverridepublicvoiddoFilter(ServletRequestservletRequest, ServletResponseservletResponse, FilterChainfilterChain) throwsIOException, ServletException {
HttpServletRequestrequest= (HttpServletRequest)servletRequest;
HttpServletResponseresponse= (HttpServletResponse) servletResponse;
// 1.获取本次请求的urlStringrequestURI=request.getRequestURI();
log.info("拦截到请求： {}",requestURI);
String[] urls=newString[]{
"/employee/login",
"/employee/logout",//这些是放行的url"/backend/**",
"/front/**",
"/common/**",
"/user/sendMsg",//移动端发送短信"/user/login", // 移动端登陆"/doc.html",
"/webjars/**",
"/swagger-resources",
"/v2/api-docs"         };
//2.判断本次请求是否需要处理booleancheck=check(urls,requestURI);
if(check){
filterChain.doFilter(request,response);
log.info("本次请求{}不需要处理",requestURI);
return;//不需要处理，直接放行        }
//3-1.判断登陆状态，如果已经登陆，直接放行if(request.getSession().getAttribute("employee") !=null){
log.info("用户已登陆,用户id为:{}",request.getSession().getAttribute("employee"));
LongempId= (Long) request.getSession().getAttribute("employee");
BaseContext.setCurrentId(empId);
filterChain.doFilter(request,response);
return;
        }
//3-2（手机端）.判断登陆状态，如果已经登陆，直接放行if(request.getSession().getAttribute("user") !=null){
log.info("用户已登陆,用户id为:{}",request.getSession().getAttribute("user"));
LonguserId= (Long) request.getSession().getAttribute("user");
BaseContext.setCurrentId(userId);
filterChain.doFilter(request,response);
return;
        }
//4.如果未登录则返回未登录结果,通过输出流方式向客户端页面响应数据response.getWriter().write(JSON.toJSONString(R.error("NOTLOGIN")));
log.info("用户未登陆");
    }
publicbooleancheck(String[] urls,StringrequestURI){
//检查本次请求是否放行for (Stringurl : urls) {
booleanmatch=PATH_MATCHER.match(url,requestURI);
if(match){
returntrue;
            }
        }
returnfalse;
    }
//新增员工}

packagecom.zhi.reggie.controller;
importcom.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
importcom.zhi.reggie.common.R;
importcom.zhi.reggie.entity.User;
importcom.zhi.reggie.service.UserService;
importcom.zhi.reggie.utils.SMSUtils;
importcom.zhi.reggie.utils.ValidateCodeUtils;
importlombok.extern.slf4j.Slf4j;
importorg.apache.commons.lang.StringUtils;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.data.redis.core.RedisTemplate;
importorg.springframework.web.bind.annotation.PostMapping;
importorg.springframework.web.bind.annotation.RequestBody;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RestController;
importjavax.servlet.http.HttpSession;
importjava.util.Map;
importjava.util.concurrent.TimeUnit;
@RestController@RequestMapping("/user")
@Slf4jpublicclassUserController {
@AutowiredprivateRedisTemplateredisTemplate;
@AutowiredprivateUserServiceuserService;
/*** 发送手机短信验证码* @param user* @return*/@PostMapping("/sendMsg")
publicR<String>sendMsg(@RequestBodyUseruser, HttpSessionsession){
//获取手机号Stringphone=user.getPhone();
if(StringUtils.isNotEmpty(phone)){
//生成随机的4位验证码Stringcode=ValidateCodeUtils.generateValidateCode(4).toString();
log.info("code={}",code);
//调用阿里云提供的短信服务API完成发送短信//SMSUtils.sendMessage("瑞吉外卖","",phone,code);//需要将生成的验证码保存到Session//session.setAttribute(phone,code);//将生成的验证码缓存到redis中，并且设置有效期为5分钟redisTemplate.opsForValue().set(phone,code,5, TimeUnit.MINUTES);
returnR.success("手机验证码短信发送成功");
        }
returnR.error("短信发送失败");
    }
/*** 移动端用户登录* @param map* @param session* @return*/@PostMapping("/login")
publicR<User>login(@RequestBodyMapmap, HttpSessionsession){
log.info(map.toString());
//获取手机号Stringphone=map.get("phone").toString();
//获取验证码Stringcode=map.get("code").toString();
//从Session中获取保存的验证码//Object codeInSession = session.getAttribute(phone);//从reids中获取缓存的验证码ObjectcodeInSession=redisTemplate.opsForValue().get(phone);
//进行验证码的比对（页面提交的验证码和Session中保存的验证码比对）if(codeInSession!=null&&codeInSession.equals(code)){
//如果能够比对成功，说明登录成功LambdaQueryWrapper<User>queryWrapper=newLambdaQueryWrapper<>();
queryWrapper.eq(User::getPhone,phone);
Useruser=userService.getOne(queryWrapper);
if(user==null){
//判断当前手机号对应的用户是否为新用户，如果是新用户就自动完成注册user=newUser();
user.setPhone(phone);
user.setStatus(1);
userService.save(user);
            }
session.setAttribute("user",user.getId());
//如果用户登陆成功，删除redis中缓存的验证码redisTemplate.delete(phone);
returnR.success(user);
        }
returnR.error("登录失败");
    }
}