java获取ip、jwt+rsa、cookie工具类

最新推荐文章于 2023-05-04 17:49:16 发布
最新推荐文章于 2023-05-04 17:49:16 发布
阅读量385 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44229250/article/details/108008000
版权
  1. 获取ip地址
/**
 * 获取ip地址
 */
public class IpUtil {

    /**
     * 在服务中获取用户的ip地址
     * @param request
     * @return
     */
    public static String getIpAddressAtService(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)) {
                ipAddress = request.getRemoteAddr();
                if (ipAddress.equals("127.0.0.1")) {
                    // 根据网卡取本机配置的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) { // "***.***.***.***".length()
                // = 15
                if (ipAddress.indexOf(",") > 0) {
                    ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
                }
            }
        } catch (Exception e) {
            ipAddress="";
        }
        // ipAddress = this.getRequest().getRemoteAddr();

        return ipAddress;
    }

    /**
     * 在网关中获取用户的ip地址
     * @param request
     * @return
     */
    public static String getIpAddressAtGateway(ServerHttpRequest request) {
        HttpHeaders headers = request.getHeaders();
        String ip = headers.getFirst("x-forwarded-for");
        if (ip != null && ip.length() != 0 && !"unknown".equalsIgnoreCase(ip)) {
            // 多次反向代理后会有多个ip值，第一个ip才是真实ip
            if (ip.indexOf(",") != -1) {
                ip = ip.split(",")[0];
            }
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = headers.getFirst("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = headers.getFirst("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = headers.getFirst("HTTP_CLIENT_IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = headers.getFirst("HTTP_X_FORWARDED_FOR");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = headers.getFirst("X-Real-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddress().getAddress().getHostAddress();
        }
        return ip;
    }
}
  1. Cookie 工具类
/**
 *
 * Cookie 工具类
 *
 */
public final class CookieUtils {

	static final Logger logger = LoggerFactory.getLogger(CookieUtils.class);

	/**
	 * 得到Cookie的值, 不编码
	 *
	 * @param request
	 * @param cookieName
	 * @return
	 */
	public static String getCookieValue(HttpServletRequest request, String cookieName) {
		return getCookieValue(request, cookieName, false);
	}

	/**
	 * 得到Cookie的值,
	 *
	 * @param request
	 * @param cookieName
	 * @return
	 */
	public static String getCookieValue(HttpServletRequest request, String cookieName, boolean isDecoder) {
		Cookie[] cookieList = request.getCookies();
		if (cookieList == null || cookieName == null){
			return null;
		}
		String retValue = null;
		try {
			for (int i = 0; i < cookieList.length; i++) {
				if (cookieList[i].getName().equals(cookieName)) {
					if (isDecoder) {
						retValue = URLDecoder.decode(cookieList[i].getValue(), "UTF-8");
					} else {
						retValue = cookieList[i].getValue();
					}
					break;
				}
			}
		} catch (UnsupportedEncodingException e) {
			logger.error("Cookie Decode Error.", e);
		}
		return retValue;
	}

	/**
	 * 得到Cookie的值,
	 *
	 * @param request
	 * @param cookieName
	 * @return
	 */
	public static String getCookieValue(HttpServletRequest request, String cookieName, String encodeString) {
		Cookie[] cookieList = request.getCookies();
		if (cookieList == null || cookieName == null){
			return null;
		}
		String retValue = null;
		try {
			for (int i = 0; i < cookieList.length; i++) {
				if (cookieList[i].getName().equals(cookieName)) {
					retValue = URLDecoder.decode(cookieList[i].getValue(), encodeString);
					break;
				}
			}
		} catch (UnsupportedEncodingException e) {
			logger.error("Cookie Decode Error.", e);
		}
		return retValue;
	}

	/**
	 * 生成cookie，并指定编码
	 * @param request 请求
	 * @param response 响应
	 * @param cookieName name
	 * @param cookieValue value
	 * @param encodeString 编码
	 */
	public static final void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, String encodeString) {
		setCookie(request,response,cookieName,cookieValue,null,encodeString, null);
	}

	/**
	 * 生成cookie，并指定生存时间
	 * @param request 请求
	 * @param response 响应
	 * @param cookieName name
	 * @param cookieValue value
	 * @param cookieMaxAge 生存时间
	 */
	public static final void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, Integer cookieMaxAge) {
		setCookie(request,response,cookieName,cookieValue,cookieMaxAge,null, null);
	}

	/**
	 * 设置cookie，不指定httpOnly属性
	 */
	public static final void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, Integer cookieMaxAge, String encodeString) {
		setCookie(request,response,cookieName,cookieValue,cookieMaxAge,encodeString, null);
	}

	/**
	 * 设置Cookie的值，并使其在指定时间内生效
	 *
	 * @param cookieMaxAge
	 *            cookie生效的最大秒数
	 */
	public static final void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, Integer cookieMaxAge, String encodeString, Boolean httpOnly) {
		try {
			if(StringUtils.isBlank(encodeString)) {
				encodeString = "utf-8";
			}

			if (cookieValue == null) {
				cookieValue = "";
			} else {
				cookieValue = URLEncoder.encode(cookieValue, encodeString);
			}
			Cookie cookie = new Cookie(cookieName, cookieValue);
			if (cookieMaxAge != null && cookieMaxAge > 0)
				cookie.setMaxAge(cookieMaxAge);
			if (null != request)// 设置域名的cookie
				cookie.setDomain(getDomainName(request));
			cookie.setPath("/");

			if(httpOnly != null) {
				cookie.setHttpOnly(httpOnly);
			}
			response.addCookie(cookie);
		} catch (Exception e) {
			logger.error("Cookie Encode Error.", e);
		}
	}

	/**
	 * 得到cookie的域名
	 */
	private static final String getDomainName(HttpServletRequest request) {
		String domainName = null;

//		String serverName = request.getRequestURL().toString();
		String serverName = request.getHeader("X-Forwarded-Host");

		if (serverName == null || serverName.equals("")) {
			domainName = "";
		} else {
			serverName = serverName.toLowerCase();
//			serverName = serverName.substring(7);
//			final int end = serverName.indexOf("/");
//			serverName = serverName.substring(0, end);
			final String[] domains = serverName.split("\\.");
			int len = domains.length;
			if (len > 3) {
				// www.xxx.com.cn
				domainName = domains[len - 3] + "." + domains[len - 2] + "." + domains[len - 1];
			} else if (len <= 3 && len > 1) {
				// xxx.com or xxx.cn
				domainName = domains[len - 2] + "." + domains[len - 1];
			} else {
				domainName = serverName;
			}
		}

		if (domainName != null && domainName.indexOf(":") > 0) {
			String[] ary = domainName.split("\\:");
			domainName = ary[0];
		}
		return domainName;
	}

}

在pom.xml文件中引入jwt相关依赖

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.10.6</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.10.6</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.10.6</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>joda-time</groupId>
    <artifactId>joda-time</artifactId>
    <version>2.10.3</version>
</dependency>
  1. jwt生成
public class JwtTest {

    // 别忘了创建D:\\project\rsa目录
	private static final String pubKeyPath = "E:\\ideaWorkspase\\12-191125\\zcc\\myOwn\\java\\rsa\\rsa.pub";
    private static final String priKeyPath = "E:\\ideaWorkspase\\12-191125\\zcc\\myOwn\\java\\rsa\\rsa.pri";

    private PublicKey publicKey;

    private PrivateKey privateKey;

    @Test
    public void testRsa() throws Exception {
        RsaUtils.generateKey(pubKeyPath, priKeyPath, "esfsacd234");
    }

    @BeforeEach
    public void testGetRsa() throws Exception {
        this.publicKey = RsaUtils.getPublicKey(pubKeyPath);
        this.privateKey = RsaUtils.getPrivateKey(priKeyPath);
    }

    @Test
    public void testGenerateToken() throws Exception {
        Map<String, Object> map = new HashMap<>();
        map.put("id", "11");
        map.put("username", "liuyan");
        // 生成token
        String token = JwtUtils.generateToken(map, privateKey, 5);
        System.out.println("token = " + token);
    }

    @Test
    public void testParseToken() throws Exception {
        String token = "eyJhbGciOiJSUzI1NiJ9.eyJpZCI6IjExIiwidXNlcm5hbWUiOiJsaXV5YW4iLCJleHAiOjE1OTE1MTI3MjN9.HY7u9VjGj6E72ALrCad7LeeDe7ps4Gc75OrcO84o3uObypGvqSB6JueRKHfAvnrN2xpk6oYoruq0MFZNuxZEahLwlBo5uQH3eV4bEM_kwf8wim_v7B7yFWOpU22xum1isPDxzB3CWRN1wJsm90lj2eBRTSGq6b8or_ArC1Izp9Iw8Kl5MqJVDM3efBgiRJpEUWlt1yIr4xZ4dhBk5jlnerV-MEq5R6j3ncJ_5SJHDLStq1bAbJkPX4Q0qcQmu9bAICNiihEKtpt3rHzFvVcY-LSIGMpaPBLTVrpSRjsLqI3uMAP9rkH4n1ReQ8IAJXe8KB-nOeiZGW1eySiF3nUrzw";

        // 解析token
        Map<String, Object> map = JwtUtils.getInfoFromToken(token, publicKey);
        System.out.println("id: " + map.get("id"));
        System.out.println("userName: " + map.get("username"));
    }
}

测试生成公钥和私钥，我们运行testRsa方法：注意需要把@Before方法注释掉
在这里插入图片描述
运行之后，查看目标目录：
在这里插入图片描述
测试testGenerateToken生成token：注意把@BeforeEach的注释去掉的
在这里插入图片描述
在这里插入图片描述
测试解析token：
在这里插入图片描述
正常情况：
在这里插入图片描述
任意改动一下：

  1. 专门读取jwt配置信息在这里插入图片描述
    配置公钥和私钥

我们需要在授权中心生成真正的公钥和私钥。可以把相关配置内容配置到相关工程的application.yml中或者配置中心：

auth:
  jwt:
    pubKeyPath: D:\\project-1010\\rsa\\rsa.pub
    priKeyPath: D:\\project-1010\\rsa\\rsa.pri
    secret: 30489ouerweljrLROE@#)(@$*343jlsdf
    cookieName: GMALL-TOKEN
    expire: 180
    unick: unick

然后编写属性类读取jwt配置，并从秘钥配置文件中读取出响应的公钥及私钥，加载这些数据：在这里插入图片描述
内容如下：

@Data
@Slf4j
@ConfigurationProperties(prefix = "auth.jwt")
public class JwtProperties {

    private String pubKeyPath;
    private String priKeyPath;
    private String secret;
    private String cookieName;
    private Integer expire;
    private String unick;

    private PublicKey publicKey;
    private PrivateKey privateKey;

    /**
     * 该方法在构造方法执行之后执行
     */
    @PostConstruct
    public void init(){
        try {
            File pubFile = new File(pubKeyPath);
            File priFile = new File(priKeyPath);
            // 如果公钥或者私钥不存在，重新生成公钥和私钥
            if (!pubFile.exists() || !priFile.exists()) {
                RsaUtil.generateKey(pubKeyPath, priKeyPath, secret);
            }
            this.publicKey = RsaUtil.getPublicKey(pubKeyPath);
            this.privateKey = RsaUtil.getPrivateKey(priKeyPath);
        } catch (Exception e) {
            log.error("生成公钥和私钥出错");
            e.printStackTrace();
        }
    }
}

/**
 * 专门读取jwt配置信息
 */
@ConfigurationProperties(prefix = "jwt")
@Data
@Slf4j
public class JwtProperties {

    private String pubKeyPath;
    private String cookieName;

    private PublicKey publicKey;

    /**
     * 读取公钥和私钥文件对应的内容到公私钥对象
     * 将来就可以直接使用公私钥对象，不需要每次去读取文件了
     */
    @PostConstruct
    public void init(){
        try {
            // 初始化公私钥对象，这里只需要读取公钥，私钥是留给auth自己的。密钥生成是由auth生成
            this.publicKey = RsaUtils.getPublicKey(pubKeyPath);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("读取公钥异常！" + e.getMessage());
        }
    }
}
  1. 公钥加密私钥解密token及获取token
public class JwtUtils {
    /**
     * 私钥加密token
     *
     * @param map           载荷中的数据
     * @param expireMinutes 过期时间，单位秒
     * @return
     * @throws Exception
     */
    public static String generateToken(Map<String, Object> map, PrivateKey key, int expireMinutes) throws Exception {
        return Jwts.builder()
                .setClaims(map)
                .setExpiration(DateTime.now().plusMinutes(expireMinutes).toDate())
                .signWith(key, SignatureAlgorithm.RS256)
                .compact();
    }

    /**
     * 公钥解析token
     *
     * @param token  用户请求中的token
     * @return
     * @throws Exception
     */
    private static Jws<Claims> parserToken(String token, PublicKey key) {
        return Jwts.parser().setSigningKey(key).parseClaimsJws(token);
    }

    /**
     * 获取token中的用户信息
     *
     * @param token  用户请求中的令牌
     * @return 用户信息
     * @throws Exception
     */
    public static Map<String, Object> getInfoFromToken(String token, PublicKey key) throws Exception {
        Jws<Claims> claimsJws = parserToken(token, key);
        return claimsJws.getBody();
    }

}
  1. rsa工具类
public class RsaUtils {
    /**
     * 从文件中读取公钥
     *
     * @param filename 公钥保存路径，相对于classpath
     * @return 公钥对象
     * @throws Exception
     */
    public static PublicKey getPublicKey(String filename) throws Exception {
        byte[] bytes = readFile(filename);
        return getPublicKey(bytes);
    }

    /**
     * 从文件中读取密钥
     *
     * @param filename 私钥保存路径，相对于classpath
     * @return 私钥对象
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(String filename) throws Exception {
        byte[] bytes = readFile(filename);
        return getPrivateKey(bytes);
    }

    /**
     * 获取公钥
     *
     * @param bytes 公钥的字节形式
     * @return
     * @throws Exception
     */
    public static PublicKey getPublicKey(byte[] bytes) throws Exception {
        X509EncodedKeySpec spec = new X509EncodedKeySpec(bytes);
        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePublic(spec);
    }

    /**
     * 获取密钥
     *
     * @param bytes 私钥的字节形式
     * @return
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(byte[] bytes) throws Exception {
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(bytes);
        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePrivate(spec);
    }

    /**
     * 根据密文，生存rsa公钥和私钥,并写入指定文件
     *
     * @param publicKeyFilename  公钥文件路径
     * @param privateKeyFilename 私钥文件路径
     * @param secret             生成密钥的密文
     * @throws IOException
     * @throws NoSuchAlgorithmException
     */
    public static void generateKey(String publicKeyFilename, String privateKeyFilename, String secret) throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        SecureRandom secureRandom = new SecureRandom(secret.getBytes());
        keyPairGenerator.initialize(2048, secureRandom);
        KeyPair keyPair = keyPairGenerator.genKeyPair();
        // 获取公钥并写出
        byte[] publicKeyBytes = keyPair.getPublic().getEncoded();
        writeFile(publicKeyFilename, publicKeyBytes);
        // 获取私钥并写出
        byte[] privateKeyBytes = keyPair.getPrivate().getEncoded();
        writeFile(privateKeyFilename, privateKeyBytes);
    }

    private static byte[] readFile(String fileName) throws Exception {
        return Files.readAllBytes(new File(fileName).toPath());
    }

    private static void writeFile(String destPath, byte[] bytes) throws IOException {
        File dest = new File(destPath);
        if (!dest.exists()) {
            dest.createNewFile();
        }
        Files.write(dest.toPath(), bytes);
    }
}
922C
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JWT+RSA 登录 注销 续租 请求 流程图 + 代码
10-28
JWT+RSA 登录 注销 续租 请求 流程图 + 代码
java生成jwt并使用RSA签名
fggdgh的博客
01-05 1548
java生成jwt使用RSA签名
java 基于JWT的RSA数据加密生成token
qq_32699791的博客
04-16 1530
引入maven依赖 <!--jwt用户登录数据加密--> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.1</version> </dependency> <!-- 将RSA加密后的文件bytes 和 string 的相互转化 --...
Java校园淘项目实战（1）————JWT+RSA非对称加密生成token
China_TomCat的博客
10-12 1330
springCloud环境配置好了，接下来就是先把工具类写好，因为接下来要写用户接口微服务，所有打算先把密钥工具类和生成token的工具类写好。 （1）yml配置，里面声明了公钥和私钥存放的地方。 server: port: 10021 spring: application: name: commons-service eureka: client: service-url: defaultZone: http://127.0.0.1:10086/eureka/
无状态单点登录方案--jwt+rsa
LC的博客
01-11 3163
无状态单点登录方案–jwt+rsa思路： jwt（token格式）+RSA（非对称对token进行加密）+rsa（生成公、私钥；私钥加密，公钥解密） 分布式认证流程分为两种： 有状态登录：服务器需要存储token 无状态登录：服务器不用存储token #无状态登录的流程： 当客户端第一次请求服务时，服务端对用户进行信息认证（登录） 认证通过，将用户信息进行加密形成token，返回给客户端，作为登录凭证 以后每次请求，客户端都携带认证的token 服务的对token进行解密，判断是否有效。 流程图： 整
新版前后端接口安全技术JWT+RSA加密
06-18
例如登录：用户登录后，我们把登录者的信息保存在服务端session中，并且给用户一个cookie值，记录对应的session。然后下次请求，用户携带cookie值来，我们就能识别到对应session，从而找到用户的信息。缺点是什么？-...
springboot+mybatis-plus+jwt+redis的简易后端框架
04-10
一个简单的后端框架，实现步骤可以根据文章 ...2.springboot+JWT+redis实现token身份令牌验证（附代码）（超详细） https://blog.csdn.net/pengpm/article/details/124077041?spm=1001.2014.3001.5501
springboot+security+jwt+mybaits-plus+mysql实现权限管理
03-13
1.传统spring boot框架 2.security框架 3.jwt取代session 4.mybatis-plus+mysql【sql文件项目中有】 5.不想下载，可以看博客，博客中有写
springboot + jwt + websocket + 拦截
09-02
springboot + jwt + websocket + 拦截
java加密工具类(jwt-RSA256算法)
秋风渡人
11-07 2688
【代码】java加密工具类(jwt-RSA256算法)
JWT使用RSA加解密
底层码农
08-07 4421
JWT使用RSA加解密
java获取请求ip的方法
花生日记
04-17 8426
首先，我们需要定义一个函数，作为反射的对象。获取请求 ip的方法就介绍到这里，下面我们来看一下获取登录密码的方法： 第一步、同样是使用 servlet框架来编写小项目，在 servlet中通过 double类来获取请求 ip： 第二步、通过 javascript代码，从 URL中获取登陆密码的账号信息： 第三步、获取账号信息后，我们就要验证它的合法性，然后就可以使用 setnx方法进行登录了： 第四步、接着，我们就可以在 web服务器上输入用户名和密码来进行登陆操作了。下面我们就来介绍下怎么获取。
java rsa签名验证失败,在Java中验证jwt：无法为RSA签名指定密钥字节
weixin_30844407的博客
02-13 962
I receive the jwt (access token) from an OAuth Server. The OAuth server has already provided me with the secret, public key, and self-signed CA certificate.I want to write a code that when I receive a...
【Java工具类】建议使用Rsa加密JTW，贼安全！
墩墩分墩
04-11 270
【代码】【Java工具类】建议使用Rsa加密JTW，贼安全！
java获取真实ip的方法
花生日记
05-04 3260
14、以上两种方法就是获取 IP地址的方法，当然了，如果你想要获取真实的 IP地址，那么还可以使用 ip代理技术，也就是在别人的电脑上设置一个代理服务器，让其为自己的电脑服务，这样就可以获取到真实的 IP地址了。12、在弹出的窗口中，需要注意的是， ip地址不能小于1,否则会报错，或者出现一些其他的错误信息；以上就是获取真实 IP地址的两种方法了，在电脑上使用 iptables软件获取 IP地址，相对来说是比较方便的，如果在网络中使用此方法，那么就会面临被人监听的风险，那么如何避免呢？
java判断用户是否在某一个区域登录_使用 JWT 技术，简单快速实现系统间的单点登录...
weixin_39697096的博客
11-26 358
一、JWT定义及其组成二、认证过程三、java代码实现单点登录（single sign on），简称sso。它的定义是多个应用系统间，只需要登录一次就可以访问所有相互信任的应用系统。下面介绍用jwt技术如何来实现单点登录。一、JWT定义及其组成JWT(JSON WEB TOKEN)是一个非常轻巧的规范，这个规范允许我们使用jwt在客户端和服务器之间传递安全可靠的信息。JWT由3个部分组成，分别是头...
JWT的使用流程
weixin_33875564的博客
08-20 428
JWT的实现原理 一篇文章告诉你JWT的实现原理 发布于 3 个月前 作者 axetroy 3097 次浏览 来自 分享 在使用 JWT 的时候，有没有想过，为什么我们需要 JWT？以及它的工作原理是什么? 我们就来对比，传统的 session 和 JWT 的区别 我们以一个用户，获取用户资料的例子 传统的 session 流程 浏览器发起请求登陆 服务端验证身份...
新手小白入门JWT
zhanlijuan
07-31 274
一、产生背景 在传统的有状态服务应用中，服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如Tomcat中的Session。例如登录：用户登录后，我们把用户的信息保存在服务端session中，并且给用户一个cookie值，记录对应的session，然后下次请求，用户携带cookie值来（这一步有浏览器自动完成），我们就能识别到对应session，从而找到用户的信息。这种方式目前来看最方便，但在分布式应用中，由服务端保存用户状态不是一种很好的选择，因此JWT诞生 二
JWT授权、身份认证和RSA非对称加密 工具类
qq_45042013的博客
11-02 970
JWT 密钥的解析和加密 工具类 import io.jsonwebtoken.Claims; import io.jsonwebtoken.Jws; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.SignatureAlgorithm; import org.joda.time.DateTime; import java.security...
java 解密jwttoken工具类
最新发布
09-09
Java解密JWTTOKEN的工具类主要有以下几个步骤： 1. 导入相关的Java库：解密JWTTOKEN需要使用到一些Java库，如`Jjwt`或`Nimbus JOSE + JWT`等。在工具类中，首先需要将这些库导入到项目中。 2. 解析JWTTOKEN：使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值