Spring Redis Cache Service on Heroku
1. Setup Heroku RedisConnectionFactory Configuration
2. Setup RedisTemplate Configuration
3. Setup Redis Service
4. Setup Redis Controller
1. Setup Heroku RedisConnectionFactory Configuration
package com.example.redis;
import java.net.URI;
import java.net.URISyntaxException;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import redis.clients.jedis.Protocol;
@Configuration
@Profile("default")
public class LocalRedisConfiguration {
@Bean
public RedisConnectionFactory redisConnectionFactory() {
try {
URI redisUri = new URI(System.getenv("REDISCLOUD_URL"));
JedisConnectionFactory redisConnectionFactory = new JedisConnectionFactory();
redisConnectionFactory.setHostName(redisUri.getHost());
redisConnectionFactory.setPort(redisUri.getPort());
redisConnectionFactory.setTimeout(Protocol.DEFAULT_TIMEOUT);
redisConnectionFactory.setPassword(redisUri.getUserInfo().split(":",2)[1]);
return redisConnectionFactory;
} catch (URISyntaxException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}
}
2. Setup RedisTemplate Configuration
package com.example.redis;
import javax.inject.Inject;
import org.springframework.context.annotation.*;
import org.springframework.core.task.TaskExecutor;
import org.springframework.data.redis.connection.*;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.listener.*;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
@Configuration
@Import({LocalRedisConfiguration.class})
public class RedisConfiguration {
@Inject private RedisConnectionFactory redisConnectionFactory;
@Bean
public Topic topic() {
return new ChannelTopic("pubsub:customer");
}
@Bean
public RedisMessageListenerContainer redisMessageListenerContainer(Topic topic, RedisConnectionFactory redisConnectionFactory, TaskExecutor taskExecutor) {
RedisMessageListenerContainer redisMessageListenerContainer = new RedisMessageListenerContainer();
redisMessageListenerContainer.setTaskExecutor(taskExecutor);
redisMessageListenerContainer.setConnectionFactory(redisConnectionFactory);
redisMessageListenerContainer.addMessageListener(new MessageListener() {
@Override
public void onMessage(Message message, byte[] pattern) {
System.out.println("Received notification " + new String(message.getBody()) + ".");
System.out.println(new String(pattern));
}
}, topic);
return redisMessageListenerContainer;
}
@Bean
public TaskExecutor taskExecutor() {
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
taskExecutor.setQueueCapacity(1);
taskExecutor.setCorePoolSize(10);
return taskExecutor;
}
@Bean
public RedisTemplate<String, Object> redisTemplate() throws Exception {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
return redisTemplate;
}
}
3. Setup Redis Service
package com.example.redis;
import com.example.service.CustomerService;
import com.example.model.Customer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.math.BigInteger;
import java.util.*;
@Service
public class RedisCustomerService implements CustomerService {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
private String uniqueIdKey = "customerId";
private BigInteger uniqueId() {
long uniqueId = this.redisTemplate.opsForValue().increment(uniqueIdKey, 1);
return BigInteger.valueOf(uniqueId);
}
private String lastNameKey(BigInteger id) {
return "customer:ln:" + id;
}
private String firstNameKey(BigInteger id) {
return "customer:fn:" + id;
}
public Collection<Customer> loadAllCustomers() {
String keyPattern = "customer:fn:*";
Set<String> keys = redisTemplate.keys(keyPattern);
Set<Customer> customerSet = new HashSet<Customer>();
for (String firstNameKey : keys) {
long id = Long.parseLong(firstNameKey.split(":")[2]);
customerSet.add(this.getCustomerById(BigInteger.valueOf(id)));
}
return customerSet;
}
@Override
public Customer updateCustomer(BigInteger id, String fn, String ln) {
this.redisTemplate.opsForValue().set(lastNameKey(id), ln);
this.redisTemplate.opsForValue().set(firstNameKey(id), fn);
return getCustomerById(id);
}
@Override
public List<Customer> updateCustomers(List<Customer> customersToUpdate) {
// TODO Auto-generated method stub
return null;
}
@Override
public Customer getCustomerById(BigInteger id) {
String ln = (String) this.redisTemplate.opsForValue().get(lastNameKey(id));
String fn = (String) this.redisTemplate.opsForValue().get(firstNameKey(id));
return new Customer(id, fn, ln);
}
@Override
public Collection<Customer> getAllCustomers() {
String keyPattern = "customer:fn:*";
Set<String> keys = redisTemplate.keys(keyPattern);
Set<Customer> customerSet = new HashSet<Customer>();
for (String firstNameKey : keys) {
long id = Long.parseLong(firstNameKey.split(":")[2]);
customerSet.add(this.getCustomerById(BigInteger.valueOf(id)));
}
return customerSet;
}
@Override
public void deleteCustomer(BigInteger id) {
redisTemplate.opsForValue().getOperations().delete(String.valueOf(id));
}
@Override
public int getTotalRecords() {
return redisTemplate.keys("customer:fn:*").size();
}
private void setCustomerValues(BigInteger lid, String fn, String ln) {
this.redisTemplate.opsForValue().set(lastNameKey(lid), ln);
this.redisTemplate.opsForValue().set(firstNameKey(lid), fn);
}
@Override
public Customer createCustomer(String fn, String ln) {
BigInteger lid = uniqueId();
setCustomerValues(lid, fn, ln);
return getCustomerById(lid);
}
}
4. Setup Redis Controller
package com.example.controller;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import com.example.redis.RedisCustomerService;
@Controller
@RequestMapping("/redis")
public class RedisController {
@Autowired
RedisCustomerService redisCustomerService;
@RequestMapping("")
public String redisView(Map<String, Object> map){
map.put("redisCustomerList", redisCustomerService.getAllCustomers());
return "redis";
}
@RequestMapping(value="/insert")
public String insertCustomersView(){
return "insertredis";
}
@RequestMapping(value="/insert", method=RequestMethod.POST)
public String insertCustomers(Map<String, Object> map, @RequestParam("firstName") String firstName, @RequestParam("lastName") String lastName) {
redisCustomerService.createCustomer(firstName, lastName);
return "redis";
}
@RequestMapping(value="/delete/{id}", method=RequestMethod.POST)
public String deleteCustomer(@PathVariable("id") String id, Map<String, Object> map){
redisCustomerService.deleteCustomer(new BigInteger(id));
map.put("redisCustomerList", redisCustomerService.getAllCustomers());
return "redis";
}
@RequestMapping(value="/update/{id}", method=RequestMethod.GET)
public String updateCustomerView(@PathVariable("id") String id, Map<String, Object> map){
map.put("redisupdate", Arrays.asList(redisCustomerService.getCustomerById(new BigInteger(id))));
return "updateredis";
}
@RequestMapping(value="/update/{id}", method=RequestMethod.POST)
public String updateCustomer(@PathVariable("id") String id, Map<String, Object> map, @RequestParam("firstName") String firstName, @RequestParam("lastName") String lastName){
redisCustomerService.updateCustomer(new BigInteger(id), firstName, lastName);
map.put("redisCustomerList", redisCustomerService.getAllCustomers());
return "redis";
}
}
Thys Michels Blog 