目录
3.2、Mapper接口AddressBookService
3.4、业务层实现类AddressBookServiceImpl
一、导入用户地址簿相关功能代码
1、需求分析：
2、数据模型：
3、导入功能代码：
3.1、实体类AddressBook
/**
* 用户地址簿
*/
@Data
public class AddressBook implements Serializable {
private static final long serialVersionUID=1l;
private Long id;
//用户id
private Long userId;
//收货人
private String consignee;
//性别 0 女 1 男
private Integer sex;
//手机号
private String phone;
//省级区划编号
private String provinceCode;
//省级名称
private String provinceName;
//市级区划编号
private String cityCode;
//市级名称
private String cityName;
//区级区划编号
private String districtCode;
//区级名称
private String districtName;
//详细地址
private String detail;
//标签
private String label;
//默认 0 否 1 是
private Integer isDefault;
//将时间转换为自己要的时间格式向前端发送(具体还是json数据不变)
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@TableField(fill = FieldFill.INSERT) //插入时填充字段
private Date createTime;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@TableField(fill = FieldFill.INSERT_UPDATE) //插入和更新时填充字段
private Date updateTime;
@TableField(fill = FieldFill.INSERT) //插入时填充字段
private Long createUser;
@TableField(fill = FieldFill.INSERT_UPDATE) //插入和更新时填充字段
private Long updateUser;
private Integer isDeleted;
}3.2、Mapper接口AddressBookService
@Mapper
public interface AddressBookMapper extends BaseMapper<AddressBook> {
}3.3、业务层接口AddressBookService
public interface AddressBookService extends IService<AddressBook> {
}3.4、业务层实现类AddressBookServiceImpl
@Service
public class AddressBookServiceImpl extends ServiceImpl<AddressBookMapper, AddressBook> implements AddressBookService {
}3.5、控制层AddressBookController
/**
* 用户地址簿管理
*/
@RestController
@RequestMapping("/addressBook")
@Slf4j
public class AddressBookController {
@Autowired
private AddressBookService addressBookService;
}4.功能实现：
/**
* 用户地址簿管理
*/
@RestController
@RequestMapping("/addressBook")
@Slf4j
public class AddressBookController {
@Autowired
private AddressBookService addressBookService;
/**
* 添加地址成功
* @param address
* @return
*/
@PostMapping
public R<String> save(@RequestBody AddressBook address){
address.setUserId(BaseContext.getCurrentId());
addressBookService.save(address);
return R.success("添加成功");
}
/**
* 获取该用户的所有地址
* @return
*/
@GetMapping("/list")
public R<List> list(){
LambdaQueryWrapper<AddressBook> eq = Wrappers.lambdaQuery(AddressBook.class)
.eq(AddressBook::getUserId, BaseContext.getCurrentId())
.orderByDesc(AddressBook::getUpdateTime);
List<AddressBook> list = addressBookService.list(eq);
if(list == null){
return R.error("没有找到任何地址");
}
return R.success(list);
}
/**
* 设置默认地址
* @param address
* @return
*/
@PutMapping("/default")
public R<AddressBook> defaultId(@RequestBody AddressBook address){
//默认地址只有一个
//把该用户的所有地址设置为is_default = 0（相当于清空默认）
LambdaUpdateWrapper<AddressBook> set = Wrappers.lambdaUpdate(AddressBook.class)
.eq(AddressBook::getUserId, BaseContext.getCurrentId())
.set(AddressBook::getIsDefault, 0);
//UPDATE address_book SET is_default = 0 WHERE user_id = ?;
addressBookService.update(set);
//再将默认地址设为is_default = 0
address.setIsDefault(1);
//UPDATE address_book SET is_default = 1 WHERE id = ?;
addressBookService.updateById(address);
return R.success(address);
}
/**
* 查询单个地址
* @param id
* @return
*/
@GetMapping("/{id}")
public R<AddressBook> getById(@PathVariable Long id){
AddressBook byId = addressBookService.getById(id);
if(byId == null){
return R.error("没有找到该对象");
}
return R.success(byId);
}
/**
* 查询默认地址
* @return
*/
@GetMapping("/default")
public R<AddressBook> getOne(){
LambdaQueryWrapper<AddressBook> eq = Wrappers.lambdaQuery(AddressBook.class)
.eq(AddressBook::getUserId, BaseContext.getCurrentId())
.eq(AddressBook::getIsDefault, 1);
AddressBook one = addressBookService.getOne(eq);
if(one == null){
return R.error("没有找到该对象");
}
return R.success(one);
}
/**
* 修改地址
* @param addressBook
* @return
*/
@PutMapping
public R<String> update(@RequestBody AddressBook addressBook){
addressBookService.updateById(addressBook);
return R.success("修改成功");
}
/**
* 获取最新地址
* @return
*/
@GetMapping("/lastUpdate")
public R<AddressBook> lastUpdate(){
LambdaQueryWrapper<AddressBook> one = Wrappers.lambdaQuery(AddressBook.class)
.eq(AddressBook::getUserId, BaseContext.getCurrentId())
.orderByDesc(AddressBook::getUpdateTime)
.last("limit 1");
AddressBook one1 = addressBookService.getOne(one);
return R.success(one1);
}
/**
* 删除地址
* @param ids
* @return
*/
@DeleteMapping
public R<String> delete(Long ids){
LambdaQueryWrapper<AddressBook> eq = Wrappers.lambdaQuery(AddressBook.class)
.eq(AddressBook::getUserId, BaseContext.getCurrentId())
.eq(AddressBook::getId,ids);
addressBookService.remove(eq);
return R.success("删除成功");
}
}二、菜品展示
1、需求分析
2、代码开发
/**
* 根据条件查询对应的菜品数据
* @param dish
* @return
*/
@GetMapping("list")
public R<List<DishDto>> list(Dish dish){
//构造查询条件,并添加排序条件,再查询状态为1（起售状态）的菜品
LambdaQueryWrapper<Dish> dishLambdaQueryWrapper = Wrappers.lambdaQuery(Dish.class)
.eq(dish.getCategoryId() != null, Dish::getCategoryId, dish.getCategoryId())
.eq(Dish::getStatus,1)
.orderByAsc(Dish::getSort)
.orderByDesc(Dish::getUpdateTime);
List<Dish> list = dishService.list(dishLambdaQueryWrapper);
List<DishDto> collect = list.stream().map((item) -> {
DishDto dishDto = new DishDto();
BeanUtils.copyProperties(item, dishDto);
Long categoryId = item.getCategoryId(); //分类id
//根据id查询分类对象
Category byId = categoryService.getById(categoryId);
if (byId != null) {
String byIdName = byId.getName();
dishDto.setCategoryName(byIdName);
}
//当前菜品的id
Long dishId = item.getId();
//获取当前菜品口味
LambdaQueryWrapper<DishFlavor> eq = Wrappers.lambdaQuery(DishFlavor.class)
.eq(DishFlavor::getDishId, dishId);
List<DishFlavor> dishFlavorsList = dishFlavorService.list(eq);
dishDto.setFlavors(dishFlavorsList);
return dishDto;
}).collect(Collectors.toList());
return R.success(collect);
}
/**
* 根据条件查询套餐数据
* @return
*/
@GetMapping("list")
public R<List<Setmeal>> list(Setmeal setmeal){
LambdaQueryWrapper<Setmeal> eq = Wrappers.lambdaQuery(Setmeal.class)
.eq(setmeal.getCategoryId() != null,Setmeal::getCategoryId,setmeal.getCategoryId())
.eq(setmeal.getStatus() != null,Setmeal::getStatus, setmeal.getStatus())
.orderByDesc(Setmeal::getUpdateTime);
List<Setmeal> list = setmealService.list(eq);
return R.success(list);
}三、购物车
1、需求分析
2、数据模型
3、代码开发
实体类：
@Data
public class ShoppingCart implements Serializable {
private static final long serialVersionUID=1L;
private Long id;
//名称
private String name;
//图片
private String image;
//用户id
private Long userId;
//菜品id
private Long dishId;
//套餐id
private Long setmealId;
//口味
private String dishFlavor;
//数量
private Integer number;
//金额
private BigDecimal amount;
//将时间转换为自己要的时间格式向前端发送(具体还是json数据不变)
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@TableField(fill = FieldFill.INSERT) //插入时填充字段
private LocalDateTime createTime;
}控制类：
@RestController
@RequestMapping("/shoppingCart")
@Slf4j
public class ShoppingCartController {
@Autowired
private ShoppingCartService shoppingCartService;
/**
* 获取购物车内商品的集合
* @return
*/
@GetMapping("/list")
public R<List<ShoppingCart>> list(){
LambdaQueryWrapper<ShoppingCart> shoppingCartLambdaQueryWrapper = Wrappers.lambdaQuery(ShoppingCart.class)
.eq(ShoppingCart::getUserId, BaseContext.getCurrentId())
.orderByAsc(ShoppingCart::getCreateTime);
List<ShoppingCart> list = shoppingCartService.list(shoppingCartLambdaQueryWrapper);
return R.success(list);
}
/**
* 购物车中添加商品
* @param shoppingCart
* @return
*/
@PostMapping("/add")
public R<ShoppingCart> add(@RequestBody ShoppingCart shoppingCart){
//设置用户id，指定当前是哪个用户的购物车数据
Long currentId = BaseContext.getCurrentId();
shoppingCart.setUserId(currentId);
LambdaQueryWrapper<ShoppingCart> shoppingCartLambdaQueryWrapper = new LambdaQueryWrapper<>();
shoppingCartLambdaQueryWrapper.eq(currentId != null,ShoppingCart::getUserId, currentId);
Long dishId = shoppingCart.getDishId();
if(dishId != null){
//添加到购物车的是菜品
shoppingCartLambdaQueryWrapper.eq(ShoppingCart::getDishId, dishId);
}else{
//添加到购物车的是套餐
shoppingCartLambdaQueryWrapper.eq(shoppingCart.getSetmealId() != null,ShoppingCart::getSetmealId, shoppingCart.getSetmealId());
}
//查询当前菜品或者套餐是否在购物车中
ShoppingCart one = shoppingCartService.getOne(shoppingCartLambdaQueryWrapper);
if(one != null){
//如果已经存在，就在原来数量的基础上加一
Integer number = one.getNumber();
one.setNumber(number + 1);
shoppingCartService.updateById(one);
}else{
//如果不存在，则添加到购物车，数量默认就是一
shoppingCart.setNumber(1);
shoppingCartService.save(shoppingCart);
one = shoppingCart;
}
return R.success(one);
}
/**
* 购物车中修改商品
* @param shoppingCart
* @return
*/
@PostMapping("/sub")
public R<String> sub(@RequestBody ShoppingCart shoppingCart){
LambdaQueryWrapper<ShoppingCart> eq = Wrappers.lambdaQuery(ShoppingCart.class)
.eq(shoppingCart.getUserId() != null, ShoppingCart::getUserId, BaseContext.getCurrentId())
.eq(shoppingCart.getDishId() != null,ShoppingCart::getDishId,shoppingCart.getDishId())
.eq(shoppingCart.getSetmealId() != null,ShoppingCart::getSetmealId,shoppingCart.getSetmealId());
ShoppingCart one = shoppingCartService.getOne(eq);
Integer number = one.getNumber();
if(number == 1){
shoppingCartService.remove(eq);
}
if(number > 1){
number -= 1;
one.setNumber(number);
shoppingCartService.update(one, eq);
}
return R.success("修改成功");
}
/**
* 清空购物车
* @return
*/
@DeleteMapping("/clean")
public R<String> clean(){
Long currentId = BaseContext.getCurrentId();
LambdaQueryWrapper<ShoppingCart> eq = Wrappers.lambdaQuery(ShoppingCart.class)
.eq(currentId != null, ShoppingCart::getUserId, currentId);
shoppingCartService.remove(eq);
return R.success("清空购物车成功");
}
}四、用户下单
1、需求分析：
2、数据模型：
3、代码开发：
实体类：
@Data
public class Orders implements Serializable {
private static final long serialVersionUID=1L;
private Long id;
//订单号
private String number;
//订单状态 1待付款 2待配送 3已配送 4已完成 5已取消
private Integer status;
//下单用户
private Long userId;
//地址id
private Long addressBookId;
//下单时间
//将时间转换为自己要的时间格式向前端发送(具体还是json数据不变)
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@TableField(fill = FieldFill.INSERT) //插入时填充字段
private LocalDateTime orderTime;
//结账时间
//将时间转换为自己要的时间格式向前端发送(具体还是json数据不变)
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@TableField(fill = FieldFill.INSERT) //插入时填充字段
private LocalDateTime checkoutTime;
//支付方式 1微信 2支付宝
private Integer payMethod;
//实收金额
private BigDecimal amount;
//备注
private String remark;
private String phone;
private String address;
private String userName;
private String consignee;
}@Data
public class OrderDetail implements Serializable {
private static final long serialVersionUID=1L;
private Long id;
//名字
private String name;
//图片
private String image;
//订单id
private Long orderId;
//菜品id
private Long dishId;
//套餐id
private Long setmealId;
//口味
private String dishFlavor;
//数量
private Integer number;
//金额
private BigDecimal amount;
}@Data
public class OrdersDto extends Orders {
private List<OrderDetail> orderDetails;
}服务层：重写下单方法
public interface OrdersService extends IService<Orders> {
/**
* 用户下单
* @param orders
*/
public void submit(Orders orders);
}@Service
public class OrdersServiceImpl extends ServiceImpl<OrdersMapper, Orders> implements OrdersService {
@Autowired
private ShoppingCartService shoppingCartService;
@Autowired
private UserService userService;
@Autowired
private AddressBookService addressBookService;
@Autowired
private OrderDetailService orderDetailService;
/**
* 用户下单
* @param orders
*/
@Override
@Transactional
public void submit(Orders orders) {
//获取当前用户id
Long currentId = BaseContext.getCurrentId();
//查询当前用户的购物车数据
LambdaQueryWrapper<ShoppingCart> eq = Wrappers.lambdaQuery(ShoppingCart.class)
.eq(ShoppingCart::getUserId, currentId);
List<ShoppingCart> list = shoppingCartService.list(eq);
if(list == null || list.size() == 0){
throw new CustomException("购物车为空，不能下单");
}
//查询用户数据
User byId = userService.getById(currentId);
//查询地址数据
Long addressBookId = orders.getAddressBookId();
AddressBook addressBook = addressBookService.getById(addressBookId);
if(addressBook == null){
throw new CustomException("用户地址信息有误，不能下单");
}
//算总金额
AtomicInteger amount = new AtomicInteger(0);
List<OrderDetail> orderDetails = list.stream().map((item) -> {
OrderDetail orderDetail = new OrderDetail();
orderDetail.setOrderId(currentId);
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());
//每次遍历都会将金额加上，算出总金额，addAndGet就是+=，multiply相乘
amount.addAndGet(item.getAmount().multiply(new BigDecimal(item.getNumber())).intValue());
return orderDetail;
}).collect(Collectors.toList());
long orderId = IdWorker.getId(); //自动生成订单号
//向订单表插入数据
orders.setId(orderId);
orders.setStatus(2);
orders.setAmount(new BigDecimal(amount.get()));
orders.setUserId(currentId);
orders.setNumber(String.valueOf(orderId));
orders.setUserName(byId.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(eq);
}
}控制层：
@RestController
@Slf4j
@RequestMapping("/order")
public class OrdersController {
@Autowired
private OrdersService ordersService;
@Autowired
private OrderDetailService orderDetailService;
/**
* 用户下单
* @param orders
* @return
*/
@PostMapping("/submit")
public R<String> submit(@RequestBody Orders orders){
ordersService.submit(orders);
return R.success("下单成功");
}
/**
* 移动端分页查询订单
* @param page
* @param pageSize
* @return
*/
@GetMapping("/userPage")
public R<Page> userPage(int page,int pageSize){
Page<Orders> ordersPage = new Page<>(page,pageSize);
Page<OrdersDto> ordersDtoPage = new Page<>();
//当前登录用户id
Long id = BaseContext.getCurrentId();
LambdaQueryWrapper<Orders> eq = Wrappers.lambdaQuery(Orders.class)
.eq(Orders::getUserId,id)
.orderByDesc(Orders::getOrderTime);
ordersService.page(ordersPage,eq);
//对象拷贝:将第一个参数对象，拷贝到第二个参数的对象中，第三个参数表示忽略拷贝的内容
BeanUtils.copyProperties(ordersPage,ordersDtoPage);
List<Orders> records = ordersPage.getRecords();
List<OrdersDto> list = records.stream().map((item) -> {
OrdersDto ordersDto = new OrdersDto();
BeanUtils.copyProperties(item,ordersDto);
Long categoryId = item.getUserId(); //分类id
LambdaQueryWrapper<OrderDetail> orderId = Wrappers.lambdaQuery(OrderDetail.class)
.eq(OrderDetail::getOrderId, categoryId);
//根据订单号查询分类对象
List<OrderDetail> listOrderDetail = orderDetailService.list(orderId);
ordersDto.setOrderDetails(listOrderDetail);
return ordersDto;
}).collect(Collectors.toList());
ordersDtoPage.setRecords(list);
return R.success(ordersDtoPage);
}
/**
* 客户端订单分页查询
* @param page
* @param pageSize
* @param number
* @return
*/
@GetMapping("/page")
public R<Page> page(int page, int pageSize, Long number,String beginTime,String endTime){
Page<Orders> ordersPage = new Page<>(page, pageSize);
Page<OrdersDto> ordersDtoPage = new Page<>();
//当前登录用户id
Long id = BaseContext.getCurrentId();
LambdaQueryWrapper<Orders> eq = Wrappers.lambdaQuery(Orders.class)
.eq(Orders::getUserId,id)
.like(number != null, Orders::getNumber, number)
.between(beginTime!=null&&endTime!=null,Orders::getCheckoutTime,beginTime,endTime)
.orderByDesc(Orders::getOrderTime);
BeanUtils.copyProperties(ordersPage,ordersDtoPage);
ordersService.page(ordersPage,eq);
List<Orders> records = ordersPage.getRecords();
List<OrdersDto> list = records.stream().map((item) -> {
OrdersDto ordersDto = new OrdersDto();
//用户id
Long userId = item.getUserId();
LambdaQueryWrapper<OrderDetail> eq1 = Wrappers.lambdaQuery(OrderDetail.class)
.eq(OrderDetail::getOrderId, userId);
List<OrderDetail> orderDetails = orderDetailService.list(eq1);
ordersDto.setOrderDetails(orderDetails);
BeanUtils.copyProperties(item,ordersDto);
return ordersDto;
}).collect(Collectors.toList());
ordersDtoPage.setRecords(list);
return R.success(ordersDtoPage);
}
/**
* 修改订单状态
* @param orders
* @return
*/
@PutMapping
public R<String> update(@RequestBody Orders orders){
//获取当前登录用户id
Long currentId = BaseContext.getCurrentId();
LambdaQueryWrapper<Orders> eq = Wrappers.lambdaQuery(Orders.class)
.eq(currentId != null, Orders::getUserId, currentId)
.eq(orders.getNumber() != null, Orders::getNumber, orders.getNumber());
ordersService.update(orders,eq);
return R.success("订单已派送");
}
}
1224
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
