UNIVERSITATEA “TRANSILVANIA” DIN BRAŞOV

Departamentul:Automatică și Tehnologia Informației

Programul de studiu: Sisteme Avansate în Automatică şi
Tehnologia Informaţiei

Spring Boot
CSVPI
- Proiect -

Îndrumător Student
Conf. dr.ing Dominic M. KRISTALY Vlad – Ştefan PETRE

Anul II, Grupa 4762

BRAȘOV, 2018
Facultatea de Inginerie Electrică şi Ştiinţa Calculatoarelor Sisteme Avansate în Automatică și
Departamentul Automaticăşi Tehnologia Informaţiei Tehnologii Informatice

Cuprins
1. Introducere ....................................................................................................................................3
2. Spring Boot vs Spring MVC .........................................................................................................3
3. Detalii tehnice ...............................................................................................................................4
3.1. Cerințe de sistem: ..................................................................................................................4
3.2. Container pentru servlet-uri ...................................................................................................4
4. Folosirea Spring Boot ...................................................................................................................4
4.1. Configurarea: .........................................................................................................................4
4.2. Auto-configurarea:.................................................................................................................5
4.3. Obiecte Spring și injectarea dependințelor: ...........................................................................5
4.4. Instalarea uneri aplicații Spring Boot ....................................................................................5
4.5. Rularea aplicației: ..................................................................................................................6
5. Caracteristici Spring Boot: ............................................................................................................6
6. Autoconfigurare ............................................................................................................................7
6.1. General...................................................................................................................................7
6.2. Asocierea proprietăților .........................................................................................................9
6.3. Adnotările @Conditional.......................................................................................................9
6.4. ApplicationContextInitializer ................................................................................................9
7. Concluzii .....................................................................................................................................10

2
Facultatea de Inginerie Electrică şi Ştiinţa Calculatoarelor Sisteme Avansate în Automatică și
Departamentul Automaticăşi Tehnologia Informaţiei Tehnologii Informatice

1. Introducere
Spring reprezintă cea mai populară și invovativă comunitate pentru dezvoltatorii de Java. Acesta
schimbă modalitatea de a construi și de a administra aplicații foarte mari. Spring Boot este ultima
lor inovație pentru a ține pasul cu nevoile schimbării tehnologiilor.
Principalul motiv din spatele dezvoltării Spring Boot este simplificarea procesului de configurare și
lansare a aplicațiilor Spring.
Proiectul Spring Boot reprezintă o viziune clară asupra dezvoltării de aplicații Spring gata de
producție. Acesta oferă o convenție asupra configurării și este proiectat pentru a pregăti și rula
aplicații cât mai repede posibil.
Spring Boot facilitează dezvoltarea de aplicații de sine stătătoare pe nivel de producție care pot fi
pur și simplu “executată”. Folosește viziunea clară a platformei Spring, cât și o colecție de
biblioteci de la diferiți terți pentru a începe dezolvatarea unei aplicații fără bătăi de cap, datorită
faptului ca aceasta din urmă are nevoie de foarte puține configurări de Spring.

Obiectivele principale sunt:

 Creearea de aplicații de sine stătătoare
 Furnizarea unei modalități rapide și accesibile pentru pornirea dezvoltării pentru orice
proiect Spring
 Configurare automată pentru Spring unde este posibil
 Furnizarea unor game de caracteristici non-funcționale comune unor părți mari de proiect
(server integrat, sercuritate, metrici, verificare de stare a rulării, configurări externe)
 Nicio generare automată de cod sau nevoia de configurare prin fișiere XML

2. Spring Boot vs Spring MVC

Deși cele două entități nu pot fi comparate, mulți începători confundă scopul unui proiect Spring
Boot.
Pe scurt, Spring MVC este un framework pentru dezvoltarea de aplicații web, în timp ce Spring
Boot reprezintă un proiect menit să ajute dezvoltatorul să pună aplicație cap la cap și să o instaleze
pe un server cu un efort minim.
De excemplu, se poate creea o aplicație web folosind framwork-ul Spring MVC, dar se va utiliză
Spring Boot pentru a pregăti instalarea acesteia în producție.

3
Facultatea de Inginerie Electrică şi Ştiinţa Calculatoarelor Sisteme Avansate în Automatică și
Departamentul Automaticăşi Tehnologia Informaţiei Tehnologii Informatice

3. Detalii tehnice
3.1.Cerințe de sistem:
Versiunile de Spring Boot se pot folosi începân cu Java 6. Versiunea 6 de Java necesită anumite
configurări suplimentare, însă versiunile mai noi sunt integrate nativ.
Recomandarea comunității este de a folosi Java 8 sau mai sus pentru dezolvatarea de aplicații
folosind Spring boot.

3.2.Container pentru servlet-uri

Este oferit suport pentru următoarele containere integrate pentru servel-uri:

Name Servlet Version Java Version

Tomcat 8 3.1 Java 7+

Tomcat 7 3.0 Java 6+

Jetty 9.3 3.1 Java 8+

Jetty 9.2 3.1 Java 7+

Jetty 8 3.0 Java 6+

Undertow 1.3 3.1 Java 7+

Tabel 1. Container pentru servlet-uri - versiuni

De asemenea o aplicație Spring Boot poate fi rulată pe orice container care suportă Servlet
versiunea 3.0 sau mai sus.

4. Folosirea Spring Boot

Pentru dezvoltarea aplicațiilor folosind Spring Boot se recomandă utilizarea unor sisteme ce oferă
management pentru dependințe și care poate consuma artefacete de pe repository-ul Maven Central.
Astfel, recomandarea este să se folosească Maven sau Gradle, deși, cu puțin efort, se poate integra
și cu Ant.
Structura codului nu este influențată în niciun fel de Spring Boot, însă există câteva bune practici de
care se poate ține cont. Spre exemplu, se descurajează folosirea pachetelor implicite, deoarece
căutarea componentelor construite în aplicație va fi eronată. De asemenea, clasa principală a
proiectului este verificată de adnotarea pentru autoconfigurare în pachetul rădăcină.

4.1.Configurarea:
Spring Boot favorizează configurarea proiectului din cod Java, deși aceasta se poate face și prin
XML. Astfel, clasa ce contine metoda main este candidatul perfect pentru a fi adnotată cu
@Configuration, ceea ce înseamnă că sursa principală este reprezentată de clasă de configurare.

4
Facultatea de Inginerie Electrică şi Ştiinţa Calculatoarelor Sisteme Avansate în Automatică și
Departamentul Automaticăşi Tehnologia Informaţiei Tehnologii Informatice

4.2.Auto-configurarea:
De asemenea, Spring Boot oferă și posibilitatea de autoconfigurare a aplicației în funcțtie de
arhivele .jar ce au fost adaugate. Acest lucru este posibil prin adăugarea adnotarilor
@EnableAutoConfiguration sau @SpringBootApplication pe o clasă deja stabilită pentru
configurare.
Dat fiind faptul că în principiu pentru configurare se folosesc trei adnotări diferite
(@Configuration, @EnableAutoConfiguration și @ComponentScan), Spring Boot introduce o
scurtătură prin @SpringBootApplication care inglobează toate aceste funcționalități.

4.3.Obiecte Spring și injectarea dependințelor:

Obiectele Spring, se referă la faptul ca în momentul în care o clasă obiect java este adnotată drept
componentă (@Component, @Service etc.) aceasta intră sub controlul Spring, iar în momentul
execuției @ComponentScan, adnotare pe clasa de configurare, framework-ul se va ocupa de crearea
de obiect în funcție de dependințtele specifice acestuia.
Odată ajuns sub controlul Spring Boot, obiectul reprezintă un singleton, deci se poate folosi aceeași
instantă în mai multe scenarii. Pentru ca acest lucru sa fie posibil, declarația unui obiect de acest tip
trebuie completată de @Autowired, care duce către instanța existentă.

4.4.Instalarea uneri aplicații Spring Boot

Spring Boot se poate instala și integra într-un proiect folosind Maven sau Gradle. Acesta este
compatibil cu Maven incepând cu versiunea 3.2, iar cu Gradle de începând cu versiunea 2.9.
Dependințele pentru Spring Boot folosesc proprietatea org.springframework.boot groupId, care este
moștenită de la părinte din fișierul de configurare pom.xml. După cum se poate vedea în excemplul
de mai jos, configurarea se realizează folosind anumite șabloane pe care le oferă framework-ul.

<groupId>com.example</groupId>
<artifactId>myproject</artifactId>
<version>0.0.1-SNAPSHOT</version>

<!-- Inherit defaults from Spring Boot -->

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.10.RELEASE</version>
</parent>

<!-- Add typical dependencies for a web application -->

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
Listing. 1. Exemplu configurare Spring Boot – pom.xml

5
Facultatea de Inginerie Electrică şi Ştiinţa Calculatoarelor Sisteme Avansate în Automatică și
Departamentul Automaticăşi Tehnologia Informaţiei Tehnologii Informatice

Spring Boot pune la dispoziție o varietate de metode de instalare a aplicației dezvoltate în acest
sens. O aplicație Spring Boot poate fi instalată pe mai multe platforme cloud, pe mașini reale sau
virtuale, sau pe containere precum Docker.
Arhivele executabile .jar făcute de Spring Boot sunt potrivite pentru a fi puse pe așa numitele
Platforme ca Serviciu oferite de furnizorii cloud. Aceștia tind să ceară ca aplicația să vină cu
propiul container, iar pentru că administrază procese, dar nu neapărat aplicații Java, este nevoie de
un strat superior care să adapteze aplicație în cauză la un proces ce rulează în cloud.
Cei mai populari furnizorii de servicii cloud care au suport pentru aplicații Spring Boot sunt Cloud
Foundry, Heroku și Amazon Web Services.

4.5.Rularea aplicației:
Prin faptul că împachetarea aplicației se face în formatul .jar și este folosit un server HTTP integrat
se oferă avantajul rulării mult mai facile, mai rapide, și de asemenea posibilitatea de debug, precum
la o aplicație obișnuită și fără necesitatea vreunui mediu de dezvoltare sau un modul special.

5. Caracteristici Spring Boot:

Spring boot:
 Oferă o metodă convenabilă pentru contruierea unei aplicații care sa fie pornită prin metoda
main.
 Oferă suport pentru externalizarea configurațiilor ce se pot constitui în fișiere cu proprietăți,
fișiere YAML, variabile de mediu sau argumente la rulare. Astfel, este favorizat accesul
facil la mediul în care aplicația rulează.
 Oferă posibilitatea segregării unor parți din configurația aplicației în scopul folosirii acestora
doar în anumite medii.
 Logarea este de asemenea configurabilă. În mod implicit sunt folosite Log4J și Logback, dar
acestea pot fi personalizate sau modificate ăn funcție de nevoi. De asemenea, logarea se
poate face pe mai multe nivele, în concordanță cu specificațiile mediului în care rulează.
 Este foarte potrivit pentru dezvoltarea aplicațiilor web, prin utilizarea unui server web
integrat.
 Oferă un mecanism de securitate implicit, în cazul în care nu este specificat, astfel fiecare
endpoint prezintă un nivel de bază de autentificare.
 Oferă suport extins pentru lucrul cu baze de date relaționale începând cu driver-ul JDBC și
până la tehnologii de transpunere și asociere a bazei de date precut Hibernate, Spring Data,
care prezintă implementari pentru resitory-uri direct din interfețe folosind convenții pentru
generarea de interogări direct din cod.
 Oferă suport pentru lucrul cu tehnologii și baze de date nerelaționale precum MongoDB,
ElasticSearch, Solr, Cassandra, pentru care există deja variante pentru autoconfigurare.

6
Facultatea de Inginerie Electrică şi Ştiinţa Calculatoarelor Sisteme Avansate în Automatică și
Departamentul Automaticăşi Tehnologia Informaţiei Tehnologii Informatice

 Prezintă mecanisme de cache pentru reducerea execuțiilor bazată pe informație deja

disponibilă. Acest proces de cache este transparent, se realizează fără intervenția vreunui
apelant.
 Oferă posibilitatea executării de apeluri către servicii de tip REST externe. Pentru acest
lucru se oferă un șablon, dar nu se oferă nicio variantă de autoconfigurare, deci aceasta
trebuie facută pentru fiecare tip de apel.
 Oferă autoconfigurare pentru sochet-uri web pentru Tomcat(7 și 8) integrat și altele. Dacă se
lansează un fișier .war intr-un container de sine stătător, Spring Boot va cosidera că acel
container este responsabil pentru configurarea sochet-urilor web.
 Oferă autoconfigurare pentru servicii web, prin urmare trebuie doar definite endpoint-urile

6. Autoconfigurare
6.1. General
În mod implicit, Spring boot folosește un mecanism de autoconfigurare pentru aplicație în
dezvoltare. Aceasta este bazată pe arhivele jar ți clasele definite în classpath.
Spring Boot folosește informațiile găsite în classpath pentru a își face o opinie despre cum ar trebui
să configureze anumite comportamente în mod automat. Astfel, obiectele găsite produc o imagine a
cum Spring Boot trebuie să se configureze pe el însuși.
Principalul atuu al Spring Boot se află în spatele adnotării @EnableAutoConfiguration. Care caută
și încarcă automat toate obiectele sau compenentele de care aplicația are nevoie ținând cont de ce
Spring-ul găsește în classpath.
Adnotările @Enable* nu sunt noi, acestea au fost introduse în versiunea 3 de Spring în ideea de a
înlocui fișierel XML cu clase java.
Printre cele mai populare adnotări de acest tip se află @EnableTransactionManagement care
activează managementul pentru tranzacții, @EnableMVC care activează Spring MVC sau
@EnableScheduling care inițializează un programator (timer).
În esență, aceste adnotări sunt de fapt simple importuri de configurare folosind @Import, după cum
se poate vedea în exemplul de mai jos.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({ EnableAutoConfigurationImportSelector.class,
AutoConfigurationPackages.Registrar.class })
public @interface EnableAutoConfiguration {

/** * Exclude specific auto-configuration classes such that they will never
be applied. */
Class<?>[] exclude() default {};
}

Listing 2. Exemplu @Import

7
Facultatea de Inginerie Electrică şi Ştiinţa Calculatoarelor Sisteme Avansate în Automatică și
Departamentul Automaticăşi Tehnologia Informaţiei Tehnologii Informatice

EnableAutoConfigurationImportSelector folosește SpringFactoriesLoader#loadFactoryNames din

nucleul Spring care va căuta arhive Java care conțin fișiere cu calea META-Inf/spring.factories. În
momentul în care este găsit un asemenea fișier, va fi căutată proprietatea ce poartă numele fișierului
de configurare mai sus amintit, org.springframework.boot.autoconfigure.EnableAutoConfiguration.
Arhiva jar spring-boot-autoconfigure conține un fișier spring.factories după cum urmează:

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingIni
tializer

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConf
iguration,\
org.springframework.boot.autoconfigure.jms.JmsTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.DeviceResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfigura
tion,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfigura
tion,\
org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguratio
n,\
org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration
Listing 3. Conținut spring-boot-autoconfigure

Aceste clase de configurare se bazează pe adnotările Spring precum:

 @ConditionOnClass – activează o configurare doar în cazul în care una sau mai multe clase
au fost găsite în classpath
 @EnableConfigurationProperties – asociză atumoat un obiect Java (POJO) la un se de
proprietăți din fișier de configurare Spring Boot (ex. application.properties)
 @ConditionalOnMissingBean – crează o definiție pentru un obiect doar dacă nu a fost
defini anterior.

8
Facultatea de Inginerie Electrică şi Ştiinţa Calculatoarelor Sisteme Avansate în Automatică și
Departamentul Automaticăşi Tehnologia Informaţiei Tehnologii Informatice

6.2. Asocierea proprietăților

Adnotarea @ConfigurationProperties va asocia fiecare proprietate cu un anume sufix la un obiect
Java. În exemplul de mai jos, proprietatea spring.data.mongodb.port va fi asociată cu atributul port
din clasă.

@ConfigurationProperties(prefix = "spring.data.mongodb")
public class MongoProperties {

private String host;

private int port = DBPort.PORT;
private String uri = "mongodb://localhost/test";
private String database;

// ... getters/ setters omitted

}
Listing 4. Exemplu asociere proprietăți

6.3. Adnotările @Conditional

@Conditional este o adnotare ce a apărut cu versiunea Spring 4 și are rolul de a activa anumite
configurări doar în cazul în care anumite condiții sunt îndeplinite.
Pachetul org.springframwork.boot.autoconfigure.condition prezintă personalizări ale acestei
funcționalități:
 @ConditionalOnBean
 @ConditionalOnClass
 @ConditionalOnExpression
 @ConditionalOnMissingBean
 @ConditionalOnNotWebApplication
 @ConditionalOnResource
 @ConditionalOnWebApplication

6.4. ApplicationContextInitializer
O altă caracteristică a fișierului spring.factories reprezintă posibilitatea de a defini inițializatori de
aplicație. Aceștia permit manipularea conextului aplicației Spring înainte ca aceasta din urmă să fie
încărcată.
Mai în detaliu, inițializatorii de aplicație creează listeneri prin metoda
ConfigurableApplicationContext#addApplicationListener. Spring Boot face acest lucru în
AutoConfigurationReportLoggingInitializer care ascultă la evenimentele de sistem cum ar fi
reîmprospătarea contextului aplicației sau eșecul la pronire a aplicației. Acest procesfacilitează
creearea unui raport al autoconfigurării atunci când aplicația este rulată în modul depanare. Pornirea
aplicației în diferite moduri se poate face prin argumentul –Ddebug sau prin proprietatea
debug=true din fișierul application.properties.

9
Facultatea de Inginerie Electrică şi Ştiinţa Calculatoarelor Sisteme Avansate în Automatică și
Departamentul Automaticăşi Tehnologia Informaţiei Tehnologii Informatice

7. Concluzii
Abordarea Spring Boot facilitează creearea de aplicații executabile jar care dispun de un mecanism
de autoconfigurare.
De asemenea, urmând documentația se pot înlocui gradual clasele de autoconfigurare cu clase de
configurare personalizate.
Spring Boot permite realizarea de prototipuri de aplicație foarte rapid, dar totodată avand control
asupra codului. Pornind de la metodele de autoconfigurare se poate evolua și personaliza o aplicație.

10