【Java项目推荐之黑马头条】你的登录鉴权业务是怎么实现的？

水深无声 2024-03-01 08:12 6阅读 0赞

### 前言 ###

在学习Java的路上还是遇到了很多不错的好项目的，今天分享给大家，希望能对大家面试有所帮助！

后续会继续推荐其他好的项目，这次推荐的是B站开源的视频黑马头条项目，来吧学会它一起去虐面试官！！！

### 登录业务怎么实现的？ ###

在我的经验中，我曾使用多种方式来实现登录功能，具体根据项目需求和场景选择不同的实现方式。以下是我所使用过的几种方式：

1.  Cookie + Session：这是常见的传统方式，通过在客户端保存会话标识(Session ID)的Cookie，并在服务器端使用Session对象存储用户的登录状态信息。这种方式简单易用，适用于小型应用。
2.  Redis存储：为了提高扩展性和性能，我也使用过将会话信息存储在Redis中。通过将会话数据存储在高速缓存中，可以减轻服务器的负载并实现分布式环境下的会话共享。
3.  Token鉴权：另一种常见的方式是使用Token进行身份验证和鉴权。用户在登录成功后，服务器颁发一个加密的Token给客户端，客户端将该Token存储，并在后续请求中携带该Token进行身份验证。这种方式适用于前后端分离的应用和API接口的身份验证。
4.  社交媒体登录：为了提供更多的登录选项，我也实现了使用第三方平台（例如微信、GitHub等）进行登录的功能。用户可以通过授权登录第三方平台，然后使用其身份验证信息进行应用登录。

#### 具体实现方式？ ####

##### Cookie + Session #####

1.  用户向服务器发送用户名和密码。
2.  验证服务器后，相关数据（如用户角色，登录时间等）将保存在当前会话中。
3.  服务器向用户返回session\_id，session信息都会写入到用户的Cookie。
4.  用户的每个后续请求都将通过在Cookie中取出session\_id传给服务器。
5.  服务器收到session\_id并对比之前保存的数据，确认用户的身份。

@WebServlet("/login")
    public class LoginServlet extends HttpServlet {
        
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            String username = request.getParameter("username");
            String password = request.getParameter("password");
            
            // 验证用户名和密码，假设验证成功
            if (authenticate(username, password)) {
        
                // 创建会话
                HttpSession session = request.getSession(true);
                session.setAttribute("username", username);
                
                // 登录成功，重定向到用户主页或其他受保护的页面
                response.sendRedirect("home.jsp");
            } else {
        
                // 登录失败，重定向到登录页面并显示错误消息
                response.sendRedirect("login.jsp?error=1");
            }
        }
        
        private boolean authenticate(String username, String password) {
        
            // 在此处进行用户名和密码的验证逻辑，返回验证结果
            // 例如，检查数据库或其他身份验证方式
            // 如果验证成功，返回true；否则，返回false
            return true;
        }
    }

##### Redis存储 #####

public Result userLogin(LoginFormDTO loginForm, HttpSession session) {
        
            //1.获取手机号
            String phone = loginForm.getPhone();
            if (RegexUtils.isPhoneInvalid(phone)) {
        
                //2.不符合,返回错误信息
                return Result.fail("手机号格式错误");
            }
    
            //3.校验验证码
    //        Object cachecode = session.getAttribute("code");
    
            //3.1校验验证码通过redis
            String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
    
            String code = loginForm.getCode();
            if (cacheCode == null || !cacheCode.equals(code)) {
        
                return Result.fail("验证码错误");
            }
    
            //4.检查用户是否存在
            QueryWrapper<User> wrapper = new QueryWrapper<>();
            wrapper.eq("phone", phone);
            User user = baseMapper.selectOne(wrapper);
            //4.1判断用户是否存在
            if (user == null) {
        
                //4.2不存在创建用户
                user = new User();
                user.setPhone(phone);
                user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
                baseMapper.insert(user);
            }
    
            //5.保持用户信息到session
    //        session.setAttribute("user", BeanUtil.copyProperties(user, UserDTO.class));
    
            //5.1 保持用户信息到redis
            //1.随机生成token,作为登录令牌
            String token = UUID.randomUUID().toString(true);
            //2.将user对象转化为hash存储
            UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
            Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
                    CopyOptions.create()
                            .setIgnoreNullValue(true)
                            //这里用了lambda表达式来直接实现这个接口了,意思就是将所有字段都转换为string类型
                            .setFieldValueEditor((fileName, fileValue) -> fileValue.toString()));
    //        3.存储
            //3.1这里选择redis的hash数据结构,就是一个key(token),对应着一个hash结构的value(对象属性:对象值)
            //opsForHash().put()是一条一条的存储对象的value,如下格式
    //        key: name:li
    //        key: age:21
    
    //        opsForHash().putAll是一下把对象数据全放进去,也就是如下这种格式
    //        key : name:zs
    //              age:22
    //              address:beijing
            stringRedisTemplate.opsForHash().putAll(LOGIN_USER_KEY + token, userMap);
            //3.2 我们要给token设置有效期,因为随着用户越来越多,redis压力是越来越大,所以设置token有效期30分钟
            //LOGIN_USER_TTL为30分钟
            //现在存在的问题是,从登录的那一刻起,30分钟改token就会被踢出,那么30分钟之后还需要重新认证,所以我们要设置只要用户活跃就不踢出token
    //        1.我们通过拦截器来判断用户是不是活跃.  2.活跃的话就更新token的过期时间
            stringRedisTemplate.expire(LOGIN_USER_KEY + token, LOGIN_USER_TTL, TimeUnit.DAYS);
    
    //        4.返回token
            return Result.ok(token);
        }

##### Token鉴权 #####

该项目使用为Token鉴权模式，具体流程如下

> token鉴权和把token存储到redis中鉴权有什么区别？

前者是通过jwt工具类解析token，后者是通过redis解析token

> 代码编写思路

1.  实体类

通过Mybatisplus逆向生成实体类，也可以用代码生成器生成

1.  dao

自己写，或者通过Mybatisplus逆向生成实体类，也可以用代码生成器生成

1.  service

业务类，根据需求写，当然它也可以通过工具自动生成

1.  controller

控制类，根据需求写，也可以通过工具自动生成

> 对密码验证进行加盐

**什么是加盐？**

就是单对密码加密太容易被破解，所以在密码的基础上加一些字符串，对加过字符串的密码进行md5加密，这个过程就叫加盐。

**注册流程如下：**

![image-20230209160520930][]

**登录流程如下：**

![image-20230209160541439][]

> 思路分析

![在这里插入图片描述][0e4ffffdd9e84d03b3d61786bde188dd.png]

1，用户输入了用户名和密码进行登录，校验成功后返回jwt(基于当前用户的id生成)

2，用户游客登录，生成jwt返回(基于默认值0生成)

> 关键代码

> md5加密相同的字符，得到的结果是一样的

@Service
    public class ApUserServiceImpl extends ServiceImpl<ApUserMapper, ApUser> implements ApUserService {
        
    
        @Override
        public ResponseResult login(LoginDto dto) {
        
    
            //1.正常登录（手机号+密码登录）
            if (!StringUtils.isBlank(dto.getPhone()) && !StringUtils.isBlank(dto.getPassword())) {
        
                //1.1查询用户
                ApUser apUser = getOne(Wrappers.<ApUser>lambdaQuery().eq(ApUser::getPhone, dto.getPhone()));
                if (apUser == null) {
        
                    return ResponseResult.errorResult(AppHttpCodeEnum.DATA_NOT_EXIST,"用户不存在");
                }
    
                //1.2 比对密码
                String salt = apUser.getSalt();
                String pswd = dto.getPassword();
                pswd = DigestUtils.md5DigestAsHex((pswd + salt).getBytes());
                if (!pswd.equals(apUser.getPassword())) {
        
                    return ResponseResult.errorResult(AppHttpCodeEnum.LOGIN_PASSWORD_ERROR);
                }
                //1.3 返回数据  jwt
                Map<String, Object> map = new HashMap<>();
                map.put("token", AppJwtUtil.getToken(apUser.getId().longValue()));
                apUser.setSalt("");
                apUser.setPassword("");
                map.put("user", apUser);
                return ResponseResult.okResult(map);
            } else {
        
                //2.游客  同样返回token  id = 0
                Map<String, Object> map = new HashMap<>();
                map.put("token", AppJwtUtil.getToken(0l));
                return ResponseResult.okResult(map);
            }
        }
    }
    
    控制层controller
    @RestController
    @RequestMapping("/api/v1/login")
    public class ApUserLoginController {
        
    
        @Autowired
        private ApUserService apUserService;
    
        @PostMapping("/login_auth")
        public ResponseResult login(@RequestBody LoginDto dto) {
        
            return apUserService.login(dto);
        }
    }

##### 测试 #####

> 手机号密码登录

*  不存在的用户测试登录

![image-20230209161815202][]

*  存在的用户测试

![image-20230209162327885][]

##### 微信登录 #####

1.  在微信开放平台注册应用，获取相应的AppID和AppSecret，用于与微信服务器进行交互。
2.  前端页面发起微信登录请求，跳转至微信登录页面，用户进行授权登录。
3.  微信登录成功后，微信服务器会返回一个授权临时票据（code）。
4.  后端接收前端传递的授权临时票据，通过调用微信API获取访问令牌（access\_token）和用户唯一标识（openid）。
5.  后端根据用户唯一标识（openid）判断用户是否已存在于系统中，如果存在，则直接生成登录凭证（如JWT Token）返回给前端；如果不存在，则根据微信返回的用户信息创建新用户并生成登录凭证返回给前端。
6.  前端收到登录凭证后，将其保存在本地（如LocalStorage）用于后续的鉴权操作。
7.  在后续的请求中，前端将登录凭证（JWT Token）在请求头中发送给后端。
8.  后端对于受保护的接口，需要进行登录状态的校验和鉴权操作。根据前端发送的登录凭证，后端验证其有效性，并获取相关用户信息进行鉴权判断。

#### 鉴权逻辑怎么写的？ ####

Q: 鉴权逻辑是什么？在哪里编写的？

A: 鉴权逻辑是用于验证用户的身份和权限的过程。它用于确定用户是否有权访问受保护的资源或执行特定操作。鉴权逻辑通常在后端服务器中编写。

Q: 在哪个组件或模块中编写鉴权逻辑？

A: 在基于Web框架的应用中，鉴权逻辑通常在控制器、拦截器、过滤器或中间件中编写。这些组件负责接收请求并在处理请求之前或之后执行鉴权逻辑。

Q: 请给出一个示例来说明鉴权逻辑的编写和实现位置。

A: 下面是一个基于Spring Boot的示例代码，演示了在gateway中的过滤器和拦截器中编写鉴权逻辑的实现方法：

##### 拦截器（interceptor）示例 #####

public class LoginInterceptor implements HandlerInterceptor {
        
    
        //1. 这里不能做依赖注入,因为LoginInterceptor不属于Spring管理
        private StringRedisTemplate stringRedisTemplate;
    
        //1.1 那不通过Spring怎么注入呢?我们可以通过该类的构造方法,LoginInterceptor初始化的时候StringRedisTemplate也会被初始化
        public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {
        
            this.stringRedisTemplate = stringRedisTemplate;
        }
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
    
            //1.获取session
    //        HttpSession session = request.getSession();
            //1.1 获取token
            String token = request.getHeader("authorization");
    
            //2.获取session中的用户
    //        Object user = session.getAttribute("user");
    
            //2.2 基于token获取redis中用户
            if (StrUtil.isBlank(token)){
        
                //4.token不存在,拦截
                response.setStatus(401);
                return false;
            }
            //2.3 token存在的话,获取用户
            String key = LOGIN_USER_KEY + token;
            Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
    
            //3.判断用户是否存在
    //        if (user == null){
        
    //            //4.不存在,拦截
    //            response.setStatus(401);
    //            return false;
    //        }
            //3.1 判断用户是否存在
            if (userMap.isEmpty()){
        
                //4.token不存在,拦截
                response.setStatus(401);
                return false;
            }
            //5.存在,保持到TheadLocal
    //        UserHolder.saveUser((UserDTO) user);
    
            //5.1 将查询到的Hash数据转为UserDTO对象(因为我们存到redis中的数据类型是Hash,用户数据为一个Map)
    
            UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
            //5.2 存在,保持用户信息到ThreadLocal
            UserHolder.saveUser(userDTO);
    
            //6.1 刷新token有效期
            stringRedisTemplate.expire(key, RedisConstants.LOGIN_USER_TTL, TimeUnit.DAYS);
    
            //6.放行
            return true;
    
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        
            UserHolder.removeUser();
        }
    }

##### 过滤器（filter）示例 #####

@Component
    @Slf4j
    public class AuthorizeFilter implements Ordered, GlobalFilter {
        
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        
            //1.获取request和response对象
            ServerHttpRequest request = exchange.getRequest();
            ServerHttpResponse response = exchange.getResponse();
    
            //2.判断是否是登录
            if(request.getURI().getPath().contains("/login")){
        
                //放行
                return chain.filter(exchange);
            }
    
    
            //3.获取token
            String token = request.getHeaders().getFirst("token");
    
            //4.判断token是否存在
            if(StringUtils.isBlank(token)){
        
                response.setStatusCode(HttpStatus.UNAUTHORIZED);
                return response.setComplete();
            }
    
            //5.判断token是否有效
            try {
        
                Claims claimsBody = AppJwtUtil.getClaimsBody(token);
                //是否是过期
                int result = AppJwtUtil.verifyToken(claimsBody);
                if(result == 1 || result  == 2){
        
                    response.setStatusCode(HttpStatus.UNAUTHORIZED);
                    return response.setComplete();
                }
    
                //获取用户信息
                Object userId = claimsBody.get("id");
    
                //存储header中
                ServerHttpRequest serverHttpRequest = request.mutate().headers(httpHeaders -> {
        
                    httpHeaders.add("userId", userId + "");
                }).build();
                //重置请求
                exchange.mutate().request(serverHttpRequest);
            }catch (Exception e){
        
                e.printStackTrace();
                response.setStatusCode(HttpStatus.UNAUTHORIZED);
                return response.setComplete();
            }
    
            //6.放行
            return chain.filter(exchange);
        }
    
        /**
         * 优先级设置  值越小  优先级越高
         * @return
         */
        @Override
        public int getOrder() {
        
            return 0;
        }
    }

##### 拦截器和过滤器的区别 #####

拦截器通常用于在请求到达目标处理程序（如控制器）之前或之后执行一些操作。它可以拦截方法调用、HTTP 请求等。在 Java 的 Spring 框架中，拦截器用于拦截 Spring MVC 请求，执行一些通用的任务，如鉴权、日志记录、处理异常等。拦截器在请求处理的各个阶段都可以介入，如请求前、请求后、视图渲染前等。拦截器通常与 AOP（面向切面编程）概念结合使用。

过滤器通常用于在请求进入 web 容器之前或之后执行一些操作。在 Java 的 Servlet 编程中，过滤器可以用于对请求和响应进行预处理和后处理，如鉴权、编码转换、防止 XSS 攻击等。过滤器在请求的一开始就会生效，而在请求处理完毕后，响应返回给客户端之前也会生效。过滤器通常在 web.xml 文件中进行配置。

[image-20230209160520930]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/01/729070e0eb664d0cba7392e9657fd63f.png
[image-20230209160541439]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/01/205f13f9dd974155a20296fb827b47d7.png
[0e4ffffdd9e84d03b3d61786bde188dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/01/9316fb4ab95541f5a1e2b12031c4cd63.png
[image-20230209161815202]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/01/cd1aca7790204f3f9eddeda79bdf2a31.png
[image-20230209162327885]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/01/37a70fd3f0634b7b8a7ddab65b891267.png