Introduzione a Maven, Spring, MySQL, Hibernate e alla prima applicazione CRUD (parte 1)

Buon pomeriggio. In questo articolo vorrei condividere il mio primo incontro con cose come Maven, Spring, Hibernate, MySQL e Tomcat nel processo di creazione di una semplice applicazione CRUD. Questa è la prima parte di 4. L'articolo è destinato principalmente a coloro che hanno già completato 30-40 livelli qui, ma non si sono ancora avventurati oltre Java puro e stanno appena iniziando (o stanno per iniziare) ad entrare nel mondo aperto con tutte queste tecnologie, strutture e altre parole sconosciute.

Contenuto:

• introduzione
• Creazione di un progetto
• Connessione MVC a molla
• Creazione di pagine e controller
• Configurazione
• Modello
• Modello-View-Controller

introduzione

Ho iniziato a conoscere tecnologie e framework che erano nuovi per me studiando vari esempi in cui sono stati utilizzati, perché di solito capisco meglio qualcosa quando lo vedo in azione utilizzando un esempio di un'applicazione a tutti gli effetti. In genere, tali esempi sono le applicazioni CRUD ( Crea , Leggi , Aggiorna , Elimina ), Internet è pieno di tali esempi con vari gradi di complessità. Il problema è che di solito non spiegano in dettaglio come, cosa e perché è stato fatto lì, perché è stata aggiunta questa o quella dipendenza, perché è necessaria questa o quella classe, ecc. Nella maggior parte dei casi, prendono un'applicazione completamente finita, con un file POM finale, con le versioni finali delle classi, e le esaminano semplicemente ciascuna, senza concentrarsi sulle piccole cose che probabilmente sembrano ovvie a una persona esperta. Ho esaminato molti di questi esempi e di solito è chiaro come funziona il tutto, ma come si sia arrivati ​​a questo non è del tutto chiaro. Pertanto, ho deciso che un esempio del genere sarebbe stato utile non dalla posizione di uno sviluppatore esperto, ma dalla posizione di un principiante che non ha mai avuto a che fare con Spring, Hibernate e altre cose. Cercherò di descrivere nel modo più dettagliato possibile (per quanto la mia comprensione me lo consente) il mio intero percorso di creazione di un'applicazione CRUD, iniziando con qualcosa al livello più semplice di Hello World. Prima di tutto lo faccio per me stesso, perché quando provi a descrivere, raccontare, spiegare qualcosa, è molto meglio assorbito e organizzato nella tua testa. Ma se questo è utile a qualcuno e lo aiuta a capire qualcosa, ne sarò molto felice. In questo esempio, proviamo a creare una semplice applicazione CRUD utilizzando Maven , Tomcat , Spring , Hibernate e MySQL . Passaggi preliminari come l'installazione di Maven , MySQL , l'utilizzo della versione Ultimate dell'idea, ecc. Penso che non sia necessario descriverlo in dettaglio, non dovrebbero esserci problemi con questo. Vale la pena notare che in questo esempio la configurazione verrà configurata utilizzando le classi Java (chiamate JavaConfig) senza utilizzare xml.

Creazione di un progetto

Quindi, poiché sono un principiante, non utilizzeremo alcun archetipo oscuro. L'inizializzazione primaverile sembra ancora troppo spaventosa. Pertanto, creeremo il progetto Maven semplice più ordinario. Non ho un nome di dominio, quindi in groupid scriverò semplicemente testgroupe in artifactid scriverò il nome, ad esempio filmography(questo sarà un elenco di film). Creiamo un progetto e scegliamo Enable auto-importquando l'idea lo suggerisce. Grazie a questo, ogni volta che apporteremo qualche modifica al file POM (Project Object Model, questo file descrive l'intera struttura del progetto Maven), tutto verrà immediatamente applicato automaticamente al progetto. Le librerie verranno prese dal nostro repository locale se le abbiamo già, o se utilizziamo alcune nuove dipendenze che non abbiamo trattato prima, Maven le scaricherà semplicemente via Internet dal repository centrale. Maven ha anche una funzione per scaricare fonti e documentazione (Scarica fonti e/o documentazione). È anche molto comodo, se qualcosa non è chiaro con qualche classe o metodo, puoi andare al codice sorgente e vedere come funziona il tutto all'interno. Aggiungiamo un paio di dettagli. Questa sarà un'applicazione web e utilizzeremo Tomcat . Per distribuire un'applicazione su Tomcat, è necessario trasferirla lì sotto forma di archivio di guerra (Web Application Resource, un formato speciale per le applicazioni web). Per fare ciò, aggiungi la seguente riga al file POM in modo che l'applicazione venga compilata in un archivio war:

<packaging>war</packaging>

Bene, avrai anche bisogno di una directory speciale per le fonti web, nel nostro caso ci saranno pagine jsp e alcune risorse web. Creiamo una maindirectory webapp. Dovrebbe essere chiamato esattamente così ed essere posizionato esattamente nello mainstesso modo di java, resourcesperché questa è la struttura di directory standard di Maven. Una volta installato il pacchetto ware stabilito che si tratta di un progetto Web, la directory webappverrà automaticamente contrassegnata come origini dell'applicazione Web (ci sarà un punto blu su di essa) e tutto ciò che riguarda il Web verrà cercato in questa cartella. E un momento. Per impostazione predefinita, Maven utilizza la versione del linguaggio 1.5, ma voglio utilizzare, ad esempio, la versione 1.8 - Java 8 (puoi prendere 10 o 11, ma non ci sono ancora piani per utilizzare alcuna funzionalità da lì, quindi lascia che sia 8 ). Questo può essere risolto in modo molto semplice, scriviamo in Google qualcosa come "Maven java 8" e vediamo cosa è necessario aggiungere al file POM in modo che Maven compili le nostre classi per la versione richiesta. Di conseguenza, abbiamo quanto segue:

Connessione MVC a molla

Devi iniziare da qualche parte. Secondo il piano collegheremo il database e utilizzeremo Hibernate, ma per ora tutto questo sembra un po' troppo spaventoso. Dobbiamo prima fare qualcosa di più semplice. Spring MVC, questo è già migliore, conosciamo il pattern MVC da molto tempo, è stato utilizzato nella metà dei compiti di grandi dimensioni del corso. Da qui inizieremo a ballare. Per creare un'applicazione web con Spring MVC, abbiamo bisogno anche di una Servlet-API, ad es. quella cosa con l'aiuto della quale avrà luogo l'interazione richiesta-risposta. Proviamo a collegarlo. Andiamo su Google, cerchiamo le dipendenze necessarie nel repository Maven e le aggiungiamo al file pom.xml. Nella sezione Librerie esterne puoi vedere che non è stato caricato solo spring-webmvc , ma anche un sacco di altre cose. Quelli. non è necessario includere inoltre le dipendenze per spring core , context , bean , ecc. di cui abbiamo bisogno, tutto ciò di cui avevamo bisogno è stato recuperato insieme a spring-webmvc . Ancora una nota. Cosa significa provideddipendere javax.servlet-api? L'ambito è l'ambito della dipendenza, providedil che significa che la dipendenza sarà disponibile nella fase di compilazione e test dell'applicazione, ma non verrà archiviata. Il fatto è che per distribuire l'applicazione utilizzeremo un contenitore servlet, Tomcat, e contiene già tali librerie al suo interno, quindi non è necessario trasferirle lì e caricare l'archivio con carichi inutili. Guardando al futuro, per lo stesso motivo faremo a meno del solito metodo main, perché esiste già all'interno di Tomcat.

Creazione di pagine e controller

Proviamo a cucinare qualcosa di semplice ora. Per prima cosa creiamo una webappdirectory aggiuntiva, ad esempio pages, in cui verranno archiviate le nostre visualizzazioni, ad es. jsp e creare un paio di pagine. Avremo bisogno di una pagina in cui in futuro verrà visualizzato un elenco di film, ad esempio films.jsp, e forse possiamo creare una pagina separata per il montaggio, lascia che sia editPage.jsp. Per ora non li riempiremo con nulla di serio; solo per test, creeremo un collegamento da una pagina all'altra. Ora abbiamo bisogno di una classe che elaborerà le richieste, ad es. controllore. Aggiungiamo un nuovo pacchetto controllere creiamo una classe al suo interno FilmController(in generale non è necessario impacchettare tutto in pacchetti diversi, questa applicazione sarà molto piccola e semplice, ma in un progetto normale possono esserci molti controller, classi di configurazione, modelli , ecc., quindi anche partendo da piccoli progetti è meglio abituarsi subito a fare tutto in modo ordinato e strutturato in modo che non ci siano disordini). In questa classe creeremo metodi che restituiranno le nostre opinioni in risposta alle richieste.

package testgroup.filmography.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class FilmController {

    @RequestMapping(value = "/", method = RequestMethod.GET)
    public ModelAndView allFilms() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("films");
        return modelAndView;
    }

    @RequestMapping(value = "/edit", method = RequestMethod.GET)
    public ModelAndView editPage() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("editPage");
        return modelAndView;
    }
}

Qual e il punto? Spring MVC ha una cosa chiamata DispatcherServlet. È come il controller principale, tutte le richieste in entrata passano attraverso di esso e poi le trasmette a un controller specifico. L'annotazione @Controllerdice semplicemente a Spring MVC che questa classe è un controller (beh, logico in generale), il dispatcher controllerà le annotazioni @RequestMappingper chiamare il metodo appropriato. L'annotazione @RequestMappingconsente di impostare gli indirizzi per i metodi del controller, tramite i quali saranno disponibili nel client (browser). Può anche essere applicato alla classe controller per impostare, per così dire, l'indirizzo root per tutti i metodi. allFilms()Il parametro del metodo valueè impostato su " /", quindi verrà chiamato immediatamente quando nel browser viene inserita la combinazione http://host:porta/ (ovvero, per impostazione predefinita è http://localhost:8080/ o http ://127.0.0.1:8080/ ). Il parametro methodspecifica quale tipo di richiesta è supportata (GET, POST, PUT, ecc.). Poiché qui riceviamo solo dati, viene utilizzato GET. Successivamente, quando verranno visualizzati i metodi per aggiungere e modificare, ci saranno già richieste POST. (A proposito, invece di un'annotazione @RequestMappingche indica un metodo, puoi usare annotazioni @GetMapping, @PostMappingecc. @GetMappingin modo equivalente @RequestMapping(method = RequestMethod.GET)). Nei nostri metodi creiamo un oggetto ModelAndViewe impostiamo il nome della vista che deve essere restituita.

Configurazione

Passiamo all'impostazione della configurazione. configCreiamo una classe nel pacchetto WebConfig. Avrà un solo metodo che restituisce un oggetto di tipo ViewResolver, questa è l'interfaccia necessaria per trovare una rappresentazione per nome.

package testgroup.filmography.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "testgroup.filmography")
public class WebConfig {

    @Bean
    ViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/pages/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }
}

@Configurationdice a Spring che questa classe è una classe di configurazione e contiene le definizioni e le dipendenze beandei componenti. I bean sono oggetti gestiti da Spring. L'annotazione viene utilizzata per definire un bean @Bean. @EnableWebMvcconsente di importare la configurazione Spring MVC dal file WebMvcConfigurationSupport. Puoi anche implementare, ad esempio, un'interfaccia WebMvcConfigurerche abbia un sacco di metodi e personalizzare tutto a tuo piacimento, ma non è necessario approfondire questo argomento, basteranno le impostazioni standard. @ComponentScandice a Spring dove cercare i componenti che dovrebbe gestire, cioè classi contrassegnate da un'annotazione @Componento dai suoi derivati ​​come @Controller, @Repository, @Service. Queste annotazioni definiscono automaticamente il bean di classe. Nel metodo, viewResolver()creiamo la sua implementazione e determiniamo dove cercare esattamente le rappresentazioni in webapp. Pertanto, quando nel metodo del controller impostiamo il nome " films", la vista verrà trovata come " /pages/films.jsp" Quindi, abbiamo una classe di configurazione, ma per ora è solo una sorta di classe separata, non influisce in alcun modo sulla nostra applicazione . Dobbiamo registrare questa configurazione nel contesto Spring. Per questo hai bisogno di un corso AbstractAnnotationConfigDispatcherServletInitializer. Nel pacchetto configcreiamo il suo successore, ad esempio AppInitializer , e ne implementiamo i metodi.

package testgroup.filmography.config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

L'ultimo metodo registra gli indirizzi e ci sono altri 2 metodi per registrare le classi di configurazione. Le configurazioni Web, dove ViewResolversono definiti e simili, vengono inserite in getServletConfigClasses(). È meglio leggere tutto questo nella documentazione e nelle varie guide, ma nel nostro caso non è ancora necessario approfondire questo, il nostro, WebConfigin linea di principio, può essere RootClassesdefinito in entrambi, puoi anche definirli entrambi contemporaneamente, funzionerà comunque . Un'altra cosa. Potrebbero esserci problemi con la codifica quando, quando si inviano valori con caratteri russi dal modulo, il risultato saranno scarabocchi. Per risolvere questo problema, aggiungeremo un filtro che pre-elaborerà le richieste. Andiamo alla classe AppInitializer e sovrascriviamo il metodo getServletFilters, in cui indichiamo la codifica desiderata, ovviamente dovrebbe essere la stessa di ovunque, come nelle pagine e nel database:

protected Filter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceEncoding(true);
        return new Filter[] {characterEncodingFilter};
    }

Bene, sembra che tutto sia impostato, puoi provare a eseguirlo e vedere cosa succede. Esegui -> Esegui -> Modifica configurazioni -> Aggiungi nuova configurazione -> Tomcat Server -> Locale Successivamente, è necessario selezionare un artefatto da distribuire. L'idea stessa fornirà un suggerimento. Avvertenza: nessun artefatto contrassegnato per la distribuzione . Fare clic sul pulsante Correggi e selezionare ...: la guerra è esplosa . Oppure puoi andare su Distribuzione -> aggiungi -> Artefatto -> ...: la guerra è esplosa . E devi anche andare su Distribuzione e impostare il campo Contesto Applecation (questo farà parte dell'indirizzo URL in cui l'applicazione sarà disponibile nel browser) su " /". Allora la nostra applicazione sarà immediatamente disponibile su http://localhost:8080/ (ma puoi anche specificare qualcosa lì, ad esempio " /filmography", e poi basterà aggiungerlo a tutti gli indirizzi, cioè ad esempio non ci sarà " http://localhost:8080/edit" , ma sarà "http://localhost:8080/filmography/edit" ). Fare clic su Esegui e attendere l'avvio. Ecco cosa ho ottenuto: sembra che tutto vada bene, ma c'è un avvertimento. Il fatto è che le nostre pagine sono ormai accessibili pubblicamente e vi si può accedere direttamente scrivendo il percorso nella barra degli indirizzi. Entriamo in http://localhost:8080/pages/films.jsp e ora abbiamo ricevuto la nostra pagina all'insaputa del responsabile del trattamento. In qualche modo questo non è molto corretto, quindi creeremo una webappdirectory speciale WEB-INF. Ciò che c'è dentro sarà nascosto al pubblico e sarà possibile accedervi solo tramite un controller. Inseriamo la directory con le nostre visualizzazioni ( pages) in WEB-INFe ViewResolverdi conseguenza la aggiungiamo al prefisso:

viewResolver.setPrefix("/WEB-INF/pages/");

Ora otteniamo la nostra pagina su http://localhost:8080 , ma se proviamo direttamente su http://localhost:8080/WEB-INF/pages/films.jsp otteniamo un errore 404. Bene, fantastico, abbiamo il l'applicazione web più semplice, Hello World come si suol dire. La struttura del progetto attualmente è la seguente:

Modello

Abbiamo già delle visualizzazioni e un controller, ma in MVC c'è anche una terza lettera, quindi per completare il quadro aggiungeremo anche un modello. Nel pacchetto modelcreiamo Film, ad esempio, una classe con i seguenti campi: int id, String title(titolo), int year(anno di uscita), String genre(genere) e boolean watched(cioè hai già visto questo film oppure no).

package testgroup.filmography.model;

public class Film {
    private int id;
    private String title;
    private int year;
    private String genre;
    private boolean watched;
// + Getters and setters
}

Niente di speciale, solo una classe ordinaria, campi privati, getter e setter. Gli oggetti di tali classi sono anche chiamati POJO(Plain Old Java Object), beh, ad es. "semplice oggetto Java". Proviamo ora a creare un oggetto di questo tipo e a visualizzarlo sulla pagina. Per ora, non ci preoccuperemo troppo di come crearlo e inizializzarlo. Per provarlo, creiamolo stupidamente direttamente nel controller, ad esempio, in questo modo:

public class FilmController {
    private static Film film;

    static {
        film = new Film();
        film.setTitle("Inception");
        film.setYear(2010);
        film.setGenre("sci-fi");
        film.setWatched(true);
    }

E aggiungi questo oggetto al nostro ModelAndViewusando il metodo addObject:

@RequestMapping(method = RequestMethod.GET)
    public ModelAndView allFilms() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("films");
        modelAndView.addObject("film", film);
        return modelAndView;
    }

Ora possiamo visualizzare questo oggetto sulla nostra pagina. Al films.jspposto di Hello World scriveremo e qui verrà sostituito ${film}l'oggetto corrispondente al nome dell'attributo " ". filmProviamo a eseguirlo e vediamo cosa è successo (per un output chiaro dell'oggetto, la classe Filmè stata ridefinita toString()):

Modello-View-Controller

In questa fase, sembra che disponiamo già di un'applicazione Spring MVC a tutti gli effetti. Prima di proseguire, sarebbe bene dare un’altra occhiata a tutto e capire come funziona. Su Internet puoi trovare molte immagini e diagrammi a riguardo, mi piace questo: Quando scriviamo una richiesta nella riga del browser, viene accettata Dispatcher Servlet, quindi trova un controller adatto per elaborare questa richiesta utilizzando HandlerMapping(questa è un'interfaccia per selezionare un controller, controlla quale dei controller disponibili ha un metodo che accetta tale indirizzo) , chiama un metodo adatto e Controllerrestituisce informazioni sulla vista, quindi il dispatcher trova la vista desiderata per nome utilizzando ViewResolver'a, dopodiché i dati del modello vengono trasferiti a questa vista e otteniamo la nostra pagina come output. Qualcosa come questo. Continua... Presentazione di Maven, Spring, MySQL, Hibernate e la prima applicazione CRUD (parte 1) Presentazione di Maven, Spring, MySQL, Hibernate e la prima applicazione CRUD (parte 2) Presentazione di Maven, Spring, MySQL, Hibernate e la prima applicazione CRUD (parte 3) Introduzione a Maven, Spring, MySQL, Hibernate e alla prima applicazione CRUD (parte 4)