SpringBoot

一、SpringBoot

SpringBoot采用习惯优于配置的理念快速的搭建项目开发环境，我们无需或者很少进行相关的Spring配置，就能够快速的将项目运行起来
优点：
1.快速构建项目
2.对主流的开发框架都提供无配置集成，无需手动配置
3.项目可以独立运行、无需依赖servlet容器（内置了servlet容器）
4.极大提高了开发、部署效率
5.提供了运行时的监控系统
6.与云计算有天然的集成
缺点：
1.版本迭代速度很快，一些模块改动较大
2.由于配置都是内置的，所以报错时很难定位
3.互联网上现成的解决方案资源并不多

二、SpringBoot项目结构说明

SpringbootDemo1Application 程序入口
resources:1.static(静态资源文件夹 存储图片、css、JS…)2.templates（存放模板资源的目录,thymeleat）3.application.properties（SpringBoot项目的全局配置文件 实际项目开发中通常修改为yaml语言支持 后缀改为yml）
.gitignore:Git过滤配置文件（忽略）
pom.xml(Maven的依赖管理配置文件)

三、SpringBoot的全局配置

1.SpringBoot项目创建使用了一个全局配置文件application.properties进行项目相关的配置
2.如果Spring默认的设置无法满足要求，就可以进行修改

# application.properties文件中配置的 key 必须遵守SpringBoot的要求
# 应用名称
spring.application.name=SpringBoot-Demo1
# 应用服务 WEB 访问端口
server.port=8080

3.SpringBoot默认的属性设置
4.全局配置文件格式也支持yml，并且在开发的过程中也经常使用yml格式进行配置(yaml语言)
application.properties 和 application.yml 对比

application.properties
# 应用服务 WEB 访问端口
server.port=8080
  # 配置全局路径
server.servlet.context-path=/demo1

  spring.datasource.url=1
  spring.datasource.username=1
  spring.datasource.password=1
  spring.datasource.driver-class-name=1
application.yml
server:
  port:8080
  sevlet:
    context-path: /demo1

spring:
  datasource:
    url: 1
    user-name:(空格)1
    password: 1
    driver-class-name: 1

四、Java配置方式

对于SpringBoot提倡的是无xml文件管理
1.如何将一个类交给Spring容器管理呢？
1.xml
<bean id="user" class="com.lxr.springboot.demo1.bean.User></bean>"
2.注解配置
@Component
3.Java配置
基于Java的配置方式
闯将config包，下创建MyConfig类

package com.example.springbootdemo1.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Date;


//加上@Configuration相当于一个配置文件
@Configuration
public class MyConfig {
    
    //在Spring容器中引入Data对象
    @Bean
    public Date getData(){
        return new Date();
    }
}

五、Starter POM

Starter POM，是指在pom文件中配置的SpringBoot提供的starter
1.一个Stater我们就可以理解为对一种开发场景的支持
2.SpringBoot为我们提供了简化企业级开发绝大多数场景的支持（多个StarterPOM），在我们的项目中只要使用了对应场景的StarterPOM,相关的技术配置就会被内置进来，同时我们就可以获得SpringBoot为我们提供的内置的Bean
例：
在pom.xml引入redis对应的starter

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

在servcie中就可以直接使用SpringBoot内置的基于redis的开发场景（直接使用bean）

@Service
public class RedisService {
    @Resource
    private RedisTemplate redisTemplate;
}

3.SpringBoot支持绝大多数的主流框架（提供对应的starter）

六、SpringBoot常用注解

6.1 @SpringBootApplication

SpringBoot项目都有一个Applicatin入口类，入口类中都是有main方法的，在此添加@SpringBootApplicatin表示是当前应用的入口程序
@SpringBootApplicatin是一个组合注解：
@SpringBootConfiguration：继承了@Configuration注解，并且作用一致，都是用来声明当前类为一个Java配置类
@EnableAutoConfiguration：启用SpringBoot内置的自动配置功能
@ComponentScan：扫描bean，扫描范围是当前应用的入口程序所在的包

6.2 @SpringBootConfiguration

继承了@Configuration注解，并且作用一致，都是用来声明当前类为一个Java配置类

6.3 @EnableAutoConfiguration

启用SpringBoot内置的自动配置功能

6.4 @ComponentScan

扫描bean，扫描范围是当前应用的入口程序所在的包

6.5 IoC注解

6.5.1 组件注册

@Component 普通组件注册 把这个类注册到Spring里面
@Controller MVC控制层注解
@Service 业务逻辑层组件注册
@Repository 持久层组件注册

6.5.2 依赖注入注解

@Autowired/@Inject：类型注入
@Qualifier：名字注入
@Resouce：名字注入

6.5.3 bean作用域，生命周期

@Scope
@PostConstruct
@PreDestory

6.6 SpringMVC注解

@Controller
@RestController
@RequestMapping
@RequestBody
@ResponseBody
@PathVariable

七、基于SpringBoot的SSM开发

7.1 Spring支持

SpringBoot项目本身就是依赖于Spring的，所以当我们创建SpringBoot之后，Spring的支持就默认导入了，也就是说，只要SpringBoot项目能够启动就默认支持Spring(IoC/AOP)

7.2 SpringMVC支持

7.3 Druid支持

1.添加依赖 druid-spring-boot-starter（1.1.10）

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.10</version>
</dependency>

2.添加mysql数据库驱动依赖

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

3.在全局配置文件中配置数据库连接池

spring:
  datasource:
    druid:
      url: jdbc:mysql://localhost:3306/db2
      dirver-class-name: com.mysql.cj.jdbc.Driver
      username: root
      password: 
      initial-size: 1
      min-idle: 3
      max-active: 20
mybatis:
  mapper-locations: classpath:mappers/*Mapper.xml
  type-aliases-package: com.example.springbootssm.beans

7.4 MyBatis支持

1.添加MyBatis依赖

<!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.3</version>
</dependency>

2.在全局配置文件中配置

mybatis:
  mapper-locations: classpath:mappers/*Mapper.xml
  type-aliases-package: com.example.springbootssm.beans

7.5 测试

1.创建数据表

create table tb_book(
    book_id int primary key auto_increment,
    book_name varchar(100) not null,
    book_author varchar(50) not null,
    book_price float not null,
    book_desc varchar(200)
)

2.创建实体类

public class Book {
    private int bookId;
    private String bookName;
    private String bookAuthor;
    private double bookPrice;
    private String bookDesc;
}

3.创建DAO接口

public interface BookDAO {
    
    void insertBook(Book book);
    
    List<Book> listBooks();
    
}

4.创建映射文件

<?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="com.example.springbootssm.dao.BookDAO">
    
    <insert id="insertBook" parameterType="Book" useGeneratedKeys="true" keyProperty="bookId">
        insert into tb_book (book_name,book_author,book_price,book_desc)
        values (#{bookName},#{bookAuthor},#{bookPrice},#{bookDesc});
    </insert>
    
    <resultMap id="bookMap" type="Book">
        <id column="book_id" property="bookId"/>
        <result column="book_name" property="bookName"/>
        <result column="book_author" property="bookAuthor"/>
        <result column="book_price" property="bookPrice"/>
        <result column="book_desc" property="bookDesc"/>
    </resultMap>
    
    <select id="listBook" resultMap="bookMap" resultSets="java.util.List">
        select book_name,book_author,book_price,book_desc 
        from tb_book
    </select>
</mapper>
5.单元测试

```java
package com.example.springbootssm.dao;

import com.example.springbootssm.SpringbootSsmApplication;
import com.example.springbootssm.beans.Book;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootSsmApplication.class)
public class BookDAOTest {

    @Resource
    private BookDAO bookDAO;

    @Test
    public void testInsertBook(){
        Book book = new Book(0,"C++","赵武",22.2,"暂无");
        bookDAO.insertBook(book);
        System.out.println(book.getBookId());
    }

    @Test
    public void testListBooks(){
        List<Book> books = bookDAO.listBooks();
        for(Book i : books){
            System.out.println(i);
        }
    }
}

7.6 Mapper注册

方案一：在DAO接口添加 @Mapper
方案二：在application添加 @MapperScan(basePackages = "com.example.springbootssm.dao")

全局异常处理

1.创建全局异常处理类，添加@ControllerAdvice
2.在异常处理类中提供处理方法

package com.example.springbootssm.utils;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

@ControllerAdvice
public class GlobalExceptionHandler {


    @ExceptionHandler
    @ResponseBody
    public String exceptionHanler(Exception e){
        String message = e.getMessage();
        System.out.println("----------" + message);
        //根据不同的异常类型进行不同的处理
        return message;
    }
}

八、Thymeleaf

Thymeleaf是一个用于前端数据显示的模板引擎，完全可以替代jsp同时弥补了jsp的不足
特点：
1.基于HTML的动态网页（一个thymeleaf就是一个HTML页面）
2.基于浏览器运行可以看到静态效果，同时基于服务器运行的时候可以动态显示数据
3.开发便捷、效率高

8.1 Thymeleaf基本使用

1.配置相关参数
2.创建控制器

package com.lxr.springbootthymeleaf.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class TestController {

    @RequestMapping("/test")
    public String test1(Model model){
        System.out.println("nulllllll");
        model.addAttribute("str","从控制器传递到页面的参数");
        return "index";
    }
}

3.创建对应的HTML
HTML文件放在emplates
在HTML文件的html标签中引入th命名空间
通过th标签可以获取动态数据(从控制器传递到HTML数据)

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
123
<label th:text="${str}"></label>
</body>
</html>

8.2 Thymeleaf的基本语法

8.2.1 获取变量值

1.简单数据
<tag th:text="${ket}"></tag>
2.对象数据
<p th:text="${book.bookName}"></p>

8.2.2 运算符

算术运算，关系运算，三元运算 都可以

<p th:text=""原价："+${book.bookPrice}"></p>

<p th:text="'折扣价：'+${book.bookPrice} * 0.8"></p>

8.2.3 *号的使用

代表object这个对象

<div th:object="${book}">
    <p th:text="*{bookName}"></p>
    <p th:text="*{bookPrice}"></p>
</div>

8.2.4 内敛使用

1.可以在HTML标签里面完成取值

<label th:text="${str}"></label>

<label th:inline="text">[[${str}]]</label>

2.在javascript中获取传递的值

<script type="text/javascript" th:inline="javascript">
    var s = [[${str}]];
    alert(s);
</script>

3.在style标签内部取值

<style type="text/css" th:inline="css">
    div{color: [[${clolr}]]};
</style>

8.3 流程控制

8.3.1 分支语句（条件）

1.if：条件成立执行
<label th:if="${book.bookPrice} > 20">贵了</label>
2.unless：条件不成立执行
<label th:unless="${book.bookPrice} >=30">贵了</label>
3.switch

<div th:switch="${book.bookId}">
         <p th:case="101">1</p>
         <p th:case="102">2</p>
         ......
         <p th:case="*">前面都不成立</p>
</div>

8.3.2 循环语句

<table>
    <caption>图书信息列表</caption>
    <tr>
        <th>编号</th>
        <th>名称</th>
        <th>作者</th>
        <th>价格</th>
    </tr>

    <tr th:each="i:${books}">
        <td th:text="${i.bookId}"></td>
        <td th:text="${i.bookName}"></td>
        <td th:text="${i.bookAuthor}"></td>
        <td th:text="${i.bookPrice}"></td>
    </tr>
</table>

8.4 Thymeleaf的碎片使用

8.4.1 什么是碎片？

碎片指的是html片段，我们可以将多个页面使用的相同的GTML标签部分单独定义(head.html、foot.html)，然后通过th:include可以在需要使用这个HTML片段的页面进行引用
就是可以拼接页面
head.html 碎片1
foot.html 碎片2

页面1：
<div th:include="head::碎片名称"></div>
当前页面
<div th:include="foot::碎片名称"></div>

8.4.2 使用

1.引用页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>


</head>
<body>


<div id="header" th:include="head::fragment1"></div>

<div id="content">
.......
</div>

include是使用碎片标签中的内容填充当前标签
replace是使用碎片标签替代当前标签

<div id="footer" th:replace="foot::fragement2"></div>
</body>
</html>

2.head页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div style="background: pink" th:fragment="fragment1">
  this is header!
</div>
</body>
</html>

九、SpringBoot的热部署配置

9.1 什么是热部署？

项目首次部署，服务器启动后，如果项目发生了更改就自动的完成jar的更新，而无需重写手动启服务器。

9.2 热部署配置

9.2.1 IDE配置(idea)

1.File—>Settings->compiler–>勾选Build project automatically
2.返回页面 然后找到Registry 勾选compiler.automake.allow.when.app.running

9.2.2 在项目中配置

1.添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

2.配置Maven插件：

<plugin>
          <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.3.7.RELEASE</version>
            <configuration>
                <mainClass>com.lxr.springbootthymeleaf.SpringbootThymeleafApplication</mainClass>
                <!--添加这个，显示声明编译版本配置有效-->
                <fork>true</fork>
            </configuration>
            <executions>
                <execution>
                    <id>repackage</id>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>

3.配置服务器更新范围

十、tkMapper（tk.mybatis）

10.1 tkMapper是什么？

1.MyBatis完成持久化操作需要：建库建表，创建实体类bean，创建Mapper接口(DAO接口)，创建并配置映射文件
2.tkMapper是一个MyBatis插件，是在MyBatis的基础上提供了很多工具，让开发变得更高效
3.针对单表操作可以实现无操作配置（不用写在映射文件-不用写SQL）
4.支持逆向工程（根据数据表生成beans、生成mapper接口、映射文件）

10.2 在SpringBoot项目中整合tkMapper

1.整合数据库连接池

<dependency>
   <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.10</version>
</dependency>

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

spring:
  datasource:
    druid:
      url: jdbc:mysql://localhost:3306/db2
      dirver-class-name: com.mysql.cj.jdbc.Driver
      username: root
      password:
      initial-size: 1
      min-idle: 3
      max-active: 20

2.整合tkMapper

<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>2.1.5</version>
</dependency>

mybatis:
  mapper-locations: classpath:mappers/*Mapper.xml
  type-aliases-package: com.lxr.springboottkmapper.beans

3.创建GeneralMapper接口

import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.common.MySqlMapper;

//此GeneralMapper不能被@MapperScan扫描到
public interface GeneralMapper<T> extends Mapper<T>, MySqlMapper<T> {

}

4.在SpringBoot应用启动类添加MapperScan注解
添加tk.mybatis包的注解

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;

@SpringBootApplication
@MapperScan(basePackages = "com.lxr.springboottkmapper.dao")
public class SpringbootTkmapperApplication {

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

}

10.3 tkMapper使用

1.创建数据表

create table book(
    book_id int primary key auto_increment,
    book_name varchar(100) not null ,
    book_author varchar(20) not null,
    book_price float not null,
    book_desc varchar(200)
);

2.创建Bean(所有的属性如果是简单类型则使用其对应的封装类，否则不会生成sql)

package com.lxr.springboottkmapper.beans;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
//如果不一致
//@Table(name = "数据库表的名字")
public class Book {
    //注意主键声明@Id
    @Id
    //@Column(name = "数据库表里的名字")
    private Integer bookId;
    private String bookName;
    private String bookAuthor;
    private Double bookPrice;
    private String bookDesc;
}

3.创建DAO接口
创建接口，继承tk包提供的Mapper接口和MySQLMapper接口
指定当前DAO接口要操作的bean

package com.lxr.springboottkmapper.dao;

import com.lxr.springboottkmapper.beans.Book;
import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.common.MySqlMapper;

public interface BookDAO extends Mapper<Book>, MySqlMapper<Book> {
    //定义需要完成的操作方法
}

4.测试使用

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootTkmapperApplication.class)
public class BookDAOTest {

    @Resource
    private BookDAO bookDAO;

    //测试添加操作
    @Test
    public void testInsert(){
        Book book = new Book(0,"Java","wangwu",22.2,"none");

        int i = bookDAO.insert(book);
         
        System.out.println(i);
    }
}

10.4 删改

1.删

 public void testDelete(){
        //1.根据主键删除一条数据
        //int i = bookDAO.deleteByPrimaryKey(1);

        //Example类用来构造删除函数、修改及查询操作的条件
        Example example = new Example(Book.class);
        Example.Criteria criteria = example.createCriteria();//内部类
        //通过criteria对象构造执行条件
        criteria.andEqualTo("bookName","C++");

        //可以多条件查询
        criteria.orEqualTo("bookAuthor","zhangsan");

        criteria.orBetween("bookPrice",10,20);
        //3.直接通过sql写
        //criteria.andCondition("name = 'Java' and ...");
        //根据指定的条件进行删除
        int i = bookDAO.deleteByExample(example);
        System.out.println(i);
    }

2.改

public void testUpdate(){
        Book book = new Book(7,"Java","zhangsan",22.22,"无");
       //1.根据bean中的主键修改（bean对象中一定要有@Id声明的主键）
        int i =bookDAO.updateByPrimaryKey(book);
        //2.修改满足example指定的条件的数据
        //bookDAO.updateByExample(book,example)
        System.out.println(i);
    }

10.5 查

@Test
    public void testSelect(){
        //1.返回数据表中的记录
        int i = bookDAO.selectCount(new Book());
        //查询满足条件的图书信息记录数
        //int j = bookDAO.selectCountByExample(example);
        System.out.println(i);

        //2.查询所有的图书信息
        List<Book> books = bookDAO.selectAll();
        System.out.println(books);

        //3.根据主键查询一条记录
        Book book = bookDAO.selectByPrimaryKey(3);

        //4.根据指定的条件进行查询
        //List<Book> books1 = bookDAO.selectByExample(exmale);
    }

    @Test
    public void testPage(){
        int pageNum = 1;
        int pageSize = 3;

        RowBounds rowBounds = new RowBounds((pageNum-1)*pageSize,pageSize);

        //无条件分页查询
        List<Book> books = bookDAO.selectByRowBounds(new Book(),rowBounds);

        for(Book i :books){
            System.out.println(i);
        }

        //带条件分页查询
        //List<Book> books1 = bookDAO.selectByExampleAndRowBounds(example,rowBounds);
        
    }

10.6 逆向工程

根据数据表生成bean、DAO和Mapper

十一、Swagger

前后端分离开发，后端需要编写接口说明文档，会耗费比较多的时间
swagger是一个用于生成服务器接口的规范性文档，并且能够对接口进行测试的工具

10.1 作用

1.生成接口说明文档
2.对接口进行测试

10.2 整合

1.添加依赖（Swagger2\Swagger UI）(2.9.2)

<!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>

<!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>

在api子工程添加依赖
2.在api子工程创建swagger的配置（Java配置方式）

package com.lxr.shopping_mall2.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    //swagger会帮助我们生成接口文档
    //1.配置文档信息
    //2.配置生成规则

    //Docket封装接口文档信息
    @Bean
    public Docket getDocket(){
        Docket docket = new Docket(DocumentationType.SWAGGER_2);//指定文档风格

        //创建封面信息对象
        ApiInfoBuilder apiInfoBuilder = new ApiInfoBuilder();
        apiInfoBuilder.title("《商城后端接口说明书》")
                .description("此文档详细说明了商城后端接口规范")
                .version("v 1.0.1")
                .contact( new Contact("lixingrui","www.lixingrui.com","419690112@qq.com") );

        ApiInfo apiInfo = apiInfoBuilder.build();
        docket.apiInfo(apiInfo)//指定生成的文档中的封面信息：文档标题，版本，作者
        .select()
        .apis(RequestHandlerSelectors.basePackage("com.lxr.shopping_mall2.controller"))
        .paths(PathSelectors.any())
        .build();
        return docket;
    }

}

测试：启动项目 输入网址http://localhost:8080/swagger-ui.html

10.3 Swagger注解说明

swagger提供了一套注解，可以对每个接口进行详细说明

1.@Api 类注解，在控制器添加此类注解，可以对控制器类进行功能说明

@Api(value = "提供用户的登录和注册接口",tags = "用户管理")

2.@ApiOperation 方法注解，说明接口方法的作用
3.@ApiImplicitParams 和 @ApiImplicitParam
方法注解，说明接口方法的参数

@ApiOperation(value = "用户登录接口")
@ApiImplicitParams({
        @ApiImplicitParam(dataType = "string",name ="name",value = "用户名",required = true),
        @ApiImplicitParam(dataType = "string",name ="pwd",value = "用户密码",required = true),
})
@RequestMapping("/login")
public ResultVO login(String name,String pwd){
    return userService.checkLogin(name,pwd);
}

4.ApiModel和ApiModelProperty 当接口参数和返回值为对象类型时，在实体类中添加注解说明

package com.lxr.shopping_mall2.entity;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
@ApiModel(value = "User对象",description = "用户/买家信息")
public class User {

    @ApiModelProperty(dataType = "int",required = false)
    private int userId;
    @ApiModelProperty(dataType = "String",required = true,value = "用户注册账号")
    private String userName;
    @ApiModelProperty(dataType = "String",required = true,value = "用户注册密码")
    private String userPwd;
    @ApiModelProperty(dataType = "String",required = true,value = "用户真实姓名")
    private String userRealname;
    @ApiModelProperty(dataType = "String",required = true,value = "用户头像url")
    private String userImg;
}

5.@ApiIgnore 接口方法注解，添加此注解的方法将不会生成到接口文档中

10.4 RESTful

前后端分离开发的项目中，前后端之间是通过接口进行请求和响应的，后端向前端提供请求时，就要对外暴露一个URL；URL不是随意的，需要遵从一定的设计规范-RESTful
RESTful 是一直Web api的标准，也就是一种url设计风格/规范
每个URL请求路径代表服务器标准，也就是⼀种url设计⻛格/规范

传统的URL设计：
 http://localhost:8080/goods/delete?goodsId=1 商品1
 http://localhost:8080/goods/delete?goodsId=2 商品2
RESTful设计：
 http://localhost:8080/goods/delete/1 商品1
 http://localhost:8080/goods/delete/2 商品2
 
@RequestMapping("/delete/{gid}")
public ResultVO deleteGoods(@PathVariable("gid") int goodsId){
 System.out.println("-----"+goodsId);
 return new ResultVO(10000,"delete success",null);
}

使⽤不同的请求⽅式表示不同的操作：
post 添加
get 查询
put 修改
delete 删除
option (预检)

根据ID删除⼀个商品：
//http://localhost:8080/goods/1 [delete]
@RequestMapping(value = "/{id}",method = RequestMethod.DELETE)
public ResultVO deleteGoods(@PathVariable("id") int goodsId){
 System.out.println("-----"+goodsId);
 return new ResultVO(10000,"delete success",null);
}
根据ID查询⼀个商品：
//http://localhost:8080/goods/1 [get]
@RequestMapping(value = "/{id}",method = RequestMethod.GET)
public ResultVO getGoods(@PathVariable("id") int goodsId){
 return null;
}

SpringMVC对RESTful⻛格提供了很好的⽀持，在我们定义⼀个接⼝的URL时，可以通过
@RequestMapping(value="/{id}",method=RequestMethod.GET) 形式指定请求⽅式，也可使⽤
特定请求⽅式的注解设定URL
@PostMapping("/add")
@DeleteMapping("/{id}")
@PutMapping("/{id}")
@GetMapping("/{id}")

接⼝响应的资源的表现形式采⽤JSON
在控制类或者每个接⼝⽅法添加 @ResponseBody 注解将返回的对象格式为json
或者直接在控制器类使⽤ @RestController 注解声明控制器
前端(Android\ios\pc)通过⽆状态的HTTP协议与后端接⼝进⾏交互