常见的http状态码 + ResponseEntity

常见的http状态码

@ResponseStatus(HttpStatus.CREATED) 是 Spring Framework 中的注解，用于指定 HTTP 响应状态码。

1. 基本说明

  • HttpStatus.CREATED 对应 HTTP 状态码 201
  • 表示请求成功且创建了新的资源
  • 通常用于 POST 请求的处理方法上

2. 使用场景和示例

基本使用
@RestController
@RequestMapping("/api/users")
public class UserController {

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)  // 将返回 201 状态码
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }
}
带有详细响应的使用
@RestController
@RequestMapping("/api/products")
public class ProductController {

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public ResponseEntity<Product> createProduct(@RequestBody Product product) {
        Product savedProduct = productService.save(product);
        
        // 创建资源的 URI
        URI location = ServletUriComponentsBuilder
            .fromCurrentRequest()
            .path("/{id}")
            .buildAndExpand(savedProduct.getId())
            .toUri();

        // 返回 201 状态码和资源位置
        return ResponseEntity
            .created(location)
            .body(savedProduct);
    }
}

3. 常用的 HTTP 状态码注解

// 成功相关
@ResponseStatus(HttpStatus.OK)           // 200 - 请求成功，返回资源或结果
@ResponseStatus(HttpStatus.CREATED)      // 201 - 资源创建成功
@ResponseStatus(HttpStatus.NO_CONTENT)   // 204 - 成功但无返回内容

// 客户端错误
@ResponseStatus(HttpStatus.BAD_REQUEST)         // 400 - 请求格式错误,客户端请求无效
@ResponseStatus(HttpStatus.UNAUTHORIZED)        // 401 - 未授权，需身份验证
@ResponseStatus(HttpStatus.FORBIDDEN)           // 403 - 禁止访问
@ResponseStatus(HttpStatus.NOT_FOUND)          // 404 - 资源未找到
@ResponseStatus(HttpStatus.CONFLICT)           // 409 - 资源冲突

// 服务器错误
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR) // 500 - 服务器内部错误

如果需要更灵活地设置响应内容（如返回自定义的响应体或头部信息），可以使用 ResponseEntity，而不是 @ResponseStatus

@ResponseStatus 是一种简洁的方式，用于指定固定的 HTTP 状态码，但它的功能相对有限。如果需要更灵活地设置响应内容（如自定义响应体、响应头、动态状态码等），可以使用 ResponseEntity。

1. 为什么选择 ResponseEntity？

ResponseEntity 是 Spring 提供的一个强大的工具，用于构建 HTTP 响应。它允许你：

  • 动态设置 HTTP 状态码
  • 自定义响应头
  • 返回复杂的响应体
  • 更灵活地处理不同的场景

2. ResponseEntity 的基本用法

示例 1: 返回自定义状态码和响应体
@PostMapping("/users")
public ResponseEntity<String> createUser(@RequestBody UserRequest userRequest) {
    userService.createUser(userRequest);
    return ResponseEntity.status(HttpStatus.CREATED).body("User created successfully");
}
  • ResponseEntity.status(HttpStatus.CREATED)：设置 HTTP 状态码为 201 Created。
  • .body("User created successfully")：设置响应体为自定义的字符串。
示例 2: 返回带有响应头的信息
@PostMapping("/users")
public ResponseEntity<String> createUser(@RequestBody UserRequest userRequest) {
    userService.createUser(userRequest);

    // 设置自定义响应头
    HttpHeaders headers = new HttpHeaders();
    headers.add("Custom-Header", "CustomHeaderValue");

    return ResponseEntity.status(HttpStatus.CREATED)
                         .headers(headers)
                         .body("User created successfully");
}
  • HttpHeaders：用于设置响应头。
  • .headers(headers)：将自定义的响应头添加到响应中。
示例 3: 返回带有资源位置的响应

在 RESTful API 中，创建资源后通常会返回 Location 头，指向新创建资源的 URI。

@PostMapping("/users")
public ResponseEntity<Void> createUser(@RequestBody UserRequest userRequest) {
    Long userId = userService.createUser(userRequest);

    // 构造资源的 URI
    URI location = ServletUriComponentsBuilder
        .fromCurrentRequest()
        .path("/{id}")
        .buildAndExpand(userId)
        .toUri();

    // 返回 201 Created 和 Location 头
    return ResponseEntity.created(location).build();
}
  • ServletUriComponentsBuilder：用于动态构建资源的 URI。
  • .created(location)：设置状态码为 201 Created，并添加 Location 头。
示例 4: 动态返回不同的状态码
@PostMapping("/users")
public ResponseEntity<String> createUser(@RequestBody UserRequest userRequest) {
    if (userService.isDuplicate(userRequest)) {
        return ResponseEntity.status(HttpStatus.CONFLICT).body("User already exists");
    }

    userService.createUser(userRequest);
    return ResponseEntity.status(HttpStatus.CREATED).body("User created successfully");
}
  • 如果用户已存在，返回 409 Conflict。
  • 如果创建成功，返回 201 Created。

3. 与 @ResponseStatus 的对比

特性@ResponseStatusResponseEntity
设置状态码固定状态码，不能动态设置可以动态设置状态码
自定义响应体不支持支持返回任意类型的响应体
自定义响应头不支持支持通过 HttpHeaders 设置响应头
适用场景简单场景，状态码固定复杂场景，需要动态响应
代码简洁性更简洁代码稍显冗长

4. 综合示例：结合异常处理

自定义异常类
@ResponseStatus(HttpStatus.NOT_FOUND) // 默认返回 404
public class UserNotFoundException extends RuntimeException {
    public UserNotFoundException(String message) {
        super(message);
    }
}
使用 ResponseEntity 处理异常
@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.findById(id)
            .orElseThrow(() -> new UserNotFoundException("User not found with id: " + id));

        return ResponseEntity.ok(user); // 返回 200 和用户信息
    }

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFound(UserNotFoundException ex) {
        ErrorResponse errorResponse = new ErrorResponse("USER_NOT_FOUND", ex.getMessage());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
    }
}
  • @ExceptionHandler：捕获异常并返回自定义的响应。
  • ErrorResponse：自定义的错误响应体。

5. 总结

  • @ResponseStatus：适合简单场景，状态码固定，代码简洁。
  • ResponseEntity：适合复杂场景，允许动态设置状态码、响应头和响应体。

如果你的需求需要动态响应内容（如返回资源位置、错误信息、或自定义头部信息），ResponseEntity 是更灵活的选择。通过使用 ResponseEntity，我们可以更精确地控制 HTTP 响应的各个方面，使 API 更加灵活和专业。这对于构建复杂的 RESTful API 特别有用，因为它允许我们根据不同的业务场景返回不同的响应。

@RestController/@ResponseBody + ResponseEntity

使用 @RestController 或 @ResponseBody 返回对象时，Spring 会自动将返回的对象序列化为 JSON 并写入响应体，@RestController 或 @ResponseBody 返回的对象会自动设置状态码为 200 OK。 缺点：无法直接设置响应头或动态状态码。使用 @RestController 或 @ResponseBody 返回对象 如果需要返回特定的 HTTP 状态码，可以结合 ResponseEntity 使用。

使用 @RestController 或 @ResponseBody 直接返回对象时的主要缺点是无法直接设置响应头或动态状态码。以下是这些限制的详细说明和解决方案：

1. 基本限制示例

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    // 直接返回对象的方式
    @GetMapping("/{id}")
    @ResponseBody
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);  // 只能返回 200 OK
    }
    
    // 无法直接设置响应头
    @PostMapping
    @ResponseBody
    public User createUser(@RequestBody User user) {
        return userService.save(user);  // 应该返回 201 Created，但只能是 200 OK
    }
}

2. 主要限制

  1. 状态码限制：

    • 默认总是返回 200 OK
    • 无法动态设置状态码
    • 无法返回创建成功（201）等特定状态码

  2. 响应头限制：

    • 无法添加自定义响应头
    • 无法设置 Content-Disposition 等特殊头部
    • 无法控制缓存相关头部

  3. 错误处理限制：

    • 无法直接返回错误状态码
    • 需要依赖全局异常处理

3. 解决方案

方案一：使用 ResponseEntity
@RestController
@RequestMapping("/api/users")
public class UserController {

    // 使用 ResponseEntity 返回特定状态码
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User savedUser = userService.save(user);
        return ResponseEntity
            .status(HttpStatus.CREATED)
            .body(savedUser);
    }

    // 设置自定义响应头
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        return userService.findById(id)
            .map(user -> ResponseEntity.ok()
                .header("X-Custom-Header", "value")
                .body(user))
            .orElse(ResponseEntity.notFound().build());
    }
}
方案二：使用 HttpServletResponse
@RestController
@RequestMapping("/api/users")
public class UserController {

    // 注入 HttpServletResponse
    @PostMapping("/manual")
    @ResponseBody
    public User createUserManual(
            @RequestBody User user,
            HttpServletResponse response) {
        User savedUser = userService.save(user);
        response.setStatus(HttpServletResponse.SC_CREATED);
        response.setHeader("X-Custom-Header", "value");
        return savedUser;
    }
}
方案三：使用统一响应包装类
// 统一响应包装类
public class ApiResponse<T> {
    private int code;
    private String message;
    private T data;
    private Map<String, String> headers = new HashMap<>();

    // 构造方法和静态工厂方法
    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(200, "Success", data);
    }

    public static <T> ApiResponse<T> created(T data) {
        return new ApiResponse<>(201, "Created", data);
    }
}

// 使用响应包装类的控制器
@RestController
@RequestMapping("/api/users")
public class UserController {

    @PostMapping
    public ApiResponse<User> createUser(@RequestBody User user) {
        User savedUser = userService.save(user);
        return ApiResponse.created(savedUser);
    }
}

// 响应拦截器
@Component
public class ApiResponseInterceptor implements ResponseBodyAdvice<ApiResponse<?>> {

    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return ApiResponse.class.isAssignableFrom(returnType.getParameterType());
    }

    @Override
    public ApiResponse<?> beforeBodyWrite(ApiResponse<?> body, 
            MethodParameter returnType,
            MediaType selectedContentType,
            Class<? extends HttpMessageConverter<?>> selectedConverterType,
            ServerHttpRequest request,
            ServerHttpResponse response) {
        
        if (body != null) {
            response.setStatusCode(HttpStatus.valueOf(body.getCode()));
            body.getHeaders().forEach((key, value) -> 
                response.getHeaders().add(key, value));
        }
        return body;
    }
}
方案四：使用 AOP 拦截
@Aspect
@Component
public class ResponseHeaderAspect {

    @Around("@annotation(responseHeaders)")
    public Object addResponseHeaders(ProceedingJoinPoint joinPoint, 
            ResponseHeaders responseHeaders) throws Throwable {
        Object result = joinPoint.proceed();
        HttpServletResponse response = 
            ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes())
                .getResponse();

        if (response != null) {
            for (Header header : responseHeaders.value()) {
                response.setHeader(header.name(), header.value());
            }
        }
        return result;
    }
}

// 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ResponseHeaders {
    Header[] value();
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Header {
    String name();
    String value();
}

// 使用示例
@RestController
@RequestMapping("/api/users")
public class UserController {

    @PostMapping
    @ResponseHeaders({
        @Header(name = "X-Custom-Header", value = "value"),
        @Header(name = "X-Created-By", value = "system")
    })
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
}
方案五：使用过滤器
@Component
public class ResponseModifierFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, 
            ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        ContentCachingResponseWrapper responseWrapper = 
            new ContentCachingResponseWrapper(httpResponse);

        chain.doFilter(request, responseWrapper);

        // 修改响应
        if (isUserCreationEndpoint(request)) {
            responseWrapper.setStatus(HttpServletResponse.SC_CREATED);
            responseWrapper.setHeader("X-Custom-Header", "value");
        }

        responseWrapper.copyBodyToResponse();
    }
}
特性@RestController / @ResponseBodyResponseEntityHttpServletResponse
默认状态码固定为 200 OK可动态设置可动态设置
自定义响应头不支持支持支持
动态状态码不支持支持支持
代码复杂性简单中等较高
推荐场景简单的 RESTful API需要动态状态码或自定义头部的场景特殊场景（如文件流、低级操作）

详细解释如何使用 @RestController 或 @ResponseBody 结合 ResponseEntity 来返回对象和特定的 HTTP 状态码。

1. 基本用法

@RestController
@RequestMapping("/api/users")
public class UserController {

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User savedUser = userService.save(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(savedUser);
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        return userService.findById(id)
            .map(ResponseEntity::ok)  // 返回 200 OK
            .orElse(ResponseEntity.notFound().build());  // 返回 404 Not Found
    }
}

2. 统一响应格式

// 统一响应格式
public class ApiResponse<T> {
    private int code;           // 状态码
    private String message;     // 消息
    private T data;            // 数据
    private LocalDateTime timestamp = LocalDateTime.now();  // 时间戳

    // 成功静态方法
    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(200, "Success", data);
    }

    // 错误静态方法
    public static <T> ApiResponse<T> error(int code, String message) {
        return new ApiResponse<>(code, message, null);
    }

    // 构造方法、getter和setter
}

3. CRUD 操作示例

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    // 构造注入
    public UserController(UserService userService) {
        this.userService = userService;
    }

    // 创建用户
    @PostMapping
    public ResponseEntity<ApiResponse<User>> createUser(@RequestBody @Valid User user) {
        User savedUser = userService.save(user);
        return ResponseEntity
            .status(HttpStatus.CREATED)
            .body(ApiResponse.success(savedUser));
    }

    // 获取用户
    @GetMapping("/{id}")
    public ResponseEntity<ApiResponse<User>> getUser(@PathVariable Long id) {
        return userService.findById(id)
            .map(user -> ResponseEntity.ok(ApiResponse.success(user)))
            .orElse(ResponseEntity
                .status(HttpStatus.NOT_FOUND)
                .body(ApiResponse.error(404, "User not found")));
    }

    // 更新用户
    @PutMapping("/{id}")
    public ResponseEntity<ApiResponse<User>> updateUser(
            @PathVariable Long id, 
            @RequestBody @Valid User user) {
        return userService.findById(id)
            .map(existingUser -> {
                User updatedUser = userService.update(id, user);
                return ResponseEntity.ok(ApiResponse.success(updatedUser));
            })
            .orElse(ResponseEntity
                .status(HttpStatus.NOT_FOUND)
                .body(ApiResponse.error(404, "User not found")));
    }

    // 删除用户
    @DeleteMapping("/{id}")
    public ResponseEntity<ApiResponse<Void>> deleteUser(@PathVariable Long id) {
        if (userService.existsById(id)) {
            userService.deleteById(id);
            return ResponseEntity.ok(ApiResponse.success(null));
        }
        return ResponseEntity
            .status(HttpStatus.NOT_FOUND)
            .body(ApiResponse.error(404, "User not found"));
    }

    // 获取用户列表（分页）
    @GetMapping
    public ResponseEntity<ApiResponse<Page<User>>> getUsers(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size) {
        Page<User> users = userService.findAll(PageRequest.of(page, size));
        return ResponseEntity.ok(ApiResponse.success(users));
    }
}

4. 异常处理

@RestControllerAdvice
public class GlobalExceptionHandler {

    // 处理验证错误
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ApiResponse<Map<String, String>>> handleValidationErrors(
            MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getFieldErrors().forEach(error -> 
            errors.put(error.getField(), error.getDefaultMessage())
        );
        
        return ResponseEntity
            .status(HttpStatus.BAD_REQUEST)
            .body(ApiResponse.error(400, "Validation failed", errors));
    }

    // 处理业务逻辑异常
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ApiResponse<Void>> handleBusinessException(BusinessException ex) {
        return ResponseEntity
            .status(ex.getStatus())
            .body(ApiResponse.error(ex.getStatus().value(), ex.getMessage()));
    }

    // 处理其他未知异常
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ApiResponse<Void>> handleUnknownException(Exception ex) {
        return ResponseEntity
            .status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(ApiResponse.error(500, "Internal server error"));
    }
}

5. 自定义业务异常

public class BusinessException extends RuntimeException {
    private final HttpStatus status;

    public BusinessException(String message, HttpStatus status) {
        super(message);
        this.status = status;
    }

    public HttpStatus getStatus() {
        return status;
    }
}

6. 带条件的响应示例

@RestController
@RequestMapping("/api/orders")
public class OrderController {

    // 创建订单
    @PostMapping
    public ResponseEntity<ApiResponse<Order>> createOrder(@RequestBody @Valid OrderRequest request) {
        // 检查库存
        if (!inventoryService.checkStock(request)) {
            return ResponseEntity
                .status(HttpStatus.CONFLICT)
                .body(ApiResponse.error(409, "Insufficient stock"));
        }

        // 检查用户信用
        if (!userService.checkCredit(request.getUserId())) {
            return ResponseEntity
                .status(HttpStatus.PAYMENT_REQUIRED)
                .body(ApiResponse.error(402, "Insufficient credit"));
        }

        // 创建订单
        Order order = orderService.createOrder(request);

        // 如果是加急订单，添加特殊响应头
        if (request.isUrgent()) {
            return ResponseEntity
                .status(HttpStatus.CREATED)
                .header("X-Priority", "High")
                .body(ApiResponse.success(order));
        }

        return ResponseEntity
            .status(HttpStatus.CREATED)
            .body(ApiResponse.success(order));
    }
}

7. 文件上传响应示例

@RestController
@RequestMapping("/api/files")
public class FileController {

    @PostMapping("/upload")
    public ResponseEntity<ApiResponse<FileInfo>> uploadFile(
            @RequestParam("file") MultipartFile file) {
        try {
            FileInfo savedFile = fileService.store(file);
            
            return ResponseEntity
                .status(HttpStatus.CREATED)
                .header("Location", "/api/files/" + savedFile.getId())
                .body(ApiResponse.success(savedFile));
        } catch (IOException e) {
            return ResponseEntity
                .status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(ApiResponse.error(500, "Failed to upload file"));
        }
    }

    @GetMapping("/download/{id}")
    public ResponseEntity<Resource> downloadFile(@PathVariable String id) {
        Resource file = fileService.loadAsResource(id);
        
        return ResponseEntity.ok()
            .header(HttpHeaders.CONTENT_DISPOSITION, 
                "attachment; filename=\"" + file.getFilename() + "\"")
            .body(file);
    }
}

8. 返回流式数据

如果需要返回流式数据（如文件下载），可以结合 ResponseEntity 和 InputStreamResource。

示例：返回文件下载
@RestController  
@RequestMapping("/files")  
public class FileController {  

    @GetMapping("/download/{filename}")  
    public ResponseEntity<InputStreamResource> downloadFile(@PathVariable String filename) throws IOException {  
        File file = fileService.getFile(filename);  

        InputStreamResource resource = new InputStreamResource(new FileInputStream(file));  

        return ResponseEntity.ok()  
            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + file.getName())  
            .contentLength(file.length())  
            .contentType(MediaType.APPLICATION_OCTET_STREAM)  
            .body(resource);  
    }  
}

  • 响应：

    • 状态码：200 OK

    • 响应头：

      Content-Disposition: attachment; filename=myfile.txt

    • 响应体：文件内容

9. 使用建议

  1. 统一响应格式：

    • 使用统一的响应封装类（如 ApiResponse）
    • 包含必要的状态码、消息和数据字段
    • 添加时间戳便于调试和日志追踪

  2. 适当的状态码：

    • 200: 成功获取资源
    • 201: 成功创建资源
    • 204: 成功处理但无返回内容
    • 400: 请求参数错误
    • 401: 未认证
    • 403: 无权限
    • 404: 资源不存在
    • 409: 资源冲突
    • 500: 服务器错误

  3. 异常处理：

    • 使用全局异常处理器统一处理异常
    • 区分业务异常和系统异常
    • 提供清晰的错误信息

  4. 响应头设置：

    • 根据需要设置自定义响应头
    • 文件操作时设置适当的 Content-Type 和 Content-Disposition

  5. 验证处理：

    • 使用 @Valid 注解进行请求验证
    • 提供详细的验证错误信息

通过这种方式，可以构建出统一、规范的 API 响应，便于客户端处理和调试。

10. 最佳实践建议

  • 优先使用 @RestController 或 @ResponseBody：
    • 如果不需要动态设置状态码或响应头，直接返回对象即可，简单高效。
  • 使用 ResponseEntity 解决局限性：
    • 当需要动态设置状态码或自定义响应头时，推荐使用 ResponseEntity，它是 Spring 提供的标准解决方案，代码优雅且易于维护。
  • 仅在特殊场景下使用 HttpServletResponse：
    • 如果需要直接操作底层响应流（如文件下载、流式数据），可以使用 HttpServletResponse。

  1. 优先使用 ResponseEntity：

    • 最清晰和直接的解决方案
    • 提供完整的响应控制
    • 类型安全且易于维护

  2. 统一响应格式：

    • 定义统一的响应包装类
    • 使用响应拦截器统一处理
    • 便于维护和扩展

  3. 分层处理：

    • 控制器层：业务逻辑和基本响应
    • 拦截器层：通用响应头和状态码
    • 过滤器层：全局响应修改

  4. 异常处理：

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ApiResponse<String>> handleException(Exception ex) {
        ApiResponse<String> response = ApiResponse.error(
            500, 
            "Internal Server Error",
            ex.getMessage()
        );
        
        return ResponseEntity
            .status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(response);
    }
}
  1. 文档和注释：
/**
 * 用户控制器
 * 注意：直接返回对象时无法设置状态码和响应头
 * 建议使用 ResponseEntity 或其他替代方案
 */
@RestController
@RequestMapping("/api/users")
public class UserController {
    // 控制器方法...
}

通过以上方案，可以克服 @RestController 和 @ResponseBody 的限制，实现更灵活的响应控制。选择合适的方案取决于具体需求和项目架构。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/951165.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【ROS2】☆ launch之Python

【ROS2】☆ launch之Python

☆重点 ROS1和ROS2其中一个很大区别之一就是launch的编写方式。在ROS1中采用xml格式编写launch&#xff0c;而ROS2保留了XML 格式launch&#xff0c;还另外引入了Python和YAML 编写方式。选择哪种编写取决于每位开发人员的爱好&#xff0c;但是ROS2官方推荐使用Python方式编写…
阅读更多...
Shell编程详解

Shell编程详解

文章目录 一、Linux系统结构二、Shell介绍1、Shell简介2、Shell种类3、Shell查询和切换 三、Shell基础语法1、注释2、本地变量3、环境变量3.1、查看环境变量3.2、临时设置环境变量3.3、永久设置环境变量 4、特殊变量5、控制语句5.1、shell中的中括号5.2、if语句5.3、for循环5.4…
阅读更多...
Zemax 序列模式下的扩束器

Zemax 序列模式下的扩束器

扩束器结构原理 扩束器用于增加准直光束&#xff08;例如激光束&#xff09;的直径&#xff0c;同时保持其准直。它通常用于激光光学和其他需要修改光束大小或发散度的应用。 在典型的扩束器中&#xff0c;输入光束是准直激光器&#xff0c;或光束进入第一个光学元件。当光束开…
阅读更多...
react-quill 富文本组件编写和应用

react-quill 富文本组件编写和应用

index.tsx文件 import React, { useRef, useState } from react; import { Modal, Button } from antd; import RichEditor from ./RichEditor;const AnchorTouchHistory: React.FC () > {const editorRef useRef<any>(null);const [isModalVisible, setIsModalVis…
阅读更多...
【深度学习】多目标融合算法（二）：底部共享多任务模型（Shared-Bottom Multi-task Model）

【深度学习】多目标融合算法（二）：底部共享多任务模型（Shared-Bottom Multi-task Model）

目录 一、引言 1.1 往期回顾 1.2 本期概要 二、Shared-Bottom Multi-task Model&#xff08;SBMM&#xff09; 2.1 技术原理 2.2 技术优缺点 2.3 业务代码实践 三、总结 一、引言 在朴素的深度学习ctr预估模型中&#xff08;如DNN&#xff09;&#xff0c;通常以一个行…
阅读更多...
探秘MetaGPT：革新软件开发的多智能体框架（22/30）

探秘MetaGPT：革新软件开发的多智能体框架（22/30）

一、MetaGPT 引发的 AI 变革浪潮 近年来&#xff0c;人工智能大模型领域取得了令人瞩目的进展&#xff0c;GPT-3、GPT-4、PaLM 等模型展现出了惊人的自然语言处理能力&#xff0c;仿佛为 AI 世界打开了一扇通往无限可能的大门。它们能够生成流畅的文本、回答复杂的问题、进行创…
阅读更多...
LabVIEW软件Bug的定义与修改

LabVIEW软件Bug的定义与修改

在LabVIEW软件开发过程中&#xff0c;bug&#xff08;程序错误或缺陷&#xff09;指的是程序中导致不符合预期行为的任何问题。Bug可能是由于编码错误、逻辑漏洞、硬件兼容性问题、系统资源限制等因素引起的。它可能会导致程序崩溃、功能无法正常执行或输出结果不符合预期。理解…
阅读更多...
高性能网络模式：Reactor 和 Proactor

高性能网络模式：Reactor 和 Proactor

Reactor Reactor 采用I/O多路复用监听事件&#xff0c;收到事件后&#xff0c;根据事件类型分配给某个进程/线程。 实际应用中用到的模型&#xff1a; 单 Reactor 单进程 单 Reactor 多线程 优点&#xff1a;能充分利用多核CPU性能。 缺点&#xff1a;存在多线程竞争共享资源…
阅读更多...
扩散模型论文概述（三）：Stability AI系列工作【学习笔记】

扩散模型论文概述（三）：Stability AI系列工作【学习笔记】

视频链接&#xff1a;扩散模型论文概述&#xff08;三&#xff09;&#xff1a;Stability AI系列工作_哔哩哔哩_bilibili 本期视频讲的是Stability AI在图像生成的工作。 同样&#xff0c;第一张图片是神作&#xff0c;总结的太好了&#xff01; 介绍Stable Diffusion之前&…
阅读更多...
大数据技术-Hadoop（四）Yarn的介绍与使用

大数据技术-Hadoop（四）Yarn的介绍与使用

目录 一、Yarn 基本结构 1、Yarn基本结构 2、Yarn的工作机制 二、Yarn常用的命令 三、调度器 1、Capacity Scheduler&#xff08;容量调度器&#xff09; 1.1、特点 1.2、配置 1.2.1、yarn-site.xml 1.2.2、capacity-scheduler.xml 1.3、重启yarn、刷新队列 测试 向hi…
阅读更多...
玩转大语言模型——ollama导入huggingface下载的模型

玩转大语言模型——ollama导入huggingface下载的模型

ollama导入huggingface模型 前言gguf模型查找相关模型下载模型 导入Ollama配置参数文件导入模型查看导入情况 safetensfors模型下载模型下载llama.cpp配置环境并转换 前言 ollama在大语言模型的应用中十分的方便&#xff0c;但是也存在一定的问题&#xff0c;比如不能使用自己…
阅读更多...
apollo内置eureka dashboard授权登录

apollo内置eureka dashboard授权登录

要确保访问Eureka Server时要求输入账户和密码&#xff0c;需要确保以下几点&#xff1a; 确保 eurekaSecurityEnabled 配置为 true&#xff1a;这个配置项控制是否启用Eureka的安全认证。如果它被设置为 false&#xff0c;即使配置了用户名和密码&#xff0c;也不会启用安全认…
阅读更多...
【Dify】Dify自定义模型设置 | 对接DMXAPI使用打折 Openai GPT 或 Claude3.5系列模型方法详解

【Dify】Dify自定义模型设置 | 对接DMXAPI使用打折 Openai GPT 或 Claude3.5系列模型方法详解

一、Dify & DMXAPI 1、Dify DIFY&#xff08;Do It For You&#xff09;是一种自动化工具或服务&#xff0c;旨在帮助用户简化操作&#xff0c;减少繁琐的手动操作&#xff0c;提升工作效率。通过DIFY&#xff0c;用户能够快速完成任务、获取所需数据&#xff0c;并且可以…
阅读更多...
【深度学习】布匹寻边：抓边误差小于3px【附完整链接】

【深度学习】布匹寻边：抓边误差小于3px【附完整链接】

布匹寻边 项目简介 布匹寻边是指布料裁剪过程中&#xff0c;通过AI寻边技术自动识别布匹的边缘&#xff0c;将检测到的边缘信息输出&#xff0c;确保裁剪的准确性&#xff0c;减少浪费&#xff0c;并提高生产效率。 项目需求 将打满针眼的布匹边缘裁剪掉&#xff0c;且误差小…
阅读更多...
http range 下载大文件分片

http range 下载大文件分片

摘自&#xff1a;https://www.jianshu.com/p/32c16103715a 上传分片下载也能分 HTTP 协议范围请求允许服务器只发送 HTTP 消息的一部分到客户端。范围请求在传送大的媒体文件&#xff0c;或者与文件下载的断点续传功能搭配使用时非常有用。 检测服务器端是否支持范围请求 假…
阅读更多...
解决WordPress出现Fatal error: Uncaught TypeError: ftp_nlist()致命问题

解决WordPress出现Fatal error: Uncaught TypeError: ftp_nlist()致命问题

错误背景 WordPress版本&#xff1a;wordpress-6.6.2-zh_CN WooCommerce版本&#xff1a;woocommerce.9.5.1 WordPress在安装了WooCommerce插件后&#xff0c;安装的过程中没有问题&#xff0c;在安装完成后提示&#xff1a; 此站点遇到了致命错误&#xff0c;请查看您站点管理…
阅读更多...
用户使用LLM模型都在干什么？

用户使用LLM模型都在干什么？

Anthropic 对用户与 Claude 3.5 Sonnet 的大量匿名对话展开分析&#xff0c;主要发现及相关情况如下&#xff1a; 使用用途分布 软件开发主导&#xff1a;在各类使用场景中&#xff0c;软件开发占比最高&#xff0c;其中编码占 Claude 对话的 15% - 25%&#xff0c;网页和移动应…
阅读更多...
【巨实用】Git客户端基本操作

【巨实用】Git客户端基本操作

本文主要分享Git的一些基本常规操作&#xff0c;手把手教你如何配置~ ● 一个文件夹中初始化Git git init ● 为了方便以后提交代码需要对git进行配置&#xff08;第一次使用或者需求变更的时候&#xff09;&#xff0c;告诉git未来是谁在提交代码 git config --global user.na…
阅读更多...
腾讯云AI代码助手编程挑战赛：自动生成漂亮的网页

腾讯云AI代码助手编程挑战赛：自动生成漂亮的网页

在当今数字化时代&#xff0c;网页设计和开发已经成为一项至关重要的技能。在当今时代&#xff0c;借助AI的力量&#xff0c;这部分工作变得简单。本文借助腾讯云AI代码助手——“自动生成需要的网页”。本文将详细介绍如何利用AI代码助手生成网页素材&#xff0c;帮助你轻松打…
阅读更多...
多台PC共用同一套鼠标键盘

多台PC共用同一套鼠标键盘

当环境中有多个桌面 pc 需要操作的时候&#xff0c;在 多台 pc 之间切换会造成很多的不方便 可以通过远程进行连接&#xff0c;但是有一个更好的方案是让多台机器之间共用同一套键盘鼠标 常用的解决方案 synergy 和 sharemouse&#xff0c;通过移动光标在不同的 pc 间切换 s…
阅读更多...
最新文章

Copyright @ 2022~2023