mysql动态查询

最新推荐文章于 2024-05-17 14:37:10 发布
最新推荐文章于 2024-05-17 14:37:10 发布
阅读量1k 收藏
点赞数
文章标签： mysql mybatis 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43634655/article/details/125946052
版权

mysql动态查询

mapper接口文件：

package qin.com.mapper;/*
 *@program:learn_mybatis
 *@author: 小虎
 *@Time: 2022/7/22  20:36
 *@description:
 *@version 1.0.0
 */

import org.apache.ibatis.annotations.Param;
import qin.com.entity.Users;

import javax.swing.event.ListDataEvent;
import java.util.Date;
import java.util.List;

public interface UsersMapper {
    public List<Users> getAll();

    int update(Users users);

    Users getUsersById(int id);

    //模糊查询
    Users getNameLike(String userName);

    //优化后的模糊查询
    List<Users> getByNameGood(String name);

    int addUsers(Users users);

    int deleteUserById(int id);

    //模糊用户名和地址
    List<Users> getByNameAndAddress(@Param("columnName") String columnName,@Param("columnValue") String columnValue);



    //按照指定条件进行多条件查询
    List<Users> selectUserByCondition(Users users);

    //有选择的更新
    int updateBySet(Users users);

    //查询多个指定id用户的信息  批量查询指定id的用户信息
    List<Users> getByIds(Integer []arr);

    //批量删除
    int delByIds(Integer []arr);

    //批量增加
    int addByIds(List<Users> users);

    //批量更新
    int updateByIds(List<Users> users);

    //多id查询
    List<Users> selectByIDS(Integer []arr);

    int addUserList(List<Users> users);

    //查询指定日期范围内的信息
    List<Users> getByBirthday(Date begin,Date end);

}

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="qin.com.mapper.UsersMapper"> <!-- 一般为数据表在持久层对应接口的完整路径 -->
    <resultMap id="userBean" type="qin.com.entity.Users">     <!-- 一般为数据表对应实体类所在数据包 -->
        <id property="id" column="id"></id>
        <result property="userName" column="userName"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>
    </resultMap>

    <!--定义SQL代码片段-->
    <sql id="allColumns">
        id,username,birthday,sex,address
    </sql>
    <!-- 查询数据表中所有数据,这相标签的id值要与数据表对应接口中的查询方法的名称要一样 -->
    <select id="getAll" resultType="qin.com.entity.Users">
        select <include refid="allColumns"/>
        from users
    </select>

  <!--  private int id;
    private String userName;
    private Date birth;
    private String sex;
    private String address;
    #{}写的是实体类的属性名，注意大小写
    -->
    <update id="update" parameterType="Users">
        update users set username=#{userName},birthday=#{birthday},sex=#{sex},address=#{address}
        where id=#{id}
    </update>

    <select id="getUsersById" resultType="qin.com.entity.Users">
        select * from users where id=#{id}
    </select>



    <insert id="addUsers" parameterType="Users">
        <selectKey keyProperty="id" resultType="int" order="AFTER">
            select last_insert_id()
        </selectKey>

        insert into users(username, birthday, sex, address)
        values(#{userName},#{birthday},#{sex},#{address})
    </insert>

    <delete id="deleteUserById" parameterType="int">
        delete from users where id=#{id}
    </delete>


    <select id="getNameLike" resultType="qin.com.entity.Users">
        select * from users where username like '%${userName}%'
    </select>
   <!-- //优化后的模糊查询-->
    <select id="getByNameGood" parameterType="string" resultType="qin.com.entity.Users">
        select <include refid="allColumns"/>
        from users where username like concat('%',#{name},'%')
    </select>


    <!--//模糊用户名和地址
    如果参数超过一个，则parameterType不写
    List<Users> getByNameAndAddress(String colum,String columValue);-->
    <select id="getByNameAndAddress" resultType="qin.com.entity.Users">
        select <include refid="allColumns"/>
        from users
        where ${columnName} like concat('%',#{columnValue},'%')
    </select>

    <!--
    //有选择的更新
    int updateBySet(Users users);-->
    <update id="updateBySet" parameterType="Users">
        update users
        <set>
            <if test="userName != null and userName != ''">
                userName = #{userName},
            </if>
            <if test="birthday != null">
                brithday =#{brithday},
            </if>
            <if test="sex != null and sex != ''">
                sex = #{sex},
            </if>
            <if test="address != null and address != ''">
                address #{address},
            </if>
        </set>
        where id = #{id}
    </update>


    <!-- //按照指定条件进行多条件查询
             根据实体类中的成员变量是否有值来决定是否添加条件
     List<Users> getByCondition(Users users);-->



    <select id="selectUserByCondition" resultType="Users" parameterType="Users">
        select <include refid="allColumns"></include>
        from users
        <where>
            <if test="userName != null and userName != ''" >
                and username like concat('%',#{userName},'%')
            </if>
            <if test="birthday != null" >
                and birthday = #{birthday}
            </if>
            <if test="sex != null and sex != ''" >
                and sex = #{sex}
            </if>
            <if test="address != null and address != ''" >
                and address like concat('%',#{address},'%')
            </if>
        </where>
    </select>





    <!-- //批量删除
     List<Users> delByIds(Integer []arr);-->
    <delete id="delByIds">
        delete from users
        where id in
        <foreach collection="array" item="id" separator="," open="(" close=")">
            #{id}
        </foreach>
    </delete>
    <!-- //批量增加
     int addByIds(List<Users> users);-->
    <insert id="addByIds">
        insert into  users(username, birthday, sex, address)
        values
        <foreach collection="list" item="user" separator=",">
            (#{user.userName},#{user.birthday},#{user.sex},#{user.address})
        </foreach>
    </insert>
    <!--
        //批量更新
        int updateByIds(List<Users> users);-->

    <update id="updateByIds">
        <foreach collection="list" item="user" separator=";">
            update users
            <set>
                <if test="user.userName != null and user.userName != ''">
                    username = #{user.userName},
                </if>
                <if test="user.birthday != null">
                    birthday = #{user.birthday},
                </if>
                <if test="user.sex != null and user.sex != ''">
                    sex = #{user.sex},
                </if>
                <if test="user.address != null and user.address != ''">
                    address = #{user.address}
                </if>
            </set>
            where id = #{user.id}
        </foreach>
    </update>

    <!--
       //查询多个指定id用户的信息
       List<Users> getByIds(Integer []arr);
       -->

    <select id="getByIds" resultType="qin.com.entity.Users">
        select <include refid="allColumns"></include>
        from users
        where id in
        <!-- (
         <foreach collection="array" item="id" separator=",">
             #{id}
         </foreach>
         )-->

        <foreach collection="array" item="id" separator="," open="(" close=")">
            #{id}
        </foreach>

    </select>
<!--
    //多id查询
    List<Users> selectByIDS(Integer[] arr);-->
    <select id="selectByIDS" resultType="qin.com.entity.Users">
        select <include refid="allColumns"></include>
        from users
        where id in
        <foreach collection="array" item="id" separator="," open="(" close=")" >
            #{id}
        </foreach>
    </select>


    <!--  //批量添加
      int addUserList(List<Users> users);-->
    <insert id="addUserList">
        insert into users(username, birthday, sex, address) values
        <foreach collection="list" item="user" separator=",">
            (#{user.userName},#{user.birthday},#{user.sex},#{user.address})
        </foreach>
    </insert>



    <!--//查询指定日期范围内的信息
    List<Users> getByBirthday(Date begin,Date end);
                       对应between #{arg0} in #{arg1}
    -->
    <select id="getByBirthday" resultType="qin.com.entity.Users">
        select <include refid="allColumns"></include>
        from users
        where birthday between #{arg0} and #{arg1}
    </select>


</mapper>

mybatis-config.xml

<?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>

    <!--读取jdbc.properties属性文件-->
  <!--  <properties resource="db.properties"></properties>-->
    <!--控制台打印sql输出语句-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <typeAliases>
        <package name="qin.com.entity"></package>
    </typeAliases>
    <!--配置数据库环境变量
        default值：使用environment的id属性名
    -->
    <environments default="mysql">
        <!--配置数据库连接环境-->
        <!--开发时的环境配置-->
        <environment id="mysql">
            <!--配置事务管理器
                type:指定事务管理的方式
                    JDBC:事务的控制交给程序员处理
                    MANAGED:由容器(Spring)来管理事务
            -->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源：driver、url、username、password
                type:指定不同的配置方式
                    JNDI :java命名目录接口，在服务器端进行数据库连接池的管理POOLED:使用数据库连接池
                    UNPOLLED:不使用数据库连接池 -->
            <dataSource type="POOLED">
                <!-- 连接mysql数据库的驱动程序 -->
                <property name="driver" value="com.mysql.jdbc.Driver"></property>
                <!-- 连接mysql数据库的地址 -->
                <property name="url" value="jdbc:mysql://localhost/mybatis"></property>
                <!-- 连接mysql数据库的管理员 -->
                <property name="username" value="root"></property>
                <!-- 连接mysql数据库的管理员的密码 -->
                <property name="password" value="root"></property>
            </dataSource>
        </environment>
        <!--在家时的环境配置-->
        <!--<environment id="home">
            <transactionManager type="JDBC"></transactionManager>
            &lt;!&ndash;数据源：driver、url、username、password&ndash;&gt;
            <dataSource type="POOLED">
                &lt;!&ndash; 连接mysql数据库的驱动程序 &ndash;&gt;
                <property name="driver" value="com.mysql.jdbc.Driver"></property>
                &lt;!&ndash; 连接mysql数据库的地址 &ndash;&gt;
                <property name="url" value="jdbc:mysql://localhost/dataName"></property>
                &lt;!&ndash; 连接mysql数据库的管理员 &ndash;&gt;
                <property name="username" value="root"></property>
                &lt;!&ndash; 连接mysql数据库的管理员的密码 &ndash;&gt;
                <property name="password" value="root"></property>
            </dataSource>
        </environment>-->
        <!--上线后的环境配置-->
      <!--  <environment id="online">
            <transactionManager type="JDBC"></transactionManager>
            &lt;!&ndash;数据源：driver、url、username、password&ndash;&gt;
            <dataSource type="POOLED">
                &lt;!&ndash; 连接mysql数据库的驱动程序 &ndash;&gt;
                <property name="driver" value="com.mysql.jdbc.Driver"></property>
                &lt;!&ndash; 连接mysql数据库的地址 &ndash;&gt;
                <property name="url" value="jdbc:mysql://localhost/demo"></property>
                &lt;!&ndash; 连接mysql数据库的管理员 &ndash;&gt;
                <property name="username" value="root"></property>
                &lt;!&ndash; 连接mysql数据库的管理员的密码 &ndash;&gt;
                <property name="password" value="root"></property>
            </dataSource>
        </environment>-->
    </environments>
    <!--注册mapper文件配置-->
    <!--注册mapper.xml文件
        resource: 从resources目录下找指定名称的文件注册url:使用绝对路径注册
        class:动态代理方式下的注册-->
    <mappers>
        <!--
            注册单个mapper.xml文件
        <mapper class="qin.com.mapper.UsersMapper"></mapper>
        -->
        <!--注册批量mapper.xml-->
        <package name="qin.com.mapper"/>
    </mappers>

</configuration>

Test测试类

package qin.com.service;/*
 *@program:learn_mybatis
 *@author: 小虎
 *@Time: 2022/7/22  18:19
 *@description:
 *@version 1.0.0
 */

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 org.junit.After;
import org.junit.Before;
import org.junit.Test;

import qin.com.entity.Users;
import qin.com.mapper.UsersMapper;

import java.io.IOException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;

public class MyTest {
    //日期格式化刷子
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");





    SqlSession sqlSession;
    UsersMapper usersMapper;
    @Before
    public void openSqlSession() throws IOException {
        //读取核心配置文件
       InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
       //创建会话工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //取出SQLSession
        sqlSession = sqlSessionFactory.openSession();

        usersMapper = sqlSession.getMapper(UsersMapper.class);
    }

    @After
    public void closeSqlsSession(){
        //关闭Sqlsession
        sqlSession.close ();
    }
    @Test
    public void testgetAll() throws IOException {

        //取出动态代理的对象完成接口中的方法的调用实则是调用xml文件中相应的标签的功能

        System.out.println(usersMapper.getClass());

        List<Users> usersList = usersMapper.getAll();




    }
    @Test
    public void testUpdate() throws ParseException {
        Users users = new Users(31,"大白奶子", sdf.parse("2022-12-20"), "2", "美国");
        int count = usersMapper.update(users);
        System.out.println(count);
        sqlSession.commit();
    }

    @Test
    public void testgetUsersById(){

        Users usersById = usersMapper.getUsersById(2);
        usersById.toString();
    }

    @Test
    public void testgetNameLike(){
        Users nameLike = usersMapper.getNameLike("虎");
        nameLike.toString();
    }


    @Test
    public void testAddUser() throws ParseException {
        Users users = new Users("大屁股大白奶子", sdf.parse("2022-02-02"), "2", "日本");
        int i = usersMapper.addUsers(users);
        System.out.println(i);
        sqlSession.commit();
        System.out.println(users);
    }

    @Test
    public void testdeleteUserById(){
        int i = usersMapper.deleteUserById(33);
        System.out.println(i);
        sqlSession.commit();
    }

    @Test
    public void testgetByNameGood(){
        List<Users> nameLike = usersMapper.getByNameGood("虎");
        for(Users users:nameLike){
            System.out.println(users);
        }
    }

    @Test
    public void testgetByNameAndAddress(){
        List<Users> nameLike = usersMapper.getByNameAndAddress("address","市");
        for(Users users:nameLike){
            System.out.println(users);
        }
    }



    @Test
    public void testUUID(){
        UUID uuid = UUID.randomUUID();
        System.out.println(uuid);
    }

    @Test
    public void testUpdateByCondition(){
        Users users = new Users();
        users.setId(35);
        users.setUserName("小奶子");
        int num = usersMapper.updateBySet(users);
        System.out.println(num);
        sqlSession.commit();
    }

    /*<!--
    //多id查询
    List<Users> selectByIDS(Integer[] arr);-->*/
    @Test
    public void testSelectByIDS(){
        Integer[] array = {1,3,5,31,32,36};
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
        List<Users> list = usersMapper.selectByIDS(array);
        list.forEach(users -> System.out.println(users));

    }

    @Test
    public void testaddUserList() throws ParseException {
        Users users1 = new Users("翘臀大美女1",sdf.parse("2022-02-02"),"2","日本1");
        Users users2 = new Users("翘臀大美女2",sdf.parse("2022-02-02"),"2","日本2");
        Users users3 = new Users("翘臀大美女3",sdf.parse("2022-02-02"),"2","日本3");
        Users users4 = new Users("翘臀大美女4",sdf.parse("2022-02-02"),"2","日本4");
List list = new ArrayList();
list.add(users1);
list.add(users2);
list.add(users3);
list.add(users4);
        int i = usersMapper.addUserList(list);
        System.out.println(i);
        sqlSession.commit();
    }
   /*
    <!--//查询指定日期范围内的信息
    List<Users> getByBirthday(Date begin,Date end);
    对应between #{arg0} in #{arg1}*/
    @Test
    public void testgetBirthday() throws ParseException {
        Date begin = sdf.parse("2018-02-02");
        Date end = sdf.parse("2021-08-08");
        List<Users> byBirthday = usersMapper.getByBirthday(begin, end);
        byBirthday.forEach(users -> System.out.println(users));
        
    }
}
MO慕雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MySQL子查询
01-08
分类： 多表关联或者表内字段关联时，或做相似功能判断时，往往会使用子查询来...每一行的行记录,而这种迭代中产生的值都是动态生成的. 结论: 性能排序/优先使用 关联/分组查询>无关子查询>相关子查询 找出各个部门中大
【mysql系列】动态sql语句
檀越的博客
11-18 5404
动态 SQL 是指在运行时动态生成 SQL 语句，它可以根据不同的条件和参数生成不同的 SQL 语句，从而实现灵活性和可重用性。在许多编程语言中，动态 SQL 可以使用字符串拼接或参数化查询的方式来实现。使用字符串拼接的方法，可以通过在字符串中插入变量或条件语句，来动态构建 SQL 语句。搜索和过滤：动态 SQL 可以根据用户的搜索条件和过滤条件生成不同的 SQL 查询语句，从而实现灵活的搜索和过滤功能。
mysql动态获取列
乔木晨子的博客
06-07 1997
1.主要是使用case when 的写法需要将所有情况都考虑进来，但是有些情况下你不知道所有情况有哪些，即情况是不定的。 2.先来sql结果 SET @EE=''; SELECT @EE:=CONCAT(@EE,'SUM(IF(type_string=\'',type_string,'\'',',amount_int,0)) AS ',type_string,',') FROM (SELECT DISTINCT type_string FROM test) A; SET @
动态查询：将mybatis查询sql存在数据库里，执行查询时调用
as18214965543的博客
02-28 778
题主经手一个中台系统，大部分需求为查询数据，发版频繁。因为公司使用k8s，一个服务从提交代码到maven docker k8s发版一个工作流下来，至少要十来分钟，效率十分低下。因为多数为查询需求，经常就是写好sql后还得从requestDto controller service mapper responseDto 写一遍，非常浪费时间。
MySQL行专列----动态列
qq_37196265的博客
07-13 1442
SET @EE=‘’;/**将CONCAT()拼接后的SQL片段赋值给变量@EE。:= 对变量进行赋值concat() 拼接字符串函数sum() 求和函数IF(condition, value_if_true, value_if_false) 如果条件为 TRUE，IF() 函数返回一个值，如果条件为 FALSE，则返回另一个值。sum(if()) : 如果subject = subject, 则取对应的score， 否则取0进行求和，并取别名为subject字段对应的值。
mysql实现动态查询表字段（返回JSON格式）
weixin_42827269的博客
09-11 1654
-- 准备测试配置表 DROP TABLE IF EXISTS `field_config`; CREATE TABLE `field_config` ( `text` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL ) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORM..
mysql动态查列(case when then else end)
一起coding，一起嗨。
05-19 1036
根据数据库字段的值，动态查询列
动态MySQL及连表查询
lpt1314的博客
06-05 641
目录1.动态MySQL1.1set标签1.2foreach标签2.mybatis映射文件处理特殊字符3.mybatis模糊查询3.1使用字符串函数拼接4.连表查询set标签一般配合if标签使用于修改语句，如果传递的参数为null，那么不会修改该列的值 1.2foreach标签 根据id查询 删除 添加 2.mybatis映射文件处理特殊字符 3.mybatis模糊查询 select * from 表明 where 列明 like ...
MySql动态行转列和查询表字段信息及备注
LETIAN_Z的博客
08-05 775
MySql动态行转列函数和查询表字段信息和备注sql使用
MYSQL_querytest:与MYSQL中的静态查询，动态查询和过程调用进行性能比较
05-02
在MySQL中使用静态查询，动态查询和过程调用进行性能比较（语言：Java） 概念 使用MYSQL中的静态查询，动态查询和过程调用测试每个查询和性能比较 静态查询 动态查询 带参数绑定的动态查询 程序调用 测试方法 测试...
mysql 如何动态修改复制过滤器
12-14
MySQL动态修改复制过滤器  说说今天遇到的问题吧，今天在处理一个业务方的需求，比较变态，我大概描述一下： 1、线上的阿里云rds上面有个游戏的日志库，里面的表都是日表的形式，数据量比较大了，每次备份的时候，...
MySQL 存储过程中执行动态SQL语句的方法
12-15
drop PROCEDURE if exists my_procedure; create PROCEDURE my_procedure() BEGIN declare my_sqll varchar(500);... 您可能感兴趣的文章:mysql 存储过程中变量的定义与赋值操作mysql存储过程详解mysq
mysql存储过程 在动态SQL内获取返回值的方法详解
09-10
本篇文章是对mysql存储过程在动态SQL内获取返回值进行了详细的分析介绍，需要的朋友参考下
mysql实现动态查询_mysql 实现动态查询
weixin_42524276的博客
01-28 1883
从MySQL 5.0 开始，支持了一个全新的SQL句法：PREPARE stmt_name FROM preparable_stmt;EXECUTE stmt_name [USING @var_name [, @var_name] ...];{DEALLOCATE | DROP} PREPARE stmt_name;通过它，我们就可以实现类似 MS SQL 的 sp_executesql 执行动态...
mysql如何动态查询_Mysql动态查询
weixin_35853363的博客
02-03 1300
if条件查询格式: 添加到sql的语句where标签简化SQL语句中WHERE条件判断智能处理and和or如果使用几个if条件标签,如果第一个条件不成立,那么该sql语句就不成立了.把所有的if条件语句加入到where标签内,则会根据if语句成立是否添加where条件,若标签返回的内容是以and或者or开头的,会自动剔除.案例:"getUserListByClassify" resultMap="...
mysql根据字段值动态查询多个表
qq_42926722的博客
10-10 746
mysql根据字段值动态查询多个表
mysql 动态查询表_使用动态表的MySQL列子查询
weixin_35886058的博客
01-20 725
我试图从相关表中提取信息，具体取决于某列中存在的信息 . 在这种情况下，它的列 Page . type 并且理想情况下我喜欢用字符串创建表名然后查询该表的CONCAT .有没有办法做这样的子查询？也许我需要将此子查询嵌套为LEFT JOIN .或者，这种类型的动态行为只能作为存储过程完成吗？关键是我们有各种类型的元数据与我们的SiteManagerPage相关联 . 这种数据在类型和列结构方...
MySQL动态查询
郝啊的博客
03-29 2205
MySQL动态查询 代码结合Mybatis框架一起使用，再次提醒。 if条件查询 格式：<if test="条件判断">sql语句</if> where标签 简化SQL语句中WHERE条件判断 智能处理and和or 如果使用几个if条件标签,如果第一个条件不成立,那么该sql语句就不成立了. 把所有的if条件语句加入到where标签内,则会根据if语句成立是否添...
MYSQL 视图/存储过程/触发器详解
最新发布
lIujunXHU的博客
05-17 1114
视图（View）是一种虚拟存在的表。视图中的数据并不在数据库中实际存在，行和列数据来自定义视图的查询中使用的表，并且是在使用视图时动态生成的，视图的主要目的是简化复杂的SQL查询，提高数据访问的安全性，以及隐藏数据的复杂性。。通俗的讲，视图只保存了查询的SQL逻辑，不保存查询结果。所以在创建视图的时候，主要的工作就在于创建这条SQL查询语句上。存储过程是事先经过编译并存储在数据库中。
mysql 动态查询上一年同一个月数据
03-26
```mysql SELECT * FROM mytable WHERE MONTH(date_column) = MONTH(DATE_SUB(NOW(), INTERVAL 1 YEAR)) AND YEAR(date_column) = YEAR(DATE_SUB(NOW(), INTERVAL 1 YEAR)); ``` 其中，`date_column`为需要查询的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值