这篇文章主要讲解了“密码加密与微服务鉴权java JWT使用方法是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“密码加密与微服务鉴权java JWT使用方法是什么”吧！
成都创新互联是一家从事企业网站建设、成都网站设计、成都做网站、外贸网站建设、行业门户网站建设、网页设计制作的专业的建站公司，拥有经验丰富的网站建设工程师和网页设计人员，具备各种规模与类型网站建设的实力，在网站建设领域树立了自己独特的设计风格。自公司成立以来曾独立设计制作的站点近千家。
微服务集群中的每个服务，对外提供的都是Rest风格的接口，而Rest风格的一个最重要的规范就是：服务的无状态性。
什么是无状态？
1.服务端不保存任何客户端请求者信息
2.客户端的每次请求必须自备描述信息，通过这些信息识别客户端身份
无状态，在微服务开放中，优势是？
1.客户端请求不依赖服务端的信息，任何多次请求不需要必须访问到同一台服务
2.服务端的是否集群对客户端透明
3.服务端可以任意的迁移和伸缩
4.减小服务端储存压力
服务器端生产唯一标识(注意：最终需要进行校验)
方案1：UUID，数据单一，不能包含种类过多的信息。
方案2：RSA加密，数据多样，需要使用算法，有一定的理解难度。【使用】
浏览器储存和自动携带数据
方案1：使用cookie，有很多局限性(大小，个数)
方案2：请求参数，get请求URL有长度限制，每一个路径都需要处理比较麻烦。
方案3：浏览器localStroage存储，请求头携带。【使用】
服务与服务之间共享数据，采用JWT先生成数据，在另一个服务中解析数据，为了保证数据安全性，使用RSA对数据进行加密。
使用RSA加密保证token数据在传输过程中不会被篡改
RSA：非对称加密算法
同时生产一对密钥：公钥和私钥
公钥秘钥：用于加密
私钥秘钥：用于解密
特点
工具类RasUtils
package com.czxy.utils;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
/**
* @author 庭前云落
* @Date 2019/12/13 22:01
* @description
*/
public class RasUtils {
/**
* 从文件中读取公钥
*
* @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 Exception
*/
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(1024, 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.getParentFile().exists()){
dest.getParentFile().mkdirs();
}
//创建需要的文件
if (!dest.exists()) {
dest.createNewFile();
}
Files.write(dest.toPath(), bytes);
}
}//生成公钥和私钥 RasUtils.generateKey(公钥位置,私钥位置,密码); RasUtils.generateKey(pubKeyPath,priKeyPath,"234"); //获得公钥 RasUtils.getPublicKey(pubKeyPath); //获得私钥 RasUtils.getPrivateKey(priKeyPath);
package com.czxy;
import com.czxy.utils.RasUtils;
import org.junit.Test;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
* @author 庭前云落
* @Date 2019/12/13 22:07
* @description
*/
public class TestRAS {
private static final String pugbKeyPath="D:\\ras\\ras.pub";
private static final String priKeyPath="D:\\ras\\ras.pri";
@Test
public void testRas() throws Exception {
//生产公钥和私钥
RasUtils.generateKey(pugbKeyPath,priKeyPath,"234");
}
@Test
public void testGetRas() throws Exception {
//获得公钥和私钥
PublicKey publicKey = RasUtils.getPublicKey(pugbKeyPath);
PrivateKey privateKey = RasUtils.getPrivateKey(priKeyPath);
System.out.println(publicKey.toString());
System.out.println(privateKey.toString());
}
}
JWT，全称是JSON Web Token，是JSON风格轻量级的授权和身份认证规范，可实现无状态、分布式的Web应用授权：官网：https://jwt.io
JWT基于JSON的认证规范。（Json Web Token）
使用JWT目的：生成数据、解析数据
pom
0.9.0 2.9.7 1.16.20 1.9.3 org.springframework.cloud spring-cloud-starter-netflix-zuul org.springframework.cloud spring-cloud-starter-netflix-eureka-client org.springframework.boot spring-boot-starter-test commons-beanutils commons-beanutils ${beanutils.version} io.jsonwebtoken jjwt ${jwt.jjwt.version} joda-time joda-time ${jwt.joda.version} org.projectlombok lombok ${lombok.version} provided
导入工具类
工具类：JwtUtils
package com.czxy.utils;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.apache.commons.beanutils.BeanUtils;
import org.joda.time.DateTime;
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
* @author 庭前云落
* @Date 2019/12/13 22:01
* @description
*/
public class JwtUtils {
/**
* 私钥加密token
* @param data 需要加密的数据（载荷内容）
* @param expireMinutes 过期时间，单位：分钟
* @param privateKey 私钥
* @return
*/
public static String generateToken(Object data, int expireMinutes, PrivateKey privateKey) throws Exception {
//1 获得jwt构建对象
JwtBuilder jwtBuilder = Jwts.builder();
//2 设置数据
if( data == null ) {
throw new RuntimeException("数据不能为空");
}
BeanInfo beanInfo = Introspector.getBeanInfo(data.getClass());
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
// 获得属性名
String name = propertyDescriptor.getName();
// 获得属性值
Object value = propertyDescriptor.getReadMethod().invoke(data);
if(value != null) {
jwtBuilder.claim(name,value);
}
}
//3 设置过期时间
jwtBuilder.setExpiration(DateTime.now().plusMinutes(expireMinutes).toDate());
//4 设置加密
jwtBuilder.signWith(SignatureAlgorithm.RS256, privateKey);
//5 构建
return jwtBuilder.compact();
}
/**
* 通过公钥解析token
* @param token 需要解析的数据
* @param publicKey 公钥
* @param beanClass 封装的JavaBean
* @return
* @throws Exception
*/
public static T getObjectFromToken(String token, PublicKey publicKey,Class beanClass) throws Exception {
//1 获得解析后内容
Claims body = Jwts.parser().setSigningKey(publicKey).parseClaimsJws(token).getBody();
//2 将内容封装到对象JavaBean
T bean = beanClass.newInstance();
BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
// 获得属性名
String name = propertyDescriptor.getName();
// 通过属性名，获得对应解析的数据
Object value = body.get(name);
if(value != null) {
// 将获得的数据封装到对应的JavaBean中
BeanUtils.setProperty(bean,name,value);
}
}
return bean;
}
} 时间处理工具：DateTime
//当前时间 DateTime.now().toDate().toLocaleString() //当前时间加5分钟 DateTime.now().plusMinutes(5).toDate().toLocaleString() //当前时间减5分钟 DateTime.now().minusMinutes(5).toDate().toLocaleString()
//生成数据， UserInfo --> String（加密） //JwtUtils.generateToken(数据,过期时间(分钟), 私钥) String token = JwtUtils.generateToken(userInfo,30, RasUtils.getPrivateKey(priKeyPath)); //解析数据， String(加密) --> UserInfo // JwtUtils.getObjectFromToken(加密数据, 公钥, 封装对象.class); UserInfo userInfo = JwtUtils.getObjectFromToken(token, RasUtils.getPublicKey(pubKeyPath), UserInfo.class);
生产Token
package com.czxy;
import com.czxy.utils.RasUtils;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.joda.time.DateTime;
import org.junit.Test;
/**
* @author 庭前云落
* @Date 2019/12/13 22:32
* @description
*/
public class TestJWT {
private static final String pugbKeyPath="D:\\ras\\ras.pub";
private static final String priKeyPath="D:\\ras\\ras.pri";
@Test
public void testGenerateToken() throws Exception {
String str = Jwts.builder()
.claim("test","庭前云落")
.setExpiration(DateTime.now().plusMinutes(60).toDate())
.signWith(SignatureAlgorithm.RS256, RasUtils.getPrivateKey(priKeyPath))
.compact();
System.out.println(str);
}
}"庭前云落"：Token ---》eyJhbGciOiJSUzI1NiJ9.eyJ0ZXN0Ijoi5bqt5YmN5LqR6JC9IiwiZXhwIjoxNTc2MjkzMTEyfQ.a32GamgbG6F1xC-4NtEJNNLX8mcV6Ycyc2bf7_7wX6_xa4LzimqO5ZH9d4bSii-IixYudSreurJ2Rjq72aXvv3nv_VsZasmODeLkBMLtBGhKDztKW3hNQM7rcRLIxL4PFP48xjosJl48F-hXSgEWqYXuC6Voexlk8W4eonRcGqg
解析Token
@Test
public void testParseToken() throws Exception {
String token="\n" +
"eyJhbGciOiJSUzI1NiJ9.eyJ0ZXN0Ijoi5bqt5YmN5LqR6JC9IiwiZXhwIjoxNTc2MjkzMTEyfQ.a32GamgbG6F1xC-4NtEJNNLX8mcV6Ycyc2bf7_7wX6_xa4LzimqO5ZH9d4bSii-IixYudSreurJ2Rjq72aXvv3nv_VsZasmODeLkBMLtBGhKDztKW3hNQM7rcRLIxL4PFP48xjosJl48F-hXSgEWqYXuC6Voexlk8W4eonRcGqg";
Claims claims = Jwts.parser().setSigningKey(RasUtils.getPublicKey(pubKeyPath)).
parseClaimsJws(token).getBody();
String text = claims.get("test",String.class);
System.out.println(text);
}
编写测试对象UserInfo
package com.czxy.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author 庭前云落
* @Date 2019/12/13 21:55
* @description
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserInfo {
private Long id;
private String username;
}测试
package com.czxy;
import com.czxy.domain.UserInfo;
import com.czxy.utils.JwtUtils;
import com.czxy.utils.RasUtils;
import org.junit.Test;
/**
* @author 庭前云落
* @Date 2019/12/13 22:32
* @description
*/
public class TestJWT {
private static final String pubKeyPath="D:\\ras\\ras.pub";
private static final String priKeyPath="D:\\ras\\ras.pri";
@Test
public void testToken() throws Exception {
UserInfo userInfo = new UserInfo();
userInfo.setId(10L);
userInfo.setUsername("庭前云落");
String token = JwtUtils.generateToken(userInfo, 30, RasUtils.getPrivateKey(priKeyPath));
System.out.println(token);
}
@Test
public void testParserToken() throws Exception {
String token="eyJhbGciOiJSUzI1NiJ9.eyJjbGFzcyI6ImNvbS5jenh6LmRvbWFpbi5Vc2VySW5mbyIsImlkIjoxMCwidXNlcm5hbWUiOiLluq3liY3kupHokL0iLCJleHAiOjE1NzYyOTI1Mzd9.LlyCCBeW4f7fjU3LmE7cA8W7aNB1BXp23Yv9WQJouCRCtoD46GiXQAHn2kezuzuPfp2u5G0OXOIeahHtnvRMSDjtQFJ6s-cZcKNupJPOPK8BzuEnladx0ilcrSr5TeWNxujg-svSz5EJRwWj8KbRKhQluohpAg0VhERjJjD5wTY";
UserInfo userInfo = JwtUtils.getObjectFromToken(token, RasUtils.getPublicKey(pubKeyPath), UserInfo.class);
System.out.println(userInfo);
}
}
JWT的token包含三部分数据：头部、载荷、签名。
| 名称 | 描述 | 组成部分 |
|---|---|---|
| 头部（Header） | 通常头部有两部分信息 | 1. 声明类型，这里是JW2. 加密算法，自定义 |
| 载荷（Payload） | 就是有效数据 | 1. 用户身份信息2. 注册声明 |
| 签名（Signature） | 整个数据的认证信息 | 一般根据前两步的数据，再加上服务的的密钥（secret），通过加密算法生成。用于验证整个数据完整和可靠性 |
生成的数据格式
感谢各位的阅读，以上就是“密码加密与微服务鉴权java JWT使用方法是什么”的内容了，经过本文的学习后，相信大家对密码加密与微服务鉴权java JWT使用方法是什么这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是创新互联，小编将为大家推送更多相关知识点的文章，欢迎关注！
