piblenqhp
/
test
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

123

Browse Source
master
康菊菊 4 months ago
parent 8b5ecd6f27
commit cd15e27884
35 changed files with 1265 additions and 344 deletions
Show Stats Download Patch File Download Diff File

21
src/main/java/com/shanzhu/flower/config/Constant.java
Unescape View File

@ -1,20 +1,29 @@
package com.shanzhu.flower.config;
/**
* 常量
* 图片静态文件路径
* 常量类，用于存储项目中常用的配置常量。
* 包括分页大小、图片路径等配置。
*
* @author: ShanZhu
* @date: 2024-01-24
*/
public class Constant {
// 默认分页大小，用于分页查询时每页显示的记录数。
// 默认值为5，可根据实际需求调整。
public static int PAGE_SIZE = 5;
// 商品展示
//
// 商品展示页面的分页大小。
// 用于商品列表展示时每页显示的商品数量。
// 默认值为9，可根据页面布局调整。
//
public static int SHOW_PAGE_SIZE = 9;
// 图片静态文件的存储路径。
// 用于存放项目中使用的图片资源。
// 路径为项目根目录下的static/imgs/文件夹。
public static String IMG_USE_PATH = "static/imgs/";
// 默认图片文件名。
// 当没有指定图片时，使用此默认图片作为占位图。
// 文件名为img.jpg，位于IMG_USE_PATH路径下。
public static String DEFAULT_IMG = "img.jpg";
}

150
src/main/java/com/shanzhu/flower/config/HttpMsg.java
Unescape View File

@ -1,52 +1,186 @@
package com.shanzhu.flower.config;
/**
* http状态消息
* HTTP状态消息常量类。
* 用于存储项目中常见的HTTP响应消息，便于统一管理和维护。
* 包括用户操作、类型管理、商品管理、订单管理等操作的反馈信息。
*
* @author: ShanZhu
* @date: 2024-01-24
*/
public class HttpMsg {
// 表单输入错误的提示信息。
// 当用户提交的表单数据不符合要求时返回此消息。
public static String ERROR_INPUT = "表单信息不正确";
// 用户名或密码错误的提示信息。
// 当用户登录时输入的用户名或密码不匹配时返回此消息。
public static String ERROR_VERIFY = "用户名或密码错误";
// 新建用户成功的提示信息。
// 当用户注册成功时返回此消息。
public static String ADD_USER_OK = "新建用户成功";
// 新建用户失败的提示信息（账号已存在）。
// 当用户注册时输入的账号已存在时返回此消息。
public static String ADD_USER_FAILED = "新建用户失败，该账号已存在";
// 修改用户信息成功的提示信息。
// 当用户更新个人信息成功时返回此消息。
public static String UPDATE_USER_OK = "修改用户信息成功";
// 修改用户信息失败的提示信息。
// 当用户更新个人信息失败时返回此消息。
public static String UPDATE_USER_FAILED = "修改用户信息失败";
// 删除用户信息成功的提示信息。
// 当管理员删除用户信息成功时返回此消息。
public static String DELETE_USER_OK = "删除用户信息成功";
// 删除用户信息失败的提示信息。
// 当管理员删除用户信息失败时返回此消息。
public static String DELETE_USER_FAILED = "删除用户信息失败";
// 删除类型成功的提示信息。
// 当管理员删除花朵类型成功时返回此消息。
public static String DELETE_TYPE_OK = "删除类型成功";
// 删除类型失败的提示信息（有商品绑定此类型）。
// 当管理员删除花朵类型失败（因为有商品绑定此类型）时返回此消息。
//
public static String DELETE_TYPE_FAILED = "有商品绑定此类型，删除类型失败";
// 修改类型成功的提示信息。
// 当管理员修改花朵类型成功时返回此消息。
public static String UPDATE_TYPE_OK = "修改类型成功";
// 修改类型失败的提示信息（有商品绑定此类型）。
// 当管理员修改花朵类型失败（因为有商品绑定此类型）时返回此消息。
public static String UPDATE_TYPE_FAILED = "有商品绑定此类型，修改类型失败";
// 新建类型成功的提示信息。
// 当管理员新建花朵类型成功时返回此消息。
public static String ADD_TYPE_OK = "新建类型成功";
// 新建类型失败的提示信息（该类型名称已存在）。
// 当管理员新建花朵类型失败（因为该类型名称已存在）时返回此消息。
public static String ADD_TYPE_FAILED = "新建类型失败，该类型名称已存在";
// 删除商品成功的提示信息。
// 当管理员删除商品成功时返回此消息。
public static String DELETE_FLOWER_OK = "删除商品成功";
public static String DELETE_FLOWER_OK = "删除类型成功";
public static String DELETE_FLOWER_FAILED = "有商品绑定此类型，删除类型失败";
public static String UPDATE_FLOWER_OK = "修改类型成功";
public static String UPDATE_FLOWER_FAILED = "有商品绑定此类型，修改类型失败";
public static String ADD_FLOWER_OK = "新建类型成功";
public static String ADD_FLOWER_FAILED = "新建类型失败，该类型名称已存在";
//
// 删除商品失败的提示信息（有商品绑定此类型）。
// 当管理员删除商品失败（因为有商品绑定此类型）时返回此消息。
//
public static String DELETE_FLOWER_FAILED = "有商品绑定此类型，删除商品失败";
//
// 修改商品成功的提示信息。
// 当管理员修改商品成功时返回此消息。
//
public static String UPDATE_FLOWER_OK = "修改商品成功";
//
// 修改商品失败的提示信息（有商品绑定此类型）。
// 当管理员修改商品失败（因为有商品绑定此类型）时返回此消息。
//
public static String UPDATE_FLOWER_FAILED = "有商品绑定此类型，修改商品失败";
//
// 新建商品成功的提示信息。
// 当管理员新建商品成功时返回此消息。
//
public static String ADD_FLOWER_OK = "新建商品成功";
//
// 新建商品失败的提示信息（该商品名称已存在）。
// 当管理员新建商品失败（因为该商品名称已存在）时返回此消息。
//
public static String ADD_FLOWER_FAILED = "新建商品失败，该商品名称已存在";
//
// 当前没有花朵种类的提示信息。
// 当系统中没有花朵种类时返回此消息，提示管理员需要先创建种类。
//
public static String NO_TYPE_NOW = "当前没有花朵种类，请先创建！";
//
// 更新图片成功的提示信息。
// 当用户或管理员更新图片成功时返回此消息。
//
public static String UPDATE_PIC_OK = "更新图片成功";
//
// 更新图片失败的提示信息。
// 当用户或管理员更新图片失败时返回此消息。
//
public static String UPDATE_PIC_FAILED = "更新图片失败";
//
// 参数不合法的提示信息。
// 当请求中包含的参数不符合要求时返回此消息。
//
public static String INVALID_PARAM = "参数不合法";
//
// 登录失效的提示信息。
// 当用户登录状态失效时返回此消息，提示用户重新登录。
//
public static String INVALID_USER = "登录失效，请重新登录";
//
// 加入购物车成功的提示信息。
// 当用户将商品加入购物车成功时返回此消息。
//
public static String ADD_CART_OK = "加入购物车成功";
//
// 加入购物车失败的提示信息。
// 当用户将商品加入购物车失败时返回此消息。
//
public static String ADD_CART_FAILED = "加入购物车失败";
//
// 下单成功的提示信息。
// 当用户下单成功时返回此消息。
//
public static String BUY_OK = "下单成功";
//
// 订单发货状态更新成功的提示信息。
// 当管理员更新订单发货状态成功时返回此消息。
//
public static String UPDATE_ORDER_OK = "订单发货状态更新成功";
//
// 错误的文件类型的提示信息。
// 当上传的文件类型不符合要求时返回此消息。
//
public static String ERROR_FILE_TYPE = "错误的文件类型";
//
// 商品上架成功的提示信息。
// 当管理员将商品上架成功时返回此消息。
//
public static String GOODS_UP_OK = "商品上架成功";
//
// 商品下架成功的提示信息。
// 当管理员将商品下架成功时返回此消息。
//
public static String GOODS_DOWN_OK = "商品下架成功";
}

20
src/main/java/com/shanzhu/flower/config/ProcessInterceptor.java
Unescape View File

@ -9,6 +9,7 @@ import javax.servlet.http.HttpServletResponse;
/**
* 请求处理拦截器
* 用于处理跨域请求和预请求（OPTIONS方法）。
*
* @author: ShanZhu
* @date: 2024-01-24
@ -18,23 +19,38 @@ public class ProcessInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
// 设置允许跨域访问的来源，允许所有来源
httpServletResponse.setHeader("Access-Control-Allow-Origin", "*");
// 设置允许的请求头字段
httpServletResponse.setHeader("Access-Control-Allow-Headers", "Content-Type,Content-Length, Authorization, Accept,X-Requested-With");
// 设置允许的请求方法
httpServletResponse.setHeader("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS");
// 设置服务器信息头，表明服务器使用的服务器软件
httpServletResponse.setHeader("X-Powered-By", "Jetty");
// 获取请求的方法类型
String method = httpServletRequest.getMethod();
// 判断是否为OPTIONS预请求
if (method.equals("OPTIONS")) {
// 如果是OPTIONS请求，直接返回200状态码，表示预请求通过
httpServletResponse.setStatus(200);
return false;
return false; // 不继续处理后续的请求
}
// 如果不是OPTIONS请求，继续后续的处理流程
return true;
}
@Override
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
// 在请求处理之后进行调用（在Controller方法之后）
// 用于修改ModelAndView对象，例如添加额外的模型数据或修改视图
// 本拦截器中未实现具体逻辑
}
@Override
public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
// 在整个请求结束之后被调用，主要用于进行资源清理工作
// 例如关闭数据库连接、释放资源等
// 本拦截器中未实现具体逻辑
}
}
}

15
src/main/java/com/shanzhu/flower/config/WebMvcConfig.java
Unescape View File

@ -5,7 +5,9 @@ import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* web mvc配置，跨域配置等
* Web MVC配置类，用于配置Spring MVC的相关功能。
* 主要功能包括：
* - 添加拦截器，用于处理跨域请求等。
*
* @author: ShanZhu
* @date: 2024-01-24
@ -15,8 +17,11 @@ public class WebMvcConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new ProcessInterceptor()).addPathPatterns("/**");
// 添加自定义的拦截器ProcessInterceptor
// ProcessInterceptor用于处理跨域请求和预请求（OPTIONS方法）
registry.addInterceptor(new ProcessInterceptor())
// 指定拦截器的应用路径模式
// 使用"/**"表示拦截所有请求路径
.addPathPatterns("/**");
}
}
}

144
src/main/java/com/shanzhu/flower/controller/CartController.java
Unescape View File

@ -1,5 +1,4 @@
package com.shanzhu.flower.controller;
import com.shanzhu.flower.config.Constant;
import com.shanzhu.flower.config.HttpMsg;
import com.shanzhu.flower.dao.FlowersDao;
@ -9,15 +8,13 @@ import com.shanzhu.flower.service.CartService;
import com.shanzhu.flower.service.OrderService;
import org.springframework.web.bind.annotation.*;
import tk.mybatis.mapper.util.StringUtil;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 购物车 控制层
* 提供购物车相关的RESTful API接口，包括查询、分页查询、购买、新增、更新和删除购物车项。
*
* @author: ShanZhu
* @date: 2024-01-24
@ -25,48 +22,43 @@ import java.util.Map;
@RestController
@RequestMapping("cart")
public class CartController {
@Resource
private CartService cartService;
private CartService cartService; // 注入购物车服务层
@Resource
private OrderService orderService;
private OrderService orderService; // 注入订单服务层
@Resource
private FlowersDao flowersDao;
private FlowersDao flowersDao; // 注入花朵数据访问对象
/**
* 查询用户购物车
* 根据用户账号查询其购物车中的所有商品，并计算每个商品的总价。
*
* @param account 用户账号
* @return 购物车
* @return 购物车信息
*/
@RequestMapping("/queryByAccount")
R queryByAccount(@RequestParam("account") String account) {
R r = new R();
R r = new R(); // 创建响应对象
// 检查用户账号是否为空
if (StringUtil.isEmpty(account)) {
return r.setCode(4000).setMsg(HttpMsg.INVALID_PARAM);
return r.setCode(4000).setMsg(HttpMsg.INVALID_PARAM); // 参数不合法
}
// 查询购物车中的商品
List<Cart> carts = cartService.queryByAccount(account);
// 计算每个商品的总价
for (Cart cart : carts) {
float price = flowersDao.queryPrice(cart.getFid());
cart.setPrice(cart.getAmount() * price);
float price = flowersDao.queryPrice(cart.getFid()); // 查询商品单价
cart.setPrice(cart.getAmount() * price); // 设置总价
}
return r.setCode(2000).setData(carts);
return r.setCode(2000).setData(carts); // 返回成功响应
}
/**
* 分页查询购物车
* 根据用户账号和查询条件分页查询购物车中的商品。
*
* @param page 页数
* @param page 页数
* @param searchKey 查询条件
* @param account 账户
* @return 购物车列表
* @param account 用户账号
* @return 分页后的购物车信息
*/
@RequestMapping("/find")
R find(
@ -74,103 +66,101 @@ public class CartController {
@RequestParam("searchKey") String searchKey,
@RequestParam("account") String account
) {
R r = new R();
Map<String, Object> map = new HashMap<>();
List<Cart> carts = cartService.find(searchKey, account);
R r = new R(); // 创建响应对象
// 创建返回数据的Map
Map map = new HashMap<>();
// 查询购物车中的商品
List carts = cartService.find(searchKey, account);
// 如果查询结果为空，直接返回
if (carts == null) {
return r.setCode(2000);
}
List<Cart> items = carts.size() >= page * Constant.PAGE_SIZE ?
carts.subList((page - 1) * Constant.PAGE_SIZE, page * Constant.PAGE_SIZE)
: carts.subList((page - 1) * Constant.PAGE_SIZE, carts.size());
int len = carts.size() % Constant.PAGE_SIZE == 0 ? carts.size() / Constant.PAGE_SIZE
: (carts.size() / Constant.PAGE_SIZE + 1);
// 计算分页信息
int totalSize = carts.size(); // 总记录数
int pageSize = Constant.PAGE_SIZE; // 每页大小
int totalPages = (totalSize + pageSize - 1) / pageSize; // 总页数
// 获取当前页的数据
int start = (page - 1) * pageSize;
int end = Math.min(start + pageSize, totalSize);
List items = carts.subList(start, end);
// 将分页信息和当前页数据放入Map
map.put("items", items);
map.put("len", len);
return r.setCode(2000).setData(map);
map.put("len", totalPages);
return r.setCode(2000).setData(map); // 返回成功响应
}
/**
* 购买
* 将购物车中的商品生成订单，并清空购物车。
*
* @param account 账号
* @return 结果
* @param account 用户账号
* @return 购买结果
*/
@RequestMapping("/buy")
R buy(@RequestParam("account") String account) {
R r = new R();
// 查该用户的购物车
List<Cart> carts = (List<Cart>) queryByAccount(account).getData();
R r = new R(); // 创建响应对象
// 查询该用户的购物车
List<Cart> carts = (List) queryByAccount(account).getData();
// 遍历购物车中的商品
for (Cart cart : carts) {
// 增加订单数据
// 增加订单数据
orderService.add(cart);
// 删除购物车数据
// 删除购物车数据
cartService.delete(cart.getId());
}
return r.setCode(2000).setMsg(HttpMsg.BUY_OK);
return r.setCode(2000).setMsg(HttpMsg.BUY_OK); // 返回购买成功响应
}
/**
* 新增购物车
* 将商品添加到购物车中。
*
* @param cart 购物车信息
* @return 购物车
* @return 新增结果
*/
@RequestMapping("/create")
R create(@RequestBody Cart cart) {
R r = new R();
R r = new R(); // 创建响应对象
// 调用服务层添加购物车
int ans = cartService.add(cart);
// 根据返回结果设置响应
if (ans == 1) {
return r.setCode(2000).setMsg(HttpMsg.ADD_CART_OK);
return r.setCode(2000).setMsg(HttpMsg.ADD_CART_OK); // 添加成功
}
return r.setCode(4000).setMsg(HttpMsg.ADD_CART_FAILED);
return r.setCode(4000).setMsg(HttpMsg.ADD_CART_FAILED); // 添加失败
}
/**
* 更新购物车
* 更新购物车中的商品信息。
*
* @param cart 购物车信息
* @return 结果
* @return 更新结果
*/
@RequestMapping("/update")
R update(@RequestBody Cart cart) {
R r = new R();
R r = new R(); // 创建响应对象
// 调用服务层更新购物车
int ans = cartService.update(cart);
// 根据返回结果设置响应
if (ans >= 0) {
return r.setCode(2000).setMsg(HttpMsg.UPDATE_USER_OK);
return r.setCode(2000).setMsg(HttpMsg.UPDATE_USER_OK); // 更新成功
}
return r.setCode(4000).setMsg(HttpMsg.UPDATE_USER_FAILED);
return r.setCode(4000).setMsg(HttpMsg.UPDATE_USER_FAILED); // 更新失败
}
/**
* 删除购物车
* 根据购物车ID删除购物车中的商品。
*
* @param id 购物车id
* @return 结果
* @param id 购物车ID
* @return 删除结果
*/
@DeleteMapping("/delete")
R delete(@RequestParam("id") int id) {
R r = new R();
R r = new R(); // 创建响应对象
// 调用服务层删除购物车
int ans = cartService.delete(id);
// 根据返回结果设置响应
if (ans == 1) {
return r.setCode(2000).setMsg(HttpMsg.DELETE_USER_OK);
return r.setCode(2000).setMsg(HttpMsg.DELETE_USER_OK); // 删除成功
}
return r.setCode(4000).setMsg(HttpMsg.DELETE_USER_FAILED);
return r.setCode(4000).setMsg(HttpMsg.DELETE_USER_FAILED); // 删除失败
}
}

93
src/main/java/com/shanzhu/flower/controller/FlowerController.java
Unescape View File

@ -29,12 +29,12 @@ import java.util.UUID;
public class FlowerController {
@Value("${uploadPath}")
private String uploadPath;
private String uploadPath; // 注入文件上传路径配置
@Resource
private FlowersService flowerService;
private FlowersService flowerService; // 注入鲜花业务逻辑服务
@Resource
private FlowersDao flowersDao;
private FlowersDao flowersDao; // 注入鲜花数据访问对象
/**
* 分页查询鲜花商品
@ -42,7 +42,7 @@ public class FlowerController {
* @param page 页数
* @param searchKey 查询条件
* @param searchType 查询类型
* @return 商品
* @return 商品分页数据
*/
@RequestMapping("/find")
R find(
@ -51,13 +51,13 @@ public class FlowerController {
@RequestParam("searchType") String searchType
) {
R r = new R();
List<Flower> flowers = flowerService.find(searchKey, searchType);
List<Flower> flowers = flowerService.find(searchKey, searchType); // 调用服务层查询鲜花列表
if (flowers == null) {
return r.setCode(2000);
return r.setCode(2000); // 返回查询失败状态码
}
return getResponse(flowers, page, Constant.SHOW_PAGE_SIZE, r);
return getResponse(flowers, page, Constant.SHOW_PAGE_SIZE, r); // 构建分页响应数据
}
/**
@ -70,13 +70,13 @@ public class FlowerController {
@RequestMapping("/findAll")
R findAll(@RequestParam("page") int page, @RequestParam("searchKey") String searchKey) {
R r = new R();
List<Flower> flowers = flowerService.findAll(searchKey);
List<Flower> flowers = flowerService.findAll(searchKey); // 调用服务层查询所有鲜花
if (flowers == null) {
return r.setCode(2000);
return r.setCode(2000); // 返回查询失败状态码
}
return getResponse(flowers, page, Constant.PAGE_SIZE, r);
return getResponse(flowers, page, Constant.PAGE_SIZE, r); // 构建分页响应数据
}
/**
@ -89,12 +89,12 @@ public class FlowerController {
R create(@RequestBody Flower flower) {
R r = new R();
int ans = flowerService.add(flower);
int ans = flowerService.add(flower); // 调用服务层添加鲜花
if (ans == 1) {
return r.setCode(2000).setMsg(HttpMsg.ADD_FLOWER_OK);
return r.setCode(2000).setMsg(HttpMsg.ADD_FLOWER_OK); // 返回添加成功信息
}
return r.setCode(4000).setMsg(HttpMsg.ADD_FLOWER_FAILED);
return r.setCode(4000).setMsg(HttpMsg.ADD_FLOWER_FAILED); // 返回添加失败信息
}
/**
@ -107,12 +107,12 @@ public class FlowerController {
R update(@RequestBody Flower flower) {
R r = new R();
int ans = flowerService.update(flower);
int ans = flowerService.update(flower); // 调用服务层更新鲜花信息
if (ans >= 0) {
return r.setCode(2000).setMsg(HttpMsg.UPDATE_FLOWER_OK);
return r.setCode(2000).setMsg(HttpMsg.UPDATE_FLOWER_OK); // 返回更新成功信息
}
return r.setCode(4000).setMsg(HttpMsg.UPDATE_FLOWER_FAILED);
return r.setCode(4000).setMsg(HttpMsg.UPDATE_FLOWER_FAILED); // 返回更新失败信息
}
/**
@ -125,10 +125,10 @@ public class FlowerController {
R changeState(@RequestBody Flower flower) {
R r = new R();
flowersDao.changeState(flower);
String msg = flower.getState() == 1 ? HttpMsg.GOODS_UP_OK : HttpMsg.GOODS_DOWN_OK;
flowersDao.changeState(flower); // 直接调用DAO层修改商品状态
String msg = flower.getState() == 1 ? HttpMsg.GOODS_UP_OK : HttpMsg.GOODS_DOWN_OK; // 判断上下架状态
return r.setCode(2000).setMsg(msg);
return r.setCode(2000).setMsg(msg); // 返回操作成功信息
}
/**
@ -144,16 +144,16 @@ public class FlowerController {
// 只接收 jpg/png 图片
String filename = file.getOriginalFilename();
if (!filename.endsWith(".jpg") && !filename.endsWith(".png")) {
return r.setCode(4000).setMsg(HttpMsg.ERROR_FILE_TYPE);
return r.setCode(4000).setMsg(HttpMsg.ERROR_FILE_TYPE); // 返回文件类型错误信息
}
String img_guid = UUID.randomUUID().toString().replaceAll("-", "") + ".jpg";
String img_guid = UUID.randomUUID().toString().replaceAll("-", "") + ".jpg"; // 生成唯一图片文件名
try {
savePic(file.getInputStream(), img_guid);
return r.setCode(2000).setMsg(HttpMsg.UPDATE_PIC_OK).setData(img_guid);
savePic(file.getInputStream(), img_guid); // 保存图片文件
return r.setCode(2000).setMsg(HttpMsg.UPDATE_PIC_OK).setData(img_guid); // 返回上传成功信息
} catch (IOException e) {
return r.setCode(4000).setMsg(HttpMsg.UPDATE_PIC_FAILED);
return r.setCode(4000).setMsg(HttpMsg.UPDATE_PIC_FAILED); // 返回上传失败信息
}
}
@ -169,12 +169,12 @@ public class FlowerController {
R updateImgGuid(@RequestParam("guid") String guid, @RequestParam("id") int id) {
R r = new R();
int ans = flowerService.updateImg(guid, id);
int ans = flowerService.updateImg(guid, id); // 调用服务层更新图片GUID
if (ans == 1) {
return r.setCode(2000).setMsg(HttpMsg.UPDATE_PIC_OK);
return r.setCode(2000).setMsg(HttpMsg.UPDATE_PIC_OK); // 返回更新成功信息
}
return r.setCode(4000).setMsg(HttpMsg.UPDATE_PIC_FAILED);
return r.setCode(4000).setMsg(HttpMsg.UPDATE_PIC_FAILED); // 返回更新失败信息
}
/**
@ -187,14 +187,19 @@ public class FlowerController {
R delete(@RequestParam("id") int id) {
R r = new R();
int ans = flowerService.delete(id);
int ans = flowerService.delete(id); // 调用服务层删除鲜花
if (ans == 1) {
return r.setCode(2000).setMsg(HttpMsg.DELETE_FLOWER_OK);
return r.setCode(2000).setMsg(HttpMsg.DELETE_FLOWER_OK); // 返回删除成功信息
}
return r.setCode(4000).setMsg(HttpMsg.DELETE_FLOWER_FAILED);
return r.setCode(4000).setMsg(HttpMsg.DELETE_FLOWER_FAILED); // 返回删除失败信息
}
/**
* 保存图片文件到指定路径
* @param inputStream 输入流
* @param fileName 文件名
*/
private void savePic(InputStream inputStream, String fileName) {
OutputStream os = null;
try {
@ -207,38 +212,48 @@ public class FlowerController {
os = new FileOutputStream(new File(path + fileName));
// 开始读取
while ((len = inputStream.read(bs)) != -1) {
os.write(bs, 0, len);
os.write(bs, 0, len); // 将数据写入文件
}
} catch (Exception e) {
e.printStackTrace();
e.printStackTrace(); // 打印异常堆栈信息
} finally {
// 完毕，关闭所有链接
try {
os.close();
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
e.printStackTrace(); // 打印关闭流异常信息
}
}
}
/**
* 构建分页响应数据
* @param flowers 鲜花列表
* @param page 当前页码
* @param pageSize 每页大小
* @param r 响应对象
* @return 分页数据
*/
private R getResponse(List<Flower> flowers, int page, int pageSize, R r) {
Map<String, Object> map = new HashMap<>();
// 计算当前页数据
List<Flower> items = flowers.size() >= page * pageSize ?
flowers.subList((page - 1) * pageSize, page * pageSize)
: flowers.subList((page - 1) * pageSize, flowers.size());
// 计算总页数
int len = flowers.size() % pageSize == 0 ? flowers.size() / pageSize
: (flowers.size() / pageSize + 1);
// 处理图片路径
for (Flower item : items) {
if (item.getImg_guid() == null) {
item.setImg_guid(Constant.DEFAULT_IMG);
item.setImg_guid(Constant.DEFAULT_IMG); // 设置默认图片
}
item.setImg_guid(Constant.IMG_USE_PATH + item.getImg_guid());
item.setImg_guid(Constant.IMG_USE_PATH + item.getImg_guid()); // 添加图片访问路径前缀
}
map.put("items", items);
map.put("len", len);
return r.setCode(2000).setData(map);
map.put("items", items); // 分页数据
map.put("len", len); // 总页数
return r.setCode(2000).setData(map); // 返回分页响应
}
}

69
src/main/java/com/shanzhu/flower/controller/FlowerTypeController.java
Unescape View File

@ -21,68 +21,97 @@ import java.util.Map;
public class FlowerTypeController {
@Resource
private SpeciesService speciesService;
private SpeciesService speciesService; // 注入鲜花种类业务逻辑服务
/**
* 查询所有鲜花种类
* @return 鲜花种类列表
*/
@RequestMapping("/findAll")
R findAll() {
R r = new R();
List<Species> all = speciesService.findAll();
if (all.size()<=0){
return r.setCode(4000).setMsg(HttpMsg.NO_TYPE_NOW);
List<Species> all = speciesService.findAll(); // 调用服务层查询所有鲜花种类
if (all.size() <= 0) {
return r.setCode(4000).setMsg(HttpMsg.NO_TYPE_NOW); // 返回无种类信息
}
return r.setCode(2000).setData(all);
return r.setCode(2000).setData(all); // 返回成功及种类列表
}
/**
* 分页查询鲜花种类
* @param page 页码
* @param searchKey 查询关键词
* @return 分页结果
*/
@RequestMapping("/find")
R find(@RequestParam("page") int page, @RequestParam("searchKey") String searchKey) {
R r = new R();
Map<String, Object> map = new HashMap<>();
List<Species> list = speciesService.find(searchKey);
List<Species> list = speciesService.find(searchKey); // 调用服务层查询符合条件的种类
if (list == null) {
return r.setCode(2000);
return r.setCode(2000); // 返回查询失败状态
}
// 分页逻辑 - 获取当前页数据
List<Species> items = list.size() >= page * Constant.PAGE_SIZE ?
list.subList((page - 1) * Constant.PAGE_SIZE, page * Constant.PAGE_SIZE)
: list.subList((page - 1) * Constant.PAGE_SIZE, list.size());
// 计算总页数
int len = list.size() % Constant.PAGE_SIZE == 0 ? list.size() / Constant.PAGE_SIZE
: (list.size() / Constant.PAGE_SIZE + 1);
map.put("items", items);
map.put("len", len);
return r.setCode(2000).setData(map);
map.put("items", items); // 当前页数据
map.put("len", len); // 总页数
return r.setCode(2000).setData(map); // 返回分页结果
}
/**
* 创建鲜花种类
* @param species 种类信息
* @return 操作结果
*/
@RequestMapping("/create")
R create(@RequestBody Species species) {
R r = new R();
try {
speciesService.add(species);
return r.setCode(2000).setMsg(HttpMsg.ADD_TYPE_OK);
speciesService.add(species); // 调用服务层添加种类
return r.setCode(2000).setMsg(HttpMsg.ADD_TYPE_OK); // 返回添加成功信息
} catch (Exception e) {
return r.setCode(4000).setMsg(HttpMsg.ADD_TYPE_FAILED);
return r.setCode(4000).setMsg(HttpMsg.ADD_TYPE_FAILED); // 返回添加失败信息
}
}
/**
* 更新鲜花种类信息
* @param species 种类信息
* @return 操作结果
*/
@RequestMapping("/update")
R update(@RequestBody Species species) {
R r = new R();
try {
speciesService.update(species);
return r.setCode(2000).setMsg(HttpMsg.UPDATE_TYPE_OK);
speciesService.update(species); // 调用服务层更新种类信息
return r.setCode(2000).setMsg(HttpMsg.UPDATE_TYPE_OK); // 返回更新成功信息
} catch (Exception e) {
return r.setCode(4000).setMsg(HttpMsg.UPDATE_TYPE_FAILED);
return r.setCode(4000).setMsg(HttpMsg.UPDATE_TYPE_FAILED); // 返回更新失败信息
}
}
/**
* 删除鲜花种类
* @param id 种类ID
* @return 操作结果
*/
@DeleteMapping("/delete")
R delete(@RequestParam("id") int id) {
R r = new R();
try {
speciesService.delete(id);
return r.setCode(2000).setMsg(HttpMsg.DELETE_TYPE_OK);
speciesService.delete(id); // 调用服务层删除种类
return r.setCode(2000).setMsg(HttpMsg.DELETE_TYPE_OK); // 返回删除成功信息
} catch (Exception e) {
return r.setCode(4000).setMsg(HttpMsg.DELETE_TYPE_FAILED);
return r.setCode(4000).setMsg(HttpMsg.DELETE_TYPE_FAILED); // 返回删除失败信息
}
}
}

23
src/main/java/com/shanzhu/flower/controller/LoginController.java
Unescape View File

@ -12,9 +12,9 @@ import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
* 用户登录 控制层
* 提供用户登录的RESTful API接口，处理用户登录请求，验证登录信息，并返回登录结果。
*
* @author: ShanZhu
* @date: 2024-01-24
@ -24,19 +24,32 @@ import javax.annotation.Resource;
public class LoginController {
@Resource
private LoginDao loginDao;
private LoginDao loginDao; // 注入登录数据访问对象
/**
* 用户登录
* 处理用户登录请求，验证登录表单信息，查询用户数据，返回登录结果。
*
* @param form 登录表单信息
* @return 登录结果
*/
@RequestMapping("/doLogin")
R doLogin(@RequestBody LoginForm form) {
R r = new R();
R r = new R(); // 创建响应对象
// 验证登录表单信息
if (!VerifyUtil.verifyLoginForm(form)) {
return r.setCode(4000).setMsg(HttpMsg.ERROR_INPUT);
return r.setCode(4000).setMsg(HttpMsg.ERROR_INPUT); // 表单信息不正确
}
// 查询用户信息
User loginUser = loginDao.login(form);
if (loginUser != null) {
// 登录成功，返回用户信息和欢迎消息
return r.setCode(2000).setMsg("欢迎您：" + loginUser.getName()).setData(loginUser);
}
// 登录失败，返回错误信息
return r.setCode(4000).setMsg(HttpMsg.ERROR_VERIFY);
}
}

145
src/main/java/com/shanzhu/flower/controller/OrderController.java
Unescape View File

@ -1,5 +1,4 @@
package com.shanzhu.flower.controller;
import com.shanzhu.flower.config.Constant;
import com.shanzhu.flower.config.HttpMsg;
import com.shanzhu.flower.dao.OrderDao;
@ -11,16 +10,14 @@ import com.shanzhu.flower.entity.User;
import com.shanzhu.flower.service.OrderService;
import org.springframework.web.bind.annotation.*;
import tk.mybatis.mapper.util.StringUtil;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 订单 控制层
* 提供订单相关的RESTful API接口，包括查询订单、分页查询订单列表、更新订单状态、删除订单等。
*
* @author: ShanZhu
* @date: 2024-01-24
@ -28,92 +25,140 @@ import java.util.Map;
@RestController
@RequestMapping("order")
public class OrderController {
@Resource
private OrderService orderService;
private OrderService orderService; // 注入订单服务层
@Resource
private UserDao userDao;
private UserDao userDao; // 注入用户数据访问对象
@Resource
private OrderDao orderDao;
private OrderDao orderDao; // 注入订单数据访问对象
/**
* 根据账号查询订单
* 查询指定账号的所有订单。
*
* @param account 用户账号
* @return 订单列表
*/
@RequestMapping("/queryByAccount")
R queryByAccount(@RequestParam("account") String account) {
R r = new R();
R r = new R(); // 创建响应对象
// 检查账号是否为空
if (StringUtil.isEmpty(account)) {
return r.setCode(4000).setMsg(HttpMsg.INVALID_PARAM);
return r.setCode(4000).setMsg(HttpMsg.INVALID_PARAM); // 参数不合法
}
List<Order> orders = orderService.queryByAccount(account);
return r.setCode(2000).setData(orders);
// 查询订单
List orders = orderService.queryByAccount(account);
return r.setCode(2000).setData(orders); // 返回订单列表
}
/**
* 分页查询订单
* 根据查询条件和页码分页查询订单列表。
*
* @param page 页码
* @param searchKey 查询条件
* @param account 用户账号
* @return 分页后的订单列表
*/
@RequestMapping("/find")
R find(@RequestParam("page") int page, @RequestParam("searchKey") String searchKey, @RequestParam("account") String account) {
R r = new R();
Map<String, Object> map = new HashMap<>();
List<Order> orders = orderService.find(searchKey, account);
R r = new R(); // 创建响应对象
Map map = new HashMap<>(); // 创建返回数据的Map
// 查询订单列表
List orders = orderService.find(searchKey, account);
if (orders == null) {
return r.setCode(2000);
return r.setCode(2000); // 没有查询到数据
}
// 将订单列表放入Map
map.put("items", orders);
map.put("len", orders.size());
return r.setCode(2000).setData(map);
return r.setCode(2000).setData(map); // 返回分页后的订单列表
}
/**
* 分页查询所有订单
* 查询所有订单，并根据页码分页。
*
* @param page 页码
* @param searchKey 查询条件
* @return 分页后的订单列表
*/
@RequestMapping("/findAll")
R findAll(@RequestParam("page") int page, @RequestParam("searchKey") String searchKey) {
R r = new R();
Map<String, Object> map = new HashMap<>();
List<Order> orders = orderService.findAll(searchKey);
R r = new R(); // 创建响应对象
Map map = new HashMap<>(); // 创建返回数据的Map
// 查询所有订单
List orders = orderService.findAll(searchKey);
if (orders == null) {
return r.setCode(2000);
return r.setCode(2000); // 没有查询到数据
}
List<Order> items = orders.size() >= page * Constant.PAGE_SIZE ?
orders.subList((page - 1) * Constant.PAGE_SIZE, page * Constant.PAGE_SIZE)
: orders.subList((page - 1) * Constant.PAGE_SIZE, orders.size());
int len = orders.size() % Constant.PAGE_SIZE == 0 ? orders.size() / Constant.PAGE_SIZE
: (orders.size() / Constant.PAGE_SIZE + 1);
List<OrderVo> vos = new ArrayList<>();
// 计算分页信息
int totalSize = orders.size(); // 总记录数
int pageSize = Constant.PAGE_SIZE; // 每页大小
int totalPages = (totalSize + pageSize - 1) / pageSize; // 总页数
// 获取当前页的数据
int start = (page - 1) * pageSize;
int end = Math.min(start + pageSize, totalSize);
List<Order> items = orders.subList(start, end);
// 将订单信息转换为OrderVo
List vos = new ArrayList<>();
for (Order item : items) {
User user = userDao.queryById(item.getUid());
OrderVo vo = new OrderVo();
User user = userDao.queryById(item.getUid()); // 查询用户信息
OrderVo vo = new OrderVo(); // 创建OrderVo对象
vo.setAddress(user.getAddress()).setPhone(user.getPhone()).setUsername(user.getName())
.setAmount(item.getAmount()).setFlower(item.getFlower()).setId(item.getId())
.setUid(item.getUid()).setOrder_guid(item.getOrder_guid()).setPrice(item.getPrice())
.setState(item.getState());
vos.add(vo);
vos.add(vo); // 添加到列表
}
// 将分页信息和订单列表放入Map
map.put("items", vos);
map.put("len", len);
return r.setCode(2000).setData(map);
map.put("len", totalPages);
return r.setCode(2000).setData(map); // 返回分页后的订单列表
}
/**
* 更新订单
* 更新指定订单的信息。
*
* @param order 订单信息
* @return 更新结果
*/
@RequestMapping("/update")
R update(@RequestBody Order order) {
R r = new R();
R r = new R(); // 创建响应对象
// 调用服务层更新订单
int ans = orderService.update(order);
// 根据返回结果设置响应
if (ans >= 0) {
return r.setCode(2000).setMsg(HttpMsg.UPDATE_USER_OK);
return r.setCode(2000).setMsg(HttpMsg.UPDATE_USER_OK); // 更新成功
}
return r.setCode(4000).setMsg(HttpMsg.UPDATE_USER_FAILED);
return r.setCode(4000).setMsg(HttpMsg.UPDATE_USER_FAILED); // 更新失败
}
/**
* 改变订单状态
* 更新指定订单的状态。
*
* @param order 订单信息
* @return 更新结果
*/
@RequestMapping("/changeState")
R changeState(@RequestBody Order order) {
orderDao.changeState(order);
return new R().setCode(2000).setMsg(HttpMsg.UPDATE_ORDER_OK);
orderDao.changeState(order); // 调用数据访问对象更新订单状态
return new R().setCode(2000).setMsg(HttpMsg.UPDATE_ORDER_OK); // 返回成功响应
}
/**
* 删除订单
* 根据订单ID删除订单。
*
* @param id 订单ID
* @return 删除结果
*/
@DeleteMapping("/delete")
R delete(@RequestParam("id") int id) {
R r = new R();
R r = new R(); // 创建响应对象
// 调用服务层删除订单
int ans = orderService.delete(id);
// 根据返回结果设置响应
if (ans == 1) {
return r.setCode(2000).setMsg(HttpMsg.DELETE_USER_OK);
return r.setCode(2000).setMsg(HttpMsg.DELETE_USER_OK); // 删除成功
}
return r.setCode(4000).setMsg(HttpMsg.DELETE_USER_FAILED);
return r.setCode(4000).setMsg(HttpMsg.DELETE_USER_FAILED); // 删除失败
}
}

122
src/main/java/com/shanzhu/flower/controller/UserController.java
Unescape View File

@ -13,9 +13,9 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 用户 控制层
* 提供用户相关的RESTful API接口，包括查询用户信息、分页查询用户列表、新增用户、更新用户信息和删除用户。
*
* @author: ShanZhu
* @date: 2024-01-24
@ -25,68 +25,132 @@ import java.util.Map;
public class UserController {
@Resource
private UserService userService;
private UserService userService; // 注入用户服务层
/**
* 根据账号查询用户信息
* 查询指定账号的用户详细信息。
*
* @param account 用户账号
* @return 用户信息
*/
@RequestMapping("/queryInfoByAccount")
R queryInfoByAccount(@RequestParam("account") String account) {
R r = new R();
if (StringUtil.isEmpty(account)){
return r.setCode(4000).setMsg(HttpMsg.INVALID_PARAM);
R r = new R(); // 创建响应对象
// 检查账号是否为空
if (StringUtil.isEmpty(account)) {
return r.setCode(4000).setMsg(HttpMsg.INVALID_PARAM); // 参数不合法
}
// 查询用户信息
User loginUser = userService.queryInfo(account);
if (loginUser == null){
return r.setCode(4000).setMsg(HttpMsg.INVALID_USER);
if (loginUser == null) {
return r.setCode(4000).setMsg(HttpMsg.INVALID_USER); // 用户不存在
}
return r.setCode(2000).setData(loginUser);
return r.setCode(2000).setData(loginUser); // 返回用户信息
}
/**
* 分页查询用户列表
* 根据查询条件和页码分页查询用户列表。
*
* @param page 页码
* @param searchKey 查询条件
* @return 分页后的用户列表
*/
@RequestMapping("/find")
R find(@RequestParam("page") int page, @RequestParam("searchKey") String searchKey) {
R r = new R();
Map<String, Object> map = new HashMap<>();
R r = new R(); // 创建响应对象
Map<String, Object> map = new HashMap<>(); // 创建返回数据的Map
// 查询用户列表
List<User> users = userService.find(searchKey);
if (users == null) {
return r.setCode(2000);
return r.setCode(2000); // 没有查询到数据
}
List<User> items = users.size() >= page * Constant.PAGE_SIZE ?
users.subList((page - 1) * Constant.PAGE_SIZE, page * Constant.PAGE_SIZE)
: users.subList((page - 1) * Constant.PAGE_SIZE, users.size());
int len = users.size() % Constant.PAGE_SIZE == 0 ? users.size() / Constant.PAGE_SIZE
: (users.size() / Constant.PAGE_SIZE + 1);
// 计算分页信息
int totalSize = users.size(); // 总记录数
int pageSize = Constant.PAGE_SIZE; // 每页大小
int totalPages = (totalSize + pageSize - 1) / pageSize; // 总页数
// 获取当前页的数据
int start = (page - 1) * pageSize;
int end = Math.min(start + pageSize, totalSize);
List<User> items = users.subList(start, end);
// 将分页信息和当前页数据放入Map
map.put("items", items);
map.put("len", len);
return r.setCode(2000).setData(map);
map.put("len", totalPages);
return r.setCode(2000).setData(map); // 返回分页后的用户列表
}
/**
* 新增用户
* 添加一个新的用户记录。
*
* @param user 用户信息
* @return 新增结果
*/
@RequestMapping("/create")
R create(@RequestBody User user) {
R r = new R();
R r = new R(); // 创建响应对象
// 调用服务层添加用户
int ans = userService.add(user);
// 根据返回结果设置响应
if (ans == 1) {
return r.setCode(2000).setMsg(HttpMsg.ADD_USER_OK);
return r.setCode(2000).setMsg(HttpMsg.ADD_USER_OK); // 添加成功
}
return r.setCode(4000).setMsg(HttpMsg.ADD_USER_FAILED);
return r.setCode(4000).setMsg(HttpMsg.ADD_USER_FAILED); // 添加失败
}
/**
* 更新用户信息
* 更新指定用户的详细信息。
*
* @param user 用户信息
* @return 更新结果
*/
@RequestMapping("/update")
R update(@RequestBody User user) {
R r = new R();
R r = new R(); // 创建响应对象
// 调用服务层更新用户
int ans = userService.update(user);
// 根据返回结果设置响应
if (ans >= 0) {
return r.setCode(2000).setMsg(HttpMsg.UPDATE_USER_OK);
return r.setCode(2000).setMsg(HttpMsg.UPDATE_USER_OK); // 更新成功
}
return r.setCode(4000).setMsg(HttpMsg.UPDATE_USER_FAILED);
return r.setCode(4000).setMsg(HttpMsg.UPDATE_USER_FAILED); // 更新失败
}
/**
* 删除用户
* 根据用户ID删除用户记录。
*
* @param id 用户ID
* @return 删除结果
*/
@DeleteMapping("/delete")
R delete(@RequestParam("id") int id) {
R r = new R();
R r = new R(); // 创建响应对象
// 调用服务层删除用户
int ans = userService.delete(id);
// 根据返回结果设置响应
if (ans == 1) {
return r.setCode(2000).setMsg(HttpMsg.DELETE_USER_OK);
return r.setCode(2000).setMsg(HttpMsg.DELETE_USER_OK); // 删除成功
}
return r.setCode(4000).setMsg(HttpMsg.DELETE_USER_FAILED);
}
return r.setCode(4000).setMsg(HttpMsg.DELETE_USER_FAILED); // 删除失败
}
}

63
src/main/java/com/shanzhu/flower/dao/CartDao.java
Unescape View File

@ -9,33 +9,84 @@ import java.util.List;
@Repository
public interface CartDao {
@Select("select * from carts where flower like concat('%',#{searchKey},'%') and account = #{account};")
//
// 根据搜索关键词和用户账号查询购物车
// 查询购物车中包含指定搜索关键词的商品，并且属于指定用户账号的记录。
//
// @param searchKey 搜索关键词
// @param account 用户账号
// @return 购物车列表
//
@Select("select * from carts where flower like concat('%',#{searchKey},'%') and account = #{account};")
List<Cart> find(@Param("searchKey") String searchKey, @Param("account") String account);
//
// 查询所有购物车记录
// 查询购物车表中的所有记录。
//
// @return 购物车记录列表
//
@Select("select * from carts;")
List<Cart> findAll();
//
// 检查商品是否已添加到购物车
// 查询指定用户是否已将指定商品添加到购物车。
//
// @param cart 购物车对象，包含商品ID（fid）和用户ID（uid）
// @return 购物车记录，如果已添加则返回记录，否则返回null
//
@Select("select * from carts where fid = #{fid} and uid = #{uid};")
Cart checkIsAdded(Cart cart);
//
// 增加购物车中商品的数量
// 将指定用户购物车中指定商品的数量加1。
//
// @param cart 购物车对象，包含商品ID（fid）和用户ID（uid）
// @return 影响的行数，成功返回1，失败返回0
//
@Update("update carts set amount = amount + 1 where fid = #{fid} and uid = #{uid};")
int addAmount(Cart cart);
//
// 根据用户ID查询购物车
// 查询指定用户购物车中的所有商品。
//
// @param uid 用户ID
// @return 购物车列表
//
@Select("select * from carts where uid = #{uid};")
List<Cart> queryByUid(int uid);
//
// 更新购物车记录
// 更新购物车中的记录，包括商品名称、密码、电话和地址。
//
// @param cart 购物车对象，包含需要更新的字段
// @return 影响的行数，成功返回1，失败返回0
//
@Update("update carts set name = #{name},password = #{password},phone = #{phone},address = #{address} where id = #{id};")
int update(Cart cart);
//
// 删除购物车记录
// 根据购物车ID删除记录。
//
// @param id 购物车ID
// @return 影响的行数，成功返回1，失败返回0
//
@Delete("delete from carts where id = #{id};")
int delete(int id);
//
// 添加购物车记录
// 将新的购物车记录插入到数据库中。
//
// @param cart 购物车对象，包含商品ID、商品名称、数量和用户ID
// @return 影响的行数，成功返回1，失败返回0
//
@Insert("insert into carts(fid,flower,amount,uid) " +
"values(#{fid},#{flower},1,#{uid});")
int add(Cart cart);
}

54
src/main/java/com/shanzhu/flower/dao/FlowersDao.java
Unescape View File

@ -6,36 +6,76 @@ import org.springframework.stereotype.Repository;
import java.util.List;
//
// 鲜花数据访问接口，定义与鲜花表相关的数据库操作
//
@Repository
public interface FlowersDao {
//
// 根据搜索关键词和种类分页查询上架鲜花
// @param searchKey 搜索关键词，匹配鲜花名称
// @param searchType 种类名称，匹配鲜花种类
// @return 符合条件的鲜花列表
//
@Select("select * from flowers where name like concat('%',#{searchKey},'%') " +
"and species_name like concat('%',#{searchType},'%') and state = 1;")
List<Flower> find(@Param("searchKey") String searchKey, @Param("searchType")String searchType);
List<Flower> find(@Param("searchKey") String searchKey, @Param("searchType") String searchType);
//
// 管理员查询所有鲜花（含未上架）
// @param searchKey 搜索关键词，匹配鲜花名称
// @return 符合条件的鲜花列表
//
@Select("select * from flowers where name like concat('%',#{searchKey},'%');")
List<Flower> findAll(String searchKey);
//
// 查询指定ID鲜花的价格
// @param fid 鲜花ID
// @return 鲜花价格
//
@Select("select price from flowers where id = #{fid};")
Float queryPrice(int fid);
//
// 更新鲜花基本信息
// @param flower 包含ID和要更新信息的鲜花对象
// @return 受影响的行数
//
@Update("update flowers set name = #{name}, species_name = #{species_name}, price = #{price}, detail = #{detail} where id = #{id};")
Integer update(Flower flower);
//
// 更新鲜花图片GUID
// @param img_guid 新的图片GUID
// @param id 鲜花ID
// @return 受影响的行数
//
@Update("update flowers set img_guid = #{img_guid} where id = #{id};")
Integer updateImg(@Param("img_guid") String img_guid,@Param("id") Integer id);
Integer updateImg(@Param("img_guid") String img_guid, @Param("id") Integer id);
//
// 修改鲜花状态（上架/下架）
// @param flower 包含ID和状态的鲜花对象
// @return 受影响的行数
//
@Update("update flowers set state = ${state} where id = #{id};")
Integer changeState(Flower flower);
//
// 删除指定ID的鲜花
// @param id 鲜花ID
// @return 受影响的行数
//
@Delete("delete from flowers where id = #{id};")
Integer delete(int id);
//
// 添加新鲜花
// @param flower 鲜花对象（ID自增，状态默认为1-上架）
// @return 受影响的行数
//
@Insert("insert into flowers(name,species_name,price,detail,state) values(#{name},#{species_name},${price},#{detail},1);")
Integer add(Flower flower);
}

15
src/main/java/com/shanzhu/flower/dao/LoginDao.java
Unescape View File

@ -7,12 +7,15 @@ import org.springframework.stereotype.Repository;
@Repository
public interface LoginDao {
//
//
// 用户登录验证
// 根据登录表单信息（账号、密码和角色）查询用户信息。
// 如果查询到用户记录，则表示登录成功；否则登录失败。
//
// @param form 登录表单信息，包含账号（account）、密码（password）和角色（role）
// @return 查询到的用户信息，如果登录成功返回User对象，否则返回null
//
@Select("select * from users where account = #{account} and password = #{password} and role = #{role};")
User login(LoginForm form);
}

66
src/main/java/com/shanzhu/flower/dao/OrderDao.java
Unescape View File

@ -10,35 +10,85 @@ import java.util.List;
@Repository
public interface OrderDao {
@Select("select * from orders where flower like concat('%',#{searchKey},'%') and uid = #{uid};")
//
// 根据搜索关键词和用户ID查询订单
// 查询指定用户的所有订单，订单中的商品名称包含指定的搜索关键词。
//
// @param searchKey 搜索关键词
// @param uid 用户ID
// @return 订单列表
//
@Select("select * from orders where flower like concat('%',#{searchKey},'%') and uid = #{uid};")
List<Order> find(@Param("searchKey") String searchKey, @Param("uid") int uid);
//
// 根据搜索关键词查询所有订单
// 查询所有订单，订单中的商品名称包含指定的搜索关键词。
//
// @param searchKey 搜索关键词
// @return 订单列表
//
@Select("select * from orders where flower like concat('%',#{searchKey},'%');")
List<Order> findAll(String searchKey);
//
// 检查订单是否已存在
// 查询指定用户是否已存在指定商品的订单。
//
// @param order 订单对象，包含商品ID（fid）和用户ID（uid）
// @return 订单记录，如果已存在则返回订单对象，否则返回null
//
@Select("select * from orders where fid = #{fid} and uid = #{uid};")
Order checkIsAdded(Order order);
//
// 更新订单状态
// 根据订单ID更新订单的状态。
//
// @param order 订单对象，包含订单ID（id）和新状态（state）
// @return 影响的行数，成功返回1，失败返回0
//
@Update("update orders set state = #{state} where id = #{id};")
int changeState(Order order);
//
// 根据用户ID查询订单
// 查询指定用户的所有订单。
//
// @param uid 用户ID
// @return 订单列表
//
@Select("select * from orders where uid = #{uid};")
List<Order> queryByUid(int uid);
//
// 更新订单信息
// 更新订单的详细信息，包括商品名称、密码、电话和地址。
//
// @param order 订单对象，包含需要更新的字段
// @return 影响的行数，成功返回1，失败返回0
//
@Update("update orders set name = #{name},password = #{password},phone = #{phone},address = #{address} where id = #{id};")
int update(Order order);
//
// 删除订单
// 根据订单ID删除订单。
//
// @param id 订单ID
// @return 影响的行数，成功返回1，失败返回0
//
@Delete("delete from orders where id = #{id};")
int delete(int id);
//
// 添加订单
// 将新的订单记录插入到数据库中。
//
// @param cart 购物车对象，包含商品名称、数量、价格和用户ID
// @return 影响的行数，成功返回1，失败返回0
//
@Insert("insert into orders(flower,amount,price,state,uid) " +
"values(#{flower},#{amount},#{price},0,#{uid});")
int add(Cart cart);
}

33
src/main/java/com/shanzhu/flower/dao/SpeciesDao.java
Unescape View File

@ -9,26 +9,51 @@ import org.springframework.stereotype.Repository;
import java.util.List;
//
// 鲜花种类数据访问对象接口，用于定义对鲜花种类表的数据库操作方法
//
@Repository
public interface SpeciesDao {
//
// 根据模糊查询关键词搜索鲜花种类
// 使用 LIKE 语句进行模糊匹配，查询数据库中名称包含指定关键词的鲜花种类记录
// @param searchKey 用于模糊查询的关键词，会拼接在 SQL 的 LIKE 语句中
// @return 符合查询条件的鲜花种类列表，若没有匹配记录则返回空列表
//
@Select("select * from species where species_name like concat('%',#{searchKey},'%');")
List<Species> find(String searchKey);
//
// 查询数据库中所有的鲜花种类记录
// @return 包含所有鲜花种类的列表，若表中没有记录则返回空列表
//
@Select("select * from species;")
List<Species> findAll();
//
// 更新鲜花种类的名称
// 根据传入的鲜花种类对象中的 ID，更新数据库中对应记录的种类名称
// @param species 包含要更新的鲜花种类信息的对象，其中包含 ID 和新的种类名称
// @return 受影响的行数，若成功更新则返回大于 0 的值，若未找到对应记录则返回 0
//
@Update("update species set species_name = #{species_name} where id = #{id};")
int update(Species species);
//
// 根据 ID 删除数据库中的鲜花种类记录
// @param id 要删除的鲜花种类的 ID
// @return 受影响的行数，若成功删除则返回 1，若未找到对应记录则返回 0
//
@Delete("delete from species where id = #{id};")
int delete(int id);
//
// 向数据库中插入新的鲜花种类记录
// @param species 包含要插入的鲜花种类名称的对象
// @return 受影响的行数，若成功插入则返回 1，若插入失败则返回 0
//
@Insert("insert into species(species_name) values(#{species_name});")
int add(Species species);
}

62
src/main/java/com/shanzhu/flower/dao/UserDao.java
Unescape View File

@ -12,33 +12,83 @@ import java.util.List;
@Repository
public interface UserDao {
@Select("select * from users where (account like concat('%',#{searchKey},'%') or name like concat('%',#{searchKey},'%')) and role = 'user';")
//
// 根据搜索关键词查询用户
// 查询用户表中账号或姓名包含指定搜索关键词的普通用户（角色为'user'）。
//
// @param searchKey 搜索关键词
// @return 用户列表
//
@Select("select * from users where (account like concat('%',#{searchKey},'%') or name like concat('%',#{searchKey},'%')) and role = 'user';")
List<User> find(String searchKey);
//
// 根据用户ID查询用户
// 查询指定ID的用户信息。
//
// @param id 用户ID
// @return 用户信息
//
@Select("select * from users where id = #{id};")
User queryById(Integer id);
//
// 查询所有用户
// 查询用户表中的所有用户信息。
//
// @return 用户列表
//
@Select("select * from users;")
List<User> findAll();
//
// 根据账号查询用户信息
// 查询指定账号的普通用户信息（角色为'user'）。
//
// @param account 用户账号
// @return 用户信息
//
@Select("select * from users where account = #{account} and role = 'user';")
User queryInfo(String account);
//
// 根据账号查询用户ID
// 查询指定账号的普通用户的ID。
//
// @param account 用户账号
// @return 用户ID
//
@Select("select id from users where account = #{account} and role = 'user';")
Integer queryIdByAccount(String account);
//
// 更新用户信息
// 更新用户的基本信息，包括姓名、密码、电话和地址。
//
// @param user 用户对象，包含需要更新的字段
// @return 影响的行数，成功返回1，失败返回0
//
@Update("update users set name = #{name},password = #{password},phone = #{phone},address = #{address} where id = #{id};")
int update(User user);
//
// 删除用户
// 根据用户ID删除用户记录。
//
// @param id 用户ID
// @return 影响的行数，成功返回1，失败返回0
//
@Delete("delete from users where id = #{id};")
int delete(int id);
//
// 添加用户
// 将新的用户记录插入到数据库中，用户角色默认为'user'。
//
// @param user 用户对象，包含账号、姓名、密码、电话和地址
// @return 影响的行数，成功返回1，失败返回0
//
@Insert("insert into users(account,name,password,phone,address,role) " +
"values(#{account},#{name},#{password},#{phone},#{address},'user');")
int add(User user);
}

30
src/main/java/com/shanzhu/flower/entity/Cart.java
Unescape View File

@ -7,13 +7,39 @@ import lombok.experimental.Accessors;
@Accessors(chain = true)
public class Cart {
//
// 购物车记录的唯一标识符。
// 用于在数据库中唯一标识每条购物车记录。
//
private int id;
//
// 商品的唯一标识符。
// 用于标识购物车中的具体商品。
//
private int fid;
//
// 商品名称。
// 用于存储购物车中商品的名称。
//
private String flower;
//
// 商品数量。
// 用于存储购物车中商品的数量。
//
private int amount;
//
// 商品总价。
// 用于存储购物车中商品的总价，计算方式为单价乘以数量。
//
private float price;
// 用户的唯一标识符。
// 用于标识购物车记录所属的用户。
private int uid;
// 用户账号。
// 用于存储购物车记录所属用户的账号信息。
private String account;
}

16
src/main/java/com/shanzhu/flower/entity/Flower.java
Unescape View File

@ -3,23 +3,23 @@ package com.shanzhu.flower.entity;
import lombok.Data;
import lombok.experimental.Accessors;
// 鲜花实体类，用于封装鲜花相关的信息
@Data
@Accessors(chain = true)
public class Flower {
// 鲜花的唯一标识 ID，数据库表中的主键，通常用于唯一确定一条鲜花记录
private int id;
// 鲜花的名称，用于描述鲜花的具体品种或类型
private String name;
// 分类名称
// 鲜花所属的种类名称，用于分类管理不同种类的鲜花
private String species_name;
// 鲜花的价格，记录该鲜花的售卖价格，以浮点数类型存储
private float price;
// 详细介绍
// 鲜花的详细描述信息，可包含鲜花的特征、产地、养护方法等内容
private String detail;
// 图片
// 鲜花图片的唯一标识符（GUID），用于关联存储在服务器上的鲜花图片资源
private String img_guid;
// 是否上架
// 鲜花的状态，通常 1 表示上架（可售卖），0 表示下架（不可售卖）
private int state;
}

3
src/main/java/com/shanzhu/flower/entity/LoginForm.java
Unescape View File

@ -6,7 +6,10 @@ import lombok.experimental.Accessors;
@Data
@Accessors(chain = true)
public class LoginForm {
// 计数
private String account;
// 密码
private String password;
// 角色
private String role;
}

39
src/main/java/com/shanzhu/flower/entity/Order.java
Unescape View File

@ -7,16 +7,45 @@ import lombok.experimental.Accessors;
@Accessors(chain = true)
public class Order {
//
// 订单的唯一标识符。
// 用于在数据库中唯一标识每条订单记录。
//
private int id;
//
// 订单的全局唯一标识符（GUID）。
// 用于在系统中唯一标识订单，便于跟踪和管理。
//
private String order_guid;
//
// 订单中的商品名称。
// 用于存储订单中商品的名称。
//
private String flower;
//
// 商品数量。
// 用于存储订单中商品的数量。
//
private int amount;
//
// 商品总价。
// 用于存储订单中商品的总价，计算方式为单价乘以数量。
//
private float price;
//
// 订单状态。
// 用于标识订单的当前状态，例如：0表示未发货，1表示已发货，2表示已完成等。
//
private float state;
// 用户 id
private int uid;
//
// 用户ID。
// 用于标识订单所属的用户。
//
private int uid; // 用户 id
}

4
src/main/java/com/shanzhu/flower/entity/OrderVo.java
Unescape View File

@ -6,9 +6,11 @@ import lombok.experimental.Accessors;
@Data
@Accessors(chain = true)
public class OrderVo extends Order{
//姓名
private String username;
// 电话
private String phone;
// 地址
private String address;
}

2
src/main/java/com/shanzhu/flower/entity/Param.java
Unescape View File

@ -6,6 +6,8 @@ import lombok.experimental.Accessors;
@Data
@Accessors(chain = true)
public class Param {
// 秘钥
private String searchKey;
// 张数
private int page;
}

2
src/main/java/com/shanzhu/flower/entity/Species.java
Unescape View File

@ -6,7 +6,9 @@ import lombok.experimental.Accessors;
@Data
@Accessors(chain = true)
public class Species {
// ID
private int id;
// 重命名
private String species_name;
}

37
src/main/java/com/shanzhu/flower/entity/User.java
Unescape View File

@ -6,14 +6,45 @@ import lombok.experimental.Accessors;
@Data
@Accessors(chain = true)
public class User {
//
// 用户的唯一标识符。
// 用于在数据库中唯一标识每个用户。
//
private int id;
//
// 用户账号。
// 用于用户登录和身份验证。
//
private String account;
//
// 用户姓名。
// 用于存储用户的真实姓名或昵称。
//
private String name;
//
// 用户密码。
// 用于用户登录验证，存储时应加密处理以保证安全。
//
private String password;
//
// 用户电话号码。
// 用于联系用户或验证用户身份。
//
private String phone;
//
// 用户地址。
// 用于存储用户的配送地址或其他联系地址。
//
private String address;
//
// 用户角色。
// 用于标识用户在系统中的权限级别，例如："admin" 表示管理员，"user" 表示普通用户。
//
private String role;
}

44
src/main/java/com/shanzhu/flower/service/CartService.java
Unescape View File

@ -1,20 +1,60 @@
package com.shanzhu.flower.service;
import com.shanzhu.flower.entity.Cart;
import java.util.List;
/**
* 购物车 服务
* 定义了购物车相关的业务逻辑接口，包括添加、删除、更新购物车项，以及查询购物车内容。
*
* @author: ShanZhu
* @date: 2024-01-24
*/
public interface CartService {
//
// 添加商品到购物车
// 如果商品已存在于购物车中，则增加该商品的数量；否则，将商品作为新的记录添加到购物车。
//
// @param cart 购物车对象，包含商品信息和用户账号
// @return 添加结果，成功返回1，失败返回0
//
int add(Cart cart);
//
// 删除购物车中的商品
// 根据用户ID删除购物车中的所有商品。
//
// @param uid 用户ID
// @return 删除结果，成功返回1，失败返回0
//
int delete(int uid);
//
// 更新购物车中的商品信息
// 更新购物车中指定商品的数量或其他信息。
//
// @param cart 购物车对象，包含需要更新的商品信息
// @return 更新结果，成功返回1，失败返回0
//
int update(Cart cart);
List<Cart> find(String searchKey,String account);
//
// 根据搜索关键词和用户账号查询购物车
// 查询购物车中商品名称包含指定搜索关键词的记录，并且属于指定用户账号。
//
// @param searchKey 搜索关键词
// @param account 用户账号
// @return 购物车记录列表
//
List<Cart> find(String searchKey, String account);
//
// 根据用户账号查询购物车
// 查询指定用户账号的购物车中的所有商品。
//
// @param account 用户账号
// @return 购物车记录列表
//
List<Cart> queryByAccount(String account);
}

60
src/main/java/com/shanzhu/flower/service/FlowersService.java
Unescape View File

@ -4,18 +4,62 @@ import com.shanzhu.flower.entity.Flower;
import java.util.List;
/**
* 鲜花商品 服务层
*
* @author: ShanZhu
* @date: 2024-01-24
*/
//
// * 鲜花商品 服务层接口，定义了与鲜花商品相关的业务操作方法，
// * 具体的实现由实现类来完成，用于处理鲜花商品的增删改查以及图片更新等业务逻辑。
// *
// * @author: ShanZhu
// * @date: 2024-01-24
//
public interface FlowersService {
//
// * 向系统中添加一个新的鲜花商品记录。
// *
// * @param flower 要添加的鲜花商品对象，包含了鲜花的详细信息，如名称、种类、价格等。
// * @return 成功添加时返回 1，添加失败返回 0（可以根据具体业务逻辑扩展返回值含义）。
//
int add(Flower flower);
//
// * 根据给定的鲜花商品 ID，从系统中删除对应的鲜花商品记录。
// *
// * @param id 要删除的鲜花商品的 ID。
// * @return 成功删除时返回 1，删除失败返回 0（可以根据具体业务逻辑扩展返回值含义）。
//
int delete(int id);
//
// * 更新系统中已有的鲜花商品记录信息。
// *
// * @param flower 包含更新后鲜花商品信息的对象，其中 ID 用于定位要更新的记录。
// * @return 成功更新时返回大于等于 0 的值，该值表示受影响的行数；更新失败返回 0。
//
int update(Flower flower);
List<Flower> find(String searchKey,String searchType);
//
// * 根据给定的搜索关键词和搜索类型，从系统中查询匹配的鲜花商品记录。
// *
// * @param searchKey 用于模糊查询的关键词，会根据该关键词搜索鲜花的名称或其他相关信息。
// * @param searchType 搜索的类型，例如可以是鲜花的种类等，用于更精确地筛选查询结果。
// * @return 包含所有符合查询条件的鲜花商品对象的列表，如果没有匹配的记录则返回空列表。
//
List<Flower> find(String searchKey, String searchType);
//
// * 根据给定的搜索关键词，从系统中查询所有匹配的鲜花商品记录（包括上架和下架的商品）。
// *
// * @param searchKey 用于模糊查询的关键词，会根据该关键词搜索鲜花的名称或其他相关信息。
// * @return 包含所有符合查询条件的鲜花商品对象的列表，如果没有匹配的记录则返回空列表。
//
List<Flower> findAll(String searchKey);
int updateImg(String img_guid,Integer id);
//
// * 根据给定的图片唯一标识符（GUID）和鲜花商品 ID，更新系统中对应鲜花商品的图片信息。
// *
// * @param img_guid 新的图片唯一标识符，用于关联新的图片资源。
// * @param id 要更新图片的鲜花商品的 ID。
// * @return 成功更新时返回 1，更新失败返回 0（可以根据具体业务逻辑扩展返回值含义）。
//
int updateImg(String img_guid, Integer id);
}

14
src/main/java/com/shanzhu/flower/service/OrderService.java
Unescape View File

@ -7,16 +7,30 @@ import java.util.List;
/**
* 订单 服务层
* 定义了订单相关的业务逻辑接口，包括添加订单、删除订单、更新订单状态，以及查询订单。
*
* @author: ShanZhu
* @date: 2024-01-24
*/
public interface OrderService {
//
// 添加订单
// 将购物车中的商品转换为订单并插入到数据库中。
// 如果购物车中的商品已存在订单中，则更新订单数量。
//
// @param cart 购物车对象，包含商品信息和用户账号
// @return 添加结果，成功返回1，失败返回0
//
int add(Cart cart);
int delete(int uid);
int update(Order order);
List<Order> find(String searchKey, String account);
List<Order> findAll(String searchKey);
List<Order> queryByAccount(String account);
}

37
src/main/java/com/shanzhu/flower/service/SpeciesService.java
Unescape View File

@ -4,11 +4,48 @@ import com.shanzhu.flower.entity.Species;
import java.util.List;
//
// * 鲜花种类服务层接口，定义了与鲜花种类相关的业务操作方法，
// * 具体的实现由对应的实现类来完成，用于处理鲜花种类的增删改查等业务逻辑。
//
public interface SpeciesService {
//
// * 向系统中添加一个新的鲜花种类记录。
// *
// * @param species 要添加的鲜花种类对象，包含了种类的名称等信息。
// * @return 成功添加时返回 1，添加失败返回 0（可根据实际业务逻辑扩展返回值含义）。
//
int add(Species species);
//
// * 根据给定的鲜花种类 ID，从系统中删除对应的鲜花种类记录。
// *
// * @param id 要删除的鲜花种类的 ID。
// * @return 成功删除时返回 1，删除失败返回 0（可根据实际业务逻辑扩展返回值含义）。
//
int delete(int id);
//
// * 更新系统中已有的鲜花种类记录信息。
// *
// * @param species 包含更新后鲜花种类信息的对象，其中 ID 用于定位要更新的记录。
// * @return 成功更新时返回大于等于 0 的值，该值表示受影响的行数；更新失败返回 0。
//
int update(Species species);
//
// * 根据给定的搜索关键词，从系统中查询匹配的鲜花种类记录。
// *
// * @param searchKey 用于模糊查询的关键词，会根据该关键词搜索种类名称中包含它的记录。
// * @return 包含所有符合查询条件的鲜花种类对象的列表，如果没有匹配的记录则返回空列表。
//
List<Species> find(String searchKey);
//
// * 从系统中查询所有的鲜花种类记录。
// *
// * @return 包含所有鲜花种类对象的列表，如果系统中没有记录则返回空列表。
//
List<Species> findAll();
}

41
src/main/java/com/shanzhu/flower/service/UserService.java
Unescape View File

@ -1,20 +1,59 @@
package com.shanzhu.flower.service;
import com.shanzhu.flower.entity.User;
import java.util.List;
/**
* 用户 服务层
* 定义了用户相关的业务逻辑接口，包括添加用户、删除用户、更新用户信息，以及查询用户。
*
* @author: ShanZhu
* @date: 2024-01-24
*/
public interface UserService {
//
// 添加用户
// 将新的用户记录插入到数据库中。
//
// @param user 用户对象，包含用户的基本信息（账号、姓名、密码等）
// @return 添加结果，成功返回1，失败返回0
//
int add(User user);
//
// 删除用户
// 根据用户ID删除用户记录。
//
// @param uid 用户ID
// @return 删除结果，成功返回1，失败返回0
//
int delete(int uid);
//
// 更新用户信息
// 更新用户的基本信息，如姓名、密码、电话和地址。
//
// @param user 用户对象，包含需要更新的用户信息
// @return 更新结果，成功返回1，失败返回0
//
int update(User user);
//
// 根据搜索关键词查询用户
// 查询用户表中账号或姓名包含指定搜索关键词的用户。
//
// @param searchKey 搜索关键词
// @return 用户列表
//
List<User> find(String searchKey);
//
// 根据账号查询用户信息
// 查询指定账号的用户详细信息。
//
// @param account 用户账号
// @return 用户信息，如果查询不到返回null
//
User queryInfo(String account);
}

26
src/main/java/com/shanzhu/flower/service/impl/CartServiceImpl.java
Unescape View File

@ -13,43 +13,51 @@ import java.util.List;
public class CartServiceImpl implements CartService {
@Resource
private CartDao cartDao;
private CartDao cartDao; // 注入购物车数据访问对象
@Resource
private UserDao userDao;
private UserDao userDao; // 注入用户数据访问对象
@Override
public int add(Cart cart) {
// 根据用户账号查询用户ID
int uid = userDao.queryIdByAccount(cart.getAccount());
cart.setUid(uid);
cart.setUid(uid); // 设置购物车记录的用户ID
// 检查该用户是否已将该商品添加到购物车
Cart cart1 = cartDao.checkIsAdded(cart);
if (cart1==null){
if (cart1 == null) {
// 如果未添加，直接插入新的购物车记录
return cartDao.add(cart);
}else {
} else {
// 如果已添加，增加该商品的数量
return cartDao.addAmount(cart);
}
}
@Override
public int delete(int uid) {
// 根据用户ID删除购物车记录
return cartDao.delete(uid);
}
@Override
public int update(Cart cart) {
// 更新购物车记录
return cartDao.update(cart);
}
@Override
public List<Cart> find(String searchKey,String account) {
return cartDao.find(searchKey,account);
public List<Cart> find(String searchKey, String account) {
// 根据搜索关键词和用户账号查询购物车记录
return cartDao.find(searchKey, account);
}
@Override
public List<Cart> queryByAccount(String account) {
// 根据用户账号查询用户ID
Integer uid = userDao.queryIdByAccount(account);
// 根据用户ID查询购物车记录
return cartDao.queryByUid(uid);
}
}

53
src/main/java/com/shanzhu/flower/service/impl/FlowersServiceImpl.java
Unescape View File

@ -8,39 +8,74 @@ import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
//
// * 鲜花业务逻辑实现类，处理鲜花相关的业务操作
//
@Service
public class FlowersServiceImpl implements FlowersService {
@Resource
private FlowersDao flowersDao;
private FlowersDao flowersDao; // 注入鲜花数据访问对象
//
// * 添加鲜花信息
// * @param flower 鲜花实体对象
// * @return 数据库操作影响的行数
//
@Override
public int add(Flower flower) {
return flowersDao.add(flower);
return flowersDao.add(flower); // 调用DAO层添加鲜花
}
//
// * 根据ID删除鲜花
// * @param id 鲜花ID
// * @return 数据库操作影响的行数
//
@Override
public int delete(int id) {
return flowersDao.delete(id);
return flowersDao.delete(id); // 调用DAO层删除鲜花
}
//
// * 更新鲜花信息
// * @param flower 包含更新信息的鲜花实体对象
// * @return 数据库操作影响的行数
//
@Override
public int update(Flower flower) {
return flowersDao.update(flower);
return flowersDao.update(flower); // 调用DAO层更新鲜花信息
}
//
// * 根据搜索条件查询鲜花列表（用户视角，仅包含上架商品）
// * @param searchKey 搜索关键词（名称）
// * @param searchType 搜索类型（种类）
// * @return 符合条件的鲜花列表
//
@Override
public List<Flower> find(String searchKey,String searchType) {
return flowersDao.find(searchKey,searchType);
public List<Flower> find(String searchKey, String searchType) {
return flowersDao.find(searchKey, searchType); // 调用DAO层查询鲜花列表
}
//
// * 管理员查询所有鲜花（包含下架商品）
// * @param searchKey 搜索关键词（名称）
// * @return 符合条件的鲜花列表
//
@Override
public List<Flower> findAll(String searchKey) {
return flowersDao.findAll(searchKey);
return flowersDao.findAll(searchKey); // 调用DAO层查询所有鲜花
}
//
// * 更新鲜花图片
// * @param img_guid 图片唯一标识
// * @param id 鲜花ID
// * @return 数据库操作影响的行数
//
@Override
public int updateImg(String img_guid,Integer id) {
return flowersDao.updateImg(img_guid,id);
public int updateImg(String img_guid, Integer id) {
return flowersDao.updateImg(img_guid, id); // 调用DAO层更新鲜花图片
}
}

24
src/main/java/com/shanzhu/flower/service/impl/OrderServiceImpl.java
Unescape View File

@ -14,42 +14,54 @@ import java.util.List;
public class OrderServiceImpl implements OrderService {
@Resource
private OrderDao orderdao;
private OrderDao orderdao; // 注入订单数据访问对象
@Resource
private UserDao userDao;
private UserDao userDao; // 注入用户数据访问对象
@Override
public int add(Cart cart) {
// 将购物车中的商品添加为订单
// 直接调用订单数据访问对象的add方法，将购物车对象转换为订单对象后插入数据库
return orderdao.add(cart);
}
@Override
public int delete(int uid) {
// 根据用户ID删除订单
// 调用订单数据访问对象的delete方法，删除指定用户ID的所有订单
return orderdao.delete(uid);
}
@Override
public int update(Order order) {
// 更新订单信息
// 调用订单数据访问对象的update方法，更新指定订单的详细信息
return orderdao.update(order);
}
@Override
public List<Order> find(String searchKey,String account) {
public List<Order> find(String searchKey, String account) {
// 根据搜索关键词和用户账号查询订单
// 首先根据用户账号查询用户ID
Integer uid = userDao.queryIdByAccount(account);
return orderdao.find(searchKey,uid);
// 然后根据搜索关键词和用户ID查询订单
return orderdao.find(searchKey, uid);
}
@Override
public List<Order> findAll(String searchKey) {
// 根据搜索关键词查询所有订单
// 调用订单数据访问对象的findAll方法，查询所有包含搜索关键词的订单
return orderdao.findAll(searchKey);
}
@Override
public List<Order> queryByAccount(String account) {
// 根据用户账号查询订单
// 首先根据用户账号查询用户ID
Integer uid = userDao.queryIdByAccount(account);
// 然后根据用户ID查询订单
return orderdao.queryByUid(uid);
}
}

45
src/main/java/com/shanzhu/flower/service/impl/SpeciesServiceImpl.java
Unescape View File

@ -8,34 +8,67 @@ import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
/**
* 鲜花种类业务逻辑实现类，实现了 SpeciesService 接口，
* 负责处理与鲜花种类相关的业务操作，通过调用 SpeciesDao 来访问数据库。
*/
@Service
public class SpeciesServiceImpl implements SpeciesService {
@Resource
private SpeciesDao speciesDao;
private SpeciesDao speciesDao; // 注入鲜花种类数据访问对象，用于操作数据库
//
// * 向数据库中添加一个新的鲜花种类记录。
// *
// * @param species 要添加的鲜花种类对象，包含种类名称等信息。
// * @return 执行数据库插入操作后受影响的行数，成功插入时返回 1，失败返回 0。
//
@Override
public int add(Species species) {
return speciesDao.add(species);
return speciesDao.add(species); // 调用 SpeciesDao 的 add 方法执行插入操作
}
//
// * 根据给定的鲜花种类 ID，从数据库中删除对应的鲜花种类记录。
// *
// * @param uid 要删除的鲜花种类的 ID。
// * @return 执行数据库删除操作后受影响的行数，成功删除时返回 1，失败返回 0。
//
@Override
public int delete(int uid) {
return speciesDao.delete(uid);
return speciesDao.delete(uid); // 调用 SpeciesDao 的 delete 方法执行删除操作
}
//
// * 更新数据库中指定鲜花种类的记录信息。
// *
// * @param species 包含更新后鲜花种类信息的对象，其中 ID 用于定位要更新的记录。
// * @return 执行数据库更新操作后受影响的行数，成功更新时返回大于 0 的值，未找到对应记录返回 0。
//
@Override
public int update(Species species) {
return speciesDao.update(species);
return speciesDao.update(species); // 调用 SpeciesDao 的 update 方法执行更新操作
}
//
// * 根据给定的搜索关键词，从数据库中查询匹配的鲜花种类记录。
// *
// * @param searchKey 用于模糊查询的关键词，会根据该关键词搜索种类名称中包含它的记录。
// * @return 包含所有符合查询条件的鲜花种类对象的列表，如果没有匹配的记录则返回空列表。
//
@Override
public List<Species> find(String searchKey) {
return speciesDao.find(searchKey);
return speciesDao.find(searchKey); // 调用 SpeciesDao 的 find 方法执行查询操作
}
//
// * 从数据库中查询所有的鲜花种类记录。
// *
// * @return 包含所有鲜花种类对象的列表，如果数据库中没有记录则返回空列表。
//
@Override
public List<Species> findAll() {
return speciesDao.findAll();
return speciesDao.findAll(); // 调用 SpeciesDao 的 findAll 方法执行查询操作
}
}

15
src/main/java/com/shanzhu/flower/service/impl/UserServiceImpl.java
Unescape View File

@ -12,34 +12,45 @@ import java.util.List;
public class UserServiceImpl implements UserService {
@Resource
private UserDao userdao;
private UserDao userdao; // 注入用户数据访问对象
@Override
public int add(User user) {
try {
// 尝试添加用户记录
// 调用用户数据访问对象的add方法，将用户对象插入数据库
return userdao.add(user);
}catch (Exception e){
} catch (Exception e) {
// 如果发生异常，返回0表示添加失败
return 0;
}
}
@Override
public int delete(int uid) {
// 根据用户ID删除用户记录
// 调用用户数据访问对象的delete方法，删除指定用户ID的用户记录
return userdao.delete(uid);
}
@Override
public int update(User user) {
// 更新用户信息
// 调用用户数据访问对象的update方法，更新指定用户的详细信息
return userdao.update(user);
}
@Override
public List<User> find(String searchKey) {
// 根据搜索关键词查询用户
// 调用用户数据访问对象的find方法，查询用户表中账号或姓名包含指定搜索关键词的用户
return userdao.find(searchKey);
}
@Override
public User queryInfo(String account) {
// 根据账号查询用户信息
// 调用用户数据访问对象的queryInfo方法，查询指定账号的用户信息
return userdao.queryInfo(account);
}
}

22
src/main/java/com/shanzhu/flower/util/VerifyUtil.java
Unescape View File

@ -1,19 +1,33 @@
package com.shanzhu.flower.util;
import com.shanzhu.flower.entity.LoginForm;
import tk.mybatis.mapper.util.StringUtil;
/**
* 验证工具类，提供表单验证相关的静态方法
*/
public class VerifyUtil {
/**
* 验证登录表单的有效性
* @param form 登录表单对象
* @return 验证通过返回true，否则返回false
*/
public static boolean verifyLoginForm(LoginForm form) {
if (form==null || StringUtil.isEmpty(form.getAccount())|| StringUtil.isEmpty(form.getPassword())|| StringUtil.isEmpty(form.getRole())) {
// 检查表单对象是否为空，或必填字段是否为空
if (form == null
|| StringUtil.isEmpty(form.getAccount())
|| StringUtil.isEmpty(form.getPassword())
|| StringUtil.isEmpty(form.getRole())) {
return false;
}
if (form.getRole().equals("user") || form.getRole().equals("admin")){
// 检查角色是否为允许的类型
if (form.getRole().equals("user") || form.getRole().equals("admin")) {
return true;
}
// 角色类型不合法
return false;
}
}

Write Preview
Loading…
Cancel
Save