springboot搭建增刪改查以及創建token

廢話不多說，直接代碼：

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com</groupId>
    <artifactId>springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR1</spring-cloud.version>
    </properties>

    <dependencies>
        <!--<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

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

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.2</version>
        </dependency>


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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

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

        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring-boot-starter</artifactId>
            <version>1.4.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <!--<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>-->

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

 實體類如下：

import lombok.Data;

import java.io.Serializable;
@Data
public class Student implements Serializable {
    //編號
    private Integer id;
    //姓名
    private String name;
    //性別
    private String sex;

}

controller如下：

package com.controller;

import com.model.Student;
import com.service.StudentService;
import org.springframework.web.bind.annotation.*;

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

/**
 * @Auther: 澹若水
 * @Date: 2020/1/3
 * @Description: 學生信息控制器，主要描述了簡單的增刪改查
 */
@RestController
@RequestMapping(value = "/student")
public class StudentController {

    @Resource
    StudentService studentService;

    /**
     * 查找所有學生信息(先從緩存查，如果緩存無再查數據庫)
     * @return
     */
    @GetMapping("/findAll")
    public List<Student> findAll() {
        return studentService.findAll();
    }

    /**
     * 通過id查找學生信息(先從緩存查，如果緩存無再查數據庫)
     * @param id
     * @return
     */
    @GetMapping("/findById/{id}")
    public Student findById(@PathVariable("id") Integer id) {
        return studentService.findById(id);
    }

    /**
     * 通過id刪除學生信息，如果緩存有，緩存的也一併刪除
     * @param id
     * @return
     */
    @DeleteMapping("/delById/{id}")
    public int delById(@PathVariable("id") Integer id) {
        return studentService.del(id);
    }

    /**
     * 修改學生信息並更新緩存信息
     * @param student
     * @return
     */
    @PutMapping("/modify")
    public int modify(Student student) {
        return studentService.modify(student);
    }

    /**
     * 添加學生信息，並給緩存存一份
     * @param student
     */
    @PostMapping("/save")
    public void save(Student student) {
        studentService.save(student);
    }

}

登錄的控制器：

package com.controller;


import com.common.CreateToken;
import com.common.GenerateRandCode;
import com.common.Md5Util;
import com.common.Result;
import com.model.User;
import com.request.LoginRequest;
import com.request.RegUserRequest;
import com.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Auther: 澹若水
 * @Date: 2020/1/3
 * @Description: 用戶登錄註冊的控制器
 */
@Slf4j
@RestController
@RequestMapping(value = "/login")
public class LoginController {

    Map<String, String> map = new HashMap<>();
    @Autowired
    private UserService userService;

    /**
     * 用戶登錄並生成token
     *
     * @param loginRequest
     * @return
     */
    @PostMapping(value = "/user/login")
    // public Result login(LoginRequest loginRequest, String verificationCode){
    public Result login(LoginRequest loginRequest) {
        String pwd = Md5Util.inputPassToDBPass(loginRequest.getPassword(), Md5Util.SALT);
        loginRequest.setPassword(pwd);
        User user = userService.findByNameAndPwd(loginRequest);
        // if (!StringUtils.isEmpty(user)  &&  map.get(user.getUserName()).equalsIgnoreCase(verificationCode)) {
        if (!StringUtils.isEmpty(user)) {
            Map<String, Object> map = new HashMap<>();
            map.put("userName", user.getUserName());
            //String roleName = userService.findRoleName(user.getUserRole());
            // map1.put("roleName", roleName);
            String token = CreateToken.createToken(map);
            return Result.ok(token);
        } else {
            return Result.fail(null, "用戶不存在！");
        }
    }

    /**
     * 生成驗證碼
     *
     * @param userName
     * @return
     */
    @PutMapping("/user/generateCode")
    public Map<String, String> generateCode(String userName) {
        String verificationCode = GenerateRandCode.RandCode();
        if (!map.isEmpty()) {
            map.remove(userName);
        }
        if (StringUtils.isEmpty(verificationCode)) {
            log.debug("驗證碼爲空！請輸入正確的用戶名信息！");
        }
        map.put(userName, verificationCode);
        return map;
    }

    /**
     * 註冊用戶信息
     *
     * @param regUserRequest
     * @return
     */
    @PostMapping(value = "/regUserInfo")
    public Result regUserInfo(RegUserRequest regUserRequest) {
        String pwd = Md5Util.inputPassToDBPass(regUserRequest.getPassword(), Md5Util.SALT);
        regUserRequest.setPassword(pwd);
        userService.saveUserInfo(regUserRequest);
        return Result.ok("新增用戶信息成功!");
    }

    /**
     * 查找所有用戶信息
     *
     * @return
     */
    @GetMapping(value = "/findAll")
    public Result findAll() {
        List<User> list = userService.findAll();
        Result result = new Result();
        if (list.size() > 0) {
            return result.ok(list);
        } else {
            result.fail(null, "沒有查到用戶信息！");
        }
        return result;
    }
}

 

創建token的類：

package com.common;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import lombok.extern.slf4j.Slf4j;

import java.util.Calendar;
import java.util.Date;
import java.util.Map;

/**
 * @Author:澹若水
 * @Description: 生成token類
 * @Date:Created in  2018/12/19
 */
@Slf4j
public class CreateToken {

    private static final String SECRET = "JKKLJOoasdlfj";
    // token 過期時間: 10天
    private static final int CALENDARFIELD = Calendar.DATE;
    private static final int CALENDARINTERGERVAL = 10;
    /**
     * JWT生成Token.
     *
     * JWT構成: header, payload, signature
     */
    public static String createToken(Map<String, Object> map){
        Date iatDate = new Date();
        Calendar nowTime = Calendar.getInstance();
        nowTime.add(CALENDARFIELD, CALENDARINTERGERVAL);
        Date expiresDate = nowTime.getTime();
        // header Map
        String token = JWT.create().withHeader(map) // header
                .withIssuedAt(iatDate) // sign time
                .withExpiresAt(expiresDate) // expire time
                .sign(Algorithm.HMAC256(SECRET)); // signature
        return token;
    }
    /**
     * 解密Token
     *
     * @param token
     * @return
     */
    public static boolean verifyToken(String token) {
        DecodedJWT jwt = null;
        try {
            JWTVerifier verifier = JWT.require(Algorithm.HMAC256(SECRET)).build();
            jwt = verifier.verify(token);
        } catch (Exception e) {
            System.out.println("token 校驗失敗, 拋出Token驗證非法異常");
        }
        if (jwt == null) {

            return false;
        }
            return true;
    }
}

用戶密碼加密的工具類：

package com.common;


import org.apache.commons.codec.digest.DigestUtils;

/**
 * @Auther: 澹若水
 * @Date: 2020/1/3
 * @Description: 用於生成MD5 密碼的工具類
 */
public class Md5Util {

    public static String md5(String input) {

        return DigestUtils.md5Hex(input);

    }

    /*固定鹽值*/
    public static final String SALT = "1a2b3c4d";

    /**
     * 第一次md5 ：
     * <p>
     * 用於 通過輸入的密碼生成 傳輸的密碼 ：方法 通過固定鹽值和明文密碼之間的拼接在生成md5
     *
     * @param password
     * @return
     */

    public static String inputPassToFormPass(String password) {

        String str = "" + SALT.charAt(5) + SALT.charAt(4) + password + SALT.charAt(3) + SALT.charAt(2);

        return md5(str);

    }


    /**
     * 第二次md5 : 通過輸入的密碼和數據庫隨機鹽值 繼續生成 密碼
     *
     * @param input
     * @param salt
     * @return
     */

    public static String formPassToDBPass(String input, String salt) {

        String str = "" + salt.charAt(0) + salt.charAt(2) + input + salt.charAt(5) + salt.charAt(4);

        return md5(str);

    }


    /**
     * 最終調用生成密碼的方法
     */

    public static String inputPassToDBPass(String password, String dbsalt) {

        String FirstMd5 = inputPassToFormPass(password);

        String SecondMd5 = formPassToDBPass(FirstMd5, dbsalt);

        return SecondMd5;

    }

}

登陸的攔截器：

package com.intercepter;

import com.auth0.jwt.JWT;
import com.common.CreateToken;
import com.model.User;
import com.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
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;

/**
 * @Auther: 澹若水
 * @Date: 2020/1/3
 * @Description: 用戶登錄攔截器，如果token爲空直接拋異常
 */
@Component
public class LoginIntercepter implements HandlerInterceptor {

    @Autowired
    private UserService userService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object object) throws Exception {
        response.setHeader("Access-Control-Allow-Headers", "token");
        // 從 http 請求頭中取出 token
        String token = request.getHeader("token");
        // 如果不是映射到方法直接通過
        if (!(object instanceof HandlerMethod)) {
            return true;
        }
        if (StringUtils.isEmpty(token)) {
            throw new RuntimeException("token爲空，請重新登錄！");
        }
        //獲取登陸時存入頭部的用戶名
        String userName = JWT.decode(token).getHeaderClaim("userName").asString();
        //獲取登陸時存入的角色名
        String roleName = JWT.decode(token).getHeaderClaim("roleName").asString();
        //獲取創建的token的簽名
        String str = JWT.decode(token).getSignature();
        User user = userService.findUserByName(userName);
        if (user == null) {
            throw new RuntimeException("用戶不存在，請重新登錄");
        }
        boolean b = CreateToken.verifyToken(token);
        if (b) {
            return true;
        }
        throw new RuntimeException("token無效，請重新輸入！");
    }

    @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 {

    }
}

攔截器的配置文件：

package com.intercepter;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private LoginIntercepter loginIntercepter;

    /**
     * 配置攔截器信息，過濾掉登錄和註冊方法，其餘方法都要經過攔截器
     * @param registry
     */
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginIntercepter).addPathPatterns("/**").excludePathPatterns("/login/user/login","/login/regUserInfo");
    }
}

service接口：

package com.service;

import com.model.Student;

import java.util.List;

public interface StudentService {

    /**
     * 查詢所有
     *
     * @return
     */
    List<Student> findAll();

    /**
     * 根據id查詢學生信息
     *
     * @param id id
     * @return
     */
    Student findById(Integer id);


    /**
     * 根據id刪除學生信息
     *
     * @param id id
     * @return
     */
    int del(Integer id);

    /**
     * 修改學生信息
     *
     * @param student
     * @return
     */
    int modify(Student student);
    /**
     * 添加學生信息
     */
    void save(Student student);
}

service的實現類：

package com.service.impl;

import com.mapper.StudentMapper;
import com.model.Student;
import com.service.StudentService;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;

@Service("studentService")
public class StudentServiceImpl implements StudentService {

    @Resource
    StudentMapper studentMapper;

    @Resource
    RedisTemplate redisTemplate;

    //Jedis js;

    /**
     * 查詢所有
     *
     * @return
     */
    @Override
    public List<Student> findAll() {
        //緩存存在
        ListOperations<String, Student> operations = redisTemplate.opsForList();
        String key = "student";
        if (redisTemplate.hasKey(key)) {
            return operations.range(key, 0, -1);
        } else {
            //得到學生集合
            List<Student> list = studentMapper.findAll();
            operations.leftPushAll(key, list);
            return list;
        }
    }

    /**
     * 根據id查詢學生信息
     *
     * @param id id
     * @return
     */
    @Override
    public Student findById(Integer id) {
        String key = "student_" + id;
        ValueOperations<String, Student> operations = redisTemplate.opsForValue();

        //緩存存在
        if (redisTemplate.hasKey(key)) {
            return operations.get(key);
        } else {
            //得到學生對象
            Student student = studentMapper.findById(id);
            //添加到緩存
            operations.set(key, student);
            return student;
        }
    }


    /**
     * 根據id刪除學生信息
     *
     * @param id id
     * @return
     */
    @Override
    public int del(Integer id) {
        //刪除數據庫中的數據
        int count = studentMapper.del(id);

        //緩存存在
        String key = "student_" + id;
        if (redisTemplate.hasKey(key)) {
            //刪除對應緩存
            redisTemplate.delete(key);
        }
        return count;
    }

    /**
     * 修改學生信息
     *
     * @param student
     * @return
     */
    @Override
    public int modify(Student student) {
        //修改數據庫中的數據
        int count = studentMapper.modify(student);

        ValueOperations operations = redisTemplate.opsForValue();
        //緩存存在
        String key = "student_" + student.getId();
        if (redisTemplate.hasKey(key)) {
            //更新緩存
            Student stu = studentMapper.findById(student.getId());
            operations.set(key, stu);
        }
        return count;
    }

    @Override
    public void save(Student student) {
        studentMapper.save(student);
        ValueOperations operations = redisTemplate.opsForValue();
        operations.set("student_" + student.getId(),student);
    }
}

 mapper文件：

package com.mapper;

import com.model.Student;
import org.apache.ibatis.annotations.*;
import java.util.List;

@Mapper
public interface StudentMapper {

    /**
     * 查詢所有
     *
     * @return
     */
    @Select("select * from student")
    List<Student> findAll();

    /**
     * 根據id查詢學生信息
     *
     * @param id id
     * @return
     */
    @Select("select * from student where id=#{id}")
    Student findById(Integer id);

    /**
     * 根據id刪除學生信息
     *
     * @param id id
     * @return
     */
    @Delete("delete from student where id =#{id}")
    int del(Integer id);

    /**
     * 修改學生信息
     *
     * @param student
     * @return
     */
    @Update("update student set name =#{name},sex=#{sex} where id=#{id}")
    int modify(Student student);
    /**
     * 添加學生信息
     */
    @Insert("insert into student(name,sex) values(#{name},#{sex})")
    void save(Student student);
}

 最後是配置文件：

redis.ip= 192.168.0.101    ## redis所在的服務器IP
redis.port=6379


#數據源配置
spring.datasource.driverClassName=com.mysql.jdbc.Driver
#在下面3306配置自己的數據庫（自己配置）
spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false&useUnicode=true&characterEncoding=utf-8&autoReconnect=true&serverTimezone=Asia/Shanghai
#數據庫用戶（自己配置）
spring.datasource.username=root
#數據庫密碼（自己配置）
spring.datasource.password=root
spring.datasource.initialSize=20
spring.datasource.minIdle=50
spring.datasource.maxActive=500



## Mybatis 配置
# 配置爲 com.pancm.bean 指向實體類包路徑。
mybatis.typeAliasesPackage=com.model

 redis和數據庫是我本地的，根據不同可以修改成自己的。以上就是最簡單的一套增刪改查了。