SpringBoot单数据源配置（一）

最新推荐文章于 2024-03-15 09:50:20 发布
最新推荐文章于 2024-03-15 09:50:20 发布
阅读量953 收藏 2
点赞数
分类专栏： spring全家桶学习记录 文章标签： SpringBoot单数据源配置，Spring数据源配置，数据源配置
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38277366/article/details/88418015
版权

SpringBoot单数据源配置（一）

一、默认数据源

1、类型
Springboot默认支持4种数据源类型，定义在 org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration 中，分别是：

数据源类型包
jdbcorg.apache.tomcat.jdbc.pool.DataSource
hikaricom.zaxxer.hikari.HikariDataSource
dbcporg.apache.commons.dbcp.BasicDataSource
dbcp2org.apache.commons.dbcp2.BasicDataSource

对于这4种数据源，当 classpath 下有相应的类存在时，Springboot 会通过自动配置为其生成DataSource Bean，DataSource Bean默认只会生成一个，四种数据源类型的生效先后顺序如下：Tomcat–> Hikari --> Dbcp --> Dbcp2 。

2、添加依赖
在Springboot 使用JDBC可直接添加官方提供的 spring-boot-start-jdbc 或者 spring-boot-start-data-jpa 依赖。

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.4.1.RELEASE</version>
</parent>
<dependencies>
	<!-- 添加MySQL依赖 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
	</dependency>
	<!-- 添加JDBC依赖 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-jdbc</artifactId>
	</dependency>
</dependencies>

3、核心配置-数据源相关配置
在核心配置application.properties或者application.yml文件中添加数据源相关配置。
application.properties文件中添加如下配置：

spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root

application.yml文件中添加如下配置：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
    driverClassName: com.mysql.jdbc.Driver
    username: root
    password: root

4、切换默认数据源
按照上述配置启动应用时，Springboot会读取核心配置中的配置并自动装配一个Tomcat DataSource。如果要切换成其他的默认支持的数据源类型，有以下两种方式：

   方式一 排除其他的数据源依赖，仅保留需要的数据源依赖；
   方式二 通过在核心配置中通过spring.datasource.type属性指定数据源的类型；

4-1、方式一
当我们引入spring-boot-start-jdbc依赖时，其实里面就包含了 Tomcat-JDBC 的依赖，如果想要切换为其他的数据源类型，需要先将Tomcat-JDBC 依赖排除，再添加上需要的数据源的依赖，以使用HikariCP数据源为例，依赖配置如下。

<!-- 添加JDBC依赖 -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-jdbc</artifactId>
	<exclusions>
		<!-- 排除Tomcat-JDBC依赖 -->
		<exclusion>
			<groupId>org.apache.tomcat</groupId>
			<artifactId>tomcat-jdbc</artifactId>
		</exclusion>
	</exclusions>
</dependency>
<!-- 添加HikariCP依赖 -->
<dependency>
	<groupId>com.zaxxer</groupId>
	<artifactId>HikariCP</artifactId>
</dependency>

4-2、方式二
还可以通过在核心配置中通过添加spring.datasource.type = [数据源类型] 来指定数据源的类型；

spring.datasource.type=com.zaxxer.hikari.HikariDataSource
# spring.datasource.type=org.apache.tomcat.jdbc.pool.DataSource
# spring.datasource.type=org.apache.commons.dbcp.BasicDataSource
# spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource

二、第三方数据源

如果不想使用Springboot默认支持的4种数据源，还可以选择使用其他第三方的数据源，例如：Druid、c3p0等。
以使用Druid数据源为例。

1、添加依赖及配置

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.4.1.RELEASE</version>
</parent>
<dependencies>
	<!-- 添加MySQL依赖 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
	</dependency>
	<!-- 添加JDBC依赖 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-jdbc</artifactId>
	</dependency>
	<!-- 添加Druid依赖 -->
	<dependency>
		<groupId>com.alibaba</groupId>
		<artifactId>druid</artifactId>
		<version>1.1.6</version>
	</dependency>
</dependencies>

2、核心配置文件中的添加数据源

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root
# 下面为连接池的补充设置，应用到上面所有数据源中
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
# 配置获取连接等待超时的时间
spring.datasource.maxWait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.timeBetweenEvictionRunsMillis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.minEvictableIdleTimeMillis=300000
spring.datasource.validationQuery=SELECT 1 FROM DUAL
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
spring.datasource.filters=stat,wall,log4j
spring.datasource.logSlowSql=true

3、定义数据源
由于springboot程序的特性，我们在工程的config包下面，创建DruidConfig.java文件，配置数据库连接池。使用注解@Bean 并将其纳入到Spring容器中进行管理即可。

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.util.StringUtils;
import org.apache.ibatis.io.VFS;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.boot.autoconfigure.SpringBootVFS;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.bind.RelaxedPropertyResolver;
import org.springframework.context.ApplicationContextException;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
 
import java.sql.SQLException;
import java.util.Arrays;
 
@Configuration
@EnableTransactionManagement
public class DuridConfig implements EnvironmentAware {
    private static final Logger logger = LoggerFactory.getLogger(DuridConfig.class);
 
    private Environment environment;
    private RelaxedPropertyResolver propertyResolver;
 
    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
        this.propertyResolver = new RelaxedPropertyResolver(environment, "spring.datasource.");
    }
 
    //注册dataSource
    @Bean(initMethod = "init", destroyMethod = "close")
    public DruidDataSource dataSource() throws SQLException {
        if (StringUtils.isEmpty(propertyResolver.getProperty("url"))) {
            System.out.println("Your database connectio n pool configuration is incorrect!"
                    + " Please check your Spring profile, current profiles are:"
                    + Arrays.toString(environment.getActiveProfiles()));
            throw new ApplicationContextException(
                    "Database connection pool is not configured correctly");
        }
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(propertyResolver.getProperty("driver-class-name"));
        druidDataSource.setUrl(propertyResolver.getProperty("url"));
        druidDataSource.setUsername(propertyResolver.getProperty("username"));
        druidDataSource.setPassword(propertyResolver.getProperty("password"));
        druidDataSource.setInitialSize(Integer.parseInt(propertyResolver.getProperty("initialSize")));
        druidDataSource.setMinIdle(Integer.parseInt(propertyResolver.getProperty("minIdle")));
        druidDataSource.setMaxActive(Integer.parseInt(propertyResolver.getProperty("maxActive")));
        druidDataSource.setMaxWait(Integer.parseInt(propertyResolver.getProperty("maxWait")));
        druidDataSource.setTimeBetweenEvictionRunsMillis(Long.parseLong(propertyResolver.getProperty("timeBetweenEvictionRunsMillis")));
        druidDataSource.setMinEvictableIdleTimeMillis(Long.parseLong(propertyResolver.getProperty("minEvictableIdleTimeMillis")));
        druidDataSource.setValidationQuery(propertyResolver.getProperty("validationQuery"));
        druidDataSource.setTestWhileIdle(Boolean.parseBoolean(propertyResolver.getProperty("testWhileIdle")));
        druidDataSource.setTestOnBorrow(Boolean.parseBoolean(propertyResolver.getProperty("testOnBorrow")));
        druidDataSource.setTestOnReturn(Boolean.parseBoolean(propertyResolver.getProperty("testOnReturn")));
        druidDataSource.setPoolPreparedStatements(Boolean.parseBoolean(propertyResolver.getProperty("poolPreparedStatements")));
        druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(Integer.parseInt(propertyResolver.getProperty("maxPoolPreparedStatementPerConnectionSize")));
        druidDataSource.setFilters(propertyResolver.getProperty("filters"));
        logger.info("DuridConfig-----数据源完成");
        return druidDataSource;
    }
 
    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource());
//        //mybatis分页
//        PageHelper pageHelper = new PageHelper();
//        Properties props = new Properties();
//        props.setProperty("dialect", "mysql");
//        props.setProperty("reasonable", "true");
//        props.setProperty("supportMethodsArguments", "true");
//        props.setProperty("returnPageInfo", "check");
//        props.setProperty("params", "count=countSql");
//        pageHelper.setProperties(props);
//        //添加插件
//        sqlSessionFactoryBean.setPlugins(new Interceptor[]{pageHelper});
        //添加XML目录
        VFS.addImplClass(SpringBootVFS.class);
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:mapper/*.xml"));
        logger.info("dao层扫描包为:mapper/*.xml");
        return sqlSessionFactoryBean.getObject();
    }
 
    @Bean
    public PlatformTransactionManager transactionManager() throws SQLException {
        return new DataSourceTransactionManager(dataSource());
 
    }
 
 
}

或者

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import com.github.pagehelper.PageHelper;
import org.apache.ibatis.io.VFS;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.boot.autoconfigure.SpringBootVFS;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
 
import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.Properties;
@Configuration
@EnableTransactionManagement
public class DruidConfig {
 
    private Logger logger = LoggerFactory.getLogger(DruidConfig.class);
 
 
    @Value("${spring.datasource.url}")
    private String dbUrl;
 
    @Value("${spring.datasource.username}")
    private String username;
 
    @Value("${spring.datasource.password}")
    private String password;
 
    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;
 
    @Value("${spring.datasource.initialSize}")
    private int initialSize;
 
    @Value("${spring.datasource.minIdle}")
    private int minIdle;
 
    @Value("${spring.datasource.maxActive}")
    private int maxActive;
 
    @Value("${spring.datasource.maxWait}")
    private int maxWait;
 
    @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;
 
    @Value("${spring.datasource.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;
 
    @Value("${spring.datasource.validationQuery}")
    private String validationQuery;
 
    @Value("${spring.datasource.testWhileIdle}")
    private boolean testWhileIdle;
 
    @Value("${spring.datasource.testOnBorrow}")
    private boolean testOnBorrow;
 
    @Value("${spring.datasource.testOnReturn}")
    private boolean testOnReturn;
 
    @Value("${spring.datasource.filters}")
    private String filters;
 
    @Value("${spring.datasource.logSlowSql}")
    private String logSlowSql;
 
    @Bean
    public ServletRegistrationBean druidServlet() {
        ServletRegistrationBean reg = new ServletRegistrationBean();
        reg.setServlet(new StatViewServlet());
        reg.addUrlMappings("/druid/*");
        reg.addInitParameter("loginUsername", username);
        reg.addInitParameter("loginPassword", password);
        reg.addInitParameter("logSlowSql", logSlowSql);
        return reg;
    }
 
    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new WebStatFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        filterRegistrationBean.addInitParameter("profileEnable", "true");
        return filterRegistrationBean;
    }
 
    @Bean
    public DataSource druidDataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(dbUrl);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setValidationQuery(validationQuery);
        datasource.setTestWhileIdle(testWhileIdle);
        datasource.setTestOnBorrow(testOnBorrow);
        datasource.setTestOnReturn(testOnReturn);
        try {
            datasource.setFilters(filters);
        } catch (SQLException e) {
            logger.error("druid configuration initialization filter", e);
        }
        return datasource;
    }
 
    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(druidDataSource());
        //mybatis分页
        PageHelper pageHelper = new PageHelper();
        Properties props = new Properties();
        props.setProperty("dialect", "mysql");
        props.setProperty("reasonable", "true");
        props.setProperty("supportMethodsArguments", "true");
        props.setProperty("returnPageInfo", "check");
        props.setProperty("params", "count=countSql");
        pageHelper.setProperties(props);
        //添加插件
       sqlSessionFactoryBean.setPlugins(new Interceptor[]{pageHelper});
        //添加XML目录
        VFS.addImplClass(SpringBootVFS.class);
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:mapper/*.xml"));
        logger.info("dao层扫描包为:mapper/*.xml");
        return sqlSessionFactoryBean.getObject();
    }
    @Bean
    public PlatformTransactionManager transactionManager() throws SQLException {
        return new DataSourceTransactionManager(druidDataSource());
    }
}

三、SpringBoot-JDBC 也为我们提供了事物的功能。

使用事物，需要使用@EnableTransactionManagement启用对事务的支持（默认打开），然后在需要使用事务的方法上面加上@Transactional即可。

注意，默认只会对运行时异常进行事务回滚，非运行时异常不会回滚事务。如果要使得非运行期异常也回滚，就要使用@Transactional进行相关配置，比如@Transactional(rollbackFor=Exception.class)对所有异常进行回滚不管是运行期还是非运行期异常。

andyzau007
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot+mybatis+druid（SQL监控+Spring监控）， 单数据源配置+多数据配置两种
06-21
springboot+mybatis+druid（SQL监控+Spring监控）， 单数据源配置+多数据配置两种， 单数据源中添加日志打印，对日志进行了不同环境的判断，mybatis有注解和xml两种形式的配置。
application.yml的多环境配置方式（单文件、多文件）
weixin_44343658的博客
09-15 8788
这里写目录标题一：多文件配置方式：二：单文件配置方式：扩展配置的使用（以上两种方式均可）： 一：多文件配置方式： application.yml #在application.yml中指定命名空间： spring: # 资源信息 messages: # 国际化资源文件路径 basename: i18n/messages profiles: active: dev # 文件上传 servlet: multipart: # 单个文件大小
application.yml数据库配置
qq_30272167的博客
03-29 3316
注意：MySQL 5.7之后的版本必须要加上useSSL=false；之前不用，默认是false。设置之后，不管数据库是什么编码，读取的时候都会转换成UTF-8，存取的时候还是会按数据库编码存。**SSL即为：**Secure Sockets Layer 安全套接字协议。**useSSL=true：**就是一般通过证书或者令牌进行安全验证。**useSSL=false：**就是通过账号密码进行连接。时区配置，MySQL8.0以上版本，url需要添加时区。
springboot项目不需要数据库的时候这样配置
最新发布
fengfeng99999的博客
03-15 391
在Spring Boot应用程序的配置文件（application.properties或application.yml）中来禁用数据库自动配置。有些springboot项目，只是作为接口服务（算法类），不存数据，不取数据，可以把数据库配置给禁用掉，不然启动项目会自动加载数据库，没有数据库会报错。注解方式，在启动类里面有个注解@SpringBootApplication，只需要在注解后面加上下面的就可以了。
多数据源配置（application.properties或application.yml配置详情）
前路漫漫，少年，继续披荆斩棘！
12-27 4380
@DS切换多数据源
SpringBoot项目配置多数据源的两种方式
weixin_50003028的博客
11-24 3208
spring:druid:db1:db2:该类的作用就是初始化数据源DataSource实例，以及初始化SqlSessionFactory实例。这里需要注意的是必须使用来获取会话工厂SqlSessionFactory，不然的话，baseMapper中的生成动态SQL的方法就不能使用了。//mapper模式下的接口层/*** 配置数据源* @return*/@Primary/*** 配置数据源* @return*/@Bean。
SpringBoot - 配置文件application.yml使用详解（附：Profile多环境配置）
热门推荐
m0_56753567的博客
08-10 1万+
（1）YAML 是 JSON 的超集，简洁而强大，是一种专门用来书写配置文件的语言，可以替代 application.properties。（2）在创建一个 SpringBoot 项目时，引入的 spring-boot-starter-web 依赖间接地引入了 snakeyaml 依赖， snakeyaml 会实现对 YAML 配置的解析。（3）YAML 的使用非常简单，利用缩进来表示层级关系，并且大小写敏感。
application.yml基础配置以及读取
weixin_51725434的博客
10-06 9001
application.yml基础配置以及读取
SpringBoot配置多数据源（application.yml）
u010786200的博客
03-27 1494
简单三步解决springboot配置多数据源
SpringBoot项目，单数据源版 集成 Mysql + Redis + RabbitMQ + Shiro.zip
01-04
SpringBoot项目，单数据源版 集成 Mysql + Redis + RabbitMQ + Shiro
duird单数据源连接.rar
05-30
SpringBoot2实现duird数据库连接池连接数据库，仅支持单数据源
单数据源xilinx vdma hdmi彩条测试
08-12
单数据源xilinx vdma hdmi彩条测试
SpringBoot-Mysql-Redis-RabbitMQ-Shiro:SpringBoot项目，单数据源版 集成 Mysql + Redis + RabbitMQ + Shiro
05-14
SpringBoot-Mysql-Redis-RabbitMQ-Shiro 主要的架构：Spring Boot Mybatis Druid Pagehelper Redis Shiro RabbitMQ Freemarker poi 等等。 运行环境： maven jdk1.8 访问路径： 初始账号：admin 密码: 123456 注释...
【精·超详细】SpringBoot 配置多个数据源（连接多个数据库）
马涛的博客
11-28 1万+
1.项目路径2.pom.xml 引入依赖 3.application.yml配置文件 4.两个entity类 5.Conroller 6.两个Service以及两个ServiceImpl 7.两个Mapper及两个Mapper.xml 8.运行Application 然后在浏览器请求 9.查看两个数据库是否有新增数据
Spring Boot多数据源配置详解及报错问题解决
qq_57794788的博客
02-20 6260
SpringBoot多数据源配置流程及报错解决
application.yml数据库连接配置
qq_44765534的博客
12-15 1146
【代码】application.yml数据库连接配置。
SpringBoot 配置 application.yml连接MySQL数据库
m0_58580098的博客
07-15 1097
【代码】SpringBoot 配置 application.yml连接MySQL数据库。
若依ruoyi框架增加2个以上的数据源配置
AVATAR
11-20 1394
若依ruoyi框架增加2个以上的数据源配置
Spring Boot 集成Mybatis Plus 多数据源配置
weixin_43901631的博客
02-07 204
二、配置类：二个配置文件数据源1配置为SysDataSourceConfig 数据源2配置为OaDataSourceConfig。数据源1 取名sys;一、application.yml 配置。
springBoot + Hikari 配置单数据源报错，找不到数据源
06-06
如果你使用Spring Boot和Hikari配置单数据源时出现找不到数据源的错误，可能是因为你没有正确地配置数据源的连接信息。请确认以下几点： 1. 在application.properties或application.yml文件中，确保已正确地配置了数据源连接信息，包括数据库URL、用户名、密码等； 2. 确认Hikari连接池是否已正确地集成到Spring Boot应用程序中。可以在应用程序启动时查看控制台日志以确认是否已成功加载Hikari连接池； 3. 确认你的数据源是否已正确地配置在Spring Boot应用程序中。可以使用@Autowired注解将数据源注入到应用程序中，确保应用程序可以正确地访问数据源。 如果你已经确认了以上几点，但仍然遇到了找不到数据源的错误，请提供更多的错误信息，以便我能够更好地帮助你解决问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值