springCloud Alibaba教程- 搭建springboot工程(最新版本)

最新推荐文章于 2024-05-10 21:09:39 发布
最新推荐文章于 2024-05-10 21:09:39 发布
阅读量2k 收藏 5
点赞数 1
分类专栏： spring boot spring cloud alibaba 文章标签： spring boot spring cloud java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tdt008/article/details/127320691
版权

使用最新版springCloud版本教你一步一步搭建起springcloud alibaba开发环境。

1 springBoot、springCloud以及springCloud Alibaba版本

下图为springCloud Alibaba推荐的springBoot、springCloud适配版本，也是最新的版本：
在这里插入图片描述

2 搭建springboot工程

首先搭建一个spirngBoot工程，后面再一步一步引入cloud alibaba组件。

2.1 搭建cloudAlibaba父工程

父工程其实就一个空的maven工程，主要是引入相关依赖，并对依赖版本号进行约束。pom文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <packaging>pom</packaging>

    <groupId>com.tdt.platform.cloud</groupId>
    <artifactId>platform-cloud-b-parent</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <modules>
        <module>cloud-common</module>
        <module>cloud-user-service</module>
    </modules>

    <properties>
        <java.version>17</java.version>
        <spring.cloud.version>2021.0.4</spring.cloud.version>
        <spring.cloud.alibaba.version>2021.0.4.0</spring.cloud.alibaba.version>
        <spring.boot.version>2.6.11</spring.boot.version>
        <mybatis.plus.version>3.5.2</mybatis.plus.version>
        <mysql.connector.java.version>8.0.30</mysql.connector.java.version>
        <druid.spring.boot.starter.version>1.2.13</druid.spring.boot.starter.version>
        <mapstruct.version>1.5.3.Final</mapstruct.version>
        <lombok.version>1.18.24</lombok.version>
        <lombok.mapstruct.binding.version>0.2.0</lombok.mapstruct.binding.version>
        <maven.compiler.plugin.version>3.10.1</maven.compiler.plugin.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- 整合spring-cloud-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- 整合spring-cloud-alibaba-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring.cloud.alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- springboot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring.boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- mybatis plus-->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatis.plus.version}</version>
            </dependency>

            <!--  mysql connector  -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.connector.java.version}</version>
            </dependency>
            <!-- druid -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>${druid.spring.boot.starter.version}</version>
            </dependency>

            <dependency>
                <groupId>com.alibaba.fastjson2</groupId>
                <artifactId>fastjson2</artifactId>
                <version>2.0.15</version>
            </dependency>


            <!-- mapstruct -->
            <dependency>
                <groupId>org.mapstruct</groupId>
                <artifactId>mapstruct-processor</artifactId>
                <version>${mapstruct.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mapstruct</groupId>
                <artifactId>mapstruct</artifactId>
                <version>${mapstruct.version}</version>
            </dependency>

            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven.compiler.plugin.version}</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>UTF-8</encoding>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>${mapstruct.version}</version>
                        </path>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>${lombok.version}</version>
                        </path>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok-mapstruct-binding</artifactId>
                            <version>${lombok.mapstruct.binding.version}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring.boot.version}</version>
            </plugin>
        </plugins>
    </build>

</project>

2.2 搭建common子工程

common工程主要是做一些公共操作。目前只是封装了接口相应体对象，以及异常的基础处理。后面随着组件的引入会封装成独立的springboot starter或者cloud starter。

1. pom文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>

    <parent>
        <groupId>com.tdt.platform.cloud</groupId>
        <artifactId>platform-cloud-b-parent</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>

    <artifactId>cloud-common</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

2. 公共响应对象JsonResult

public class JsonResult<T> implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 请求成功
     */
    private static final boolean REQUEST_SUCCESS = true;

    /**
     * 请求失败
     */
    private static final boolean REQUEST_FAIL = false;

    /**
     * 默认错误码
     */
    private static final String DEFAULT_ERROR_CODE = "-1";

    /**
     * 请求是否成功
     */
    private Boolean success;

    /**
     * 业务数据
     */
    private T data;

    /**
     * 错误码
     */
    private String errorCode;

    /**
     * 错误提示语
     */
    private String errorMessage;


    public JsonResult() {
    }

    public JsonResult(Boolean success, T data, String errorCode, String errorMessage) {
        this.success = success;
        this.data = data;
        this.errorCode = errorCode;
        this.errorMessage = errorMessage;
    }

    /**
     * 成功，不用返回数据
     *
     * @return
     */
    public static <T> JsonResult<T> buildSuccess() {
        return new JsonResult<>(REQUEST_SUCCESS, null, null, null);
    }

    /**
     * 成功，返回数据
     *
     * @param data
     * @return
     */
    public static <T> JsonResult<T> buildSuccess(T data) {
        return new JsonResult<>(REQUEST_SUCCESS, data, null, null);
    }

    /**
     * 失败，固定状态码
     *
     * @param errorMsg
     * @return
     */
    public static <T> JsonResult<T> buildError(String errorMsg) {
        return new JsonResult<>(REQUEST_FAIL, null, DEFAULT_ERROR_CODE, errorMsg);
    }

    /**
     * 失败，自定义错误码和信息
     *
     * @param errorCode 错误码
     * @param errorMsg  错误提示
     * @return
     */
    public static <T> JsonResult<T> buildError(String errorCode, String errorMsg) {
        return new JsonResult<>(REQUEST_FAIL, null, errorCode, errorMsg);
    }

    /**
     * 失败，枚举类定义错误码和信息
     *
     * @param baseErrorCodeEnum
     * @return
     */
    public static <T> JsonResult<T> buildError(BaseErrorCodeEnum baseErrorCodeEnum) {
        return new JsonResult<>(REQUEST_FAIL, null, baseErrorCodeEnum.getErrorCode(), baseErrorCodeEnum.getErrorMsg());
    }
    // 省略get/set方法
}

3. 公共异常

定义一个异常错误码枚举的抽象接口：

public interface BaseErrorCodeEnum {
    String getErrorCode();
    String getErrorMsg();
}

系统通用的异常错误编号和描述枚举类：

public enum CommonErrorCodeEnum implements BaseErrorCodeEnum {
    /**
     * 系统未知错误
     */
    SYSTEM_UNKNOWN_ERROR("-1", "系统未知错误"),
    /**
     * 客户端HTTP请求方法错误
     * org.springframework.web.HttpRequestMethodNotSupportedException
     */
    CLIENT_HTTP_METHOD_ERROR("1001", "客户端HTTP请求方法错误"),

    /**
     * 客户端request body参数错误
     * 主要是未能通过Hibernate Validator校验的异常处理
     * org.springframework.web.bind.MethodArgumentNotValidException
     */
    CLIENT_REQUEST_BODY_CHECK_ERROR("1002", "客户端请求体参数校验不通过"),

    /**
     * 客户端@RequestBody请求体JSON格式错误或字段类型错误
     * org.springframework.http.converter.HttpMessageNotReadableException
     * <p>
     * eg:
     * 1、参数类型不对:{"test":"abc"}，本身类型是Long
     * 2、{"test":}  test属性没有给值
     */
    CLIENT_REQUEST_BODY_FORMAT_ERROR("1003", "客户端请求体JSON格式错误或字段类型不匹配"),

    /**
     * 客户端@PathVariable参数错误
     * 一般是类型不匹配，比如本来是Long类型，客户端却给了一个无法转换成Long字符串
     * org.springframework.validation.BindException
     */
    CLIENT_PATH_VARIABLE_ERROR("1004", "客户端URL中的参数类型错误"),

    /**
     * 客户端@RequestParam参数校验不通过
     * 主要是未能通过Hibernate Validator校验的异常处理
     * javax.validation.ConstraintViolationException
     */
    CLIENT_REQUEST_PARAM_CHECK_ERROR("1005", "客户端请求参数校验不通过"),

    /**
     * 客户端@RequestParam参数必填
     * 入参中的@RequestParam注解设置了必填，但是客户端没有给值
     * javax.validation.ConstraintViolationException
     */
    CLIENT_REQUEST_PARAM_REQUIRED_ERROR("1006", "客户端请求缺少必填的参数"),

    /**
     * 通用的业务方法入参检查错误
     * java.lang.IllegalArgumentException
     */
    SERVER_ILLEGAL_ARGUMENT_ERROR("2001", "业务方法参数检查不通过"),
    ;

    private String errorCode;

    private String errorMsg;

    CommonErrorCodeEnum(String errorCode, String errorMsg) {
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }

    @Override
    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }

    @Override
    public String getErrorMsg() {
        return errorMsg;
    }

    public void setErrorMsg(String errorMsg) {
        this.errorMsg = errorMsg;
    }
}

4. 公共自定义异常

public class BaseBizException extends RuntimeException {
    /**
     * 默认错误码
     */
    private static final String DEFAULT_ERROR_CODE = "-1";

    private String errorCode;

    private String errorMsg;

    public BaseBizException(String errorMsg) {
        super(errorMsg);
        this.errorCode = DEFAULT_ERROR_CODE;
        this.errorMsg = errorMsg;
    }

    public BaseBizException(String errorCode, String errorMsg) {
        super(errorMsg);
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }

    public BaseBizException(BaseErrorCodeEnum baseErrorCodeEnum) {
        super(baseErrorCodeEnum.getErrorMsg());
        this.errorCode = baseErrorCodeEnum.getErrorCode();
        this.errorMsg = baseErrorCodeEnum.getErrorMsg();
    }

    public BaseBizException(String errorCode, String errorMsg, Object... arguments) {
        super(MessageFormat.format(errorMsg, arguments));
        this.errorCode = errorCode;
        this.errorMsg = MessageFormat.format(errorMsg, arguments);
    }

    public BaseBizException(BaseErrorCodeEnum baseErrorCodeEnum, Object... arguments) {
        super(MessageFormat.format(baseErrorCodeEnum.getErrorMsg(), arguments));
        this.errorCode = baseErrorCodeEnum.getErrorCode();
        this.errorMsg = MessageFormat.format(baseErrorCodeEnum.getErrorMsg(), arguments);
    }
// 省略get/set
}

2.3 搭建一个springboot工程

示例sql：

CREATE TABLE `user` (
  `id` bigint NOT NULL,
  `username` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `age` int DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

pom文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>

    <parent>
        <groupId>com.tdt.platform.cloud</groupId>
        <artifactId>platform-cloud-b-parent</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>

    <artifactId>cloud-user-service</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>

        <!-- mybatis mysql -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
        </dependency>

        <!-- common  -->
        <dependency>
            <groupId>com.tdt.platform.cloud</groupId>
            <artifactId>cloud-common</artifactId>
            <version>${version}</version>
        </dependency>

        <!-- bean copy-->
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct-processor</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

application.yml配置文件：

# 配置端口
server:
  port: 9001
  servlet:
    context-path: /cloud-user-service

spring:
  application:
    name: cloud-user-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://127.0.0.1:3306/cloud-user?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: root
    password: 12345678
    driverClassName: com.mysql.cj.jdbc.Driver
    initialSize: 50
    minIdle: 50
    maxActive: 500
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20
    filters: stat,wall,log4j
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true
  mapper-locations: classpath:mapper/*.xml

全局异常处理：

@Slf4j
@RestControllerAdvice
@Order
public class GlobalExceptionHandler {
    /**
     * 1001 HTTP请求方法类型错误
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = HttpRequestMethodNotSupportedException.class)
    public JsonResult<Object> handle(HttpRequestMethodNotSupportedException e) {
        log.error("[客户端HTTP请求方法错误]", e);
        return JsonResult.buildError(CommonErrorCodeEnum.CLIENT_HTTP_METHOD_ERROR);
    }

    /**
     * 1002 客户端请求体参数校验不通过
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = MethodArgumentNotValidException.class)
    public JsonResult<Object> handle(MethodArgumentNotValidException e) {
        log.error("[客户端请求体参数校验不通过]", e);
        String errorMsg = this.handle(e.getBindingResult().getFieldErrors());
        return JsonResult.buildError(CommonErrorCodeEnum.CLIENT_REQUEST_BODY_CHECK_ERROR.getErrorCode(), errorMsg);
    }

    private String handle(List<FieldError> fieldErrors) {
        StringBuilder sb = new StringBuilder();
        for (FieldError obj : fieldErrors) {
            sb.append(obj.getField());
            sb.append("=[");
            sb.append(obj.getDefaultMessage());
            sb.append("]  ");
        }
        return sb.toString();
    }

    /**
     * 1003 客户端请求体JSON格式错误或字段类型不匹配
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = HttpMessageNotReadableException.class)
    public JsonResult<Object> handle(HttpMessageNotReadableException e) {
        log.error("[客户端请求体JSON格式错误或字段类型不匹配]", e);
        return JsonResult.buildError(CommonErrorCodeEnum.CLIENT_REQUEST_BODY_FORMAT_ERROR);
    }

    /**
     * 1004 客户端URL中的参数类型错误
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = BindException.class)
    public JsonResult<Object> handle(BindException e) {
        log.error("[客户端URL中的参数类型错误]", e);
        FieldError fieldError = e.getBindingResult().getFieldError();
        String errorMsg = null;
        if (fieldError != null) {
            errorMsg = fieldError.getDefaultMessage();
            if (errorMsg != null && errorMsg.contains("java.lang.NumberFormatException")) {
                errorMsg = fieldError.getField() + "参数类型错误";
            }
        }
        if (errorMsg != null && !"".equals(errorMsg)) {
            return JsonResult.buildError(CommonErrorCodeEnum.CLIENT_PATH_VARIABLE_ERROR.getErrorCode(), errorMsg);
        }
        return JsonResult.buildError(CommonErrorCodeEnum.CLIENT_PATH_VARIABLE_ERROR);
    }

    /**
     * 1005 客户端请求参数校验不通过
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = ConstraintViolationException.class)
    public JsonResult<Object> handle(ConstraintViolationException e) {
        log.error("[客户端请求参数校验不通过]", e);
        Iterator<ConstraintViolation<?>> it = e.getConstraintViolations().iterator();
        String errorMsg = null;
        if (it.hasNext()) {
            errorMsg = it.next().getMessageTemplate();
        }
        if (errorMsg != null && !"".equals(errorMsg)) {
            return JsonResult.buildError(CommonErrorCodeEnum.CLIENT_REQUEST_PARAM_CHECK_ERROR.getErrorCode(), errorMsg);
        }
        return JsonResult.buildError(CommonErrorCodeEnum.CLIENT_REQUEST_PARAM_CHECK_ERROR);
    }


    /**
     * 1006 客户端请求缺少必填的参数
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = MissingServletRequestParameterException.class)
    public JsonResult<Object> handle(MissingServletRequestParameterException e) {
        log.error("[客户端请求缺少必填的参数]", e);
        String errorMsg = null;
        String parameterName = e.getParameterName();
        if (!"".equals(parameterName)) {
            errorMsg = parameterName + "不能为空";
        }
        if (errorMsg != null) {
            return JsonResult.buildError(CommonErrorCodeEnum.CLIENT_REQUEST_PARAM_REQUIRED_ERROR.getErrorCode(), errorMsg);
        }
        return JsonResult.buildError(CommonErrorCodeEnum.CLIENT_REQUEST_PARAM_REQUIRED_ERROR);
    }

    /**
     * 2001 业务方法参数检查不通过
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = IllegalArgumentException.class)
    public JsonResult<Object> handle(IllegalArgumentException e) {
        log.error("[业务方法参数检查不通过]", e);
        return JsonResult.buildError(CommonErrorCodeEnum.SERVER_ILLEGAL_ARGUMENT_ERROR);
    }

    /**
     * 系统自定义业务异常
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = BaseBizException.class)
    public JsonResult<Object> handle(BaseBizException e) {
        log.error("[ 业务异常 ]", e);
        return JsonResult.buildError(e.getErrorCode(), e.getErrorMsg());
    }
}

DO/DTO实体类创建：

@Data
@TableName(value = "user")
public class UserDO {
    @TableId(value = "id")
    private Long id;
    @TableField(value = "username")
    private String username;
    @TableField(value = "age")
    private Integer age;
}

@Data
public class UserDTO {
    private Long id;
    private String username;
    private Integer age;
}

实体类转换器，使用mapstruct来进行处理：

@Mapper(componentModel = "spring")
public interface UserConverter {
    UserDTO userDO2DTO(UserDO userDO);
}

业务代码编写：

// mapper
@Mapper
public interface UserMapper extends BaseMapper<UserDO> {
}

// dao
@Slf4j
@Repository
public class UserDAO extends ServiceImpl<UserMapper, UserDO> {
    @Resource
    private UserMapper userMapper;
}

// service
public interface UserService {
    UserDTO getById(Long id);
}

@Service
@Slf4j
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDAO userDAO;
    @Resource
    private UserConverter userConverter;

    @Override
    public UserDTO getById(Long id) {
        log.info("UserService getById id:{}", id);
        UserDO userDO = userDAO.getById(id);
        return userConverter.userDO2DTO(userDO);
    }
}

// controller
@RestController
@RequestMapping("/user")
public class UserController {
    @Resource
    private UserService userService;

    @GetMapping("/getUser")
    public JsonResult<UserDTO> getByUser() {
        UserDTO userDTO = userService.getById(1L);
        return JsonResult.buildSuccess(userDTO);
    }
 }

然后运行项目，postman测试：
在这里插入图片描述
至此springboot工程搭建好了。后面会基于该工程创建多个服务项目。

代码羊羊
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot全局异常处理GlobalExceptionHandler
weixin_33910460的博客
03-02 2万+
全局异常处理 自定义异常 在应用开发过程中，除系统自身的异常外，不同业务场景中用到的异常也不一样，为了与标题轻松搞定全局异常更加的贴切，定义个自己的异常，看看如何捕获… package com.baizhi.exception; public class CustomException extends RuntimeException { private static final ...
GlobalExceptionHandler 异常处理机制说明
Maoxim的博客
03-09 9509
GlobalExceptionHandler是一个程序中的异常处理机制，可以在应用程序中捕获和处理未被处理的异常。它是一个全局异常处理器，可以截取应用程序中的任何异常并执行特定的操作，例如记录异常、生成错误报告、通知开发人员或用户、回滚事务等。使用GlobalExceptionHandler，可以在应用程序的任何层次上捕获异常，包括控制器、服务、数据访问层等，而不需要在每个方法中都进行异常处理。它可以减少代码重复性，提高代码可读性和可维护性。
GlobalExceptionHandler全局异常处理器
UpjQ16的博客
01-22 3284
异常处理
Springboot整合 Spring Cloud Alibaba Sentinel
最新发布
Java_Scholar0的博客
05-10 365
Springboot整合 Spring Cloud Alibaba Sentinel
GlobalExceptionHandler全局异常处理器的设计
wddblog的博客
03-14 916
GlobalExceptionHandler是Java Web开发中一个重要的概念，它允许我们集中处理应用程序中的异常，并提供统一的错误响应。通过合理设计和实现GlobalExceptionHandler，我们可以简化异常处理逻辑、提高用户体验、增强系统稳定性。在实际开发中，我们应该根据项目的需求和特点来定制GlobalExceptionHandler的实现方式，以满足项目的特定要求。
第三章 SpringBoot系列GlobalException全局异常捕获
main方法
10-26 7919
文章目录前言一、需要用到的注解二、全局异常捕获代码实现1.创建GlobalExceptionHandler.java2.读入数据总结 前言 程序异常相信大家都不陌生，有可预知的，也有一些未知异常，通常我们会为异常做转义统一返回处理，从而能够更好的定位程序问题，由于过多的异常处理，我们代码中的try…catch就会很多，这样代码就会看起来很乱、不整洁、冗余，那么就会有人问，如果不这样写那么改怎么处理呢？不要慌，本章内容让你从try…catch中解救出来，咱往下看???? 提示：以下是本篇文章正文内容，下面
Spring Cloud alibaba项目搭建及配置详细步骤
10-17
在本教程中，我们将探讨如何搭建一个基于Spring Cloud Alibaba的项目并进行配置。主要关注的组件是Dubbo，它是阿里巴巴的一个高性能、轻量级的服务治理框架。 **一、环境准备** 1. **JDK**: 首先确保安装了Java 8或...
es(elasticsearch)整合SpringCloud（SpringBoot）搭建教程详解
08-19
在本教程中，我们将探讨如何将Elasticsearch与SpringBoot和SpringCloud进行集成，以便在微服务架构中利用Elasticsearch强大的搜索和分析能力。Elasticsearch是一个分布式、RESTful风格的搜索和数据分析引擎，而...
基于SpringCloud Alibaba+SpringBoot+MybatisPlus+ElasticSearch搭建的商城
06-27
基于SpringCloud Alibaba+SpringBoot+MybatisPlus+ElasticSearch搭建的商城项目; 系统对接了腾讯第三方：短信、图片等功能。只需要替换对应的key即可使用^_^
springCloud-alibaba简介学习讲义.pdf
10-03
* 快速搭建分布式应用系统：通过使用 Spring Cloud Alibaba，开发者可以快速搭建分布式应用系统，减少开发时间和成本。 * 简化微服务开发：Spring Cloud Alibaba 提供了一站式的微服务开发解决方案，简化了微服务...
华夏代驾资料（SpringBoot / SpringCloud Alibaba）
04-22
【标题】"华夏代驾资料（SpringBoot / SpringCloud Alibaba）"揭示了这是一个关于构建代驾服务系统的教程或参考资料，核心技术栈是Spring Boot和Spring Cloud Alibaba。Spring Boot是Java领域一个快速开发框架，用于...
druid-spring-boot-starter-1.2.8.jar
04-04
druid-spring-boot-starter-1.2.8.jar
druid-spring-boot-starter-1.2.8-javadoc.jar
04-04
druid-spring-boot-starter-1.2.8-javadoc.jar
springboot简单入门（四）：全局异常处理（GlobalExceptionHandler类）
weixin_46822085的博客
10-25 1613
通过一些步骤，虽然已经解决了事务问题，但界面上出现这500错误，这对用户来说还是不友好。 一般在企业里面对这些异常一般都会统一捕获，由一个专门的异常处理类来统一处理。 1、异常捕获 GlobalExceptionHandler 类 package cn.enjoy.utils; import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.bind.annotation..
SpringBoot中集成数据库连接池Druid
m0_37732829的博客
04-12 378
1、引入Pom依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1....
全局异常处理
Alan_ran的博客
03-17 2139
1、通过@controllerAdvice 注解，我们可以在一个地方对所有@controller注解的控制器进行管理 注解了@ControllerAdvice 的类的方法可以使用 @ExceptionHandler、@InitBinder、@ModelAttribute 注解到方法上,这对所有注解了@RequestMapping的控制器内的方法都有效 2、@ExceptionHandler：用于捕获所有控制器里面的异常,并进行处理 3、InitBinder: 用来设置 webDataBinder, w
SpringBoot中@ControllerAdvice的三种使用场景
qinxun2008081的博客
06-15 1296
SpringBoot中@ControllerAdvice的三种使用场景
SpringBoot 使用 Validation 进行参数校验并统一返回校验异常
m0_73311735的博客
05-16 2898
新建自定义注解java复制代码import com.jk.validator.StatusValidator;String message() default "状态传递有误";Class
全局异常处理器：优雅处理Java应用中的异常情况
weixin_41245021的博客
07-26 569
在Java应用开发中，异常处理是至关重要的一环。无论是在业务逻辑中还是在外部依赖调用中，异常都可能随时发生。然而，合理的异常处理不仅可以保障应用的稳定性，还能提供更好的用户体验和问题排查。在本篇博客中，我们将深入探讨全局异常处理器，这是一种强大的异常处理方案，用于优雅地处理Java应用中的异常情况。我们将学习如何实现一个全局异常处理器，捕获并处理应用中抛出的异常，使得应用在出现异常时能够有序地做出响应。通过统一处理异常信息，我们可以记录日志、向用户提供友好的错误信息，并保障应用的稳定性。
springboot cloud alibaba教程
07-28
您可以使用最新版的Spring Cloud Alibaba来搭建Spring Boot和Spring Cloud的开发环境。您可以使用组ID为com.alibaba.cloud和工件ID为spring-cloud-starter-alibaba-nacos-config的启动器来快速开始。您还可以使用组ID为com.alibaba.cloud和工件ID为spring-cloud-starter-alibaba-nacos-config的starter来使用Nacos来管理您的应用程序的外部化配置。\[1\]\[2\]\[3\] #### 引用[.reference_title] - *1* [springCloud Alibaba教程- 搭建springboot工程(最新版本)](https://blog.csdn.net/tdt008/article/details/127320691)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [Spring Cloud 阿里巴巴 Nacos 配置](https://blog.csdn.net/qq_15604349/article/details/122936550)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值