JAVA 数据导入导出（CSV、TXT、EXCL（读取大文件））

已于 2023-08-21 13:27:15 修改
阅读量9.7k 收藏 26
点赞数 3
文章标签： java web
于 2017-11-10 14:10:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32662595/article/details/78499257
版权

文件数据导入功能：

设计思路：

  1. 先实现文件上传到服务器，获取到文件名和文件保存的路径
  2. 获取当前项目运行的路径，读取服务器中的文件
  3. 解析文件数据
  4. 数据处理，导入数据库

文件部分上传代码：

	if (!file.isEmpty()) {
			FileTb upLoadFile = null;
			String originalName = file.getOriginalFilename();
			int dotPosition = originalName.indexOf(".");
			String fileType = null;
			String filename;
			if (dotPosition != -1) {
				fileType = originalName.substring(
						originalName.indexOf(".") + 1, originalName.length());
				filename = originalName;
			} else {
				filename = DateUtils.currentDate();
			}
			File savedFile = new File(path, filename);
			try {
				FileUtils.copyInputStreamToFile(file.getInputStream(),
						savedFile);
			} catch (IOException e) {
				e.printStackTrace();
  1. excel文件上传（包括一些特定的处理方式POI常用模式：适合小数据量）：
	 Workbook wookbook = getSheets(path);
		//获取sheet的总数
		for (int i = 0; i < wookbook.getNumberOfSheets(); i++) {
			Date startTime = new Date();
			//得到一个工作表
			Sheet sheet = wookbook.getSheetAt(i);
			
			//1.创建一个存储导入数据的列表：importList:List<LinkedList>
			
			List<LinkedList> importList = new ArrayList<>();
			
			
			//2.将excel中为表头保存为key-value的集合：excelFieldMap
			Map<Object, Integer> excelFieldMap = new HashMap<>();
			Row headRow = sheet.getRow(0);
			//3.表属性列表
			LinkedList<String> propsTabList = new LinkedList<>();
			propsTabList.add(MYJZConfig.TABLENAMEPROMARYKEY);
			if (headRow != null) {
				for (int j = 0; j < headRow.getPhysicalNumberOfCells(); j++) {
					
					//4.获取该表下所有的属性字段名且移除id：propsList :List<String>
					List<String> propsList = commenUtilMapper.findAllPropsName('"' + tableName + '"');
					propsList.remove(MYJZConfig.TABLENAMEPROMARYKEY);
					
					//5.根据表属性字段名去查询表属性字段名和excel字段名对应表，获取1. excel中的字段名 ：excelfield
					
					for (String prop : propsList) {
						if (headRow.getCell(j).getStringCellValue().equalsIgnoreCase(excelTableFieldMapper.findExcelFieldByTabNameAndTabFiledName(tableName, prop))) {
							
							//6.将excelFieldMap中的value值用prop替换
							excelFieldMap.put(prop, j);
							
							propsTabList.add(prop);
						}
					}
				}
				//TODO 操作数据-----------------------------------
				//6.获得数据的总行数
				int totalRowNum = sheet.getLastRowNum();
				int successCount = 0;
				//7.获得所有数据:通过下标index获取
				
				for (int rowNum = 1; rowNum < totalRowNum; rowNum++) {
					
					Row row = sheet.getRow(rowNum);
			
				}

	/**
	 * 获取sheet表
	 *
	 * @param filePath ：完整file的URL
	 * @return
	 */

	private Workbook getSheets(String filePath) {
		
		FileInputStream fis = null;
		Workbook wookbook = null;
		try {
			//获取一个绝对地址的流
			fis = new FileInputStream(filePath);
		} catch (Exception e) {
			e.printStackTrace();
		}
		if (filePath.endsWith(".xls")) {
			/*2003版本的excel，用.xls结尾：得到工作簿*/
			try {
				wookbook = new HSSFWorkbook(fis);//
			} catch (IOException e) {
				e.printStackTrace();
			}
		} else if (filePath.endsWith(".xlsx")) {
			try {
				/*2007版本的excel，用.xlsx结尾 ：工作薄*/
				wookbook = new XSSFWorkbook(fis);
			} catch (IOException e) {
				//  Auto-generated catch block
				e.printStackTrace();
			}
		} else {
			throw new CustomException("文件不是excel类型");
		}
		
		return wookbook;
	}
  1. csv 文件导入：
/* 读取文件内容*/
		try {
			
			// 创建CSV读对象 例如:CsvReader(文件路径，分隔符，编码格式);
			CsvReader reader = new CsvReader(savePath, ',', Charset.forName("UTF-8"));
			
			// 跳过表头 如果需要表头的话，这句可以忽略
			reader.readHeaders();
			
			/**
			 * 获取关系表中的字段名
			 */
			List<String> tableFieldsList = commenUtilMapper.findAllPropsName('"' + tableName + '"');
			
			// 逐行读入除表头的数据
			while (reader.readRecord()) {
				
				String excelfieldValue = reader.get(excelfield);

			}
	
			reader.close();
  1. txt数据文件导入：
 RandomAccessFile raf = new RandomAccessFile(path, “rw”);
		  while ((line_record = raf.readLine()) != null) {
		line_record = new String(line_record.getBytes("ISO-8859-1"), "utf8");

excel 2007：快速读取数据(POI 用户模式：适合大数据量）

public class ExcelAnalyseUtils {
	public static void main(String[] args) {
		Date da = new Date();
		List<Map<String, String>> datas = getFileData(
				"D:\\apache-tomcat-8.5.20\\webapps\\files\\upload\\201805161306480986.xlsx", "四川1");
		System.out.println(new Date().getTime() - da.getTime());
	}

	public static List<Map<String, String>> getFileData(String filePath, String sheeName) {
		List<Map<String, String>> results = new ArrayList<>();
		ExcelParser parser;
		OPCPackage pkg = null;
		try {
			pkg = OPCPackage.open(filePath, PackageAccess.READ);
			parser = new ExcelParser(pkg, null, -1, results);
			parser.process(sheeName);
		} catch (OpenXML4JException | SAXException | IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (null != pkg) {
				try {
					pkg.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}

		return results;
	}
}

class ExcelParser {
	/**
	 * Uses the XSSF Event SAX helpers to do most of the work of parsing the
	 * Sheet XML, and outputs the contents as a (basic) CSV.
	 */
	private class SheetToCSV implements SheetContentsHandler {
		private boolean firstCellOfRow;
		private int currentRow = -1;
		private int currentCol = -1;
		private Map<String, String> record = new HashMap();
		private int index = 0;
		private List<String> title = new ArrayList<>();

		private void outputMissingRows(int number) {
			for (int i = 0; i < number; i++) {
				for (int j = 0; j < minColumns; j++) {
					output.append(',');
				}
				output.append('\n');
			}
		}

		@Override
		public void startRow(int rowNum) {
			firstCellOfRow = true;
			currentRow = rowNum;
			currentCol = -1;
			index = 0;
		}

		@Override
		public void endRow(int rowNum) {
			if (rowNum > 0) {
				Map<String, String> result = new HashMap();
				result.putAll(record);
				record.clear();
				results.add(result);
			}

		}

		@Override
		public void cell(String cellReference, String formattedValue, XSSFComment comment) {
			if (currentRow == 0) {
				title.add(formattedValue);
			} else {
				record.put(title.get(index), formattedValue);
			}

			index++;
		}

		@Override
		public void headerFooter(String text, boolean isHeader, String tagName) {
			
		}
	}

	

	private final OPCPackage xlsxPackage;

	/**
	 * Number of columns to read starting with leftmost
	 */
	private final int minColumns;

	/**
	 * Destination for data
	 */
	private final PrintStream output;

	private final List<Map<String, String>> results;

	/**
	 * Creates a new XLSX -> CSV examples
	 *
	 * @param pkg
	 *            The XLSX package to process
	 * @param output
	 *            The PrintStream to output the CSV to
	 * @param minColumns
	 *            The minimum number of columns to output, or -1 for no minimum
	 */
	public ExcelParser(OPCPackage pkg, PrintStream output, int minColumns, List<Map<String, String>> results) {
		this.xlsxPackage = pkg;
		this.output = output;
		this.minColumns = minColumns;
		this.results = results;
	}

	/**
	 * Parses and shows the content of one sheet using the specified styles and
	 * shared-strings tables.
	 *
	 * @param styles
	 *            The table of styles that may be referenced by cells in the
	 *            sheet
	 * @param strings
	 *            The table of strings that may be referenced by cells in the
	 *            sheet
	 * @param sheetInputStream
	 *            The stream to read the sheet-data from.
	 * 
	 * @exception java.io.IOException
	 *                An IO exception from the parser, possibly from a byte
	 *                stream or character stream supplied by the application.
	 * @throws SAXException
	 *             if parsing the XML data fails.
	 */
	public void processSheet(StylesTable styles, ReadOnlySharedStringsTable strings, SheetContentsHandler sheetHandler,
			InputStream sheetInputStream) throws IOException, SAXException {
		DataFormatter formatter = new DataFormatter();
		InputSource sheetSource = new InputSource(sheetInputStream);
		try {
			XMLReader sheetParser = SAXHelper.newXMLReader();
			ContentHandler handler = new XSSFSheetXMLHandler(styles, null, strings, sheetHandler, formatter, false);
			sheetParser.setContentHandler(handler);
			sheetParser.parse(sheetSource);
		} catch (ParserConfigurationException e) {
			throw new RuntimeException("SAX parser appears to be broken - " + e.getMessage());
		}
	}

	/**
	 * Initiates the processing of the XLS workbook file to CSV.
	 *
	 * @throws IOException
	 *             If reading the data from the package fails.
	 * @throws SAXException
	 *             if parsing the XML data fails.
	 */
	public void process(String sheet) throws IOException, OpenXML4JException, SAXException {
		ReadOnlySharedStringsTable strings = new ReadOnlySharedStringsTable(this.xlsxPackage);
		XSSFReader xssfReader = new XSSFReader(this.xlsxPackage);
		StylesTable styles = xssfReader.getStylesTable();
		XSSFReader.SheetIterator iter = (XSSFReader.SheetIterator) xssfReader.getSheetsData();
		while (iter.hasNext()) {
			try (InputStream stream = iter.next()) {
				String sheetName = iter.getSheetName();
				if (!sheetName.equals(sheet)) {
					continue;
				}
				processSheet(styles, strings, new SheetToCSV(), stream);
			}
		}
	}

}

用StreamingReader读取

  public static Map<String, List<List<String>>> readExcelByStreamingReader(String filePath, int num) {
        Workbook wk = null;
        Map<String, List<List<String>>> metaInfo = null;
        try {
            wk = StreamingReader.builder().rowCacheSize(100) // 缓存到内存中的行数，默认是10
                    .bufferSize(4096) // 读取资源时，缓存到内存的字节大小，默认是1024
                    .open(new FileInputStream(filePath)); // 打开资源，必须，可以是InputStream或者是File，注意：只能打开XLSX格式的文件

//            wk = StreamingReader.builder()
//                    .sstCacheSize(100)
//                    .open(new FileInputStream(filePath)); // 打开资源，必须，可以是InputStream或者是File，注意：只能打开XLSX格式的文件

            metaInfo = new LinkedHashMap<>();
            for (int i = 0; i < wk.getNumberOfSheets(); i++) {
                Sheet sheet = wk.getSheetAt(i);
                List<List<String>> sample = new LinkedList<>();
                for (Row row : sheet) {
                    // 遍历所有的列
                    List<String> rowData = new LinkedList<>();
                    for (Cell cell : row) {
                        rowData.add(cell.getStringCellValue() + "");
                    }
                    if (num>=0 && sample.size() < num) {
                        sample.add(rowData);
                        break;
                    }
                }
                metaInfo.put(sheet.getSheetName(), sample);
            }
        } catch (FileNotFoundException e) {
            throw new AsuraRuntimeException(e);
        } finally {
            try {
                if (null != wk) {
                    wk.close();
                }
            } catch (IOException e) {
                wk = null;
            }
        }
        return metaInfo;


import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang3.StringUtils;

/**
 * @author liaowei
 * @create 2018-05-03 16:46
 * @desc 将数据load进mysql
 * sql.csv：可不用
 **/

public class LoadDataToMysqlUtils {

	/**
	 * 获取字段列表及字段流
	 *
	 * @param datas
	 * @return String testSql = "LOAD DATA LOCAL INFILE '12.csv' IGNORE INTO TABLE
	 *         test.test (a,b,c,d,e,f)";
	 */
	public static LoadDataToMysqlFieldsVo getDataInputStream(HttpServletRequest request,
			List<Map<String, String>> datas, Map<String, String> MysqlToExcelProp, String userName, String caseId) {
		LoadDataToMysqlFieldsVo loadDataToMysqlFieldsVo = new LoadDataToMysqlFieldsVo();
		String sql = "LOAD DATA LOCAL INFILE 'sql.csv' IGNORE INTO TABLE  " + 表名 + " (";
		StringBuilder builder = new StringBuilder();
		String midSql = "";
		request.getSession().setAttribute("TotalNumberOfData", datas.size());
		for (int i = 0; i < datas.size(); i++) {
			for (Map.Entry<String, String> mapData : MysqlToExcelProp.entrySet()) {
				if (i == 0) {
					if (StringUtils.isEmpty(midSql)) {
						midSql = mapData.getValue();
					} else {
						midSql += "," + mapData.getValue();
					}
				}
				if ("member_register_date".equalsIgnoreCase(mapData.getValue())) {
					if (StringUtils.isNotEmpty(datas.get(i).get(mapData.getKey()))) {
						List<String> convetTime = DateUtils.ArrayDateForm(datas.get(i).get(mapData.getKey()));
						String date = convetTime.get(0) + "-" + convetTime.get(1) + "-" + convetTime.get(2) + " "
								+ convetTime.get(3) + ":" + convetTime.get(4) + ":" + convetTime.get(5);
						builder.append(date);
					} else {
						builder.append("");
					}
				} else {
					if (StringUtils.isNotEmpty(datas.get(i).get(mapData.getKey()))) {
						builder.append(datas.get(i).get(mapData.getKey()));
					} else {
						builder.append("");
					}
				}
				builder.append("\t");
			}

			builder.append(caseId);
			builder.append("\t");
			builder.append(AsuraTimeUtils.currentDate_Time());
			builder.append("\t");
			builder.append(userName);
			builder.append("\t");
			builder.append(AsuraTimeUtils.currentDate_Time());
			builder.append("\t");
			builder.append(userName);
			builder.append("\t");
			builder.append("\n");
			request.getSession().setAttribute("LoadedData", (long) (i + 1));
		}
		sql += midSql + ",case_id,create_date,create_account,last_modify_time,last_modify_account)";
		byte[] bytes = builder.toString().getBytes();
		InputStream is = new ByteArrayInputStream(bytes);
		loadDataToMysqlFieldsVo.setSql(sql);
		loadDataToMysqlFieldsVo.setDataStream(is);
		return loadDataToMysqlFieldsVo;
	}

	/**
	 * 保存到数据库中
	 *
	 * @param loadDataToMysqlFieldsVo
	 */
	public static void loadDataIntoMysql(LoadDataToMysqlFieldsVo loadDataToMysqlFieldsVo) {
		Connection conn = null;
		try {

			System.out.println(loadDataToMysqlFieldsVo.getSql());

			conn = JdbcConnUtils.getConn();
			PreparedStatement statement = conn.prepareStatement(loadDataToMysqlFieldsVo.getSql());
			if (statement.isWrapperFor(com.mysql.jdbc.Statement.class)) {
				com.mysql.jdbc.PreparedStatement mysqlStatement = statement
						.unwrap(com.mysql.jdbc.PreparedStatement.class);
				mysqlStatement.setLocalInfileInputStream(loadDataToMysqlFieldsVo.getDataStream());
				mysqlStatement.executeUpdate();
			}
		} catch (Exception e) {
			throw new RuntimeException("操作数据库错误!" + e);
		} finally {
			try {
				if (null != conn) {
					conn.close();
				} else {

				}

			} catch (SQLException e) {
				conn = null;
			}
		}
	}

}
数据库连接方式(可用多数据源替换)

/**
 * @create 2017-11-06 10:36
 * @desc 原始连接数据库方式
 */
public class JdbcConnUtils {

	private static Connection conn = null;

	private static Properties props = null;

	static {
		loadProps();
	}

	synchronized static private void loadProps() {
		props = new Properties();
		InputStream in = null;
		try {
			// 第一种 通过类加载器进行获取properties文件流
			in = ResourceUtils.class.getClassLoader().getResourceAsStream("project_config.properties");
	
			props.load(in);
		} catch (FileNotFoundException e) {
			throw new RuntimeException("未找到需要读取的文件！");
		} catch (IOException e) {
			throw new RuntimeException("IO异常！");
		} finally {
			try {
				if (null != in) {
					in.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("数据流关闭失败！");
			}
		}
	}

	public static String getProperty(String key) {
		if (null == props || props.size() <= 0) {
			loadProps();
		}
		return props.getProperty(key);
	}

	public static Connection getConn() {
		try {
			Class.forName(getProperty("asura.db.driver"));
			conn = DriverManager.getConnection(props.getProperty("asura.db.url"),
					props.getProperty("asura.db.username"), props.getProperty("asura.db.pwd"));
		} catch (ClassNotFoundException cnfe) {
			throw new RuntimeException("加载驱动失败");
		} catch (SQLException e) {
			throw new RuntimeException("获取连接失败");
		}

		return conn;
	}

	public void closeConn() {
		try {
			if (conn != null)
				conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}

	}

	public static void main(String[] args) {
		System.out.println(JdbcConnUtils.getProperty("asura.db.pwd"));
	}
}
一介布衣+
关注
java导入大数量文件csv，txt，利用sqlloader导入
xy_liwei的专栏
04-24 5347
导入sqlloader数据例子（when条件的，只能使用and连接，插入的顺序要跟文件中的列的顺序相同）： 1， options(skip=1) load data characterset UTF8 infile 'd:\xxkCommon\20120310_hb_cust_basic_data_month.csv' replace INTO TABLE T_CUSTOMER_
java实现CSV文件导入与导出功能
08-25
Java 实现 CSV 文件导入与导出功能 Java 中实现 CSV 文件导入与导出的知识点主要包括以下几个方面： 一、CSV 文件简介 ...CSV 文件导入导出功能可以用于各种业务场景，如数据导入、数据导出、数据报表等。
JAVA导入CSV文件
09-14
JAVA读取CSV文件，可以将数据写入数据库。
Java导出txt文件的方法
09-03
主要介绍了Java导出txt文件的方法,实例分析了两种java导出txt文本文件的使用技巧,需要的朋友可以参考下
java 实现txt文件导出
最新发布
weixin_42523104的博客
07-27 123
Java 实现txt文件导出 作为一名刚入行的开发者，你可能会对如何使用Java实现txt文件导出感到困惑。不用担心，下面我将为你详细讲解整个流程，并提供相应的代码示例。 流程概览 首先，让我们通过一个表格来了解整个流程： 步骤 描述 1 导入必要的类库 2 创建一个FileWriter对象 3 创建...
java 导入、导出 csv
jinjuana521的博客
07-21 5289
1.在pom.xml文件中加。2.在application.yml文件中加。3.建立工具类CSVUtils。4.接口Contorller。5.逻辑层Service。
java导入csv文件
虽千万人,吾往矣
11-18 2116
本文是在springboot项目中新建一个子模块点击这里->创建子模块步骤，专门用于执行定时任务读取本地window的csv文件，下面是实际操作步骤；
Java导入导出csv格式文件完整版详解
weixin_45231589的博客
04-26 4484
CSV（Comma-Separated Values，逗号分隔的值）是一种简单、实用的文件格式，用于存储和表示包括文本、数值等各种类型的数据。CSV 文件通常以。
JAVA操作csv文件（导入导出）
热门推荐
红尘浪子的专栏
11-10 1万+
CSV是逗号分隔文件(Comma Separated Values)的首字母英文缩写，是一种用来存储数据的纯文本格式，通常用于电子表格或数据库软件。在 CSV文件中，数据“栏”以逗号分隔，可允许程序通过读取文件为数据重新创建正确的栏结构，并在每次遇到逗号时开始新的一栏。   1、csv文件用文本打开显示为：   1,张三,男 2,李四,男 3,小红,女 2、csv文件用Excel打开...
Java导入csv文件读取数据存入数据库
withme977的博客
01-08 1767
CSVUtils工具类：(设置对应的csv编码格式，例如GBK)以上就是全部的csv数据读取导入至数据库，如有补充请留言~ServiceImpl实现类层。
java使用javacsv读取csv文件 导入Mysql数据库
06-08
NULL 博文链接：https://qq-24665727.iteye.com/blog/2339850
javaCSV导入导出
01-22
javaCSV导入导出 ... File file = new File("C:/name.csv"); FileOutputStream out = new FileOutputStream(file); OutputStreamWriter osw = new OutputStreamWriter(out); BufferedWriter bw = new BufferedWriter(osw); ...
JAVA操作csv文件（导入导出）-附件资源
03-05
JAVA操作csv文件（导入导出）-附件资源
javacsv导入导出代码
09-05
csv 总结导入导出 已经自测过，没有问题
JAVA读取CSV到数据库表中
10-15
本人以JAVA来实现以支付宝的账单表为例,实现JAVA读取CSV..csv是一种文件格式（如.txt、.doc等），也可理解.csv文件就是一种特殊格式的纯文本文件。即是一组字符序列，字符之间已英文字符的逗号或制表符（Tab）分隔。
java生成csv文件乱码的解决方法示例 java导出csv乱码
09-04
CSV文件是一种常见的数据交换格式，通常用于导入和导出数据到电子表格程序如Microsoft Excel。当在Java程序中创建或读取CSV文件时，确保正确的字符编码是至关重要的，尤其是对于包含非ASCII字符（如中文字符）的数据...
Java实现excel大数据量导入
09-07
Java实现Excel大数据量导入是一项常见的任务，特别是在处理企业级数据导入导出时。Apache POI 是Java中广泛使用的库，用于处理Microsoft Office格式的文件，包括Excel。然而，当涉及大量数据时，直接使用POI的用户...
java导出生成csv文件的方法
08-31
以下是一个简单的Java类`CsvUtil`，用于导出CSV格式的文件： ```java public class CsvUtil { /** * 导出生成csv格式的文件 * @param titles csv格式头文字 * @param propertys 需要导出的数据实体的属性，注意...
java mysql数据导入导出
06-14
Java和MySQL数据库之间的数据导入导出通常涉及使用Java的JDBC（Java Database Connectivity）API以及一些用于操作数据库的工具或第三方库，如`java.sql`, `PreparedStatement`等。以下是Java中常见的MySQL数据导入导出的方法： 1. **导入数据** (使用`LOAD DATA INFILE`命令): 使用`java.sql.Statement`或`PreparedStatement`执行SQL `LOAD DATA INFILE`命令，将CSV、Excel或文本文件中的数据直接加载到MySQL表中。例如： ```java try (Connection conn = DriverManager.getConnection(url, username, password); Statement stmt = conn.createStatement()) { String sql = "LOAD DATA LOCAL INFILE 'file.csv' INTO TABLE my_table FIELDS TERMINATED BY ','"; stmt.executeUpdate(sql); } catch (SQLException e) { // handle exceptions } ``` 2. **导出数据** (使用SQL查询或存储过程): - SQL查询: 通过SQL `SELECT ... INTO OUTFILE`命令导出数据到CSV、TEXT等文件格式。 - Java代码生成：使用`ResultSet`对象逐行读取数据，然后用`FileWriter`或`BufferedWriter`写入文件。 3. **使用Java库**: - 使用JDBC连接执行复杂的查询并将结果集转换为文件。例如，`JDBCDriverManager`和`JDBCStatement`。 - 使用第三方库如`mysql-connector-java`的`Statement.setQueryTimeout()`配合流式处理，提高性能。 4. **使用工具类**: - Java提供了一些ORM框架，如MyBatis、Hibernate等，它们通常有内置的导出和导入功能，支持多种格式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一介布衣+

做好事，当好人

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

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

打赏作者

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

抵扣说明：

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

余额充值