API 开放接口设计之 appId，appSecret，accessToken (同微信开发平台接口)_authcontroller accesstokeninterceptor-CSDN博客

本文链接：https://blog.csdn.net/qq_41463655/article/details/103376957

前篇：如何设计开放 Api

以下链接来源于网络素材：
需要考虑点摘录一： https://blog.csdn.net/weixin_34414196/article/details/92105613
需要考虑点摘录二：https://blog.csdn.net/fengdijiang/article/details/93850389
摘录三（详细）：https://blog.csdn.net/l18848956739/article/details/86664142

一、开放接口设计说明：

为每个合作机构创建对应的appid、app_secret，生成对应的access_token（有效期2小时），在调用外网开放接口的时候，必须传递有效的access_token。
使用 access_token 验证通过才能正常调用开放的 API 接口

appid             是每个用户唯一的
app_secret        可以开发着平台更改
access_token      通过 appid +  app_secret  生成 ，（有效期2小时）

如：微信公众号开发调用微信接口，下面就自己写一个类似于微信开发的api 开放接口平台

使用流程：同调用第三方平台接口
1、api 开发平台申请appid ，app_secret ，或自行提供给消费方
2、消费方通过 appid ，app_secret 获得 access_token ( 有效期2小时)
3、消费方调用接口携带 accessToken 参数，验证通过可以才访问接口，未提供返回错误信息

二、数据库表设计 (已下为核心字段，更多自行添加)

App_Name          表示机构名称
App_ID            应用id
App_Secret        应用密钥  （可更改） 
Is_flag           是否可用 （是否对某个机构开放）
access_token      上一次access_token


CREATE TABLE `m_app` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `app_name` varchar(255) DEFAULT NULL,
  `app_id` varchar(255) DEFAULT NULL,
  `app_secret` varchar(255) DEFAULT NULL,
  `is_flag` varchar(255) DEFAULT NULL,
  `access_token` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

三、Redis 缓存工具类 (自行配置缓存框架)

自行项目配置，也可以使用其他缓存框架
setString 保存
getString 读取
delKey 删除


import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class BaseRedisService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * TODO    添加/更新
     * @param key  键
     * @param data  值
     * @param timeout 时间（秒）
     * @date  2019/12/3 0003 21:26
     * @return void
     */
    public void setString(String key, Object data, Long timeout) {
        if (data instanceof String) {
            String value = (String) data;
            stringRedisTemplate.opsForValue().set(key, value);
        }
        if (timeout != null) {
            //重新设置过期时间，刷新时间
            stringRedisTemplate.expire(key, timeout, TimeUnit.SECONDS);
        }
    }

    /**
     * TODO    读取
     * @param key 键
     * @date  2019/12/3 0003 21:27
     * @return java.lang.Object
     */
    public Object getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * TODO    删除
     * @param key 键
     * @date  2019/12/3 0003 21:27
     * @return void
     */
    public void delKey(String key) {
        stringRedisTemplate.delete(key);
    }
}

四、AppEntity 实体类

public class AppEntity {

	private long id;
	private String appId;
	private String appName;
	private String appSecret;
	private String accessToken;
	private int isFlag;
}

五、AppMapper ，数据层

public interface AppMapper {

	@Select("SELECT ID AS ID ,APP_NAME AS appName, app_id as appId, app_secret as appSecret ,is_flag as isFlag , access_token as accessToken from m_app "
			+ "where app_id=#{appId} and app_secret=#{appSecret}  ")
	AppEntity findApp(AppEntity appEntity);

	@Select("SELECT ID AS ID ,APP_NAME AS appName, app_id as appId, app_secret as appSecret ,is_flag as isFlag  access_token as accessToken from m_app "
			+ "where app_id=#{appId} and app_secret=#{appSecret}  ")
	AppEntity findAppId(@Param("appId") String appId);

	@Update(" update m_app set access_token =#{accessToken} where app_id=#{appId} ")
	int updateAccessToken(@Param("accessToken") String accessToken, @Param("appId") String appId);
}

六、 Token生成工具类TokenUtils

public class TokenUtils {

	@RequestMapping("/getToken")
	public static String getAccessToken() {
		return UUID.randomUUID().toString().replace("-", "");
	}
}

七、getAccessToken 接口生成 accessToken

步骤：
1、调用接口传递 appId+appSecret
2、判断是否存在商户信息
3、判断商户信息是否有权限
4、生成AccessToke，根据当前appId 商户更新最新的 accessToke 到数据库
5、删除Redis 上次生成的AccessToke缓存，保存最新的accessToke到Redis


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.alibaba.fastjson.JSONObject;
import com.itmayiedu.base.BaseApiService;
import com.itmayiedu.base.ResponseBase;
import com.itmayiedu.entity.AppEntity;
import com.itmayiedu.mapper.AppMapper;
import com.itmayiedu.utils.BaseRedisService;
import com.itmayiedu.utils.TokenUtils;

/**
 * TODO  创建获取getAccessToken
 *
 * @date 2019/12/3 0003 21:31
 */
@RestController
@RequestMapping(value = "/auth")
public class AuthController extends BaseApiService {

    /**
     * Redis
     */
    @Autowired
    private BaseRedisService baseRedisService;

    /**
     * 创建的表appEntity ,的 dao对象
     */
    @Autowired
    private AppMapper appMapper;

    /**
     * 过期时间，单位秒
     */
    private long timeToken = 60 * 60 * 2;


    /**
     * TODO    使用appId+appSecret 生成AccessToke
     * @param appEntity
     * @date  2019/12/3 0003 21:33
     * @return com.itmayiedu.base.ResponseBase
     */
    @RequestMapping("/getAccessToken")
    public ResponseBase getAccessToken(AppEntity appEntity) {
        // 使用appId + appSecret查询
        AppEntity appResult = appMapper.findApp(appEntity);
        // 判断是否存在商户信息，等同与微信开发平台申请的appid，appSecret信息是否正确
        if (appResult == null) {
            return setResultError("没有对应机构的认证信息");
        }
        //判断是否开发权限给该商户
        int isFlag = appResult.getIsFlag();
        if (isFlag == 1) {
            return setResultError("您现在没有权限生成对应的AccessToken");
        }
        // 从redis中删除之前的accessToken
        baseRedisService.delKey(appResult.getAccessToken());
        // 生成的新的accessToken 保存到 Redis，并保存到数据库
        String newAccessToken = newAccessToken(appResult.getAppId());
        //返回 accessToken，setResultSuccessData为封装返回信息，请自定义
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("accessToken", newAccessToken);
        return setResultSuccessData(jsonObject);
    }


    /**
     * TODO
     * @param appId
     * @date  2019/12/3 0003 21:33
     * @return java.lang.String
     */
    private String newAccessToken(String appId) {
        // 使用 appid+appsecret 生成对应的AccessToken , 保存两个小时
        String accessToken = TokenUtils.getAccessToken();
        // 保证在同一个事物redis 事物中
        // 生成最新的token, key=accessToken ,value=appid
        baseRedisService.setString(accessToken, appId, timeToken);
        // 表数据更新为最新的 accessToken，删除之前的accessToken使用
        appMapper.updateAccessToken(accessToken, appId);
        return accessToken;
    }
}

八、添加拦截器AccessTokenInterceptor ，判断请求参数 accessToken

统一拦截所有开放接口的请求，判断accessToken 是否有效


import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.deser.Deserializers.Base;
import com.itmayiedu.base.BaseApiService;
import com.itmayiedu.utils.BaseRedisService;

/**
 * TODO    验证AccessToken 是否正确
 *
 * @date 2019/12/3 0003 21:54
 * @return
 */
@Component
public class AccessTokenInterceptor extends BaseApiService implements HandlerInterceptor {

    /**
     * redis
     */
    @Autowired
    private BaseRedisService baseRedisService;

    /**
     * 进入controller层之前拦截请求
     *
     * @param httpServletRequest
     * @param httpServletResponse
     * @param o
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o)
            throws Exception {
        System.out.println("---------------------开始进入请求地址拦截----------------------------");
        //获取到accessToken
        String accessToken = httpServletRequest.getParameter("accessToken");
        // 判断accessToken是否空
        if (StringUtils.isEmpty(accessToken)) {
            // 返回错误消息
            resultError(" this is parameter accessToken null ", httpServletResponse);
            return false;
        }
        //从redis 中获取获取到accessToken
        String appId = (String) baseRedisService.getString(accessToken);
        if (StringUtils.isEmpty(appId)) {
            // accessToken 已经失效!
            resultError(" this is  accessToken Invalid ", httpServletResponse);
            return false;
        }
        // 正常执行业务逻辑...
        return true;
    }

    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o,
                           ModelAndView modelAndView) throws Exception {
        System.out.println("--------------处理请求完成后视图渲染之前的处理操作---------------");
    }

    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,
                                Object o, Exception e) throws Exception {
        System.out.println("---------------视图渲染之后的操作-------------------------0");
    }

    /**
     * TODO    返回错误提示
     * @param errorMsg
     * @param httpServletResponse
     * @date  2019/12/3 0003 21:58
     * @return void
     */
    public void resultError(String errorMsg, HttpServletResponse httpServletResponse) throws IOException {
        PrintWriter printWriter = httpServletResponse.getWriter();
        // setResultError为封装的返回信息，请自定义
        printWriter.write(new JSONObject().toJSONString(setResultError(errorMsg)));
    }

九、添加拦截器AccessTokenInterceptor 的拦截范围

/openApi 下的所有接口

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebAppConfig {
	@Autowired
	private AccessTokenInterceptor accessTokenInterceptor;

	@Bean
	public WebMvcConfigurer WebMvcConfigurer() {
		return new WebMvcConfigurer() {
			public void addInterceptors(InterceptorRegistry registry) {
			    //  /openApi   下的所有接口
				registry.addInterceptor(accessTokenInterceptor).addPathPatterns("/openApi/*");
			};
		};
	}
}