Spring JdbcTemplate 辅助类

最新推荐文章于 2022-05-22 21:15:14 发布
最新推荐文章于 2022-05-22 21:15:14 发布
阅读量1.2k 收藏 1
点赞数 1
分类专栏： Spring Framework 文章标签： spring jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/top_code/article/details/52334169
版权

在日常开发中，我们经常需要访问数据库，从而不可避免需要去跟ResultSet打交道。Spring JdbcTemplate 对原生的JDBC API进行了包装，让程序员更专注于业务逻辑编码，例如查询数据库操作：

public User queryUserById(long id) {

        return jdbcTemplate.queryForObject("SELECT * FROM tb_employee WHERE id=?", new Object[]{id}, new RowMapper<User>() {

            @Override
            public User mapRow(ResultSet rs, int i) throws SQLException {
                User user = new User();
                user.setId(rs.getLong("id"));
                user.setName(rs.getString("name"));
                user.setAge(rs.getInt("age"));
                return user;
            }
        });
    }

我们只需要编写自己的RowMapper将ResultSet 转换为JavaBean即可。

但是这样还是不够简洁，特别是当JavaBean的属性特别多时，实现RowMapper会让人很烦躁。于是乎自己造了一个轮子，它自动将ResultSet 转换为Array、Map、JavaBean等对象。

简化Spring JdbcTemplate

1、IConverter 接口
package com.bytebeats.toolkit.orm;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

public interface IConverter {

    Object[] toArray(ResultSet rs) throws SQLException;

    Map<String, Object> toMap(ResultSet rs) throws SQLException;

    <T> T toBean(ResultSet rs, Class<T> type) throws SQLException;

    <T> List<T> toBeanList(ResultSet rs, Class<T> type) throws SQLException;


}

IConverter 接口定义了将ResultSet 转换为Object[] 、Map、JavaBean、List<JavaBean>行为。

接下来，使用Spring JdbcTemplate 查询数据库就是一件很惬意的事情了。

2、查询数据库

1、User类

package com.bytebeats.toolkit.samples.model;

import com.bytebeats.toolkit.orm.Column;
import java.util.Date;

public class User {
    private long id;
    private String name;
    private int age;
    private double amount;
    @Column("create_time")
    private Date createTime;

    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 int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getAmount() {
        return amount;
    }

    public void setAmount(double amount) {
        this.amount = amount;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
}

2、IUserDao 

package com.bytebeats.toolkit.samples.db.dao;

import com.bytebeats.toolkit.samples.model.User;
import java.util.List;

public interface IUserDao {

    User queryUserById(long id);

    List<User> queryUsers();

    int insert(User user);

}

3、UserDaoImpl类

package com.bytebeats.toolkit.samples.db.dao.impl;

import com.bytebeats.toolkit.orm.IConverter;
import com.bytebeats.toolkit.samples.db.dao.IUserDao;
import com.bytebeats.toolkit.samples.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

@Repository("userDao")
public class UserDaoImpl implements IUserDao {

    @Resource(name = "pkJdbcTemplate")
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private IConverter converter;

    public User queryUserById(long id) {

        return jdbcTemplate.queryForObject("SELECT * FROM tb_employee WHERE id=?", new Object[]{id}, new RowMapper<User>() {

            @Override
            public User mapRow(ResultSet rs, int i) throws SQLException {

                return converter.toBean(rs, User.class);
            }
        });
    }

    public List<User> queryUsers() {

        return jdbcTemplate.query("SELECT * FROM tb_employee", new RowMapper<User>() {

            @Override
            public User mapRow(ResultSet rs, int i) throws SQLException {

                return converter.toBean(rs, User.class);
            }
        });
    }

    public int insert(User user) {
        return 0;
    }
}

一行代码搞定ResultSet 到JavaBean的转换，是不是很easy。

实现原理

原理：

注解+反射技术
通过反射获取到JavaBean的属性列表，通过ResultSetMetaData 获取数据库表的column列表，然后根据列名找到与之相对的属性（名称相同&类型一致）并赋值。JavaBean的属性名可能会与列名不一致，可以通过Column注解指定其对应的列名。

不卖关子了，直接上代码，Talk is cheap, show me the code.

BasicRowConverter
package com.bytebeats.toolkit.orm;

import com.bytebeats.toolkit.annotation.ThreadSafe;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@ThreadSafe
public class BasicRowConverter implements IConverter {

    private final BeanConverter converter = new BeanConverter();

    @Override
    public Object[] toArray(ResultSet rs) throws SQLException {
        ResultSetMetaData meta = rs.getMetaData();
        int cols = meta.getColumnCount();
        Object[] result = new Object[cols];

        for (int i = 0; i < cols; i++) {
            result[i] = rs.getObject(i + 1);
        }

        return result;
    }

    @Override
    public Map<String, Object> toMap(ResultSet rs) throws SQLException {
        Map<String, Object> result = new HashMap<String, Object>();
        ResultSetMetaData rsmd = rs.getMetaData();
        int cols = rsmd.getColumnCount();

        for (int i = 1; i <= cols; i++) {
            String columnName = rsmd.getColumnLabel(i);
            if (null == columnName || 0 == columnName.length()) {
                columnName = rsmd.getColumnName(i);
            }
            result.put(columnName, rs.getObject(i));
        }

        return result;
    }

    @Override
    public <T> T toBean(ResultSet rs, Class<T> type) throws SQLException {

        return this.converter.toBean(rs, type);
    }

    @Override
    public <T> List<T> toBeanList(ResultSet rs, Class<T> type) throws SQLException {

        return this.converter.toBeanList(rs, type);
    }
}

BeanConverter类

package com.bytebeats.toolkit.orm;

import com.bytebeats.toolkit.model.ClassInfo;
import com.bytebeats.toolkit.annotation.ThreadSafe;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.*;
import java.util.concurrent.ExecutionException;

@ThreadSafe
public class BeanConverter {

    protected static final int PROPERTY_NOT_FOUND = -1;

    private static final Map<Class<?>, Object> primitiveDefaults = new HashMap<Class<?>, Object>();

    private final LoadingCache<Class<?>, ClassInfo> columnToPropertyCache = CacheBuilder.newBuilder()
            .maximumSize(200)
            .build(new CacheLoader<Class<?>, ClassInfo>() {
                @Override
                public ClassInfo load(Class<?> cls) throws Exception {

                    ClassInfo classInfo = new ClassInfo();
                    classInfo.setColumnToPropertyOverrides(getColumnToProperty(cls));
                    classInfo.setProps(getPropertyDescriptors(cls));
                    return classInfo;
                }
    });

    static {
        primitiveDefaults.put(Integer.TYPE, Integer.valueOf(0));
        primitiveDefaults.put(Short.TYPE, Short.valueOf((short) 0));
        primitiveDefaults.put(Byte.TYPE, Byte.valueOf((byte) 0));
        primitiveDefaults.put(Float.TYPE, Float.valueOf(0f));
        primitiveDefaults.put(Double.TYPE, Double.valueOf(0d));
        primitiveDefaults.put(Long.TYPE, Long.valueOf(0L));
        primitiveDefaults.put(Boolean.TYPE, Boolean.FALSE);
        primitiveDefaults.put(Character.TYPE, Character.valueOf((char) 0));
    }

    public BeanConverter(){
    }

    public <T> T toBean(ResultSet rs, Class<T> type) throws SQLException {

        ClassInfo classInfo = null;
        try {
            classInfo = columnToPropertyCache.get(type);
        } catch (ExecutionException e) {
            throw new IllegalArgumentException("", e);
        }

        ResultSetMetaData rsmd = rs.getMetaData();
        int[] columnToProperty = this.mapColumnsToProperties(rsmd, classInfo.getProps(), classInfo.getColumnToPropertyOverrides());

        return createBean(rs, type, classInfo.getProps(), columnToProperty);
    }

    public <T> List<T> toBeanList(ResultSet rs, Class<T> type) throws SQLException {

        List<T> results = new ArrayList<T>();

        if (!rs.next()) {
            return results;
        }
        ClassInfo classInfo = null;
        try {
            classInfo = columnToPropertyCache.get(type);
        } catch (ExecutionException e) {
            throw new IllegalArgumentException("", e);
        }

        ResultSetMetaData rsmd = rs.getMetaData();
        int[] columnToProperty = this.mapColumnsToProperties(rsmd, classInfo.getProps(), classInfo.getColumnToPropertyOverrides());

        do {
            results.add(this.createBean(rs, type, classInfo.getProps(), columnToProperty));
        } while (rs.next());

        return results;
    }

    private <T> T createBean(ResultSet rs, Class<T> type,
                         PropertyDescriptor[] props, int[] columnToProperty)
            throws SQLException {

        T bean = this.newInstance(type);
        for (int i = 1; i < columnToProperty.length; i++) {

            if (columnToProperty[i] == PROPERTY_NOT_FOUND) {
                continue;
            }

            PropertyDescriptor prop = props[columnToProperty[i]];
            Class<?> propType = prop.getPropertyType();

            Object value = null;
            if(propType != null) {
                value = this.processColumn(rs, i, propType);

                if (value == null && propType.isPrimitive()) {
                    value = primitiveDefaults.get(propType);
                }

                this.setValueToBean(bean, prop, value);
            }
        }

        return bean;
    }

    private void setValueToBean(Object target, PropertyDescriptor prop, Object value)
            throws SQLException {

        Method setter = prop.getWriteMethod();

        if (setter == null) {
            return;
        }
        Class<?>[] params = setter.getParameterTypes();
        try {
            // convert types for some popular ones
            if (value instanceof java.util.Date) {
                final String targetType = params[0].getName();
                if ("java.sql.Date".equals(targetType)) {
                    value = new java.sql.Date(((java.util.Date) value).getTime());
                } else
                if ("java.sql.Time".equals(targetType)) {
                    value = new java.sql.Time(((java.util.Date) value).getTime());
                } else
                if ("java.sql.Timestamp".equals(targetType)) {
                    Timestamp tsValue = (Timestamp) value;
                    int nanos = tsValue.getNanos();
                    value = new java.sql.Timestamp(tsValue.getTime());
                    ((Timestamp) value).setNanos(nanos);
                }
            }

            // Don't call setter if the value object isn't the right type
            if (this.isCompatibleType(value, params[0])) {
                setter.invoke(target, new Object[]{value});
            } else {
                throw new SQLException(
                        "Cannot set " + prop.getName() + ": incompatible types, cannot convert "
                                + value.getClass().getName() + " to " + params[0].getName());
            }

        } catch (IllegalArgumentException e) {
            throw new SQLException(
                    "Cannot set " + prop.getName() + ": " + e.getMessage());

        } catch (IllegalAccessException e) {
            throw new SQLException(
                    "Cannot set " + prop.getName() + ": " + e.getMessage());

        } catch (InvocationTargetException e) {
            throw new SQLException(
                    "Cannot set " + prop.getName() + ": " + e.getMessage());
        }

    }

    private boolean isCompatibleType(Object value, Class<?> type) {
        // Do object check first, then primitives
        if (value == null || type.isInstance(value)) {
            return true;

        } else if (type.equals(Integer.TYPE) && value instanceof Integer) {
            return true;

        } else if (type.equals(Long.TYPE) && value instanceof Long) {
            return true;

        } else if (type.equals(Double.TYPE) && value instanceof Double) {
            return true;

        } else if (type.equals(Float.TYPE) && value instanceof Float) {
            return true;

        } else if (type.equals(Short.TYPE) && value instanceof Short) {
            return true;

        } else if (type.equals(Byte.TYPE) && value instanceof Byte) {
            return true;

        } else if (type.equals(Character.TYPE) && value instanceof Character) {
            return true;

        } else if (type.equals(Boolean.TYPE) && value instanceof Boolean) {
            return true;

        }

        return false;
    }

    protected int[] mapColumnsToProperties(ResultSetMetaData rsmd,
                                           PropertyDescriptor[] props,
                                           Map<String, String> columnToPropertyOverrides) throws SQLException {

        int cols = rsmd.getColumnCount();
        int[] columnToProperty = new int[cols + 1];
        Arrays.fill(columnToProperty, PROPERTY_NOT_FOUND);

        for (int col = 1; col <= cols; col++) {
            String columnName = rsmd.getColumnLabel(col);
            if (null == columnName || 0 == columnName.length()) {
                columnName = rsmd.getColumnName(col);
            }
            String propertyName = columnToPropertyOverrides.get(columnName);
            if (propertyName == null) {
                propertyName = columnName;
            }
            for (int i = 0; i < props.length; i++) {

                if (propertyName.equalsIgnoreCase(props[i].getName())) {
                    columnToProperty[col] = i;
                    break;
                }
            }
        }

        return columnToProperty;
    }

    private PropertyDescriptor[] getPropertyDescriptors(Class<?> c)
            throws SQLException {
        BeanInfo beanInfo = null;
        try {
            beanInfo = Introspector.getBeanInfo(c);

        } catch (IntrospectionException e) {
            throw new SQLException(
                    "Bean introspection failed: " + e.getMessage());
        }

        return beanInfo.getPropertyDescriptors();
    }

    protected <T> T newInstance(Class<T> c) throws SQLException {
        try {
            return c.newInstance();

        } catch (InstantiationException e) {
            throw new SQLException(
                    "Cannot create " + c.getName() + ": " + e.getMessage());

        } catch (IllegalAccessException e) {
            throw new SQLException(
                    "Cannot create " + c.getName() + ": " + e.getMessage());
        }
    }

    protected Object processColumn(ResultSet rs, int index, Class<?> propType)
            throws SQLException {

        if ( !propType.isPrimitive() && rs.getObject(index) == null ) {
            return null;
        }

        if (propType.equals(String.class)) {
            return rs.getString(index);

        } else if (
                propType.equals(Integer.TYPE) || propType.equals(Integer.class)) {
            return Integer.valueOf(rs.getInt(index));

        } else if (
                propType.equals(Boolean.TYPE) || propType.equals(Boolean.class)) {
            return Boolean.valueOf(rs.getBoolean(index));

        } else if (propType.equals(Long.TYPE) || propType.equals(Long.class)) {
            return Long.valueOf(rs.getLong(index));

        } else if (
                propType.equals(Double.TYPE) || propType.equals(Double.class)) {
            return Double.valueOf(rs.getDouble(index));

        } else if (
                propType.equals(Float.TYPE) || propType.equals(Float.class)) {
            return Float.valueOf(rs.getFloat(index));

        } else if (
                propType.equals(Short.TYPE) || propType.equals(Short.class)) {
            return Short.valueOf(rs.getShort(index));

        } else if (propType.equals(Byte.TYPE) || propType.equals(Byte.class)) {
            return Byte.valueOf(rs.getByte(index));

        } else if (propType.equals(Timestamp.class)) {
            return rs.getTimestamp(index);

        } else {
            return rs.getObject(index);
        }

    }

    private Map<String,String> getColumnToProperty(Class<?> type) {

        Map<String, String> columnToPropertyMap = new HashMap<String, String>();
        Field[] fields = type.getDeclaredFields();
        for (Field field : fields){

            String columnName = null;
            if(field.isAnnotationPresent(Column.class)){
                Column col = field.getAnnotation(Column.class);
                if(col!=null){
                    columnName = col.value();
                }
            }
            if(columnName==null || "".equals(columnName)){
                columnName = field.getName();
            }

            columnToPropertyMap.put(columnName, field.getName());
        }

        return columnToPropertyMap;
    }

}

ClassInfo 类

package com.bytebeats.toolkit.model;

import java.beans.PropertyDescriptor;
import java.util.Map;

public class ClassInfo {
    private Map<String, String> columnToPropertyOverrides;
    private PropertyDescriptor[] props;

    public Map<String, String> getColumnToPropertyOverrides() {
        return columnToPropertyOverrides;
    }

    public void setColumnToPropertyOverrides(Map<String, String> columnToPropertyOverrides) {
        this.columnToPropertyOverrides = columnToPropertyOverrides;
    }

    public PropertyDescriptor[] getProps() {
        return props;
    }

    public void setProps(PropertyDescriptor[] props) {
        this.props = props;
    }
}

Column 注解

package com.bytebeats.toolkit.orm;

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@Documented
public @interface Column {

    String value() default "";
}
SpringBoot中封装jdbc工具类
04-08
现在的数据层的开发，大多会使用如MyBatis或JPA之类的开发工具。这些开发工具给我们的开发过程中带来了极大的便利。 但是在一些极端的场景下往往原生的jdbc方式操作数据库更灵活，性能更高。由于部分场景下MyBatis或JPA之类无法满足我的需求，所以我打算自己封装一套查数据库的工具类。 文章地址： https://blog.csdn.net/lxyoucan/article/details/124042295
Spring JdbcTemplate 常用方法整理
04-24
Spring的JdbcTemplate是Spring框架中用于简化数据库操作的工具类，它是基于JDBC但又抽象出了一层，避免了直接与数据库驱动API交互，从而提高了代码的可读性和可维护性。本文将深入探讨Spring JdbcTemplate的常用方法...
Spring中jdbc工具类
qq_36943809的博客
12-11 433
import Day01.Text03.Student; import Day02.Text02.My_JdbcUtils; import org.junit.jupiter.api.Test; import org.springframework.jdbc.core.BeanPropertyRowMapper; import org.springframework.jdbc.core.JdbcT...
JDBC getParameterType call failed - using fallback method instead
qq_31499975的博客
12-30 3110
更多日志 [main] TRACE o.springframework.jdbc.core.StatementCreatorUtils - Setting SQL statement parameter value: column index 4, parameter value [null], value class [null], SQL type unknown [main] DEBUG o.springframework.jdbc.core.StatementCreatorUtils - J
从0开始学JAVA【3】
Manonll的博客
05-22 692
线程ThreadRunnableCallable && Future第2关：使用 Callable 和 Future 创建线程 新建状态: 使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。 就绪状态: 当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。 运行状态: 如果就绪状态的线程获取 CPU 资源，就可以执行 ru
JDBC 3.0 getParameterType call not supported
Jack魏
12-01 913
报错提示 DEBUG o.s.jdbc.core.StatementCreatorUtils - JDBC 3.0 getParameterType call not supported java.sql.SQLException: Parameter metadata not available for the given statement 解决方案 这里只需要添加generateSimpleParameterMetadata=true 即可 jdbc.url=jdbc\:mysql\://12
Spring JdbcTemplate辅助工具：简化数据库操作
基于Spring JdbcTemplate的JDBC帮助包是一个Java开发中的对象关系映射（ORM）框架，旨在简化Java应用程序中与关系型数据库交互的过程。在深入分析这个帮助包之前，首先需要了解几个关键技术点。 ### Spring ...
Spring JdbcTemplate详解与事务管理
JdbcTemplate 包含在 Spring 的核心、数据源、对象和支持四个不同包中，提供了一系列的类和接口来支持数据库交互。在 org.springframework.jdbc.core 包中，定义了关键类如 SQLExceptionTranslator 和 ...
一个简单的spring-jdbctemplate扩展
03-12
"util"目录可能包含了一些工具类，例如数据库连接池管理、SQL语句构建辅助类等。这些工具类可以帮助优化数据库操作，比如通过连接池提高数据库连接的效率，或者提供更安全、可维护的SQL构建方式，避免硬编码SQL字符...
Spring JdbcTemplate示例：获取记录与依赖注入实践
5. **辅助工具**：Spring库中的类，如`JdbcTemplate`，可以帮助开发者快速操作数据库，提高开发效率。 6. **框架集成**：Spring与许多主流应用框架如Hibernate的集成，进一步简化了开发流程。 本文展示了如何在...
一个灵活轻量级的基于SpringjdbcTemplate的ORM
08-07
这是一个基于 Spring JdbcTemplate 的小工具，帮助开发者简单地完成 Mysql 的增删改查。 使用 nimble-orm 的优势 为互联网频繁的表变动而生。 表名、字段名
HttpClient 4.5 Best Practice
Ricky
08-22 3305
最近在封装http请求相关的library，希望接口的行为和实现分离，这样底层library再切换不同http请求实现 例如：Apache HttpClient、OkHttp、AsyncHttpClient 等不影响上层调用行为。介绍HttpClient 4.5 Tutorial主要分为：基础（Fundamentals）、连接管理（Connection management）、http状态管理（HT
AsyncHttpClient Best Practice
Ricky
08-27 2735
AsyncHttpClient是一款开源的Java异步Http和WebSocket 客户端官方原文 Asynchronous Http and WebSocket Client library for Java Async Http Client library purpose is to allow Java applications to easily execute HTTP req
OkHttp 3.x Best Practice
Ricky
08-27 2188
OkHttp 是square开源的一款优秀HTTP+HTTP/2客户端，它适用于Android和Java平台。官方介绍： An HTTP+HTTP/2 client for Android and Java applications. http://square.github.io/okhttp/ API示例1、get请求OkHttpClient client = new OkHttpClien
com.google.common.cache.CacheLoader原因分析
nuistcc的专栏
11-28 5173
问题描述         今天在使用guava cache的时候，报了如下错误：     com.google.common.cache.CacheLoader$InvalidCacheLoadException: CacheLoader returned null for key 50816009. at com.google.common.cache.LocalC...
Spring 之 ORM (JdbcTemplate)
u010085393的博客
01-29 2453
JdbcTemplate 简介                  spring 提供了不同持久层的技术的支持! ORM持久化技术  主要包含: JDBC,Hibernate,IBatis(MyBatis),JPA        对应的模板类如下:           ①JDBC               org.springframework.jdbc.core.JdbcTemplate
【freemarker】NoClassDefFoundError: freemarker/cache/TemplateLoader
anyway, life must全力以赴
04-09 3610
【问题背景】:【maven仓库没有freeMarkerjar包。Idea POM.xml添加坐标后。自动下载jar包。】启动后总是报错：类似freeMarker下：“NoClassDefFoundError”。解决：【必须： 向lib文件夹中复制“freemarker-2.3.19.jar”包】操作：...
关于在Spring4 jdbctemplate 遇到的一些基本问题总结
xiaosi1202的专栏
08-16 910
1.org.springframework.http.converter.json.MappingJacksonHttpMessageConverter找不到Class       ①  json包是否导入 ② Spring4 将MappingJacksonHttpMessageConverter修改为：MappingJackson2HttpMessageConverter 2 调用到serv
SpringMVC集成Hibernate Validator进行注解式的参数校验——让代码更少、更加专注于业务逻辑
热门推荐
lhever_的博客
02-25 1万+
SpringMVC集成Hibernate Validator进行注解式的参数校验 ——让代码更少、更加专注于业务逻辑 1 问题背景：参数验证是一个常见的问题，例如验证用户输入的密码是否为空、邮箱是否合法等。但是无论是前端还是后台，都需对用户输入进行验证，以此来保证系统数据的正确性。对于web
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值