东拼西凑学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,访问需要授权接口,因为没有主动捕获该异常,被全局异常统一处理

巴特西