MongoDB์ ์ ์ง์ฑ ๋ํ๋จผํธ
MongoDB : ์คํ์์ค ๋ํ๋จผํธ ๋ฐ์ดํฐ(๋น์ ๊ทํ ๋ ๊ตฌ์กฐ์ ์ ๋ณด) ๋ฒ ์ด์ค
-> ์คํ๋ง์์๋ ์ฌ์ฉ ๊ฐ๋ฅ - ์ฌ์ฉํ๋ ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ
๊ฐ์ฒด ๋ํ๋จผํธ ๋งคํ์ ์ํ ์ ๋ํ
์ด์
MongoTemplate์ ์ฌ์ฉํ ํ
ํ๋ฆฟ ๊ธฐ๋ฐ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ก์ธ์ค
์๋ ๋ฐํ์ ์ ์ฅ์ ์์ฑ
์คํ๋ง ๋ฐ์ดํฐ JPA์ ๋ฌ๋ฆฌ, ์คํ๋ง ๋ฐ์ดํฐ MongoDB๋ ์๋ฐ ๊ฐ์ฒด๋ฅผ ๋ํ๋จผํธ์ ๋งคํํ๊ธฐ ์ํ ์ ๋ํ
์ด์
์ ์ ๊ณต. ๋ํ MongoDB๋ ๋ค์์ ์ผ๋ฐ ๋ํ๋จผํธ ์ฒ๋ฆฌ ํ์คํฌ๋ฅผ ์ํ ํ
ํ๋ฆฟ ๊ธฐ๋ฐ ๋ฐ์ดํฐ ์ก์ธ์ค๋ฅผ ์ ๊ณต
MongoDB ํ์ฑํ
@Configuration
@EnableMongoRepositories("orders.db")
public class MongoConfig extends AbstractMongoConfiguration {
@Override
protected String getDatabaseName() {
return "OrdersDB"; // ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ช
์ ์ง์ ํด์ค๋ค.
}
@Override
public Mongo mongo() throws Exception { // Mongoํด๋ผ์ด์ธํธ๋ฅผ ์์ฑ
return new MongoClient("mongodbserver", 37017); // ๋๋น ์๋ฒ ์ค์ ๊ณผ ํฌํธ์ค์ (๊ธฐ๋ณธ localhost, 27017)
}
}
=> AbstractMongoConfiguration(์ต๊ทผ ๋ฒ์ ์์๋ depreacted) ์ ์ฌ์ฉํ์ฌ ์์์ ์ผ๋ก ์ง์ MongoTemplate์ ์ ์ธํ์ง ์์. MongoFactoryBean์ ์ฌ์ฉํ์ง ์๊ณ ๋ฐ๋ก MongoClient() ์ฌ์ฉ
* MongoDB์ ์ธ์ฆ๋ ์๋ฒ๋ก ์ก์ธ์ค๊ฐ ํ์ํ ์๊ฐ ์์
@Override
public Mongo mongo() throws Exception {
MongoCredential credential = MongoCredential.createMongoCRCredential(
env.getProperty("mongo.username"),"OrdersDB", env.getProperty("mongo.password").toCharArray());
return new MongoClient(new ServerAddress("localhost", 37017),Arrays.asList(credential));
// ์ธ์ฆ์ ๋ณด๊ฐ ํฌํจ๋ MongoClient ๋ง๋ค๊ธฐ
}
MongoDB ํผ์์คํดํธ๋ฅผ ์ํ ์ ๋ํ
์ด์
๋ชจ๋ธ ํ์
MongoDB๋ ๊ฐ์ฒด-๋ํ๋จผํธ ๋งคํ ์ ๋ํ
์ด์
์ ๊ฐ์ง์ง ์์ผ๋ฉฐ, ๋จ์ง ๊ฐญ์ ์ฑ์ธ ์ ์๋ ๊ธฐํ๋ฅผ ๊ฐ์ง๋ค. ์๋ฐ ํ์
์ MongoDB ๋ํ๋จผํธ์ ๋งคํํ๋ค
@Document @Id๋ JPA์ @Entity, @Id์ ๋น์ทํ๋ค
@Document // ๋ํ๋จผํธ
public class Order {
@Id // ์์ด๋ ์ ์ธ
private String id;
@Field("client") // ๊ธฐ๋ณธ ํ๋๋ช
์ค๋ฒ๋ผ์ด๋
private String customer; // ์ปค์คํฐ๋จธ ํ๋กํผํด๋ @Feild๋ก ์ ๋ํ
์ด์
๋๊ณ , ๋ํ๋จผํธ๊ฐ ์ง์ ์ ์ง๋ ๋ field๋ก ๋ช
๋ช
๋ ํด๋ผ์ด์ธํธ๋ก ๋งคํ
private String type;
private Collection<Item> items = new LinkedHashSet<Item>();
public String getCustomer() {
return customer;
}
public void setCustomer(String customer) {
this.customer = customer;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
*item์ ๊ฒฝ์ฐ๋ JPA์์ @OneToMany๋ก ์ ๋ํ
์ด์
๋์ด์๊ณ , ๋
๋ฆฝ๋ ํ
์ด๋ธ๋ก ๊ด๋ฆฌ๋๋ ๊ฒฝ์ฐ์ด๋ค.(์์)
MongoTemplate์ ์ฌ์ฉํ์ฌ MongoDB ์ก์ธ์ค
AbstractAbstractMongoConfiguration์ ํ์ฅํ์ฌ MongoTemplate ๋น์ ์ค์ ํ์๋ค
MongoTemplate์ ๊ตฌํ ์ธํฐํ์ด์ค์ธ MongoOperations์ ํ์
์ผ๋ก ํ๋กํผํฐ๋ฅผ ์ฃผ์
์ ํด์ผํจ
@Autowired
MongoOperations mongo;
* MongoOperations๋ MongoDB๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํ, ์ฌ๋ฌ ์ ์ฉํ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค. ์๋๋ ๊ทธ๋ฌํ ๋ฉ์๋๋ค์ ์์์ด๋ค.
// ์ปฌ๋ ์
์ ๊ฐ์ง๊ณ , ํด๋น ์ปฌ๋ ์
์ ์๋ฅผ ์ธ๋ count()
long orderCount = mongo.getCollection("order").count();
// ์ ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋ save()
Order order = new Order();
order.set~~~ // ๊ฐ์ฒด ๊ฐ ์ค์
~~~
mongo.save(order, "order");
// ID์ ๋ฐ๋ผ ๊ฒ์์ ํ๋ findById()
String orderId = test;
Order order = mongo.findById(orderId, Order.class);
// Query๋ก ๊ณ ๊ธ ๊ฒ์์ ๊ฐ๋ฅํ ๊ฒ ํ๋ find()
List<Order> chucksOrders = mongo.find(Query.query(
Criteria.where("client").is("Chuck Wagon")), Order.class);
// ํด๋ผ์ด์ธํธํ๋๊ฐ "Chuck Wagon"์ธ ๋ชจ๋ ์ผ์ด์ค
List<Order> chucksWebOrders = mongo.find(Query.query(
Criteria.where("customer").is("Chuck Wagon")
.and("type").is("WEB")), Order.class);
// Crieteria๋ ํ ๊ฐ์ ํ๋๋ฅผ ์ฒดํฌํ๋ ์ฟผ๋ฆฌ๋ฅผ ์์ฑํ๊ธฐ ์ํด ์ฌ์ฉ. WEB์ ํตํด Chuck์ ๋ชจ๋ Order๋ฅผ ์ป์
// ๋ํ๋จผํธ๋ฅผ ์ญ์ ํ๋ remove()
mongo.remove(order);
MongoDB ์ ์ฅ์ ์์ฑ
* ์ผ๋ฐ์ ์ผ๋ก, ๋ง๋ ์ ์ฅ์ ํด๋์ค์ MongoOperations๋ฅผ ์ฃผ์
ํ๊ณ ๋ฉ์๋๋ฅผ ๊ตฌํํ๋ค. ๊ทธ๋ฌ๋ ์ ์ฅ์๋ฅผ ์์ฑํ๋๋ฐ ์ ๋ฅผ ์ฐ๊ณ ์ถ์ง ์๋ค๋ฉด, ๋ฐํ์ ์์ ์๋์ผ๋ก ์ ์ฅ์๋ฅผ ๊ตฌํํ๊ฒ ํ๋ค.
OrderRepository ์ธํฐํ์ด์ค๋ก, Order ๋ํ๋จผํธ๋ฅผ ์ํ ๊ธฐ๋ณธ CRUD ๋์์ ์ ๊ณตํ๊ธฐ ์ํด MongoRepository๋ฅผ ํ์ฅํ๋ค.
public interface OrderRepository extends MongoRepository<Order, String> {}
// MongoRepsoitory< ๋ํ๋จผํธ , ์์ด๋ >
* ์ ์ฅ์, JpaRepositoryํ์ฅ๊ฐ ๋ง์ฐฌ๊ฐ์ง๋ก, ๋ฐํ์ ์์ ์ ์ฅ์์ ๊ตฌํ์ฒด๋ฅผ ์์ฑํ๋ค.
๋ง์ถคํ ์ฟผ๋ฆฌ ๋ฉ์๋
* JPA๋์ ํฌ๊ฒ ๋ค๋ฅด์ง ์๋ค.
List<Order> findByCustomer(String c) - ๋ฑ
* ๋์ฌ - ๋์ By - ์กฐ๊ฑด
์ฟผ๋ฆฌ ์ง์ ํ๊ธฐ
@Query ์ ๋ํ
์ด์
์ฌ์ฉ
@Query("{'customer': 'Chuck Wagon', 'type' : ?0}")
List<Order> findChucksOrders(String t);
-> JPA์ ๋์ผ
๋ง์ถคํ ์ ์ฅ์ ํผํฉ
... JPA์ ๋์ผ
public interface OrderOperations {
List<Order> findOrdersByType(String t);
}
// ์ค๊ฐ ๋ฒ์ ์ ์ธํฐํ์ด์ค ์ ์
Impl ์ฌ์ฉ
public class OrderRepositoryImpl implements OrderOperations {
@Autowired
private MongoOperations mongo; // MongoOperation ์ฃผ์
public List<Order> findOrdersByType(String t) {
String type = t.equals("NET") ? "WEB" : t;
Criteria where = Criteria.where("type").is(t);
Query query = Query.query(where); // ์ฟผ๋ฆฌ ์์ฑ
return mongo.find(query, Order.class); // ์ฟผ๋ฆฌ ์ํ
}
}
๋ง์ง๋ง์ผ๋ก ์ค๊ฐ๋ฒ์ ์ ์ธํฐํ์ด์ค ํ์ฅ์ ์ํ, ์ ์ฅ์ ์ธํฐํ์ด์ค ๋ณ๊ฒฝ
public interface OrderRepository
extends MongoRepository<Order, String>, OrderOperations { ~~~ }
Neo4j๋ก ๊ทธ๋ํ ๋ฐ์ดํฐ ์ฌ์ฉํ๊ธฐ
Neo4j : ๊ทธ๋ํ ๋ฐ์ดํฐ๋ฒ ์ด์ค - ๊ด๊ณ๋ฅผ ์ ์ฅํ๊ณ ํ์ํ๋๋ก ํน๋ณํ ๊ตฌ์ถ๋์์ต๋๋ค. ๋
ธ๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ ์ํฐํฐ๋ฅผ ์ ์ฅํ๊ณ ์ฃ์ง๋ก๋ ์ํฐํฐ ๊ฐ์ ๊ด๊ณ๋ฅผ ์ ์ฅํฉ๋๋ค. ์ฃ์ง๋ ํญ์ ์์ ๋
ธ๋, ๋ ๋
ธ๋, ์ ํ๊ณผ ๋ฐฉํฅ์ ๊ฐ์ง๋ฉฐ, ์-ํ์ ๊ด๊ณ, ๋์, ์์ ์ ๋ฑ์ ๋ฌธ์ํ ํฉ๋๋ค. ํ๋์ ๋
ธ๋๊ฐ ๊ฐ์ง ์ ์๋ ๊ด๊ณ์ ์์ ์ข
๋ฅ์๋ ์ ํ์ด ์์.
* MongoDB์ JPA์ ๋์ผํ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ค
์คํ๋ง์ผ๋ก Neo4j ์ค์ ํ๊ธฐ
@EnableNeo4jRepositories : Neo4j ์๋์ ์ฅ์ ํ์ฑํ ์ ๋ํ
์ด์
@Configuration
@EnableNeo4jRepositories(basePackages="orders.db") // ์๋ ์ ์ฅ์ ํ์ฑํ, marker Repository ํ์ฅ ํ, ์ธํฐํ์ด์ค์ฉ db ํจํค์ง๋ฅผ ์ค์บ
public class Neo4jConfig extends Neo4jConfiguration {
public Neo4jConfig() { // ์์ฑ์, ordersํจํค์ง์, ๋ชจ๋ธ ํด๋์ค๋ฅผ ์ฐพ๋๋ค
setBasePackage("orders"); // ๋ชจ๋ธ ๋ฒ ์ด์ค ํจํค์ง ์ธํ
}
@Bean(destroyMethod="shutdown")
public GraphDatabaseService graphDatabaseService() { // ์ฐธ์กฐํ๋ ๊ทธ๋ํ๋ฐ์ดํฐ๋ฒ ์ด์ค
return new GraphDatabaseFactory()
.newEmbeddedDatabase("/tmp/graphdb"); // ์๋ฒ ๋๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค ํจํค์ง ์ค์ (์ธ๋ฉ๋ชจ๋ฆฌ ์๋), ์ ํ๋ฆฌ์ผ์ด์
์ ์ผ๋ถ๋ก JVM ๋ด์์ ๋์
}
/*
@Bean(destroyMethod="shutdown")
public GraphDatabaseService graphDatabaseService() {
return new SpringRestGraphDatabase(
"http://grephdb:7575/db/data/", env.getProperty("db.username"), env.getProperty("db.password")
);
// ์๊ฒฉ์๋ฒ + ๋ณด์ ์์๊ฐ ์๋ ๊ฒฝ์ฐ
}
*/
}
๊ทธ๋ํ ์ํฐํฐ ์ ๋ํ
์ด์
Neo4j์์๋, ์๋์ ์ ๋ํ
์ด์
์ ์ฌ์ฉํ์ฌ, ๋
ธ๋์ ๊ด๊ณ ๋ฑ์ ์ ๋ํ
์ด์
ํ๋ค.
๋
ธ๋ ์ํฐํฐ๋, @NodeEntity.. ๊ด๊ณ ์ํฐํฐ๋ @RelationshipEntity๋ก ์ ๋ํ
์ด์
ํ๋ค. ๋จ์ํ ๋
ธ๋๋ผ๋ฆฌ์ ๊ด๊ณ๋ @RelationTo ์ ๋ํ
์ด์
์ผ๋ก ์ ์ ๊ฐ๋ฅ
@NodeEntity // Order๋ ๋
ธ๋์ํฐํฐ
public class Order {
@GraphId // ๊ทธ๋ํ ์์ด๋
private Long id;
private String customer;
private String type;
// items ํ๋กํผํฐ๋, Order์ Item์ Set์ ๊ด๊ณ๋จ
@RelatedTo(type="HAS_ITEMS")
private Set<Item> items = new LinkedHashSet<Item>();
~~~
}
@NodeEntity // ์์ดํ
๋
ธ๋
public class Item {
@GraphId // ๊ทธ๋ํ์ ์์ด๋
private Long id;
private String product;
private double price;
private int quantity;
~~~
}
==>์กฐ๊ธ ๋ ๋ณต์กํ ๊ฒฝ์ฐ
* @RelationShipEntity ์ฌ์ฉ !!
@RelationshipEntity(type="HAS_LINE_ITEM_FOR") // ๊ด๊ณ์ํฐํฐ, ํ์
์ ์
public class LineItem {
@GraphId // ๊ทธ๋ํ ์์ด๋
private Long id;
@StartNode // ์์ ๋
ธ๋
private Order order;
@EndNode // ๋๋๋ ๋
ธ๋
private Product product;
// ๊ด๊ณ์ํฐํฐ์ ์์ฒด ํ๋กํผํฐ
private int quantity;
~~~
}
* LineItem ๊ด๊ณ ์์ฑ ์, ๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ด์ ์ ์ง๋๋ quanity ํ๋กํผํฐ๋ฅผ ๊ฐ์ง๋ค.
Neo4jTemplate ์ฌ์ฉํ๊ธฐ
* MongoDB์ ๊ฒฝ์ฐ์ฒ๋ผ, Neo4jConfiguration์ ํ์ฅํ๋ค๋ฉด, Neoj4Template๋น์ด ์๋์ผ๋ก ์์ฑ๋จ
// ๋ง์ฐฌ๊ฐ์ง๋ก, Neo4jOpreations๋ก ์ง์ ์คํ ์์ด์ด๋ง
@Autowired
private Neo4Operations neo4j;
* Neo4Operations๋ ๋ง์ฐฌ๊ฐ์ง๋ก Neo4j๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํ, ์ฌ๋ฌ ์ ์ฉํ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค. ์๋๋ ๊ทธ๋ฌํ ๋ฉ์๋๋ค์ ์์์ด๋ค.
// save() ๋ฉ์๋
Order order = ...;
Order savedOrder = neo4j.save(order);
// findOne() ๋ฉ์๋ - id๊ธฐ๋ฐ // ์กด์ฌํ์ง ์์ผ๋ฉด NotFoundException
Order order = neo4j.findOne(42, Order.class);
// ๊ฐ์ฒด ์ ๋ถ ๊ฒ์ findAll()
EndResult<Order> allOrders = neo4j.findAll(Order.class);
// count()
long orderCount = count(Order.class);
// delete()
neo4j.delete(order);
// ๊ฐ์ฅ ํน์ดํ ๋ฉ์๋์ค ํ๋ createRelastionshipBetween() ๋ฉ์๋ -- ๋ ๋
ธ๋๊ฐ์ ๊ด๊ณ๋ฅผ ๋ง๋ ๋ค
Order order = ...;
Product prod = ...;
LineItem lineItem = neo4j.createRelationshipBetween(order, prod, LineItem.class, "HAS_LINE_ITEM_FOR", false); // order์ prod๊ฐ์ LineItem ๊ด๊ณ๋ฅผ ์์ฑ(type - HAS_LINE_ITEM_FOR)
lineItem.setQuantity(5);
neo4j.save(lineItem);
์๋ ์ ์ฅ์ ๋ง๋ค๊ธฐ
MongoDB์ ๋์ผ.. ๊ฒน์น๋ ๋ด์ฉ์ด ๋ง์์ ์ฝ๋์ ๊ฐ๋จํ ์ค๋ช
์ ๋๋ง ๋จ๊น.
* GraphRepsitory ์ธํฐํ์ด์ค ํ์ฅ
public interface OrderRepository extends GraphRepository<Order> {}
* ํ์ฅ์ผ๋ก ์ป๋ ๋ฉ์๋
* Order saveOrder = orderRepository.save(order) ๋ฑ, ๊ฐ๋จํ๊ฒ ์ฌ์ฉ ๊ฐ๋ฅ
๋ง์ถคํ ์ฟผ๋ฆฌ ๋ฉ์๋
=> MongoDB๋ JPA์ ๋ช
๋ช
๊ท์น์ ๊ฐ์ง๋ง, ์์ ๋๊ณผ๋ ๋ฌ๋ฆฌ OrderRepository์ ์ฟผ๋ฆฌ ๋ฉ์๋๋ฅผ ๋ฐ๋ก ์ง์ ํด์ฃผ์ด์ผํจ
public interface OrderRepository extends GraphRepository<Order> {
List<Order> findByCustomer(String customer);
List<Order> findByCustomerAndType(String customer, String type); // ๋ค๋ฅธ ๋ฉ์๋์ ์ ์ฌํ๋ฉฐ, ์ฃผ์ด์ง ํ์
์ type ํ๋กํผํฐ๋ฅผ ๊ฐ์ง๋ค.
}
๋ง์ถคํ ์ฟผ๋ฆฌ ์ง์ : ๋ง์ฐฌ๊ฐ์ง๋ก @Query ์ ๋ํ
์ด์
์ ์ฌ์ฉํ๋ค
@Query("match (o:Order)-[:HAS_ITEMS]->(i:Item) " +
"where i.product='Spring in Action' return o")
List<Order> findSiAOrders();
๋ง์ถคํ ์ ์ฅ์ ๋์ ํผํฉ
MongoDB์ ๊ฑฐ์ ๋์ผํ๋ค
* OrderOperation ์ค๊ฐ ์ธํฐํ์ด์ค ์์ฑ
public interface OrderOperations {
List<Order> findSiAOrders();
}
* OrderRepository ํ์ฅ
public interface OrderRepository
extends GraphRepository<Order>, OrderOperations {
~~~
}
--> ๋ง์ฐฌ๊ฐ์ง๋ก, Impl ํด๋์ค๋ก ๊ตฌํ์ฒด ํด๋์ค๋ฅผ ๊ฒ์ํจ
* OrderRepositoryImpl
public class OrderRepositoryImpl implements OrderOperations {
private final Neo4jOperations neo4j;
@Autowired
public OrderRepositoryImpl(Neo4jOperations neo4j) {
this.neo4j = neo4j;
}
public List<Order> findSiAOrders() {
Result<Map<String, Object>> result = neo4j.query(
"match (o:Order)-[:HAS_ITEMS]->(i:Item) " +
"where i.product='Spring in Action' return o",
EndResult<Order> endResult = result.to(Order.class);
return IteratorUtil.asList(endResult);
}
}
Redis์์ ํค-๊ฐ ๋ฐ์ดํฐ ์ฌ์ฉ
* ํค-๊ฐ ๋ฐ์ดํฐ๋ฒ ์ด์ค : ๋์
๋๋ฆฌ, ํด์ ๋งต๊ณผ ๊ฐ์, ๋จ์ํ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ์ํ ๋ฐ์ดํฐ ์คํ ๋ฆฌ์ง ํจ๋ฌ๋ค์ - Redis
* ์คํ๋ง ๋ฐ์ดํฐ Redis๋, ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๊ณ , ์ ์ฅํ๊ธฐ ์ํ ํ
ํ๋ฆฟ์ ๊ตฌํ
Redis์ ์ฐ๊ฒฐํ๊ธฐ
์คํ๋ง๋ฐ์ดํฐ๋ Redis๋ฅผ ์ํ 4๊ฐ์ง Connection Factory๋ฅผ ์ ๊ณตํ๋ค
** JedisConnectionFactory **JredisConnectionFactory ** LettuceConnectionFactory ** SrpConnectionFactory
-> ์ฑ
์์๋ JedisConnectionFactory๋ฅผ ์ฌ์ฉ
@Bean
public RedisConnectionFactory redisCF() {
JedisConnectionFactory cf = new JedisConnectionFactory();
cf.setHostName("redis-server"); // ํธ์คํธ ์๋ฒ ์ค์
cf.setPort(7379); // ํฌํธ ์ค์
cf.setPassword("foobared"); // ๋น๋ฐ๋ฒํธ ์ค์
return cf;
}
RedisTemplate ์ฌ์ฉํ๊ธฐ
ConnectionFactory๋ ๊ธฐ๋ณธ์ ์ผ๋ก byte ๋ฐฐ์ด์ ๊ฐ์ ธ์ฌ ์ ์๋ค.
RedisConnectionFactory cf = ...;
RedisConnection conn = cf.getConnection();
// ์ธํ
conn.set("greeting".getBytes(), "Hello World".getBytes())
// ๊ฒ์
byte[] greetingBytes = conn.get("greeting".getBytes());
String greeting = new String(greetingBytes);
ํ์ง๋ง, ์ค์ ๋ก byte๋ฐฐ์ด๋ณด๋ค๋, ์์ ๋ ๋ฒจ์ ๋ฐ์ดํฐ ์ก์ธ์ค๊ฐ ํ์ํ๋ค. ์คํ๋ง๋ฐ์ดํฐ Redis ์ด๋ด ๋ ์ฌ์ฉํ ์ ์๋ 2๊ฐ์ง์ Template์ ์ ๊ณตํ๋ค.
** RedisTemplate ** StringRedisTemplate(ํค, ๋ฐธ๋ฅ๊ฐ ๋ชจ๋ String์ผ ๊ฒฝ์ฐ ๊ถ์ฅ)
RedisConnectionFactory cf = ~~;
RedisTemplate<String, Product> redis = new RedisTemplate<String, Product>();
redis.setConnectionFactory(cf); // ์ผ๋ฐ RedisTemplate์ ๊ฒฝ์ฐ์ ์ง์ ์ ํด์ฃผ์ด์ผํจ
=====
/// ์์ฃผ ์ฌ์ฉํ ๊ฒฝ์ฐ ๋น ์ค์
@Bean
public RedisTemplate<String, Product> redisTemplate(RedisConnectionFactory cf) {
RedisTemplate<String, Product> redis = new RedisTemplate<String, Product>();
redis.setConnectionFactory(cf);
return redis;
}
RedisConnectionFactory cf = ...;
StringRedisTemplate redis = new StringRedisTemplate(cf); // RedisConnectionFactory๋ฅผ ๋ฐ๋ก ํ์ฉ
====
//์์ฃผ ์ฌ์ฉํ ๊ฒฝ์ฐ ๋น ์ค์
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory cf) {
return new StringRedisTemplate(cf);
}
* RedisTemplate๊ฐ ์ง์ํ๋ ๋ค์ํ ๋ฉ์๋
์์..
///// ๋จ์ Value ๋ฉ์๋
// sku ํ๋กํผํฐ์ ๊ฐ์ ๊ฐ์ ธ์ค๊ณ ์ถ์ ๋ ์ค์
redis.opsForValue().set(product.getSku(), product);
// sku๊ฐ 123456์ผ ๋,
Product product = redis.opsForValue().get("123456");
//// ๋ฆฌ์คํธ ๋ฉ์๋ left(์์์ ) right(์ข
๋จ)
// ๋ฆฌ์คํธ์ ์ข
๋จ(์ค๋ฅธ์ชฝ)์ ๊ฐ ์ถ๊ฐ
redis.opsForList().rightPush("cart", product);
// ์ข
๋จ pop ๋ฉ์๋
Product last = redis.opsForList().rightPop("cart");
// ๋จ์ ๊ฐ ์ถ์ถ
List<Product> products = redis.opsForList().range("cart", 2, 12);
//// ์ธํธ ๋ฉ์๋
// ์ธํธ์ ์์ดํ
์ถ๊ฐ
redis.opsForSet().add("cart", product);
// difference, union, intersec
List<Product> diff = redis.opsForSet().difference("cart1", "cart2");
List<Product> union = redis.opsForSet().union("cart1", "cart2");
List<Product> intersect = redis.opsForSet().intersect("cart1", "cart2");
//// ํค ๋ฐ์ธ๋ฉ.. ์ฃผ์ด์ง ํค์ ์ง์คํ๋ค
// cart๋ผ๋ ํค๊ฐ ์ ๊ณตํ๋ ๋ฆฌ์คํธ ์ํธ๋ฆฌ์ Product ๊ฐ์ฒด
BoundOperations<String, Product> cart = redis.boundListOps("cart");
Product popped = cart.rightPop();
cart.rightPush(product1);
cart.rightPush(product2);
ํค์ ๊ฐ์ ์ง๋ ฌ ๋ณํ ์ค์
์ํธ๋ฆฌ๊ฐ Redis์ ํค-๊ฐ์ผ๋ก ์ ์ฅ๋ ๊ฒ์ ์ง๋ ฌํํ๋ ์ง๋ ฌ ๋ณํ๊ธฐ๋ฅผ, ์คํ๋ง ๋ฐ์ดํฐ Redis๊ฐ ์ง์ํ๋ค
GenericToStringSerializer - ์ผ๋ฐ์ ์ธ ์คํ๋ง ๋ณํ ์๋น์ค
JacksonJsonRedisSerializer - Jackson1๋ฅผ ์ด์ฉํ์ฌ JSON ์ง๋ ฌ ๋ณํ
Jackson2JsonRedisSerializer - Jackson2๋ฅผ ์ด์ฉํ์ฌ JSON ์ง๋ ฌ ๋ณํ
JdkSerializationRedisSerializer - ์๋ฐ ์ง๋ ฌ ๋ณํ
OxmSerializer - XML ์ง๋ ฅ๋ณํ ์ฉ, ์คํ๋ง O/X ๋งคํ ์งํ์/๋น์งํ์๋ฅผ ์ด์ฉํ ๋ณํ
StringRedisSerializer - String ํค์ ๊ฐ์ ์ง๋ ฌ๋ณํ
RedisTemplate์ JdkSerializationRedisSerializer๋ฅผ ์ฌ์ฉ.. StringRedisTemplate์ StringRedisSerializer๋ฅผ ์ฌ์ฉ => ๋ค๋ฅธ ์ง๋ ฌ ๋ณํ๋ ๋น์ฐํ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค
==> Jackson2JsonRedisSerializer๋ฅผ ์ฌ์ฉํ์ฌ, JSON์ผ๋ก ์ง๋ ฌ ๋ณํํ๊ณ ์ถ์ ๋์ ์์
@Bean
public RedisTemplate<String, Product> redisTemplate(RedisConnectionFactory cf) {
RedisTemplate<String, Product> redis = new RedisTemplate<String, Product>();
redis.setConnectionFactory(cf);
// ํค๋ String์ผ๋ก
redis.setKeySerializer(new StringRedisSerializer());
// ๊ฐ์ JSON์ผ๋ก ์ง๋ ฌํ
redis.setValueSerializer(new Jackson2JsonRedisSerializer<Product>(Product.class));
return redis;
}