分布式锁 starter

最新推荐文章于 2023-03-11 16:51:26 发布
最新推荐文章于 2023-03-11 16:51:26 发布
阅读量283 收藏
点赞数
分类专栏： 开源共享 文章标签： 分布式 spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/javacoo/article/details/122229028
版权

lock-spring-boot-starter

分布式锁 starter

介绍

说明

工程接口(扩展点)：

         接口->com.javacoo.lock.client.api.Lock

基于xkernel 提供的SPI机制，结合SpringBoot注解 ConditionalOnBean,ConditionalOnProperty实现。

类关系图

Lock.png

项目结构

lock-spring-boot-starter
 └── src
    ├── main  
    │	├── java  
    │	│   └── com.javacoo 
    │	│	├────── lock
    │	│	│         ├──────client
    │   │   │         │         ├── api
    │   │   │         │         │     ├── annotation
    │   │   │         │         │     │      └── MethodLock 锁注解
    │   │   │         │         │     ├── client
    │   │   │         │         │     │      └── Lock 锁接口
    │   │   │         │         │     ├── aspect
    │   │   │         │         │     │      └── LockAspect 锁切面
    │   │   │         │         │     ├── config
    │   │   │         │         │     │      └── LockConfig 锁配置
    │   │   │         │         │     ├── exception
    │   │   │         │         │            └── LockException 锁异常
    │   │   │         │         └── internal 接口内部实现
    │   │   │         │               ├── redis
    │   │   │         │                      ├── RedissionConfig Redission配置类
    │   │   │         │                      └── RedssionLock 锁接口实现类
    │	│	│         └──────starter
    │   │   │                   ├── LockAutoConfiguration 自动配置类
    │   │   │                   └── LockHolder 锁接口对象持有者
    │	└── resource  
    │	    ├── META-INF
    │             └── ext
    │	               └── internal
    │	                       └── com.javacoo.lock.client.api.Lock
    └── test  测试

如何使用

  1. pom依赖：

    <dependency>
   <groupId>com.javacoo</groupId>
   <artifactId>lock-spring-boot-starter</artifactId>
   <version>1.0.0</version>
</dependency>

  2. 配置参数，如果使用默认实现，则无需配置，如要扩展则需要，配置如下：

    #lock是否可用,默认可用
lock.enabled = true
#lock实现，默认内部实现
lock.impl = default

  3. 方法加注解，如：

     @MethodLock(fieldName = "applNo")
 @Override
 public BaseResponse gjjloanConfirm(LoanConfirmRequest request)

SPI扩展

基于xkernel 提供的SPI机制，扩展非常方便，大致步骤如下：

  1. 实现锁接口：如 com.xxxx.xxxx.MyLockImpl

  2. 配置锁接口：

    • 在项目resource目录新建包->META-INF->services

    • 创建com.javacoo.lock.client.api.Lock文件，文件内容：实现类的全局限定名，如：

      myLock=com.xxxx.xxxx.MyLockImpl

    • 修改配置文件，添加如下内容:

    #lock实现
lock.impl = myLock

默认实现

1、锁接口：

/**
 * 锁接口
 * <li></li>
 *
 * @author: duanyong
 * @since: 2020/6/22 10:19
 */
@Spi(LockConfig.DEFAULT_IMPL)
public interface Lock<T> {
    /**超时时间*/
    int TIMEOUT_SECOND = 60;
    /**
     * 对lockKey加锁
     * <li></li>
     * @author duanyong
     * @date 2020/6/22 10:30
     * @param lockKey:lockKey
     * @return: T 锁对象
     */
    T lock(String lockKey);
    /**
     * 对lockKey加锁,timeout后过期
     * <li></li>
     * @author duanyong
     * @date 2020/6/22 10:31
     * @param lockKey: lockKey
     * @param timeout: 锁超时时间，单位：秒
     * @return: T 锁对象
     */
    T lock(String lockKey, int timeout);
    /**
     * 对lockKey加锁,指定时间单位，timeout后过期
     * <li></li>
     * @author duanyong
     * @date 2020/6/22 10:33
     * @param lockKey: lockKey
     * @param unit: 时间单位
     * @param timeout: 锁超时时间
     * @return: T 锁对象
     */
    T lock(String lockKey, TimeUnit unit , int timeout);
    /**
     * 尝试获取锁
     * <li></li>
     * @author duanyong
     * @date 2020/6/22 10:35
     * @param lockKey: lockKey
     * @return: boolean 是否成功,成功返回:true
     */
    boolean tryLock(String lockKey);
    /**
     * 尝试获取锁
     * <li></li>
     * @author duanyong
     * @date 2020/6/22 10:35
     * @param lockKey: lockKey
     * @param waitTime:最多等待时间
     * @param timeout:上锁后自动释放锁时间
     * @return: boolean 是否成功,成功返回:true
     */
    boolean tryLock(String lockKey, int waitTime, int timeout);
    /**
     * 尝试获取锁
     * <li></li>
     * @author duanyong
     * @date 2020/6/22 10:36
     * @param lockKey: lockKey
     * @param unit:时间单位
     * @param waitTime:最多等待时间
     * @param timeout:上锁后自动释放锁时间
     * @return: boolean 是否成功,成功返回:true
     */
    boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int timeout);
    /**
     * 释放锁
     * <li></li>
     * @author duanyong
     * @date 2020/6/22 10:37
     * @param lockKey: lockKey
     * @return: void
     */
    void unlock(String lockKey);
    /**
     * 释放锁
     * <li></li>
     * @author duanyong
     * @date 2020/6/22 10:37
     * @param lock:锁对象
     * @return: void
     */
    void unlock(T lock);
}

2、实现锁接口，如默认实现：

/**
 * 锁接口实现类
 * <li>基于Redssion</li>
 *
 * @author: duanyong
 * @since: 2020/6/22 10:39
 */
@Slf4j
public class RedssionLock implements Lock<RLock> {
    /**约定缓存前缀：appId:模块:key*/
    public static final String CACHE_PREFIX_KEY ="javacoo:service:lock:";
    @Autowired
    private RedissonClient redissonClient;
    /**
     * 对lockKey加锁
     * <li>阻塞获取锁</li>
     *
     * @param lockKey :lockKey
     * @author duanyong
     * @date 2020/6/22 10:30
     * @return: T 锁对象
     */
    @Override
    public RLock lock(String lockKey) {
        log.info(">>>>> lock key[{}]",lockKey);
        Assert.hasText(lockKey,"lockKey 不能为空");
        RLock lock = redissonClient.getLock(CACHE_PREFIX_KEY +lockKey);
        lock.lock();
        return lock;
    }

    /**
     * 对lockKey加锁,timeout后过期
     * <li></li>
     *
     * @param lockKey : lockKey
     * @param timeout : 锁超时时间，单位：秒
     * @author duanyong
     * @date 2020/6/22 10:31
     * @return: T 锁对象
     */
    @Override
    public RLock lock(String lockKey, int timeout) {
        return lock(lockKey, TimeUnit.SECONDS,timeout);
    }

    /**
     * 对lockKey加锁,指定时间单位，timeout后过期
     * <li></li>
     *
     * @param lockKey : lockKey
     * @param unit : 时间单位
     * @param timeout : 锁超时时间
     * @author duanyong
     * @date 2020/6/22 10:33
     * @return: T 锁对象
     */
    @Override
    public RLock lock(String lockKey, TimeUnit unit, int timeout) {
        log.info(">>>>> lockKey:{},TimeUnit:{},timeout:{}",lockKey,unit,timeout);
        Assert.hasText(lockKey,"lockKey 不能为空");
        RLock lock = redissonClient.getLock(CACHE_PREFIX_KEY +lockKey);
        lock.lock(timeout, unit);
        return lock;
    }

    /**
     * 尝试获取锁
     * <li>获取锁失败立即返回，上锁后60秒自动释放锁</li>
     *
     * @param lockKey : lockKey
     * @author duanyong
     * @date 2020/6/22 10:35
     * @return: boolean 是否成功,成功返回:true
     */
    @Override
    public boolean tryLock(String lockKey) {
        return tryLock(lockKey,0,60);
    }

    /**
     * 尝试获取锁
     * <li></li>
     *
     * @param lockKey : lockKey
     * @param waitTime :最多等待时间
     * @param timeout :上锁后自动释放锁时间
     * @author duanyong
     * @date 2020/6/22 10:35
     * @return: boolean 是否成功,成功返回:true
     */
    @Override
    public boolean tryLock(String lockKey, int waitTime, int timeout) {
        return tryLock(lockKey, TimeUnit.SECONDS,waitTime,timeout);
    }

    /**
     * 尝试获取锁
     * <li></li>
     *
     * @param lockKey : lockKey
     * @param unit :时间单位
     * @param waitTime :最多等待时间
     * @param timeout :上锁后自动释放锁时间
     * @author duanyong
     * @date 2020/6/22 10:36
     * @return: boolean 是否成功,成功返回:true
     */
    @Override
    public boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int timeout) {
        Assert.hasText(lockKey,"lockKey 不能为空");
        lockKey = CACHE_PREFIX_KEY +lockKey;
        log.info(">>>>> tryLock lockKey:{},TimeUnit:{},waitTime:{},timeout:{}",lockKey,unit,waitTime,timeout);
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, timeout, unit);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("尝试获取锁:{}，TimeUnit:{},waitTime:{},timeout:{},失败",lockKey,unit,waitTime,timeout,e);
        }
        return false;
    }

    /**
     * 释放锁
     * <li></li>
     *
     * @param lockKey : lockKey
     * @author duanyong
     * @date 2020/6/22 10:37
     * @return: void
     */
    @Override
    public void unlock(String lockKey) {
        lockKey = CACHE_PREFIX_KEY +lockKey;
        try {
            RLock lock = redissonClient.getLock(lockKey);
            if(!lock.isLocked()){
                log.error(">>>>> unlock lockKey fail:{},isLocked:{}",lockKey,lock.isLocked());
                return;
            }
            if(!lock.isHeldByCurrentThread()){
                log.error(">>>>> unlock lockKey fail:{},isHeldByCurrentThread:{}",lockKey,lock.isHeldByCurrentThread());
                return;
            }
            lock.unlock();
            log.info(">>>>> unlock lockKey success:{}",lockKey);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("释放锁失败:{}",lockKey,e);
        }
    }

    /**
     * 释放锁
     * <li></li>
     *
     * @param lock :锁对象
     * @author duanyong
     * @date 2020/6/22 10:37
     * @return: void
     */
    @Override
    public void unlock(RLock lock) {
        lock.unlock();
    }

3、锁注解

/**
 * 服务锁注解
 * <li></li>
 * @author duanyong
 * @date 2020/10/14 9:20
 */
@Documented
@Inherited
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodLock {

    /**
     * 指定需要加入锁的字段
     * <li></li>
     * @author duanyong
     * @date 2020/10/14 9:21
     * @return: java.lang.String[]
     */
    String[] fieldName() default {};
    /**
     * 锁的有效时间，单位为秒，默认值为60
     * <li></li>
     * @author duanyong
     * @date 2020/10/14 9:21
     * @return: int
     */
    int timeInSecond() default 60;
    /**
     * 指定字段在参数列表中的索引
     * <li></li>
     * @author duanyong
     * @date 2020/10/14 9:22
     * @return: int
     */
    int paramIndex() default 0;
}

4、锁切面

/**
 * 业务拦截器
 * <li></li>
 * @author duanyong
 * @date 2021/3/1 15:56
 */
@Slf4j
@Aspect
@Component
public class LockAspect {
    /**锁对象*/
    @Autowired
    private Lock lock;


    @Around("@annotation(methodLock)")
    public Object around(ProceedingJoinPoint joinPoint, MethodLock methodLock) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 获取被拦截的方法
        Method method = signature.getMethod();
        // 获取被拦截的类名
        String className = signature.getDeclaringType().getSimpleName();
        // 获取被拦截的方法名
        String methodName = method.getName();
        log.info("[加锁交易]请求开始,方法口名:{}", className+"."+methodName);
        //生成锁KEY
        String lockKey = generateKey(joinPoint.getArgs(),className,methodName,methodLock);
        if(tryLock(lockKey,methodLock)){
            try {
                log.info("[加锁交易]加锁成功,MethodName:{},key:{}",methodName,lockKey);
                return joinPoint.proceed();
            } catch (Exception e) {
                log.error("[加锁交易]执行方法发生异常,MethodName:{},lockKey:{},Exception:{}",methodName,lockKey,e);
                throw e;
            }finally {
                lock.unlock(lockKey);
                log.info("[加锁交易]方法解锁,MethodName:{},key:{}",methodName,lockKey);
            }
        }else{
            log.error("[加锁交易]过滤频繁操作,加锁失败,Key:{}",lockKey);
        }
        return null;
    }

    /**
     * 对添加RedisLock注解的方法进行重复访问限制
     * @param cacheKey
     * @param methodLock
     */
    private boolean tryLock(String cacheKey,MethodLock methodLock) {
        boolean isLocked = lock.tryLock(cacheKey, TimeUnit.SECONDS,0,methodLock.timeInSecond());
        if(isLocked){
            log.info("[交易系统拦截器]加锁成功,KEY:{}",cacheKey);
        }
        return isLocked;
    }
    /**
     * 生成锁的key key=类名-方法名-参数集合
     * <li></li>
     * @author duanyong
     * @date 2021/4/29 13:08
     * @param args: 参数
     * @param className: 类名
     * @param methodName: 方法名
     * @param methodLock: 锁接口
     * @return: java.lang.String 锁的key
     */
    private String generateKey(Object[] args, String className, String methodName,MethodLock methodLock) throws Exception {
        //根据参数列表索引获取入参 默认为第一个参数
        Object param = args[methodLock.paramIndex()];
        List<String> fieldValueList = new ArrayList<>();
        String[] fieldNames = methodLock.fieldName();
        if(param instanceof String){
            fieldValueList.add(String.valueOf(param));
        }else if(param instanceof Long){
            fieldValueList.add(String.valueOf(param));
        }else{
            String jsonString = JSON.toJSONString(param);
            JSONObject jsonObject = JSON.parseObject(jsonString);
            for (String filedName:fieldNames){
                if(jsonObject.containsKey(filedName)){
                    fieldValueList.add(jsonObject.getString(filedName));
                }
            }
        }

        StringBuilder keyBuilder = new StringBuilder();
        keyBuilder.append(className)
            .append("-")
            .append(methodName)
            .append("-")
            .append(fieldValueList);
        return keyBuilder.toString();
    }
}

5、锁接口对象持有者

/**
 * 锁接口对象持有者
 * <li></li>
 *
 * @author: duanyong
 * @since: 2021/3/16 8:56
 */
public class LockHolder {
    /** 锁对象*/
    static Lock lock;

    public static Optional<Lock> getLock() {
        return Optional.ofNullable(lock);
    }
}

6、自动配置。

/**
 * 自动配置类
 * <li></li>
 * @author duanyong
 * @date 2021/3/5 9:50
 */
@Slf4j
@Configuration                                                                                                                              
@EnableConfigurationProperties(value = LockConfig.class)
@ConditionalOnClass(Lock.class)
@ConditionalOnProperty(prefix = LockConfig.PREFIX, value = LockConfig.ENABLED, matchIfMissing = true)
public class LockAutoConfiguration {
	@Autowired                                                                                                                              
    private LockConfig lockConfig;
	@Bean
	@ConditionalOnMissingBean(Lock.class)
	public Lock createLock() {
        log.info("初始化分布式锁,实现类名称:{}",lockConfig.getImpl());
        LockHolder.lock = ExtensionLoader.getExtensionLoader(Lock.class).getExtension(lockConfig.getImpl());
        log.info("初始化分布式锁成功,实现类:{}",LockHolder.lock);
        return LockHolder.lock;
	}

    @Bean
    public LockAspect createLockAspect() {
        return new LockAspect();
    }

}
一些信息
路漫漫其修远兮,吾将上下而求索
码云：https://gitee.com/javacoo
QQ群：164863067
作者/微信：javacoo
邮箱：xihuady@126.com
javacoo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
springboot基于redis分布式锁
11-06
SpringBoot基于redis的分布式锁,有word使用文档,根据文档配置即可使用
Java分布式锁lock-spring-boot-starter的应用
yizhi鬼的专栏
05-09 1723
lock-spring-boot-starter是一个基于Spring Boot的starter机制编写的分布式锁工具。 与其他分布式锁不同的是,使用起来更方便快捷,只需要通过注解@Lock的方式即可实现对方法进行加锁。 官网地址：http://tooleek.gitee.io/lock-spring-boot-starter/ 支持的锁类型 可重入锁、公平锁、联锁、红锁、读锁、写锁 入门...
以spring boot starter搭建redis分布式锁项目
qq_35721287的博客
01-20 597
spring boot starter搭建redis分布式锁项目及原理分析 本文作者：FUNKYE(陈健斌),杭州某互联网公司主程。 前言 demo项目地址 Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。 Redis为什么这么快? (一)纯内存操作，避免大量访问数据库，减少直接读取磁盘数据，redis 将数据储存在内存里面，读写数据的时候都不会受...
实现基于redis的分布式锁并集成spring-boot-starter
litterfrog的博客
10-25 2260
Introduction 基于redis的分布式锁 Features 分布式锁 锁降级（支持锁重试） Quick Start 环境准备 本地安装好redis，启动redis服务（默认端口） 下载代码 从github克隆代码到本地，导入项目 运行测试用例 运行redislock-spring-boot-starter-test里的RedislockTest测试用例 Documentation...
spring-boot-lock-starter基于redis的分布式锁实现
09-20 325
一、软件介绍 spring-boot-lock-starter 是基于redis实现的简单分布式锁。软件面向接口编程，同时兼顾基于zk或者其他实现的方便扩展。基于redis的分布式锁实现，主要依赖以reids 的set命令 和get del 的lua脚本。同时对锁做了注解封装，...
SpringBoot自动装配
mayongzhan_csdn的专栏
09-17 1030
Springboot自动装配-自定义starter实践与踩坑什么是spring-boot的starter自定义starter步骤示例自动装配原理自定义Starter注意事项新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必...
一款基于 Spring Boot Starter 机制的分布式锁框架
05-13
一款基于 Spring Boot Starter 机制的分布式锁框架,实现了redis和zookeeper两种模式的分布式锁功能,以注解的方式(@RLock和@ZLock)对方法进行加锁操作,零代码实现业务加锁能力,涵盖各种加锁方式,并支持redis和...
基于redis的分布式锁spring-boot starter组件
最新发布
11-08
基于redis的分布式锁spring-boot starter组件，使得项目拥有分布式锁能力变得异常简单，支持spring boot，和spirng mvc等spring相关项目
springboot 集成Redission 简单完美解决分布式锁
06-03
springboot 集成Redission 简单完美解决分布式锁,上手看一眼就会
redis-distributed-lock:redis分布式锁工具包，提供纯Java方式调用，支持传统Spring工程， 为spring boot应用提供了starter，更方便快捷的调用
05-17
redis-distributed-lock ... 基于Redisson的分布式锁spring starter实现，可用于实际项目中 redis-distributed-lock-starter调用实例 文档 springboot应用（直接编程方式） 配置文件application.properties中引
java7源码-spring-boot-starter-lock:spring分布式锁
06-04
java7 源码 分布式锁 - starter 基于redis 的 setnx 实现 和 zk 的分布式锁组件 使用场景： case1: bean注入获取锁 application.properties(yml) 配置相关的lockName, 例如： lock.names = test_lock, demo_lock, temp_lock 使用方式如下： import com.example.component; import org.springframework.stereotype.Service; @Service public class CounterService { /** * lockName 来源 application.properties 中配置的 lock.names * 推荐使用 @resource 指定 lockName 的方式获取lockBean * 当然你也可以使用 @Autowired + @Qualifier("test_lock") 获取lockBean * 注意：如果不指定lockName 则默认获取到的 名称为：global_lock 的 l
SpringBoot 自定义starter 与自动配置
晒太阳的猫
03-27 701
SpringBoot的核心就是自动配置，而支持自动配置的是一个个starter项目。除了官方已有的starter，用户自己也可以根据规则自定义自己的starter项目。 本文以自定义一个简单的请求锁为例子，时间有限，简单说下如何自定义一个starter。 一、命名 SpringBoot的官方项目命名方式为spring-boot-starter-xxx 如 spring-boot-starter...
第三章 redis redisson实现分布式锁
qq_36740038的博客
10-20 341
上一章节 通过spring boot 集成了 redis ,本章在上一章的基础上集成 redisson，并实现分布式锁 1.在pom.xml 文件中加入 以下 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> </dependency> <
启动项目时编码格式问题导致的server(s) address(es) not defined异常
ViktorChen的博客
02-08 813
导致server(s) address(es) not defined异常发生的可能原因，提供解决方法
spring boot redis分布式锁
chyk1414的博客
01-02 446
随着现在分布式架构越来越盛行，在很多场景下需要使用到分布式锁。分布式锁的实现有很多种，比如基于数据库、 zookeeper 等，本文主要介绍使用 Redis 做分布式锁的方式，并封装成spring boot starter，方便使用 一. Redis 分布式锁的实现以及存在的问题 锁是针对...
spring-boot-klock-starter分布式锁项目开源
llianlianpay的博客
01-05 4181
前言碎语 spring-boot-klock-starter是一个基于redis的分布式锁spring boot starter组件，使得项目拥有分布式锁能力变得异常简单，支持spring boot，和spirng mvc等spring相关项目， 使用和接入都非常简单方便，现开源出来，给所有需要分布式锁能力的项目提供一个方案 项目地址：https://gitee.com/ke
深入理解 Spring Boot Starters 原理
weixin_34162695的博客
07-25 1994
2019独角兽企业重金招聘Python工程师标准>>> ...
分布式锁工具Redisson，太香了！！
竹林幽深
03-11 369
一、Redisson概述什么是Redisson？Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。
[springboot专栏]使用redisson实现分布式锁
字母哥博客
08-25 1962
Redisson是Redis官方推荐的Java版的Redis客户端（Jedis、letture也是官方推荐的java版本redis客户端程序）。它提供的功能非常多，也非常强大，特别是它默认提供的分布式锁支持功能。，包含多个子项目，对于我们本节比较有用的是集成redisson-spring-data-2x之后能够支持Spring Data redis及RedisTemplate。...
springboot分布式锁
07-29
分布式锁是在分布式系统中用于控制共享资源访问的一种机制。在单机部署的系统中，我们可以使用Java API提供的锁来解决并发控制的问题。但是在分布式系统中，由于多线程、多进程分布在不同的机器上，简单的Java API锁无法满足分布式环境下的并发控制需求。因此，我们需要使用分布式锁来解决这个问题。\[1\] 在Spring Boot项目中使用分布式锁可以借助Redis实现。首先，需要引入相关的Redis依赖，如spring-boot-starter-data-redis和commons-pool2。然后，在代码中使用Redisson等分布式锁框架来获取锁对象，并在需要控制共享资源访问的地方加锁。例如，在Controller中使用Redisson获取锁对象，并在需要进行库存扣减的地方加锁。加锁后，可以执行相应的业务逻辑，确保在同一时间只有一个线程可以访问共享资源。最后，记得在业务逻辑执行完毕后释放锁。\[2\]\[3\] #### 引用[.reference_title] - *1* *2* *3* [Springboot集成Redis——实现分布式锁](https://blog.csdn.net/tang_seven/article/details/126769580)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

javacoo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值