Restfult风格的统一缓存架构设计

最新推荐文章于 2024-06-04 18:30:06 发布
原创 最新推荐文章于 2024-06-04 18:30:06 发布 · 2.7k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#restful #缓存

本文以用户信息的CURD操作为例，详细介绍了基于RESTful架构的缓存设计方法。通过具体的代码示例展示了如何利用SpringMVC和AOP实现缓存的统一处理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

概述

基于Restful的架构风格已被广泛接收，因为Restful对资源URI的命名要求、对资源操作明确的动词语义，在很大程度上影响了Web应用的整体架构设计。


本文以一个简单的CURD操作为例，讨论基于Restful的缓存设计，抛砖引玉，共通探讨。


本文中的示例代码可以从下面地址下载：https://github.com/hubin0011/research/restful/restful_rw


环境和要求

本示例在以下环境中测试通过：

OS：WindowsXP SP3

JDK：1.6.0_26

Servlet：2.5

SpringMVC：3.2.3.RELEASE

Tomcat：6.0.33

Maven：3.0.3

crul：7.34.0-win32


简单的CURD示例示例说明

简单起见，以用户信息（User）的CURD操作为例，用户信息包括：用户Id、email地址两个属性，其中用户Id是主键。


用户资源的URI约定如下：

用户资源操作资源URI方法动词参数
创建用户/userPOST请求体中是JSON格式的User 
查询用户/user/{id}GETid:User的Id
更新用户/user/{id}PUTid:User的Id，请求体中是JSON格式的User
删除用户/user/{id}|删除用户 |/user/{id} |DELETE |id:User的Id |id:User的Id


创建工程

本节说明如何创建示例工程。


创建工程命令

工程创建使用Maven，创建命令如下：

mvn archetype:create -DgroupId=com.github.hubin0011 -DartifactId=rest-rw -DarchetypeArtifactId=maven-archetype-webapp


添加依赖

Maven工程创建成功后，在pom.xml中添加如下依赖：

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>servlet-api</artifactId>
  <version>2.5</version>
  <scope>provided</scope>
</dependency>

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>jstl</artifactId>
  <version>1.2</version>
  <scope>provided</scope>
</dependency>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>3.2.3.RELEASE</version>
</dependency>

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.2.1</version>
</dependency>

工程配置

创建工程后，需要对SpringMVC做一些配置


配置SpringMVC前端拦截器

在web.xml中加入下面配置：

<servlet>
  <servlet-name>dispatcher</servlet-name>
  <servlet-class>
    org.springframework.web.servlet.DispatcherServlet
  </servlet-class>
  <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:web-servlet.xml</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
  <servlet-name>dispatcher</servlet-name>
  <url-pattern>/</url-pattern>
</servlet-mapping>

配置SpringMVC的组件扫描

在web-servlet.xml中配置Spring的组件扫描：


<context:annotation-config />

<mvc:annotation-driven content-negotiation-manager="contentNegotiationManager">
</mvc:annotation-driven>

<context:component-scan base-package="com.github.hubin0011" >
</context:component-scan>

<bean id="contentNegotiationManager" class="org.springframework.web.accept.ContentNegotiationManagerFactoryBean">
  <property name="favorPathExtension" value="false" />
</bean>

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <property name="prefix" value="/WEB-INF/jsp/" />
  <property name="suffix" value=".jsp" />
</bean>

实现示例Restful

之前的章节完成了工程创建和配置，本节介绍具体Restful的实现。


创建用户实体类

首先，先创建用户实体类。代码如下：

package com.github.hubin0011.rest.rw.domain;


import com.github.hubin0011.rest.rw.ICachableDomain;

public class User implements ICachableDomain {

private String id;

private String email;

public String getId() {
  return id;
}

public void setId(String id) {
  this.id = id;
}

public String getEmail() {
  return email;
}

public void setEmail(String email) {
  this.email = email;
}
}


为了能够统一的取得资源id，资源需要实现ICachableDomain接口，ICachableDomain接口定义如下：


package com.github.hubin0011.rest.rw;


public interface ICachableDomain {

public String getId();
}


创建用户的Restful服务

创建用户、查询用户、更新用户、删除用户的Restful服务的方法都在UserRestController类中实现。具体实现如下：


package com.github.hubin0011.rest.rw.controller;

import com.github.hubin0011.rest.rw.domain.User;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@Controller
@RequestMapping("user")
public class UserRestController {

private List<User> users = new ArrayList<User>();
private Log log = LogFactory.getLog(this.getClass());

@RequestMapping(method = RequestMethod.POST)
@ResponseBody
public HttpStatus create(@RequestBody User user){
  System.out.println("in Request Post ");
  users.add(user);
  return HttpStatus.CREATED;
}

@RequestMapping(value="{id}", method = RequestMethod.GET)
@ResponseBody
public User get(@PathVariable("id")String id){
  System.out.println("in Request Get ");
  if(id == null) {
    return null;
  }

  for(User user : users){
    if(user.getId().equals(id)){
      return user;
    }
  }

  return null;
}

@RequestMapping(value="{id}",method = RequestMethod.PUT)
@ResponseBody
public HttpStatus update(@PathVariable("id")String id, @RequestBody User user){
  System.out.println("in Request Put ");

  for(User aUser : users){
    if(aUser.getId().equals(id)){
      aUser.setEmail(user.getEmail());
      return HttpStatus.OK;
    }
  }

  return HttpStatus.BAD_REQUEST;
}

@RequestMapping(value="{id}",method = RequestMethod.DELETE)
@ResponseBody
public HttpStatus delete(@PathVariable("id")String id){
  System.out.println("in Request Delete ");
  for(User aUser : users){
    if(aUser.getId().equals(id)){
      users.remove(aUser);
      return HttpStatus.OK;
    }
  }

  return HttpStatus.BAD_REQUEST;
}

}


缓存统一处理

因为Restful对资源操作有明确的动词语义，再配合AOP的拦截机制，架构设计上就能够根据动词的含义对读写操作进行统一的处理。


下面是一个简单的AOP拦截器的实现，要注意的是下面的拦截器只是是简单的、实验性质的，只作为抛砖引玉用。


package com.github.hubin0011.rest.rw.aspect;


import com.github.hubin0011.rest.rw.ICachableDomain;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

@Component
@Aspect
public class RestfulRWAspect {

private Map<String,Object> cachedMap = new HashMap<String, Object>();

private Log log = LogFactory.getLog(this.getClass());

/**
* 拦截Restful请求，根据请求的方法进行资源缓存处理。
* @param pjp
* @return
* @throws Throwable
*/
@Around("execution(public * com.github.hubin0011.rest.rw.controller.*RestController.*(..))")
public Object intercept(ProceedingJoinPoint pjp) throws Throwable{
  //取得请求方法类别
  RequestMethod requestMethod = getRequestMethod(pjp);
  //取得请求资源的id
  String id = getParamId(pjp);

  //判断是GET请求，如果缓存中存在请求资源，则直接从缓存中返回资源。
  if(requestMethod == RequestMethod.GET && id != null){
    if(cachedMap.containsKey(id)){
      System.out.println("直接从缓存中返回资源。资源id:" + id);
      return cachedMap.get(id);
    }
  }

  //继续进行拦截链，取得执行结果
  Object obj = pjp.proceed();

  //判断是POST请求，则将资源信息加入到缓存中
  if(requestMethod == RequestMethod.POST ){
    //取得资源信息数据
    Object resource = getPostDomain(pjp);
      if(resource instanceof ICachableDomain){
        ICachableDomain domain = (ICachableDomain)resource;
        //取得资源id
        String newId = domain.getId();
        if(newId != null){
          System.out.println("将资源添加到缓存。资源id:" + newId);
          cachedMap.put(newId,resource);
        }
     }
  }

  //判断是PUT请求，则将资源信息更新到缓存中
  if(requestMethod == RequestMethod.PUT){
    if(id != null){
      Object param = getPutDomain(pjp);
      System.out.println("从缓存中更新相应资源。资源id:" + id);
      cachedMap.put(id,param);
    }
  }

  //判断是DELETE请求，则从缓存中删除相应资源
  if(requestMethod == RequestMethod.DELETE){
    if(id != null){
      System.out.println("从缓存中删除相应资源。资源id:" + id);
      cachedMap.remove(id);
    }
  }

  //返回执行结果
  log.debug("返回执行结果");
  return obj;
}

/**
* 取得Restful请求的资源id
*
* @param pjp
* @return
*/
protected String getParamId(ProceedingJoinPoint pjp){
  String id = null;

  Object[] args = pjp.getArgs();
  if(args.length >= 1){
    id = args[0].toString();
  }

  return id;
}

/**
* 取得Post请求时资源的信息数据
* @param pjp
* @return
*/
protected Object getPostDomain(ProceedingJoinPoint pjp){
  Object obj = null;

  Object[] args = pjp.getArgs();
  if(args.length == 1){
    obj = args[0];
  }

  return obj;
}

/**
* 取得Put请求时资源的信息数据
* @param pjp
* @return
*/
protected Object getPutDomain(ProceedingJoinPoint pjp){
  Object obj = null;

  Object[] args = pjp.getArgs();
  if(args.length == 2){
    obj = args[1];
  }

  return obj;
}

/**
* 取得Restful请求的方法
* @param pjp
* @return
*/
protected RequestMethod getRequestMethod(ProceedingJoinPoint pjp){
  MethodSignature methodSignature = (MethodSignature)pjp.getSignature();
  Method targetMethod = methodSignature.getMethod();
  RequestMapping methodRequestMapping = AnnotationUtils.findAnnotation(targetMethod, RequestMapping.class);
  RequestMethod[] methods = methodRequestMapping.method();

  if(methods.length <= 0){
    return null;
  }
  return methods[0];
}
}


测试

首先部署应用到Tomcat中，并启动Tomcat。之后用curl工具测试缓存拦截器。


创建用户

在curl的bin目录下，执行测试命令和返回结果如下：

curl.exe -X POST -H "Content-Type: application/json" -d "{\"id\":\"hubin0011\",\"email\":\"demo\"}" http://localhost:8080/rest-rw/user

"CREATED"

服务端日志： 


in Request Post
将资源添加到缓存。资源id:hubin0011

查询用户

在curl的bin目录下，执行测试命令和返回结果如下：


curl.exe http://localhost:8080/rest-springmvc/user/hubin0011

{"id":"hubin0011","email":"demo"}

服务端日志： 


直接从缓存中返回资源。资源id:hubin0011

可以看到结果是从缓存中返回。


更新用户

测试更新用户，命令和如下：


curl.exe -X PUT -H "Content-Type: application/json" -d "{\"id\":\"hubin0011\",\"email\":\"demo1\"}" http://localhost:8080/rest-springmvc/user/hubin0011

"OK"

服务端日志： 

in Request Put
从缓存中更新相应资源。资源id:hubin0011

查询用户检验更新结果： 

curl.exe http://localhost:8080/rest-springmvc/user/hubin0011

{"id":"hubin0011","email":"demo1"}

服务端日志： 

直接从缓存中返回资源。资源id:hubin0011

可以看到结果是从缓存中返回，并且缓存数据已经更新。



删除用户

测试删除用户，命令和如下：

curl.exe -X DELETE http://localhost:8080/rest-springmvc/user/hubin0011

"OK"

服务端日志： 

in Request Delete
从缓存中删除相应资源。资源id:hubin0011

查询用户检验删除结果： 

curl.exe http://localhost:8080/rest-springmvc/user/hubin0011

服务端日志：

in Request Get

示例代码下载

本文中的示例代码可以从下面地址下载：https://github.com/hubin0011/research/restful/restful_rw




缓存管理设计
qq_38940885的博客
11-14 2071
本文主题：一、去除Redis，使用进程内缓存；二、集中缓存管理。 我们在写系统时为了提高系统业务处理速度，在系统中大量使用Redis作为缓存使用，但是对于一些信息使用Reids是首选吗？我们还是以支付系统为例，对于对接的通道的一些配置信息、交易机构信息(银行)，响应码转换信息等等，真的有必要上来就怼Redis里吗？对于这些信息每笔交易都会使用到，那么我们系统在运行时强依赖Redis，还是那句话，我们系统在运行时依赖的外界系统越少越好，依赖的越多，在后期运行过程系统性能瓶颈有很大可能发生在和这些系统交互上面
Java架构师缓存架构设计
赵广陆
10-11 1393
目录 1 导学 2 高性能概述 2.1 高性能的定义和衡量指标 2.2 如何实现高性能的计算机系统或软件程序 2.3 木桶理论 2.4 如何实现计算机系统或软件程序的高性能 3 多级缓存设计 3.1 浏览器缓存 3.2 CDN缓存 3.3 负载均衡的缓存 3.4 进程内缓存 3.5 分布式缓存 4 缓存技术方案 5 如何进行缓存拆分 6 缓存持久化和集群 6.1 缓存持久化 6.2 缓存集群
Restful接口开发（6）：缓存服务Cache/Redis
小蚯蚓的博客
11-05 999
一、实现功能 通过spring的缓存机制，通过spring cache启动spring缓存，以及通过Redis实现缓存。 二、spring cache基本参数 1.@EnableCaching 启用缓存注解，放置位置：注释在启动类或者配置类上 2.@Cacheable 有则用缓存，没有则运行方法 （1）作用：Cacheable表示方法结果可以被缓存，第一次运行方法后，结果即被缓存；以后调...
初学 HTTP [状态码 Restful Headers 缓存]
u014688172的博客
09-22 380
HTTP 常见状态码 1 开头 表示服务器接收到请求（使用较少） 2 开头 表示加载成功 200 加载成功 3 开头 表示重定向 301永久重定向 302 临时重定向 304 缓存未改变 4 开头 表示客户端错误 404 页面未找到 5 开头 表示服务端错误 Restful 风格 url 与传统的url相比，restful是将url看作一种功能，传统url是定义为一种定位资源 传统风格url 查询 /user/query?name=tom GET 详情 /user/getInfo?id=1
挑战大型系统的缓存设计——应对一致性问题
芋艿V
05-04 268
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 10:33更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT ...
Restful架构风格
qq_71314862的博客
04-14 313
Restful是一种软件架构风格，指的是一组架构约束和原则。满足这些约束条件和原则就是采用Restful风格
架构设计之分布式缓存.jpg
09-25
架构设计之分布式缓存
一线大厂高并发Redis缓存架构
qq_44027353的博客
03-25 2028
的问题，我们都是请求–>web服务–>redis，如果并发量很大，多个web服务的请求到发到了一个redis节点上，redis处理不过来一秒十几万或更多的请求，那么redis就可能宕机或者是用户线程一直等待redis响应，此时并发很高，web服务中线程得不到释放，又不断有新的请求进来，又导致微服务可能宕机，进而影响到整个系统宕机。问题，热点数据过期或者是冷门数据忽然变成热点数据，这时缓存中没数据，DB中有数据，一瞬间大量的请求要查询这条数据就都落到了DB上。，锁的粒度要小，比如电商中使用锁前缀+商品id。
设计高并发架构与系统多级缓存架构如何设计？
m0_67322837的博客
04-10 2136
高并发经常会发生在有大活跃用户量，用户高聚集的业务场景中，如：秒杀活动，定时领取红包等。 为了让业务可以流畅的运行并且给用户一个好的交互体验，我们需要根据业务场景预估达到的并发量等因素，来设计适合自己业务场景的高并发处理方案。 在电商相关产品开发的这些年，我有幸的遇到了并发下的各种坑，这一路摸爬滚打过来有着不少的血泪史，这里进行的总结，作为自己的归档记录，同时分享给大家。 服务器架构 业务从发展的初期到逐渐成熟，服务器架构也是从相对单一到集群，再到分布式服务。 一个可以支持高并发的服务少不了好的服
系统架构设计师【第19章】: 大数据架构设计理论与实践 (核心总结)
最新发布
数据知道的博客
06-04 1万+
大数据架构主要面向大数据的容量体量、类型多样、高速实时、客观真实、价值可观、变化多 样和复杂多源的特性，既要构建高质量属性的架构解决方案，又受制于成本、性能、可扩展性等诸多条件。同时，云计算、物联网以及边缘计算等客观环境的发展，也对大数据架构的设计提出了弹性、容器化等新的要求。
缓存统一处理法
08-10
这是一份关于单片机应用时，接收数据的缓存处理程序，可以参考并修改使用！
RESTful Web 服务 - 缓存
勇往直前的专栏
03-09 1539
缓存是指在客户端存储服务器响应，以便客户端不需要一次又一次的请求服务器上相同的资源。服务器响应应该有关于如何进行缓存的信息，以便客户端缓存一段时间内的响应或者永远不缓存服务器响应。 下面是可以用来配置客户端缓存的服务器响应头： 编号 头信息 &amp; 描述 1 Date  创建资源的日期和时间。 2 Last Modified  最后修改资源的日期和时间...
restful路径变量和缓存协议
fei33423的专栏
04-23 198
浏览器具有缓存的功能，缓存的本质是为了：使用缓存能直接从本地读取数据，减少向服务器请求数据，缓解服务器压力。使用缓存能提高浏览器的二次渲染的时间，以及减少用户的流量消耗。
RestFult的理解
L__MY的博客
07-13 233
何为RESTful RESTful架构，就是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易 于理解、扩展方便，所以正得到越来越多网站的采用。REST这个词，是Roy Thomas Fielding在他2000年的博士论文中提出的 . REST 是Representational State Transfer的缩写，翻译是”表现层状态转化”。 可以 总结为一句话：REST是所有Web应用都...
什么是RestFul
T Yuan
07-27 415
REST (REpresentation State Transfer) 描述了一个架构样式的网络系统，比如 web 应用程序。REST 指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是 RESTful。Web 应用程序最重要的 REST 原则是，客户端和服务器之间的交互在请求之间是无状态的。从客户端到服务器的每个请求都必须包含理解请求所必需的信息。如果服务器在请求之间的任何
RESTful 风格
t949500898的博客
11-02 168
什么是RESTful风格？ REST是REpresentational State Transfer的缩写（一般中文翻译为表述性状态转移），REST 是一种体系结构，而 HTTP 是一种包含了 REST 架构属性的协议，为了便于理解，我们把它的首字母拆分成不同的几个部分： 表述性（REpresentational）： REST 资源实际上可以用各种形式来进行表述，包括 XML、JSON 甚至HTML——最适合资源使用者的任意形式； 状态（State）： 当使用 REST 的时候，我们更关注资源的状态而不是
使用SpringMVC创建Restfult风格应用
hubin0011的专栏
02-11 917
目的 本文介绍如何使用SpringMVC搭建Restful风格的应用。 为更容易理解，以维护用户信息为例，说明如何实现restful的增删改查和列表功能。 简单起见，用户信息（User）包括：用户Id、email地址两个属性，其中用户Id是主键。 环境和要求 本示例在以下环境中测试通过： OS：WindowsXP SP3 JDK：1.6.0_26 Servle
一起代码，两分钟，实现 java restful webservice
GY的的专栏
11-17 2435
新接手个项目中用到了restful webservice, 开始研究JAX-RX,JAX-WS,CXF,jaxb等概念，也从网上找一些简单的例子，其实java实现rest还是非常简单的（要不怎么叫rest呢^_^），但是发现找到的例子都是eclipse实现，代码虽然没有几行，但是都是手工敲，尤其是各种annotations,和web.xml,这些东东对于我这样一个懒人来说实在是不愿意手工输入，手工
彻底理解 RESTful
ArtisticProgramming的博客
08-17 349
内容转载于https://zhuanlan.zhihu.com/p/37980590 内容列表 REST 的出处 REST 的概念 REST 的推导与其特征 REST 与 HTTP 、URI 的关系 REST 的使用示例与描述 开发 RESTful API 的流行框架 总结 REST 的出处 REST 这个概念是　Roy Thomas Fielding2000　年在加州大学欧文分校 (UNIVERSITY OF CALIFORNIA, IRVINE)　的　博士论文　中提出...
深入解析分布式系统架构与实战设计技巧
分布式系统架构与设计实战课程内容涵盖了分布式计算的核心概念、架构原则、设计模式以及工程实践。本课程面向软件架构师、系统工程师以及对分布式系统有兴趣的技术人员，旨在深入讲解如何构建可扩展、高性能和高可用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值