【谷粒商城之服务认证OAuth2.0】

港控/mmm° 2023-09-27 17:58 126阅读 0赞

本笔记内容为[尚硅谷][Link 1][谷粒商城][Link 2]服务认证OAuth2.0部分

**目录**

一、OAuth 2.0

二、微博登录测试

1、微博登陆准备工作

2、获取微博Access Token

3、登录测试

1.添加HttpUtils工具类

2.controller

3.service

4.vo

总结

--------------------

![51222a77fd274ff1969749e08a44173b.png][]

# 一、OAuth 2.0 #

--------------------

*  OAuth： OAuth（开放授权）是一个开放标准，允许用户授权第三方网站访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方网站或分享他们数据的所有内容。
 *  OAuth2.0：对于用户相关的 OpenAPI（例如获取用户信息，动态同步，照片，日志，分享等），为了保护用户数据的安全和隐私，第三方网站访问用户数据前都需要显式的向用户征求授权。

**官方版流程：**

![e718c92408d94e33b9ae55df56157b93.png][]

（A）用户打开客户端以后，客户端要求用户给予授权。  
（B）用户同意给予客户端授权。  
（C）客户端使用上一步获得的授权，向认证服务器申请令牌。  
（D）认证服务器对客户端进行认证以后，确认无误，同意发放令牌。  
（E）客户端使用令牌，向资源服务器申请获取资源。  
（F）资源服务器确认令牌无误，同意向客户端开放资源。

![7526833263d545cc98f512184caf3169.png][]

# 二、微博登录测试 #

--------------------

> 1.  Client（第三方应用，gulimall）给User Agent（用户代理，浏览器）发请求，相当于在第三方网站点了微博登录的按钮
> 2.  浏览器携带客户端的标识和重定向的地址，还有用户的认证信息（账号密码），去向微博认证服务器进行认证，认证成功会跳转回浏览器，并给出一个授权码。
> 3.  浏览器会将授权码给到第三方网站，第三方网站拿着授权码和重定向地址，向微博认证服务器交换一个访问令牌，第三方网站就拿着访问令牌来调用微博的api。

## 1、微博登陆准备工作 ##

不使用微博也可以使用gitee等等来测试

1、进入微博开放平台

2、登陆微博，进入微连接，选择网站接入

![77cbf3378e074894ae7c06f6540c4341.png][]

3、选择立即接入

![852e824da44f4033b5b92c3065913d5e.png][]

4、创建自己的应用

![b471cdb679de4f59bc45716ce4dacf02.png][]

5、我们可以在开发阶段进行测试了

![8a88da4e0635440aa16df99f017b244b.png][]

6、进入高级信息，填写授权回调页的地址

![a0ce61b1c61841a3a8f7a993507bab37.png][]

7、进入文档，按照流程测试社交登陆

![3c6fc138cb94434ebec5f5dc10c16cf3.png][]

![fb51fb4227df441597c61093b4128f03.png][]

## 2、获取微博Access Token ##

1.引导需要授权的用户到如下地址：

// client_id 上面的 App Key
    // redirect_uri 上面配置的授权回调页
    https://api.weibo.com/oauth2/authorize?client_id=YOUR_CLIENT_ID&response_type=code&redirect_uri=YOUR_REGISTERED_REDIRECT_URI

2.如果用户同意授权，页面跳转至 YOUR\_REGISTERED\_REDIRECT\_URI/?code=CODE，得到code码

![5a2f724adbe74c238dee6653de83aab4.png][]

3.使用返回的`CODE`换取Access Token

*  一个CODE只能换取一次Access Token
 *  同一个用户的Access Token在一段时间是不会变化的，即使用多个不同的code获取

https://api.weibo.com/oauth2/access_token?client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&grant_type=authorization_code&redirect_uri=YOUR_REGISTERED_REDIRECT_URI&code=CODE

注意，上面这个是 post 请求

![a957b231fa8d44f1b10fc073b634ffc5.png][]

4.使用 AccessToken 调用开发 API 获取用户信息

![0c8678bf2d524f67a5fd8370712cbde2.png][]

> Oauth2.0；授权通过后，使用 code 换取 access\_token，然后去访问任何开放 API  
> 1）、code 用后即毁  
> 2）、access\_token 在几天内是一样的  
> 3）、uid 永久固定

## 3、登录测试 ##

### 1.添加HttpUtils工具类 ###

HttpUtils放进 common服务中方便调用

package com.atguigu.common.utils;
    
    import java.io.UnsupportedEncodingException;
    import java.net.URLEncoder;
    import java.security.KeyManagementException;
    import java.security.NoSuchAlgorithmException;
    import java.security.cert.X509Certificate;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.TrustManager;
    import javax.net.ssl.X509TrustManager;
    
    import org.apache.commons.lang.StringUtils;
    import org.apache.http.HttpResponse;
    import org.apache.http.NameValuePair;
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.HttpDelete;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.client.methods.HttpPut;
    import org.apache.http.conn.ClientConnectionManager;
    import org.apache.http.conn.scheme.Scheme;
    import org.apache.http.conn.scheme.SchemeRegistry;
    import org.apache.http.conn.ssl.SSLSocketFactory;
    import org.apache.http.entity.ByteArrayEntity;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.DefaultHttpClient;
    import org.apache.http.message.BasicNameValuePair;
    
    public class HttpUtils {
    
        /**
         * get
         *
         * @param host
         * @param path
         * @param method
         * @param headers
         * @param querys
         * @return
         * @throws Exception
         */
        public static HttpResponse doGet(String host, String path, String method,
                                         Map<String, String> headers,
                                         Map<String, String> querys)
                throws Exception {
            HttpClient httpClient = wrapClient(host);
    
            HttpGet request = new HttpGet(buildUrl(host, path, querys));
            for (Map.Entry<String, String> e : headers.entrySet()) {
                request.addHeader(e.getKey(), e.getValue());
            }
    
            return httpClient.execute(request);
        }
    
        /**
         * post form
         *
         * @param host
         * @param path
         * @param method
         * @param headers
         * @param querys
         * @param bodys
         * @return
         * @throws Exception
         */
        public static HttpResponse doPost(String host, String path, String method,
                                          Map<String, String> headers,
                                          Map<String, String> querys,
                                          Map<String, String> bodys)
                throws Exception {
            HttpClient httpClient = wrapClient(host);
    
            HttpPost request = new HttpPost(buildUrl(host, path, querys));
            for (Map.Entry<String, String> e : headers.entrySet()) {
                request.addHeader(e.getKey(), e.getValue());
            }
    
            if (bodys != null) {
                List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();
    
                for (String key : bodys.keySet()) {
                    nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
                }
                UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
                formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
                request.setEntity(formEntity);
            }
    
            return httpClient.execute(request);
        }
    
        /**
         * Post String
         *
         * @param host
         * @param path
         * @param method
         * @param headers
         * @param querys
         * @param body
         * @return
         * @throws Exception
         */
        public static HttpResponse doPost(String host, String path, String method,
                                          Map<String, String> headers,
                                          Map<String, String> querys,
                                          String body)
                throws Exception {
            HttpClient httpClient = wrapClient(host);
    
            HttpPost request = new HttpPost(buildUrl(host, path, querys));
            for (Map.Entry<String, String> e : headers.entrySet()) {
                request.addHeader(e.getKey(), e.getValue());
            }
    
            if (StringUtils.isNotBlank(body)) {
                request.setEntity(new StringEntity(body, "utf-8"));
            }
    
            return httpClient.execute(request);
        }
    
        /**
         * Post stream
         *
         * @param host
         * @param path
         * @param method
         * @param headers
         * @param querys
         * @param body
         * @return
         * @throws Exception
         */
        public static HttpResponse doPost(String host, String path, String method,
                                          Map<String, String> headers,
                                          Map<String, String> querys,
                                          byte[] body)
                throws Exception {
            HttpClient httpClient = wrapClient(host);
    
            HttpPost request = new HttpPost(buildUrl(host, path, querys));
            for (Map.Entry<String, String> e : headers.entrySet()) {
                request.addHeader(e.getKey(), e.getValue());
            }
    
            if (body != null) {
                request.setEntity(new ByteArrayEntity(body));
            }
    
            return httpClient.execute(request);
        }
    
        /**
         * Put String
         * @param host
         * @param path
         * @param method
         * @param headers
         * @param querys
         * @param body
         * @return
         * @throws Exception
         */
        public static HttpResponse doPut(String host, String path, String method,
                                         Map<String, String> headers,
                                         Map<String, String> querys,
                                         String body)
                throws Exception {
            HttpClient httpClient = wrapClient(host);
    
            HttpPut request = new HttpPut(buildUrl(host, path, querys));
            for (Map.Entry<String, String> e : headers.entrySet()) {
                request.addHeader(e.getKey(), e.getValue());
            }
    
            if (StringUtils.isNotBlank(body)) {
                request.setEntity(new StringEntity(body, "utf-8"));
            }
    
            return httpClient.execute(request);
        }
    
        /**
         * Put stream
         * @param host
         * @param path
         * @param method
         * @param headers
         * @param querys
         * @param body
         * @return
         * @throws Exception
         */
        public static HttpResponse doPut(String host, String path, String method,
                                         Map<String, String> headers,
                                         Map<String, String> querys,
                                         byte[] body)
                throws Exception {
            HttpClient httpClient = wrapClient(host);
    
            HttpPut request = new HttpPut(buildUrl(host, path, querys));
            for (Map.Entry<String, String> e : headers.entrySet()) {
                request.addHeader(e.getKey(), e.getValue());
            }
    
            if (body != null) {
                request.setEntity(new ByteArrayEntity(body));
            }
    
            return httpClient.execute(request);
        }
    
        /**
         * Delete
         *
         * @param host
         * @param path
         * @param method
         * @param headers
         * @param querys
         * @return
         * @throws Exception
         */
        public static HttpResponse doDelete(String host, String path, String method,
                                            Map<String, String> headers,
                                            Map<String, String> querys)
                throws Exception {
            HttpClient httpClient = wrapClient(host);
    
            HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
            for (Map.Entry<String, String> e : headers.entrySet()) {
                request.addHeader(e.getKey(), e.getValue());
            }
    
            return httpClient.execute(request);
        }
    
        private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
            StringBuilder sbUrl = new StringBuilder();
            sbUrl.append(host);
            if (!StringUtils.isBlank(path)) {
                sbUrl.append(path);
            }
            if (null != querys) {
                StringBuilder sbQuery = new StringBuilder();
                for (Map.Entry<String, String> query : querys.entrySet()) {
                    if (0 < sbQuery.length()) {
                        sbQuery.append("&");
                    }
                    if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
                        sbQuery.append(query.getValue());
                    }
                    if (!StringUtils.isBlank(query.getKey())) {
                        sbQuery.append(query.getKey());
                        if (!StringUtils.isBlank(query.getValue())) {
                            sbQuery.append("=");
                            sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
                        }
                    }
                }
                if (0 < sbQuery.length()) {
                    sbUrl.append("?").append(sbQuery);
                }
            }
    
            return sbUrl.toString();
        }
    
        private static HttpClient wrapClient(String host) {
            HttpClient httpClient = new DefaultHttpClient();
            if (host.startsWith("https://")) {
                sslClient(httpClient);
            }
    
            return httpClient;
        }
    
        private static void sslClient(HttpClient httpClient) {
            try {
                SSLContext ctx = SSLContext.getInstance("TLS");
                X509TrustManager tm = new X509TrustManager() {
                    public X509Certificate[] getAcceptedIssuers() {
                        return null;
                    }
                    public void checkClientTrusted(X509Certificate[] xcs, String str) {
    
                    }
                    public void checkServerTrusted(X509Certificate[] xcs, String str) {
    
                    }
                };
                ctx.init(null, new TrustManager[] { tm }, null);
                SSLSocketFactory ssf = new SSLSocketFactory(ctx);
                ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
                ClientConnectionManager ccm = httpClient.getConnectionManager();
                SchemeRegistry registry = ccm.getSchemeRegistry();
                registry.register(new Scheme("https", 443, ssf));
            } catch (KeyManagementException ex) {
                throw new RuntimeException(ex);
            } catch (NoSuchAlgorithmException ex) {
                throw new RuntimeException(ex);
            }
        }
    }

导入依赖

<dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.15</version>
            </dependency>
            <dependency>
                <groupId>org.apache.httpcomponents</groupId>
                <artifactId>httpclient</artifactId>
                <version>4.2.1</version>
            </dependency>
            <dependency>
                <groupId>org.apache.httpcomponents</groupId>
                <artifactId>httpcore</artifactId>
                <version>4.2.1</version>
            </dependency>
            <dependency>
                <groupId>commons-lang</groupId>
                <artifactId>commons-lang</artifactId>
                <version>2.6</version>
            </dependency>
            <dependency>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-util</artifactId>
                <version>9.3.7.v20160115</version>
            </dependency>

### 2.controller ###

authserver

/**
     * 处理社交登录请求
     */
    @Controller
    @Slf4j
    public class OAuth2Controller {
    
    
        @Autowired
        MemberFeignService memberFeignService;
        @GetMapping("/auth2.0/weibo/success")
        public String weibo(@RequestParam("code") String code) throws Exception {
    
            // 1. 根据登录微博返回的code换取accessToken
            Map<String,String> map = new HashMap<>();
    
            map.put("client_id","1657382705");
            map.put("client_secret","ca422dd82a99de49026332a9ecf6a7c4");
            map.put("grant_type","authorization_code");
            map.put("redirect_uri","http://auth.gulimall.com/auth2.0/weibo/success");
            map.put("code",code);
    
    
    
            HttpResponse response = HttpUtils.doPost("https://api.weibo.com", "/oauth2/access_token", "post",
                    null, null, map);
    
            if (response.getStatusLine().getStatusCode()==200){
                // 获取到了accessToken
                String json = EntityUtils.toString(response.getEntity());
                SocialUser socialUser = JSON.parseObject(json, SocialUser.class);
    
                // 知道了当前是哪个微博用户
                // 1. 当前用户如果是第一次进网站，自动注册进来（为当前社交用户生成一个会员信息账号，
                // 以后这个社交账号就对应我们指定的会员）
                R oauthLogin = memberFeignService.oauthLogin(socialUser);
                if (oauthLogin.getCode()==0){
                    // 2. 登录成功就跳回首页
                    MemberRespVo data = oauthLogin.getData(new TypeReference<MemberRespVo>() {});
                    System.out.println("登录成功：用户信息" + data);
                    log.info("登录成功：用户信息：{}",data.toString());
                    return "redirect:http://gulimall.com";
                }else {
                    return "redirect:http://auth.gulimall.com/login.html";
                }
    
                // 登录或者注册这个社交用户
            }else {
                return "redirect:http://auth.gulimall.com/login.html";
            }
    
    
    
        }
    }

member

@RefreshScope
    @RestController
    @RequestMapping("member/member")
    public class MemberController {
        @Autowired
        private MemberService memberService;
    
        @Autowired
        CouponFeignService couponFeignService;
    
        @Value("${member.name}")
        private String memberName;
    
        @Value("${member.age}")
        private String memberAge;
    
    
        @PostMapping("/oauth2/login")
        public R oauthLogin(@RequestBody SocialUser socialUser) throws Exception {
    
            MemberEntity memberEntity = memberService.login(socialUser);
    
            if (memberEntity!=null){
                return R.ok().setData(memberEntity);
            }else {
                return R.error(BizCodeEnume.LOGINACCT_PASSWORD_INVALID_EXCEPTION.getCode(),
                        BizCodeEnume.LOGINACCT_PASSWORD_INVALID_EXCEPTION.getMessage());
            }
    
    
        }

### 3.service ###

MemberServiceImpl

@Override
        public MemberEntity login(SocialUser socialUser) throws Exception {
            // 登录和注册合并逻辑
            String uid = socialUser.getUid();
            // 1. 判断当前社交用户是否已经登陆过系统
            MemberEntity memberEntity = baseMapper.selectOne(new QueryWrapper<MemberEntity>().eq("social_uid", uid));
    
            if (memberEntity!=null){
                // 这个用户已经注册了
                MemberEntity update = new MemberEntity();
                update.setId(memberEntity.getId());
                update.setAccessToken(socialUser.getAccess_token());
                update.setExpiresIn(socialUser.getExpires_in());
                baseMapper.updateById(update);
    
                memberEntity.setExpiresIn(socialUser.getExpires_in());
                memberEntity.setAccessToken(socialUser.getAccess_token());
    
                return memberEntity;
            }else {
                // 2. 没有查到当前社交用户对应的记录，我们就需要注册一个
                MemberEntity regist = new MemberEntity();
                try {
    // 3. 查询当前社交用户的社交账号信息（昵称，性别等）
                    Map<String,String> query = new HashMap<>();
                    query.put("access_token", socialUser.getAccess_token());
                    query.put("uid", socialUser.getUid());
                    HttpResponse response = HttpUtils.doGet("https://api.weibo.com", "/2/users/show.json", "get",
                            new HashMap<String, String>(), query);
    
                    if (response.getStatusLine().getStatusCode() == 200){
                        // 查询成功
                        String json = EntityUtils.toString(response.getEntity());
                        JSONObject jsonObject = JSON.parseObject(json);
                        // 昵称
                        String name = jsonObject.getString("name");
                        String gender = jsonObject.getString("gender");
                        // 获取微博返回的其他信息。。。。。。
                        regist.setGender("m".equals(gender)?1:0);
    
    
    
                    }
                }catch (Exception e){
    
    
                }
    
    
                regist.setSocialUid(socialUser.getUid());
                regist.setAccessToken(socialUser.getAccess_token());
                regist.setExpiresIn(socialUser.getExpires_in());
                baseMapper.insert(regist);
    
                return regist;
            }
    
        }

远程调用：认证服务调用会员服务

认证服务feign包下的MemberFeignService

@FeignClient("gulimall-member")

@PostMapping("/member/member/oauth2/login")
        R oauthlogin(@RequestBody SocialUser socialUser) throws Exception;

### 4.vo ###

SocialUser

package com.atguigu.gulimall.authserver.vo;
    
    import lombok.Data;
    
    @Data
    public class SocialUser {
    
        private String access_token;
        private String remind_in;
        private long expires_in;
        private String uid;
        private String isRealName;
    }

MemberRespVo

**为member表新增三个字段**

![7e1709d8ec854a4ab934cacded97bcf9.png][]

package com.atguigu.gulimall.authserver.vo;
    
    import lombok.Data;
    import lombok.ToString;
    
    import java.util.Date;
    
    @Data
    @ToString
    public class MemberRespVo {
    
        /**
         * id
         */
        private Long id;
        /**
         * 会员等级id
         */
        private Long levelId;
        /**
         * 用户名
         */
        private String username;
        /**
         * 密码
         */
        private String password;
        /**
         * 昵称
         */
        private String nickname;
        /**
         * 手机号码
         */
        private String mobile;
        /**
         * 邮箱
         */
        private String email;
        /**
         * 头像
         */
        private String header;
        /**
         * 性别
         */
        private Integer gender;
        /**
         * 生日
         */
        private Date birth;
        /**
         * 所在城市
         */
        private String city;
        /**
         * 职业
         */
        private String job;
        /**
         * 个性签名
         */
        private String sign;
        /**
         * 用户来源
         */
        private Integer sourceType;
        /**
         * 积分
         */
        private Integer integration;
        /**
         * 成长值
         */
        private Integer growth;
        /**
         * 启用状态
         */
        private Integer status;
        /**
         * 注册时间
         */
        private Date createTime;
    
        private String socialUid;
        private String accessToken;
        private Long expiresIn;
    }

测试

登录成功返回首页（这里很容易出现 超时现象，多试几次即可。）

### 总结 ###

![d7f6ce300d864180968fee5ed0eade1e.png][]

结束！

[Link 1]: https://so.csdn.net/so/search?q=%E5%B0%9A%E7%A1%85%E8%B0%B7&spm=1001.2101.3001.7020
[Link 2]: https://so.csdn.net/so/search?q=%E8%B0%B7%E7%B2%92%E5%95%86%E5%9F%8E&spm=1001.2101.3001.7020
[51222a77fd274ff1969749e08a44173b.png]: https://img-blog.csdnimg.cn/51222a77fd274ff1969749e08a44173b.png
[e718c92408d94e33b9ae55df56157b93.png]: https://img-blog.csdnimg.cn/e718c92408d94e33b9ae55df56157b93.png
[7526833263d545cc98f512184caf3169.png]: https://img-blog.csdnimg.cn/7526833263d545cc98f512184caf3169.png
[77cbf3378e074894ae7c06f6540c4341.png]: https://img-blog.csdnimg.cn/77cbf3378e074894ae7c06f6540c4341.png
[852e824da44f4033b5b92c3065913d5e.png]: https://img-blog.csdnimg.cn/852e824da44f4033b5b92c3065913d5e.png
[b471cdb679de4f59bc45716ce4dacf02.png]: https://img-blog.csdnimg.cn/b471cdb679de4f59bc45716ce4dacf02.png
[8a88da4e0635440aa16df99f017b244b.png]: https://img-blog.csdnimg.cn/8a88da4e0635440aa16df99f017b244b.png
[a0ce61b1c61841a3a8f7a993507bab37.png]: https://img-blog.csdnimg.cn/a0ce61b1c61841a3a8f7a993507bab37.png
[3c6fc138cb94434ebec5f5dc10c16cf3.png]: https://img-blog.csdnimg.cn/3c6fc138cb94434ebec5f5dc10c16cf3.png
[fb51fb4227df441597c61093b4128f03.png]: https://img-blog.csdnimg.cn/fb51fb4227df441597c61093b4128f03.png
[5a2f724adbe74c238dee6653de83aab4.png]: https://img-blog.csdnimg.cn/5a2f724adbe74c238dee6653de83aab4.png
[a957b231fa8d44f1b10fc073b634ffc5.png]: https://img-blog.csdnimg.cn/a957b231fa8d44f1b10fc073b634ffc5.png
[0c8678bf2d524f67a5fd8370712cbde2.png]: https://img-blog.csdnimg.cn/0c8678bf2d524f67a5fd8370712cbde2.png
[7e1709d8ec854a4ab934cacded97bcf9.png]: https://img-blog.csdnimg.cn/7e1709d8ec854a4ab934cacded97bcf9.png
[d7f6ce300d864180968fee5ed0eade1e.png]: https://img-blog.csdnimg.cn/d7f6ce300d864180968fee5ed0eade1e.png