Maven - Build Profiles:
Un profilo di compilazione è un insieme di valori di configurazione, che può essere utilizzato per impostare o sovrascrivere i valori predefiniti della build Maven. Utilizzando un profilo di compilazione, è possibile personalizzare la compilazione per ambienti diversi, ad esempio ambienti di sviluppo e produzione.
Cos’è un repository Maven?
Nella terminologia di Maven, un repository è una directory in cui sono memorizzati tutti i jar del progetto, i jar della libreria, i plugin o qualsiasi altro artefatto specifico del progetto e può essere utilizzato facilmente da Maven.
I repository Maven sono di tre tipi:
*Locale
*Centrale
*Remoto
Repository maven Locale:
l repository locale Maven è una posizione di cartella sul computer. Viene creato quando si esegue qualsiasi comando maven per la prima volta.
Il repository locale di Maven mantiene tutte le dipendenze del progetto (jar di librerie, jar di plug-in, ecc.). Quando si esegue una build Maven, Maven scarica automaticamente tutti i jar di dipendenza nel repository locale.
Il repository locale di Maven per impostazione predefinita viene creato da Maven nella directory %USER_HOME%.
Repository centrale:
Il repository centrale di Maven è un repository fornito dalla comunità Maven. Contiene un gran numero di librerie di uso comune.
Quando Maven non trova alcuna dipendenza nel repository locale, inizia la ricerca nel repository centrale utilizzando il seguente URL − https://repo1.maven.org/maven2/
I concetti chiave del repository centrale sono i seguenti:
- Questo repository è gestito dalla comunità Maven.
- Non è necessario configurarlo.
- Richiede l’accesso a Internet per essere cercato.
Repository remoto:
A volte, Maven non trova una dipendenza menzionata anche nel repository centrale. Quindi interrompe il processo di compilazione e restituisce il messaggio di errore alla console. Per evitare tale situazione, Maven fornisce il concetto di Remote Repository, che è il repository personalizzato dello sviluppatore contenente le librerie richieste o altri jar di progetto.
L’operatore ternario
è un operatore condizionale che permette di assegnare un valore a una variabile basato su una condizione. Si chiama “ternario” perché coinvolge tre parti: la condizione, il valore se la condizione è vera e il valore se la condizione è falsa.
La sintassi generale dell’operatore ternario è la seguente:
*variabile = (condizione) ? valore_se_vera : valore_se_falsa;
Special Comment
Esistono tre tipi di commenti speciali:
- XXX: per definire qualcosa di sbagliato ma che funziona
- FIXME: per definire qualcosa di sbagliato e che non funziona
- TODO: per definire qualcosa ancora da fare
Loose coupling
significa che le classi o componenti del tuo programma dipendono il meno possibile l’una dall’altra. Ciò rende il codice più flessibile e facile da modificare, poiché le componenti possono essere cambiate senza influire sulle altre
POJOs “Plain Old Java Object”
è una semplice classe Java con campi e metodi di accesso (getter e setter) utilizzata per rappresentare dati in modo indipendente da librerie o framework specifici.
AOP “Aspect-Oriented Programming”
in Java, è un paradigma di programmazione che permette di separare le preoccupazioni trasversali, come il logging, la sicurezza o la gestione delle transazioni, dal codice di business principale.
AOP consente di definirle separatamente in “aspetti” o “advice”, che possono poi essere applicati in modo trasparente al codice principale.
Comandi per eseguire una aplicazione java
Ci sono due opzioni:
1.mvn exec:java
2.java -jar target/TestApiTraduttore-1.0-SNAPSHOT.jar
Eseguire questo comando per generare le dipendence e il jar a deployare
mvn clean dependency:copy-dependencies package
Inversion of control ?
L’inversione di controllo (Inversion of Control o IoC) è un principio di progettazione software che ribalta il controllo dell’esecuzione del programma. Invece di avere il controllo centralizzato all’interno di un componente o di una classe principale, l’IoC sposta il controllo dell’esecuzione a un framework o a un contenitore.
Ci sono principalmente due tipi di inversione di controllo:
- Iniezione di Dipendenza (Dependency Injection - DI): La DI è un tipo comune di IoC in cui un componente o una classe riceve le sue dipendenze da un’esterna, invece di crearle internamente. Questo può essere fatto tramite il passaggio dei parametri nel costruttore, tramite setter o anche tramite annotazioni, a seconda del linguaggio di programmazione e del framework utilizzati.
2.Gestione degli Eventi: Un altro tipo di IoC è la gestione degli eventi, in cui il controllo viene gestito da eventi o messaggi generati da oggetti o componenti all’interno del sistema. Un componente può registrarsi per ascoltare determinati eventi e reagire quando quegli eventi si verificano. Questo è spesso utilizzato in framework basati su eventi come JavaBeans o nella programmazione basata su messaggi.
Dependency Injection (DI)
Nel contesto della Dependency Injection (DI) in Java, ci sono due forme fondamentali per implementarla:
- Questa è la forma più comune di Dependency Injection ed è basata sulla passaggio delle dipendenze attraverso il costruttore di una classe. Qui, le dipendenze sono fornite come argomenti al costruttore della classe.
esempio: - Iniezione di Dipendenza tramite Setter (Setter Injection):
In questa le dipendenze sono impostate utilizzando i metodi setter di una classe. Invece di passare le dipendenze attraverso il costruttore, le classi forniscono metodi setter che consentono di impostare le dipendenze.
esempio:
Singleton
è uno dei pattern di progettazione più comuni utilizzati in Java. Questo pattern ha lo scopo di garantire che una classe abbia una sola istanza e fornisce un punto di accesso globale a tale istanza.
Prototype
il pattern Prototype consente di duplicare oggetti senza doverne definire ogni dettaglio di nuovo. Puoi pensare a un “prototipo” come un modello da cui creare altre copie, o clone, con la stessa struttura e stato iniziale. Questo è utile quando desideri avere diverse copie di un oggetto, ma non vuoi passare attraverso il processo di inizializzazione complessa ogni volta che ne hai bisogno.
Ciclo di vita del Bean
Il ciclo di vita di un bean comprende tipicamente le seguenti fasi:
- Definizione: In questa fase, il bean viene configurato. Questo coinvolge la definizione delle dipendenze del bean, i valori delle proprietà e altre configurazioni. Questa definizione può essere fatta attraverso XML o annotazioni.
- Creazione (instantiation):
- Injection delle dipendenze:
4.Inizializzazione: - Utilizzo
6.
(da rivedere)
Annotations
Le annotazioni (annotations) in Java sono metadati aggiunti al codice sorgente per fornire informazioni aggiuntive su classi, metodi, variabili e altri elementi del programma. Le annotazioni sono ampiamente utilizzate in Java per scopi di documentazione, refactoring, sicurezza e persino per la configurazione di framework come Spring.
Annotations piu comuni
Ecco alcune delle annotazioni più comuni in Java:
- @Override: Usato per dichiarare un metodo come un’implementazione effettiva di un metodo da una superclasse o da un’interfaccia. Aiuta a prevenire errori di battitura o sovrascritture accidentali.
- @Deprecated: Indica che un elemento (solitamente un metodo o una classe) è deprecato e non dovrebbe essere utilizzato. È utilizzato per avvisare gli sviluppatori di metodi o classi obsoleti.
- @SuppressWarnings: Usato per sopprimere i warning del compilatore. È utile quando si sa che un certo warning è sicuro da ignorare.
java - @Entity (utilizzata in JPA - Java Persistence API): Usata per dichiarare una classe come entità, cioè una classe che è mappata a una tabella in un database relazionale.
5.@Autowired (utilizzata in Spring): Usata per l’iniezione di dipendenze. Indica a Spring di iniettare un’istanza di una classe in un’altra classe.
- @RequestMapping (utilizzata in Spring MVC): Definisce un mapping tra un URL e un metodo di gestione delle richieste in un controller Spring.
- @Test (utilizzata in JUnit): Usata per annotare metodi di test. I metodi annotati con @Test vengono eseguiti quando si eseguono i test JUnit.
- @Component: è una delle annotazioni principali nel framework Spring. Essenzialmente, indica a Spring che una classe è un componente o un bean che deve essere gestito dal container Spring. Ciò significa che Spring riconoscerà questa classe, la istanzierà e la manterrà nel suo contesto, consentendoti di accedervi quando necessario.
9.@Qualifier:
<context:component-scan>
</context:component-scan>
Serve per cercare automaticamente i componenti del tuo progetto, come classi con annotazioni
MVC / Model-view-controller
E’ un modello di progettazione spesso utilizzato nello sviluppo del software per organizzare il codice in modo più chiaro e separare le diverse responsabilità di un’applicazione.
*Modello : Rappresenta i dati e la logica di business. Il Modello contiene informazioni sullo stato dell’applicazione e fornisce metodi per accedere e modificarlo. Ad esempio, se stai sviluppando un’applicazione per una libreria, il Model potrebbe contenere le informazioni sui libri, come titolo, autore, anno di pubblicazione, ecc.
*Vista: è responsabile dell’interfaccia utente e di come i dati vengono presentati agli utenti.
*Controllore: Il Controllore funge da intermediario tra il Modello e la Vista. Accetta le richieste dell’utente, le elabora e agisce di conseguenza sul Modello o sulla Vista. Ad esempio, se un utente cerca un libro nella tua applicazione, il Controller riceve la richiesta di ricerca, consulta il Model per ottenere i dati pertinenti e quindi li presenta alla Vista per visualizzarli all’utente.
JPA / Java Persistence API
è una specifica Java che definisce un’interfaccia standard per la gestione della persistenza dei dati in applicazioni Java. In altre parole, JPA fornisce un modo unificato e orientato agli oggetti per interagire con database relazionali all’interno delle applicazioni Java
JSP / Java server pages
è una tecnologia utilizzata nello sviluppo web per creare pagine web dinamiche. È basata su Java e consente agli sviluppatori di mescolare codice Java con il markup HTML per generare contenuti web interattivi
Aspect-Oriented Programming / AOP
(Programmazione Orientata agli Aspetti) è un paradigma di programmazione utilizzato in Java e in altri linguaggi per separare le preoccupazioni o gli aspetti di un’applicazione che non sono correlati alla sua funzionalità principale. AOP consente di modularizzare aspetti specifici di un’applicazione, come la registrazione, la sicurezza, le transazioni, la gestione degli errori e altri, in modo più pulito e manutenibile.
Invece di mescolare questi aspetti con il codice principale dell’applicazione, AOP utilizza qualcosa chiamato “aspetti” per incapsulare e modularizzare il comportamento correlato a queste preoccupazioni. Un aspetto è un modulo che incapsula il comportamento specifico e può essere applicato a più parti dell’applicazione.
AOP si basa su due concetti chiave:
- Punto di Unione (Join Point): È un punto nel flusso di esecuzione dell’applicazione in cui è possibile applicare un aspetto. I punti di unione possono essere i metodi in esecuzione, eventi specifici, chiamate a metodi e altri luoghi in cui si desidera iniettare il comportamento dell’aspetto.
- Consiglio (Advice): È il codice che viene eseguito in un punto di unione specifico. I consigli sono metodi o blocchi di codice che rappresentano il comportamento incapsulato in un aspetto. I consigli possono essere eseguiti prima, dopo o intorno al punto di unione.
Inoltre, AOP introduce anche altri concetti come:
- Aspetto (Aspect): È il modulo che incapsula un insieme di consigli e regole su dove applicare quei consigli. Gli aspetti sono i mattoni di base di AOP.
- Punto di Taglio (Pointcut): È un’espressione che definisce dove applicare i consigli. I punti di taglio vengono utilizzati per specificare i punti di unione specifici in cui verrà applicato un consiglio.
- Introduzione (Introduction): Consente di aggiungere nuovi metodi e attributi alle classi esistenti senza modificarle. Questo può essere utile per estendere la funzionalità delle classi senza modificare il loro codice sorgente.
*crosscutting concern: si riferisce a una parte del software che coinvolge molte parti del codice, tagliando trasversalmente diversi moduli o componenti. Queste preoccupazioni trasversali sono funzionalità o requisiti che non sono facilmente incapsulati all’interno di un singolo modulo o classe e spesso coinvolgono operazioni comuni, come la gestione delle transazioni, il logging, la sicurezza, la gestione delle eccezioni o l’aspetto transazionale.
