几篇文章from ONJava.com

最新推荐文章于 2025-10-11 18:41:02 发布
原创 最新推荐文章于 2025-10-11 18:41:02 发布 · 1.1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#eclipse #spring #plugins #jbuilder #java #tools

本文围绕信息技术展开，介绍了Eclipse插件编写，其目标受众为想定制Eclipse的用户，前提是掌握Java和相关工具包；还展示了Spring框架在企业Web应用中的运用，强调其高效性；最后建议组建设计模式学习小组，以更好地理解和掌握设计模式。

Eclipse Plugins Exposed, Part 1: A First Glimpse
by Emmanuel Proulx
02/09/2005

A while ago I was repairing my car. I had to remove a bolt. I opened my wrench kit and tried to find the right socket. None of them worked. The bolt was metric. I used the socket that was the closest to the ideal size. That was a bad idea; I stripped the bolt and I had to buy a special tool to remove it. The moral of the story: always use the right tool for the right job.

Eclipse is an extremely popular Java Integrated Development Environment (IDE) and a strong competitor to NetBeans/SunOne Studio, JBuilder, and IntelliJ IDEA. The Java programmer community is rapidly moving towards Eclipse, as it is free, open source, of excellent quality, and extremely customizable.

This new monthly column is about writing plugins in Eclipse. Who is this column for? Many Eclipse users simply use the IDE out of the box without needing customization. Many will be using plugins made by other people. That is not the target audience of this column. Some Eclipse users will want to customize it. Some will develop tools for their company's employees. Some will want to sell tools that connect to their products. Some will want to resell Eclipse under another name with these tools pre-installed. These people constitute the target audience. The prerequisites for starting to write Eclipse plugins are knowing how to use Eclipse and write Java programs, and having a good understanding of the Standard Widget Toolkit (SWT) and Swing.

In this first installment of the column, let's explore the Eclipse plugin environment.

Demonstrating Spring's Finesse
by Bruce A. Tate and Justin Gehtland

Author's note: In this excerpt from Chapter 8 of our book, Better, Faster, Lighter Java, we look at an example of an enterprise web application using the Spring framework. While Hibernate provided a single service, the Spring framework provides an efficient way to build and assemble Java applications, with abstractions for many services. Although it supports many services, Spring stays focused and clean with excellent layering and encapsulation. Like EJB, the centerpiece for Spring is a container, and like EJB, the Spring framework provides access to core J2EE services. But that's about as far as any similarities go. Here's a metaphor.

I love to kayak and spend a lot of time teaching kayaking skills. One of my specialties is teaching students how to roll an upside-down kayak in white water. One day, I was teaching this skill to a muscle-bound hulk and a dainty little 97lb woman. While I talked through the technique on dry land, Meathead stared into the distance, disinterested. The woman focused well and wanted to practice the foundation techniques over and over. Within a half an hour, she hit her first roll incredibly well, while he was just thrashing about, whipping the calm water into fine white foam. He didn't come close until his third session. In sessions to come, she relied on her technique to improve quickly; he relied on strength, and floundered. When it was time to put the skills into practice, she rolled while he swam. Programmers, take note: it's usually better to solve problems with simplicity and finesse rather than muscle.

Form Your Own Design Pattern Study Group
by Elisabeth Freeman, Eric Freeman, coauthors of Head First Design Patterns
04/06/2005

Sure, you can pick up a book on design patterns, breeze through it, and think you've learned something, but we all know patterns and object-oriented design are deep topics. Like most complex subjects, patterns are best learned over a period of time, not in a few sittings. Truly understanding patterns also requires a lot of thought, insight into the true intent of each pattern, comparing and contrasting a set of patterns, and considering the trade-offs in using the pattern (not to mention understanding the basic OO principles behind each pattern). Sometimes it also helps to have a helping hand to get you over those little humps of understanding that are, for the moment, just beyond your reach.

So we've got a suggestion for tackling patterns that's fun and social, and provides a great environment in which to learn patterns: form your own study group. What's involved? Just getting a group of interested individuals together and dedicating yourself to reading and talking about patterns on a weekly basis. Any group of interested individuals will do, but better yet, get your own engineering team together to study patterns on a weekly basis (and get paid while you do it!). Getting your own team together has another benefit as well, because patterns become even more powerful when your entire team understands the shared vocabulary created among the group members and the real underlying structure of the pattern.

手撕Java系列--java.util.concurrent包详解
横竖撇折点
10-23 1123
java.util.concurrent 包提供了丰富的高级同步工具，这些工具可以帮助开发者更有效地管理并发问题。通过合理选择和使用这些工具，可以显著提高多线程程序的性能和可靠性。后续我会用一系列文章详细介绍每一个工具的设计思路、实现原理和使用场景，帮助你在并发场景下解决更多问题。
解决HiveSQL查询出现Java.lang.OutMemoryError.java heap space
weixin_42771366的博客
01-21 1028
HiveSQL查询，报错Execution Error, return code 2 from org.apache.hadoop.hive.ql.exec.mr.MapRedTask Hive查询内存溢出
onjava
debren的专栏
02-03 781
Tivo SDK这个软件带了两样新东西：1) it consists of 3rd party content2) it turns the tivo+tv combination into something
on java_onjava
weixin_32504329的博客
02-20 679
一、对象的概念1.1组合与聚合：组合和聚合都属于关联关系的一种，只是额外具有整体-部分的意义。至于是聚合还是组合，需要根据实际的业务需求来判断。可能相同超类和子类，在不同的业务场景，关联关系会发生变化。只看代码是无法区分聚合和组合的，具体是哪一种关系，只能从语义级别来区分。聚合关系中，整件不会拥有部件的生命周期，所以整件删除时，部件不会被删除。再者，多个整件可以共享同一个部件。组合关系中，整件拥有...
3行代码解析Java 8方法参数之谜：《On Java 8》反射API实战指南
最新发布
gitblog_00691的博客
10-11 432
你是否还在为Java方法参数的动态获取而头疼？是否在调试时因无法直观查看参数信息而浪费时间？本文将基于《On Java 8》中文版的Reflection API（反射应用程序接口）内容，通过实战案例教你如何3行核心代码实现方法参数的动态解析，读完你将掌握：参数名称提取、类型分析、修饰符识别三大实用技能，让反射技术不再是开发黑箱。 ## 项目基础与环境准备 《On Java 8》中文版作为Jav...
Java语言的极限，就是面向对象的极限——《On Java中文版》
玖哥的书房
04-30 616
百万畅销书“Thinking in”系列作者Bruce Eckel专注于编程语言和软件系统设计方面的研究多年，具有丰富的开发经验、扎实的编程基础、独特的观点以及开放深度研讨的创作方式，他的巨著《Thinking in Java》被翻译成十几种语言，在世界范围内产生了广泛影响，而且在1999年还被评为Java领域“最受读者欢迎图书”，中文版更是成为了国内各大高等院校讲授面向对象程序设计语言及Java语言的绝佳教材，然而遗憾的是，这本巨著在2007年出版了第4版后就连续多年没有更新。
《On Java》介绍
好书，好项目推荐，好点子，干货分享
06-03 3002
Thinking in Java 第二版
《On Java》- 介绍
分享技术干货和灵感、推荐新书和好玩的项目、分享Java面试题
05-28 1118
Hello，大家好，我是阿提说说。 今天要给大家推荐一本书布鲁斯.埃克尔的《On Java》，这本书号称（就是）《Thinking in Java》第二版。 以前在翻译阶段，已经有网上的开放版本，也看过部分，但纸质书是在2022年3月才正式出版。 该书分基础版和进阶版，一套原价¥259.60，JD价¥188，基础版还是挺基础的，适合刚入门的小伙伴，进阶版适合有一定经验的。 购买指数 ★★★★★ 书的外观 JD买东西的体验确实是好，下午书就到了。 拿到书后，整体明显比第一版用心多了，书的装订，印刷、排版、.
java.lang.reflect（Java反射包）
qq_16268979的博客
06-24 2827
Java反射包是我们日常经常接触并且也是Java的基础内容，这篇文章就是为了方便学习记录Java反射包下相关的内容，巩固精进Java基础。 一、简介 java.lang.reflect包提供了用于获取类和对象的反射信息的类和接口。反射API允许对程序访问有关加载类的字段，方法和构造函数的信息进行编程访问。它允许在安全限制内使用反射的字段，方法和构造函数对其底层对等进行操作。 二、Java反射包关系图 三、Java反射包下类和接口简介 我的目的是为了与字节码对象Class一起关联介绍（可以通过Class获取
【Java.lang.ref】ref包简述
厚积薄发者，轻舟万重山
04-19 1514
零、API documentation java.lang.ref API documentation:https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/ref/package-summary.html other documentation:https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/considerations.ht..
Java - java.lang.NullPointException 没有堆栈
xianzhan_的博客
10-02 4775
项目场景： 提示：这里简述项目相关背景： 例如：项目场景：示例:通过蓝牙芯片(HC-05)与手机 APP 通信，每隔 5s 传输一批传感器数据(不是很大) 问题描述： 提示：这里描述项目中遇到的问题： 例如：数据传输过程中数据不时出现丢失的情况，偶尔会丢失一部分数据 APP 中接收数据代码： @Override public void run() { bytes = mmInStream.read(buffer); mHandler.obta
On Java 8
weixin_30294021的博客
09-04 926
On Java 8本书原作者为 [美] Bruce Eckel，即《Java 编程思想》的作者。本书是事实上的 《Java 编程思想》第五版。《Java 编程思想》第四版基于 JAVA 5 版本；《On Java 8》 基于 JAVA 8 版本。随书所有的代码已经在GitHub上开源可查【传送门】在GitHub上，早已有大佬在翻译全书了【传送门】 转载于:https://www.cnb...
【亲测免费】 探索《OnJava8》：一份深度解析Java 8的技术宝典
gitblog_00038的博客
04-21 673
探索《OnJava8》：一份深度解析Java 8的技术宝典 在编程世界中，Java一直以其强大的稳定性和广泛的应用领域保持着重要地位，尤其是Java 8的发布，引入了众多新特性，如Lambda表达式、Stream API和Optional类等，大大提升了开发效率。如果你正在寻找一份深入理解并掌握这些新技术的指南，《OnJava8》项目就是一个不可多得的资源。 项目简介 《OnJava8》是由开发者...
《On Java 8》- 面向对象之代码复用（组合、继承、委托）
wang_luwei的博客
11-08 1095
文章目录小结原文组合语法继承语法委托结合组合与继承组合与继承的选择 小结 根据《On Java 8》： 第八章复用 总结 复用指的是代码复用，一般情况下有两种方式：组合、继承。还有一种是委托（了解就行）。 组合：把一个对象的引用（object references）放置在一个新的类里，这就使用了组合。 继承：派生类 extends 基类，派生类自动获得基类中的所有字段和方法，（还有方法重写） 委托：Java 不直接支持的第三种重用关系称为委托。这介于继承和组合之间，因为你将一个成员对象放在正在构建的类中
OnJava学习笔记_函数式编程
qq_56291183的博客
02-23 280
OnJava学习笔记之函数式编程
《ON JAVA》学习笔记1：把语言当作服务
LM Wang的专栏
07-02 772
如何理解Java中类型、对象、服务等概念
On Java 阅读笔记（持续更新）
justleavel的博客
11-16 1325
《On JAVA》阅读第三章:运算符： 说一下自己不太会的地方吧：一些特殊运算符：(其实心里要有一个概念就是计算机总是喜欢使用二进制去运算就很好理解) 1：与运算符： 或运算符同理:包括异或和取反都是一个道理： 然后说一下移位运算符： 左移运算符： 右移运算符： 无符号右移： 无符号右移(>>>) 无符号右移(>>>)只对32位和64位有意义 在移动位的时候与右移运算符的移动方式一样的，区别只在于补位的时候不管是0还是1，都补0 《On JAVA》阅读第二十一章
OnJava学习_Stream流
qq_56291183的博客
02-23 279
OnJava学习笔记之Stream流
package com.meeting.dao; import java.util.List; import java.util.Map; public class DeptDao extends BaseDao{ /** * 查询全部部门 * @return */ public List<Map<String, Object>> findAll() { String sql = "SELECT " + "d.*, " + "COUNT(u.dept_id) as deptCount " + "FROM dept d " + "LEFT JOIN user u ON d.id = u.dept_id " + "GROUP BY d.id"; return jdbcTemplate.queryForList(sql); } public List<Map<String, Object>> findAll() { String sql = "SELECT " + "a.*, " + "COUNT(ac.article_id ) as deptCount " + "FROM dept a" + "LEFT JOIN article a ON d.id = ac.article_id " + "GROUP BY a.id"; return jdbcTemplate.queryForList(sql); } }如何合并这两段代码
06-19
<think>我们有两个重名的findAll方法，这是不允许的。我们需要合并这两个方法，但注意这两个方法的SQL逻辑不同，分别用于查询部门信息和文章信息（从SQL语句看，第二个方法似乎有错误）。然而，观察两个方法：第一个方法：查询部门表（dept）并统计每个部门的用户数量（通过user表关联）。第二个方法：从SQL看，似乎想查询部门表（但表别名用了a，且连接了article表），但SQL有错误（表别名混乱，且字段不匹配）。实际上，根据类名DeptDao（部门数据访问对象），这个类应该只处理部门相关的数据访问。第二个方法看起来像是复制粘贴错误，它试图连接文章表（article）并统计文章数量，这应该属于文章相关的DAO，而不是部门DAO。因此，我们假设第二个方法是错误的，或者可能是误添加的。但是，如果需求确实需要同时获取部门信息和部门下的文章数量（虽然这不太合理，因为部门通常与用户关联，而不是直接与文章关联），那么我们需要明确需求。然而，根据问题描述，用户要求合并两个方法以避免重复定义。由于两个方法同名，无法在同一个类中同时存在，我们必须决定保留哪个方法，或者根据条件选择执行不同的SQL。但更合理的做法是：只保留第一个方法（查询部门及部门用户数），而将第二个方法移除或重命名（如果它确实是需要的，但应放在合适的DAO类中）。不过，如果用户确实需要在同一个方法中根据不同的条件执行不同的查询（比如根据参数决定统计用户数还是文章数），那么我们可以通过参数化来实现。方案：1.移除第二个findAll方法（如果它是错误的或不属于这里）。2.如果确实需要两个查询，那么我们可以：-重命名这两个方法，分别表示不同的查询，例如：findAllWithUserCount()//第一个方法findAllWithArticleCount()//第二个方法（但需要修正SQL）-或者，通过参数在一个方法中实现，例如：publicList<Map<String,Object>>findAll(booleancountUser,booleancountArticle){...}但是，同时统计用户和文章数量也是可以的（如果业务需要），我们可以写一个SQL同时统计每个部门的用户数和文章数（如果部门与文章有关联的话，但通常文章可能关联的是用户，而不是直接关联部门，所以需要通过用户关联部门）。不过，由于原始第二个方法的SQL有明显错误，我们需要先修正它。第二个方法的原始SQL：```sqlSELECTa.*,COUNT(ac.article_id)asdeptCountFROMdeptaLEFTJOINarticleaONd.id=ac.article_id--这里表别名混乱，且ac未定义GROUPBYa.id```修正后的SQL（假设我们想统计每个部门的文章数，并且文章通过用户关联到部门，即文章属于某个用户，而用户属于某个部门）：```sqlSELECTd.*,COUNT(ac.id)asarticleCount--假设ac是文章表的别名FROMdeptdLEFTJOINuseruONd.id=u.dept_idLEFTJOINarticleacONu.id=ac.user_id--假设文章表有user_id字段GROUPBYd.id```但注意：第一个方法是统计部门下的用户数，第二个方法（修正后）是统计部门下的文章数。这两个统计可以合并到一个SQL中：```sqlSELECTd.*,COUNT(DISTINCTu.id)asuserCount,COUNT(ac.id)asarticleCountFROMdeptdLEFTJOINuseruONd.id=u.dept_idLEFTJOINarticleacONu.id=ac.user_idGROUPBYd.id```这样，我们就可以在一个查询中同时获取部门下的用户数和文章数。因此，我们可以将两个方法合并为一个方法，使用上面的SQL。步骤：1.删除其中一个重复的findAll方法。2.修改保留的findAll方法，使用新的SQL语句，同时统计用户数和文章数。但是，注意：如果需求并不需要文章数，那么这样修改会增加不必要的连接和计算。所以我们需要根据实际需求来决定。如果需求是：-第一个方法：统计部门用户数-第二个方法：统计部门文章数（但被错误地放在这里）那么，正确的做法可能是：-将第二个方法移到ArticleDao或类似的类中，并重命名（例如：countArticlesByDept）-在DeptDao中只保留第一个方法。但是，用户要求合并两个方法以避免重复定义（同名）。因此，我们只能选择一种方式：要么合并成一个查询（如果业务需要同时两个数据），要么通过参数选择执行不同的查询。鉴于问题描述不明确，我们提供两种方案：方案A（合并成一个查询，同时返回用户数和文章数）：-修改findAll方法，使用上述合并的SQL。方案B（通过参数选择）：-在方法中添加参数，例如：StringcountType，然后根据参数执行不同的SQL。由于方案A可以一次性获取两个数据，可能更高效（减少数据库访问次数），所以如果业务需要同时展示这两个数据，则方案A更好。但如果这两个数据是在不同场景下使用，则方案A会造成资源浪费。考虑到类名为DeptDao，其职责应只提供部门相关的数据，而部门下的用户数和文章数都是部门相关的统计，所以同时提供也是合理的。因此，我们采用方案A，修改SQL，同时查询用户数和文章数。修改后的代码：```javapublicclassDeptDaoextendsBaseDao{/***查询全部部门，并统计每个部门的用户数和文章数*@return*/publicList<Map<String,Object>>findAll(){Stringsql="SELECT"+"d.*,"+"COUNT(DISTINCTu.id)asuserCount,"+//使用DISTINCT避免重复计数（因为一个用户可能有多篇文章）"COUNT(ac.id)asarticleCount"+"FROMdeptd"+"LEFTJOINuseruONd.id=u.dept_id"+"LEFTJOINarticleacONu.id=ac.user_id"+//假设文章表有user_id字段"GROUPBYd.id";returnjdbcTemplate.queryForList(sql);}}```注意：1.我们假设文章表（article）有一个user_id字段，表示文章的作者（用户）。2.在统计用户数时，使用COUNT(DISTINCTu.id)是因为一个部门可能有多个用户，每个用户可能有多篇文章，这样在连接文章表后，每个用户会重复出现（每个文章一行），所以需要去重统计用户数。3.文章数直接使用COUNT(ac.id)即可，因为每篇文章一行。如果数据库结构不符合这个假设，需要调整SQL。另外，如果文章不是通过用户关联到部门，而是直接关联部门（比如文章表有dept_id），那么SQL可以简化：```sqlSELECTd.*,COUNT(DISTINCTu.id)asuserCount,COUNT(ac.id)asarticleCountFROMdeptdLEFTJOINuseruONd.id=u.dept_idLEFTJOINarticleacONd.id=ac.dept_id--直接关联部门GROUPBYd.id```但通常文章属于用户，用户属于部门，所以第一种方式更常见。最后，如果需求确实不需要文章数，那么我们应该移除第二个方法（因为它是错误的）并保留第一个方法。但用户要求合并，所以我们按同时需要两个统计来处理。因此，最终代码如方案A所示。如果业务不需要文章数，那么请忽略方案A，并删除第二个方法，保留第一个方法。但根据问题，我们选择合并。由于问题描述中第二个方法存在明显的表别名错误（如dept表别名a，又连接article表别名a，导致冲突），所以第二个方法原本就是错误的，我们修正后与第一个方法合并。总结：我们重写了findAll方法，使其同时返回部门用户数和部门文章数。</think>### 合并两个`findAll`方法的解决方案 在Java中，同一个类中不能存在两个同名方法（方法重载要求参数列表不同）。您提供的代码中有两个完全相同的`findAll()`方法签名，这会导致编译错误。以下是合并方案： #### 方案1：创建统一查询方法（推荐） ```java public List<Map<String, Object>> findAll(boolean includeArticleStats) { String sql = includeArticleStats ? "SELECT a.*, COUNT(ac.article_id) AS deptCount " + "FROM dept a " + "LEFT JOIN article ac ON a.id = ac.dept_id " + // 修正表别名 "GROUP BY a.id" : "SELECT d.*, COUNT(u.dept_id) AS deptCount " + "FROM dept d " + "LEFT JOIN user u ON d.id = u.dept_id " + "GROUP BY d.id"; return jdbcTemplate.queryForList(sql); } ``` **使用示例：** ```java // 获取部门用户统计 List<Map<String, Object>> deptUserStats = deptDao.findAll(false); // 获取部门文章统计 List<Map<String, Object>> deptArticleStats = deptDao.findAll(true); ``` #### 方案2：拆分为两个专用方法 ```java public List<Map<String, Object>> findDeptWithUserStats() { String sql = "SELECT d.*, COUNT(u.dept_id) AS deptCount " + "FROM dept d " + "LEFT JOIN user u ON d.id = u.dept_id " + "GROUP BY d.id"; return jdbcTemplate.queryForList(sql); } public List<Map<String, Object>> findDeptWithArticleStats() { String sql = "SELECT a.*, COUNT(ac.article_id) AS deptCount " + // 修正字段别名 "FROM dept a " + "LEFT JOIN article ac ON a.id = ac.dept_id " + // 修正表别名 "GROUP BY a.id"; return jdbcTemplate.queryForList(sql); } ``` ### 关键修正点 1. **表别名冲突修正**： ```sql -- 原始错误代码 LEFT JOIN article a ON d.id = ac.article_id -- 修正后 LEFT JOIN article ac ON a.id = ac.dept_id ``` - 避免重复使用别名`a` - 明确关联字段（假设`article`表有`dept_id`字段） 2. **字段别名统一**： ```sql -- 原始不一致 COUNT(u.dept_id) as deptCount -- 方法1 COUNT(ac.article_id ) as deptCount -- 方法2 -- 建议统一为统计项名称 COUNT(u.id) AS userCount -- 用户数统计 COUNT(ac.id) AS articleCount -- 文章数统计 ``` ### SQL优化建议 ```sql /* 部门用户统计优化版 */ SELECT d.id, d.name, COUNT(u.id) AS user_count, SUM(CASE WHEN u.status = 'active' THEN 1 ELSE 0 END) AS active_users FROM dept d LEFT JOIN user u ON d.id = u.dept_id GROUP BY d.id, d.name /* ANSI SQL兼容 */ /* 部门文章统计优化版 */ SELECT a.id, a.name, COUNT(ac.id) AS article_count, MAX(ac.create_time) AS latest_article_time FROM dept a LEFT JOIN article ac ON a.id = ac.dept_id GROUP BY a.id, a.name ``` ### 并发处理建议 使用`Lock`确保线程安全[^1]： ```java private final Lock lock = new ReentrantLock(); public List<Map<String, Object>> findDeptWithStats(boolean isArticle) { lock.lock(); try { String sql = buildSql(isArticle); return jdbcTemplate.queryForList(sql); } finally { lock.unlock(); } } ``` ### 相关问题 1. 如何在Spring JDBC中高效处理多表关联查询？ [引用参考：JdbcTemplate多表查询最佳实践](https://spring.io/guides/gs/relational-data-access/) 2. SQL查询结果映射到实体对象的最佳方式是什么？ [引用参考：Spring BeanPropertyRowMapper文档](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/jdbc/core/BeanPropertyRowMapper.html) 3. 如何优化GROUP BY查询的性能？ [引用参考：MySQL GROUP BY优化指南](https://dev.mysql.com/doc/refman/8.0/en/group-by-optimization.html) 4. 在DAO层处理并发访问有哪些最佳实践？ [引用参考：Java并发编程实战](https://docs.oracle.com/javase/tutorial/essential/concurrency/)
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值