Springboot 获取当前登录用户

最新推荐文章于 2024-05-30 15:19:01 发布
最新推荐文章于 2024-05-30 15:19:01 发布
阅读量2.6w 收藏 8
点赞数 4
分类专栏： Java进阶 文章标签： session
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/U2133048/article/details/83183505
版权

在Springboot使用Redis缓存基础上编写

User类

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonView;

@Entity
@Table(name = "MFC_USER")
public class User extends CreatedTimeEntity implements Serializable {

    private static final long serialVersionUID = 1499996380665206081L;

    // 用户名
    @JsonView(ListView.class)
    @Column(length = 30, name = "user_name", unique = true)
    private String userName;

    // 手机号
    @JsonView(ListView.class)
    @Column(length = 30, name = "phone", unique = true)
    private String phone;
    @Column
    private String num;
    // 密码
    @JsonIgnore
    @Column(length = 50)
    private String password;

    // 随机字符串，加强密码用
    @JsonIgnore
    @Column(length = 36, nullable = false)
    private String salt;

    // 姓名
    @JsonView(ListView.class)
    @Column(length = 30, nullable = false)
    private String name;

    // 性别
    @JsonView(ListView.class)
    @Column(nullable = false)
    private Boolean sex;

    // 部门
    @JsonView(ListView.class)
    @ManyToOne(fetch = FetchType.EAGER)
    private Department department;

    // 卡面号
    @JsonView(ListView.class)
    @Column(length = 50)
    private String cardnumber;

    // 卡物理号
    @JsonView(ListView.class)
    @Column(length = 50)
    private String cardnumberwl;

    // 是否超级用户
    @JsonView(ListView.class)
    private Boolean superuser;

    // 是否授权
    @JsonView(ListView.class)
    private Boolean accredit;

    // 卡有效期
    @JsonView(ListView.class)
    @Column(length = 50)
    private String valid;

    // 属性集
    @JsonView(ListView.class)
    @Column(length = 50)
    private String property;

    // 备注
    @JsonView(ListView.class)
    @Column(length = 100)
    private String remark;

    // 类别 0代表员工 1代表外协
    @JsonView(ListView.class)
    @Column(length = 20, nullable = false)
    private String type;

    // 车站Id
    @JsonView(ListView.class)
    @OneToMany(fetch = FetchType.EAGER, cascade = {CascadeType.ALL})
    @JoinColumn(name = "user_middle_id")
    private List<UserStation>stationId;

    @JsonView({ UserDetailView.class, UserListView.class })
    @ManyToMany(cascade = CascadeType.REFRESH)
    @JoinTable(name = "MFC_USER_ROLE", joinColumns = {
            @JoinColumn(name = "user_id", referencedColumnName = "id") }, inverseJoinColumns = {
                    @JoinColumn(name = "role_id", referencedColumnName = "id") })
    private List<Role> roles = new ArrayList<Role>();

    public User() {
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getSalt() {
        return salt;
    }

    public void setSalt(String salt) {
        this.salt = salt;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    public String getCardnumber() {
        return cardnumber;
    }

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    public void setCardnumber(String cardnumber) {
        this.cardnumber = cardnumber;
    }

    public String getCardnumberwl() {
        return cardnumberwl;
    }

    public void setCardnumberwl(String cardnumberwl) {
        this.cardnumberwl = cardnumberwl;
    }

    public Boolean getSex() {
        return sex;
    }

    public void setSex(Boolean sex) {
        this.sex = sex;
    }

    public Boolean getSuperuser() {
        return superuser;
    }

    public void setSuperuser(Boolean superuser) {
        this.superuser = superuser;
    }

    public Boolean getAccredit() {
        return accredit;
    }

    public void setAccredit(Boolean accredit) {
        this.accredit = accredit;
    }

    public String getValid() {
        return valid;
    }

    public void setValid(String valid) {
        this.valid = valid;
    }

    public String getProperty() {
        return property;
    }

    public void setProperty(String property) {
        this.property = property;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public List<UserStation> getStationId() {
        return stationId;
    }

    public void setStationId(List<UserStation> stationId) {
        this.stationId = stationId;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

}
 

Session类

import java.util.UUID;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonView;

public class Session {

    @JsonView(ListView.class)
    private String token = UUID.randomUUID().toString();
    
    @JsonView(ListView.class)
    private long lastModifiedTime = System.currentTimeMillis();
    
    @JsonView(ListView.class)
    private User user;
    
    @SuppressWarnings("unused")
    private Session(){
        
    }

    public Session(User user) {
        this.user = user;
    }
    
    @JsonIgnore
    public String getUserId(){
        if(null!=user){
            return user.getId();
        }else{
            return null;
        }
    }

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public long getLastModifiedTime() {
        return lastModifiedTime;
    }

    public void setLastModifiedTime(long lastModifiedTime) {
        this.lastModifiedTime = lastModifiedTime;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}
 

SessionService类

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

@Component
public class SessionService {

    public static final String EFFECTIVE_TIME = "com.gzydt.passport.exports.effectiveTime";
    public static final String REFRESHED_TIME = "com.gzydt.passport.exports.refreshedTime";
    private static final String PRE_SESSION_KEY = "session_";
    private static final String PRE_USER_KEY = "user_";

    private static final Logger log = LoggerFactory.getLogger(SessionService.class);

    @Autowired
    private JedisClient client;

    @Autowired
    private Environment env;

    private long effectiveTime = 1800000;
    private long refreshedTime = 300000;

    private boolean inited = false;

    private void init() {
        if (!inited) {
            inited = true;
            dealConfig();
        }
    }

    private void dealConfig() {
        // 处理启动配置项
        dealTime(env);
    }

    private void dealTime(Environment env) {
        dealEffectiveTime(env);
        dealRefreshedTime(env);
    }

    private void dealEffectiveTime(Environment env) {
        try {
            long _effectiveTime = Long.valueOf(env.getProperty(EFFECTIVE_TIME));
            effectiveTime = _effectiveTime <= 0 ? effectiveTime : _effectiveTime;
        } catch (NumberFormatException e) {
            // 什么也不做
        }
        log.debug(EFFECTIVE_TIME + ":" + effectiveTime);
    }

    private void dealRefreshedTime(Environment env) {
        try {
            long _refreshedTime = Long.valueOf(env.getProperty(REFRESHED_TIME));
            refreshedTime = _refreshedTime <= 0 ? refreshedTime : _refreshedTime;
        } catch (NumberFormatException e) {
            // 什么也不做
        }
        log.debug(REFRESHED_TIME + ":" + refreshedTime);
    }

    public long getEffectiveTime() {
        init();
        return effectiveTime;
    }

    public long getRefreshedTime() {
        init();
        return refreshedTime;
    }

    public Session getSession(String key) {
        key = dealSessionKey(key);
        Session session = JsonUtil.toBean(Session.class, client.get(key));
        if (null != session) {
            if (need2Refresh(session)) {
                session.setLastModifiedTime(System.currentTimeMillis());
                client.set(key, JsonUtil.toJson(UserDetailView.class, session), this.getEffectiveTime() / 1000);
                log.debug("刷新session【" + key + "】");
            } else {
                // 什么都不做
            }
            return session;
        } else {
            throw new SessionNotFoundException();
        }
    }
    
    public User getLoginUser(String key) {
        Session session = getSession(key);
        return session.getUser();
    }

    public boolean deleteSession(String key) {
        key = dealSessionKey(key);
        client.delete(key);
        log.debug("删除session【" + key + "】");
        return true;
    }

    public void addSession(Session session) {
        String key = dealSessionKey(session.getToken());
        log.debug("添加session【" + key + "】");
        client.set(key, JsonUtil.toJson(UserDetailView.class, session), this.getEffectiveTime() / 1000);
    }

    private boolean need2Refresh(Session session) {
        if (System.currentTimeMillis() > session.getLastModifiedTime() + this.getRefreshedTime()) {
            return true;
        } else {
            return false;
        }
    }

    private String dealSessionKey(String key) {
        if (null == key || "".equals(key)) {
            return "";
        } else {
            return PRE_SESSION_KEY + key;
        }
    }

    public static String getTokenFromRequest(HttpServletRequest request) {
        String token = getTokenFromQueryParam(request);
        return null == token ? getTokenFromCookie(request) : token;
    }

    private static String getTokenFromCookie(HttpServletRequest request) {
        Cookie[] cookies = request.getCookies();
        if (null != cookies) {
            for (Cookie cookie : cookies) {
                if (StaticFinalStringUtil.TOKEN_NAME.equals(cookie.getName())) {
                    return cookie.getValue();
                }
            }
        }
        return null;
    }

    private static String getTokenFromQueryParam(HttpServletRequest request) {
        return request.getParameter(StaticFinalStringUtil.TOKEN_NAME);
    }

    public Session getSession(HttpServletRequest request) {
        String key = getTokenFromRequest(request);
        key = dealSessionKey(key);
        Session session = JsonUtil.toBean(Session.class, client.get(key));
        if (null != session) {
            if (need2Refresh(session)) {
                session.setLastModifiedTime(System.currentTimeMillis());
                client.set(key, JsonUtil.toJson(UserDetailView.class, session), this.getEffectiveTime() / 1000);
                log.debug("刷新session【" + key + "】");
            } else {
                // 什么都不做
            }
            return session;
        } else {
            throw new SessionNotFoundException();
        }
    }

    public User getLoginUser(HttpServletRequest request) {
        Session session = getSession(request);
        return session.getUser();
    }
    
    public void addUserUnion(String userId, String token) {
        client.set(dealUserKey(userId), token);
    }
    
    public String getUserUnion(String userId) {
        userId = dealUserKey(userId);
        return client.get(userId);
    }
    
    private String dealUserKey(String userId) {
        if (null == userId || "".equals(userId)) {
            return "";
        } else {
            return PRE_USER_KEY + userId;
        }
    }
}
 

登录类

private JsonResponse<?> _login(LoginForm form, HttpServletResponse response, HttpServletRequest request) {
        try {
            String checkCode = verificationCodeService.get(request);
            if (!CommonUtil.isEmtpy(checkCode) && checkCode.equalsIgnoreCase(form.getCheckCode())) {
                String key = userService.login(form.getAccount(), form.getPassword());
                this.setCookie(key, response);
                
                if (null == key) {
                    log.info("【" + form.getAccount() + "】登录失败！");
                    return new JsonResponse<>(400, "登录失败！");
                } else {
                    log.info("【" + form.getAccount() + "】登录成功！");
                    verificationCodeService.delete(request);// 删除验证码
                    LoginVo loginVo = new LoginVo(sessionService.getLoginUser(key), key);
                    dealLoginVo(loginVo);
                    return new JsonResponse<>(loginVo);
                }
            } else {
                log.info("【" + form.getCheckCode() + "】验证码错误！");
                return new JsonResponse<>(400, "验证码错误");
            }
        } catch (IllegalArgumentException | SessionNotFoundException e) {
            return new JsonResponse<>(400, e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
            return new JsonResponse<>(500, e.getMessage());
        }
    }

获取当前登录用户

public JsonResponse<Role> add(HttpServletRequest request) {
            User user = sessionService.getLoginUser(request);
        } catch (Exception e) {
            e.printStackTrace();
            return new JsonResponse<>(500, e.getMessage());
        }
    }

 

U2133048
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Springboot +spring security，登录用户数据获取
weixin_40991408的博客
05-21 1259
Springboot +spring security，登录用户数据获取
Springboot+Shiro记录用户登录信息并获取当前登录用户信息的实现代码
08-19
主要介绍了Springboot+Shiro记录用户登录信息，并获取当前登录用户信息,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
springboot如何获取当前登录用户信息
weixin_45501219的博客
06-26 9308
1、 内部使用SpringSecurity的 SpringBoot提供了一个SecurityContextHolder类，该类允许通过以下方式查找当前经过身份验证的用户： SecurityContextHolder.getContext().getAuthentication().getPrincipal(); 获取登录用户的用户名：getPrincipal() 获取通过身份验证的用户的密码：getCredentials() 获取已认证用户的分配角色：getAuthorities() 获...
Spring Boot 获取Cookie/Session
最新发布
蓝天it（让亿万孩子在蓝天下共享优质教育）
05-30 1132
在计算机领域, 会话是⼀个客⼾与服务器之间的不中断的请求响应. 对客⼾的每个请求，服务器能够识别出请求来⾃于同⼀个客⼾. 当⼀个未知的客⼾向Web应⽤程序发送第⼀个请求时就开始了⼀个会话.当客⼾明确结束会话或服务器在⼀个时限内没有接受到客⼾的任何请求时，会话就结束了.服务器同⼀时刻收到的请求是很多的. 服务器需要清楚的区分每个请求是从属于哪个⽤⼾, 也就是属于哪个会话, 就需要在服务器这边记录每个会话以及与⽤⼾的信息的对应关系.Session是服务器为了保存⽤⼾信息⽽创建的⼀个特殊的对象.
springboot获取用户
u014414110的博客
03-17 533
AccountAuthentic account = (AccountAuthentic) SecurityContextHolder.getContext() .getAuthentication().getPrincipal();
springboot给方法参数加注解判断当前登录用户
qq_41358574的博客
10-05 667
自定义注解：LoginUser。
springboot获取登录用户的个人信息
weixin_39868387的博客
02-18 9478
在Spring Boot中，获取登录用户的个人信息通常需要使用Spring Security框架来进行身份认证和授权。Spring Security提供了一个名为SecurityContextHolder的上下文对象，它包含了当前请求的身份认证信息。通过SecurityContextHolder，可以访问当前已认证的用户的信息。
springboot通过参数注解自动获取当前用户信息
qq614571540的博客
03-11 1138
HandlerMethodArgumentResolver 使用实例
SpringBoot 并发登录人数控制的实现方法
08-25
在 Filter 逻辑中，我们首先获取用户的 token，然后从队列中获取对应的 token，如果队列中已经达到最大登录人数，我们就踢出之前登录的用户或当前用户，并返回错误信息；否则，我们就将当前 token 添加到队列中。 ...
spring oauth2获取当前登录用户信息.docx
07-10
通常，Spring Security允许我们通过`SecurityContextHolder.getContext().getAuthentication().getPrincipal()`来获取详细的用户信息，但当你尝试在OAuth2环境中使用同样的方法时，你可能只会得到当前用户的用户名，...
使用spring oauth2框架获取当前登录用户信息的实现代码
08-18
在部分内容中，作者首先提到使用 Spring Oauth2 框架获取当前登录用户信息的实现代码，然后提到可以通过 `SecurityContextHolder.getContext().getAuthentication().getPrincipal()` 获取到当前用户的用户名。...
SpringBoot登录拦截配置详解(实测可用)
08-18
在上面的代码中，我们首先从Session中获取当前用户的信息，如果用户信息为空，则抛出CustomException异常，提示用户登录。 在WebConfigurer中添加拦截器 ------------------------- 为了使LoginInterceptor生效，...
Springboot通过请求头获取当前用户信息的一种方式
rgrhiea的博客
11-27 6607
springboot中一种简洁的获取当前用户信息的方法
springboot-Security获取当前的用户信息案例
不怕万人阻挡，只怕自己投降
11-02 2291
springboot-Security获取当前的用户信息案例
SpringBoot项目（Spring security）获取登录用户用户名
大佛拈花的博客
04-29 5185
String username=SecurityContextHolder.getContext().getAuthentication().getName(); AuthUser user=userRepository.findFirstByUserName(username); SecurityContextHolder ==>从ThreadLocal中获取用户 ThreadLoc...
SpringBoot实现在线用户数统计功能
RuiHao-He的博客
01-24 3455
@RestController //第一步：实现HttpSessionListener接口 public class CalculatorController implements HttpSessionListener { public static List<String> list = new ArrayList<String>(); //用户登陆成功...
Springboot+Shiro记录用户登录信息，并获取当前登录用户信息
热门推荐
qq_43656233的博客
05-06 1万+
由于最近做项目需要，在用户登陆后有一个功能是需要用户的信息，进行写入数据库的操作。但是目前还用不到Shiro的高级权限，只为了简单获取用户信息，自己整合了一个只记录用户，获取用户信息的功能。 导入Shiro依赖 <!-- Shiro --> <dependency> <groupId>org.apache.shiro</groupId&gt...
Springboot 方法注解 获取当前用户
zsj777的专栏
06-25 8121
1、注解 package com.ahies.system.common.annotation; import java.lang.annotation.*; /** * 当前用户Java对象注解类. * */ @Documented @Target({ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) public...
如何 获取用户的ID
ruiguang21的博客
12-17 1194
Use useEn=(Use)session.getAttribute("Useen"); int useID=useEn.getId();//获取用户的ID System.out.println("刘瑞光如何 获取用户的ID----"+useID);
springboot获取当前登录用户
03-16
Spring Security提供了一个SecurityContextHolder类，可以用来获取当前用户的信息。 首先，在pom.xml文件中添加Spring Security的依赖： ``` <groupId>org.springframework.security <artifactId>spring-...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值