用户上下文打通+本地缓存Guava

最新推荐文章于 2024-09-10 13:04:49 发布
最新推荐文章于 2024-09-10 13:04:49 发布
阅读量2.4k 收藏 36
点赞数 45
分类专栏： 社区项目 文章标签： 缓存 guava 上下文 Java 微服务 ThreadLocal
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64637029/article/details/140950481
版权

文章目录

🌞 Sun Frame：SpringBoot 的轻量级开发框架（个人开源项目推荐）

Sun Frame Banner

轻松高效的现代化开发体验

Sun Frame 是我个人开源的一款基于 SpringBoot 的轻量级框架，专为中小型企业设计。它提供了一种快速、简单且易于扩展的开发方式。

我们的开发文档记录了整个项目从0到1的任何细节，实属不易，请给我们一个Star！🌟
您的支持是我们持续改进的动力。

🌟 亮点功能

  • 组件化开发：灵活选择，简化流程。
  • 高性能：通过异步日志和 Redis 缓存提升性能。
  • 易扩展：支持多种数据库和消息队列。

📦 spring cloud模块概览

  • Nacos 服务：高效的服务注册与发现。
  • Feign 远程调用：简化服务间通信。
  • 强大网关：路由与限流。

常用工具

  • 日志管理：异步处理与链路追踪。
  • Redis 集成：支持分布式锁与缓存。
  • Swagger 文档：便捷的 API 入口。
  • 测试支持：SpringBoot-Test 集成。
  • EasyCode：自定义EasyCode模板引擎，一键生成CRUD。

🔗 更多信息

1.设计

1.链路流程

img

2.详细设计

img

2.网关过滤器获取唯一标识放到Header

1.LoginFilter.java
package com.sunxiansheng.club.gateway.filter;

import cn.dev33.satoken.stp.SaTokenInfo;
import cn.dev33.satoken.stp.StpUtil;
import com.alibaba.cloud.commons.lang.StringUtils;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

/**
 * Description: 网关过滤器，在用户登录之后再次请求网关就会携带token，可以通过网关过滤器通过redis获取用户的唯一标识然后放到Header中传递到后端
 * 过滤器的优先级是比配置文件中配置的路由要低
 * @Author sun
 * @Create 2024/6/15 15:28
 * @Version 1.0
 */
@Component
@Slf4j
public class LoginFilter implements GlobalFilter {

    @Override
    @SneakyThrows
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 获取请求
        ServerHttpRequest request = exchange.getRequest();
        // 获取一个很全的东西
        ServerHttpRequest.Builder mutate = request.mutate();
        // 获取url
        String url = request.getURI().getPath();
        log.info("网关过滤器：用户请求的url：" + url);
        // 如果发现是用户登录的请求，直接放行，注意先走的网关配置，所以前缀会被删除
        if (url.equals("/user/doLogin")) {
            return chain.filter(exchange);
        }
        // 通过sa-token框架获取用户的tokenInfo，可以通过这个对象来获取用户信息
        SaTokenInfo tokenInfo = StpUtil.getTokenInfo();
        // 根据token获取用户的唯一标识
        String loginId = (String) tokenInfo.getLoginId();
        if (StringUtils.isBlank(loginId)) {
            log.info("网关过滤器获取用户唯一标识失败！");
        }
        // 如果到这了，就说明已经获取到了用户的唯一标识，将其放到Header中
        mutate.header("loginId", loginId);
        // 将携带了用户唯一标识的request发送到其他微服务模块
        return chain.filter(exchange.mutate().request(mutate.build()).build());
    }
}
2.SubjectCategoryController.java 测试

image-20240615155811919

3.进行测试
1.用户登录
2.携带token访问后端接口

image-20240615161700008

3.基于ThreadLocal实现上下文传递

1.目录结构

image-20240615172226319

2.ThreadLocal的工具类 LoginContextHolder.java
package com.sunxiansheng.subject.application.context;

import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Description: 上下文对象（ThreadLocal）
 * @Author sun
 * @Create 2024/6/15 16:27
 * @Version 1.0
 */
public class LoginContextHolder {

    // 这个ThreadLocal持有一个Map
    private static final InheritableThreadLocal<Map<String, Object>> THREAD_LOCAL
            = new InheritableThreadLocal<>();

    /**
     * 为ThreadLocal持有的Map设值
     * @param key
     * @param val
     */
    public static void set(String key, Object val) {
        Map<String, Object> map = getThreadLocalMap();
        map.put(key, val);
    }

    /**
     * 从ThreadLocal持有的Map取值
     * @param key
     * @return
     */
    public static Object get(String key) {
        Map<String, Object> map = THREAD_LOCAL.get();
        return map.get(key);
    }

    /**
     * 清除ThreadLocal
     */
    public static void remove() {
        THREAD_LOCAL.remove();
    }

    /**
     * 初始化一个ThreadLocal持有的Map，要保证这个Map是单例的
     * @return
     */
    public static Map<String, Object> getThreadLocalMap() {
        // 获取到ThreadLocal的Map
        Map<String, Object> map = THREAD_LOCAL.get();
        // 如果是空的再创建一个Map，然后放进去
        if (Objects.isNull(map)) {
            map = new ConcurrentHashMap<>();
            THREAD_LOCAL.set(map);
        }
        // 放到ThreadLocal中
        return map;
    }

    // 以下为获取用户信息的方法
    public static String getLoginId() {
        return (String) getThreadLocalMap().get("loginId");
    }


}
3.拦截器将网关传递的信息放到 LoginInterceptor.java
package com.sunxiansheng.subject.application.interceptor;

import com.sunxiansheng.subject.application.context.LoginContextHolder;
import org.springframework.web.servlet.HandlerInterceptor;

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

/**
 * Description: 处理用户上下文的拦截器
 * @Author sun
 * @Create 2024/6/15 16:20
 * @Version 1.0
 */
public class LoginInterceptor implements HandlerInterceptor {

    /**
     * 当请求到这里了，就说明，网关已经将用户的loginId放到了Header里了
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String loginId = request.getHeader("loginId");
        // 将loginId放到ThreadLocal里面
        LoginContextHolder.set("loginId", loginId);
        return true;
    }


    /**
     * 在操作结束后清除ThreadLocal，因为如果线程复用并且没清除，这个ThreadLocal还会存在，造成数据污染
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        LoginContextHolder.remove();
    }
}
4.配置类将自定义拦截器注册 GlobalConfig.java

image-20240615172339191

5.LoginUtil.java
package com.sunxiansheng.subject.application.util;

import com.sunxiansheng.subject.application.context.LoginContextHolder;

/**
 * Description: 用户登录的util
 * @Author sun
 * @Create 2024/6/15 17:12
 * @Version 1.0
 */
public class LoginUtil {

    /*
    获取loginId
     */
    public static String getLoginId() {
        return LoginContextHolder.getLoginId();
    }
}
6.测试 SubjectCategoryController.java

image-20240615172455473

image-20240615172514330

4.OpenFeign的使用

1.目录结构
1.sun-club-auth

image-20240616134039744

2.sun-club-auth-api引入依赖
<dependencies>
    <!-- OpenFeign依赖 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
        <version>3.0.7</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-loadbalancer</artifactId>
        <version>3.0.6</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.16</version>
    </dependency>
</dependencies>
3.UserFeignService.java 将controller层的接口暴露
package com.sunxiansheng.auth.api;

import com.sunxiansheng.auth.entity.AuthUserDTO;
import com.sunxiansheng.auth.entity.Result;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * Description: 用户服务feign
 * @Author sun
 * @Create 2024/6/16 13:20
 * @Version 1.0
 */
@FeignClient("sub-club-auth") // 服务名
public interface UserFeignService {

    @RequestMapping("/user/getUserInfo")
    public Result<AuthUserDTO> getUserInfo(@RequestBody AuthUserDTO authUserDTO);
}
4.AuthUserDTO.java 从controller剪切到api层
5.Result.java和ResultCodeEnum.java从common包中剪切过来
6.sun-club-auth-application-controller 引入api层的依赖，DTO和Result都使用api层的
<!-- 引入api层 -->
<dependency>
    <groupId>com.sun.club</groupId>
    <artifactId>sun-club-auth-api</artifactId>
    <version>1.0-SNAPSHOT</version>
    <scope>compile</scope>
</dependency>
7.sun-club-subject微服务调用sun-club-auth微服务
1.sun-club-infra引入sun-club-auth微服务的api包
<!-- 引入鉴权模块的api层，用于微服务间的调用 -->
<dependency>
    <groupId>com.sun.club</groupId>
    <artifactId>sun-club-auth-api</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>
2.在sun-club-infra模块的UserRpc.java进行rpc调用
package com.sunxiansheng.subject.infra.rpc;

import com.sunxiansheng.auth.api.UserFeignService;
import com.sunxiansheng.auth.entity.AuthUserDTO;
import com.sunxiansheng.auth.entity.Result;
import com.sunxiansheng.subject.infra.eneity.UserInfo;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * Description:
 * @Author sun
 * @Create 2024/6/16 13:45
 * @Version 1.0
 */
@Component
public class UserRpc {

    // 直接注入FeignService
    @Resource
    private UserFeignService userFeignService;

    /**
     * 根据用户名来获取用户信息
     * @param userName
     * @return
     */
    public UserInfo getUserInfo(String userName) {
        AuthUserDTO authUserDTO = new AuthUserDTO();
        authUserDTO.setUserName(userName);
        // 向调用方法一样远程调用auth微服务的接口并得到结果
        Result<AuthUserDTO> result = userFeignService.getUserInfo(authUserDTO);
        // 创建一个自己的eneity用于存放data
        UserInfo userInfo = new UserInfo();

        // 没有成功响应，直接返回一个空的对象
        if (!result.getSuccess()) {
            return userInfo;
        }
        // 成功获取信息，将获取到的信息放到自己定义的Entity中
        // 获取到data
        AuthUserDTO data = result.getData();
        // 将data中的数据封装到自己定义的entity中
        userInfo.setUserName(data.getUserName());
        userInfo.setNickName(data.getNickName());
        return userInfo;
    }
}
3.创建接受信息的entity，UserInfo.java
package com.sunxiansheng.subject.infra.eneity;

import lombok.Data;

/**
 * Description:
 * @Author sun
 * @Create 2024/6/16 13:47
 * @Version 1.0
 */
@Data
public class UserInfo {

    private String userName;

    private String nickName;
}
4.在启动类加注解，启动Feign

image-20240616153405974

5.测试TestFeignController.java
package com.sunxiansheng.subject.application.controller;

import com.sunxiansheng.subject.infra.eneity.UserInfo;
import com.sunxiansheng.subject.infra.rpc.UserRpc;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * Description: 题目分类控制器
 * @Author sun
 * @Create 2024/5/24 9:33
 * @Version 1.0
 */
@RestController
@RequestMapping("/subject/category")
@Slf4j
public class TestFeignController {

    @Resource
    private UserRpc userRpc;

    @RequestMapping("/testFeign")
    public void testFeign() {
        UserInfo userInfo = userRpc.getUserInfo("鸡翅");
        log.info("testFeign:" + userInfo);
    }
}
6.测试

image-20240616145116795

image-20240616145124958

5.OpenFeign拦截器打通微服务上下文（由调用方来写）

1.FeignRequestInterceptor.java 将唯一标识放到Header中传递到其他微服务
package com.sunxiansheng.subject.application.interceptor;

import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Objects;

/**
 * Description: feign的拦截器，当使用feign调用另一个微服务时需要将用户的唯一标识放到Header中
 * @Author sun
 * @Create 2024/6/16 15:01
 * @Version 1.0
 */
@Component
public class FeignRequestInterceptor implements RequestInterceptor {

    @Override
    public void apply(RequestTemplate requestTemplate) {
        // 首先，从网关过来的请求，在Header中一定存着用户的唯一标识，从请求中获取
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = requestAttributes.getRequest();
        if (Objects.nonNull(request)) {
            // 从请求获取唯一标识
            String loginId = request.getHeader("loginId");
            if (StringUtils.isNotBlank(loginId)) {
                // 如果获得的标识不为空，就将其放到header中
                requestTemplate.header("loginId", loginId);
            }
        }

    }
}
2.FeignConfiguration.java 将拦截器注入容器
package com.sunxiansheng.subject.application.config;

import com.sunxiansheng.subject.application.interceptor.FeignRequestInterceptor;
import feign.RequestInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

/**
 * Description:
 * @Author sun
 * @Create 2024/6/16 15:12
 * @Version 1.0
 */
@Configuration
public class FeignConfiguration extends WebMvcConfigurationSupport {

    // 将Feign的拦截器注入进去
    @Bean
    public RequestInterceptor requestInterceptor() {
        return new FeignRequestInterceptor();
    }
}
3.在被调用方使用过滤器将用户唯一标识存到ThreadLocal（跟前面写过的一样）
1.目录结构

image-20240616153838689

2.ThreadLocal的工具类LoginContextHolder.java
package com.sunxiansheng.auth.application.context;

import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Description: 上下文对象（ThreadLocal）
 * @Author sun
 * @Create 2024/6/15 16:27
 * @Version 1.0
 */
public class LoginContextHolder {

    // 这个ThreadLocal持有一个Map
    private static final InheritableThreadLocal<Map<String, Object>> THREAD_LOCAL
            = new InheritableThreadLocal<>();

    /**
     * 为ThreadLocal持有的Map设值
     * @param key
     * @param val
     */
    public static void set(String key, Object val) {
        Map<String, Object> map = getThreadLocalMap();
        map.put(key, val);
    }

    /**
     * 从ThreadLocal持有的Map取值
     * @param key
     * @return
     */
    public static Object get(String key) {
        Map<String, Object> map = THREAD_LOCAL.get();
        return map.get(key);
    }

    /**
     * 清除ThreadLocal
     */
    public static void remove() {
        THREAD_LOCAL.remove();
    }

    /**
     * 初始化一个ThreadLocal持有的Map，要保证这个Map是单例的
     * @return
     */
    public static Map<String, Object> getThreadLocalMap() {
        // 获取到ThreadLocal的Map
        Map<String, Object> map = THREAD_LOCAL.get();
        // 如果是空的再创建一个Map，然后放进去
        if (Objects.isNull(map)) {
            map = new ConcurrentHashMap<>();
            THREAD_LOCAL.set(map);
        }
        // 放到ThreadLocal中
        return map;
    }

    // 以下为获取用户信息的方法
    public static String getLoginId() {
        return (String) getThreadLocalMap().get("loginId");
    }


}
3.自定义拦截器获取Header中的唯一标识，并放到ThreadLocal中 LoginInterceptor.java
package com.sunxiansheng.auth.application.interceptor;

import com.sunxiansheng.auth.application.context.LoginContextHolder;
import org.springframework.web.servlet.HandlerInterceptor;

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

/**
 * Description: 处理用户上下文的拦截器
 * @Author sun
 * @Create 2024/6/15 16:20
 * @Version 1.0
 */
public class LoginInterceptor implements HandlerInterceptor {

    /**
     * 当请求到这里了，就说明，网关已经将用户的loginId放到了Header里了
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String loginId = request.getHeader("loginId");
        // 将loginId放到ThreadLocal里面
        LoginContextHolder.set("loginId", loginId);
        return true;
    }


    /**
     * 在操作结束后清除ThreadLocal，因为如果线程复用并且没清除，这个ThreadLocal还会存在，造成数据污染
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        LoginContextHolder.remove();
    }
}
4.将拦截器注入容器 GlobalConfig.java

image-20240616154236431

5.UserController.java 测试获取调用方传来的唯一标识

image-20240616154256468

4.用户上下文整体流程测试
1.网关过滤器将唯一标识从redis中取出，放到Header，传到微服务模块

image-20240616154819177

2.Feign的调用微服务的登录拦截器，将唯一标识放到ThreadLocal中

image-20240616160615477

3.在调用Feign之前，进入Feign拦截器，将唯一标识放到Header中，传递给被调用方

image-20240616160721862

4.被调用方的登录拦截器，读取Header中的唯一标识，放到ThreadLocal中

image-20240616160801869

5.被调用方从ThreadLocal中可以获取到唯一标识

image-20240616160911141

6.本地缓存guava使用

1.SubjectCategoryDomainServiceImpl.java
/**
 * 注意：这里使用本地缓存的原因是分类和标签的改动不大
 * @param subjectCategoryBO
 * @return
 */
@Override
public List<SubjectCategoryBO> queryCategoryAndLabel(SubjectCategoryBO subjectCategoryBO) {
    // 构建一个本地缓存的key
    String cacheKey = "categoryAndLabel." + subjectCategoryBO.getId();
    // 根据缓存key来获取id对应的分类列表
    String content = localCache.getIfPresent(cacheKey);
    // 如果缓存中没有，则从数据库中查
    List<SubjectCategoryBO> subjectCategoryBOS = new LinkedList<>();
    if (StringUtils.isBlank(content)) {
        subjectCategoryBOS = getSubjectCategoryBOS(subjectCategoryBO.getId());
        // 将其放到本地缓存中
        localCache.put(cacheKey, JSON.toJSONString(subjectCategoryBOS));
    } else {
        // 如果缓存中有，则将其序列化然后返回
        subjectCategoryBOS = JSON.parseArray(content, SubjectCategoryBO.class);
    }
    return subjectCategoryBOS;
}
2.测试

image-20240616171528673

image-20240616171541514

3.本地缓存工具类
1.ListLocalCacheUtil.java
package com.sunxiansheng.subject.domain.util;

import com.alibaba.fastjson.JSON;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

/**
 * Description: List本地缓存工具类（guava）
 * @Author sun
 * @Create 2024/6/16 17:20
 * @Version 1.0
 */
@Component
public class ListLocalCacheUtil<V> {

    // 使用谷歌提供的本地缓存，value的类型是String，存什么数据直接序列化即可
    private Cache<String, String> localCache =
            CacheBuilder.newBuilder()
                    .maximumSize(5000)
                    .expireAfterWrite(10, TimeUnit.SECONDS)
                    .build();

    /**
     * 根据key来获取本地缓存中的value，如果有就直接获取，如果没有，就从db中查询
     * @param cacheKey 构建的本地缓存的key
     * @param clazz 要返回的类型
     * @param supplier 函数式接口，没有参数，返回值为DB查询结果
     * @return
     */
    public List<V> getResult(String cacheKey, Class<V> clazz, Supplier<List<V>> supplier) {
        // 要返回的list
        List<V> resultList = new LinkedList<>();
        // 根据key，获取本地缓存的内容
        String content = localCache.getIfPresent(cacheKey);
        if (StringUtils.isNotBlank(content)) {
            // 如果缓存中有，就将其序列化
            resultList = JSON.parseArray(content, clazz);
        } else {
            // 缓存中没有，List<V>作为返回值，交给数据库中查，具体逻辑交给函数式接口
            resultList = supplier.get();
            if (!CollectionUtils.isEmpty(resultList)) {
                // 如果从数据库查出来的不是空，就序列化，然后放到缓存中
                localCache.put(cacheKey, JSON.toJSONString(resultList));
            }
        }
        return resultList;
    }

}
2.使用方式
1.依赖注入

image-20240617121126924

2.使用
/**
 * 注意：这里使用本地缓存的原因是分类和标签的改动不大
 * @param subjectCategoryBO
 * @return
 */
@Override
public List<SubjectCategoryBO> queryCategoryAndLabel(SubjectCategoryBO subjectCategoryBO) {
    // 要查询的分类id
    Long categoryId = subjectCategoryBO.getId();
    // 构建一个本地缓存的key，结果是根据id查询，所以key也根据这个构建
    String cacheKey = "categoryAndLabel." + categoryId;
    // 使用本地缓存工具类，本地缓存中获取数据，如果没有再从数据库中获取，然后将其放到本地缓存中
    List<SubjectCategoryBO> subjectCategoryBOS = listLocalCacheUtil.getResult(cacheKey, SubjectCategoryBO.class,
            () -> {
                // 函数式接口，参数：空，返回值：List<SubjectCategoryBO>，对象逻辑：从db中查List<SubjectCategoryBO>，然后返回
                return getSubjectCategoryBOS(subjectCategoryBO.getId());
            });
    return subjectCategoryBOS;
}
3.测试

image-20240617121034988

S-X-S
关注
  • 45
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
AI电商导购Chatbot IM 消息框架系统的高可用、稳定性、安全性、高性能技术架构设计
程序员光剑
05-26 209
本文全面梳理了AI电商导购Chatbot IM消息框架的技术架构,重点探讨了其高可用性、稳定性、安全性、高性能等质量属性的设计要点,并给出了一些具体的技术方案和最佳实践。在算法层面,要在对话理解、检索、推荐等方面追求性能极致,不断尝试前沿模型;在工程层面,要在高可用、稳定性、安全性、高性能等质量属性方面狠下功夫,为算法赋能护航。
面试题
weixin_46597615的博客
06-12 416
面试题
【SpringBoot：实现上下文管理】
Glubin的博客
10-01 6625
所定义的上下文变量应具有高兼容性，支持存放比较复杂的数据，且方便读取。一般的实现方式是放置一个Map来实现。本文所实现的上下文，可存放变量，以及用户信息，我所使用的工程为了区分一般变量和业务变量，定义了两个存放变量的Map，一般使用一个Map就可以。定义上下文管理接口类，具体的管理逻辑在实现类中编写，上下文的具体变量也在实现类中编写。// 项目中定义的用户实体类 BaseCurrentUser getBaseCurrentUser();
第五阶段-第五阶段高性能分布式缓存Redis
无
06-01 1599
第五阶段 大型分布式系统缓存架构进阶 第一部分 Redis 快速实战 第一节 缓存原理与设计 1.1 缓存基本思想 1.11 缓存的使用场景 1.12 什么是缓存？ 1.13 大型网站中缓存的使用 1.2 常见缓存的分类 1.21 客户端缓存 1.22 网络端缓存 1.23 服务端缓存 1.3 缓存的优势与代价 1.31 使用缓存的优势 1.32 使用缓存的代价 1.4 缓存的读写模式 1.41 Cache Aside Pattern（常用） 1.42 Read/Write Through Pattern
分享一篇牛人的工作总结
smooth的博客
06-19 9989
转自http://www.ituring.com.cn/article/497377，让大家感受一下什么叫优秀的架构师，我比较喜欢在总结里大量构图（而且喜欢在excel、ppt中直接绘制拼接，不受专业绘图工具的约束），喜欢了就收藏，而且还和性能监控产品有关！ 正文内容： 掐指一算，从 OneAPM 离职也快一个月了，在 OneAPM 工作的种种，仿佛还像是在昨天。细数两年的工作经历，我很庆幸...
项目面试题
weixin_46597615的博客
06-12 376
项目面试题
gradle 指定springcloud 版本_Maven 程序员难道就不能快速上手 Gradle了吗？
weixin_39942785的博客
10-23 177
背景庖丁同学在混迹在古典互联网界多年，构建 Java 应用程序一直都是使用Apache Maven，mvn的那几个常用命令早已烂熟于心，在加上现代 IDE 越来越智能，应用程序的构建从来就不是事儿，但是惊喜总会出现，有一天，庖丁的工作性质发生了改变，眼前的构建工具清一色的都是 Gradle,庖丁一脸的懵逼，束手无策，难道Maven 程序员就不能快速上手 Gradle了吗？实战性或者战术性程序员这时...
java面试宝典-抱你过岸
qq_40500099的博客
10-19 1375
java面试手册
当前疫情下火爆的直播应用，你了解背后的技术架构吗？
凡是过往，皆为序章
05-08 872
这场疫情让线下零售降至冰点，但是却带火了直播应用。直播电商、直播教育等各类直播应用可谓赢得了历史性的机会，很多大众开始接受并认可这种新型应用的便利和价值，个人感觉随着5G的普及，『直播+垂直领域+精细化的私域流量』将会是互联网的一个大热点，迎来真正的红利期。 直播行业大概在10年多前就开始兴起了，秀场直播和游戏直播是PC时代比较成功的应用场景，直到16年，随着移动互联网的大规模普及，直播行业迎来...
《超大流量分布式系统架构解决方案》
welcome to 一点点 home
06-01 551
超大流量分布式系统架构解决方案
java应用提速(速度与激情)
阿里云技术
09-06 227
本文将阐述通过基础设施与工具的改进，实现从构建到启动全方面大幅提速的实践和理论。
大数据之路：阿里巴巴大数据实践
qq_27639777的博客
08-16 6379
第1章：总述 如果说在IT时代是以自我控制、自我管理为主，那么到了DT（Data Technology）时代，则是以服务大众、激发生产力为主。阿里巴巴大数据系统体系架构主要分为数据采集、数据计算、数据服务和数据应用四大层次。 第2章：日志采集 阿里巴巴的日志采集体系方案包括两大体系：Aplus.JS是Web端（基于浏览器）日志采集技术方案：UserTrack是APP端（无线客户端）日志采集技术方案。 2.1 浏览器的页面日志采集 浏览器的页面型产品／服务的日志采集可分为如下两大类。 页面浏览（展现）日志
谷粒商城の缓存篇
西岭千秋雪的博客
09-07 1131
谷粒商城项目实战缓存篇
Django缓存
brucexia的专栏
09-04 1672
为了方便起见，Django框架提供了不同级别的缓存粒度，既可以缓存特定视图的输出，也可以仅缓存难以生成的片段，甚至可以缓存整个站点。在本地安装好Memcached后，还需要安装Memcached的绑定，最常见的两种Python Memcached绑定方式是python-memcached和pylibmc。当然，如果不使用数据库缓存后端，则无须为数据库缓存模型提供路由指令。这个命令将在数据库中创建一张表，该表的格式与Django的数据库缓存系统期望的格式相同，且该表的名称取自LOCATION。
缓存和数据库缓存有什么区别
weixin_57763462的博客
09-04 403
缓存通常是在应用层面进行管理的，它就像是应用的一个临时数据仓库，可以存储一些常用的数据，这样应用就可以直接从缓存中获取数据，而不用每次都去数据库里查询。而数据库缓存则是在数据库层面进行管理的，它主要存储的是数据库表中的数据块或查询结果，用来减少对磁盘的访问次数，提高数据库的查询效率。应用缓存的管理通常是由应用开发者来负责的，他们可以根据应用的具体需求来定制缓存策略，比如缓存的数据结构、过期时间等。总的来说，缓存和数据库缓存都是为了提高数据的读取效率而设计的，但它们的位置、管理方式和使用场景都有所不同。
【Docker系列】docker缓存详解
檀越的博客
09-04 1888
💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。非常期待和您一起在这个小小的网络世界里共同探索、学习和成长。💝💝💝 ✨✨ 欢迎订阅本专栏 ✨✨。
vue缓存用法
最新发布
凌寒赋雪的博客
09-10 543
Store 临时缓存特点：需要定义，有初始值、响应式、全局使用、刷新重置Pinia官方文档。
SpringBoot本地缓存实现：Guava与Caffeine
本文档介绍了如何在Spring Boot项目中实现本地缓存，主要探讨了使用Google的Guava和Caffeine作为缓存解决方案。 在许多Web应用中，本地缓存是一种提高性能的有效策略，它可以避免频繁地从数据库或其他远程服务获取...
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

S-X-S

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值