SpringBoot2.x入门教程之引入jdbc模块与JdbcTemplate简单使用方法

前提

这篇文章是《SpringBoot2.x入门》专辑的第7篇文章,使用的SpringBoot版本为2.3.1.RELEASEJDK版本为1.8

这篇文章会简单介绍jdbc模块也就是spring-boot-starter-jdbc组件的引入、数据源的配置以及JdbcTemplate的简单使用。为了让文中的例子相对通用,下文选用MySQL8.xh2database(内存数据库)作为示例数据库,选用主流的DruidHikariCP作为示例数据源。

引入jdbc模块

引入spring-boot-starter-jdbc组件,如果在父POM全局管理spring-boot依赖版本的前提下,只需要在项目pom文件的dependencies元素直接引入:

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

通过IDEA展开该依赖的关系图如下:

其实spring-boot-starter-jdbc模块本身已经引入了spring-jdbc(间接引入spring-corespring-beansspring-tx)、spring-boot-starterHikariCP三个依赖,如果希望启动Servlet容器,可以额外引入spring-boot-starter-jdbc

spring-boot-starter-jdbc提供了数据源配置、事务管理、数据访问等等功能,而对于不同类型的数据库,需要提供不同的驱动实现,才能更加简单地通过驱动实现根据连接URL、用户口令等属性直接连接数据库(或者说获取数据库的连接),因此对于不同类型的数据库,需要引入不同的驱动包依赖。对于MySQL而言,需要引入mysql-connector-java,而对于h2database而言,需要引入h2(驱动包和数据库代码位于同一个依赖中),两者中都具备数据库抽象驱动接口java.sql.Driver的实现类:

  • 对于mysql-connector-java而言,常用的实现是com.mysql.cj.jdbc.DriverMySQL8.x版本)。
  • 对于h2而言,常用的实现是org.h2.Driver

如果需要连接的数据库是h2database,引入h2对应的数据库和驱动依赖如下:

<dependency>
 <groupId>com.h2database</groupId>
 <artifactId>h2</artifactId>
 <version>1.4.200</version>
</dependency>

如果需要连接的数据库是MySQL,引入MySQL对应的驱动依赖如下:

<dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <version>8.0.20</version>
</dependency>

上面的类库版本选取了编写本文时候的最新版本,实际上要根据软件对应的版本选择合适的驱动版本。

数据源配置

spring-boot-starter-jdbc模块默认使用HikariCP作为数据库的连接池。

HikariCP,也就是Hikari Connection Pool,Hikari连接池。HikariCP的作者是日本人,而Hikari是日语,意义和light相近,也就是"光"。Simplicity is prerequisite for reliability(简单是可靠的先决条件)是HikariCP的设计理念,他是一款代码精悍的高性能连接池框架,被Spring项目选中作为内建默认连接池,值得信赖。

如果决定使用HikariCP连接h2数据库,则配置文件中添加如下的配置项以配置数据源HikariDataSource

spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.url=jdbc:h2:mem:test
spring.datasource.username=root
spring.datasource.password=123456
# 可选配置,是否启用h2数据库的WebUI控制台
spring.h2.console.enabled=true
# 可选配置,访问h2数据库的WebUI控制台的路径
spring.h2.console.path=/h2-console
# 可选配置,是否允许非本机访问h2数据库的WebUI控制台
spring.h2.console.settings.web-allow-others=true

如果决定使用HikariCP连接MySQL数据库,则配置文件中添加如下的配置项以配置数据源HikariDataSource

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 注意MySQL8.x需要指定服务时区属性
spring.datasource.url=jdbc:mysql://localhost:3306/local?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&useSSL=false
spring.datasource.username=root
spring.datasource.password=root

有时候可能更偏好于使用其他连接池,例如Alibaba出品的Durid,这样就要禁用默认的数据源加载,改成Durid提供的数据源。引入Druid数据源需要额外添加依赖:

<dependency>
 <groupId>com.alibaba</groupId>
 <artifactId>druid</artifactId>
 <version>1.1.23</version>
</dependency>

如果决定使用Druid连接MySQL数据库,则配置文件中添加如下的配置项以配置数据源DruidDataSource

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 注意MySQL8.x需要指定服务时区属性
spring.datasource.url=jdbc:mysql://localhost:3306/local?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&useSSL=false
spring.datasource.username=root
spring.datasource.password=root
# 指定数据源类型为Druid提供的数据源
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

上面这样配置DruidDataSource,所有数据源的属性值都会选用默认值,如果想深度定制数据源的属性,则需要覆盖由DataSourceConfiguration.Generic创建的数据源,先预设所有需要的配置,为了和内建的spring.datasource属性前缀避嫌,这里自定义一个属性前缀druid,配置文件中添加自定义配置项如下:

druid.url=jdbc:mysql://localhost:3306/local?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&useSSL=false
druid.driver-class-name=com.mysql.cj.jdbc.Driver
druid.username=root
druid.password=root
# 初始化大小
druid.initialSize=1
# 最大
druid.maxActive=20
# 空闲
druid.minIdle=5
# 配置获取连接等待超时的时间
druid.maxWait=60000
# 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
druid.timeBetweenEvictionRunsMillis=60000
# 配置一个连接在池中最小生存的时间,单位是毫秒
druid.minEvictableIdleTimeMillis=60000
druid.validationQuery=SELECT 1 FROM DUAL
druid.testWhileIdle=true
druid.testOnBorrow=false
druid.testOnReturn=false
# 打开PSCache,并且指定每个连接上PSCache的大小
druid.poolPreparedStatements=true
druid.maxPoolPreparedStatementPerConnectionSize=20
# 配置监控统计拦截的filters,后台统计相关
druid.filters=stat,wall
# 打开mergeSql功能;慢SQL记录
druid.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

这里要确保本地安装了一个8.x版本的MySQL服务,并且建立了一个命名为local的数据库。

需要在项目中添加一个数据源自动配置类,这里命名为DruidAutoConfiguration,通过注解@ConfigurationPropertiesdruid前缀的属性注入到数据源实例中:

@Configuration
public class DruidAutoConfiguration {

 @Bean
 @ConfigurationProperties(prefix = "druid")
 public DataSource dataSource() {
  return new DruidDataSource();
 }

 @Bean
 public ServletRegistrationBean<StatViewServlet> statViewServlet() {
  ServletRegistrationBean<StatViewServlet> servletRegistrationBean
    = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
  // 添加IP白名单
  servletRegistrationBean.addInitParameter("allow", "127.0.0.1");
  // 添加控制台管理用户
  servletRegistrationBean.addInitParameter("loginUsername", "admin");
  servletRegistrationBean.addInitParameter("loginPassword", "123456");
  // 是否能够重置数据
  servletRegistrationBean.addInitParameter("resetEnable", "true");
  return servletRegistrationBean;
 }

 @Bean
 public FilterRegistrationBean<WebStatFilter> webStatFilter() {
  WebStatFilter webStatFilter = new WebStatFilter();
  FilterRegistrationBean<WebStatFilter> filterRegistrationBean = new FilterRegistrationBean<>();
  filterRegistrationBean.setFilter(webStatFilter);
  // 添加过滤规则
  filterRegistrationBean.addUrlPatterns("/*");
  // 忽略过滤格式
  filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*,");
  return filterRegistrationBean;
 }
}

可以通过访问${requestContext}/druid/login.html跳转到Druid的监控控制台,登录账号密码就是在statViewServlet中配置的用户和密码:

Druid是一款争议比较多的数据源框架,项目的Issue中也有人提出过框架中加入太多和连接池无关的功能,例如SQL监控、属性展示等等,这些功能本该让专业的监控软件完成。但毫无疑问,这是一款活跃度比较高的优秀国产开源框架。

配置schema和data脚本

spring-boot-starter-jdbc可以通过一些配置然后委托DataSourceInitializerInvoker进行schema(一般理解为DDL)和data(一般理解为DML)脚本的加载和执行,具体的配置项是:

# 定义schema的加载路径,可以通过英文逗号指定多个路径
spring.datasource.schema=classpath:/ddl/schema.sql
# 定义data的加载路径,可以通过英文逗号指定多个路径
spring.datasource.data=classpath:/dml/data.sql
# 可选
# spring.datasource.schema-username=
# spring.datasource.schema-password=
# 项目数据源初始化之后的执行模式,可选值EMBEDDED、ALWAYS和NEVER
spring.datasource.initialization-mode=always

类路径的resources文件夹下添加ddl/schema.sql

DROP TABLE IF EXISTS customer;

CREATE TABLE customer
(
 id   BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY COMMENT '主键',
 customer_name VARCHAR(32) NOT NULL COMMENT '客户名称',
 create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
 edit_time  DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间'
) COMMENT '客户表';

由于spring.datasource.initialization-mode指定为ALWAYS,每次数据源初始化都会执行spring.datasource.schema中配置的脚本,会删表重建。接着类路径的resources文件夹下添加dml/data.sql

INSERT INTO customer(customer_name) VALUES ('throwable');

添加一个CommandLineRunner实现验证一下:

@Slf4j
@SpringBootApplication
public class Ch7Application implements CommandLineRunner {

 @Autowired
 private DataSource dataSource;

 public static void main(String[] args) {
  SpringApplication.run(Ch7Application.class, args);
 }

 @Override
 public void run(String... args) throws Exception {
  Connection connection = dataSource.getConnection();
  ResultSet resultSet = connection.createStatement().executeQuery("SELECT * FROM customer WHERE id = 1");
  while (resultSet.next()) {
   log.info("id:{},name:{}", resultSet.getLong("id"), resultSet.getString("customer_name"));
  }
  resultSet.close();
  connection.close();
 }
}

启动后执行结果如下:

这里务必注意一点,spring.datasource.schema指定的脚本执行成功之后才会执行spring.datasource.data指定的脚本,如果想仅仅执行spring.datasource.data指定的脚本,那么需要至少把spring.datasource.schema指向一个空的文件,确保spring.datasource.schema指定路径的文件初始化成功。

使用JdbcTemplate

spring-boot-starter-jdbc中自带的JdbcTemplate是对JDBC的轻度封装。这里只简单介绍一下它的使用方式,构建一个面向前面提到的customer表的具备CURD功能的DAO。这里先在前文提到的DruidAutoConfiguration中添加一个JdbcTemplate实例到IOC容器中:

@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource){
 return new JdbcTemplate(dataSource);
}

添加一个Customer实体类:

// 实体类
@Data
public class Customer {

 private Long id;
 private String customerName;
 private LocalDateTime createTime;
 private LocalDateTime editTime;
}

接着添加一个CustoemrDao类,实现增删改查:

// CustoemrDao
@RequiredArgsConstructor
@Repository
public class CustomerDao {

 private final JdbcTemplate jdbcTemplate;

 /**
  * 增
  */
 public int insertSelective(Customer customer) {
  StringJoiner p = new StringJoiner(",", "(", ")");
  StringJoiner v = new StringJoiner(",", "(", ")");
  Optional.ofNullable(customer.getCustomerName()).ifPresent(x -> {
   p.add("customer_name");
   v.add("?");
  });
  Optional.ofNullable(customer.getCreateTime()).ifPresent(x -> {
   p.add("create_time");
   v.add("?");
  });
  Optional.ofNullable(customer.getEditTime()).ifPresent(x -> {
   p.add("edit_time");
   v.add("?");
  });
  String sql = "INSERT INTO customer" + p.toString() + " VALUES " + v.toString();
  KeyHolder keyHolder = new GeneratedKeyHolder();
  int updateCount = jdbcTemplate.update(con -> {
   PreparedStatement ps = con.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
   int index = 1;
   if (null != customer.getCustomerName()) {
    ps.setString(index++, customer.getCustomerName());
   }
   if (null != customer.getCreateTime()) {
    ps.setTimestamp(index++, Timestamp.valueOf(customer.getCreateTime()));
   }
   if (null != customer.getEditTime()) {
    ps.setTimestamp(index, Timestamp.valueOf(customer.getEditTime()));
   }
   return ps;
  }, keyHolder);
  customer.setId(Objects.requireNonNull(keyHolder.getKey()).longValue());
  return updateCount;
 }

 /**
  * 删
  */
 public int delete(long id) {
  return jdbcTemplate.update("DELETE FROM customer WHERE id = ?", id);
 }

 /**
  * 查
  */
 public Customer queryByCustomerName(String customerName) {
  return jdbcTemplate.query("SELECT * FROM customer WHERE customer_name = ?",
    ps -> ps.setString(1, customerName), SINGLE);
 }

 public List<Customer> queryAll() {
  return jdbcTemplate.query("SELECT * FROM customer", MULTI);
 }

 public int updateByPrimaryKeySelective(Customer customer) {
  final long id = Objects.requireNonNull(Objects.requireNonNull(customer).getId());
  StringBuilder sql = new StringBuilder("UPDATE customer SET ");
  Optional.ofNullable(customer.getCustomerName()).ifPresent(x -> sql.append("customer_name = ?,"));
  Optional.ofNullable(customer.getCreateTime()).ifPresent(x -> sql.append("create_time = ?,"));
  Optional.ofNullable(customer.getEditTime()).ifPresent(x -> sql.append("edit_time = ?,"));
  StringBuilder q = new StringBuilder(sql.substring(0, sql.lastIndexOf(","))).append(" WHERE id = ?");
  return jdbcTemplate.update(q.toString(), ps -> {
   int index = 1;
   if (null != customer.getCustomerName()) {
    ps.setString(index++, customer.getCustomerName());
   }
   if (null != customer.getCreateTime()) {
    ps.setTimestamp(index++, Timestamp.valueOf(customer.getCreateTime()));
   }
   if (null != customer.getEditTime()) {
    ps.setTimestamp(index++, Timestamp.valueOf(customer.getEditTime()));
   }
   ps.setLong(index, id);
  });
 }

 private static Customer convert(ResultSet rs) throws SQLException {
  Customer customer = new Customer();
  customer.setId(rs.getLong("id"));
  customer.setCustomerName(rs.getString("customer_name"));
  customer.setCreateTime(rs.getTimestamp("create_time").toLocalDateTime());
  customer.setEditTime(rs.getTimestamp("edit_time").toLocalDateTime());
  return customer;
 }

 private static ResultSetExtractor<List<Customer>> MULTI = rs -> {
  List<Customer> result = new ArrayList<>();
  while (rs.next()) {
   result.add(convert(rs));
  }
  return result;
 };

 private static ResultSetExtractor<Customer> SINGLE = rs -> rs.next() ? convert(rs) : null;
}

测试结果如下:

JdbcTemplate的优势是可以应用函数式接口简化一些值设置和值提取的操作,并且获得接近于原生JDBC的执行效率,但是它的明显劣势就是会产生大量模板化的代码,在一定程度上影响开发效率。

小结

本文简单分析spring-boot-starter-jdbc引入,以及不同数据库和不同数据源的使用方式,最后简单介绍了JdbcTemplate的基本使用。

demo项目仓库:

Githubhttps://github.com/zjcscut/spring-boot-guide/tree/master/ch6-jdbc-module-h2

Githubhttps://github.com/zjcscut/spring-boot-guide/tree/master/ch7-jdbc-module-mysql

总结

到此这篇关于SpringBoot2.x入门教程:引入jdbc模块与JdbcTemplate简单使用的文章就介绍到这了,更多相关SpringBoot2.x入门教程:引入jdbc模块与JdbcTemplate简单使用内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • SpringBoot使用JdbcTemplate操作数据库

    前言 本文是对SpringBoot使用JdbcTemplate操作数据库的一个介绍,提供一个小的Demo供大家参考. 操作数据库的方式有很多,本文介绍使用SpringBoot结合JdbcTemplate. 新建项目 新建一个项目.pom文件中加入Jdbc依赖,完整pom如下: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM

  • Spring Boot中使用jdbctemplate 操作MYSQL数据库实例

    最近在学习使用Spring Boot连接数据库,今天学习了使用jdbctemplate 操作MYSQL数据库,下面就留个笔记 不废话,先来代码 pom文件: <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org

  • SpringBoot JdbcTemplate批量操作的示例代码

    前言 在我们做后端服务Dao层开发,特别是大数据批量插入的时候,这时候普通的ORM框架(Mybatis.hibernate.JPA)就无法满足程序对性能的要求了.当然我们又不可能使用原生的JDBC进行操作,那样尽管效率会高,但是复杂度会上升. 综合考虑我们使用Spring中的JdbcTemplate和具名参数namedParameterJdbcTemplate来进行批量操作. 改造前 在开始讲解之前,我们首先来看下之前的JPA是如何批量操作的. 实体类User: public class App

  • springboot使用JdbcTemplate完成对数据库的增删改查功能

    首先新建一个简单的数据表,通过操作这个数据表来进行演示 DROP TABLE IF EXISTS `items`; CREATE TABLE `items` ( `id` int(11) NOT NULL AUTO_INCREMENT, `title` varchar(255) DEFAULT NULL, `name` varchar(10) DEFAULT NULL, `detail` varchar(255) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE

  • spring boot tomcat jdbc pool的属性绑定

    下面看下spring boot tomcat jdbc pool的属性绑定代码,具体代码如下所示: spring: datasource: type: org.apache.tomcat.jdbc.pool.DataSource driver-class-name: org.postgresql.Driver url: jdbc:postgresql://192.168.99.100:5432/postgres?connectTimeout=6000&socketTimeout=6000 use

  • 详解spring boot中使用JdbcTemplate

    本文将介绍如何将spring boot 与 JdbcTemplate一起工作. Spring对数据库的操作在jdbc上面做了深层次的封装,使用spring的注入功能,可以把DataSource注册到JdbcTemplate之中. JdbcTemplate 是在JDBC API基础上提供了更抽象的封装,并提供了基于方法注解的事务管理能力. 通过使用SpringBoot自动配置功能并代替我们自动配置beans. 数据源配置 在maven中,我们需要增加spring-boot-starter-jdbc

  • SpringBoot2.x入门教程之引入jdbc模块与JdbcTemplate简单使用方法

    前提 这篇文章是<SpringBoot2.x入门>专辑的第7篇文章,使用的SpringBoot版本为2.3.1.RELEASE,JDK版本为1.8. 这篇文章会简单介绍jdbc模块也就是spring-boot-starter-jdbc组件的引入.数据源的配置以及JdbcTemplate的简单使用.为了让文中的例子相对通用,下文选用MySQL8.x.h2database(内存数据库)作为示例数据库,选用主流的Druid和HikariCP作为示例数据源. 引入jdbc模块 引入spring-boo

  • SpringBoot 入门教程之引入数据传输层的方法

    我们现在操作的数据直接就使用了实体类,假如我们输出的用户对象需要包含用户拥有的权限列表,那么我们怎么封装呢? 直接封装进实体类中显然不行,因为实体类的职责就是提供与数据库表字段一一对应的映射关系,所以我们还需要封装出一层数据传输层 DTO(Data Transfer Object),通过它暴露给外部,这样我们就能高度定制化我们需要输出的数据而不会影响到实体类. 在项目中创建 dto 目录,新建 UserDto.java 文件: package com.foxescap.wxbox.dto; im

  • nodejs入门教程六:express模块用法示例

    本文实例讲述了nodejs入门教程之express模块用法.分享给大家供大家参考,具体如下: /** * Created by Dason on 2017/3/28. */ var express = require('express'); var morgan = require('morgan');//打印日志的中间件 //创建express 的实例 var app = express(); /** * 中间件: * Connect: Node.js的中间件框架 * 分层处理:每层实现一个功

  • AngularJS入门教程二:在路由中传递参数的方法分析

    本文实例讲述了AngularJS在路由中传递参数的方法.分享给大家供大家参考,具体如下: 我们不仅可以在控制器中直接定义属性的值,比如: app.controller('listController',function($scope){ $scope.name="ROSE"; }); AngularJS还提供了传递参数的功能,目前我接触到的一种方式是从视图中传参: <!--首页html--> <li><a href="#/user/18"

  • Python入门教程1. 基本运算【四则运算、变量、math模块等】 原创

    在熟悉了Python的基本安装与环境配置之后,我们来看看Python的基本运算操作. 1. 基本运算 >>>6 # 这里的'#'是注释符号,不参与运算 6 >>>666666666666666 #整数类型,原样输出 666666666666666 >>>3.14 #浮点数类型 3.14 >>>id(6) #id()函数用于查看内存地址 1409471616 >>>help(id) #help()函数可用于查看函数文档

  • Angular2入门教程之模块和组件详解

    本文呢主要给大家介绍的关于Angular2模块和组件的相关内容,分享出来供大家参考学习,下面来一起看看详细的介绍: 一.初步了解模块和组件 之前给大家介绍了构建工程,这篇文章简单讲述一下Angular2中的模块和组件. app文件夹下有五个文件,其中,app.component.spec.ts应该是和模块测试有关的文件,目前不用管它.剩下的四个文件就是典型的模块+组件的文件组成模式. Angular2应用由模块和组件构成,每个模块这样明明name.module.ts,组件则是name.compo

  • Python pyecharts模块安装与入门教程

    目录 pyecharts产生背景 一.pyecharts模块安装 二.pyecharts入门 1.基础折线图 2.pyecharts配置选项 pyecharts产生背景 Echarts是由百度开源的数据可视化,凭借良好的交互性和精巧的图表设计,得到众多开发者的认可,而python很适合用于数据处理,数据分析遇到数据可视化时pyecharts就产生了. 官网链接:https://pyecharts.org/#/ 画廊pyecharts-gallery pyecharts支持的图表众多,官方提供了画

  • nodejs入门教程四:URL相关模块用法分析

    本文实例讲述了nodejs入门教程之URL相关模块用法.分享给大家供大家参考,具体如下: 1.URL 模块:用于 URL 处理与解析 1)URI 与 URL : URI,是uniform resource identifier,统一资源标识符,用来唯一的标识一个资源. URL是uniform resource locator,统一资源定位器,它是一种具体的URI,即URL可以用来标识一个资源,而且还指明了如何locate(定位)这个资源. 2)URL模块中的方法: ① url.format(ur

  • 一篇不错的Python入门教程

    原文 http://www.hetland.org/python/instant-hacking.php Instant Hacking[译文] 译者: 肯定来过 这是一篇简短的关于python程序设计语言的入门教程,原文在这里,翻着词典翻译了来! 这是一份对编程艺术的简短介绍,其中的例子是用python写成的.(如果你已经知道了该如何编程,但是想简单了解一下python,你可以查阅我的另一篇文章Instant Python.)这篇文章已经被翻译为意大利.波兰.日本.塞尔维亚以及巴西葡萄亚语等许

  • react.js使用webpack搭配环境的入门教程

    本文介绍了react.js使用webpack搭配环境的入门教程,分享给大家,也给自己做个笔记 如果你想直接上手开发,而跳过这些搭配环境的繁琐过程,推荐你使用官方的create-react-app命令 npm install -g create-react-app //安装create-react-app脚手架 npm为node.js的包管理工具,请确保你已经安装了node.js create-react-app my-app //使用create-react-app创建,my-app为项目名称

随机推荐