Java中的日志系统及在SpringBoot中的使用

最新推荐文章于 2024-06-06 09:30:28 发布
最新推荐文章于 2024-06-06 09:30:28 发布
阅读量323 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43995020/article/details/106037931
版权

Java中的日志系统及在SpringBoot中的使用

为什么需要日志框架

在Java的实际开发中，需要将程序的一些运行信息打印或写入日志文件。System.out是在当前线程执行的，即将日志写入文件后才会执行下面的程序，会极大的影响运行效率。因此在实际开发中都会使用SLF4J（Simple Logging Façade For Java）+ 其实现类（log4j、logback等）实现日志的记录和输出。

SLF4J概念

实际开发的系统中可能需要使用不同的日志框架，例如自己的系统中使用了logback实现日志输出，而系统的依赖A.jar使用了log4j框架。为了同时支持和维护不同日志框架，提出了SLF4J（Simple Logging Façade For Java）。SLF4J是门面模式的典型应用，可以简单理解成日志系统的适配层，决定具体使用哪一种日志框架，这样调用端只需要打印日志而不需要关心如何打印日志。

门面(Facade)模式

门面模式，其核心为外部与一个子系统的通信必须通过一个统一的外观对象进行，使得子系统更易于使用。可以通过下图进行理解：
门面模式类图
在这个对象图中，出现了两个角色：

门面(Facade)角色 ：知道所有子角色的功能和责任；将客户端发来的请求委派到子系统中，没有实际业务逻辑；不参与子系统内业务逻辑的实现。

子系统(SubSystem)角色 ：可以同时有一个或者多个子系统。每个子系统都不是一个单独的类，而是一个类的集合（如上面的子系统就是由ModuleA、ModuleB、ModuleC三个类组合而成）。每个子系统都可以被客户端直接调用，或者被门面角色调用。子系统并不知道门面的存在，对于子系统而言，门面仅仅是另外一个客户端而已。

SLF4J就相当于所有日志框架的门面，它只做两件事情：

  1. 提供日志接口
  2. 提供获取具体日志对象的方法

SLF4J实现原理

在代码中，使用SLF4J非常简单，只需要使用下面的一行代码就能通过LoggerFactory去拿SLF4J提供的一个Logger接口的具体实现。

Logger logger = LoggerFactory.getLogger(this.getClass());

通过观察LoggerFactory中getLogger的源码

/**
 * Return a logger named corresponding to the class passed as parameter,
 * using the statically bound {@link ILoggerFactory} instance.
 * */
public static Logger getLogger(Class<?> clazz) {
    Logger logger = getLogger(clazz.getName());
    if (DETECT_LOGGER_NAME_MISMATCH) {
        Class<?> autoComputedCallingClass = Util.getCallingClass();
        if (autoComputedCallingClass != null && nonMatchingClasses(clazz, autoComputedCallingClass)) {
            Util.report(String.format("Detected logger name mismatch. Given name: \"%s\"; computed name: \"%s\".", logger.getName(),
                            autoComputedCallingClass.getName()));
            Util.report("See " + LOGGER_NAME_MISMATCH_URL + " for an explanation");
        }
    }
    return logger;
}

这里关键是第二行的getLogger方法，后面的逻辑是如果使用类的名字和传入类的名字不一致时会输出logger name mismatch warning ，但也要在系统变量中将DETECT_LOGGER_NAME_MISMATCH设置为true才会生效。

public static Logger getLogger(String name) {
    ILoggerFactory iLoggerFactory = getILoggerFactory();
    return iLoggerFactory.getLogger(name);
}

ILoggerFactory是个接口，里面只有getLogger一个方法，关键在于getILoggerFactory() 如何确认系统使用的日志框架并返回接口实现类。

public static ILoggerFactory getILoggerFactory() {
    if (INITIALIZATION_STATE == UNINITIALIZED) {
        synchronized (LoggerFactory.class) {
            if (INITIALIZATION_STATE == UNINITIALIZED) {
                INITIALIZATION_STATE = ONGOING_INITIALIZATION;
                performInitialization();
            }
        }
    }
    switch (INITIALIZATION_STATE) {
    case SUCCESSFUL_INITIALIZATION:
        return StaticLoggerBinder.getSingleton().getLoggerFactory();
    case NOP_FALLBACK_INITIALIZATION:
        return NOP_FALLBACK_FACTORY;
    case FAILED_INITIALIZATION:
        throw new IllegalStateException(UNSUCCESSFUL_INIT_MSG);
    case ONGOING_INITIALIZATION:
        return SUBST_FACTORY;
    }
    throw new IllegalStateException("Unreachable code");
}

private final static void performInitialization() {
    bind();
    if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
        versionSanityCheck();
    }
}

可以看出，一开始当 INITIALIZATION_STATE 是UNINITIALIZED 时（即第一次调用该方法时），通过 performInitialization() 方法中的 bind() 方法去发现和绑定日志框架。

private final static void bind() {
    try {
        Set<URL> staticLoggerBinderPathSet = null;
        if (!isAndroid()) {
            //找到所有StaticLoggerBinder.class存在的路径
            staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
            //如果有多处存在StaticLoggerBinder.class，下面的方法会发出警告
            reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
        }
        // the next line does the binding
        StaticLoggerBinder.getSingleton();
        INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
        reportActualBinding(staticLoggerBinderPathSet);
        fixSubstituteLoggers();
        replayEvents();
        // release all resources in SUBST_FACTORY
        SUBST_FACTORY.clear();
    } catch (NoClassDefFoundError ncde) {
        String msg = ncde.getMessage();
        if (messageContainsOrgSlf4jImplStaticLoggerBinder(msg)) {
            INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
            Util.report("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
            Util.report("Defaulting to no-operation (NOP) logger implementation");
            Util.report("See " + NO_STATICLOGGERBINDER_URL + " for further details.");
        } else {
            failedBinding(ncde);
            throw ncde;
        }
    } catch (java.lang.NoSuchMethodError nsme) {
        String msg = nsme.getMessage();
        if (msg != null && msg.contains("org.slf4j.impl.StaticLoggerBinder.getSingleton()")) {
            INITIALIZATION_STATE = FAILED_INITIALIZATION;
            Util.report("slf4j-api 1.6.x (or later) is incompatible with this binding.");
            Util.report("Your binding is version 1.5.5 or earlier.");
            Util.report("Upgrade your binding to version 1.6.x.");
        }
        throw nsme;
    } catch (Exception e) {
        failedBinding(e);
        throw new IllegalStateException("Unexpected initialization failure", e);
    }
}

这里通过第5行的 findPossibleStaticLoggerBinderPathSet() 方法找到所有logger框架可能的绑定路径，并在第9行的 StaticLoggerBinder.getSingleton() 方法中实现绑定。

private static String STATIC_LOGGER_BINDER_PATH = "org/slf4j/impl/StaticLoggerBinder.class";
static Set<URL> findPossibleStaticLoggerBinderPathSet() {
    Set<URL> staticLoggerBinderPathSet = new LinkedHashSet<URL>();
    try {
        ClassLoader loggerFactoryClassLoader = LoggerFactory.class.getClassLoader();
        Enumeration<URL> paths;
        if (loggerFactoryClassLoader == null) {
            paths = ClassLoader.getSystemResources(STATIC_LOGGER_BINDER_PATH);
        } else {
            paths = loggerFactoryClassLoader.getResources(STATIC_LOGGER_BINDER_PATH);
        }
        while (paths.hasMoreElements()) {
            URL path = paths.nextElement();
            staticLoggerBinderPathSet.add(path);
        }
    } catch (IOException ioe) {
        Util.report("Error getting resources from path", ioe);
    }
    return staticLoggerBinderPathSet;
}

该方法最终返回所有 StaticLoggerBinder.class 的存在路径，即所有SLF4J的实现的jar包路径下，org/slf4j/impl/StaticLoggerBinder.class 是一定存在的。

最终，SLF4J将具体日志框架的 StaticLoggerBinder.class 绑定在了StaticLoggerBinder 对象中，通过 StaticLoggerBinder.getSingleton().getLoggerFactory().getLogger(name) 可以得到具体的Logger对象。

SpringBoot中日志的使用

日志框架的关系

slf4j-simple、logback都是SLF4J的具体实现，log4j并不直接实现SLF4J，但是有专门的一层桥接slf4j-log4j12来实现slf4j。其中，slf4j-simple不常用，因此主要介绍logback和log4j。logback是log4j的改良版本，比log4j拥有更多的特性，同时也带来很大性能提升。因此 SpringBoot 提供了一套日志系统，logback是最优先的选择。关于这一点，我们可以从点击pom.xml文件里的 spring-boot-starter-parent 中的spring-boot-dependencies

pom.xml:
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.2.RELEASE</version>
</parent>

spring-boot-starter-parent-2.2.2.RELEASE.pom.xml:
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>2.2.2.RELEASE</version>
  <relativePath>../../spring-boot-dependencies</relativePath>
</parent>

可以看到以下依赖：

<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-access</artifactId>
  <version>${logback.version}</version>
</dependency>
<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>${logback.version}</version>
</dependency>
<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-core</artifactId>
  <version>${logback.version}</version>
</dependency>

其中，logback被分为3个组件，logback-core, logback-classic 和 logback-access。
其中logback-core提供了logback的核心功能，是另外两个组件的基础。
logback-classic则实现了SLF4J的API，所以当想配合SLF4J使用时，需要将logback-classic加入classpath。

当然，也可以选择不使用 SpringBoot 自带的日志系统而使用log4j，但此时需要先在依赖中排除 SpringBoot 自带的日志系统，再引入log4j的依赖，如下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
     </exclusions>
</dependency>
        
<!-- log4j. -->
<dependency>  
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j</artifactId>
</dependency>

logback的使用

默认配置

SpringBoot 默认帮我们配置好了日志；日志有五种级别，由低到高是trace<debug<info<warn<error，日志就只会在这个级别及更高级别生效，SpringBoot 默认指定是info级别，

private Logger logger = LoggerFactory.getLogger(this.getClass());

@Test
public void printLog() {
    logger.trace("This is Trace Logger.");
    logger.debug("This is Debug Logger.");
    logger.info("This is Info Logger.");
    logger.warn("This is Warn Logger.");
    logger.error("This is Error Logger.");
}

运行上面的测试类，可以得到

2020-05-11 14:22:11.068 -- [main] -- INFO  -- com.temp.LogTest -- This is Info Logger.
2020-05-11 14:22:11.069 -- [main] -- WARN  -- com.temp.LogTest -- This is Warn Logger.
2020-05-11 14:22:11.070 -- [main] -- ERROR -- com.temp.LogTest -- This is Error Logger.

这印证了SpringBoot的默认日志配置级别为Info的事实。

自定义配置

可以在resource/applications.properties文件中加入以下属性修改日志的配置。

修改默认级别为error。
logging.level.root = error

如果仅想指定某个包内的日志级别可以将root改为包名。

logging.level.com.test.web = error

这样该包下的所有日志输出级别将改为error，其他包不受影响。（注：如果同时指定了上面两者，后者将覆盖前者）

指定输出日志文件
logging.file.name=./springboot.log

该属性指定在resource/下生成一个springboot.log文件存放日志。

logging.file.path=/log

该属性指定日志的目录在resource/log下，会自动生成一个springboot.log文件存放日志。
（注：两者同时指定，前者生效。当检测到日志的生成时间和日志文件里日志的时间相差一天时，会自动将原日志名称改为springboot.log.2020-05-10.0(前一天时间).gz，重新生成springboot.log存放当天的日志）

修改输出格式
logging.pattern.console = %d{yyyy-MM-dd HH:mm:ss.SSS} -- [%thread] -- %-5level -- %logger{50} -- %msg%n
logging.pattern.file = %d{yyyy-MM-dd HH:mm:ss.SSS} -- [%thread] -- %-5level -- %logger{50} -- %msg%n

前者指定在控制台输出的格式，后者指定在文件中输出的格式。其中：
%d：表示日期时间；
%thread：表示线程名；
%-5level：级别从左显示固定5个字符宽度；
%logger{50}：表示logger名字，意思是最长50个字符，否则按照句点分割；
%msg：日志消息；
%n是换行符；
可以通过上述符号自定义想要的日志输出格式。

指定配置文件
logging.config=classpath:log/logback-spring.xml

该属性指定了日志的配置文件从resouce/log/logback-spring.xml进行读取。（注：如果直接在/resouce下建立logback.xml，则不需要显示指定路径，SpringBoot会自动在该路径下识别该文件。如果配置文件中的属性和applications.properties文件冲突，以后者为准。）

多环境日志配置

在/resource下直接建立lockback.xml可以不需要显示指定配置文件路径，但是官方依旧推荐优先使用 *-spring.* 的形式命名日志配置文件，因为使用该命名可以获得spring扩展的profile支持，即springProfile标签，实现根据不同环境（prod:生产环境，test:测试环境，dev:开发环境）来定义不同的日志输出。配置文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/base.xml" />
    <logger name="org.springframework.web" level="INFO"/>
    <logger name="org.springboot.sample" level="TRACE" />
    
    <!-- 测试环境+开发环境. 多个使用逗号隔开. -->
     <springProfile name="test,dev">
        <logger name="org.springframework.web" level="INFO"/>
        <logger name="org.springboot.sample" level="INFO" />
        <logger name="com.kfit" level="info" />
    </springProfile>
 
    
    <!-- 生产环境. -->
    <springProfile name="prod">
        <logger name="org.springframework.web" level="ERROR"/>
        <logger name="org.springboot.sample" level="ERROR" />
        <logger name="com.kfit" level="ERROR" />
    </springProfile>
    
</configuration>

参考文献

[1] https://www.iteye.com/blog/412887952-qq-com-2307244
[2] https://www.cnblogs.com/zhangjianbing/p/8992897.html
[3] https://www.cnblogs.com/xrq730/p/8619156.html
[4] https://www.cnblogs.com/zouwangblog/p/11198915.html

陈育龙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java企业oa管理系统使用SpringBoot+MyBatis框架.zip
03-06
本企业OA管理系统有管理员和用户。...本系统的使用使管理人员从繁重的工作中解脱出来，实现无纸化办公，能够有效的提高企业OA管理系统管理效率。 关键词：企业OA管理系统；Spring Boot框架；MYSQL数据库
[Java]SpringBoot日志
weixin_44417042的博客
06-08 241
日志日志SLF4j使用系统中使用SLF4j统一日志记录SpringBoot日志关系SpringBoot日志使用SpringBoot默认日志配置修改日志默认配置指定配置日志框架切换 日志 市面上常见的日志框架：JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j… 日志门面 （日志的抽象层） 日志实现 JCL（Jakarta Commons Logging） SLF4j（Simple Logging Facade for Java）
LoggerFactory.getLogger具体用法
weixin_48027611的博客
06-28 4759
java开发过程中经常需要打印日志信息，往往会在每个类的第一行加上形如以下代码： protected Logger logger = LoggerFactory.getLogger(getClass()); getClass() 是 java.lang.Object 中的方法，它返回一个对象的运行时类； Logger.getLogger(getClass())又得到什么？ 它得到一个Logger对象，这个Logger将监视this.getClass()这个运行时类，这个运行时类里面你可能创建了log.in
【JavaEE】Spring Boot 日志详解
最新发布
m0_74105656的博客
06-06 922
详细的解释了springboot日志相关的内容,包括日志构成,已经如何修改日志的相关配置.
java LoggerFactory日志记录
myyw001的博客
09-24 1042
1.引入库 代码如下（示例）： import org.slf4j.LoggerFactory; 2.日志记录 代码如下（示例）： protected final Logger logger = LoggerFactory.getLogger(this.getClass()); //记录日志 logger.info("用户登录成功"); //记录错误日志 logger.error("getUserInfo 异常【{}】", e); 3.application.yml 配置 代码如下（示例）： ####
LoggerFactory.getLogger用法
douxubao的博客
08-03 876
使用指定类初始化日志对象,在日志输出的时候，可以打印出日志信息所在类 如：Logger logger = LoggerFactory.getLogger(com.lz.Test.class); logger.debug(“日志信息”); 将会打印出: com.lz.Test : 日志信息 Logger logger = LoggerFactory.getLogger(this.getClass()); logger.info方法的使用 https://blog.csdn.net/halimao/articl
日志框架学习2
意亦逸的博客
01-05 186
1.slf4j 源码分析 import org.slf4j.Logger; import org.slf4j.LoggerFactory; private Logger log = LoggerFactory.getLogger(this.getClass()); 1.1 getLogger方法解析 public static Logger getLogger(Class&amp;lt;?&amp;gt; c...
在SpringBoot中使用日志
qq_42681787的博客
01-13 249
背景:springBoot提供了java ee开发的一站式解决方案，可以整合其他框架,每一个框架为了简化开发人员的调试，均采用了日志框架。不同的框架采用了不同的日志:SpringBoot（slf4j+logback）、Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis、xxxx 。那么如何统一日志记录，用SpringBoot整合别的框架...
Java智能物流管理系统使用SpringBoot+MyBatis框架.zip
03-06
本智能物流管理系统有管理员，顾客，...本系统的使用使管理人员从繁重的工作中解脱出来，实现无纸化办公，能够有效的提高智能物流管理系统管理效率。 关键词：智能物流管理系统；SSM框架；MYSQL数据库；Spring Boot
Java组件课程设计-基于SpringBoot的酒店管理系统.zip
08-05
在这个项目中，“Java组件课程设计-基于SpringBoot的酒店管理系统”是一个典型的例子，它利用了Java生态中的SpringBoot框架来构建高效、可扩展的后台服务。SpringBoot是Java开发中的一个热门框架，以其快速启动、...
springboot项目查询es中的日志内容
04-21
在本项目中，我们主要探讨如何使用SpringBoot与Elasticsearch（ES）集成，以便查询存储在ES中的日志内容。Elasticsearch是一种强大的、分布式、实时的搜索和分析引擎，常用于处理大量数据，特别是在日志管理和分析...
产品的管理.java
05-07
产品的管理public class OmOrderController extends Controller { protected Logger logger = LoggerFactory.getLogger(getClass()); /** * <p>open grid page</p> * */ public void list() { this.render(SUCCESS); }
日志处理系统 (springboot+kafka)Log.zip
05-15
该项目利用了基于springboot + vue + mysql的开发模式框架实现的课设系统，包括了项目的源码资源、sql文件、相关指引文档等等。 【项目资源】：包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理...
Java日志:log4j2
a4453368的博客
06-04 1375
java日志框架、log4j2
【Java】彩色日志+日志写入到系统文件中
qq_42666609的博客
04-17 1051
在SpringBoot框架中，实现控制台彩色日志打印以及生成txt日志文件保存在指定目录，并且可设置txt日志文件保存的时间以及文件名称在项目resources文件夹下新建一个logback.xml文件。 文件代码如下： 二、启动项目 1.项目启动成功后就能看到控制台已经实现了彩色日志 以上就是今天要讲的内容，谢谢各位的点赞评论支持！
SpringBoot实现日志收集原理
JavaMyDream的博客
04-19 520
【代码】SpringBoot实现日志收集原理。
SpringBoot打印日志
zengjyxxz的博客
06-03 1429
使用： //使用默认的 appender private final Logger logger = LoggerFactory.getLogger(this.getClass()); //使用自定义的 appender private final Logger logger = LoggerFactory.getLogger("HuiFuERROR"); 添加 logback-spring.xml 文件： 这个文件定义了3个默认的 appender，一个自定义的 appender： <?xml v
框架技术---SpringBoot(四)日志系统使用
qq_41184981的博客
11-18 199
SpringBoot日志的使用 1.默认配置 //记录器 Logger logger = LoggerFactory.getLogger(getClass()); @Test public void contextLoads() { // 日志的级别: // 由低到高：trace<debug<info<warn<error // 可以调整输出级别：日志就会只...
java logger使用_在可序列化的Java类中使用Logger的正确方法是什么？
weixin_42500631的博客
02-16 513
我在我正在开发的系统中有以下(doctored)类,而Findbugs正在生成一个SE_BAD_FIELD警告,我想知道为什么会这样说,在我以我想的方式解决它之前.我感到困惑的原因是因为这个描述似乎表明我在类中没有使用其他非串行化的实例字段,但是bar.model.Foo也不是可序列化的,并且以完全相同的方式使用(就我而言可以告诉),但是Findbugs不会生成警告.import bar.mode...
我想在Java的SpringBoot项目中使用
06-02
好的，您可以按照以下步骤来在Java的SpringBoot项目中使用阿里云短信服务： 1. 在阿里云控制台上开通短信服务并获取Access Key ID和Access Key Secret。 2. 在您的SpringBoot项目中添加aliyun-java-sdk-core和aliyun-java-sdk-dysmsapi的依赖。 3. 创建一个SmsSender类，并在其中引用aliyun-java-sdk-dysmsapi中的DefaultProfile、DefaultAcsClient、SendSmsRequest和SendSmsResponse类。 4. 在SmsSender类中实现发送短信的方法，例如： ```java public class SmsSender { public static void sendSms(String phoneNumbers, String signName, String templateCode, String templateParam) throws ClientException { String accessKeyId = "yourAccessKeyId"; String accessKeySecret = "yourAccessKeySecret"; // 设置超时时间-可自行调整 System.setProperty("sun.net.client.defaultConnectTimeout", "10000"); System.setProperty("sun.net.client.defaultReadTimeout", "10000"); // 初始化ascClient需要的几个参数 final String product = "Dysmsapi"; final String domain = "dysmsapi.aliyuncs.com"; // 初始化ascClient,暂时不支持多region（请勿修改） IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret); DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product, domain); IAcsClient acsClient = new DefaultAcsClient(profile); // 组装请求对象 SendSmsRequest request = new SendSmsRequest(); // 必填:待发送手机号 request.setPhoneNumbers(phoneNumbers); // 必填:短信签名-可在短信控制台中找到 request.setSignName(signName); // 必填:短信模板-可在短信控制台中找到 request.setTemplateCode(templateCode); // 可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为 request.setTemplateParam(templateParam); // 发送请求 SendSmsResponse sendSmsResponse = acsClient.getAcsResponse(request); // 打印日志 System.out.println("短信接口返回的数据----------------"); System.out.println("Code=" + sendSmsResponse.getCode()); System.out.println("Message=" + sendSmsResponse.getMessage()); System.out.println("RequestId=" + sendSmsResponse.getRequestId()); System.out.println("BizId=" + sendSmsResponse.getBizId()); } } ``` 其中，phoneNumbers表示接收短信的手机号码，signName表示短信签名，templateCode表示短信模板的编号，templateParam表示短信模板中的变量替换JSON串。 5. 在需要发送短信的地方调用SmsSender类中的sendSms方法即可。 希望以上步骤对您有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值