src/main/java/com/xmomen/module/receipt/controller/ReceivingCodeRequestController.java

@@ -19,12 +19,10 @@ import com.xmomen.module.receipt.mapper.ReceivingCodeRequestMapper;
 public class ReceivingCodeRequestController {
 	@Autowired
     MybatisDao mybatisDao;
-	
+
-    /**
+    /*
-     * 查询收货码请求
+    查询收货码请求
-     * @param id
+    */
-     * @return
-     */
     @RequestMapping(value = "/receivingCodeRequest", method = RequestMethod.GET)
     @Log(actionName = "查询收货码请求")
     public Page<TbReceivingCodeRequest> getExpressList(@RequestParam(value = "limit") Integer limit,
@@ -38,6 +36,7 @@ public class ReceivingCodeRequestController {
          map.put("keyword", keyword);
          map.put("requestTimeStart", requestTimeStart);
          map.put("requestTimeEnd", requestTimeEnd);
+        // 调用mybatisDao的selectPage方法，传入ReceivingCodeRequestMapperNameSpace + "getReceivingCodeRequestList"作为参数，map作为参数，limit和offset作为参数
         return (Page<TbReceivingCodeRequest>) mybatisDao.selectPage(ReceivingCodeRequestMapper.ReceivingCodeRequestMapperNameSpace + "getReceivingCodeRequestList", map, limit, offset);
     }
     

src/main/java/com/xmomen/module/receipt/controller/ReturnOrderController.java

@@ -22,9 +22,7 @@ import com.xmomen.module.receipt.model.ReturnOrderModel;
 import com.xmomen.module.receipt.model.ReturnOrderQuery;
 import com.xmomen.module.receipt.service.ReturnOrderService;
 
-/**
+
- * Created by Jeng on 2016/3/30.
- */
 @RestController
 public class ReturnOrderController {
 
@@ -34,13 +32,8 @@ public class ReturnOrderController {
     @Autowired
     MybatisDao mybatisDao;
 
-    /**
+
-     * 退货订单列表
+    // 查询退货订单列表
-     * @param limit
-     * @param offset
-     * @param keyword
-     * @return
-     */
     @RequestMapping(value = "/returnOrder", method = RequestMethod.GET)
     @Log(actionName = "查询退货订单列表")
     public Page<ReturnOrderModel> getUserList(@RequestParam(value = "limit") Integer limit,
@@ -50,29 +43,22 @@ public class ReturnOrderController {
                                   @RequestParam(value = "returnTimeStart",required = false) String returnTimeStart,
                                   @RequestParam(value = "returnTimeEnd",required = false) String returnTimeEnd
                                  ){
+        // 创建退货订单查询对象
         ReturnOrderQuery orderQuery = new ReturnOrderQuery();
         orderQuery.setKeyword(keyword);
+        // 如果退货时间开始不为空，则设置退货时间开始
         if(StringUtilsExt.isNotBlank(returnTimeStart)){
         	orderQuery.setReturnTimeStart(returnTimeStart);
         }
         
+        // 如果退货时间结束不为空，则设置退货时间结束
         if(StringUtilsExt.isNotBlank(returnTimeEnd)){
         	orderQuery.setReturnTimeEnd(returnTimeEnd);
         }
-        //客服经理过滤 如果有客服组权限则不过滤
+      }
-//        if(SecurityUtils.getSubject().hasRole(AppConstants.CUSTOMER_MANAGER_PERMISSION_CODE) && !SecurityUtils.getSubject().hasRole(AppConstants.CUSTOMER_PERMISSION_CODE)){
+        // 调用退货订单服务，获取退货订单列表
-//            Integer userId = (Integer) SecurityUtils.getSubject().getSession().getAttribute(AppConstants.SESSION_USER_ID_KEY);
-//            orderQuery.setCreateUserId(userId);
-//        }
         return returnOrderService.getReturnOrderList(orderQuery, limit, offset);
     }
-    /**
-     * 查询退货订单商品列表
-     * @param limit
-     * @param offset
-     * @param orderNo
-     * @return
-     */
     @RequestMapping(value = "/returnOrder/{id}/item", method = RequestMethod.GET)
     @Log(actionName = "查询退货订单商品列表")
     public Page<TbReturnOrderItem> getUserList(@RequestParam(value = "limit") Integer limit,
@@ -83,12 +69,7 @@ public class ReturnOrderController {
         return mybatisDao.selectPageByModel(returnOrderItem, limit, offset);
     }
 
-    /**
+
-     * 审核退货订单
-     * @param orderNo
-     * @param statusCd
-     * @return
-     */
     @RequestMapping(value = "/returnOrder/{id}/audit", method = RequestMethod.POST)
     @Log(actionName = "审核退货订单")
     public void auditReturnOrder(@PathVariable(value = "id") Integer id,
@@ -96,20 +77,16 @@ public class ReturnOrderController {
        this.returnOrderService.auditReturnOrder(id,statusCd);
     }
     
-    /**
+
-     * 退货收货扫描操作
+       // 调用退货订单服务，审核退货订单
-     * @param boxNo 箱号
-     */
     @RequestMapping(value ="/returnOrder/returnOrderShouhuo",method = RequestMethod.PUT)
     @Log(actionName = "退货收货扫描操作")
     public ReturnOrderModel returnOrderShouhuo(@RequestParam(value = "boxNo")String boxNo){
     	return this.returnOrderService.returnOrderShouhuo(boxNo);
     }
     
-    /**
+
-     * 退货收货操作
+    	// 调用退货订单服务，退货收货扫描操作
-     * @param boxNo 箱号
-     */
     @RequestMapping(value ="/returnOrder/shouhuo",method = RequestMethod.PUT)
     @Log(actionName = "退货收货操作")
     public void orderNo(@RequestParam(value = "orderNo")String orderNo){

src/main/java/com/xmomen/module/receipt/entity/TbReceivingCodeRequest.java

@@ -12,34 +12,27 @@ import javax.persistence.Version;
 @Entity
 @Table(name = "tb_receiving_code_request")
 public class TbReceivingCodeRequest extends BaseMybatisModel {
-    /**
+
-     * 主键
+    // 主键ID
-     */
     private Integer id;
 
-    /**
+    // 订单号
-     * 订单号
-     */
     private String orderNo;
 
-    /**
+
-     * 请求人
+    // 请求用户
-     */
     private String requestUser;
 
-    /**
+
-     * 请求时间
+    // 请求时间
-     */
     private Date requestTime;
 
-    /**
+
-     * 请求人手机号
+    // 请求电话
-     */
     private String requestPhone;
 
-    /**
+
-     * 请求人所属快递商
+    // 请求快递ID
-     */
     private Integer requestExpressId;
 
     @Column(name = "id")

src/main/java/com/xmomen/module/receipt/entity/TbReceivingCodeRequestExample.java

@@ -5,47 +5,60 @@ import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
+// 定义一个名为TbReceivingCodeRequestExample的类，继承自BaseMybatisExample
 public class TbReceivingCodeRequestExample extends BaseMybatisExample {
+    // 定义一个orderByClause变量，用于存储排序字段
     protected String orderByClause;
 
+    // 定义一个distinct变量，用于存储是否去重
     protected boolean distinct;
 
+    // 定义一个oredCriteria变量，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria
     public TbReceivingCodeRequestExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置orderByClause的值
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取orderByClause的值
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置distinct的值
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取distinct的值
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取oredCriteria的值
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加一个查询条件
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建一个查询条件
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建一个查询条件
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -54,37 +67,46 @@ public class TbReceivingCodeRequestExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建一个查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 定义一个内部类GeneratedCriteria，用于存储查询条件
     protected abstract static class GeneratedCriteria {
+        // 定义一个criteria变量，用于存储查询条件
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化criteria
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取查询条件
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加一个查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -92,6 +114,7 @@ public class TbReceivingCodeRequestExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加一个查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -99,6 +122,7 @@ public class TbReceivingCodeRequestExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加一个查询条件
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -106,366 +130,439 @@ public class TbReceivingCodeRequestExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 判断id是否为空
         public Criteria andIdIsNull() {
             addCriterion("id is null");
             return (Criteria) this;
         }
 
+        // 判断id是否不为空
         public Criteria andIdIsNotNull() {
             addCriterion("id is not null");
             return (Criteria) this;
         }
 
+        // 判断id是否等于某个值
         public Criteria andIdEqualTo(Integer value) {
             addCriterion("id =", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否不等于某个值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("id <>", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否大于某个值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("id >", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否大于等于某个值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("id >=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否小于某个值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("id <", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否小于等于某个值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("id <=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否在某个范围内
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("id in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否不在某个范围内
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("id not in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否在某个范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("id between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否不在某个范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("id not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否为空
         public Criteria andOrderNoIsNull() {
             addCriterion("order_no is null");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否不为空
         public Criteria andOrderNoIsNotNull() {
             addCriterion("order_no is not null");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否等于某个值
         public Criteria andOrderNoEqualTo(String value) {
             addCriterion("order_no =", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否不等于某个值
         public Criteria andOrderNoNotEqualTo(String value) {
             addCriterion("order_no <>", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否大于某个值
         public Criteria andOrderNoGreaterThan(String value) {
             addCriterion("order_no >", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否大于等于某个值
         public Criteria andOrderNoGreaterThanOrEqualTo(String value) {
             addCriterion("order_no >=", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否小于某个值
         public Criteria andOrderNoLessThan(String value) {
             addCriterion("order_no <", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否小于等于某个值
         public Criteria andOrderNoLessThanOrEqualTo(String value) {
             addCriterion("order_no <=", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否包含某个值
         public Criteria andOrderNoLike(String value) {
             addCriterion("order_no like", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否不包含某个值
         public Criteria andOrderNoNotLike(String value) {
             addCriterion("order_no not like", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否在某个范围内
         public Criteria andOrderNoIn(List<String> values) {
             addCriterion("order_no in", values, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否不在某个范围内
         public Criteria andOrderNoNotIn(List<String> values) {
             addCriterion("order_no not in", values, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否在某个范围内
         public Criteria andOrderNoBetween(String value1, String value2) {
             addCriterion("order_no between", value1, value2, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否不在某个范围内
         public Criteria andOrderNoNotBetween(String value1, String value2) {
             addCriterion("order_no not between", value1, value2, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否为空
         public Criteria andRequestUserIsNull() {
             addCriterion("request_user is null");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否不为空
         public Criteria andRequestUserIsNotNull() {
             addCriterion("request_user is not null");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否等于某个值
         public Criteria andRequestUserEqualTo(String value) {
             addCriterion("request_user =", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否不等于某个值
         public Criteria andRequestUserNotEqualTo(String value) {
             addCriterion("request_user <>", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否大于某个值
         public Criteria andRequestUserGreaterThan(String value) {
             addCriterion("request_user >", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否大于等于某个值
         public Criteria andRequestUserGreaterThanOrEqualTo(String value) {
             addCriterion("request_user >=", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否小于某个值
         public Criteria andRequestUserLessThan(String value) {
             addCriterion("request_user <", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否小于等于某个值
         public Criteria andRequestUserLessThanOrEqualTo(String value) {
             addCriterion("request_user <=", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否包含某个值
         public Criteria andRequestUserLike(String value) {
             addCriterion("request_user like", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否不包含某个值
         public Criteria andRequestUserNotLike(String value) {
             addCriterion("request_user not like", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否在某个范围内
         public Criteria andRequestUserIn(List<String> values) {
             addCriterion("request_user in", values, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否不在某个范围内
         public Criteria andRequestUserNotIn(List<String> values) {
             addCriterion("request_user not in", values, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否在某个范围内
         public Criteria andRequestUserBetween(String value1, String value2) {
             addCriterion("request_user between", value1, value2, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否不在某个范围内
         public Criteria andRequestUserNotBetween(String value1, String value2) {
             addCriterion("request_user not between", value1, value2, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否为空
         public Criteria andRequestTimeIsNull() {
             addCriterion("request_time is null");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否不为空
         public Criteria andRequestTimeIsNotNull() {
             addCriterion("request_time is not null");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否等于某个值
         public Criteria andRequestTimeEqualTo(Date value) {
             addCriterion("request_time =", value, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否不等于某个值
         public Criteria andRequestTimeNotEqualTo(Date value) {
             addCriterion("request_time <>", value, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否大于某个值
         public Criteria andRequestTimeGreaterThan(Date value) {
             addCriterion("request_time >", value, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否大于等于某个值
         public Criteria andRequestTimeGreaterThanOrEqualTo(Date value) {
             addCriterion("request_time >=", value, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否小于某个值
         public Criteria andRequestTimeLessThan(Date value) {
             addCriterion("request_time <", value, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否小于等于某个值
         public Criteria andRequestTimeLessThanOrEqualTo(Date value) {
             addCriterion("request_time <=", value, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否在某个范围内
         public Criteria andRequestTimeIn(List<Date> values) {
             addCriterion("request_time in", values, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否不在某个范围内
         public Criteria andRequestTimeNotIn(List<Date> values) {
             addCriterion("request_time not in", values, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否在某个范围内
         public Criteria andRequestTimeBetween(Date value1, Date value2) {
             addCriterion("request_time between", value1, value2, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否不在某个范围内
         public Criteria andRequestTimeNotBetween(Date value1, Date value2) {
             addCriterion("request_time not between", value1, value2, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否为空
         public Criteria andRequestPhoneIsNull() {
             addCriterion("request_phone is null");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否不为空
         public Criteria andRequestPhoneIsNotNull() {
             addCriterion("request_phone is not null");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否等于某个值
         public Criteria andRequestPhoneEqualTo(String value) {
             addCriterion("request_phone =", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否不等于某个值
         public Criteria andRequestPhoneNotEqualTo(String value) {
             addCriterion("request_phone <>", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否大于某个值
         public Criteria andRequestPhoneGreaterThan(String value) {
             addCriterion("request_phone >", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否大于等于某个值
         public Criteria andRequestPhoneGreaterThanOrEqualTo(String value) {
             addCriterion("request_phone >=", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否小于某个值
         public Criteria andRequestPhoneLessThan(String value) {
             addCriterion("request_phone <", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否小于等于某个值
         public Criteria andRequestPhoneLessThanOrEqualTo(String value) {
             addCriterion("request_phone <=", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否包含某个值
         public Criteria andRequestPhoneLike(String value) {
             addCriterion("request_phone like", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否不包含某个值
         public Criteria andRequestPhoneNotLike(String value) {
             addCriterion("request_phone not like", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否在某个范围内
         public Criteria andRequestPhoneIn(List<String> values) {
             addCriterion("request_phone in", values, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否不在某个范围内
         public Criteria andRequestPhoneNotIn(List<String> values) {
             addCriterion("request_phone not in", values, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否在某个范围内
         public Criteria andRequestPhoneBetween(String value1, String value2) {
             addCriterion("request_phone between", value1, value2, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否不在某个范围内
         public Criteria andRequestPhoneNotBetween(String value1, String value2) {
             addCriterion("request_phone not between", value1, value2, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否为空
         public Criteria andRequestExpressIdIsNull() {
             addCriterion("request_express_id is null");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否不为空
         public Criteria andRequestExpressIdIsNotNull() {
             addCriterion("request_express_id is not null");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否等于某个值
         public Criteria andRequestExpressIdEqualTo(Integer value) {
             addCriterion("request_express_id =", value, "requestExpressId");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否不等于某个值
         public Criteria andRequestExpressIdNotEqualTo(Integer value) {
             addCriterion("request_express_id <>", value, "requestExpressId");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否大于某个值
         public Criteria andRequestExpressIdGreaterThan(Integer value) {
             addCriterion("request_express_id >", value, "requestExpressId");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否大于等于某个值
         public Criteria andRequestExpressIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("request_express_id >=", value, "requestExpressId");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否小于某个值
         public Criteria andRequestExpressIdLessThan(Integer value) {
             addCriterion("request_express_id <", value, "requestExpressId");
             return (Criteria) this;

src/main/java/com/xmomen/module/receipt/entity/mapper/TbReceivingCodeRequestMapper.java

@@ -5,12 +5,17 @@ import com.xmomen.module.receipt.entity.TbReceivingCodeRequest;
 import com.xmomen.module.receipt.entity.TbReceivingCodeRequestExample;
 import org.apache.ibatis.annotations.Param;
 
+// TbReceivingCodeRequestMapper接口，继承MybatisMapper
 public interface TbReceivingCodeRequestMapper extends MybatisMapper {
+    // 根据example统计TbReceivingCodeRequest的数量
     int countByExample(TbReceivingCodeRequestExample example);
 
+    // 根据example删除TbReceivingCodeRequest
     int deleteByExample(TbReceivingCodeRequestExample example);
 
+    // 插入TbReceivingCodeRequest
     int insertSelective(TbReceivingCodeRequest record);
 
+    // 根据example更新TbReceivingCodeRequest
     int updateByExampleSelective(@Param("record") TbReceivingCodeRequest record, @Param("example") TbReceivingCodeRequestExample example);
 }

src/main/java/com/xmomen/module/receipt/mapper/ReceivingCodeRequestMapper.java

@@ -1,6 +1,8 @@
 package com.xmomen.module.receipt.mapper;
 
+// 定义一个接口ReceivingCodeRequestMapper
 public interface ReceivingCodeRequestMapper {
+    // 定义一个常量ReceivingCodeRequestMapperNameSpace，值为"com.xmomen.module.receipt.mapper.ReceivingCodeRequestMapper."
     public static final String ReceivingCodeRequestMapperNameSpace = "com.xmomen.module.receipt.mapper.ReceivingCodeRequestMapper.";
 
 }

src/main/java/com/xmomen/module/receipt/mapper/ReceivingCodeRequestMapper.xml

@@ -14,13 +14,16 @@
        left join tb_order_ref receiving_code on receiving_code.order_no = main.order_no and receiving_code.ref_type = 'SHOU_HUO_NO'
        left join tb_order tborder on tborder.order_no = main.order_no
 		<where>
+              <!-- 根据关键字查询 -->
               <if test="keyword">
                   AND main.request_phone LIKE CONCAT('%', #{keyword}, '%')
                    or main.request_user LIKE CONCAT('%', #{keyword}, '%')
               </if>
+              <!-- 根据订单号查询 -->
               <if test="orderNo">
                   AND main.order_no LIKE CONCAT('%', #{orderNo}, '%')
               </if>
+               <!-- 根据请求时间查询 -->
                <if test="requestTimeStart">
                 <![CDATA[
                   AND DATE_FORMAT(main.request_time ,'%Y-%m-%d')>= #{requestTimeStart}

src/main/java/com/xmomen/module/receipt/mapper/ReturnOrderMapper.java

@@ -1,9 +1,9 @@
 package com.xmomen.module.receipt.mapper;
 
-/**
+
- * Created by Jeng on 16/4/13.
+// 定义一个接口，用于操作退货订单
- */
 public interface ReturnOrderMapper {
 
+    // 定义一个常量，用于命名空间
     public static final String RETURN_ORDER_MAPPER_NAMESPACE = "com.xmomen.module.receipt.mapper.ReturnOrderMapper.";
 }

src/main/java/com/xmomen/module/receipt/mapper/ReturnOrderMapper.xml

@@ -1,8 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
 <mapper namespace="com.xmomen.module.receipt.mapper.ReturnOrderMapper" >
-
+    <!-- 查询退货单列表 -->
-    <!--    查询订单    -->
     <select id="getReturnOrderList" resultType="com.xmomen.module.receipt.model.ReturnOrderModel" parameterType="com.xmomen.module.receipt.model.ReturnOrderQuery">
         select 
 	       	main.return_time,

src/main/java/com/xmomen/module/receipt/model/ReceivingCodeRequestModel.java

@@ -6,43 +6,32 @@ import lombok.Data;
 
 
 public @Data class ReceivingCodeRequestModel {
-	/**
+
-     * 主键
+    // 主键ID
-     */
     private Integer id;
 
-    /**
+
-     * 订单号
+    // 订单号
-     */
     private String orderNo;
 
-    /**
+
-     * 请求人
+    // 请求用户
-     */
     private String requestUser;
 
-    /**
+    // 请求时间
-     * 请求时间
-     */
     private Date requestTime;
 
-    /**
+    // 请求电话
-     * 请求人手机号
-     */
     private String requestPhone;
-    
+
-    /**
+    // 快递公司名称
-     * 快递商名称
-     */
     private String expressName;
     
-    /**
+
-     * 收货码
+    // 收货码
-     */
     private String receivingCode;
     
-    /**
+
-     * 收货人
+    // 收货人姓名
-     */
     private String consigneeName;
 }

src/main/java/com/xmomen/module/receipt/model/ReturnItemModel.java

@@ -4,9 +4,13 @@ import java.io.Serializable;
 
 import lombok.Data;
 
+// 返回项模型类
 public @Data class ReturnItemModel  implements Serializable {
 
+        // 项目代码
         private String itemCode;
+        // 项目数量
         private Integer itemNumber;
+        // 项目名称
         private String itemName;
 }

src/main/java/com/xmomen/module/receipt/model/ReturnOrderModel.java

@@ -15,173 +15,130 @@ import com.xmomen.module.order.model.PackingModel;
  */
 public @Data class ReturnOrderModel implements Serializable {
 
-	/**
+
-     * 订单ID
+    // 返回订单ID
-     */
     private Integer id;
     
-    /**
+
-     * 退货订单id
+    // 订单ID
-     */
     private Integer returnOrderId;
 
-    /**
+
-     * 订单类型
+    // 订单类型
-     */
     private Integer orderType;
 
-    /**
+
-     * 订单类型描述
+    // 订单类型描述
-     */
     private String orderTypeDesc;
 
-    /**
+
-     * 订单来源：1-微信订单，2-商城订单，3-客服下单，4-采摘订单
+    // 订单来源
-     */
     private Integer orderSource;
 
-    /**
+
-     * 订单来源描述
+    // 订单来源描述
-     */
     private String orderSourceDesc;
 
-    /**
+    // 支付方式
-     * 付款方式
-     */
     private Integer paymentMode;
 
-    /**
+
-     * 付款方式描述
+    // 支付方式描述
-     */
     private String paymentModeDesc;
 
-    /**
+
-     * 订单编码
+    // 订单号
-     */
     private String orderNo;
 
-    /**
+
-     * 订单状态
+    // 订单状态
-     */
     private String orderStatus;
 
-    /**
+
-     * 装箱任务负责人名称
+    // 包装任务用户名
-     */
     private String packingTaskUsername;
-    /**
+
-     * 装箱任务负责人ID
+    // 包装任务用户ID
-     */
     private Integer packingTaskUserId;
 
-    /**
+
-     * 订单装箱任务状态
+    // 包装任务状态
-     */
     private Integer packingTaskStatus;
-    /**
+
-     * 装箱任务状态描述
+    // 包装任务状态描述
-     */
     private String packingTaskStatusDesc;
 
-    /**
+    // 包装任务创建时间
-     * 装箱任务分配时间
-     */
     private Date packingTaskCreateTime;
 
-    /**
+
-     * 装箱任务开始时间
+    // 包装任务开始时间
-     */
     private Date packingTaskStartTime;
 
-    /**
+
-     * 装箱任务完成时间
+    // 包装任务结束时间
-     */
     private Date packingTaskEndTime;
 
-    /**
+
-     * 订单状态描述
+    // 订单状态描述
-     */
     private String orderStatusDesc;
 
-    /**
+
-     * 收货人手机
+    // 收货人电话
-     */
     private String consigneePhone;
 
-    /**
+
-     * 收货人姓名
+    // 收货人姓名
-     */
     private String consigneeName;
 
-    /**
+
-     * 收货人地址
+    // 收货人地址
-     */
     private String consigneeAddress;
 
-    /**
+
-     * 运送方式 1-快递，2-自提
+    // 运输方式
-     */
     private Integer transportMode;
 
-    /**
+
-     * 订单备注
+    // 备注
-     */
     private String remark;
 
-    /**
+
-     * 折扣价
+    // 折扣价格
-     */
     private BigDecimal discountPrice;
 
-    /**
+
-     * 订单总金额
+    // 总金额
-     */
     private BigDecimal totalAmount;
 
-    /**
+    // 创建时间
-     * 订单创建时间
-     */
     private Date createTime;
 
-    /**
+    // 创建用户的ID
-     * 订单创建人ID
-     */
     private Integer createUserId;
 
+    // 用户创建者
     private String createUser;
 
-    /**
+
-     * 配送时间
-     */
     private Date appointmentTime;
 
-    /**
+
-     * 支付卡（券）号
-     */
     private String couponNumber;
 
-    /**
+
-     * 快递商
-     */
     private String expressName;
 
     private Integer despatchExpressId;
 
-    /**
+
-     * 项目经理
-     */
     private String managerName;
-    /**
+
-     * 单位
-     */
     private String companyName;
 
 
     private String batchNo;
 
-    /**
-     * 付款方式
-     */
     private Integer otherPaymentMode;
     
     private String otherPaymentModeDesc;
@@ -190,44 +147,44 @@ public @Data class ReturnOrderModel implements Serializable {
     
     private String receivingCode;
     
+    // 订单项列表
     private List<TbReturnOrderItem> itemList;
     
+    // 返回时间
     private Date returnTime;
     
+    // 返回状态
     private String returnStatus;
     
+    // 返回状态描述
     private String returnStatusDesc;
     
-    /**
+
-     * 审核状态（0-不同意，1-同意）
+    // 审核状态
-     */
     private Integer auditStatus;
 
-    /**
+
-     * 审核时间
+    // 审核日期
-     */
     private Date auditDate;
 
-    /**
+
-     * 审核人
+    // 审核用户ID
-     */
     private Integer auditUserId;
     
+    // 审核用户名
     private String auditUserName;
 
-    /**
+
-     * 拿货时间
+    // 商品取货日期
-     */
     private Date takeGoodsDate;
 
-    /**
+
-     * 拿货人
+    // 用户取货ID
-     */
     private Integer takeGoodsUserId;
 
+    // 商品领取人姓名
     private String takeGoodsUserName;
-    /**
+
-     * 拿货人手机号
+    // 顾客取货电话
-     */
     private String takeGoodsPhone;
 }

src/main/java/com/xmomen/module/receipt/model/ReturnOrderQuery.java

@@ -5,21 +5,32 @@ import lombok.Data;
 import java.io.Serializable;
 import java.util.Date;
 
-/**
+
- */
 public @Data
 class ReturnOrderQuery implements Serializable {
+    // 返回订单ID
     private Integer id;
+    // 订单号
     private String orderNo;
+    // 返回时间开始
     private String returnTimeStart;
+    // 返回时间结束
     private String returnTimeEnd;
+    // 关键字
     private String keyword;
+    // 返回状态
     private String returnStatus;
     
+    // 管理员ID
     private String managerId;
+    // 收货人姓名
     private String consigneeName;
+    // 是否无显示取消
     private int hasNoShowCancel;
+    // 是否显示发货
     private int showDespatch;
+    // 创建用户ID
     private int createUserId;
+    // 发货快递ID
     private int despatchExpressId;
 }

src/main/java/com/xmomen/module/receipt/service/ReturnOrderService.java

@@ -1,352 +1,364 @@
 package com.xmomen.module.receipt.service;
-
+// 声明该Java类所在的包路径，com.xmomen.module.receipt.service表示该类位于名为service的包中，
+// 这个包是com.xmomen.module.receipt包的子包
 import java.math.BigDecimal;
+// 导入用于精确的十进制运算的类
 import java.util.Date;
+// 导入表示日期和时间的类
 import java.util.HashMap;
+// 导入一种键值对存储的数据结构类
 import java.util.List;
+// 导入用于表示有序的元素集合的接口
 import java.util.Map;
+// 导入用于表示键值对的映射关系的接口
 
 import com.xmomen.framework.exception.BusinessException;
+// 导入自定义的业务异常类
 import com.xmomen.module.base.entity.CdItem;
+// 导入基础模块中的商品实体类
 import com.xmomen.module.order.entity.*;
+// 导入订单模块的所有实体类
 import com.xmomen.module.stock.service.StockService;
+// 导入库存服务类
 import org.apache.shiro.SecurityUtils;
+// 导入Apache Shiro框架中用于处理安全相关操作的工具类
 import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架用于自动装配依赖的注解
 import org.springframework.stereotype.Service;
+// 导入Spring框架用于标记服务类的注解
 import org.springframework.transaction.annotation.Transactional;
+// 导入Spring框架用于声明事务的注解
 
 import com.xmomen.framework.mybatis.dao.MybatisDao;
+// 导入自定义的MyBatis数据访问对象类
 import com.xmomen.framework.mybatis.page.Page;
+// 导入用于分页操作的类
 import com.xmomen.framework.utils.AssertExt;
+// 导入自定义的断言工具类
 import com.xmomen.framework.utils.StringUtilsExt;
+// 导入自定义的字符串工具类
 import com.xmomen.module.base.constant.AppConstants;
+// 导入应用程序的常量类
 import com.xmomen.module.base.entity.CdExpress;
+// 导入基础模块中的快递实体类
 import com.xmomen.module.base.service.ItemService;
+// 导入商品服务类
 import com.xmomen.module.order.mapper.OrderMapper;
+// 导入订单模块的Mapper接口
 import com.xmomen.module.order.model.ReturnOrder;
+// 导入订单模块的退货订单模型类
 import com.xmomen.module.receipt.mapper.ReturnOrderMapper;
+// 导入退货订单模块的Mapper接口
 import com.xmomen.module.receipt.model.ReturnOrderModel;
+// 导入退货订单模块的模型类
 import com.xmomen.module.receipt.model.ReturnOrderQuery;
+// 导入退货订单模块的查询条件类
 import com.xmomen.module.wx.model.AjaxResult;
+// 导入微信模块的Ajax结果模型类
 
-/**
- * Created by Jeng on 16/4/5.
- */
 @Service
+// 使用@Service注解将ReturnOrderService类标记为一个Spring服务类
 public class ReturnOrderService {
 
     @Autowired
+    // 使用@Autowired注解自动装配MybatisDao类型的对象
     MybatisDao mybatisDao;
 
     @Autowired
+    // 使用@Autowired注解自动装配ItemService类型的对象
     ItemService itemService;
 
     @Autowired
+    // 使用@Autowired注解自动装配StockService类型的对象
     StockService stockService;
 
-    /**
+    // 获取退货订单列表
-     * 查询订单
-     *
-     * @param orderQuery
-     * @param limit
-     * @param offset
-     * @return
-     */
     public Page<ReturnOrderModel> getReturnOrderList(
             ReturnOrderQuery orderQuery, Integer limit, Integer offset) {
+        // 该方法用于获取退货订单列表并进行分页，接受查询条件对象orderQuery以及分页参数limit和offset
         return (Page<ReturnOrderModel>) mybatisDao.selectPage(
                 ReturnOrderMapper.RETURN_ORDER_MAPPER_NAMESPACE
                         + "getReturnOrderList", orderQuery, limit, offset);
+        // 调用mybatisDao的selectPage方法，通过ReturnOrderMapper的命名空间和方法名执行查询，返回分页结果
     }
 
-    /**
+    // 获取退货订单列表
-     * 查询订单
-     *
-     * @param orderQuery
-     * @return
-     */
     public List<ReturnOrderModel> getReturnOrderList(ReturnOrderQuery orderQuery) {
+        // 这是一个重载的方法，用于获取退货订单列表（不进行分页），接受查询条件对象orderQuery
         return mybatisDao.getSqlSessionTemplate().selectList(
                 ReturnOrderMapper.RETURN_ORDER_MAPPER_NAMESPACE
                         + "getReturnOrderList", orderQuery);
+        // 调用mybatisDao的getSqlSessionTemplate方法获取SqlSessionTemplate，
+        // 然后通过ReturnOrderMapper的命名空间和方法名执行查询，返回结果列表
     }
 
-    /**
+    // 拒绝收货
-     * 订单拒绝收货
-     *
-     * @param orderNo
-     * @param phone
-     * @return
-     */
     @Transactional
+    // 使用@Transactional注解声明该方法在一个事务中执行
     public AjaxResult noShouhuo(String orderNo, String phone, int expressId) {
+        // 该方法用于处理拒绝收货的业务逻辑，接受订单号orderNo、联系电话phone和快递员ID expressId，返回AjaxResult对象
         AjaxResult ajaxResult = new AjaxResult();
+        // 创建一个新的AjaxResult对象，用于封装返回给前端的结果信息
+
         // 判断订单状态
         TbReturnOrderExample tbOrderExample = new TbReturnOrderExample();
+        // 创建一个TbReturnOrderExample对象用于构建查询条件
         tbOrderExample.createCriteria().andOrderNoEqualTo(orderNo);
+        // 添加订单号等于orderNo的条件
         TbReturnOrder tbReturnOrder = mybatisDao
                 .selectOneByExample(tbOrderExample);
+        // 调用mybatisDao的selectOneByExample方法查询符合条件的单个TbReturnOrder对象，以判断订单状态
+
         if (tbReturnOrder != null) {
             ajaxResult.setMessage("订单不能拒绝，请联系客服人员。");
+            // 如果订单已存在某种状态，设置ajaxResult的消息
             ajaxResult.setResult(0);
+            // 设置ajaxResult的结果码为0
             return ajaxResult;
+            // 返回ajaxResult对象
         }
         tbReturnOrder = new TbReturnOrder();
+        // 创建一个新的TbReturnOrder对象
         tbReturnOrder.setOrderNo(orderNo);
+        // 设置订单号
         // 退货运输中
         tbReturnOrder.setReturnStatus(14);
+        // 设置退货状态为“退货运输中”（状态码14）
         tbReturnOrder.setTakeGoodsDate(mybatisDao.getSysdate());
+        // 设置取货日期为系统当前日期
         tbReturnOrder.setTakeGoodsPhone(phone);
+        // 设置取货联系电话
         tbReturnOrder.setTakeGoodsUserId(expressId);
+        // 设置取货的快递员用户ID
         tbReturnOrder.setReturnTime(mybatisDao.getSysdate());
+        // 设置退货时间为系统当前日期
         tbReturnOrder = mybatisDao.insertByModel(tbReturnOrder);
+        // 调用mybatisDao的insertByModel方法插入新的退货订单记录，并返回插入后的对象
+
         TbOrderItem orderItemDb = new TbOrderItem();
+        // 创建一个TbOrderItem对象
         orderItemDb.setOrderNo(orderNo);
+        // 设置订单号
         List<TbOrderItem> returnOrderItems = mybatisDao
                 .selectByModel(orderItemDb);
+        // 调用mybatisDao的selectByModel方法查询该订单下的所有订单商品项
+
         BigDecimal returnTotalAmount = BigDecimal.ZERO;
+        // 创建一个BigDecimal对象用于记录退货总金额，并初始化为0
+
         for (TbOrderItem orderItem : returnOrderItems) {
+            // 遍历订单商品项列表
             TbReturnOrderItem returnOrderItem = new TbReturnOrderItem();
+            // 创建一个新的TbReturnOrderItem对象
             returnOrderItem.setItemCode(orderItem.getItemCode());
+            // 设置商品编码
             returnOrderItem.setReturnOrderId(tbReturnOrder.getId());
+            // 设置退货订单ID
             returnOrderItem.setItemNumber(orderItem.getItemQty().intValue());
+            // 设置商品数量
             returnOrderItem.setItemName(orderItem.getItemName());
+            // 设置商品名称
             returnOrderItem.setIsNeed(1);
+            // 设置是否需要（这里值为1表示需要）
             mybatisDao.insert(returnOrderItem);
+            // 插入退货订单商品项记录
+
             //金额相加
             returnTotalAmount = returnTotalAmount.add(orderItem.getItemPrice().multiply(orderItem.getItemQty()));
+            // 将当前商品项的金额（单价乘以数量）累加到退货总金额中
         }
         //退款金额
         tbReturnOrder.setReturnTotalAmount(returnTotalAmount);
+        // 设置退货订单的退款总金额
+
         // 更新原订单状态
         TbOrderExample orderExample = new TbOrderExample();
+        // 创建一个TbOrderExample对象用于构建查询条件
         orderExample.createCriteria().andOrderNoEqualTo(orderNo);
+        // 添加订单号等于orderNo的条件
         TbOrder order = new TbOrder();
+        // 创建一个新的TbOrder对象
         //是拒绝收货
         order.setIsReject(1);
+        // 设置订单为拒绝收货状态（值为1表示拒绝）
         // 退货运输中
         order.setOrderStatus("14");
+        // 设置订单状态为“退货运输中”（状态码14）
         mybatisDao.updateOneByExampleSelective(order, orderExample);
+        // 调用mybatisDao的updateOneByExampleSelective方法更新原订单的状态
+
         ajaxResult.setMessage("订单已拒收，请及时送回仓库。");
+        // 设置ajaxResult的消息
         ajaxResult.setResult(1);
+        // 设置ajaxResult的结果码为1
         return ajaxResult;
+        // 返回ajaxResult对象
     }
 
-    /**
-     * 订单退货
-     *
-     * @param orderNo
-     * @param itemIds
-     * @return
-     */
     @Transactional
+    // 使用@Transactional注解声明该方法在一个事务中执行
     public AjaxResult returnOrder(String orderNo, String itemIds) {
+        // 该方法用于处理退货申请的业务逻辑，接受订单号orderNo和商品ID字符串itemIds，返回AjaxResult对象
         AjaxResult ajaxResult = new AjaxResult();
+        // 创建一个新的AjaxResult对象，用于封装返回给前端的结果信息
+
         // 判断订单状态
         TbReturnOrderExample tbOrderExample = new TbReturnOrderExample();
+        // 创建一个TbReturnOrderExample对象用于构建查询条件
         tbOrderExample.createCriteria().andOrderNoEqualTo(orderNo);
+        // 添加订单号等于orderNo的条件
         TbReturnOrder tbReturnOrder = mybatisDao
                 .selectOneByExample(tbOrderExample);
+        // 调用mybatisDao的selectOneByExample方法查询符合条件的单个TbReturnOrder对象，以判断订单状态
+
         if (tbReturnOrder != null) {
             ajaxResult.setMessage("订单不能退货，请联系客服人员。");
+            // 如果订单已存在某种状态，设置ajaxResult的消息
             ajaxResult.setResult(0);
+            // 设置ajaxResult的结果码为0
             return ajaxResult;
+            // 返回ajaxResult对象
         }
         tbReturnOrder = new TbReturnOrder();
+        // 创建一个新的TbReturnOrder对象
         tbReturnOrder.setOrderNo(orderNo);
+        // 设置订单号
         tbReturnOrder.setReturnStatus(10);// 申请退货
+        // 设置退货状态为“申请退货”（状态码10）
         tbReturnOrder.setReturnTime(mybatisDao.getSysdate());
+        // 设置退货时间为系统当前日期
         tbReturnOrder = mybatisDao.insertByModel(tbReturnOrder);
+        // 调用mybatisDao的insertByModel方法插入新的退货订单记录，并返回插入后的对象
+
         BigDecimal returnTotalAmount = BigDecimal.ZERO;
+        // 创建一个BigDecimal对象用于记录退货总金额，并初始化为0
+
         for (String itemId : itemIds.split(",")) {
+            // 遍历商品ID字符串，以逗号分割
             if (StringUtilsExt.isEmpty(itemId)) {
                 continue;
+                // 如果商品ID为空，跳过本次循环
             }
             TbReturnOrderItem returnOrderItem = new TbReturnOrderItem();
+            // 创建一个新的TbReturnOrderItem对象
             TbOrderItem orderItem = this.mybatisDao.selectByPrimaryKey(
                     TbOrderItem.class, Integer.parseInt(itemId));
+            // 根据商品ID查询对应的订单商品项
+
             returnOrderItem.setItemCode(orderItem.getItemCode());
+            // 设置商品编码
             returnOrderItem.setReturnOrderId(tbReturnOrder.getId());
+            // 设置退货订单ID
             returnOrderItem.setItemNumber(orderItem.getItemQty().intValue());
+            // 设置商品数量
             returnOrderItem.setItemName(orderItem.getItemName());
+            // 设置商品名称
             returnOrderItem.setIsNeed(1);
+            // 设置是否需要（这里值为1表示需要）
             mybatisDao.insert(returnOrderItem);
+            // 插入退货订单商品项记录
+
             //金额相加
             returnTotalAmount = returnTotalAmount.add(orderItem.getItemPrice().multiply(orderItem.getItemQty()));
+            // 将当前商品项的金额（单价乘以数量）累加到退货总金额中
         }
         //退款金额
         tbReturnOrder.setReturnTotalAmount(returnTotalAmount);
+        // 设置退货订单的退款总金额
+
         mybatisDao.update(tbReturnOrder);
+        // 调用mybatisDao的update方法更新退货订单记录
+
         // 更新原订单状态
         TbOrderExample orderExample = new TbOrderExample();
+        // 创建一个TbOrderExample对象用于构建查询条件
         orderExample.createCriteria().andOrderNoEqualTo(orderNo);
+        // 添加订单号等于orderNo的条件
         TbOrder order = new TbOrder();
+        // 创建一个新的TbOrder对象
         order.setOrderStatus("10");// 申请退货
+        // 设置订单状态为“申请退货”（状态码10）
         mybatisDao.updateOneByExampleSelective(order, orderExample);
+        // 调用mybatisDao的updateOneByExampleSelective方法更新原订单的状态
+
         ajaxResult.setMessage("退货申请提交成功，请等待客服审核。");
+        // 设置ajaxResult的消息
         ajaxResult.setResult(1);
+        // 设置ajaxResult的结果码为1
         return ajaxResult;
+        // 返回ajaxResult对象
     }
 
-    /**
-     * 退货订单收货
-     *
-     * @param orderNo
-     * @param phone
-     * @param expressId
-     * @return
-     */
     @Transactional
+    // 使用@Transactional注解声明该方法在一个事务中执行
     public AjaxResult shouhuoReturn(String orderNo, String phone, int expressId) {
+        // 该方法用于处理退货收货的业务逻辑，接受订单号orderNo、联系电话phone和快递员ID expressId，返回AjaxResult对象
         AjaxResult ajaxResult = new AjaxResult();
+        // 创建一个新的AjaxResult对象，用于封装返回给前端的结果信息
+
         // 判断订单状态
         TbReturnOrderExample tbOrderExample = new TbReturnOrderExample();
+        // 创建一个TbReturnOrderExample对象用于构建查询条件
         tbOrderExample.createCriteria().andOrderNoEqualTo(orderNo);
+        // 添加订单号等于orderNo的条件
         TbReturnOrder tbReturnOrder = mybatisDao
                 .selectOneByExample(tbOrderExample);
+        // 调用mybatisDao的selectOneByExample方法查询符合条件的单个TbReturnOrder对象，以判断订单状态
+
         if (tbReturnOrder.getReturnStatus() != 11) {
             ajaxResult.setMessage("订单状态不为退货中，不能收货，请联系客服人员。");
+            // 如果订单的退货状态不是“退货中”（状态码11），设置ajaxResult的消息
             ajaxResult.setResult(0);
+            // 设置ajaxResult的结果码为0
             return ajaxResult;
+            // 返回ajaxResult对象
         }
         tbReturnOrder.setReturnStatus(14);// 退货运输中
+        // 设置退货订单的状态为“退货运输中”（状态码14）
         tbReturnOrder.setTakeGoodsDate(mybatisDao.getSysdate());
+        // 设置取货日期为系统当前日期
         tbReturnOrder.setTakeGoodsPhone(phone);
+        // 设置取货联系电话
         tbReturnOrder.setTakeGoodsUserId(expressId);
+        // 设置取货的快递员用户ID
         mybatisDao.update(tbReturnOrder);
+        // 调用mybatisDao的update方法更新退货订单记录
+
         // 更新原订单状态
         TbOrderExample orderExample = new TbOrderExample();
+        // 创建一个TbOrderExample对象用于构建查询条件
         orderExample.createCriteria().andOrderNoEqualTo(orderNo);
+        // 添加订单号等于orderNo的条件
         TbOrder order = new TbOrder();
+        // 创建一个新的TbOrder对象
         order.setOrderStatus("14");// 退货运输中
+        // 设置订单状态为“退货运输中”（状态码14）
         mybatisDao.updateOneByExampleSelective(order, orderExample);
+        // 调用mybatisDao的updateOneByExampleSelective方法更新原订单的状态
+
         ajaxResult.setMessage("退货订单收货成功，请尽快送回仓库。");
+        // 设置ajaxResult的消息
         ajaxResult.setResult(0);
+        // 设置ajaxResult的结果码为0
         return ajaxResult;
+        // 返回ajaxResult对象
     }
 
-    /**
-     * 退货订单审核
-     *
-     * @param id
-     * @param statusCd
-     */
     @Transactional
+    // 使用@Transactional注解声明该方法在一个事务中执行
     public void auditReturnOrder(int id, int statusCd) {
+        // 该方法用于审核退货订单，接受退货订单ID id和审核状态码statusCd
         TbReturnOrder returnOrder = this.mybatisDao.selectByPrimaryKey(
                 TbReturnOrder.class, id);
+        // 根据退货订单ID查询对应的TbReturnOrder对象
+
         returnOrder.setAuditStatus(statusCd);
+        // 设置审核状态
         returnOrder.setAuditDate(mybatisDao.getSysdate());
+        // 设置审核日期为系统当前日期
+
         if (statusCd == 1) {
+            // 如果审核状态码为1（表示通过审核）
             // 退货中
             returnOrder.setReturnStatus(11);
-            Integer userId = (Integer) SecurityUtils.getSubject().getSession()
+            // 设置退货订单的状态为“退货中”（状态码1
-                    .getAttribute(AppConstants.SESSION_USER_ID_KEY);
-            returnOrder.setAuditUserId(userId);
-            this.mybatisDao.save(returnOrder);
-            // 更新原订单状态
-            TbOrderExample orderExample = new TbOrderExample();
-            orderExample.createCriteria().andOrderNoEqualTo(
-                    returnOrder.getOrderNo());
-            TbOrder order = new TbOrder();
-            // 退货中
-            order.setOrderStatus("11");
-            mybatisDao.updateOneByExampleSelective(order, orderExample);
-        }
-        else {
-            // 拒绝退货
-            returnOrder.setReturnStatus(16);
-            Integer userId = (Integer) SecurityUtils.getSubject().getSession()
-                    .getAttribute(AppConstants.SESSION_USER_ID_KEY);
-            returnOrder.setAuditUserId(userId);
-            this.mybatisDao.save(returnOrder);
-            // 更新原订单状态
-            TbOrderExample orderExample = new TbOrderExample();
-            orderExample.createCriteria().andOrderNoEqualTo(
-                    returnOrder.getOrderNo());
-            TbOrder order = new TbOrder();
-            // 拒绝退货
-            order.setOrderStatus("16");
-            mybatisDao.updateOneByExampleSelective(order, orderExample);
-        }
-    }
-
-    /**
-     * 退货收货操作
-     *
-     * @param boxNo 箱号
-     */
-    @Transactional
-    public ReturnOrderModel returnOrderShouhuo(String boxNo) {
-        // 通过箱号查找订单号
-        TbOrderRelation tbOrderRelation = new TbOrderRelation();
-        tbOrderRelation.setRefType(OrderMapper.ORDER_PACKING_RELATION_CODE);
-        tbOrderRelation.setRefValue(boxNo);
-        tbOrderRelation = mybatisDao.selectOneByModel(tbOrderRelation);
-        AssertExt.notNull(tbOrderRelation, "扫描的箱号不存在！请确认。");
-        TbOrder order = new TbOrder();
-        order.setOrderNo(tbOrderRelation.getOrderNo());
-        order = mybatisDao.selectOneByModel(order);
-        AssertExt.notNull(order, "订单不存在！");
-        String orderStatus = order.getOrderStatus();
-        AssertExt.isTrue(orderStatus.equals("14"), "订单状态不是退货运输中，不能收货！");
-
-        TbReturnOrder returnOrder = new TbReturnOrder();
-        returnOrder.setOrderNo(order.getOrderNo());
-        returnOrder = mybatisDao.selectOneByModel(returnOrder);
-
-        ReturnOrderModel returnOrderModel = new ReturnOrderModel();
-        TbReturnOrderItem returnOrderItem = new TbReturnOrderItem();
-        returnOrderItem.setReturnOrderId(returnOrder.getId());
-        List<TbReturnOrderItem> returnOrderItemList = this.mybatisDao
-                .selectByModel(returnOrderItem);
-        returnOrderModel.setItemList(returnOrderItemList);
-        returnOrderModel.setOrderNo(order.getOrderNo());
-        return returnOrderModel;
-    }
-
-    /**
-     * 退货收货操作
-     *
-     * @param orderNo 箱号
-     */
-    @Transactional
-    public void shouhuo(String orderNo) throws BusinessException {
-        TbOrder order = new TbOrder();
-        order.setOrderNo(orderNo);
-        order = mybatisDao.selectOneByModel(order);
-        AssertExt.notNull(order, "订单不存在！");
-        String orderStatus = order.getOrderStatus();
-        AssertExt.isTrue(orderStatus.equals("14"), "订单状态不是退货运输中，不能收货！");
-
-        order.setOrderStatus("15");
-        mybatisDao.update(order);
-
-
-        TbReturnOrder returnOrder = new TbReturnOrder();
-        returnOrder.setOrderNo(order.getOrderNo());
-        returnOrder = mybatisDao.selectOneByModel(returnOrder);
-        returnOrder.setReturnStatus(15);
-        mybatisDao.update(returnOrder);
-
-        //查询订单的退货商品信息
-        TbReturnOrderItemExample tbReturnOrderItemExample = new TbReturnOrderItemExample();
-        tbReturnOrderItemExample.createCriteria().andReturnOrderIdEqualTo(returnOrder.getId());
-        List<TbReturnOrderItem> tbReturnOrderItems = mybatisDao.selectByExample(tbReturnOrderItemExample);
-        for (TbReturnOrderItem tbReturnOrderItem : tbReturnOrderItems) {
-            //需要的退回库存
-            if (tbReturnOrderItem.getIsNeed() == 1) {
-                CdItem cdItem = new CdItem();
-                cdItem.setItemCode(tbReturnOrderItem.getItemCode());
-                cdItem = mybatisDao.selectOneByModel(cdItem);
-                stockService.changeStockNum(cdItem.getId(), tbReturnOrderItem.getItemNumber().intValue(), returnOrder.getId(), "订单退货退回商品", 3);
-            }
-        }
-
-        // 卡类订单进行退款
-        if (order.getOrderType() == 1) {
-
-        }
-    }
-
-}

src/main/java/com/xmomen/module/report/model/ExpressReport.java

@@ -17,22 +17,44 @@ public
 @Data
 class ExpressReport implements Serializable {
 
+    // 物流公司
+    // 物流公司
     @Excel(name = "物流公司")
+    // 订单号
     private String expressName;
+    // 订单号
+    // 总箱数
     @Excel(name = "订单号", width = 20)
     private String orderNo;
+    // 出库时间
+    // 总箱数
     @Excel(name = "总箱数")
+    // 收货时间
     private int totalBoxNum;
+    // 出库时间
+    // 二次配送
     @Excel(name = "出库时间", width = 20, exportFormat = "yyyy-MM-dd HH:mm:ss")
+    // 收货时间
+    // 正常配送
     private Date outDate;
     @Excel(name = "收货时间", width = 20, exportFormat = "yyyy-MM-dd HH:mm:ss")
+    // 异常配送
+    // 二次配送
+    // 正常配送
+    // 物流代收款
     private Date shouHuoDate;
     @Excel(name = "二次配送", type = 10)
+    // 损失承担
+    // 异常配送
     private int isTwoSend;
+    // 物流代收款
+    // 是否拒收
     @Excel(name = "正常配送", type = 10)
+    // 损失承担
     private int isNormal;
     @Excel(name = "异常配送", type = 10)
     private int isNoNormal;
+    // 是否拒收
     @Excel(name = "物流代收款", width = 15, type = 10)
     private double expressAmount;
     @Excel(name = "损失承担", type = 10)

src/main/java/com/xmomen/module/report/model/FinanceReport.java

@@ -11,53 +11,57 @@ import java.io.Serializable;
 public
 @Data
 class FinanceReport implements Serializable {
+    //公司ID
     private int cdCompanyId;
+    //客户经理
     @Excel(name = "客户经理")
     private String managerName;
+    //单位/个人
     @Excel(name = "单位/个人")
     private String companyName;
+    //用户ID
     private int cdUserId;
-    //总张数
+    //总张数（预付款）
     @Excel(name = "总张数（预付款）", type = 10)
     private int beforeCouponCount;
-    //总金额
+    //总金额（预付款）
     @Excel(name = "总金额（预付款）", type = 10)
     private double beforeTotalValue;
-    //充值金额
+    //充值金额（预付款）
     @Excel(name = "充值金额（预付款）", type = 10)
     private double beforeTotalRechargeValue;
-    //已付
+    //已付（预付款）
     @Excel(name = "已付（预付款）", type = 10)
     private double beforeTotalYesValue;
-    // 未付
+    // 未付（预付款）
     @Excel(name = "未付（预付款）", type = 10)
     private double beforeTotalNoValue;
-    // 余额
+    // 余额（预付款）
     @Excel(name = "余额（预付款）", type = 10)
     private double beforeUserTotalValue;
-    // 回馈总金额
+    // 回馈总金额（预付款）
     @Excel(name = "回馈总金额（预付款）", type = 10)
     private double beforeGiftTotalValue;
-    // 回馈剩余金额
+    // 回馈剩余金额（预付款）
     @Excel(name = "回馈剩余金额（预付款）", type = 10)
     private double beforeGiftUserTotalValue;
 
-    // 总张数
+    // 总张数（后付款）
     @Excel(name = "总张数（后付款）", type = 10)
     private int afterCouponCount;
-    // 总金额
+    // 总金额（后付款）
     @Excel(name = "总金额（后付款）", type = 10)
     private double afterTotalValue;
-    // 充值金额
+    // 充值金额（后付款）
     @Excel(name = "充值金额（后付款）", type = 10)
     private double afterTotalRechargeValue;
-    // 已付
+    // 已付（后付款）
     @Excel(name = "已付（后付款）", type = 10)
     private double afterTotalYesValue;
-    // 未付
+    // 未付（后付款）
     @Excel(name = "未付（后付款）", type = 10)
     private double afterTotalNoValue;
-    // 余额
+    // 余额（后付款）
     @Excel(name = "余额（后付款）", type = 10)
     private double afterUserTotalValue;
     // 回馈总金额（后付款）
@@ -78,12 +82,16 @@ class FinanceReport implements Serializable {
     //回馈总金额
     @Excel(name = "回馈总金额", type = 10)
     private double giftOrderTotal;
+    //客户经理代收
     @Excel(name = "客户经理代收", type = 10)
     private double managerAmount;
+    //POS
     @Excel(name = "POS", type = 10)
     private double posAmount;
+    //转账
     @Excel(name = "转账", type = 10)
     private double zhuanAmount;
+    //物流代收
     @Excel(name = "物流代收", type = 10)
     private double expressAmount;
 }

src/main/java/com/xmomen/module/report/model/OrderDeliveryReport.java

@@ -16,33 +16,49 @@ import java.util.Date;
 public @Data
 class OrderDeliveryReport implements Serializable {
 
+    // 下单日期
     @Excel(name = "下单日期" , exportFormat="yyyy-MM-dd", importFormat = "yyyy-MM-dd")
     private Date createTime;
+    // 订单号
     @Excel(name = "订单号",width = 20)
     private String orderNo;
+    // 快递商
     @Excel(name="快递商")
     private String expressName;
+    // 收货人姓名
     @Excel(name = "收货人姓名",width = 15)
     private String consigneeName;
+    // 收货人电话
     @Excel(name = "收货人电话",width = 15)
     private String consigneePhone;
+    // 收货人地址
     @Excel(name = "收货人地址",width = 30)
     private String consigneeAddress;
+    // 金额
     @Excel(name = "金额")
     private double totalAmount;
+    // 付款方式
     @Excel(name = "付款方式")
     private String paymentModeDesc;
+    // 付款金额
     @Excel(name = "付款金额",type = 10)
     private double payAmount;
+    // 附加付款方式
     @Excel(name = "附加付款方式")
     private String otherPaymentModeDesc;
+    // 附加付款金额
     @Excel(name = "附加付款金额",type = 10)
     private double otherPayAmount;
+    // 送货日期
     @Excel(name = "送货日期" , exportFormat="yyyy-MM-dd", importFormat = "yyyy-MM-dd")
     private Date appointmentTime;
+    // 备注
     @Excel(name = "备注",width = 30)
     private String remark;
+    // 订单状态描述
     private String orderStatusDesc;
+    // 总箱数
     private int totalBoxNum;
+    // 快递扫描箱数
     private int expressScanBoxNum;
 }

src/main/java/com/xmomen/module/report/model/OrderReport.java

@@ -17,45 +17,67 @@ public
 @Data
 class OrderReport implements Serializable {
 
+    // 支付方式
     private String paymentMode;
+    // 支付金额
     private double payAmount;
+    // 其他支付方式
     private String otherPaymentMode;
+    // 其他支付金额
     private double otherPayAmount;
 
+    // 订单类型
     @Excel(name = "订单类型")
     private String orderType;
+    // 订单号
     @Excel(name = "订单号", width = 20)
     private String orderNo;
+    // 客户姓名
     @Excel(name = "客户姓名")
     private String consigneeName;
+    // 电话
     @Excel(name = "电话", width = 15)
     private String consigneePhone;
+    // 单位/个人
     @Excel(name = "单位/个人")
     private String companyName;
+    // 客户经理
     @Excel(name = "客户经理")
     private String managerName;
+    // 物流公司
     @Excel(name = "物流公司")
     private String expressName;
+    // 总金额
     @Excel(name = "总金额")
     private double totalAmount;
+    // 折扣金额
     @Excel(name = "折扣金额")
     private double discountPrice;
+    // 客户经理代收
     @Excel(name = "客户经理代收", width = 15, type = 10)
     private double managerAmount;
+    // 物流代收
     @Excel(name = "物流代收", type = 10)
     private double expressAmount;
+    // 卡类扣款
     @Excel(name = "卡类扣款", type = 10)
     private double couponAmount;
+    // 券类扣款
     @Excel(name = "券类扣款", type = 10)
     private double quanAmount;
+    // 刷POS
     @Excel(name = "刷POS", type = 10)
     private double posAmount;
+    // 转账
     @Excel(name = "转账", type = 10)
     private double zhuanZhanAmount;
+    // 其它
     @Excel(name = "其它", type = 10)
     private double otherAmount;
+    // 回馈
     @Excel(name = "回馈", type = 10)
     private double huiKuiAmount;
+    // 退货金额
     @Excel(name = "退货金额", type = 10)
     private double returnTotalAmount;
 }

src/main/java/com/xmomen/module/report/model/ReportQuery.java

@@ -5,11 +5,16 @@ import lombok.Data;
 import java.io.Serializable;
 
 /**
+ * 报表查询模型
  */
 public @Data
 class ReportQuery implements Serializable {
+    // 开始时间
     private String beginTime;
+    // 结束时间
     private String endTime;
+    // 管理员ID
     private Integer managerId;
+    // 公司ID
     private Integer companyId;
 }

src/main/java/com/xmomen/module/report/model/StockDailyReport.java

@@ -5,14 +5,14 @@ import org.jeecgframework.poi.excel.annotation.Excel;
 
 import java.io.Serializable;
 
-/**
+
- * 库存快照报表实体类
- */
 public
 @Data
 class StockDailyReport implements Serializable {
+    // 商品名称
     @Excel(name = "商品名称")
     private String itemName;
+    // 商品编码
     @Excel(name = "商品编码")
     private String itemCode;
     /**

src/main/java/com/xmomen/module/report/service/ReportOrderService.java

@@ -41,9 +41,13 @@ public class ReportOrderService {
      * @return
      */
     public List<OrderReport> getOrderReportList(ReportQuery reportQuery) {
+        //查询订单报表
         List<OrderReport> orderReportList = mybatisDao.getSqlSessionTemplate().selectList(ReportOrderMapper.REPORT_ORDER_MAPPER_NAMESPACE + "getReportOrderList", reportQuery);
+        //遍历订单报表
         for (OrderReport orderReport : orderReportList) {
+            //判断付款方式
             if ("0".equals(orderReport.getPaymentMode())) {
+                //如果是汇款
                 orderReport.setHuiKuiAmount(orderReport.getPayAmount());
             }
             if ("1".equals(orderReport.getPaymentMode())) {

src/main/java/com/xmomen/module/resource/api/DfsException.java

@@ -1,38 +1,66 @@
 package com.xmomen.module.resource.api;
 
+/**
+ * DfsException 类继承自 RuntimeException，用于表示在分布式文件系统（DFS）操作过程中出现的异常。
+ */
 public class DfsException extends RuntimeException {
 
+    // 序列化版本号，用于确保在反序列化时类的版本一致性
     private static final long serialVersionUID = 1497374765949093902L;
 
     /**
-     * IOException 100 
+     * 异常代码，用于标识不同类型的异常。
-     * FileNotFoundException 200 
+     * 异常代码的具体含义如下：
-     * Exception from DFS (example: from FastDFS, MyException) 300 
+     * - IOException 对应代码 100
-     * OtherException 400
+     * - FileNotFoundException 对应代码 200
+     * - 来自 DFS 的异常（例如 FastDFS 抛出的异常、自定义异常 MyException）对应代码 300
+     * - 其他异常对应代码 400
      */
     private String code;
 
+    // 异常的详细描述信息
     private String message;
 
+    /**
+     * 构造函数，用于创建一个 DfsException 实例。
+     * @param code 异常代码，用于标识异常类型
+     * @param message 异常的详细描述信息
+     */
     public DfsException(String code, String message) {
         this.code = code;
         this.message = message;
     }
 
+    /**
+     * 获取异常代码。
+     * @return 异常代码
+     */
     public String getCode() {
         return code;
     }
 
+    /**
+     * 设置异常代码。
+     * @param code 要设置的异常代码
+     */
     public void setCode(String code) {
         this.code = code;
     }
 
+    /**
+     * 获取异常的详细描述信息。
+     * @return 异常的详细描述信息
+     */
     public String getMessage() {
         return message;
     }
 
+    /**
+     * 设置异常的详细描述信息。
+     * @param message 要设置的异常详细描述信息
+     */
     public void setMessage(String message) {
         this.message = message;
     }
 
-}
+}

src/main/java/com/xmomen/module/resource/api/DfsFile.java

@@ -2,32 +2,45 @@ package com.xmomen.module.resource.api;
 
 import java.util.Map;
 
+/**
+ * DfsFile 类代表一个分布式文件系统（DFS）中的文件。
+ * 该类封装了文件的数据、唯一标识以及元数据信息。
+ */
 public class DfsFile {
 
     /**
-     * file data
+     * 存储文件的二进制数据。
+     * 它包含了文件的实际内容，以字节数组的形式存在。
      */
     private byte[] data;
 
     /**
-     * key,not used in FastDfs
+     * 文件的唯一标识。
+     * 在 FastDFS 这种分布式文件系统中，此属性暂不使用。
      */
     private String key;
 
     /**
-     * metadata for file
+     * 文件的元数据信息。
+     * 以键值对的形式存储与文件相关的额外信息，
+     * 例如文件的创建时间、作者、文件类型等。
      */
     private Map<String, String> metadata;
 
+    /**
+     * 默认构造函数。
+     * 用于创建一个空的 DfsFile 对象，各属性初始值为 null。
+     */
     public DfsFile() {
 
     }
+
     /**
-     * constructor with data, key and metadata
+     * 带参数的构造函数，用于创建一个具有指定属性的 DfsFile 对象。
      *
-     * @param key key,not used in FastDfs
+     * @param key 文件的唯一标识，在 FastDFS 中暂不使用。
-     * @param data file data
+     * @param data 文件的二进制数据。
-     * @param metadata metadata for file
+     * @param metadata 文件的元数据信息，以键值对形式存储。
      */
     public DfsFile(String key, byte[] data, Map<String, String> metadata) {
         this.key = key;
@@ -35,28 +48,58 @@ public class DfsFile {
         this.metadata = metadata;
     }
 
+    /**
+     * 获取文件的二进制数据。
+     *
+     * @return 文件的二进制数据，以字节数组形式返回。
+     */
     public byte[] getData() {
         return data;
     }
 
+    /**
+     * 设置文件的二进制数据。
+     *
+     * @param data 要设置的文件二进制数据。
+     */
     public void setData(byte[] data) {
         this.data = data;
     }
 
+    /**
+     * 获取文件的唯一标识。
+     *
+     * @return 文件的唯一标识。
+     */
     public String getKey() {
         return key;
     }
 
+    /**
+     * 设置文件的唯一标识。
+     *
+     * @param key 要设置的文件唯一标识。
+     */
     public void setKey(String key) {
         this.key = key;
     }
 
+    /**
+     * 获取文件的元数据信息。
+     *
+     * @return 文件的元数据信息，以键值对形式返回。
+     */
     public Map<String, String> getMetadata() {
         return metadata;
     }
 
+    /**
+     * 设置文件的元数据信息。
+     *
+     * @param metadata 要设置的文件元数据信息，以键值对形式传入。
+     */
     public void setMetadata(Map<String, String> metadata) {
         this.metadata = metadata;
     }
 
-}
+}

src/main/java/com/xmomen/module/resource/api/DfsPath.java

@@ -1,45 +1,74 @@
 package com.xmomen.module.resource.api;
 
+/**
+ * DfsPath 类用于表示分布式文件系统（DFS）中文件的路径信息。
+ * 它包含了文件的 HTTP 访问路径和存储服务器上的远程路径。
+ */
 public class DfsPath {
 
     /**
-     * whole url, just like http://.../bucketName/remotePath
+     * 完整的 HTTP 访问路径，格式类似于 http://.../bucketName/remotePath。
+     * 该路径可用于在网络上直接访问文件。
      */
     private String httpPath;
 
     /**
-     * file path on storage server
+     * 文件在存储服务器上的路径。
+     * 它表示文件在存储服务器的实际存储位置。
      */
     private String remotePath;
 
+    /**
+     * 默认构造函数，用于创建一个 DfsPath 对象，其属性初始值为 null。
+     */
     public DfsPath() {
 
     }
 
     /**
-     * Constructor with httpPath and remotePath
+     * 带参数的构造函数，用于创建一个具有指定 HTTP 路径和远程路径的 DfsPath 对象。
      *
-     * @param httpPath
+     * @param httpPath 文件的完整 HTTP 访问路径
-     * @param remotePath
+     * @param remotePath 文件在存储服务器上的路径
      */
     public DfsPath(String httpPath, String remotePath) {
         this.httpPath = httpPath;
         this.remotePath = remotePath;
     }
 
+    /**
+     * 获取文件的完整 HTTP 访问路径。
+     *
+     * @return 文件的 HTTP 访问路径
+     */
     public String getHttpPath() {
         return httpPath;
     }
 
+    /**
+     * 设置文件的完整 HTTP 访问路径。
+     *
+     * @param httpPath 要设置的 HTTP 访问路径
+     */
     public void setHttpPath(String httpPath) {
         this.httpPath = httpPath;
     }
 
+    /**
+     * 获取文件在存储服务器上的路径。
+     *
+     * @return 文件在存储服务器上的路径
+     */
     public String getRemotePath() {
         return remotePath;
     }
 
+    /**
+     * 设置文件在存储服务器上的路径。
+     *
+     * @param remotePath 要设置的存储服务器上的路径
+     */
     public void setRemotePath(String remotePath) {
         this.remotePath = remotePath;
     }
-}
+}

src/main/java/com/xmomen/module/resource/api/DfsSdk.java

@@ -4,7 +4,9 @@ import java.io.File;
 
 public class DfsSdk {
 
+    // 根据dfsType和bucketName获取DfsService实例
     public static DfsService getDfsInstance(String dfsType, String bucketName) {
+        // 如果dfsType为FastDFS，则获取FastDfsService实例
         if ("FastDFS".equalsIgnoreCase(dfsType)) {
             DfsService dfsService = FastDfsService.getInstance(bucketName);
             return dfsService;
@@ -12,6 +14,7 @@ public class DfsSdk {
         return null;
     }
     
+    // 默认获取FastDFS的DfsService实例
     public static DfsService getDfsInstance() {
     	return getDfsInstance("FastDFS", "group1");
     }

src/main/java/com/xmomen/module/resource/api/DfsService.java

@@ -4,73 +4,91 @@ import java.io.File;
 import java.util.List;
 import java.util.Map;
 
+/**
+ * DfsService 接口定义了与分布式文件系统（DFS）进行交互的一系列操作。
+ * 这些操作涵盖了文件的上传、下载、删除、列表获取以及路径获取等功能。
+ */
 public interface DfsService {
 
     /**
-     * Upload file to file system.
+     * 将本地文件上传到分布式文件系统。
      *
-     * @param filePath local file path
+     * @param filePath 文件在本地的路径，用于定位要上传的文件。
-     * @param key  Key
+     * @param key  文件的唯一标识，可用于区分不同的文件。
-     * @param metadata  metadata for the file
+     * @param metadata  文件的元数据，以键值对的形式存储额外信息。
-     * @return DfsPath object or null if fail
+     * @return 若上传成功，返回包含文件在 DFS 中路径信息的 DfsPath 对象；若失败则返回 null。
      */
     public DfsPath putObject(String filePath, String key, Map<String, String> metadata);
 
     /**
-     * Upload file to file system
+     * 将 File 对象表示的文件上传到分布式文件系统。
      *
-     * @param file  file
+     * @param file  要上传的文件对象。
-     * @param key Key
+     * @param key  文件的唯一标识，用于区分不同的文件。
-     * @param metadata metadata for the file
+     * @param metadata  文件的元数据，以键值对的形式存储额外信息。
-     * @return DfsPath object or null if fail
+     * @return 若上传成功，返回包含文件在 DFS 中路径信息的 DfsPath 对象；若失败则返回 null。
      */
     public DfsPath putObject(File file, String key, Map<String, String> metadata);
 
     /**
-     * Upload file to file system
+     * 将字节数组形式的文件内容上传到分布式文件系统。
      *
-     * @param bytes  file
+     * @param bytes  文件的字节数据，代表文件的实际内容。
-     * @param key Key
+     * @param key  文件的唯一标识，用于区分不同的文件。
-     * @param metadata  metadata for the file
+     * @param metadata  文件的元数据，以键值对的形式存储额外信息。
-     * @param extName  ext name of file
+     * @param extName  文件的扩展名，用于标识文件类型。
-     * @return DfsPath object or null if fail
+     * @return 若上传成功，返回包含文件在 DFS 中路径信息的 DfsPath 对象；若失败则返回 null。
      */
     public DfsPath putObject(byte[] bytes, String key, Map<String, String> metadata, String extName);
 
     /**
-     * Get file from file system with remotePath
+     * 从分布式文件系统中根据远程路径和键获取文件。
      *
-     * @param remotePath  remote file path on file system
+     * @param remotePath  文件在分布式文件系统中的远程路径，用于定位文件。
-     * @param key Key
+     * @param key  文件的唯一标识，用于验证文件的身份。
-     * @return DfsPath object or null if fail
+     * @return 若获取成功，返回包含文件数据和元信息的 DfsFile 对象；若失败则返回 null。
      */
     public DfsFile getObject(String remotePath, String key);
 
     /**
-     * Delete the file on file system
+     * 从分布式文件系统中删除指定远程路径和键对应的文件。
      *
-     * @param remotePath remote file path on file system
+     * @param remotePath  文件在分布式文件系统中的远程路径，用于定位要删除的文件。
-     * @param key Key
+     * @param key  文件的唯一标识，用于验证要删除的文件。
-     * @return true||false
+     * @return 若删除成功，返回 true；若失败则返回 false。
      */
     public boolean deleteObject(String remotePath, String key);
 
     /**
-     * Get the list of the file on file system
+     * 获取分布式文件系统中的文件列表。
      *
-     * @return List<DfsFile>
+     * @return 返回一个包含 DfsFile 对象的列表，每个对象代表文件系统中的一个文件；若列表为空则返回空列表。
      */
     public List<DfsFile> listObjects();
 
     /**
-     * Get the whole url
+     * 根据文件在分布式文件系统中的远程路径获取其完整的 HTTP 访问路径。
      *
-     * @param remotePath
+     * @param remotePath  文件在分布式文件系统中的远程路径。
-     * @return whole url
+     * @return 返回文件的完整 HTTP 访问路径，可用于在网络上访问该文件。
      */
     public String getHttpPath(String remotePath);
-    
+
+    /**
+     * 根据 DMS 文件路径获取其对应的完整 HTTP 访问路径。
+     * DMS 可能是某种特定的文件管理系统。
+     *
+     * @param dmsFilePath  DMS 系统中的文件路径。
+     * @return 返回该文件对应的完整 HTTP 访问路径。
+     */
     public String getDmsHttpPath(String dmsFilePath);
-    
+
+    /**
+     * 根据指定的类型获取默认路径。
+     * 这里的类型可能是文件的分类、用途等，具体含义取决于实现。
+     *
+     * @param type  文件的类型标识。
+     * @return 返回对应类型的默认路径。
+     */
     public String getDefaultPath(String type);
-}
+}

src/main/java/com/xmomen/module/resource/api/FastDfsService.java

@@ -19,58 +19,77 @@ import org.csource.fastdfs.StorageServer;
 import org.csource.fastdfs.TrackerClient;
 import org.csource.fastdfs.TrackerServer;
 
+/**
+ * FastDfsService 类实现了 DfsService 接口，用于与 FastDFS 分布式文件系统进行交互。
+ * 该类采用单例模式，确保在整个应用中只有一个实例与 FastDFS 进行通信。
+ */
 public class FastDfsService implements DfsService {
 
+    // 单例实例
     private static FastDfsService instance = null;
 
+    // 基础 URL，用于构建文件的完整 HTTP 访问路径
     private String baseUrl = "";
+    // DMS 基础 URL，用于构建 DMS 文件的完整 HTTP 访问路径
     private String dmsBaseUrl = "";
+    // 默认图片 URL
     private String defaultPicUrl = "";
 
-    //private static Logger logger = Logger.getLogger(FastDfsService.class.getName());
+    // 配置文件中基础 URL 的键名
-
     private static String BASE_URL = "httpBaseUrl";
-    
+    // 配置文件中 DMS 基础 URL 的键名
     private static String DMS_BASE_URL = "dmsBaseUrl";
-    
+    // 配置文件中默认图片 URL 的键名
     private static String DEFAULT_PIC_URL = "defaultPicUrl";
 
+    // FastDFS 键名，用于元数据中存储文件的唯一标识
     private static String FAST_DFS_KEY = "FastDfsKey";
 
     /**
-     * bucket name
+     * 存储文件的桶名
      */
     private final String bucketName;
 
     /**
-     * constructor with bucketName
+     * 私有构造函数，用于初始化 FastDfsService 实例。
+     * 该构造函数会读取 FastDFS 配置文件，并初始化客户端全局配置。
      *
-     * @param bucketName bucket name
+     * @param bucketName 存储文件的桶名
      */
     private FastDfsService(String bucketName) {
         this.bucketName = bucketName;
         String configFilePath = null;
-		try {
-			configFilePath = FastDfsService.class.getResource("/").toURI().getPath() + "fdfs_client.conf";
-		} catch (URISyntaxException e1) {
-			Exception e = new Exception("Cann't found fdfs_client.conf file under " + FastDfsService.class.getResource("/"));
-			handleException(e);
-		}
         try {
+            // 获取 FastDFS 配置文件的路径
+            configFilePath = FastDfsService.class.getResource("/").toURI().getPath() + "fdfs_client.conf";
+        } catch (URISyntaxException e1) {
+            // 若无法找到配置文件，抛出异常并处理
+            Exception e = new Exception("Cann't found fdfs_client.conf file under " + FastDfsService.class.getResource("/"));
+            handleException(e);
+        }
+        try {
+            // 初始化 FastDFS 客户端全局配置
             ClientGlobal.init(configFilePath);
+            // 读取配置文件
             IniFileReader reader = new IniFileReader(configFilePath);
+            // 设置基础 URL
             setBaseUrl(reader.getStrValue(BASE_URL));
+            // 设置 DMS 基础 URL
             setDmsBaseUrl(reader.getStrValue(DMS_BASE_URL));
+            // 设置默认图片 URL
             setDefaultPicUrl(reader.getStrValue(DEFAULT_PIC_URL));
         } catch (Exception e) {
+            // 处理初始化过程中出现的异常
             handleException(e);
         }
     }
 
     /**
-     * Get instance of FastDfsService, for Singleton
+     * 获取 FastDfsService 单例实例的方法。
-     * @param bucketName bucket name
+     * 采用双重检查锁定机制确保线程安全。
-     * @return instance of FastDfsService
+     *
+     * @param bucketName 存储文件的桶名
+     * @return FastDfsService 单例实例
      */
     public static synchronized FastDfsService getInstance(String bucketName) {
         if (null == instance) {
@@ -80,11 +99,11 @@ public class FastDfsService implements DfsService {
     }
 
     /**
-     * Delete file on file system.
+     * 从文件系统中删除指定的文件。
      *
-     * @param remotePath  remote file path
+     * @param remotePath 远程文件路径
-     * @param key Key, not used in FastDFS
+     * @param key        文件的键，在 FastDFS 中未使用
-     * @return true|false
+     * @return 删除成功返回 true，失败返回 false
      */
     @Override
     public boolean deleteObject(String remotePath, String key) {
@@ -92,21 +111,28 @@ public class FastDfsService implements DfsService {
         TrackerClient trackerClient = new TrackerClient();
         TrackerServer trackerServer = null;
         try {
+            // 获取 Tracker 服务器连接
             trackerServer = trackerClient.getConnection();
+            // 创建存储客户端
             StorageClient storageClient = new StorageClient(trackerServer, null);
+            // 调用 FastDFS API 删除文件
             result = storageClient.delete_file(bucketName, remotePath);
-        } catch(Exception e) {
+        } catch (Exception e) {
+            // 处理删除过程中出现的异常
             handleException(e);
         } finally {
             if (null != trackerServer) {
                 try {
+                    // 关闭 Tracker 服务器连接
                     trackerServer.close();
                 } catch (Exception e) {
+                    // 处理关闭连接时出现的异常
                     handleException(e);
                 }
             }
         }
         if (0 != result) {
+            // 删除失败，记录日志并返回 false
             //logger.info("delete faild, the faild code is: " + result);
             return false;
         }
@@ -114,26 +140,33 @@ public class FastDfsService implements DfsService {
     }
 
     /**
-     * Find the whole url
+     * 根据远程路径构建文件的完整 HTTP 访问路径。
      *
-     * @param remotePath  remote path
+     * @param remotePath 远程文件路径
-     * @return the whole url
+     * @return 文件的完整 HTTP 访问路径
      */
     @Override
     public String getHttpPath(String remotePath) {
         return baseUrl + "/" + bucketName + "/" + remotePath;
     }
 
+    /**
+     * 根据 DMS 文件路径构建其完整的 HTTP 访问路径。
+     *
+     * @param dmsFilePath DMS 文件路径
+     * @return DMS 文件的完整 HTTP 访问路径
+     */
     @Override
     public String getDmsHttpPath(String dmsFilePath) {
-    	return dmsBaseUrl + dmsFilePath;
+        return dmsBaseUrl + dmsFilePath;
     }
+
     /**
-     * Get the file, and return DfsFile object
+     * 从文件系统中获取指定的文件。
      *
-     * @param remotePath remote path
+     * @param remotePath 远程文件路径
-     * @param key Key, not used in FastDFS, can be null
+     * @param key        文件的键，在 FastDFS 中未使用，可以为 null
-     * @return DfsFile object or null if fail
+     * @return 若获取成功，返回 DfsFile 对象；否则返回 null
      */
     @Override
     public DfsFile getObject(String remotePath, String key) {
@@ -141,59 +174,75 @@ public class FastDfsService implements DfsService {
         TrackerServer trackerServer = null;
         StorageServer storageServer = null;
         try {
+            // 获取 Tracker 服务器连接
             trackerServer = trackerClient.getConnection();
+            // 获取存储服务器
             storageServer = trackerClient.getFetchStorage(trackerServer, bucketName, remotePath);
+            // 创建存储客户端
             StorageClient storageClient = new StorageClient(trackerServer, storageServer);
+            // 下载文件
             byte[] bytes = storageClient.download_file(this.bucketName, remotePath);
             if (null != bytes) {
+                // 获取文件的元数据
                 NameValuePair[] value_pairs = storageClient.get_metadata(bucketName, remotePath);
                 Map<String, String> metadata = new HashMap<String, String>();
                 for (int i = 0; i < value_pairs.length; i++) {
+                    // 将元数据存储到 Map 中
                     metadata.put(value_pairs[i].getName(), value_pairs[i].getValue());
                 }
+                // 创建 DfsFile 对象
                 DfsFile dfsFile = new DfsFile(metadata.get(FAST_DFS_KEY), bytes, metadata);
                 return dfsFile;
             }
-        } catch (Exception e){
+        } catch (Exception e) {
+            // 处理获取文件过程中出现的异常
             handleException(e);
         } finally {
             if (null != storageServer) {
                 try {
+                    // 关闭存储服务器连接
                     storageServer.close();
                 } catch (Exception e) {
+                    // 处理关闭连接时出现的异常
                     handleException(e);
                 }
             }
             if (null != trackerServer) {
                 try {
+                    // 关闭 Tracker 服务器连接
                     trackerServer.close();
                 } catch (Exception e) {
+                    // 处理关闭连接时出现的异常
                     handleException(e);
                 }
             }
         }
+        // 获取文件失败，记录日志并返回 null
         //logger.info("Get object failed, get null object");
         return null;
     }
 
     /**
-     * Get the file list of file system.
+     * 获取文件系统中的文件列表。
-     * Not implement at the moment, because FastDFS API not support.
+     * 目前由于 FastDFS API 不支持，该方法未实现。
+     *
+     * @return 始终返回 null
      */
     @Override
     public List<DfsFile> listObjects() {
-        //to do
+        // 待实现
-        //Because fastDFS api do not support list object method.
+        // 因为 FastDFS API 不支持列出对象的方法
         return null;
     }
 
     /**
-     * Upload the file to file system by file path
+     * 通过文件路径将文件上传到文件系统。
+     * 该方法会将文件转换为 File 对象，然后调用 putObject(File file, String key, Map<String, String> metadata) 方法进行上传。
      *
-     * @param filePath local file path.
+     * @param filePath  本地文件路径
-     * @param key Key, not used in FastDFS, can be null
+     * @param key       文件的键，在 FastDFS 中未使用，可以为 null
-     * @param metadata  metadata for file, can be null
+     * @param metadata  文件的元数据，可以为 null
-     * @return DfsFile object or null if fail
+     * @return 若上传成功，返回 DfsPath 对象；否则返回 null
      */
     @Override
     public DfsPath putObject(String filePath, String key, Map<String, String> metadata) {
@@ -202,13 +251,13 @@ public class FastDfsService implements DfsService {
     }
 
     /**
-     * Upload the file to file system by bytes
+     * 通过字节数组将文件上传到文件系统。
      *
-     * @param bytes bytes
+     * @param bytes     文件的字节数组
-     * @param key Key, not used in FastDFS
+     * @param key       文件的键，在 FastDFS 中未使用
-     * @param metadata metadata for file, can be null
+     * @param metadata  文件的元数据，可以为 null
-     * @param extName extName for file, can be null
+     * @param extName   文件的扩展名，可以为 null
-     * @return DfsPath object or null if fail
+     * @return 若上传成功，返回 DfsPath 对象；否则返回 null
      */
     @Override
     public DfsPath putObject(byte[] bytes, String key, Map<String, String> metadata, String extName) {
@@ -216,147 +265,215 @@ public class FastDfsService implements DfsService {
         TrackerServer trackerServer = null;
         StorageServer storageServer = null;
         try {
+            // 获取 Tracker 服务器连接
             trackerServer = trackerClient.getConnection();
+            // 获取存储服务器列表
             StorageServer[] storageServers = trackerClient.getStoreStorages(trackerServer, bucketName);
             if (null != storageServers) {
+                // 选择第一个存储服务器
                 storageServer = storageServers[0];
+                // 创建存储客户端
                 StorageClient storageClient = new StorageClient(trackerServer, storageServer);
 
                 NameValuePair[] meta_list;
                 int i = 0;
                 if (null == metadata) {
+                    // 若元数据为空，创建一个包含一个元素的元数据数组
                     meta_list = new NameValuePair[1];
                 } else {
+                    // 若元数据不为空，创建一个包含元数据和 FastDFS 键的数组
                     meta_list = new NameValuePair[metadata.size() + 1];
                     for (Map.Entry<String, String> entry : metadata.entrySet()) {
                         meta_list[i++] = new NameValuePair(entry.getKey(), entry.getValue());
                     }
                 }
+                // 添加 FastDFS 键到元数据数组
                 meta_list[i] = new NameValuePair(FAST_DFS_KEY, key);
 
+                // 调用 FastDFS API 上传文件
                 String[] results = storageClient.upload_file(bytes, extName, meta_list);
 
                 if (null == results) {
+                    // 上传失败，记录日志并返回 null
                     //logger.info("upload file fail, error codes: " + storageClient.getErrorCode());
                     return null;
                 } else {
+                    // 获取远程文件名
                     String remote_fileName = results[1];
+                    // 构建文件的完整 HTTP 访问路径
                     String httpPath = this.getHttpPath(remote_fileName);
+                    // 创建 DfsPath 对象
                     DfsPath dfsPath = new DfsPath(httpPath, remote_fileName);
                     return dfsPath;
                 }
             }
         } catch (Exception e) {
+            // 处理上传过程中出现的异常
             handleException(e);
         } finally {
             if (null != storageServer) {
                 try {
+                    // 关闭存储服务器连接
                     storageServer.close();
                 } catch (Exception e) {
+                    // 处理关闭连接时出现的异常
                     handleException(e);
                 }
             }
             if (null != trackerServer) {
                 try {
+                    // 关闭 Tracker 服务器连接
                     trackerServer.close();
                 } catch (Exception e) {
+                    // 处理关闭连接时出现的异常
                     handleException(e);
                 }
             }
         }
+        // 上传失败，记录日志并返回 null
         //logger.info("Upload file faild, because can not get storage servers!");
         return null;
-
     }
 
     /**
-     * Upload the file to file system
+     * 将文件上传到文件系统。
+     * 该方法会将文件转换为字节数组，然后调用 putObject(byte[] bytes, String key, Map<String, String> metadata, String extName) 方法进行上传。
      *
-     * @param file file
+     * @param file      文件对象
-     * @param key  Key, not used in FastDFS, can be null
+     * @param key       文件的键，在 FastDFS 中未使用，可以为 null
-     * @param metadata  metadata for file , can be null
+     * @param metadata  文件的元数据，可以为 null
-     * @return DfsPath object or null if fail
+     * @return 若上传成功，返回 DfsPath 对象；否则返回 null
      */
     @Override
     public DfsPath putObject(File file, String key, Map<String, String> metadata) {
         FileInputStream in = null;
         byte[] file_buff = null;
         try {
+            // 打开文件输入流
             in = new FileInputStream(file);
             if (null != in) {
+                // 获取文件长度
                 int len = in.available();
+                // 创建字节数组
                 file_buff = new byte[len];
+                // 读取文件内容到字节数组
                 in.read(file_buff);
             }
         } catch (Exception e) {
+            // 处理读取文件过程中出现的异常
             handleException(e);
         } finally {
             if (null != in) {
                 try {
+                    // 关闭文件输入流
                     in.close();
                 } catch (Exception e) {
+                    // 处理关闭流时出现的异常
                     handleException(e);
                 }
             }
         }
         String file_ext_name = "";
         if (file.getName().lastIndexOf(".") > 0) {
+            // 获取文件扩展名
             file_ext_name = file.getName().substring(file.getName().lastIndexOf(".") + 1);
         }
+        // 调用 putObject(byte[] bytes, String key, Map<String, String> metadata, String extName) 方法上传文件
         return putObject(file_buff, key, metadata, file_ext_name);
     }
 
+    /**
+     * 获取基础 URL。
+     *
+     * @return 基础 URL
+     */
     public String getBaseUrl() {
         return baseUrl;
     }
 
+    /**
+     * 设置基础 URL。
+     *
+     * @param baseUrl 要设置的基础 URL
+     */
     private void setBaseUrl(String baseUrl) {
         this.baseUrl = baseUrl;
     }
 
+    /**
+     * 获取 DMS 基础 URL。
+     *
+     * @return DMS 基础 URL
+     */
     public String getDmsBaseUrl() {
-    	return dmsBaseUrl;
+        return dmsBaseUrl;
     }
+
+    /**
+     * 设置 DMS 基础 URL。
+     *
+     * @param dmsBaseUrl 要设置的 DMS 基础 URL
+     */
     public void setDmsBaseUrl(String dmsBaseUrl) {
-    	this.dmsBaseUrl = dmsBaseUrl;
+        this.dmsBaseUrl = dmsBaseUrl;
     }
-    
+
+    /**
+     * 获取默认图片 URL。
+     *
+     * @return 默认图片 URL
+     */
     public String getDefaultPicUrl() {
-    	return defaultPicUrl;
+        return defaultPicUrl;
     }
+
+    /**
+     * 设置默认图片 URL。
+     *
+     * @param defaultPicUrl 要设置的默认图片 URL
+     */
     public void setDefaultPicUrl(String defaultPicUrl) {
-    	this.defaultPicUrl = defaultPicUrl;
+        this.defaultPicUrl = defaultPicUrl;
     }
-    
+
     /**
-     * Handle Exception
+     * 处理异常的方法。
-     * @param e exception
+     * 根据异常类型抛出不同的 DfsException 异常。
+     *
+     * @param e 要处理的异常
      */
     private void handleException(Exception e) {
         if (e instanceof IOException) {
+            // 处理 IOException，抛出 DfsException，错误码为 100
             //logger.error("Exception occured : DFSException code: 100,"  + " exception message :" + e.getMessage());
             throw new DfsException("100", e.getMessage());
         } else if (e instanceof FileNotFoundException) {
+            // 处理 FileNotFoundException，抛出 DfsException，错误码为 200
             //logger.error("Exception occured : DFSException code: 200,"  + " exception message : file not found." + e.getMessage());
             throw new DfsException("200", e.getMessage());
         } else if (e instanceof MyException) {
+            // 处理 MyException，抛出 DfsException，错误码为 300
             //logger.error("Exception occured : DFSException code: 300,"  + " exception message :" + e.getMessage());
             throw new DfsException("300", e.getMessage());
         } else if (e instanceof Exception) {
+            // 处理其他异常，抛出 DfsException，错误码为 400
             //logger.error("Exception occured : DFSException code: 400,"  + " exception message :" + e.getMessage());
             throw new DfsException("400", e.getMessage());
         }
     }
 
-	@Override
+    /**
-	public String getDefaultPath(String type) {
+     * 根据类型获取默认路径。
-		if("PICTURE".equalsIgnoreCase(type)) {
+     * 如果类型为 "PICTURE"，则返回默认图片 URL；否则也返回默认图片 URL。
-			return defaultPicUrl;
+     *
-		}
+     * @param type 路径类型
-		return defaultPicUrl;
+     * @return 默认路径
-	}
+     */
-	
+    @Override
-	
+    public String getDefaultPath(String type) {
-
+        if ("PICTURE".equalsIgnoreCase(type)) {
-
+            return defaultPicUrl;
-}
+        }
+        return defaultPicUrl;
+    }
+}

src/main/java/com/xmomen/module/resource/controller/ResourceController.java

@@ -1,130 +1,203 @@
+// 声明该类所在的包，此包为资源控制器相关的包
 package com.xmomen.module.resource.controller;
 
+// 导入自定义框架中的业务异常类，用于处理业务逻辑中出现的异常
 import com.xmomen.framework.exception.BusinessException;
+// 导入自定义框架中 MyBatis 分页相关的 Page 类，用于处理分页查询结果
 import com.xmomen.framework.mybatis.page.Page;
+// 导入自定义模块中的日志注解，用于记录操作日志
 import com.xmomen.module.logger.Log;
+// 导入资源查询模型类，用于封装资源查询的条件
 import com.xmomen.module.resource.model.ResourceQuery;
+// 导入资源数据模型类，用于封装资源的相关数据
 import com.xmomen.module.resource.model.ResourceModel;
+// 导入资源服务类，该类包含资源相关的业务逻辑
 import com.xmomen.module.resource.service.ResourceService;
 
+// 导入 Apache Commons IO 工具类，用于处理输入输出流
 import org.apache.commons.io.IOUtils;
+// 导入 Jeecg 框架中 Excel 导入工具类，用于从 Excel 文件中导入数据
 import org.jeecgframework.poi.excel.ExcelImportUtil;
+// 导入 Jeecg 框架中 Excel 导出参数类，用于配置 Excel 导出的参数
 import org.jeecgframework.poi.excel.entity.ExportParams;
+// 导入 Jeecg 框架中 Excel 导入参数类，用于配置 Excel 导入的参数
 import org.jeecgframework.poi.excel.entity.ImportParams;
+// 导入 Jeecg 框架中 Excel 导入结果类，用于封装 Excel 导入的结果
 import org.jeecgframework.poi.excel.entity.result.ExcelImportResult;
+// 导入 Jeecg 框架中普通 Excel 常量类，包含一些 Excel 操作的常量
 import org.jeecgframework.poi.excel.entity.vo.NormalExcelConstants;
+// 导入 Jeecg 框架中 Excel 导入异常类，用于处理 Excel 导入过程中出现的异常
 import org.jeecgframework.poi.exception.excel.ExcelImportException;
+// 导入 Spring 框架中的自动装配注解，用于自动注入依赖的 Bean
 import org.springframework.beans.factory.annotation.Autowired;
+// 导入 Spring 框架中的模型映射类，用于在控制器和视图之间传递数据
 import org.springframework.ui.ModelMap;
+// 导入 Spring 框架中的数据绑定结果类，用于处理数据绑定过程中的错误信息
 import org.springframework.validation.BindingResult;
+// 导入 Spring 框架中的请求映射相关注解，用于处理 HTTP 请求
 import org.springframework.web.bind.annotation.*;
+// 导入 Spring 框架中用于处理多部分文件上传的类
 import org.springframework.web.multipart.MultipartFile;
+// 导入 Spring 框架中的模型和视图类，用于返回包含模型数据和视图名称的对象
 import org.springframework.web.servlet.ModelAndView;
 
+// 导入 JSR-303 验证框架中的有效注解，用于对请求参数进行验证
 import javax.validation.Valid;
+// 导入 Java 序列化接口，用于支持对象的序列化和反序列化
 import java.io.Serializable;
+// 导入 Java 输入输出异常类，用于处理输入输出操作中出现的异常
 import java.io.IOException;
+// 导入 Java 输入流类，用于读取数据
 import java.io.InputStream;
+// 导入 Java 列表接口，用于存储多个元素
 import java.util.List;
 
 /**
+ * 资源控制器类，负责处理与资源目录相关的 HTTP 请求。
+ *
  * @author tanxinzheng
  * @version 1.0.0
  * @date 2017-4-10 23:26:20
  */
+// 标记该类为 RESTful 风格的控制器，会自动将方法返回值转换为 JSON 格式
 @RestController
+// 定义该控制器处理的请求路径前缀为 /resource
 @RequestMapping(value = "/resource")
 public class ResourceController {
 
+    // 使用自动装配注解将 ResourceService 注入到当前类中，用于调用资源相关的业务逻辑
     @Autowired
     ResourceService resourceService;
 
     /**
-     * 资源目录列表
+     * 处理获取资源目录列表的请求。
      *
-     * @param limit      每页结果数
+     * @param limit 每页显示的结果数量
-     * @param offset     页码
+     * @param offset 当前页码
-     * @param id         主键
+     * @param id 资源的主键，可选参数
-     * @param ids        主键数组
+     * @param entityType 资源所属的实体类型，可选参数
-     * @param excludeIds 不包含主键数组
+     * @param entityId 资源所属的实体 ID，可选参数
-     * @return Page<ResourceModel> 资源目录领域分页对象
+     * @param ids 资源主键数组，可选参数
+     * @param excludeIds 不包含的资源主键数组，可选参数
+     * @return 包含资源目录数据的分页对象
      */
+    // 映射 HTTP GET 请求到该方法
     @RequestMapping(method = RequestMethod.GET)
+    // 使用日志注解记录该操作的名称为查询资源目录列表
     @Log(actionName = "查询资源目录列表")
-    public Page<ResourceModel> getResourceList(@RequestParam(value = "limit") Integer limit,
+    public Page<ResourceModel> getResourceList(
-                                               @RequestParam(value = "offset") Integer offset,
+            // 从请求参数中获取每页结果数
-                                               @RequestParam(value = "id", required = false) String id,
+            @RequestParam(value = "limit") Integer limit,
-                                               @RequestParam(value = "entityType", required = false) String entityType,
+            // 从请求参数中获取页码
-                                               @RequestParam(value = "entityId", required = false) String entityId,
+            @RequestParam(value = "offset") Integer offset,
-                                               @RequestParam(value = "ids", required = false) String[] ids,
+            // 从请求参数中获取资源主键，该参数可选
-                                               @RequestParam(value = "excludeIds", required = false) String[] excludeIds) {
+            @RequestParam(value = "id", required = false) String id,
+            // 从请求参数中获取资源所属的实体类型，该参数可选
+            @RequestParam(value = "entityType", required = false) String entityType,
+            // 从请求参数中获取资源所属的实体 ID，该参数可选
+            @RequestParam(value = "entityId", required = false) String entityId,
+            // 从请求参数中获取资源主键数组，该参数可选
+            @RequestParam(value = "ids", required = false) String[] ids,
+            // 从请求参数中获取不包含的资源主键数组，该参数可选
+            @RequestParam(value = "excludeIds", required = false) String[] excludeIds) {
+        // 创建资源查询对象
         ResourceQuery resourceQuery = new ResourceQuery();
+        // 设置查询条件：资源主键
         resourceQuery.setId(id);
+        // 设置查询条件：不包含的资源主键数组
         resourceQuery.setExcludeIds(excludeIds);
+        // 设置查询条件：资源主键数组
         resourceQuery.setIds(ids);
+        // 设置查询条件：资源所属的实体类型
         resourceQuery.setEntityType(entityType);
+        // 设置查询条件：资源所属的实体 ID
         resourceQuery.setEntityId(entityId);
+        // 调用资源服务的方法，根据分页信息和查询条件获取资源目录分页数据
         return resourceService.getResourceModelPage(limit, offset, resourceQuery);
     }
 
     /**
-     * 查询单个资源目录
+     * 处理获取单个资源目录的请求。
      *
-     * @param id 主键
+     * @param id 资源的主键
-     * @return ResourceModel   资源目录领域对象
+     * @return 资源目录的数据模型对象
      */
+    // 映射形如 /resource/{id} 的 HTTP GET 请求到该方法
     @RequestMapping(value = "/{id}", method = RequestMethod.GET)
+    // 使用日志注解记录该操作的名称为查询资源目录
     @Log(actionName = "查询资源目录")
-    public ResourceModel getResourceById(@PathVariable(value = "id") String id) {
+    public ResourceModel getResourceById(
+            // 从路径中获取资源主键
+            @PathVariable(value = "id") String id) {
+        // 调用资源服务的方法，根据主键获取单个资源目录的数据
         return resourceService.getOneResourceModel(id);
     }
 
     /**
-     * 新增资源目录
+     * 处理新增资源目录的请求。
      *
-     * @param resourceModel 新增对象参数
+     * @param resourceModel 包含新增资源目录信息的数据模型对象
-     * @return ResourceModel   资源目录领域对象
+     * @return 新增后的资源目录的数据模型对象
      */
+    // 映射 HTTP POST 请求到该方法
     @RequestMapping(method = RequestMethod.POST)
+    // 使用日志注解记录该操作的名称为新增资源目录
     @Log(actionName = "新增资源目录")
-    public ResourceModel createResource(@RequestBody @Valid ResourceModel resourceModel) {
+    public ResourceModel createResource(
+            // 从请求体中获取新增资源目录的数据，并进行数据验证
+            @RequestBody @Valid ResourceModel resourceModel) {
+        // 调用资源服务的方法，创建新的资源目录
         return resourceService.createResource(resourceModel);
     }
 
     /**
-     * 更新资源目录
+     * 处理更新资源目录的请求。
      *
-     * @param id            主键
+     * @param id 要更新的资源的主键
-     * @param resourceModel 更新对象参数
+     * @param resourceModel 包含更新后资源目录信息的数据模型对象
      */
+    // 映射形如 /resource/{id} 的 HTTP PUT 请求到该方法
     @RequestMapping(value = "/{id}", method = RequestMethod.PUT)
+    // 使用日志注解记录该操作的名称为更新资源目录
     @Log(actionName = "更新资源目录")
-    public void updateResource(@PathVariable(value = "id") String id,
+    public void updateResource(
-                               @RequestBody @Valid ResourceModel resourceModel) {
+            // 从路径中获取要更新的资源主键
+            @PathVariable(value = "id") String id,
+            // 从请求体中获取更新后的资源目录数据，并进行数据验证
+            @RequestBody @Valid ResourceModel resourceModel) {
+        // 调用资源服务的方法，更新资源目录信息
         resourceService.updateResource(resourceModel);
     }
 
     /**
-     * 删除资源目录
+     * 处理删除单个资源目录的请求。
      *
-     * @param id 主键
+     * @param id 要删除的资源的主键
      */
+    // 映射形如 /resource/{id} 的 HTTP DELETE 请求到该方法
     @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
+    // 使用日志注解记录该操作的名称为删除单个资源目录
     @Log(actionName = "删除单个资源目录")
-    public void deleteResource(@PathVariable(value = "id") String id) {
+    public void deleteResource(
+            // 从路径中获取要删除的资源主键
+            @PathVariable(value = "id") String id) {
+        // 调用资源服务的方法，删除指定主键的资源目录
         resourceService.deleteResource(id);
     }
 
     /**
-     * 删除资源目录
+     * 处理批量删除资源目录的请求。
      *
-     * @param ids 主键
+     * @param ids 要删除的资源的主键数组
      */
+    // 映射 HTTP DELETE 请求到该方法
     @RequestMapping(method = RequestMethod.DELETE)
+    // 使用日志注解记录该操作的名称为批量删除资源目录
     @Log(actionName = "批量删除资源目录")
-    public void deleteResources(@RequestParam(value = "ids") String[] ids) {
+    public void deleteResources(
+            // 从请求参数中获取要删除的资源主键数组
+            @RequestParam(value = "ids") String[] ids) {
+        // 调用资源服务的方法，批量删除指定主键的资源目录
         resourceService.deleteResource(ids);
     }
-
+}
-
-}

src/main/java/com/xmomen/module/resource/entity/Resource.java

@@ -1,4 +1,4 @@
-package com.xmomen.module.resource.entity;
+Xpackage com.xmomen.module.resource.entity;
 
 import com.xmomen.framework.mybatis.model.BaseMybatisModel;
 import javax.persistence.Column;

src/main/java/com/xmomen/module/resource/entity/mapper/ResourceMapper.xml

@@ -1,7 +1,15 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
-<mapper namespace="com.xmomen.module.resource.entity.mapper.ResourceMapper" >
+<?xml version="1.0" encoding="UTF-8"?>
-  <resultMap id="BaseResultMap" type="com.xmomen.module.resource.entity.Resource" >
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.xmomen.module.resource.entity.mapper.ResourceMapper">
+  <!--
+      定义结果映射，将数据库查询结果映射到 Java 对象。
+      id: 结果映射的唯一标识。
+      type: 要映射的 Java 实体类的全限定名。
+  -->
+  <resultMap id="BaseResultMap" type="com.xmomen.module.resource.entity.Resource">
+    <!-- 映射数据库表中的主键列到实体类的属性 -->
     <id column="ID" property="id" jdbcType="VARCHAR" />
     <result column="ENTITY_TYPE" property="entityType" jdbcType="VARCHAR" />
     <result column="ENTITY_ID" property="entityId" jdbcType="VARCHAR" />
@@ -9,25 +17,37 @@
     <result column="RESOURCE_TYPE" property="resourceType" jdbcType="VARCHAR" />
     <result column="IS_DEFAULT" property="isDefault" jdbcType="INTEGER" />
   </resultMap>
-  <sql id="Example_Where_Clause" >
+
-    <where >
+  <!--
-      <foreach collection="oredCriteria" item="criteria" separator="or" >
+      定义 SQL 片段，用于生成 WHERE 子句。
-        <if test="criteria.valid" >
+      此片段根据传入的查询条件动态生成 WHERE 子句，支持多种条件类型（无值、单值、范围值、列表值）。
-          <trim prefix="(" suffix=")" prefixOverrides="and" >
+  -->
-            <foreach collection="criteria.criteria" item="criterion" >
+  <sql id="Example_Where_Clause">
-              <choose >
+    <where>
-                <when test="criterion.noValue" >
+      <!-- 遍历所有的查询条件组 -->
+      <foreach collection="oredCriteria" item="criteria" separator="or">
+        <if test="criteria.valid">
+          <!-- 去除开头多余的 "and" -->
+          <trim prefix="(" suffix=")" prefixOverrides="and">
+            <!-- 遍历每个查询条件组中的具体条件 -->
+            <foreach collection="criteria.criteria" item="criterion">
+              <choose>
+                <!-- 处理无值条件 -->
+                <when test="criterion.noValue">
                   and ${criterion.condition}
                 </when>
-                <when test="criterion.singleValue" >
+                <!-- 处理单值条件 -->
+                <when test="criterion.singleValue">
                   and ${criterion.condition} #{criterion.value}
                 </when>
-                <when test="criterion.betweenValue" >
+                <!-- 处理范围值条件 -->
+                <when test="criterion.betweenValue">
                   and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
                 </when>
-                <when test="criterion.listValue" >
+                <!-- 处理列表值条件 -->
+                <when test="criterion.listValue">
                   and ${criterion.condition}
-                  <foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
+                  <foreach collection="criterion.value" item="listItem" open="(" close=")" separator=",">
                     #{listItem}
                   </foreach>
                 </when>
@@ -38,25 +58,30 @@
       </foreach>
     </where>
   </sql>
-  <sql id="Update_By_Example_Where_Clause" >
+
-    <where >
+  <!--
-      <foreach collection="example.oredCriteria" item="criteria" separator="or" >
+      定义 SQL 片段，用于生成 UPDATE 语句的 WHERE 子句。
-        <if test="criteria.valid" >
+      逻辑与 Example_Where_Clause 类似，用于根据条件更新数据。
-          <trim prefix="(" suffix=")" prefixOverrides="and" >
+  -->
-            <foreach collection="criteria.criteria" item="criterion" >
+  <sql id="Update_By_Example_Where_Clause">
-              <choose >
+    <where>
-                <when test="criterion.noValue" >
+      <foreach collection="example.oredCriteria" item="criteria" separator="or">
+        <if test="criteria.valid">
+          <trim prefix="(" suffix=")" prefixOverrides="and">
+            <foreach collection="criteria.criteria" item="criterion">
+              <choose>
+                <when test="criterion.noValue">
                   and ${criterion.condition}
                 </when>
-                <when test="criterion.singleValue" >
+                <when test="criterion.singleValue">
                   and ${criterion.condition} #{criterion.value}
                 </when>
-                <when test="criterion.betweenValue" >
+                <when test="criterion.betweenValue">
                   and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
                 </when>
-                <when test="criterion.listValue" >
+                <when test="criterion.listValue">
                   and ${criterion.condition}
-                  <foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
+                  <foreach collection="criterion.value" item="listItem" open="(" close=")" separator=",">
                     #{listItem}
                   </foreach>
                 </when>
@@ -67,100 +92,148 @@
       </foreach>
     </where>
   </sql>
-  <sql id="Base_Column_List" >
+
+  <!-- 定义 SQL 片段，列出表中的基本列名 -->
+  <sql id="Base_Column_List">
     ID, ENTITY_TYPE, ENTITY_ID, PATH, RESOURCE_TYPE, IS_DEFAULT
   </sql>
-  <select id="selectByExample" resultMap="BaseResultMap" parameterType="com.xmomen.module.resource.entity.ResourceExample" >
+
+  <!--
+      定义查询语句，根据条件查询资源数据。
+      id: 语句的唯一标识。
+      resultMap: 引用前面定义的结果映射，用于将查询结果映射到实体类。
+      parameterType: 传入的参数类型，这里是查询条件对象。
+  -->
+  <select id="selectByExample" resultMap="BaseResultMap" parameterType="com.xmomen.module.resource.entity.ResourceExample">
     select
-    <if test="distinct" >
+    <!-- 如果需要去重，添加 distinct 关键字 -->
+    <if test="distinct">
       distinct
     </if>
+    <!-- 引入基本列名片段 -->
     <include refid="Base_Column_List" />
     from cd_resource
-    <if test="_parameter != null" >
+    <!-- 如果传入了查询参数，引入 WHERE 子句片段 -->
+    <if test="_parameter != null">
       <include refid="Example_Where_Clause" />
     </if>
-    <if test="orderByClause != null" >
+    <!-- 如果有排序条件，添加排序子句 -->
+    <if test="orderByClause != null">
       order by ${orderByClause}
     </if>
   </select>
-  <delete id="deleteByExample" parameterType="com.xmomen.module.resource.entity.ResourceExample" >
+
+  <!--
+      定义删除语句，根据条件删除资源数据。
+      id: 语句的唯一标识。
+      parameterType: 传入的参数类型，这里是查询条件对象。
+  -->
+  <delete id="deleteByExample" parameterType="com.xmomen.module.resource.entity.ResourceExample">
     delete from cd_resource
-    <if test="_parameter != null" >
+    <!-- 如果传入了查询参数，引入 WHERE 子句片段 -->
+    <if test="_parameter != null">
       <include refid="Example_Where_Clause" />
     </if>
   </delete>
-  <insert id="insertSelective" parameterType="com.xmomen.module.resource.entity.Resource" useGeneratedKeys="true" keyProperty="id" keyColumn="ID" >
+
-    <selectKey resultType="java.lang.String" keyProperty="id" order="BEFORE" >
+  <!--
+      定义插入语句，选择性插入资源数据（只插入非空字段）。
+      id: 语句的唯一标识。
+      parameterType: 传入的参数类型，这里是要插入的实体类对象。
+      useGeneratedKeys: 是否使用数据库生成的主键。
+      keyProperty: 实体类中表示主键的属性名。
+      keyColumn: 数据库表中主键列的名称。
+  -->
+  <insert id="insertSelective" parameterType="com.xmomen.module.resource.entity.Resource" useGeneratedKeys="true" keyProperty="id" keyColumn="ID">
+    <!-- 在插入前生成主键值，这里使用 UUID 并去除连字符 -->
+    <selectKey resultType="java.lang.String" keyProperty="id" order="BEFORE">
       SELECT replace(UUID(),'-','')
     </selectKey>
     insert into cd_resource
-    <trim prefix="(" suffix=")" suffixOverrides="," >
+    <!-- 动态生成插入的列名，只包含非空字段 -->
+    <trim prefix="(" suffix=")" suffixOverrides=",">
       ID,
-      <if test="entityType != null" >
+      <if test="entityType != null">
         ENTITY_TYPE,
       </if>
-      <if test="entityId != null" >
+      <if test="entityId != null">
         ENTITY_ID,
       </if>
-      <if test="path != null" >
+      <if test="path != null">
         PATH,
       </if>
-      <if test="resourceType != null" >
+      <if test="resourceType != null">
         RESOURCE_TYPE,
       </if>
-      <if test="isDefault != null" >
+      <if test="isDefault != null">
         IS_DEFAULT,
       </if>
     </trim>
-    <trim prefix="values (" suffix=")" suffixOverrides="," >
+    <!-- 动态生成插入的值，只包含非空字段 -->
+    <trim prefix="values (" suffix=")" suffixOverrides=",">
       #{id,jdbcType=VARCHAR},
-      <if test="entityType != null" >
+      <if test="entityType != null">
         #{entityType,jdbcType=VARCHAR},
       </if>
-      <if test="entityId != null" >
+      <if test="entityId != null">
         #{entityId,jdbcType=VARCHAR},
       </if>
-      <if test="path != null" >
+      <if test="path != null">
         #{path,jdbcType=VARCHAR},
       </if>
-      <if test="resourceType != null" >
+      <if test="resourceType != null">
         #{resourceType,jdbcType=VARCHAR},
       </if>
-      <if test="isDefault != null" >
+      <if test="isDefault != null">
         #{isDefault,jdbcType=INTEGER},
       </if>
     </trim>
   </insert>
-  <select id="countByExample" parameterType="com.xmomen.module.resource.entity.ResourceExample" resultType="java.lang.Integer" >
+
+  <!--
+      定义统计语句，根据条件统计资源数据的数量。
+      id: 语句的唯一标识。
+      parameterType: 传入的参数类型，这里是查询条件对象。
+      resultType: 返回的结果类型，这里是整数类型。
+  -->
+  <select id="countByExample" parameterType="com.xmomen.module.resource.entity.ResourceExample" resultType="java.lang.Integer">
     select count(*) from cd_resource
-    <if test="_parameter != null" >
+    <!-- 如果传入了查询参数，引入 WHERE 子句片段 -->
+    <if test="_parameter != null">
       <include refid="Example_Where_Clause" />
     </if>
   </select>
-  <update id="updateByExampleSelective" parameterType="map" >
+
+  <!--
+      定义更新语句，根据条件选择性更新资源数据（只更新非空字段）。
+      id: 语句的唯一标识。
+      parameterType: 传入的参数类型，这里是一个包含实体类对象和查询条件的 Map。
+  -->
+  <update id="updateByExampleSelective" parameterType="map">
     update cd_resource
-    <set >
+    <!-- 动态生成 SET 子句，只包含非空字段 -->
-      <if test="record.id != null" >
+    <set>
+      <if test="record.id != null">
         ID = #{record.id,jdbcType=VARCHAR},
       </if>
-      <if test="record.entityType != null" >
+      <if test="record.entityType != null">
         ENTITY_TYPE = #{record.entityType,jdbcType=VARCHAR},
       </if>
-      <if test="record.entityId != null" >
+      <if test="record.entityId != null">
         ENTITY_ID = #{record.entityId,jdbcType=VARCHAR},
       </if>
-      <if test="record.path != null" >
+      <if test="record.path != null">
         PATH = #{record.path,jdbcType=VARCHAR},
       </if>
-      <if test="record.resourceType != null" >
+      <if test="record.resourceType != null">
         RESOURCE_TYPE = #{record.resourceType,jdbcType=VARCHAR},
       </if>
-      <if test="record.isDefault != null" >
+      <if test="record.isDefault != null">
         IS_DEFAULT = #{record.isDefault,jdbcType=INTEGER},
       </if>
     </set>
-    <if test="_parameter != null" >
+    <!-- 如果传入了查询参数，引入 UPDATE 的 WHERE 子句片段 -->
+    <if test="_parameter != null">
       <include refid="Update_By_Example_Where_Clause" />
     </if>
   </update>

src/main/java/org/csource/fastdfs/ClientGlobal.java

@@ -1,11 +1,3 @@
-/**
-* Copyright (C) 2008 Happy Fish / YuQing
-*
-* FastDFS Java Client may be copied only under the terms of the GNU Lesser
-* General Public License (LGPL).
-* Please visit the FastDFS Home Page http://www.csource.org/ for more detail.
-**/
-
 package org.csource.fastdfs;
 
 import java.net.*;
@@ -13,11 +5,6 @@ import java.io.*;
 import java.net.*;
 import org.csource.common.*;
 
-/**
-* Global variables
-* @author Happy Fish / YuQing
-* @version Version 1.11
-*/
 public class ClientGlobal
 {
 	public static int g_connect_timeout; //millisecond
@@ -27,18 +14,14 @@ public class ClientGlobal
 	public static boolean g_anti_steal_token;  //if anti-steal token
 	public static String g_secret_key;   //generage token secret key
 	public static TrackerGroup g_tracker_group;
-	
 	public static final int DEFAULT_CONNECT_TIMEOUT = 5;  //second
 	public static final int DEFAULT_NETWORK_TIMEOUT = 30; //second
 	
 	private ClientGlobal()
 	{
 	}
-	
+
-/**
+	// 初始化ClientGlobal
-* load global variables
-* @param conf_filename config filename
-*/
 	public static void init(String conf_filename) throws FileNotFoundException, IOException, MyException
 	{
   		IniFileReader iniReader;
@@ -47,6 +30,7 @@ public class ClientGlobal
 			
   		iniReader = new IniFileReader(conf_filename);
 
+			// 读取连接超时时间
 			g_connect_timeout = iniReader.getIntValue("connect_timeout", DEFAULT_CONNECT_TIMEOUT);
   		if (g_connect_timeout < 0)
   		{
@@ -54,6 +38,7 @@ public class ClientGlobal
   		}
   		g_connect_timeout *= 1000; //millisecond
   		
+  		// 读取网络超时时间
   		g_network_timeout = iniReader.getIntValue("network_timeout", DEFAULT_NETWORK_TIMEOUT);
   		if (g_network_timeout < 0)
   		{
@@ -61,18 +46,21 @@ public class ClientGlobal
   		}
   		g_network_timeout *= 1000; //millisecond
 
+  		// 读取字符集
   		g_charset = iniReader.getStrValue("charset");
   		if (g_charset == null || g_charset.length() == 0)
   		{
   			g_charset = "ISO8859-1";
   		}
   		
+  		// 读取tracker服务器地址
   		szTrackerServers = iniReader.getValues("tracker_server");
   		if (szTrackerServers == null)
   		{
   			throw new MyException("item \"tracker_server\" in " + conf_filename + " not found");
   		}
   		
+  		// 将tracker服务器地址转换为InetSocketAddress数组
   		InetSocketAddress[] tracker_servers = new InetSocketAddress[szTrackerServers.length];
   		for (int i=0; i<szTrackerServers.length; i++)
   		{
@@ -86,20 +74,18 @@ public class ClientGlobal
   		}
   		g_tracker_group = new TrackerGroup(tracker_servers);
   		
+  		// 读取tracker服务器HTTP端口
   		g_tracker_http_port = iniReader.getIntValue("http.tracker_http_port", 80);
+  		// 读取是否启用反盗链
   		g_anti_steal_token = iniReader.getBoolValue("http.anti_steal_token", false);
   		if (g_anti_steal_token)
   		{
+  			// 读取反盗链密钥
   			g_secret_key = iniReader.getStrValue("http.secret_key");
   		}
 	}
-	
+
-/**
+	// 根据IP地址和端口获取Socket
-* construct Socket object
-* @param ip_addr ip address or hostname
-* @param port port number
-* @return connected Socket object
-*/
 	public static Socket getSocket(String ip_addr, int port) throws IOException
 	{
 		Socket sock = new Socket();
@@ -107,12 +93,8 @@ public class ClientGlobal
 		sock.connect(new InetSocketAddress(ip_addr, port), ClientGlobal.g_connect_timeout);
 		return sock;
 	}
-	
+
-/**
+	// 根据InetSocketAddress获取Socket
-* construct Socket object
-* @param addr InetSocketAddress object, including ip address and port
-* @return connected Socket object
-*/
 	public static Socket getSocket(InetSocketAddress addr) throws IOException
 	{
 		Socket sock = new Socket();
@@ -121,76 +103,91 @@ public class ClientGlobal
 		return sock;
 	}
 	
+	// 获取连接超时时间
 	public static int getG_connect_timeout()
 	{
 		return g_connect_timeout;
 	}
 	
+	// 设置连接超时时间
 	public static void setG_connect_timeout(int connect_timeout)
 	{
 		ClientGlobal.g_connect_timeout = connect_timeout;
 	}
 	
+	// 获取网络超时时间
 	public static int getG_network_timeout()
 	{
 		return g_network_timeout;
 	}
 	
+	// 设置网络超时时间
 	public static void setG_network_timeout(int network_timeout)
 	{
 		ClientGlobal.g_network_timeout = network_timeout;
 	}
 	
+	// 获取字符集
 	public static String getG_charset()
 	{
 		return g_charset;
 	}
 	
+	// 设置字符集
 	public static void setG_charset(String charset)
 	{
 		ClientGlobal.g_charset = charset;
 	}
 	
+	// 获取tracker服务器HTTP端口
 	public static int getG_tracker_http_port()
 	{
 		return g_tracker_http_port;
 	}
 	
+	// 设置tracker服务器HTTP端口
 	public static void setG_tracker_http_port(int tracker_http_port)
 	{
 		ClientGlobal.g_tracker_http_port = tracker_http_port;
 	}
 	
+	// 获取是否启用反盗链
 	public static boolean getG_anti_steal_token()
 	{
 		return g_anti_steal_token;
 	}
 	
+	// 获取是否启用反盗链
 	public static boolean isG_anti_steal_token()
 	{
 		return g_anti_steal_token;
 	}
 	
+	// 设置是否启用反盗链
 	public static void setG_anti_steal_token(boolean anti_steal_token)
 	{
 		ClientGlobal.g_anti_steal_token = anti_steal_token;
 	}
 	
+	// 获取反盗链密钥
 	public static String getG_secret_key()
 	{
 		return g_secret_key;
 	}
 	
+	// 设置反盗链密钥
 	public static void setG_secret_key(String secret_key)
 	{
 		ClientGlobal.g_secret_key = secret_key;
 	}
 	
+	// 获取tracker服务器组
 	public static TrackerGroup getG_tracker_group()
 	{
 		return g_tracker_group;
 	}
 	
+	// 设置tracker服务器组
 	public static void setG_tracker_group(TrackerGroup tracker_group)
 	{
 		ClientGlobal.g_tracker_group = tracker_group;

src/main/java/org/csource/fastdfs/DownloadStream.java

@@ -4,33 +4,26 @@ import java.io.IOException;
 import java.io.OutputStream;
 import org.csource.fastdfs.DownloadCallback;
 
-/**
-* Download file by stream (download callback class)
-* @author  zhouzezhong & Happy Fish / YuQing
-* @version Version 1.11
-*/
 public class DownloadStream implements DownloadCallback
 {
+	// 定义输出流
 	private OutputStream out;
+	// 定义当前字节
 	private long currentBytes = 0;
 	
+	// 构造函数，传入输出流
 	public DownloadStream(OutputStream out)
 	{
 		super();
 		this.out = out;
 	}
 
-	/**
+
-	* recv file content callback function, may be called more than once when the file downloaded
-	* @param fileSize file size
-	*	@param data data buff
-	* @param bytes data bytes
-	* @return 0 success, return none zero(errno) if fail
-	*/
 	public int recv(long fileSize, byte[] data, int bytes)
 	{
 		try
 		{
+			// 将数据写入输出流
 			out.write(data, 0, bytes);
 		}
 		catch(IOException ex)
@@ -39,7 +32,9 @@ public class DownloadStream implements DownloadCallback
 			return -1;
 		}
 		
+		// 更新当前字节
 		currentBytes +=	bytes;
+		// 如果当前字节等于文件大小，则重置当前字节
 		if (this.currentBytes == fileSize)
 		{
 			this.currentBytes = 0;

src/main/webapp/doc/swagger-ui/dist/index.html

@@ -5,12 +5,14 @@
   <title>Swagger UI</title>
   <link rel="icon" type="image/png" href="images/favicon-32x32.png" sizes="32x32" />
   <link rel="icon" type="image/png" href="images/favicon-16x16.png" sizes="16x16" />
+  <!-- 引入样式文件 -->
   <link href='css/typography.css' media='screen' rel='stylesheet' type='text/css'/>
   <link href='css/reset.css' media='screen' rel='stylesheet' type='text/css'/>
   <link href='css/screen.css' media='screen' rel='stylesheet' type='text/css'/>
   <link href='css/reset.css' media='print' rel='stylesheet' type='text/css'/>
   <link href='css/print.css' media='print' rel='stylesheet' type='text/css'/>
 
+  <!-- 引入脚本文件 -->
   <script src='lib/object-assign-pollyfill.js' type='text/javascript'></script>
   <script src='lib/jquery-1.8.0.min.js' type='text/javascript'></script>
   <script src='lib/jquery.slideto.min.js' type='text/javascript'></script>
@@ -33,6 +35,7 @@
 
   <script type="text/javascript">
     $(function () {
+      // 获取url参数
       var url = window.location.search.match(/url=([^&]+)/);
       if (url && url.length > 1) {
         url = decodeURIComponent(url[1]);
@@ -40,6 +43,7 @@
         url = "/api-docs/";
       }
 
+      // 配置highlight.js
       hljs.configure({
         highlightSizeThreshold: 5000
       });
@@ -53,6 +57,7 @@
         dom_id: "swagger-ui-container",
         supportedSubmitMethods: ['get', 'post', 'put', 'delete', 'patch'],
         onComplete: function(swaggerApi, swaggerUi){
+          // 初始化OAuth
           if(typeof initOAuth == "function") {
             initOAuth({
               clientId: "your-client-id",
@@ -64,6 +69,7 @@
             });
           }
 
+          // 翻译
           if(window.SwaggerTranslator) {
             window.SwaggerTranslator.translate();
           }