1.
Page 1 sur 16 Zaghir.Y
Table des matières
Objectif utilisation de SQLite avec Hibernate....................................................................................... 2
Structure de projet : ............................................................................................................................... 4
................................................................................................................................................................. 4
Fichier Pom.xml pour la configuration de projet (package , déploiement ,test): ................................ 5
Fichier import.sql ......................................................................................................................... 8
Fichier SQLiteDialect.java....................................................................................................................... 8
Fichier Test2.java ....................................................................................................................... 13
Pour démarrer le test................................................................................................................. 14
............................................................................................................................................................... 14
............................................................................................................................................................... 15
Utilisation de la Sqlite Manager......................................................................................... 15
Pour la création ou consulté les données de la base de donnée de type
SQLite , utilisez un plugin de fireFox............................................................................ 15
............................................................................................................................................................... 15
............................................................................................................................................................... 15
............................................................................................................................................................... 16

2.
Page 2 sur 16 Zaghir.Y
Objectif utilisation de SQLite avec Hibernate
Fait le : 12-04-2016
Outils : Eclipse version mars2,
Maven v3 pour la gestion de projet
SQLite Manager - Firefox addon pour la création de fichier de base de donnée
Hibernate-core v5.1.0.Final
Hibernate-entitymanager v5.1.0.Final
Jta v1.1
Hibernate-jpa-2.0-api
Sqlite-jdbc v3.8.11.2
Junit v4.12
log4j v1.2.14

3.
Page 3 sur 16 Zaghir.Y

4.
Page 4 sur 16 Zaghir.Y
Structure de projet :

5.
Page 5 sur 16 Zaghir.Y
Fichier Pom.xml pour la configuration de projet (package , déploiement ,test):
<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>com.zaghir</groupId>
<artifactId>SQLite-Hibernate</artifactId>
<version>1</version>
<properties>
<hibernate.version>5.1.0.Final</hibernate.version>
<hibernateJpa.version>1.0.1.Final</hibernateJpa.version>
<sqlite.version>3.8.11.2</sqlite.version>
<junit.version>4.12</junit.version>
<jta.version>1.1</jta.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!-- hibernate -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>${jta.version}</version>
</dependency>
<!-- Hibernate & JPA -->
<dependency>
<groupId>org.hibernate.javax.persistence</groupId>
<artifactId>hibernate-jpa-2.0-api</artifactId>
<version>${hibernateJpa.version}</version>
</dependency>
<!-- SQLite JDBC library -->
<dependency>
<groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId>
<version>${sqlite.version}</version>
</dependency>
<!-- junit test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>

6.
Page 6 sur 16 Zaghir.Y
<artifactId>slf4j-log4j12</artifactId>
<version>1.5.2</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.14</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
<!-- <resources> -->
<!-- <resource> -->
<!-- <directory>src/main/resources</directory> -->
<!-- <filtering>true</filtering> -->
<!-- </resource> -->
<!-- </resources> -->
</build>
<!-- <repositories> -->
<!-- <repository> -->
<!-- <id>hibernatesqlite-maven</id> -->
<!-- <url>https://hibernate-sqlite.googlecode.com/svn/trunk/mavenrepo</url>
-->
<!-- </repository> -->
<!-- </repositories> -->
</project>
Fichier log4j.properties :
Pour la configuration de Log4J -> logger les messages d’erreur ou information …
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=all, stdout
#log4j.logger.org.hibernate=all
#log4j.logger.org.hibernate.type=all
#log4j.logger.org.hibernate.tool.hbm2ddl=debug

7.
Page 7 sur 16 Zaghir.Y
Fichier persistence.xml
C’est le fichier de configuration de JPA-Hibernate il faut qu’il soit dans le dossier
ressources/META-INF
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
version="2.0">
<!-- persistence-unit name c'est la reference utilisé dans nos
EntityMangerfactory(Class Java) -->
<persistence-unit name="pu-sqlite-jpa">
<properties>
<!-- Hobernate scan et mappe toutes les classes configuer avec
les annotation @Entity -->
<property name="hibernate.archive.autodetection" value="class" />
<!-- utilisez le dialect SQLiteDialect pour communiquer avec les
tables -->
<!-- SQLite c'est un peu special la classe qui defini le dialect
se trouve dans -->
<!-- org.hibernate.dialect.SQLliteDialete.java par contre les
autre dialect se trouve -->
<!-- dans le jar de hibernate !!! -->
<property name="hibernate.dialect"
value="org.hibernate.dialect.SQLiteDialect"/>
<!-- Data Definition Language pour Sql -->
<!-- value="create" creer les table qui sont defini dans les Classe
package entity -->
<!-- value="update" appliquez les changements sur les tables quand les
classe change -->
<!-- value="none" en passe au mode production -->
<property name="hibernate.hbm2ddl.auto" value="create"/>
<!-- dire à hibernate au moment de l'execution de l'application
afficher les requette sql -->
<property name="hibernate.show_sql" value="true"/>
<property name="hibernate.format_sql" value="false"/>
<!-- driver pour communiquer avec SQLite -->
<property name="javax.persistence.jdbc.driver"
value="org.sqlite.JDBC"/>
<!-- mydb.sqlite notre base de donnée -->
<property name="javax.persistence.jdbc.url"
value="jdbc:sqlite:mydb.sqlite"/>
</properties>
</persistence-unit>
</persistence>

8.
Page 8 sur 16 Zaghir.Y
Fichier import.sql
A chaque démarrage de l’application Hibernate vérifie la présence de ce fichier si le fichier
import.sql comporte des requêtes, il va les exécutées, comme le cas ici c’est pour faire
peupler les tables, c’est pratique
insert into Contact (id_contact,name, email) values (9, 'PAPA OUSMAN',
'sosos@gmail.com');
insert into Person (id_person,name, age) values (10, 'person1',
'sosos@gmail.com');
Fichier SQLiteDialect.java
C’est possible le créer n’importe où mais il faut indiquer son chemin dans le persistance.xml
/*
* The author disclaims copyright to this source code. In place of
* a legal notice, here is a blessing:
*
* May you do good and not evil.
* May you find forgiveness for yourself and forgive others.
* May you share freely, never taking more than you give.
*
*/
package org.hibernate.dialect;
import java.sql.Types;
import org.hibernate.dialect.function.AbstractAnsiTrimEmulationFunction;
import org.hibernate.dialect.function.NoArgSQLFunction;
import org.hibernate.dialect.function.SQLFunction;
import org.hibernate.dialect.function.SQLFunctionTemplate;
import org.hibernate.dialect.function.StandardSQLFunction;
import org.hibernate.dialect.function.VarArgsSQLFunction;
import org.hibernate.type.StandardBasicTypes;
public class SQLiteDialect extends Dialect {
public SQLiteDialect() {
registerColumnType(Types.BIT, "boolean");
registerColumnType(Types.TINYINT, "tinyint");
registerColumnType(Types.SMALLINT, "smallint");
registerColumnType(Types.INTEGER, "integer");
registerColumnType(Types.BIGINT, "bigint");
registerColumnType(Types.FLOAT, "float");
registerColumnType(Types.REAL, "real");
registerColumnType(Types.DOUBLE, "double");
registerColumnType(Types.NUMERIC, "numeric($p, $s)");
registerColumnType(Types.DECIMAL, "decimal");
registerColumnType(Types.CHAR, "char");
registerColumnType(Types.VARCHAR, "varchar($l)");
registerColumnType(Types.LONGVARCHAR, "longvarchar");
registerColumnType(Types.DATE, "date");
registerColumnType(Types.TIME, "time");
registerColumnType(Types.TIMESTAMP, "datetime");
registerColumnType(Types.BINARY, "blob");

9.
Page 9 sur 16 Zaghir.Y
registerColumnType(Types.VARBINARY, "blob");
registerColumnType(Types.LONGVARBINARY, "blob");
registerColumnType(Types.BLOB, "blob");
registerColumnType(Types.CLOB, "clob");
registerColumnType(Types.BOOLEAN, "boolean");
//registerFunction( "abs", new StandardSQLFunction("abs") );
registerFunction( "concat", new VarArgsSQLFunction(StandardBasicTypes.STRING,
"", "||", "") );
//registerFunction( "length", new StandardSQLFunction("length",
StandardBasicTypes.LONG) );
//registerFunction( "lower", new StandardSQLFunction("lower") );
registerFunction( "mod", new SQLFunctionTemplate(StandardBasicTypes.INTEGER,
"?1 % ?2" ) );
registerFunction( "quote", new StandardSQLFunction("quote",
StandardBasicTypes.STRING) );
registerFunction( "random", new NoArgSQLFunction("random",
StandardBasicTypes.INTEGER) );
registerFunction( "round", new StandardSQLFunction("round") );
registerFunction( "substr", new StandardSQLFunction("substr",
StandardBasicTypes.STRING) );
registerFunction( "substring", new SQLFunctionTemplate(
StandardBasicTypes.STRING, "substr(?1, ?2, ?3)" ) );
registerFunction( "trim", new AbstractAnsiTrimEmulationFunction() {
protected SQLFunction resolveBothSpaceTrimFunction() {
return new SQLFunctionTemplate(StandardBasicTypes.STRING, "trim(?1)");
}
protected SQLFunction resolveBothSpaceTrimFromFunction() {
return new SQLFunctionTemplate(StandardBasicTypes.STRING, "trim(?2)");
}
protected SQLFunction resolveLeadingSpaceTrimFunction() {
return new SQLFunctionTemplate(StandardBasicTypes.STRING, "ltrim(?1)");
}
protected SQLFunction resolveTrailingSpaceTrimFunction() {
return new SQLFunctionTemplate(StandardBasicTypes.STRING, "rtrim(?1)");
}
protected SQLFunction resolveBothTrimFunction() {
return new SQLFunctionTemplate(StandardBasicTypes.STRING, "trim(?1,
?2)");
}
protected SQLFunction resolveLeadingTrimFunction() {
return new SQLFunctionTemplate(StandardBasicTypes.STRING, "ltrim(?1,
?2)");
}
protected SQLFunction resolveTrailingTrimFunction() {
return new SQLFunctionTemplate(StandardBasicTypes.STRING, "rtrim(?1,
?2)");
}
} );
//registerFunction( "upper", new StandardSQLFunction("upper") );
}
public boolean supportsIdentityColumns() {

10.
Page 10 sur 16 Zaghir.Y
return true;
}
/*
public boolean supportsInsertSelectIdentity() {
return true; // As specify in NHibernate dialect
}
*/
public boolean hasDataTypeInIdentityColumn() {
return false; // As specify in NHibernate dialect
}
/*
public String appendIdentitySelectToInsert(String insertString) {
return new StringBuffer(insertString.length()+30). // As specify in NHibernate
dialect
append(insertString).
append("; ").append(getIdentitySelectString()).
toString();
}
*/
public String getIdentityColumnString() {
// return "integer primary key autoincrement";
return "integer";
}
public String getIdentitySelectString() {
return "select last_insert_rowid()";
}
public boolean supportsLimit() {
return true;
}
public boolean bindLimitParametersInReverseOrder() {
return true;
}
protected String getLimitString(String query, boolean hasOffset) {
return new StringBuffer(query.length()+20).
append(query).
append(hasOffset ? " limit ? offset ?" : " limit ?").
toString();
}
public boolean supportsTemporaryTables() {
return true;
}
public String getCreateTemporaryTableString() {
return "create temporary table if not exists";
}
public boolean dropTemporaryTableAfterUse() {
return true; // TODO Validate
}

11.
Page 11 sur 16 Zaghir.Y
public boolean supportsCurrentTimestampSelection() {
return true;
}
public boolean isCurrentTimestampSelectStringCallable() {
return false;
}
public String getCurrentTimestampSelectString() {
return "select current_timestamp";
}
public boolean supportsUnionAll() {
return true;
}
public boolean hasAlterTable() {
return false; // As specify in NHibernate dialect
}
public boolean dropConstraints() {
return false;
}
/*
public String getAddColumnString() {
return "add column";
}
*/
public String getForUpdateString() {
return "";
}
public boolean supportsOuterJoinForUpdate() {
return false;
}
public String getDropForeignKeyString() {
throw new UnsupportedOperationException("No drop foreign key syntax supported
by SQLiteDialect");
}
public String getAddForeignKeyConstraintString(String constraintName,
String[] foreignKey, String referencedTable, String[] primaryKey,
boolean referencesPrimaryKey) {
throw new UnsupportedOperationException("No add foreign key syntax supported
by SQLiteDialect");
}
public String getAddPrimaryKeyConstraintString(String constraintName) {
throw new UnsupportedOperationException("No add primary key syntax supported
by SQLiteDialect");
}
public boolean supportsIfExistsBeforeTableName() {
return true;
}

12.
Page 12 sur 16 Zaghir.Y
public boolean supportsCascadeDelete() {
return true;
}
/* not case insensitive for unicode characters by default (ICU extension needed)
public boolean supportsCaseInsensitiveLike() {
return true;
}
*/
public boolean supportsTupleDistinctCounts() {
return false;
}
public String getSelectGUIDString() {
return "select hex(randomblob(16))";
}
}
Classe Contact.java
package entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity(name="contact")
public class Contact {
@Id
@Column(name = "id_contact")
@GeneratedValue(strategy =GenerationType.AUTO)
private Long id;
private String name;
private String email;
public Contact() {
}
public Contact(Long id, String name, String email) {
this.id = id;
this.name = name;
this.email = email;
}
public Long getId() {
return this.id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {

13.
Page 13 sur 16 Zaghir.Y
return this.name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
Fichier Test2.java
On va utiliser Junit pour faire les tests , au lieu de créer un classe simple
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import org.junit.BeforeClass;
import org.junit.Test;
import entity.Contact;
import junit.framework.Assert;
public class Test2 {
static EntityManagerFactory emf; // emf c’est la fabrique
EntityManager em;
@BeforeClass
public static void setUp() {
emf = Persistence.createEntityManagerFactory("pu-sqlite-jpa");
//cablé avec le fichier de configuration persistence.xml ("pu-sqlite-jpa")
}
@Test
public void testPersist() {
try {
//Persist in database
EntityManager em = emf.createEntityManager();
System.out.println(" la table est cree");
EntityTransaction tx = em.getTransaction();
tx.begin();
Contact c1 = new Contact();
c1.setName("Youssef");
c1.setEmail("ppp@gmail.com");
em.persist(c1);
tx.commit();

14.
Page 14 sur 16 Zaghir.Y
tx.begin();
Contact c2 = new Contact();
c2.setName("Youssef 2");
c2.setEmail("ppp2@gmail.com");
em.persist(c2);
tx.commit();
tx.begin();
c1.setName("Youssef 4");
em.persist(c1);
tx.commit();
//Find by id
Contact contact = em.find(Contact.class, c1.getId());
Assert.assertEquals(c1.getName(), contact.getName());
em.close();
emf.close();
} catch (Throwable e) {
e.printStackTrace();
Assert.fail();
}
}
}
Pour démarrer le test

15.
Page 15 sur 16 Zaghir.Y
Utilisation de la Sqlite Manager
Pour la création ou consulté les données de la base de
donnée de type SQLite , utilisez un plugin de fireFox

16.
Page 16 sur 16 Zaghir.Y