mogodb,redis,mysql的Java连接

最新推荐文章于 2024-04-16 22:19:19 发布
最新推荐文章于 2024-04-16 22:19:19 发布
阅读量428 收藏
点赞数
文章标签： mysql redis mongodb 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31645907/article/details/77865469
版权

1.读取配置文件的配置项信息

/**
 * 读取配置文件中的配置项
 * 
 *
 */
public class Configures {

private static String URL = System.getenv("STAFF_PATH") + "/mqttweb/constant.properties";

private static Properties prop = new Properties();


public static void init() {
if (prop == null || prop.size() == 0) {
try {
// 读取属性文件URL
InputStream in = new BufferedInputStream(new FileInputStream(URL));
prop.load(in); /// 加载属性列表
in.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}


public static String getValue(String key) {
if (StringUtils.isNotEmpty(key)) {
return prop.getProperty(key);
}
return null;


}


}

 System.getenv("STAFF_PATH")  是读取系统变量的配置信息（如下图）


2. 配置项的内容(constant.properties的内容)

#mongoDB的ip
MONGODB_IP=127.0.0.1




#mongoDB的端口
MONGODB_PORT=27017
#mongoDB连接的最大空闲时间
MONGODB_MAX_IDLE_TIME=60000
#mongodb的账号
MONGODB_USER=staff
#mongodb的密码
MONGODB_PASSWD=123456




#redis的IP
REDIS_IP=127.0.0.1
#redis的端口
REDIS_PORT=6379
#redis可连接实例的最大数目
REDIS_MAX_ACTIVE=1024
#redis pool最多为空闲的实例，默认为8
REDIS_MAX_IDLE=200
#redis等待可连接的最大时间，单位毫秒
REDIS_MAX_WAIT=1000
#redis连接密码
REDIS_PASSWD=123456
#在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
REDIS_TEST_ON_BORROW=true;
#redis超时时间
REDIS_TIME_OUT=60000


#mqtt发布的主题（阻塞线程的标识，通知mqtt服务器，队列空了）
#发布到主题
MQTT_TOPIC=register/test
#MQTT连接IP+端口
MQTT_BROKER=tcp://127.0.0.1:1883
#mqtt连接的客户端ID
MQTT_CLIENTID=test
#MQTT发送的信息
MQTT_INFO=idle




#thread pool 线程池允许的最大并发数
THREAD_NUMBER=4
#等待时间
WAIT_TIME=60000


#socket连接模块
SOCKET_IP=172.168.1.142
SOCKET_PORT=11111




#mysql连接
MYSQL_URL=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false
MYSQL_USERNAME=root
MYSQL_PASSWD=123456


3.连接

  1 .mongodb

package com.hand.utils;


import java.util.ArrayList;
import java.util.List;


import org.bson.Document;


import com.hand.method.Configures;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;


public class MongoDB {
private static MongoClient mongoClient = null;
private static String IP = "192.168.10.250";
//private static String IP = "192.168.10.117";
//private static String IP = "192.168.10.226";
// private static String IP = "192.168.10.250";
// 10.150
private static Integer PORT = 27017;
private static Integer MAX_IDLE_TIME = 60000;


/**
* mongodb连接
* 
* @return
*/
public MongoDB() {
List<ServerAddress> addresses = new ArrayList<ServerAddress>();
if (StringUtils.isNotEmpty(Configures.getValue("MONGODB_IP"))) {
IP = Configures.getValue("MONGODB_IP").trim();
}
if (StringUtils.isNotEmpty(Configures.getValue("MONGODB_PORT"))) {
PORT = Integer.valueOf(Configures.getValue("MONGODB_PORT").trim());
}
if (StringUtils.isNotEmpty(Configures.getValue("MONGODB_MAX_IDLE_TIME"))) {
MAX_IDLE_TIME = Integer.valueOf(Configures.getValue("MONGODB_MAX_IDLE_TIME").trim());
}
ServerAddress address3 = new ServerAddress(IP, PORT);
addresses.add(address3);
MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
builder.maxConnectionIdleTime(MAX_IDLE_TIME);
MongoClientOptions opts = builder.build();
mongoClient = new MongoClient(addresses, opts);
}


/**
* 获取mongodb collection
* 
* @param dbname
* @param colname
* @return
*/
public MongoCollection<Document> getCollection(String dbname, String colname) {
// 数据库名 表名不为空
if (StringUtils.isNotEmpty(dbname) && StringUtils.isNotEmpty(colname)) {
MongoDatabase mongoDatabase = mongoClient.getDatabase(dbname); // 获取db
MongoCollection<Document> districtTitleCollection = mongoDatabase.getCollection(colname);// 获取collection
return districtTitleCollection;
} else {
return null;
}


}


/**
* 获取数据库连接
* 
* @param dbname
* @return
*/
public MongoDatabase getDatabase(String dbname) {
return mongoClient.getDatabase(dbname);
}


/**
* 获取集合连接
* 
* @param colname
* @param mongoDatabase
* @return
*/
public MongoCollection<Document> getCollection(String colname, MongoDatabase mongoDatabase) {
return mongoDatabase.getCollection(colname);
}


public static void close(MongoClient mongoClient) {
mongoClient.close();
}


public static void main(String[] args) {
// update();
MongoDB mongodb = new MongoDB();
MongoCollection<Document> col = mongodb.getCollection("hand_hygiene", "actions");
col.updateOne(new Document().append("_id", "1"),
new Document().append("$addToSet", new Document().append("info", "2")));
}
}


2. redis

package com.hand.utils;


import java.util.Map;


import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;


public class RedisUtils {
// Redis服务器IP
private static String ADDR = "192.168.10.4";
// Redis的端口号
private static int PORT = 6379;
// 可连接实例的最大数目，默认值为8
// 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
private static int MAX_ACTIVE = 1024;
// 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
private static int MAX_IDLE = 200;
// 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
private static int MAX_WAIT = 1000;
private static Integer TIME_OUT = 60000;
// 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
private static boolean TEST_ON_BORROW = true;
private static JedisPool jedisPool = null;
//private static String PASSWD = "123456";


/**
* 初始化Redis连接池
*/
public static void initialPool() {
try {
JedisPoolConfig config = new JedisPoolConfig();
// if (StringUtils.isNotEmpty(Configures.getValue("REDIS_IP"))) {
// ADDR = Configures.getValue("REDIS_IP").trim();
// }
// if (StringUtils.isNotEmpty(Configures.getValue("REDIS_PORT"))) {
// PORT = Integer.valueOf(Configures.getValue("REDIS_PORT").trim());
// }
// if
// (StringUtils.isNotEmpty(Configures.getValue("REDIS_MAX_ACTIVE")))
// {
// MAX_ACTIVE =
// Integer.valueOf(Configures.getValue("REDIS_MAX_ACTIVE").trim());
// }
// if
// (StringUtils.isNotEmpty(Configures.getValue("REDIS_MAX_IDLE"))) {
// MAX_IDLE =
// Integer.valueOf(Configures.getValue("REDIS_MAX_IDLE").trim());
// }
// if
// (StringUtils.isNotEmpty(Configures.getValue("REDIS_MAX_WAIT"))) {
// MAX_WAIT =
// Integer.valueOf(Configures.getValue("REDIS_MAX_WAIT").trim());
// }
// if (StringUtils.isNotEmpty(Configures.getValue("REDIS_PASSWD")))
// {
// PASSWD = Configures.getValue("REDIS_PASSWD").trim();
// }
// if
// (StringUtils.isNotEmpty(Configures.getValue("REDIS_TEST_ON_BORROW")))
// {
// TEST_ON_BORROW =
// Boolean.valueOf(Configures.getValue("REDIS_TEST_ON_BORROW").trim());
// }
// if
// (StringUtils.isNotEmpty(Configures.getValue("REDIS_TIME_OUT"))) {
// TIME_OUT =
// Integer.valueOf(Configures.getValue("REDIS_TIME_OUT").trim());
// }
config.setMaxTotal(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWaitMillis(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR, PORT, TIME_OUT);
} catch (Exception e) {
e.printStackTrace();
}
}


/**
* 在多线程环境同步初始化
*/
private synchronized static void poolInit() {
if (jedisPool == null) {
initialPool();
}
}


/**
* 同步获取Jedis实例
* 
* @return
*/
public static Jedis getJedis() {
Jedis jedis = getjedisCon();
Integer i = 1;
while (jedis == null && i < 3) {
System.out.println("第" + i + "次，连接失败");
jedis = getjedisCon();
i++;
}
return jedis;
}


/**
* 获取Jedis实例
* 
* @return
*/
public static Jedis getjedisCon() {
if (jedisPool == null) {
poolInit();
}
Jedis resource = null;
try {
if (jedisPool != null) {
resource = jedisPool.getResource();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (resource != null) {
// returnResource(resource);
}
}
return resource;
}


/**
* 不在redis连接池中获取jedis实例
* 
* @return
*/
public static Jedis getSingleJedis() {
Jedis jedis = new Jedis(ADDR, PORT);
//jedis.auth(PASSWD);
return jedis;
}

/**
* 获取Map值
* 
* @param mapKey
*            valueKey
*/
public static String getStringFromRedis(String mapKey, String valueKey) {
Jedis jedis = getJedis();
String val = null;
if(jedis != null){
try {
val = jedis.hget(mapKey, valueKey);
} catch (Exception e) {
e.printStackTrace();
} finally {
close(jedis);
}
}
return val;
}


/**
* 取到队列的最后一个元素，并将其移除
* 
* @param listName
* @return
*/
public static String rpop(String listName) {
Jedis jedis = RedisUtils.getJedis();
String s = null;
try {
s = jedis.rpop(listName);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (jedis != null) {
jedis.close();
}
}
return s;


}


/**
* 获取散列hash中某域的值
* 
* @param key
* @param field
* @return
*/
public static String hget(String key, String field) {
Jedis jedis = RedisUtils.getJedis();
String val = null;
try {
val = jedis.hget(key, field);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (jedis != null) {
jedis.close();
}
}
return val;


}


/**
* 移除散列中的某个键
* 
* @param key
* @param field
*/
public static void hdel(String key, String field) {
Jedis jedis = RedisUtils.getJedis();
try {
jedis.hdel(key, field);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (jedis != null) {
jedis.close();
}
}
}


/**
* 设置散列某个域的值
* 
* @param key
* @param field
* @param value
*/
public static void hset(String key, String field, String value) {
Jedis jedis = RedisUtils.getJedis();
try {
jedis.hset(key, field, value);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (jedis != null) {
jedis.close();
}
}
}


/**
* 获取散列
* 
* @param key
* @return
*/
public static Map<String, String> hgetAll(String key) {
Jedis jedis = RedisUtils.getJedis();
Map<String, String> map = null;
try {
map = jedis.hgetAll(key);
} catch (Exception e) {
e.printStackTrace();
}
return map;
}

/**
* 释放jedis资源
* 
* @param jedis
*/
public static void close(Jedis jedis) {
if (jedis != null) {
jedis.close();
}
}

}

3.mysql 

package com.hand.utils;


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;


import com.hand.method.Configures;


public class MysqlUtil {
//驱动信息   
private static String URL = "jdbc:mysql://192.168.10.4:3307/hand?useUnicode=true&characterEncoding=utf8&useSSL=false";
private static String USERNAME = "root";
private static String PASSWD = "123456";
static {
if (StringUtils.isNotEmpty(Configures.getValue("MYSQL_URL"))) {
URL = Configures.getValue("MYSQL_URL").trim();
}
if (StringUtils.isNotEmpty(Configures.getValue("MYSQL_USERNAME"))) {
USERNAME = Configures.getValue("MYSQL_USERNAME").trim();
}
if (StringUtils.isNotEmpty(Configures.getValue("MYSQL_PASSWD"))) {
PASSWD = Configures.getValue("MYSQL_PASSWD").trim();
}
}


public static Connection getConnection() {
try {
Connection con = DriverManager.getConnection(URL, USERNAME, PASSWD);
return con;
} catch (SQLException se) {
getConnection();
}
return null;
}


public static ResultSet query(Connection conn, String sql) {
// statement创建对象
try {
Statement statement = conn.createStatement();
// 返回的结果集
ResultSet rs = statement.executeQuery(sql);
return rs;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}


public static Integer update(Connection conn, String sql) {
// statement创建对象
try {
Statement statement = conn.createStatement();
Integer i = statement.executeUpdate(sql);
return i;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}


public static void main(String[] args) throws Exception {
Connection conn = getConnection();
String sql = "select * from synchro_data";
ResultSet rs = query(conn, sql);
while(rs.next()){
System.out.println(rs.getString("id"));
}
//Connection conn = getConnection("", "", "");
// 创建sql
// String sql = "select * from test where name LIKE '%����%'";
// ResultSet rs = query(conn, sql);
//String sql = "insert test(name,gmt_created,gmt_modified) values" + "('����',now(),now())";
// 执行结果
//Integer rs = update(conn, sql);
//System.out.println(rs);
// while (rs.next()) {
// // ������
// System.out.println(rs.getString("id") + "\t" + rs.getString("name") +
// "\t" + rs.getString("gmt_created")
// + "\t" + rs.getString("gmt_modified"));
// }
// rs.close();
//conn.close();
}


}


2.2packacom.hand.utils;


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;


import com.hand.method.Configures;


public class MysqlUtil {
//驱动信息   
private static String URL = "jdbc:mysql://192.168.10.4:3307/hand?useUnicode=true&characterEncoding=utf8&useSSL=false";
private static String USERNAME = "root";
private static String PASSWD = "123456";
static {
if (StringUtils.isNotEmpty(Configures.getValue("MYSQL_URL"))) {
URL = Configures.getValue("MYSQL_URL").trim();
}
if (StringUtils.isNotEmpty(Configures.getValue("MYSQL_USERNAME"))) {
USERNAME = Configures.getValue("MYSQL_USERNAME").trim();
}
if (StringUtils.isNotEmpty(Configures.getValue("MYSQL_PASSWD"))) {
PASSWD = Configures.getValue("MYSQL_PASSWD").trim();
}
}


public static Connection getConnection() {
try {
Connection con = DriverManager.getConnection(URL, USERNAME, PASSWD);
return con;
} catch (SQLException se) {
getConnection();
}
return null;
}


public static ResultSet query(Connection conn, String sql) {
// statement创建对象
try {
Statement statement = conn.createStatement();
// 返回的结果集
ResultSet rs = statement.executeQuery(sql);
return rs;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}


public static Integer update(Connection conn, String sql) {
// statement创建对象
try {
Statement statement = conn.createStatement();
Integer i = statement.executeUpdate(sql);
return i;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}


public static void main(String[] args) throws Exception {
Connection conn = getConnection();
String sql = "select * from synchro_data";
ResultSet rs = query(conn, sql);
while(rs.next()){
System.out.println(rs.getString("id"));
}
//Connection conn = getConnection("", "", "");
// 创建sql
// String sql = "select * from test where name LIKE '%����%'";
// ResultSet rs = query(conn, sql);
//String sql = "insert test(name,gmt_created,gmt_modified) values" + "('����',now(),now())";
// 执行结果
//Integer rs = update(conn, sql);
//System.out.println(rs);
// while (rs.next()) {
// // ������
// System.out.println(rs.getString("id") + "\t" + rs.getString("name") +
// "\t" + rs.getString("gmt_created")
// + "\t" + rs.getString("gmt_modified"));
// }
// rs.close();
//conn.close();
}


}




22




qq_31645907
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java语言链接MongoDB常用的方法
m0_46420244的博客
07-17 6236
MongoDB官方提供了Java和Python语言的驱动包，利用这些驱动包可使用多种编程方法来连接并操作MongoDB数据库。本节将介绍如何设置和使用MongoDBJDBC驱动程序，通过JDBC实现与MongoDB服务端的通信功能，用户可以在此基础上进行各种Java程序的开发。MongoDB作为一种介于关系型数据库和非关系型数据库之间的产品，它可以提供可扩展的高性能的数据存储解决方案，近些年来受到了开发者的喜爱。1.社交场景，比如朋友圈，附近的人的地点的存储。...
Java经典面试题：Redis 和 Mysql 如何保证数据一致性
wml_JavaKill的博客
07-28 3352
实时一致性方案：采用“先写 MySQL，再删除Redis”的策略，这种情况虽然也会存在两者不一致，但是需要满足的条件有点苛刻，所以是满足实时性条件下，能尽量满足一致性的最优解。最终一致性方案：采用“先写 MySQL，通过 Binlog，异步更新 Redis”，可以通过 Binlog，结合消息队列异步更新 Redis，是最终一致性的最优解。
Java+MySQL+redis缓存
12-18
案例中数据来自MySQL数据库，对查询出来的数据缓存到redis,redis缓存工具可以将缓存string，bean,list，map等类型，代码中有详细的注释，而且还将要缓存的数据进行了序列化，大家可以借鉴，进而更改成自己想要的格式。数据库配置使用了xml和propertis两种配置方式，redis缓存采用非切片和切片两种配置，大家可以自选择
【JAVA面试】Redis和Mysql如何保证数据一致
Gangangan_的博客
05-09 1053
提示：文章先作为初版，等后续时间充足后，补充更深的内容。
JDBC 使用
hjh_cos
03-14 1549
jedis没有根据 jdbc 规范实现接口
springboot整合mongodb+redis+mybatis+mysql
08-15
本示例项目整合了多种数据库技术，包括 MongoDB、Redis 和 MyBatis，同时使用 MySQL 作为传统的关系型数据库。 MongoDB 是一个基于分布式文件存储的非关系型数据库，适用于处理大量数据的场景，尤其适合文档型数据...
MongoDB，Netty，Nginx，MySQL，Java，Redis，Shiro，Solr，SpringBoot.zip
03-06
目前已经完成：MongoDB，Netty，Nginx，MySQL，Java，Redis，Shiro，Solr，SpringBoot，SpringData，SSO，Mybatis，Kotlin，还在持续更新中.zip 每天都在进步，每周都在总结，Java架构师成长之路。目前已经完成：...
databases:适用于MySQL，MongoDB和Redis的ORM
03-26
该数据库项目是一个基于com.celeste.messenger.annotation的连接提供程序，以及对SQL和NoSQL数据库（例如MongoDB，MySQL和Redis）的查询。 在这里，您可以找到该项目的源代码和文档。 该项目将完全支持MongoDB，...
Mysql,Mongodb,Redis对比
12-14
MySQL、MongoDB和Redis是三种广泛应用的数据库系统，它们各自具有独特的特性和适用场景。下面是对这三种数据库的详细对比： MySQL： 1. **多语言支持**：MySQL为多种编程语言如Java、Python、PHP、C++等提供了API，...
基于微服务架构实现的智能招聘系统+本科毕业设计+Mysql+Mongodb+Redis+Spring-Boot
06-14
基于微服务架构实现的智能招聘系统+本科毕业设计+Mysql+Mongodb+Redis+Spring-Boot 项目经过严格测试，确保可以运行！ 部署方式 docker部署：mvn docker:build & java -jar 物理机部署：mvn install & java -jar ...
redis+mysql使用学习
07-02
redis缓存mysql数据，实现通过redis解决数据库读操作频繁的问题。
REDIS缓存数据库在JAVA中的使用
01-18
零基础学会REDIS缓存数据库在JAVA中的使用。从REDIS的安装和使用开始，到Java程序与REDIS数据库进行连接互动，简单明了。
Redis+mysql整合spring的Demo
04-07
redis使用例子，包含增删改査
MySQL 与 Redis 缓存的同步方案
qiang327839549的博客
04-06 1659
MySQL 和 Redis 都是常见的数据存储方案，MySQL 用于存储结构化数据，Redis 用于存储非结构化数据。在一些高并发场景下，为了提升系统的性能，我们通常会将数据存储在 Redis 缓存中，并通过 Redis 缓存来提高系统的读取速度。但是，Redis 缓存中的数据是不稳定的，可能会随时被删除或者被更新，因此需要和 MySQL 中的数据进行同步，保证数据的一致性。本文将介绍如何通过 Java 代码实现 MySQL 和 Redis 缓存的同步方案。缓存同步方案方案一：基于消息队列的同步方案。
java、redis、mysql归纳总结
qq_25073261的博客
04-27 4303
1 HashMap底层源码，数据结构 hashMap的底层结构在jdk1.7中由数组+链表实现，在jdk1.8中由数组+链表+红黑树实现，以数组+链表的结构为例。 JDK1.8之前Put方法： JDK1.8之后Put方法： 附： 一、HashMap底层实现原理解析 我们常见的有数据结构有三种结构： 数组结构 链表结构 哈希表结构 下面我们来看看各自的数据结构的特点： 1）数组结构： 存储区间连续、内存占用严重、空间复杂度大 优点：随机读取和修改效率高，原因是数组是连续的（随机访问性强，查找速度快） 缺点：插
Redis与MySQL数据双写一致性工程落地案例
最新发布
2401_84048149的博客
04-16 387
总的来说，面试是有套路的，一面基础，二面架构，三面个人。最后，小编这里收集整理了一些资料，其中包括面试题（含答案）、书籍、视频等。希望也能帮助想进大厂的朋友《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！)][外链图片转存中…(img-tFhMcaR3-1713277146570)][外链图片转存中…(img-9oLELWiM-1713277146570)]
win下安装jdk/redis/mysql等服务简单安装步骤
weixin_42653892的博客
02-16 515
jdk,mysql,redis 等服务的安装 及开发中常用的基础软件安装包
如何保障 MySQL 和 Redis 的数据一致性？
m0_62051288的博客
04-23 3629
前言 在写这篇文章前，我把所有的情况简单列一下： 先写 MySQL，再写 Redis 先写 Redis，再写 MySQL 先删除 Redis，再写 MySQL 先删除 Redis，再写 MySQL，再删除 Redis 先写 MySQL，再删除 Redis 先写 MySQL，通过 Binlog，异步更新 Redis 除了上面的 Case，还有文章总结出以下策略： Cache Aside（旁路缓存）策略 Read/Write Through（读穿 / 写穿）策略 Write Back（写回）
java连接远程Redis
qq_52061700的博客
08-02 819
jedis远程连接Redis步骤
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值