src/main/java/com/shanzhu/flower/controller/FlowerController.java

@@ -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); // 直接调用DAO层修改商品状态
-        String msg = flower.getState() == 1 ? HttpMsg.GOODS_UP_OK : HttpMsg.GOODS_DOWN_OK; // 判断上下架状态
+        flowersDao.changeState(flower);
+        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); // 调用服务层更新图片GUID
+        int ans = flowerService.updateImg(guid, id);
         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,19 +187,14 @@ 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 {
@@ -212,48 +207,38 @@ 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);
     }
 
 }
+

src/main/java/com/shanzhu/flower/controller/FlowerTypeController.java

@@ -21,97 +21,68 @@ 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(); // 调用服务层查询所有鲜花种类
+        List<Species> all = speciesService.findAll();
         if (all.size()<=0){
-            return r.setCode(4000).setMsg(HttpMsg.NO_TYPE_NOW); // 返回无种类信息
+            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);
         }
     }
 
 }
+

src/main/java/com/shanzhu/flower/dao/FlowersDao.java

@@ -6,76 +6,36 @@ 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);
 
-//
-//      管理员查询所有鲜花（含未上架）
-//      @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);
 
-//
-//      修改鲜花状态（上架/下架）
-//     @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);
+
 }
+
+
+
+

src/main/java/com/shanzhu/flower/dao/SpeciesDao.java

@@ -9,51 +9,26 @@ 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);
 
 }
+
+
+
+

src/main/java/com/shanzhu/flower/entity/Flower.java

@@ -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;
 
 }
+
+
+

src/main/java/com/shanzhu/flower/entity/LoginForm.java

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

src/main/java/com/shanzhu/flower/entity/OrderVo.java

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

src/main/java/com/shanzhu/flower/entity/Param.java

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

src/main/java/com/shanzhu/flower/entity/Species.java

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

src/main/java/com/shanzhu/flower/service/FlowersService.java

@@ -4,62 +4,18 @@ 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);
-
-//
-//     * 根据给定的搜索关键词和搜索类型，从系统中查询匹配的鲜花商品记录。
-//     *
-//     * @param searchKey 用于模糊查询的关键词，会根据该关键词搜索鲜花的名称或其他相关信息。
-//     * @param searchType 搜索的类型，例如可以是鲜花的种类等，用于更精确地筛选查询结果。
-//     * @return 包含所有符合查询条件的鲜花商品对象的列表，如果没有匹配的记录则返回空列表。
-//
     List<Flower> find(String searchKey,String searchType);
-
-//
-//     * 根据给定的搜索关键词，从系统中查询所有匹配的鲜花商品记录（包括上架和下架的商品）。
-//     *
-//     * @param searchKey 用于模糊查询的关键词，会根据该关键词搜索鲜花的名称或其他相关信息。
-//     * @return 包含所有符合查询条件的鲜花商品对象的列表，如果没有匹配的记录则返回空列表。
-//
     List<Flower> findAll(String searchKey);
-
-//
-//     * 根据给定的图片唯一标识符（GUID）和鲜花商品 ID，更新系统中对应鲜花商品的图片信息。
-//     *
-//     * @param img_guid 新的图片唯一标识符，用于关联新的图片资源。
-//     * @param id 要更新图片的鲜花商品的 ID。
-//     * @return 成功更新时返回 1，更新失败返回 0（可以根据具体业务逻辑扩展返回值含义）。
-//
     int updateImg(String img_guid,Integer id);
 }

src/main/java/com/shanzhu/flower/service/OrderService.java

@@ -24,13 +24,49 @@ public interface OrderService {
 //
     int add(Cart cart);
 
+//
+//      删除订单
+//      根据用户ID删除所有订单。
+//
+//      @param uid 用户ID
+//      @return 删除结果，成功返回1，失败返回0
+//
     int delete(int uid);
 
+//
+//     更新订单
+//      更新订单的状态或其他信息。
+//
+//      @param order 订单对象，包含需要更新的订单信息
+//      @return 更新结果，成功返回1，失败返回0
+//
     int update(Order order);
 
+//
+//      根据搜索关键词和用户账号查询订单
+//      查询订单中商品名称包含指定搜索关键词的记录，并且属于指定用户账号。
+//
+//      @param searchKey 搜索关键词
+//      @param account   用户账号
+//      @return 订单记录列表
+//
     List<Order> find(String searchKey, String account);
 
+//
+//      根据搜索关键词查询所有订单
+//      查询所有订单中商品名称包含指定搜索关键词的记录。
+//
+//      @param searchKey 搜索关键词
+//      @return 订单记录列表
+//
     List<Order> findAll(String searchKey);
 
+//    /**
+//     根据用户账号查询订单
+//      查询指定用户账号的所有订单。
+//
+//      @param account 用户账号
+//      @return 订单记录列表
+//
     List<Order> queryByAccount(String account);
 }

src/main/java/com/shanzhu/flower/service/SpeciesService.java

@@ -4,48 +4,11 @@ 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();
 }

src/main/java/com/shanzhu/flower/service/impl/FlowersServiceImpl.java

@@ -8,74 +8,39 @@ 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); // 调用DAO层添加鲜花
+        return flowersDao.add(flower);
     }
 
-//
-//     * 根据ID删除鲜花
-//     * @param id 鲜花ID
-//     * @return 数据库操作影响的行数
-//
     @Override
     public int delete(int id) {
-        return flowersDao.delete(id); // 调用DAO层删除鲜花
+        return flowersDao.delete(id);
     }
 
-//
-//     * 更新鲜花信息
-//     * @param flower 包含更新信息的鲜花实体对象
-//     * @return 数据库操作影响的行数
-//
     @Override
     public int update(Flower flower) {
-        return flowersDao.update(flower); // 调用DAO层更新鲜花信息
+        return flowersDao.update(flower);
     }
 
-//
-//     * 根据搜索条件查询鲜花列表（用户视角，仅包含上架商品）
-//     * @param searchKey 搜索关键词（名称）
-//     * @param searchType 搜索类型（种类）
-//     * @return 符合条件的鲜花列表
-//
     @Override
     public List<Flower> find(String searchKey,String searchType) {
-        return flowersDao.find(searchKey, searchType); // 调用DAO层查询鲜花列表
+        return flowersDao.find(searchKey,searchType);
     }
 
-//
-//     * 管理员查询所有鲜花（包含下架商品）
-//     * @param searchKey 搜索关键词（名称）
-//     * @return 符合条件的鲜花列表
-//
     @Override
     public List<Flower> findAll(String searchKey) {
-        return flowersDao.findAll(searchKey); // 调用DAO层查询所有鲜花
+        return flowersDao.findAll(searchKey);
     }
 
-//
-//     * 更新鲜花图片
-//     * @param img_guid 图片唯一标识
-//     * @param id 鲜花ID
-//     * @return 数据库操作影响的行数
-//
     @Override
     public int updateImg(String img_guid,Integer id) {
-        return flowersDao.updateImg(img_guid, id); // 调用DAO层更新鲜花图片
+        return flowersDao.updateImg(img_guid,id);
     }
 }

src/main/java/com/shanzhu/flower/service/impl/SpeciesServiceImpl.java

@@ -8,67 +8,34 @@ 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); // 调用 SpeciesDao 的 add 方法执行插入操作
+        return speciesDao.add(species);
     }
 
-//
-//     * 根据给定的鲜花种类 ID，从数据库中删除对应的鲜花种类记录。
-//     *
-//     * @param uid 要删除的鲜花种类的 ID。
-//     * @return 执行数据库删除操作后受影响的行数，成功删除时返回 1，失败返回 0。
-//
     @Override
     public int delete(int uid) {
-        return speciesDao.delete(uid); // 调用 SpeciesDao 的 delete 方法执行删除操作
+        return speciesDao.delete(uid);
     }
 
-//
-//     * 更新数据库中指定鲜花种类的记录信息。
-//     *
-//     * @param species 包含更新后鲜花种类信息的对象，其中 ID 用于定位要更新的记录。
-//     * @return 执行数据库更新操作后受影响的行数，成功更新时返回大于 0 的值，未找到对应记录返回 0。
-//
     @Override
     public int update(Species species) {
-        return speciesDao.update(species); // 调用 SpeciesDao 的 update 方法执行更新操作
+        return speciesDao.update(species);
     }
 
-//
-//     * 根据给定的搜索关键词，从数据库中查询匹配的鲜花种类记录。
-//     *
-//     * @param searchKey 用于模糊查询的关键词，会根据该关键词搜索种类名称中包含它的记录。
-//     * @return 包含所有符合查询条件的鲜花种类对象的列表，如果没有匹配的记录则返回空列表。
-//
     @Override
     public List<Species> find(String searchKey) {
-        return speciesDao.find(searchKey); // 调用 SpeciesDao 的 find 方法执行查询操作
+        return speciesDao.find(searchKey);
     }
 
-//
-//     * 从数据库中查询所有的鲜花种类记录。
-//     *
-//     * @return 包含所有鲜花种类对象的列表，如果数据库中没有记录则返回空列表。
-//
     @Override
     public List<Species> findAll() {
-        return speciesDao.findAll(); // 调用 SpeciesDao 的 findAll 方法执行查询操作
+        return speciesDao.findAll();
     }
 }

src/main/java/com/shanzhu/flower/util/VerifyUtil.java

@@ -1,33 +1,19 @@
 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")){
             return true;
         }
-
-        // 角色类型不合法
         return false;
     }
+
 }