（仿牛客社区项目）Java开发笔记4.6：优化登录模块

最新推荐文章于 2023-05-24 23:19:43 发布
最新推荐文章于 2023-05-24 23:19:43 发布
阅读量466 收藏
点赞数 1
分类专栏： Java项目 文章标签： java 数据库 redis spring 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45700663/article/details/125947209
版权

文章目录

优化登录模块

NowCoder_23_1

1.util包

添加redis中形成相关键的方法。

package com.gerrard.community.util;

public class RedisKeyUtil {

    private static final String SPLIT = ":";
    private static final String PREFIX_ENTITY_LIKE = "like:entity";
    private static final String PREFIX_USER_LIKE = "like:user";
    private static final String PREFIX_FOLLOWEE = "followee";
    private static final String PREFIX_FOLLOWER = "follower";
    private static final String PREFIX_KAPTCHA = "kaptcha";
    private static final String PREFIX_TICKET = "ticket";
    private static final String PREFIX_USER = "user";

   //某个实体的赞
    //like:entity:【entityType:entityId】->【set(userId)】
    public static String getEntityLikeKey(int entityType, int entityId) {
        return PREFIX_ENTITY_LIKE + SPLIT + entityType + SPLIT + entityId;
    }

    //某个用户的赞
    //like:user:【userId】->int
    public static String getUserLikeKey(int userId) {
        return PREFIX_USER_LIKE + SPLIT + userId;
    }

   //某个用户关注的实体（键：用户Id，值：实体Id）
    //followee:【userId:entityType】->zset(entityId,now)
    public static String getFolloweeKey(int userId, int entityType) {
        return PREFIX_FOLLOWEE + SPLIT + userId + SPLIT + entityType;
    }

     //某个实体拥有的粉丝（键：实体Id，值：用户Id)
    //follower:【entityType:entityId】->zset(userId,now)
    public static String getFollowerKey(int entityType, int entityId) {
        return PREFIX_FOLLOWER + SPLIT + entityType + SPLIT + entityId;
    }
		//entityType不可以删除，userId和entityId值会有重复，需要借助entityType构成键的一部分加以区分，【不对】
        //entityType不可以删除，Id值相同的情况下，需要借助entityType以示区分

    // 登录验证码 kaptcha:【owner（随机生成的字符串)，60s后过期】->验证码的值
    public static String getKaptchaKey(String owner) {
        return PREFIX_KAPTCHA + SPLIT + owner;
    }

 	// 登录的凭证 ticket:【ticket】->set(ticket实体类，过期时间存放在该实体中)
    public static String getTicketKey(String ticket) {
        return PREFIX_TICKET + SPLIT + ticket;
    }

	//用户 user:【userId】->set(user实体类,3600s后过期)
    public static String getUserKey(int userId) {
        return PREFIX_USER + SPLIT + userId;
    }

}

2.dao层

LoginTicketMapper类添加Deprecated注解。

package com.gerrard.community.dao;

import com.gerrard.community.entity.LoginTicket;
import org.apache.ibatis.annotations.*;

@Mapper
@Deprecated
public interface LoginTicketMapper {

    @Insert({
            "insert into login_ticket(user_id,ticket,status,expired) ",
            "values(#{userId},#{ticket},#{status},#{expired})"
    })
    @Options(useGeneratedKeys = true, keyProperty = "id")
    int insertLoginTicket(LoginTicket loginTicket);

    @Select({
            "select id,user_id,ticket,status,expired ",
            "from login_ticket where ticket=#{ticket}"
    })
    LoginTicket selectByTicket(String ticket);

    @Update({
            "<script>",
            "update login_ticket set status=#{status} where ticket=#{ticket} ",
            "<if test=\"ticket!=null\"> ",
            "and 1=1 ",
            "</if>",
            "</script>"
    })
    int updateStatus(String ticket, int status);

}

3.service层

修改UserService类的findUserById，login，logout，findLoginTicket，updateHeader方法，并添加getCache，initCache，clearCache方法。

package com.gerrard.community.service;

import com.gerrard.community.dao.LoginTicketMapper;
import com.gerrard.community.dao.UserMapper;
import com.gerrard.community.entity.LoginTicket;
import com.gerrard.community.entity.User;
import com.gerrard.community.util.CommunityConstant;
import com.gerrard.community.util.CommunityUtil;
import com.gerrard.community.util.MailClient;
import com.gerrard.community.util.RedisKeyUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.thymeleaf.TemplateEngine;
import org.thymeleaf.context.Context;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.TimeUnit;

@Service
public class UserService implements CommunityConstant {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private MailClient mailClient;

    @Autowired
    private TemplateEngine templateEngine;

    @Value("${community.path.domain}")
    private String domain;

    @Value("${server.servlet.context-path}")
    private String contextPath;

//    @Autowired
//    private LoginTicketMapper loginTicketMapper;

    @Autowired
    private RedisTemplate redisTemplate;

    public User findUserById(int id) {
//        return userMapper.selectById(id);
        User user = getCache(id);
        if (user == null) {
            user = initCache(id);
        }
        return user;
    }

    public Map<String, Object> register(User user) {
        Map<String, Object> map = new HashMap<>();

        // 空值处理
        if (user == null) {
            throw new IllegalArgumentException("参数不能为空!");
        }
        if (StringUtils.isBlank(user.getUsername())) {
            map.put("usernameMsg", "账号不能为空!");
            return map;
        }
        if (StringUtils.isBlank(user.getPassword())) {
            map.put("passwordMsg", "密码不能为空!");
            return map;
        }
        if (StringUtils.isBlank(user.getEmail())) {
            map.put("emailMsg", "邮箱不能为空!");
            return map;
        }

        // 验证账号
        User u = userMapper.selectByName(user.getUsername());
        if (u != null) {
            map.put("usernameMsg", "该账号已存在!");
            return map;
        }

        // 验证邮箱
        u = userMapper.selectByEmail(user.getEmail());
        if (u != null) {
            map.put("emailMsg", "该邮箱已被注册!");
            return map;
        }

        // 注册用户
        user.setSalt(CommunityUtil.generateUUID().substring(0, 5));
        user.setPassword(CommunityUtil.md5(user.getPassword() + user.getSalt()));
        user.setType(0);
        user.setStatus(0);
        user.setActivationCode(CommunityUtil.generateUUID());
        user.setHeaderUrl(String.format("http://images.nowcoder.com/head/%dt.png", new Random().nextInt(1000)));
        user.setCreateTime(new Date());
        userMapper.insertUser(user);

        // 激活邮件
        Context context = new Context();
        context.setVariable("email", user.getEmail());
        // http://localhost:8080/community/activation/101/code
        String url = domain + contextPath + "/activation/" + user.getId() + "/" + user.getActivationCode();
        context.setVariable("url", url);
        String content = templateEngine.process("/mail/activation", context);
        mailClient.sendMail(user.getEmail(), "激活账号", content);

        return map;
    }

    public int activation(int userId, String code) {
        User user = userMapper.selectById(userId);
        if (user.getStatus() == 1) {
            return ACTIVATION_REPEAT;
        } else if (user.getActivationCode().equals(code)) {
            userMapper.updateStatus(userId, 1);
            clearCache(userId);
            return ACTIVATION_SUCCESS;
        } else {
            return ACTIVATION_FAILURE;
        }
    }

    public Map<String, Object> login(String username, String password, int expiredSeconds) {
        Map<String, Object> map = new HashMap<>();

        // 空值处理
        if (StringUtils.isBlank(username)) {
            map.put("usernameMsg", "账号不能为空!");
            return map;
        }
        if (StringUtils.isBlank(password)) {
            map.put("passwordMsg", "密码不能为空!");
            return map;
        }

        // 验证账号
        User user = userMapper.selectByName(username);
        if (user == null) {
            map.put("usernameMsg", "该账号不存在!");
            return map;
        }

        // 验证状态
        if (user.getStatus() == 0) {
            map.put("usernameMsg", "该账号未激活!");
            return map;
        }

        // 验证密码
        password = CommunityUtil.md5(password + user.getSalt());
        if (!user.getPassword().equals(password)) {
            map.put("passwordMsg", "密码不正确!");
            return map;
        }

        // 生成登录凭证
        LoginTicket loginTicket = new LoginTicket();
        loginTicket.setUserId(user.getId());
        loginTicket.setTicket(CommunityUtil.generateUUID());
        loginTicket.setStatus(0);
        loginTicket.setExpired(new Date(System.currentTimeMillis() + expiredSeconds * 1000));
//        loginTicketMapper.insertLoginTicket(loginTicket);

        String redisKey = RedisKeyUtil.getTicketKey(loginTicket.getTicket());
        redisTemplate.opsForValue().set(redisKey, loginTicket);

        map.put("ticket", loginTicket.getTicket());
        return map;
    }

    public void logout(String ticket) {
//        loginTicketMapper.updateStatus(ticket, 1);
        String redisKey = RedisKeyUtil.getTicketKey(ticket);
        LoginTicket loginTicket = (LoginTicket) redisTemplate.opsForValue().get(redisKey);
        loginTicket.setStatus(1);
        redisTemplate.opsForValue().set(redisKey, loginTicket);
    }

    public LoginTicket findLoginTicket(String ticket) {
//        return loginTicketMapper.selectByTicket(ticket);
        String redisKey = RedisKeyUtil.getTicketKey(ticket);
        return (LoginTicket) redisTemplate.opsForValue().get(redisKey);
    }

    public int updateHeader(int userId, String headerUrl) {
//        return userMapper.updateHeader(userId, headerUrl);
        int rows = userMapper.updateHeader(userId, headerUrl);
        clearCache(userId);
        return rows;
    }

    public User findUserByName(String username) {
        return userMapper.selectByName(username);
    }

    // 1.优先从缓存中取值
    private User getCache(int userId) {
        String redisKey = RedisKeyUtil.getUserKey(userId);
        return (User) redisTemplate.opsForValue().get(redisKey);
    }

    // 2.取不到时初始化缓存数据
    private User initCache(int userId) {
        User user = userMapper.selectById(userId);
        String redisKey = RedisKeyUtil.getUserKey(userId);
        redisTemplate.opsForValue().set(redisKey, user, 3600, TimeUnit.SECONDS);
        return user;
    }

    // 3.数据变更时清除缓存数据
    private void clearCache(int userId) {
        String redisKey = RedisKeyUtil.getUserKey(userId);
        redisTemplate.delete(redisKey);
    }

}

4.controller层

LoginController修改getKaptcha方法，修改login方法。

loginticket不设置过期时间是为了防止以后用到，比如开发查看历史信息的功能【您最早于xxx点登陆系统】，用户和验证码在redis中都设置过期时间。

package com.gerrard.community.controller;

import com.google.code.kaptcha.Producer;
import com.gerrard.community.entity.User;
import com.gerrard.community.service.UserService;
import com.gerrard.community.util.CommunityConstant;
import com.gerrard.community.util.CommunityUtil;
import com.gerrard.community.util.RedisKeyUtil;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import javax.imageio.ImageIO;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Controller
public class LoginController implements CommunityConstant {

    private static final Logger logger = LoggerFactory.getLogger(LoginController.class);

    @Autowired
    private UserService userService;

    @Autowired
    private Producer kaptchaProducer;

    @Value("${server.servlet.context-path}")
    private String contextPath;

    @Autowired
    private RedisTemplate redisTemplate;

    @RequestMapping(path = "/register", method = RequestMethod.GET)
    public String getRegisterPage() {
        return "/site/register";
    }

    @RequestMapping(path = "/login", method = RequestMethod.GET)
    public String getLoginPage() {
        return "/site/login";
    }

    @RequestMapping(path = "/register", method = RequestMethod.POST)
    public String register(Model model, User user) {
        Map<String, Object> map = userService.register(user);
        if (map == null || map.isEmpty()) {
            model.addAttribute("msg", "注册成功,我们已经向您的邮箱发送了一封激活邮件,请尽快激活!");
            model.addAttribute("target", "/index");
            return "/site/operate-result";
        } else {
            model.addAttribute("usernameMsg", map.get("usernameMsg"));
            model.addAttribute("passwordMsg", map.get("passwordMsg"));
            model.addAttribute("emailMsg", map.get("emailMsg"));
            return "/site/register";
        }
    }

    // http://localhost:8080/community/activation/101/code
    @RequestMapping(path = "/activation/{userId}/{code}", method = RequestMethod.GET)
    public String activation(Model model, @PathVariable("userId") int userId, @PathVariable("code") String code) {
        int result = userService.activation(userId, code);
        if (result == ACTIVATION_SUCCESS) {
            model.addAttribute("msg", "激活成功,您的账号已经可以正常使用了!");
            model.addAttribute("target", "/login");
        } else if (result == ACTIVATION_REPEAT) {
            model.addAttribute("msg", "无效操作,该账号已经激活过了!");
            model.addAttribute("target", "/index");
        } else {
            model.addAttribute("msg", "激活失败,您提供的激活码不正确!");
            model.addAttribute("target", "/index");
        }
        return "/site/operate-result";
    }

    @RequestMapping(path = "/kaptcha", method = RequestMethod.GET)
    public void getKaptcha(HttpServletResponse response/*, HttpSession session*/) {
        // 生成验证码
        String text = kaptchaProducer.createText();
        BufferedImage image = kaptchaProducer.createImage(text);

        // 将验证码存入session
        // session.setAttribute("kaptcha", text);

        // 验证码的归属
        String kaptchaOwner = CommunityUtil.generateUUID();
        Cookie cookie = new Cookie("kaptchaOwner", kaptchaOwner);
        cookie.setMaxAge(60);
        cookie.setPath(contextPath);
        response.addCookie(cookie);
        // 将验证码存入Redis
        String redisKey = RedisKeyUtil.getKaptchaKey(kaptchaOwner);
        redisTemplate.opsForValue().set(redisKey, text, 60, TimeUnit.SECONDS);

        // 将突图片输出给浏览器
        response.setContentType("image/png");
        try {
            OutputStream os = response.getOutputStream();
            ImageIO.write(image, "png", os);
        } catch (IOException e) {
            logger.error("响应验证码失败:" + e.getMessage());
        }
    }

    @RequestMapping(path = "/login", method = RequestMethod.POST)
    public String login(String username, String password, String code, boolean rememberme,
                        Model model, /*HttpSession session, */HttpServletResponse response,
                        @CookieValue("kaptchaOwner") String kaptchaOwner) {
        // 检查验证码
        // String kaptcha = (String) session.getAttribute("kaptcha");
        String kaptcha = null;
        if (StringUtils.isNotBlank(kaptchaOwner)) {
            String redisKey = RedisKeyUtil.getKaptchaKey(kaptchaOwner);
            kaptcha = (String) redisTemplate.opsForValue().get(redisKey);
        }

        if (StringUtils.isBlank(kaptcha) || StringUtils.isBlank(code) || !kaptcha.equalsIgnoreCase(code)) {
            model.addAttribute("codeMsg", "验证码不正确!");
            return "/site/login";
        }

        // 检查账号,密码
        int expiredSeconds = rememberme ? REMEMBER_EXPIRED_SECONDS : DEFAULT_EXPIRED_SECONDS;
        Map<String, Object> map = userService.login(username, password, expiredSeconds);
        if (map.containsKey("ticket")) {
            Cookie cookie = new Cookie("ticket", map.get("ticket").toString());
            cookie.setPath(contextPath);
            cookie.setMaxAge(expiredSeconds);
            response.addCookie(cookie);
            return "redirect:/index";
        } else {
            model.addAttribute("usernameMsg", map.get("usernameMsg"));
            model.addAttribute("passwordMsg", map.get("passwordMsg"));
            return "/site/login";
        }
    }

    @RequestMapping(path = "/logout", method = RequestMethod.GET)
    public String logout(@CookieValue("ticket") String ticket) {
        userService.logout(ticket);
        return "redirect:/login";
    }

}

使用redis存储验证码：

旧版：客户端不保存有验证码信息，服务端保存一份验证码信息于session中。

当多用户从不同客户端发起访问时，则不能满足需求，因为服务端只会保存一条验证码信息，无法实现多用户登录。

改进：客户端只保存一份验证码信息（用cookie，多次刷新验证码则覆盖cookie，60s过后清除），服务端保存多份验证码信息（存储于redis数据库中，60s过后清除）， cookie中的kaptchaOwner值与redis中的kaptcha：【owner】键一一对应。

获取验证码时，客户端将随机字符串存储在cookie中，将随机字符串作为键，验证码的值作为值存储在redis中；

用户登录校验时，根据用户cookie传来的随机字符串查询redis数据库，获取验证码的值。

例：用户A刷新验证码，生成的随机字符串为fae737adc5eb41eaa189334f9d152d4e，验证码的值为4ZBT，则

cookie中存放的信息为：

kaptchaOwner:fae737adc5eb41eaa189334f9d152d4e  //60s后删除

redis中存放的信息为：

kaptcha:【owner（随机生成的字符串)】->验证码的值     //60s后删除
kaptcha:【fae737adc5eb41eaa189334f9d152d4e】->4ZBT

使用redis存储登录凭证：

旧版：客户端登录凭证存储在cookie中【cookie过期时间为expiredSeconds】，服务端登录凭证存储在login_ticket MySQL表中。

改进：客户端登录凭证存储在cookie中【cookie过期时间为expiredSeconds】，服务端登录凭证存储在login_ticket Redis数据库中。

涉及到查询login_ticket MySQL表的操作皆替换为redis操作。

 public Map<String, Object> login(String username, String password, int expiredSeconds) {
        Map<String, Object> map = new HashMap<>();

        // 空值处理
        if (StringUtils.isBlank(username)) {
            map.put("usernameMsg", "账号不能为空!");
            return map;
        }
        if (StringUtils.isBlank(password)) {
            map.put("passwordMsg", "密码不能为空!");
            return map;
        }

        // 验证账号
        User user = userMapper.selectByName(username);
        if (user == null) {
            map.put("usernameMsg", "该账号不存在!");
            return map;
        }

        // 验证状态
        if (user.getStatus() == 0) {
            map.put("usernameMsg", "该账号未激活!");
            return map;
        }

        // 验证密码
        password = CommunityUtil.md5(password + user.getSalt());
        if (!user.getPassword().equals(password)) {
            map.put("passwordMsg", "密码不正确!");
            return map;
        }

        // 生成登录凭证
        LoginTicket loginTicket = new LoginTicket();
        loginTicket.setUserId(user.getId());
        loginTicket.setTicket(CommunityUtil.generateUUID());
        loginTicket.setStatus(0);
        loginTicket.setExpired(new Date(System.currentTimeMillis() + expiredSeconds * 1000));
//        loginTicketMapper.insertLoginTicket(loginTicket);

        String redisKey = RedisKeyUtil.getTicketKey(loginTicket.getTicket());
        redisTemplate.opsForValue().set(redisKey, loginTicket);

        map.put("ticket", loginTicket.getTicket());
        return map;
    }

    public void logout(String ticket) {
//        loginTicketMapper.updateStatus(ticket, 1);
        String redisKey = RedisKeyUtil.getTicketKey(ticket);
        LoginTicket loginTicket = (LoginTicket) redisTemplate.opsForValue().get(redisKey);
        loginTicket.setStatus(1);
        redisTemplate.opsForValue().set(redisKey, loginTicket);
    }

    public LoginTicket findLoginTicket(String ticket) {
//        return loginTicketMapper.selectByTicket(ticket);
        String redisKey = RedisKeyUtil.getTicketKey(ticket);
        return (LoginTicket) redisTemplate.opsForValue().get(redisKey);
    }

    public int updateHeader(int userId, String headerUrl) {
//        return userMapper.updateHeader(userId, headerUrl);
        int rows = userMapper.updateHeader(userId, headerUrl);
        clearCache(userId);
        return rows;
    }

使用redis缓存用户信息；

旧版：用户信息仅存储在user MySQL表中。

改进：添加缓存，优先在缓存中取到用户实体。

	public User findUserById(int id) {
//        return userMapper.selectById(id);
        User user = getCache(id);
        if (user == null) {
            user = initCache(id);
        }
        return user;
    }
 	public int activation(int userId, String code) {
        User user = userMapper.selectById(userId);
        if (user.getStatus() == 1) {
            return ACTIVATION_REPEAT;
        } else if (user.getActivationCode().equals(code)) {
            userMapper.updateStatus(userId, 1);
            clearCache(userId);
            return ACTIVATION_SUCCESS;
        } else {
            return ACTIVATION_FAILURE;
        }
    }
 	public int updateHeader(int userId, String headerUrl) {
//        return userMapper.updateHeader(userId, headerUrl);
        int rows = userMapper.updateHeader(userId, headerUrl);
        clearCache(userId);
        return rows;
    }
 // 1.优先从缓存中取值
    private User getCache(int userId) {
        String redisKey = RedisKeyUtil.getUserKey(userId);
        return (User) redisTemplate.opsForValue().get(redisKey);
    }

    // 2.取不到时初始化缓存数据
    private User initCache(int userId) {
        User user = userMapper.selectById(userId);
        String redisKey = RedisKeyUtil.getUserKey(userId);
        redisTemplate.opsForValue().set(redisKey, user, 3600, TimeUnit.SECONDS);
        return user;
    }

    // 3.数据变更时清除缓存数据
    private void clearCache(int userId) {
        String redisKey = RedisKeyUtil.getUserKey(userId);
        redisTemplate.delete(redisKey);
    }

id为154的用户登录后，发放ticket为”ea90f2f3a2324ef9862a14bc25cf3729“的凭证，并将凭证号存储在cookie中，凭证存储在redis中，并返回主页【会经历一次拦截器，根据凭证号查询到凭证实体，取到凭证中的user_id，接着根据user_id获取user实体，此时会将user信息放在缓存中，并在整个请求过程中持有user hostholder信息】。

cookie中存放的信息为：

 ticket:ea90f2f3a2324ef9862a14bc25cf3729     //expiredSeconds后删除

redis存放的信息为：

// 登录的凭证 ticket:【ticket】->set(ticket实体类，过期时间存放在该实体中，永久保存)
ticket:【ea90f2f3a2324ef9862a14bc25cf3729】->{"{\"@class\":\"com.gerrard.community.entity.User\",\"id\":154,\"username\":\"ilovenjupt\",\"password\":\"e87075c7da5cfdbddb7d89627ac43476\",\"salt\":\"632f9\",\"email\":\"3150262925@qq.com\",\"type\":0,\"status\":1,\"activationCode\":\"b5c6c4e9db954d5a948c457ea61610b2\",\"headerUrl\":\"http://localhost:8080/community/user/header/22965adc32854b0abdb5cf76f0af83a7.jpeg\",\"createTime\":[\"java.util.Date\",1658050167000]}"}

//用户 user:【userId】->set(user实体类,3600s后删除)
user:【154】->{"{\"@class\":\"com.gerrard.community.entity.LoginTicket\",\"id\":0,\"userId\":154,\"ticket\":\"ea90f2f3a2324ef9862a14bc25cf3729\",\"status\":0,\"expired\":[\"java.util.Date\",1658606189535]}"}

5.功能测试

测试验证码：用户A刷新验证码，生成的随机字符串为fae737adc5eb41eaa189334f9d152d4e，验证码的值为4ZBT。

验证码：

NowCoder_23_2

cookie存放：

InkedNowCoder_23_3

redis存放：

NowCoder_23_4

测试登录凭证和用户信息：

cookie中存放的凭证：

InkedNowCoder_23_5

redis中存放的凭证和user实体：

NowCoder_23_6

Gerrar_d
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 用户登录模块_登录模块的实现
weixin_39747296的博客
02-16 3698
1、模块介绍以JSP+Servlet+JavaBean模式进行开发，系统流程图如下：用户登录之前需要进行注册，在注册成功后通过注册的用户名和密码进行登录，登录失败可以根据系统提示重新登录，登录成功后进入主页。2、关键技术本实例采用MVC模式进行开发，战士了模型层(Model)、视图层(View)和控制层(Controller)的结构体系，程序设计结构如下图所示：程序为用户提供了JSP页面进行战士，...
Javaweb登录功能优化及注销登录
weixin_53603117的博客
04-24 2387
登录功能优化 上篇登录功能代码在从数据库取出用户信息的代码中少写了取出用户姓名，现在将其加上user.setName(rs.getString("u_name")); 在登录成功后右上角会有一个xx用户，我们希望把用户名字显示在xx上，所以对其admin.jsp页面进行一些代码的调整 在LoginServlet中我们已经把从数据库中查出的用户信息保存在了session中 因此我们只需要再将用户信息中的用户姓名从session中取出来就可以了 将前台页面的xx修改成<%=((User)session
Java项目SpringMVC拦截器+Redis优化登录功能
qq_41894176的博客
09-13 447
1）登录注册功能的验证码之前是存放在Session中，会增加服务端的内存压力，现在通过Cookie获取信息存储到Redis中，Redis的key存随机字符串，Value存生成的字符串；Session 是保存在服务器的⽂件中，如果是集群服务，同⼀个⽤户过来可能落在不同机器上，这就会导致⽤户频繁登陆；preHandle：此方法在进入controller之前执行，如果该方法返回ture，则程序继续向下执行处理器中的方法，否则程序将不再往下继续执行；a.处理每次请求时，都需要查询用户的登录凭证，访问的频率非常高。
【JAVA项目实战】【图书管理系统】登录模块【Servlet】+【Session】+【Filter】+【JSP】
热门推荐
ALi.S的博客
09-06 2万+
这里是【JAVASE】项目实战的第五节课，以上就是今天要讲的内容，使用【Servlet】、【Session】、【Filterl】、【JSP】完成登录模块，对用户数据进行校验避免直接进入主页，设置过滤器保证资源的安全，通过Session记住密码，与本地的Cookie共同作用，实现用户登录和注销的功能。
java项目中如何写登录模块
weixin_47777564的博客
01-01 1395
首先我们对用户的字符串进行判断是否为空，不为空我们进入下一步验证； // isBlank：检查字符串是否为空或是否为null if(StringUtils.isBlank(account) || StringUtils.isBlank(password)) { return Result.fail(ErrorCode.ACCOUNT_PWD_NOT_EXIST.getCode(),ErrorCode.ACCOUNT_PWD_NOT_EXIST.getMs
java优化登录注册,Java-Web(项目)优化登录注册
weixin_32259417的博客
03-11 220
Java-Web(项目)优化登录注册Java-Web(项目)优化登录注册实现代码：package com.homework.dao1;public interface Login {public String doLogin(String _username,String _password);}```javapackage com.homework.dao1;import com.homewor...
Java仿牛客系统源码.zip
06-06
Java仿牛客系统源码是一个基于Java开发的在线编程训练和招聘平台的实现，它旨在提供类似牛客网的功能，帮助程序员进行技能提升、实战演练以及求职准备。这个源码库通常包含了完整的后端服务、前端界面以及数据库设计...
牛客网 牛客Java高级工程师 - 高薪求职项目课vol.4.zip
最新发布
01-12
软件开发设计：应用软件开发、系统软件开发、移动应用开发、网站开发C++、Java、python、web、C#等语言的项目开发与学习资料 硬件与设备：单片机、EDA、proteus、RTOS、包括计算机硬件、服务器、网络设备、存储设备...
基于SpringBoot 仿牛客网讨论社区项目
04-03
仿牛客网讨论社区项目： 主要技术架构： SpringBoot Spring SpringMVC MyBatis Redis Kakfa Elasticsearch Spring Security Spring Actator 基于SpringBoot的社区平台，实现了牛客网讨论区的功能。实现了邮箱注册...
基于SpringBoot的仿牛客论坛源码.zip
05-21
开发环境 构建工具：Apache Maven 集成开发工具：IntelliJ IDEA 数据库：MySQL、Redis 应用服务器：Apache Tomcat 版本控制工具：Git 软件架构 基础功能 邮箱设置 启用客户端SMTP服务 Spring Email： ——导入jar包...
仿牛客博客项目源码（有部分功能没有实现） https://gitee.com/xudahu/community
05-25
本项目名为"仿牛客博客"，是一个基于Java技术栈实现的开源项目，可以从Gitee平台上的链接<https://gitee.com/xudahu/community>获取源代码。虽然该项目可能未实现全部功能，但它仍能为我们提供一个学习和实践Java ...
Java项目性能优化
lgleje的博客
03-14 925
Java项目性能优化的目标是提高系统的响应速度、减少资源消耗、提高用户体验等，以达到更好的系统性能和更高的效率。Java项目性能优化是提高Java项目性能和效率的重要手段，可以从代码优化、数据库优化、网络优化等多个方面入手。在Java语言中，循环语句是常用的语句之一，但如果循环过程中存在过多的计算和判断，则会影响系统性能。在Java项目中，可以使用缓存技术来缓存数据库中的数据，以便下次访问时可以直接从缓存中获取数据，而不需要再次访问数据库。网络协议是通信的基础，优化网络协议可以提高通信的效率。
仿牛客网社区项目 全栈总结
qq_50209297的博客
02-08 1378
仿牛客网社区项目总结 第八章
仿牛客社区项目描述
qq_35484331的博客
05-30 6433
仿牛客社区项目描述1. 权限模块1.1 注册1.2 登录 本项目是一个校内互动交流平台，主要涉及模块有权限模块、帖子模块、性能模块、通知模块、搜索模块。主要使用的技术有SpringBoot，SpringMVC，MyBatis，MySQL，Redis，Kafka。 权限模块主要实现了注册登录和权限管理等功能。 帖子模块主要实现了发帖，评论和私信等功能。 性能模块使用Redis实现点赞，关注和网站数据统计等功能。 通知模块使用Kafka实现系统通知功能。 搜索模块使用Elasticsearch实现帖子搜索功能
仿牛客社区——开发社区搜索功能
zssxcj的博客
05-24 544
将帖子保存至Elasticsearch服务器。- 从Elasticsearch服务器删除帖子。- 从Elasticsearch服务器搜索帖子。
仿牛客网社区项目总结 第四章
qq_50209297的博客
01-26 436
仿牛客网社区项目总结 第四章
仿牛客项目（三）-- 社区核心功能
weixin_51930617的博客
09-22 363
牛客项目第三章的内容：前缀树和发私信
仿牛客网社区项目总结 第二章
qq_50209297的博客
12-28 701
仿牛客网社区项目总结 第二章
仿牛客网社区 部分代码逐行精读
qq_50209297的博客
04-13 609
一行行看懂项目代码
仿牛客项目kafka
08-29
在仿牛客项目中使用Kafka可以实现消息的异步处理和分布式架构。 使用Kafka的第一步是创建一个主题(topic)，主题既是消息的类别，也是消息在Kafka中的存储位置。可以使用命令行工具kafka-topics.bat来创建主题。例如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值