Amped: Principals

  • Make doing things the right way easy
    • <30 minutes to make production ready
    • Health checks
    • Monitoring
  • Business driven & mean time to production
  • Monoliths don’t scale so decompose via Micro Services (runnable Jar)
  • Introduce loose coupling & Distributed execution & Independent provisioning
  • Reusability & API Catalog
  • Implement main makes debugging easier inside IDE’s
  • Simplified Deployment:
    • Install Java
    • Install App Jar
    • Execute Jar

Logging 

Alerting

DropWizard

Make features Not war

 

  • Memcached alternative with protocol compatible interface
  • CAP theorem based java.util.* & mapreduce
  • Elastic Scaling & Auto sharding
  • Service Registry & Discovery
  • MongoDB backed for non transient map data
  • Edge Cache frequently accessed data in-memory
  • Store temporal data like web sessions
  • In-memory data processing/analytics
  • Cross-JVM communication/shared storage
Hazelcast<->MongoDB 
// KeyValueSource from com.hazelcast.core.MultiMap
MultiMap<String, String> multiMap = hazelcastInstance.getMultiMap( "enacted-curriculum" );
KeyValueSource<String, String> source = KeyValueSource.fromMultiMap( multiMap );

Apache Camel

Solves the needs of:

  • Enterprise Integration Patterns (Glue Code)
  • Good for decomposition / Component based
  • Service Orchestration / Reuse via Routes
  • Cross-JVM communications (Hazelcast)
  • Business Intelligence
<route>
    <from uri="direct:get" />
    <log message="get.."/>
    <setHeader headerName="CamelHazelcastOperationType">
        <constant>get</constant>
    </setHeader>
    <to uri="hazelcast:multimap:AmpedServices" />
    <to uri="seda:out" />
</route>

Solves the needs of:

  • API Catalog / Promotes Reuse
  • Server - live document
  • Annotation driven
  • Client - describes how to use
  • Documentation (~like javadoc for Rest API)
  • Sandbox - live endpoints

https://github.com/wordnik/swagger-core/wiki/JavaDropwizard-Quickstart

@GET
@Path("/{petId}")
@ApiOperation(value = "Find pet by ID", notes = "More notes about this method", response = Pet.class)
@ApiResponses(value = {
  @ApiResponse(code = 400, message = "Invalid ID supplied"),
  @ApiResponse(code = 404, message = "Pet not found") 
})
public Response getPetById(
    @ApiParam(value = "ID of pet to fetch", required = true) @PathParam("petId") String petId)
    throws WebApplicationException {

Jetty for HTTP servin'

  • Full-featured and standards-based
  • Open source and commercially usable
  • Flexible and extensible
  • Small footprint
  • Embeddable
  • Asynchronous
  • Enterprise scalable
  • Dual licensed under Apache and Eclipse

Text

Jersey for REST modelin'

  • Support for multipart/* media type
  • Support for OAuth
  • Support for Atom
  • MVC using freemarker templating
  • Support for FastInfoset
  • Declarative server hyperlinking support
  • Non-blocking client implementation
  • Integration with Apache HTTP Client
  • Integration with Guice and Spring
  • Integration with MOXy 

Jackson for JSON parsin' and generatin'

  • Streaming API (aka "Incremental parsing/generation") reads and writes JSON content as discrete events.
  • org.codehaus.jackson.JsonParser reads, org.codehaus.jackson.JsonGenerator writes.
  • Inspired by the StAX API.
  • Tree Model provides a mutable in-memory tree representation of a JSON document.
  • org.codehaus.jackson.map.ObjectMapper can build trees; trees consist of JsonNode nodes.
  • The tree model is similar to the XML DOM.
  • Data Binding converts JSON to and from POJOs based either on property accessor conventions or annotations.
  • There are two variants: simple and full data binding
  • Simple data binding means converting to and from Java Maps, Lists, Strings, Numbers, Booleans and nulls
  • Full data binding means converting to and from any Java bean type (as well as "simple" types mentioned above)
    org.codehaus.jackson.map.ObjectMapper performs the marshalling (writing JSON) and unmarshalling (reading JSON) for both variants.
  • Inspired by the annotation-based (code-first) variant of JAXB.

Logback for loggin'

  • Faster implementation
  • logback-classic speaks SLF4J natively
  • Configuration files in XML or Groovy
  • Automatic reloading of configuration files
  • Graceful recovery from I/O failures
  • Automatic removal of old log archives
  • Prudent mode
  • Conditional processing of configuration files
  • SiftingAppender
  • Filters
  • Logback-access, i.e. HTTP-access logging with brains
  • Automatic reloading of configuration files

Hibernate Validator for validatin'

public class Car {

   @NotNull
   private String manufacturer;

   @NotNull
   @Size(min = 2, max = 14)
   private String licensePlate;

   @Min(2)
   private int seatCount;

   // ...
}

Hibernate Validator allows to express and validate application constraints. The default metadata source are annotations, with the ability to override and extend through the use of XML.

  • Extendable
  • Rich Metadata API
  • Reference Implementation
  • Added Value

Metrics for figurin' out what your application is doin' in production

  • Registry - Container for all application metrics
  • Guages - an instantaneous measurement of a value
  • Counter - a guage for an AtomicLong Instance
  • Meter - measures rate of events over time
  • Histogram -  measures the statistical distribution of values in a stream of data
  • Timer - a histogram of the duration of a type of event and a meter of the rate of its occurrence​
  • Reporter - the way the application exports all measurements being made by its metrics

Hazelcast for all things distributin'

  • Distributed java.util.{Queue, Set, List, Map}
  • Distributed java.util.concurrency.locks.Lock
  • Distributed java.util.concurrent.ExecutorService
  • Distributed MultiMap for one to many mapping
  • Distributed Topic for publish/subscribe messaging
  • Distributed Indexing and Query support
  • Socket level encryption for secure clusters
  • Write-Through and Write-Behind persistence for maps
  • Transaction support and J2EE container integration via JCA
  • Java Client for accessing the cluster remotely
  • Dynamic HTTP session clustering
  • Support for cluster info and membership events
  • Dynamic discovery
  • Dynamic scaling
  • Dynamic partitioning with backups
  • Dynamic fail-over
  • Web-based cluster monitoring tool

Camel for Enterprise Integration Pattern'

  • Lightweight, concise, and sophisticated DSL for integration
  • Reusable through Routes
  • 100s of components including:
  • Metrics - collect various metrics directly from camel routes
  • Hazelcast - supports map, multimap, seda, queue, set, atomic number, XA Locking, and clustering.
  • Scripting DSLs - JavaScript, OGNL, and Groovy to name a few
  • Very active community and numerous tools like hawt.io:
  • Jackson compoent
  • Jetty component
  • displaces the need for an ESB
  • Staged Event Driven Architecture (SEDA)
  • Optimized pass by reference (Direct)
  • Asynchronous API
  • MultiThreaded Routes
  • Load balanced Routes
Made with Slides.com