project > Maven > Update Project > "Force Update of Snapshots/Releases" check > "ok" click

Caching with Spring Data Redis

source - http://blog.joshuawhite.com/java/caching-with-spring-data-redis/

This article will cover the following topics:

1. How to install Redis on a *nix machine.
2. How to write a simple app using Spring-Data and Redis.

Before moving forward let's understand what Redis is.

Redis is an open source, advanced key-value store. It is often referred to as a data structure serversince keys can contain strings, hashes, lists, sets and sorted sets.

In this article I'm not going to talk how fast is redis and how it works. But believe me it's a very fast key-value store.

Now let's install redis on *nix machine

That's all! Your redis is ready to use.

Now let's create a simple maven application to work with redis.

 Currently Spring Redis has support for Jedis and JRedis (Jedis and JRedis are Redis bindings for Java).

 In this article we are going to use Jedis. Here are the Maven dependencies:

You can find the full application on GitHub here: spring-data-redis example

Now let's define and configure our beans:

RedisTemplate provides high level abstraction for redis operations. If your application stores and retrieves strings, then you may use StringRedisTemplate.

Let's create a simple domain object.

Now let's create Service layer classes.

So domain and service classes are ready. Now let's use them.

Here is the simple Main class which uses the above-mentioned classes.

Wasn't it simple? Spring makes everything much more easy to use.

And this isn't the end. spring-data-redis's org.springframework.data.redis.support package provides List, Set, Map implemetations.

Let's try to use a map:

This may help you with unit testing, and you may change the datastore without the changing service layer.

You may also use RedisCacheManager as a backing implementation for spring cache abstraction.

Find the full version of this application on GitHub here:  spring-data-redis example

source - http://java.dzone.com/articles/spring-data-redis-0

2013년 3월 26일 화요일

@Configuration
@EnableCaching
@ComponentScan(basePackageClasses = UserRepository.class)
// @PropertySource("classpath:redis.properties")
public class RedisCacheConfiguration {
 
    @Autowired
    Environment env;
 
    @Bean
    public JedisShardInfo jedisShardInfo() {
        return new JedisShardInfo("localhost");
    }
 
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new JedisConnectionFactory(jedisShardInfo());
    }
 
    @Bean
    public RedisTemplate redisTemplate() {
        RedisTemplate<String,Object> template = new RedisTemplate<String,Object>();
        template.setConnectionFactory(redisConnectionFactory());
        return template;
    }
 
    @Bean
    public RedisCacheManager redisCacheManager() {
        return new RedisCacheManager(redisTemplate(), 300);
    }
}

@Slf4j
public class RedisCacheManager extends AbstractTransactionSupportingCacheManager {
 
    private RedisTemplate redisTemplate;
    private int expireSeconds;
 
    public RedisCacheManager(RedisTemplate redisTemplate) {
        this(redisTemplate, 300);
    }
 
    public RedisCacheManager(RedisTemplate redisTemplate, int expireSeconds) {
        Guard.shouldNotBeNull(redisTemplate, "redisTemplate");
        this.redisTemplate = redisTemplate;
        this.expireSeconds = expireSeconds;
    }
 
    @Override
    protected Collection<? extends Cache> loadCaches() {
        Collection<Cache> caches = Lists.newArrayList();
 
        for (String name : getCacheNames()) {
            caches.add(new RedisCache(name, redisTemplate, expireSeconds));
        }
        return caches;
    }
 
    @Override
    public Cache getCache(String name) {
        synchronized (this) {
            Cache cache = super.getCache(name);
            if (cache == null) {
                cache = new RedisCache(name, redisTemplate, expireSeconds);
                addCache(cache);
            }
            return cache;
        }
    }
}

@Slf4j
public class RedisCache implements Cache {
    @Getter
    private String name;
    @Getter
    private int expireSeconds;
 
    private RedisTemplate redisTemplate;
 
    public RedisCache(String name, RedisTemplate redisTemplate) {
        this(name, redisTemplate, 300);
    }
 
    public RedisCache(String name, RedisTemplate redisTemplate, int expireSeconds) {
        Guard.shouldNotBeEmpty(name, "name");
        Guard.shouldNotBeNull(redisTemplate, "redisTemplate");
 
        this.name = name;
        this.redisTemplate = redisTemplate;
 
        if (log.isDebugEnabled())
            log.debug("MongoCache를 생성합니다. name=[{}], mongodb=[{}]", name, redisTemplate);
    }
 
    @Override
    public Object getNativeCache() {
        return redisTemplate;
    }
 
    public String getKey(Object key) {
        return name + ":" + key;
    }
 
    @Override
    public ValueWrapper get(Object key) {
        Guard.shouldNotBeNull(key, "key");
        if (log.isDebugEnabled())
            log.debug("캐시 키[{}] 값을 구합니다...", key);
 
        Object result = redisTemplate.opsForValue().get(getKey(key));
 
        SimpleValueWrapper wrapper = null;
        if (result != null) {
            if (log.isDebugEnabled())
                log.debug("캐시 값을 로드했습니다. key=[{}]", key);
            wrapper = new SimpleValueWrapper(result);
        }
        return wrapper;
    }
 
    @Override
    @SuppressWarnings("unchecked")
    public void put(Object key, Object value) {
        Guard.shouldNotBeNull(key, "key");
 
        if (log.isDebugEnabled())
            log.debug("캐시에 값을 저장합니다. key=[{}], value=[{}]", key, value);
 
        redisTemplate.opsForValue().set(getKey(key), value, expireSeconds);
    }
 
    @Override
    @SuppressWarnings("unchecked")
    public void evict(Object key) {
        Guard.shouldNotBeNull(key, "key");
        if (log.isDebugEnabled())
            log.debug("지정한 키[{}]의 캐시를 삭제합니다...", key);
 
        try {
            redisTemplate.delete(key);
        } catch (Exception e) {
            log.error("캐시 항목 삭제에 실패했습니다. key=" + key, e);
        }
    }
 
    @Override
    @SuppressWarnings("unchecked")
    public void clear() {
        if (log.isDebugEnabled())
            log.debug("모든 캐시를 삭제합니다...");
        try {
            redisTemplate.execute(new RedisCallback() {
                @Override
                public Object doInRedis(RedisConnection connection) throws DataAccessException {
                    connection.flushAll();
                    return null;
                }
            });
        } catch (Exception e) {
            log.warn("모든 캐시를 삭제하는데 실패했습니다.", e);
        }
    }
}

@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {RedisCacheConfiguration.class})
public class RedisCacheTest {
 
    @Autowired
    RedisCacheManager redisCacheManager;
 
    @Autowired
    UserRepository userRepository;
 
    @Test
    public void clearTest() {
        Assert.assertNotNull(redisCacheManager);
        Cache cache = redisCacheManager.getCache("user");
        Assert.assertNotNull(cache);
        cache.clear();
        Assert.assertNotNull(cache);
    }
 
    @Test
    public void getUserFromCache() {
 
        Stopwatch sw = new Stopwatch("initial User");
        sw.start();
        User user1 = userRepository.getUser("debop", 100);
        sw.stop();
 
        sw = new Stopwatch("from Cache");
        sw.start();
        User user2 = userRepository.getUser("debop", 100);
        sw.stop();
 
        Assert.assertEquals(user1.getUsername(), user2.getUsername());
    }
 
    @Test
    public void componentConfigurationTest() {
        Assert.assertNotNull(redisCacheManager);
        Cache cache = redisCacheManager.getCache("user");
        Assert.assertNotNull(cache);
 
        cache.evict("debop");
 
        Assert.assertNotNull(userRepository);
    }
}

출처 - http://debop.blogspot.kr/2013/03/spring-31-redis-cache.html

Using Redis with Spring

source - http://www.javacodegeeks.com/2012/06/using-redis-with-spring.html

As you’ve read about Redis Installation & Configuration, you’re mostly understand the main concept of Redis database. Redis is an extremely high-performed, lightweight data store. It provides key/value data access to persistent byte arrays, lists, sets and hash data structures. So, the insertion, deletion and retrieve operations inside Redis becomes very simple how we have worked with using of Map, List , Set and an Array data structures how it is used inside normal Java program; although some minimal modifications that you’ve probably never care about them.

• Social Connection : Google+ | Twitter | FaceBook

As you’ve been doing once it comes to deal with any database platform, you have to download/install the database driver. For Redis four driver libraries are provided for allowing your application to get connected to Redis. Spring Data supports connecting to Redis using either the Jedis (That will be considered in this tutorial), JRedis, RJC or SRP driver libraries. It doesn’t matter which library have been used, cause the Spring Data has abstracted the differences between those drivers into common set of APIs and template-style helpers.

1. Spring Context Configuration

To connect to Redis using Jedis, you need to create an instance of org.springframework.data.redis.connection.jedis.JedisConnectionFactory. The other driver libraries have corresponding ConnectionFactory subclasses. Below the proper Spring Context (SpringContext.xml) that should be used for initializing and connecting the Redis database through using of Spring.

SpringContext.xml

• For searching about all Spring component (beans), you’ve provided the component-scan element.
• For connecting the Redis database, you’ve provided the Jedis connection factory bean.
• The central abstraction you’re likely to use when accessing Redis via Spring Data Redis is the org.springframework.data.redis.core.RedisTemplate class.

Since the feature set of Redis is really too large to effectively encapsulate into a single class, the various operations on data are split into separate operations classes as follows:

• ValueOperations:Returns the operations performed on simple values (or Strings in Redis terminology.
• ListOperations:Returns the operations performed on list values.
• SetOperations:Returns the operations performed on set values.
• ZSetOperations:Returns the operations performed on zset values (also known as sorted sets.
• HashOperations:Returns the operations performed on hash values.
• BoundValueOperations:Returns the operations performed on hash values bound to the given key.
• BoundListOperations:Returns the operations performed on list values bound to the given key.
• BoundSetOperations:Returns the operations performed on set values bound to the given key.
• BoundZSetoperations:Returns the operations performed on zset values (also known as sorted sets) bound to the given key.
• BoundHashOperations:Returns the operations performed on hash values bound to the given key.

2. Maven Dependencies for Spring Data Redis

The required libraries and dependencies for making the connecting of Redis is achievable are listed inside the below pom.xml file.

pom.xml

3. Spring Beans (RegisterationBean)

For accessing the RedisTemplate that defined above, you have to use @Autowired annotation for being RedisTemplate available at your Spring Beans.

RegistrationBean.java

4. Java Beans

The business domain is very simple, it’s just a User entity associated with an instance of Address. Look below.

User.java

Address.java

5. Spring Data Redis Example Application

The below Java Class, is just an executable application that developed for persisting an User entity associated with an Address inside Redis key/value database. Note that the using of this concept entity is just theoretical uses and it doesn’t mean anything when it comes to apply it inside the Redis.

Executable.java