springdatajpa学习笔记

最新推荐文章于 2023-04-20 18:53:13 发布
最新推荐文章于 2023-04-20 18:53:13 发布
阅读量160 收藏
点赞数
分类专栏： java 后端 后台框架 文章标签： spring-data-jpa学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42793833/article/details/95766958
版权
后端 同时被 3 个专栏收录
11 篇文章 0 订阅
订阅专栏
后台框架
7 篇文章 0 订阅
订阅专栏
java
6 篇文章 0 订阅
订阅专栏

SpringDataJpa学习笔记

1.创建maven项目

2.添加pom依赖

<properties>
    <spring.version>4.2.4.RELEASE</spring.version>
    <hibernate.version>5.0.7.Final</hibernate.version>
    <slf4j.version>1.6.6</slf4j.version>
    <log4j.version>1.2.12</log4j.version>
    <c3p0.version>0.9.1.2</c3p0.version>
    <mysql.version>5.1.6</mysql.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.6.8</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-jpa</artifactId>
        <version>1.9.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.9</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-entitymanager</artifactId>
        <version>${hibernate.version}</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
        <version>5.2.1.Final</version>
    </dependency>
    <!-- hibernate end -->

    <!-- c3p0 beg -->
    <dependency>
        <groupId>c3p0</groupId>
        <artifactId>c3p0</artifactId>
        <version>${c3p0.version}</version>
    </dependency>
    <!-- c3p0 end -->

    <!-- log end -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>${log4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>${slf4j.version}</version>
        <exclusions>
            <exclusion>
                <artifactId>log4j</artifactId>
                <groupId>log4j</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    <!-- log end -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
    </dependency>
    <!-- el beg 使用spring data jpa 必须引入 -->
    <dependency>
        <groupId>javax.el</groupId>
        <artifactId>javax.el-api</artifactId>
        <version>2.2.4</version>
    </dependency>
    <dependency>
        <groupId>org.glassfish.web</groupId>
        <artifactId>javax.el</artifactId>
        <version>2.2.4</version>
    </dependency>
    <!-- el end -->
</dependencies>

3.配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/data/jpa
		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

    <!--1.数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/demo"/>
        <property name="user" value="root"/>
        <property name="password" value="******"/>
    </bean>

    <!--2.entityManagerFactory配置-->
    <bean id="entityManagerFactory" 		     class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--数据库-->
        <property name="dataSource" ref="dataSource"/>
        <!--配置扫描包-->
        <property name="packagesToScan" value="com.zjb.po"/>
        <!--jpa实现厂家-->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>
        <!--jpa提供商适配器-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--是否自动创建数据库表-->
                <property name="generateDdl" value="false"/>
                <!--数据库类型-->
                <property name="database" value="MYSQL"/>
                <!--数据库方言-->
                <property name="databasePlatform"          			value="org.hibernate.dialect.MySQLDialect"/>
                <!--是否显示sql-->
                <property name="showSql" value="true"/>
            </bean>
        </property>
        <!--jpa方言-->
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
        </property>
    </bean>

    <!--3.事物管理器-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <!--4.整合spring-data-jpa-->
    <jpa:repositories base-package="com.zjb.dao" transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
    <!--5.txAdvice-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--5.aop-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.zjb.service.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
    </aop:config>

    <!--6.配置扫描包-->
    <context:component-scan base-package="com.zjb"/>
</beans>

4.实体类(一对多关系)

####4.1一的一方

package com.zjb.po;

import javax.persistence.*;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

/**
 * @author zhaojianbo
 * @date 2019/7/13 11:11
 */
@Entity
@Table(name = "cst_customer")//数据库表名称
public class Customer implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    @Column(name = "cust_id") //数据库中的列名
    private Long custId;

    @Column(name = "cust_name") 
    private String custName;

    @Column(name = "cust_source")
    private String custSource;

    @Column(name = "cust_industry")
    private String custIndustry;

    @Column(name = "cust_level")
    private String custLevel;

    @Column(name = "cust_address")
    private String custAddress;

    @Column(name = "cust_phone")
    private String custPhone;

    //一对多时在一的一方放弃外键维护，由多的一方维护
    //因为对于多的一方来说，永远都是一对一
    //mappedBy对应的内容是一的一方在多的一方的列名称
    @OneToMany(mappedBy = "customer")
    private Set<LinkMan> linkmans = new HashSet<LinkMan>();

    public Long getCustId() {
        return custId;
    }

    public void setCustId(Long custId) {
        this.custId = custId;
    }

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public String getCustSource() {
        return custSource;
    }

    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }

    public String getCustIndustry() {
        return custIndustry;
    }

    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }

    public String getCustLevel() {
        return custLevel;
    }

    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }

    public String getCustAddress() {
        return custAddress;
    }

    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }

    public String getCustPhone() {
        return custPhone;
    }

    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }

    public Set<LinkMan> getLinkmans() {
        return linkmans;
    }

    public void setLinkmans(Set<LinkMan> linkmans) {
        this.linkmans = linkmans;
    }
}
4.2多的一方
package com.zjb.po;

import javax.persistence.*;
import java.io.Serializable;

/**
 * @author zhaojianbo
 * @date 2019/7/13 14:59
 */
@Entity
@Table(name = "cst_linkman")
public class LinkMan implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "lkm_id")
    private Long lkmId;
    @Column(name = "lkm_name")
    private String lkmName;
    @Column(name = "lkm_gender")
    private String lkmGender;
    @Column(name = "lkm_phone")
    private String lkmPhone;
    @Column(name = "lkm_mobile")
    private String lkmMobile;
    @Column(name = "lkm_email")
    private String lkmEmail;
    @Column(name = "lkm_position")
    private String lkmPosition;
    @Column(name = "lkm_memo")
    private String lkmMemo;

    //配置多对一关系
    //targetEntity 多对一时一的一方的类名
    //cascade级联操作
    @ManyToOne(targetEntity = Customer.class, cascade = CascadeType.ALL)
    //外键描述
    //name数据库中外键的名称
    //referencedColumnName 外键对应的字段名称
    @JoinColumn(name = "lkm_cust_id", referencedColumnName = "cust_id")
    private Customer customer;

    public Long getLkmId() {
        return lkmId;
    }

    public void setLkmId(Long lkmId) {
        this.lkmId = lkmId;
    }

    public String getLkmName() {
        return lkmName;
    }

    public void setLkmName(String lkmName) {
        this.lkmName = lkmName;
    }

    public String getLkmGender() {
        return lkmGender;
    }

    public void setLkmGender(String lkmGender) {
        this.lkmGender = lkmGender;
    }

    public String getLkmPhone() {
        return lkmPhone;
    }

    public void setLkmPhone(String lkmPhone) {
        this.lkmPhone = lkmPhone;
    }

    public String getLkmMobile() {
        return lkmMobile;
    }

    public void setLkmMobile(String lkmMobile) {
        this.lkmMobile = lkmMobile;
    }

    public String getLkmEmail() {
        return lkmEmail;
    }

    public void setLkmEmail(String lkmEmail) {
        this.lkmEmail = lkmEmail;
    }

    public String getLkmPosition() {
        return lkmPosition;
    }

    public void setLkmPosition(String lkmPosition) {
        this.lkmPosition = lkmPosition;
    }

    public String getLkmMemo() {
        return lkmMemo;
    }

    public void setLkmMemo(String lkmMemo) {
        this.lkmMemo = lkmMemo;
    }

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
}

5.实体类（多对多关系）

package com.zjb.po;

import javax.persistence.*;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

/**
 * 用户的数据模型
 */
@Entity
@Table(name="sys_user")
public class SysUser implements Serializable {
	
	@Id
	@GeneratedValue(strategy= GenerationType.IDENTITY)
	@Column(name="user_id")
	private Long userId;
	@Column(name="user_code")
	private String userCode;
	@Column(name="user_name")
	private String userName;
	@Column(name="user_password")
	private String userPassword;
	@Column(name="user_state")
	private String userState;
	
	//放弃主键维护
	@ManyToMany(mappedBy="users")
	private Set<SysRole> roles = new HashSet<SysRole>(0);
	
	public Long getUserId() {
		return userId;
	}
	public void setUserId(Long userId) {
		this.userId = userId;
	}
	public String getUserCode() {
		return userCode;
	}
	public void setUserCode(String userCode) {
		this.userCode = userCode;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getUserPassword() {
		return userPassword;
	}
	public void setUserPassword(String userPassword) {
		this.userPassword = userPassword;
	}
	public String getUserState() {
		return userState;
	}
	public void setUserState(String userState) {
		this.userState = userState;
	}
	public Set<SysRole> getRoles() {
		return roles;
	}
	public void setRoles(Set<SysRole> roles) {
		this.roles = roles;
	}
}

package com.zjb.po;

import javax.persistence.*;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

/**
 * 角色的数据模型
 */
@Entity
@Table(name="sys_role")
public class SysRole implements Serializable {
	
	@Id
	@GeneratedValue(strategy= GenerationType.IDENTITY)
	@Column(name="role_id")
	private Long roleId;
	@Column(name="role_name")
	private String roleName;
	@Column(name="role_memo")
	private String roleMemo;
	
	//多对多关系映射
	@ManyToMany
	@JoinTable(name="user_role_rel",//中间表的名称
			  //中间表user_role_rel字段关联sys_role表的主键字段role_id
			  joinColumns={@JoinColumn(name="role_id",referencedColumnName="role_id")},
			  //中间表user_role_rel的字段关联sys_user表的主键user_id
			  inverseJoinColumns={@JoinColumn(name="user_id",referencedColumnName="user_id")}
	)
	private Set<SysUser> users = new HashSet<SysUser>(0);
	
	
	public Long getRoleId() {
		return roleId;
	}
	public void setRoleId(Long roleId) {
		this.roleId = roleId;
	}
	public String getRoleName() {
		return roleName;
	}
	public void setRoleName(String roleName) {
		this.roleName = roleName;
	}
	public String getRoleMemo() {
		return roleMemo;
	}
	public void setRoleMemo(String roleMemo) {
		this.roleMemo = roleMemo;
	}
	public Set<SysUser> getUsers() {
		return users;
	}
	public void setUsers(Set<SysUser> users) {
		this.users = users;
	}
}

6.dao的写法(CustomerDao为例)

package com.zjb.dao;

import com.zjb.po.Customer;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.test.annotation.Rollback;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author zhaojianbo
 * @date 2019/7/13 11:15
 */
//接口类型、需要继承JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer>
//JpaRepository对应的是实体类名和id类型
//dao中包含了基本的增删改查，由JpaRepository提供
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
    //jpql写法
    @Query(value = "from Customer ")
    List<Customer> findAllCustomer();

    @Query(value = "from Customer where custName = ?1")
    Customer findCustomer(String custName);
    
    //jpql修改时的写法
    @Query(value = "update Customer set custName = ?1 where custId = ?2")
    @Modifying
    @Transactional
    @Rollback(value = false)
    void updateCustomer(String custName, Long custId);
	//原生sql写法
    @Query(value = "select * from cst_customer", nativeQuery = true)
    List<Customer> findAllSql();
}

###7.JpaSpecificationExecutor使用

@Test
public void testSpecifications() {
    //创建接口实现里面的方法
    Specification<Customer> specification = new Specification<Customer>() {
        public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
            //root指的是Customer，可以获取Customer任意字段的值
            Expression<String> cb = root.get("custName").as(String.class);
            //criteriaBuilder查询的方式
            return criteriaBuilder.like(cb, "你%");
        }
    };
    Customer customer = customerDao.findOne(specification);
    System.out.println(customer);
}

8.注意事项

  • 一对多进行保存时先保存一的一方，因为多的一方需要一的一方提供的id作为外键
逆风奔袭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
超全面综合笔记！Spring Data Jpa 学习
08-06
综合多家视频，超全面综合笔记！Spring Data Jpa 学习
Spring Data JPA笔记.zip
02-02
JPA 的全称是 Java Persistence API， 即 Java 持久化 API，是 SUN 公司推出的一套基于 ORM 的规范，内部是由一系列的接口和抽象类构成。JPA 的查询语言是面向对象而非面向... 本文档包含了JPA的课件笔记与学习标注。
Spring Data JPA学习（1.0）
weixin_44641846的博客
07-15 114
关于以前的JDBC: //SQL语句 String sql = "insert into xx(xx,xx,xx) values(xx,xx,xx); "; //加载驱动： Class.forname(com.mysql.jdbc.Driver); //建立连接 Connection con = DirverManager.getCon(username,password,url,driver); //创建预处理对象 PreparedStatment psmt = con.prepareStatment(s
Hibernate4+Spring4+Struts2在老版本基础上升级遇到的问题
mingming_vip的专栏
07-16 1333
之前的项目是spring2.5+hibernate3+struts2，
maven依赖jar包时版本冲突的解决
热门推荐
sinat_39789638的博客
09-16 3万+
共有四种解决方式： 1、第一声明优先原则： 在pom.xml配置文件中，如果有两个名称相同版本不同的依赖声明，那么先写的会生效。 所以，先声明自己要用的版本的jar包即可。 2、路径近者优先： 直接依赖优先于传递依赖，如果传递依赖的jar包版本冲突了，那么可以自己声明一个指定版本的依赖jar，即可解决冲突。 3、排出原则： 传递依赖冲突时，可以在不需要的jar的传递依赖中声明排除，从而
spring data jpa（一）
weixin_30399871的博客
01-09 340
第1章 Spring Data JPA的快速入门 1.1 需求说明 Spring Data JPA完成客户的基本CRUD操作 1.2 搭建Spring Data JPA的开发环境 1.2.1 引入Spring Data JPA的坐标 使用Spring Data JPA，需要整合Spring与Spring Data JPA，并且需要提供JPA的服务提供者...
Spring Data Jpa学习笔记
有多勉为其难的博客
08-31 479
都跟数据∙库操作有关，JPA 是JDBC 的升华，升级版。JDBC和JPA都是一组规范接口 3.都是由SUN官方推出的JDBC是由各个关系型数据库实现的， JPA 是由ORM框架实现。JDBC 使用SQL语句和数据库通信。JPA用面向对象方式， 通过ORM框架来生成SQL，进行操作。JPA在JDBC之上的， JPA也要依赖JDBC才能操作数据库。需要面向SQL语句来操作数据库，开发人员学习成本更高。数据库的移至性不高，不同数据库的SQL语句无法通用。..................
SpringData JPA学习笔记
qq_56754651的博客
10-10 522
Spring Data JPA 是基于JDBC之上的一组规范接口，JPA是由ORM框架实现，JPA用面向对象的方式，通过ORM框架生成SQL进行操作（最后还是要用JDBC去操作数据库）
Spring Data JPA学习笔记
RainHey的博客
04-20 196
Spring Data JPA
SpringDataJpa学习笔记
qq_52117632的博客
05-30 245
SpringDataJpa学习笔记
SpringDataJPA学习笔记
ilove_story的博客
10-13 258
1、Spring Data Jpa 概述 Spring Data Jpa是Spring基于ORM框架、JPA规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码实现对数据库的访问和操作，推荐使用Spring Data JPA+ORM（如：hibernate）完成操作，这样在切换不同的ORM框架时提供了极大的方便，同时也使数据库层操作简单，方便解耦。 SpringDataJpa、JPA和Hibernate的关系 JPA是一种规范，内部由接口和抽象类构成。而我们的Hibernate是一套成熟的ORM框
spring-data-JPA学习笔记
10-22
在"spring-data-JPA学习笔记"中，我们主要关注的是如何使用JPA进行CRUD操作以及一些常用的查询方法。 首先，Spring Data JPA 提供了一种基于方法名的自动查询映射机制。例如，`findByUsernameAndPassword(String ...
SpringDataJPA.md
07-09
SpringDataJPA学习笔记
Spring Data JPA精讲
06-12
**Spring Data JPA精讲** 在Java开发领域，Spring Data JPA是一个不可或缺的工具，它为开发者提供了方便快捷的方式来操作...通过学习这门课程，你将具备使用Spring Data JPA构建高效、可维护的Java应用程序的能力。
spring整合Swagger
狂奔小蚂蚁的博客
05-06 6340
Spring整合Swagger 1.我这里使用的spring版本是4.1.2.RELEASE 2.导入Swagger的maven依赖 <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> &l...
如何获取泛型T的类型即T.class
狂奔小蚂蚁的博客
04-25 5372
如何获取泛型T的类型即T.class 想写一个spring-boot中mongodb的工具类，对mongodb的一些放进进行简单的封装，在写工具类的过程中发现spring-boot集成的mongodb方法中许多都需要用到实体类的类型，而工具类中我是用泛型T代表实体类，所以遇到的最大的问题就是不能获取到T.class。不太明白什么意思的直接看例子。 问题—例子 不太美观的工具类 /** ...
serviceComb学习笔记
狂奔小蚂蚁的博客
07-15 1504
##ServiceComb学习笔记 1.下载并安装SDK //使用git下载，需要先安装git git clone https://github.com/apache/servicecomb-java-chassis.git cd servicecomb-java-chassis //将sdk安装的本地仓库 mvn clean install -DskipTests 2.rest方式...
ConditionalOnProperty
狂奔小蚂蚁的博客
04-21 945
ConditionalOnProperty详解 控制配置类是否生效 confitionalonproperty里面的参数 public @interface ConditionalOnProperty { String[] value() default {}; //与ConfigurationProperties中的prefix相同 String prefix() defau...
SpringData JPA笔记.docx
最新发布
11-29
Spring Data JPA是一个用来简化JPA开发的框架，其主要目的是为了简化操作实体类就相当于操作数据库表的过程。它建立了实体类和表的映射关系以及实体类中属性和数据库表字段的映射关系。同时，Spring Data JPA还结合...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值