spring-boot-实例教程

spring-boot-实例教程

源码下载

https://download.csdn.net/download/chinaxsw/19758950

1.项目数据库表

mysql数据库 spring-boot-demo

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for admin
-- ----------------------------
DROP TABLE IF EXISTS `admin`;
CREATE TABLE `admin`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Table structure for products
-- ----------------------------
DROP TABLE IF EXISTS `products`;
CREATE TABLE `products`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `price` decimal(10, 2) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

2.新建maven项目 spring-boot-demo

设置项目JDK(略)

设置项目maven(略)

项目pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!--SpringBoot依赖-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/>
    </parent>

    <!--项目信息-->
    <groupId>org.wenqu</groupId>
    <artifactId>spring-boot-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <!--统一管理版本号-->
    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <mysql-connector-java.version>8.0.22</mysql-connector-java.version>
        <mybatis-plus-boot-starter.version>3.4.1</mybatis-plus-boot-starter.version>
        <hikaricp.version>3.4.5</hikaricp.version>
        <lombok.version>1.18.16</lombok.version>
        <fastjson.version>1.2.75</fastjson.version>
        <commons-lang3.version>3.11</commons-lang3.version>
    </properties>

    <dependencies>
        <!-- Spring Boot -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- DataSource -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-connector-java.version}</version>
        </dependency>
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>${hikaricp.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
            <exclusions>
                <!-- 排除 tomcat-jdbc 以使用 HikariCP -->
                <exclusion>
                    <groupId>org.apache.tomcat</groupId>
                    <artifactId>tomcat-jdbc</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus-boot-starter.version}</version>
        </dependency>

        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>

        <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>

        <!--commons-lang3-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons-lang3.version}</version>
        </dependency>
    </dependencies>

    <!--项目打包-->
    <build>
        <finalName>spring-boot-demo</finalName>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <excludes>
                    <exclude>**/*.java</exclude>
                </excludes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                    <addResources>true</addResources>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

项目application.yml

server:
  # 端口
  port: 9000

spring:
  application:
    name: spring-boot-demo
  # 连接mysql数据库
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/spring-boot-demo?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: wenqu555

  mybatis-plus:
    # 扫描 mapper.xml
    mapper-locations: classpath:/mapper/*Mapper.xml
    configuration:
      jdbc-type-for-null: 'null'

3.项目启动文件

com.wenqu.demo.DemoApplication.java

package com.wenqu.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

4.项目domain层(可用工具生成)

com.wenqu.demo.domain.Admin.java

package com.wenqu.demo.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import lombok.Data;

@Data
@TableName(value = "`admin`")
public class Admin implements Serializable {
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @TableField(value = "username")
    private String username;

    @TableField(value = "password")
    private String password;

    private static final long serialVersionUID = 1L;
}

com.wenqu.demo.domain.products.java

package com.wenqu.demo.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import lombok.Data;

@Data
@TableName(value = "products")
public class Products implements Serializable {
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @TableField(value = "name")
    private String name;

    @TableField(value = "price")
    private BigDecimal price;

    private static final long serialVersionUID = 1L;
}

5.项目mapper层(可用工具生成)

com.wenqu.demo.mapper.AdminMapper.java

package com.wenqu.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.wenqu.demo.domain.Admin;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface AdminMapper extends BaseMapper<Admin> {
}

com.wenqu.demo.mapper.ProductsMapper.java

package com.wenqu.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.wenqu.demo.domain.Products;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface ProductsMapper extends BaseMapper<Products> {
}

6.项目service层(可用工具生成)

com.wenqu.demo.service.AdminService.java

package com.wenqu.demo.service;

import com.wenqu.demo.domain.Admin;
import com.baomidou.mybatisplus.extension.service.IService;
public interface AdminService extends IService<Admin>{

}

com.wenqu.demo.service.ProductsService.java

package com.wenqu.demo.service;

import com.wenqu.demo.domain.Products;
import com.baomidou.mybatisplus.extension.service.IService;
public interface ProductsService extends IService<Products>{

}

7.项目service实现层(可用工具生成)

com.wenqu.demo.service.impl.AdminServiceImpl.java

package com.wenqu.demo.service.impl;

import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.wenqu.demo.mapper.AdminMapper;
import com.wenqu.demo.domain.Admin;
import com.wenqu.demo.service.AdminService;
@Service
public class AdminServiceImpl extends ServiceImpl<AdminMapper, Admin> implements AdminService{

}

com.wenqu.demo.service.impl.ProductsServiceImpl.java

package com.wenqu.demo.service.impl;

import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.wenqu.demo.mapper.ProductsMapper;
import com.wenqu.demo.domain.Products;
import com.wenqu.demo.service.ProductsService;
@Service
public class ProductsServiceImpl extends ServiceImpl<ProductsMapper, Products> implements ProductsService{

}

9.项目*Mapper.XML(可用工具生成)

src/main/resources/mapper/AdminMapper.xml

<?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.wenqu.demo.mapper.AdminMapper">
  <resultMap id="BaseResultMap" type="com.wenqu.demo.domain.Admin">
    <!--@mbg.generated-->
    <!--@Table `admin`-->
    <id column="id" jdbcType="BIGINT" property="id" />
    <result column="username" jdbcType="VARCHAR" property="username" />
    <result column="password" jdbcType="VARCHAR" property="password" />
  </resultMap>
  <sql id="Base_Column_List">
    <!--@mbg.generated-->
    id, username, `password`
  </sql>
</mapper>

src/main/resources/mapper/ProductsMapper.xml

<?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.wenqu.demo.mapper.ProductsMapper">
  <resultMap id="BaseResultMap" type="com.wenqu.demo.domain.Products">
    <!--@mbg.generated-->
    <!--@Table products-->
    <id column="id" jdbcType="BIGINT" property="id" />
    <result column="name" jdbcType="VARCHAR" property="name" />
    <result column="price" jdbcType="DECIMAL" property="price" />
  </resultMap>
  <sql id="Base_Column_List">
    <!--@mbg.generated-->
    id, `name`, price
  </sql>
</mapper>

10.建立统一返回信息类

com.wenqu.demo.Result

package com.wenqu.demo.domain;

import lombok.Data;

import java.io.Serializable;

/**
 * 通用数据传输对象
 */
@Data
public class Result<T> implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 状态码
     */
    private Integer code;

    /**
     * 消息
     */
    private String message;

    /**
     * 返回对象
     */
    private T data;

    /**
     * 构造方法
     */
    public Result() {
        super();
    }

    public static Result success(){
        Result result = new Result();
        result.setCode(ResultCode.SUCCESS);
        result.setMessage("success");
        return result;
    }

    public static Result error(){
        Result result = new Result();
        result.setCode(ResultCode.ERROR);
        result.setMessage("error");
        return result;
    }

    public Result data(T data) {
        this.setData(data);
        return this;
    }

    public Result(Integer code, String message) {
        super();
        this.code = code;
        this.message = message;
    }

    public Result(Integer code, T data) {
        super();
        this.code = code;
        this.data = data;
    }

    public Result(Integer code, String message, T data) {
        super();
        this.code = code;
        this.message = message;
        this.data = data;
    }

    /**
     * 通用状态码
     */
    public interface ResultCode {
        //通用成功
        public static Integer SUCCESS = 2000;
        //通用失败
        public static Integer ERROR = 4000;
    }
}

11.项目controller层

com.wenqu.demo.controller

package com.wenqu.demo.controller;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.wenqu.demo.domain.Admin;
import com.wenqu.demo.domain.Product;
import com.wenqu.demo.domain.Result;
import com.wenqu.demo.service.AdminService;
import com.wenqu.demo.service.ProductService;
import com.wenqu.demo.utils.JwtUtil;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping(value="/api")
public class DemoController {
    @Resource
    private AdminService adminService;
    @Resource
    private ProductService productService;

    /**
     * hello测试
     * @return
     */
    @GetMapping(value = "hello")
    public Result hello(){
        return Result.success().data("hello");
    }

    /**
     * 保存数据Admin
     * @param admin
     * @return
     */
    @PostMapping(value = "admin/save")
    public Result saveAdmin(@RequestBody Admin admin){
        boolean flag = adminService.save(admin);
        if(flag){
            return Result.success().data(admin);
        }else{
            return Result.error();
        }
    }

    /**
     * 删除数据Admin
     * @param id
     * @return
     */
    @PostMapping(value = "admin/remove")
    public Result removeAdmin(Integer id){
        boolean flag = adminService.removeById(id);
        if(flag){
            return Result.success();
        }else{
            return Result.error();
        }
    }

    /**
     * 更新数据Admin
     * @param admin
     * @return
     */
    @PostMapping(value = "admin/update")
    public Result updateAdmin(@RequestBody Admin admin){
        boolean flag = adminService.updateById(admin);
        if(flag){
            return Result.success().data(admin);
        }else{
            return Result.error();
        }
    }

    /**
     * 登录查询login
     * @param admin
     * @return
     */
    @PostMapping(value = "admin/login")
    public Result login(@RequestBody Admin admin){
        QueryWrapper<Admin> qw = new QueryWrapper<>();
        qw.eq("username", admin.getUsername()).eq("password", admin.getPassword());
        List<Admin> list = adminService.list(qw);
        if(list.size()>0){
            Map<String, Object> map = new HashMap<>();
            Map<String, String> payload = new HashMap<>();
            payload.put("username", list.get(0).getUsername());
            String token = JwtUtil.getToken(payload);
            map.put("status", true);
            map.put("msg", "认证成功");
            map.put("token", token);
            map.put("admin", list.get(0));
            return Result.success().data(map);
        }else{
            return new Result(Result.ResultCode.ERROR,"账号或密码错误");
        }
    }

    /**
     * 保存数据Product
     * @param product
     * @return
     */
    @PostMapping(value = "product/save")
    public Result saveProduct(@RequestBody Product product){
        boolean flag = productService.save(product);
        if(flag){
            return Result.success().data(product);
        }else{
            return Result.error();
        }
    }

    /**
     * 保存数据Product
     * @param id
     * @return
     */
    @PostMapping(value = "product/remove")
    public Result removeProduct(Integer id){
        boolean flag = productService.removeById(id);
        if(flag){
            return Result.success();
        }else{
            return Result.error();
        }
    }

    /**
     * 更新数据Product
     * @param product
     * @return
     */
    @PostMapping(value = "product/update")
    public Result updateProducts(@RequestBody Product product){
        boolean flag = productService.updateById(product);
        if(flag){
            return Result.success().data(product);
        }else{
            return Result.error();
        }
    }

    /**
     * 查询全部Product
     * @return
     */
    @PostMapping(value = "product/list")
    public Result getProductList() {
        List<Product> list = productService.list();
        return Result.success().data(list);
    }

    /**
     * 根据id
     * @param id 查询 Product
     * @return
     */
    @PostMapping(value = "product/get/{id}")
    public Result getProductsList(@PathVariable Integer id) {
        Product product = productService.getById(id);
        return Result.success().data(product);
    }


    @PostMapping(value = "product/collect")
    public Result getProductsList(@RequestBody Product product) {
        //将record转换成map
        String jsonStr = JSONObject.toJSONString(product);
        List<Product> products = productService.listByMap(JSONObject.parseObject(jsonStr));
        return Result.success().data(products);
    }

}

12.测试

postman测试

hello测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ds96XC2E-1622705000088)(images\2021-02-13_192318.jpg)]

# http://localhost:9000/api/hello
# 返回
{
    "code": 2000,
    "message": "success",
    "data": "hello"
}

保存数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S79PZQHU-1622705000094)(images\2021-02-13_192756.jpg)]

# http://localhost:9000/api/admin/save
# Post方法  Body-raw-json传参数
{
    "username": "123",
    "password": "123"
}
# 返回
{
    "code": 2000,
    "message": "success",
    "data": {
        "id": 1,
        "username": "123",
        "password": "123"
    }
}

# http://localhost:9000/api/product/save
# Post方法  Body-raw-json传参数
{
    "name": "产品",
    "price": 10.00
}
# 返回
{
    "code": 2000,
    "message": "success",
    "data": {
        "id": 1,
        "name": "产品",
        "price": 10.00
    }
}

删除数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8V5JfLhW-1622705000096)(images\2021-02-13_193103.jpg)]

# http://localhost:9000/api/admin/remove?id=1
# Post方法  参数id 1
# 返回
{
    "code": 2000,
    "message": "success",
    "data": null
}
# http://localhost:9000/api/product/remove?id=1
# Post方法  参数id 1
# 返回
{
    "code": 2000,
    "message": "success",
    "data": null
}

更新数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A8O4mf9m-1622705000099)(images\2021-02-13_193250.jpg)]

# http://localhost:9000/api/admin/update
# Post方法  Body-raw-json传参数
{
    "id": 1,
    "username": "111",
    "password": "222"
}
# 返回
{
    "code": 2000,
    "message": "success",
    "data": {
        "id": 1,
        "username": "111",
        "password": "222"
    }
}

# http://localhost:9000/api/product/update
# Post方法  Body-raw-json传参数
{
      "id": 1,
      "name": "产品",
      "price": 5.00
}
# 返回
{
    "code": 2000,
    "message": "success",
    "data": {
        "id": 1,
        "name": "产品",
        "price": 5.00
    }
}

查询数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZijLJ3Zn-1622705000101)(images\2021-02-13_193458.jpg)]

# http://localhost:9000/api/admin/login
# Post方法  Body-raw-json传参数
{
    "username": "111",
    "password": "222"
}
# 返回
{
    "code": 2000,
    "message": "success",
    "data": [
        {
            "id": 1,
            "username": "111",
            "password": "222"
        }
    ]
}

# http://localhost:9000/api/product/list
# Get方法
# 返回
{
    "code": 2000,
    "message": "success",
    "data": [
        {
            "id": 1,
            "name": "产品",
            "price": 10.00
        },
        {
            "id": 2,
            "name": "产品",
            "price": 5.00
        }
    ]
}

# http://localhost:9000/api/product/get/1
# Get方法
# 返回
{
    "code": 2000,
    "message": "success",
    "data": {
        "id": 1,
        "name": "产品",
        "price": 10.00
    }
}

# http://localhost:9000/api/product/collect
# Post方法  Body-raw-json传参数
{
      "name": "产品",
      "price": 5.00
}
# 返回
{
    "code": 2000,
    "message": "success",
    "data": {
        "id": 1,
        "name": "产品",
        "price": 5.00
    }
}

13.整合JWT授权认证

添加依赖

<!-- java-jwt -->
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.13.0</version>
</dependency>

创建JWT工具类JwtUtil

com.wenqu.demo.utils.JwtUtil

package com.wenqu.demo.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.auth0.jwt.interfaces.JWTVerifier;
import java.util.Date;
import java.util.Map;

public class JwtUtil {

    // Token过期时间30分钟
    public static final long EXPIRE_TIME = 30 * 60 * 1000;
    //设置SING
    private static final String SING = "!@#$%^&*(^432142@#$^)&";

    /**
     * 校验token是否正确
     * @param token
     * @return
     */
    public static boolean verify(String token){
        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(SING)).build();
        try {
            jwtVerifier.verify(token);
        } catch (JWTVerificationException e) {
            return false;
        }
        return true;
    }


    /**
     * 生成签名,30min后过期
     * @param map
     * @return
     */
    public static String getToken(Map<String, String> map) {
        Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
        JWTCreator.Builder builder = JWT.create();
        map.forEach(builder::withClaim);
        String token = builder.withExpiresAt(date)
                .sign(Algorithm.HMAC256(SING));
        return token;
    }

    /**
     * 解析token
     * @param token
     * @return
     */
    public static DecodedJWT decode(String token){
        try {
            return JWT.require(Algorithm.HMAC256(SING)).build().verify(token);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

}

自定义拦截器JwtInterceptor，实现HandlerInterceptor接口，每次请求到达之前都会验证token是否有效

com.wenqu.demo.interceptor.JwtInterceptor

package com.wenqu.demo.interceptor;

import com.alibaba.fastjson.JSON;
import com.wenqu.demo.domain.Result;
import com.wenqu.demo.utils.JwtUtil;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class JwtInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 从 http 请求头中取出 token
        String token = request.getHeader("Authorization");
        // 如果不是映射到方法直接通过
        if(!(handler instanceof HandlerMethod)){
            return true;
        }
        if (token != null){
            boolean result = JwtUtil.verify(token.replace("Bearer ",""));
            if(result){
                return true;
            }
        }
        response.setContentType("application/json;charset=UTF8");
        response.getWriter().write(JSON.toJSONString(new Result(Result.ResultCode.ERROR, "token认证失败")));
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

拦截器配置中主要定义拦截请求规则，将拦截器注入WebMvcConfigurer；cors跨域处理

package com.wenqu.demo.configuration;

import com.wenqu.demo.interceptor.JwtInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import javax.annotation.Resource;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Resource
    private JwtInterceptor jwtInterceptor;

    /* *
     * <p> 设置拦截路径 </p>
     * @Param [registry]
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor((HandlerInterceptor) jwtInterceptor)
                .addPathPatterns("/api/**")
                .excludePathPatterns("/api/admin/login");
    }

    /* *
     * <p>跨域支持 </p>
     * @Param [registry]
     */
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("*")
                .allowCredentials(true)
                .allowedMethods("GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD")
                .maxAge(3600 * 24);
    }
}

14.修改DemoController中的login方法

/**
     * 登录查询
     * @param admin
     * @return
     */
    @PostMapping(value = "admin/login")
    public Result login(@RequestBody Admin admin) throws UnsupportedEncodingException {
        QueryWrapper<Admin> qw = new QueryWrapper<>();
        qw.eq("username", admin.getUsername()).eq("password", admin.getPassword());
        List<Admin> list = adminService.list(qw);
        if(list.size()>0){
            Map<String, Object> map = new HashMap<>();
            Map<String, String> payload = new HashMap<>();
            payload.put("username", list.get(0).getUsername());
            String token = JwtUtil.getToken(payload);
            map.put("status", true);
            map.put("msg", "认证成功");
            map.put("token", token);
            map.put("admin", list.get(0));
            return Result.success().data(map);
        }else{
            return new Result(Result.ResultCode.ERROR,"账号或密码错误");
        }
    }

15.整合JWT测试

postman测试

登录并获取token

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OQOAB4TW-1622705000102)(images\2021-02-13_193458.jpg)]

# http://localhost:9000/api/admin/login
# Post方法  Body-raw-json传参数
{
    "username": "111",
    "password": "222"
}
# 返回
{
    "code": 2000,
    "message": "success",
    "data": {
        "msg": "认证成功",
        "admin": {
            "id": 2,
            "username": "222",
            "password": "222"
        },
        "status": true,
        "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MTMxMjM5MDEsInVzZXJuYW1lIjoiMjIyIn0.A-9dETRMPMXHVYnJCzCgxAGe11Ns2QlVZMV7nRyd-ts"
    }
}

更新数据测试

无token测试，其余方法相同

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZKPvuBpT-1622705000104)(images\2021-02-13_193837.jpg)]

# http://localhost:9000/api/admin/update
# Post方法  Body-raw-json传参数
{
    "id": 1,
    "username": "111",
    "password": "222"
}
# 返回
{
    "code": 4000,
    "message": "token认证失败"
}

有token测试，其余方法相同

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1qumNrBl-1622705000105)(images\2021-02-13_194226.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q7qluRnL-1622705000106)(images\2021-02-13_194118.jpg)]

# http://localhost:9000/api/admin/update
# Post方法  Body-raw-json传参数
# 在Authorization里添加Bearer token参数，值为登录后获取的token
{
    "id": 1,
    "username": "111",
    "password": "222"
}
# 返回
{
    "code": 2000,
    "message": "success",
    "data": {
        "id": 1,
        "username": "111",
        "password": "222"
    }
}

源码下载

https://download.csdn.net/download/chinaxsw/19758950