在学习Springboot之前，你最好具备以下知识：1、使用Maven构建项目；2、熟悉Spring注解；3、了解RESTful API相关知识。需要说明的是你可以不会SpringMVC，但是需要注意Maven版本和Java版本保持一致等问题。

首先请确保你的电脑上安装了java1.8和Maven 3.5及以上，可以使用以下命令进行查看：

1 2	java -version mvn -version

第一个springboot程序

第一步，使用spring Initializr新建一个项目ispringboot，具体操作如下（按照图中序号依次进行即可）：

当然如果说你不是idea，那么你可以点击这里，然后按照图示填写信息：

最后稍等一会，页面就会弹出下载文件，你只需要将其保存到本地即可：

然后删除图中蓝色的4个文件，这些目前使用不到的：

注意为保证本项目能正常运行，请将springboot的版本修改为2.1.3版，切记切记。

启动项目

为了保证启动项目能看到一些信息，在com.envy.luckymoney包内新建一个controller包，里面新建一个HelloController类，里面的代码为：

package com.envy.luckymoney.controller;

import org.springframework.web.bind.annotation.*;

@RestController
public class HelloController {

    //@RequestMapping(value = "/hello",method = RequestMethod.GET)  //1.x版本
    @GetMapping("/hello")
    public String say(){
        return "First SpringBoot!";
    }
}

然后启动项目，注意项目的启动方式有三种：第一种，最简单的方式：

第二种：在项目根路径下执行maven命令: mvn spring-boot:run，如图所示：

请注意是:mvn spring-boot:run，而不是: mvn springboot:run，中间必须有一个-号，否则就会出现No plugin found for prefix 'spring-boot' ...的问题。

第三种：先在项目根路径（也就是pom.xml所在目录）下执行maven命令mvn install，接着进入到target目录，然后在target目录下执行java -jar luckymoney-0.0.1-SNAPSHOT.jar即可（注意这种方式是springboot项目脱机后运行的方式）

三种方式都成功运行项目后，在浏览器地址栏输入http://localhost:8080/hello，即可看到信息：First SpringBoot!。

配置文件

前面的项目默认启动的是8080端口，现在想使用其他端口。又或者说现在不明确是哪个项目在运行，需要在url中多加一层项目名字，这时应该如何配置呢？很简单找到resources 的application.properties文件，这个就是配置文件，在里面进行设置即可。

1 2	server.port=8081 server.servlet.context-path=/luckymoney

启动项目，在浏览器地址栏输入http://localhost:8081/luckymoney/hello，即可看到信息：First SpringBoot!。

当然这样配置是可以的，但是看到配置文件前面的server是相同的，可不可以省略一下呢？当然可以使用yaml就可以解决。在application.properties同级目录下创建一个application.yml文件，里面的代码为：

server:
  port: 8081
  servlet:
    context-path: /luckymoney

启动项目，在浏览器地址栏输入http://localhost:8081/luckymoney/hello，同样可以看到信息：First SpringBoot!。既然都可以的话，优先使用后者，因为它层次感很强，一眼就能看到目录关系。需要注意的是YAML格式语法：key:(空格)value，一定不能忘记空格，否则会出问题。

在实际项目开发中，我们通常希望可以自定义一些信息，而这些信息最好可以放在某个文件中，然后通过某种方式就能读取，Springboot支持将项目的自定义信息放在配置文件中。在application.yml文件中新增以下配置：

#个人信息配置项
info:
  name: envy
  sex: male
  address: beijing

然后希望在HelloController文件中，通过注解给属性赋值的方式来获取配置文件的值并赋值给属性：

package com.envy.luckymoney.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

@RestController
public class HelloController {
    @Value("${info.name}")
    private String name;
    @Value("${info.sex}")
    private String sex;
    @Value("${info.address}")
    private String address;

    @GetMapping("/hello")
    public String say(){
        return String.format("name:%s,sex:%s,address:%s",
                name,sex,address) ;
    }
}

启动项目，在浏览器地址栏输入http://localhost:8081/luckymoney/hello，同样可以看到信息：name:envy,sex:male,address:beijing。

现在更复杂一些，需要在配置中使用配置，此时可以使用${}形式：

#个人信息配置项
info:
  name: envy
  sex: male
  address: beijing
  description: hey,i am come from ${info.address},and name is ${info.name}.

那么此时在HelloController文件中的代码就需要修改为：

package com.envy.luckymoney.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

@RestController
public class HelloController {
    @Value("${info.name}")
    private String name;
    @Value("${info.sex}")
    private String sex;
    @Value("${info.address}")
    private String address;
    @Value("${info.description}")
    private String description;

    @GetMapping("/hello")
    public String say(){
        return String.format("name:%s,sex:%s,address:%s,description:%s",
                name,sex,address,description) ;
    }
}

启动项目，在浏览器地址栏输入http://localhost:8081/luckymoney/hello，同样可以看到信息：name:envy,sex:male,address:beijing,description:hey,i am come from beijing,and name is envy.。

现在问题来了，这才仅仅是4个配置信息，每一个配置信息前都需要使用@Value("${info.name}")这种形式，实际上配置信息有很多，甚至几百种，那时候怎么办？此时观察配置文件发现，目前关于个人的配置信息都在info这个层级下面，那么我们是不是可以理解为info就是一个对象，而第二层级的信息可以看做是它的属性？

在HelloController类的同级目录下新建一个InfoConfig类，里面用于定义哪些属性，及getter和setter、toString方法：

package com.envy.luckymoney.controller;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "info")
public class InfoConfig {
    private String name;
    private String address;
    private String sex;
    private String description;
   //getter和setter、toString方法
}

注意在这个类中需要使用@ConfigurationProperties注解，用于把配置信息自动封装成实体类，然后配置里面的前缀prefix，也就是配置文件的第一层info，这个要注意。当然仅仅这样是不够的，因为后面我们是在controller中调用这个bean，那么应当使用@Component注解来让IOC容器管理Bean。那么在HelloController类中的代码应当修改为：

package com.envy.luckymoney.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
public class HelloController {

    @Autowired
    private InfoConfig infoConfig;

    @GetMapping("/hello")
    public String say(){
        return infoConfig.toString();
    }
}

启动项目，在浏览器地址栏输入http://localhost:8081/luckymoney/hello，同样可以看到信息：InfoConfig{name='envy', address='beijing', sex='male', description='hey,i am come from beijing,and name is envy.'}。

那么什么时候使用单个配置，什么时候使用实体类呢？这个就需要看自己的业务了。

多环境配置

接下来谈谈运行环境，一般而言有开发、生产和测试这三种环境，这些环境中的一些参数值肯定是不一样的，那么我们需要在某种环境下再修改配置文件吗?当然不是了，springboot提供了多环境配置。在resources目录下新建两个文件：application-dev.yml和application-prd.yml，内容就直接复制application.yml的即可：（注意名称其实可以随意，只要符合application-{}.yml形式即可）

application-dev.yml中的代码为：

#个人信息配置项
info:
  name: dev
  sex: male
  address: beijing
  description: hey,i am come from ${info.address},and name is ${info.name}.

application-prd.yml中的代码为：

#个人信息配置项
info:
  name: prd
  sex: male
  address: beijing
  description: hey,i am come from ${info.address},and name is ${info.name}.

当你需要指定使用哪个环境的时候，只需要在application.yml中进行配置即可：

1
2
3

spring:
  profiles:
    active: dev

只需要这样修改是不是非常简单。

SpringBoot打包与运行

springboot打包方式很简单，直接在项目目录（pom.xml所在同级目录），执行mvn package，接着在生成的target目录下，找到luckymoney-0.0.1-SNAPSHOT.jar文件，这个就是打包生成的jar包，为什么是jar包而不是war包呢？因为war包需要在tomcat容器内才能运行，也就意味着你本机还需要安装tomcat并启动它，但是jar不需要，因为它是标准的java包，可以使用java -jar 项目名称这种方式和就能启动项目。

现在你可能需要问，假如我某一个项目当时打包用了dev环境，现在我想运行在prd环境，那应该怎样操作呢？有人说这是一个jar包可以解压后，通过修改主配置文件方式啊，这种方式似乎是可行的，但是假设某个人电脑上此时没有安装可以解压jar包的软件呢？这时候不就没办法了吗？

其实SpringBoot早就想到这个问题了，你只需要将三个配置文件：application.yml、application-dev.yml和application-prd.yml放在之前打包成的jar的文件夹内即可（注意它们四个必须在同一个文件夹中），然后通过修改这三个配置文件，jar包会优先读取外面三个yml文件的相关配置。

如果你觉得上面那种方式还是不行，那你可以在项目启动的时候指定运行环境，使用的命令为：java -jar Dspring.profiles.active=prd 项目名称，还有其实后面可以直接使用项目绝对路径启动的java -jar Dspring.profiles.active=prd F:\Springboot\Test\luckymoney\target\luckymoney-0.0.1-SNAPSHOT.jar这种方式来启动。

Controller的使用

先来看三个注解的使用：@Controller和在SpringMVC中的用法没什么大的变化，用于处理http请求；@RestController这个注解是Spring4之后新增的，用于替代原来返回json数据需要使用@Controller和@ResponseBody这两个注解；@RequestMapping在方法上使用，用于配置url映射。（前面说过是在springboot1.x版本中使用，但是在一些特殊项目中还是需要使用这个）

前面都是直接返回json对象，接下来介绍如何返回html信息。首先明确既然需要返回html信息，因此不能使用@RestController注解，同时有必要说明一下
@ResponseBody注解的作用，@ResponseBody注解的作用是将controller中方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML。所以需要将HelloController类中的@RestController修改为@Controller，但是你仅仅这样是不行的，因为你返回的对象无法通过视图解析器进行解析，因此还需要引入模板解析引擎thymeleaf（读做[taim li:f] ，也就是百里香的意思）。

第一步，在pom.xml文件中新增thymeleaf依赖：

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

第二步，在templates文件夹中新建index.html文件，里面的代码为：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
<h1>welcome to learn springboot!</h1>
</body>
</html>

第三步，使用thymeleaf模板，修改HelloController.java中的代码为：

package com.envy.luckymoney.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

@Controller
public class HelloController {

    @Autowired
    private InfoConfig infoConfig;

    @GetMapping("/hello")
    public String say(){
        return "index";
    }
}

启动项目，在浏览器地址栏输入http://localhost:8081/luckymoney/hello，可以看到信息：welcome to learn springboot!。这种模板渲染用的比较少，大部分都是前后端分离的模式。注释掉刚才增加的依赖和代码，我们继续回到之前的内容。

注意@ResponseBody注解的位置，如果你希望某个controller中的所有方法都是返回json，那么可以直接在controller类上使用@ResponseBody，如果其中某个方法需要返回内容，那么就建议只在某个需要返回json数据的方法上使用@ResponseBody注解。

链接访问问题

现在我们希望当你访问http://localhost:8081/luckymoney/hello和http://localhost:8081/luckymoney/hey这两个链接时，页面显示相同的信息，此时你可以在say方法上使用数组形式：

@GetMapping({"/hello","/hey"})
public String say(){
    return infoConfig.toString();
}

这样就能实现这个需求。现在又有一个需求，希望访问刚才的内容链接是：http://localhost:8081/luckymoney/hello/hey，你可能说这样操作不就可以了嘛？

@GetMapping("/hello/hey")
public String say(){
    return infoConfig.toString();
}

但是假如现在要求这个controller中的所有方法都是在/hello下访问，你可能说直接在controller类上加不就可以了嘛？

@RestController
@RequestMapping("/hello")
public class HelloController {
    /**
     * @RestController = @Controller+@ResopnseBody
     * **/

    @Autowired
    private InfoConfig infoConfig;

    @GetMapping("/hey")
    public String say(){
        return infoConfig.toString();
    }
}

这种确实是可以的。接下来说一下请求方式，这里面的say方法使用的是@GetMapping("/hey")，（@GetMapping是@RequestMapping(method = RequestMethod.GET)的缩写。）也就是说你只能以get方式来访问这个链接，同理当你配置了@PostMapping("/hey")注解就说明你只能以post方式来访问这个链接，有时候你不清楚这个链接应该是什么方式时，就可以使用@RequestMapping("/hey")注解（个人并不建议使用这种方式，因为post和get这两种方式的实现机制是不同的）。

在实际的请求中，往往是会携带参数的，此时你可以使用两个注解：@PathVariable用于获取url中的数据，而@RequestParam用于获取请求参数的值。

尝试修改HelloController类中的代码为：

@GetMapping("/hey/{id}")
public String say(@PathVariable("id") Integer id){
    return "id："+id;
}

然后在浏览器中输入http://localhost:8081/luckymoney/hello/hey/100，页面就会出现id:100字样。这种方式比较简洁，当然还有另外一种方式，继续修改代码为：

@GetMapping("/hey")
public String say(@RequestParam("id") Integer id){
    return "id："+id;
}

然后在浏览器中输入http://localhost:8081/luckymoney/hello/hey?id=100，页面就会出现id:100字样。需要注意的是，此时@RequestParam("id")中的id必须与url中的id名称保持一致，而Integer id中的id只是一个形参。

现在问题来了，如果不给id传值呢？访问一下url会发现页面报错了，说明此时需要修改say方法：

@GetMapping("/hey")
public String say(@RequestParam(value = "id",required = false,defaultValue = "0") Integer id){
    return "id："+id;
}

注意里面的defaultValue的值必须是String类型，同时需要说明的是无论你使用的是@GetMapping还是@PostMapping，@RequestParam注解都是可以正常使用的，因为框架对方法进行了兼容性设计。

数据库操作

这里我们使用了Spring-Data-Jpa来操作数据库，Jpa定义了一系列对象持久化的标准、目前实现这一规范的产品有Hibernate、TopLink等。也就是说SpringDataJPA就是springboot对Hibernate的整合，让开发者不用写一行SQL语句，就能实现对数据库的操作。

接下来进行RESTful API的设计，我们主要完成以下功能：1、使用GET方法去获取所有的红包列表，请求路径为/luckymoneys；2、使用POST方法去创建一个红包，请求路径为/luckymoneys；3、使用GET方法并携带id去查询某一个红包，请求路径为/luckymoneys/id；4、使用PUT方法并携带id去更新某一个红包，请求路径为/luckymoneys/id。

第一步，在pom.xml中引入jpa依赖（注意无需选择版本，springboot已经自动选择合适版本）：

<!--spring-data-jpa-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!--mysql数据库连接-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

第二步，在application-dev.yml中配置数据库连接信息：

# 数据库连接
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/luckymoney?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: root
  jpa:
    hibernate:
      ddl-auto: create
    show-sql: true

注意上面的几个参数com.mysql.cj.jdbc.Driver是新版的数据库驱动程序，而com.mysql.jdbc.Driver则是老版的；ddl-auto使用了create表示自动创建ddl语句；show-sql设置为true表示会在控制台显示执行的SQL语句。

第三步，创建luckymoney数据库，注意在Mac平台上建议mysql可视化工具使用Sequel Pro，Windows平台上建议使用Navicat。然后运行一下项目，当项目出现下面的界面时，表示运行没有问题：

第四步，新建Luckmoney.java类，里面用于定义实体信息：

package com.envy.luckymoney.controller;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import java.math.BigDecimal;

@Entity
public class Luckymoney {
    @Id
    @GeneratedValue
    private Integer id;  //红包id
    private BigDecimal money;  //红包金额
    private String sender;  //发送方
    private String receiver;  //接收方

    public Luckmoney(){};  //jpa要求必须提供无参数的构造方法

    public Integer getId() {
        return id;
    }

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

    public BigDecimal getMoney() {
        return money;
    }

    public void setMoney(BigDecimal money) {
        this.money = money;
    }

    public String getSender() {
        return sender;
    }

    public void setSender(String sender) {
        this.sender = sender;
    }

    public String getReceiver() {
        return receiver;
    }

    public void setReceiver(String receiver) {
        this.receiver = receiver;
    }
}

注意这里面使用到的三个注解：@Entity用于表明这个类是实体类，@Id和@GeneratedValue这两个注解必须加在字段id上面，用于表明id为数据表中的id，且为自增的。

然后再运行项目，并且请仔细观察控制台的输出信息：

然后刷新数据库，发现数据库中已经有两个表了，里面什么数据也没有：

当你在数据库中填写一些数据然后保存后，再次启动项目发现控制台依然输出上述图片的信息，而且数据库中新增的数据也被删除了，那是因为你在application-dev.yml中的ddl-auto设置为create了，也就是每次启动都会重新新建数据表。如果你将其修改为update，再次往数据库中填写一些数据，你会发现数据不会被删除了。

第五步，新建一个LuckymoneyRepository接口（注意这个其实就相当于Mybatis框架中的Dao层的接口，但是里面不需要书写抽象方法）：

package com.envy.luckymoney.controller;

import org.springframework.data.jpa.repository.JpaRepository;

//里面有两个参数，第一个是数据库的实体类名称，第二个是id的类型
public interface LuckymoneyRepository extends JpaRepository<Luckymoney,Integer> {
}

第六步，新建LuckymoneyController类，用于书写具体的方法：

@RestController
public class LuckymoneyController {

    @Autowired
    private LuckymoneyRepository luckymoneyRepository;

    /**
     * 获取红包列表
     * **/
    @GetMapping("/luckymoneys")
    public List<Luckmoney> list(){
        return luckymoneyRepository.findAll();
    }
}

你可能会好奇这里的findAll方法哪里来的，我们并没有在LuckymoneyRepository接口中定义啊，那是因为你继承了JpaRepository这个接口，而这个接口中就定义了findAll方法：

然后往数据库中新增一些数据，我这里新增了3条数据。最后运行项目，在浏览器地址栏中输入地址http://localhost:8081/luckymoney/luckymoneys,即可访问到刚才的信息（注意前面的luckymoney是contex-tpath）：

然后观察浏览器控制台输出类似的SQL语句（和平常的不太一样）：

1	Hibernate: select luckmoney0_.id as id1_0_, luckmoney0_.money as money2_0_, luckmoney0_.receiver as receiver3_0_, luckmoney0_.sender as sender4_0_ from luckmoney luckmoney0_

没有问题后，开始完成其余三个API的开发，LuckymoneyController.java类修改为以下代码：

package com.envy.luckymoney.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

@RestController
public class LuckymoneyController {

    @Autowired
    private LuckymoneyRepository luckymoneyRepository;

    /**
     * 获取红包列表
     * **/
    @GetMapping("/luckymoneys")
    public List<Luckymoney> list(){
        return luckymoneyRepository.findAll();
    }

    /**
     * 创建单个红包（发红包）
     * **/
    @PostMapping("/luckymoneys")
    public Luckymoney create(@RequestParam("sender")String sender,
                             @RequestParam("money")BigDecimal money){
        Luckymoney luckymoney = new Luckymoney();
        luckymoney.setSender(sender);
        luckymoney.setMoney(money);
        return luckymoneyRepository.save(luckymoney);
    }

    /**
     * 查询某一个红包
     * **/
    @GetMapping("/luckymoney/{id}")
    public Luckymoney findById(@PathVariable("id")Integer id){
        //optional类用于解决空指针问题，能查到信息就返回，查不到就返回null
        return luckymoneyRepository.findById(id).orElse(null);
    }

    /**
     * 更新某一个红包（领红包）
     * **/
    @PutMapping("/luckymoneys/{id}")
    public Luckymoney update(@PathVariable("id")Integer id,
                             @RequestParam("receiver")String receiver
                             ){
        //先根据Id去查红包是否存在
        Optional<Luckymoney> optional=luckymoneyRepository.findById(id);
        if(optional.isPresent()){
            Luckymoney luckymoney = optional.get();
            luckymoney.setReceiver(receiver);
            return luckymoneyRepository.save(luckymoney);
        }
        return null;
    }
}

然后运行项目，如果发现出现数据无法插入的问题，请删除之前数据表中手动新增的数据，或者说直接删除数据表，因为jpa会先根据hibernate_sequence这个表中的next_val来获取下一个数据的id，所以你手动添加的会导致获取到的next_val值与实际数据表中的数据不一致的问题。

再强调一下就是@PathVariable用于获取url中的数据，即用于指定url中的参数，而@RequestParam用于获取请求参数的值，即需要你往URL中提交的数据）

事务管理

数据库事务是指作为单个逻辑工作单元执行的一系列操作，要么完全执行，要么就完全不执行，不存在一部分执行，一部分不执行的情况。现在你需要发一个红包，如果发5201314那这个金额就太大了，因此你希望可以分两次发送，一次520，一次1314。为了完成这个任务，使用MVC设计模式，引入Service层，新建service包，接着在里面新建一个LuckymoneyService类，里面的代码为：

package com.envy.luckymoney.service;

import com.envy.luckymoney.controller.Luckymoney;
import com.envy.luckymoney.controller.LuckymoneyRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;

@Service
public class LuckymoneyService {
    @Autowired
    private LuckymoneyRepository luckymoneyRepository;

    public void createTwo(){
        Luckymoney luckymoney1 = new Luckymoney();
        luckymoney1.setSender("小不");
        luckymoney1.setMoney(new BigDecimal("520"));
        luckymoneyRepository.save(luckymoney1);

        Luckymoney luckymoney2 = new Luckymoney();
        luckymoney2.setSender("小不");
        luckymoney2.setMoney(new BigDecimal("1314"));
        luckymoneyRepository.save(luckymoney2);
    }
}

然后在LuckymoneyController类中新增一个方法，用于一次创建两个红包：

@PostMapping("/luckymoneys/two")
   public void createTwo(){
       luckymoneyService.createTwo();
   }

然后运行项目，测试链接http://localhost:8081/luckymoney/luckymoneys/two，发现数据库中已经有了两条数据。

现在开始测试事务，我们要求一次发送520，一次是1314，两者必须一块发，不能只发一个，同时假设数据库中money的位数限制为5位（小数和整数一起算），也就是最大发送999.99元（如果修改为5后数据表保存不了，请将1314那条记录给删除）：

然后删除刚才添加的两条数据，同时在Service的方法createTwo上面添加@Transactional事务注解，接着重新运行项目，看数据表中是否已经有数据，你会发现数据库中还是插入了520那条记录，说好的事务不是要么执行，要么不执行的嘛？上面的520.00满足5位数限制，1314.00不满足，那么应该就是都不会执行啊，怎么还会插入数据到数据库中呢？

其实你说的没错，不过这里所说的事务其实是mysql数据库的事务，并不是Java程序的事务，使用了@Transactional事务注解只是说这个方法具有了事务的特性，可以支持提交、回滚等操作，最终需要提交到数据库，所以需要数据库支持事务才行。而这里我们的mysql使用的引擎是MyISAM，它是不支持事务的，所以需要更换引擎为InnoDB。查看当前数据库支持的引擎和默认的数据库引擎命令为：

1	show engines;

可以使用SQL命令来修改数据表的引擎：

1	alter table luckmoney ENGINE=InnoDB;

查看当前表的创建语句命令为：

1	show create table luckmoney;

修改后才发现事务才启用了。