La costruzione del progetto con Maven e la definizione del DB

Vai all'indice

I primi articoli riguardano la costruzione di un'applicazione utilizzando il progetto Maven, la creazione del database di esempio, la gestione e la persistenza dei dati utilizzando Hibernate.
Riporto di seguito la tecnologia utilizzata per il mio progetto:

• JDK 1.6 (o succcessiva), scaricabile nell'area download del sito Oracle.com.
• Apache Derby, un leggero DB relazionale che ha il vantaggio di essere già contenuto nella JDK con il nome di JavaDB.
• IDE Eclipse Kepler contenente già il plugin per la creazione di progetti Maven.
• Hibernate, framework che gestisce la persistenza dei dati sul database e che implementa JPA (Java Persistence Api) ovvero la specifica Java per l’accesso, la persistenza e la gestione dei dati tra oggetti Java e database relazionali.
• Maven è un progetto open source, sviluppato dalla Apache, che permette di organizzare in modo molto efficiente una applicazione java.

Come prima cosa ho installato Apache Derby sul mio pc, seguendo il tutorial: Installazione javadb su windows7 .

Il database gestisce e mantiene i dati degli utenti e delle applicazioni a cui essi sono abilitati ad accedere. La struttura è la seguente:

Gli script di seguito creano le tabelle del DB:

CREATE TABLE utente (userid INT not null PRIMARY KEY GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1), nome VARCHAR(50), cognome VARCHAR(50), ruolo VARCHAR(50), iduf INT, ufficioid INT, CONSTRAINT FKUFF FOREIGN KEY (ufficioid) REFERENCES ufficio (ufficioid));

CREATE TABLE dettaglioutente (userid INT not null PRIMARY KEY, datanascita date, via VARCHAR(50), citta VARCHAR(50), telefono VARCHAR(50), CONSTRAINT FKUSR FOREIGN KEY (userid) REFERENCES utente (userid));

CREATE TABLE ufficio (ufficioid INT not null PRIMARY KEY GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1), nomeufficio VARCHAR(50));

CREATE TABLE applicazione (appid INT not null PRIMARY KEY GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1), nomeapp VARCHAR(50), desrizioneapp VARCHAR(250));

CREATE TABLE utente_applicazione (userid int NOT NULL, appid int NOT NULL,  PRIMARY KEY (userid, appid), CONSTRAINT FK_UFF FOREIGN KEY (userid) REFERENCES utente (userid),  CONSTRAINT FK_APP FOREIGN KEY (appid) REFERENCES applicazione (appid));

Per creare un progetto Maven è necessario assicurarsi di avere installato il plugin m2e su Eclipse. Quindi selezionare: File -> New -> Maven Project e seguire lo wizard impostando  maven-archetypes-quickstart e successivamente groupId e artifactId come in figura:

A questo punto il progetto è stato creato. Il passo successivo consiste nel modificare il file di configurazione Pom.xml. Il POM guida l’esecuzione in Maven definendo l’identità e la struttura di un progetto in ogni suo aspetto. Tutto è descritto nel POM: informazioni del progetto, dipendenze, repository, processo di compilazione e fasi secondarie. Riporto di seguito la definizione del Pom del mio progetto:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>it.sample</groupId>
  <artifactId>test</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>test</name>
  <url>http://maven.apache.org</url>
  <repositories>
    <repository>
      <id>JBoss repository</id>
      <url>http://repository.jboss.com/maven2/</url>
    </repository>
<repository>
      <id>java.net</id>
      <url>http://download.java.net/maven/2/</url>
</repository>
  </repositories>
  <dependencies>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>4.0.1.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>ejb3-persistence</artifactId>
      <version>1.0.1.GA</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-annotations</artifactId>
      <version>3.4.0.GA</version>
    </dependency>
    <dependency>
 <groupId>org.hibernate</groupId>
 <artifactId>hibernate-commons-annotations</artifactId>
 <version>3.2.0.Final</version>
</dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.5.2</version>
    </dependency>
    <dependency>
 <groupId>org.apache.derby</groupId>
 <artifactId>derbyclient</artifactId>
 <version>10.10.1.1</version>
</dependency>
  </dependencies>
</project>

Una volta caricato il POM cliccare col tasto destro sul progetto e selezionare "Run as" -> "Maven clean" e successivamente "Maven install". Il comando "Maven clean" aggiorna il progetto, mentre con "Maven install" si lanciano tutta una serie di fasi del processo di build tra cui compilazione, esecuzione di unit test, creazione del Jar e deploy degli artefatti nel repository locale.

Maven di default si collegherà ai repository remoti indicati nel pom e scaricherà tutti i pacchetti descritti nelle dipendenze, senza la necessità di caricare nessun jar nel progetto.
Per ulteriori informazioni su Maven per Eclipse consultare:
http://www.cosenonjaviste.it/organizziamoci-con-maven-parte-ii/

Hai apprezzato questo post? Conferma le mie competenze o scrivi una segnalazione sul mio profilo Linkedin!