Spring-SpringMVC-JPA整合

最新推荐文章于 2022-01-13 22:37:32 发布
最新推荐文章于 2022-01-13 22:37:32 发布
阅读量243 收藏 1
点赞数
分类专栏： springmvc spring 文章标签： spring java hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rzpy_qifengxiaoyue/article/details/107253993
版权

整合策略

SSM = Spring + SpringMVC + JPA= (Spring + JPA)+ SpringMVC
先整合 Spring + JPA
然后再整合 SpringMVC

JPA整合Spring

  1. 整合目标
  • 创建工程导入坐标(Java框架于我们而言就是一堆jar)
  • 配置 Spring 的配置文件(配置指定框架执行的细节)
  • 编写实体类 Resume，使用 JPA 注解配置映射关系
  • 编写一个符合 Spring Data JPA 的 Dao 层接口(ResumeDao接口)
  • 操作 ResumeDao 接口对象完成 Dao 层开发
  1. 整合所需 Jar 分析
  • Junit测试jar(4.12版本)
  • spring-data-jpa的jar(3.4.5)
  • Spring相关jar(spring-context、spring-test、spring-jdbc、spring-tx、spring-aop)
  • spring对orm框架的支持包
  • hibernate相关jar包
  • hibernate对jpa的实现jar
  • Mysql数据库驱动jar
  • Druid数据库连接池的jar
  1. 整合后的 Pom 坐标
<!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--spring相关-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.12.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.12.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.12.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.1.12.RELEASE</version>
        </dependency>

        <!--hibernate相关jar包,start-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.4.0.Final</version>
        </dependency>
        <!--hibernate对jpa的实现jar-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.4.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.4.0.Final</version>
        </dependency>

        <!--spring-data-jpa 需要引入的jar,start-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.1.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>3.0.1-b04</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.6</version>
        </dependency>
        <!--spring-data-jpa 需要引入的jar,end-->
        <!--数据库驱动jar-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <!--druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.21</version>
        </dependency>
  1. jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=123456
  1. Spring 配置文件
  • applicationContext-dao.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/data/jpa
       https://www.springframework.org/schema/data/jpa/spring-jpa.xsd
">

    <!--包扫描-->
    <context:component-scan base-package="com.rpp.dao"/>

    <!--对Spring和SpringDataJPA进行配置-->

    <!-- 创建数据库连接池druid-->
    <!--引入外部资源文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--第三方jar中的bean定义在xml中-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>


    <!--配置一个JPA中非常重要的对象,entityManagerFactory
            entityManager类似于mybatis中的SqlSession
            entityManagerFactory类似于Mybatis中的SqlSessionFactory
    -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--配置数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--配置包扫描（pojo实体类所在的包）-->
        <property name="packagesToScan" value="com.rpp.pojo"/>
        <!--指定jpa的具体实现，也就是hibernate-->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"></bean>
        </property>
        <!--jpa方言配置,不同的jpa实现对于类似于beginTransaction等细节实现起来是不一样的，
               所以传入JpaDialect具体的实现类-->
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"></bean>
        </property>

        <!--配置具体provider，hibearnte框架的执行细节-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--
                    配置数据表是否自动创建
                    因为我们会建立pojo和数据表之间的映射关系
                    程序启动时，如果数据表还没有创建，是否要程序给创建一下
                -->
                <property name="generateDdl" value="false"/>
                <!--
                    指定数据库的类型
                    hibernate本身是个dao层框架，可以支持多种数据库类型的，这里就指定本次使用的什么数据库
                -->
                <property name="database" value="MYSQL"/>
                <!--
                    配置数据库的方言
                    hiberante可以帮助我们拼装sql语句，但是不同的数据库sql语法是不同的，所以需要我们注入具体的数据库方言
                -->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
                <!--是否显示sql
                    操作数据库时，是否打印sql
                -->
                <property name="showSql" value="true"/>

            </bean>
        </property>
    </bean>

    <!--引用上面创建的entityManagerFactory
       <jpa:repositories> 配置jpa的dao层细节
       base-package:指定dao层接口所在包
    -->
    <jpa:repositories base-package="com.rpp.dao" entity-manager-factory-ref="entityManagerFactory"
                      transaction-manager-ref="transactionManager"/>

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

    <!--包扫描-->
    <context:component-scan base-package="com.rpp.service"/>

    <!--事务管理器配置
        jdbcTemplate/mybatis 使用的是DataSourceTransactionManager
        jpa规范：JpaTransactionManager
    -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <!--事务管理注解驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"/>


</beans>
  1. 编写实体类 Resume，使用 JPA 注解配置映射关系
/**
* 实体类和数据表映射关系
* @Entity
* @Table
* 2、实体类属性和表字段的映射关系
* @Id 标识主键
* @GeneratedValue 标识主键的生成策略
* @Column 建立属性和字段映射
*/
@Entity
@Table(name = "tbl_resume")
public class Resume {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
    @Column(name = "name")
    private String name;
    @Column(name = "address")
    private String address;
    @Column(name = "phone")
    private String phone;

    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 getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }


    @Override
    public String toString() {
        return "Resume{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", phone='" + phone + '\'' +
                '}';
    }
}
  1. 编写 ResumeDao 接口
/**
 * 一个符合SpringDataJpa要求的Dao层接口是需要继承JpaRepository和JpaSpecificationExecutor
 * paRepository<操作的实体类类型,主键类型> 封装了基本的CRUD操作
 * JpaSpecificationExecutor<操作的实体类类型> 封装了复杂的查询(分⻚、排序等
 */
public interface ResumeDao extends JpaRepository<Resume, Long>, JpaSpecificationExecutor<Resume> {


    @Query("from Resume  where id=?1 and name=?2")
    List<Resume> findByJpql(Long id, String name);

    /**
     * 使用原生sql语句查询，需要将nativeQuery属性设置为true，默认为false（jpql）
     *
     * @param name
     * @param address
     * @return
     */
    @Query(value = "select * from tb_resume  where name like ?1 and address like ?2", nativeQuery = true)
    List<Resume> findBySql(String name, String address);

    /**
     * 方法命名规则查询,按照name模糊查询(like)
     * 方法名以findBy开头
     * -属性名(首字母大写)
     * -查询方式(模糊查询、等价查询)，如果不写查询方式，默认等价查询
     *
     * @param name
     * @param address
     * @return
     */
    List<Resume> findByNameLikeAndAddress(String name, String address);

}
  1. 测试程序
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath*:application*.xml"})
public class JpaSpringTest {

    @Autowired
    private ResumeDao resumeDao;

    @Test
    public void testFindById() throws Exception {
        Optional<Resume> optional = resumeDao.findById(1l); 
        Resume resume = optional.get(); 
        System.out.println(resume);
    }
}

整合SpringMVC

  1. 引入pom坐标
		<!--SpringMVC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.12.RELEASE</version>
        </dependency>
        <!--jsp-api&servlet-api-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--页面使用jstl表达式-->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>

        <!--json数据交互所需jar，start-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.0</version>
        </dependency>
  1. 配置springmvc.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd
">

    <!--扫描controller-->
    <context:component-scan base-package="com.rpp.controller"/>

    <!--配置springmvc注解驱动，自动注册合适的组件handlerMapping和handlerAdapter-->
    <mvc:annotation-driven/>

    <!--配置springmvc的视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--静态资源位置-->
    <mvc:resources location="/WEB-INF/jsp/" mapping="/jsp/**"/>
    <mvc:resources location="/WEB-INF/js/" mapping="/js/**"/>
    <mvc:resources location="/WEB-INF/css/" mapping="/css/**"/>

    <mvc:interceptors>
        <mvc:interceptor>
            <!--配置当前拦截器的url拦截规则，**代表当前目录下及其子目录下的所有url-->
            <mvc:mapping path="/**"/>
            <!--exclude-mapping可以在mapping的基础上排除一些url拦截-->
            <mvc:exclude-mapping path="/user/login"/>
            <bean class="com.rpp.interceptor.LoginInterceptor"/>
        </mvc:interceptor>

    </mvc:interceptors>

</beans>
  1. 配置web.xml
<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

<!--配置文件位置-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:applicationContext*.xml</param-value>
  </context-param>
<!--  <context-param>-->
<!--    <param-name>contextClass</param-name>-->
<!--    <param-value></param-value>-->
<!--  </context-param>-->
  <!--spring框架启动-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  
  <!--springmvc启动-->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath*:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

  
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

乱码问题解决

  1. Post请求乱码，web.xml中加入过滤器
 	<!-- 解决post乱码问题 -->
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <!-- 设置编码参是UTF8 -->
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>

            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
  1. Get请求乱码(Get请求乱码需要修改tomcat下server.xml的配置)
<Connector URIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>
四月丶丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Spring】SpringMVC整合JPA
简约人生的博客
05-09 2万+
这篇文章是在SpringMVC的基础上对数据持久层JPA的整合，实现了应用层和数据库的数据交互。在整合JPA前，请先参照下面第一篇博文搭建好SpringMVC框架。一. 和本篇博文相关的一些基础知识请参考下面几篇博文： SpringMVC框架的搭建和配置详解请参考：http://blog.csdn.net/jianyuerensheng/article/details/51258942。 JPA的O
SpringMVC-整合Spring整合
Good good study!
06-09 693
SpringMVC配置文件中Bean和Spring配置文件中Bean关系 1.多个Spring IoC容器之间可以设置为父子关系，以实现良好的解耦。 2.Spring MVC容器（配置文件中的内容-servlet.xml)中Bean可以引用Spring容器Bean。 而Spring容器Bean，不能引用SpringMVC容器。即Spring.xml中定义的bean不能引用-servlet
springmvc+jpa(hibernate实现)+spring整合实例
04-29
工作用了springmvc+jpa+spring这么长时间，这段时间正好有点时间就想整合一下，但在整合过程中遇到了各种问题，上网查了很多资料但讲的都很模糊或者是没有注释，在我一步一步的试验中终于整合成功了，做为我自已以后复习用的资料我注释写的很全，其中项目里面的配置文件或是代码每行都有注释，网上这种整合实例很少，就奉献出来大家一起学习吧，在整合过程中遇到一个很奇怪的问题，就是spring的事务我配置成@Transactional(readOnly = true)只读事务，但是还可以对数据库进行操作，大家如果知道原因的就一起交流下吧
vue+springmvc前后端分离开发（五）（JPA映射与Validation）
qq_44938644的博客
04-20 401
这一节主要讲解了如何用jpa对字段进行映射，jpa的一些关系，以及属性的验证
SpringMVC整合Spring Data JPA
布先生
12-16 383
1.整合SpringMVC https://blog.csdn.net/qqq327954699/article/details/85036739 2.加入数据库驱动依赖mysql-connector-java 3.加入Spring Data JPA依赖spring-boot-starter-data-jpa 4.在src/main/resources下加入SpringBoot配置文件 appli...
SpringMVC-Spring-JPA配置
Dear__Liu的博客
08-01 241
一：Spring集成JPA 1、配置pom.xml <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>4.2.5....
Spring整合SpringMVC
Jumpingyyds的博客
01-13 923
本博客将会运用Spring+SpringMVC整合连接数据库做一个简单的数据查询操作。本次整合运用的知识点有XML和Config配置的结合使用，整合环境的搭建，数据库的连接等。首先我们拿到需求后第一步要做的事，就是创建一个Maven工程，因为要用到SpringMVC，所以我们需要把Maven工程打包成一个web工程，打包的步骤很简单就不一一赘述了，此时src目录底下的main目录下面应该有三个包，分别是java代码包、resource资源包、webapp web工程包。war包底下应该是WE...
spring-springmvc:弹簧
03-14
Spring 和 Spring MVC 是 Java 开发中的两个核心框架，它们在企业级应用开发中扮演着重要角色。...开发者可以通过查看这些源码，学习如何整合 Spring 和 Spring MVC，理解它们的工作原理以及如何在实际项目中应用。
finance:springmvc-spring-springjpa Maven 项目
07-17
【标题】"finance:springmvc-spring-springjpa Maven 项目" 提供了一个金融领域应用的示例，它基于Spring MVC、Spring和Spring JPA技术栈构建。这个项目使用了Maven作为构建工具，旨在展示如何在Java环境中集成这三...
spring-springmvc-mybatis
01-06
4. **SSM整合**：整合SSM框架，首先需要在Spring配置文件中定义DataSource、SqlSessionFactoryBean和MapperScannerConfigurer，以实现MyBatis的初始化。然后，使用Spring MVC的Controller处理请求，并通过Service层...
spring+springmvc+jpa(hibernate)框架整合
02-23
包含构建spring+springmvc+jpa(hibernate)架构框架的所需文件
SpringMVC+Spring+Spring-Data-JPA整合-完整Demo
02-27
SpringMVC+Spring+Spring-Data-JPA整合-完整Demo
Spring SpringMVC Jpa整合Demo
03-26
JavaEE中使用Spring SpringMVC Jpa三个框架开发的一个Demo
Spring mvc + jpa 配置，两个案例
12-29
Spring mvc + jpa +mysql5.6 配置，项目可运行。其中有两个案例，包含增删改查，复合主键开发 查询列表中，下拉列表显示名称所采用方式数据量大的时候存在问题，建议使用多表关联的方式。适合菜鸟学习。
spring mvc整合jpa后项目
02-05
spring mvc整合jpa后项目,包括源码及用到的包
spring+springMVC+jpa+hibernate框架整合
01-07
在IT领域，构建高效、可扩展的Web应用是至关重要的，而"spring+springMVC+jpa+hibernate框架整合"就是一个常见的解决方案。这个整合涉及到四个关键的技术栈：Spring框架、SpringMVC、JPA（Java Persistence API）...
spring springmvc jpa整合
liu289747235的专栏
01-01 609
github：https://github.com/leelun/ssjpa.git 1 配置项目需要依赖包（pom.xml） &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http...
Spring SpringMVC JPA整合配置
metjoyful的博客
09-26 4451
1. 三大框架 ssh struts spring hibernate Struts2 Spring Hibernate ssm(目前最流行的框架) SpringMVC Spring MyBatis ssj(Spring springMvc jpa) Struts2 Spring JPA(过时) SpringMVC Spring JPA（今天集成的框架） SpringMVC Spri...
Spring MVC + jpa框架搭建，及全面分析
weixin_30493321的博客
03-25 171
一，hibernate与jpa的关系 首先明确一点jpa是什么？以前我就搞不清楚jpa和hibernate的关系。 1,JPA(Java Persistence API)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关系映射工具来管理Java应用中的关系数据。而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的toplink...
SpringBoot开发实战（理论基础）
最新发布
07-06
3. **相关插件**：介绍Spring Boot的内置插件，如Spring Data JPA、Thymeleaf等。 4. **学生新增案例**：通过一个实例展示如何基于Spring Boot实现数据的CRUD操作。 ### 第六章 Spring Boot数据访问 1. **学习目标*...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值