SpringBoot 集成 Sharding-JDBC（二）：读写分离

已于 2024-11-22 14:22:23 修改
阅读量1k 收藏 10
点赞数 27
CC 4.0 BY-SA版权
分类专栏： 数据库 java # Sharding-Sphere 文章标签： spring boot 后端 java
于 2024-11-22 09:31:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kersixy/article/details/143919919

 Sharding-Sphere官网：Apache ShardingSphere

Sharding-Sphere官方文档：Overview :: ShardingSphere

Sharding-Sphere中文文档：概览 :: ShardingSphere

Sharding-Sphere中文文档2：概览 :: ShardingSphere

1. 核心概念

  • 主库：添加、更新以及删除数据操作所使用的数据库，目前仅支持单主库。
  • 从库：查询数据操作所使用的数据库，可支持多从库。
  • 主从同步：将主库的数据异步的同步到从库的操作。由于主从同步的异步性，从库与主库的数据会短时间内不一致。
  • 负载均衡策略：通过负载均衡策略将查询请求疏导至不同从库。

2. 核心功能

  1. 提供一主多从的读写分离配置，可独立使用，也可配合分库分表使用。
  2. 独立使用读写分离支持SQL透传。
  3. 同一线程且同一数据库连接内，如有写入操作，以后的读操作均从主库读取，用于保证数据一致性。
  4. 基于Hint的强制主库路由。

3. 不支持项

  1. 主库和从库的数据同步。
  2. 主库和从库的数据同步延迟导致的数据不一致。
  3. 主库双写或多写。
  4. 跨主库和从库之间的事务的数据不一致。主从模型中，事务中读写均用主库。

4. 配置步骤

1. 添加依赖

<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
    <version>4.1.1</version>
</dependency>

2. 编写配置文件

spring:
  main:
    allow-bean-definition-overriding: true
  shardingsphere:
    datasource:
      names: master,slave1
      master:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://192.168.88.131:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=false
        username: root
        password: root
      slave1:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://192.168.88.132:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=false
        username: root
        password: root
    sharding:
      master-slave-rules:
        master:
          name: # 读写分离数据源名称
          master-data-source-name: master # 主库数据源名称
          slave-data-source-names: # 从库数据源名称列表
            - slave1
          loadBalanceAlgorithmType: ROUND_ROBIN # 从库负载均衡算法类型，可选值：ROUND_ROBIN，RANDOM。若`loadBalanceAlgorithmClassName`存在则忽略该配置
          props:  # 读写分离负载算法的属性配置
    props: # 属性配置
      sql:
        show: true #是否开启SQL显示，默认值: false
      # executor.size: #工作线程数量，默认值: CPU核数
      # max.connections.size.per.query: # 每个查询可以打开的最大连接数量,默认为1
      # check.table.metadata.enabled: #是否在启动时检查分表元数据一致性，默认值: false

5. 解决jdk8新时间类与Sharding-Sphere兼容问题

以 LocalDate 和 LocalDateTime 为例：

1. 引入依赖

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.7.17</version>
</dependency>

2. 编写 BaseTypeHandler 的实现类：

  • LocalDate适配：
package com.zjp.shadingjdbcdemo.handler;

import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.TypeReference;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;
import org.springframework.stereotype.Component;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.LocalDate;


@Component
@MappedTypes(LocalDate.class)
@MappedJdbcTypes(value = JdbcType.DATE, includeNullJdbcType = true)
public class LocalDateTypeHandler extends BaseTypeHandler<LocalDate> {
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, LocalDate parameter, JdbcType jdbcType)
            throws SQLException {
        ps.setObject(i, parameter);
    }

    @Override
    public LocalDate getNullableResult(ResultSet rs, String columnName) throws SQLException {
        return Convert.convert(new TypeReference<LocalDate>() {
            @Override
            public String getTypeName() {
                return super.getTypeName();
            }
        },rs.getObject(columnName));
    }

    @Override
    public LocalDate getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        return Convert.convert(new TypeReference<LocalDate>() {
            @Override
            public String getTypeName() {
                return super.getTypeName();
            }
        },rs.getObject(columnIndex));
    }

    @Override
    public LocalDate getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        return Convert.convert(new TypeReference<LocalDate>() {
            @Override
            public String getTypeName() {
                return super.getTypeName();
            }
        },cs.getObject(columnIndex));
    }
}
  • LocalDateTime适配：
package com.zjp.shadingjdbcdemo.handler;

import cn.hutool.core.convert.Convert;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;
import org.springframework.stereotype.Component;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.LocalDateTime;

@Component
@MappedTypes(LocalDateTime.class)
@MappedJdbcTypes(value = JdbcType.DATE, includeNullJdbcType = true)
public class LocalDateTimeTypeHandler extends BaseTypeHandler<LocalDateTime> {

    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, LocalDateTime parameter, JdbcType jdbcType)
            throws SQLException {
        ps.setObject(i, parameter);
    }

    @Override
    public LocalDateTime getNullableResult(ResultSet rs, String columnName) throws SQLException {
        return Convert.toLocalDateTime(rs.getObject(columnName));
    }

    @Override
    public LocalDateTime getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        return Convert.toLocalDateTime(rs.getObject(columnIndex));
    }

    @Override
    public LocalDateTime getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        return Convert.toLocalDateTime(cs.getObject(columnIndex));
    }
}

其他时间类可仿照上述方案仿写。

6. 测试

1. 创建数据表

CREATE DATABASE IF NOT EXISTS test;
USE test;

-- ----------------------------
-- Table structure for t_user
-- ----------------------------
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '用户编号',
  `name` varchar(255) CHARACTER SET utf8mb4 NULL DEFAULT NULL COMMENT '用户名',
  `age` int(11) NULL DEFAULT NULL COMMENT '用户年龄',
  `salary` double NULL DEFAULT NULL COMMENT '用户薪资',
  `birthday` datetime NULL DEFAULT NULL COMMENT '用户生日',
  PRIMARY KEY (`id`)
) ENGINE = InnoDB CHARACTER SET = utf8mb4;

 2. 创建实体类

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.time.LocalDateTime;

@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("t_user")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 用户编号
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 用户名
     */
    private String name;

    /**
     * 用户年龄
     */
    private Integer age;

    /**
     * 用户薪资
     */
    private Double salary;

    /**
     * 用户生日
     */
    private LocalDateTime birthday;
}

 3. 编写sevice层和mapper层

import com.zjp.shardingjdbcdemo.entity.User;
import com.baomidou.mybatisplus.extension.service.IService;

public interface IUserService extends IService<User> {
}
import com.zjp.shardingjdbcdemo.entity.User;
import com.zjp.shardingjdbcdemo.mapper.UserMapper;
import com.zjp.shardingjdbcdemo.service.IUserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
}

import com.zjp.shardingjdbcdemo.entity.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface UserMapper extends BaseMapper<User> {
}

 4. 测试接口

import com.github.javafaker.Faker;
import com.zjp.shardingjdbcdemo.entity.User;
import com.zjp.shardingjdbcdemo.service.IUserService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
public class ShardingJdbcDemoApplicationTests {
    @Autowired
    private IUserService userService;

    @Test
    public void testClusterSave() {
        Date birthday = FAKER.date().birthday(18, 100);
        User user = new User()
                .setName(FAKER.name().fullName())
                .setAge(Year.now().getValue() - birthday.getYear() - 1900)
                .setSalary((RANDOM.nextInt(500000) + 500000) / 100.0)
                .setBirthday(birthday.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime());
        userService.save(user);
    }

    @Test
    public void testClusterGet() {
        List<User> list = userService.list();
        log.info("查询结果为：{}", list);
    }
}

如下图所示，写操作在master库：

如下图所示，写操作在slave库：

7.  基于暗示(Hint)的强制主库路由

7.1. 配置步骤

1. 编写配置文件（同读写分离配置文件）

spring:
  main:
    allow-bean-definition-overriding: true
  shardingsphere:
    datasource:
      names: master,slave1
      master:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://192.168.88.131:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=false
        username: root
        password: root
      slave1:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://192.168.88.132:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=false
        username: root
        password: root
    sharding:
      master-slave-rules:
        master:
          name: # 读写分离数据源名称
          master-data-source-name: master # 主库数据源名称
          slave-data-source-names: # 从库数据源名称列表
            - slave1
          loadBalanceAlgorithmType: ROUND_ROBIN # 从库负载均衡算法类型，可选值：ROUND_ROBIN，RANDOM。若`loadBalanceAlgorithmClassName`存在则忽略该配置
          props:  # 读写分离负载算法的属性配置
    props: # 属性配置
      sql:
        show: true #是否开启SQL显示，默认值: false
      # executor.size: #工作线程数量，默认值: CPU核数
      # max.connections.size.per.query: # 每个查询可以打开的最大连接数量,默认为1
      # check.table.metadata.enabled: #是否在启动时检查分表元数据一致性，默认值: false

2. 获取HintManager：与基于暗示(Hint)的数据分片相同。

3. 设置主库路由：使用hintManager.setMasterRouteOnly设置主库路由。

4. 清除分片键值：与基于暗示(Hint)的数据分片相同。

7.2. 代码示例

import com.github.javafaker.Faker;
import com.zjp.shardingjdbcdemo.entity.User;
import com.zjp.shardingjdbcdemo.service.IUserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.shardingsphere.api.hint.HintManager;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
public class ShardingJdbcDemoApplicationTests {
    @Autowired
    private IUserService userService;

    @Test
    public void testClusterHint() {
        try (HintManager hintManager = HintManager.getInstance();) {
            hintManager.setMasterRouteOnly();
            List<User> list = userService.list();
            log.info("查询结果为：{}", list);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

如下图所示，读操作在master库执行：

8. 自定义负载均衡算法

8.1. 源码参考

Ctrl + 左键点击 loadBalanceAlgorithmType，点击定位文件位置，如下图所示，这三个文件即为主键生成策略的配置文件。org.apache.shardingsphere.spi.keygen.ShardingKeyGenerator文件指定了两种生成策略，分别为UUID和雪花算法。

8.2. 自定义主键生成策略步骤 

1. 编写配置文件

spring:
  shardingsphere:
    sharding:
      master-slave-rules:
        master:
          name: # 读写分离数据源名称
          master-data-source-name: master # 主库数据源名称
          slave-data-source-names: # 从库数据源名称列表
            - slave1
          loadBalanceAlgorithmType: MY_LOAD_BALANCE # 从库负载均衡算法类型，可选值：ROUND_ROBIN，RANDOM。若`loadBalanceAlgorithmClassName`存在则忽略该配置
          props: # 读写分离负载算法的属性配置
            weight.formula: "weight_random()"

 2. 编写负载均衡算法

package com.zjp.shardingjdbcdemo.strategy.masterslave;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.apache.shardingsphere.spi.masterslave.MasterSlaveLoadBalanceAlgorithm;

import java.util.List;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
@Getter
@Setter
public class MyMasterSlaveLoadBalanceAlgorithm implements MasterSlaveLoadBalanceAlgorithm {
    private Properties properties = new Properties();
    private static final AtomicInteger CURRENT_INDEX = new AtomicInteger(0);

    @Override
    public String getDataSource(String s, String s1, List<String> list) {
        log.info("自定义负载均衡算法");
        log.info("s:{},s1:{},list:{},properties:{}", s, s1, list, properties); // s: master,s1: master, list:[slave1, slave2],properties: prop里的参数

        if (list == null || list.isEmpty()) {
            log.warn("数据源列表为空");
            return null;
        }

        // 获取当前索引的数据源
        int index = CURRENT_INDEX.getAndIncrement() % list.size();
        if (index < 0) {
            index += list.size();
        }

        return list.get(index);
    }

    @Override
    public String getType() {
        return "MY_LOAD_BALANCE";
    }
}

在src/main/resources/META-INF/services/org.apache.shardingsphere.spi.masterslave.MasterSlaveLoadBalanceAlgorithm 目录下编写自定义算法路径

com.zjp.shardingjdbcdemo.strategy.masterslave.MyMasterSlaveLoadBalanceAlgorithm

 测试读操作：

import com.github.javafaker.Faker;
import com.zjp.shardingjdbcdemo.entity.User;
import com.zjp.shardingjdbcdemo.service.IUserService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
public class ShardingJdbcDemoApplicationTests {
    @Autowired
    private IUserService userService;

    @Test
    public void testClusterGet() {
        List<User> list = userService.list();
        log.info("查询结果为：{}", list);
    }
}

从日志可以看出自定义负载均衡算法配置成功： 

本篇文章示例代码：GitHub - kerrsixy/sharding-jdbc-demo

springboot整合sharding-jdbc实现分库分表详解
congge
05-21 8167
springboot整合sharding-jdbc实现分库分表详解
SpringBoot整合Sharding-JDBC实现读写分离
YIYIYI
11-07 263
SpringBoot整合Sharding-JDBC实现读写分离
Spring Boot项目中使用Sharding-JDBC实现读写分离
战族狼魂的博客
08-17 641
Sharding-JDBC是一个分布式数据库中间件，它不仅支持数据分片，还可以轻松实现数据库的读写分离。
SpringBoot使用Sharding-JDBC读写分离
weixin_34208283的博客
02-12 367
本文介绍SpringBoot使用当当Sharding-JDBC进行读写分离。 1.有关Sharding-JDBC 本文还是基于当当网Sharding-Jdbc的依赖，与上一篇使用Sharding-Jdbc进行分库分表依赖一致，并且本文大致内容与上一篇文章相似，建议先查看我的另一篇在查看这篇会简单许多，传送门《SpringBoot使用Sharding-JDBC分库分表》。 这里需要特殊介绍的是，...
Shardingsphere新版本（5.5.1）实践
最新发布
thekenofDIS的专栏
05-19 687
这里还用到了多数据源，db0是读写分离的数据源，db1是另一个数据源，不做读写分离，注意这里，上面注释掉的是读取环境变量的写法，需要url参数里指定placeholder-type=environment，而下面是我们通过SPI扩展的方式，所以读取的方式从classpath变成了kms，这个kms是我们自己定义的，也可以改成其他的。其他三方工具版本升级，一般就是增加些配置，新添些功能，而Shardingsphere的升级，配置文件的配置方法改动很大，导致很多在网上查的资料，对于新版本已经完全不适用了。
SpringBoot+ShardingSphereJDBC实现读写分离！
程序员闪充宝
08-03 1017
1 概述本文讲述了如何使用MyBatisPlus+ShardingSphereJDBC进行读写分离，以及利用MySQL进行一主一从的主从复制。具体步骤包括：MySQL主从复制环境准备（Docker）搭建ShardingShpereJDBC+MyBatisPlus+Druid环境测试2 环境OpenJDK 17.0.3Spring Boot 2.7.0MyBatis Plu...
SpringBoot+ShardingJDBC实现读写分离、分库分表
田维常
06-23 1344
简介Sharding-JDBC 最早是当当网内部使用的一款分库分表框架，到2017年的时候才开始对外开源，这几年在大量社区贡献者的不断迭代下，功能也逐渐完善，现已更名为 ShardingSphere，2020年4⽉16日正式成为 Apache 软件基金会的顶级项目。如果你正在准备面试，推荐给你一篇文章：★手把手教：如何准备面试！ShardingSphere-Jdbc定位为...
在springBoot中使用Sharding-JDBC实现我们的数据库读写分离
ebdbbd的博客
08-12 907
此时我们如果启动我们的项目的话，会报错，原因是因为数据源起冲突了。因为我们的导入的Sharding_JDBC会为我们建一个数据源。②、在我们的配置文件application中配置我们的读写分离规则和数据库，连接池等等一系列。但是我们的druid连接词也会为我们建一个数据源，这样他们就起冲突了。①、首先我们在我们的POM中导入我们的maven坐标。.........
springboot整合sharding-jdbc完整代码
05-14
**二、SpringBoot集成Sharding-JDBC** 1. **依赖添加**：在`pom.xml`中引入SpringBoot和Sharding-JDBC的相关依赖，包括`spring-boot-starter-jdbc`和`sharding-jdbc-spring-boot-starter`。 2. **配置ShardingRule...
基于yml 配置方式 ，实现springBoot+sharding-jdbc+mybatis-plus 实现分库分表，读写分离，以及全局表，子表的配置
10-26
1、基于yml 配置方式 ，实现springBoot+sharding-jdbc+mybatis-plus 实现分库分表，读写分离，以及全局表，子表的配置。 2、实现mybatis-plus 整合到springboot 详细使用请看 测试用例
Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能
09-07
Sharding-JDBC支持水平和垂直切分，能够帮助开发者实现数据库分片、读写分离以及分布式事务等功能。它的核心特性包括： 1. 数据分片：根据预设规则将数据分散到多个数据库或表中，以减轻单个数据库的压力。 2. 读写...
springboot(二十二)-sharding-jdbc-读写分离
weixin_30677475的博客
07-05 298
前面我们使用sharding-jdbc配置了分库分表。sharding-jdbc还有个用法，就是实现读写分离。 什么时候需要或者可以使用读写分离？ 当我们的项目所使用的数据库查询的访问量，访问频率，及访问的并发量远大于修改的时候，我们需要将访问数据库的方式读写分离。比如我们使用的微博，更多人都只是刷一刷，发布微博动态的次数还是远小于我们刷微博的次数的。 sharding-jdbc ...
SpringBoot+ShardingSphereJDBC实现读写分离
油墨香^-^的博客
09-21 3018
本文讲述了如何使用+进行读写分离，以及利用MySQL进行一主一从的主从复制。MySQL主从复制环境准备（Docker）搭建++Druid环境测试数据库中间件可以简化对读写分离以及分库分表的操作，并隐藏底层实现细节，可以像操作单库单表那样操作多库多表，主流的设计方案主要有两种：服务端代理：需要独立部署一个代理服务，该代理服务后面管理多个数据库实例，在应用中通过一个数据源与该代理服务器建立连接，由该代理去操作底层数据库，并返回相应结果。
spring boot+Sharding-JDBC读写分离
weixin_46423549的博客
02-05 279
spring boot+Sharding-JDBC读写分离
SpringBoot集成Sharding-JDBC实现读写分离
qq_43750656的博客
06-10 659
一、数据库一主一从环境搭建 1.首先打开服务管理器，找到mysql服务。 右击属性查看mysql服务的磁盘位置 找到D磁盘上的mysql文件夹，复制一份mysql-slave当做从机 进入mysql-slave的data文件夹，修改my.ini文件 修改四个地方，端口，slave服务的磁盘位置，以及slave服务的数据库的磁盘位置，按照datadir="C:/ProgramData/MySQL/MySQL Server 5.5 - slave/Data/"的路径在相应目录复制一份数据库。 这样的话
springboot+Sharding-JDBC实现读写分离
叶子来啦
12-06 923
技术选型 SpringBoot + hikari + Sharding-JDBC + MyBatis 使用Sharding-JDBC配置读写分离，优点在于数据源完全有Sharding托管，写操作自动执行master库，读操作自动执行slave库。不需要程序员在程序中关注这个实现了。 核心jar包 <dependency> <groupId>org.springframework.boot</groupId> <a
SpringBoot整合sharding-jdbc实现读写分离
小尾寒羊的博客
08-04 1801
一、什么是sharding-jdbc Sharding-Jdbc在3.0后改名为Shardingsphere它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（计划中）这3款相互独立的产品组成。他们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于如Java同构、异构语言、容器、云原生等各种多样化的应用场景。 Sharding-Sphere定位...
SpringBoot集成Sharding-JDBC实现分库分表及读写分离
在当前IT行业，使用SpringBoot框架结合Mybatis-Plus和Sharding-JDBC实现分库分表、读写分离以及全局表和子表配置已经成为常见的数据库架构设计。下面详细说明这些知识点： ### 1. SpringBoot框架 SpringBoot是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

可儿·四系桜

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

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

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

打赏作者

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

抵扣说明：

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

余额充值