Spring jdbc
di Carlo Inserra email: inserracarlo@gmail.com
Inversion of control
INVERSION OF CONTROL (IOC)
L’Inversion of Control è un principio architetturale nato alla fine degli anni ottanta, basato sul concetto di invertire il controllo del flusso di sistema (Control Flow) rispetto alla programmazione tradizionale. Nella Programmazione tradizionale lo sviluppatore definisce la logica del flusso di controllo, specificando le operazioni di creazione, inizializzazione degli oggetti ed invocazione dei metodi. Nell’ Inversion of Controlo (IOC) si inverte il control flow, facendo in modo che non sia più lo sviluppatore a doversi preoccupare di questi aspetti, ma il framework, che reagendo a qualche “stimolo” se ne occuperà per suo conto.
Inversion of control
L'Inversion of Control (IoC) è un principio architetturale che si contrappone alla tradizionale programmazione sequenziale dove il flusso di controllo è gestito direttamente dal programmatore. Invece di avere il controllo diretto sul flusso di esecuzione del programma, con IoC si inverte questa logica, delegando il controllo a un framework o a un contenitore (come ad esempio Spring Framework per Java).
Nel paradigma IoC, il flusso di controllo non è gestito direttamente dal programmatore, ma dal framework. Questo significa che il framework si occuperà di creare, inizializzare e gestire gli oggetti necessari per l'applicazione, oltre a coordinare le interazioni tra essi.
Inversion of control
L'IoC viene spesso realizzato attraverso il concetto di Dependency Injection (DI), dove le dipendenze tra gli oggetti vengono gestite esternamente, generalmente attraverso l'utilizzo di file di configurazione o annotazioni.
Per comprendere meglio, considera un'applicazione che ha bisogno di accedere a un database. In un approccio tradizionale, il programmatore dovrebbe creare e gestire manualmente la connessione al database, includendo codice per creare l'oggetto di connessione, configurarlo e chiuderlo correttamente dopo l'uso.
Con l'approccio IoC, il framework (come ad esempio Spring) si occupa di creare e gestire l'oggetto di connessione al database. Il programmatore si limita a dichiarare le dipendenze dell'applicazione (ad esempio, che la classe del servizio ha bisogno di un'istanza di connessione al database), mentre il framework si occupa di soddisfare queste dipendenze e iniettarle nell'oggetto appropriato.
In questo modo, l'Inversion of Control permette una maggiore modularità, facilità di manutenzione e testabilità del codice, in quanto le dipendenze sono gestite in modo trasparente dal framework, riducendo la complessità e il codice boilerplate necessario per la gestione delle dipendenze manualmente.
DEPENDENCY INJECTION (DI)
Il termine Dependency Injection (DI) è utilizzato per riferirsi ad una specifica implementazione dello IoC:
DI è rivolta ad invertire il processo di risoluzione delle dipendenze, facendo in modo che queste vengano iniettate dall’esterno.
Esempio di “tight coupling”: Una classe A si dice dipendente dalla classe B se ne usa in qualche punto i servizi offerti.
Uso del costruttore
Uso di una Factory
Uso di un servizio di naming (lookup)
Per intenderci, Spring implementa la IoC tramite Dependency Injection.
La DI prevede che tutti gli oggetti all’interno della nostra applicazione accettino le dipendenze, ovvero gli (altri) oggetti di cui hanno bisogno, tramite costruttore o metodi setter. Non sono quindi gli stessi oggetti a creare le proprie dipendenze, ma esse vengono iniettate dall’esterno.
(DI) Esempio
public class ConsoleWriter {
public void write(String message) {
System.out.println("Log: " + message);
}}
public class Logger {
private ConsoleWriter consoleWriter;
// Costruttore che accetta un'istanza di ConsoleWriter
public Logger(ConsoleWriter consoleWriter) {
this.consoleWriter = consoleWriter;
}
public void log(String message) {
consoleWriter.write(message);
}}
Queste due classi rappresentano un esempio molto semplice di Dependency Injection in Java.
ConsoleWriter: Questa classe ha un metodo write che stampa un messaggio sulla console.
Logger: Questa classe è dipendente dalla classe ConsoleWriter. Nel suo costruttore, accetta un'istanza di ConsoleWriter. Quando il metodo log viene chiamato, utilizza l'istanza di ConsoleWriter per scrivere il messaggio sulla console.
L'utilizzo del costruttore di Logger per accettare un'istanza di ConsoleWriter è un esempio di Dependency Injection.
(DI) Esempio
public class ConsoleWriter {
public void write(String message) {
System.out.println("Log: " + message);
}}
Questa riga definisce una classe chiamata Logger. La classe è pubblica, quindi può essere utilizzata da altre classi.
write(String message): Questo metodo accetta una stringa message e la stampa sulla console aggiungendo il prefisso "Log: " prima del messaggio. In pratica, questa classe è progettata per scrivere messaggi di log sulla console.
(DI) Esempio
public class Logger {
private ConsoleWriter consoleWriter;
public Logger(ConsoleWriter consoleWriter) {
this.consoleWriter = consoleWriter;
}
public void log(String message) {
consoleWriter.write(message);
}
}
Questo codice definisce la classe Logger, che ha le seguenti caratteristiche:
Attributo consoleWriter: La classe Logger ha un attributo di tipo ConsoleWriter chiamato consoleWriter. Questo attributo è utilizzato per scrivere i messaggi di log.
(DI) Esempio
public class Logger {
private ConsoleWriter consoleWriter;
public Logger(ConsoleWriter consoleWriter) {
this.consoleWriter = consoleWriter;
}
public void log(String message) {
consoleWriter.write(message);
}
}
Costruttore: La classe Logger ha un costruttore che accetta un parametro di tipo ConsoleWriter. Questo costruttore viene utilizzato per inizializzare l'attributo consoleWriter con un'istanza specifica di ConsoleWriter fornita dall'esterno.
(DI) Esempio
public class Logger {
private ConsoleWriter consoleWriter;
public Logger(ConsoleWriter consoleWriter) {
this.consoleWriter = consoleWriter;
}
public void log(String message) {
consoleWriter.write(message);
}
}
Metodo log(String message): Questo metodo accetta una stringa message come parametro e utilizza l'oggetto consoleWriter per scrivere il messaggio di log chiamando il metodo write(String message) dell'oggetto consoleWriter.
(DI) Esempio: la classe di configuration
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
// Definiamo un bean per la classe ConsoleWriter
@Bean
public ConsoleWriter consoleWriter() {
return new ConsoleWriter();}
// Definiamo un bean per la classe Logger e iniettiamo ConsoleWriter tramite costruttore
@Bean
public Logger logger() {
return new Logger(consoleWrite) }}
questa classe di configurazione definisce due bean: uno per la classe ConsoleWriter e uno per la classe Logger. Quando l'applicazione viene avviata, Spring gestisce la creazione e l'inizializzazione di questi bean, risolvendo le dipendenze necessarie e rendendo i bean disponibili per essere utilizzati all'interno dell'applicazione.
(DI) Esempio: la classe di configuration
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
// Definiamo un bean per la classe ConsoleWriter
@Bean
public ConsoleWriter consoleWriter() {
return new ConsoleWriter();}
// Definiamo un bean per la classe Logger e iniettiamo ConsoleWriter tramite costruttore
@Bean
public Logger logger() {
return new Logger(consoleWrite) }}
Questa importazione riguarda l'annotazione Configuration di Spring. L'annotazione @Configuration viene utilizzata per indicare a Spring che una determinata classe contiene definizioni di bean e configurazioni per l'applicazione. Le classi contrassegnate con @Configuration sono considerate classi di configurazione in Spring e possono definire i bean che verranno gestiti e creati da Spring durante il ciclo di vita dell'applicazione.
(DI) Esempio: la classe di configuration
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
// Definiamo un bean per la classe ConsoleWriter
@Bean
public ConsoleWriter consoleWriter() {
return new ConsoleWriter();}
// Definiamo un bean per la classe Logger e iniettiamo ConsoleWriter tramite costruttore
@Bean
public Logger logger() {
return new Logger(consoleWrite) }}
Questa importazione riguarda la classe Bean del framework Spring. La classe Bean è un'annotazione di Spring che viene utilizzata per indicare a Spring che un metodo all'interno di una classe di configurazione (annotata con @Configuration) deve essere interpretato come un metodo di creazione di un bean gestito da Spring.
(DI) Esempio: la classe di configuration: fanno parte del context
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
// Definiamo un bean per la classe ConsoleWriter
@Bean
public ConsoleWriter consoleWriter() {
return new ConsoleWriter();}
// Definiamo un bean per la classe Logger e iniettiamo ConsoleWriter tramite costruttore
@Bean
public Logger logger() {
return new Logger(consoleWrite) }}
. Le annotazioni @Configuration e @Bean sono visibili e influenti sull'intera applicazione Spring e sono valide per tutto il ciclo di vita dell'applicazione.
@Configuration: Questa annotazione viene utilizzata per segnalare che una classe definisce uno o più bean e che tali bean devono essere gestiti e configurati dal contesto dell'applicazione Spring. Indica che la classe contiene metodi annotati con @Bean per la creazione e la configurazione dei bean.
(DI) Esempio: la classe di configuration: fanno parte del context
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
// Definiamo un bean per la classe ConsoleWriter
@Bean
public ConsoleWriter consoleWriter() {
return new ConsoleWriter();}
// Definiamo un bean per la classe Logger e iniettiamo ConsoleWriter tramite costruttore
@Bean
public Logger logger() {
return new Logger(consoleWrite) }}
@Bean: Questa annotazione viene utilizzata per segnalare che un metodo di un bean restituisce un oggetto che deve essere registrato come bean all'interno del contesto dell'applicazione Spring. Spring gestisce il ciclo di vita di questi bean e li rende disponibili per l'iniezione delle dipendenze in altre parti dell'applicazione.
Insieme, queste annotazioni consentono di definire e configurare i bean all'interno di un'applicazione Spring, rendendoli accessibili e utilizzabili da qualsiasi parte dell'applicazione durante tutto il suo ciclo di vita.
(DI) Esempio: il main
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
@SpringBootApplication
public class DiExampleApplication {
public static void main(String[] args) {
SpringApplication.run(DiExampleApplication.class, args);
// Creiamo il contesto dell'applicazione utilizzando la configurazione definita in AppConfig
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// Otteniamo un'istanza di Logger dal contesto
Logger logger = context.getBean(Logger.class);
// Utilizziamo il logger per registrare un messaggio
logger.log("Hello, world!"); }}
La classe DiExampleApplication è l'entry point dell'applicazione Spring Boot.
questa classe avvia un'applicazione Spring Boot, crea un contesto dell'applicazione utilizzando una configurazione definita in AppConfig, recupera un bean Logger dal contesto e utilizza il logger per registrare un messaggio
(DI) Esempio: il main
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
@SpringBootApplication
public class DiExampleApplication {
public static void main(String[] args) {
SpringApplication.run(DiExampleApplication.class, args);
// Creiamo il contesto dell'applicazione utilizzando la configurazione definita in AppConfig
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// Otteniamo un'istanza di Logger dal contesto
Logger logger = context.getBean(Logger.class);
// Utilizziamo il logger per registrare un messaggio
logger.log("Hello, world!"); }}
org.springframework.context.ApplicationContext: Questa classe rappresenta il contesto dell'applicazione Spring, che gestisce il ciclo di vita dei bean e le dipendenze tra di essi. È responsabile della creazione e della gestione dei bean all'interno dell'applicazione Spring. L'interfaccia ApplicationContext fornisce metodi per ottenere bean, pubblicare eventi, risolvere espressioni e altro ancora.
(DI) Esempio: il main
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
@SpringBootApplication
public class DiExampleApplication {
public static void main(String[] args) {
SpringApplication.run(DiExampleApplication.class, args);
// Creiamo il contesto dell'applicazione utilizzando la configurazione definita in AppConfig
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// Otteniamo un'istanza di Logger dal contesto
Logger logger = context.getBean(Logger.class);
// Utilizziamo il logger per registrare un messaggio
logger.log("Hello, world!"); }}
org.springframework.context.annotation.AnnotationConfigApplicationContext: Questa classe è un'implementazione specifica di ApplicationContext che accetta classi di configurazione basate su annotazioni, come quelle definite con @Configuration, per la configurazione dell'applicazione Spring. In particolare, AnnotationConfigApplicationContext consente di creare un contesto dell'applicazione Spring utilizzando una configurazione definita tramite annotazioni presenti nelle classi di configurazione.
(DI) Esempio: il main
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
@SpringBootApplication
public class DiExampleApplication {
public static void main(String[] args) {
SpringApplication.run(DiExampleApplication.class, args);
// Creiamo il contesto dell'applicazione utilizzando la configurazione definita in AppConfig
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// Otteniamo un'istanza di Logger dal contesto
Logger logger = context.getBean(Logger.class);
// Utilizziamo il logger per registrare un messaggio
logger.log("Hello, world!"); }}
Questa parte del programma è responsabile della creazione del contesto dell'applicazione Spring utilizzando la configurazione definita nella classe AppConfig.
(DI) Esempio: il main
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
@SpringBootApplication
public class DiExampleApplication {
public static void main(String[] args) {
SpringApplication.run(DiExampleApplication.class, args);
// Creiamo il contesto dell'applicazione utilizzando la configurazione definita in AppConfig
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// Otteniamo un'istanza di Logger dal contesto
Logger logger = context.getBean(Logger.class);
// Utilizziamo il logger per registrare un messaggio
logger.log("Hello, world!"); }}
AnnotationConfigApplicationContext(AppConfig.class): Questo costruttore di AnnotationConfigApplicationContext accetta una classe di configurazione come argomento. Qui viene passata la classe AppConfig, che è annotata con @Configuration. Ciò indica che la classe AppConfig contiene le informazioni necessarie per configurare il contesto dell'applicazione Spring utilizzando annotazioni.
(DI) Esempio: il main
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
@SpringBootApplication
public class DiExampleApplication {
public static void main(String[] args) {
SpringApplication.run(DiExampleApplication.class, args);
// Creiamo il contesto dell'applicazione utilizzando la configurazione definita in AppConfig
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// Otteniamo un'istanza di Logger dal contesto
Logger logger = context.getBean(Logger.class);
// Utilizziamo il logger per registrare un messaggio
logger.log("Hello, world!"); }}
Dopo aver creato il contesto dell'applicazione, utilizziamo il metodo getBean(Class<T> requiredType) per ottenere un'istanza del bean di tipo Logger dal contesto. Spring gestisce il processo di creazione dell'istanza del bean, iniezione delle dipendenze e qualsiasi altra configurazione necessaria, basandosi sulle definizioni di bean presenti nella classe AppConfig.
(DI) Esempio: il main
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
@SpringBootApplication
public class DiExampleApplication {
public static void main(String[] args) {
SpringApplication.run(DiExampleApplication.class, args);
// Creiamo il contesto dell'applicazione utilizzando la configurazione definita in AppConfig
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// Otteniamo un'istanza di Logger dal contesto
Logger logger = context.getBean(Logger.class);
// Utilizziamo il logger per registrare un messaggio
logger.log("Hello, world!"); }}
Qui stiamo istanziando un oggetto AnnotationConfigApplicationContext passando la classe AppConfig.class come argomento al costruttore. Questo istruisce Spring a creare un contesto dell'applicazione utilizzando la configurazione definita nella classe AppConfig
(DI) Esempio: injection
Nella classe DiExampleApplication, l'injection avviene tramite il contesto dell'applicazione, creato utilizzando AnnotationConfigApplicationContext con AppConfig.class. All'interno del metodo main, viene recuperato un'istanza del bean Logger dal contesto dell'applicazione utilizzando il metodo getBean. Quando viene richiesto il bean Logger, Spring si occupa di iniettare automaticamente l'istanza di ConsoleWriter necessaria per il costruttore del Logger, poiché è stata definita una relazione tra queste due classi nella configurazione di Spring (AppConfig). Questo processo è noto come dependency injection (DI), e permette di gestire le dipendenze tra i vari componenti dell'applicazione in modo trasparente e modulare.
(DI) Esempio: configuration
ecco alcuni scenari comuni in cui definire una classe di configurazione può essere utile in un'applicazione Spring:
Configurazione del database: Se l'applicazione si connette a uno o più database, è utile definire una classe di configurazione per gestire le informazioni di connessione, come URL, nome utente, password e driver JDBC.
Configurazione dei servizi esterni: Se l'applicazione utilizza servizi esterni come servizi web REST, è possibile definire una classe di configurazione per gestire le informazioni di configurazione relative a questi servizi, come URL, chiavi API, timeout e così via.
Configurazione della sicurezza: Se l'applicazione utilizza Spring Security per la gestione dell'autenticazione e dell'autorizzazione, è possibile definire una classe di configurazione per configurare le regole di sicurezza, i provider di autenticazione, i filtri di sicurezza e altro ancora.
(DI) Esempio: configuration
Configurazione dei bean personalizzati: Se l'applicazione utilizza bean personalizzati o configurazioni specifiche, è possibile definire una classe di configurazione per creare e inizializzare tali bean, evitando la necessità di definirli manualmente in ogni parte dell'applicazione.
Configurazione dei percorsi di scansione dei componenti: Se l'applicazione utilizza l'annotazione @ComponentScan per individuare automaticamente i componenti Spring all'interno dell'applicazione, è possibile definire una classe di configurazione per specificare i percorsi di scansione dei componenti e altre opzioni di configurazione.
Questi sono solo alcuni esempi di come una classe di configurazione può essere utile in un'applicazione Spring. In generale, è consigliabile utilizzare le classi di configurazione per separare la configurazione dell'applicazione dalla logica di business, rendendo più facile gestire e mantenere l'applicazione nel tempo.
Spring jdbc
Il framework Spring JDBC si occupa di tutti i dettagli a basso livello, partendo dall'apertura della connessione, dalla preparazione ed esecuzione dello statement SQL, dal trattamento delle eccezioni, dalla gestione delle transazioni e infine dalla chiusura della connessione.
Spring jdbc
JDBC (Java Database Connectivity) è un'interfaccia di programmazione delle applicazioni (API) che definisce come un client può accedere a un database. È una tecnologia di accesso ai dati utilizzata per la connettività dei database Java. Fornisce metodi per interrogare e aggiornare i dati in un database ed è orientata verso i database relazionali. JDBC offre un'interfaccia Java naturale per lavorare con SQL. JDBC è necessario per fornire una soluzione "Pure Java" per lo sviluppo delle applicazioni. L'API JDBC utilizza driver JDBC per connettersi al database.
In breve, JDBC è un'API che consente alle applicazioni Java di comunicare con i database. Essa fornisce un set di metodi e classi per eseguire operazioni di query e aggiornamento sui dati all'interno del database, offrendo agli sviluppatori uno strumento standardizzato per interagire con i database relazionali utilizzando il linguaggio di programmazione Java. Per utilizzare JDBC, è necessario avere il driver JDBC specifico del database che si intende utilizzare, il quale fornisce l'implementazione specifica dei metodi definiti nell'API JDBC per la connessione e l'interazione con il database.
Spring jdbc: jdbc-template
La classe JdbcTemplate è un componente fondamentale nell'ecosistema JDBC di Spring. Essenzialmente, semplifica l'utilizzo di JDBC fornendo un'interfaccia più user-friendly e affrontando molti degli aspetti complessi e soggetti a errori associati all'utilizzo diretto dell'API JDBC standard.
Spring jdbc: jdbc-template
Esecuzione di Query e Aggiornamenti: JdbcTemplate fornisce metodi per eseguire query SQL e aggiornamenti del database senza la necessità di scrivere codice boilerplate per la gestione delle risorse JDBC come apertura e chiusura della connessione, creazione e chiusura dello statement SQL, e gestione dei result set.
Iterazione sui ResultSet: JdbcTemplate gestisce automaticamente l'iterazione sui ResultSet restituiti dalle query SQL, eliminando la necessità per il programmatore di scrivere codice di iterazione manuale.
Gestione delle Eccezioni: JdbcTemplate cattura le eccezioni JDBC e le traduce in eccezioni più generiche fornite dal framework Spring, semplificando la gestione degli errori e fornendo messaggi di errore più significativi e informativi.
Workflow Core di JDBC: JdbcTemplate esegue il flusso di lavoro centrale di JDBC, consentendo al codice dell'applicazione di concentrarsi sulle query SQL specifiche e sull'elaborazione dei risultati anziché sui dettagli di basso livello dell'interazione con il database.
Spring jdbc: jdbc-template
In sintesi, JdbcTemplate agisce come uno strato di astrazione sopra l'API JDBC standard, semplificando notevolmente lo sviluppo di applicazioni che interagiscono con il database utilizzando Java. Permette agli sviluppatori di scrivere meno codice, evitando al contempo molti dei problemi e delle complicazioni tipiche dell'utilizzo diretto di JDBC.
Spring jdbc: jdbc-template: metodi
Spring jdbc: jdbc-template: metodi
public int update(String query):
Utilizzato per eseguire operazioni di aggiornamento del database come inserimento, aggiornamento e cancellazione di record.
Prende una stringa SQL come argomento e esegue la query definita dalla stringa SQL.
Restituisce il numero di righe interessate dall'operazione di aggiornamento nel database.
Spring jdbc: jdbc-template: metodi
public int update(String query, Object... args):
Simile al metodo precedente, ma permette di utilizzare un PreparedStatement per eseguire la query con gli argomenti forniti.
La stringa SQL può contenere segnaposto "?" che verranno sostituiti dagli argomenti forniti nell'array.
Restituisce il numero di righe interessate dall'operazione di aggiornamento nel database.
Spring jdbc: jdbc-template: metodi
public T execute(String sql, PreparedStatementCallback action):
Esegue una query utilizzando un oggetto PreparedStatementCallback per elaborare i risultati.
È utile per eseguire query complesse dove è necessario personalizzare il processo di elaborazione dei risultati.
Restituisce il risultato dell'elaborazione dei risultati definito dall'oggetto PreparedStatementCallback.
Spring jdbc: jdbc-template: metodi
public void execute(String query):
Utilizzato per eseguire query DDL (Data Definition Language) come la creazione di tabelle o l'aggiunta di colonne.
Prende una stringa SQL come argomento e esegue la query definita dalla stringa SQL.
Spring jdbc: jdbc-template: metodi
public T query(String sql, ResultSetExtractor<T> result):
Esegue una query e restituisce il risultato tramite un oggetto ResultSetExtractor.
Utile quando si desidera elaborare i risultati della query in modo personalizzato utilizzando un'implementazione personalizzata di ResultSetExtractor.
Spring jdbc: jdbc-template: metodi
public T query(String sql, ResultSetExtractor<T> result):
Esegue una query e restituisce il risultato tramite un oggetto ResultSetExtractor.
Utile quando si desidera elaborare i risultati della query in modo personalizzato utilizzando un'implementazione personalizzata di ResultSetExtractor.
Spring jdbc: jdbc-template: metodi
Una "DDL query" è una query che viene utilizzata per definire, modificare o eliminare strutture di database. "DDL" è l'acronimo di "Data Definition Language", che è un linguaggio utilizzato per definire la struttura e le caratteristiche dei dati in un database.
Le query DDL possono includere istruzioni come:
CREATE: Utilizzata per creare nuove tabelle, viste, indici, trigger, ecc.
ALTER: Utilizzata per modificare la struttura di un'entità esistente nel database, ad esempio aggiungendo, modificando o eliminando colonne da una tabella.
DROP: Utilizzata per eliminare una tabella, vista, indice, trigger, ecc.
TRUNCATE: Utilizzata per eliminare tutti i dati da una tabella mantenendo la sua struttura.
RENAME: Utilizzata per rinominare una tabella.
Spring jdbc: esempio Database Config
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
@Configuration
public class DatabaseConfig {
@Bean
public DataSource dataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
dataSource.setUsername("root");
dataSource.setPassword("Ilfoggia1");
return dataSource;
}
}
Import delle librerie necessarie:
javax.sql.DataSource: Questa interfaccia definisce un'astrazione per l'accesso a un database relazionale.
org.springframework.context.annotation.Bean: Questa annotazione viene utilizzata per dichiarare un metodo come un bean di Spring.
org.springframework.context.annotation.Configuration: Questa annotazione indica che la classe è una classe di configurazione di Spring.
Spring jdbc: esempio Database Config
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
@Configuration
public class DatabaseConfig {
@Bean
public DataSource dataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
dataSource.setUsername("root");
dataSource.setPassword("Ilfoggia1");
return dataSource;
}
}
Definizione della classe DatabaseConfig come classe di configurazione:
La classe è annotata con @Configuration, che indica a Spring che questa classe contiene le definizioni dei bean da gestire.
Spring jdbc: esempio Database Config
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
@Configuration
public class DatabaseConfig {
@Bean
public DataSource dataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
dataSource.setUsername("root");
dataSource.setPassword("Ilfoggia1");
return dataSource;
}
}
Definizione del bean dataSource:
Il metodo dataSource() è annotato con @Bean, indicando che questo metodo definisce un bean gestito da Spring.
All'interno del metodo, viene istanziata una classe DriverManagerDataSource, che è un'implementazione di DataSource fornita da Spring per l'uso con driver JDBC.
Spring jdbc: esempio Database Config
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
@Configuration
public class DatabaseConfig {
@Bean
public DataSource dataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
dataSource.setUsername("root");
dataSource.setPassword("Ilfoggia1");
return dataSource;
}
}
Vengono impostati i parametri necessari per la connessione al database, come il nome del driver, l'URL del database, il nome utente e la password.
Infine, viene restituito l'oggetto dataSource.