Cette fois, je voudrais expliquer l'utilisation de base de Sql2o, qui est une bibliothèque pour l'accès aux bases de données Java.
Je connaissais Sql2o en premier lieu parce que j'ai utilisé Sql2o pour l'accès à la base de données dans les directives de Spark Framework.
Si Spark Framework, qui est un cadre pour des micro-services simples, est utilisé, Sql2o est également simple, alors j'ai essayé de l'utiliser.
Pour plus d'informations sur Spark Framework, veuillez consulter [Easy Micro Service with Spark Framework!".
Une bibliothèque Java très simple pour l'accès à la base de données, décrite sur le site officiel (https://www.sql2o.org/) comme suit:
Sql2o is a small Java library, that makes it easy to execute sql statements against your JDBC compliant database.
Il y a Rating: star: 642 sur github. (Au 1er avril 2018)
Comme indiqué sur cette page, il affirme que les performances de «SELECT» sont très élevées.
Contient des résultats de comparaison avec d'autres bibliothèques d'accès aux bases de données majeures (ʻApache DbUtils, MyBatis, Spring JdbcTemplate`, etc.). Si vous êtes intéressé, jetez un œil.
La bibliothèque sql2o peut être obtenue à partir du référentiel maven. Ajoutez le pilote jdbc du SGBDR à utiliser ensemble dans la dépendance. Dans l'exemple, nous utiliserons PostgreSQL.
pom.xml
<dependency>
<groupId>org.sql2o</groupId>
<artifactId>sql2o</artifactId>
<version>1.5.4</version>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>9.4-1201-jdbc41</version>
</dependency>
Créez une table à utiliser dans l'exemple.
create_table.ddl
CREATE TABLE todo
(
todo_id character(36) NOT NULL,
todo_title character(100),
created_at timestamp without time zone NOT NULL,
finished character(1) NOT NULL,
CONSTRAINT todo_pk PRIMARY KEY (todo_id)
)
Définit une classe qui contient les données de la table. Il n'y a rien de spécial et il est implémenté en tant que POJO.
Il est facile de générer automatiquement le constructeur et la méthode toString () avec la fonction Eclipse.
Todo.java
package com.example.spark.demo;
import java.io.Serializable;
import java.util.Date;
public class Todo implements Serializable {
private static final long serialVersionUID = 1L;
private String todoId;
private String todoTitle;
private Date createdAt;
private boolean finished;
public Todo() {
}
public Todo(String todoId, String todoTitle, Date createdAt,
boolean finished) {
super();
this.todoId = todoId;
this.todoTitle = todoTitle;
this.createdAt = createdAt;
this.finished = finished;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Todo [todoId=");
builder.append(todoId);
builder.append(", todoTitle=");
builder.append(todoTitle);
builder.append(", createdAt=");
builder.append(createdAt);
builder.append(", finished=");
builder.append(finished);
builder.append("]");
return builder.toString();
}
// setter, getter omitted
}
Tout d'abord, prenons l'exemple le plus simple "obtenir un seul enregistrement", et ici je voudrais expliquer principalement le flux lors de l'utilisation de Sql2o.
Sql2oDemo.java
package com.example.spark.demo;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.sql2o.Connection;
import org.sql2o.Query;
import org.sql2o.Sql2o;
public class Sql2oDemo2 {
public static void main(String[] args) {
//★ Point 1
// 1. create sql2o instance
Sql2o sql2o = new Sql2o("jdbc:postgresql://127.0.0.1:5432/demodb", // url
"username", // user
"password"); // pass
//★ Point 2
// 2. set default column mappings (optional)
Map<String, String> colMaps = new HashMap<String, String>();
colMaps.put("TODO_ID", "todoId");
colMaps.put("TODO_TITLE", "todoTitle");
colMaps.put("CREATED_AT", "createdAt");
sql2o.setDefaultColumnMappings(colMaps);
//★ Point 3
// 3. get connection
try (Connection connection = sql2o.open()) {
//★ Point 4
// 4. create query
String queryText = "SELECT todo_id, todo_title, created_at, finished FROM todo"
+ " WHERE created_at = (SELECT max(created_at) FROM todo)";
Query query = connection.createQuery(queryText);
//★ Point 5
// 5. execute query
Todo todo = query.executeAndFetchFirst(Todo.class);
System.out.println(todo);
}
}
}
** ★ Point 1 **
Créez un objet de Sql2o avec l'opérateur new.
Les arguments du constructeur sont les suivants.
Désormais, l'objet Sql2o généré ici sera utilisé.
**(Mise en garde)
Certains constructeurs prennent DataSource comme argument. Il est recommandé de l'utiliser lors de l'utilisation de Sql2o dans une application Web. ** **
** ★ Point 2 **
Si le nom de la colonne de la table à laquelle vous accédez et le nom du champ de la classe correspondent, Sql2o fera le mappage automatiquement (si le type de données est convertible).
Si les noms sont différents, vous devez faire correspondre les noms dans la clause SQL ʻAS, mais vous pouvez utiliser setDefaultColumnMappings` pour préconfigurer cette règle de traduction de nom.
** ★ Point 3 **
★ Utilisez la méthode ʻopen () de l'objet Sql2ocréé au point 1 pour obtenir une connexion. Comme recommandé dans les directives, établissons une connexion avectry-with-resourcespour le fermer automatiquement. Il s'agit du flux de traitement de routine lors de l'utilisation deSql2o`.
** ★ Point 4 **
Créez un objet de ʻorg.sql2o.Queryqui définit le SQL à exécuter. La méthode de définition est la même pour le système de référence et le système de mise à jour, et le SQL à émettre est défini comme «String». ★ Utilisez la méthodecreateQuery ()de la connexion obtenue au point 3 pour créer un objetQuery`.
Pour définir les paramètres dans SQL, reportez-vous à "[3.4. Définir les paramètres](# 34-Définir les paramètres)".
** ★ Point 5 **
SQL est exécuté en appelant la méthode de l'objet Query généré dans ★ Point 4.
La méthode à utiliser diffère selon le SQL à émettre. Les principales méthodes sont décrites ci-dessous.
Pour obtenir un seul enregistrement, utilisez la méthode ʻexecuteAndFetchFirst. Dans l'argument, spécifiez le type de données (classe) de la valeur de retour. ★ Si le mappage est effectué correctement au point 2, vous pouvez facilement obtenir l'enregistrement acquis en tant qu'objet. Notez que, comme le suggère le nom ʻexecuteAndFetchFirst, même si le résultat de l'exécution SQL est plusieurs enregistrements, aucune erreur ne se produira et le premier enregistrement sera retourné.
// 4. create query
String queryText = "SELECT todo_id, todo_title, created_at, finished FROM todo"
+ " WHERE created_at = (SELECT max(created_at) FROM todo)";
Query query = connection.createQuery(queryText);
// 5. execute query
Todo todo = query.executeAndFetchFirst(Todo.class);
System.out.println(todo);
Pour obtenir plusieurs enregistrements, utilisez la méthode createQuery.
Dans l'argument, spécifiez le type de données (classe) de la valeur de retour.
La valeur de retour sera «java.util.List» du type de données (classe) spécifié par l'argument.
Si le résultat de la recherche est 0, ce sera «Liste» avec 0 élément.
// 4. create query
String queryText2 = "SELECT todo_id, todo_title, created_at, finished FROM todo";
Query query2 = connection.createQuery(queryText2);
// 5. execute query
List<Todo> todoList = query2.executeAndFetch(Todo.class);
System.out.println(todoList);
L'injection SQL peut se produire avec la méthode d'incorporation de paramètres lors de la construction d'une chaîne SQL.
Sql2o fournit une méthode ʻaddParameter dans Querycomme moyen de définir les paramètres. La méthode est simple, écrivez simplement: nom du paramètre à l'endroit où vous voulez utiliser le paramètre SQL, et définissez la valeur que vous souhaitez incorporer en tant que paramètre avec ʻaddParameter.
// 4. create query
String queryText3 = "SELECT todo_id, todo_title, created_at, finished FROM todo WHERE todo_id=:todoId";
Query query3 = connection.createQuery(queryText3)
.addParameter("todoId", "e8a57ac5-0e79-4444-be8a-3a281a5c0943");
// 5. execute query
Todo todo2 = query3.executeAndFetchFirst(Todo.class);
System.out.println(todo2);
Utilisez la méthode ʻexecuteUpdatepour exécuter la mise à jour SQL. Cette méthode renvoie une connexionSql2ocomme valeur de retour. Je pense que le nombre d'enregistrements modifiés peut être requis pour la mise à jour SQL. Dans ce cas, vous pouvez obtenir le numéro avec la méthodegetResult` de la connexion.
// 4. create query
String updateQueryText = "INSERT INTO todo(todo_id, todo_title, created_at, finished)"
+ " VALUES (:todoId, :todoTitle, :createAt, :finished)";
Query query4 = connection.createQuery(updateQueryText)
.addParameter("todoId", UUID.randomUUID().toString())
.addParameter("todoTitle", "world!")
.addParameter("createAt", new Date())
.addParameter("finished", "0");
// 5. execute query
int effectiveCount = query4.executeUpdate().getResult();
System.out.println(effectiveCount);
Je n'ai pas encore parlé de transactions, mais c'est un point dont il faut tenir compte dans le développement d'un système réel.
Sql2o ne fournit pas de fonctionnalité de transaction déclarative.
Il existe une méthode qui contrôle explicitement la transaction, et l'implémenteur l'utilise pour contrôler la transaction.
beginTransaction de Sql2o (obtenir la connexion qui a démarré la transaction)commit// management transaction
try (Connection connection = sql2o.beginTransaction()) {
// first sql
String updateQuery = "UPDATE todo SET todo_title=:todoTitle WHERE todo_id = :todoId";
Query query1 = connection.createQuery(updateQuery)
.addParameter("todoTitle", "googbye.")
.addParameter("todoId",
"e7801fe3-6e67-41ee-abb9-4f01841a3bf0");
int updateCount = query1.executeUpdate().getResult();
System.out.println(updateCount);
// If you want to try it, let's raise an exception here.
// sql2o.open() : first sql is effective(committed)
// sql2o.beginTransaction() : first sql is ineffective(uncommitted)
// second sql
String deleteQuery = "DELETE FROM todo WHERE todo_title = :todoTitle";
Query query2 = connection.createQuery(deleteQuery)
.addParameter("todoTitle", "world!");
int deleteCount = query2.executeUpdate().getResult();
System.out.println(deleteCount);
// commit transaction
connection.commit();
}
**(Mise en garde)
Si vous démarrez une transaction avec la méthode beginTransaction dans try-with-resources, la restauration sera exécutée automatiquement si ni la validation ni la restauration ne sont effectuées. ** **
Ceci est également mentionné dans les directives [https://github.com/aaberg/sql2o/wiki/Transactions).
Cette fois, j'ai expliqué l'utilisation de base de Sql2o, qui est une bibliothèque pour l'accès aux bases de données Java. Je pense que c'était une fonction et une utilisation très simples. Il manque un peu de traitement d'accès aux bases de données complexe pour l'entreprise, mais n'est-il pas juste parfait pour créer un microservice simple?
Recommended Posts