iSharkFly-Docs
/
java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Example code for using Multiple Cache Manager in SpringBoot

This commit is contained in:
Ankur Gupta 2020-04-10 03:57:55 +05:30
parent 65a6083cd6
commit a9ab80c75e
24 changed files with 443 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
hexagonaljava/src/main/java/com/baeldung/hexagonaljava/HexagonaljavaApplication.java
View File

@ -1,12 +0,0 @@
package com.baeldung.hexagonaljava;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class HexagonaljavaApplication {
public static void main(String[] args) {
SpringApplication.run(HexagonaljavaApplication.class, args);
}
}

28
hexagonaljava/src/main/java/com/baeldung/hexagonaljava/controller/StudentResultController.java
View File

@ -1,28 +0,0 @@
package com.baeldung.hexagonaljava.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import com.baeldung.hexagonaljava.entity.Student;
import com.baeldung.hexagonaljava.service.StudentResultService;
@RestController
public class StudentResultController {
@Autowired
private StudentResultService studentResultService;
@PostMapping(value = "/save")
public void saveStudent(@RequestBody Student student) {
studentResultService.save(student);
}
@GetMapping(value = "/getTotalMarks/{id}")
public Double getTotalMarks(@PathVariable Integer id) {
return studentResultService.getTotalMarks(id);
}
}

36
hexagonaljava/src/main/java/com/baeldung/hexagonaljava/entity/Student.java
View File

@ -1,36 +0,0 @@
package com.baeldung.hexagonaljava.entity;
import java.util.Map;
public class Student {
private Integer id;
private String name;
private Map<String, Double> marks;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Map<String, Double> getMarks() {
return marks;
}
public void setMarks(Map<String, Double> marks) {
this.marks = marks;
}
}

72
hexagonaljava/src/main/java/com/baeldung/hexagonaljava/repository/StudentResultJdbcRepoImpl.java
View File

@ -1,72 +0,0 @@
package com.baeldung.hexagonaljava.repository;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.stereotype.Component;
import com.baeldung.hexagonaljava.entity.Student;
@Primary
@Component
public class StudentResultJdbcRepoImpl implements StudentResultRepo {
@Autowired
JdbcTemplate jdbcTemplate;
@Override
public void save(Student student) {
jdbcTemplate.update("insert into student (id, name) " + "values(?, ?)", new Object[] { student.getId(), student.getName() });
insertResult(student);
}
public void insertResult(Student student) {
String insertQuery = "insert into " + "studentresult " + "(subject,marks,id) " + "values " + "(?,?,?)";
for (final Map.Entry<String, Double> entry : student.getMarks()
.entrySet()) {
this.jdbcTemplate.batchUpdate(insertQuery, new BatchPreparedStatementSetter() {
@Override
public void setValues(final PreparedStatement ps, final int i) throws SQLException {
ps.setString(1, entry.getKey());
ps.setDouble(2, entry.getValue());
ps.setInt(3, student.getId());
}
public int getBatchSize() {
return student.getMarks()
.size();
}
});
}
}
@Override
public Student getStudent(Integer id) {
String selectQuery = "select * from ( select * from student where id = ? ) s left join studentresult on s.id = studentresult.id";
Student student = new Student();
jdbcTemplate.query(selectQuery, new Object[] { id }, new RowCallbackHandler() {
public void processRow(ResultSet rs) throws SQLException {
while (rs.next()) {
if (student.getId() == null) {
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setMarks(new HashMap<String, Double>());
}
String subject = rs.getString("subject");
Double marks = rs.getDouble("marks");
student.getMarks()
.put(subject, marks);
}
}
});
return student;
}
}

10
hexagonaljava/src/main/java/com/baeldung/hexagonaljava/repository/StudentResultRepo.java
View File

@ -1,10 +0,0 @@
package com.baeldung.hexagonaljava.repository;
import com.baeldung.hexagonaljava.entity.Student;
public interface StudentResultRepo {
void save(Student student);
Student getStudent(Integer id);
}

24
hexagonaljava/src/main/java/com/baeldung/hexagonaljava/repository/StudentResultRepoImpl.java
View File

@ -1,24 +0,0 @@
package com.baeldung.hexagonaljava.repository;
import java.util.HashMap;
import java.util.Map;
import org.springframework.stereotype.Repository;
import com.baeldung.hexagonaljava.entity.Student;
@Repository
public class StudentResultRepoImpl implements StudentResultRepo {
private Map<Integer, Student> studentsMap = new HashMap<Integer, Student>();
@Override
public void save(Student student) {
studentsMap.put(student.getId(), student);
}
@Override
public Student getStudent(Integer id) {
return studentsMap.get(id);
}
}

10
hexagonaljava/src/main/java/com/baeldung/hexagonaljava/service/StudentResultService.java
View File

@ -1,10 +0,0 @@
package com.baeldung.hexagonaljava.service;
import com.baeldung.hexagonaljava.entity.Student;
public interface StudentResultService {
void save(Student student);
Double getTotalMarks(Integer id);
}

30
hexagonaljava/src/main/java/com/baeldung/hexagonaljava/service/StudentResultServiceImpl.java
View File

@ -1,30 +0,0 @@
package com.baeldung.hexagonaljava.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.baeldung.hexagonaljava.entity.Student;
import com.baeldung.hexagonaljava.repository.StudentResultRepo;
@Component
public class StudentResultServiceImpl implements StudentResultService {
@Autowired
private StudentResultRepo studentResultRepo;
@Override
public void save(Student student) {
studentResultRepo.save(student);
}
@Override
public Double getTotalMarks(Integer id) {
Student student = studentResultRepo.getStudent(id);
double totalMarks = 0;
for (double marks : student.getMarks()
.values()) {
totalMarks += marks;
}
return totalMarks;
}
}

11
hexagonaljava/src/main/resources/schema.sql
View File

@ -1,11 +0,0 @@
CREATE TABLE STUDENT (
id INT PRIMARY KEY,
name VARCHAR(250) NOT NULL
);
CREATE TABLE STUDENTRESULT(
subject VARCHAR(250) NOT NULL,
marks NUMERIC(8,2),
id VARCHAR(250),
FOREIGN KEY (id) references STUDENT(id)
);

41
hexagonaljava/pom.xml → multiplecachemanager/pom.xml
View File

@ -5,25 +5,45 @@
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.5.RELEASE</version>
<version>2.2.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.baeldung.</groupId>
<artifactId>hexagonaljava</artifactId>
<groupId>com.baeldung</groupId>
<artifactId>multiplecachemanager</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>hexagonaljava</name>
<description>Demo project for Spring Boot</description>
<name>multiplecachemanager</name>
<description>sample project for configuring multiple cache managers</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
@ -35,17 +55,6 @@
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
<build>

45
multiplecachemanager/src/main/java/com/baeldung/multiplecachemanager/MultiplecachemanagerApplication.java Normal file
View File

@ -0,0 +1,45 @@
package com.baeldung.multiplecachemanager;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
import org.springframework.cache.interceptor.CacheResolver;
import org.springframework.context.annotation.Bean;
import com.baeldung.multiplecachemanager.config.MultipleCacheResolver;
import com.github.benmanes.caffeine.cache.Caffeine;
@SpringBootApplication
@EnableCaching
public class MultiplecachemanagerApplication extends CachingConfigurerSupport {
public static void main(String[] args) {
SpringApplication.run(MultiplecachemanagerApplication.class, args);
}
@Bean
// @Primary
public CacheManager cacheManager() {
CaffeineCacheManager cacheManager = new CaffeineCacheManager("customers", "orders");
cacheManager.setCaffeine(Caffeine.newBuilder()
.initialCapacity(200)
.maximumSize(500)
.weakKeys()
.recordStats());
return cacheManager;
}
@Bean
public CacheManager alternateCacheManager() {
return new ConcurrentMapCacheManager("customerOrders", "orderprice");
}
@Bean
public CacheResolver cacheResolver() {
return new MultipleCacheResolver(alternateCacheManager(), cacheManager());
}
}

28
multiplecachemanager/src/main/java/com/baeldung/multiplecachemanager/bo/CustomerDetailBO.java Normal file
View File

@ -0,0 +1,28 @@
package com.baeldung.multiplecachemanager.bo;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;
import com.baeldung.multiplecachemanager.entity.Customer;
import com.baeldung.multiplecachemanager.entity.Order;
import com.baeldung.multiplecachemanager.repository.CustomerDetailRepository;
@Component
public class CustomerDetailBO {
@Autowired
private CustomerDetailRepository customerDetailRepository;
@Cacheable(cacheNames = "customers")
public Customer getCustomerDetail(Integer customerId) {
return customerDetailRepository.getCustomerDetail(customerId);
}
@Cacheable(cacheNames = "customerOrders", cacheManager = "alternateCacheManager")
public List<Order> getCustomerOrders(Integer customerId) {
return customerDetailRepository.getCustomerOrders(customerId);
}
}

25
multiplecachemanager/src/main/java/com/baeldung/multiplecachemanager/bo/OrderDetailBO.java Normal file
View File

@ -0,0 +1,25 @@
package com.baeldung.multiplecachemanager.bo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;
import com.baeldung.multiplecachemanager.entity.Order;
import com.baeldung.multiplecachemanager.repository.OrderDetailRepository;
@Component
public class OrderDetailBO {
@Autowired
private OrderDetailRepository orderDetailRepository;
@Cacheable(cacheNames = "orders", cacheResolver = "cacheResolver")
public Order getOrderDetail(Integer orderId) {
return orderDetailRepository.getOrderDetail(orderId);
}
@Cacheable(cacheNames = "orderprice", cacheResolver = "cacheResolver")
public double getOrderPrice(Integer orderId) {
return orderDetailRepository.getOrderPrice(orderId);
}
}

38
multiplecachemanager/src/main/java/com/baeldung/multiplecachemanager/config/MultipleCacheResolver.java Normal file
View File

@ -0,0 +1,38 @@
package com.baeldung.multiplecachemanager.config;
import java.util.ArrayList;
import java.util.Collection;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.interceptor.CacheOperationInvocationContext;
import org.springframework.cache.interceptor.CacheResolver;
public class MultipleCacheResolver implements CacheResolver {
private final CacheManager simpleCacheManager;
private final CacheManager caffeineCacheManager;
private static final String ORDER_CACHE = "orders";
private static final String ORDER_PRICE_CACHE = "orderprice";
public MultipleCacheResolver(CacheManager simpleCacheManager, CacheManager caffeineCacheManager) {
this.simpleCacheManager = simpleCacheManager;
this.caffeineCacheManager = caffeineCacheManager;
}
@Override
public Collection<? extends Cache> resolveCaches(CacheOperationInvocationContext<?> context) {
Collection<Cache> caches = new ArrayList<Cache>();
if ("getOrderDetail".equals(context.getMethod()
.getName())) {
caches.add(caffeineCacheManager.getCache(ORDER_CACHE));
} else {
caches.add(simpleCacheManager.getCache(ORDER_PRICE_CACHE));
}
return caches;
}
}

43
multiplecachemanager/src/main/java/com/baeldung/multiplecachemanager/controller/MultipleCacheManagerController.java Normal file
View File

@ -0,0 +1,43 @@
package com.baeldung.multiplecachemanager.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import com.baeldung.multiplecachemanager.bo.CustomerDetailBO;
import com.baeldung.multiplecachemanager.bo.OrderDetailBO;
import com.baeldung.multiplecachemanager.entity.Customer;
import com.baeldung.multiplecachemanager.entity.Order;
@RestController
public class MultipleCacheManagerController {
@Autowired
private CustomerDetailBO customerDetailBO;
@Autowired
private OrderDetailBO orderDetailBO;
@GetMapping(value = "/getCustomer/{customerid}")
public Customer getCustomer(@PathVariable Integer customerid) {
return customerDetailBO.getCustomerDetail(customerid);
}
@GetMapping(value = "/getCustomerOrders/{customerid}")
public List<Order> getCustomerOrders(@PathVariable Integer customerid) {
return customerDetailBO.getCustomerOrders(customerid);
}
@GetMapping(value = "/getOrder/{orderid}")
public Order getOrder(@PathVariable Integer orderid) {
return orderDetailBO.getOrderDetail(orderid);
}
@GetMapping(value = "/getOrderPrice/{orderid}")
public double getOrderPrice(@PathVariable Integer orderid) {
return orderDetailBO.getOrderPrice(orderid);
}
}

24
multiplecachemanager/src/main/java/com/baeldung/multiplecachemanager/entity/Customer.java Normal file
View File

@ -0,0 +1,24 @@
package com.baeldung.multiplecachemanager.entity;
public class Customer {
private int customerId;
private String customerName;
public int getCustomerId() {
return customerId;
}
public void setCustomerId(int customerId) {
this.customerId = customerId;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
}

34
multiplecachemanager/src/main/java/com/baeldung/multiplecachemanager/entity/Item.java Normal file
View File

@ -0,0 +1,34 @@
package com.baeldung.multiplecachemanager.entity;
public class Item {
private int itemId;
private String itemDesc;
private double itemPrice;
public int getItemId() {
return itemId;
}
public void setItemId(int itemId) {
this.itemId = itemId;
}
public String getItemDesc() {
return itemDesc;
}
public void setItemDesc(String itemDesc) {
this.itemDesc = itemDesc;
}
public double getItemPrice() {
return itemPrice;
}
public void setItemPrice(double itemPrice) {
this.itemPrice = itemPrice;
}
}

44
multiplecachemanager/src/main/java/com/baeldung/multiplecachemanager/entity/Order.java Normal file
View File

@ -0,0 +1,44 @@
package com.baeldung.multiplecachemanager.entity;
public class Order {
private int orderId;
private int itemId;
private int quantity;
private int customerId;
public int getOrderId() {
return orderId;
}
public void setOrderId(int orderId) {
this.orderId = orderId;
}
public int getItemId() {
return itemId;
}
public void setItemId(int itemId) {
this.itemId = itemId;
}
public int getQuantity() {
return quantity;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
public int getCustomerId() {
return customerId;
}
public void setCustomerId(int customerId) {
this.customerId = customerId;
}
}

49
multiplecachemanager/src/main/java/com/baeldung/multiplecachemanager/repository/CustomerDetailRepository.java Normal file
View File

@ -0,0 +1,49 @@
package com.baeldung.multiplecachemanager.repository;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.stereotype.Repository;
import com.baeldung.multiplecachemanager.entity.Customer;
import com.baeldung.multiplecachemanager.entity.Order;
@Repository
public class CustomerDetailRepository {
@Autowired
private JdbcTemplate jdbcTemplate;
public Customer getCustomerDetail(Integer customerId) {
String customerQuery = "select * from customer where customerid = ? ";
Customer customer = new Customer();
jdbcTemplate.query(customerQuery, new Object[] { customerId }, new RowCallbackHandler() {
public void processRow(ResultSet rs) throws SQLException {
customer.setCustomerId(rs.getInt("customerid"));
customer.setCustomerName(rs.getString("customername"));
}
});
return customer;
}
public List<Order> getCustomerOrders(Integer customerId) {
String customerOrderQuery = "select * from orderdetail where customerid = ? ";
List<Order> orders = new ArrayList<Order>();
jdbcTemplate.query(customerOrderQuery, new Object[] { customerId }, new RowCallbackHandler() {
public void processRow(ResultSet rs) throws SQLException {
Order order = new Order();
order.setCustomerId(rs.getInt("customerid"));
order.setItemId(rs.getInt("orderid"));
order.setOrderId(rs.getInt("orderid"));
order.setQuantity(rs.getInt("quantity"));
orders.add(order);
}
});
return orders;
}
}

53
multiplecachemanager/src/main/java/com/baeldung/multiplecachemanager/repository/OrderDetailRepository.java Normal file
View File

@ -0,0 +1,53 @@
package com.baeldung.multiplecachemanager.repository;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.stereotype.Repository;
import com.baeldung.multiplecachemanager.entity.Item;
import com.baeldung.multiplecachemanager.entity.Order;
@Repository
public class OrderDetailRepository {
@Autowired
private JdbcTemplate jdbcTemplate;
public Order getOrderDetail(Integer orderId) {
String orderDetailQuery = "select * from orderdetail where orderid = ? ";
Order order = new Order();
jdbcTemplate.query(orderDetailQuery, new Object[] { orderId }, new RowCallbackHandler() {
public void processRow(ResultSet rs) throws SQLException {
order.setCustomerId(rs.getInt("customerid"));
order.setOrderId(rs.getInt("orderid"));
order.setItemId(rs.getInt("itemid"));
order.setQuantity(rs.getInt("quantity"));
}
});
return order;
}
public double getOrderPrice(Integer orderId) {
String orderItemJoinQuery = "select * from ( select * from orderdetail where orderid = ? ) o left join item on o.itemid = ITEM.itemid";
Order order = new Order();
Item item = new Item();
jdbcTemplate.query(orderItemJoinQuery, new Object[] { orderId }, new RowCallbackHandler() {
public void processRow(ResultSet rs) throws SQLException {
order.setCustomerId(rs.getInt("customerid"));
order.setOrderId(rs.getInt("orderid"));
order.setItemId(rs.getInt("itemid"));
order.setQuantity(rs.getInt("quantity"));
item.setItemDesc("itemdesc");
item.setItemId(rs.getInt("itemid"));
item.setItemPrice(rs.getDouble("price"));
}
});
return order.getQuantity() * item.getItemPrice();
}
}

7
hexagonaljava/src/main/resources/application.properties → multiplecachemanager/src/main/resources/application.properties
View File

@ -2,4 +2,9 @@ spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.h2.console.enabled=false
#spring.h2.console.enabled=false
# Enabling H2 Console
spring.h2.console.enabled=true
spring.h2.console.path=/h2

7
multiplecachemanager/src/main/resources/data.sql Normal file
View File

@ -0,0 +1,7 @@
INSERT INTO CUSTOMER VALUES(1001,'BAELDUNG');
INSERT INTO ITEM VALUES(10001,'ITEM1',50.0);
INSERT INTO ITEM VALUES(10002,'ITEM2',100.0);
INSERT INTO ORDERDETAIL VALUES(300001,1001,10001,2);
INSERT INTO ORDERDETAIL VALUES(300002,1001,10002,5);

19
multiplecachemanager/src/main/resources/schema.sql Normal file
View File

@ -0,0 +1,19 @@
CREATE TABLE CUSTOMER(
CUSTOMERID INT PRIMARY KEY,
CUSTOMERNAME VARCHAR(250) NOT NULL
);
CREATE TABLE ITEM(
ITEMID INT PRIMARY KEY,
ITEMDESC VARCHAR(250),
PRICE DOUBLE
);
CREATE TABLE ORDERDETAIL(
ORDERID INT PRIMARY KEY,
CUSTOMERID INT NOT NULL,
ITEMID INT NOT NULL,
QUANTITY INT,
FOREIGN KEY (customerid) references CUSTOMER(customerid),
FOREIGN KEY (itemid) references ITEM(itemid)
);

5
hexagonaljava/src/test/java/com/baeldung/hexagonaljava/HexagonaljavaApplicationTests.java → multiplecachemanager/src/test/java/com/baeldung/multiplecachemanager/MultiplecachemanagerApplicationTests.java
View File

@ -1,12 +1,13 @@
package com.baeldung.hexagonaljava;
package com.baeldung.multiplecachemanager;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class HexagonaljavaApplicationTests {
class MultiplecachemanagerApplicationTests {
@Test
void contextLoads() {
}
}