SpringBoot使用MyBatis连接MySQL

已于 2024-01-29 18:44:52 修改
阅读量1.8k 收藏 38
点赞数 33
分类专栏： SpringBoot系列基础教程 文章标签： spring boot mysql 后端 java mybatis
于 2024-01-23 18:19:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laisc7301/article/details/135779032
版权

[!NOTE]

本教程是《SpringBoot系列基础教程》之一，教程目录：https://blog.csdn.net/laisc7301/article/details/135918617

首先按照图示新建项目：

添加以下依赖：

找到application.properties文件，并写入下面内容：

server.port=8001

#设置数据库名为testdata
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/testdata?characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#下面两行设置数据库用户名和密码
spring.datasource.username=root
spring.datasource.password=root1234


mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.configuration.map-underscore-to-camel-case=true

注意 testdata 就是数据库名。

整个项目的文件结构如下图所示：

先把代码贴出来：

UserController.java

package com.laisc.example3.controller;

import com.laisc.example3.entity.User;
import com.laisc.example3.mapper.UserMapper;
import com.laisc.example3.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Controller
@RequestMapping("/test")
public class UserController {

    @Autowired
    UserService userService;

    @ResponseBody
    @RequestMapping("/insert")
    public String insert() { // 插入数据
        User u = new User();
        u.setUsername("admin");
        u.setPassword("admin123");
        u.setRole("root");
        int num = userService.insertUser(u);
        return "成功添加" + num + "条记录";
    }

    @ResponseBody
    @RequestMapping("/findone")
    public String findone() { //仅搜索一条结果，结果多于一条时，会报错
        User u = new User();
        u.setUsername("admin");
        User ret = userService.findOneUser(u);
        return ret.toString();
    }

    @ResponseBody
    @RequestMapping("/findmany")
    public String findMany() { //搜索所有符合条件的结果
        User u = new User();
        u.setUsername("admin");
        List<User> ret = userService.findManyUser(u);
        return ret.toString();
    }

    @ResponseBody
    @RequestMapping("/findmany2")
    public String findMany2() { // 和 findMany() 方法一样，只是这次在mapper配置文件里的resultType属性上使用了User类
        User u = new User();
        u.setUsername("admin");
        List<User> ret = userService.findManyUser2(u);
        return ret.toString();
    }

    @ResponseBody
    @RequestMapping("/findmany3")
    public String findMany3() { // 和 findMany() 方法一样，只是这次ret的类型是List<Map>。
        User u = new User();
        u.setUsername("admin");
        List<Map> ret = userService.findManyUser3(u);
        return ret.toString();
    }

    @ResponseBody
    @RequestMapping("/findmany4")
    public String findMany4() { // 和 findMany() 方法一样，只是这次传入的参数的类型是Map，ret的类型也是List<Map>。
        Map<String, String> map = new HashMap<String, String>();
        map.put("username", "admin");

        List<Map> ret = userService.findManyUser4(map);
        return ret.toString();
    }

    @ResponseBody
    @RequestMapping("/update1")
    public String update1() { // 更新数据库
        User u = new User();
        u.setUsername("admin");
        u.setPassword("abcd1234");
        u.setRole("user");
        int num = userService.updateUserPasswordAndRole(u);
        return "成功更新" + num + "条记录";
    }

    @ResponseBody
    @RequestMapping("/update2")
    public String update2() { // 更新数据库，但是不更新对象u中值为空的数据
        User u = new User();
        u.setUsername("admin");
        //u.setPassword("abcd1234");
        u.setRole("user");
        int num = userService.updateUser(u);
        return "成功更新" + num + "条记录";
    }

    @ResponseBody
    @RequestMapping("/delete")
    public String delete() { // 删除记录
        int num = userService.deleteUser("admin");
        return "成功删除" + num + "条记录";
    }
}

UserService.java

package com.laisc.example3.service;

import com.laisc.example3.entity.User;

import java.util.List;
import java.util.Map;

public interface UserService {
    public int insertUser(User user);

    public User findOneUser(User user);//仅搜索一条结果，结果多于一条时，会报错

    public List<User> findManyUser(User user);

    public List<User> findManyUser2(User user);

    public List<Map> findManyUser3(User user);

    public List<Map> findManyUser4(Map map);

    public int updateUserPasswordAndRole(User user);

    public int updateUser(User user);

    public int deleteUser(String username);
}

UserServiceImpl.java

package com.laisc.example3.service.impl;

import com.laisc.example3.entity.User;
import com.laisc.example3.mapper.UserMapper;
import com.laisc.example3.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    UserMapper userMapper;
    @Override
    public int insertUser(User user) {
        return userMapper.insertUser(user);
    }

    @Override
    public User findOneUser(User user) {
        return userMapper.findOneUser(user);
    }

    @Override
    public List<User> findManyUser(User user) {
        return userMapper.findManyUser(user);
    }

    @Override
    public List<User> findManyUser2(User user) {
        return userMapper.findManyUser2(user);
    }

    @Override
    public List<Map> findManyUser3(User user) {
        return userMapper.findManyUser3(user);
    }

    @Override
    public List<Map> findManyUser4(Map map) {
        return userMapper.findManyUser4(map);
    }

    @Override
    public int updateUserPasswordAndRole(User user) {
        return userMapper.updateUserPasswordAndRole(user);
    }

    @Override
    public int updateUser(User user) {
        return userMapper.updateUser(user);
    }

    @Override
    public int deleteUser(String username) {
        return userMapper.deleteUser(username);
    }
}

UserMapper.java

package com.laisc.example3.mapper;


import com.laisc.example3.entity.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;
import java.util.Map;

@Mapper
public interface UserMapper {

    public int insertUser(User user);

    public User findOneUser(User user);//仅搜索一条结果，结果多于一条时，会报错

    public List<User> findManyUser(User user);

    public List<User> findManyUser2(User user);

    public List<Map> findManyUser3(User user);

    public List<Map> findManyUser4(Map map);

    public int updateUserPasswordAndRole(User user);

    public int updateUser(User user);

    public int deleteUser(String username);
}

User.java

package com.laisc.example3.entity;

public class User {
    private int id = -1;
    private String username= "";
    private String password= "";
    private String role= "";

    public User() {
    }

    public User(int id, String username, String password, String role) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.role = role;
    }

    public int getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

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

    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", role='" + role + '\'' +
                '}';
    }
}

UserMapper.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.laisc.example3.mapper.UserMapper">

    <insert id="insertUser" parameterType="com.laisc.example3.entity.User">
        insert into myuser (username, password, role)
        VALUES (#{username}, #{password}, #{role})
    </insert>


    <resultMap id="myfinduser" type="com.laisc.example3.entity.User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="password" column="password"/>
        <result property="role" column="role"/>
    </resultMap>
    <select id="findOneUser" resultMap="myfinduser" parameterType="com.laisc.example3.entity.User">
        select myuser.id       id,
               myuser.username username,
               myuser.password password,
               myuser.role     role
        from myuser
        where username = #{username}
    </select>

    <select id="findManyUser" resultMap="myfinduser" parameterType="com.laisc.example3.entity.User">
        select myuser.id       id,
               myuser.username username,
               myuser.password password,
               myuser.role     role
        from myuser
        where username = #{username}
    </select>

    <select id="findManyUser2" resultType="com.laisc.example3.entity.User" parameterType="com.laisc.example3.entity.User">
        select myuser.id       id,
               myuser.username username,
               myuser.password password,
               myuser.role     role
        from myuser
        where username = #{username}
    </select>

    <select id="findManyUser3" resultType="Map" parameterType="com.laisc.example3.entity.User">
        select myuser.id       id,
               myuser.username username,
               myuser.password password,
               myuser.role     role
        from myuser
        where username = #{username}
    </select>

    <select id="findManyUser4" resultType="Map" parameterType="Map">
        select myuser.id       id,
               myuser.username username,
               myuser.password password,
               myuser.role     role
        from myuser
        where username = #{username}
    </select>

    <update id="updateUserPasswordAndRole" parameterType="com.laisc.example3.entity.User">
        update myuser
        <set>
            myuser.password=#{password},
            myuser.role=#{role}
        </set>
        where username = #{username}
    </update>


    <update id="updateUser" parameterType="com.laisc.example3.entity.User">-- 不更新值为空的数据
        update myuser
        <set>
            <if test="id != null and id != -1 ">id=#{id},</if>
            <if test="password != null and password != '' ">password=#{password},</if>
            <if test="role != null and role != '' ">role=#{role},</if>

        </set>
        where username = #{username}
    </update>


    <delete id="deleteUser" parameterType="String">
        delete
        from myuser
        where username = #{username}
    </delete>

</mapper>

数据库(myuser @testdata)：

idusernamepasswordrole
adminabc123root
admin123root

看UserController.java：

@Autowired
UserService userService;

UserService.java 里调用了UserServiceImpl.java

UserServiceImpl.java

@Autowired
UserMapper userMapper;

打上这段代码后，我们就可以使用UserMapper了。

另外，不要忘记在UserMapper.java里写上这一行：

@Mapper

在UserServiceImpl.java里写上这一行：

@Service

然后，UserMapper.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.laisc.example3.mapper.UserMapper">
</mapper>

看这一段：

UserController.java

@ResponseBody
@RequestMapping("/insert")
public String insert() { // 插入数据
    User u = new User();
    u.setUsername("admin");
    u.setPassword("admin123");
    u.setRole("root");
    int num = userService.insertUser(u);
    return "成功添加" + num + "条记录";
}

UserService.java、UserMapper.java

public int insertUser(User user);

UserServiceImpl.java

@Override
public int insertUser(User user) {
    return userMapper.insertUser(user);
}

UserMapper.xml

<insert id="insertUser" parameterType="com.laisc.example3.entity.User">
    insert into myuser (username, password, role)
    VALUES (#{username}, #{password}, #{role})
</insert>

运行代码，访问 http://localhost:8001/test/insert ，得到文字：成功添加1条记录。

看这几段：

@ResponseBody
@RequestMapping("/findone")
public String findone() { //仅搜索一条结果，结果多于一条时，会报错
    User u = new User();
    u.setUsername("admin");
    User ret = userService.findOneUser(u);
    return ret.toString();
}

@ResponseBody
@RequestMapping("/findmany")
public String findMany() { //搜索所有符合条件的结果
    User u = new User();
    u.setUsername("admin");
    List<User> ret = userService.findManyUser(u);
    return ret.toString();
}

@ResponseBody
@RequestMapping("/findmany2")
public String findMany2() { // 和 findMany() 方法一样，只是这次在mapper配置文件里的resultType属性上使用了User类
    User u = new User();
    u.setUsername("admin");
    List<User> ret = userService.findManyUser2(u);
    return ret.toString();
}

@ResponseBody
@RequestMapping("/findmany3")
public String findMany3() { // 和 findMany() 方法一样，只是这次ret的类型是List<Map>。
    User u = new User();
    u.setUsername("admin");
    List<Map> ret = userService.findManyUser3(u);
    return ret.toString();
}

@ResponseBody
@RequestMapping("/findmany4")
public String findMany4() { // 和 findMany() 方法一样，只是这次传入的参数的类型是Map，ret的类型也是List<Map>。
    Map<String, String> map = new HashMap<String, String>();
    map.put("username", "admin");

    List<Map> ret = userService.findManyUser4(map);
    return ret.toString();
}

public User findOneUser(User user);//仅搜索一条结果，结果多于一条时，会报错

public List<User> findManyUser(User user);

public List<User> findManyUser2(User user);

public List<Map> findManyUser3(User user);

public List<Map> findManyUser4(Map map);

<resultMap id="myfinduser" type="com.laisc.example3.entity.User">
    <id property="id" column="id"/>
    <result property="username" column="username"/>
    <result property="password" column="password"/>
    <result property="role" column="role"/>
</resultMap>
<select id="findOneUser" resultMap="myfinduser" parameterType="com.laisc.example3.entity.User">
    select myuser.id       id,
           myuser.username username,
           myuser.password password,
           myuser.role     role
    from myuser
    where username = #{username}
</select>

<select id="findManyUser" resultMap="myfinduser" parameterType="com.laisc.example3.entity.User">
    select myuser.id       id,
           myuser.username username,
           myuser.password password,
           myuser.role     role
    from myuser
    where username = #{username}
</select>

<select id="findManyUser2" resultType="com.laisc.example3.entity.User" parameterType="com.laisc.example3.entity.User">
    select myuser.id       id,
           myuser.username username,
           myuser.password password,
           myuser.role     role
    from myuser
    where username = #{username}
</select>

<select id="findManyUser3" resultType="Map" parameterType="com.laisc.example3.entity.User">
    select myuser.id       id,
           myuser.username username,
           myuser.password password,
           myuser.role     role
    from myuser
    where username = #{username}
</select>

<select id="findManyUser4" resultType="Map" parameterType="Map">
    select myuser.id       id,
           myuser.username username,
           myuser.password password,
           myuser.role     role
    from myuser
    where username = #{username}
</select>

此时访问 findmany、findmany2、findmany3、findmany4 分别会返回查询结果。访问 findone会出错，因为符合条件的结果不止一个。

看下面代码：

@ResponseBody
@RequestMapping("/update1")
public String update1() { // 更新数据库
    User u = new User();
    u.setUsername("admin");
    u.setPassword("abcd1234");
    u.setRole("user");
    int num = userService.updateUserPasswordAndRole(u);
    return "成功更新" + num + "条记录";
}

public int updateUserPasswordAndRole(User user);

<update id="updateUserPasswordAndRole" parameterType="com.laisc.example3.entity.User">
    update myuser
    <set>
        myuser.password=#{password},
        myuser.role=#{role}
    </set>
    where username = #{username}
</update>

访问 http://localhost:8001/test/update1 ，将得到下面信息：成功更新2条记录。

看一下数据库，数据库会变成下面这样：

idusernamepasswordrole
adminabcd1234user
adminabcd1234user

看这一段：

@ResponseBody
@RequestMapping("/update2")
public String update2() { // 更新数据库，但是不更新对象u中值为空的数据
    User u = new User();
    u.setUsername("admin");
    //u.setPassword("abcd1234");
    u.setRole("user");
    int num = userService.updateUser(u);
    return "成功更新" + num + "条记录";
}

public int updateUser(User user);

<update id="updateUser" parameterType="com.laisc.example3.entity.User">-- 不更新值为空的数据
    update myuser
    <set>
        <if test="id != null and id != -1 ">id=#{id},</if>
        <if test="password != null and password != '' ">password=#{password},</if>
        <if test="role != null and role != '' ">role=#{role},</if>

    </set>
    where username = #{username}
</update>

访问 http://localhost:8001/test/update2 ，将得到下面信息：成功更新2条记录。

看一下数据库，数据库会变成下面这样：

idusernamepasswordrole
adminabc123user
admin123user

最后看这一段：

@ResponseBody
@RequestMapping("/delete")
public String delete() { // 删除记录
    int num = userService.deleteUser("admin");
    return "成功删除" + num + "条记录";
}

public int deleteUser(String username);

<delete id="deleteUser" parameterType="String">
    delete
    from myuser
    where username = #{username}
</delete>

这一段比较简单，就是删除所有username值为admin的记录。

项目源代码下载：https://pan.baidu.com/s/1w0yKDOJsbOazc27OLM0WUQ?pwd=zvx3

上一篇：SpringBoot使用Thymeleaf：https://laisc7301.github.io/blog/2024/01/04/202401040000SpringBoot%E4%BD%BF%E7%94%A8Thymeleaf/

下一篇：SpringBoot使用MongoDB：https://laisc7301.github.io/blog/2024/01/12/202401120000SpringBoot%E4%BD%BF%E7%94%A8MongoDB/

原文：https://laisc7301.github.io/blog/2024/01/07/202401070000SpringBoot%E4%BD%BF%E7%94%A8MyBatis%E8%BF%9E%E6%8E%A5MySQL/

睿虎
关注
  • 33
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
springboot+mybatis+mysql
11-14
在IT行业中，SpringBoot、MyBatis和MySQL是三个非常重要的技术组件，它们共同构建了高效、稳定的Web应用开发框架。下面将详细讲解这三个技术及其整合应用。 **SpringBoot** SpringBoot是由Pivotal团队提供的全新...
Springboot+MyBatis+mysql+jsp页面跳转详细示例.docx
06-18
在本示例中，我们探讨的是如何使用SpringBoot框架整合MyBatis，连接MySQL数据库，并通过JSP页面展示数据及实现页面跳转。首先，我们需要理解SpringBoot的核心特性，它是一个简化Spring应用初始搭建以及开发过程的...
mysql 基础（三）- springboot项目连接mysql
java19930421的博客
01-18 1429
下一步选择springWeb完成。
SpringBoot整合Mybatis
weixin_62616050的博客
06-05 345
下新建名称相同的xml文件，在本例中就是java.cn.scnu.mapper.UserMapper.java -> resources.cn.scnu.mapper.UserMapper.xml。现在我们并没有指定数据源， SpringBoot 有默认的数据源，我们也可以指定使用 Druid 数据源，按照以下步骤实现。SpringBoot 版本低于2.4.3(不含)且Mysql驱动版本大于8.0时，需要在url连接串中配置时区。若想在已有项目中引入，=则在pom.xml文件中引入以下依赖即可。
springboot使用 mybatis 连接 MySQL
waylonZXH的博客
02-01 212
创建好springboot项目 导入相关的依赖包 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> .
Springboot+Mybatis连接mysql数据库
qq_54867493的博客
11-08 3114
Springboot+Mybatis连接mysql数据库
springboot使用mybatis连接两个mysql
kk12927的博客
01-12 2170
介绍：一个项目里使用mybatis连接两个mysql 1.yml配置 datasource: devicedb: jdbc-url: jdbc:mysql://127.0.0.1:3306/industry_device?serverTimezone=GMT%2B8 username: root password: 123456 driver-class-name: com.mysql.jdbc.Driver userdb: j
SpringBoot+Mybatis连接Mysql数据库常见问题
hauchun的博客
11-18 566
1.通信链路故障 详细错误：com.mysql.cj.jdbc.exceptions.CommunicationsException: Communications link failure 问题原因： 解决办法： 2.未能找到合适的驱动程序类 Description: Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be confi.
SpringBoot结合MyBatis 【超详细】
m0_65563175的博客
10-16 9万+
Spring Boot与MyBatis框架集合实践。内置MyBatis大部分使用技巧，而Spring Boot起到个快速入门的效果。其中MyBatis内容涉及到业务层与数据访问层的传参知识、企业常用的动态SQL拼接、高级映射及延迟加载、以及缓存机制、最后包括PageHelper分页插件
Springboot整合Mybatis连接MySql数据库的基础配置
主要是学习笔记和一些学习心得~
11-28 1435
SpringBoot+Mybatis连接Mysql配置和使用druid的默认配置
SpringBoot集成MyBatis和MySQL
牧小七的博客
08-22 4676
文章目录1. 创建SpringBoot项目2. 添加MyBatis和MySQL依赖3. 添加MyBatis和MySQL配置4. 创建数据库5. 创建UserController类6. 创建User类7. 创建UserService类8. 创建UserMapper接口9. 创建UserMapper.xml文件10. 源码地址 1. 创建SpringBoot项目 创建SpringBoot项目可以在Spring官方网站创建，也可以使用IDE开发工具创建。 2. 添加MyBatis和MySQL依赖 <!--M
springboot整合mybatis（详解）
热门推荐
zhenghuishengq的博客
11-05 11万+
springboot整合mybatis 1，整体结构 2，需要的依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency>
基于SpringBoot+Mybatis+MySQL5.7的音乐网站
04-27
使用Springboot+Mybatis搭建整个系统 使用ajax连接前后端 使用框架Bootstrap、JQuery开发前端界面 使用MySQL存储歌曲链接和图片链接 使用cookies存储用户id等 使用阿里云OSS存储歌曲的大部分mp3文件 主要分为六个...
创建springboot+mybatis+mysql项目的源码
04-30
在本项目中，我们主要探讨的是如何利用SpringBoot、MyBatis和MySQL构建一个完整的Java Web应用程序...通过学习和实践这个项目，开发者可以深入了解SpringBoot、MyBatis和MySQL的结合使用，提升自己的Java Web开发技能。
SpringBoot+Mybatis+mysql
08-17
【SpringBoot+Mybatis+MySQL】是一个常见的Java后端开发框架组合，用于快速构建高效、自动配置的Web应用。这个小DEMO展示了如何整合这三个组件，实现与MySQL数据库的交互。接下来，我们将深入探讨这些技术及其整合...
Spring boot 配置文件
最新发布
2301_79547900的博客
07-25 370
properties使用key=value的形式配置键类型的配置文件，而yml使用的是树形结构来配置yml层级之间使⽤换⾏缩进的⽅式配置，key和value，之间使⽤": "(英⽂冒号)加空格的⽅式设置，并且空格不可省略。properties是早期默认的配置文件格式，其配置存在一定的冗余，使用yml可以很好解决这些问题。yml和properties可以共存，但建议只使用一种，可以降低故障率。
Spring boot 2.0 升级到 3.3.1 的相关问题 （五）
飞一站的博客
07-24 513
解决Spring boot 2.0 升级到3.3.1 版本的druid 配置和Redis配置不生效的问题。
1.Spring Boot 简介(Spring MVC+Mybatis-plus)
m0_61086522的博客
07-23 652
SpringBoot是Spring的子工程(或是spring的脚手架),快速搭建spring项目,自动配置了Spring 应用程序和第三方库（spring+mybaties+web（servlet）+ reids+ 消息中间件）,而且使用很少xml配文件，提高开发效率。一款基于mvc模式、请求驱动、轻量级web框架（封装了Servlet）给予MVC模式请求驱动轻量级web框架封装了Servlet程序。
springboot使用mybatis连接Mysql
06-02
使用Spring Boot连接MySQL数据库，需要先在pom.xml中添加Mybatis和MySQL连接驱动的依赖。示例pom.xml文件如下： ```xml <!-- MyBatis --> <groupId>org.mybatis.spring.boot <artifactId>mybatis-spring-boot...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值