黑马程序员redis实战篇

已于 2022-09-10 19:53:43 修改
阅读量1.4k 收藏 2
点赞数
分类专栏： 黑马程序员redis 文章标签： redis
于 2022-08-23 22:30:27 首次发布
本文为博主原创文章，未经博主允许不得转载
本文链接：https://blog.csdn.net/qq_46198929/article/details/126494165
版权

文章目录

黑马点评项目

1.实现发送短信验证码功能

controller层

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {
@Resource
    private IUserService userService;
    /**
     * 发送手机验证码
     */
    @PostMapping("code")
    public Result sendCode(@RequestParam("phone") String phone, HttpSession session) {
        // TODO 发送短信验证码并保存验证码
        return userService.sendCode(phone,session);
    }
}
    

public interface IUserService extends IService<User> {

    Result sendCode(String phone, HttpSession session);
}

@Slf4j
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {

    @Override
    public Result sendCode(String phone, HttpSession session) {
        //1校验手机号
        if (RegexUtils.isPhoneInvalid(phone)) {
            //2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误");
        }

        //3.符合，生成验证码
        String code = RandomUtil.randomNumbers(6);

        //4.保存验证码到session
        session.setAttribute("code",code);
        //5.发送验证码
        log.debug("发送短信验证码成功，验证码：{}",code);
        return Result.ok();
    }
}

2.实现短信验证码登录和注册功能

@PostMapping("/login")
    public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session){
        // TODO 实现登录功能
        return userService.login(loginForm,session);
    }

public interface IUserService extends IService<User> {
    Result login(LoginFormDTO loginForm, HttpSession session);
}

@Slf4j
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
@Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        //1.校验手机号
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            //2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误");
        }
        //3.从session获取验证码并校验
        Object cacheCode= session.getAttribute("code");
        String code = loginForm.getCode();
        if(cacheCode==null||!cacheCode.toString().equals(code)){
            //不一致，报错
            return Result.fail("验证码错误");
        }

        //4.一致，根据手机号查询用户
        User user = query().eq("phone", phone).one();

        //5.判断用户是否存在
        if (user==null) {
            //6.不存在，创建用户并保存
            user=createUserWithPhone(phone);
        }


        //7.保存用户信息到session中
        session.setAttribute("user",user);
        return Result.ok();
    }

    private User createUserWithPhone(String phone) {
        //1.创建用户
        User user=new User();
        user.setPhone(phone);
        user.setNickName("hmdp"+RandomUtil.randomString(10));
        //2.保存用户
        save(user);
        return user;
    }
}

3.实现登录校验拦截器

拦截器

package com.hmdp.utils;

import com.hmdp.dto.UserDTO;
import com.hmdp.entity.User;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.获取session
        HttpSession session = request.getSession();
        //2.获取session中的用户
        Object user = session.getAttribute("user");
        //3.判断用户是否存在
        if (user==null) {
            //4.不存在，拦截,返回401状态码
            response.setStatus(401);
            return false;
        }

        //5.存在，保存用户信息到ThreadLocal
        UserHolder.saveUser((User) user);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserHolder.removeUser();
    }
}

配置拦截

package com.hmdp.config;

import com.hmdp.utils.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor()).
                excludePathPatterns(
                        "/user/code",
                        "/user/login",
                        "/blog/hot",
                        "/shop/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/voucher/**"
                );
    }
}

@GetMapping("/me")
    public Result me(){
        // TODO 获取当前登录的用户并返回
        User user = UserHolder.getUser();

        return Result.ok(user);
    }

4.隐藏用户敏感信息

1.session.setAttribute(“user”, BeanUtil.copyProperties(user, UserDTO.class));
2.UserHolder.saveUser((UserDTO) user);
3.import com.hmdp.dto.UserDTO;

public class UserHolder {
private static final ThreadLocal tl = new ThreadLocal<>();

public static void saveUser(UserDTO user){
    tl.set(user);
}

public static UserDTO getUser(){
    return tl.get();
}

public static void removeUser(){
    tl.remove();
}

}

5.Redis代替session的业务流程

public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result sendCode(String phone, HttpSession session) {
        //1校验手机号
        if (RegexUtils.isPhoneInvalid(phone)) {
            //2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误");
        }

        //3.符合，生成验证码
        String code = RandomUtil.randomNumbers(6);

        //4.保存验证码到redis
        stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY+phone,code,3,TimeUnit.MINUTES);


        //5.发送验证码
        log.debug("发送短信验证码成功，验证码：{}",code);
        return Result.ok();
    }


    @Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        //1.校验手机号
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            //2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误");
        }
        //3.从redis获取验证码并校验
        String cacheCode= stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY+phone);
        String code = loginForm.getCode();
        if(cacheCode==null||!cacheCode.equals(code)){
            //不一致，报错
            return Result.fail("验证码错误");
        }

        //4.一致，根据手机号查询用户
        User user = query().eq("phone", phone).one();

        //5.判断用户是否存在
        if (user==null) {
            //6.不存在，创建用户并保存
            user=createUserWithPhone(phone);
        }


        //7.保存用户信息到redis中
        //7.1随机生成token，作为登录令牌
        String token= UUID.randomUUID().toString(true);

        //7.2将User对象转为Hash存储
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
        Map<String, Object> userMap = BeanUtil.beanToMap(userDTO,new HashMap<>(),
                CopyOptions.create()
                .setIgnoreNullValue(true)
                .setFieldValueEditor((fieldName,fieldValue)->fieldValue.toString()));
        //7.3存储
        String tokenKey=LOGIN_USER_KEY+token;
        stringRedisTemplate.opsForHash().putAll(tokenKey,userMap);
        //7.4设置token有效期

        stringRedisTemplate.expire(tokenKey,30,TimeUnit.MINUTES);
        //8.返回token
        return Result.ok(token);
    }

    private User createUserWithPhone(String phone) {
        //1.创建用户
        User user=new User();
        user.setPhone(phone);
        user.setNickName("hmdp"+RandomUtil.randomString(10));
        //2.保存用户
        save(user);
        return user;
    }
}


package com.hmdp.utils;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.hmdp.dto.UserDTO;
import com.hmdp.entity.User;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.security.Key;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class LoginInterceptor implements HandlerInterceptor {

    private StringRedisTemplate stringRedisTemplate;

    
    
    public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }
    
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.获取请求头中的token
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {
            //不存在，拦截,返回401状态码
            response.setStatus(401);
            return false;
        }
        //2.基于token获取redis中的用户
        String key=RedisConstants.LOGIN_USER_KEY + token;
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);

        //3.判断用户是否存在
        if (userMap.isEmpty()) {
            //4.不存在，拦截,返回401状态码
            response.setStatus(401);
            return false;
        }
        //5.将查询的Hash数据转化为UserDTO对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        //6.存在，保存用户信息到ThreadLocal
        UserHolder.saveUser(userDTO);

        //7.刷新token有效期
        stringRedisTemplate.expire(key,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
        //8.放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //移除用户
        UserHolder.removeUser();
    }
}


import com.hmdp.utils.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor(stringRedisTemplate)).
                excludePathPatterns(
                        "/user/code",
                        "/user/login",
                        "/blog/hot",
                        "/shop/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/voucher/**"
                );
    }
}

解决状态登录刷新的问题

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.hmdp.dto.UserDTO;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class RefreshTokenInterceptor implements HandlerInterceptor {

    private StringRedisTemplate stringRedisTemplate;



    public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.获取请求头中的token
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {
            return true;
        }
        //2.基于token获取redis中的用户
        String key=RedisConstants.LOGIN_USER_KEY + token;
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);

        //3.判断用户是否存在
        if (userMap.isEmpty()) {
            //4.不存在，拦截,返回401状态码
            return true;
        }
        //5.将查询的Hash数据转化为UserDTO对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        //6.存在，保存用户信息到ThreadLocal
        UserHolder.saveUser(userDTO);

        //7.刷新token有效期
        stringRedisTemplate.expire(key,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
        //8.放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //移除用户
        UserHolder.removeUser();
    }
}


import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.hmdp.dto.UserDTO;
import com.hmdp.entity.User;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.security.Key;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class LoginInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.判断是否需要拦截（ThreadLocal中是否有用户）
        if(UserHolder.getUser()==null){
            response.setStatus(401);
            return false;
        }
        //有用户，则放行
        return true;
    }
}


import com.hmdp.utils.LoginInterceptor;
import com.hmdp.utils.RefreshTokenInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //登录拦截器
        registry.addInterceptor(new LoginInterceptor()).
                excludePathPatterns(
                        "/user/code",
                        "/user/login",
                        "/blog/hot",
                        "/shop/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/voucher/**"
                ).order(1);
        //token刷新的拦截器
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
    }
}

添加商户缓存

@GetMapping("/{id}")
    public Result queryShopById(@PathVariable("id") Long id) {
        return shopService.queryById(id);
    }

public interface IShopService extends IService<Shop> {

    Result queryById(Long id);
}

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.hmdp.dto.Result;
import com.hmdp.entity.Shop;
import com.hmdp.mapper.ShopMapper;
import com.hmdp.service.IShopService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 虎哥
 * @since 2021-12-22
 */
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public Result queryById(Long id) {
        //1.从redis查询商铺缓存
        String key="cache:shop:" + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
        //3.存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //4.不存在，根据id查询数据库
        Shop shop = getById(id);
        //5.不存在，返回错误
        if (shop==null) {
            return Result.fail("店铺不存在");
        }

        //6.存在，写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop));

        //7.返回
        return Result.ok(shop);
    }
}

缓存更新策略

实现商铺缓存与数据库的双写一致

stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),30L, TimeUnit.MINUTES);

@Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public Result queryById(Long id) {
        //1.从redis查询商铺缓存
        String key="cache:shop:" + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
        //3.存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //4.不存在，根据id查询数据库
        Shop shop = getById(id);
        //5.不存在，返回错误
        if (shop==null) {
            return Result.fail("店铺不存在");
        }

        //6.存在，写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),30L, TimeUnit.MINUTES);

        //7.返回
        return Result.ok(shop);
    }

@PutMapping
    public Result updateShop(@RequestBody Shop shop) {
        // 写入数据库
        return shopService.update(shop);
    }

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

@Resource
    private StringRedisTemplate stringRedisTemplate;

 @Override
    @Transactional
    public Result update(Shop shop) {
        Long id = shop.getId();
        if(id==null){
            return Result.fail("店铺id不能为空");
        }

        //1.更新数据库
        updateById(shop);
        //2.删除缓存
        stringRedisTemplate.delete(CACHE_SHOP_KEY+id);
        return Result.ok();
    }
}

解决商铺查询的缓存穿透问题

在这里插入图片描述
将

if (shop==null) {

            return Result.fail("店铺不存在");
}

改为

if (shop==null) {
            //将空值写入redis
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL, TimeUnit.MINUTES);
            return Result.fail("店铺不存在");
}

添加一段

if (shopJson!=null) {
            //返回一个错误信息
            return Result.fail("店铺信息不存在");
}

完整代码

public Result queryById(Long id) {
        //1.从redis查询商铺缓存
        String key="cache:shop:" + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
        //3.存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //判断命中的是否是空值
        if (shopJson!=null) {
            //返回一个错误信息
            return Result.fail("店铺信息不存在");
        }


        //4.不存在，根据id查询数据库
        Shop shop = getById(id);
        //5.不存在，返回错误
        if (shop==null) {
            //将空值写入redis
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL, TimeUnit.MINUTES);
            return Result.fail("店铺不存在");
        }

        //6.存在，写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),30L, TimeUnit.MINUTES);

        //7.返回
        return Result.ok(shop);
    }

缓存雪崩问题及解决思路

在这里插入图片描述

缓存击穿问题及解决方案

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

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public Result queryById(Long id) {
        //缓存穿透
        //Shop shop = queryWithPassThrough(id);
        //互斥锁解决缓存击穿
        Shop shop = queryWithMutex(id);
        if(shop==null){
            return Result.fail("店铺不存在");
        }
        //7.返回
        return Result.ok(shop);
    }

	public Shop queryWithMutex(Long id){
        //1.从redis查询商铺缓存
        String key="cache:shop:" + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            //3.存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }
        //判断命中的是否是空值
        if (shopJson!=null) {
            //返回一个错误信息
            return null;
        }
        //4.实现缓存重建
        //4.1获取互斥锁
        String lockKey="lock:shop:"+id;
        Shop shop = null;
        try {
            boolean isLock = tryLock(lockKey);
            //4.2判断是否获取成功
            if(!isLock){
                //4.3失败，则休眠并重试
                Thread.sleep(50);
                return queryWithMutex(id);
            }

            //4.4成功，根据id查询数据库
            shop = getById(id);
            Thread.sleep(200);
            //5.不存在，返回错误
            if (shop==null) {
                //将空值写入redis
                stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }

            //6.存在，写入redis
            stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),30L, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            //7.释放互斥锁
            unlock(lockKey);
        }

        //8.返回
        return shop;
    }


}

在这里插入图片描述

漫漫人生路^_^
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马---Redis实战篇
qq_52714234的博客
11-19 951
redis
黑马Redis学习——实战篇（2）
Ydin00的博客
08-22 901
黑马Redis课程学习实战篇（2）
黑马点评项目个人笔记+项目优化调整
最新发布
m0_64897866的博客
05-01 1444
博客须知 本篇博客内容来源与黑马点评项目实战篇-16.用户签到-实现签到功能_哔哩哔哩_bilibili，作者对视频内容进行了整合，由于记笔记时图片使用的是本地路径，所以导致博客的图片无法正常显示，如果有图片需求可以下载上方的pdf 须知 该项目主要是通过Redis实现的，基本上把Redis的使用场景学了个遍 封装Redis工具类和生成分布式id需要重点学习一下，这两块的思路很好 本篇博客不包含课程中的自研分布式锁的内容，因为我以前跟着周阳的redis课程和谷粒商城自研过两遍了 Redis版本的消息队列
黑马程序员redis详细笔记（基础篇、实战篇）
weixin_50523986的博客
08-16 1679
RedisTemplate可以接收任意Object作为值写入Redis：只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的：可读性差、内存占用较大可以自定义RedisTemplate的序列化方式，代码如下：// redis配置类@Bean// 1 创建RedisTemplate对象// 2 设置连接工厂// 3 创建JSON序列化工具// 4.1 设置Key的序列化 key和hashkey采用String序列化。
Redis笔记-实战篇(黑马视频教程)
m0_51512780的博客
06-20 2654
黑马Redis视频教程实战篇笔记
Redis项目实战——黑马点评7w+字笔记【2023.10】
Kixuan214的博客
10-17 1644
⿊马点评是⼀个⼤量使⽤Redis的项⽬，该项⽬的功能类似⼤众点评。短信登录：使用redis共享session来实现商户查询缓存：理解缓存击穿，缓存穿透，缓存雪崩等问题优惠券秒杀：Redis的计数器功能， 结合Lua完成高性能的redis操作，同时学会Redis分布式锁的原理，包括Redis的三种消息队列好友关注：基于Set集合的关注、取消关注，共同关注等等功能附近的商户：利用Redis的GEOHash来完成对于地理坐标的操作用户签到：使用Redis的BitMap数据统计功能。
根据黑马程序员的 redis 课程自学做的 redis 笔记，备份一下
02-20
黑马程序员的 Redis 课程提供了详细的讲解和实战指导，建议结合实际项目需求，深入学习并实践 Redis 的使用，提升开发效率和系统性能。 在使用 Redis 时，要充分考虑数据量、内存占用、持久化策略等因素，以实现...
2018年下半年黑马程序员课改之后最新Java企业级项目—学成在线学习平台。包含所有的资料和代码
03-27
本项目基于Java技术栈，是2018年下半年黑马程序员进行课程改革后推出的企业级实战项目，名为“学成在线学习平台”。该平台旨在模拟真实的在线教育环境，为用户提供丰富的学习资源和互动交流的空间，同时也为企业级...
黑马程序员面试宝典(java).7z
11-04
《黑马程序员面试宝典》是针对Java开发人员的一份综合性的面试准备资料，它涵盖了Java全栈开发中的关键知识点，并且特别强调了在面试中可能会遇到的问题和解答。这份资源包含了一份超过500页的企业面试真题集，旨在...
Java黑马商城代码文档数据库
12-05
在【描述】中反复提及“黑马课程最后一个大项目”，这表明它可能是黑马程序员培训机构的一个高级课程项目，用于总结和巩固学员在整个课程中的所学知识。这个项目可能涵盖了从前端界面到后端服务的完整流程，包括用户...
黑马点评-完整代码资源
12-15
【描述】"黑马点评-完整代码资源"描述简洁，暗示了这是一个与黑马程序员平台相关的一系列代码实例，可能涵盖了课程中的实战项目、练习题解以及可能的课后作业。这个资源包对于那些希望通过动手实践来提升编程技能的...
黑马程序员 Redis 基础教程
weixin_51271263的博客
02-13 247
黑马程序员 Redis 基础教程
【黑马程序员】Redis学习笔记005：企业级解决方案
诗和远方，代码和你
07-24 169
缓存穿透是访问了不存在的数据，跳过了合法数据的redis数据缓存阶段，每次访问数据库，导致对数据库服务器造成压力。通常此类数据的出现量是一个较低的值，当出现此类情况以毒攻毒，并即时报警。应对策略应该在临时预案防范方面多做文章无论是黑名单还是白名单，都是对整体系统的压力，警报解除后尽快移除。...
【黑马程序员】Redis学习笔记001：Redis简介+五种基本数据类型
诗和远方，代码和你
07-24 959
即Not-OnlySQL（泛指非关系型的数据库），作为关系型数据库的补充。应用对于海量用户和海量数据前提吓得数据处理问题。可扩容，可伸缩大数据量下得高性能灵活得数据模型高可用RedismemcacheHBaseMongoDB作为缓存使用原始业务功能设计秒杀618活动双十一活动排队购票运营平台监控到的突发高频访问数据突发市政要闻，被强势关注围观高频、复杂的统计数据在线人数投票排行榜附加功能系统功能优化或升级单服务器升级集群。...............
黑马程序员Redis学习笔记--Redis基础篇
qq_33888850的博客
03-26 456
SQLNoSQL数据结构结构化(Structured)非结构化数据关联关联的(Relational)无关联的查询方式SQL查询非SQL事务特性ACIDBASE存储方式磁盘内存扩展性垂直水平使用场景1）数据结构固定2)对一致性、安全性要求不高1)数据结构不固定2)相关业务对数据安全性、一致性要求较高3）对性能要求存储方式关系型数据库基于磁盘进行存储，会有大量的磁盘IO，对性能有一定影响。
Redis基础项目：黑马程序员
qq_59740031的博客
06-11 1295
Redis基础项目:黑马程序员
黑马程序员Redis学习笔记--Redis实战篇
qq_33888850的博客
03-27 901
短信登录这部分会使用Redis共享session来实现但其实我在之前的瑞吉外卖的项目优化部分就做过了，用Redis替换session来存储邮箱验证码商户查询缓存这部分要理解缓存击穿，缓存穿透，缓存雪崩等问题，对于这些概念的理解不仅仅是停留在概念上，更是能在代码中看到对应的内容优惠卷秒杀这部分我们可以学会Redis的计数器功能，结合Lua(之前一直想学Lua然后写饥荒mod)完成高性能的Redis操作，同时学会Redis分布式锁的原理，包括Redis的三种消息队列附近的商户。
Redis
黑马程序员广州中心的专栏
04-27 181
1.1.什么是NOSQL NoSQL(NoSQL = Not Only SQL)，意即“不仅仅是SQL”，是一项全新的数据库理念，泛指非关系型的数据库。 随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难...
Redis学习笔记整理（黑马程序员视频课程）
fuzzy_cat的博客
06-03 1450
目录 Redis简介 NoSQL Redis Redis的应用 Redis 的数据存储类型介绍 String string类型数据的操作 hash hash类型数据的操作 list list类型数据的操作 set set类型数据的操作 sorted_set sorted_set类型数据的操作 key通用操作 key特征 key基本操作 key扩展操作（时效性控制） key扩展操作（查询模式） key其他操作 数据库通用操作 db相关操作 Jedis..
黑马程序员redis
10-31
黑马程序员是一家专业的IT职业教育机构，提供各种编程语言和技术的在线课程。其中，他们的Redis课程是一门非常受欢迎的课程，主要介绍了Redis的基本概念、使用方法和应用场景等内容。通过学习该课程，学生可以掌握Redis的核心知识和实际应用技巧，从而提高自己的技术水平和竞争力。 关于引用中提到的安全性问题，确实仅仅靠黑名单是不能完全解决安全问题的。因为黑名单只能列举出已知的危险IP地址或用户，而无法预防未知的攻击行为。因此，为了提高应用的安全性，我们需要采用更为苛刻的访问验证方式，例如白名单，只允许特定的用户或IP地址访问应用。这样可以有效地减少应用被攻击的风险。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值