Mybatis笔记

最新推荐文章于 2024-06-20 14:04:57 发布
最新推荐文章于 2024-06-20 14:04:57 发布
阅读量173 收藏
点赞数
分类专栏： 笔记 文章标签： 数据库架构 java 数据库 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31240423/article/details/126710734
版权

文章目录

创建第一个mybatis程序

  1. 准备数据库环境

  2. 搭建普通maven项目环境

  3. 倒入maven依赖

  4. 删除src目录（为了新建后面的子模块）

  5. 在子模块中编写mybatis的核心配置文件，这个框架需要配置之后才能使用

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--    mybatis核心配置文件-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

</configuration>

  6. 编写mybatis工具类，因为需要从配置文件中拿到建造者来建造工厂，读取配置文件这个过程可以写成工具类

    import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        String resource = "mybatis-config.xml";
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSqlSession() {
        return sqlSessionFactory.openSession();

    }
}

  7. 开始写程序（就按照mvc三层架构开始）

    • dao层接口

      package com.zhong.dao;

import com.zhong.pojo.User;

import java.util.List;

public interface UserDao {
    public List<User> getUserList();
}

    • dao层实现类（这里是配置文件来实现，由原来的impl转换成mapper.xml文件）

      <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--实现接口-->
<mapper namespace="com.zhong.dao.UserDao">
    <select id="getUserList" resultType="com.zhong.pojo.User">
    select * from `user`;
  </select>
</mapper>

    • 测试问题。因为我们的mapper.xml不是建在resources文件夹下的，所以需要对mapper.xml进行注册。但是由于maven无法导出Java文件夹下的配置文件。所以需要在xml中配置过滤，让maven能够导出我们的mapper.xml。或者把mapper.xml直接建立在resources文件夹下，然后在配置中文件路径写文件名即可

Map

使用map键值对来传递参数

配置解析

核心配置

环境配置

学会配置多套环境

属性

可以通过properties来动态的配置mybatis的核心配置文件。通过在核心配置文件中的properties的属性来引用

别名

在配置文件中，使用完全限定名规定类型，我们可以使用别名来为减少完全限定名的使用

<!--    给实体类起别名-->
    <typeAliases>
        <typeAlias type="com.zhong.pojo.User" alias="User"></typeAlias>
    </typeAliases>

包扫描，会默认的给包中的实体类起一个首字母小写的类名的别名

<!--    给实体类起别名-->
    <typeAliases>
        <package name="com.zhong.pojo"/>
    </typeAliases>

起别名也可以直接在实体类里面实现，在实体类中使用注解@Alias（“别名”）。在所有的起别名的方式中，注解的优先级最高

设置

映射器

注册mapper，就像使用配置文件去实现接口必须要注册一样。它有三种方式resouce使用/来分隔。class使用.分隔。以及打包一个包内的mapper package name=…

第二第三种方式需要注意的是，配置文件必须和接口同名，而且配置文件必须和接口在同一个包下

生命周期和作用域

错误的使用生命周期和作用域会导致严重的并发问题

ResultMap

用来解决数据库字段名和封装的对象的属性名不一致的问题，当这两个不一致的时候，mybatis无法将数据库查出来的数据放到对应的位置上

<resultMap id="UserMap" type="User">
    <result column="id" property="id"></result>
    <result column="name" property="name"></result>
    <result column="pwd" property="password"></result>
</resultMap>

    <select id="getUserById" parameterType="int" resultMap="UserMap">
        select * from `user` where id = #{id};
    </select>

日志

日志工厂

STDOUT_LOGGING 标准日志输出，开箱即用

<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

LOG4J　需要配置（IDEA 2022.1弃用log4j）

导包

<!-- 日志导包       -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.12</version>
</dependency>

log4j配置文件

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/kuang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

使用

static Logger logger = Logger.getLogger(UserDaoTest.class);


@Test
public void testLog4j() {
    logger.info("info");
    logger.debug("debug");
    logger.error("error");
}

分页

List<User> getUserByLimit(Map<String,Object> map);

<select id="getUserByLimit" resultType="User" parameterType="map" resultMap="UserMap">
    select * from mybatis.user limit #{startIndex},#{pageSize};
</select>

@Test
public void testLimit(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    HashMap<String, Object> map = new HashMap<String, Object>();
    map.put("startIndex",0);
    map.put("pageSize",2);

    List<User> userByLimit = mapper.getUserByLimit(map);
    for (User user : userByLimit) {
        System.out.println(user);
    }

    sqlSession.close();
}

使用注解开发

当我们需要使用一些简单的sql语句，可以使用注解来代替配置xml文件。这会让配置文件看起来比较干净整洁。但是使用一些复杂的sql语句的时候，在使用xml配置文件还是很有必要的。比如数据库字段和实体类数据名字不一样这样就映射不了

直接在接口的方法上面写@select("这里写你的查询sql")即可

@Select("select * from `user`")
List<User> getUsers();

<mappers>
    <!--<mapper resource="com/zhong/dao/UserMapper.xml"></mapper>-->
    <mapper class="com.zhong.dao.UserMapper"></mapper>
</mappers>

参数注解

在使用注解写sql语句的时候，如果方法本身需要一个外部的参数，那么在sql语句中为了使用到这个参数，需要在参数列表的参数前面加上参数注解@param("被sql调用的参数名")。参数注解只使用在基本类型和String，引用类型不需要参数注解

Lombok使用（重要）：

这是一个java的库，它是一个插件、构建工具。使用注释就可以写getter等方法。可以用idea的插件市场安装

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.10</version>
</dependency>

常用的注解

@Data//getter...等方法
@AllArgsConstructor//所有参数的构造方法
@NoArgsConstructor//无参数构造方法
@ToString

多对一的处理

我们需要在实现xml文件中关联sql语句，并且做结果集映射

按照查询嵌套处理

<resultMap id="StudentTeacher" type="Student">
    <!--简单映射可以直接使用result，但是对于复杂的对象需要进行特殊的处理-->
    <!--对象：association（多对一）
    集合：collection（一对多）-->
    <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"></association>
</resultMap>

<select id="getStudent" resultMap="StudentTeacher">
    select * from mybatis.student;
</select>

<select id="getTeacher" resultType="Teacher">
    select * from mybatis.teacher where id = #{id};
</select>

按结果嵌套查询

<select id="getStudent2" resultMap="StudentTeacher2">
    select s.id sid, s.name sname, t.name tname
    from mybatis.student s,mybatis.teacher t
    where s.tid = t.id;
</select>

<resultMap id="StudentTeacher2" type="Student">
    <result property="id" column="sid"></result>
    <result property="name" column="sname"></result>
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"></result>

    </association>
</resultMap>

一对多处理

按结果嵌套查询

<select id="getTeacher" resultMap="TeacherStudent">
    select s.name sname, s.id sid, t.name tname, t.id tid
    from mybatis.teacher t, mybatis.student s
    where t.id = s.tid and t.id = #{tid};
</select>

<resultMap id="TeacherStudent" type="Teacher">
    <result property="id" column="tid"></result>
    <result property="name" column="tname"></result>
    <!--这里clooection要区别javatype，因为是集合所以用oftype-->
    <collection property="students" ofType="Student">
        <result property="id" column="sid"></result>
        <result property="name" column="sname"></result>
        <result property="tId" column="tid"></result>
    </collection>
</resultMap>

按查询嵌套查询

<select id="getTeacher2" resultMap="TeacherStudent2">
    select * from mybatis.teacher where id = #{tid};
</select>

<resultMap id="TeacherStudent2" type="Teacher">
    <collection property="students" javaType="ArrayList" ofType="Student" column="id" select="getStudentByTeacher"></collection>
</resultMap>

<select id="getStudentByTeacher" resultType="Student">
    select * from mybatis.student where tid = #{tid};
</select>

动态sql

动态sql和jstl标签类似。主要有这几种

  • if
  • choose（when，otherwise）
  • trim（where，set）
  • foreach

if

@Test
public void test1() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    HashMap<String,String> map = new HashMap<String,String>();
    map.put("title","Java");

    List<Blog> blogs = mapper.queryBlogIF(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }

    sqlSession.close();
}

//查询博客
List<Blog> queryBlogIF(Map map);

<select id="queryBlogIF" parameterType="map" resultType="blog">
    select * from mybatis.blog where 1=1
    <if test="title != null">
        and title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>

</select>

choose（when，otherwise）

在我们使用if标签来拼接sql语句的时候，我们常常使用where 1=1来处理每个语句前面跟着的and的问题。但是这个1=1实际上是没有任何意义的，它只是为了帮助我们去处理掉where后面直接跟着and或者or的问题。使用where标签可以帮助我们去掉1=1这样没有意义的sql语句。

where便签里面正常写if标签的内容即可，只要有一个if成立，那么where语句会自动的插入where，不需要我们写。并且如果where后面紧跟了and或者or这样的关键字，where标签也会帮我们把and或者or去掉

<select id="queryBlogChoose" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <if test="title != null">
            title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </where>
</select>

choose

<select id="queryBlogChoose" parameterType="map" resultType="blog">
    select * from mybatis.blog where
        <choose>
            <when test="title != null">
                title = #{title}
            </when>
            <when test="author != null">
                author = #{author}
            </when>
            <otherwise>
                views = #{views}
            </otherwise>
        </choose>
</select>

trim（where，set）

set标签会动态的加上set关键字，并且会会帮助我们去掉多余的逗号。在set里写if标签动态的添加sql语句

<update id="updateBlog" parameterType="map">
    update `mybatis`.blog
    <set>
        <if test="title != null">
            title = #{title},
        </if>
        <if test="author != null">
            author = #{author},
        </if>
    </set>
    where id = #{id}
</update>

where和set都有一个父类

<trim prefix=" " prefixOverrides="" suffix="" suffixOverrides=""></trim>

我们可以使用这个父类来定制我们需要的类似set或者where的功能

prefix：需要时自动加上前缀

prefixOverrides：需要时，自动忽略语句前的东西。例如and或者or使用 | 分隔

suffix：需要时自动加上后缀

suffixOverrides：需要时，自动忽略语句后的东西。例如set后面的逗号

SQL片段

<sql id="if-title-author">
    <if test="title != null">
        title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</sql>

这样的叫做sql片段，在sql语句中使用include包含

<select id="queryBlogWhere" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <include refid="if-title-author"></include>
    </where>
</select>

Foreach

<select id="queryBlogForeach" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <foreach collection="ids" item="id" separator="or" close=")" open="(">
            id = #{id}
        </foreach>
    </where>
</select>

@Test
public void test3() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    
    HashMap map = new HashMap();
    ArrayList<Integer> ids = new ArrayList<Integer>();
    
    ids.add(1);
    ids.add(2);

    map.put("ids",ids);

    List<Blog> blogs = mapper.queryBlogForeach(map);

    for (Blog blog : blogs) {
        System.out.println(blog);
    }

    sqlSession.close();
}

缓存

存储在内存中的临时数据

如果把我们一次查询到的数据放在内存里面，以后需要的时候去内存调用，这样就可以不用查询数据库了，查询数据库需要IO，IO相对于内存是很慢的。缓存的出现解决了高并发系统的性能问题

经常查询且不经常改变的数据可以使用缓存

mybatis默认有一级缓存和二级缓存

  • 默认一级缓存开启，一级缓存就是sqlsession的缓存
  • 二级缓存需要手动开启或者配置，它是基于namespace级别的缓存
  • 还有接口缓存cache。我们可以通过实现cache接口来自定义二级缓存

一级缓存

缓存失效

  • 增删改会刷新缓存
  • 查询不同的mapper.xml
  • 手动清除缓存

二级缓存

启用二级缓存需要在sql映射文件中添加<cache/>并且要在核心配置文件的setting中开启缓存<setting name="cacheEnabled" value="true"></setting>

二级缓存使用新会话查询的时候，需要实体类序列化，如果实体类没有序列化，那么cache标签需要设置属性readOnly为true

所有缓存数据都会放在一级缓存中，只有当会话关闭或者提交的时候才会提交到二级缓存

缓存原理

自定义缓存-ehcache

要使用它，需要去导包mybatis-ehcache

<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">

    <diskStore path="./tmpdir/Tmp_EhCache"/>

    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>

    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
</ehcache>

实际工作使用redis更多

不不爱写博客
关注
专栏目录
MyBatis笔记
qq_19387933的博客
03-03 4万+
尚硅谷2022新版MyBatis笔记
老杜Mybatis笔记
chenyu_Yang的博客
03-06 371
https://www.yuque.com/zuihoudewu/java_note/mt2812?singleDoc#《老杜MyBatis--原版》
MyBatis 笔记
最新发布
weixin_44404391的博客
06-20 1898
动态SQL：根据不同的条件生存不同的SQL语句动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。ifforeach查询：连接数据库，很消耗资源​把查询的结果，暂存在一个地方-->内存 ：缓存​再次查询相同数据时，直接去缓存查询，不用再从数据库中查询什么是缓存（cache）？
狂神Mybatis笔记
weixin_51779902的博客
06-26 1476
1.MyBatis 是一款优秀的持久层框架 2.它支持自定义 SQL、存储过程以及高级映射 3.MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作 4.MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java............
mybatis笔记
huang_yang_fan的博客
04-20 1114
复习mybatis学习笔记 第一章：概述与入门 （一）mybatis的环境搭建 1、在MySQL创建一个数据库表用来测试数据 2、在idea用maven创建一个Java工程并导入mybatis依赖 日志可以不加。 3、创建实体类和dao的接口 4、创建mybatis的主配置文件SqlMapConfug.xml url我这里需要加上 ?characterEncoding=utf-8，防止传入的数据库数据乱码。 注意：如果是基于注解来配置的话，此处应该使用clas...
MyBatis笔记(尚硅谷完整笔记)
zhb111z的博客
08-21 1730
打包方式：jar引入依赖 创建MyBatis的核心配置文件 创建mapper接口 创建MyBatis的映射文件 相关概念：ORM（Object Relationship Mapping）对象关系映射。 对象：Java的实体类对象 关系：关系型数据库 映射：二者之间的对应关系 Java概念 数据库概念 类 表 属性 字段/列 对象 记录/行 映射文件的命名规则 表所对应的实体类的类名+Mapper.xml 例如：表t_user，映射的实体类为User，所对
黑马程序员-MyBatis笔记
热门推荐
小白的博客
01-29 1万+
看这篇就够了，真的！！！
【Mybatis笔记】狂神Mybatis笔记（有道云笔记链接）
慢热型网友的博客
11-02 270
1、Mybatis简介 2、第一个Mybatis程序 3、CRUD(增删改查) 4、配置解析 5、解决属性名和字段名不一致的问题ResultMap 6、日志 7、分页 8、使用注解开发 9、Lombok 10、动态SQL 11、缓存（了解）
Mybatis笔记详解
数据知道的博客
05-23 4278
Mybatis笔记 一. 引言 现有jdbc代码实现的dao不足:代码冗余,只有sql命令不一样.sql命令硬编码程序中部利于升级维护.建立数据库连接需要手动建立, 效率差 ( 没有应用”连接池”技术) Mybatis框架 Mybatis是个做数据持久化的框架,对jdbc代码的合理封装,主要完成数据库的访问操作( 增删改查 ) Mybatis提供了一种新的实现方式替换jdbc实现的dao ...
mybatis笔记.zip
04-13
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC ...通过阅读这份“mybatis笔记”，你可以更深入地了解如何使用 MyBatis 进行数据访问，提升你的开发效率。
mybatis笔记mybatis笔记mybatis笔记
11-06
MyBatis 是一个流行的Java持久层框架，它源自Apache的iBatis项目，后来在2010年迁移到Google Code，并在2013年进一步转移到GitHub。MyBatis的主要特点在于它允许开发者自定义SQL查询，支持存储过程，以及高级的映射...
软考中级软件设计师——信息系统安全分析与设计
qq_31240423的博客
03-22 4921
五、信息系统安全分析与设计 信息系统安全属性： 对称加密技术： 对称加密技术就是用同一个密钥进行加密解密，这种方法容易破解，且密钥的分发困难 非对称加密技术： 非对称技术就是用公钥加密，私钥解密，公钥对外公开，私钥自己保存，使用对方的公钥进行加密后传输数据 信息摘要： 其实就是验证加密的一种，将传输的数据通过特殊的加密方式加密之后生成的值当作验证码，数据发送之后，接收方可以用同样的加密方式进行加密然后对比两个验证码是否一致。常见的有MD5和SHA。但是过程中也可能存在验证码被串改的问题，所以我们引入了数
JAVA中获取系统当前时间（System.currenttimemillis()慢8小时）
qq_31240423的博客
04-13 2429
currenttimemillis() 该方法是获取1970年0点一直到现在的毫秒数。 利用这个数据，我们可以得到当前系统时间 ‘’’
软考中级软件设计师——数据结构与算法基础
qq_31240423的博客
03-29 1411
六、数据结构与算法基础： 数据结构： 已学省略 线性表——顺序存储和链式存储对比 二叉树： 二叉排序树： 哈夫曼树： 线索二叉树： 使用线索划线的方法，将对应的线索二叉树的对应序列写出，前序线索就对应前序遍历，然后看对应序列的叶子节点的直接前驱和直接后继节点是谁，用叶子节点的左子树指针指向直接前驱，再用右子树节点的指针指向直接后继 平衡二叉树： 排序二叉树中，同一组权值可以构造出不同的排序二叉树，查找的效率不一样，但一般树越平衡越饱满，查找的效率越好。因此提出了平衡二叉树。 稀疏矩阵： 一般出现在
springboot笔记
qq_31240423的博客
02-25 1288
springboot学习笔记
JAVA创建随机数的两种方法
qq_31240423的博客
04-20 1253
产生一个随机数 在Java中要产生一个随机数可以使用Meth.random()来完成。但是，Meth.random()只产生了一个0到1之间的随机数，这并不符合我们的预期，我们往往需要的是一个随机的整数，甚至我们需要一个特定范围的整数。 int start = 64; int end = 128; int result = (int)(Math.random() * (end - start + 1) + start); System.out.println(result); ...
软考中级软件设计师——数据库系统
qq_31240423的博客
03-20 1180
三、数据库系统 1、数据库模式 1.1、三级模式两级映射： 外模式：一般是和用户级的数据库表打交道 外模式—概念模式映射 概念模式：一般是数据库的维护人员使用，它里面是一张一张的表格 概念模式—内模式映射 内模式：内模式和操作系统打交道 2、数据库设计： 2.1、ER模型 ER模型探索实体和实体之间的关系一对一、一对多、多对多。以及实体的属性。它是独立与实际的数据库的，是一种概念性的图示。最终都将会转换成关系模式。在一对一的情况下，至少转换两个关系模式联系可以任意加在一个实体上也可以单独转换，在一对多的情
老杜mybatis笔记
05-29
很好，您想了解老杜的MyBatis笔记。老杜是一位非常资深的Java开发工程师，他在MyBatis方面有很深的研究和实践经验。他的MyBatis笔记主要包括以下内容： 1. MyBatis基础知识：包括MyBatis的架构、Mapper接口和XML...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值