dubbo处理自定义异常

news2024/10/6 14:32:54

dubbo处理自定义异常

背景

在实际项目中，我们不可避免地需要使用自定义的异常，一般这个异常会继承RuntimeException，然后我们通过@RestControllerAdvice注解，拦截业务异常类，做一些处理，但是在使用dubbo构建项目时，会发现provider抛出自定义异常，然后在消费者端，不会捕捉到我们的自定义异常，而是以RuntimeException的形式被捕获。

原因

dubbo的异常处理类是org.apache.dubbo.rpc.filter.ExceptionFilter类，在这个类中，我们查看它的源码如下：

// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.apache.dubbo.rpc.filter;

import java.lang.reflect.Method;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.common.logger.Logger;
import org.apache.dubbo.common.logger.LoggerFactory;
import org.apache.dubbo.common.utils.ReflectUtils;
import org.apache.dubbo.common.utils.StringUtils;
import org.apache.dubbo.rpc.Filter;
import org.apache.dubbo.rpc.Invocation;
import org.apache.dubbo.rpc.Invoker;
import org.apache.dubbo.rpc.Result;
import org.apache.dubbo.rpc.RpcContext;
import org.apache.dubbo.rpc.RpcException;
import org.apache.dubbo.rpc.BaseFilter.Listener;
import org.apache.dubbo.rpc.service.GenericService;

@Activate(
    group = {"provider"}
)
public class ExceptionFilter implements Filter, Listener {
    private Logger logger = LoggerFactory.getLogger(ExceptionFilter.class);

    public ExceptionFilter() {
    }

    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        return invoker.invoke(invocation);
    }

    public void onResponse(Result appResponse, Invoker<?> invoker, Invocation invocation) {
        if (appResponse.hasException() && GenericService.class != invoker.getInterface()) {
            try {
                Throwable exception = appResponse.getException();
                if (!(exception instanceof RuntimeException) && exception instanceof Exception) {
                    return;
                }

                try {
                    Method method = invoker.getInterface().getMethod(invocation.getMethodName(), invocation.getParameterTypes());
                    Class<?>[] exceptionClasses = method.getExceptionTypes();
                    Class[] var7 = exceptionClasses;
                    int var8 = exceptionClasses.length;

                    for(int var9 = 0; var9 < var8; ++var9) {
                        Class<?> exceptionClass = var7[var9];
                        if (exception.getClass().equals(exceptionClass)) {
                            return;
                        }
                    }
                } catch (NoSuchMethodException var11) {
                    return;
                }

                this.logger.error("Got unchecked and undeclared exception which called by " + RpcContext.getServiceContext().getRemoteHost() + ". service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName() + ", exception: " + exception.getClass().getName() + ": " + exception.getMessage(), exception);
                String serviceFile = ReflectUtils.getCodeBase(invoker.getInterface());
                String exceptionFile = ReflectUtils.getCodeBase(exception.getClass());
                if (serviceFile != null && exceptionFile != null && !serviceFile.equals(exceptionFile)) {
                    String className = exception.getClass().getName();
                    if (!className.startsWith("java.") && !className.startsWith("javax.")) {
                        if (exception instanceof RpcException) {
                            return;
                        }

                        appResponse.setException(new RuntimeException(StringUtils.toString(exception)));
                        return;
                    }

                    return;
                }

                return;
            } catch (Throwable var12) {
                this.logger.warn("Fail to ExceptionFilter when called by " + RpcContext.getServiceContext().getRemoteHost() + ". service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName() + ", exception: " + var12.getClass().getName() + ": " + var12.getMessage(), var12);
            }
        }

    }

    public void onError(Throwable e, Invoker<?> invoker, Invocation invocation) {
        this.logger.error("Got unchecked and undeclared exception which called by " + RpcContext.getServiceContext().getRemoteHost() + ". service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName() + ", exception: " + e.getClass().getName() + ": " + e.getMessage(), e);
    }

    public void setLogger(Logger logger) {
        this.logger = logger;
    }
}

从上面的源码中，我们可以知道：

1. 如果provider实现了GenericService接口，直接抛出异常
2. 如果是checked异常，直接抛出
3. 在方法签名上有声明，直接抛出
4. 异常类和接口类在同一个jar包，直接抛出
5. 是JDK自带的异常，直接抛出
6. 是dubbo本身的异常，直接抛出
7. 否则，保证为RuntimeException抛出

针对上述内容，我们抛出自定义异常的实现方案有：

1)provider实现GenericService接口.(我没试过这种方式,应该是要自己实现i n v o k e ( ) 方法 , 网上说直接把 invoke()方法,网上说直接把invoke()方法,网上说直接把invoke()方法废弃掉不知道是怎么处理的,直接返回null肯定是不行的)

2)自定义异常声明为checked异常(这没啥说了,不过一般自定义异常都是unchecked)

3)在方法签名上声明抛出异常(这种基本上所有接口都要写,麻烦)

4)异常类和接口类在同一jar包里(存在链式调用时,这种可能不适用)

5)自定义异常的包名以java.或javax.开头(dubbo判断jdk自带异常的条件,一般项目都有自己的命名规范,这样干的估计很少)

6) 将dubbo源码中的ExceptionFilter复制到我们的项目名并该名为DubboExceptionFiler，然后修改源代码，遇到我们自定义的异常后，直接返回

下面我们通过演示项目，来介绍第4和第6种方法。

演示代码

创建一个maven项目，假设名为：rpcException01，pom.xml如下：

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>rpcException01</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
 

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <dubbo.version>3.0.2.1</dubbo.version>
        <spring-dubbo.version>2.0.0</spring-dubbo.version>
        <spring-boot-dependencies.version>2.7.0</spring-boot-dependencies.version>
        <lombok.version>1.18.22</lombok.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot-dependencies.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-bom</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-spring-boot-starter</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <scope>compile</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

在该项目下，创建一个子模块，假设名为rpc-common，用于存储我们的一些返回结果类
pom.xml

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>rpcException01</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>rpc-common</artifactId>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

</project>

ResultCode.java，返回状态码枚举类

package com.young.common.enums;


import java.io.Serializable;

public enum ResultCode{
    SUCCESS(200,"操作成功"),
    FAIL(400,"操作失败"),
    ERROR(500,"服务器错误");
    private Integer code;
    private String msg;
    private ResultCode(Integer code,String msg){
        this.code=code;
        this.msg=msg;
    }
    public Integer getCode(){
        return this.code;
    }
    public String getMsg(){
        return this.msg;
    }
}

ResultVO.java，返回结果类

package com.young.common.vo;

import com.young.common.enums.ResultCode;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class ResultVO <T> implements Serializable {
    private Integer code;
    private String msg;
    private T data;
    public ResultVO(ResultCode resultCode){
        this.code=resultCode.getCode();
        this.msg=resultCode.getMsg();
    }
    public ResultVO(ResultCode resultCode,T data){
        this.code=resultCode.getCode();
        this.msg=resultCode.getMsg();
        this.data=data;
    }
    public ResultVO(Integer code,String msg){
        this.code=code;
        this.msg=msg;
        this.data=null;
    }
}

ResultVOUtil.java，返回结果工具类

package com.young.common.util;

import com.young.common.enums.ResultCode;
import com.young.common.vo.ResultVO;

public class ResultVOUtil<T> {
    public static <T> ResultVO<T> success(){
        return new ResultVO<T>(ResultCode.SUCCESS);
    }
    public static <T> ResultVO<T> success(T data){
        return new ResultVO<T>(ResultCode.SUCCESS,data);
    }
    public static <T> ResultVO<T> fail(){
        return new ResultVO<T>(ResultCode.FAIL);
    }
    public static <T> ResultVO<T> fail(ResultCode resultCode){
        return new ResultVO<T>(resultCode);
    }
    public static <T> ResultVO<T> error(){
        return new ResultVO<T>(ResultCode.ERROR);
    }
}

BusinessException.java，自定义异常类

package com.young.common.err;

import com.young.common.enums.ResultCode;

public class BusinessException extends RuntimeException{
    private ResultCode resultCode;
    public BusinessException(){}
    public BusinessException(ResultCode resultCode){
        super(resultCode.getMsg());
        this.resultCode=resultCode;
    }
    public ResultCode getResultCode(){
        return this.resultCode;
    }
}

再创建一个模块，假设名为dubbo-api，用于定义接口
pom.xml

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>rpcException01</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>rpc-api</artifactId>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>rpc-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

TestService.java，测试接口类

package com.young.api.service;

public interface TestService {
    String hello1();
    String hello2();
    String hello3();
}

ApiBusinessException.java ，和接口在同一个包下，这样的话可以直接获取到自定义的异常

package com.young.api.service;

import com.young.common.enums.ResultCode;

import java.io.Serializable;

public class ApiBusinessException extends RuntimeException{
    private ResultCode resultCode;
    public ApiBusinessException(){
    }
    public ApiBusinessException(ResultCode resultCode){
        super(resultCode.getMsg());
        this.resultCode=resultCode;
    }
    public ResultCode getResultCode(){
        return this.resultCode;
    }
}

再创建一个模块，rpc-provider，用于提供服务
pom.xml

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>rpcException01</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>rpc-consumer</artifactId>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>rpc-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-registry-zookeeper</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>

TestServiceImpl.java

package com.young.provider.service.impl;

import com.young.api.service.ApiBusinessException;
import com.young.api.service.TestService;
import com.young.common.enums.ResultCode;
import com.young.common.err.BusinessException;
import org.apache.dubbo.config.annotation.DubboService;
import org.apache.dubbo.rpc.filter.ExceptionFilter;
import org.apache.dubbo.rpc.service.GenericException;
import org.apache.dubbo.rpc.service.GenericService;
import org.springframework.stereotype.Service;

@Service
@DubboService
public class TestServiceImpl implements TestService {
    @Override
    public String hello1() {
        //抛出rpc-common中的异常
        throw new BusinessException(ResultCode.ERROR);
    }

    @Override
    public String hello2() {
        System.out.println("访问到hello2================");
        //抛出rpc-api中的异常
        throw new ApiBusinessException(ResultCode.ERROR);
    }

    @Override
    public String hello3(){
        return "hello world";
    }

}

DubboExceptionFilter.java，复制ExceptionFilter的源代码，然后进行修改

package com.young.provider.filter;

import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.common.logger.Logger;
import org.apache.dubbo.common.logger.LoggerFactory;
import org.apache.dubbo.common.utils.ReflectUtils;
import org.apache.dubbo.common.utils.StringUtils;
import org.apache.dubbo.rpc.*;
import org.apache.dubbo.rpc.filter.ExceptionFilter;
import org.apache.dubbo.rpc.service.GenericService;

import java.lang.reflect.Method;

/**
 * 复制ExceptionFilter的源代码，然后进行修改
 */
@Activate(
        group = {"provider"}
)
public class DubboExceptionFilter implements Filter, BaseFilter.Listener {
    private Logger logger = LoggerFactory.getLogger(org.apache.dubbo.rpc.filter.ExceptionFilter.class);

    public DubboExceptionFilter() {
    }

    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        return invoker.invoke(invocation);
    }

    public void onResponse(Result appResponse, Invoker<?> invoker, Invocation invocation) {
        if (appResponse.hasException() && GenericService.class != invoker.getInterface()) {
            try {
                Throwable exception = appResponse.getException();
                if (!(exception instanceof RuntimeException) && exception instanceof Exception) {
                    return;
                }

                try {
                    Method method = invoker.getInterface().getMethod(invocation.getMethodName(), invocation.getParameterTypes());
                    Class<?>[] exceptionClasses = method.getExceptionTypes();
                    Class[] var7 = exceptionClasses;
                    int var8 = exceptionClasses.length;

                    for(int var9 = 0; var9 < var8; ++var9) {
                        Class<?> exceptionClass = var7[var9];
                        if (exception.getClass().equals(exceptionClass)) {
                            return;
                        }
                    }
                } catch (NoSuchMethodException var11) {
                    return;
                }

                this.logger.error("Got unchecked and undeclared exception which called by " + RpcContext.getServiceContext().getRemoteHost() + ". service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName() + ", exception: " + exception.getClass().getName() + ": " + exception.getMessage(), exception);
                String serviceFile = ReflectUtils.getCodeBase(invoker.getInterface());
                String exceptionFile = ReflectUtils.getCodeBase(exception.getClass());
                if (serviceFile != null && exceptionFile != null && !serviceFile.equals(exceptionFile)) {
                    String className = exception.getClass().getName();
                    System.out.println("className:"+className);
                    if (!className.startsWith("java.") && !className.startsWith("javax.")) {
                        //如果是自定义的异常，也直接返回
                        if (className.startsWith("com.young.common.err.")){
                            return ;
                        }

                        if (exception instanceof RpcException) {
                            return;
                        }

                        appResponse.setException(new RuntimeException(StringUtils.toString(exception)));
                        return;
                    }

                    return;
                }

                return;
            } catch (Throwable var12) {
                this.logger.warn("Fail to ExceptionFilter when called by " + RpcContext.getServiceContext().getRemoteHost() + ". service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName() + ", exception: " + var12.getClass().getName() + ": " + var12.getMessage(), var12);
            }
        }

    }

    public void onError(Throwable e, Invoker<?> invoker, Invocation invocation) {
        this.logger.error("Got unchecked and undeclared exception which called by " + RpcContext.getServiceContext().getRemoteHost() + ". service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName() + ", exception: " + e.getClass().getName() + ": " + e.getMessage(), e);
    }

    public void setLogger(Logger logger) {
        this.logger = logger;
    }
}

然后在resource目录下，创建一个META-INF目录，在META-INF目录下，再创建一个dubbo目录，然后在dubbo目录下，创建一个文件，文件名为:org.apache.dubbo.rpc.Filter，文件内容为：

dubboExceptionFilter=com.young.provider.filter.DubboExceptionFilter

application.yml

server:
  port: 8001
spring:
  application:
    name: provider-service
dubbo:
  registry:
    address: zookeeper://localhost:2181
  protocol:
    port: 29081
    name: dubbo
    host: 127.0.0.1
  provider:
    filter: dubboExceptionFilter,-exception

创建rpc-consumer模块，pom.xml

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>rpcException01</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>rpc-consumer</artifactId>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>rpc-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-registry-zookeeper</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>

GlobalExceptionHandler.java，全局异常处理类

package com.young.consumer.handler;

import com.young.api.service.ApiBusinessException;
import com.young.common.enums.ResultCode;
import com.young.common.err.BusinessException;
import com.young.common.util.ResultVOUtil;
import com.young.common.vo.ResultVO;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.rpc.filter.ExceptionFilter;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
    @ExceptionHandler(value = BusinessException.class)
    public ResultVO handlerBusiness(BusinessException e){
        log.info("捕获businessException===============");
        return ResultVOUtil.fail(e.getResultCode());
    }

    @ExceptionHandler(value = ApiBusinessException.class)
    public ResultVO handlerApiBusinessException(ApiBusinessException e){
        log.info("捕获apiBusinessException===============");
        return ResultVOUtil.fail(e.getResultCode());
    }

    @ExceptionHandler(value = Exception.class)
    public ResultVO handlerException(Exception e){
        e.printStackTrace();
        log.info("捕获exception===============");
        return new ResultVO(ResultCode.FAIL.getCode(),e.getMessage());
    }
}

TestController.java

package com.young.consumer.controller;

import com.young.api.service.TestService;
import com.young.common.util.ResultVOUtil;
import com.young.common.vo.ResultVO;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    @DubboReference
    private TestService testService;

    @GetMapping("/hello1")
    public ResultVO hello1(){
        String s = testService.hello1();
        return ResultVOUtil.success(s);
    }

    @GetMapping("/hello2")
    public ResultVO hello2(){
        String s = testService.hello2();
        return ResultVOUtil.success(s);
    }

    @GetMapping("/hello3")
    public ResultVO hello3(){
        String s = testService.hello3();
        return ResultVOUtil.success(s);
    }
}

application.yml

server:
  port: 8002
spring:
  application:
    name: consumer-service
dubbo:
  registry:
    address: zookeeper://localhost:2181
  protocol:
    port: 29082
    name: dubbo
    host: 127.0.0.1
  provider:
    filter: dubboExceptionFilter,-exception

完整文件目录如下图所示：
在这里插入图片描述
在这里插入图片描述
分别启动zookeeper，ProviderApplication，ConsumerApplication，分别访问/hello1, /hello2， /hello3，结果如下：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
至此，我们就实现了dubbo捕获自定义异常了，这里再记录一个小坑，我们在自定义异常的时候，自定义的异常要有无参构造函数，因为dubbo默认是使用Hessian进行反序列化的，该反序列化创建对象的时候，会取参数最少的构造方法来创建对象，构造方法参数设置默认值，基本类型设置为相应基本类型的默认值，不是基本类型设置为null，如果没有无参构造方法，访问接口时，结果如下：
在这里插入图片描述

参考文章

dubbo(四)异常处理
Dubbo如何处理业务异常，这个一定要知道哦！
Dubbo通过Hessian反序列化对象失败解决

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

六级备考28天｜CET-6｜听力第三讲｜篇章的做题方法与练习法｜2022年6月考题9-11题｜16:15-17:15

六级备考28天｜CET-6｜听力第三讲｜篇章的做题方法与练习法｜2022年6月考题9-11题｜16:15-17:15

目录 1. 笔记 2. 听力原文复现 (9)问题9 (10)问题10 (11)问题11 08:00开始播放 两/三个选项大面积同时出现了听力中一句话&#xff0c;一般排除这两/三个选项 1. 笔记 2. 听力原文复现 (9)问题9 -What have researchers done for the first time in history? The re…
阅读更多...
c++ boost库学习-01-lexical_cast

c++ boost库学习-01-lexical_cast

一、C/C数值转换函数 C/C语言提供了几个标准库函数&#xff0c;可以将字符串、整型浮点型等相互转换。 atof()&#xff1a;将字符串转换为双精度浮点型值。 atoi()&#xff1a;将字符串转换为整型值。 atol()&#xff1a;将字符串转换为长整型值。 itoa()&#xff1a;将字符串…
阅读更多...
redis的几种集群方式

redis的几种集群方式

https://www.zhihu.com/people/pan-zhi-74-31 Redis集群介绍Redis集群一般有四种方式&#xff0c;分别为&#xff1a;主从复制、哨兵模式、Cluster以及各大厂的集群方案。在3.0版本之前只支持单实例模式&#xff0c;3.0之后支持了集群方式。在3.0之前各大厂为了解决单实例Redis…
阅读更多...
为Eclipse安装lombok插件

为Eclipse安装lombok插件

因为原生的Eclipse没有lombok插件&#xff0c;所以即使项目引入了lombok依赖也无法使用Data等常用标签。下面介绍一下如何手动为Eclipse添加lombok插件&#xff0c;具体操作步骤如下&#xff1a; &#xff08;1&#xff09;打开Download地址&#xff0c;点击页面中间的超链接下…
阅读更多...
k8s集群内带GPU工作节点配置显卡驱动

k8s集群内带GPU工作节点配置显卡驱动

k8s集群内带GPU工作节点配置显卡驱动 系统为Centos7 一、下载、安装显卡驱动 查看显卡型号 [rootVM-3-9-centos user]# lspci | grep -i nvidia 00:08.0 3D controller: NVIDIA Corporation TU104GL [Tesla T4] (rev a1)1.1、官网下载驱动程序 https://www.nvidia.cn/Downlo…
阅读更多...
数据分析13——Pandas数据导出/日期数据处理/样本采样

数据分析13——Pandas数据导出/日期数据处理/样本采样

Pandas数据导出 1、导出Excel&#xff1a; 举例&#xff1a; 代码&#xff1a;df.to_excel(‘./data/text_01.xlsx’, sheet_name‘订单明细’, indexFalse)解释&#xff1a;将df数据导入到相对路径为’./data/text_01.xlsx’的文件中&#xff0c;其中数据表名称为’订单明细…
阅读更多...
【算法】单源最短路径算法——Dijkstra算法

【算法】单源最短路径算法——Dijkstra算法

文章目录 一、简介与使用场景二、算法思想三、朴素版Dijkstra四、堆优化版Dijkstra五、总结 一、简介与使用场景 迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959 年提出的&#xff0c;因此又叫狄克斯特拉算法。这是从一个顶点到其余各顶点的最短路径算法&#…
阅读更多...
STM32 使用SYN6288语音模块

STM32 使用SYN6288语音模块

文章目录 前言一、SYN6288介绍二、SYN6288原理讲解三.数据的异或校验四.代码编写1.串口的初始化2.SYN6288代码编写3.main函数逻辑 总结 前言 本篇文章带大家学习一下SYN6288语音模块&#xff0c;这个模块可以用于车载设备&#xff0c;语音电子书等众多产品当中&#xff0c;而且…
阅读更多...
Android 创建线程源码分析 JavaThreadNativeThread

Android 创建线程源码分析 JavaThreadNativeThread

前言 本文分析在Android中创建线程时候的源码分析，即JavaThread和NativeThread。 java/lang/Thread.java art/runtime/native/java_lang_Thread.cc art/runtime/thread.cc 两种Java Thread 有两种可以运行Java代码的线程。有两种情况： 通过new Thread创建的java线程在Nati…
阅读更多...
若依分离版——IDEA开发SpringBoot的webservice接口

若依分离版——IDEA开发SpringBoot的webservice接口

一.webservice介绍 WebService是帮助多个应用程序与平台和编程语言之间以独立的方式互相通信的标准化技术。它是利用标准 XML messaging(主要 SOAP) 技术&#xff0c;可以访问网络上的其他计算机的记述多种操作的软件接口。此接口主要由 WSDL (WebService Description Language…
阅读更多...
WPF 未能加载文件或程序集 System.Windows.Interactivity

WPF 未能加载文件或程序集 System.Windows.Interactivity

先说一下原因&#xff0c;这是因为微软抛弃了Interactivity导致。 NuGet下载Behaviors.Wpf 在xaml界面替换掉有Interactivity那一行&#xff0c;替换为: xmlns:i“http://schemas.microsoft.com/xaml/behaviors”
阅读更多...
OA管理痛点解决：从“硬编码”到“低代码”

OA管理痛点解决：从“硬编码”到“低代码”

低代码开发平台是一种逐渐流行起来的软件开发方式&#xff0c;它可以以快速且简单的方式构建各种应用程序&#xff0c;从而帮助企业快速响应市场变化和满足不断变化的业务需求。在企业的日常管理工作中&#xff0c;OA系统是一种非常常见的应用程序&#xff0c;它可以帮助企业管…
阅读更多...
外包五年，你知道这五年我怎么过的吗？

外包五年，你知道这五年我怎么过的吗？

”五年&#xff0c;你知道我这五年怎么过的吗&#xff1f;“ 5年时间&#xff0c;我一路从外包到字节&#xff0c;说一句很俗的话&#xff0c; 现在的我真的要好好谢谢当初拼命努力的自己&#xff0c;要感谢跳出舒适圈的自己&#xff0c; 外包薪资真的不少&#xff0c;当初毕…
阅读更多...
10几个类ChatGPT国内AI大模型【内附体验网址】

10几个类ChatGPT国内AI大模型【内附体验网址】

文章目录 前言1. AI文本工具站效率工具自媒体创作工具代码工具 2.道和顺ChatIC3.星期五4.文心一言5.讯飞星火认知大模型6.通义千问7.商汤-日日新8.Moss9.ChatGLM10. 360智脑写在最后 前言 随着ChatGPT迅速走红,国内各大企业纷纷发力认知大模型领域。经过一段时间的酝酿&#x…
阅读更多...
微前端子应用间通信和数据共享

微前端子应用间通信和数据共享

前面讲到了微前端的应用:(94条消息) 微前端应用(qiankunumiantd)_他夏了夏天吖的博客-CSDN博客https://blog.csdn.net/zh0623/article/details/130615234?spm1001.2014.3001.5501今天讲一下不同子应用的通信和数据共享问题 微前端不同子应用之间可能需要进行通信和数据共享,假…
阅读更多...
深度学习中，batch大小对模型的效果有影响吗？

深度学习中，batch大小对模型的效果有影响吗？

内容来自李宏毅-2021机器学习 ##先说结论&#xff1a;同一个模型&#xff0c;大batch结果往往会较差。 上图中&#xff0c;横轴代表batch size&#xff0c;从左到右越来越大&#xff1b;纵轴代表准确率acc&#xff0c;越往上正确率越来越高。 在观察validation上的结果时&…
阅读更多...
【数据结构与算法】基础数据结构

【数据结构与算法】基础数据结构

文章目录 数组概述动态数组二维数组局部性原理越界检查 链表概述单向链表单向链表&#xff08;带哨兵&#xff09;双向链表&#xff08;带哨兵&#xff09;环形链表&#xff08;带哨兵&#xff09; 队列概述链表实现环形数组实现 栈概述链表实现数组实现应用 双端队列概述链表实…
阅读更多...
Android内部存储与外部存储（私有目录与公共目录）图文详解

Android内部存储与外部存储（私有目录与公共目录）图文详解

目录 一、存储空间概述 二、存储空间的划分 1、存储划分 2、内部存储 2.1 内部存储概述 2.2 内部存储 - 私有目录 3. 外部存储 3.1 外部存储概述 3.2 外部存储 - 私有目录 3.3 外部存储 - 公共目录 三、内部存储与外部存储比较 1、横向对比 2、目录结构 3、存储分…
阅读更多...
English Learning - L3 作业打卡 Lesson3 Day15 2023.5.19 周五

English Learning - L3 作业打卡 Lesson3 Day15 2023.5.19 周五

English Learning - L3 作业打卡 Lesson3 Day15 2023.5.19 周五 引言&#x1f349;句1: We present more expressions about food.成分划分连读爆破语调 &#x1f349;句2: They are from Elenir Scardueli, a listener in Brazil.成分划分弱读连读语调 &#x1f349;句3: My m…
阅读更多...
plsql为什么连不上远程或本地的Oracle，需要做哪些准备？

plsql为什么连不上远程或本地的Oracle，需要做哪些准备？

文件配置解说 tnsnames.ora文件 文件所在地址&#xff1a;ORACLE_HOME\network\admin ORACLE_HOME&#xff1a;Oracle数据库或者客户端软件所在的地址 但是我的在Oracle数据库的目录下&#xff0c;而不是Oracle客户端软件&#xff08;instantclient_11_2&#xff09;下 里…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023