东拼西凑学java
前言
随着大环境的影响,互联网寒冬降临,程序员的日子越来越难,搞不好哪天就被噶了,多学点东西也没啥坏处,国内市场java如日中天,出门在外不会写两行java代码,都不好意思说自己是程序员,伪装成一个萌新运维,混迹于各大java群,偷师学艺,略有所获,水一篇博客以记之
本博客仅仅代表作者个人看法,以.Net视角来对比,不存在语言好坏之分,不足之处,欢迎拍砖,以免误人子弟,java大佬有兴趣可以带我一jio,探讨学习,懂的都懂
特殊用语 --> 懂的都懂 形容一些心照不宣的事情,可自行百度谷歌....
环境准备
JDK 1.8
IDEA
Maven 需配置阿里的源
工程结构
.net里工程结构大致如下:
|---解决方案
|---项目A
|---项目B
|---项目C
java里工程结构
|---项目
|---模块A
|---模块B
|---模块C
- 我们先创建一个空模板项目 文件->新建项目-->Empty Project 指定项目名称以及项目路径即可
- 在该项目路径下,创建对应的模块,比较常用的是Spring,Spring Initializr Maven,这个跟.net类似
starter 中间件
starter 是springboot里提出的一个概念,场景启动器,把一些常用的依赖聚合打包,方便使用者直接在项目中使用,简化了开发,在.net里就是中间件了,一个意思
官方解释
Starters are a set of convenient dependency descriptors that you can include in your application.
You get a one-stop shop for all the Spring and related technologies that you need without having to hunt through sample code and copy-paste loads of dependency descriptors.
For example, if you want to get started using Spring and JPA for database access, include the spring-boot-starter-data-jpa dependency in your project.
spring生态是毋庸置疑的,开发常用的中间件,spring都整理好了,可以去官网直接查阅,懂的都懂
创建一个自定义的starter
-
新建一个模块,选择Maven模块,给模块取个名字 hello-spring-boot-starter, 取名字要遵循starter的规范,望文知意
-
再创建一个模块,选择Spring Initializr模块,给模块取个名字 hello-spring-boot-starter-autoconfigure,用于给starter编写装配信息,这样spring就能根据约定,自动装配,hello-spring-boot-starter 依赖于 hello-spring-boot-starter-autoconfigure,当然了如果嫌麻烦,直接在 hello-spring-boot-starter 里写装配信息也可以,这个跟.net里类似,懂的都懂
-
java项目起手式,在src/main/java,创建包路径,通常为公司域名,com.xxx.xxx,我这里定义为com.liang.hello
1.在com.liang.hello下,定义三个包
autoConfig 用于编写装配信息,生成对象,spring将这些对象添加到IOC容器
bean 用于映射配置文件,将application.yaml里的配置映射为实体类(javabean)
service 用于编写中间件的业务代码,需要使用到配置信息的实体类
2.在bean包下,创建HelloProperties 文件,我定义了两个属性,和一个Student对象
package com.liang.hello.bean;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* @ConfigurationProperties("hello")是springboot提供读取配置文件的一个注解
* 1）让当前类的属性和配置文件中以 hello开头的配置进行绑定
* 2）以 hello为前缀在配置文件中读取/修改当前类中的属性值
*/
@ConfigurationProperties("hello")
public class HelloProperties {
private String prefix;
private String suffix;
private Student student;
public String getPrefix() {
return prefix;
}
public void setPrefix(String prefix) {
this.prefix = prefix;
}
public String getSuffix() {
return suffix;
}
public void setSuffix(String suffix) {
this.suffix = suffix;
}
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
}
package com.liang.hello.bean;
public class Student {
private String name;
private String age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
3.在service包下,定义一个接口,跟一个实现类,简单的输出配置文件的信息
package com.liang.hello.service;
public interface BaseService {
String sayMsg(String msg);
}
package com.liang.hello.service;
import com.liang.hello.bean.HelloProperties;
import org.springframework.beans.factory.annotation.Autowired;
public class HelloService implements BaseService{
@Autowired
private HelloProperties helloProperties;
public String sayMsg(String msg)
{
return helloProperties.getPrefix()+": "+msg+">> "+helloProperties.getSuffix() + helloProperties.getStudent().getName() + helloProperties.getStudent().getAge();
}
}
4.在autoConfig包下,产生一个bean对象,丢给spring ioc,要标记这个类为一个配置类
package com.liang.hello.autoConfig;
import com.liang.hello.bean.HelloProperties;
import com.liang.hello.service.BaseService;
import com.liang.hello.service.HelloService;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration //标识配置类
@EnableConfigurationProperties(HelloProperties.class)//开启属性绑定功能+默认将HelloProperties放在容器中
public class HelloAutoConfiguration {
/**
* @Bean注解用于告诉方法，产生一个Bean对象，然后这个Bean对象交给Spring管理。
* 产生这个Bean对象的方法Spring只会调用一次，随后这个Spring将会将这个Bean对象放在自己的IOC容器中；
*
* @ConditionalOnMissingBean(HelloService.class)
* 条件装配：容器中没有HelloService这个类时标注的方法才生效 / 创建一个HelloService类
*/
@Bean
@ConditionalOnMissingBean(HelloService.class)
public BaseService helloService()
{
BaseService helloService = new HelloService();
return helloService;
}
}
- 前面都非常简单,就是自己生成了一个对象,然后交给spring ioc管理,接下来就是告诉spring 如何寻找到HelloAutoConfiguration
5.在resources/META-INF 下,创建spring.factories 文件,告诉你配置类的位置,srping会扫描包里这个文件,然后执行装配
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.liang.hello.autoConfig.HelloAutoConfiguration
这样一个简单的starter就写好了,使用maven构建一下,并推送到本地仓库,maven类似于nuget,懂的都懂,现在去创建一个测试项目,来测试一下
6.新建模块,选择Spring Initializr模块,给模块取个名字 hello-spring-boot-starter-test,在pom.xml里添加依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.liang</groupId>
<artifactId>hello-spring-boot-starter</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
7.java项目起手式,在src/main/java,创建包路径,定义为com.liang.hello
在resources下,定义application.yaml配置文件
hello:
prefix: 你好!
suffix: 666 and 888
student:
name: 雪佬
age: 18
server:
port: 8080
servlet:
context-path: /
8.在com.liang.hello下,定义controller包,用于webapi的控制器
定义一个HelloController类,编写一个简单的webapi,来测试自定义的starter,DataResponse是我自定义的一个统一返回类
@Autowired
BaseService helloService;
@ResponseBody
@GetMapping("/hello") //处理get请求方式的/hello请求路径
public DataResponse sayHello() //处理方法
{
String s = helloService.sayMsg("test666777888");
return DataResponse.Success(s,"");
}
- java语法懂的都懂,由于函数没有可选参数,所以需要写很多重载方法
package com.liang.hello.common;
import lombok.Builder;
import lombok.ToString;
@Builder
@ToString
public class DataResponse {
/**
* 响应码
*/
public String Code;
/**
* 返回的数据
*/
public Object Data;
/**
* 消息
*/
public String Message;
public DataResponse(String code,Object data,String message){
Code = code;
Data = data;
Message = message;
}
public static DataResponse Error() {
return DataResponse.builder().Code("-1").build();
}
public static DataResponse Error(Object data) {
return DataResponse.builder().Code("-1").Data(data).build();
}
public static DataResponse Error(String message) {
return DataResponse.builder().Code("-1").Message(message).build();
}
public static DataResponse Error(Object data,String message) {
return DataResponse.builder().Code("-1").Data(data).Message(message).build();
}
public static DataResponse Success() {
return DataResponse.builder().Code("0").build();
}
public static DataResponse Success(Object data) {
return DataResponse.builder().Code("0").Data(data).build();
}
public static DataResponse Success(String message) {
return DataResponse.builder().Code("0").Message(message).build();
}
public static DataResponse Success(Object data,String message) {
return DataResponse.builder().Code("0").Data(data).Message(message).build();
}
}
弄到这里starter就结束了嘛,显然事情没有这么简单,既然用到了spring的自动装配,那我们不妨往深处再挖一挖,没准有意外收获哦
前面我们已经创建了HelloService,那再创建一个TestService,同样继承BaseService,然后HelloAutoConfiguration类下,在写一个testService的bean,测试一下一个接口多个实现,如何获取指定的实例
非常神奇,spring会自动匹配,根据变量名称,自动匹配bean,点击左侧spring的绿色小图标(类似于断点图标),还能自动跳转到bean的实现,不要问,问就是牛逼,懂的都懂
现在我们已经在starter里创建了2个bean,如果有N个bean,每个bean都要去HelloAutoConfiguration类下写装配,真是太麻烦了,这个时候,就可以使用到spring的自动装配注解,只用在testService类上,加一个@Service的注解,就搞定了,简单方便,连spring.factories都不用写,在.net里的DI框架目前还没有统一,有内置的,用的比较多的是autofac,还有自研的DI框架,都大同小异
项目结构
springboot
springboot现在已经是java web开发的主流了,通常我们用.net core来之对标,他们诞生的初衷完全不一样,springboot是整合自身的生态,化繁为简,starter就是非常具有代表性的特性之一,.net core是一套跨平台方案,诞生之初就是为了跨平台,本身就非常简洁,易用性也非常高,开发者往里面添加所需的中间件即可,它的关注点始终围绕框架的简洁与性能
选择springboot脚手架项目,会自动创建一个启动文件HelloSpringBootStarterTestApplication 里面有一个@SpringBootApplication的组合注解,想了解的可以去翻阅java八股文,这里我加了一个@EntityScan("com.liang.hello")注解,用于自动扫描该包下的bean,并完成装配
控制器类上,要加@RestController 注解,这也是一个组合注解,然后在方法上加@ResponseBody注解,用于返回json类型,指定方法映射的路由,就可以了,如果想做mvc项目,还需要下载模板引擎的依赖,修改返回类型,指向一个视图,略微麻烦些
aop
- 创建完springboot webapi模块,我们需要添加一个切面,用于记录请求的信息
java里分为过滤器与拦截器,过滤器依赖与servlet容器,拦截器是Spring容器的功能,本质上都是aop思想的实现
.net core里内置了各种过滤器,方便我们直接使用,拦截器则使用的比较少
1.老步骤,添加maven依赖
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.9.1</version>
</dependency>
- 定义一个SpringBootAspect的类,用于AOP拦截,先定义一个切入点,再定义切面处理逻辑,这里主要定义一个控制器全局异常处理
@Aspect
@Component
public class SpringBootAspect {
/**
* 定义一个切入点
*/
@Pointcut(value="execution(* com.liang.hello.controller.*.*(..))")
public void aop(){}
@Around("aop()")
public Object around(ProceedingJoinPoint invocation) throws Throwable{
Object res = null;
System.out.println("SpringBootAspect..环绕通知 Before");
try {
res = invocation.proceed();
}catch (Throwable throwable){
//修改内容
System.out.println("页面执行错误,懂的都懂");
res = new DataResponse("500",null,"页面执行错误");
}
System.out.println("SpringBootAspect..环绕通知 After");
return res;
}
}
ide提示异常,java规定,结束语句后面,不允许有代码,他们认为编译器不执行的代码是垃圾代码,呔,java语法懂的都懂,略施小计,成功的骗过了ide
- 执行结果
定时任务
- 定时任务是工作中使用非常频繁的部分,也有很多框架,但是一些简单的内置任务,使用框架就有点杀鸡用牛刀了,.net里我们通常用HostedService来实现,springboot内置了定时任务
1.创建一个ScheduledTasks类,使用注解开启异步,HelloSpringBootStarterTestApplication类也要开启哦,代码如下
@EnableAsync
@Component
public class ScheduledTasks {
private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
/**
* 任务调度，每隔1秒执行一次
*/
@Async
@Scheduled(fixedRate = 1000)
public void reportCurrentTime() {
runThreadTest(1);
}
public void runThreadTest(int i) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程"+Thread.currentThread().getName()+"执行异步任务"+i + "现在时间：" + dateFormat.format(new Date()));
}
}
- runThreadTest方法,堵塞3秒,模拟业务执行耗时,发现定开启了异步,但是它依旧是同步执行,需要等上一个任务执行完毕,才会再执行下一个任务,网上翻了下答案,需要配置线程池,代码如下
package com.liang.hello.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
@Configuration
public class ExecutorConfig implements AsyncConfigurer {
// ThredPoolTaskExcutor的处理流程
// 当池子大小小于corePoolSize，就新建线程，并处理请求
// 当池子大小等于corePoolSize，把请求放入workQueue中，池子里的空闲线程就去workQueue中取任务并处理
// 当workQueue放不下任务时，就新建线程入池，并处理请求，
// 如果池子大小撑到了maximumPoolSize，就用RejectedExecutionHandler来做拒绝处理
// 当池子的线程数大于corePoolSize时，多余的线程会等待keepAliveTime长时间，如果无请求可处理就自行销毁
//getAsyncExecutor：自定义线程池，若不重写会使用默认的线程池。
@Override
@Bean
public Executor getAsyncExecutor() {
ThreadPoolTaskExecutor threadPool = new ThreadPoolTaskExecutor();
//设置核心线程数
threadPool.setCorePoolSize(10);
//设置最大线程数
threadPool.setMaxPoolSize(20);
//线程池所使用的缓冲队列
threadPool.setQueueCapacity(10);
//等待任务在关机时完成--表明等待所有线程执行完
threadPool.setWaitForTasksToCompleteOnShutdown(true);
// 等待时间 （默认为0，此时立即停止），并没等待xx秒后强制停止
threadPool.setAwaitTerminationSeconds(60);
// 线程名称前缀
threadPool.setThreadNamePrefix("ThreadPoolTaskExecutor-");
// 初始化线程
threadPool.initialize();
return threadPool;
}
}
执行结果
mybatis plus
- 目前java主流的ORM框架,应该是mybatis了,我是不怎么喜欢在xml里组织sql的,麻烦的一批,但是也避免了萌新为图方便,sql写的到处都是,维护起来懂的都懂,网上随便翻个答案,直接往项目里整合
1.老样子先添加依赖
<!--mybatis-plus的springboot支持-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.3.1</version>
</dependency>
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-core</artifactId>
<version>3.4.3.1</version>
</dependency>
2.然后在yaml文件里添加mysql与mybatis plus的配置
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://************:3306/test_mybatis?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
username: root
password: ******
jackson:
date-format: yyyy-MM-dd HH:mm:ss
time-zone: GMT+8
serialization:
write-dates-as-timestamps: false
mybatis-plus:
configuration:
map-underscore-to-camel-case: false
auto-mapping-behavior: full
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
mapper-locations: classpath:mapper/*.xml
global-config:
# 逻辑删除配置
db-config:
# 删除前
logic-not-delete-value: 1
# 删除后
logic-delete-value: 0
3.再整一个mybatis plus的配置类,添加mybatis plus的拦截器,反正也是网上抄的,我猜测大致是这个意思
package com.liang.hello.config;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MybatisPlusConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
return interceptor;
}
}
现在开始添加创建mybatis的相关目录,网上都有,直接跟着抄就可以了,也非常好理解
4.定义一个mapper的包,在包下编写mybatis的接口,我这里用的是mybatis plus,已经默认实现了CRUD,我们简单的写几个接口,用来测试
package com.liang.hello.mapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.liang.hello.dto.OrderInfoResponse;
import com.liang.hello.entity.UserInfo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
@Mapper
//表明这是一个Mapper，也可以在启动类上加上包扫描
//Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能
public interface UserInfoMapper extends BaseMapper<UserInfo> {
@Select("select u.*,o.id as orderId,o.price from user_info u left join order_info o on u.id = o.userId ${ew.customSqlSegment}")
List<OrderInfoResponse> getAll(@Param(Constants.WRAPPER) Wrapper wrapper);
List<UserInfo> selectByName(@Param("UserName") String userName);
void updateUserInfo(@Param("UserName") String userName,@Param("Age") int age);
}
-
简单的sql,mybatis plus也支持直接使用注解的方式来执行,简单方便,参数是通过queryWrapper条件构造器来完成的,喜欢的同学可以重点了解一下,.net里有linq,用过的同学懂的都懂
另外一个方式,就是通过制定mapper.xml来编写sql,xml文件路径在配置文件里制定,我们按照约定即可,在resources/mapper下,创建UserInfo.xml,名称空间指向接口路径,id对应接口的名称,返回类型指向对应的实体
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "<http://mybatis.org/dtd/mybatis-3-mapper.dtd>">
<mapper namespace="com.com.liang.hello.mapper.UserInfoMapper">
<select id="selectByName" resultType="com.liang.hello.entity.UserInfo">
select * from user_info
<where>
<if test="UserName != null and UserName != ''">
UserName like CONCAT('%',#{UserName},'%');
</if>
</where>
</select>
<select id="updateUserInfo" resultType="com.liang.hello.entity.UserInfo">
update user_info set Age=#{Age}
<where>
<if test="UserName != null and UserName != ''">
UserName = #{UserName};
</if>
</where>
</select>
</mapper>
mybatis xml语法可以去学习下,也不困难,简单的看一遍就差不多了,复杂的部分用到的时候再去翻阅
5.定义一个service的包,在包下创建UserInfoServiceImpl,很熟悉的味道,经典的三层架构,在service层编写业务逻辑,调用mapper接口的增删改查方法,这里重点说下事务
spring提供了事务的注解@Transactional,使用起来也非常方便,原理应该是借助AOP来实现,使用这个注解前需要事先了解事务失效的场景,老八股文了,懂的都懂,在.net里使用手动提交事务比较多,特意去了解搜了下手动提交事务,感觉差不多
//修改年龄
@Transactional
public void update(UserInfo entity){
// TransactionStatus txStatus = transactionManager.getTransaction(new DefaultTransactionDefinition());
//
// try {
// userInfoMapper.updateUserInfo(entity.getUserName(),entity.getAge());
// if(true) {
// throw new Exception("xx");
// }
// userInfoMapper.updateUserInfo(entity.getUserName(),entity.getAge()+1);
//
// } catch (Exception e) {
// transactionManager.rollback(txStatus);
// e.printStackTrace();
// }finally {
// transactionManager.commit(txStatus);
// }
//执行第一条sql
userInfoMapper.updateUserInfo(entity.getUserName(),entity.getAge());
if(true) throw new RuntimeException();
//执行第二条sql
userInfoMapper.updateUserInfo(entity.getUserName(),entity.getAge()+1);
}
jwt
- 现在前后端分离已经成为主流,jwt是首选方案,话不多说,直接往里面怼
1.老规矩,先添加jwt的依赖
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.4.0</version>
</dependency>
2.先定义一个工具类JwtUtils,用于jwt的一些常规操作,当看到verifyToken这个方法的时候,我就发现事情没有那么简单
package com.liang.hello.common;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;
import org.springframework.util.StringUtils;
import javax.servlet.http.HttpServletRequest;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
public class JwtUtils {
// 过期时间 24 小时 60 * 24 * 60 * 1000
private static final long EXPIRE_TIME = 60 * 60 * 1000;//60分钟
// 密钥
private static final String SECRET = "uxzc5ADbRigUDaY6pZFfWus2jZWLPH1";
private static String json="";
/**
* 生成 token
*/
public static String createToken(String userId) {
try {
// 设置过期时间
Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
// 私钥和加密算法
Algorithm algorithm = Algorithm.HMAC256(SECRET);
// 设置头部信息
Map<String, Object> header = new HashMap<>(2);
header.put("Type", "Jwt");
header.put("alg", "HS256");
// 返回token字符串 附带userId信息
return JWT.create()
.withHeader(header)
.withClaim("userId", userId)
//到期时间
.withExpiresAt(date)
//创建一个新的JWT，并使用给定的算法进行标记
.sign(algorithm);
} catch (Exception e) {
return null;
}
}
/**
* 校验 token 是否正确
*/
public static Map<String, Claim> verifyToken(String token){
token = token.replace("Bearer ","");
DecodedJWT jwt = null;
try {
JWTVerifier verifier = JWT.require(Algorithm.HMAC256(SECRET)).build();
jwt = verifier.verify(token);
} catch (TokenExpiredException e) {
//效验失败
//这里抛出的异常是我自定义的一个异常，你也可以写成别的
throw new TokenExpiredException("token校验失败");
}
return jwt.getClaims();
}
/**
* 获得token中的信息
*/
public static String getUserId(String token) {
Map<String, Claim> claims = verifyToken(token);
Claim user_id_claim = claims.get("userId");
if (null == user_id_claim || StringUtils.isEmpty(user_id_claim.asString())) {
return null;
}
return user_id_claim.asString();
}
}
- 校验token正确,从token中获取信息,在.net里框架帮忙做了,使用起来非常简单,emmmmm.....我觉得spring提供一个spring-boot-starter-jwt 很有必要
.net里实现如下
//认证参数
services.AddAuthentication("Bearer")
.AddJwtBearer(o =>
{
o.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,//是否验证签名,不验证的话可以篡改数据，不安全
IssuerSigningKey = signingKey,//解密的密钥
ValidateIssuer = true,//是否验证发行人，就是验证载荷中的Iss是否对应ValidIssuer参数
ValidIssuer = jwtOptions.Iss,//发行人
ValidateAudience = true,//是否验证订阅人，就是验证载荷中的Aud是否对应ValidAudience参数
ValidAudience = jwtOptions.Aud,//订阅人
ValidateLifetime = true,//是否验证过期时间，过期了就拒绝访问
ClockSkew = TimeSpan.Zero,//这个是缓冲过期时间，也就是说，即使我们配置了过期时间，这里也要考虑进去，过期时间+缓冲，默认好像是7分钟，你可以直接设置为0
RequireExpirationTime = true,
};
o.Events = new JwtBearerEvents
{
//权限验证失败后执行
OnChallenge = context =>
{
//终止默认的返回结果(必须有)
context.HandleResponse();
var result = JsonConvert.SerializeObject(new { code = "401", message = "验证失败" });
context.Response.ContentType = "application/json";
//验证失败返回401
context.Response.StatusCode = StatusCodes.Status200OK;
context.Response.WriteAsync(result);
return Task.FromResult(0);
}
};
});
- 思路应该比较简单,弄个拦截器,校验一波jwt,完成认证,再通过jwt里的userId校验用户是否拥有访问权限,开干
3.先整一个自定义的注解AllowAnonymousAttribute,允许匿名访问,标识这个注解可以作用于类和方法上
package com.liang.hello.attribute;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface AllowAnonymousAttribute {
boolean required() default true;
}
- 编写自定义拦截器,用于jwt的校验,校验通过,获取用户信息并授权,这里主要是获取类跟方法有没有使用自定义注解,HandlerInterceptorAdapter也提示已过期,不知道有没有替代方案
package com.liang.hello.filters;
import com.auth0.jwt.interfaces.Claim;
import com.liang.hello.attribute.AllowAnonymousAttribute;
import com.liang.hello.common.JwtUtils;
import com.liang.hello.entity.UserInfo;
import com.liang.hello.service.UserInfoServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.security.SignatureException;
import java.util.Map;
@Component
public class JwtFilter extends HandlerInterceptorAdapter {
@Autowired
UserInfoServiceImpl userInfoService;
@Override
public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object object) throws SignatureException {
// 如果不是映射到方法直接通过
if (!(object instanceof HandlerMethod)) {
return true;
}
HandlerMethod handlerMethod = (HandlerMethod) object;
AllowAnonymousAttribute actionAttribute= handlerMethod.getMethod().getDeclaredAnnotation(AllowAnonymousAttribute.class);
AllowAnonymousAttribute controllerAttribute = handlerMethod.getBeanType().getDeclaredAnnotation(AllowAnonymousAttribute.class);
if (actionAttribute!=null || controllerAttribute!=null) return true;
//默认全部检查
System.out.println("被jwt拦截需要验证");
// 从请求头中取出 token 这里需要和前端约定好把jwt放到请求头一个叫Authorization的地方,**<font color=red size=3>懂的都懂</font>**
String token = httpServletRequest.getHeader("Authorization");
// 执行认证
if (token == null) {
//这里其实是登录失效,没token了 这个错误也是我自定义的，读者需要自己修改
throw new SignatureException("自定义错误");
}
// 获取 token 中的 user Id
String userId = JwtUtils.getUserId(token);
//找找看是否有这个user 因为我们需要检查用户是否存在，读者可以自行修改逻辑
UserInfo user = userInfoService.getUserInfoById(userId);
if (user == null) {
//这个错误也是我自定义的
throw new SignatureException("自定义错误");
}
//放入attribute以便后面调用
httpServletRequest.setAttribute("userName", user.getUserName());
httpServletRequest.setAttribute("id", user.getId());
httpServletRequest.setAttribute("age", user.getAge());
return true;
}
}
4.注册自定义拦截器,让spring调用这个拦截器
package com.liang.hello.config;
import com.liang.hello.filters.JwtFilter;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import javax.annotation.Resource;
@Configuration
public class WebConfig implements WebMvcConfigurer {
@Resource
private JwtFilter jwtFilter ;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(jwtFilter).addPathPatterns("/**");
}
}
异常处理
前面我们有使用过框架自定义的一些异常,TokenExpiredException,SignatureException,我们可以在SpringBootAspect里处理这些异常,并给出友好提示
@ExceptionHandler(value = {TokenExpiredException.class})
public DataResponse tokenExpiredException(TokenExpiredException e){
return new DataResponse("401",null,"权限不足token失效");
}
@ExceptionHandler(value = {SignatureException.class})
public DataResponse authorizationException(SignatureException e){
return new DataResponse("401",null,"权限不足");
}
//全局异常,兜底方案
@ExceptionHandler(value = {Exception.class})
public DataResponse exception(Exception e){
return new DataResponse("500",null,"系统错误");
}
-
未登录访问需要授权接口
-
登录,使用错误的用户名
-
登录,使用正确的用户名
-
使用token,访问需要授权接口
主动抛出异常
正常执行
-
token过期,访问需要授权接口
-
使用错误token,访问需要授权接口,因为没有主动捕获该异常,被全局异常统一处理
