Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

Spring boot


Published on

Spring boot is a suite, pre-configured, pre-sugared set of frameworks/technologies to reduce boilerplate configuration providing you the shortest way to have a Spring web application up and running with smallest line of code/configuration out-of-the-box.

Published in: Technology
  • It doesn't matter how long ago you broke up, these methods will make your Ex crawling back! See how at here. ♥♥♥
    Are you sure you want to  Yes  No
    Your message goes here
  • Be the first to like this

Spring boot

  1. 1. Code Camp April-Spring Boot April 2, 2016 Presented By - Nakul & Vishal
  2. 2. Audience Beginner Level Java Web Developers Grails Developers
  3. 3. Objective To get familiar with the Spring Boot framework and use it to build microservices architecture.
  4. 4. Agenda Introducing Spring Boot Features Artifacts Profiling Demo application using Spring Boot and Groovy Templates
  5. 5. Introducing Spring Boot - If Spring is the cake, Spring Boot is the icing.
  6. 6. Spring boot is a suite, pre-configured, pre-sugared set of frameworks/technologies to reduce boilerplate configuration providing you the shortest way to have a Spring web application up and running with smallest line of code/configuration out-of-the-box. What is Spring Boot ?
  7. 7. The primary goals of Spring Boot are: To provide a radically faster and widely accessible 'getting started' experience for all Spring development To be opinionated out of the box, but get out of the way quickly as requirements start to diverge from the defaults To provide a range of non-functional features that are common to large classes of projects (e.g. embedded servers, security, metrics, health checks, externalized configuration) Spring Boot does not generate code and there is absolutely no requirement Why Spring Boot ?
  8. 8. import org.springframework.boot.*; import org.springframework.boot.autoconfigure.*; import org.springframework.stereotype.*; import org.springframework.web.bind.annotation.*; @Controller @EnableAutoConfiguration @Configuration @ComponentScan //All three annotations can be replaced by one @SpringBootApplication public class SampleController { @RequestMapping("/") String home() { return "Hello World!"; } public static void main(String[] args) throws Exception {, args); } A simple Spring Boot Application
  9. 9. Demo Let’s hit some keys !! Hello World from Spring Boot
  10. 10. ❖@Controller - annotates a class as an MVC controller ❖@Configuration - tags the class as a source of bean definitions for the application context. ❖@EnableAutoConfiguration - enables auto configuration for the application ❖@ComponentScan - This tells Spring to look for classes with @Component ,@Configuration , @Repository , @Service , and @Controller and wire them into the app context as beans. ❖@SpringBootApplication - get the functionality of all above annotations in a single annotation Whats Happening?
  11. 11. How Spring boot works ?
  12. 12. Directory Structure of Spring Boot There is no restrictions on directory structure. We can create one as we are used to in grails or we can create one that is shown in the picture.
  13. 13. Demo Let’s hit some keys !! Look at the directory structure
  14. 14. Spring Boot Essentials Spring Boot brings a great deal of magic to Spring application development. But there are four core tricks that it performs: ■ Automatic configuration — Spring Boot can automatically provide configuration for application functionality common to many Spring applications. ■ Starter dependencies — You tell Spring Boot what kind of functionality you need,and it will ensure that the libraries needed are added to the build. ■ The command-line interface — This optional feature of Spring Boot lets you write complete applications with just application code, but no need for a traditional project build. ■ The Actuator — Gives you insight into what’s going on inside of a running Spring Boot application.
  15. 15. What Spring Boot isn’t ? 1. Spring Boot is not an application server. It has embedded server that helps it run by executing a jar file of the project. 1. Spring Boot doesn’t implement any enterprise Java specifications such as JPA or JMS. It auto configures these beans and provide them at runtime to our disposal. 1. Spring Boot doesn’t employ any form of code generation to accomplish its magic. Instead, it leverages conditional configuration features from Spring, along with transitive dependency resolution offered by Maven and Gradle, to automatically configure beans in the Spring application context.
  16. 16. Basic Artifacts Dependency Resolution Domains Repositories Controllers Services Views Configuration Deployment
  17. 17. 1. Done with the help of Gradle or Maven. 2. Dependencies are resolved by build.gradle in gradle build environment. 3. For maven they are resolved from pom.xml 4. Gradle supports groovy DSL like syntax and is much easier to maintain. It frees us from the fuss of writing xml for dependency resolution. Dependency Resolution
  18. 18. Resolving dependencies using Gradle Let’s have a look at the build.gradle file in the root of our application.
  19. 19. Demo Let’s hit some keys !! build.gradle
  20. 20. 1. Annotated by the annotation @Entity 2. javax.persistence.Entity/grails.persistence.Entity/org.hibernate.annotat ions.Entity 3. Can use JPA 2.1, Hibernate, Spring Data, GORM etc . 4. Classes annotated by @Entity is a component which our main class searches for by the help of @ComponentScan Domains
  21. 21. Demo Let’s hit some keys !! Domains
  22. 22. 1. Provides abstraction. 2. Significantly reduces the amount of boilerplate code required to implement DAO layer 3. Supports various persistence stores like MySql , MongoDB etc. The central interface in Spring Data repository abstraction is Repository.It takes the the domain class to manage as well as the id type of the domain class as type arguments. This interface acts primarily as a marker interface to capture the types to work with and to help you to discover interfaces that extend this one. Repositories
  23. 23. The CrudRepository provides sophisticated CRUD functionality for the entity class that is being managed. public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> { S save(S entity); //Saves the given entity T findOne(ID primaryKey); //Returns the entity identified by the given id Iterable<T> findAll(); //Returns all entities Long count(); //Returns the number of entities void delete(T entity); //Deletes the given entity boolean exists(ID primaryKey); //Indicates whether an entity with the given id exists // … more functionality omitted. }
  24. 24. How a repository works ? 1. Declare an interface extending Repository or one of its subinterfaces and type it to the domain class that it will handle. public interface PersonRepository extends Repository<User, Long> { … } 1. Declare query methods on the interface. List<Person> findByLastname(String lastname); 1. Get the repository instance injected and use it. public class SomeClient { @Autowired private PersonRepository repository; public void doSomething() { List<Person> persons = repository.findByLastname("Nakul"); } }
  25. 25. Demo Let’s hit some keys !! Repositories
  26. 26. 1. Any java class can be converted into a controller by annotating it with @Controller or @RestController 2. @Controller - makes a java/groovy class as an MVC controller that renders a view 3. @RestController - makes a java/groovy class as a rest controller. Controllers
  27. 27. What about ‘actions’ ? Any method defined inside a class annotated by @Controller or @RestController will behave like an action only if it has been annotated by @RequestMapping Ex - @RestController @RequestMapping(value = '/student') class RootController { @Autowired StudentRepository studentRepository @RequestMapping(method=RequestMethod.GET ,value = '{id}',produces = MediaType.APPLICATION_JSON_VALUE) public Student getOne(@PathVariable String id) { return studentRepository.findOne(Long.parseLong(id)) } }
  28. 28. What about ‘actions’ ? Continued - A simple MVC controller Ex - @Controller @RequestMapping(value = '/student') class RootController { @Autowired StudentRepository studentRepository @RequestMapping(method=RequestMethod.GET ,value = '{id}') public ModelAndView getOne(@PathVariable String id) { return new ModelAndView(“views/index”,[:]) } }
  29. 29. Demo Let’s hit some keys !! Controllers and Actions
  30. 30. 1. Any java/groovy class can be converted into a service by annotating it with @Service 2. To make a service transactional mark it with @Transactional 3. @Transactional(propagation = REQUIRED) makes a transaction complete in itself 4. @Transactional(propagation = MANDATORY) is used to protect the other methods from being called erroneously out of a transaction 5. @Transactional(readOnly=true) makes a service read-only. Services
  31. 31. Demo Let’s hit some keys !! Services
  32. 32. 1. Spring supports Groovy template engine natively to render views modelled by the controller. 2. Thymeleaf is also a popular rendering engine being used with spring- boot 3. GSP’s can also be used as a part of presentation layer. 4. We can also use Angular.js as a frontend framework for use with REST- API’s for make a complete web-app. Views
  33. 33. From where can we get these rendering engines ? Can be maintained as gradle dependencies in build.gradle Dependencies Groovy Template Engine - compile ("org.codehaus.groovy:groovy-templates:2.4.0") Thymeleaf Engine - compile("org.springframework.boot:spring-boot-starter-thymeleaf") Groovy Server Pages - compile "org.grails:grails-web-gsp:2.5.0" compile "org.grails:grails-web-gsp-taglib:2.5.0" provided "org.grails:grails-web-jsp:2.5.0"
  34. 34. Groovy Template Engine Features 1. hierarchical (builder) syntax to generate XML-like contents (in particular, HTML5) 2. template includes 3. compilation of templates to bytecode for fast rendering 4. layout mechanism for sharing structural patterns
  35. 35. Groovy Template Engine Dependency dependencies { compile "org.codehaus.groovy:groovy" compile "org.codehaus.groovy:groovy-templates" }
  36. 36. Groovy Template Engine Example 1 link(rel: 'stylesheet', href: '/css/bootstrap.min.css') will be rendered as: <link rel='stylesheet' href='/css/bootstrap.min.css'/>
  37. 37. Groovy Template Engine Example 2 a(class: 'brand', href: ' engine.html', 'Groovy - Template Engine docs') will be rendered as: <a class='brand' href=' template-engine.html'>Groovy - Template Engine docs</a>
  38. 38. Groovy Template Engine Example 3 a(class: 'brand', href:‘ template-engine.html'){ yield 'Groovy - Template Engine docs' } will be rendered as: <a class='brand' href=' template-engine.html'>Groovy - Template Engine docs</a>
  39. 39. Demo Let’s hit some keys !! Views
  40. 40. Groovy Template Engine - Layouts Layouts-Example yieldUnescaped '<!DOCTYPE html>' html { head { title(pageTitle) link(rel: 'stylesheet', href: '/css/bootstrap.min.css') } body { a(class: 'brand', href: ' engine.html', 'Groovy - Template Engine docs')
  41. 41. Groovy Template Engine - Layouts Layouts - Example a(class: 'brand', href: 'h') { yield 'Spring Boot docs' mainBody() } } }
  42. 42. Groovy Template Engine - Layouts Layouts 1. Common part of our template is kept into a main.tpl file that we will save into src/main/resources/templates/layouts 2. title(pageTitle) where pageTitle is expected to be the page title that we want to give 3. mainBody(), which will cause rendering of the main body for pages using that layout.
  43. 43. Groovy Template Engine - Layouts Layouts in action layout 'layouts/main.tpl', pageTitle: 'Spring Boot - Groovy templates example with layout', mainBody: contents { div("This is an application using Spring Boot and Groovy Template Engine") }
  44. 44. Groovy Template Engine - Layouts Layouts we call the layout method and provide it with several arguments: the name of the layout file to be used (layouts/main.tpl) pageTitle, a simple string mainBody, using the contents block
  45. 45. Groovy Template Engine - Layouts Layouts Use of the contents block will trigger the rendering of the contents of mainBody inside the layout when the mainBody() instruction is found. So using this layout file, we are definitely sharing a common, structural pattern, against multiple templates. layouts are themselves composable, so you can use layouts inside layouts…
  46. 46. Demo Let’s hit some keys !! Layouts
  47. 47. Profiles Profiles In the normal Spring way, you can use a Environment property to specify which profiles are active. specify on the command line using the switch For every environment we create a application-{environment}.properties files in the resource directory.
  48. 48. If no environment is specified then spring boot picks the default file from the ‘resources’ directory. Stores all the configurations in a single file . All the configurable properties can be referenced here
  49. 49. Demo Let’s hit some keys !! Profiles
  50. 50. References References Groovy Templates : groovy-template-engine-in-spring-boot Spring Boot : Spring Boot in Action - Craig Walls, Manning Publication Learning Spring Boot - Greg L. Turnquist, Packt Publishing More References - boot/docs/current/reference/htmlsingle/
  51. 51. Questions ?
  52. 52. For dummy project please visit demo
  53. 53. Thank You for your patience !!!