Merge remote-tracking branch 'origin/master'

yt-adage/adage-service/src/main/java/com/ytpm/adage/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.adage.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "adage-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-adage/adage-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-agent/agent-service/src/main/java/com/ytpm/handle/CustomerExceptionHandler.java

@@ -0,0 +1,174 @@
+package com.ytpm.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "agent-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-algebraic/algebraic-service/src/main/java/com/ytpm/algebraic/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.algebraic.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "carp-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-algebraic/algebraic-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-allusion/allusion-service/src/main/java/com/ytpm/allusion/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.allusion.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "allusion-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-allusion/allusion-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-answer/answer-service/src/main/java/com/ytpm/answer/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.answer.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "answer-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-answer/answer-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-arithmetic/arithmetic-service/src/main/java/com/ytpm/arithmetic/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.arithmetic.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "arithmetic-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-arithmetic/arithmetic-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-calculator/calculator-service/src/main/java/com/ytpm/calculator/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.calculator.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "calculator-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-calculator/calculator-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-carp/carp-service/src/main/java/com/ytpm/carp/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.carp.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "carp-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-carp/carp-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-common/src/main/java/com/ytpm/agent/model/YtPlatformUserApp.java

@@ -43,4 +43,16 @@ public class YtPlatformUserApp extends BaseParam {
     private String feignClassPath;
     @ApiModelProperty("服务名称")
     private String serviceName;
+    @ApiModelProperty("taku应用ID")
+    private String takuAppId;
+    @ApiModelProperty("taku应用key")
+    private String takuKey;
+    @ApiModelProperty("taku横幅")
+    private String takuBannerPid;
+    @ApiModelProperty("taku原生")
+    private String takuNativePid;
+    @ApiModelProperty("taku激励")
+    private String takuRewardPid;
+    @ApiModelProperty("taku插屏")
+    private String takuInterstitialPid;
 }

yt-common/src/main/java/com/ytpm/app/model/YtDyzUser.java

@@ -123,4 +123,6 @@ public class YtDyzUser extends PageMeta {
     private String phone;
     @ApiModelProperty(value = "设备ID")
     private String deviceId;
+    @ApiModelProperty(value = "手机json收集信息")
+    private String phoneJson;
 }

yt-common/src/main/java/com/ytpm/middle/param/AppForm.java

@@ -41,4 +41,16 @@ public class AppForm extends BaseParam {
     private BigDecimal salePrice;
     @ApiModelProperty("授权类型")
     private Integer grantType;
+    @ApiModelProperty("taku应用ID")
+    private String takuAppId;
+    @ApiModelProperty("taku应用key")
+    private String takuKey;
+    @ApiModelProperty("taku横幅")
+    private String takuBannerPid;
+    @ApiModelProperty("taku原生")
+    private String takuNativePid;
+    @ApiModelProperty("taku激励")
+    private String takuRewardPid;
+    @ApiModelProperty("taku插屏")
+    private String takuInterstitialPid;
 }

yt-countstep/countstep-service/src/main/java/com/ytpm/countstep/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.countstep.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "countstep-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-countstep/countstep-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-diary/diary-service/src/main/java/com/ytpm/diary/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.diary.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "diary-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-diary/diary-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>

yt-dtw/dtw-service/src/main/java/com/ytpm/dtw/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.dtw.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "dtw-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-dtw/dtw-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>

yt-emoticons/emoticons-service/src/main/java/com/ytpm/emoticons/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.emoticons.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "emoticons-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-emoticons/emoticons-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-funarith/funarith-service/src/main/java/com/ytpm/funarith/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.funarith.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "funarith-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-funarith/funarith-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-gateway/src/main/resources/bootstrap.yml

@@ -1,10 +1,6 @@
 spring:
   profiles:
     active: prod
-logging:
-  level:
-    com.alibaba.nacos: DEBUG
-    org.springframework.cloud: DEBUG
 ---
 spring:
   profiles: local

yt-idiom/idiom-service/src/main/java/com/ytpm/idiom/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.idiom.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "idiom-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-idiom/idiom-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-irun/irun-service/src/main/java/com/ytpm/irun/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.irun.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "irun-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-irun/irun-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>

yt-lemon/lemon-service/src/main/java/com/ytpm/lemon/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.lemon.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "lemon-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-lemon/lemon-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-lime/lime-service/src/main/java/com/ytpm/lime/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.lime.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "lime-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-lime/lime-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-middle/middle-platform/src/main/java/com/ytpm/middle/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.middle.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "middle-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-middle/middle-platform/src/main/resources/mapper/AppMapper.xml

@@ -15,6 +15,12 @@
          wx_app_id,
          wx_secret,
          sale_price,
+         taku_app_id,
+         taku_key,
+         taku_banner_pid,
+         taku_native_pid,
+         taku_reward_pid,
+         taku_interstitial_pid,
          create_user_id,
          create_time,
          available
@@ -32,6 +38,12 @@
          #{wxAppId},
          #{wxSecret},
          #{salePrice},
+         #{takuAppId},
+         #{takuKey},
+         #{takuBannerPid},
+         #{takuNativePid},
+         #{takuRewardPid},
+         #{takuInterstitialPid},
          #{createUserId},
          #{createTime},
          #{available}
@@ -110,6 +122,27 @@
             <if test="grantType != null">
                 grant_type = #{grantType},
             </if>
+            <if test="takuAppId != null">
+                taku_app_id = #{takuAppId},
+            </if>
+            <if test="takuKey != null">
+                taku_key = #{takuKey},
+            </if>
+            <if test="takuBannerPid != null">
+                taku_banner_pid = #{takuBannerPid},
+            </if>
+            <if test="takuNativePid != null">
+                taku_native_pid = #{takuNativePid},
+            </if>
+            <if test="takuRewardPid != null">
+                taku_reward_pid = #{takuRewardPid},
+            </if>
+            <if test="takuInterstitialPid != null">
+                taku_interstitial_pid = #{takuInterstitialPid},
+            </if>
+            <if test="grantType != null">
+                grant_type = #{grantType},
+            </if>
             <if test="available != null">
                 available = #{available}
             </if>

yt-mileage/mileage-service/src/main/java/com/ytpm/mileage/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.mileage.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "mileage-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-mileage/mileage-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-nofeeds/nofeeds-service/src/main/java/com/ytpm/nofeeds/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.nofeeds.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "nofeeds-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-nofeeds/nofeeds-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-picking/picking-service/src/main/java/com/ytpm/picking/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.picking.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "picking-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-picking/picking-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-raisepig/raisepig-service/src/main/java/com/ytpm/raisepig/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.raisepig.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "raisepig-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-raisepig/raisepig-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>

yt-risk/risk-feign/src/main/java/com/ytpm/feign/fallback/RiskFeignFallBack.java

@@ -4,19 +4,22 @@ import com.ytpm.app.model.YtDyzUser;
 import com.ytpm.feign.RiskFeign;
 import com.ytpm.general.RepMessage;
 import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
 import org.springframework.stereotype.Component;
 import org.springframework.web.bind.annotation.RequestBody;
 
-
+/**
+ * 服务降级配置
+ */
 @Component
 public abstract class RiskFeignFallBack implements RiskFeign {
     @Override
     public Result<?> checkRisk(@RequestBody YtDyzUser ytDyzUser) {
-        return Result.resultErr(RepMessage.SERVICE_UNAVAILABLE);
+        return new Result<>(StatusCode.ACCESS_ERR, RepMessage.TOKEN_EXPIRE);
     }
 
     @Override
     public Result<?> checkAdRisk(@RequestBody YtDyzUser ytDyzUser) {
-        return Result.resultErr(RepMessage.SERVICE_UNAVAILABLE);
+        return new Result<>(StatusCode.ACCESS_ERR, RepMessage.TOKEN_EXPIRE);
     }
 }

yt-risk/risk-manage/src/main/java/com/ytpm/handle/CustomerExceptionHandler.java

@@ -0,0 +1,174 @@
+package com.ytpm.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "risk-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-risk/risk-manage/src/main/java/com/ytpm/service/impl/RiskServiceImpl.java

@@ -568,9 +568,9 @@ public class RiskServiceImpl extends ReflectUtil implements RiskService {
         int firstAdCount = Integer.parseInt(limitMap.get("firstAdCount"));
         if(adCount>=firstAdCount){
             //过滤出ecpm值小于预设值的视频数
-            int ecpm = Integer.parseInt(limitMap.get("ecpm"));
+            BigDecimal ecpm = new BigDecimal(limitMap.get("ecpm"));
             long count = records.stream().filter(
-                    s -> Objects.nonNull(s.getEcpm())&&(s.getEcpm().compareTo(BigDecimal.valueOf(ecpm))) < 0).count();
+                    s -> Objects.nonNull(s.getEcpm())&&(s.getEcpm().compareTo(ecpm)) < 0).count();
             int exact = Math.toIntExact(count);
             //判断小于预设值的视频数超出预设次数
             int haveCount = Integer.parseInt(limitMap.get("haveCount"));

yt-summary/summary-service/src/main/java/com/ytpm/summary/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.summary.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "summary-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-summary/summary-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-vitality/vitality-service/src/main/java/com/ytpm/vitality/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.vitality.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "vitality-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-vitality/vitality-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>

yt-walk/walk-service/src/main/java/com/ytpm/walk/handle/CustomerExceptionHandler.java

@@ -0,0 +1,176 @@
+package com.ytpm.walk.handle;
+
+import cn.hutool.core.util.StrUtil;
+import com.ytpm.general.Result;
+import com.ytpm.general.StatusCode;
+import com.ytpm.handle.CustomerException;
+import com.ytpm.handle.ValidatedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.multipart.MultipartException;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Marx
+ * @date 2025/8/28 10:38
+ */
+@Slf4j(topic = "walk-exception")
+@RestControllerAdvice(annotations = RestController.class)
+public class CustomerExceptionHandler implements HandlerExceptionResolver {
+    @ResponseBody
+    @ExceptionHandler(Exception.class)
+    public Result handleException(Exception ex) {
+        //打印异常信息
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = "查询超时，请稍后重试！";
+        return new Result(StatusCode.ERROR,msg);
+    }
+
+    /**
+     * 对象参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public Result handleMissingServletRequestParameterException(Exception ex) {
+        log.error("对象参数校验失败，异常信息为：e={}", ex);
+        String msg = MessageFormat.format("缺少参数{0}", ((MissingServletRequestParameterException) ex).getParameterName());
+        return new Result(StatusCode.MISSING_PARAMETER, msg);
+    }
+
+    /**
+     * 单个参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(ConstraintViolationException.class)
+    public Result handleConstraintViolationException(Exception ex) {
+        log.error("单个参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        Set<ConstraintViolation<?>> sets = ((ConstraintViolationException) ex).getConstraintViolations();
+        if (!CollectionUtils.isEmpty(sets)) {
+            StringBuilder sb = new StringBuilder();
+            sets.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError) error).getField()).append(":");
+//                }
+                sb.append(error.getMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg, 0, msg.length() - 1);
+            return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+        }
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, "参数校验失败");
+    }
+
+    /**
+     * 自定义校验异常信息捕获
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(IllegalArgumentException.class)
+    public Result handleSpringCheckException(Exception ex) {
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    /**
+     * POST 请求参数校验失败
+     * @param ex
+     * @return
+     */
+    @ResponseBody
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public Result handleMethodArgumentNotValidException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex);
+        ex.printStackTrace();
+        List<ObjectError> errors = ((MethodArgumentNotValidException) ex).getBindingResult().getAllErrors();
+        String msg = getValidExceptionMsg(errors);
+        return new Result(StatusCode.PARAMETER_CHECK_ERR, msg);
+    }
+
+    @ResponseBody
+    @ExceptionHandler(ValidatedException.class)
+    public Result handleValidatedException(Exception ex) {
+        log.error(" 请求参数校验失败，异常信息为：ex={}",ex.getMessage());
+        return new Result(StatusCode.BUSINESS_CERTIFICATE_TYPE_STATUS_ERROR, ex.getMessage());
+    }
+
+    /**
+     * 获取属性校验异常信息
+     * @param errors
+     * @return
+     */
+    private String getValidExceptionMsg(List<ObjectError> errors) {
+        if(!CollectionUtils.isEmpty(errors)){
+            StringBuilder sb = new StringBuilder();
+            errors.forEach(error -> {
+//                if (error instanceof FieldError) {
+//                    sb.append(((FieldError)error).getField()).append(":");
+//                }
+                sb.append(error.getDefaultMessage()).append(";");
+            });
+            String msg = sb.toString();
+            msg = StrUtil.sub(msg,0, msg.length() -1);
+            return msg;
+        }
+        return "绑定异常";
+    }
+
+    @ResponseBody
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public Result handlerFileUploadException(MaxUploadSizeExceededException ex){
+        log.error("抛出异常信息，异常信息为：ex={}",ex);
+        return new Result(StatusCode.ERROR,"文件超出限制(10MB)");
+    }
+
+    @Override
+    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
+        log.error(" 系统异常，异常信息为：e={}", e.getMessage());
+        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
+        if (e instanceof MultipartException) {
+            mv.addObject("message", "系统异常");
+            mv.addObject("code", "801");
+            mv.setStatus(HttpStatus.OK);
+        } else {
+            mv.addObject("msg", e.getMessage());
+        }
+        return mv;
+    }
+
+    @ResponseBody
+    @ExceptionHandler(CustomerException.class)
+    public Result handleCustomerException(Exception ex){
+        log.error("自定义校验异常信息捕获，异常信息为：ex={}", ex);
+        ex.printStackTrace();
+        String msg = ex.getMessage();
+        return new Result(StatusCode.ACCESS_ERR, msg);
+    }
+
+
+}

yt-walk/walk-service/src/main/resources/mapper/AppUserMapper.xml

@@ -27,6 +27,7 @@
          app_id,
          power,
          phone,
+         phone_json,
          device_id
         )
         values
@@ -54,6 +55,7 @@
          #{appId},
          #{power},
          #{phone},
+         #{phoneJson},
          #{deviceId}
         )
     </insert>
@@ -153,6 +155,9 @@
             <if test="wxOpenId != null">
                 wx_open_id = #{wxOpenId},
             </if>
+            <if test="phoneJson != null">
+                phone_json = #{phoneJson},
+            </if>
             <if test="platformId != null">
                 platform_id = #{platformId}
             </if>