Springboot集成社交登录功能（微博登录）以及Session共享

最新推荐文章于 2023-06-05 20:00:00 发布
最新推荐文章于 2023-06-05 20:00:00 发布
阅读量558 收藏 1
点赞数
分类专栏： 安装教程 项目问题记录 文章标签： 微博 oauth
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/prefect_start/article/details/115218746
版权
Springboot集成社交登录功能

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
pom

	<dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.3.6</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.httpcomponents</groupId>
                    <artifactId>httpcore</artifactId>
                </exclusion>
            </exclusions>
        </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>
        <!-- https://mvnrepository.com/artifact/org.eclipse.jetty/jetty-util -->
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-util</artifactId>
            <version>11.0.0</version>
            <scope>provided</scope>
        </dependency>

工具类，用于发http请求

package com.song.common.utils;

import com.alibaba.nacos.client.utils.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;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
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;

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);
        }
    }
}

实体

package com.song.gulimall.member.entity;

import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import java.io.Serializable;
import java.util.Date;
import lombok.Data;

/* *
 * 会员
 *
 * @author 
 * @email 
 * @date 2020-12-07 22:54:20
 */
@Data
@TableName("ums_member")
public class MemberEntity implements Serializable {
	private static final long serialVersionUID = 1L;

	/**
	 * id
	 */
	@TableId
	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;


	/**
	 * 社交登录UID
	 */
	private String uid;

	/**
	 * 社交登录TOKEN
	 */
	private String accessToken;

	/**
	 * 社交登录过期时间
	 */
	private long expiresIn;

}


package com.song.gulimall.member.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;

}

微博认证的回调接口 路径可以在微博开放平台中设置

package com.song.gulimall.gulimallauthserver.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.song.common.utils.AuthServerConstant;
import com.song.common.utils.HttpUtils;
import com.song.common.utils.R;
import com.song.common.vo.MemberResponseVo;
import com.song.gulimall.gulimallauthserver.feign.MemberFeignService;
import com.song.gulimall.gulimallauthserver.vo.SocialUser;
import org.apache.http.HttpResponse;
import org.apache.http.util.EntityUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.Map;

@Controller
public class OauthController {
    @Resource
    private MemberFeignService memberFeignService;

    /* *
     * 微博认证接口
     * @param code
     * @param session
     * @return
     * @throws Exception
     */
    @RequestMapping("/oauth2.0/weibo/success")
    public String authorize(String code, HttpSession session) throws Exception {
        //1. 使用code换取token，换取成功则继续2，否则重定向至登录页
        Map<String, String> query = new HashMap<>();
        query.put("client_id", "2144471074");
        query.put("client_secret", "ff63a0d8d591a85a29a19492817316ab");
        query.put("grant_type", "authorization_code");
        query.put("redirect_uri", "http://auth.gulimall.com/oauth2.0/weibo/success");
        query.put("code", code);
        //发送post请求换取token
        HttpResponse response = HttpUtils.doPost("https://api.weibo.com", "/oauth2/access_token", "post", new HashMap<String, String>(), query, new HashMap<String, String>());
        Map<String, String> errors = new HashMap<>();
        if (response.getStatusLine().getStatusCode() == 200) {
            //2. 调用member远程接口进行oauth登录，登录成功则转发至首页并携带返回用户信息，否则转发至登录页
            String json = EntityUtils.toString(response.getEntity());
            SocialUser socialUser = JSON.parseObject(json, new TypeReference<SocialUser>() {
            });
            R login = memberFeignService.authLogin(socialUser);
            //2.1 远程调用成功，返回首页并携带用户信息
            if (login.getCode() == 0) {
                String jsonString = JSON.toJSONString(login.get("memberEntity"));
                System.out.println("----------------" + jsonString);
                MemberResponseVo memberResponseVo = JSON.parseObject(jsonString, new TypeReference<MemberResponseVo>() {
                });
                System.out.println("----------------" + memberResponseVo);
                session.setAttribute(AuthServerConstant.LOGIN_USER, memberResponseVo);
                return "redirect:http://gulimall.com";
            } else {
                //2.2 否则返回登录页
                errors.put("msg", "登录失败，请重试");
                session.setAttribute("errors", errors);
                return "redirect:http://auth.gulimall.com/login.html";
            }
        } else {
            errors.put("msg", "获得第三方授权失败，请重试");
            session.setAttribute("errors", errors);
            return "redirect:http://auth.gulimall.com/login.html";
        }
    }
}

controller

    /* *
     * 社交登录
     * @param socialUser
     * @return
     */
    @PostMapping("/oauth2/login")
    public R authLogin(@RequestBody SocialUser socialUser) {
        MemberEntity entity=memberService.authLogin(socialUser);
        if (entity!=null){
            return R.ok().put("memberEntity",entity);
        }else {
            return R.error();
        }
    }

service

  MemberEntity authLogin(SocialUser socialUser);

impl

/* *
     * 社交登录
     * @param socialUser
     * @return
     */
    @Override
    public MemberEntity authLogin(SocialUser socialUser) {
        MemberEntity uid = this.getOne(new QueryWrapper<MemberEntity>().eq("uid", socialUser.getUid()));
        //1 如果之前未登陆过，则查询其社交信息进行注册
        if (uid == null) {
            Map<String, String> query = new HashMap<>();
            query.put("access_token", socialUser.getAccess_token());
            query.put("uid", socialUser.getUid());
            //调用微博api接口获取用户信息
            String json = null;
            try {
                HttpResponse response = HttpUtils.doGet("https://api.weibo.com", "/2/users/show.json", "get", new HashMap<>(), query);
                json = EntityUtils.toString(response.getEntity());
            } catch (Exception e) {
                e.printStackTrace();
            }
            JSONObject jsonObject = JSON.parseObject(json);
            //获得昵称，性别，头像
            String name = jsonObject.getString("name");
            String gender = jsonObject.getString("gender");
            String profile_image_url = jsonObject.getString("profile_image_url");
            //封装用户信息并保存
            uid = new MemberEntity();
            MemberLevelEntity defaultLevel = memberLevelService.getOne(new QueryWrapper<MemberLevelEntity>().eq("default_status", 1));
            uid.setLevelId(defaultLevel.getId());
            uid.setNickname(name);
            uid.setGender("m".equals(gender) ? 0 : 1);
            uid.setHeader(profile_image_url);
            uid.setAccessToken(socialUser.getAccess_token());
            uid.setUid(socialUser.getUid());
            uid.setExpiresIn(socialUser.getExpires_in());
            this.save(uid);
        } else {
            //2 否则更新令牌等信息并返回
            uid.setAccessToken(socialUser.getAccess_token());
            uid.setUid(socialUser.getUid());
            uid.setExpiresIn(socialUser.getExpires_in());
            this.updateById(uid);
        }
        return uid;
    }

微博开放API接口:https://open.weibo.com/wiki/%E5%BE%AE%E5%8D%9AAPI

Session共享

在这里插入图片描述

在这里插入图片描述

解决方案：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

解决session集群的方案
在这里插入图片描述
在这里插入图片描述

整合springSession 解决了session共享问题以及不同域名之间的共享问题（自定义cookies 设置范围最大的域名）

pom

	<dependency>
		<groupId>org.springframework.session</groupId>
		<artifactId>spring-session-data-redis</artifactId>
	</dependency>

配置

server:
  servlet:
    session:
      timeout: 30 # 超时时间
spring:
  session:
    store-type: redis # 存储方式

package com.song.gulimall.product.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.session.web.http.CookieSerializer;
import org.springframework.session.web.http.DefaultCookieSerializer;

/* *
 * session 配置
 */
@Configuration
public class GulimallSessionConfig {

    /* *
     * 存入redis的序列化方式
     * @return
     */
    @Bean
    public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
        return new GenericJackson2JsonRedisSerializer();
    }

    /* *
     * 设置客户端的暴露bean  解决不同的域名之间的访问  设置父域名
     * @return
     */
    @Bean
    public CookieSerializer cookieSerializer() {
        DefaultCookieSerializer serializer = new DefaultCookieSerializer();
        serializer.setCookieName("GULISESSIONID");
        serializer.setDomainName("gulimall.com");
        return serializer;
    }
}

在这里插入图片描述

启动类注解
@EnableRedisHttpSession

@EnableRedisHttpSession
@SpringBootApplication
@EnableFeignClients("com.song.gulimall.gulimallauthserver.feign")
@EnableDiscoveryClient
public class GulimallAuthServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(GulimallAuthServerApplication.class, args);
    }

}
SpringSession的原理

在这里插入图片描述

在这里插入图片描述

后端技术那点事
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot构建简单的微博应用
04-05 733
使用Mock活Stub方法能够更好的来测试我们的代码逻辑。
springboot个人微博开发项目
11-07
springboot+grandle搭建的个人微博项目,适合新人学习观摩开发
social-login-spring-boot:Google，Github使用Spring Boot实现社交登录的实践
04-18
使用Spring Boot实施社交登录 目标 Google和Github登录实施 另存为日志文件 使用@ControllerAdvice进行全局异常处理 =>在将来的项目中轻松使用社交登录 开发环境 Java11的 Spring启动2.4.5 H2数据库
SpringBoot实现三方登录之--------微博登录
qq_46052576的博客
05-28 645
SpringBoot实现三方登录之--------微博登录 登录接入流程: 使用步骤: 一个静态页面写一个链接:点击微博登录进入微博授权. 2.输入账号密码,点击登录,会自动授权,授权成功就会展示当前账户的一些信息. 3.显示出来的个人信息: 例如微博名字,描述等. 到时候你要啥 取啥即可! 下面来说一下具体实现步骤: 准备工作: 进入微博的开放平台去注册应用先. 开放平台地址: https://open.weibo.com/ 进入以后点击: 网站接入 - 进入之后填
SpringBoot引入微博第三方登录
学而时习之，不亦说乎？温故而知新，可以为师矣！
12-15 1450
什么是第三方登录？ 用户登录操作不是基于自身建设账号体系，而是基于用户在第三方平台上已有的账号和密码来快速完成登录的过程。下面我列举了几点第三方登录的优点。 极大的简化登录注册的流程。 方便用户快捷登录，降低用户的登录流失率，第三方大厂的用户某种意义上都可以是你用户。传统的登录注册，如果网站较小或者用户不经常使用，可能时间长了，用户就把登录的用户名和密码忘记了。 第三方登录接入后，应用可直接获取用户昵称、头像、用户ID等信息，方便产品获取用户的基本资料。 国内比较广泛使用的第三方登录方式为微博、微信、QQ，
SpringBoot + Shiro 实现微博登录
asing1elife's blog
02-11 614
介绍在服务端使用 SpringBoot + Shiro ，用户端使用 jQuery 的环境下如何实现网站对接微博登录 更多精彩 更多技术博客，请移步 IT人才终生实训与职业进阶平台 - 实训在线 写在前面的话 网站要接入第三方登录，首先考虑的自然是微博和微信以及 QQ 接入之前需要在对应的开放平台去申请权限，微博的需要去 新浪微博开放平台 登录后点击 立即接入 就可以开始创建应用了，创...
SpringBoot实现微博登录--获取用户头像、微博用户名等信息（本地测试）
Gao__xi的博客
12-30 1874
写在最前面 微博登录的流程： ①开发者如何让用户选择微博登录后跳转到微博登录页？？ https://api.weibo.com/oauth2/authorize?client_id=你的应用的APPKey&response_type=code&redirect_uri=你的授权回调地址 ②用户登录了，我如何知道用户登录了？？？ 微博需要你告诉微博，用户登录后，如何把用登录的信息告诉...
springboot实现第三方登陆----微博登录
weixin_43800829的博客
05-28 1046
三方登录之微博登陆 准备工作 注册微博开放平台 注册地址: https://open.weibo.com/ 之后选择网站接入填写对应信息 基本信息照的这个填写： 高级信息是你内网穿透的地址 内网穿透 内网穿透工具地址：https://www.cpolar.com/ 下载 跑起来之后是这个样子 有一个http的请求和一个https的请求，用哪个都是一样的，这样就可以被外网访问到了 你需要用到的三个连接 https://api.weibo.com/oauth2/authorize?clien
Spring Boot集成第三方登录之微博登录
积跬步，至千里。
09-19 2272
对第三方登录之微博登录的登录授权流程进行分析,了解相关API的使用,最后使用Spring Boot集成微博登录,实现整个登录授权流程。
三小时急速入门springboot—企业级微博项目实战
04-28
通过这门课程，大家可以完成一个完整的微博项目。从项目的搭建，到业务代码的编写，到最后打包发布到云主机，我们都会手把手地去教大家一步一步完成。像一些常用的技术，例如发送邮箱验证码、将文件上传到对象存储等都会涉及到。除此之外，大家还会了解到现在企业中最常见的项目架构，例如网关的作用及实现、返回格式的统一封装等。还有springboot各组件的作用及用法，常用的中间件缓存redis和消息队列kafka都会讲到。最后，会给大家分享如何利用几乎成为业内监控标准的prometheus监控项目的运行状态及业务。跟着一步一步走下来，可以快速入门企业级项目的开发。
基于SpringBoot+Redis的Session共享与单点登录详解
08-25
主要介绍了基于SpringBoot+Redis的Session共享与单点登录,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot集成Spring Security登录管理 添加 session 共享【完整源码+数据库】
02-16
SpringBoot集成Spring Security登录管理 添加 session 共享
Springboot中登录后关于cookie和session拦截问题的案例分析
09-07
主要介绍了Springboot中登录后关于cookie和session拦截案例,本文通过实例图文相结合给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
SpringBoot+MyBatis+SpringSession+Redis实现session共享及单点登录
03-02
SpringBoot+MyBatis+SpringSession+Redis实现session共享及单点登录开发实例
SpringBoot 实现扫码登录
06-23
PC端监听二维码session状态接口，目前定义状态：0 二维码生成成功 ，1 手机端扫码成功 2手机端确认登录 -1 sessionId过期失效 二维码扫描通知，手机端扫描成功会调用此接口，发送session通知 手机端确认通知，手机端...
springboot 单点登录
prefect_start的博客
03-26 6026
1、springboot 单点登录 单点登录英文全称Single Sign On，简称就是SSO。它的解释是：在多个应用系统中，只需要登录一次，就可以访问其他相互信任的应用系统 2、流程图 3、流程解析 现在有认证服务器 ssoserver.com，客户端client1.com和客户端client2.com 两个不同域名的服务器，并且没有子域名关系（如果两个客户端有子域名关系，session进行统一存储，可以通过SpringSession手动去设置session的作用域，放大作用域，取父域名最为
Kerberos从入门到精通以及案例实操系列（一）
最新发布
prefect_start的博客
06-05 4966
整个kerberos认证的过程较为复杂，三次通信中都使用了密钥，且密钥的种类一直在变化，并且为了防止网络拦截密钥，这些密钥都是临时生成的Session Key，即他们只在一次Session会话中起作用，即使密钥被劫持，等到密钥被破解可能这次会话都早已结束，这为整个kerberos认证过程保证了较高的安全性。kerberos认证的整体流图kerberos认证的时序图本地登录（无需认证）远程登录（需进行主体认证，认证操作见下文）退出输入：exit2. 创建Kerberos主体。
RabbitMQ详解
prefect_start的博客
05-11 3976
rabbitmq详解
springboot实现session登录
03-16
Spring Boot可以通过使用Spring Session来实现Session登录。Spring Session是一个用于管理Web应用程序中的Session的框架，它提供了一种简单的方式来管理Session，并且可以与多种Session存储后端集成，如Redis、MongoDB等。 要使用Spring Session，需要在pom.xml文件中添加以下依赖： ``` <dependency> <groupId>org.springframework.session</groupId> <artifactId>spring-session-core</artifactId> <version>2.4.3</version> </dependency> ``` 然后，在Spring Boot应用程序中，可以使用@EnableRedisHttpSession注解来启用Spring Session，并指定Session存储后端的类型和配置信息。例如，以下代码片段演示了如何将Session存储在Redis中： ``` @Configuration @EnableRedisHttpSession public class HttpSessionConfig { @Bean public LettuceConnectionFactory connectionFactory() { return new LettuceConnectionFactory(); } } ``` 在上面的代码中，使用@EnableRedisHttpSession注解启用了Spring Session，并通过@Bean方法创建了一个LettuceConnectionFactory对象，用于连接Redis。 然后，在控制器中，可以使用HttpServletRequest对象来获取Session，并将数据存储在Session中。例如，以下代码片段演示了如何将用户ID存储在Session中： ``` @Controller public class UserController { @GetMapping("/login") public String login(HttpServletRequest request, String userId) { request.getSession().setAttribute("userId", userId); return "redirect:/home"; } @GetMapping("/home") public String home(HttpServletRequest request) { String userId = (String) request.getSession().getAttribute("userId"); if (userId == null) { return "redirect:/login"; } // do something with userId return "home"; } } ``` 在上面的代码中，使用HttpServletRequest对象获取Session，并使用setAttribute方法将用户ID存储在Session中。在home方法中，使用getAttribute方法获取Session中的用户ID，并进行相应的处理。 总之，使用Spring Boot和Spring Session可以轻松实现Session登录，并且可以与多种Session存储后端集成。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值