SpirngBoot + Vue 前后端分离开发工具代码

✅作者简介：大家好，我是Leo，热爱Java后端开发者，一个想要与大家共同进步的男人
个人主页：Leo的博客
当前专栏： Java从入门到精通
✨特色专栏： MySQL学习
本文内容：SpirngBoot + Vue 前后端分离开发工具代码
️个人小站 ：个人博客，欢迎大家访问
个人知识库： Leo知识库，欢迎大家访问

1.MybatisPlus配置类

导入依赖

<dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plus-boot-starterartifactId>
dependency>

package com.jerry.common.config.mp;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.autoconfigure.ConfigurationCustomizer;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * ClassName: MybatisPlusConfig
 * Package: com.jerry.common.config.mp
 * Description:
 *
 * @Author gaoziman
 * @Create 2023-03-01 11:17
 * @Version 1.0
 */

@Configuration
@MapperScan("com.jerry.auth.mapper")
public class MybatisPlusConfig {

    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题(该属性会在旧插件移除后一同移除)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return configuration -> configuration.setUseDeprecatedExecutor(false);
    }			
}	

2.使用mybatisplus分页查询

第一种

    /**
     * 条件分页查询
     *
     * @param page           当前页
     * @param pageSize       分页大小
     * @param sysRoleQueryVo 条件查询对象
     * @return
     */
    @ApiOperation("条件分页查询")
    @GetMapping("{page}/{pageSize}")
    private Result page(@PathVariable int page, @PathVariable int pageSize, SysRoleQueryVo sysRoleQueryVo) {

        // 1、创建 page 对象， 传递分页查询的参数
        Page<SysRole> sysRolePage = new Page<>(page, pageSize);

        // 2、构造分页查询条件, 判断条件是否为空，不为空进行封装
        LambdaQueryWrapper<SysRole> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        String roleName = sysRoleQueryVo.getRoleName();
        if (!StringUtils.isEmpty(roleName)) {
            // 封装
            lambdaQueryWrapper.like(SysRole::getRoleName,roleName);
        }

        // 3、调用方法实现分页查询
        sysRoleService.page(sysRolePage, lambdaQueryWrapper);
        return Result.ok(sysRolePage);
    }

第二种

 @PreAuthorize("hasAuthority('bnt.sysUser.list')")
    @ApiOperation("条件分页查询")
    @GetMapping("/page/{pageNum}/{pageSize}")
    public Result pageQueryUser(@PathVariable Long pageNum,
                                @PathVariable Long pageSize,
                                SysUserQueryVo sysUserQueryVo) {
        //1 创建Page对象，传递分页相关参数
        //page 当前页  limit 每页显示记录数
        Page<SysUser> pageParam = new Page<>(pageNum,pageSize);

        //2 调用service方法
        IPage<SysUser>  page =  userService.selectByPage(pageParam,sysUserQueryVo);

        return Result.success(page);
    }

<select id="selectByPage" resultMap="sysUserMap">
      SELECT * FROM  sys_user
        <where>
            <if test="vo.keyword != '' and vo.keyword != null ">
                and (username like CONCAT('%',#{vo.keyword},'%')
                or name like CONCAT('%',#{vo.keyword},'%')
                or phone like CONCAT('%',#{vo.keyword},'%'))
            if>
            <if test="vo.createTimeBegin != null and vo.createTimeBegin !=''">
                and create_time >= #{vo.createTimeBegin}
            if>
            <if test="vo.createTimeEnd !=null and vo.createTimeEnd !=''">
                and create_time <=#{vo.createTimeEnd}
            if>
             and is_deleted = 0
        where>
    select>

3.统一返回的结果

package com.trs.common.result;

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

/**
 * 公共返回对象
 *
 * @author gaoziman
 * @date 2022/8/7
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result {
    /**
     * 状态码
     */
    private Integer code;
    /**
     * 提示信息
     */
    private String message;
    /**
     * 返回对象
     */
    private Object data;


    /**
     * 成功返回结果
     *
     * @param resultCodeEnum 提示信息
     * @return 返回成功
     */
    public static Result success(ResultCodeEnum resultCodeEnum) {
        return new Result(resultCodeEnum.getCode(), resultCodeEnum.getMessage(), null);
    }

    /**
     * 成功返回结果
     *
     * @param resultCodeEnum 提示信息
     * @param data 返回数据
     * @return 返回成功
     */
    public static Result success(ResultCodeEnum resultCodeEnum, Object data) {
        return new Result(resultCodeEnum.getCode(), resultCodeEnum.getMessage(), data);
    }

    /**
     * 失败返回结果
     *
     * @param resultCodeEnum 提示信息
     * @return 返回失败
     */
    public static Result error(ResultCodeEnum resultCodeEnum) {
        return new Result(resultCodeEnum.getCode(), resultCodeEnum.getMessage(), null);
    }

    /**
     * 失败返回结果
     *
     * @param message 提示信息
     * @return 返回失败
     */
    public static Result error(String message) {
        return new Result(500, message, null);
    }

    /**
     * 失败返回结果
     *
     * @param resultCodeEnum 提示信息
     * @param data 返回数据
     * @return 返回失败
     */
    public static Result error(ResultCodeEnum resultCodeEnum, Object data) {
        return new Result(resultCodeEnum.getCode(), resultCodeEnum.getMessage(), data);
    }

    /**
     * 失败返回结果
     *
     * @param message 提示信息
     * @return 返回失败
     */
    public static Result error(ResultCodeEnum resultCodeEnum, String message) {
        return new Result(resultCodeEnum.getCode(), resultCodeEnum.getMessage(), null);
    }


    /**
     * 失败返回结果
     *
     * @param code 状态码
     * @param message 提示信息
     * @return 返回失败
     */
    public static Result error(Integer code, String message) {
        return new Result(code, message, null);
    }
}

package com.trs.common.result;

import lombok.Getter;

/**
 * 统一返回结果状态信息类
 *
 * @author 高自满
 */
@Getter
public enum ResultCodeEnum {

    SUCCESS(200,"成功"),
    FAIL(201, "失败"),
    SERVICE_ERROR(2012, "服务异常"),
    DATA_ERROR(204, "数据异常"),

    LOGIN_AUTH(401, "尚未登录，请重新登录"),
    PERMISSION(209, "没有权限"),

    LOGIN_MOBLE_ERROR(210,"登录认证失败" ),
    ACCOUNT_STOP(211,"账号已停用" ),
    TOKEN_ERR(212,"token异常"),
    PERMISSION_ERR(403,"权限不足，请联系管理员"),
    COMMENT_SUCCESS(200,"评论成功，请等待管理员审核" ),
    COMMENT_SUCCESS_S(200,"评论成功" ),
    COMMENT_ERROR(501,"评论失败" );

    private Integer code;

    private String message;

    private ResultCodeEnum(Integer code, String message) {
        this.code = code;
        this.message = message;
    }
}

4.Redis配置类

导入依赖

	
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>

package com.trs.blog.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis配置类
 *
 * @author : gaoziman
 * @date  2023/5/2 10:32
 */
@Configuration
public class RedisConfig {

    /**
     * Redis序列化
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // String类型key序列器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // String类型value序列器
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // Hash类型kay序列器
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // Hash类型value序列器
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        // 设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }
}

5.代码生成器

导入依赖

    <dependency>
        <groupId>com.baomidougroupId>
        <artifactId>mybatis-plus-generatorartifactId>
        <version>3.4.1version>
    dependency>

    <dependency>
        <groupId>org.apache.velocitygroupId>
        <artifactId>velocity-engine-coreartifactId>
        <version>2.0version>
    dependency>

package com.trs.serviceUtil.util;


import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

/**
 * @author gaoziman
 * 代码生成器
 */
public class CodeGet {

    public static void main(String[] args) {

        // 1、创建代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 2、全局配置
        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        gc.setOutputDir("E:\\exer_code\\cisyam-blog\\blog-parent\\service-blog"+"/src/main/java");

        gc.setServiceName("%sService");	//去掉Service接口的首字母I
        gc.setAuthor("manman");
        gc.setOpen(false);
        mpg.setGlobalConfig(gc);

        // 3、数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/blog?serverTimezone=GMT%2B8&useSSL=false");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        // 4、包配置
        PackageConfig pc = new PackageConfig();
        pc.setParent("com.trs");
        pc.setModuleName("blog"); //模块名
        pc.setController("controller");
        pc.setService("service");
        pc.setEntity("pojo");
        pc.setMapper("mapper");
        mpg.setPackageInfo(pc);

        // 5、策略配置
        StrategyConfig strategy = new StrategyConfig();

        strategy.setInclude("week_view");

        strategy.setNaming(NamingStrategy.underline_to_camel);//数据库表映射到实体的命名策略

        strategy.setColumnNaming(NamingStrategy.underline_to_camel);//数据库表字段映射到实体的命名策略
        strategy.setEntityLombokModel(true); // lombok 模型 @Accessors(chain = true) setter链式操作

        strategy.setRestControllerStyle(true); //restful api风格控制器
        strategy.setControllerMappingHyphenStyle(true); //url中驼峰转连字符

        mpg.setStrategy(strategy);

        // 6、执行
        mpg.execute();
    }
}

6.工具类

拷贝工具类

package com.trs.blog.util;

import org.springframework.beans.BeanUtils;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;

/**
 * 集合对象复制工具类
 *
 * @author gaoziman
 * @date  2023/5/1 23:32
 */
public class BeanCopyUtil {
    /**
     * 复制集合
     *
     * @param source 复制的原对象集合
     * @param clazz 对象类型
     * @param  泛型
     * @return 复制完成的集合
     */
    public static <T> List<T> copyList(List source, Class<T> clazz) {
        List<T> target = new ArrayList<>();
        if (!CollectionUtils.isEmpty(source)) {
            if (!CollectionUtils.isEmpty(source)) {
                for (Object c : source) {
                    T obj = copy(c, clazz);
                    target.add(obj);
                }
            }
        }
        return target;
    }

    /**
     * 复制对象
     *
     * @param source 复制的原对象
     * @param clazz 对象类型
     * @param  泛型
     * @return 复制完成的新对象
     */
    public static <T> T copy(Object source, Class<T> clazz) {
        if (source == null) {
            return null;
        }
        T obj = null;
        try {
            obj = clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        BeanUtils.copyProperties(source, obj);
        return obj;
    }


    /**
     * 将传来的Object对象转为指定的List集合
     *
     * @param object 传来的Object对象
     * @param clazz 指定类型
     * @param  泛型
     * @return 指定的List集合
     */
    public static <T> List<T> castObjectToList(Object object, Class<T> clazz) {
        List<T> result = new ArrayList<>();
        // 如果传来的对象属于List集合
        if (object instanceof List<?>) {
            for (Object o : (List<T>) object) {
                result.add(clazz.cast(o));
            }
            return result;
        }
        return null;
    }
}

集合工具类

package com.trs.blog.util;

import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;

/**
 * 集合工具类
 *
 * @author gaoziman
 * @date  2023/5/1 23:32
 */
public class CollectionUtil {
    /**
     * 将传来的字符串数据转为整型集合
     *
     * @param str 字符串数据
     * @return 整型集合
     */
    public static List<Integer> stringToIntegerList(String str) {
        if (StringUtils.isEmpty(str)) {
            return null;
        }
        // 去除字符串两边的[]
        str = str.substring(1, str.length() - 1);
        // 根据 , 进行分割
        String[] split = str.split(",");
        List<Integer> result = new ArrayList<>();
        for (String s : split) {
            result.add(Integer.parseInt(s));
        }
        return result;
    }
}

IP地址工具类

package com.trs.blog.util;

import com.alibaba.fastjson.JSON;
import eu.bitwalker.useragentutils.UserAgent;

import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.URL;
import java.net.UnknownHostException;
import java.util.List;
import java.util.Map;

import static com.trs.common.constant.CommonConst.LOCAL_HOST;

/**
 * IP地址工具类
 *
 * @author gaoziman
 * @date  2023/5/1 23:32
 */
public class IpUtil {



    /**
     * 获取当前IP地址以及IP所属源
     *
     * @return IP地址
     */
    public static String getCurIpAddress(HttpServletRequest request) {
        String ipAddress = null;
        try {
            ipAddress = request.getHeader("x-forwarded-for");
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("WL-Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                // 获取到本机的远程IP地址
                ipAddress = request.getRemoteAddr();
                if (LOCAL_HOST.equals(ipAddress)) {
                    // 根据网卡取本机配置的IP
                    InetAddress inet = null;
                    try {
                        inet = InetAddress.getLocalHost();
                    } catch (UnknownHostException e) {
                        e.printStackTrace();
                    }
                    ipAddress = inet.getHostAddress();
                }
            }
            // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
            if (ipAddress != null && ipAddress.length() > 15) {
                // = 15
                if (ipAddress.indexOf(",") > 0) {
                    ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
                }
            }
        } catch (Exception e) {
            ipAddress = "";
        }
        return ipAddress;
    }

    /**
     * 解析ip地址
     *
     * @param ipAddress ip地址
     * @return 解析后的ip地址
     */
    public static String getIpSource(String ipAddress) {
        try {
            URL url = new URL("http://opendata.baidu.com/api.php?query=" + ipAddress + "&co=&resource_id=6006&oe=utf8");
            BufferedReader reader = new BufferedReader(new InputStreamReader(url.openConnection().getInputStream(), "utf-8"));
            String line = null;
            StringBuffer result = new StringBuffer();
            while ((line = reader.readLine()) != null) {
                result.append(line);
            }
            reader.close();
            Map map = JSON.parseObject(result.toString(), Map.class);
            List<Map<String, String>> data = (List) map.get("data");
            return data.get(0).get("location");
        } catch (Exception e) {
            return "";
        }
    }

    /**
     * 获取用户的访问设备
     *
     * @param request 请求
     * @return 用户访问设备
     */
    public static UserAgent getUserAgent(HttpServletRequest request){
        return UserAgent.parseUserAgentString(request.getHeader("User-Agent"));
    }
}

JWT处理Token工具类

package com.trs.blog.util;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * Jwt处理Token工具类
 *  
 * @author gaoziman
 * @date  2023/5/1 23:32
 */
@Component
public class JwtTokenUtil {
    /**
     * 用户名的key
     */
    private static final String CLAIM_KEY_USERNAME = "sub";
    /**
     * JWT的创建时间
     */
    private static final String CLAIM_KEY_CREATED = "created";
    /**
     * 秘钥
     */
    @Value("${jwt.secret}")
    private String secret;
    /**
     * token失效时间
     */
    @Value("${jwt.expiration}")
    private Long expiration;

    /**
     * 根据用户信息生成token
     *
     * @param userDetails 用户信息
     * @return 生成的token
     */
    public String generateToken(UserDetails userDetails) {
        // 定义token中存储数据的载荷
        Map<String, Object> claims = new HashMap<>();
        // 1. 用户名
        claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
        // 2. 签发时间
        claims.put(CLAIM_KEY_CREATED, new Date());
        // 签发token
        return generateToken(claims);
    }

    /**
     * 根据载荷生成token
     *
     * @param claims 载荷
     * @return 生成的token
     */
    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                // 1. 设置载荷
                .setClaims(claims)
                // 2. 设置失效时间
                .setExpiration(generateExpirationDate())
                // 3. 设置签名
                .signWith(SignatureAlgorithm.HS512, secret)
                // 签发token
                .compact();
    }

    /**
     * 生成token失效时间
     *
     * @return token的失效时间
     */
    private Date generateExpirationDate() {
        // token失效时间：当前系统时间 + 自己定义的时间
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }

    /**
     * 从token中获取用户名
     *
     * @param token token
     * @return 当前token中存储的用户名
     */
    public String getUserNameFromToken(String token) {
        String userName;
        try {
            // 从token中获取到载荷
            Claims claims = getClaimsFromToken(token);
            // 通过载荷获取到用户名
            userName = claims.getSubject();
        } catch (Exception e) {
            // 如果出现异常则将 userName 设置为空
            userName = null;
        }
        return userName;
    }

    /**
     * 从token中获取载荷
     *
     * @param token token
     * @return token中的载荷
     */
    private Claims getClaimsFromToken(String token) {
        Claims claims = null;
        try {
            claims = Jwts.parser()
                    // 解密的秘钥
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return claims;
    }

    /**
     * 判断token是否可以被刷新
     *
     * @param token token
     * @return token是否可以被刷新
     */
    public boolean canRefresh(String token) {
        return !isTokenExpired(token);
    }

    /**
     * 判断token是否失效
     *
     * @param token token
     * @return 当前token是否失效
     */
    private boolean isTokenExpired(String token) {
        Date expiredDate = getExpiredDateFromToken(token);
        // 如果失效时间是在当前时间之前肯定是失效的
        return expiredDate.before(new Date());
    }

    /**
     * 获取token中的失效时间
     *
     * @param token token
     * @return 当前token中的失效时间
     */
    private Date getExpiredDateFromToken(String token) {
        // 从当前token中获取载荷
        Claims claims = getClaimsFromToken(token);
        // 从载荷中返回失效时间
        return claims.getExpiration();
    }

    /**
     * 刷新token
     *
     * @param token 用户携带的 token
     * @return 刷新后的 token
     */
    public String refreshToken(String token) {
        // 从当前token中获取载荷
        Claims claims = getClaimsFromToken(token);
        // 更新载荷中的失效时间改成当前时间
        claims.put(CLAIM_KEY_CREATED, new Date());
        // 重新生成token
        return generateToken(claims);
    }

    /**
     * 判断token是否有效
     *
     * @param token 用户携带的 token
     * @param userDetails 载荷
     * @return token 是否有效
     */
    public boolean validateToken(String token, UserDetails userDetails) {
        // 通过token是否已经过期、荷载中的用户属性与userDetails中的用户属性是否一致
        String userName = getUserNameFromToken(token);
        return userName.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }
}

时间转化工具类

package com.trs.blog.util;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;

/**
 * 时间转化工具类
 *
 * @author gaoziman
 * @date  2023/5/1 23:32
 */
public class TimeUtil {
    /**
     * LocalDateTime 转 String
     *
     * @param time LocalDateTime
     * @return 对应的字符串
     */
    public static String localDateTimeToString(LocalDateTime time) {
        return time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

    /**
     * 获取当前时间（字符串格式）
     *
     * @return 当前时间
     */
    public static String getNowTime(){
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return df.format(new Date());
    }

    /**
     * 获取当前时间（字符串格式）
     *
     * @return 当前时间
     */
    public static String getNowDate(){
        SimpleDateFormat df = new SimpleDateFormat("MM-dd");
        return df.format(new Date());
    }

    /**
     * String 转 LocalDate
     *
     * @param time String
     * @return LocalDate
     */
    public static LocalDate stringToLocalDateDay(String time){
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        return LocalDate.parse(time, df);
    }

    /**
     * String 转 LocalDate
     *
     * @param time String
     * @return LocalDate
     */
    public static LocalDate stringToLocalDate(String time){
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        return LocalDate.parse(time, df);
    }

    /**
     * String 转 LocalDateTime
     *
     * @param time String
     * @return LocalDateTime
     */
    public static LocalDateTime stringToLocalDateTimeDay(String time){
        // 先转LocalDate ===> 再转LocalDateTime
        LocalDate localDate = stringToLocalDateDay(time);
        return localDate.atTime(LocalTime.now());
    }

    /**
     * String转LocalDateTime (yyyy-MM-dd HH:mm:ss格式)
     *
     * @param time String格式时间
     * @return LocalDateTime
     */
    public static LocalDateTime stringToLocalDateTime(String time){
        // 先转LocalDate ===> 再转LocalDateTime
        LocalDate localDate = stringToLocalDate(time);
        return localDate.atTime(LocalTime.now());
    }

    /**
     * LocalDate转String
     *
     * @param time LocalDate
     * @return String
     */
    public static String localDateToString(LocalDate time) {
        return time.format(DateTimeFormatter.ofPattern("MM-dd"));
    }

}

UUID生成工具类

package com.trs.blog.util;

import java.util.UUID;

/**
 * UUID生成工具类
 *
 * @author gaoziman
 * @date  2023/5/1 23:32
 */
public class UuidUtil {

    public static String[] chars = new String[]{"a", "b", "c", "d", "e", "f",
            "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
            "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5",
            "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I",
            "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V",
            "W", "X", "Y", "Z"
    };

    /**
     * 获取短UUID
     *
     * @return 16位UUID
     */
    public static String getShortUuid() {
        StringBuffer shortBuffer = new StringBuffer();
        String uuid = UuidUtil.getUuid();
        for (int i = 0; i < 8; i++) {
            String str = uuid.substring(i * 4, i * 4 + 4);
            int x = Integer.parseInt(str, 16);
            // 对62取余
            shortBuffer.append(chars[x % 0x3E]);
        }
        return shortBuffer.toString();

    }

    /**
     * 获得32位UUID
     */
    public static String getUuid() {
        String uuid = UUID.randomUUID().toString();
        //去掉“-”符号
        return uuid.replaceAll("-", "");
    }

}

MD5工具类

package com.trs.common.util;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;


public final class MD5 {

    public static String encrypt(String strSrc) {
        try {
            char hexChars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
                    '9', 'a', 'b', 'c', 'd', 'e', 'f' };
            byte[] bytes = strSrc.getBytes();
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(bytes);
            bytes = md.digest();
            int j = bytes.length;
            char[] chars = new char[j * 2];
            int k = 0;
            for (int i = 0; i < bytes.length; i++) {
                byte b = bytes[i];
                chars[k++] = hexChars[b >>> 4 & 0xf];
                chars[k++] = hexChars[b & 0xf];
            }
            return new String(chars);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            throw new RuntimeException("MD5加密出错！！+" + e);
        }
    }

    public static void main(String[] args) {
        System.out.println(MD5.encrypt("123456"));
    }
}
 

7.knife4j文档

引入依赖

<!--knife4j-->
<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-spring-boot-starter</artifactId>
</dependency>

package com.trs.serviceUtil.config;

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

import java.util.ArrayList;
import java.util.List;

/**
 * knife4j配置信息
 */
@Configuration
@EnableSwagger2WebMvc
public class Knife4jConfig {

    @Bean
    public Docket adminApiConfig(){
        List<Parameter> pars = new ArrayList<>();
        ParameterBuilder tokenPar = new ParameterBuilder();
        tokenPar.name("token")
                .description("用户token")
                .defaultValue("")
                .modelRef(new ModelRef("string"))
                .parameterType("header")
                .required(false)
                .build();
        pars.add(tokenPar.build());
        //添加head参数end

        Docket adminApi = new Docket(DocumentationType.SWAGGER_2)
                .groupName("adminApi")
                .apiInfo(adminApiInfo())
                .select()
                //只显示admin路径下的页面
                .apis(RequestHandlerSelectors.basePackage("com.trs"))
                .paths(PathSelectors.regex("/.*"))
                .build()
                .globalOperationParameters(pars);
        return adminApi;
    }

    private ApiInfo adminApiInfo(){

        return new ApiInfoBuilder()
                .title("后台管理系统-API文档")
                .description("本文档描述了个人博客后台管理系统接口定义")
                .version("1.0")
                .contact(new Contact("manman", "http://manamn.space", "[email protected]"))
                .build();
    }


}

8.文件上传

导入依赖

        
        <dependency>
            <groupId>com.aliyun.ossgroupId>
            <artifactId>aliyun-sdk-ossartifactId>
            <version>3.14.1version>
        dependency>
        
        <dependency>
            <groupId>joda-timegroupId>
            <artifactId>joda-timeartifactId>
            <version>2.10.14version>
        dependency>
        <dependency>
            <groupId>commons-iogroupId>
            <artifactId>commons-ioartifactId>
            <version>2.4version>
        dependency>
        

#阿里云文件上传
aliyun:
  oss:
    endpoint: ************
    keyid: ************
    keysecret:  ************
    bucketname: ************

配置类读取配置文件

package com.trs.demo.oss;

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

/**
 * oss属性
 */
@Data
@Component
@ConfigurationProperties(prefix = "aliyun.oss")
public class OssProperties {
    private String endPoint;
    private String keyId;
    private String keySecret;
    private String bucketName;
}

Controller

package com.trs.demo.controller;

import com.trs.demo.service.FileService;
import com.trs.demo.util.Result;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;

@RestController
@RequestMapping("/oss/file")
public class OSSController {
    @Resource
    private FileService fileService;

    /**
     * 文件上传
     *
     * @param file
     * @param module
     * @return
     */
    @PostMapping("/upload")
    public Result upload(MultipartFile file, String module) {
        //返回上传到oss的路径
        String url = fileService.upload(file, module);
        return Result.ok(url).message("文件上传成功");
    }
}

Service

package com.trs.demo.service.impl;

import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.trs.demo.oss.OssProperties;
import com.trs.demo.service.FileService;
import org.apache.commons.io.FilenameUtils;
import org.joda.time.DateTime;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.IOException;
import java.io.InputStream;
import java.util.UUID;

/**
 * @author : gaoziman
 * @description :
 * @date 2023/5/8 9:47
 */
@Service
public class FileServiceImpl  implements FileService {
    /**
     * oss属性
     */
    @Resource
    private OssProperties ossProperties;

    /**
     * 文件上传
     *
     * @param file   文件上传对象
     * @param module 文件夹名称
     * @return {@link String}
     */
    @Override
    public String upload(MultipartFile file, String module) {
        //获取地域节点
        String endPoint = ossProperties.getEndPoint();
        //获取AccessKeyId
        String keyId = ossProperties.getKeyId();
        //获取AccessKeySecret
        String keySecret = ossProperties.getKeySecret();
        //获取BucketName
        String bucketName = ossProperties.getBucketName();
        try {
            //创建OSSClient实例
            OSS ossClient = new OSSClientBuilder().build(endPoint, keyId,
                    keySecret);
            //上传文件流
            InputStream inputStream = file.getInputStream();
            //获取旧名称
            String originalFilename = file.getOriginalFilename();
            //获取文件后缀名
            String extension = FilenameUtils.getExtension(originalFilename);
            //将文件名重命名
            String newFileName = UUID.randomUUID().toString()
                    .replace("-", "") + "." + extension;
            //使用当前日期进行分类管理
            String datePath = new DateTime().toString("yyyy/MM/dd");
            //构建文件名
            newFileName = module + "/" + datePath + "/" + newFileName;
            //调用OSS文件上传的方法
            ossClient.putObject(bucketName, newFileName, inputStream);
            //关闭OSSClient
            ossClient.shutdown();
            //返回文件地址
            return "https://" + bucketName + "." + endPoint + "/" + newFileName;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 删除文件
     *
     * @param url url
     */
    @Override
    public void deleteFile(String url) {
        //获取地域节点
        String endPoint = ossProperties.getEndPoint();
        //获取AccessKeyId
        String keyId = ossProperties.getKeyId();
        //获取AccessKeySecret
        String keySecret = ossProperties.getKeySecret();
        //获取BucketName
        String bucketName = ossProperties.getBucketName();
        try {
            //创建OSSClient实例
            OSS ossClient = new OSSClientBuilder().build(endPoint, keyId, keySecret);
            //组装文件地址
            String host = "https://" + bucketName + "." + endPoint + "/";
            //获取文件名称
            String objectName = url.substring(host.length());
            //删除文件
            ossClient.deleteObject(bucketName, objectName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}