重试框架入门：Spring-RetryGuava-Retry

news2024/9/23 11:21:19

前言

在日常工作中，随着业务日渐庞大，不可避免的涉及到调用远程服务，但是远程服务的健壮性和网络稳定性都是不可控因素，因此，我们需要考虑合适的重试机制去处理这些问题，最基础的方式就是手动重试，侵入业务代码去处理，再高端一点的通过切面去处理，较为优雅的实现重试，下面，介绍两个重试框架，只需要配置好重启策略及重试任务，即可使用。

重试任务

这里只是模拟传参、相应及异常，具体任务需对应业务

package com.example.test.MessageRetry;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.springframework.remoting.RemoteAccessException;

@Slf4j
public class RetryTask {
    /**
     * 重试方法
     * @param param
     * @return
     */
    public static boolean retryTask(String param){
        log.info("请求参数：{}",param);
        int i = RandomUtils.nextInt(0,15);
        log.info("随机数：{}",i);
        if(i == 0){
            log.error("参数异常");
            throw new IllegalArgumentException("参数异常");
        }else if(i > 10){
            log.error("访问异常");
            throw new RemoteAccessException("访问异常");
        }else if(i % 2 == 0){
            log.info("成功");
            return true;
        }else{
            log.info("失败");
            return false;
        }
    }
}

Spring-Retry

简介

Spirng-Retry是Spring提供的一个重试框架，为spring程序提供声明式重试支持，主要针对可能抛出异常的调用操作，进行有策略的重试。可以通过代码方式和注解方式实现，主要由重试执行者和两个策略构成：

  • RetryTemplet：重试执行者，可以设置重试策略（设置重试上线、如何重试）和回退策略（立即重试还是等待一段时间后重试，默认立即重试，如果需要配置等待一段时间后重试则需要指定回退策略），通过Execute提交执行操作，只有在调用时抛出指定配置的异常，才会执行重试
  • 重试策略：
策略方式
NeverRetryPolicy只允许调用RetryCallback一次，不允许重试
AlwaysRetryPolicy允许无限重试，直到成功，此方式逻辑不当会导致死循环
SimpleRetryPolicy固定次数重试策略，默认重试最大次数为3次，RetryTemplate默认使用的策略
TimeoutRetryPolicy超时时间重试策略，默认超时时间为1秒，在指定的超时时间内允许重试
ExceptionClassifierRetryPolicy设置不同异常的重试策略，类似组合重试策略，区别在于这里只区分不同异常的重试
CircuitBreakerRetryPolicy有熔断功能的重试策略，需设置3个参数openTimeout、resetTimeout和delegate
CompositeRetryPolicy组合重试策略，有两种组合方式，乐观组合重试策略是指只要有一个策略允许即可以重试，悲观组合重试策略是指只要有一个策略不允许即可以重试，但不管哪种组合方式，组合中的每一个策略都会执行
  • 重试回退策略：
回退策略方式
NoBackOffPolicy无退避算法策略，每次重试时立即重试
FixedBackOffPolicy固定时间的退避策略，需设置参数sleeper和backOffPeriod，sleeper指定等待策略，默认是Thread.sleep，即线程休眠，backOffPeriod指定休眠时间，默认1秒
UniformRandomBackOffPolicy随机时间退避策略，需设置sleeper、minBackOffPeriod和maxBackOffPeriod，该策略在minBackOffPeriod,maxBackOffPeriod之间取一个随机休眠时间，minBackOffPeriod默认500毫秒，maxBackOffPeriod默认1500毫秒
ExponentialBackOffPolicy指数退避策略，需设置参数sleeper、initialInterval、maxInterval和multiplier，initialInterval指定初始休眠时间，默认100毫秒，maxInterval指定最大休眠时间，默认30秒，multiplier指定乘数，即下一次休眠时间为当前休眠时间*multiplier
ExponentialRandomBackOffPolicy随机指数退避策略，引入随机乘数可以实现随机乘数回退
  • 此外，还需要配置重试时间间隔、最大重试次数以及可重试异常

实现

代码方式

RetryTemplate通过execute提交执行操作，需要准备RetryCallback和RecoveryCallback两个类实例，前者对应的就是重试回调逻辑实例，包装正常的功能操作，RecoveryCallback实现的是整个执行操作结束的恢复操作实例，只有在调用的时候抛出了异常，并且异常是在exceptionMap中配置的异常，才会执行重试操作，否则就调用到excute方法的第二个执行方法RecoveryCallback中

package com.example.test.MessageRetry;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.remoting.RemoteAccessException;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.retry.backoff.FixedBackOffPolicy;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.support.RetryTemplate;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;

@Service
@Slf4j
public class SpringRetryService {
    /**
     * 重试时间间隔ms，默认1000ms
     */
    private long retryPeriodTime = 5000L;
    /**
     * 最大重试次数
     */
    private int maxRetryNum = 3;
    /**
     * 哪些结果和异常要重试，key表示异常类型，value表示是否需要重试
     */
    private Map<Class<? extends Throwable>,Boolean> retryMap = new HashMap<>();

    @Test
    public void test(){
        retryMap.put(IllegalArgumentException.class,true);
        retryMap.put(RemoteAccessException.class,true);

        //构建重试模板
        RetryTemplate retryTemplate = new RetryTemplate();
        //设置重试回退操作策略，主要设置重试时间间隔
        FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
        backOffPolicy.setBackOffPeriod(retryPeriodTime);
        //设置重试策略，主要设置重试次数
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(maxRetryNum,retryMap);

        retryTemplate.setRetryPolicy(retryPolicy);
        retryTemplate.setBackOffPolicy(backOffPolicy);

        Boolean execute = retryTemplate.execute(
                //RetryCallback
                retryContext -> {
                    boolean b = RetryTask.retryTask("aaa");
                    log.info("调用结果：{}",b);
                    return b;
                },
                retryContext -> {
                    //RecoveryCallback
                    log.info("到达最多尝试次数");
                    return false;
                }
        );
        log.info("执行结果：{}",execute);
    }
}

在这里插入图片描述

注解方式

上面我们说到Spring-Retry是Spring提供的，那么，它就支持依赖整合

<!--spring-retry-->
        <dependency>
            <groupId>org.springframework.retry</groupId>
            <artifactId>spring-retry</artifactId>
            <version>1.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.1</version>
        </dependency>

然后，在启动类上添加开启注解

//表示是否开启重试，属性proxyTargetClass，boolean类型，是否创建基于子类（CGLIB）的代理，而不是标准的基于接口的代理，默认false
@EnableRetry

package com.example.test.MessageRetry;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.springframework.remoting.RemoteAccessException;

@Slf4j
public class RetryTask {
    /**
     * 重试方法
     * @param param
     * @return
     */
    public static boolean retryTask(String param){
        log.info("请求参数：{}",param);
        int i = RandomUtils.nextInt(0,15);
        log.info("随机数：{}",i);
        if(i >-1){
            log.error("参数异常");
            throw new IllegalArgumentException("参数异常");
//        }else if(i > 10){
//            log.error("访问异常");
//            throw new RemoteAccessException("访问异常");
//        }else if(i % 2 == 0){
//            log.info("成功");
//            return true;
        }else{
            log.info("失败");
            return false;
        }
    }
}


/**
     * 重试调用方法
     * @param param
     * @return
     * @Retryable注解：
     *
     */
    @Retryable(value = {RemoteAccessException.class,IllegalArgumentException.class},maxAttempts = 3,backoff = @Backoff(delay = 5000L,multiplier = 2))
    public void call(String param){
        RetryTask.retryTask(param);
    }

    /**
     * 达到最大重试次数，或抛出了没有指定的异常
     * @param e
     * @param param
     * @return
     */
    @Recover
    public void recover(Exception e,String param){
        log.error("达到最大重试次数！！！！！");
    }

@Test
    public void retry(){
        springRetryService.call("aaa");
    }
  • @Retryable注解说明
属性说明
value指定重试的异常类型，默认为空
maxAttempts最大尝试次数，默认3次
include和value一样，默认为空，当exclude也为空时，默认所有异常
exclude指定不处理的异常
Backoff重试策略
  • @Backoff注解说明：设定重试倍数，每次重试时间是上次的n倍
属性说明
delay重试之间的等待时间(以毫秒为单位)，默认0
maxDelay重试之间的最大等待时间(以毫秒为单位)，默认0
multiplier延迟的倍数，默认0.0
delayExpression重试之间的等待时间表达式，默认空
maxDelayExpression重试之间的最大等待时间表达式，默认空
multiplierExpression指定延迟的倍数表达式，默认空
random随机指定延迟时间，默认false

  • @Recover注解说明：当重试到达指定次数时，将要回调的方法

  • @Retryable和@Recover修饰的方法要在同一个类中,且被@Retryable和@Recover标记的方法不能有返回值，这样Recover方法才会生效。由于@Retryable注解是通过切面实现的，因此我们要避免@Retryable 注解的方法的调用方和被调用方处于同一个类中，因为这样会使@Retryable 注解失效。
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/22e61f2d194e4ac0aa061fa4ca7d483f.png
    我们可以看到，Spring-Retry只能针对指定异常重试，不能根据执行结果返回值重试，整体使用也比较死板，下面，看下更加灵活的Guava-Retry。

Guava-Retry

简介

Guava-Retry是谷歌的Guava库的一个小扩展，允许为任意函数调用创建可配置的重试策略，我们可以通过构建重试实例RetryBuilder，来设置重试源、配置重试次数、重试超时时间、等待时间间隔等，实现优雅的重试机制。

  • 主要属性
属性说明
attemptTimeLimiter时间限制策略，单次任务执行时间限制，超时终止
stopStrategy停止重试策略
waitStrategy等待策略
blockStrategy任务阻塞策略，即当前任务执行完，下次任务执行前做什么，仅有线程阻塞threadSleepStrategy
retryException重试异常（重试策略）
listeners自定义重试监听器，可用于记录日志等
  • 时间限制策略
策略说明
NoAttemptTimeLimit对代理方法不添加时间限制，默认
FixedAttemptTimeLimit对代理方法的尝试添加固定时间限制
  • 重试策略（重试异常）
策略说明
retryIfException抛出 runtime 异常、checked 异常时都会重试，但是抛出 error 不会重试
retryIfRuntimeException只会在抛 runtime 异常的时候才重试，checked 异常和error 都不重试
retryIfExceptionOfType允许我们只在发生特定异常的时候才重试，比如NullPointerException 和 IllegalStateException 都属于 runtime 异常，也包括自定义的error
retryIfResult可以指定你的 Callable 方法在返回值的时候进行重试
  • 停止策略
策略说明
StopAfterDelayStrategy设定最长执行时间，无论任务执行几次，一旦超时，任务终止，返回RetryException
StopAfterAttemptStrategy设定最大尝试次数，一旦超过，返回重试异常
NeverStopStrategy一直轮询直到获取期望结果
  • 等待策略
策略说明
ExceptionWaitStrategy异常时长等待，如果抛出的是指定异常，则从传入的方法中取得等待时间并返回；如果异常不匹配，则返回等待时间为0L
CompositeWaitStrategy复合时长等待，在获取等待时间时会获取多种等待策略各自的等待时间，然后累加这些等待时间
FibonacciWaitStrategy斐波那契等待策略
ExponentialWaitStrategy指数等待时长，指数增长，若设置了最大时间，则停止，否则到Long.MAX_VALUE
IncrementingWaitStrategy递增等待，提供一个初始时长和步长，随次数叠加
RandomWaitStrategy随机等待时长，可以提供一个最大和最小时间，从范围内随机
FixedWaitStrategy固定等待时长

代码

<!--guava-retryer-->
        <dependency>
            <groupId>com.github.rholder</groupId>
            <artifactId>guava-retrying</artifactId>
            <version>2.0.0</version>
        </dependency>

package com.example.test.MessageRetry;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.springframework.remoting.RemoteAccessException;

@Slf4j
public class RetryTask {
    /**
     * 重试方法
     * @param param
     * @return
     */
    public static boolean retryTask(String param){
        log.info("请求参数：{}",param);
        int i = RandomUtils.nextInt(0,15);
        log.info("随机数：{}",i);
        if(i < 3){
            log.error("参数异常");
            throw new IllegalArgumentException("参数异常");
        }else if(i > 10){
            log.error("访问异常");
            throw new RemoteAccessException("访问异常");
        }else if(i % 2 == 0){
            log.info("成功");
            return true;
        }else{
            log.info("失败");
            return false;
        }
    }
}


package com.example.test.MessageRetry;

import com.github.rholder.retry.*;
import com.google.common.base.Predicates;
import lombok.extern.slf4j.Slf4j;
import org.springframework.remoting.RemoteAccessException;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
@Slf4j
public class GuavaRetryService {
   
    public void guavaRetry(){
        //构建重试实例RetryBuilder，可以设置重试源，可以配置重试次数、重试超时时间、等待时间间隔
        Retryer<Boolean>retryer = RetryerBuilder.<Boolean>newBuilder()
                //设置异常重试源
                .retryIfExceptionOfType(RemoteAccessException.class)
                .retryIfExceptionOfType(IllegalArgumentException.class)
                //设置根据结果重试  res->res==false  Predicates.containsPattern("_error$")
                .retryIfResult(Predicates.equalTo(false))
                //设置等待时间
                .withWaitStrategy(WaitStrategies.fixedWait(3, TimeUnit.SECONDS))
                //设置最大重试次数
                .withStopStrategy(StopStrategies.stopAfterAttempt(3))
                //设置重试监听，可用作重试时的额外动作
                .withRetryListener(new RetryListener() {
                    @Override
                    public <V> void onRetry(Attempt<V> attempt) {
                        log.error("第【{}】次调用失败",attempt.getAttemptNumber());
                    }
                })
                //设置阻塞策略
                .withBlockStrategy(BlockStrategies.threadSleepStrategy())
                //设置时间限制
                .withAttemptTimeLimiter(AttemptTimeLimiters.noTimeLimit())
                .build();
        try{
            retryer.call(()->RetryTask.retryTask("aaa"));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

可以看到，我们设置了重试三次，超过这个限制没有执行成功，抛出了重试异常，而且也可以根据我们的返回结果来判断。

总结

Spring-Retry和Guava-Retry都是线程安全的重试框架，能够保证并发业务下重试逻辑的正确性。两者都很好的将正常方法和重试方法进行了解耦，可以设置超时时间、重试次数、间隔时间、监听结果等，相比来说，Guava-Retry比Spring-Retry更加灵活，并且可以通过返回值来进行重试，两者都是非常好的重试框架，具体的选用看相关的业务场景即可。

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

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

相关文章

Vue3：页面A搜索后跳转到页面B，然后从页面B退回页面A重新搜索，但是得到的页面B得刷新一下才会显示正确的数据

Vue3：页面A搜索后跳转到页面B，然后从页面B退回页面A重新搜索，但是得到的页面B得刷新一下才会显示正确的数据

问题 Vue3&#xff1a; 从页面A进行搜索后跳转到页面B&#xff0c;然后从页面B退回页面A重新搜索&#xff0c;但是得到的页面B得刷新一下才会显示正确的数据。 读取数据的代码格式大致如下&#xff08;代码做了一些删减&#xff09;&#xff1a; 解决 会出现上述情况&#…
阅读更多...
DIY 一个 Docker Base Image

DIY 一个 Docker Base Image

1. 我们先使用C语言写一个hello-world程序 vim hello.c # include <stdio.h>int main() {print("hello docker\n"); } 2. 将hello.c文件编译成二进制文件, 需要安装工具 yum install gcc yum install glibc-static 开始编译 gcc -static hello.c -o hello 编译…
阅读更多...
低代码平台“高”效率开发的5个能力

低代码平台“高”效率开发的5个能力

迫于智改数转的压力&#xff0c;促使企业要不停地思考如何从低代码的角度释放一些重复枯燥又高成本的人力投入。历经多次重大重构及大量项目实战验证之后&#xff0c;个人认为一款高效率的低代码开发平台&#xff0c;应有以下几点能力。 一、低代码平台“高”效率开发的5个能力…
阅读更多...
ES索引重建reindex详解

ES索引重建reindex详解

目录 一、使用场景 二、reindex介绍 三、使用手册 1、覆盖更新 2、创建丢失的文档并更新旧版本的文档 3、仅创建丢失的文档 4、冲突处理 5、source中添加查询条件 6、source中包含多个源索引 7、限制处理的记录数 8、从远程ES集群中重建索引 9、提取随机子集 10、…
阅读更多...
Java实现轻量型Web服务器接收http协议提交的RFID读卡信息

Java实现轻量型Web服务器接收http协议提交的RFID读卡信息

示例使用的读卡器&#xff1a;RFID网络WIFI无线TCP/UDP/HTTP可编程二次开发读卡器POE供电语音-淘宝网 (taobao.com) import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.ServerSock…
阅读更多...
Java-day07(面向对象-3,4)

Java-day07(面向对象-3,4)

继承 将多个类中共有的属性&#xff0c;方法剥离出来单独创建一个共有类&#xff0c;当需要使用共有的属性与方法时&#xff0c;就可以通过继承(extends)来调用共有的属性与方法。通过"class A extends B" 来实现类的继承&#xff08;子类&#xff1a;A 父类&#x…
阅读更多...
手把手教你 使用SpringBoot 实现业务数据动态脱敏

手把手教你 使用SpringBoot 实现业务数据动态脱敏

文章目录 什么是数据脱敏静态数据脱敏动态数据脱敏 需求实现1. 切面AOP实现脱敏是否脱敏注解定义切入点测试单条记录结果多条记录结果分页记录结果 2. 自定义注解和自定义消息转换器实现数据脱敏自定义DataDesensitization注解定义脱敏类型枚举实现AnnotationFormatterFactory接…
阅读更多...
SAP度量单位转换功能

SAP度量单位转换功能

针对今天N2项目提出业务痛点&#xff1a;物料30011110的基本单位是KG&#xff0c;在XXX的BOM里单位是G&#xff0c;由于物料没配单位转换关系&#xff0c;但系统又能正常进行转换&#xff0c;开发需要技术支持。 经专项调查&#xff0c;G和KG的转换是SAP相同量纲转换标准功能&…
阅读更多...
econml双机器学习实现连续干预和预测

econml双机器学习实现连续干预和预测

连续干预 在这个示例中&#xff0c;我们使用LinearDML模型&#xff0c;使用随机森林回归模型来估计因果效应。我们首先模拟数据&#xff0c;然后模型&#xff0c;并使用方法来effect创建不同干预值下的效应&#xff08;Conditional Average Treatment Effect&#xff0c;CATE&…
阅读更多...
现在转行搞嵌入式找工作难不难啊？

现在转行搞嵌入式找工作难不难啊？

对于应届生来说&#xff0c;嵌入式开发的经验不会有太多&#xff0c;所以要求也不会太高。 嵌入式开发常用的是C语言&#xff0c;所以需要你有扎实的功底&#xff0c;这一点很重要&#xff0c;数据结构算法&#xff0c;指针&#xff0c;函数&#xff0c;网络编程 有了上面的基…
阅读更多...
微服务——数据同步

微服务——数据同步

问题分析 mysql和redis之间有数据同步问题&#xff0c;ES和mysql之间也有数据同步问题。 单体项目可以在crud时就直接去修改&#xff0c;但在微服务里面不同的服务不行。 方案一 方案二 方案三 总结 导入酒店管理项目 倒入完成功启动后可以看见数据成功获取到了 声明队列和…
阅读更多...
word横向页面侧面页码设置及转pdf后横线变竖线的解决方案

word横向页面侧面页码设置及转pdf后横线变竖线的解决方案

在处理材料的时候&#xff0c;会遇到同一个文档里自某一页开始&#xff0c;页面布局是横向的&#xff0c;这时候页码要设置在侧面&#xff0c;方法是双击页脚&#xff0c;然后在word工具栏上选择“插入”——>“文本框”——>“绘制竖版文本框”&#xff0c;然后在页面左…
阅读更多...
Air001基于Arduino点灯实验

Air001基于Arduino点灯实验

Air001基于Arduino点灯实验 &#x1f449;&#x1f3fb;Arduino平台环境搭建可以参考&#xff1a;https://wiki.luatos.com/chips/air001/Air001-Arduino.html &#x1f516;使用国内的json&#xff0c;安装不仅成功率高还非常的快速。&#xff08;当然取决于个人网络环境&…
阅读更多...
Windows安装Redis

Windows安装Redis

自己电脑做个测试&#xff0c;需要用到Redis&#xff0c;把安装过程记录下&#xff0c;方便有需要的人 1、找到下载地址&#xff1a;Releases microsoftarchive/redis GitHub Windows的Redis需要到GitHub上下载&#xff1a; 2、下载完后设置密码&#xff0c;打开文件夹&…
阅读更多...
RemObjects Suite Subscription for Delphi Crack

RemObjects Suite Subscription for Delphi Crack

RemObjects Suite Subscription for Delphi Crack Delphi的RemObjects套件订阅提供了一种方便且经济高效的方式&#xff0c;可以随时了解所有RemObjects Delphi产品的最新情况。它允许您访问所有当前和即将推出的产品&#xff0c;而不必担心错过重要的更新或新产品。当您的平台…
阅读更多...
医院智慧运营管理数字化方案

医院智慧运营管理数字化方案

近年来&#xff0c;随着医院的发展规模不断扩大&#xff0c;其人、财、物、技术等资源的配置活动愈加复杂&#xff0c;资产管理、成本管理、收支核算管理、资金预算管理、绩效管理等经济活动日常管理也日益繁重&#xff0c;医院对于数字化提升精细化管理的需求也愈发迫切。 国…
阅读更多...
块、行内块水平垂直居中

块、行内块水平垂直居中

1.定位实现水平垂直居中 <div class"outer"><div class"test inner1">定位实现水平垂直居中</div></div><style>.outer {width: 300px;height: 300px;border: 1px solid gray;margin: 100px auto 0;position: relative;}.te…
阅读更多...
DeepSort算法简介

DeepSort算法简介

SORT算法 SORT(Simple Online and Realtime Tracking)算法是一种目标追踪算法&#xff0c;其简单有效&#xff0c;基于IOU来匹配&#xff0c;并且融入了卡尔曼滤波和匈牙利算法来降低ID Switch(可以说&#xff0c;追踪算法的目标只有两个&#xff1a;1.提高速度 2.降低ID Swit…
阅读更多...
JMeter有对手了？RunnerGo这些功能真不错！

JMeter有对手了？RunnerGo这些功能真不错！

当谈到对于性能测试的需求时&#xff0c;JMeter和RunnerGo在测试场景设置、执行性能测试、性能测试结果分析等方面都提供了很多功能&#xff0c;但两个工具仍然存在一些区别。以下是详细的比较分析&#xff1a; 层次分明的模块化设计告别文件管理混乱&#xff1a; JMeter的设…
阅读更多...
SpringBoot异步框架

SpringBoot异步框架

参考&#xff1a;解剖SpringBoot异步线程池框架_哔哩哔哩_bilibili 1、 为什么要用异步框架&#xff0c;它解决什么问题&#xff1f; 在SpringBoot的日常开发中&#xff0c;一般都是同步调用的。但经常有特殊业务需要做异步来处理&#xff0c;例如&#xff1a;注册新用户&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023