Difference between revisions of "Spring 5 training (Spring guru) - personal notes"

(command line tricks)
Line 111: Line 111:
  
  
 +
===See all spring boot magic===
 +
 +
To see all the magic you can start in FULL DEBUG mode. This is more than the "DEBUG" logs!
 +
This will:
 +
* Load the application
 +
* Display each spring action such as component scan, auto-configuration, properties load, ignore beans and configuration
 +
* Give additional information regarding spring beans access and catalog update
 +
* etc.
 +
 +
<syntaxhighlight lang="bash">
 +
mvn spring-boot:run -Dspring-boot.run.arguments=--debug
 +
</syntaxhighlight>
  
 
==Spring MVC==
 
==Spring MVC==

Revision as of 19:42, 28 March 2018


I recently (2018) subscribe to an online training related to Spring 5 on Udemy. This page is a sum-up of my personal notes related to Spring 5.


Links

  • Spring initializr - to generate a quick start project based on the libraries you choose


Very simple web-application

  • Go to Spring initializr
  • Select
    • web > web
    • SQL > JPA
    • SQL > H2
    • Templates > Thymeleaf
    • Ops > actuator


H2 hint

When using H2 on a web application, don't forget to enable the console! Edit application.properties as follow:

spring.h2.console.enabled=true
# replace "spring5webapp" by your own application
spring.datasource.url=jdbc:h2:mem:spring5webapp;DB_CLOSE_ON_EXIT=FALSE

Then you can reach the console at http://localhost:8080/h2-console


Hibernate

General notes

Hibernate recommends to implement hashCode() and equals() on all JPA entities. They also recommend to use a particular Business ID when possible, if not then use the ID. Only the key fields should be in these methods.



IntelliJ configuration

Plugins

Useful plugings:

  • File > Settings > Plugins > Browse repositories
    • .ignore
    • Ideolog
    • Sonarlint
    • Save actions
    • GenerateSerialVersion

Enable toolbars! View > Toolbar


Import optimization

see https://stackoverflow.com/questions/11704327/how-to-optimize-imports-automatically-after-each-save-in-intellij-idea


IntelliJ IDEA offers 2 options:

  • Settings | Editor | General | Auto Import > Optimize imports on the fly
  • Commit Project dialog > Optimize imports option


Outline like Eclipse (structure view)

see https://www.jetbrains.com/help/idea/viewing-structure-of-a-source-file.html


To view the file structure, do one of the following

  • On the main menu, choose View | Tool Windows | Structure.
  • Pres StructureTool Button
  • Press Alt+7.
  • Press Ctrl+F12.


Create new Spring project

On the main menu, choose File | New | Project

  • Left side: Spring initalizr (IntelliJ ultimate)


Spring 5

command line tricks

Spring boot provides some out-of-the-box tools.


Run the application

To run the application:

# Using the maven installation (outside the project)
mvn spring-boot:run

# Using the embedded tool
./mvnw spring-boot:run


See spring-boot commands

mvn spring-boot:help -Ddetail=true


See all spring boot magic

To see all the magic you can start in FULL DEBUG mode. This is more than the "DEBUG" logs! This will:

  • Load the application
  • Display each spring action such as component scan, auto-configuration, properties load, ignore beans and configuration
  • Give additional information regarding spring beans access and catalog update
  • etc.
mvn spring-boot:run -Dspring-boot.run.arguments=--debug

Spring MVC

Implementation of MVC concept in Spring:

MVC pattern in Spring (credentials: Spring Guru, UDEMY)

Here is a short description of the schema - as I understood it + based on my experience with Spring so far (v2 to v4):

  1. Client submits a request to the server (HTTP request)
  2. Dispatcher receives the request
  3. Dispatcher asks the Handler WHO should take care of the request? i.e:
    • What is the Controller for the requested endpoint?
    • Is there any java Method that match the given HTTP request type (GET, POST, PUT, ..) + arguments?
  4. Dispatcher invokes the Controller and forwards query
    • Controller calls a Service to process the query, interact with the database and other systems.
    • Once the Service processing is complete, it returns corresponding data to the Controller
    • The Controller will convert the data into a DTO (communication Model (pojo)
    • Controller sends the pojo back to the Dispatcher
  5. Data disposal: The Dispatcher disposes of the data. i.e:
    • Send back the data directly to the client [HTTP REST calls]
    • Forward the data to a View for rending
      • View generates the page thanks to UI technology (server side) such as JSP, JSF or Themeleaf to generate HTML / Javascript / CSS
      • View sends back generated content to Dispatcher
      • Dispatcher forwards content to the Client


Spring beans lifecycle

This section describes Spring's beans lifecycle. It is an extract of Spring 5 training from John Tompson. This is a summary of lecture 37.


Creation

This is how beans are created with Spring:

Spring bean creation (credentials: Spring Guru, UDEMY)

Complete description

This is the complete description of the creation lifecyle:

  1. instantiation of the Class. Spring will inject dependencies through the constructor, if available.
  2. populate properties. Spring will set the @Value attributes: it will perform placeholder resolution against environment, properties files, profiles settings, etc.
  3. BeanPostProcessing : set of operations that are performed once the bean has been initialized (the Object composition is complete). You just have to implements the BeanPostProcessort interface. These features are usually NOT used.
    1. Pre-initialization phase: to customize the bean (and its properties) for some advanced tricks.
    2. After properties. To get notify once the properties are set. You have to implements Initializing.afterPropertiesSet() interface.
    3. You can implement some custom loader.
    4. Post-initialization phase: to customize the bean once properties are set and custom loader is complete.
  4. Bean ready to use

There is one extra step that is not on the schema: Post processing. Spring will run the @PostConstruct method.


Simplify lifecycle

Some steps of the lifecycle are mostly dedicated to the Spring creators and related frameworks.


Most of the Spring users only use:

  1. instantiation through the Spring bean's constructor
  2. properties by setting the @Value attributes
  3. Bean ready to use
  4. Post processing by executing the @PostConstruct


Awareness

In the 'initialization' phase - as well as the 'reload' phase - you might want to listen to events that occurs within the application and have impact on the Spring context. Here is a list of the most common aware interfaces:

Spring aware interfaces (credentials: Spring Guru, UDEMY)


In all honesty, I've only worked with the ApplicationContextAware interface in 7 years of Spring.



Destroy

This is how beans are destroyed with Spring:

Spring bean destroy (credentials: Spring Guru, UDEMY)

  1. Container (Tomcat, Jetty, Bash, etc.) will send the shutdown signal to the application
  2. Disposable phase: Spring will call the @PreDestroy method
  3. You can also specify a custom destroy method that will be call at the end by implementing DisposableBean.destroy(). This is useful for custom socket connections close (example). Ideally, on new applications you should NOT use that custom part at all.


Spring bean components

Hierarchy

You'll find below the Spring beans components hierarchy:

spring beans hierarchy (credentials: Spring Guru, UDEMY)

Each type @Controller, @Service, @Repository provides additional @nnotations + they are marked to belong to a particular N-third layer. This helps Spring a lot.

Beans types

spring beans types (credentials: Spring Guru, UDEMY)