项目总结之Oauth2.0免登陆及相关知识点总结

简介Oauth2.0授权步骤

授权码模式的基本步骤

原文链接地址


（A）用户访问客户端，后者将前者导向认证服务器。

（B）用户选择是否给予客户端授权。

（C）假设用户给予授权，认证服务器将用户导向客户端事先指定的"重定向URI"（redirection URI），同时附上一个授权码。

（D）客户端收到授权码，附上早先的"重定向URI"，向认证服务器申请令牌。这一步是在客户端的后台的服务器上完成的，对用户不可见。

（E）认证服务器核对了授权码和重定向URI，确认无误后，向客户端发送访问令牌（access token）和更新令牌（refresh token）。

各步骤详细解析

A步骤中，客户端申请认证的URI，包含以下参数：

• response_type：表示授权类型，必选项，此处的值固定为"code"
• client_id：表示客户端的ID，必选项
• redirect_uri：表示重定向URI，可选项
• scope：表示申请的权限范围，可选项
• state：表示客户端的当前状态，可以指定任意值，认证服务器会原封不动地返回这个值。
• 下面是一个例子。
  /authorize?response_type=code&client_id=s6BhdRkqt3&state=xyz
  &redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb

C步骤中，服务器回应客户端的URI，包含以下参数：

• code：表示授权码，必选项。该码的有效期应该很短，通常设为10分钟，客户端只能使用该码一次，否则会被授权服务器拒绝。该码与客户端ID和重定向URI，是一一对应关系。
• state：如果客户端的请求中包含这个参数，认证服务器的回应也必须一模一样包含这个参数
• 下面是一个例子。 https://client.example.com/cb?code=SplxlOBeZQQYbYS6WxSbIA
  &state=xyz

D步骤中，客户端向认证服务器申请令牌的HTTP请求，包含以下参数：

• grant_type：表示使用的授权模式，必选项，此处的值固定为"authorization_code"。
• code：表示上一步获得的授权码，必选项。
• redirect_uri：表示重定向URI，必选项，且必须与A步骤中的该参数值保持一致。
• client_id：表示客户端ID，必选项。
• 下面是一个例子。 /token?grant_type=authorization_code&code=SplxlOBeZQQYbYS6WxSbIA
  &redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb

E步骤中，认证服务器发送的HTTP回复，包含以下参数：

• access_token：表示访问令牌，必选项。
• token_type：表示令牌类型，该值大小写不敏感，必选项，可以是bearer类型或mac类型。
• expires_in：表示过期时间，单位为秒。如果省略该参数，必须其他方式设置过期时间。
• refresh_token：表示更新令牌，用来获取下一次的访问令牌，可选项。
• scope：表示权限范围，如果与客户端申请的范围一致，此项可省略。
• 下面是一个例子。{
  "access_token":"2YotnFZFEjr1zCsicMWpAA",
  "token_type":"example",
  "expires_in":3600,
  "refresh_token":"tGzv3JOkF0XG5Qx2TlKWIA",
  "example_parameter":"example_value"
  }

项目实战总结

项目背景简介

• 项目用的spring全家桶+shiro+oauth2.0，不懂shiro也没关系
• A系统为门户系统，需要用户登录；
• B系统是一个业务系统，嵌在A系统里面，所以不需要再重新登陆，不提供相关登陆接口；

具体代码及流程

先介绍B网站登陆认证流程

第一步

• 有一个filter，继承自shiro的【UserFilter】，onAccessDenied方法（即未登录状态下访问B接口）

@Override
	protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
	    0. 获取当前请求的requestUri=requestUri()
	    1. 生成uuid
	    2. 将request保存到redis，有效期30秒，redis.set(uuid,request)
	    3. loginUrl = getLoginUrl()="/B/login?oauth";配置文件
	    4. 重定向到loginUrl?redirect_uri=/B/proxy?_oauth=uuid
	    即/B/login?oauth&redirect_uri=/B/proxy?_oauth=uuid
	    
	    总结：单纯系统内拦截未登录的请求，并将请求信息保存下来，然后跳转到B系统的登陆url，附加了一些参数，方便回调
	}

第二步

@RequestMapping("/login")
	public void login( 
			HttpServletRequest request,
			HttpServletResponse response
			) throws URISyntaxException, IOException{
			    
			   String code=request.getParameter("code");
			   if(StringUtils.isNotBlank(code)){
    			  // ... 
    			  // 判断code的先省略，一会再看
    			  // code不为空，代表是从A系统授权过来的请求
    			  // ....
			   }else{
			       else 部分的方法见下面
			     
			   }
			   
			  //  else 部分的方法
			   
			   //  获取loginUrl=http://localhost:8080/B/login相当于是写死的
			   1.loginUrl=String.format("%s://%s:%d%s/%s",request.getScheme(),request.getServerName(),request.getServerPort(),request.getContextPath(),"login");
			   2.取第一步中的传过来的参数redirect_uri，拼接到loginUrl的后面，
			   3.新的loginUrl=http://localhost:8080/B/login?redirect_uri=/B/proxy?_oauth=b54896bc-2c26-4763-a2a6-7cbfb9223c76
			    // 以上都只是在自己的系统中拼装参数之类的
			    // 接下来就是应用Oauth2相关的协议了
			    我们在B系统的配置文件中配置了以下配置项
			    oauth2.url=http://localhost:8080/A
                oauth2.loginUrl=http://localhost/A
                oauth2.resource.charset=utf-8
                oauth2.authorize=/oauth2/authorize
                oauth2.access_token=/oauth2/access_token
                oauth2.resource=/oauth2/resource
                oauth2.client_id=c3991093-f25c-11e6-b7ab-524f72a73ffc
                oauth2.client_secret=d02153b8-f25c-11e6-b7ab-524f72a73ffc
			    4.接下来就要调用/A系统中的方法授权方法了，取{oauth2.loginUrl}和{oauth2.authorize}俩个参数，拼装成：http://localhost/portal.web/oauth2/authorize。
			    5.接下来再拼装Oauth的参数
			    4和5俩不代码如下
			    URIBuilder uriBuilder=new URIBuilder((StringUtils.isBlank(loginUrl)?url:loginUrl)+authorizeUrl);
        		uriBuilder.addParameter("response_type", "code");
        		uriBuilder.addParameter("client_id", clientId);
        		//参数logoutUrl的获取方式与本方法的loginUrl获取方式一致
        		uriBuilder.addParameter("logout_uri",logoutUrl);
        		uriBuilder.addParameter("state", "portal");
        		// reUrl就是本方法步骤3生成的loginUrl
        		uriBuilder.addParameter("redirect_uri", reUrl);
        		
        		6.最后一步就是跳转到A系统请求授权redirect(URIBuilder.toString)
			}

第三步

• A系统的方法
  1. A系统同样有一个filter用来拦截请求，继承自shiro的UserFilter，当遇到没有登陆的请求时，

    @Override
        protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
            // 获取请求 
    		String requestURI = getPathWithinApplication(request);
    		// 判断请求，如果是登陆请求则直接拦截（意味着shiro会将重定向到登陆页面）；如果不是登陆请求，则保存请求，然后重定向
    		boolean isLogin=requestURI.indexOf(getLoginUrl())>-1;
    		if(!isLogin){
    		    
        	    String url=request.getRequestURI().toLowerCase();
    			if(url.indexOf("?")>0){ //去掉?后面的参数
    				url=url.substring(0,url.indexOf("?"));
    			}
    			if(url.endsWith(DEFAULT_REQUEST_JSON) || isJsonRequest(request)){
    				forwardResponseJson(request, response);
    			}else if(url.endsWith(DEFAULT_REQUEST_JSONP)){
    				forwardResponseJsonp(request, response);
    			}else if(url.endsWith(DEFAULT_REQUEST_XML)){
    				forwardResponseXml(request, response);
    			}else{ 
    				//判断是否是oauth2请求,否则返回局部界面
    				String requestURI = getPathWithinApplication(request);
    				if(requestURI.equals("/oauth2/authorize")) {
    				    // 第二步中发起的授权请求会进入此处
    					saveRequestAndRedirectToLogin(request, response);
    				}else{
    					redirectToLogin(request, response);
    				}
    			}
    		}
    		return isLogin;
        }

第3.1步 saveRequestAndRedirectToLogin方法

   // shiro的方法 
	@Override
    protected void saveRequestAndRedirectToLogin(ServletRequest request, ServletResponse response) throws IOException {
        saveRequest(request);
        redirectToLogin(request, response);
    }   

第4步

经过3.1步后，此时系统跳转到A系统的登陆页面，用户输入账号密码后，登陆成功后判断是否是非登陆的请求，是的话则跳转到之前的请求。登陆代码略过，

private void addRedirectUrl(LoginVo lv) {
		Subject subject =SecurityUtils.getSubject();
		SavedRequest savedRequest=(SavedRequest)subject.getSession().getAttribute(WebUtils.SAVED_REQUEST_KEY);
		if(savedRequest!=null) {
		    // 此时uri = /portal.web/oauth2/authorize，就是3.1步中保存下来的请求
			String uri=savedRequest.getRequestURI();
			if(uri.endsWith("/oauth2/authorize")){
			    // 取即将跳转的url
			    // url=/portal.web/oauth2/authorize?response_type=code&client_id=c3991093-f25c-11e6-b7ab-524f72a73ffc&logout_uri=http%3A%2F%2Flocalhost%3A8080%2Fcrm-web%2Flogout&state=portal&redirect_uri=http%3A%2F%2Flocalhost%3A8080%2Fcrm-web%2Flogin%3Fredirect_uri%3D%2Fcrm-web%2Fproxy%3F_oauth%3D9041035e-8cd1-48fb-9c90-adc46f9abcae
			    // 
				String url=savedRequest.getRequestUrl();
				// 这里就是关键了，前端会根据这个字段来判断跳转到哪里，如果不为空就会跳转到url所在的url。前端代码
				lv.setRedirectUrl(url);	
				
				// 再从shiro的session中移除该请求的信息
				Subject subject =SecurityUtils.getSubject();
		        subject.getSession().removeAttribute(WebUtils.SAVED_REQUEST_KEY);
			}
		}
	}

第5步

此时肯定是已经登陆了A系统，即将访问A系统的/oauth2/authorize方法如下
这里先把第3/4步的请求本方法的参数打开，方便观看，携带的参数如下

{

response_type=code,

client_id=c3991093-f25c-11e6-b7ab-524f72a73ffc,

logout_uri=http://localhost:8080/crm-web/logout,

state=portal,

redirect_uri=redirect_uri=http://localhost:8080/crm-web/login?redirect_uri=/crm-web/proxy?_oauth=9041035e-8cd1-48fb-9c90-adc46f9abcae

}

这个redirect_uri参数注意一下，它还接着一个redirect_uri，带着了一会登陆B系统后再跳转到后接着的这个redirect_uri参数

@RequestMapping(value = "/authorize",method = RequestMethod.GET)
	protected void authorize(HttpServletRequest request,HttpServletResponse response){
	    OAuthResponse resp=null;
	    OAuthAuthzRequest oauthRequest = oauthRequest = new OAuthAuthzRequest(request);
	    // 判断clientId是否存在
        if(exists(oauthRequest.getClientId())){
            // 生成一个授权code
        	MD5Generator generator=new MD5Generator();
			OAuthIssuer oauthIssuer = new OAuthIssuerImpl(generator);
			String authCode = oauthIssuer.authorizationCode();
            // OAuth.OAUTH_REDIRECT_URI = "redirect_uri"
            String redirectUri=oauthRequest.getParam(OAuth.OAUTH_REDIRECT_URI);
            // 然后将刚生成的code与redirect_uri拼在一起生成一个新的code
            String code=generator.generateValue(String.format("%s@%s",authCode,redirectUri));
            // 将新生成的code封装成code参数拼装到redirectUri的后面
            redirectUri=String.format("%s&code=%s",redirectUri,code);
			// 这一串看着挺吓人，就是bean的builder模式，简单说就是根据属性值生成一个bean而已
			resp = OAuthASResponse
			.setCode(code)
			.setParam("rs-platform-id", String.valueOf(platId))
			.location(redirectUri)
			.buildQueryMessage();
			
			//将clientId,code,redirectUri, user封成一个对象，存储到redis
			redis.save(clientId,code,redirectUri, user)
			
			// 跳转到resp.getLocationUri()
			// http://localhost:8080/B/login?redirect_uri=/B/proxy?_oauth=549c9e2e-f74a-4a53-8029-b8f8ceb144cb&code=224d33890c31c78070e151897c6f2882&code=224d33890c31c78070e151897c6f2882&state=portal
			//至此，终于又跳回到B系统的login方法了，相比第一次，多了一个code参数
			response.sendRedirect(resp.getLocationUri());
            
        }
	}

第6步

补全B系统的login方法

@RequestMapping("/login")
	public void login( 
			HttpServletRequest request,
			HttpServletResponse response
			) throws URISyntaxException, IOException{
			    // 补全判断code相关的方法，其余方法见第2步
			String code=request.getParameter("code");
			if(StringUtils.isNotBlank(code)){
				String host=request.getRemoteHost();
				String reutrnUri=request.getParameter(OAuth2Utils.OAUTH_RETURN_URI);
				
				RunsaOAuthToken token=new RunsaOAuthToken(code,false,host);
				ResourceVo resource=new ResourceVo();
				try {
				    // 用code换access_token
					OAuth2Response oauthResponse = OAuth2Utils.accessToken(code);
		        	// 用access_token换资源，我们项目中只用到了免登陆，所以取的是登陆信息
		        	resource=OAuth2Utils.resource(oauthResponse);
		        	token.setPrincipal(new PrincipalVo(resource.getUser(),resource.getAuthz()));
		        	// 系统B的登陆
					subject.login(token);
					//调转到访问路径
					if(StringUtils.isNotBlank(reutrnUri)){
						response.sendRedirect(reutrnUri);
					}
				}catch (Exception e) {
					logger.error(ExceptionUtils.getStackTrace(e));
					OutputStream outputStream=response.getOutputStream();
					IOUtils.write(ExceptionUtils.getStackTrace(e), outputStream);
					IOUtils.closeQuietly(outputStream);
				}
			}else{
			    // 剩下的方法详细代码见第2步 
			}
		}

到这里整个大概的流程就结束
下面介绍用code换取token和用token换取source这俩个方法。在我们项目中不太重视这个，我们俩个A/B俩个项目用的一个数据库，想取啥数据直接数据库取就好了。只是免登陆，减少用户操作罢了，没有用到oauth的精髓。我们后来又有了一个项目C，就没有再用oauth这种重量级的东西来仅仅做一个免登陆功能了，用的jwt。用户登录A后将登陆信息生成一个jwt放在cookie里，请求C接口时带上jwt就好了。仅仅一个免登陆就要用oauth2来实现，有点大材小用的感觉。当然这不妨碍我们学习。我们项目还自写了类似mybatis的东西；为了一个搜索，还引入了es，可惜最后没有投入使用，只进行了一半。（es做一半离职了）炫技的结果

第7步 code换access_token

@RequestMapping(value = "/access_token",method = RequestMethod.POST)
	protected void token(HttpServletRequest request,
			HttpServletResponse response) throws OAuthSystemException, IOException {
		OAuthTokenRequest oauthRequest = null;
		OAuthResponse oauthResponse=null;
		OAuthIssuer oauthIssuerImpl = new OAuthIssuerImpl(new MD5Generator());
		try {
			oauthRequest = new OAuthTokenRequest(request);
			String authzCode = oauthRequest.getCode();
			OAuth2Secret oAuth2Secret=oAuth2Service.selectSecretById(oauthRequest.getClientId(), oauthRequest.getClientSecret());
			if(null!=oAuth2Secret){
				OAuth2Vo vo=oAuthTokenUtils.select(authzCode);
				if(null!=vo){
				    // 生成令牌，简单理解其实就是uuid
					String accessToken = oauthIssuerImpl.accessToken();
					String refreshToken = oauthIssuerImpl.refreshToken();
					// 拼装一个json
					oauthResponse = OAuthASResponse
							.tokenResponse(HttpServletResponse.SC_OK)
							.setAccessToken(accessToken)
							.setExpiresIn("3600")
							.setTokenType("Bearer")
							.setRefreshToken(refreshToken)
							.buildJSONMessage();
					// 安全考虑，场景限制，只请求一次就足够了，用完就删
					oAuthTokenUtils.clear(authzCode);
					
					oAuthTokenUtils.save(oauthRequest.getClientId(),
							oauthRequest.getClientSecret(), 
							accessToken,
							refreshToken,
							vo.getUsers(),
							oAuth2Secret.getMeId());
				}
			}
		} catch (OAuthProblemException ex) {
			oauthResponse = OAuthResponse
					.errorResponse(HttpServletResponse.SC_UNAUTHORIZED)
					.error(ex)
					.buildJSONMessage();
		}finally{
			response.setStatus(oauthResponse.getResponseStatus());
			OutputStream outputStream=response.getOutputStream();
			IOUtils.write(oauthResponse.getBody(), outputStream);
			IOUtils.closeQuietly(outputStream);
		}
	}

第8步 access_token换source

场景限制，只能访问这一种资源，所有直接写成一个方法了，否则肯定要隔离
@RequestMapping("/resource")
	protected void resource(HttpServletRequest request, HttpServletResponse response)throws OAuthSystemException, IOException{
		try {
	    	OAuthAccessResourceRequest oauthRequest = new OAuthAccessResourceRequest(request, ParameterStyle.HEADER);
	      	String accessToken =decodeBase64(oauthRequest.getAccessToken());
	      	// 之前用code换取access_token时保存在redis里的
	      	OAuth2Vo vo=oAuthTokenUtils.select(accessToken);
	      	if(null!=vo){
	      		Map<String, Object> map= 各种操作
	      		response.setContentType("application/json;charset=UTF-8");
	      		response.setStatus(HttpServletResponse.SC_OK);
				OutputStream outputStream=response.getOutputStream();
				IOUtils.write(JSON.toJSONString(map), outputStream);
				IOUtils.closeQuietly(outputStream);
				// 老规矩，用完就删
				oAuthTokenUtils.clear(accessToken);
	      	}else{
	      		response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
		    	response.addHeader(OAuth.HeaderType.WWW_AUTHENTICATE, "failure access_token");
	      	}
	    } catch(OAuthProblemException e) {
	    	logger.error(e.getMessage());
	    	response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
	    	response.addHeader(OAuth.HeaderType.WWW_AUTHENTICATE, "authorization header error");
	    }
	}

项目总结

• 只用来做免登陆有点可惜；
• 因场景限制，项目中流程有一定的局限性；
• 后面会考虑写一个demo放到github上，

个人demo实例

前言

为了更好的理解oauth2，有了这个demo，
主要功能：

• 支持动态添加合作网站
• 支持token的级别隔离，目前常见的都只有一种token，尝试打造支持多级别的token