SpringBoot整合Spring Data JPA实现增删改查

最新推荐文章于 2024-04-18 11:28:41 发布
最新推荐文章于 2024-04-18 11:28:41 发布
阅读量2.1k 收藏 11
点赞数 3
分类专栏： SpringBoot SpringBoot Data JPA SpringBoot整合SpringBoot Data JP 文章标签： SpringBoot实现增删改查 SpringBoot整合Spring Data JPA SpringBoot Data JPA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41728540/article/details/103007405
版权

根据springboot模板创建项目

访问Spring Initializr：https://start.spring.io/，填好后点击Generate - Ctrl ，下载后解压到工作目录，IDEA打开项目

打开之后配置Maven：File---Settings，搜索maven，选择所在maven目录

选择Jdk：打开Project Structure，选择jdk，我的是1.8

pom.xml文件导入Swagger和JPA的依赖，选择web

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.2.1.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example.springdatajpa</groupId>
	<artifactId>springdatajpa</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springdatajpa</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

        <!-- swagger -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- jpa -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

swagger 配置：springdatajpa下新建config文件夹，在里面创建个SwaggerConfig类

package com.example.springdatajpa.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any()).build();
    }

    private ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("SpringBoot API Doc")
                .description("This is a restful api document of Spring Data Jpa.")
                .version("1.0")
                .build();
    }

}

在config里再新建个PageQuery类用于封装分页请求

package com.example.springdatajpa.config;
/**
 * 分页请求
 */
public class PageQuery {
    /**
     * 当前页码
     */
    private int pageNum;
    /**
     * 每页数量
     */
    private int pageSize;

    public int getPageNum() {
        return pageNum;
    }
    public void setPageNum(int pageNum) {
        this.pageNum = pageNum;
    }
    public int getPageSize() {
        return pageSize;
    }
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }
}

配置数据源：把application.properties文件改名为application.yml

server:
  port: 8080
spring:
  datasource:
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springdatajpa?useUnicode=true&characterEncoding=utf-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
    username: root
    password: root
  jpa:
    show-sql: true # 默认false，在日志里显示执行的sql语句
    database: mysql
    hibernate.ddl-auto: update #指定为update，每次启动项目检测表结构有变化的时候会新增字段，表不存在时会新建，如果指定create，则每次启动项目都会清空数据并删除表，再新建
    properties.hibernate.dialect: org.hibernate.diale ct.MySQL5Dialect
    database-platform: org.hibernate.dialect.MySQL5Dialect
    hibernate:
      naming:
        implicit-strategy: org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl #指定jpa的自动表生成策略，驼峰自动映射为下划线格式
        #physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

创建目录结构：springdatajpa目录下新建model，controller，service，serviceImpl，dao目录结构，分别在底下新建对应的类和接口

model下SysUser

package com.example.springdatajpa.model;

import javax.persistence.*;

@Entity
@Table(name = "sys_user", indexes = {@Index(name = "id", columnList = "id", unique = true), @Index(name = "name ", columnList = "name", unique = true)})
public class SysUser {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // @Column： 对应数据库列名,可选, nullable 是否可以为空, 默认true
    @Column(name = "name", nullable = false)
    private String name;

    private String password;

    private String email;

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

controller下SysUserController

package com.example.springdatajpa.controller;

import com.example.springdatajpa.config.PageQuery;
import com.example.springdatajpa.model.SysUser;
import com.example.springdatajpa.service.SysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("user")
public class SysUserController {

    @Autowired
    private SysUserService sysUserService;

    @PostMapping(value = "/save")
    public Object save(@RequestBody SysUser sysUser) {
        sysUserService.save(sysUser);
        return 200;
    }

    @PostMapping(value = "/delete")
    public Object delete(@RequestBody SysUser sysUser) {
        sysUserService.delete(sysUser);
        return 200;
    }

    @GetMapping(value = "/findAll")
    public Object findAll() {
        return sysUserService.findAll();
    }

    @PostMapping(value = "/findPage")
    public Object findPage(@RequestBody PageQuery pageQuery) {
        return sysUserService.findPage(pageQuery);
    }

}

service下SysUserService

package com.example.springdatajpa.service;

import com.example.springdatajpa.config.PageQuery;
import com.example.springdatajpa.model.SysUser;

import java.util.List;

public interface SysUserService {

    public void save(SysUser sysUser);

    public void delete(SysUser sysUser);

    public List<SysUser> findAll();

    public Object findPage(PageQuery pageQuery);

}

serviceImpl下SysUserServiceImpl

package com.example.springdatajpa.service.serviceImpl;

import com.example.springdatajpa.config.PageQuery;
import com.example.springdatajpa.dao.SysUserDao;
import com.example.springdatajpa.model.SysUser;
import com.example.springdatajpa.service.SysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class SysUserServiceImpl implements SysUserService {

    @Autowired
    private SysUserDao sysUserDao;

    @Override
    public void save(SysUser sysUser){
        sysUserDao.save(sysUser);
    }

    @Override
    public void delete(SysUser sysUser){
        sysUserDao.delete(sysUser);
    }

    @Override
    public List<SysUser> findAll(){
        return sysUserDao.findAll();
    }

    @Override
    public Object findPage(PageQuery pageQuery){
        return sysUserDao.findAll(PageRequest.of(pageQuery.getPageNum(),pageQuery.getPageSize()));
    }

}

dao下SysUserDao，继承了JpaRepository，里面不用写任何方法

package com.example.springdatajpa.dao;

import com.example.springdatajpa.model.SysUser;
import org.springframework.data.jpa.repository.JpaRepository;

import java.io.Serializable;

public interface SysUserDao extends JpaRepository<SysUser, Long>, Serializable {
}

启动项目，访问http://localhost:8080/swagger-ui.html，如下界面

点击sys-user-controller下的save，展开后点击Try it out

输入参数信息，点击Execute

成功

其他的方法就不一一试了.....来了解一下Spring Data JPA

Spring Data JPA为Java Persistence API（JPA）提供了存储库支持。它简化了需要访问JPA数据源的应用程序的开发。

Spring Data存储库抽象中的中央接口是Repository。它需要域类以及域类的ID类型作为类型参数来进行管理。该CrudRepository规定对于正在管理的实体类复杂的CRUD功能。

CrudRepository界面

public interface CrudRepository<T, ID> extends Repository<T, ID> {

  <S extends T> S save(S entity);      

  Optional<T> findById(ID primaryKey); 

  Iterable<T> findAll();               

  long count();                        

  void delete(T entity);               

  boolean existsById(ID primaryKey);   

  // … more functionality omitted.
}
save保存给定的实体。
findById返回由给定ID标识的实体。
findAll返回所有实体。
count返回实体数。
delete删除给定的实体。
existsById指示是否存在具有给定ID的实体。

还提供了特定于持久性技术的抽象，例如JpaRepository或MongoRepository。这些接口CrudRepository除了扩展了与持久性技术无关的通用接口（例如）之外，还扩展并公开了基础持久性技术的功能CrudRepository。

PagingAndSortingRepository界面，实现了排序和分页的方法

public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {

  Iterable<T> findAll(Sort sort);

  Page<T> findAll(Pageable pageable);
}

JpaRepository又在继承PagingAndSortingRepository的基础上，同时继承了QueryByExampleExecutor接口

JpaRepository界面

package org.springframework.data.jpa.repository;

import java.util.List;
import javax.persistence.EntityManager;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Sort;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.QueryByExampleExecutor;

/**
 * JPA specific extension of {@link org.springframework.data.repository.Repository}.
 *
 * @author Oliver Gierke
 * @author Christoph Strobl
 * @author Mark Paluch
 */
@NoRepositoryBean
public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.CrudRepository#findAll()
     */
    List<T> findAll();

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.PagingAndSortingRepository#findAll(org.springframework.data.domain.Sort)
     */
    List<T> findAll(Sort sort);

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.CrudRepository#findAll(java.lang.Iterable)
     */
    List<T> findAllById(Iterable<ID> ids);

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.CrudRepository#save(java.lang.Iterable)
     */
    <S extends T> List<S> saveAll(Iterable<S> entities);

    /**
     * Flushes all pending changes to the database.
     */
    void flush();

    /**
     * Saves an entity and flushes changes instantly.
     *
     * @param entity
     * @return the saved entity
     */
    <S extends T> S saveAndFlush(S entity);

    /**
     * Deletes the given entities in a batch which means it will create a single {@link Query}. Assume that we will clear
     * the {@link javax.persistence.EntityManager} after the call.
     *
     * @param entities
     */
    void deleteInBatch(Iterable<T> entities);

    /**
     * Deletes all entities in a batch call.
     */
    void deleteAllInBatch();

    /**
     * Returns a reference to the entity with the given identifier. Depending on how the JPA persistence provider is
     * implemented this is very likely to always return an instance and throw an
     * {@link javax.persistence.EntityNotFoundException} on first access. Some of them will reject invalid identifiers
     * immediately.
     *
     * @param id must not be {@literal null}.
     * @return a reference to the entity with the given identifier.
     * @see EntityManager#getReference(Class, Object) for details on when an exception is thrown.
     */
    T getOne(ID id);

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.query.QueryByExampleExecutor#findAll(org.springframework.data.domain.Example)
     */
    @Override
    <S extends T> List<S> findAll(Example<S> example);

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.query.QueryByExampleExecutor#findAll(org.springframework.data.domain.Example, org.springframework.data.domain.Sort)
     */
    @Override
    <S extends T> List<S> findAll(Example<S> example, Sort sort);
}

SysUserDao继承了JpaRepository，因而可以使用JpaRepository之上的所有接口，由此更加方便我们进行开发

spring data jpa方法命名规则，直接在接口中定义查询方法，如果是符合规范的，可以不用写实现

关键字方法命名sql where字句
AndfindByNameAndPwdwhere name= ? and pwd =?
OrfindByNameOrSexwhere name= ? or sex=?
Is,EqualsfindById,findByIdEqualswhere id= ?
BetweenfindByIdBetweenwhere id between ? and ?
LessThanfindByIdLessThanwhere id < ?
LessThanEqualsfindByIdLessThanEqualswhere id <= ?
GreaterThanfindByIdGreaterThanwhere id > ?
GreaterThanEqualsfindByIdGreaterThanEqualswhere id > = ?
AfterfindByIdAfterwhere id > ?
BeforefindByIdBeforewhere id < ?
IsNullfindByNameIsNullwhere name is null
isNotNull,NotNullfindByNameNotNullwhere name is not null
LikefindByNameLikewhere name like ?
NotLikefindByNameNotLikewhere name not like ?
StartingWithfindByNameStartingWithwhere name like '?%'
EndingWithfindByNameEndingWithwhere name like '%?'
ContainingfindByNameContainingwhere name like '%?%'
OrderByfindByIdOrderByXDescwhere id=? order by x desc
NotfindByNameNotwhere name <> ?
InfindByIdIn(Collection<?> c)where id in (?)
NotInfindByNameNotwhere name <> ?
TruefindByAaaTuewhere aaa = true
FalsefindByAaaFalsewhere aaa = false
IgnoreCasefindByNameIgnoreCasewhere UPPER(name)=UPPER(?)
topfindTop100top 10/where ROWNUM <=10
天真吴邪xie
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
使用springboot+springdata-jpa+前台Html页面实现增删改查
qq_42690761的博客
06-04 4482
大部分注解都打了注释，希望这篇对你们有用哦~ 谢谢！ 首先在实体类 @Data //自动封装getset方法 @Entity // 表示这是给实体 @Table(name = "students") // 表名 会生成表数据 public class Student { @Id //主键 @GeneratedValue(strategy= GenerationType.IDENTI...
SpringBoot整合SpringDataJPA实现增删改查（详细版）。
程序员阿皓的博客
02-23 605
创建一个实体类，使用JPA注解定义实体类与数据库表的映射关系。// 省略getter和setter方法 }// 省略getter和setter方法 }Entity;// 省略getter和setter方法 }// 省略getter和setter方法 }// 省略getter和setter方法 }Id;@Entity@Id// 省略getter和setter方法。
Springboot快速整合JPA实现增删查改
最新发布
2401_83704036的博客
04-18 460
面试是跳槽涨薪最直接有效的方式，马上金九银十来了，各位做好面试造飞机，工作拧螺丝的准备了吗？掌握了这些知识点，面试时在候选人中又可以夺目不少，暴击9999点。机会都是留给有准备的人，只有充足的准备，才可能让自己可以在候选人中脱颖而出。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！” />面试是跳槽涨薪最直接有效的方式，马上金九银十来了，各位做好面试造飞机，工作拧螺丝的准备了吗？掌握了这些知识点，面试时在候选人中又可以夺目不少，暴击9999点。
Spring Boot整合Spring Data JPA实现增删改查
zgc55987的博客
12-01 424
Spring Boot 集成Spring Data JPA 环境：idea 2019 spring boot 版本 2.x 1：创建一个Spring Boot项目 勾选web模块中的spring web 和sql模块中的spring data jpa 和mysql驱动 2：在resources下创建application.yml文件 spring: datasource: #my...
3分钟快速使用springboot整合SpringData Jpa进行增删改查
栋栋的博客
04-12 1057
文章目录浅谈SpringData Jpa与Hibernate区别环境搭建 浅谈SpringData Jpa与Hibernate区别 SpringDate Jpa： Spring Data是Spring Framework的一部分。Spring Data存储库抽象的目标是显著减少为各种持久性存储实现数据访问层所需的代码量。 Spring Data JPA不是JPA提供者。它是一个库/框架，它...
SpringBoot整合DataJpa增删改查
chengkaichengkai的博客
02-02 280
springboot整合datajpa
springboot整合spring data jpa进行增删改查
阿杰的专栏
02-04 314
springboot整合spring data jpa进行增删改查 项目结构 application.properties基础配置 server.port=8009 # 服务名 #spring.application.name=service-acl # mysql数据库连接 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/
springboot+springdata jpa增删改查
05-04
springboot+springdata jpa+freemark+ajax+bootstrap+redis增删改查，本文档简单易懂，适合初学者学习使用
spring-data-jpa实现增删改查以及分页操作方法
08-28
本资源摘要信息将详细介绍 Spring Data JPA 实现增删改查以及分页操作方法的知识点，包括增删改查操作方法的实现、分页操作方法的实现、Repository 接口的设计、Controller 层的设计等内容。 增删改查操作方法的...
idea下整合springboot+spring data jpa
02-02
idea下整合springboot+spring data jpa
基于Thymeleaf+SpringBoot+SpringDataJPA实现的的中小医院信息管理系统
06-17
本系统是基于Thymeleaf+SpringBoot+SpringDataJPA实现的的中小医院信息管理系统。简单实现了挂号收费，门诊管理，划价收费，药房取药，体检管理，药房管理，系统维护等基础功能。就诊卡提供了手动和读卡两种方式录入...
SpringBoot+MySQL+Jpa实现对数据库的增删改查和分页详解
08-25
SpringBoot+MySQL+Jpa实现对数据库的增删改查和分页详解是指使用SpringBoot框架、MySQL数据库和Jpa（Java Persistence API）技术来实现对数据库的增删改查和分页功能的详细介绍。 JPA简介 JPA（Java Persistence ...
通过SpringBoot框架实现简单的学生管理系统的增删改查
LOL_toulan的博客
05-02 1万+
简单的学生系统 SpringBoot因其其实就是简单、快速、方便！所以本文通过SpringBoot搭建一个简单的学生管理系统（持续更新）！ 准备工作： 工具：Mysql，Idea，navicat(其他也可以),Postman，HbuilderX 准备工作：创建student表，表信息为：int id，varchar name，varchar age，varchar sex。 创建一个新...
使用spring boot 整合spring jpa做基于restful风格的增删改查(maven ,mysql)
qq_34680444的博客
01-14 1542
前言：最近忙着赶着一个金融项目，感受良多，整个项目使用的是spring boot， 基础架构使用的是Dubbo集成三台服务器，利用Zookeeper分布式集群（具体知之甚少，有兴趣的可以一起学习啊） 项目中底层的持久化使用的是spring jpa和jdbc（联合使用），废话不多说，让我们一起来领略spring data jpa的强大吧！ 2.首先我们创建一个maven项目sp
spring data JPA教程（一）实现基本的增删改查
独钓寒江雪
01-12 9921
spring data JPA实战（一）实现基本的增删改查 1.构建项目 1.1使用IDEA新建项目 定义包名后next-&amp;amp;gt;勾选基本依赖 finish 完成 1.2 配置数据库参数 删除application.properties,新建application.yml,配置信息如下: spring: datasource: driver-class-name: com.mysq...
SpringdataJPA环境搭建和实现增删改查
Dengzhaoxu的博客
12-26 191
1项目需求 搭建环境实现增删改查 1.1环境搭建 使用springboot进行环境搭建，点击File，创建springboot项目，在界面中点击SQL，选中里面的springdataJPA.然后点击finish，项目就初步创建了。注意你还需要配置mysql连接驱动，这是实现数据库操作的，而JPA和JDBC一样只是sun公司提供的一套规范。 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.
SpringBoot整合Jpa实现数据的增删改查
RAVEEE的博客
12-24 4334
SpringBoot是什么？ SpringBoot框架 　Spring Boot是由Pivotal团队提供的全新框架，属于spring旗下的一个项目，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，它使用“习惯优于配置”的理念，从而使开发人员不再需要定义样板化的配置。使用springboot很容易创建一个独立运行的spring项目，并且可以几乎不使...
写给大忙人看的SpringBoot ，整合JPA实现数据库增删改查
清风~的博客
03-16 1292
SpringBoot简化了太多步骤，真心强大，当没有接触它的时候，Mybatis还要写dao层接口，还要dao层映射的sql语句，虽然也有一键生成相关配置。但是繁琐的配置，需要配置xml扫描相关路径等，springBoot通通不需要使用JPA关联数据库。
spring data jpa 更新和删除
热门推荐
laokaizzz的专栏
08-16 1万+
转自：https://docs.spring.io/spring-data/jpa/docs/2.0.9.RELEASE/reference/html/#repositories.create-instances.spring 1.repository自带的save方法 Saving an entity can be performed with the CrudRepository.save...
springboot整合Spring Data JPA
07-14
要在Spring Boot中整合Spring Data JPA，可以按照以下步骤进行操作： 1. 添加依赖：在项目的pom.xml文件中添加Spring Data JPA的依赖。...可以通过注入UserService来调用相应的方法，实现对数据库的增删改查操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值