JAVA_JDBC面向对象分页(初步设计一之mysql)

最新推荐文章于 2021-03-13 12:17:40 发布
最新推荐文章于 2021-03-13 12:17:40 发布
阅读量119 收藏
点赞数
分类专栏： JAVA 文章标签： Java JDBC MySQL Oracle SQL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_5724/article/details/81794836
版权

看了很多网上的分页写法，有兴趣的可以直接去看看hibernate的源码，里面的写法还是值得参考，先理清思路：

1.要想分页，就要获取分页所需信息，这里用一个类PageInfo表示：

哪个对象，真正面向对象分页就要配置实体和数据库的映射关系，通过解析配置文件加上java的反射技术就ok了。

有时间会慢慢补充完整。

以下是各种数据库的分页语句：

以@开头的都是自定义变量，到后面都会被替换成具体的内容，这样写看起清晰点(个人见解)，初步设计如下：
@PAGE_SIZE表示每页显示多少条
@CURRENT_PAGE 当前要查看的页数
@TABLE_NAME 表名
@PKEY 主键
@criterions 条件集合
@orders 排序集合

sqk2k5分页语句:

 

分页结果集语句：
SELECT TOP(@PAGE_SIZE) * FROM @TABLE_NAME WHERE @PKEY NOT IN 
(SELECT TOP(@PAGE_SIZE*(@CURRENT_PAGE-1)) @PKEY FROM @TABLE_NAME WHERE 1=1 @CONDITIONS @ORDERS) @CONDITIONS @ORDERS

统计语句：
SELECT COUNT(*) FROM @TABLE_NAME WHERE 1=1 @CONDITIONS

 

mysql分页语句：

分页结果集语句：
SELECT * FROM @TABLE_NAME WHERE 1=1 @CONDITIONS @ORDERS LIMIT @FIRST_INDEX,@PAGE_SIZE 
统计语句：
SELECT COUNT(*) FROM @TABLE_NAME WHERE 1=1 @CONDITIONS

  

 oracle分页语句：

 

 以下以mysql做实验,太细节的东西就不必追究了，主要是核心思想的实现：

测试准备：

1.数据库paginationdb，表student_;

2.数据库脚本：

SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for student_
-- ----------------------------
DROP TABLE IF EXISTS `student_`;
CREATE TABLE `student_` (
  `id_` int(11) NOT NULL auto_increment,
  `name_` varchar(20) default NULL,
  `sex_` varchar(20) default NULL,
  `age_` int(11) default NULL,
  `grade_` varchar(60) default NULL,
  `class_` varchar(60) default NULL,
  PRIMARY KEY  (`id_`)
) ENGINE=MyISAM AUTO_INCREMENT=21 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records 
-- ----------------------------
INSERT INTO `student_` VALUES ('1', 'student1', '男', '11', '一年级', '二班');
INSERT INTO `student_` VALUES ('2', 'student2', '男', '12', '一年级', '二班');
INSERT INTO `student_` VALUES ('3', 'student3', '男', '13', '一年级', '二班');
INSERT INTO `student_` VALUES ('4', 'student4', '女', '14', '一年级', '二班');
INSERT INTO `student_` VALUES ('5', 'student5', '女', '15', '一年级', '二班');
INSERT INTO `student_` VALUES ('6', 'student6', '男', '16', '二年级', '一班');
INSERT INTO `student_` VALUES ('7', 'student7', '男', '17', '二年级', '一班');
INSERT INTO `student_` VALUES ('8', 'student8', '女', '18', '一年级', '一班');
INSERT INTO `student_` VALUES ('9', 'story1', '男', '19', '一年级', '二班');
INSERT INTO `student_` VALUES ('10', 'story2', '女', '11', '一年级', '一班');
INSERT INTO `student_` VALUES ('11', 'story3', '男', '12', '二年级', '一班');
INSERT INTO `student_` VALUES ('12', 'story4', '女', '13', '一年级', '二班');
INSERT INTO `student_` VALUES ('13', 'story5', '男', '14', '一年级', '一班');
INSERT INTO `student_` VALUES ('14', 'story6', '男', '15', '一年级', '一班');
INSERT INTO `student_` VALUES ('15', 'story7', '女', '16', '一年级', '二班');
INSERT INTO `student_` VALUES ('16', 'story8', '男', '17', '一年级', '二班');
INSERT INTO `student_` VALUES ('17', 'story9', '男', '18', '一年级', '二班');
INSERT INTO `student_` VALUES ('18', 'story8', '男', '15', '一年级', '二班');
INSERT INTO `student_` VALUES ('19', 'story8', '男', '16', '一年级', '二班');
INSERT INTO `student_` VALUES ('20', 'story10', '保密', '16', '一年级', '二班');

 

3.测试数据

 

以下是分页类（pageInfo）的初步设计：

package org.forever.entities;

import java.util.List;

//分页信息
public class PageInfo {

	private int currentPage = 1;// 当前页
	private int totalPage;// 总页数
	private int totalItems;// 总条数
	private int pageSize = 10;// 每页显示多少条
	private List<?> result;// 结果集合

	private String tableName;// 表名
	private String pkey;// 主键
	private Condition[] conditions;// 条件集合
	private Order[] orders;// 排序集合

	public PageInfo() {

	}

	public int getCurrentPage() {
		return currentPage;
	}

	public void setCurrentPage(int currentPage) {
		this.currentPage = currentPage;
	}

	public int getTotalPage() {
		return totalPage;
	}

	public void setTotalPage(int totalPage) {
		this.totalPage = totalPage;
	}

	public int getTotalItems() {
		return totalItems;
	}

	public void setTotalItems(int totalItems) {
		this.totalItems = totalItems;
	}

	public List<?> getResult() {
		return result;
	}

	public void setResult(List<?> result) {
		this.result = result;
	}

	public String getTableName() {
		return tableName;
	}

	public void setTableName(String tableName) {
		this.tableName = tableName;
	}

	public String getPkey() {
		return pkey;
	}

	public void setPkey(String pkey) {
		this.pkey = pkey;
	}

	public Condition[] getConditions() {
		return conditions;
	}

	public void setConditions(Condition[] conditions) {
		this.conditions = conditions;
	}

	public Order[] getOrders() {
		return orders;
	}

	public void setOrders(Order[] orders) {
		this.orders = orders;
	}

	public int getPageSize() {
		return pageSize;
	}

	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

}

 操作类型枚举：

package org.forever.entities;
//操作类型
public enum Operation {
	IN,
	EQ,
	GT,
	LT,
	NE,
	GE,
	LE,
	BETWEEN,
	LIKE
	
	
}

 排序类型枚举：

package org.forever.entities;

public enum OrderType {

	ASC,
	DESC
	
}

 条件操作：

package org.forever.entities;

//条件操作
public class Condition {

	private String propertyName;// 属性名
	private Object propertyValue;// 属性值
	private Operation operation;// 操作符号

	public Condition() {
	}

	public String getPropertyName() {
		return propertyName;
	}

	public void setPropertyName(String propertyName) {
		this.propertyName = propertyName;
	}

	public Object getPropertyValue() {
		return propertyValue;
	}

	public void setPropertyValue(Object propertyValue) {
		this.propertyValue = propertyValue;
	}

	public Operation getOperation() {
		return operation;
	}

	public void setOperation(Operation operation) {
		this.operation = operation;
	}

	public Condition(String propertyName, Object propertyValue,
			Operation operation) {
		super();
		this.propertyName = propertyName;
		this.propertyValue = propertyValue;
		this.operation = operation;
	}
	
	

}

 排序操作：

package org.forever.entities;

public class Order {

	private String propertyName;// 属性名
	private OrderType orderType;// 排序类型

	public Order() {

	}

	public Order(String propertyName, OrderType orderType) {
		super();
		this.propertyName = propertyName;
		this.orderType = orderType;
	}

	public String getPropertyName() {
		return propertyName;
	}

	public void setPropertyName(String propertyName) {
		this.propertyName = propertyName;
	}

	public OrderType getOrderType() {
		return orderType;
	}

	public void setOrderType(OrderType orderType) {
		this.orderType = orderType;
	}

}

 student类：

package org.forever.entities;

import java.io.Serializable;

public class Student implements Serializable{
	private static final long serialVersionUID = -1646247293734375803L;
	public Integer id;//主键
	public String name;//名字
	public String sex;//性别
	public String grade;//年级
	public String stuClass;//班级
	public int age;//年龄

	public Student() {

	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public String getGrade() {
		return grade;
	}

	public void setGrade(String grade) {
		this.grade = grade;
	}

	public String getStuClass() {
		return stuClass;
	}

	public void setStuClass(String stuClass) {
		this.stuClass = stuClass;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	
}

 学生业务：

package org.forever.manager;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.forever.entities.Condition;
import org.forever.entities.Operation;
import org.forever.entities.Order;
import org.forever.entities.OrderType;
import org.forever.entities.PageInfo;
import org.forever.entities.Student;

import com.mysql.jdbc.Driver;

public class StudentManager {
	
	public void doPager(PageInfo pageInfo){
		
		StringBuffer sqlPage = new StringBuffer("SELECT * FROM @TABLE_NAME WHERE 1=1 @CONDITIONS @ORDERS LIMIT @FIRST_INDEX,@PAGE_SIZE ");
		StringBuffer sqlCount = new StringBuffer("SELECT COUNT(*) FROM @TABLE_NAME WHERE 1=1 @CONDITIONS ") ;
		
		//处理条件
		Condition[]conditions = pageInfo.getConditions();
		StringBuffer condition = new StringBuffer();
		List<Object> params = new ArrayList<Object>();
		
		if(conditions!=null && conditions.length>0){
			for (Condition item : conditions) {
				
				switch (item.getOperation()) {
				case EQ:
					condition.append(" AND (" + item.getPropertyName()+" =?) ");
					break;
				case LIKE:
					condition.append(" AND (" + item.getPropertyName()+" LIKE ?) ");
					break;
				case BETWEEN:
					condition.append(" AND (" + item.getPropertyName() + " BETWEEN ? AND ?) ");
					break;
				case IN:
					condition.append(" AND (" + item.getPropertyName() + " IN (");
					for (int i = 0; i < ((Object[])item.getPropertyValue()).length; i++) {
						condition.append("?,");
					}
					condition.replace(condition.length()-1, condition.length(), "");
					condition.append(")) ");
					//.....
				default:
					break;
				}
				
				if(item.getOperation() == Operation.LIKE){
					params.add("%"+item.getPropertyValue()+"%");
				}else if(item.getOperation() == Operation.BETWEEN){
					params.add(((Object[])item.getPropertyValue())[0]);
					params.add(((Object[])item.getPropertyValue())[1]);
				}else if(item.getOperation() == Operation.IN){
					for (Object object : (Object[])item.getPropertyValue()) {
						params.add(object);
					}
				}else{
					params.add(item.getPropertyValue());
				}
				
				
			}
		}
		//处理排序
		Order[]orders = pageInfo.getOrders();
		StringBuffer orderList = new StringBuffer(" ORDER BY ");
		if(orders!=null && orders.length>0){
			for (Order item : orders) {
				switch (item.getOrderType()) {
				case ASC:
					orderList.append(item.getPropertyName()+" ASC ,");
					break;
						
				case DESC:
					orderList.append(item.getPropertyName()+" DESC ,");
					break;
				}
			}
			orderList.replace(orderList.length()-1, orderList.length(), "");
		}else{
			orderList.append(" @PKEY ASC ");
		}
		
		String sqlp=sqlPage.toString()
					.replaceAll("@CONDITIONS", condition.toString())
					.replaceAll("@ORDERS", orderList.toString())
					.replaceAll("@TABLE_NAME", pageInfo.getTableName())
					.replaceAll("@PKEY", pageInfo.getPkey())
					.replaceAll("@FIRST_INDEX", (pageInfo.getCurrentPage()-1)*pageInfo.getPageSize()+"")
					.replaceAll("@PAGE_SIZE", pageInfo.getPageSize()+"");
		
		String sqlc = sqlCount.toString()
					.replaceAll("@CONDITIONS", condition.toString())
					.replaceAll("@TABLE_NAME", pageInfo.getTableName())
					.replaceAll("@PKEY", pageInfo.getPkey());
		Connection connection = null;
		PreparedStatement statement = null;
		ResultSet resultSet = null;
		try {
			Class.forName(Driver.class.getName());
			connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/paginationdb", "root", "root");
			statement = connection.prepareStatement(sqlc);
			for (int i = 0; i < params.size(); i++) {
				statement.setObject(i+1, params.get(i));
			}
			resultSet = statement.executeQuery();
			resultSet.next();
			int totalItems = resultSet.getInt(1);
			//设置总条数
			pageInfo.setTotalItems(totalItems);
			//设置总页数
			pageInfo.setTotalPage(
					totalItems%pageInfo.getPageSize()==0?
							totalItems/pageInfo.getPageSize():
								totalItems/pageInfo.getPageSize()+1
			);
			//设置结果集
			statement = connection.prepareStatement(sqlp);
			for (int i = 0; i < params.size(); i++) {
				statement.setObject(i+1, params.get(i));
			}
			resultSet = statement.executeQuery();
			List<Student> students = new ArrayList<Student>();
			while(resultSet.next()){
				Student student = new Student();
				student.setId(resultSet.getInt("id_"));
				student.setName(resultSet.getString("name_"));
				student.setSex(resultSet.getString("sex_"));
				student.setAge(resultSet.getInt("age_"));
				student.setGrade(resultSet.getString("grade_"));
				student.setStuClass(resultSet.getString("class_"));
				students.add(student);
			}
			
			pageInfo.setResult(students);
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(connection!=null){
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	public static void main(String[] args) {
		StudentManager studentManager = new StudentManager();
		PageInfo pageInfo = new PageInfo();
		pageInfo.setTableName("student_");//指定查询表名
		pageInfo.setPkey("id_");//指定该表的主键名
		pageInfo.setPageSize(2);//每页显示2条
		pageInfo.setCurrentPage(2);//查看第二页
		
		//实体暂时没有和数据库进行映射，所以条件和排序里面的属性名暂时写成数据库的属性名
		
		/*例子：查询一年级二班，名字中包含stor的，年龄在14到18的，性别是男和女的学生
		 *并且按照姓名升序排序，名字相同的按照年龄的逆序排序。 
		 */
		pageInfo.setConditions(
				new Condition[]{
					new Condition("grade_", "一年级", Operation.EQ),	
					new Condition("class_", "二班", Operation.EQ),
					new Condition("name_","stor",Operation.LIKE),
					new Condition("age_", new Object[]{14,18}, Operation.BETWEEN),
					new Condition("sex_",new Object[]{"男","女"},Operation.IN)
				}
		);
		
		pageInfo.setOrders(
				new Order[]{
					new Order("name_", OrderType.ASC),
					new Order("age_",OrderType.DESC)
				}
		);
		
		studentManager.doPager(pageInfo);
		System.out.println("totalPage:"+pageInfo.getTotalPage());
		System.out.println("totalItems:" + pageInfo.getTotalItems());
		for (Object item : pageInfo.getResult()) {
			System.out.println("***************");
			System.out.println(((Student)item).getId());
			System.out.println(((Student)item).getName());
			System.out.println(((Student)item).getSex());
		}
		
		
	}
	
}

 

iteye_5724
关注
专栏目录
Java——JDBC操作数据库，分页查询
sapce_fish的博客
10-09 1万+
原文地址：http://blog.csdn.net/sapce_fish/article/details/52764678 对数据库的操作无非就是增删改查，其中数查询操作最为复杂，所以将查询单独讲解，我这里用的Mysql数据库 增删改操作 分页查询操作 1.查询结果以list返回 2.查询结果以jsonArray返回 3.查询总记录条数
Java0基础_day22_JDBC增强版_Mybatis框架
zhugeheihei的博客
12-03 224
标签：Mybatis、JDBC、 1.Mybatis概述 本部分将简要介绍Mybatis，特别是其核心的构建。 Mybatis是什么？ Mybaits由apache→google→github，原名ibatis，它是基于java的持久层框架，可以看成是我们前面学习的jdbc 的增强版，核心概念包括Daos接口和Mysqlmaps映射文件。开发人员只需要写好sql语句，交给Mybatis处理，然后就可以得到想要的List集合/java对象，非常方便！ 为什么需要Mybatis？ 前面已经说了j.
java jdbc 分页_Java _分页Jdbc 版
weixin_35513122的博客
02-12 195
人生得意须尽欢，莫使金樽空对月。先天下之忧而忧，后天下之乐而乐。大东北的天气已经渐入佳境了，在夜深人静的时候，随着鼠标的移动，键盘清脆的声音，开启了今天的睡前代码工程！今天聊聊JDBC版本的分页，分页功能在很多的web项目中都是必须的功能，然而分页有真假分页，假分页，例如某某某网站，你懂得。什么是真分页呢，共显示9页，当点击第6页的时候，第一页会往前移动，显示2到10页 。还有首页变黑的功能，还有...
JDBC使用数据库来完成分页功能
weixin_30436101的博客
03-13 163
　　本篇讲诉如何在页面中通过操作数据库来完成数据显示的分页功能。当一个操作数据库进行查询的语句返回的结果集内容如果过多，那么内存极有可能溢出，所以在大数据的情况下分页是必须的。当然分页能通过很多种方式来实现，而这里我们采用的是操作数据库的方式，而且在这种方式中，最重要的是带限制条件的查询SQL语句： select name from user limit m,n 　　其中m与n为数字。...
java jdbc分页查询,JAVA JDBC 简单分页
weixin_39623671的博客
03-13 212
JAVA JDBC 简单分页/***需要传入 pageNo 当前页* pageSize一页显示的条数**/Connection conn = ConnectionUtil.getConnection();//获取JDBC链接。自己写的工具类try{String sql="查询语句";PreparedStatement pstat = conn.prepareStatemen...
java jdbc 分页_jdbc 实现分页
weixin_39947501的博客
02-21 362
jdbc 实现分页，的实现原理这个就不介绍了。。总之是用jdbc 的游标移动package com.sp.person.sql.util;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.uti...
java jsp mysql分页（原代码）
02-21
首先，Java是一种广泛使用的面向对象编程语言，常用于服务器端开发。在这里，Java被用来编写后台逻辑，处理与数据库的交互。JDBC（Java Database Connectivity）是Java中用于连接和操作数据库的标准接口，它使得...
基于 Java 和 MySQL 实现（控制台）邮件检索功能【100012048】
最新发布
04-28
这是一个常见的课程设计任务，旨在帮助学生掌握面向对象编程、数据库操作以及用户交互的基本技能。 首先，我们需要理解Java在其中的角色。Java是一种广泛使用的面向对象的编程语言，特别适合开发跨平台的应用程序。...
java resultset 分割_Java：一个简捷的可分页的ResultSet实现
weixin_32602727的博客
02-13 548
内容前言JDBC和分页和具体数据库相关的实现方法另一种繁琐的实现方法使用Vector进行分页一个新的Pageable接口及其实现Pageable的使用方法总结参考资料关于作者前言在使用数据库的过程中，不可避免的需要使用到分页的功能，可是JDBC的规范对此却没有很好的解决。对于这个需求很多朋友都有自己的解决方案，比如使用Vector等集合类先保存取出的数据再分页。但这种方法的可用性很差，与JDBC本...
JAVA分页MYSQL数据库
01-24
本示例"JAVA分页MYSQL数据库"是一个很好的教学案例，适用于J2EE初学者，它结合了基本的CRUD（创建、读取、更新、删除）操作与数据库分页技术。下面将详细解释相关的知识点。 1. **Java编程基础**：这个项目基于Java...
Java之JDBC数据库连接+列表展示和分页功能（三）
啊林博客
07-31 1630
目录 1.在UserDao接口中，添加Count方法 2.在UserDaoImp类中实现这个方法 3.在entity层中，添加PageUtil类 4.在service层中，UserService接口添加代码 5.在serviceImp层中，UserServiceImp类中添加代码 6.在Controller中，添加ListByPageServlet类 7.编写index.jsp 8...
java jdbc分页查询_JDBC在Java Web中的应用——分页查询
weixin_32565397的博客
02-16 713
本文转自http://www.cnblogs.com/gaopeng527/p/4448105.html 感谢作者分页查询通过JDBC实现分页查询的方法有很多种，而且不同的数据库机制也提供了不同的分页方式，在这里介绍两种非常典型的分页方法。通过ResultSet的光标实现分页通过ResultSet的光标实现分页，优点是在各种数据库上通用，缺点是占用大量资源，不适合数据量大的情况。2. 通过数据库机...
java jdbc 分页_JDBC在javaweb中的应用之分页数据查询
weixin_35927318的博客
02-21 444
---恢复内容开始---分页查询分页查询是java web开发中经常使用到的技术。在数据库中数据量非常大的情况下，不适合将所有的数据全部显示到一个页面中，同时为了节约程序以及数据库的资源，就需要对数据进行分页查询操作。通过JDBC实现分页的方法比较多，而且不同的数据库机制其分页的方式也不同，这里我们介绍典型的两个分页方法。1.通过ResultSet的光标实现分页该分页方法可以在各种数据库之间通用，...
java面包屑导航制作
iteye_5724的博客
03-04 497
做了个简单的面包屑导航功能,比如页面上大家经常看到的这种导航：   您所在的位置：音乐社区--&gt;用户模块--&gt;用户注册   我做成了标签的形式，利用jom4j来解析xml文件： 核心类SiteMapTag： package org.forever.tag; import java.io.InputStream; import java.util.ArrayList;...
JAVA与DLL交互
iteye_5724的博客
08-27 142
jna官网地址：https://jna.dev.java.net/ 首先写了一个用于测试的DLL文件: FirstDLL.h头文件：   #ifdef FirstDLL_API #else #define FirstDLL_API extern "C" _declspec(dllimport) #endif typedef struct{ char* userName;...
SERVLET3.0介绍
iteye_5724的博客
03-04 137
servlet3.0规范：   下面的说明适用从servlet 3.0规范的开始， @WebServlet @ WebServlet @WebServletContextListener @ WebServletContextListener @ServletFilter @ ServletFilter @InitParam @ InitParam  以前基于x...
OSGI学习笔记（五）
iteye_5724的博客
07-31 113
开放服务网关协议 (Open Services Gateway initiative)，简称OSGi，为网络服务定义了一个标准的、面向服务的计算环境，为用户提供了开放的、面向服务组件的、易于部署的编程模型，这个编程模型允许用户将定义好的接口规范绑定到OSGi运行环境中的特定Service，在构建SOA 面向服务为中心的企业应用的过程中，OSGi 技术正发挥越来越重要的作用。OSGi 是由 1999...
ubuntu10.04下eclipse的安装及配置
iteye_5724的博客
03-14 100
从官方http://www.eclipse.org/downloads/ 下载需要的版本。 然后转到下载的目录下,解压到指定的路径： sudo tar -zxvf eclipse-jee-indigo-SR2-linux-gtk.tar.gz -C /home/chenjun/eclipse 在桌面上创建启动器：     右键-&gt;Create Launcher，然后这样...
Java面试深度解析：面向对象与JDBC、MySQL核心技术
"Java面试宝典涵盖了Java SE编程基础、JDBC技术和MySQL数据库技术等多个方面的内容，旨在帮助求职者准备面试。" 详细说明: 1. JavaSE编程基础: - JDK, JRE, JVM的关系: JDK是Java Development Kit，包含了JRE和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值