Building Effective Apache Geode Applications with Spring Data GemFire

2© 2014 Pivotal Software, Inc. All rights reserved. 2© 2014 Pivotal Software, Inc. All rights reserved.
Building Effective Apache Geode
Applications with Spring Data GemFire
John Blum - @john_blum
© 2015 - Pivotal Software, Inc.

3© 2014 Pivotal Software, Inc. All rights reserved.
Presenter
John Blum
Spring Data GemFire Project Lead
Apache Geode Committer
GemFire Engineer/Technical Lead
Responsibilities…
• Management & Monitoring (Gfsh)
• Management REST API
• Developer REST API
• Spring Data GemFire (v1.3.3 – current)

Agenda
 Quick Overview of Apache Geode
 Spring Data GemFire
– Configuration / Bootstrapping
– Data Access (DAO patterns)
– Function Execution
– Caching (JSR-107)
 Conclusion
 QA

Why Apache Geode?
Motivation…
1. Volume of Data (Big Data)
2. Rate of Data (Fast Data)
3. Verity of Data (Data Accuracy)
Enables new and existing Java applications to operate at cloud-scale in a
consistent, highly-available and predictable manner in order to transact and
analyze big, fast data in real-time thereby achieving meaningful and impactful
business results.

What is Apache Geode?
“A distributed, in-memory compute and
data management platform that
elastically scales to achieve high-
throughput, low-latency access to big,
fast data powering business critical,
analytical applications in real-time.”
– John Blum
Elastic capacity +/-
Nodes
Ops /
SecLinear scalability
Latency optimized
data distribution

How Apache Geode Works?
 Stores data In-Memory
– JVM Heap + Off-Heap
 Functions as a Distributed System, In-Memory Data Grid (IMDG)
– Pools system resources across multiple nodes in a cluster to manage both
application state and behavior
– Includes: Memory, CPU, Network & (optionally) Disk

Characteristics of Apache Geode
 Open Source
 In-Memory
 Distributed
 Scalable (scale-out)
 High Throughput & Low/Predictable Latency
 Highly Available
 Consistent
 Durable
 Fault Tolerant (resilient)
 Data-Aware / Parallel Compute

Apache Geode Use Cases
 Persistent, OLTP/OLAP Database (System of Record)
 JSR-107 Cache Provider (Key/Value Store)
 HTTP Session State Management
 Distributed L2 Caching for Hibernate
 Memcached Server (Gemcached)
 Glorified version of ConcurrentHashMap
 Message Bus with guaranteed message delivery

Spring Data GemFire
For Apache Geode
http://projects.spring.io/spring-data-gemfire/

“Simple things should be simple;
complex things should be possible”
– Alan Kay

Spring Data GemFire (SDG)
Applies Spring's powerful, non-invasive programming model in a consistent
fashion to simplify configuration and development of Apache Geode applications.
Spring Ecosystem Integration…
– Spring Cache Abstraction / Transaction Management
– Spring Data Commons + REST
– Spring Integration (Inbound/Outbound Channel Adapters)
– Spring Session (coming soon…)
– Spring XD (Sources & Sinks)

+ +
Apache Geode with Spring Data GemFire and Spring’s Cache
Abstraction is a JSR-107 (JCache) caching provider

GRAILS
Full-stack, Web
XD
Stream, Taps, Jobs
BOOT
Bootable, Minimal, Ops-Ready
Big,
Fast,
Flexible
Data Web,
Integration,
Batch
WEB
Controllers, REST,
WebSocket
INTEGRATION
Channels, Adapters,
Filters, Transformers
BATCH
Jobs, Steps,
Readers, Writers
BIG DATA
Ingestion, Export,
Orchestration, Hadoop
DATA
NON-RELATIONALRELATIONAL
CORE
GROOVYFRAMEWORK SECURITY REACTOR

Spring Data GemFire Use Cases
 Configure & Bootstrap Apache Geode
– Replacement for cache.xml; Can be used with Cluster Configuration
 Build an Application Peer Cache (Cache)
– Embedded Cache
 Build an Application Cache Client (ClientCache)
– Client/Server

Spring Data GemFire / Apache Geode Coordinates
<repository>
<id>spring-libs-snapshot</id>
<name>Spring Maven libs-snapshot Repository</name>
<url>https://repo.spring.io/libs-snapshot</url>
</repository>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-gemfire</artifactId>
<version>1.7.0.APACHE-GEODE-EA-SNAPSHOT</version>
</dependency>

Spring-based Configuration
XML Java-based Configuration

Bootstrapping Apache Geode with Spring
@SpringBootApplication
@ImportResource("/spring-gemfire-context.xml")
public class SpringGemFireApplication {
public static void main(String[] args) {
SpringApplication.run(SpringGemFireApplication.class, args);
}
}
gfsh>start server -–name=Example --spring-xml-location=
<classpath-to-spring-application-context.xml>

Example

Data Access with Spring
Basic (Region) Data Access Object (DAO)…
@Repository
public class GolferDao extends DaoSupport {
@Resource(name = “Golfers”)
private Region<Long, Golfer> golfers;
…
}

Data Access with SDG GemfireTemplate
Advantages
 Simple, Convenient Data Access API (CRUD, OQL, Function)
 Protects developer from GemFire/Geode API changes
 Exception Translation into Spring DAO Exception Hierarchy
 Transaction Management
<bean id=“golfersTemplate” class=“org.springframework.data.gemfire.GemfireTemplate”
p:region-ref=“Golfers”/>

Data Access with Spring Data Repositories
Advantages
 Simple, interface-based, Spring Data Repository definition (CRUD, Querying)
 Convention over Configuration (Querying)
 Portable
 Exception Translation & Transaction Management Support
public interface GolferRepository extends CrudRepository<Golfer, Long> {
List<Golfer> findByName(String name);
}

Example

Annotation-based Function Support
Spring Data GemFire introduces annotation support for Function implementation
and execution.
 Functions are implemented as POJO methods
 Functions are invoked using Object-Oriented method invocation.
SDG supports…
 @OnServer / @OnServers (from client only)
 @OnMember / @OnMembers (from peer only)
 @OnRegion (from either client or peer)

Annotation-based Function Implementation
package example.app.function;
@Component
class CustomerFunctions {
@GemfireFunction
public Customer update(Address address, PhoneNumber phoneNumber) { … }
@GemfireFunction(id = “MyFunction” HA=true)
public List<?> functionTwo(FunctionContext funcCtx, @Filter Set<?> keys, …) { … }
}
<gfe:annotation-driven/>
<!– optional when using <context:annotation-config> or <context:component-scan> -->
<bean class=“example.app.function.CustomerFunctions”/>

Annotation-based Function Execution
package example.app.function.executions;
@OnRegion(“Customers”)
interface CustomersFunctionExecution {
Customer update(Address address, PhoneNumber phoneNumber);
}
<gfe-data:function-executions base-package=“example.app.function.executions”/>
@Component
class ApplicationComponent {
@Autowired
private CustomersFunctionExecution customersFunction;
public Customer someMethod(Address address, PhoneNumber phoneNumber) {
return customersFunction.update(address, phoneNumber);
}

Example

Spring Cache Abstraction
Caching is useful in cases when an “expensive” operation (i.e. CPU, IO bound)
produces the same output given identical input; results can be reused.
Spring enables Declarative, Annotation-based Caching…
 @Cacheable – triggers cache population
 @CacheEvict – triggers cache eviction
 @CachePut – updates cache without interfering with method execution
 @Caching – groups multiple cache operations per method
 @CacheConfig – class-level cache-related settings

Spring Supports JSR-107 (JCache)
Spring JCache
@Cacheable @CacheResult
@CachePut @CachePut
@CacheEvict @CacheRemove
@CacheEvict(allEntries=true) @CacheRemoveAll
@CacheConfig @CacheDefaults
http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#cache-jsr-107

Apache Geode Caching Provider
@Configuration
@EnableCaching
@Import(GemFireConfiguration.class)
class ApplicationConfiguration {
@Bean
public CacheManager cacheManager(
Cache gemfireCache) {
GemfireCacheManager cacheManager =
new GemfireCacheManager();
cacheManager.setCache(gemfireCache);
return cacheManager;
}
}
<beans …
xmlns:cache=“http://www.springframework.org/schema/cach
e”…>
<gfe:cache properties-
ref="gemfireProperties"/>
<cache:annotation-driven/>
<bean id="cacheManager" class=
”o.s.data.gemfire.support.GemfireCacheManager"
p:cache-ref="gemfireCache"/>

Example

Conclusion

Apache Geode References
 Project Page - http://geode.incubator.apache.org/contribute/
 Contribute - http://geode.incubator.apache.org/contribute/
– Ideas - https://cwiki.apache.org/confluence/display/GEODE/How+to+Contribute
 Community Events - http://geode.incubator.apache.org/community/
 Documentation - http://geode.incubator.apache.org/docs/
– Docs Project - https://github.com/project-geode/docs
 Source Code - https://github.com/apache/incubator-geode
 JIRA - https://issues.apache.org/jira/browse/GEODE
 StackOverflow - http://stackoverflow.com/questions/tagged/gemfire+and+geode

Spring Data GemFire References
 Project Page - http://projects.spring.io/spring-data/
 Documentation –
– Reference Guide - http://docs.spring.io/spring-data-gemfire/docs/current/reference/html/
– API - http://docs.spring.io/spring-data-gemfire/docs/current/api/
– Spring IO Guides - http://spring.io/guides
– Spring GemFire Examples –
 Source Code - https://github.com/spring-projects/spring-data-gemfire
 Examples - https://github.com/spring-projects/spring-gemfire-examples
 JIRA – https://jira.spring.io/browse/SGF
 StackOverflow - http://stackoverflow.com/questions/tagged/spring-data-gemfire

35© 2014 Pivotal Software, Inc. All rights reserved. 3
Building High-Scalable Spring Applications with In-Memory Data Grids
September 15th, 2015 – 10:30 am – 12 pm
Learn More. Stay Connected.
@springcentral Spring.io/video
https://2015.event.springone2gx.com/schedule/sessions/building_highly_scalable_spring_applications_with_in_memory_distribute
d_data_grids.html

Q&A
Any questions…

Thank You

Building Effective Apache Geode Applications with Spring Data GemFire

Building Effective Apache Geode Applications with Spring Data GemFire

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (11)

Similar to Building Effective Apache Geode Applications with Spring Data GemFire

Similar to Building Effective Apache Geode Applications with Spring Data GemFire (20)

Recently uploaded

Recently uploaded (20)

Building Effective Apache Geode Applications with Spring Data GemFire

Editor's Notes