springdatajpa学习笔记

最新推荐文章于 2022-10-10 10:07:02 发布
最新推荐文章于 2022-10-10 10:07:02 发布
阅读量161 收藏
点赞数
分类专栏： 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的课件笔记与学习标注。
maven依赖jar包时版本冲突的解决
热门推荐
sinat_39789638的博客
09-16 3万+
共有四种解决方式： 1、第一声明优先原则： 在pom.xml配置文件中，如果有两个名称相同版本不同的依赖声明，那么先写的会生效。 所以，先声明自己要用的版本的jar包即可。 2、路径近者优先： 直接依赖优先于传递依赖，如果传递依赖的jar包版本冲突了，那么可以自己声明一个指定版本的依赖jar，即可解决冲突。 3、排出原则： 传递依赖冲突时，可以在不需要的jar的传递依赖中声明排除，从而
Hibernate4+Spring4+Struts2在老版本基础上升级遇到的问题
mingming_vip的专栏
07-16 1335
之前的项目是spring2.5+hibernate3+struts2，
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 485
都跟数据∙库操作有关，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 523
Spring Data JPA 是基于JDBC之上的一组规范接口，JPA是由ORM框架实现，JPA用面向对象的方式，通过ORM框架生成SQL进行操作（最后还是要用JDBC去操作数据库）
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 6342
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 5374
如何获取泛型T的类型即T.class 想写一个spring-boot中mongodb的工具类，对mongodb的一些放进进行简单的封装，在写工具类的过程中发现spring-boot集成的mongodb方法中许多都需要用到实体类的类型，而工具类中我是用泛型T代表实体类，所以遇到的最大的问题就是不能获取到T.class。不太明白什么意思的直接看例子。 问题—例子 不太美观的工具类 /** ...
serviceComb学习笔记
狂奔小蚂蚁的博客
07-15 1505
##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 947
ConditionalOnProperty详解 控制配置类是否生效 confitionalonproperty里面的参数 public @interface ConditionalOnProperty { String[] value() default {}; //与ConfigurationProperties中的prefix相同 String prefix() defau...
IDEA搭建ssm的maven项目遇到的坑
狂奔小蚂蚁的博客
03-22 654
IDEA搭建ssm的maven项目遇到的坑 1.报错Error during artifact deployment. See server log for details 1.1产生错误原因 在搭建ssm项目时先创建普通项目然后转成web项目，在这使没有在pom文件中配置打包方式，深层次的原因不知道 1.2解决方法 在pom文件增加如下配置 <packaging>war</pa...
serviveComb学习笔记RPC
狂奔小蚂蚁的博客
07-16 476
ServiceComb的rpc方式 1.项目的流程见serviceComb学习笔记,此处只写核心代码 2.创建maven项目 父项目的pom <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://w...
SpringBoot整合WebSocket
狂奔小蚂蚁的博客
08-30 278
SpringBoot整合WebSocket 1.意义 集成websocket后能够实现前后端基于长连接的通信，前后端可以互相发送消息。 2.pom文件 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-websocket</artif...
maven引入外部jar包
狂奔小蚂蚁的博客
01-21 201
maven 引入外部jar 1.配置dependency <dependency> <groupId>xxx</groupId> <artifactId>xxx</artifactId> <version>xxx</version> <scope>system</s...
Nginx学习笔记
狂奔小蚂蚁的博客
03-19 163
Nginx学习笔记 1.安装 安装编译工具及库文件 yum -y install make zlib zlib-devel gcc-c++ libtool openssl openssl-devel 下载PCRE wget http://downloads.sourceforge.net/project/pcre/pcre/8.35/pcre-8.35.tar.gz 解压 tar...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值