Spring Cache Tutorial with EhCache [How to update the cache?] | Spring Cache

🚀 Master Spring Boot Today!

Subscribe to Ram N Java for the most practical Java tutorials on the web.

SUBSCRIBE FOR UPDATES

Keeping Data Fresh: Spring Cache Refresh

Caching is great for speed, but what happens when your data changes? If you don't update your cache, your users will see old "stale" data. Today, we’re learning how to refresh cache entries using Spring Cache and EhCache.

Why Refreshing Cache is Critical

Imagine a user updates their profile picture, but your website still shows the old one because the old image is stuck in the cache. To fix this, we need to tell Spring to update that specific entry whenever a change happens.

The Solution: @CachePut. Unlike @Cacheable which skips the method, @CachePut always runs the method and updates the cache with the fresh result!

How to Implement Cache Updates

• Step 1: Use @CachePut on your update methods.
• Step 2: Match the key and value (cache name) to your original @Cacheable method.
• Step 3: Watch as Spring automatically replaces the old data with the new return value.

More From Ram N Java

Check out these other trending tutorials to level up your development skills:

🔗 MCP Deep Dive: Why Developers Are Switching to This Architecture

🔗 Why Your MCP Server Will Crash (And How to Fix It)

🔗 MCP Security: Authentication vs Authorization Explained

Spring AOP AspectJ throws Advice example using XML configuration | Spring Tutorial

Implementing Spring AOP AspectJ Throws Advice with XML Configuration

🔔 SUBSCRIBE TO RAM N JAVA FOR DAILY TECH TIPS!

What is Throws Advice in Spring AOP?

In Spring Aspect-Oriented Programming (AOP), Throws Advice is a type of "after advice" that only runs if a method exits by throwing an exception. It is incredibly useful for centralized error handling, logging specific failure details, or even triggering notification systems when something goes wrong in your application.

How to Configure it Using XML

While modern Spring often uses annotations, many enterprise systems still rely on XML configuration. To implement Throws Advice with XML, you define your aspect as a standard bean and then use the section to map it.

Step-by-Step Implementation

• The Target Method: Create a service (like an Employee Service) that purposefully throws an exception under certain conditions.
• The Aspect Class: Create a Java class with a method designed to catch the exception details.
• XML Setup: Use the tag. You specify the pointcut (where the advice applies) and the method in your aspect class that should handle the error.

Why Use Throws Advice?

Instead of cluttering every single method with try-catch blocks, you can define one "Throws Advice" globally. This keeps your business logic clean and ensures that every error is handled or logged in a consistent way across your entire project.

---

Explore More Spring AOP Tutorials from Ram N Java:

• 🚀 Mastering Spring AOP: @AfterThrowing AspectJ Annotation Example
• 🚀 Spring AOP AspectJ @Before Annotation Explained: Complete Guide
• 🚀 Understanding Spring AOP: @After AspectJ Annotation Example

---

Click here to watch on Youtube:
https://www.youtube.com/watch?v=dbrPfxCCS48&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge:

Spring AOP AspectJ throws Advice example using XML configuration | Spring Tutorial

Spring AOP AspectJ throws Advice example using XML configuration | Spring Tutorial

Spring AOP AspectJ throws Advice example using XML configuration | Spring Tutorial

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.ram.core</groupId>
    <artifactId>SpringDemo</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>SpringDemo</name>
    <url>http://maven.apache.org</url>

    <properties>
        <spring.version>5.0.5.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <!-- Spring 5 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- Spring AOP + AspectJ -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
       
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.1</version>
        </dependency>
       
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.1</version>
        </dependency>

    </dependencies>

</project>

EmployeeService.java

package com.ram.service;

public class EmployeeService
{
    public String addEmployee()
    {
        System.out.println("addEmployee() is called");
        String name = null;
        name.toLowerCase();
        return "Employee Peter information is added successfully";
    }
   
    public void modifyEmployee()
    {
        System.out.println("modifyEmployee() is called");
    }
   
    public void deleteEmployee()
    {
        System.out.println("deleteEmployee() is called");
    }

}

LoggingAspect.java

package com.ram.Aspect;

import org.aspectj.lang.JoinPoint;

public class LoggingAspect
{
    public void logAfterThrowing(JoinPoint joinPoint,
            Throwable exception)
    {

        System.out.print("logAfterThrowing() is running!");
        System.out.println(
                ", after " + joinPoint.getSignature().getName()
                        + " method throwing exception");
        System.out.println("exception = " + exception);
        System.out.println("******");
    }

}

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.3.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <bean id="employeeService" class="com.ram.service.EmployeeService"></bean>

    <!-- Aspect -->
    <bean id="logAspect" class="com.ram.Aspect.LoggingAspect" />

    <aop:config>
        <aop:aspect id="aspectLoggging" ref="logAspect">
            <!-- @AfterThrowing -->
            <aop:pointcut id="pointCutAfterThrowing"
                expression="execution(* com.ram.service.EmployeeService.addEmployee()))" />

            <aop:after-throwing method="logAfterThrowing"
                throwing="exception" pointcut-ref="pointCutAfterThrowing" />
        </aop:aspect>
    </aop:config>

</beans>

App.java

package com.ram.core;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ram.service.EmployeeService;

public class App
{
    public static void main(String[] args)
    {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "applicationContext.xml");

        System.out.println("---------------------------------------");

        EmployeeService employeeService = context.getBean("employeeService",
                EmployeeService.class);

        try
        {
            employeeService.addEmployee();
        }
        catch (Exception exe)
        {
            System.out.println("exception message  = " + exe.getMessage());
        }

        employeeService.modifyEmployee();

        employeeService.deleteEmployee();

    }

}

Output

Nov 13, 2018 9:38:13 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@32709393: startup date [Tue Nov 13 09:38:13 IST 2018]; root of context hierarchy
Nov 13, 2018 9:38:13 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [applicationContext.xml]
---------------------------------------
addEmployee() is called
logAfterThrowing() is running!, after addEmployee method throwing exception
exception = java.lang.NullPointerException
******
exception message  = null
modifyEmployee() is called
deleteEmployee() is called

Click the below link to download the code:
https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_throws_advice_xml_config.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_throws_advice_xml_config

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/6bb2ff720fe1441184ee161a1a41ebd747f549ef/Spring_2018/SpringDemo_throws_advice_xml_config/?at=master

See also:

All JavaEE Videos Playlist

All JavaEE Videos

All JAVA EE Links

Spring Tutorial

Servlets Tutorial

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Cooking Tutorial

How to apply AroundAdvice using RegexpMethodPointcutAdvisor and DefaultAdvisorAutoProxyCreator

🚀 Love learning Java and Spring?

Support the channel by subscribing for more expert tutorials!

SUBSCRIBE TO RAM N JAVA

Mastering Spring AOP: Around Advice with Regex

In this tutorial, we dive deep into Spring AOP (Aspect Oriented Programming). You will learn how to target specific methods for advice using regular expressions and automate the proxy creation process.

1. The Core Components

To make this work, we use two powerful Spring classes:

• RegexpMethodPointcutAdvisor: This allows us to define which methods should be "advised" based on a pattern (regular expression).
• DefaultAdvisorAutoProxyCreator: This is the "magic" bean. If it finds any advisor that matches your beans, it automatically creates the necessary proxies so you don't have to do it manually.

2. Defining our Services

In the video, we look at two services: EmployeeService and CustomerService. Both have methods like getName, getAge, and getAddress. Our goal is to apply logic only to the "Age" methods.

3. Setting up the XML Configuration

Inside the Spring configuration file, we set the pattern in our advisor to look for the word "age". This ensures that whether it is getEmployeeAge or getCustomerAge, our AroundAdvice will trigger perfectly.

4. Seeing the Results

When the application runs, you’ll see that the Around Advice is executed for the age-related methods, while the name and address methods run normally without interference. This is the power of clean, automated AOP!

📺 Watch More from Ram N Java

Check out these related tutorials to sharpen your Spring skills:

• 🔗 Spring AOP Around Advice Applied to All Class Methods
• 🔗 Understanding Spring AOP Around Advice - Example and Explanation
• 🔗 Understanding Spring AOP: After Advice Explained

---

Click here to watch on Youtube:
https://www.youtube.com/watch?v=_7u2oS95pD0&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge:

How to apply AroundAdvice using RegexpMethodPointcutAdvisor and DefaultAdvisorAutoProxyCreator

How to apply AroundAdvice using RegexpMethodPointcutAdvisor and DefaultAdvisorAutoProxyCreator

How to apply AroundAdvice using RegexpMethodPointcutAdvisor and DefaultAdvisorAutoProxyCreator

How to apply AroundAdvice using RegexpMethodPointcutAdvisor and DefaultAdvisorAutoProxyCreator

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.ram.core</groupId>
    <artifactId>SpringDemo</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>SpringDemo</name>
    <url>http://maven.apache.org</url>

    <properties>
        <spring.version>5.0.5.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <!-- Spring 5 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>
</project>

EmployeeService.java

package com.ram.service;

public class EmployeeService
{
    public String getEmployeeName()
    {
        System.out.println("Get Employee Name");
        return "Dave";
    }
   
    public int getEmployeeAge()
    {
        System.out.println("Get Employee Age");
        return 28;
    }
   
    public String getEmployeeAddress()
    {
        System.out.println("Get Employee Address");
        return "A111, East Street";
    }
}

CustomerService.java

package com.ram.service;

public class CustomerService
{
    public String getCustomerName()
    {
        System.out.println("Get Customer Name");
        return "Peter";
    }
   
    public int getCustomerAge()
    {
        System.out.println("Get Customer Age");
        return 38;
    }
   
    public String getCustomerAddress()
    {
        System.out.println("Get Customer Address");
        return "B111, North Street";
    }
}

AroundAdvice.java

package com.ram.Advice;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class AroundAdvice implements MethodInterceptor
{

    public Object invoke(MethodInvocation mi) throws Throwable
    {
        Object obj;
        System.out.println("AroundAdvice applied before actual method = "
                + mi.getMethod().getName());
        obj = mi.proceed();
        System.out.println("obj = " + obj);
        System.out.println("AroundAdvice applied after actual method =  "
                + mi.getMethod().getName());
        return obj;
    }

}

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.3.xsd">

    <bean id="employeeService" class="com.ram.service.EmployeeService"></bean>
    <bean id="customerService" class="com.ram.service.CustomerService"></bean>
    <bean id="aroundAdvice" class="com.ram.Advice.AroundAdvice"></bean>

    <bean id="employeeAdvisor"
        class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="patterns">
            <list>
                <value>.*Age.*</value>
            </list>
        </property>
        <property name="advice" ref="aroundAdvice" />
    </bean>
   
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />

</beans>

App.java

package com.ram.core;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ram.service.CustomerService;
import com.ram.service.EmployeeService;

public class App
{
    public static void main(String[] args)
    {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "applicationContext.xml");

        System.out.println("---------------------------------------");

        EmployeeService employeeService = context
                .getBean("employeeService", EmployeeService.class);

        employeeService.getEmployeeName();

        System.out.println("----------------------------------------");

        employeeService.getEmployeeAge();

        System.out.println("----------------------------------------");

        employeeService.getEmployeeAddress();
       
       
        CustomerService customerService = context
                .getBean("customerService", CustomerService.class);
       
        System.out.println("----------------------------------------");
       
        customerService.getCustomerName();

        System.out.println("----------------------------------------");

        customerService.getCustomerAge();

        System.out.println("----------------------------------------");

        customerService.getCustomerAddress();
    }

}

Output

Oct 30, 2018 9:29:55 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@736e9adb: startup date [Tue Oct 30 09:29:55 IST 2018]; root of context hierarchy
Oct 30, 2018 9:29:55 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [applicationContext.xml]
---------------------------------------
Get Employee Name
----------------------------------------
AroundAdvice applied before actual method = getEmployeeAge
Get Employee Age
obj = 28
AroundAdvice applied after actual method =  getEmployeeAge
----------------------------------------
Get Employee Address
----------------------------------------
Get Customer Name
----------------------------------------
AroundAdvice applied before actual method = getCustomerAge
Get Customer Age
obj = 38
AroundAdvice applied after actual method =  getCustomerAge
----------------------------------------
Get Customer Address

Click the below link to download the code:
https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_DefaultAdvisorAutoProxyCreator.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_DefaultAdvisorAutoProxyCreator

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/a5cdfdc3da3c676ee6dec77cfdb6b5c635be29d3/Spring_2018/SpringDemo_DefaultAdvisorAutoProxyCreator/?at=master

See also:

All JavaEE Videos Playlist

All JavaEE Videos

All JAVA EE Links

Spring Tutorial

Servlets Tutorial

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Cooking Tutorial