客户输入手机号码，获取验证码后，输入后能成功登录。
首先修改拦截器，将手机端的发送短信和登录请求加到过滤器的放行请求中。
然后在拦截器中加入这些，利用session判断用户是否登录，用户如果没有登录就进行拦截。
//4-2、判断移动端登录状态，如果已登录，则直接放行
if(request.getSession().getAttribute("user") != null){
log.info("用户已登录，用户id为：{}",request.getSession().getAttribute("user"));
//利用基于ThreadLocal的工具类来获取用户id
Long userId=(Long) request.getSession().getAttribute("user");
BaseContext.setCurrentId(userId);
long id = Thread.currentThread().getId();
log.info("线程id:{}",id);
filterChain.doFilter(request,response);
return;
}
然后就是处理手机端发出的请求。首先是发送短信请求，我们在userController中进行处理。
/**
* 发送验证码
* @return
*/
@PostMapping("/sendMsg")
public R<String> sendMsg(@RequestBody User user, HttpSession session){
//获取手机号
String phone = user.getPhone();
//生成4位验证码
if(StringUtils.isNotEmpty(phone)){
String code = ValidateCodeUtils.generateValidateCode(4).toString();
log.info("验证码：{}",code);
//调用阿里云的短信发送api
//将验证码保存到session
session.setAttribute(phone,code);
return R.success("短信发送成功");
}else{
return R.error("短信发送失败");
}
}
然后是登录请求：
请求体：
我们使用Map来接收数据：
总体逻辑就是
1.比对map中获取的验证码和我们在session中暂存的phone对应的验证码是否相等，相等则登录
2.如果是新用户（即user表中没有相同phone的记录），要自动完成注册（即存入user表中）
3.设置session的user
/**
* 移动端用户登录
* @param map
* @param session
* @return
*/
@PostMapping("/login")
public R<User> login(@RequestBody Map map, HttpSession session){
log.info(map.toString());
String phone = (String) map.get("phone");
String code = (String) map.get("code");
String relCode = (String) session.getAttribute(phone);
if(relCode!=null&&relCode.equals(code)){
LambdaQueryWrapper<User> queryWrapper=new LambdaQueryWrapper<>();
queryWrapper.eq(User::getPhone,phone);
//如果是新用户就自动完成注册
User user = userService.getOne(queryWrapper);
if(user==null){
user=new User();
user.setPhone(phone);
userService.save(user);
}
session.setAttribute("user",user.getId());
return R.success(user);
}else{
return R.error("验证码错误");
}
}
测试。发现新用户已经存入user表中。
/**
* 员工退出
* @param request
* @return
*/
@PostMapping("/loginout")
public R<String> logout(HttpServletRequest request){
//清理session
request.getSession().removeAttribute("user");
return R.success("退出成功");
}
导入AddressBook实体类，创建Mapper、Service、ServiceImpl，此处不详细赘述
请求URL：
请求体：
编写controller方法：
利用BaseContext的ThreadLocal与当前线程绑定的userId作为userid属性的值。
/**
* 新增
*/
@PostMapping
public R<AddressBook> save(@RequestBody AddressBook addressBook) {
addressBook.setUserId(BaseContext.getCurrentId());
log.info("userId:{}",BaseContext.getCurrentId());
log.info("addressBook:{}", addressBook);
addressBookService.save(addressBook);
return R.success(addressBook);
}
测试，添加地址成功。
addressBook实体类有一个属性isDefault，为1则是默认地址，为0则不是。
看看请求：
编写controller代码
总体思路为：
1.获取所有userId与当前用户id相同的记录；
2.将这些记录的isDefault字段全部设置为0；
3.再将传进来的addressBook的usDefault设置为1，去更新数据库。
/**
* 设置默认地址
*/
@PutMapping("default")
public R<AddressBook> setDefault(@RequestBody AddressBook addressBook) {
log.info("addressBook:{}", addressBook);
LambdaUpdateWrapper<AddressBook> wrapper = new LambdaUpdateWrapper<>();
log.info(BaseContext.getCurrentId().toString());
wrapper.eq(AddressBook::getUserId, BaseContext.getCurrentId());
wrapper.set(AddressBook::getIsDefault, 0);
//先将所有这个用户的isdefault字段改为0
//SQL:update address_book set is_default = 0 where user_id = ?
addressBookService.update(wrapper);
//再将所有这个用户的isdefault字段改为1
addressBook.setIsDefault(1);
//SQL:update address_book set is_default = 1 where id = ?
addressBookService.updateById(addressBook);
return R.success(addressBook);
}
测试，变成了默认地址
服务代码：
/**
* 查询指定用户的全部地址
*/
@GetMapping("/list")
public R<List<AddressBook>> list(AddressBook addressBook) {
addressBook.setUserId(BaseContext.getCurrentId());
log.info("addressBook:{}", addressBook);
//条件构造器
LambdaQueryWrapper<AddressBook> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(null != addressBook.getUserId(), AddressBook::getUserId, addressBook.getUserId());
queryWrapper.orderByDesc(AddressBook::getUpdateTime);
//SQL:select * from address_book where user_id = ? order by update_time desc
return R.success(addressBookService.list(queryWrapper));
}
修改地址总体分两步：
1.根据id查询地址详细信息，用于回显；
2.提交修改后的地址详细信息。
其中第一个请求已经写好了：
controller：
/**
* 根据id查询地址
*/
@GetMapping("/{id}")
public R get(@PathVariable Long id) {
AddressBook addressBook = addressBookService.getById(id);
if (addressBook != null) {
return R.success(addressBook);
} else {
return R.error("没有找到该对象");
}
}
我们只需要写第二个请求：
/**
* 提交修改
* @param addressBook
* @return
*/
@PutMapping
public R<AddressBook> update(@RequestBody AddressBook addressBook){
addressBookService.updateById(addressBook);
return R.success(addressBook);
}
测试，修改成功
@DeleteMapping
public R<String> delAddress(Long ids){
addressBookService.removeById(ids);
return R.success("删除成功");
}
测试，删除成功。
在登录到首页的过程中，前端发出了两次请求：
首先是category/list请求，这个请求之前已经开发好了，能够获取所有的分类数据
第二个请求是获取购物车数据
这里我们先使用假数据代替。
测试
点击每个分类，还会发出按分类条件查询菜品信息的请求，这个请求我们之前也写过了。
搬出来之前的dishcontroller代码
@GetMapping("/list")
public R<List<Dish>> queryList(Dish dish){
LambdaQueryWrapper<Dish> queryWrapper=new LambdaQueryWrapper<>();
//查询条件
queryWrapper.eq(dish.getCategoryId()!=null,Dish::getCategoryId,dish.getCategoryId());
queryWrapper.eq(Dish::getStatus,1);//只查询起售的菜品
//排序条件
queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);
List<Dish> dishList = dishService.list(queryWrapper);
return R.success(dishList);
}
但是这里我们希望每个菜品后面能够选取对应口味，而不是只是加到购物车。而我们目前的这个请求，只能获取到菜品信息，没有办法拿到口味信息返给前端。为此，我们需要改造这个方法，返回值类型从Dish改为DishDto，用stream流修改内容。
@GetMapping("/list")
public R<List<DishDto>> queryList(Dish dish){
LambdaQueryWrapper<Dish> queryWrapper=new LambdaQueryWrapper<>();
//查询条件
queryWrapper.eq(dish.getCategoryId()!=null,Dish::getCategoryId,dish.getCategoryId());
queryWrapper.eq(Dish::getStatus,1);//只查询起售的菜品
//排序条件
queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);
List<Dish> dishList = dishService.list(queryWrapper);
//stream流处理每个dish对象，去口味表中查询对应菜品的口味数据，最终包装为DishDto类型
List<DishDto> dishDtoList = dishList.stream().map((item) -> {
//新建DishDto对象
DishDto dishDto = new DishDto();
//属性拷贝
BeanUtils.copyProperties(item, dishDto);
//根据dishId查出口味list
Long dishId = item.getId();
LambdaQueryWrapper<DishFlavor> queryWrapper1 = new LambdaQueryWrapper<>();
queryWrapper1.eq(DishFlavor::getDishId, dishId);
List<DishFlavor> flavorList = dishFlavorService.list(queryWrapper1);
//赋值
dishDto.setFlavors(flavorList);
return dishDto;
}).collect(Collectors.toList());
return R.success(dishDtoList);
}
现在就能选对应的菜品口味啦。
但是目前仍然有问题，就是选择套餐的话会报400
编写controller代码
/**
* 根据条件查询套餐数据
* @param setmeal
* @return
*/
@GetMapping("/list")
public R<List<Setmeal>> getSetDishes(Setmeal setmeal){
//get请求没有请求体，不能加requestBody注解
LambdaQueryWrapper<Setmeal> queryWrapper=new LambdaQueryWrapper<>();
queryWrapper.eq(setmeal.getCategoryId()!=null,Setmeal::getCategoryId,setmeal.getCategoryId());
queryWrapper.eq(setmeal.getStatus()!=null,Setmeal::getStatus,setmeal.getStatus());
queryWrapper.orderByAsc(Setmeal::getUpdateTime);
List<Setmeal> setmealList = setmealService.list(queryWrapper);
return R.success(setmealList);
}
发现套餐也能点开查看了
将菜品添加到购物车请求：
准备工作：
编写添加购物车controller代码
总体步骤为：
1.利用在threadLocal上绑定的userId设置userid；
2.查数据库套餐表中有没有相同的菜或套餐（id)；
3.有则获取原数量，update时+1；
4.没有则新增
/**
* 添加购物车
* @param shoppingCart
* @return
*/
@PostMapping("/add")
public R<ShoppingCart> addShop(@RequestBody ShoppingCart shoppingCart){
log.info("购物车数据：{}",shoppingCart.toString());
//设置用户id(利用在threadLocal上绑定的userId）
Long currentId = BaseContext.getCurrentId();
shoppingCart.setUserId(currentId);
//查数据库套餐表中有没有相同的菜或套餐（id)
//根据userId和dishId/setmealId查询
LambdaQueryWrapper<ShoppingCart> queryWrapper=new LambdaQueryWrapper<>();
queryWrapper.eq(ShoppingCart::getUserId,currentId);
Long dishId = shoppingCart.getDishId();
if(dishId==null){
//添加的是套餐
queryWrapper.eq(ShoppingCart::getSetmealId,shoppingCart.getSetmealId());
}else {
//添加的是菜品
queryWrapper.eq(ShoppingCart::getDishId,dishId);
}
//查询
ShoppingCart cartGetOne = shoppingCartService.getOne(queryWrapper);
if(cartGetOne !=null){
//如果有，相同记录数量直接加1
Integer number = cartGetOne.getNumber();
cartGetOne.setNumber(number+1);
shoppingCartService.updateById(cartGetOne);
}else {
//没有的话就插入一条数据
shoppingCart.setNumber(1);
shoppingCartService.save(shoppingCart);
cartGetOne =shoppingCart;
}
return R.success(cartGetOne);
}
然后就是点击购物车图标，需要显示当前用户购物车商品。页面发送ajax请求（假数据改回去）：
编写controller代码：
/**
* 查看购物车
* @return
*/
@GetMapping("/list")
public R<List<ShoppingCart>> list(){
//根据userid
Long userId = BaseContext.getCurrentId();
LambdaQueryWrapper<ShoppingCart> queryWrapper=new LambdaQueryWrapper<>();
queryWrapper.eq(ShoppingCart::getUserId,userId);
queryWrapper.orderByDesc(ShoppingCart::getCreateTime);
List<ShoppingCart> list = shoppingCartService.list(queryWrapper);
return R.success(list);
}
测试，购物车商品显示成功。
点击删除按钮，页面发送请求：
本质是根据userid去删除对应购物车数据
编写controller代码：
/**
* 清空购物车
* @return
*/
@DeleteMapping("/clean")
public R<String> del(){
Long userId = BaseContext.getCurrentId();
LambdaQueryWrapper<ShoppingCart> queryWrapper=new LambdaQueryWrapper<>();
queryWrapper.eq(ShoppingCart::getUserId,userId);
shoppingCartService.remove(queryWrapper);
return R.success("购物车清空成功");
}
测试，清空成功。
前三个请求功能已经有了：
只有第四个功能，点击“去支付”，完成下单操作：
开发具体代码之前仍然是订单类和订单明细类的基础功能：
接下来就是开发用户下单功能，由于下单业务稍微复杂点，我们在orderService层编写主要的业务逻辑代码。
总体有几个步骤：
1.获取当前用户id；
2.根据当前用户id，查询用户数据、购物车数据、地址簿数据；
3.向订单表插入一条数据；
4.向订单明细表插入多条数据；
5.清空用户购物车数据；
业务代码如下：
/**
* 用户下单
* @param orders
*/
@Transactional
@Override
public void submit(Orders orders) {
//获得当前用户id
Long userId = BaseContext.getCurrentId();
//获取当前用户购物车数据
LambdaQueryWrapper<ShoppingCart> shopQueryWrapper=new LambdaQueryWrapper<>();
shopQueryWrapper.eq(ShoppingCart::getUserId,userId);
List<ShoppingCart> shopList = shoppingCartService.list(shopQueryWrapper);
if(shopList==null||shopList.size()==0){
throw new CustomException("购物车为空，不能下单");
}
//查询用户数据
User user = userService.getById(userId);
//查询地址信息
Long addressBookId = orders.getAddressBookId();
AddressBook addressBook = addressBookService.getById(addressBookId);
if(addressBook==null){
throw new CustomException("地址信息有误，不能下单");
}
//向订单表插入数据（1条）
//计算购物车总金额，同时获取订单明细list
long orderId = IdWorker.getId();//生成订单号
AtomicInteger amount=new AtomicInteger(0);//原子int
List<OrderDetail> orderDetails=shopList.stream().map((item)->{
OrderDetail orderDetail=new OrderDetail();
orderDetail.setOrderId(orderId);
orderDetail.setNumber(item.getNumber());
orderDetail.setDishFlavor(item.getDishFlavor());
orderDetail.setDishId(item.getDishId());
orderDetail.setSetmealId(item.getSetmealId());
orderDetail.setName(item.getName());
orderDetail.setImage(item.getImage());
orderDetail.setAmount(item.getAmount());
amount.addAndGet(item.getAmount().multiply(new BigDecimal(item.getNumber())).intValue());
return orderDetail;
}).collect(Collectors.toList());
//orders赋值
orders.setId(orderId);
orders.setNumber(String.valueOf(orderId));
orders.setOrderTime(LocalDateTime.now());
orders.setCheckoutTime(LocalDateTime.now());
orders.setStatus(2);
orders.setAmount(new BigDecimal(amount.get()));//总金额
orders.setUserId(userId);
orders.setUserName(user.getName());
orders.setConsignee(addressBook.getConsignee());
orders.setPhone(addressBook.getPhone());
orders.setAddress((addressBook.getProvinceName() == null ? "" : addressBook.getProvinceName())
+ (addressBook.getCityName() == null ? "" : addressBook.getCityName())
+ (addressBook.getDistrictName() == null ? "" : addressBook.getDistrictName())
+ (addressBook.getDetail() == null ? "" : addressBook.getDetail()));
this.save(orders);
//向订单明细表插入数据（多条）
orderDetailService.saveBatch(orderDetails);
//清空购物车数据
shoppingCartService.remove(shopQueryWrapper);
}