{"id":33847,"date":"2014-12-03T10:00:18","date_gmt":"2014-12-03T08:00:18","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=33847"},"modified":"2014-12-02T12:32:36","modified_gmt":"2014-12-02T10:32:36","slug":"spring-request-level-memoization","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2014\/12\/spring-request-level-memoization.html","title":{"rendered":"Spring request-level memoization"},"content":{"rendered":"

Introduction<\/h2>\n

Memoization<\/a> is a method-level caching<\/a> technique for speeding-up consecutive invocations.<\/p>\n

This post will demonstrate how you can achieve request-level repeatable reads for any data source, using Spring AOP<\/a> only.
\n 
\n 
\n 
\n <\/p>\n

Spring Caching<\/h2>\n

Spring offers a very useful caching abstracting<\/a>, allowing you do decouple the application logic from the caching implementation details.<\/p>\n

Spring Caching uses an application-level scope, so for a request-only memoization we need to take a DIY<\/a> approach.<\/p>\n

Request-level Caching<\/h2>\n

A request-level cache entry life-cycle is always bound to the current request scope. Such cache is very similar to Hibernate Persistence Context that offers session-level repeatable reads<\/a>.<\/p>\n

Repeatable reads<\/a> are mandatory for preventing lost updates<\/a>, even for NoSQL solutions.<\/p>\n

Step-by-step implementation<\/h2>\n

First we are going to define a Memoizing marker annotation:<\/p>\n

@Target(ElementType.METHOD)\r\n@Retention(RetentionPolicy.RUNTIME)\r\npublic @interface Memoize {\r\n}<\/pre>\n
This annotation is going to explicitly mark all methods that need to be memoized.<\/p>\n
To distinguish different method invocations we are going to encapsulate the method call info into the following object type:<\/p>\n
public class InvocationContext {\r\n\r\n    public static final String TEMPLATE = \"%s.%s(%s)\";\r\n\r\n    private final Class targetClass;\r\n    private final String targetMethod;\r\n    private final Object[] args;\r\n\r\n    public InvocationContext(Class targetClass, String targetMethod, Object[] args) {\r\n        this.targetClass = targetClass;\r\n        this.targetMethod = targetMethod;\r\n        this.args = args;\r\n    }\r\n\r\n    public Class getTargetClass() {\r\n        return targetClass;\r\n    }\r\n\r\n    public String getTargetMethod() {\r\n        return targetMethod;\r\n    }\r\n\r\n    public Object[] getArgs() {\r\n        return args;\r\n    }\r\n\r\n    @Override\r\n    public boolean equals(Object that) {\r\n        return EqualsBuilder.reflectionEquals(this, that);\r\n    }\r\n\r\n    @Override\r\n    public int hashCode() {\r\n        return HashCodeBuilder.reflectionHashCode(this);\r\n    }\r\n\r\n    @Override\r\n    public String toString() {\r\n        return String.format(TEMPLATE, targetClass.getName(), targetMethod, Arrays.toString(args));\r\n    }\r\n}<\/pre>\n
Few know about the awesomeness of Spring Request<\/a>\/Session<\/a> bean scopes.
 
<\/div> <\/div><\/p>\n
Because we require a request-level memoization scope, we can simplify our design with a Spring request scope that hides the actual HttpSession resolving logic:<\/p>\n
@Component\r\n@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS, value = \"request\")\r\npublic class RequestScopeCache {\r\n\r\n    public static final Object NONE = new Object();\r\n\r\n    private final Map<InvocationContext, Object> cache = new HashMap<InvocationContext, Object>();\r\n\r\n    public Object get(InvocationContext invocationContext) {\r\n        return cache.containsKey(invocationContext) ? cache.get(invocationContext) : NONE;\r\n    }\r\n\r\n    public void put(InvocationContext methodInvocation, Object result) {\r\n        cache.put(methodInvocation, result);\r\n    }\r\n}<\/pre>\n
Since a mere annotation means nothing without a runtime processing engine, we must therefore define a Spring Aspect implementing the actual memoization logic:<\/p>\n
@Aspect\r\npublic class MemoizerAspect {\r\n\r\n    @Autowired\r\n    private RequestScopeCache requestScopeCache;\r\n\r\n    @Around(\"@annotation(com.vladmihalcea.cache.Memoize)\")\r\n    public Object memoize(ProceedingJoinPoint pjp) throws Throwable {\r\n        InvocationContext invocationContext = new InvocationContext(\r\n                pjp.getSignature().getDeclaringType(),\r\n                pjp.getSignature().getName(),\r\n                pjp.getArgs()\r\n        );\r\n        Object result = requestScopeCache.get(invocationContext);\r\n        if (RequestScopeCache.NONE == result) {\r\n            result = pjp.proceed();\r\n            LOGGER.info(\"Memoizing result {}, for method invocation: {}\", result, invocationContext);\r\n            requestScopeCache.put(invocationContext, result);\r\n        } else {\r\n            LOGGER.info(\"Using memoized result: {}, for method invocation: {}\", result, invocationContext);\r\n        }\r\n        return result;\r\n    }\r\n}<\/pre>\n
Testing time<\/h2>\n
Let\u2019s put all this to a test. For simplicity sake, we are going to emulate the request-level scope memoization requirements with a Fibonacci number calculator:<\/p>\n
@Component\r\npublic class FibonacciServiceImpl implements FibonacciService {\r\n\r\n    @Autowired\r\n    private ApplicationContext applicationContext;\r\n\r\n    private FibonacciService fibonacciService;\r\n\r\n    @PostConstruct\r\n    private void init() {\r\n        fibonacciService = applicationContext.getBean(FibonacciService.class);\r\n    }\r\n\r\n    @Memoize\r\n    public int compute(int i) {\r\n        LOGGER.info(\"Calculate fibonacci for number {}\", i);\r\n        if (i == 0 || i == 1)\r\n            return i;\r\n        return fibonacciService.compute(i - 2) + fibonacciService.compute(i - 1);\r\n    }\r\n}<\/pre>\n
If we are to calculate the 10th Fibonnaci number, we\u2019ll get the following result:<\/p>\n
Calculate fibonacci for number 10\r\nCalculate fibonacci for number 8\r\nCalculate fibonacci for number 6\r\nCalculate fibonacci for number 4\r\nCalculate fibonacci for number 2\r\nCalculate fibonacci for number 0\r\nMemoizing result 0, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([0])\r\nCalculate fibonacci for number 1\r\nMemoizing result 1, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([1])\r\nMemoizing result 1, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([2])\r\nCalculate fibonacci for number 3\r\nUsing memoized result: 1, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([1])\r\nUsing memoized result: 1, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([2])\r\nMemoizing result 2, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([3])\r\nMemoizing result 3, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([4])\r\nCalculate fibonacci for number 5\r\nUsing memoized result: 2, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([3])\r\nUsing memoized result: 3, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([4])\r\nMemoizing result 5, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([5])\r\nMemoizing result 8, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([6])\r\nCalculate fibonacci for number 7\r\nUsing memoized result: 5, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([5])\r\nUsing memoized result: 8, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([6])\r\nMemoizing result 13, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([7])\r\nMemoizing result 21, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([8])\r\nCalculate fibonacci for number 9\r\nUsing memoized result: 13, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([7])\r\nUsing memoized result: 21, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([8])\r\nMemoizing result 34, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([9])\r\nMemoizing result 55, for method invocation: com.vladmihalcea.cache.FibonacciService.compute([10])<\/pre>\n
Conclusion<\/h2>\n
Memoization is a cross-cutting concern and Spring AOP allows you to decouple the caching details from the actual application logic code.<\/p>\n