SpringBoot整合QUA-个人手稿版

举报
bayabayabaluobo 发表于 2021/01/31 11:47:41 2021/01/31
【摘要】 spring boot + quartz实现定时任务--------------------------------- 2引入maven依赖--------- 2在 application.properties中配置数据库连接信息---- 4在quartz.properties中配置quartz的 相关信息----- 4在数据库中执行quartz官方的sql脚本创建其需要的表--------...

spring boot + quartz实现定时任务--------------------------------- 2

  1. 引入maven依赖--------- 2
  2. 在 application.properties中配置数据库连接信息---- 4
  3. 在quartz.properties中配置quartz的 相关信息----- 4
  4. 在数据库中执行quartz官方的sql脚本创建其需要的表------------------------------ 4
  5. 编写quartz的配置类--- 9
  6. 编写具体要定时执行的任务执行的------------------- 12
  7. 启动微服务--------------- 13

1） quartz在数据库中插入定时执行任务信息---------------------------- 13

2） 查看实例中定时任务执行结果------------ 13

1.  引入maven依赖

<?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>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>1.5.20.RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <groupId>com.zytest.springboot-mybatis</groupId>

    <artifactId>zydemo</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>zydemo</name>

    <description>Demo project for Spring Boot</description>



    <properties>

        <java.version>1.8</java.version>

    </properties>



    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-jdbc</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

        <dependency>

            <groupId>org.mybatis.spring.boot</groupId>

            <artifactId>mybatis-spring-boot-starter</artifactId>

            <version>1.3.4</version>

        </dependency>



        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>



        <dependency> <!--quartz依赖-->

           <groupId>org.quartz-scheduler</groupId>

           <artifactId>quartz</artifactId>

           <version>2.2.3</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context-support</artifactId>

        </dependency>

        <dependency>

            <groupId>org.quartz-scheduler</groupId>

            <artifactId>quartz-jobs</artifactId>

            <version>2.2.3</version>

        </dependency>

        <dependency>

            <groupId>quartz.j</groupId>

            <artifactId>error</artifactId>

            <version>unknown</version>

        </dependency>

    </dependencies>



    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>



</project>

2.  在 application.properties中配置数据库连接信息

#配置数据库的连接信息

spring.datasource.username=root

spring.datasource.password=123456

spring.datasource.url=jdbc:mysql://localhost:3306/zytest

spring.datasource.driver-class-name=com.mysql.jdbc.Driver



# 配置指定任务的定时策略 每分钟开始执行一次

quartz.cronExperession.task1:0 0/1 * * * ?

3.  在quartz.properties中配置quartz的 相关信息

#ID设置为自动获取 每一个必须不同 （所有调度器实例中是唯一的）

org.quartz.scheduler.instanceId=AUTO

#指定调度程序的主线程是否应该是守护线程

org.quartz.scheduler.makeSchedulerThreadDaemon=true

#ThreadPool实现的类名

org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool

#ThreadPool配置线程守护进程

org.quartz.threadPool.makeThreadsDaemons=true

#线程数量

org.quartz.threadPool.threadCount:20

#线程优先级

org.quartz.threadPool.threadPriority:5

#数据保存方式为持久化

org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX

#StdJDBCDelegate说明支持集群

org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate

#quartz内部表的前缀

org.quartz.jobStore.tablePrefix=QRTZ_

#是否加入集群

org.quartz.jobStore.isClustered=true

#容许的最大作业延长时间

org.quartz.jobStore.misfireThreshold=25000

4.  在数据库中执行quartz官方的sql脚本创建其需要的表

#

# In your Quartz properties file, you'll need to set

# org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate

#

#

# By: Ron Cordell - roncordell

#  I didn't see this anywhere, so I thought I'd post it here. This is the script from Quartz to create the tables in a MySQL database, modified to use INNODB instead of MYISAM.

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;

DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;

DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;

DROP TABLE IF EXISTS QRTZ_LOCKS;

DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;

DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;

DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;

DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;

DROP TABLE IF EXISTS QRTZ_TRIGGERS;

DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;

DROP TABLE IF EXISTS QRTZ_CALENDARS;

CREATE TABLE QRTZ_JOB_DETAILS(

SCHED_NAME VARCHAR(120) NOT NULL,

JOB_NAME VARCHAR(190) NOT NULL,

JOB_GROUP VARCHAR(190) NOT NULL,

DESCRIPTION VARCHAR(250) NULL,

JOB_CLASS_NAME VARCHAR(250) NOT NULL,

IS_DURABLE VARCHAR(1) NOT NULL,

IS_NONCONCURRENT VARCHAR(1) NOT NULL,

IS_UPDATE_DATA VARCHAR(1) NOT NULL,

REQUESTS_RECOVERY VARCHAR(1) NOT NULL,

JOB_DATA BLOB NULL,

PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))

ENGINE=InnoDB;

CREATE TABLE QRTZ_TRIGGERS (

SCHED_NAME VARCHAR(120) NOT NULL,

TRIGGER_NAME VARCHAR(190) NOT NULL,

TRIGGER_GROUP VARCHAR(190) NOT NULL,

JOB_NAME VARCHAR(190) NOT NULL,

JOB_GROUP VARCHAR(190) NOT NULL,

DESCRIPTION VARCHAR(250) NULL,

NEXT_FIRE_TIME BIGINT(13) NULL,

PREV_FIRE_TIME BIGINT(13) NULL,

PRIORITY INTEGER NULL,

TRIGGER_STATE VARCHAR(16) NOT NULL,

TRIGGER_TYPE VARCHAR(8) NOT NULL,

START_TIME BIGINT(13) NOT NULL,

END_TIME BIGINT(13) NULL,

CALENDAR_NAME VARCHAR(190) NULL,

MISFIRE_INSTR SMALLINT(2) NULL,

JOB_DATA BLOB NULL,

PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),

FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)

REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))

ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPLE_TRIGGERS (

SCHED_NAME VARCHAR(120) NOT NULL,

TRIGGER_NAME VARCHAR(190) NOT NULL,

TRIGGER_GROUP VARCHAR(190) NOT NULL,

REPEAT_COUNT BIGINT(7) NOT NULL,

REPEAT_INTERVAL BIGINT(12) NOT NULL,

TIMES_TRIGGERED BIGINT(10) NOT NULL,

PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),

FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)

REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))

ENGINE=InnoDB;

CREATE TABLE QRTZ_CRON_TRIGGERS (

SCHED_NAME VARCHAR(120) NOT NULL,

TRIGGER_NAME VARCHAR(190) NOT NULL,

TRIGGER_GROUP VARCHAR(190) NOT NULL,

CRON_EXPRESSION VARCHAR(120) NOT NULL,

TIME_ZONE_ID VARCHAR(80),

PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),

FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)

REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))

ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPROP_TRIGGERS

  (

    SCHED_NAME VARCHAR(120) NOT NULL,

    TRIGGER_NAME VARCHAR(190) NOT NULL,

    TRIGGER_GROUP VARCHAR(190) NOT NULL,

    STR_PROP_1 VARCHAR(512) NULL,

    STR_PROP_2 VARCHAR(512) NULL,

    STR_PROP_3 VARCHAR(512) NULL,

    INT_PROP_1 INT NULL,

    INT_PROP_2 INT NULL,

    LONG_PROP_1 BIGINT NULL,

    LONG_PROP_2 BIGINT NULL,

    DEC_PROP_1 NUMERIC(13,4) NULL,

    DEC_PROP_2 NUMERIC(13,4) NULL,

    BOOL_PROP_1 VARCHAR(1) NULL,

    BOOL_PROP_2 VARCHAR(1) NULL,

    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),

    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)

    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))

ENGINE=InnoDB;

CREATE TABLE QRTZ_BLOB_TRIGGERS (

SCHED_NAME VARCHAR(120) NOT NULL,

TRIGGER_NAME VARCHAR(190) NOT NULL,

TRIGGER_GROUP VARCHAR(190) NOT NULL,

BLOB_DATA BLOB NULL,

PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),

INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),

FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)

REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))

ENGINE=InnoDB;

CREATE TABLE QRTZ_CALENDARS (

SCHED_NAME VARCHAR(120) NOT NULL,

CALENDAR_NAME VARCHAR(190) NOT NULL,

CALENDAR BLOB NOT NULL,

PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))

ENGINE=InnoDB;

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (

SCHED_NAME VARCHAR(120) NOT NULL,

TRIGGER_GROUP VARCHAR(190) NOT NULL,

PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))

ENGINE=InnoDB;

 

CREATE TABLE QRTZ_FIRED_TRIGGERS (

SCHED_NAME VARCHAR(120) NOT NULL,

ENTRY_ID VARCHAR(95) NOT NULL,

TRIGGER_NAME VARCHAR(190) NOT NULL,

TRIGGER_GROUP VARCHAR(190) NOT NULL,

INSTANCE_NAME VARCHAR(190) NOT NULL,

FIRED_TIME BIGINT(13) NOT NULL,

SCHED_TIME BIGINT(13) NOT NULL,

PRIORITY INTEGER NOT NULL,

STATE VARCHAR(16) NOT NULL,

JOB_NAME VARCHAR(190) NULL,

JOB_GROUP VARCHAR(190) NULL,

IS_NONCONCURRENT VARCHAR(1) NULL,

REQUESTS_RECOVERY VARCHAR(1) NULL,

PRIMARY KEY (SCHED_NAME,ENTRY_ID))

ENGINE=InnoDB;

CREATE TABLE QRTZ_SCHEDULER_STATE (

SCHED_NAME VARCHAR(120) NOT NULL,

INSTANCE_NAME VARCHAR(190) NOT NULL,

LAST_CHECKIN_TIME BIGINT(13) NOT NULL,

CHECKIN_INTERVAL BIGINT(13) NOT NULL,

PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))

ENGINE=InnoDB

CREATE TABLE QRTZ_LOCKS (

SCHED_NAME VARCHAR(120) NOT NULL,

LOCK_NAME VARCHAR(40) NOT NULL,

PRIMARY KEY (SCHED_NAME,LOCK_NAME))

ENGINE=InnoDB;

CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);

CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);

CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);

CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);

CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);

CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);

CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);

CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);

CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);

CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);

CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);

CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);

CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);

CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);

CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);

CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);

CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);

CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);

CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);

CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);

 

commit;

5.  编写quartz的配置类

package com.zytest.springbootmybatis.zydemo.quartz_demo.quartzconfig;



import com.zytest.springbootmybatis.zydemo.quartz_demo.job.JobService1;

import org.quartz.JobDetail;

import org.quartz.Trigger;

import org.quartz.spi.JobFactory;

import org.quartz.spi.TriggerFiredBundle;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.beans.factory.config.AutowireCapableBeanFactory;

import org.springframework.beans.factory.config.PropertiesFactoryBean;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.io.ClassPathResource;

import org.springframework.scheduling.quartz.CronTriggerFactoryBean;

import org.springframework.scheduling.quartz.JobDetailFactoryBean;

import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import org.springframework.scheduling.quartz.SpringBeanJobFactory;



import javax.annotation.Resource;

import javax.sql.DataSource;

import java.io.IOException;

import java.util.Properties;



@Configuration

public class ConfigureQuartz {



    @Resource

    private DataSource dataSource;



    //将定时策略注入进来

    @Value("${quartz.cronExperession.task1}")

    private String cronExperessionTask1;



    //从quartz.properties文件中读取Quartz配置属性

    @Bean

    public Properties quartzProperties() throws IOException {

        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();

        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));

        propertiesFactoryBean.afterPropertiesSet();

        return propertiesFactoryBean.getObject();

    }



    //配置JobFactory

    @Bean

    public JobFactory jobFactoryzytest(ApplicationContext applicationContext) {

        AutowiringSpringBeanToJobFactoryzytest jobFactory = new AutowiringSpringBeanToJobFactoryzytest();

        jobFactory.setApplicationContext(applicationContext);

        return jobFactory;

    }



    //配置JobFactory,为quartz作业添加自动连接支持

    public final class AutowiringSpringBeanToJobFactoryzytest extends SpringBeanJobFactory implements

            ApplicationContextAware {

        private transient AutowireCapableBeanFactory beanFactory;

        @Override

        public void setApplicationContext(final ApplicationContext context) {

            beanFactory = context.getAutowireCapableBeanFactory();

        }

        @Override

        protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {

            final Object job = super.createJobInstance(bundle);

            beanFactory.autowireBean(job);

            return job;

        }

    }

    /**

     * SchedulerFactoryBean这个类的真正作用提供了对org.quartz.Scheduler的创建与配置，并且会管理它的生命周期与Spring同步。

     * org.quartz.Scheduler: 调度器。所有的调度都是由它控制。

     */

    @Bean

    public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactoryzytest, Trigger zytestTigger1) throws IOException {

        SchedulerFactoryBean factory = new SchedulerFactoryBean();

        //可选,QuartzScheduler启动时更新己存在的Job,这样就不用每次修改targetObject后删除qrtz_job_details表对应记录

        factory.setOverwriteExistingJobs(true);

        factory.setAutoStartup(true); //设置自行启动

        factory.setDataSource(dataSource);//为SchedulerFactory配置数据源

        factory.setJobFactory(jobFactoryzytest);

        factory.setQuartzProperties(quartzProperties());

        factory.setTriggers(zytestTigger1);

        return factory;

    }



    @Bean

    public CronTriggerFactoryBean zytestTigger1(JobDetail zyJobDetail1){

        //通过 tigger.setJobDetail(zyJobDetail1);  和 tigger.setCronExpression(cronExperessionTask1);

        // 将定时策略和具体执行类关联起来

        CronTriggerFactoryBean tigger = new CronTriggerFactoryBean();

        tigger.setJobDetail(zyJobDetail1);

        tigger.setStartDelay(2000);//设置延迟启动

        tigger.setCronExpression(cronExperessionTask1);//添加定时策略

        return tigger;

    }



    @Bean

    JobDetailFactoryBean zyJobDetail1(){

        JobDetailFactoryBean jobDetai = new JobDetailFactoryBean();

        jobDetai.setDurability(true);

        jobDetai.setRequestsRecovery(true);

        //配置定时任务的执行类

        jobDetai.setJobClass(JobService1.class);

        return jobDetai;

    }



    /*

    * 若要添加新的定时策略任务

    * 1.在配置文件中配置定时策略

    * 2.在本类中用@Value标签进行注入

    * 3.向容器中添加新的JobDetailFactoryBean 对象，如zyJobDetail1，

    *   将执行类JobService1 和zyJobDetail1关联

    * 4.向容器中添加新的 CronTriggerFactoryBean，如 zytestTigger1，

    *   将执行类和定时策略关联

    *  5.将 zytestTigger1 添加到 SchedulerFactoryBean 中

    *  6.编写执行类，实现Job 接口，覆写execute方法进行具体要定时

    *   执行的操作，如JobService1 类。

    * */

}

6.  编写具体要定时执行的任务执行的

package com.zytest.springbootmybatis.zydemo.quartz_demo.job;



import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;



import java.text.SimpleDateFormat;

import java.util.Date;



public class JobService1 implements Job {

    @Override

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        System.out.println("定时任务开始执行" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));

    }

}

7.  启动微服务

1）quartz在数据库中插入定时执行任务信息

在qrtz_triggers表中存入信息：注意表中信息和config类中添加bean对象的对应关系

2）查看实例中定时任务执行结果

项目实例：

  • SpringBoot整合Quartz作为调度中心完整实用例子

https://www.cnblogs.com/ealenxie/p/9134602.html

  •  
【版权声明】本文为华为云社区用户原创内容，未经允许不得转载，如需转载请自行联系原作者进行授权。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Spring Boot 数据库
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入