Spring Boot Starter 理解

可以认为starter是一种服务（和JS的插件类似）——使得使用某个功能的开发者不需要关注各种依赖库的处理，不需要具体的配置信息，由Spring Boot自动通过classpath路径下的类发现需要的Bean，并织入bean

starter 开始

• 首先创建一个maven项目
• 项目命名方式为[name]-spring-boot-starter (官方命名方式 spring-boot-starter-[name])
• 在pom.xml中添加starter所需要的依赖
• 创建starter相关类（至少有一个自动配置类）
• 在resource文件夹下创建META-INF文件夹 (srping.factories)

jwt-spring-boot-starter 定义

• 相关配置的用实体类表示（属性配置类）
• 开放的服务类
• JWT工具类
• 自动配置类

1：创建项目

项目创建

项目命名

2：创建所需要的文件

所需文件

配置文件

3： 代码简介

JwtServiceProperties 属性配置类

// 需要在配置文件配置所需要的属性
// 本例的配置文件
jwt.base64Security = 0914234854!wa
jwt.issuer = alienlabManage

package com.alienlab.starter;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
 * Created by Msater Zg on 2017/7/13.
 */
 // 读取配置文件，采用的是实体类的方式
 当然你也可以 ${} 的方式
@ConfigurationProperties(prefix = "jwt")
public class JwtServiceProperties {

    /**
     * 密钥
     * 系统的简称
     */
    // 名称要与配置文件相同
    private String base64Security;

    private String issuer;

    public String getBase64Security() {
        return base64Security;
    }

    public void setBase64Security(String base64Security) {
        this.base64Security = base64Security;
    }

    public String getIssuer() {
        return issuer;
    }

    public void setIssuer(String issuer) {
        this.issuer = issuer;
    }
}

JwtService 启动器服务类

// 服务类 开放出来的接口，当然没有接口开放也可以不需要这个类
package com.alienlab.starter;

import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Map;

/**
 * Created by Msater Zg on 2017/7/13.
 */
public class JwtService {
    // 需要在自动配置类中注入此bean
    @Autowired   
    JwtUtils jwtUtils;

    private String base64Security;

    private String issuer;

    public JwtService(String base64Security, String issuer) {
        this.base64Security = base64Security;
        this.issuer = issuer;
    }

    // 创建 map中放个人信息，可以被他们获取到，第二个是发送给谁，第三参数是过期时间
    public String createPersonToken(Map map, String audience, long TTLMillis) {
        String personToken = jwtUtils.createJWT(map, audience, this.issuer, TTLMillis, this.base64Security);
        return personToken;
    }

    // token
    public Claims parsePersonJWT(String personToken) {
        Claims claims = jwtUtils.parseJWT(personToken, this.base64Security);
        return claims;
    }
}

JwtUtils 工具类（启动器的逻辑类）

// jwt工具类 这个主要是jwt业务逻辑的类，不同的starter业务逻辑肯定是不同的
package com.alienlab.starter;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
import java.security.Key;
import java.util.Date;
import java.util.Map;

/**
 * Created by Msater Zg on 2017/3/13.  jwt实现方式
 */
public class JwtUtils {

    // 加密方法
    public Claims parseJWT(String jsonWebToken, String base64Security) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(DatatypeConverter.parseBase64Binary(base64Security))
                    .parseClaimsJws(jsonWebToken).getBody();
            return claims;
        } catch (Exception ex) {
            return null;
        }
    }

    // 解密方法
    public String createJWT(Map map,
                            String audience, String issuer, long TTLMillis, String base64Security) {
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        //生成签名密钥 就是一个base64加密后的字符串？
        byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(base64Security);
        Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());
        //添加构成JWT的参数
        JwtBuilder builder = Jwts.builder().setHeaderParam("typ", "JWT")
                .setIssuedAt(now)  //创建时间
                .setSubject(map.toString()) //主题，也差不多是个人的一些信息
                .setIssuer(issuer) //发送谁
                .setAudience(audience) //个人签名
                .signWith(signatureAlgorithm, signingKey);  //估计是第三段密钥
        //添加Token过期时间
        if (TTLMillis >= 0) {
            // 过期时间
            long expMillis = nowMillis + TTLMillis;
            // 现在是什么时间
            Date exp = new Date(expMillis);
            // 系统时间之前的token都是不可以被承认的
            builder.setExpiration(exp).setNotBefore(now);
        }
        //生成JWT
        return builder.compact();
    }
}

JwtAutoConfiguration 自动装配类（必须的文件类）

// 自动装配类（最重要的类，没有此类，spring boot不会自动扫描jar）
package com.alienlab.starter;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Created by Msater Zg on 2017/7/13.
 */
@Configuration
@ConditionalOnClass(JwtService.class)
@EnableConfigurationProperties(JwtServiceProperties.class)
public class JwtAutoConfiguration {
    @Autowired
    private JwtServiceProperties jwtServiceProperties;

    // 创建相关bean
    @Bean
    JwtService jwtService() {
        return new JwtService(jwtServiceProperties.getBase64Security(), jwtServiceProperties.getIssuer());
    }

    @Bean
    JwtUtils jwtUtils() {
        return new JwtUtils();
    }
}

//创建bean 的一些判断条件注解
@Bean
    @ConditionalOnMissingBean
    @ConditionalOnProperty(prefix = "jwt",value ="enabled",havingValue = "true")
    JwtUtils jwtUtils() {
        return new JwtUtils();
    }
    
@ConditionalOnClass，当classpath下发现该类的情况下进行自动配置。
@ConditionalOnMissingBean，当Spring Context中不存在该Bean时。
@ConditionalOnProperty(prefix = "jwt",value = "enabled",havingValue = "true")，jwt.enabled=true时

spring.factories文件（必需的，这样spring boot启动时，才会发现并且加载这个jar）

// 指向刚才自动装配类路径
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.alienlab.starter.JwtAutoConfiguration

4：pom.xml文件详情（所依赖的jar，如果不同启动器所依赖的jar有相同，则尽量写在一起。防止两个同时引用产生jar包冲突的问题！）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>alienlab</groupId>
    <artifactId>jwt-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <jwtio.version>0.6.0</jwtio.version>
        <auth0.version>3.1.0</auth0.version>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <!--jwt-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>${auth0.version}</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>${jwtio.version}</version>
        </dependency>
    </dependencies>

</project>

4：项目打包

• 到项目的pom.xml文件所在的同一层级目录，打开命令窗口输入命令 mvn install ，打包好的starter在项目的target目录里面。

5： 开始使用（创建好spring boot项目）

// 添加依赖（选择自己的启动器路径）
<dependency>
       <groupId>alienlab</groupId>
       <artifactId>jwt-spring-boot-starter</artifactId>
       <version>1.0-SNAPSHOT</version>
 </dependency>

//在application.properties配置所需要的属性
#jwt setting
jwt.base64Security=091418wa!
jwt.issuer=yuqingmanage

//自动注入，并开始使用服务的方法
@Autowired
    JwtService jwtService;
    
@RequestMapping(value = "/getAllSysUser", method = RequestMethod.GET)
    @ApiOperation(value = "getAllSysUser", notes = "获取到所有的用户")
    @ApiImplicitParams({
    })
    public String getAllSysUser() {
        String reuslt = iUserService.getAllSysUser().toString();
        Map map = new HashMap();
        map.put("user", "赵刚");
        System.out.println(jwtService.createPersonToken(map, "1402753117", 200));
        return reuslt;
    }

结语：

• 后续的项目直接引入依赖，不需要重新复制。代码维护非常方便，将自己的starter上传到maven仓库其他人就可以下载使用。当然starter并不是万能的，适用于一些和系统的业务没有直接关联的逻辑。比如swagger，跨域的配置，拦截器，jwt安全加密，缓存等等！