Speaker: Gary Russell, Pivotal

The Spring Integration JavaConfig and DSL extension provides a set of convenient Builders and a fluent API to configure Spring Integration message flows from Spring @Configuration classes. The Java DSL for Spring Integration is essentially a facade for Spring Integration. The DSL provides a simple way to embed Spring Integration Message Flows into your application using the fluent Builder pattern together with existing Java and Annotation configurations from Spring Framework and Spring Integration as well. Another useful tool to simplify configuration is Java 8 Lambdas.

Tuesday, Jan 27th, 2015 3:00PM GMT (London GMT) Register

Tuesday, Jan 27th, 2015 10:00AM PST (San Francisco GMT-08:00) Register

Speaker: Luke Shannon

GemFire is Pivotal's distributed In Memory Data grid. In this session we will cover simplifying configuring a GemFire grid using Spring Data GemFire, and explore how data is dynamically distributed and made highly available as the grid resources are increased or decreased to meet increased client demand. GemFire access and testing patterns using Spring will be reviewed in detail. We will walk through creating a domain object and using Spring Data GemFire Repositories to perform CRUD operations on a GemFire grid, creating a Spring MVC/Spring Boot application that uses GemFire as its persistence layer, review how Spring Boot and Spring Data GemFire can be used to help with GemFire test cases and how Spring Data GemFire can make creation and execution of GemFire functions easier. We will also explore how Spring XD can be used to load and monitor data changes in the grid. This will be a hands on, code oriented session.

Tuesday, Jan 13th, 2015 3:00PM GMT (London GMT) Register

Tuesday, Jan 13th, 2015 10:00AM PST (San Francisco GMT-08:00) Register

Speakers: Josh Long, Pivotal + Adam Koblentz - ZeroTurnaround

Slides: https://speakerdeck.com/joshlong/bootiful-jrebel

Spring Boot, the new convention-over-configuration centric framework from the Spring team at Pivotal, marries Spring's flexibility with conventional, common sense defaults to make application development not just fly, but pleasant! Spring Boot gives you a huge leg up over normal starter projects, now let's give you another boost by adding JRebel. With JRebel, the average Java developer saves over 1 work-month per year by using JRebel to skip rebuild, restart, and redeploys of their application. JRebel 6 launches on November 4, 2014 and includes complete Spring Boot integration. Join Spring's Josh Long and ZeroTurnaround's Adam Koblentz and learn how to combine Boot with JRebel and get more done, in less time with less configuration.

Learn more about Spring Boot: http://projects.spring.io/spring-boot

Learn more about JRebel: http://zeroturnaround.com/software/jrebel/display/

14 day free JRebel trial download: https://zeroturnaround.com/software/jrebel/trial/

!{iframe width="420" height="315" src="//www.youtube.com/embed/N5FHiONGOsg" frameborder="0" allowfullscreen}{/iframe}

Recorded at SpringOne2GX 2014.

Speaker: Ben Hale @nebhale

Slides: http://www.slideshare.net/SpringCentral/creating-restful-hypermediabased-microservices-with-spring-boot

As data-driven applications become ubiquitous, the services that provide the data are proliferating. As teams become responsible for more and more of these services, it becomes critical that they be designed and implemented in a way that is as lightweight as possible. This session will cover how to design micro-services as RESTful APIs and implement them with minimal code using Spring Boot. It will focus on API design using REST and HATEOAS, with live coding progressing from a tweet-length implementation all the way to a full-fledged app running in the cloud.

Along the way we'll see how to leverage technologies such as Spring Boot and Reactor to develop microservices targeted at Cloud Foundry.

!{iframe width="560" height="315" src="//www.youtube.com/embed/zbeMDM-zDNI" frameborder="0" allowfullscreen}{/iframe}

Recorded at SpringOne2GX 2014.

Speaker: Matt Stine

Slides: http://www.slideshare.net/SpringCentral/developing-microservices-for-paas-with-spring-and-cloud-foundry

Marc Andressen has famously said "Software is eating the world." What does that mean? We take it to mean that multiple industries with historically entrenched leaders are being disrupted by businesses built around a software core. These software factories are characterized by: tight feedback loops rapid iteration horizontal scaling mobile-first UX continuous delivery These factors have contributed to drive a change in how we approach infrastructure, which has taken the lead in adapting to meet these needs with the move to the cloud, and Platform as a Service (PaaS) offerings like Cloud Foundry have raised the level of abstraction to a focus on an ecosystem of applications and services. However, most applications are still developed as if we're living in the previous generation of both business and infrastructure: the monolithic application. Microservices - small, loosely coupled applications that follow the Unix philosophy of ""doing one thing well"" - represent the application development side of enabling rapid, iterative development, horizontal scale, polyglot clients, and continuous delivery. They also enable us to scale application development and eliminate long term commitments to a single technology stack. While microservices are simple, they are certainly not easy. It's recently been said that "microservices are not a free lunch." Interestingly enough, if you look at the concerns typically expressed about microservices, you'll find that they are exactly the challenges that a PaaS is intended to address. So while microservices do not necessarily imply cloud (and vice versa), there is in fact a symbiotic relationship between the two, with each approach somehow compensating for the limitations of the other, much like the practices of eXtreme Programming do the same. This session will describe architectural patterns for developing microservices:

• Service Decomposition
• API Gateways
• Stateless / Shared-Nothing
• Apps Configuration and Backing Service
• Consumption
• Fault Tolerance

Along the way we'll see how to leverage technologies such as Spring Boot and Reactor to develop microservices targeted at Cloud Foundry.

!{iframe width="560" height="315" src="//www.youtube.com/embed/iMvCOEsSuAc" frameborder="0" allowfullscreen}{/iframe}

Recorded at SpringOne2GX 2014.

Speaker: Cornelia Davis

Slides: http://www.slideshare.net/SpringCentral/running-your-spring-apps-in-the-cloud

The Spring Trader application was debuted at SpringOne 2GX in 2012 and presented an application that demonstrates a multitude of Pivotal Application Fabric components working together – tcServer, RabbitMQ, SQLFire and Gemfire. In this session we will take that application and make (a few) modifications (mostly to config) to get it running on the same components in the cloud, specifically on the Cloud Foundry PaaS. We’ll show you how to use the Spring Cloud project to configure the deployment, how to leverage a cloud services catalog, how to implement a cross-site scripting solution (and why), how to do session state caching and we’ll discuss (the dangers of) auto reconfiguration. If you bring a laptop you can have your own instance of the app running by the end of the session.

!{iframe width="560" height="315" src="//www.youtube.com/embed/nuiNvI5HYkU" frameborder="0" allowfullscreen}{/iframe}

Recorded at SpringOne2GX 2014.

Speakers: Andy Clement, Martin Lippert

Slides: http://www.slideshare.net/SpringCentral/developer-tooling-whats-new-and-whats-next

In this talk we take a look at the latest changes and new features of the Spring Tool Suite, the Eclipse-based IDE that comes packed with support for Spring, Groovy, Grails, Gradle, AspectJ, and Cloud Foundry. We dive into the new ways the tooling makes it easy and convenient to develop enterprise applications that are based on Spring Boot and how the Spring Tool Suite integrates will all the different parts of Spring IO. In addition to that we will show the Java8 language tooling that comes as part of the Spring Tool Suite and demonstrate how to get the most out of Java8 in your projects. In the second part of this presentation we take a look at our vision for how we are going to move developer tooling itself into the cloud era. We provide a sneak peek under the hood of what we are working on for the next generation of developer tooling. We will demonstrate what future cloud-based developer might look like, how real Java language tooling can look and feel when running in a browser-based code editor, and show how every developer can smoothly migrate into this new world of cloud-based developer tooling. All this is based on Flux, a new project at eclipse.org, that aims at providing new and innovative ways to move towards cloud-based tooling in a smooth, seamless way.

!{iframe width="560" height="315" src="//www.youtube.com/embed/eLkVPqxFJKM" frameborder="0" allowfullscreen}{/iframe}

Recorded at SpringOne2GX 2014.

Speaker: Venkat Subramaniam

No Slides at speaker request

There is a good amount of excitement about the new version of Java. The big evolution of course is the lambda expressions. In this presentation we will dive into the language features in Java 8, take a look at some of their nuances, and look at ways to put them to good use. In addition to looking at lambdas we will also dive into the Streams capabilities and also some of the features in Java 8 that make all these possible.

!{iframe width="560" height="315" src="//www.youtube.com/embed/j9nj5dTo54Q" frameborder="0" allowfullscreen}{/iframe}

Recorded at SpringOne2GX 2014.

Speakers: Thomas Darimont, Oliver Gierke, Christoph Strobl

Slides: http://www.slideshare.net/SpringCentral/whats-new-in-spring-data

This talk will give a broad overview of the new features introduced in the latest Spring Data release trains. We will cover recent additions and improvements in Spring Data Commons - the module that's shared amongst the store specific ones. We'll then delve into the latest and greatest features of individual store modules, like JPA, MongoDB, Neo4j, Solr and the community ones as well.

!{iframe width="560" height="315" src="//www.youtube.com/embed/1kTMcZKaY3Q" frameborder="0" allowfullscreen}{/iframe}