spring security oauth2.0 實現

時間  2019-11-09
標籤 spring security oauth2.0 oauth 實現 欄目 Spring 简体版
原文   原文鏈接

　　oauth應該屬於security的一部分。關於oauth的的相關知識能夠查看阮一峯的文章：http://www.ruanyifeng.com/blog/2014/05/oauth_2_0.htmlhtml

1、目標java

　　如今不少系統都支持第三方帳號密碼等登錄咱們本身的系統，例如：咱們常常會看到，一些系統使用微信帳號，微博帳號、QQ帳號等登錄本身的系統，咱們如今就是要模擬這種登錄的方式，不少大的公司已經實現了這種受權登錄的方式，並提供了相應的API，供咱們開發人員調用。他們實際上用的也規範是oauth2.0的規範，經過用戶受權的方式，獲取一些信息。之前就作過一些相似的，如：mysql

微信掃碼登錄：http://www.cnblogs.com/0201zcr/p/5133062.htmlweb

微信客戶端受權登錄：http://www.cnblogs.com/0201zcr/p/5131602.html　　spring

　　可是假如你的系統要提供其餘網站使用你的帳號密碼登錄，你就須要寫好相應的接口規範， 給人家調用。用得比較多的是使用spring security oauth實現的方式。sql

咱們這裏使用meaven導入咱們所須要的jar包，使用配置文件的方式攔截咱們的請求並進行驗證是否有效，而後便可獲取咱們須要的信息。數據庫

這裏主要是模擬了經過給予第三方帳號密碼的方式，在第三方進行鑑權，而後將access_token等信息傳回過來，而後要登陸的系統在經過這個返回的access_token去第三方請求一些用戶受權的數據。便可完成第三方的帳號密碼登陸。apache

2、Spring security oauth 相關依賴meaven配置json

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.zhangfc</groupId>
    <artifactId>demo4ssh-security-oauth2</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <spring.version>4.0.4.RELEASE</spring.version>
        <hibernate.version>4.3.5.Final</hibernate.version>
        <spring-security.version>3.2.4.RELEASE</spring-security.version>
        <spring-security-oauth2.version>2.0.2.RELEASE</spring-security-oauth2.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>${spring-security.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-taglibs</artifactId>
            <version>${spring-security.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security.oauth</groupId>
            <artifactId>spring-security-oauth2</artifactId>
            <version>${spring-security-oauth2.version}</version>
        </dependency>
        <dependency>
           <groupId>org.hibernate</groupId>
           <artifactId>hibernate-core</artifactId>
           <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>javax.servlet.jsp.jstl-api</artifactId>
            <version>1.2.1</version>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>
        <dependency>
            <groupId>tomcat</groupId>
            <artifactId>servlet-api</artifactId>
            <version>5.5.23</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>tomcat</groupId>
            <artifactId>jsp-api</artifactId>
            <version>5.5.23</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.1.2.Final</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.31</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.13</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>demo4ssh-security-oauth2</finalName>
    </build>
</project>

3、web.xml文件配置api

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    metadata-complete="true" version="3.0">

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
                classpath:/META-INF/infrastructure.xml,classpath*:/META-INF/applicationContext*.xml</param-value>
    </context-param>

    <listener>    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <servlet>
        <servlet-name>spring-dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>spring-dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>springSecurityFilterChain</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>springSecurityFilterChain</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

4、applicationContext-security.xml

　　oauth2是security的一部分，配置也有關聯，就再也不單建文件

　　添加http攔截鏈

    <!--  /oauth/token 是oauth2登錄驗證請求的url     用於獲取access_token  ,默認的生存時間是43200秒，即12小時-->
    <http pattern="/oauth/token" create-session="stateless"
        authentication-manager-ref="oauth2AuthenticationManager">
        <intercept-url pattern="/oauth/token" access="IS_AUTHENTICATED_FULLY" />     <!--  能夠訪問的角色名稱，若是須要攔截，須要實現UserDetails接口，實現getAuthorities（）方法-->
        <anonymous enabled="false" />
        <http-basic entry-point-ref="oauth2AuthenticationEntryPoint" />
        <custom-filter ref="clientCredentialsTokenEndpointFilter"
            before="BASIC_AUTH_FILTER" />
        <access-denied-handler ref="oauth2AccessDeniedHandler" />
    </http>

　　這個標籤處理/oauth/token的網絡請求，這是oauth2的登陸驗證請求，那麼登陸須要什麼，首先，和Spring Security同樣，須要一個認證管理器，Spring Oauth2須要兩個認證管理器，第一個就是以前Spring中配置的那一個，用來驗證用戶名密碼的，

    <!-- 驗證的權限控制 -->
    <authentication-manager>
        <authentication-provider>
            <!-- <password-encoder hash="md5"> <salt-source user-property="email"/> 
                </password-encoder> -->
            <jdbc-user-service data-source-ref="dataSource"
                users-by-username-query="select username, password, 1 from user where username = ?"
                authorities-by-username-query="select u.username, r.role from user u left join role r on u.role_id=r.id where username = ?" />
        </authentication-provider>
    </authentication-manager>

　　還有一個是用來區分客戶端用戶的，給它起個名字叫oauth2AuthenticationManager：

<oauth2:client-details-service id="clientDetailsService" >
        <oauth2:client client-id="mobile_1"
            authorized-grant-types="password,authorization_code,refresh_token,implicit"
            secret="secret_1" scope="read,write,trust"      />
    </oauth2:client-details-service>
    <beans:bean id="oauth2ClientDetailsUserService"
        class="org.springframework.security.oauth2.provider.client.ClientDetailsUserDetailsService">
        <beans:constructor-arg ref="clientDetailsService" />
    </beans:bean>
    <authentication-manager id="oauth2AuthenticationManager">
        <authentication-provider user-service-ref="oauth2ClientDetailsUserService" />
    </authentication-manager>

　　這兒設置了一種客戶端，id叫作mobile_1，secret叫作secret_1，針對read、write和trust幾個域有效。這幾個域會在訪問控制中被用到。

　　當登陸成功以後會獲得一個token，再次訪問的時候須要攜帶這個token，spring-oauth2根據這個token來作認證，那麼spring-oauth2必須先存一份token和用戶關係的對應，由於不用session了，這就至關於session，那麼這個token在服務器中怎麼存，有兩種主要的存儲方式，一是建立數據表，把token存到數據庫裏，我如今追求簡單可用，採用第二種方式，直接存到內存裏。下面配置一個管理token的service：

    <!-- for spring oauth2 -->
    <!--token在服務器存儲的方式    InMemoryTokenStore ：保存在內存     ；JdbcTokenStore : 保存在數據庫中 -->
    <beans:bean id="tokenStore"
        class="org.springframework.security.oauth2.provider.token.store.InMemoryTokenStore" />
    <!--<beans:bean id="tokenServices"
        class="org.springframework.security.oauth2.provider.token.DefaultTokenServices">-->     <!--令牌服務的實體-->
    <beans:bean id="tokenServices"
                class="org.zhangfc.demo4ssh.service.MyTokenService">      <!-- 本身重寫的類 -->

　　下面配置4個基本的bean：分別處理訪問成功、訪問拒絕、認證點和訪問控制：

    <!--處理訪問成功-->
    <beans:bean id="oauth2AuthenticationEntryPoint"
        class="org.springframework.security.oauth2.provider.error.OAuth2AuthenticationEntryPoint" />
    <!--處理訪問拒絕-->
    <beans:bean id="oauth2AccessDeniedHandler"
        class="org.springframework.security.oauth2.provider.error.OAuth2AccessDeniedHandler" />
    <!--處理認證點-->
    <beans:bean id="oauthUserApprovalHandler"
        class="org.springframework.security.oauth2.provider.approval.DefaultUserApprovalHandler" />
    <!--處理訪問控制-->
    <beans:bean id="oauth2AccessDecisionManager"
        class="org.springframework.security.access.vote.UnanimousBased">
        <beans:constructor-arg>
            <beans:list>
                <beans:bean
                    class="org.springframework.security.oauth2.provider.vote.ScopeVoter" />
                <beans:bean class="org.springframework.security.access.vote.RoleVoter" />
                <beans:bean
                    class="org.springframework.security.access.vote.AuthenticatedVoter" />
            </beans:list>
        </beans:constructor-arg>
    </beans:bean>

　　配置這個oauth2的server所能支持的請求類型：

    <!--oauth2 的server所能支持的請求類型-->
    <oauth2:authorization-server
        client-details-service-ref="clientDetailsService" token-services-ref="tokenServices"
        user-approval-handler-ref="oauthUserApprovalHandler">
        <oauth2:authorization-code />
        <oauth2:implicit />
        <oauth2:refresh-token />
        <oauth2:client-credentials />
        <oauth2:password />
    </oauth2:authorization-server>

　　咱們的請求裏，要把驗證類型、用戶名密碼都做爲表單參數提交，這就須要配置下面的filter：

    <beans:bean id="clientCredentialsTokenEndpointFilter"
        class="org.springframework.security.oauth2.provider.client.ClientCredentialsTokenEndpointFilter">
        <beans:property name="authenticationManager" ref="oauth2AuthenticationManager" />
    </beans:bean>

　　下面定義一種資源，指定spring要保護的資源，若是沒有這個，訪問控制的時候會說沒有Authentication object：

    <!--指定spring要保護的資源，若是沒有這個，訪問控制的時候會說沒有Authentication object：-->
    <oauth2:resource-server id="mobileResourceServer"
        resource-id="mobile-resource" token-services-ref="tokenServices" />

　　好了，到此爲止基本配置就都有了，下面就看訪問控制的配置：在前面的攔截鏈上，已經爲登陸驗證配了一個/auth/token，在這個標籤下面添加對/json和/admin這兩個路徑的控制

    <http pattern="/json**" create-session="never"
        entry-point-ref="oauth2AuthenticationEntryPoint"
        access-decision-manager-ref="oauth2AccessDecisionManager">
        <anonymous enabled="false" />
        <intercept-url pattern="/json**" access="ROLE_USER" />
        <custom-filter ref="mobileResourceServer" before="PRE_AUTH_FILTER" />
        <access-denied-handler ref="oauth2AccessDeniedHandler" />
    </http>
    <http pattern="/admin**" create-session="never"
        entry-point-ref="oauth2AuthenticationEntryPoint"
        access-decision-manager-ref="oauth2AccessDecisionManager">
        <anonymous enabled="false" />
        <intercept-url pattern="/admin**" access="SCOPE_READ,ROLE_ADMIN" />
        <custom-filter ref="mobileResourceServer" before="PRE_AUTH_FILTER" />
        <access-denied-handler ref="oauth2AccessDeniedHandler" />
    </http>

　　咱們用oauth2AccessDecisionManager來作決策，這個地方須要注意，spring-security裏面配置access="ROLE_USER,ROLE_ADMIN"是說user和admin均可以訪問，是一個「或」的關係，可是這裏是「與」的關係，好比第二個，須要ROLE_ADMIN而且當前的scope包含read才能夠，不然就沒有權限。認證失敗會返回一段xml，這個能夠自定義handler來修改，暫且按下不表。

　　 默認的12小時access_token可能對於咱們來講太長，經過UUID.randomUUID()來生成一個36的惟一的access_token 也不是咱們想要的生存方式。故咱們能夠複製org.springframework.security.oauth2.provider.token.DefaultTokenServices，並對其進行必定修改便可，這裏我把這個類複製出來，修改爲MyTokenService，並在上面的配置文件中進行了配置。主要是修改其如下成員變量：

    private int refreshTokenValiditySeconds = 2592000;       //refresh_token 的超時時間  默認2592000秒
    private int accessTokenValiditySeconds = 10;             //access_token 的超時時間   默認12個小時
    private boolean supportRefreshToken = false;            //是否支持access_token 刷新，默認是false,在配置文件中以配置成能夠支持了，
    private boolean reuseRefreshToken = true;               //使用refresh_token刷新以後該refresh_token是否依然使用，默認是依然使用
    private TokenStore tokenStore;                             //access_token的存儲方式，這個在配置文件中配

　　經過修改修改其createAccessToken方法來修改access_token 的生成方式：

    private OAuth2AccessToken createAccessToken(OAuth2Authentication authentication, OAuth2RefreshToken refreshToken) {
        String access_tokens = UUID.randomUUID().toString().replaceAll("-","");  
        DefaultOAuth2AccessToken token = new DefaultOAuth2AccessToken(access_tokens);
        int validitySeconds = this.getAccessTokenValiditySeconds(authentication.getOAuth2Request());if(validitySeconds > 0) {
            token.setExpiration(new Date(System.currentTimeMillis() + (long)validitySeconds * 1000L));
        
        token.setRefreshToken(refreshToken);
        token.setScope(authentication.getOAuth2Request().getScope());
        return (OAuth2AccessToken)(this.accessTokenEnhancer != null?this.accessTokenEnhancer.enhance(token, authentication):token);
    }

　　源碼下載：http://pan.baidu.com/s/1mhSfKFY

獲取access_token  URL ：

http://localhost:8080/AOuth/oauth/token?client_id=mobile_1&client_secret=secret_1&grant_type=password&username=aa&password=aa

這時候會返回一個access_token：

{"access_token":"4219a91f-45d5-4a07-9e8e-3acbadd0c23e","token_type":"bearer","refresh_token":"d41df9fd-3d36-4a20-b0b7-1a1883c7439d","expires_in":43199,"scope":"read write trust"}

這以後再拿着這個access_token去訪問資源：

http://localhost:8080/AOuth/admin?access_token=4219a91f-45d5-4a07-9e8e-3acbadd0c23e

刷新access_token：

http://localhost:8080/AOuth/oauth/token?client_id=mobile_1&client_secret=secret_1&grant_type=refresh_token&refresh_token=ad18fc89e1424278b675ca05bf8afbb3 

　　致謝：感謝您的閱讀！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程