基于javaweb+mysql的springboot前后端分离网上商城项目设计和实现(java+ssm+springboot+vue+redis+oss)
私信源码获取及调试交流
运行环境
Java≥8、MySQL≥5.7、Node.js≥10
开发工具
后端：eclipse/idea/myeclipse/sts等均可配置运行
前端：WebStorm/VSCode/HBuilderX等均可
适用
课程设计，大作业，毕业设计，项目练习，学习演示等
功能说明
基于javaweb+mysql的SpringBoot前后端分离网上商城项目设计和实现(java+ssm+springboot+vue+redis+oss)
后台管理员：
1325554003@qq.com/123456
前台用户：
user1@qq.com/123456
1 启动后端：StartApplication
2 启动前端：npm run dev
主要功能实现：
用户登录、注册、商城浏览、购买、订单、购物车、退货、用户、个人中心、修改密码、角色等管理
前端主页面：商品关键字搜索和分类搜索功能以及首页轮播图配置展示
首页个人中心主要功能：密码修改、订单、购物车、商品详情模块、可以购买、加入购物车
购买时需要填写用户手机号和收获地址等信息
后台管理员主要对商品数据进行管理、分类管理、订单管理以及用户管理
商品列表数据管理、后台添加商品信息、商品基础数据的维护管理、商品订单详情管理：根据关键字查询以及查看每一个订单的详情信息
首页轮播图配置展示、用户角色和权限管理控制
/**
* @email qiudb.top@aliyun.com
* @description 商品相关业务
*/
@RestController
@CrossOrigin
public class ProductController {
final ProductTypeService productTypeService;
final ProductBrandService productBrandService;
final ProductService productService;
public ProductController(ProductService productService, ProductTypeService productTypeService,ProductBrandService productBrandService) {
this.productTypeService = productTypeService;
this.productBrandService = productBrandService;
this.productService = productService;
}
/*商品类别*/
@RequestMapping(value = "/product/findById")
private CommonResult findById(Integer productId) {
Product product = productService.selectById(productId);
if(product!=null){
return CommonResult.success("商品查询成功",product);
}else{
return CommonResult.error("商品查询失败");
}
}
String serialNumber = redisTemplate.opsForValue().get(tradeNo);
if(serialNumber !=null){
response.sendRedirect("http://"+hostAddress+"/?#/personalCenter?serialNumber="+serialNumber);
redisTemplate.delete(tradeNo);
}else{
response.sendRedirect("http://"+hostAddress+"/?#/personalCenter?serialNumber="+"ERROR");
}
orderService.updateById(order);
}else{
String Str = redisTemplate.opsForValue().get(tradeNo);
redisTemplate.delete(tradeNo);
assert Str != null;
String[] ordersNo = Str.split(",");
System.out.println(Arrays.toString(ordersNo));
for (String orderNo1 : ordersNo) {
Integer orderId = orderService.selectIdByKey(orderNo1);
Order order = new Order();
order.setOrderId(orderId);
order.setOrderState("待发货");
orderService.updateById(order);
}
response.sendRedirect("http://"+hostAddress+"/?#/myOrder");
}
}catch (IOException e) {
e.printStackTrace();
}
}
@ResponseBody
@PostMapping(value = "/vip", produces = "text/html;charset=utf-8")
public String create(@RequestParam("orderNo") String orderNo,
@RequestParam("orderName") String orderName,
@RequestParam("payPrice") String payPrice,
@RequestParam("serialNumber") String serialNumber) {
//开通vip的序列号暂时存入redis中
redisTemplate.opsForValue().set(orderNo,serialNumber,2, TimeUnit.HOURS);
//发起支付
return alipayService.create(orderNo, orderName, payPrice);
}
}
}
/*查询用户状态*/
@RequestMapping(value = "/user/userState")
private CommonResult userState(String accountNumber) {
Boolean state = userService.selectUserState(accountNumber);
if(state!=null){
return CommonResult.success("查询成功",state);
}else{
return CommonResult.error("查询失败");
}
}
/*查询用户记录的总条数*/
@RequestMapping(value = "/user/count")
private CommonResult findCount() {
Integer count = userService.selectCount();
if(count!=null){
if(count!=0){
return CommonResult.success("查询成功",count);
}else{
return CommonResult.error("查询失败");
}
}else{
return CommonResult.error("查询失败");
}
}
//通过用户帐号去查询用户的id
@RequestMapping(value = "/user/findIdByKey")
private CommonResult findIdByKey(String key) {
Integer id = userService.selectIdByKey(key);
if(id!=null){
if(id!=0){
return CommonResult.success("查询成功","id: "+id);
}else{
return CommonResult.error("未查询到");
}
}else{
return CommonResult.error("查询失败");
}
}
//删除用户
@RequestMapping(value = "/user/delete")
private CommonResult delete(Integer userId) {
if(userService.deleteById(userId)){
if(ProductReviewService.updateById(productReview)){
return CommonResult.success("商品评论修改成功",productReview);
}else{
return CommonResult.error("商品评论修改失败");
}
}
@RequestMapping(value = "/productReview/deleteById")
private CommonResult deleteProductReview(Integer reviewId) {
if(ProductReviewService.deleteById(reviewId)){
return CommonResult.success("商品评论删除成功","reviewId: "+reviewId);
}else{
return CommonResult.error("商品评论删除失败");
}
}
@RequestMapping(value = "/productReview/findAll")
private CommonResult findAllProductReview(String productNo) {
List<Map<String, Object>> productReviewInfo = ProductReviewService.selectAll(productNo);
if(productReviewInfo!=null){
return CommonResult.success("商品评论查询成功",productReviewInfo);
}else{
return CommonResult.error("商品评论查询失败");
}
}
@RequestMapping(value = "/productReview/findById")
private CommonResult findById(Integer reviewId) {
ProductReview productReview = ProductReviewService.selectById(reviewId);
if(productReview!=null){
return CommonResult.success("商品评论查询成功",productReview);
}else{
return CommonResult.error("商品评论查询失败");
}
}
}
//存放sessionId, 即 token
info.put("sessionId", authorization);
List<Role> roles = roleService.selectAll();
List<String> rs = new ArrayList<>(); // rs 存放的是role的名称
List<String> rsInfo = new ArrayList<>(); //rsInfo 存放role的描述
for (Role role : roles) {
rs.add(role.getRoleName());
rsInfo.add(role.getRoleName());
}
boolean[] booleans = subject.hasRoles(rs);
for (int i = booleans.length - 1; i >= 0; i--) {
if (!booleans[i]) {
rs.remove(i);
rsInfo.remove(i);
}
}
info.put("role", rs);
info.put("roleInfo", rsInfo);
return CommonResult.success("登录成功", info);
}catch (LockedAccountException e){
return CommonResult.error("您的帐号存在异常行为，已被封停（请联系工作人员）");
} catch (IncorrectCredentialsException e) {
return CommonResult.error("密码错误,请重新输入");
} catch (AuthenticationException e) {
return CommonResult.error("该用户不存在");
}
}
/**
* 退出登录操作
* @param key 用户登录的帐号
* @param session 前端存储的session（token）
*/
@RequestMapping(value = "/logout")
private CommonResult logout(String key,String session) {
if(key!=null){
try{
User user = userService.selectByKey(key);
Subject subject = SecurityUtils.getSubject();
//清除用户缓存
RealmSecurityManager securityManager = (RealmSecurityManager) SecurityUtils.getSecurityManager();
UserRealm userRealm = (UserRealm) securityManager.getRealms().iterator().next();
//清空redis中的缓存信息
userRealm.clearRedis(user,session);
userRealm.clearCache(SecurityUtils.getSubject().getPrincipals());
//退出登录
subject.logout();
return CommonResult.success("退出成功");
}catch(Exception e){
}
@RequestMapping(value = "/product/findByKey")
private CommonResult findByKey(String productNo) {
Product product = productService.selectByKey(productNo);
if(product!=null){
return CommonResult.success("商品查询成功",product);
}else{
return CommonResult.error("商品查询失败");
}
}
@RequestMapping(value = "/product/findIdByKey")
private CommonResult findIdByKey(String productNo) {
Integer productId = productService.selectIdByKey(productNo);
if(productId!=null){
return CommonResult.success("商品id查询成功",productId);
}else{
return CommonResult.error("商品id查询失败");
}
}
@RequestMapping(value = "/product/findCount")
private CommonResult findCount() {
Integer count = productService.selectCount();
if(count!=null){
return CommonResult.success("商品数量查询成功",count);
}else{
return CommonResult.error("商品数量查询失败");
}
}
@RequestMapping(value = "/product/existsKey")
private CommonResult existsKey(String productNo) {
Boolean isExist = productService.existsWithPrimaryKey(productNo);
if(isExist!=null){
return CommonResult.success("商品是否存在查询成功",isExist);
}else{
return CommonResult.error("商品是否存在查询失败");
}
}
@RequestMapping(value = "/product/existsType")
private CommonResult existsType(String productType) {
Boolean isExist = productService.existsProductType(productType);
if(isExist!=null){
return CommonResult.success("查询成功",isExist);
}else{
return CommonResult.error("查询失败");
}
}
@RequestMapping(value = "/user/delete")
private CommonResult delete(Integer userId) {
if(userService.deleteById(userId)){
return CommonResult.success("删除成功",userId);
}else{
return CommonResult.error("删除失败");
}
}
@RequestMapping(value = "/user/author")
private CommonResult author(Integer userId,@RequestParam List<Integer> roleId) {
System.out.println(userId);
System.out.println(roleId);
if(userId!=null && roleId!=null && roleId.size()!=0){
if(userRoleService.deleteById(userId)){
UserRole userRole = new UserRole();
userRole.setUserId(userId);
for (Integer id : roleId) {
userRole.setRoleId(id);
userRoleService.insertData(userRole);
}
}
return CommonResult.success("授权成功");
}else{
return CommonResult.error("角色授权数据不完整！");
}
}
/*查询所有VIP用户*/
@RequestMapping(value = "/vip/findAllVip")
private CommonResult findAllVip() {
List<Vip> vips = vipService.selectAll();
if(vips!=null){
return CommonResult.success("查询成功",vips);
}else{
return CommonResult.error("查询失败");
}
}
/*查询VIP用户信息根据id*/
@RequestMapping(value = "/vip/findVipById")
private CommonResult findVipById(Integer vipId) {
Vip vip = vipService.selectById(vipId);
if(vip!=null){
return CommonResult.success("更新成功",role);
}else{
return CommonResult.error("更新失败");
}
}
@RequestMapping(value = "/role/delete")
private CommonResult delete(Integer roleId) {
if(roleService.deleteById(roleId)){
return CommonResult.success("删除成功",roleId);
}else{
return CommonResult.error("删除失败");
}
}
}
/**
* @email qiudb.top@aliyun.com
* @description 商品评价 业务类
*/
@RestController
@CrossOrigin
public class ProductReviewController {
final ProductReviewService ProductReviewService;
final OrderService orderService;
public ProductReviewController(ProductReviewService ProductReviewService,OrderService orderService){
this.ProductReviewService = ProductReviewService;
this.orderService = orderService;
}
/*商品类别*/
@RequestMapping(value = "/productReview/add")
private CommonResult addProductReview(ProductReview productReview) {
if(ProductReviewService.insertData(productReview)){
Integer orderId = orderService.selectIdByKey(productReview.getOrderNo());
Order order = new Order();
order.setOrderId(orderId);
}
}
/*查询全部退货原因名称*/
@RequestMapping(value = "/returnReason/findReasonName")
private CommonResult findReasonName() {
List<String> names = returnReasonService.selectAllName();
if(names!=null){
return CommonResult.success("退货原因查询成功",names);
}else{
return CommonResult.error("退货原因查询失败");
}
}
/*查询退货原因是否存在*/
@RequestMapping(value = "/returnReason/existReasonName")
private CommonResult existReasonName(Integer reasonId,String reasonName) {
Boolean isExist = returnReasonService.existsWithReasonName(reasonId,reasonName);
if(isExist!=null){
return CommonResult.success("查询成功",isExist);
}else{
return CommonResult.error("查询失败");
}
}
@RequestMapping(value = "/returnReason/addReason")
private CommonResult addReason(ReturnReason returnReason) {
if(returnReason!=null){
if(returnReasonService.insertData(returnReason)){
return CommonResult.success("添加成功",returnReason);
}else{
return CommonResult.error("添加失败");
}
}
return CommonResult.error("退货原因数据不存在");
}
@RequestMapping(value = "/returnReason/updateReason")
private CommonResult updateReason(ReturnReason returnReason) {
if(returnReason!=null){
if(returnReasonService.updateById(returnReason)){
return CommonResult.success("更新成功",returnReason);
}else{
return CommonResult.error("更新失败");
}
}
return CommonResult.error("退货原因数据不存在");
}
@RequestMapping(value = "/returnReason/deleteReason")
return CommonResult.success("退货订单数量查询成功",count);
}else{
return CommonResult.error("退货订单数量查询失败");
}
}
@RequestMapping(value = "/returnGoods/addReturn")
private CommonResult addReturn(ReturnGoods returnGoods) {
if(returnGoods!=null){
Integer orderId = orderService.selectIdByKey(returnGoods.getOrderNo());
System.out.println(returnGoods);
System.out.println(orderId);
Order order = new Order();
order.setOrderId(orderId);
order.setOrderState("待处理");
if (orderService.updateById(order)){
if(returnGoodsService.insertData(returnGoods)){
return CommonResult.success("添加成功",returnGoods);
}else{
return CommonResult.error("添加失败");
}
}else{
return CommonResult.error("添加失败");
}
}
return CommonResult.error("商品退货数据不存在");
}
@RequestMapping(value = "/returnGoods/updateReturn")
private CommonResult updateReturn(ReturnGoods returnGoods) {
if(returnGoods!=null){
returnGoods.setDealTime(new Date());
if(returnGoodsService.updateById(returnGoods)){
return CommonResult.success("更新成功",returnGoods);
}else{
return CommonResult.error("更新失败");
}
}
return CommonResult.error("商品退货数据不存在");
}
/*我的订单 查询退货订单信息*/
@RequestMapping(value = "/returnGoods/findReturnInfo")
return CommonResult.error("商品评论查询失败");
}
}
}
/**
* @email qiudb.top@aliyun.com
* @description 购物车业务类
*/
@RestController
@CrossOrigin
public class ShoppingCartController {
final ShoppingCartService shoppingCartService;
public ShoppingCartController(ShoppingCartService shoppingCartService){
this.shoppingCartService = shoppingCartService;
}
/*商品类别*/
@RequestMapping(value = "/shoppingCart/add")
private CommonResult addShoppingCart(ShoppingCart shoppingCart) {
if(shoppingCartService.insertData(shoppingCart)){
return CommonResult.success("购物车添加成功",shoppingCart);
}else{
return CommonResult.error("购物车添加失败");
}
}
@RequestMapping(value = "/shoppingCart/update")
private CommonResult updateShoppingCart(ShoppingCart shoppingCart) {
if(shoppingCartService.updateById(shoppingCart)){
@RequestMapping(value = "/purchase/receipts")
private CommonResult deletePurchase(String productNo,Integer purchaseId,Integer purchaseNumber) {
Integer productId = productService.selectIdByKey(productNo);
Product product = productService.selectById(productId);
Integer lowestStock = product.getLowestStock();
Integer productStock = product.getProductStock();
product.setProductStock(productStock+purchaseNumber);
product.setIsStockOut(product.getProductStock()<lowestStock);
if(productService.updateById(product)){
Purchase purchase = new Purchase();
purchase.setPurchaseId(purchaseId);
purchase.setReceiptStatus(true);
purchase.setReceiptTime(new Date());
if(purchaseService.updateById(purchase)){
return CommonResult.success("收货成功",purchaseId);
}else{
return CommonResult.error("采购信息更新失败");
}
}else{
return CommonResult.error("商品库存更新失败");
}
}
}
/**
* @email qiudb.top@aliyun.com
* @description 用户相关业务
*/
@RestController
@CrossOrigin
public class UserController {
final RoleService roleService;
final UserService userService;
Map<String, Object> productMap = productService.productOverview();
Map<String, Object> orderMap = orderService.orderOverview();
Map<String, Object> returnGoodsMap = returnGoodsService.returnGoodsOverview();
if(productMap!=null){
resultMap.putAll(productMap);
}
if(orderMap!=null){
resultMap.putAll(orderMap);
}
if(returnGoodsMap!=null){
resultMap.putAll(returnGoodsMap);
}
if(resultMap.size()!=0){
return CommonResult.success("查询成功",resultMap);
}else{
return CommonResult.error("查询失败");
}
}
@RequestMapping(value = "/view/orderChartDATE")
private CommonResult orderChartDATE(String startTime,String endTime) {
Map<String, Object> data = new HashMap<>();
List<Map<String, Object>> lineData = orderService.selectChartDATE(startTime,endTime);
List<Map<String, Object>> ringData = orderService.selectProductTypeChart(startTime, endTime);
Map<String, Object> countData = orderService.selectCountAndAmount(startTime,endTime);
if(lineData.size()!=0){
data.put("lineData",lineData);
}
if(ringData.size()!=0){
data.put("ringData",ringData);
}
if(countData.size()!=0){
data.put("countData",countData);
}
if(data.size()!=0){
return CommonResult.success("查询成功",data);
}else{
return CommonResult.error("查询失败");
}
}
}
/**
* @email qiudb.top@aliyun.com
if(accountNumber!=null && password!=null){
// SimpleHash md5 = new SimpleHash("MD5", password, ByteSource.Util.bytes(accountNumber), 2);
// password=md5.toHex();
Integer id = userService.selectIdByKey(accountNumber);
User user = new User();
user.setUserId(id);
user.setPassword(password);
if(userService.updateById(user)){
return CommonResult.success("重置密码成功",user);
}else{
return CommonResult.error("重置密码失败");
}
}
return CommonResult.error("用户数据不存在");
}
/*用于注册新用户*/
@RequestMapping(value = "/allow/add")
private CommonResult add(User user) {
if(user.getPassword()!=null && user.getUserName()!=null){
// SimpleHash md5 = new SimpleHash("MD5", user.getPassword(), ByteSource.Util.bytes(user.getAccountNumber()), 2);
// user.setPassword(md5.toHex());
user.setUserState(true);
user.setCreatTime(Timestamp.valueOf(LocalDateTime.now()));
if(userService.insertData(user)){
logger.info("成功添加了一个新用户");
return CommonResult.success("注册成功",user);
}else{
return CommonResult.error("注册失败");
}
}
return CommonResult.error("用户数据不存在");
}
//更新用户信息
@RequestMapping(value = "/allow/update")
private CommonResult update(User user) {
System.out.println(user);
if(userService.updateById(user)){
/**
* 验证输入的验证码是否正确
*
* @param key 验证的依据
* @param code 验证码
*/
@RequestMapping(value = "/allow/checkCode")
public CommonResult checkCode(String key, String code) {
String codeK = redisTemplate.opsForValue().get(key);
if (codeK == null) {
return CommonResult.error("验证码不存在或已过期，请重新发送！");
}
if (codeK.equals(code)) {
redisTemplate.delete(key);
return CommonResult.success("验证码成功！", true);
} else {
return CommonResult.success("验证码错误！", false);
}
}
/**
* 用于绑定手机号操作，发送验证码
*
* @param phone 发送的手机号
*/
@RequestMapping(value = "/util/smsCode")
public CommonResult aliYunSmsCode(String phone) {
String code = redisTemplate.opsForValue().get(phone);
if (!StringUtils.isEmpty(code)) {
return CommonResult.error(phone + "的验证码还未过期！");
}
//生成验证码并存储到redis中
code = MyUtils.getCode(6);
boolean isSend = aliYunSmsService.sendSms(phone, code);
if (isSend) {
redisTemplate.opsForValue().set(phone, code, 10, TimeUnit.MINUTES);
return CommonResult.success("验证码已发送，网络有延迟请稍等~");
} else {
return CommonResult.error("验证码发送失败，请稍后重试~");
}
}
}
@RequestMapping(value = "/returnGoods/dealRefund")
private CommonResult dealRefund(Integer returnId,String operatorNumber,String operatorName) {
if(returnId!=null){
ReturnGoods returnGoods = returnGoodsService.selectById(returnId);
returnGoods.setReturnState("退款完成");
returnGoods.setDealTime(new Date());
returnGoods.setOperatorNumber(operatorNumber);
returnGoods.setOperatorName(operatorName);
String orderNo = returnGoods.getOrderNo();
Integer orderId = orderService.selectIdByKey(orderNo);
Order order = new Order();
order.setOrderId(orderId);
order.setReturnState(true);
order.setOrderState("已退款");
Logistics logistics = logisticsService.selectOrderNo(orderNo);
if(logistics!=null){
logisticsService.deleteById(logistics.getLogisticId());
}
if(orderService.updateById(order)){
if(returnGoodsService.updateById(returnGoods)){
return CommonResult.success("更新成功",returnGoods);
}else{
return CommonResult.error("更新失败");
}
}else{
return CommonResult.error("更新失败");
}
}
return CommonResult.error("商品退款数据不存在");
}
/*拒绝买家退款申请*/
@RequestMapping(value = "/returnGoods/rejectRefund")
private CommonResult rejectRefund(Integer returnId,String operatorNumber,String operatorName) {
if(returnId!=null){
ReturnGoods returnGoods = returnGoodsService.selectById(returnId);
returnGoods.setReturnState("拒绝退款");
returnGoods.setDealTime(new Date());
returnGoods.setOperatorNumber(operatorNumber);
returnGoods.setOperatorName(operatorName);
String orderNo = returnGoods.getOrderNo();
Integer orderId = orderService.selectIdByKey(orderNo);
Order order = new Order();
order.setOrderId(orderId);
order.setOrderState("待发货");
if(orderService.updateById(order)){
if(returnGoodsService.updateById(returnGoods)){
return CommonResult.success("更新成功",returnGoods);
}else{
return CommonResult.error("更新失败");
}
}else {
// 如果库存小于等于0，自动下架
newProduct.setIsSale(newStock>0);
if(productService.updateById(newProduct)){
if(orderService.insertData(order)){
orderInfo.add(order.getOrderNo());
productInfo.add(order.getProductNo());
}
}
}
}
if(orderInfo.size()!=0){
String orderNoInfo = StringUtils.join(orderInfo, ",");
String productNoInfo = StringUtils.join(productInfo, ",");
redisTemplate.opsForValue().set(orderNo,orderNoInfo,24, TimeUnit.HOURS);
return CommonResult.success("创建订单成功",productNoInfo);
}else{
return CommonResult.success("创建订单失败");
}
}else{
return CommonResult.error("订单数据不完整");
}
}
@RequestMapping(value = "/order/update")
private CommonResult updateOrder(Order order) {
if(orderService.updateById(order)){
return CommonResult.success("修改订单成功",order);
}else{
return CommonResult.error("修改订单失败");
}
}
@RequestMapping(value = "/order/delete")
private CommonResult deleteOrder(Integer orderId) {
if(orderService.deleteById(orderId)){
return CommonResult.success("删除订单成功","订单id："+orderId);
}else{
return CommonResult.error("删除订单失败");
}
}
扫一扫
708
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
