Hikari 数据库连接池配置主从结构

最新推荐文章于 2024-05-22 18:30:54 发布
最新推荐文章于 2024-05-22 18:30:54 发布
阅读量2.9k 收藏 1
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a631258447/article/details/89101440
版权

HikariCP是数据库连接池,而且是号称史上最快的,而且目前来看确实是这样的,SpringBoot2.0也已经采用HikariCP作为默认连接池配置.

HikariCP 默认配置
主要参数是在 com.zaxxer.hikari.HikariConfig 中初始化的，部分参数是在 com.zaxxer.hikari.pool.PoolBase 中初始化的。

name描述构造器默认值默认配置validate之后的值validate重置
autoCommit自动提交从池中返回的连接truetrue-
connectionTimeout等待来自池的连接的最大毫秒数SECONDS.toMillis(30) = 3000030000如果小于250毫秒，则被重置回30秒
idleTimeout连接允许在池中闲置的最长时间MINUTES.toMillis(10) = 600000600000如果idleTimeout+1秒>maxLifetime 且 maxLifetime>0，则会被重置为0（代表永远不会退出）；如果idleTimeout!=0且小于10秒，则会被重置为10秒
maxLifetime池中连接最长生命周期MINUTES.toMillis(30) = 18000001800000如果不等于0且小于30秒则会被重置回30分钟
connectionTestQuery如果您的驱动程序支持JDBC4，我们强烈建议您不要设置此属性nullnull-
minimumIdle池中维护的最小空闲连接数-110minIdle<0或者minIdle>maxPoolSize,则被重置为maxPoolSize
maximumPoolSize池中最大连接数，包括闲置和使用中的连接-110如果maxPoolSize小于1，则会被重置。当minIdle<=0被重置为DEFAULT_POOL_SIZE则为10;如果minIdle>0则重置为minIdle的值
metricRegistry该属性允许您指定一个 Codahale / Dropwizard MetricRegistry 的实例，供池使用以记录各种指标nullnull-
healthCheckRegistry该属性允许您指定池使用的Codahale / Dropwizard HealthCheckRegistry的实例来报告当前健康信息nullnull-
poolName连接池的用户定义名称，主要出现在日志记录和JMX管理控制台中以识别池和池配置nullHikariPool-1-
initializationFailTimeout如果池无法成功初始化连接，则此属性控制池是否将 fail fast11-
isolateInternalQueries是否在其自己的事务中隔离内部池查询，例如连接活动测试falsefalse-
allowPoolSuspension控制池是否可以通过JMX暂停和恢复falsefalse-
readOnly从池中获取的连接是否默认处于只读模式falsefalse-
registerMbeans是否注册JMX管理Bean（MBeans）falsefalse-
catalog为支持 catalog 概念的数据库设置默认 catalogdriver defaultnull-
connectionInitSql该属性设置一个SQL语句，在将每个新连接创建后，将其添加到池中之前执行该语句。nullnull-
driverClassNameHikariCP将尝试通过仅基于jdbcUrl的DriverManager解析驱动程序，但对于一些较旧的驱动程序，还必须指定driverClassNamenullnull-
transactionIsolation控制从池返回的连接的默认事务隔离级别nullnull-
validationTimeout连接将被测试活动的最大时间量SECONDS.toMillis(5) = 50005000如果小于250毫秒，则会被重置回5秒
leakDetectionThreshold记录消息之前连接可能离开池的时间量，表示可能的连接泄漏00如果大于0且不是单元测试，则进一步判断：(leakDetectionThreshold < SECONDS.toMillis(2) or (leakDetectionThreshold > maxLifetime && maxLifetime > 0)，会被重置为0 . 即如果要生效则必须>0，而且不能小于2秒，而且当maxLifetime > 0时不能大于maxLifetime
dataSource这个属性允许你直接设置数据源的实例被池包装，而不是让HikariCP通过反射来构造它nullnull-
schema该属性为支持模式概念的数据库设置默认模式driver defaultnull-
threadFactory此属性允许您设置将用于创建池使用的所有线程的java.util.concurrent.ThreadFactory的实例。nullnull-
scheduledExecutor此属性允许您设置将用于各种内部计划任务的java.util.concurrent.ScheduledExecutorService实例nullnull-

0.maven

  <dependency>
		    <groupId>com.zaxxer</groupId>
		    <artifactId>HikariCP</artifactId>
		    <version>3.2.0</version>
		</dependency>

1.mysqlContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
       
  
    
   <!--  hikari datasource  --> 
    <bean id="abstractDataSource" abstract="true" class="com.zaxxer.hikari.HikariDataSource"  destroy-method="close">
        <property name="connectionTimeout" value="30000" />
        <property name="idleTimeout" value="600000" />
        <property name="maxLifetime" value="1800000" />
        
    </bean>  

    <bean id="master" parent="abstractDataSource">
        <property name="driverClassName" value="${mysql.connection.driver_class}" />
        <property name="jdbcUrl" value="${mysql.connection.url}" />
        <property name="username" value="${mysql.connection.username}" />
        <property name="password" value="${mysql.connection.password}" />
        <property name="readOnly" value="false" />
        <property name="maximumPoolSize" value="3" />
    </bean>
    
    <bean id="slave" parent="abstractDataSource">
        <property name="driverClassName" value="${mysql.slave.connection.driver_class}" />
        <property name="jdbcUrl" value="${mysql.slave.connection.url}" />
        <property name="username" value="${mysql.slave.connection.username}" />
        <property name="password" value="${mysql.slave.connection.password}" />
        <property name="readOnly" value="true" />
        <property name="maximumPoolSize" value="20" />
    </bean>
    
    <bean id="dynamicDataSource" class="cn.xxx.common.persistence.datasource.DynamicDataSource">
        <property name="targetDataSources">
            <map>
                <entry value-ref="master" key="master"></entry>
                <entry value-ref="slave" key="slave"></entry>
            </map>
        </property>
    </bean>
    
     <bean id="dataSource" class="org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy">
        <property name="targetDataSource">
            <ref bean="dynamicDataSource"></ref>
        </property>
    </bean>

    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation" value="classpath:mybatis-config.xml" />
    </bean>

    <!-- scan for mappers and let them be autowired -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="cn.xxx.common.persistence.mapper" />
        <property name="sqlSessionFactoryBeanName" value="sessionFactory"/>
    </bean>

    <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

</beans>

2.mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <settings>
        <!-- 这个配置使全局的映射器启用或禁用缓存 -->
        <setting name="cacheEnabled" value="false"/>
        <!-- 全局启用或禁用延迟加载。当禁用时，所有关联对象都会即时加载 -->
        <setting name="lazyLoadingEnabled" value="false"/>
        <!-- 当启用时，有延迟加载属性的对象在被调用时将会完全加载任意属性。否则，每种属性将会按需要加载 -->
        <setting name="aggressiveLazyLoading" value="false"/>
        <!-- 允许JDBC支持生成的键。需要适合的驱动。如果设置为true则这个设置强制生成的键被使用，尽管一些驱动拒绝兼容但仍然有效（比如Derby） -->
        <setting name="useGeneratedKeys" value="true"/>
        <!-- 允许或不允许多种结果集从一个单独的语句中返回（需要适合的驱动） -->
        <setting name="multipleResultSetsEnabled" value="true"/>
        <!-- 使用列标签代替列名。不同的驱动在这方便表现不同。参考驱动文档或充分测试两种方法来决定所使用的驱动 -->
        <setting name="useColumnLabel" value="true"/>
        <!-- 指定MyBatis如何自动映射列到字段/属性。PARTIAL只会自动映射简单，没有嵌套的结果。FULL会自动映射任意复杂的结果（嵌套的或其他情况） -->
        <setting name="autoMappingBehavior" value="PARTIAL"/>
        <!-- 配置默认的执行器。SIMPLE执行器没有什么特别之处。REUSE执行器重用预处理语句。BATCH执行器重用语句和批量更新 -->
        <setting name="defaultExecutorType" value="SIMPLE"/>
        <!-- 设置超时时间，它决定驱动等待一个数据库响应的时间 -->
        <setting name="defaultStatementTimeout" value="25000"/>
    </settings>

    <typeAliases>
        <package name="cn.xxx.common.persistence.model"/>
    </typeAliases>

    <plugins>
    	<plugin interceptor="cn.xxx.common.persistence.datasource.DynamicDataSourceInterceptor" />
        <plugin interceptor="com.xxx.orm.mybatis.interceptor.PersistenceInterceptor" />
    </plugins>
    
    <mappers>
        <package name="cn.xxx.common.persistence.mapper"/>
    </mappers>

</configuration>

3.DynamicDataSourceInterceptor


import java.util.Locale;
import java.util.Properties;

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.keygen.SelectKeyGenerator;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.springframework.transaction.support.TransactionSynchronizationManager;

@Intercepts({ @Signature(type = Executor.class, method = "update", args = { MappedStatement.class, Object.class }),
		@Signature(type = Executor.class, method = "query", args = { MappedStatement.class, Object.class,
				RowBounds.class, ResultHandler.class }) })

public class DynamicDataSourceInterceptor implements Interceptor {

	private static final String REGEX = ".*insert\\u0020.*|.*delete\\u0020.*|.*update\\u0020.*|.*xxl_job.*|.*XXL_JOB.*";

	@Override
	public Object intercept(Invocation invocation) throws Throwable {

		boolean syschronizationActive = TransactionSynchronizationManager.isActualTransactionActive();
		Object[] objects = invocation.getArgs();
		MappedStatement mappedStatement = (MappedStatement) objects[0];
		String lookupKey = DynamicDataSourceHolder.DB_MASTER;

		if (syschronizationActive != true) {

			if (mappedStatement.getSqlCommandType().equals(SqlCommandType.SELECT)) {
				if (mappedStatement.getId().contains(SelectKeyGenerator.SELECT_KEY_SUFFIX)) {
					lookupKey = DynamicDataSourceHolder.DB_MASTER;
				} else {
					BoundSql boundSql = mappedStatement.getSqlSource().getBoundSql(objects[1]);
					String sql = boundSql.getSql().toLowerCase(Locale.CHINA).replaceAll("[\\t\\n\\r]", " ");
					if (sql.matches(REGEX)) {
						lookupKey = DynamicDataSourceHolder.DB_MASTER;
					} else {
						lookupKey = DynamicDataSourceHolder.DB_SLAVE;
					}
				}

			}
		} else {
			lookupKey = DynamicDataSourceHolder.DB_MASTER;
		}
		DynamicDataSourceHolder.setDbType(lookupKey);
		return invocation.proceed();
	}

	@Override
	public Object plugin(Object target) {
		if (target instanceof Executor)
			return Plugin.wrap(target, this);
		else
			return target;
	}

	@Override
	public void setProperties(Properties properties) {
	}

}

4.PersistenceInterceptor


import java.util.Collection;
import java.util.Date;
import java.util.Properties;
import org.apache.ibatis.binding.MapperMethod.ParamMap;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;

@Intercepts({@Signature(
    type = Executor.class,
    method = "update",
    args = {MappedStatement.class, Object.class}
)})
public class PersistenceInterceptor implements Interceptor {
    public PersistenceInterceptor() {
    }

    public Object intercept(Invocation invocation) throws Throwable {
        Object[] args = invocation.getArgs();
        MappedStatement mappedStatement = (MappedStatement)args[0];
        Object object = args[1];
        NulEntity entity;
        if (mappedStatement.getSqlCommandType().equals(SqlCommandType.INSERT) && ThreadLocalHolder.get() != null) {
            if (object instanceof NulEntity) {
                entity = (NulEntity)object;
                entity.setCreator(ThreadLocalHolder.get().toString());
                entity.setCreatedAt(new Date());
            }

            if (object instanceof ParamMap) {
                ParamMap paramMap = (ParamMap)object;
                Object obj = paramMap.get("param1");
                if (obj instanceof Collection) {
                    Collection list = (Collection)obj;
                    Object[] objects = list.toArray();
                    if (objects[0] instanceof NulEntity) {
                        for(int i = 0; i < objects.length; ++i) {
                            NulEntity entity = (NulEntity)objects[i];
                            entity.setCreator(ThreadLocalHolder.get().toString());
                            entity.setCreatedAt(new Date());
                        }
                    }
                }
            }
        } else if (mappedStatement.getSqlCommandType().equals(SqlCommandType.UPDATE) && ThreadLocalHolder.get() != null && object instanceof NulEntity) {
            entity = (NulEntity)object;
            entity.setModifier(ThreadLocalHolder.get().toString());
            entity.setUpdatedAt(new Date());
            String key = CacheHelper.buildKey(entity.getClass().getName() + ":" + entity.getId());
            CacheHelper.evict(CacheType.FIVE_MINUTE_STORE.getValue(), key);
        }

        return invocation.proceed();
    }

    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    public void setProperties(Properties properties) {
    }
}

5.DynamicDataSourceHolder


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DynamicDataSourceHolder {

	private static final Logger LOG = LoggerFactory.getLogger(DynamicDataSourceHolder.class);

	private static ThreadLocal<String> contextHolder = new ThreadLocal<String>();
	public static final String DB_MASTER = "master";
	public static final String DB_SLAVE = "slave";

	public static String getDbType() {
		String db = contextHolder.get();
		if (db == null)
			db = DB_MASTER;
		if (LOG.isInfoEnabled())
			LOG.info("当前所使用的数据源为：" + db);
		return db;
	}

	public static void setDbType(String datasource) {

		contextHolder.set(datasource);
	}

	public static void clearDbType() {
		contextHolder.remove();
	}

	public static boolean isMaster() {
		return DB_MASTER.equals(getDbType());
	}

}

6.DynamicDataSource

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {

	@Override
	protected Object determineCurrentLookupKey() {
		return DynamicDataSourceHolder.getDbType();
	}

}
LYJ_er
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hikari如何切换数据源_java – 使用HikariCP到多个数据库的连接池
weixin_39596720的博客
12-18 583
后者：池与单个数据库配置参数相关联,您有责任实例化与我将使用的数据库一样多的池.相应地创建池.我有一个DataSourceFactory来完成这个：public final class DataSourceFactory {private static final Logger LOG = LoggerFactory.getLogger(DataSourceFactory.class);//con...
数据库连接池DataSource
I_like_kan_draw的博客
05-29 413
数据库连接池 概念：是一个容器(集合)，用于存放与数据库连接的容器(Connection对象) 系统初始化之后容器会创建，容器中会申请一些连接对象，当用户需要访问数据库时，会分配一个容器中的连接对象，在用户使用玩之后不会将这些对象关闭，而是将这个对象再次放入数据库连接池(容器)中等待下一次的使用 好处：节约资源，用户的访问更加高效 实现： 标准接口：DataSource 在javax.sql包下，由jdk提供 方法： 获取连接：getConnection(); 归还连接：Connec
Spring主从数据库的配置和动态数据源切换原理
葵续浅笑的博客
03-06 1072
在大型应用程序中，配置主从数据库并使用读写分离是常见的设计模式。在Spring应用程序中，要实现读写分离，最好不要对现有代码进行改动，而是在底层透明地支持。 Spring内置了一个AbstractRoutingDataSource，它可以把多个数据源配置成一个Map，然后，根据不同的key返回不同的数据源。因为AbstractRoutingDataSource也是一个DataSource接口，因此，应用程序可以先设置好key， 访问数据库的代码就可以从AbstractRoutingDataSource拿到对
SpringBoot Hikari数据源的正确配置是这样的
最新发布
ttyy1112的专栏
05-22 527
【代码】SpringBoot Hikari数据源的正确配置是这样的。
SpringBoot数据库连接池Hikari配置
fly_duck的博客
11-17 2万+
在项目中，一般情况下访问数据库，会创建一个连接，用完后就关闭它，对于简单的系统这样不会带来什么明显的性能上的开销。但是对于一个复杂的系统，频繁的建立、关闭连接，会极大的减低系统的性能，因为对于数据库连接的使用可能会成为系统性能的瓶颈。数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。 SpringBoot默认使用Hikari SpringBoot项目如果
数据库连接池配置（案例及排查指南）
Enmotech的博客
06-18 428
墨墨导读：本文以 druid 1.1.5 (https://github.com/alibaba/druid) 连接池为例来阐述几个参数的重要性及如果避免踩坑，虽然下...
Springboot+MySQL 主从配置和读写分离
dounet的专栏
06-10 5666
springboot +mysql 主从复制，读写分离
springboot多数据源配置和HikariPool线程池配置
qq_42051115的博客
01-15 3207
配置类： 注意 @Primary 注解,他可以理解为优先选择，这下面的代码是一个主要连接，如果需要再加入一个连接的话复制以下代码修改name 吧@Primary注解去掉就行了。 注意spring.datasource.test 是后面配置的。 @Configuration @MapperScan(basePackages = {"mapper地址"},sqlSessionFactoryRef = "testSqlSessionFactory") public class OADataSourceConfig
spring boot配置MySQL数据库连接、Hikari连接池和Mybatis的简单配置方法
08-27
Spring Boot 配置 MySQL 数据库连接、Hikari 连接池和 MyBatis 的简单配置方法 Spring Boot 是一个基于 Java 的框架，用于快速构建生产级别的应用程序。作为一个现代化的框架，Spring Boot 提供了许多便捷的配置...
Hikari数据库连接池
10-28
**Hikari数据库连接池**是一种高效的数据库连接管理机制，主要在C#环境中用于优化数据库操作性能和资源利用。在传统的数据库操作中，每次数据库请求都会创建新的连接，这不仅消耗系统资源，还可能导致连接过多时...
数据库连接池jar包.zip
05-27
通过合理配置和使用连接池，可以有效避免数据库连接的频繁创建和销毁，降低系统资源消耗，同时提供更稳定的数据库服务。希望这个“数据库连接池jar包”能为初学者提供方便，快速地开始JDBC连接池的实践。在学习过程...
达梦数据库的连接配置
03-17
达梦数据库的连接配置 达梦数据库的连接配置是指在 Java 应用程序中连接达梦数据库的过程。该过程主要包括两个方面：JDBC 连接和 iBatis 连接设置。 JDBC 连接 JDBC（Java Database Connectivity）是 Java 应用...
HikariCP数据库连接池实战.docx
09-13
HikariCP 数据库连接池实战 HikariCP 是一个高性能的 Java 数据库连接池，由 Zachary Tong 开发并维护。它基于 Apache Commons DBCP，并进行了许多优化和改进，以提供更好的性能和可扩展性。 HikariCP 的核心理念...
springboot启动报错com.zaxxer.hikari.pool.HikariPool : root - Exception during pool initialization.
ljj123_的博客
07-12 1万+
springboot启动时报错com.zaxxer.hikari.pool.HikariPool : root - Exception during pool initialization. 改为如下配置后，启动成功 server.port=8080 spring.application.name=server_edu spring.profiles.active=dev spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver .
Hikari数据源项目启动后覆盖为新数据源
weixin_53403577的博客
01-06 747
Hikari数据源项目启动后再切换
hikari配置mysql和oracle_spring boot配置MySQL数据库连接、Hikari连接池和Mybatis的简单配置方法...
weixin_33970380的博客
02-01 875
org.mybatis.spring.bootmybatis-spring-boot-starter1.1.1org.apache.tomcattomcat-jdbccom.zaxxerHikariCPmysqlmysql-connector-java我们使用了mybatis-spring-boot-starter，并让它把tomcat-jdbc连接池排除掉，这样spring-boot就会寻找是否...
Failed to validate connection com.mysql.cj.jdbc.ConnectionImpl问题排查
热门推荐
Brucelwl的博客
03-20 6万+
2021-03-19 13:25:58.486 WARN 21806 --- [scheduling-1] com.zaxxer.hikari.pool.PoolBase : slave - Failed to validate connection com.mysql.cj.jdbc.ConnectionImpl@2e2ce118 (No operations allowed after connection closed.). Possibly consider using a sh
HikariCP数据库连接池中文使用手册
GIS地图技术分享(GIS入门、Openlayers教程、Leaflet教程)，做最好的GIS地图开发教程
09-17 4540
HikariCP 数据库连接池 迄今为止，性能最好，速度最快的数据库连接池。 依赖项 Java 8 thru 11 maven artifact: <dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP</artifactId> <version>3.4.5</version>...
连接双数据源启动报错
weixin_44215804的博客
01-25 757
021-01-25 16:14:08.514 SvUSService [main] DEBUG org.mybatis.spring.SqlSessionUtils - Creating a new SqlSession 2021-01-25 16:14:08.555 SvUSService [main] DEBUG org.mybatis.spring.SqlSessionUtils - SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSe
HikariDataSource 连接池配置
10-12
HikariDataSource 是一个高性能的 JDBC 连接池，可以通过以下方式进行配置： 1. 配置数据源的基本信息，如 JDBC URL、用户名、密码等。 2. 配置连接池的大小，即最大连接数和最小连接数。 3. 配置连接的超时时间和闲置时间。 4. 配置连接测试语句，用于检测连接是否可用。 5. 配置其他高级选项，如事务隔离级别、自动提交等。 以下是一个 HikariDataSource 的配置示例： ``` HikariConfig config = new HikariConfig(); config.setJdbcUrl("jdbc:mysql://localhost:3306/mydatabase"); config.setUsername("myusername"); config.setPassword("mypassword"); config.setMaximumPoolSize(10); config.setMinimumIdle(5); config.setConnectionTimeout(30000); config.setIdleTimeout(600000); config.setConnectionTestQuery("SELECT 1"); config.setAutoCommit(false); HikariDataSource dataSource = new HikariDataSource(config); ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值