SpringBoot中常用的一些工具类

最新推荐文章于 2024-04-30 11:07:52 发布
最新推荐文章于 2024-04-30 11:07:52 发布
阅读量630 收藏 2
点赞数
文章标签： spring boot java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Exusiai_/article/details/125632623
版权

SpringBoot中常用的一些工具类

bean拷贝

package com.zhinian.utils;

import org.springframework.beans.BeanUtils;

import java.util.List;
import java.util.stream.Collectors;

/**
 * @author zhinian
 * @version V1.0
 * @Package com.zhinian.utils
 * @date 2022/3/26 16:17
 */
public class BeanCopyUtils {

    private BeanCopyUtils() {
    }

    public static <V> V copyBean(Object source,Class<V> clazz) {
        //创建目标对象
        V result = null;
        try {
            result = clazz.newInstance();
            //实现属性copy
            BeanUtils.copyProperties(source, result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //返回结果
        return result;
    }
    public static <O,V> List<V> copyBeanList(List<O> list, Class<V> clazz){
        return list.stream()
                .map(o -> copyBean(o, clazz))
                .collect(Collectors.toList());
    }
}

JWT工具类

package com.zhinian.utils;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
import java.util.Date;
import java.util.UUID;

/**
 * JWT工具类
 */
public class JwtUtil {

    //有效期为
    public static final Long JWT_TTL = 24*60 * 60 *1000L;// 60 * 60 *1000  一个小时
    //设置秘钥明文
    public static final String JWT_KEY = "zhinian";

    public static String getUUID(){
        String token = UUID.randomUUID().toString().replaceAll("-", "");
        return token;
    }
    
    /**
     * 生成jtw
     * @param subject token中要存放的数据（json格式）
     * @return
     */
    public static String createJWT(String subject) {
        JwtBuilder builder = getJwtBuilder(subject, null, getUUID());// 设置过期时间
        return builder.compact();
    }

    /**
     * 生成jtw
     * @param subject token中要存放的数据（json格式）
     * @param ttlMillis token超时时间
     * @return
     */
    public static String createJWT(String subject, Long ttlMillis) {
        JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID());// 设置过期时间
        return builder.compact();
    }

    private static JwtBuilder getJwtBuilder(String subject, Long ttlMillis, String uuid) {
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        SecretKey secretKey = generalKey();
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        if(ttlMillis==null){
            ttlMillis=JwtUtil.JWT_TTL;
        }
        long expMillis = nowMillis + ttlMillis;
        Date expDate = new Date(expMillis);
        return Jwts.builder()
                .setId(uuid)              //唯一的ID
                .setSubject(subject)   // 主题  可以是JSON数据
                .setIssuer("sg")     // 签发者
                .setIssuedAt(now)      // 签发时间
                .signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥
                .setExpiration(expDate);
    }

    /**
     * 创建token
     * @param id
     * @param subject
     * @param ttlMillis
     * @return
     */
    public static String createJWT(String id, String subject, Long ttlMillis) {
        JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 设置过期时间
        return builder.compact();
    }

    public static void main(String[] args) throws Exception {
        String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJjYWM2ZDVhZi1mNjVlLTQ0MDAtYjcxMi0zYWEwOGIyOTIwYjQiLCJzdWIiOiJzZyIsImlzcyI6InNnIiwiaWF0IjoxNjM4MTA2NzEyLCJleHAiOjE2MzgxMTAzMTJ9.JVsSbkP94wuczb4QryQbAke3ysBDIL5ou8fWsbt_ebg";
        Claims claims = parseJWT(token);
        System.out.println(claims);
    }

    /**
     * 生成加密后的秘钥 secretKey
     * @return
     */
    public static SecretKey generalKey() {
        byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }
    
    /**
     * 解析
     *
     * @param jwt
     * @return
     * @throws Exception
     */
    public static Claims parseJWT(String jwt) throws Exception {
        SecretKey secretKey = generalKey();
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(jwt)
                .getBody();
    }


}

RedisCache

package com.zhinian.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
    @Autowired
    public RedisTemplate redisTemplate;

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value)
    {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
    {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout)
    {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit)
    {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key)
    {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key)
    {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public long deleteObject(final Collection collection)
    {
        return redisTemplate.delete(collection);
    }

    /**
     * 缓存List数据
     *
     * @param key 缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList)
    {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key)
    {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
    {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext())
        {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key)
    {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
    {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key)
    {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value)
    {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey)
    {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 删除Hash中的数据
     * 
     * @param key
     * @param hkey
     */
    public void delCacheMapValue(final String key, final String hkey)
    {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.delete(key, hkey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
    {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern)
    {
        return redisTemplate.keys(pattern);
    }
}

SecurityUtils

package com.zhinian.utils;

import com.zhinian.domain.entity.LoginUser;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;

/**
 * @Author zhinian
 */
public class SecurityUtils
{

    /**
     * 获取用户
     **/
    public static LoginUser getLoginUser()
    {
        return (LoginUser) getAuthentication().getPrincipal();
    }

    /**
     * 获取Authentication
     */
    public static Authentication getAuthentication() {
        return SecurityContextHolder.getContext().getAuthentication();
    }

    public static Boolean isAdmin(){
        Long id = getLoginUser().getUser().getId();
        return id != null && 1L == id;
    }

    public static Long getUserId() {
        return getLoginUser().getUser().getId();
    }
}

WebUtils

package com.zhinian.utils;

import org.springframework.web.context.request.RequestContextHolder;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class WebUtils
{
    /**
     * 将字符串渲染到客户端
     * 
     * @param response 渲染对象
     * @param string 待渲染的字符串
     * @return null
     */
    public static void renderString(HttpServletResponse response, String string) {
        try
        {
            response.setStatus(200);
            response.setContentType("application/json");
            response.setCharacterEncoding("utf-8");
            response.getWriter().print(string);
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }


    public static void setDownLoadHeader(String filename, ServletContext context, HttpServletResponse response) throws UnsupportedEncodingException {
        String mimeType = context.getMimeType(filename);//获取文件的mime类型
        response.setHeader("content-type",mimeType);
        String fname= URLEncoder.encode(filename,"UTF-8");
        response.setHeader("Content-disposition","attachment; filename="+fname);

//        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
//        response.setCharacterEncoding("utf-8");
    }
}
Exusiai_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot应用常用的工具类
qq_35669498的博客
06-18 1483
统一返回结果类、统一异常处理类、常用的配置类
JWT工具类，SpringBoot整合Jwt-Token使用
weixin_43992507的博客
08-22 715
JWT工具类，SpringBoot整合Jwt-Token使用
SpringBoot常用工具类及配置
最新发布
m0_68076368的博客
04-30 491
简便
SpringBoot内置工具类简单介绍
leaf__yang的博客
10-26 347
在java的庞大体系中，其实有很多不错的小工具，也就是我们平常说的：轮子。如果在我们的日常工作当中，能够将这些轮子用户，再配合一下idea的快捷键，可以极大得提升我们的开发效率。今天我决定把一些压箱底的小工具，分享给大家，希望对你有所帮助。本文会分享17个我们日常工作中一定会用得到的小工具。
【SpringBoot实战】常用工具类总结
weixin_53065229的博客
12-15 396
在SpringBoot项目中，不可避免地需要使用一些工具类来来提升我们的开发效率。常用的工具类有全局异常处理类、统一返回结果类、MyBatisPlus配置类、Swagger配置类等。尽管不同项目的配置类的代码不尽相同，但主要逻辑还是类似的，经过相应修改可以应用于项目中。因此本篇文章总结了SpringBoot项目常用的配置类，并将会持续更新。
SpringBoot常用工具类
qq_39305378的博客
06-22 1369
SpringBoot常用工具类JSON序列化工具Spring注入工具反射工具 JSON序列化工具 主要使用ObjectMapper类，将任何对象类型转化成字符类型。 import com.fasterxml.jackson.annotation.JsonInclude.Include; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.core.JsonParser.Feature;
SpringBoot之自带工具类常用示例
04-29
本篇将详细介绍Spring Boot中的一些常用工具类及其示例。 1. **`java.time` API** Spring Boot完全支持Java 8的日期时间API，如`LocalDateTime`, `LocalDate`, `LocalTime`等。这些类提供了丰富的功能，如日期时间...
基于springboot的FtpUtil工具类.zip
04-08
《基于SpringBoot的FTPUtil工具类详解》 在IT领域，SpringBoot框架因其简洁的配置、快速的开发特性，已经成为Java开发的首选。而在实际项目中，文件上传和下载是常见的功能之一，FTP（File Transfer Protocol）作为...
easypoi的springBoot集成案例和工具类
06-21
在本案例中，我们将深入探讨如何在SpringBoot应用中整合Easypoi，以及如何构建实用的工具类来处理Excel的读写任务。 首先，让我们理解Easypoi的基本概念。Easypoi提供了一套完善的API，允许开发者通过简单的注解...
SpringBoot整合redis及工具类
04-19
在本文中，我们将深入探讨如何将SpringBoot与Redis集成，并创建实用工具类来处理不同类型的Redis数据存储。SpringBoot以其简化微服务应用开发而闻名，而Redis则是一种高性能的键值存储系统，常用于缓存、消息队列等...
springboot-project:SpringBoot项目常用类
04-05
SpringBoot项目常用类是指在创建和开发SpringBoot应用时经常会用到的一些核心类和接口。这个名为"springboot-project"的项目可能是一个集合，包含了多个实用功能，方便开发者快速构建自己的SpringBoot应用。现在我们...
Spring boot工具集
12-07
可以选择使用哪个项目管理工具（maven 以及 Gradle），JVM语言（Java，Groovy，Kotlin），spring boot的版本号。设置好group和artificial信息之后，还可以选择需要使用哪些组件（starter），如基本的test，web，个性化的data-redis等等。然后就可以生成一个zip文件夹，相当于一个快速的基本的脚手架工具，方便项目的生成。 当然，我们还可以使用集成开发环境，如STS（Spring Tool Suite），基于Eclipse，非常便于 spring boot 开发，应用部署（提供cloud AWS，cloud Foundry等）。 对于不喜欢Eclipse的小伙伴，可以使用IntelliJ IDEA，作为最好用的Java IDE。当然支持spring boot项目的快速搭建。新建工程，选择spring initializer，后续和网页在线版差别不大
SpringBoot打印日志（二）（原生工具类）
orehrepuS的博客
12-05 472
该打印日志的工具类，不是在logback,log4j的基础上进行封装的。你只需将这两个类复制到你的util包下即可使用，不需要其他配置。
Spring Boot内置工具 处理字符串
yuzheh521的博客
01-20 1978
// 判断字符串是否为 null，或 ""。注意，包含空白符的字符串为非空 boolean isEmpty(Object str) // 判断字符串是否是以指定内容结束。忽略大小写 boolean endsWithIgnoreCase(String str, String suffix) // 判断字符串是否已指定内容开头。忽略大小写 boolean startsWithIgnoreCase(String str, String prefix) // 是否包含空白符 boolean containsWh.
Java工具类SpringBoot内置工具类
usa_washington的博客
09-08 299
【代码】Java工具类。
aksk生成工具类及加密算法
yujiubo2008的专栏
09-03 5625
一、aksk生成工具类 public class SignUtil{ private static final String[] chars = new String[]{"a", "b", "c", "d", "e", "f", "g", "h", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"} /** * 生成8位app_key
SpringBoot 中的自带工具类，开发效率增加一倍
Java后端技术
03-20 119
往期热门文章：1、程序员面阿里三面无理由挂了，被HR一句话噎死，网友：这可是阿里啊 2、这款 IDEA 插件太好用了，堪称日志管理神器！ 3、只改了五行代码接口吞吐量提升了10多倍！爽！ 4、服务端如何防止订单重复支付！ 5、我司为什么禁止使用阿里巴巴Java规范？断言断言是一个逻辑判断，用于检查不应该发生的情况Assert 关键字在 JDK1.4 中引入，可通过 JVM 参数-enableass...
【SpringBoot系列】 Spring Boot 中事半功倍的一些工具类
我是香菜
02-06 4088
Spring Boot 中事半功倍的一些工具类
springboot常用工具类
08-22
以下是一些常用的Spring Boot工具类： 1. SpringApplication：用于启动Spring Boot应用程序的主类，可用于指定应用程序配置和启动服务。 2. @RestController和@RequestMapping：用于定义RESTful API的控制器类和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值