TOC

Spring Boot avec SQLite

Spring Boot avec SQLite

1. Vue d'ensemble

Dans ce rapide tutoriel, nous allons passer par les étapes pour utiliser une base de donnéesSQLite dans une application Spring Boot compatible JPA.

Spring Bootsupports a few well known in-memory databasesest prêt à l'emploi, mais SQLite exige un peu plus de notre part.

Jetons un coup d'œil à ce qu'il faut.

2. Configuration du projet

Pour notre illustration,we’ll start with a Spring Data Rest app we’ve used in past tutorials.

Dans le pom, nous devons ajouter la dépendancesqllite-jdbc: 


    org.xerial
    sqlite-jdbc
    3.25.2

Cette dépendance nous donne ce dont nous avons besoin pour utiliserJDBC pour communiquer avec SQLite. Mais,if we are going to use an ORM, it’s not enough.

3. SQLite Dialect

Voir,Hibernate doesn’t ship with a Dialect for SQLite. Nous devons en créer un nous-mêmes.

3.1. Extension deDialect

Notre première étape consiste à étendre la classeorg.hibernate.dialect.Dialect pour enregistrer lesdata types fournis par SQLite: 

public class SQLiteDialect extends Dialect {

    public SQLiteDialect() {
        registerColumnType(Types.BIT, "integer");
        registerColumnType(Types.TINYINT, "tinyint");
        registerColumnType(Types.SMALLINT, "smallint");
        registerColumnType(Types.INTEGER, "integer");
        // other data types
    }
}

Il y en a plusieurs, alors jetez un coup d'œil à l'exemple de code.

Ensuite, nous devrons remplacer certains comportements par défaut deDialect.

3.2. Support de colonne d'identité

Par exemple,we need to tell Hibernate how SQLite handles @Id columns, ce que nous pouvons faire avec une implémentation personnalisée deIdentityColumnSupport: 

public class SQLiteIdentityColumnSupport extends IdentityColumnSupportImpl {

    @Override
    public boolean supportsIdentityColumns() {
        return true;
    }

    @Override
    public String getIdentitySelectString(String table, String column, int type)
      throws MappingException {
        return "select last_insert_rowid()";
    }

    @Override
    public String getIdentityColumnString(int type) throws MappingException {
        return "integer";
    }
}

Pour garder les choses simples ici, gardons le type de colonne d'identité àInteger uniquement. Et pour obtenir la prochaine valeur d'identité disponible, nous spécifierons le mécanisme approprié.

Ensuite, nous remplaçons simplement la méthode correspondante dans notre classeSQLiteDialect croissante: 

@Override
public IdentityColumnSupport getIdentityColumnSupport() {
    return new SQLiteIdentityColumnSupport();
}

3.3. Désactiver la gestion des contraintes

Et,SQLite doesn’t have support for the database constraints, so we’ll need to disable those en remplaçant à nouveau les méthodes appropriées pour les clés primaires et étrangères: 

@Override
public boolean hasAlterTable() {
    return false;
}

@Override
public boolean dropConstraints() {
    return false;
}

@Override
public String getDropForeignKeyString() {
    return "";
}

@Override
public String getAddForeignKeyConstraintString(String cn,
  String[] fk, String t, String[] pk, boolean rpk) {
    return "";
}

@Override
public String getAddPrimaryKeyConstraintString(String constraintName) {
    return "";
}

Et, dans un instant, nous pourrons référencer ce nouveau dialecte dans notre configuration Spring Boot.

4. Configuration deDataSource

De plus, depuisSpring Boot doesn’t provide configuration support for SQLite database out of the box, nous devons également exposer notre propre beanDataSource: 

@Autowired Environment env;

@Bean
public DataSource dataSource() {
    final DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName(env.getProperty("driverClassName"));
    dataSource.setUrl(env.getProperty("url"));
    dataSource.setUsername(env.getProperty("user"));
    dataSource.setPassword(env.getProperty("password"));
    return dataSource;
}

Et enfin, nous allons configurer les propriétés suivantes dans notre fichierpersistence.properties: 

driverClassName=org.sqlite.JDBC
url=jdbc:sqlite:memory:myDb?cache=shared
username=sa
password=sa
hibernate.dialect=com.example.dialect.SQLiteDialect
hibernate.hbm2ddl.auto=create-drop
hibernate.show_sql=true

Notez que nous devons conserver le cache en tant queshared afin de garder les mises à jour de la base de données visibles sur plusieurs connexions de base de données.

So, with the above configurations, the app will start and will launch an in-memory database called myDb, que la configuration deSpring Data Rest restante peut prendre.

5. Conclusion

Dans cet article, nous avons pris un exemple d'application Spring Data Rest et l'avons pointé vers une base de données SQLite. Cependant, pour ce faire, nous avons dû créer un dialecte Hibernate personnalisé.

Assurez-vous de vérifier l'applicationover on Github. Exécutez simplement avecmvn -Dspring.profiles.active=sqlite spring-boot:run and et naviguez vershttp://localhost:8080.

Related