Sei sulla pagina 1di 36

Sommario

COLLOQUIO PERSONALE ................................................................................................................................... 4


PATTERN ............................................................................................................................................................ 4
MVC ............................................................................................................................................................... 4
MVVM............................................................................................................................................................ 5
Singleton ........................................................................................................................................................ 6
IoC (Inversion of Control) e DI (Dipendency Injection) ................................................................................. 6
DAO................................................................................................................................................................ 6
DTO ................................................................................................................................................................ 6
BACKEND ........................................................................................................................................................... 6
Java ................................................................................................................................................................ 6
Descrittori di visibilità ................................................................................................................................ 9
Interfaccia .................................................................................................................................................. 9
Classe astratta ......................................................................................................................................... 10
Modificatori final e static......................................................................................................................... 10
Differenze tra classi astratte ed interfacce.............................................................................................. 11
API Java ........................................................................................................................................................ 11
Spring ........................................................................................................................................................... 13
SpringBoot ................................................................................................................................................... 14
Hibernate ..................................................................................................................................................... 15
Servizi REST .................................................................................................................................................. 15
SOAP ............................................................................................................................................................ 16
Differenza tra Web Service REST e SOAP .................................................................................................... 16
Microservizi ................................................................................................................................................. 17
FRONTEND ....................................................................................................................................................... 19
Javascript ..................................................................................................................................................... 19
Bootstrap ..................................................................................................................................................... 19
Angular ........................................................................................................................................................ 20
Errori ............................................................................................................................................................ 23
Html ............................................................................................................................................................. 23
CSS ............................................................................................................................................................... 24
TESTING ........................................................................................................................................................... 25
JUnit ............................................................................................................................................................. 25
Mockito........................................................................................................................................................ 25
Protractor .................................................................................................................................................... 25
DEVOPS ............................................................................................................................................................ 25

2
Apache Maven ............................................................................................................................................. 25
Git ................................................................................................................................................................ 25
.NET.............................................................................................................................................................. 26
Node.js ......................................................................................................................................................... 28
JHipster ........................................................................................................................................................ 29
Jenkins ......................................................................................................................................................... 29
Test driven development............................................................................................................................. 30
Database relazionali e non relazionali ......................................................................................................... 30
Scrum ........................................................................................................................................................... 31
Servlet Container e Application Server ....................................................................................................... 32
Docker.......................................................................................................................................................... 33
Appendice A: Glossario.................................................................................................................................... 34
Appendice B: Domande ................................................................................................................................... 35

3
COLLOQUIO PERSONALE
Queste sono le linee guida per il colloquio personale che si sostiene con il cliente.

• Nome e cognome
• Diploma o laurea
• Esperienze precedenti con dettagli dalla meno recente alla più recente. Ricordarsi di specificare le
tecnologie utilizzate o i linguaggi adottati.
• Esperienza in Contrader e specificare:
o Progetto su cui si sta lavorando con relativo scopo
o Architettura del progetto (backend e frontend)
o Metodologia di sviluppo utilizzata

E’ buona norma:

• esprimere il colloquio personale a ritmo sostenuto evitando pause nel discorso.


• farlo durare almeno 4 o 5 minuti

PATTERN
MVC
MVC è un pattern di Java (Model-view-controller):

1. Il Model è il livello che gestisce la persistenza dei dati


2. La View visualizza i dati contenuti nel model e interagisce con l’utente.
3. Il Controller riceve i comandi dall’utente (dalla View) e modifica lo stato degli altri due componenti.

La view comunica con il Controller, il Controller con il Model attraverso i Service (che non usa le classi del
Model ma i DTO), e il Model con il DAO che attinge o aggiunge al dB.

I DTO sono una mappatura del model, contengono i campi del Model che mi servono e vengono usati dal
controller che non può interagire con le classi del model per motivi di sicurezza. Sopra il Service usiamo i
DTO e sotto i DAO, il passaggio da DTO a DAO e da DAO a DTO avviene attraverso i converter (I service
interagiscono con model e sono gli unici a chiamare i converter).

4
VIEW
--------------------------
DTO
CONTROLLER
--------------------------
CONVERTER
SERVICES

MODEL --------------------------
DAO
--------------------------
Framework è un’architettura logica di supporto su cui un software può essere progettato e realizzato. È
definito da un insieme di classi astratte e dalle relazioni tra esse; alla base di un framework c’è sempre una
serie di librerie di codice.

MVVM
Il pattern Model-View-ViewModel è una variante del patten MVC tipicamente utilizzata in diversi
framework e librerie per la progettazione di interfacce grafiche (Angular, React, ecc.)

E’ costituito essenzialmente da tre componenti:

• Model: sono i business object, i service, ecc.


• View: sono gli elementi visualizzati all’utente. Non contiene logica. Contiene una serie di direttive
che definiscono il tipo di databinding con il View Model.
• View Model: fa da intermediario tra la View ed il Model e contiene tutta la logica della vista. Invoca
i metodi facenti parte delle classi del modello.

5
Singleton
E’ un pattern che evita l’istanziazione multipla, quindi ha il vantaggio di far risparmiare molta memoria ed
utilizzare una sola istanza di un oggetto. Viene implementato con un metodo statico getIstance() che
verifica se è presente o meno un’istanza dell’oggetto: se presente la restituisce, altrimenti ne crea una
nuova. Nel caso di una applicazione con più thread (multithreaded) deve essere applicata la keyword
synchronized al metodo statico getInstance() per renderlo thread-safe, evitando così l’accesso multiplo.
Con la keyword synchronized l’accesso da parte di più thread è garantito che sia sempre sequenziale.

IoC (Inversion of Control) e DI (Dipendency Injection)


E’ un pattern dove un componente di livello applicativo riceve il controllo da un componente appartenente
ad una libreria riusabile. Tutto ciò differisce dalla programmazione procedurale classica poiché in quel caso
il controllo viene passato alla procedura di libreria utilizzata.

Vantaggi:

• Rende le componenti software il più indipendenti possibili poiché posso modificarne una parte
senza dover modificare le altre.
• Le dipendenze possono essere iniettate dall’esterno

La Dependency Injection è una delle tecniche con le quali si può attuare l’Inversion of Control. In pratica un
programmatore può iniettare le dipendenze cioè richiamare l’istanza di un oggetto precedentemente
creato, evitando quindi l’inizializzazione.

DAO
DAO sta per Data Access Object. Si creano una serie di oggetti che mappano ogni entità ad una tabella. Si
ha così il vantaggio di confinare tutta la comunicazione col DB in delle classi ben definite che possono far
parte di un livello dell’architettura.

DTO
DTO sta per Data Transfer Object: è’ un oggetto usato per trasferire dati alla View. Spesso gli oggetti DTO
sono usati in congiunzione con gli oggetti DAO. La differenza sostanziale tra i due sta nel fatto che i DTO
sono soltanto oggetti contenitori.

I vantaggi sono:

• Si crea una netta distinzione tra i dati utilizzati nel business (DAO) e quello utilizzati nella view
(DTO)
• Si alleggerisce la view perché i DTO possono trasferire solo le informazioni necessarie ad una
determinata view, senza la necessità di caricare interamente l’oggetto oppure creando DTO
specifici per una View tipo una dashboard.

BACKEND
Java
Java è un linguaggio di programmazione orientato agli oggetti (OOP: Object Oriented Programming) ed è
progettato per lavorare indipendentemente dalla piattaforma di esecuzione (concetto di portabilità).

E’ un linguaggio compilato dal compilatore Java che produce il cosiddetto Bytecode ed interpretato sulla
Java Virtual Machine. Tutti gli oggetti non più referenziati vengono automaticamente liberati dal Garbage

6
Collector, quindi il programmatore non deve esplicitamente distruggere le istanze come in altri linguaggi
tipo il C++.

La programmazione ad oggetti si basa su 3 principi:

1. L’ereditarietà si ha quando una classe (sottoclasse) eredita i metodi o gli attributi da una classe
padre (superclasse).
2. Il polimorfismo in base alla classe che lo richiama può avere diverse funzionalità (es metodo
getArea diverso in base a classe Quadrato o Cerchio).
3. L’incapsulamento dei dati è un concetto importante all’interno di una classe, infatti le
caratteristiche di una classe creata da noi si dichiarano come “private” in modo da non dare a tutti
libero accesso al contenuto della classe se non attraverso metodi opportuni.

Il package è il contenitore delle classi.

La classe è un costrutto per creare oggetti. È un contenitore di attributi, metodi e costruttori.

Il main è metodo per l’avvio dell’applicazione. Deve essere (public static void main(String[] args) ).

Con oggetto si intende nella maniera generica una regione di memoria allocata, è un’istanza di una classe.
Per definirlo serve individuare caratteristiche (attributi) e metodi (azioni che può compiere o subire).

Persona p = new Persona(); p è nome del’oggetto della classe Persona

Un’istanza di una classe è un oggetto e si crea come nella tabella precedente.

Il parametro esplicito è quello che passiamo al metodo. Il parametro implicito è l’oggetto su cui chiamiamo
il metodo.

La variabile è un puntatore all’indirizzo di memoria in cui sono salvate le proprietà dell’oggetto (stato,
comportamento, proprietà).

1) Persona p1 = new Persona(“Pippo”); 1) // valido solo se ho un costruttore di


Persona che riceve una stringa
2) Persona p1 = new Persona(); 2) //valido
p1.setNome(“Pippo”);

3) Persona p2= new Persona(“Pippo”);


p1 == p2 FALSO in quanto si trovano in celle di memoria
diverse

Il costruttore indica il metodo associato ad una classe e ha lo scopo di inizializzare le variabili di istanza. Non
ha tipo di ritorno. Viene chiamato automaticamente quando creo un nuovo oggetto.
Persona p = new Persona(); Persona = classe;
p = nome della variabile (oggetto)
new Persona () = costruttore della classe Persona
p.setNome(“Pippo”); per modificare il valore di una campo

7
8
Descrittori di visibilità
Un campo è la proprietà o caratteristica dell’oggetto, detto anche attributo dell’oggetto.
Il metodo o funzione è una parte di codice che ci può o meno restituire qualcosa.

Ci sono diversi descrittori di visibilità:

• public: rende visibile un campo o un metodo a tutti (non è buona norma utilizzarli per accedere ai
campi)
• private: rende visibile un campo o un metodo solo all’interno della classe. Un campo private può
diventare accessibile all’esterno se vengono dichiarati i metodi get e set come public.
• protected: un campo o un metodo sono visibili solo alle classi dello stesso package o alle sottoclassi
• default: visibile dallo stesso package e dalle sottoclassi se sono nello stesso package. È la visibilità
assegnata di default se non viene specificato nulla.

Get (metodo di accesso) e Set (metodo di modifica) sono dei metodi che ci permettono di settare
(assegnare) un valore ad una variabile o di prendere (get) un valore (campo) che ho già nella classe.

public class Persona { Le variabili all’interno di una classe vanno


private string nome; dichiarate come private così da non poter essere
} modificate da fuori la classe.

public String getNome(){ String è quello che ci aspettiamo come risposta


return nome;
}
public void setNome(String void perché non deve ritornarci niente
valore){
this.nome = valore;
}

Interfaccia
L’interfaccia possiede solo la signature dei metodi (i metodi non vengono implementati). È una classe
astratta senza parametri. Può solo definire variabili final o static. C’è solo la signature del metodo.
Un’interfaccia può estendere un’altra interfaccia

public interface FiguraGeometrica{ L’interfaccia ci aiuta per creare un


int calcolaArea(); qualcosa che può valere per più
} classi

public class Quadrato implements


FiguraGeometrica{ Implements vuol dire che la classe
int lato = 5; Quadrato deve PER FORZA avere al
suo interno la funzione
(2) @Override //annotaz. Java x implement.
interfacci “calcolaArea” che restituisce un
Public int calcolaArea(){ intero.
Return lato x lato; Infatti arriva il suggerimento che ti
} scrive (2)
}

9
ArrayList<FiguraGeometrica> f = new
ArrayList<>(); f.add(q1) = consentito perché
Quadrato q1 = new Quadrato(); quadrato è una figura geometrica
f.add(q1);
L’array “FiguraGeometrica” può
contenere al suo interno diverse
ArrayList<FiguraGeometrica> f = new
figure geometriche.
ArrayList<>();
int area = f.get(0).calcolaArea(); f.get(0).calcolaArea() va a prendere
la figura che si trova all’indice 0
dell’array e calcola l’area.

Classe astratta
Una classe astratta è una classe che non può essere istanziata (cioè senza costruttore). Si possono
implementare i metodi. Se nella classe che estende la classe astratta non implementi con un return, fa di
default quanto implementato nella classe padre. La classe concreta DEVE implementare i metodi non
implementati dalla classe astratta.

@overload quando puoi costruire due metodi con lo stesso nome che possono avere return o parametri
espliciti diversi (dati passati in un metodo). Come con un costruttore.

@override operazione di sovrascrittura dei metodi per Interfaccia devi sovrascrivere i metodi che sono
dichiarati nell’interfaccia.

Modificatori final e static


Esistono 2 tipi di modificatori:

• static: può essere applicato a classi, metodi o variabili.


o Se applicato ad una classe: non è necessario istanziarla per utilizzare metodi e attributi al
suo interno. Non ha costruttore, né return.
o Se applicato a variabili posso accedervi direttamente con la sintassi nomeclasse.nomevabile
senza istanziare l’oggetto
o Se applicato a metodi significa che i metodi sono accessibili sempre senza istanziare la
classe che li contiene. Ad esempio per chiamare un metodo statico scrivo
nomeclasse.nomemetodo()
• final: può essere applicata a classi, metodi, o variabili.
o Se applicato a classe allora la classe non può essere estesa
o Se applicata a variabili è utile quando si vuole che una variabile memorizzi sempre lo stesso
valore
o Se applicato a metodi questi non possono essere estesi

Una classe è immutabile se lo stato di un oggetto di quella classe (detto anche oggetto immutabile) non
può essere modificato dopo che è stato creato. Solo accedere con i get.

Boxing per passare da tipo primitivo a tipo di classe (nel metodo dichiaro la variabile in una classe, quando
la richiamo metto INTEGER e mi trasforma l’int in una variabile di classe). classe wrapper.

Java bean sono classi scritte in java usate per incapsulare più oggetti in un singolo oggetto detto bean, cosi
che tali oggetti possono essere passati come un unico oggetto invece che come tanti oggetti multipli.

10
Differenze tra classi astratte ed interfacce
Una classe astratta è una classe che non può essere instanziata e che serve solo per essere
derivata, definendo al suo interno metodi e proprietà tutti o in parte anch'essi astratti. Una classe astratta
che implementa solo ed esclusivamente metodi e proprietà astratte viene detta classe astratta pura.
Per definire una classe astratta in C#, dobbiamo anteporre alla definizione della classe la keyword abstract,
stessa cosa vale per la definizione di metodi e proprietà astratte, come possiamo vedere nell'esempio
seguente:
public abstract class Mammifero {

//metodo astratto
public abstract GetModoCamminare();

//proprietà astratta
public abstract string Name { get; set; }
...
}

Le interfacce sono molto simili alle classi astratte, in quanto anch'essa definisce metodi e proprietà
astratte. Nelle interfacce non troveremo l'implementazione di alcun metodo o proprietà, come per le classi
astratte pure, si dice che le interfacce stipulino un contratto con la classe derivata che le implementa.

Per definire un'interfaccia in C#, bisogna anteporre la keyword interface al nome dell'interfaccia
stessa, inoltre gli access modifier per i membri non vengono specificati nelle interfacce. Proviamo ad es. a
definire un'interfaccia che definisca un metodo che sarà comune a tutte le sue classi derivate:

public interface ICalc {

//metodo dell'interfaccia
public Count();
}

Interfaccia Classe astratta


Contiene metodi implementati e non implementati
Contiene solo firme dei metodi e costanti
e variabili
Una classe può implementare uno o più interfacce Una classe può estendere una sola classe astratta
Non può essere istanziata Non può essere istanziata

API Java
La piattaforma Java è disponibile in tre configurazioni a seconda dell'uso che se ne vuole fare:

• Standard Edition. Fornisce API per le esigenze più comuni, che permette di scrivere applicazioni
stand-alone, applicazioni client e server in un contesto di reti di computer, applicazioni per accesso
a database, applicazioni per il calcolo scientifico e di altro tipo.
• Enterprise Edition. Permette di scrivere applicazioni distribuite. E’ costituito da diverse tecnologie
come (vedi immagine sottostante):
o JMS: Java Messsage Service
o EJB: Enterprise Java Beans
o JPA: Java Persistence API, ecc.
11
• Micro Edition. Permette di scrivere applicazioni per i terminali mobili e, più in generale, per i
dispositivi dotati di poche risorse computazionali (telefoni cellulari, palmari, smart cards ed altri).

12
Spring
È un framework, che di solito si usa con Hibernate (piattaforma che gestiste la persistenza dei dati
appoggiandosi ad un framework) con cui puoi gestire un DB tramite Java. Uso Hibernate perché ho dei
vantaggi dovuti al fatto che non ho necessità di query e posso fare findByCampo(nomeCampo) e mi
restituisce la tupla.

Annotazioni

1. @Entity = crea tabella


2. @id = PK
3. @Column= ci dice che stiamo riempiendo una colonna
4. @GeneratedValue (autoincrement)
5. @ManyToOne = molti a uno (associazione chiave primaria - chiave esterna);
6. @JoinColumn(name = ‘nomecampo(foreignKey)’) ;
7. private nomeTabella nomecampo;

Inversion of control (IoC) è un pattern che permette al programmatore di non preoccuparsi di istanziare
determinati elementi ma sarà direttamente il framework a metterli a disposizione.

Un Bean è un oggetto che viene istanziato, assemblato e gestito in altro modo da un contenitore IoC di
Spring. Questi bean vengono creati con i metadati di configurazione forniti al contenitore.

@Repository Classe @service Classe


DAO Service
@Autowired Costruttore @autowired Costruttore

@Autowired permette di iniettare le istanze all’interno di una classe, sostituisce il costruttore, creando le
dipendenze. Segna un costruttore, un campo, un metodo setter o un metodo di configurazione che deve
essere eseguito automaticamente dai servizi di iniezione delle dipendenze di Spring.

@Repository identifica un componente Spring che corrisponde al DAO. L’obiettivo è quello di ridurre il
codice implementato. Indica che una classe annotata è un "Repository" come "un meccanismo per
incapsulare il comportamento di archiviazione, recupero e ricerca che emula una collezione di oggetti".

Il CrudRepository (interfaccia) fornisce funzionalità CRUD per la classe di entità che viene gestito.

@CrossOrigin è un meccanismo per indicare ad un browser che un app dispone delle autorizzazioni per
accedere alle risorse selezionate. Un'applicazione web invia una cross-origin HTTP request quando richiede
una risorsa che ha un'origine (protocollo, dominio e porta) differente dalla propria.

@RestController sono i servizi rest. Realizza un’architettura client-server per scambiare dati attraverso il
protocollo http. I metodi delle richieste http che ho utilizzato sono :

1. POST: si utilizza nel create per ottenere qualcosa passando dei parametri che non si vedono in
chiaro nell’URL.
2. GET: si utilizza nella read per ottenere qualcosa senza passare parametri (cambio pagina) o se passi
parametri si vedono in chiaro nell’URL.
13
3. PUT: si utilizza nell’update , serve per allocare nuove risorse sul server passategli dal client.
4. DELETE: si utilizza nella delete che consente la cancellazione di un oggetto su un server.

Pom.xml contiene le dependency (librerie, oggetto ecc) che sono necessarie all’app per funzionare.

Dependency injection instanziano automaticamente degli oggetti.

Utilizzare Spring ha una serie di vantaggi:

• Modularità. La struttura modulare del framework, che ad oggi si compone di oltre venti sotto-
progetti, ne costituisce un altro punto di forza. In fase di progettazione potremo scegliere quali
sono le funzionalità richieste dalla nostra applicazione e includere solamente i package necessari.
• Flessibilità. Spring lascia ampia libertà allo sviluppatore riguardo al percorso da seguire per arrivare
al risultato desiderato. I vincoli da rispettare sono veramente pochi. Spring ci consegna i
mattoncini, sta a noi incastrarli nel modo che riteniamo più opportuno.
• Testabilità. Aspetto spesso sottovalutato. Il cuore di Spring implementa un’architettura di tipo IoC
(Inversion of Control), che permette di eliminare dal nostro codice dipendenze dirette tra le classi.
Ne consegue un’elevata testabilità dei singoli componenti dell’applicazione.

SpringBoot
Spring Boot non è un framework, è un progetto collaterale nato dal progetto principale Spring con lo scopo
di creare applicazioni stand-alone con configurazioni minime.

Per realizzare un’applicazione Spring Boot è necessario andare su https://start.spring.io/, selezionare i


parametri e moduli desiderati e scaricare un file zippato che conterrà il progetto.

Il progetto scaricato avrà le seguenti caratteristiche:

• Esso avrà diversi starter nel POM di Maven a seconda delle dipendenze selezionate sulla pagina
precedente
• Un server tomcat integrato visibile come dipendenza nel file POM, quindi il file Jar risultante sarà
automaticamente avviabile
• Una serie di annotazioni di autoconfigurazione (vedi l’annotazione @SpringBootApplication
presente nel file principali di un progetto che usa Spring Web)

Il file finale di output di un progetto Spring Boot sarà un JAR contenente al proprio interno tutto il
necessario per il suo funzionamento (senza considerare l’RDBMS)

14
Hibernate
Gestisci la persistenza dei dati sul DB attraverso la rappresentazione e il mantenimento sul db relazionale di
un sistema di oggetti Java. E’ un’implementazione open source delle specifiche JPA. Permette di
implementare classi DAO.
Un’entità è una classe che rappresenta una
@Entity
tabella all’interno del dB.
@Id
@Column
Definisce una Primary Key come autoincrement
@GeneratedValue(strategy=GenerationType.IDENTITY)
private long id;
@ManyToOne Crei una relazione
@JoinColumn (name = "owner") Relazione con tabella Customer con campo
private Customer owner; owner

JPA si occupa della “gestione della persistenza dei dati di un DBMS relazionale nelle
applicazioni che usano le piattaforme Java Standard Edition e Java Enterprise Edition”. JPA è una
piattaforma che estende Hibernate fornendo un consolidato strumento di mapping relazionale.

I vantaggi di utilizzarlo sono:

• Offre la possibilità di gestire la persistenza in Java senza preoccuparsi del tipo di DB sottostante:
basta cambiare una stringa di configurazione ed è possibile cambiare il tipo di DB
• Offre il linguaggio HQL (Hibernate Query Language) che estende il linguaggio JPQL (Java Persistence
API Language)

Gli svantaggi stanno nel fatto di non poter utilizzare stored procedure o functions altrimenti di perde la
portabilità

E’ possibile effettuare una query in diversi modi:

• Query native scritte nel linguaggio del RDBMS -> non portabili
• Query in HQL (Hibernate Query Language) -> portabili
• Query dinamiche, dette anche criteria query -> portabili

NB: i metodi findAll e findAllBy… fanno parte del modulo Spring Data, non fanno parte di Hibernate.

Servizi REST
Realizzano l’architettura client-server per scambiare dati usando il protocollo http. Infatti i metodi di
trasmissione in un REST controller Spring sono GET, POST, PUT E DELETE.

L’annotazione @Requestmapping si prende sia il valore (ossia la parte di percorso per raggiungere la
funzione) che il metodo (method = RequestMethod.POST) che gli passi. Per passare i parametri utilizzo
l’annotazione @RequestParam. L’annotazione @CrossOrigin è un’annotazione di sicurezza che ci permette
di comunicare con più domini (porte localhost).

JSON è un formato utilizzato per lo scambio di dati nei servizi REST. Per le persone è facile da leggere e
scrivere, mentre per le macchine risulta facile da generare e analizzarne la sintassi.

15
SOAP
SOAP può operare su differenti protocolli di rete, ma HTTP è il più comunemente utilizzato. SOAP si basa sul
metalinguaggio XML e la sua struttura segue la configurazione head-body, analogamente ad HTML. Il
segmento opzionale "Header" contiene metadati come quelli che riguardano il routing, la sicurezza,
le transazioni e parametri per l'orchestration. Il segmento obbligatorio "Body" trasporta il contenuto
informativo e talora viene detto carico utile, o payload.

Differenza tra Web Service REST e SOAP


Anche se l’obiettivo dei due approcci è pressoché identico, cioè l’adozione del Web come piattaforma di
elaborazione, la loro visione e la soluzione suggerita sono totalmente differenti.

• La prima evidente differenza tra i due tipi di Web Service è la visione del Web proposta come
piattaforma di elaborazione. REST propone una visione del Web incentrata sul concetto di risorsa
mentre i SOAP Web Service mettono in risalto il concetto di servizio.
o Un Web Service RESTful è custode di un insieme di risorse sulle quali un client può chiedere le
operazioni canoniche del protocollo http
o Un Web Service basato su SOAP espone un insieme di metodi richiamabili da remoto da parte di
un client
• L’approccio dei SOAP Web service ha mutuato un’architettura applicativa denominata SOA(Service
Oriented Architecture) a cui si è recentemente contrapposta l’architettura ROA (Resource Oriented
Architecture) ispirata ai principi REST.

Il protocollo SOAP (Simple Object Access Protocol) definisce una struttura dati per lo scambio di messaggi
tra applicazioni, riproponendo in un certo senso parte di quello che il protocollo HTTP faceva già. SOAP
utilizza HTTP come protocollo di trasporto, ma non è limitato nè vincolato ad esso, dal momento che può
benissimo usare altri protocolli di trasporto.

• Quindi SOAP non sfrutta appieno il protocollo HTTP, utilizzandolo come semplice protocollo di
trasporto. REST invece sfrutta HTTP per quello che è, un protocollo di livello applicativo, e ne utilizza
appieno le potenzialità.

SOAP REST
Protocollo basato su messaggi XML Stile architetturale
Utilizza solo POST nelle richieste HTTP Utilizza POST, GET, DELETE e PUT nelle richieste
HTTP
Può essere stateless o statefull a seconda Per definizione è stateless
dell’implementazione
L’architettura SOA espone servizi L’architettura REST espone risorse
Usa WSDL per la comunicazione tra produttore e Utilizza XML o JSON per inviare e ricevere dati
consumatore
Invoca servizi chiamando metodi RPC (Remote Chiama i servizi attraverso path URL
Procedure Call)
Il trasferimento avviene su http Il trasferimento avviene solo su http

16
Microservizi

Sono un’architettura software distribuita.

Tutta l’architettura si basa sui seguenti componenti:

• Gateway: ha il compito di instradare tutte le richieste provenienti dal frontend. Il gateway ha il compito
di mostrare l’API di tutti i microservizi in modo unificato. Il frontend si interfaccia solo e soltanto con il
gateway.
• Microservizio: un microservizio è un servizio REST che compone un’architettura distribuita. Ogni
microservizio ha le seguenti caratteristiche:
o Ha un proprio database
o può essere realizzato in qualunque linguaggio di programmazione (Java, PHP, C#, ecc.)
o Ha una propria API REST
o deve registrarsi al service discovery altrimenti non risulterà visibile al gateway.
o In ogni microservizio confino delle funzionalità comuni: è importante che ogni microservizio sia
debolmente accoppiato con altri microservizi in modo da limitare la loro interazione e migliorare di
conseguenza le prestazioni del sistema.
o Ogni microservizio per funzionare è necessario che giri su un server web. Nel mondo Java il
progetto SpringBoot fornisce un Tomcat integrato che ben si presta a questo scopo.
• Service discovery (Consul): Consul è un servizio che fornisce il service discovery cioè permette al
gateway di capire dove solo localizzati tutti i microservizi in modo dinamico. Sia i microservizi che il
gateway appena partono si registrano a Consul. In questo modo il gateway capisce dinamicamente
dove solo localizzati i microservizi e sa dove inoltrare le richieste proveniente dal client (browser)
• Frontend: è rappresentato dal browser che si interfaccia con le API fornite dal gateway.

17
La comunicazione tra due microservizi può avvenire in 2 modi:

• Feign client: in questo caso il backend di un microservizio nel livello service si comporterà da client
che contatta direttamente i servizi REST di un altro microservizio bypassando il gateway.
• Bus: in questo caso il bus è un modulo (libreria) condiviso dell’applicazione che non bypassa il
gateway, ma contatterà sempre le sue API unificate.

I vantaggi dei microservizi sono:

• Se un microservizio cede, non cade tutto il sistema.


• L’implementazione di un microservizio non è legata a nessun linguaggio di programmazione
specifico: si può utilizzare qualsiasi linguaggio di programmazione che sia in grado di creare servizi
REST

Svantaggi dei microservizi:

Se i microservizi non sono debolmente accoppiati, quindi ho che un microservizio chiama spesso un altro
microservizio, all’aumentare del numero di richieste avrò un degrado notevole di prestazioni.

I container di Docker ci permettono di isolare ogni microservizio.

In ambiente di produzione i microservizi verranno deployati su piattaforme cloud di orchestrazione servizi


tipo Kubernetes.io.

18
FRONTEND

Javascript
JavaScript è un linguaggio di scripting orientato agli oggetti e agli eventi, comunemente utilizzato nella
programmazione Web lato client per la creazione, in siti web e applicazioni web, di effetti dinamici
interattivi tramite funzioni di script invocate da eventi innescati a loro volta in vari modi dall'utente sulla
pagina web in uso (mouse, tastiera, caricamento della pagina ecc...).

Tali funzioni di script, utilizzati dunque nella logica di presentazione, possono essere opportunamente
inserite in file HTML, in pagine JSP o in appositi file separati con estensione .js poi richiamati nella logica di
business.

In JavaScript lato client, il codice viene eseguito direttamente sul client (browser) e non sul server. Il
vantaggio di questo approccio è che, anche con la presenza di script particolarmente complessi, il web
server non viene sovraccaricato a causa delle richieste dei client. Di contro, nel caso di script che presentino
un codice sorgente particolarmente grande, il tempo per lo scaricamento può diventare abbastanza lungo.

Bootstrap
Bootstrap è un toolkit per la creazione di interfacce grafiche.

Per funzionare ha bisogno di:

• JQuery: una libreria javascript


• Popper.js: un’altra libreria
• Un file css che contiene tutte le classi utilizzabili nei tag html

I vantaggi di Bootstrap sono:

• se usato crea automaticamente siti responsive, quindi che si adattano a tutti gli schermi dei più
svariati dispositivi.
• Introduce un layout a griglia composto da 12 colonne che si attiva scrivendo la seguente struttura
HTML. Nella figura sottostante il numero di colonne da occupare per ogni div è specificato
nell’attributo class (col-sm-4: indica 4 colonne. Il numero totale deve fare sempre 12. In questo
caso 4x3=12)

<div class="container-fluid">
<div class="row">
<div class="col-sm-4" style="background-color:lavender;">.col-sm-4</div>
<div class="col-sm-4" style="background-color:lavenderblush;">.col-sm-4</div>
<div class="col-sm-4" style="background-color:lavender;">.col-sm-4</div>
</div>
</div>

E’ possibile applicare più classi di Bootstrap ad un elemento HTML semplicemente separandole con uno
spazio nell’attributo “class”.

19
Angular
Angular è un framework open source per lo sviluppo di applicazioni web.

E’ basato sul pattern MVVM (Model-View-ViewModel) dove per

• Model si intendono i service e i DTO


• la view è il file html di ogni componente
• ViewModel è il .ts, detto Component, che contiene tutta la logica e usa gli oggetti del Model.

La prima versione di Angular era detta AngularJS poiché utilizzava Javascript, dalla versione 2 il linguaggio
che utilizza è Typescript, che a differenza di Javascript è un linguaggio tipizzato.

Vantaggi di Angular:

• Viene usato per la creazione di Single-Page Applications (un’applicazione web o un sito web che può
essere usato o consultato su una singola pagina web con l’obiettivo di fornire una esperienza utente
più fluida e simile alle applicazioni desktop dei sistemi operativi tradizionali.)
• ogni applicazione è eseguita all’interno del browser e non viene mai ricaricata poiché ogni modifica
dell’interfaccia grafica avviene a livello DOM (Document Object Model). Così facendo si evita la
spedizione dell’intera pagina da server a browser, inviando così solo i componenti che si modificano.
• Utilizzando toolkit come Angular Material o Bootstrap è possibile realizzare siti responsive, ossia il
design del sito web si adatta in funzione alle dimensioni del dispositivo utilizzato.
• carica i dati asincronicamente: l’interfaccia grafica non resta in attesa dei dati, ma viene prima
costruita e poi caricata con dati.

I principali file di configurazione di Angular sono:

• app-module: è il file dove sono definiti sia i componenti che i service. Tali componenti verranno
inizializzati all’avvio dell’application e poi verranno iniettati col meccanismo della Dependency
Injection così come avviene con Spring
• app-routing: è un file che contiene le coppie “path – componente” necessarie a visualizzare i
componenti
• package.json: tale file viene letto quando si avvia il comando npm install e contiene tutte le
dipendenze del progetto. Se si aggiunge una dipendenza al progetto Angular con il comando npm
install [nomedipendenza] questo file verrà automaticamente aggiornato
• angular.json: contiene le configurazioni principali dell’applicazione. E’ possibile specificare in tale
file eventuali file .css e .js che si vuole inglobare nell’output finale dell’applicazione.

I componenti sono gli elementi costitutivi fondamentali delle applicazioni Angular. Visualizzano i dati sullo
schermo, ascoltano l'input dell'utente e agiscono in base a tale input.

L’AppComponent è distribuita su tre file:

1. app.component.ts- il codice della classe del componente, scritto in TypeScript.


2. app.component.html- il modello del componente, scritto in HTML.
3. app.component.css- Gli stili CSS privati del componente.

Il @Component ha tre proprietà (metadati):

1. selector- il selettore di elementi CSS del componente


2. templateUrl- la posizione del file modello del componente.
3. styleUrls- la posizione degli stili CSS privati del componente.

20
Il Selector corrisponde al nome dell'elemento HTML che identifica questo componente all'interno di
template di un componente genitore.

[(ngModel)] è la sintassi di associazione dei dati bidirezionale di Angular. Ciò significa che il flusso di dati
dalla classe del componente verso la view e dalla view ritorna torna al component.

metadata ci dice come si integrano i pezzi dell’app e quali altri file e librerie richiede l’app. Alcuni dei
metadati sono in @Component. Altri in @Ngmodule va importato nella classe AppModule.

Observable offrono vantaggi significativi rispetto ad altre tecniche per la gestione degli eventi, la
programmazione asincrona e la gestione di più valori.

Observable è un oggeto a cui ci si può sottoscrivere. Appena la funzione si completa l’utente riceve una
notifica.

Routing è un percorso di navigazione tra diversi stati dell’applicazione.

Forms è una libreria per le form.

button -> type -> (click)

=> funzione anonima

<li> è l'elemento host. Crea una lista puntata.

attraverso l’app-routing.

21
export class UpdateListinoComponent implements OnInit{ Implemento l’interfaccia OnInit.
La nostra classe dovrà
contenere i metodi della clsse
constructor(private listinoService:ListinoService, Oninit, in questo caso ngOnInit.
private router:Router){ Devo anche inserire il
costruttore in cui passo il
service e il router.
}

ngOnInit(){

this.listinoService.readListino().subscribe((response)
=> {
this.listino = response;
})

@Component({ Sto creando un componente


selector: 'app-updateListino', dichiarando app (che verrà
templateUrl: './updateListino.component.html', dichiarato nell’app-
styleUrls: ['./updateListino.component.css'] routing.module).
}) Nell’app-module dichiariamo
Service.
<tr *ngFor = "let building of buildings" (click) = building è un nome che diamo
'toFloorMenu(building.id)'> noi che deve corrispondere a
<td >{{building.id}}</td> building.id.
<td>{{building.address}}</td>
buildings è una lista che
<td>{{building.city}}</td>
dichiariamo nel file.ts
<td>{{building.cap}}</td>
<td>{{building.interno}}</td>
</tr>
<form #f=ngForm > Si utilizza la form quando devi
<table> fare una POST per inviare dati.
<tr> Carico la variabile #f.
<td><h2>Id Listino:</h2></td>
<td><select name="idselected"
ngModel="idselected">
<option *ngFor="let lista of listino"
[attr.value]="lista.id">{{lista.id}}</option>
</select></td>
</tr>
</table>

<button class="deleteButton" type="submit"


(click)="update(f)">Modifica</button>

22
update(f:NgForm){ In file.ts mando tutte le
this.listinoService.edit(f.value.idselected, componenti di f nel service che
f.value.newNomeListino, mi serve in questa maniera.
f.value.newAnno).subscribe((response) => { => funzione anonima
if(response != null){
this.router.navigateByUrl("/gestioneListino");
}

edit(id:string ,nomeListino:string, Observable fa parte della


anno:string):Observable<Listino>{ libreria rxjs, rimane in ascolto
const params = new HttpParams().set("id",id). per la gestione degli eventi.
set("nomeListino",nomeListino).set("anno",anno); HttpParams.set sono dei
return this.http.post<Listino> parametri per mandare o
("http://localhost:8080/Listino/edit", params)
ricevere ai/dai servizi REST.
}

<button class="deleteButton" type="submit"


(click)="update(f)">Modifica</button>

Errori
Lato SERVER

• 500: errore sul server

Lato CLIENT

• 400: Richiesta sbagliata (errore di sintassi)


• 401: Stiamo sbagliando qualcosa nell’autenticazione
• 403: Non abbiamo i permessi
• 404: pagina non trovata

Html
L’HTML definisce gli elementi presenti nella pagina, il CSS il loro stile. La classe css si crea scrivendo
.nomeclasse e si richiama all’interno del tag html mettendo class=”nomeclasse”. Se lo creo attraverso
#nomeclasse posso richiamare direttamente la classe tramite il nome senza dover mettere
classe=”nomeclasse”.

Differenza tra padding e margin: il padding ti sposta il contenuto del box ed une proprietà interna, il
secondo ti sposta tutto il blocco poiché è una proprietà esterna.

Differenza tra radiobutton e checkbox? Radiobutton ne puoi selezionare una sola, in checkbox puoi
selezionare di più.

DOM quando il browser interpreta l’html. La struttura costruita a run time dai browser per visualizzare e
reindirizzare la pagina.
23
La struttura base è <HTML><HEAD></HEAD><BODY></BODY></HTML>.

href è un link in cui voglio andare con tag “a”. Possiamo passare da un vista all’altra

<html><head></head><body></body></html>

head contiene meta informazioni sul documento.

<p> definisce il paragrafo.

<body> contiene il contenuto della pagina visibile.

<br> definisce un'interruzione di riga.

I collegamenti HTML sono definiti con il <a>. L'indirizzo del link è specificato href nell'attributo.

Il nome file dell'origine dell'immagine è specificato src.

Gli attributi width e height forniscono informazioni sulle dimensioni per le immagini.

La font-size proprietà definisce la dimensione del testo per un elemento HTML

tr crei una riga, th crei una riga enfatizzata, div è un “contenitore”, td colonna.

CSS
Il CSS ha delle proprietà che servono per dare lo stile alla pagina. Può essere inserito all’interno di una
pagina web in tre modi:

• Importando un file css nel tag HEAD della pagina Html


• Inserendo il codice nel tag HEAD utilizzando il tag <style></style>
• Inserendo il codice direttamente nel codice HTML, in questo caso è detto inserimento inline.

Il CSS fornisce 4 tipi di selettori:

• Selettore universale “*”: si indica con l’asterisco e se lo si usa, tutte le regole che lo seguono si
applicano ad ogni elemento della pagina HTML
• Tag: è un tag dell’HTML
• Classi: sono precedute da un punto nella definizione delle regole del CSS. Si possono applicare più
classi and un tag HTML separandole con uno spazio.
• Id: sono preceduti da un # nelle definizione delle regole del CSS.

24
TESTING
JUnit
JUnit è un framework di unit testing per il linguaggio di programmazione Java. Attualmente è arrivato alla
versione 5.

Esso fornisce una serie di annotazioni:

• @BeforeClass: eseguito prima dell’esecuzione classe


• @AfterClass: eseguito dopo l’esecuzione della classe
• @Before: eseguito prima di ogni metodo di @Test
• @After: eseguito dopo ogni metodo di @Test
• @Test: indica il test vero e proprio

Mockito
E’ un framework che permette di mockare oggetti Java.
Il mock è un oggetto Java fittizio che per ogni metodo chiamato ha output predefiniti.
I mock possono essere utilizzati nel testing per isolare un certo livello architetturale, e quindi si può testare
un livello senza avere i componenti chiamati implementati.
Faccio il mock del oggetto chiamato per testare l’oggetto chiamante.

Protractor
E’ un framework per il testing di applicazioni Angular e AngularJS. Il framework emula il comportamento di
un utente sull’interfaccia grafica, cliccando su bottoni o inserendo dati in qualsiasi componente html.

Utilizza il driver del progetto Selenium per interagire con il browser.

DEVOPS
Apache Maven
Apache Maven (build tool) è uno strumento di gestione di progetti software basati su Java e build
automation.
Maven usa un costrutto conosciuto come Project Object Model (POM): un file XML che descrive le
dipendenze fra il progetto e le varie versioni di librerie necessarie nonché le dipendenze fra di esse.

Per libreria/dipendenza si intente un file JAR contenente classi utilizzate in un progetto.

Vantaggi di Maven:

• Download automatico delle librerie dipendenti in una cartella locale .m2, nei sistemi Windows
localizzata in C:\Utenti\NomeUtente\.m2
• Separazione delle librerie dal progetto principale
• Facilità di spostamento di un progetto da un ambiente all’altro poiché non è necessario portarsi
dietro tutte le librerie poiché verranno automaticamente scaricate da Maven con le giuste versioni.

Git
Git è un controllo di versione. Considera i propri dati più come una serie di istantanee (snapshot) di un mini
filesystem. Serve sostanzialmente per tenere traccia di tutte le modifiche relative ad un progetto attraverso
i “commit”. Nel momento in cui fai un cambiamento lo salvi attraverso “add .”, tieni traccia del tuo
cambiamento attraverso il “commit” e lo butti nel tuo branch attraverso la funzione “push”.
25
Poiché hai l'intera storia del progetto sul tuo disco locale, molte operazioni sembrano quasi istantanee.
La prima cosa da ricordare sempre di Git se vuoi affrontare al meglio il processo di apprendimento è che i
tuoi file in Git possono essere in tre stati: committed (committati), modified(modificati) e staged (in stage).
Committato significa che il file è al sicuro nel database locale. Modificato significa che il file è stato
modificato, ma non è ancora stato committato nel database. In stage significa che hai contrassegnato un
file, modificato nella versione corrente, perché venga inserito nello snapshot alla prossima commit.
La directory di Git è dove Git salva i metadati e il database degli oggetti del tuo progetto. Questa è la parte
più importante di Git, ed è ciò che viene copiato quando si clona un repository da un altro computer.
Git add . serve per iniziare a tracciare un nuovo file. Se adesso fai git commit lo stato del file dopo “add .”
sarà nella cronologia degli stati di git.
Continous integration : tutti I membri si allineano con l’ambiente condiviso (GIT)
Continous delivery: creiamo tanto prototipi in maniera che il cliente possa seguire lo state dell’arte.

.NET
Entity Framework (EF) Core è una versione semplice, estendibile e multipiattaforma della tecnologia di
accesso dati Entity Framework più diffusa.

Entity Framework Core può essere usato come mapper relazionale a oggetti (O/RM), consentendo agli
sviluppatori .NET di utilizzare un database con oggetti .NET ed eliminando la necessità della maggior parte
del codice di accesso ai dati che è in genere necessario scrivere. EFcore supporta molti motori di dB (SQL
server).

Entity Framework Core può accedere a molti database diversi tramite librerie plug-in denominate provider
di database. Con EFcore l’accesso ai dati viene eseguito tramire un modello.

Modello

Un modello è costituito da classi di entità e da un contesto derivato che rappresenta una sessione con il
database che consente di eseguire una query e salvare i dati.
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;

namespace Intro
{
public class BloggingContext : DbContext
{
public DbSet<Blog> Blogs { get; set; }

protected override void OnConfiguring(DbContextOptionsBuilder


optionsBuilder)
{

optionsBuilder.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=MyDatab
ase;Trusted_Connection=True;");
}
}

public class Blog


{
public int BlogId { get; set; }
public string Url { get; set; }
public int Rating { get; set; }

26
public List<Post> Posts { get; set; }
}
}

Query

Le istanze di classi di entità vengono recuperate dal dB tramite LINQ che si usa per eseguire query sui dati
del dB. Una rappresentazione della query LINQ viene passata al provider di database, per essere convertita
nel linguaggio di query specifico del database, come ad esempio SQL per un database relazionale.

27
Node.js
Node NON è un linguaggio di programmazione e nemmeno un framework, ma è un runtime environment
per eseguire codice Javascript.

Blocking sincono: single thread gestisce una richiesta alla volta. Deve aspettare che venga interrogato il dB.

Blocking asincrono: single thread può gestire richieste multiple. Node funziona così, un single thread
gestisce una richiesta, mentre la request interroga il db, il single thread gestisce un’altra richiesta. Quando il
dB è pronto, inserisce il messaggio in un Eventi Queue che è in continuo contatto con il single thread.
Quando trova un evento lo estrae e lo elabora.

Un primo concetto importante è quello delle variabili globali, che possono cioè essere utilizzate in ogni file
(es. console.log() , setTimeout() ). Abbiamo un oggetto “window” che ci permette di accedere alle nostre
variabili globali.

In Node ogni file è considerato un modello e ogni funzione e ogni variabile definita in quel modello non
sono disponibili al di fuori di quel modello. Per rendere “public” una variabile o una funzione e poterlo
utilizzare in un altro modello dobbiamo registrarlo e poi caricarlo:

• module.exports.name = var name // dove il primo “name” è come viene richiamato il modello in un
altro, il secondo è il nome che la variabile (o la funzione) ha all’interno di quel modello. Possiamo
non scrivere il primo “name” qualora abbiamo solo una funzione all’interno del modello
(module.export = name). (modello registrato)
• const namemodello = require (‘path’); // dove in path mettiamo il percorso che ci porta al modello
(./nomemodello). Per richiamarlo scrivo : namemodello.nomefunction(‘ciòchevuoleinIN’). È buona
norma usare “const” e non “var” in modo da non rischiare di sovrascrivere. Se nel modello
registrato abbiamo una sola funzione possiamo richiamare direttamente quella funzione (const
nomefunction = require (‘path’)) e lo richiamo (nomefunction(ciòchevuoleinIN’)). (modello caricato)

Uno strumento importante per capire che errore hai commesso è “jshint nomefile.js” da scrivere in fase di
esecuzione sul prompt dei comandi.

Una funzione importante che a volte viene usata come argomento è callback con due parametri: un errore
e un risultato

Prima dichiariamo il modulo fs di cui abbiamo


const fs = require('fs'); bisogno.
(err,files) => { è la callback che gestisce i due
fs.readdir('$', (err,files) => { risultati ed è equivalente a Funtion(err,files) {
if(err) console.log('Error' , err);
else console.log('Result', files);
})

Un altro concetto importante in Node è l’Evento che ci dice che qualcosa è successo. Ogni volta che un
classe invia una richiesta, la porta crea un evento. Il nostro compito è rispondere all’evento leggendolo e
restituendo la risposta giusta.

28
const EventEmitter = require('events')
const emitter = new EventEmitter ();

// emitter.emit('messageLogged') //solitamente conviene mandare anche dati oltre al


solo messaggio quindi

emitter.emit('messageLogged', {id : 1 , url : 'http//ecc'} ) // metto graffe per


mettere dati all'interno di un oggetto

//manca un ascoltatore

emitter.on('messageLogged', (arg) => { //usiamo arg per prenderci quello che abbiamo
messo tra graffe
console.log('Listner called', arg);
})

Le classi Node sono (ordine di riempimento):

Api : Controller

Model : model

Repository : DAO

JHipster
JHipster è un tool di scaffolding (generatore di codice) per il back-end (monolitiche e microservizi) e
frontend (gateway).

Crea tutta la struttura di un progetto in vari passi.

Di default il gateway gira sulla porta 8080, mentre i microservizi di default girano sulla porta 8081 che è
necessario modificare nel caso siano eseguiti più microservizi contemporaneamente sulla stessa macchina.

E’ possibile aggiungere entità a JHipster in 2 modi:

• importando un file .jdl creabile con JDL Studio (https://start.jhipster.tech/jdl-studio/) con il


seguente comando jhipster import-jdl nomedelfile.jdl
• eseguendo il comando jhipster entity [nomeentità]

Jenkins
Jenkins è uno strumento open source di continuous integration, scritto in linguaggio Java.

29
Fornisce dei servizi di integrazione continua per lo sviluppo del software. Viene eseguito lato server
all'interno di un server web che supporta la tecnologia Servlet e quindi può essere utilizzato da
remoto all'interno di un Web browser. E’ un file .war eseguito all’interno di un servlet container.

Test driven development


Il test-driven development (abbreviato in TDD), in italiano sviluppo guidato dai test, è un modello
di sviluppo del software che prevede che la stesura dei test automatici avvenga prima di quella del
software che deve essere sottoposto a test, e che lo sviluppo del software applicativo sia orientato
esclusivamente all'obiettivo di passare i test automatici precedentemente predisposti.
Il TDD prevede la ripetizione di un breve ciclo di sviluppo in tre fasi, detto "ciclo TDD".

• Nella prima fase (detta "fase rossa"), il programmatore scrive un test automatico per la
nuova funzione da sviluppare, che deve fallire in quanto la funzione non è stata ancora
realizzata.
• Nella seconda fase (detta "fase verde"), il programmatore sviluppa la quantità minima
di codice necessaria per passare il test.
• Nella terza fase (detta "fase grigia" o di refactoring), il programmatore esegue il
refactoring del codice per adeguarlo a determinati standard di qualità.

Database relazionali e non relazionali


I database relazionali salvano i dati in tabelle, che modellano le diverse entità all’interno del dominio
dell’applicazione.

Una tabella ha un numero fisso di colonne e un numero variabile di righe (o record). Le colonne definiscono
i dati degli attributi elle entità di una data tabella.

Le tabelle hanno colonne speciali chiamate chiavi primarie (primary key), che contengono identificatori
unici per ogni riga di una tabella. Le tabelle possono anche avere delle colonne chiamate chiavi
esterne (foreign key), che contengono un riferimento chiave primaria di una riga su un’altra tabella (o
anche sè stessa). Questi collegamenti tra righe sono chiamate associazioni (o relazioni,
dall’inglese relationships) e sono la base del modello relazionale di un database

I database relazionali salvano i dati in maniera efficiente evitando la creazione di duplicati.

Un database NoSQL utilizza le collections (collezioni di documenti), invece delle tabelle, e i documenti al
posto dei record. I database NoSQL, quindi non relazionali, sono progettati in modo da rendere le join
difficili, pertanto la maggior parte di loro non supporta direttamente questa operazione.

La differenza tra database SQL e database NoSQL sta sostanzialmente nella progettazione e in come
vengono immagazzinati i dati al loro interno.

I database SQL eccellono nel salvare dati strutturati in maniera efficiente e compatta. Questi database
preservano la coerenza dei dati. I database NoSQL perdono parte della coerenza per guadagnare migliori
prestazioni rispetto ai relazionali. I database NoSQL, inoltre, sono indicati per sistemi distribuiti.

30
Scrum
Scrum è il metodo Agile più diffuso, particolarmente indicato per progetti complessi ed innovativi.
Divide il processo di gestione di un progetto in sprint per coordinare il processo di sviluppo del prodotto
con le esigenze del committente/cliente. Un processo iterativo in cui gli sprint durano da 2 a 4 settimane.
Le componenti principali di SCRUM si dividono in: ruoli, artefatti ed eventi.

RUOLI
Sono 3 i ruoli definiti all’interno dello Scrum Team, e che lavorano in stretta connessione per assicurare un
continuo e veloce flusso di informazioni.

SCRUM MASTER: il responsabile del processo, colui che deve garantire che la metodologia Scrum venga
compresa ed eseguita con successo. Deve accertarsi che il team lavori in maniera coerente con lo sviluppo
del progetto, eliminare eventuali ostacoli esterni allo Scrum Team che hanno impatto sulla produttività e
organizzare e facilitare i meeting di confronto.

PRODUCT OWNER: colui che conosce tutti i requisiti del prodotto e porta avanti gli interessi di tutti gli
stakeholder. L’interfaccia tra il business, i clienti e i requisiti del prodotto da un lato e il team dall’altro.
Deve massimizzare il valore del prodotto e del lavoro svolto dal Team di Sviluppo.

TEAM DI SVILUPPO: il gruppo di professionisti cross-funzionali ed auto-organizzato, il cui numero di solito si


mantiene da 5 a 9. Si occupa dello sviluppo del prodotto e del testing delle funzionalità, e ha la
responsabilità di organizzare le priorità trasformandole in task da completare per portare a termine quel
determinato sprint.

ARTEFATTI
Gli artefatti sono 3, progettati per massimizzare la trasparenza delle informazioni chiave (sia per lo Scrum
Team che per tutti gli stakeholder) e l’opportunità di ispezione e adattamento.

PRODUCT BACKLOG: il documento che contiene la lista di tutti requisiti necessari per la realizzazione del
progetto. Il Product Owner è responsabile del suo contenuto, della sua disponibilità e dell’ordinamento dei
suoi elementi in base alla rispettiva priorità di svolgimento.

SPRINT BACKLOG: il documento che definisce tutti i task da completare nei singoli sprint. È una previsione
fatta dal Team di Sviluppo in relazione alle priorità indicate nel Product Backlog e al lavoro necessario per
raggiungere gli obiettivi dello sprint.

INCREMENTO: la somma di tutti gli elementi del Product Backlog completati durante uno sprint e durante
gli sprint precedenti. Al termine dello sprint l’incremento dovrà essere realizzato in base a quanto
concordato dal Team di Sviluppo per garantire un prodotto utilizzabile.

EVENTI
Sono 4 gli eventi formali utilizzati in Scrum (con durata prefissata) per creare regolarità,
sincronizzare le attività e ridurre al minimo la necessità di incontri non definiti. L’obiettivo di questi
eventi è consentire trasparenza critica ed ispezione sull’andamento del progetto.
SPRINT PLANNING: la riunione in cui il Product Owner ha stilato il Product Backlog e, in presenza
del Team di Sviluppo e dello Scrum Master, descrive gli item più importanti e l’obiettivo da
raggiungere nello sprint seguente. Al termine della riunione lo Scrum Master può compilare lo
Sprint Backlog.

31
DAILY SCRUM: un breve confronto giornaliero (della durata di 15 min) fra Team di Sviluppo e Scrum
Master, il quale annota il lavoro svolto il giorno precedente e crea un piano per le prossime 24 ore (fino al
prossimo Daily Scrum) per prevedere e sincronizzare le attività.

SPRINT REVIEW: una revisione alla fine di ogni sprint per valutare se l’obiettivo prefissato è stato raggiunto
e con quali risultati. Partecipa tutto lo Scrum Team e, in più, anche il committente del prodotto, al quale
verrà mostrato il lavoro svolto fino a quello sprint.

SPRINT RETROSPECTIVE: un’ulteriore analisi retrospettiva effettuata con la partecipazione di tutto lo Scrum
Team per valutare cosa continuare a fare, cosa smettere di fare e cosa migliorare nello sprint successivo per
ottenere performance ancora più efficienti.

Servlet Container e Application Server


Un esempio di servlet container è Apache Tomcat (o semplicemente Tomcat). E’ un web server (nella
forma di contenitore servlet). Implementa le specifiche JavaServer Pages (JSP) e servlet, fornendo quindi
una piattaforma software per l'esecuzione di applicazioni Web sviluppate in linguaggio Java.

Tomcat non è un servizio che implementa completamente la specifica Java EE, in quanto tale specifica, oltre
le servlet ed alle JSP, supporta tantissime altre tecnologie. Quindi Tomcat non può essere considerato un
application server.

Anche se supporta solo parzialmente alcune tecnologie di Java EE (ovvero Servlet e JavaServer Pages), lo
sviluppatore è libero di importarne altre come le JPA o altre tecnologie sempre in ambiente Java EE. Tomcat
può essere utilizzato anche come contenitore servlet per framework come Spring framework.

Un application server (a volte abbreviato con la sigla AS) è una tipologia di server che fornisce
l'infrastruttura e le funzionalità di supporto, sviluppo ed esecuzione di applicazioni.

Si tratta di un complesso di servizi orientati alla realizzazione di applicazioni ad architettura multilivello ed


enterprise, con alto grado di complessità, spesso orientate per il web (applicazioni web). In altre parole su
di esso gira la cosiddetta logica di business in un'architettura hardware/software di tipo multi-tier e può
dunque essere definito un middleware.

STRUTTURA MODULARE
I moduli normalmente presenti in un application server sono:

• modulo web server che espone al client browser la logica di presentazione statica delle applicazioni
e in diretta interazione con la sottostante logica di business;
• contenitore di componenti server-side detti anche logica di business;
• gestore degli accessi degli utenti e della sicurezza;
• gestione accesso a database o in generale a sorgenti di dati esterne;
• gestore transazioni;
• interfaccia per l'accesso ad un sistema legacy;
• altri componenti per massimizzare le prestazioni, come connection pool, load balancer, caching,
ecc.

Esempi di application server sono:

• JBoss AS, o più semplicemente JBoss, ora chiamato WildFly

32
• WebSphere Application Server (WAS) è un prodotto software che svolge il ruolo di un server di
applicazioni Web. Più specificamente, è un framework e un middleware software che ospita
applicazioni Web basate su Java.

Le differenze fra i due sono molte. Sintetizzando al massimo:

• un Servlet Container (come Tomcat) supporta SOLO lo standard Java Servlet API,
• un Application Server supporta (o dovrebbe supportare, in quanto tale) tutto il framework JEE, che
è composto, oltre che dalla Servlet API, anche da molte altre tecnologie: Enterprise Java Beans
(EJB), Java Message Service (JMS), Java Transaction API (JTA) e diverse altre.

Docker
Docker è un containeirizzatore di applicazioni. E’ in grado di isolare un’applicazione all’interno di container
evitando di far uso di una macchina virtuale.

Utilizzando i container, le risorse possono essere isolate, i servizi limitati ed i processi avviati in modo da
avere una prospettiva completamente privata del sistema operativo, col loro proprio identificativo, file
system ed interfaccia di rete.

I container a differenze delle macchine virtuali condividono lo stesso kernel ed alcune librerie.

Ogni container può essere costretto ad utilizzare una certa quantità di risorse, come la CPU, la memoria e
l'I/O. L'utilizzo di Docker per creare e gestire i container può semplificare la creazione di sistemi distribuiti,
permettendo a diverse applicazioni o processi di lavorare in modo autonomo sulla stessa macchina fisica o
su diverse macchine virtuali. Ciò consente di effettuare il deployment di nuovi nodi solo quando necessario.
Per far interagire tra loro più container Docker, spesso si utilizzano dei software di orchestrazione, come ad
esempio Docker Swarm o Kubernetes.

33
Appendice A: Glossario

IDE (Integrated Development Environment): un ambiente di sviluppo software integrato (Eclipse, Visual
Studio, STS) estensibile tramite plugin (Egit, Spring Boot plugin, ecc.)

34
Appendice B: Domande

Domanda Argomento
Diffetenza tra REST e SOAP Backend
Cos'è Jhipster? Backend
Differenza tra Json e SOAP Backend
Cos'è una JSP Backend
Differenze tra Spring e SpringBoot Backend
Quali moduli di Spring hai usato? Backend
Cos'è Hibernate? Database
Query su DB (insert, update, delete, join) Database
Tipi di database (relazionali e non relazionali) Database
Differenza tra Hibernate e JPA Database
che cos'è un design patten Design Pattern
fammi un esempio di design pattern conosciuti Design Pattern
Pattern MVC Design Pattern
Inversion of Control (dependency injection) Design Pattern
Pattern Singleton Design Pattern
Pattern DAO Design Pattern
Pattern DTO Design Pattern
Pattern Observer Design Pattern
Giro del pattern MVC Design Pattern
Git clone devops
Git checkout Devops
Cos'è git? Devops
Docker Devops
Consul Devops
Tomcat Devops
Jboss Devops
Differenza tra Tomcat e Jboss Devops
HTML Frontend
CSS Frontend
Javascript Frontend
Angular Frontend
Typescript Frontend
Come avviene il passaggio di parametri in una pagina html? Frontend
Che significa responsive? Frontend
Proprietà del linguaggio object oriented? Esempi? Java
Cos'è il garbage collector? Java
Il linguaggio Java è compilato o interpretato? Java
Che cos'è una classe? Com'è costituita? Java
Cos'è un'istanza? Java
Che cos'è una variabile in Java? Java
Quali sono i tipi di visibilità di metodi, classi e attributi Java

35
Differenza tra classe astratta e interfaccia Java
Differenza tra overriding e overloading. Java
Differenza tra static e final Java
cos'è un bean? Java
Differenza tra framework e libreria Java
Cos'è Spring? Java
Testing di unità Testing
Protractor Testing
Cos'è la copertura Testing

36