市面上有很多第三方提供的短信服务，这些第三方短信服务和各个运营商（移动、联通、电信）对接，我么只需要注册成会员并且按照提供的开发文档进行调用就可以发送短信了。这些服务一般都是收费的。
常用的短信服务：（阿里云、华为云、腾讯云、京东、梦网、乐信）
阿里云短信服务（Short Message Service）是广大企业客户快速触达手机用户所优选使用的通信能力。调用API或群发助手，即可发送验证码、通知类和营销类短信；国内验证码秒级触达，到达率最高可达99%；国际/港澳台短信覆盖200多个国家和地区，安全稳定，广受出海企业选用。
应用场景：（验证码，短信通知，推广短信 ）
阿里云官网：https://www.aliyun.com/
进入短信服务管理页面，选择国内消菜单：
短信签名是短信发送者的署名，表示发送方的身份。
1、添加签名
2、切换到模板管理标签页：
短信模板包含短信发送内容、场景、变量信息。
添加模板：
设置签名，和模板后设置AccessKey
光标移动到用户头像上，在弹出的窗口中点击[AccessKey管理]：
点击后跳转到：
创建成功：
C
使用阿里云短信服务发送短信，参考官方提供的文档即可。
快速入门：链接
具体步骤如下：
1、导入Maven坐标
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>aliyun-java-sdk-core</artifactId>
<version>4.5.16</version>
</dependency>
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>aliyun-java-sdk-dysmsapi</artifactId>
<version>1.1.0</version>
</dependency>
2、调用API
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.exceptions.ServerException;
import com.aliyuncs.profile.DefaultProfile;
import com.google.gson.Gson;
import java.util.*;
import com.aliyuncs.dysmsapi.model.v20170525.*;
public class SendSms {
public static void main(String[] args) {
DefaultProfile profile = DefaultProfile.getProfile("cn-beijing", "<your-access-key-id>", "<your-access-key-secret>");
/** use STS Token
DefaultProfile profile = DefaultProfile.getProfile(
"<your-region-id>", // The region ID
"<your-access-key-id>", // The AccessKey ID of the RAM account
"<your-access-key-secret>", // The AccessKey Secret of the RAM account
"<your-sts-token>"); // STS Token
**/
IAcsClient client = new DefaultAcsClient(profile);
SendSmsRequest request = new SendSmsRequest();
request.setPhoneNumbers("1368846****");//接收短信的手机号码
request.setSignName("阿里云");//短信签名名称
request.setTemplateCode("SMS_20933****");//短信模板CODE
request.setTemplateParam("张三");//短信模板变量对应的实际值
try {
SendSmsResponse response = client.getAcsResponse(request);
System.out.println(new Gson().toJson(response));
} catch (ServerException e) {
e.printStackTrace();
} catch (ClientException e) {
System.out.println("ErrCode:" + e.getErrCode());
System.out.println("ErrMsg:" + e.getErrMsg());
System.out.println("RequestId:" + e.getRequestId());
}
}
}
为了方便用户登录，移动端通常会提供手机验证码登录的功能。
手机验证码登录的优点：
登录流程：
输入手机号->获取验证码->输入验证码->点击登录->登录成功
注意：通过手机验证码登录，手机号是区分不同用户的标识。
通过手机验证码登录时，涉及到的表为user表即，用户表，结构如下：
前端页面和服务端的交互过程：
1、在登录页面（front/page/login.html2）输入手机号，点击【获取验证码】按钮，页面发送ajax请求，在服务端调用短信服务API给指定的手机号发送验证码短信
2、在登录页面输入验证码，点击登录，发送ajax请求，在服务端处理登录请求
开发手机验证码登录功能，就是在服务端编写代码去处理前端页面发送的这两次请求。
开发业务功能前，先将需要用到的类和接口基本结构创建好：
/**
* 用户信息
*/
@Data
public class User implements Serializable {
private static final long serialVersionUID = 1L;
private Long id;
//姓名
private String name;
//手机号
private String phone;
//性别 0 女 1 男
private String sex;
//身份证号
private String idNumber;
//头像
private String avatar;
//状态 0:禁用，1:正常
private Integer status;
}
@Mapper
public interface UserMapper extends BaseMapper<User> {
}
public interface UserService extends IService<User> {
}
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}
@RestController
@RequestMapping("/user")
public class Usercontroller {
@Autowired
private UserService userService;
}
/**
* 短信发送工具类
*/
public class SMSUtils {
/**
* 发送短信
* @param signName 签名
* @param templateCode 模板
* @param phoneNumbers 手机号
* @param param 参数
*/
public static void sendMessage(String signName, String templateCode,String phoneNumbers,String param){
DefaultProfile profile = DefaultProfile.getProfile("cn-hangzhou", "", "");
IAcsClient client = new DefaultAcsClient(profile);
SendSmsRequest request = new SendSmsRequest();
request.setSysRegionId("cn-hangzhou");
request.setPhoneNumbers(phoneNumbers);
request.setSignName(signName);
request.setTemplateCode(templateCode);
request.setTemplateParam("{\"code\":\""+param+"\"}");
try {
SendSmsResponse response = client.getAcsResponse(request);
System.out.println("短信发送成功");
}catch (ClientException e) {
e.printStackTrace();
}
}
}
/**
* 随机生成验证码工具类
*/
public class ValidateCodeUtils {
/**
* 随机生成验证码
* @param length 长度为4位或者6位
* @return
*/
public static Integer generateValidateCode(int length){
Integer code =null;
if(length == 4){
code = new Random().nextInt(9999);//生成随机数，最大为9999
if(code < 1000){
code = code + 1000;//保证随机数为4位数字
}
}else if(length == 6){
code = new Random().nextInt(999999);//生成随机数，最大为999999
if(code < 100000){
code = code + 100000;//保证随机数为6位数字
}
}else{
throw new RuntimeException("只能生成4位或6位数字验证码");
}
return code;
}
/**
* 随机生成指定长度字符串验证码
* @param length 长度
* @return
*/
public static String generateValidateCode4String(int length){
Random rdm = new Random();
String hash1 = Integer.toHexString(rdm.nextInt());
String capstr = hash1.substring(0, length);
return capstr;
}
}
前面完成了LoginCheckFilter过滤器的开发，此过滤器用于检查用户的登录状态。我们在进行手机验证码登录时，发送的请求需要在此过滤处理时直接放行。
//定义不需要处理的请求路径
String[] urls = new String[]{
"/employee/login",
"/employee/logout",
"/backend/**",
"/front/**",
"/common/**",
"/user/sendMsg", //移动端发送短信
"/user/login" //移动端登录
};
在LoginCheckFilter过滤器中扩展逻辑，判断移动用户登录状态：
//4-2、判断用户登录状态，如果已经登录，则直接放行
if (request.getSession().getAttribute("user") != null) {
log.info("用户已经登录，用户id为：{}", request.getSession().getAttribute("user"));
Long userId = (Long) request.getSession().getAttribute("user");
BaseContext.setCurrentId(userId);
long id = Thread.currentThread().getId();
log.info("线程id:{}", id);
filterChain.doFilter(request, response);
return;
}
地址薄，指的是移动端消费者用户的地址信息，用户登录成功后可以维护自己的地址信息。同一个用户可以有多个地址信息，但是默认的只能有一个。
用户的地址信息会存储在address_book表，即地址薄表中，具体如下：
/**
* 地址簿
*/
@Data
public class AddressBook implements Serializable {
private static final long serialVersionUID = 1L;
private Long id;
//用户id
private Long userId;
//收货人
private String consignee;
//手机号
private String phone;
//性别 0 女 1 男
private String sex;
//省级区划编号
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;
//创建时间
@TableField(fill = FieldFill.INSERT)
private LocalDateTime createTime;
//更新时间
@TableField(fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
//创建人
@TableField(fill = FieldFill.INSERT)
private Long createUser;
//修改人
@TableField(fill = FieldFill.INSERT_UPDATE)
private Long updateUser;
//是否删除
private Integer isDeleted;
}
@Mapper
public interface AddressBookMapper extends BaseMapper<AddressBook> {
}
public interface AddressBookService extends IService<AddressBook> {
}
@Service
public class AddressBookServiceImpl extends ServiceImpl<AddressBookMapper, AddressBook> implements AddressBookService {
}
/**
* 地址簿管理
*/
@Slf4j
@RestController
@RequestMapping("/addressBook")
public class AddressBookController {
@Autowired
private AddressBookService addressBookService;
/**
* 新增一个地直薄
*/
@PostMapping
public R<AddressBook> save(@RequestBody AddressBook addressBook) {
//设置userId，知道当前这个地址是谁的
addressBook.setUserId(BaseContext.getCurrentId());
log.info("addressBook:{}", addressBook);
addressBookService.save(addressBook);
return R.success(addressBook);
}
/**
* 设置默认地址
*/
@PutMapping("default")
public R<AddressBook> setDefault(@RequestBody AddressBook addressBook) {
log.info("addressBook:{}", addressBook);
LambdaUpdateWrapper<AddressBook> wrapper = new LambdaUpdateWrapper<>();
//根据当前登录用户id去匹配地址薄地址
wrapper.eq(AddressBook::getUserId, BaseContext.getCurrentId());
//设置当前默认地址状态为 0 （0不是默认地址）
wrapper.set(AddressBook::getIsDefault, 0);
//SQL:update address_book set is_default = 0 where user_id = ?
addressBookService.update(wrapper);
//把当前要改的这条数据的地址状态改成1（1默认地址）
addressBook.setIsDefault(1);
//SQL:update address_book set is_default = 1 where id = ?
addressBookService.updateById(addressBook);
return R.success(addressBook);
}
/**
* 根据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("没有找到该对象");
}
}
/**
* 查询默认地址
*/
@GetMapping("default")
public R<AddressBook> getDefault() {
LambdaQueryWrapper<AddressBook> queryWrapper = new LambdaQueryWrapper<>();
//根据当前登录的UserID来查
queryWrapper.eq(AddressBook::getUserId, BaseContext.getCurrentId());
//条件查询，查地址状态为1的数据
queryWrapper.eq(AddressBook::getIsDefault, 1);
//SQL:select * from address_book where user_id = ? and is_default = 1
AddressBook addressBook = addressBookService.getOne(queryWrapper);
if (null == addressBook) {
return R.error("没有找到该对象");
} else {
return R.success(addressBook);
}
}
/**
* 查询指定用户的全部地址
*/
@GetMapping("/list")
public R<List<AddressBook>> list(AddressBook addressBook) {
//根据当前登录的UserID来查
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、页面（front/index.html）发送ajax请求，获取分类数据（菜品分类和套餐分类）
2、页面发送ajax请求，获取一个分类下的菜品或者套餐
开发菜品展示功能，就是在服务端编写代码去处理前端发送的这2次请求即可。
注意： 首页加载完成之后，还发送了一条ajax请求用于加载购物车数据，此次请求的地址暂时修改下，从静态json文件获取数据，等后续开发购物车功能时在修改过来。
main.js:
//获取购物车内商品的集合
function cartListApi(data) {
return $axios({
//'url': '/shoppingCart/list', //原来的请求地址
'url': '/front/cartData.json',
'method': 'get',
params: {...data}
})
}
移动端用户可以将菜品或者套餐添加到购物车，对于菜品来说，如果设置了口味信息，则需要选择规格后才能加入购物车，对于套餐来说，可以直接点击加号将套餐加入购物车。在购物车中可以修改菜品和套餐的数量，也可以清空购物车
购物车对应的数据表为shopping_cart表，结构如下：
购物车操作时前端页面和服务端的交互过程：
1、点击加入购物车或者加号按钮，页面发送ajax请求，请求服务端，将菜品或者套餐添加到购物车
2、点击购物车图标，页面发送ajax请求，请求服务端查询购物车中的菜品和套餐
3、点击清空购物车按钮，页面发送ajax请求，请求服务端来执行清空购物车操作
开发购物车功能，就是在服务单编写代码去处理前端页面发送的3次请求即可。
开发购物车功能时需要把请求地址改回来:
//获取购物车内商品的集合
function cartListApi(data) {
return $axios({
'url': '/shoppingCart/list', //原来的请求地址
//'url': '/front/cartData.json',
'method': 'get',
params: {...data}
})
}
创建需要用的类和接口：
/**
* 购物车
*/
@Data
public class ShoppingCart implements Serializable {
private static final long serialVersionUID = 1L;
private Long id;
//名称
private String name;
//用户id
private Long userId;
//菜品id
private Long dishId;
//套餐id
private Long setmealId;
//口味
private String dishFlavor;
//数量
private Integer number;
//金额
private BigDecimal amount;
//图片
private String image;
private LocalDateTime createTime;
}
@Mapper
public interface ShoppingCartMapper extends BaseMapper<ShoppingCart> {
}
public interface ShoppingCartService extends IService<ShoppingCart> {
}
@Service
public class ShoppingCartServiceImp extends ServiceImpl<ShoppingCartMapper, ShoppingCart> implements ShoppingCartService {
}
/**
* 购物车
*/
@Slf4j
@RestController
@RequestMapping("/shoppingCart")
public class ShoppingCartController {
@Autowired
private ShoppingCartService shoppingCartService;
/**
* 添加购物车
*
* @param shoppingCart
* @return
*/
@PostMapping("/add")
public R<ShoppingCart> add(@RequestBody ShoppingCart shoppingCart) {
log.info("购物车数据：{}", shoppingCart);
//设置用户id，指定当前是哪个用户的的购物车数据
Long currentId = BaseContext.getCurrentId();
shoppingCart.setUserId(currentId);
//查询当前菜品或者套餐是否在购物车中
Long dishId = shoppingCart.getDishId();
LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ShoppingCart::getUserId, currentId);
if (dishId != null) {
//添加到购物车的是菜品
queryWrapper.eq(ShoppingCart::getDishId, dishId);
} else {
//添加到购物车的是套餐
queryWrapper.eq(ShoppingCart::getSetmealId, shoppingCart.getSetmealId());
}
//SQL:select * from shopping_cart where user_id = ? and dish_id/setmeal_id = ?
ShoppingCart cartServiceOne = shoppingCartService.getOne(queryWrapper);
if (cartServiceOne != null) {
//如果已经存在，就在原来数量基础上加一
Integer number = cartServiceOne.getNumber();
cartServiceOne.setNumber(number + 1);
shoppingCartService.updateById(cartServiceOne);
} else {
// 如果不存在，添加到购物车，数量默认就是1
shoppingCart.setNumber(1);
shoppingCart.setCreateTime(LocalDateTime.now());
shoppingCartService.save(shoppingCart);
cartServiceOne = shoppingCart;
}
return R.success(cartServiceOne);
}
/**
* 套餐或者是菜品数量减少设置
* @param shoppingCart
* @return
*/
@PostMapping("/sub")
@Transactional
//携带的参数可能是dish_id也可能是setmeal_id所以我们需要用shoppingCart接收
public R<ShoppingCart> sub(@RequestBody ShoppingCart shoppingCart) {
//菜品id
Long dishId = shoppingCart.getDishId();
//套餐id
Long setmealId = shoppingCart.getSetmealId();
LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
//代表数量减少的是菜品数量
if (dishId != null) {
//通过dishId查出购物车菜品
queryWrapper.eq(ShoppingCart::getDishId, dishId);
//查询当前用户对应的购物车
queryWrapper.eq(ShoppingCart::getUserId, BaseContext.getCurrentId());
ShoppingCart cartDish = shoppingCartService.getOne(queryWrapper);
cartDish.setNumber(cartDish.getNumber() - 1);
Integer number = cartDish.getNumber();
if (number > 0) {
//对数据进行更新
shoppingCartService.updateById(cartDish);
} else if (number == 0) {
//如果购物车的数量为0，那么就将菜品从购物车删除
shoppingCartService.removeById(cartDish.getId());
} else if (number < 0) {
return R.error("操作异常");
}
return R.success(cartDish);
}
//代表数量减少的是套餐数量
if (setmealId != null) {
queryWrapper.eq(ShoppingCart::getSetmealId, setmealId);
//查询当前用户对应的购物车
queryWrapper.eq(ShoppingCart::getUserId, BaseContext.getCurrentId());
ShoppingCart cartSetmeal = shoppingCartService.getOne(queryWrapper);
cartSetmeal.setNumber(cartSetmeal.getNumber() - 1);
Integer number = cartSetmeal.getNumber();
if (number > 0) {
//对数据进行更新
shoppingCartService.updateById(cartSetmeal);
} else if (number == 0) {
//如果购物车的数量为0，那么就将套餐从购物车删除
shoppingCartService.removeById(cartSetmeal);
} else if (number < 0) {
return R.error("操作异常");
}
return R.success(cartSetmeal);
}
//如果菜品和套餐都进不去
return R.error("操作异常");
}
/**
* 查看购物车
*
* @return
*/
@GetMapping("/list")
public R<List<ShoppingCart>> list() {
log.info("查看购物车...");
LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
Long currentId = BaseContext.getCurrentId();
queryWrapper.eq(ShoppingCart::getUserId, currentId);
queryWrapper.orderByAsc(ShoppingCart::getCreateTime);
List<ShoppingCart> list = shoppingCartService.list(queryWrapper);
return R.success(list);
}
/**
* 清空购物车
*
* @return
*/
@DeleteMapping("/clean")
public R<String> clean() {
//SQL：Delete from shopping_cart where user_id = ?
LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ShoppingCart::getUserId, BaseContext.getCurrentId());
shoppingCartService.remove(queryWrapper);
return R.success("清空购物车成功");
}
}
移动端用户将菜品或者套餐加入购物车后，可以点击购物车中的去结算按钮，页面跳转到订单确认页面，点击去支付按钮完成下单操作。
用户下单业务对应的数据表为orders表和order_detail表：
orders：订单表
order_detail：订单明细表
用户下单操作时前端页面和服务端的交互过程：
1、在购物车中点击，去结算按钮，页面跳转到订单确认页面
2、在订单确认页面，发送ajax请求，请求服务端获取当前登录用户的默认地址（前面已实现）
3、在订单确认页面，发送ajax请求，请求服务端获取当前登录用户的购物车数据（前面已实现）
4、在订单确认页面点击去支付按钮，发送ajax请求，请求服务端完成下单操作
开发用户下单功能，其实就是在服务端编写代码去处理前端页面发送的请求即可。
创建需要用到的类和接口：
/**
* 订单
*/
@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;
//下单用户id
private Long userId;
//地址id
private Long addressBookId;
//下单时间
private LocalDateTime orderTime;
//结账时间
private LocalDateTime checkoutTime;
//支付方式 1微信，2支付宝
private Integer payMethod;
//实收金额
private BigDecimal amount;
//备注
private String remark;
//用户名
private String userName;
//手机号
private String phone;
//地址
private String address;
//收货人
private String consignee;
}
/**
* 订单明细
*/
@Data
public class OrderDetail implements Serializable {
private static final long serialVersionUID = 1L;
private Long id;
//名称
private String name;
//订单id
private Long orderId;
//菜品id
private Long dishId;
//套餐id
private Long setmealId;
//口味
private String dishFlavor;
//数量
private Integer number;
//金额
private BigDecimal amount;
//图片
private String image;
}
@Mapper
public interface OrderMapper extends BaseMapper<Order> {
}
@Mapper
public interface OrderDetailMapper extends BaseMapper<OrderDetail> {
}
public interface OrderService extends IService<Order> {
}
public interface OrderDetailService extends IService<OrderDetail> {
}
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
}
@Service
public class OrderDetailServiceImpl extends ServiceImpl<OrderDetailMapper, OrderDetail> implements OrderDetailService {
}
@RestController
@RequestMapping("/order")
public class OrderController {
@Autowired
private OrderService orderService;
}
@RestController
@RequestMapping("/orderDetail")
public class OrderDetailController {
@Autowired
private OrderDetailService orderDetailService;
}
业务实现层代码：OrderServiceImpl
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Orders> implements OrderService {
@Autowired
private OrderDetailService orderDetailService;
@Autowired
private ShoppingCartService shoppingCartService;
@Autowired
private UserService userService;
@Autowired
private AddressBookService addressBookService;
/**
* 用户下单
*
* @param orders
*/
@Override
@Transactional
public void subimt(Orders orders) {
//获取当前用户id
Long currentId = BaseContext.getCurrentId();
//查询当前用户的购物车数据
LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ShoppingCart::getUserId, currentId);
List<ShoppingCart> shoppingCarts = shoppingCartService.list(queryWrapper);
if (shoppingCarts == null || shoppingCarts.size() == 0) {
throw new CustomException("购物车为空不能下单");
}
//查询用户数据
User user = userService.getById(currentId);
//查询地址数据
Long addressBookId = orders.getAddressBookId();
AddressBook addressBook = addressBookService.getById(addressBookId);
if (addressBook == null) {
throw new CustomException("用户地址不能为空");
}
long orderId = IdWorker.getId();
//原子操作，保证线程安全
AtomicInteger amount = new AtomicInteger(0);
List<OrderDetail> orderDetails = shoppingCarts.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.setNumber(String.valueOf(orderId));
orders.setId(orderId);
orders.setOrderTime(LocalDateTime.now());
orders.setCheckoutTime(LocalDateTime.now());
orders.setStatus(2);
orders.setAmount(new BigDecimal(amount.get()));//总金额
orders.setUserId(currentId);
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(queryWrapper);
}
}
控制层代码：
@Slf4j
@RestController
@RequestMapping("/order")
public class OrderController {
@Autowired
private OrderService orderService;
/**
* 用户下单
*
* @param orders
* @return
*/
//当前用户已经完成登录了，可以从session或者BaseContext上下文工具类获取当前用户id，所以用户id不需要传递
@PostMapping("/submit")
public R<String> submit(@RequestBody Orders orders) {
log.info("订单数据：{}", orders);
orderService.subimt(orders);
return R.success("下单成功！");
}
}
用户支付后通过点击查看订单，可以查看下单的菜品或者套餐的详细信息
分析前端代码: 这个item是从order.orderDetails里面 获取到的，但是orders实体类里面并没有orderDetails这个属性，而且数据库中这个order表里面也没有这个字段，所以这里我使用的是dto来封装数据给前端，这就需要使用到dto对象的分页查询了。
创建需要用到的类和接口：
@Data
public class OrdersDto extends Orders {
private String userName;
private String phone;
private String address;
private String consignee;
private List<OrderDetail> orderDetails;
}
/**
* 用户个人中心订单信息查看
*
* @param page
* @param pageSize
* @return
*/
@Override
public Page<OrdersDto> userPage(int page, int pageSize) {
//分页构造器对象
Page<Orders> pageInfo = new Page<>(page, pageSize);
Page<OrdersDto> dtoPage = new Page<>();
//创建条件查询对象
LambdaQueryWrapper<Orders> queryWrapper = new LambdaQueryWrapper<>();
//添加排序条件，根据更新时间降序排序
queryWrapper.orderByDesc(Orders::getOrderTime);
this.page(pageInfo, queryWrapper);
//通过OrderId查寻对应的菜品/套餐
LambdaQueryWrapper<OrderDetail> wrapper = new LambdaQueryWrapper<>();
//对OrderDto进行需要的属性赋值
List<Orders> records = pageInfo.getRecords();
List<OrdersDto> list = records.stream().map((item) -> {
OrdersDto ordersDto = new OrdersDto();
//为orderDetails属性赋值
//获取订单ID
Long orderId = item.getId();
//根据订单ID查询对应的订单明细
wrapper.eq(OrderDetail::getOrderId, orderId);
List<OrderDetail> orderDetailList = orderDetailService.list(wrapper);
BeanUtils.copyProperties(item, ordersDto);
//对ordersDto的OorderDetai属性进行赋值
ordersDto.setOrderDetails(orderDetailList);
return ordersDto;
}).collect(Collectors.toList());
BeanUtils.copyProperties(pageInfo, dtoPage, "records");
dtoPage.setRecords(list);
return dtoPage;
}
/**
* 用户个人中心订单信息查看
*
* @param page
* @param pageSize
* @return
*/
@GetMapping("/userPage")
public R<Page> userPage(int page, int pageSize) {
Page<OrdersDto> dtoPage = orderService.userPage(page, pageSize);
return R.success(dtoPage);
}
再来一单：
/**
* 再来一单
*
* @param order
*/
@Override
public void again(Orders order) {
//获取订单里订单号
Orders orderId = this.getById(order.getId());
String number = order.getNumber();
//根据条件进行查询
LambdaQueryWrapper<OrderDetail> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(OrderDetail::getOrderId, number);
List<OrderDetail> orderDetailList = orderDetailService.list(queryWrapper);
//根据查到的数据再次添加到购物车里
List<ShoppingCart> list = orderDetailList.stream().map((item) -> {
//把从order表中和order_details表中获取到的数据赋值给这个购物车对象
ShoppingCart shoppingCart = new ShoppingCart();
shoppingCart.setName(item.getName());
shoppingCart.setImage(item.getImage());
shoppingCart.setUserId(BaseContext.getCurrentId());
shoppingCart.setDishId(item.getDishId());
shoppingCart.setSetmealId(item.getSetmealId());
shoppingCart.setDishFlavor(item.getDishFlavor());
shoppingCart.setNumber(item.getNumber());
shoppingCart.setAmount(item.getAmount());
return shoppingCart;
}).collect(Collectors.toList());
shoppingCartService.saveBatch(list);
}
/**
* 再来一单
* @param order
* @return
*/
@PostMapping("/again")
public R<String> again(@RequestBody Orders order) {
orderService.again(order);
return R.success("再来一单啊");
}
查看套餐详情
控制层SetmealController
/**
* 查看套餐详情
* @param SetmealId
* @return
*/
@GetMapping("/dish/{id}")
//使用路径来传值的
public R<List<Dish>> dish(@PathVariable("id") Long SetmealId) {
LambdaQueryWrapper<SetmealDish> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SetmealDish::getSetmealId, SetmealId);
List<SetmealDish> list = setmealDishService.list(queryWrapper);
LambdaQueryWrapper<Dish> queryWrapper2 = new LambdaQueryWrapper<>();
ArrayList<Long> dishIdList = new ArrayList<>();
for (SetmealDish setmealDish : list) {
Long dishId = setmealDish.getDishId();
dishIdList.add(dishId);
}
queryWrapper2.in(Dish::getId, dishIdList);
List<Dish> dishList = dishService.list(queryWrapper2);
return R.success(dishList);
}
Usercontroller控制层
/**
* 用户退出
*
* @param request
* @return
*/
@PostMapping("/loginout")
public R<String> logout(HttpServletRequest request) {
//清理Session中保存的当前登录用户的id
request.getSession().removeAttribute("user");
return R.success("退出成功");
}