Participer au site avec un Tip
Rechercher
 

Améliorations / Corrections

Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.

Emplacement :

Description des améliorations :

Les chaînes de caractères de type « Text Blocks » (Java SE 15)

Les chaînes de caractères StringBuilder / StringBuffer



Accès rapide :
Qu'est-ce qu'une chaîne de caractères de type « Text Blocks » ?
Générer des chaînes de caractères multi-lignes avec la syntaxe traditionnelle
La nouvelle syntaxe « Text Blocks »
Quelques situations ou cette nouvelle syntaxe pourra vous être utile
Définition d'une requête SQL
Définition d'une requête JPQL
Définition d'un contenu JSON

Qu'est-ce qu'une chaîne de caractères de type « Text Blocks » ?

Derrière ce nom de « Text Blocks » se cache, en vérité, un concept très simple : des chaînes de caractères multi-lignes. Une chaîne « Text Block » s'introduit via trois doubles guillemets et se termine par la même séquence de caractères.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
package fr.koor.sample;

public interface Sample {
    
    public static void main( String[] args ) throws Exception {
        
        String welcome = """
                My Super App - Copyright KooR.fr
                Usage: [options] SuperApp param1 param2
                    -h      display this help
                    -x      imagine a parameter
                """;
        
        System.out.print( welcome );
        
        // La suite du programme
                
    }
    
}
Exemple de définition d'un Text Block

Et voici le résultat affiché par cet exemple de code.

My Super App - Copyright KooR.fr
Usage: [options] SuperApp param1 param2
    -h      display this help
    -x      imagine a parameter
les « Text Blocks » sont décris dans la JEP (Java Enhancement Proposal) 378.
ce type de chaînes de caractères est disponible dans le langage Java depuis sa version Java SE 15. Elles sont aussi accessibles en version 13 et 14, mais à condition d'activer les « Preview Features » (option --enable-preview ). Si vous utilisez une version antérieure de Java, vous ne pourrez donc pas tester cette fonctionnalité.

Générer des chaînes de caractères multi-lignes avec la syntaxe traditionnelle

Avant l'apparition des « Text Blocks », on avait l'habitude de travailler par concaténations successives de chaînes de caractères. A titre de rappel, voici l'équivalent de l'exemple précédent, mais utilisant des concaténations de chaînes de caractères.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
package fr.koor.sample;

public interface Sample {
    
    public static void main( String[] args ) throws Exception {
        
        String welcome = "My Super App - Copyright KooR.fr\n"
                       + "Usage: [options] SuperApp param1 param2\n"
                       + "    -h      display this help\n"
                       + "    -x      imagine a parameter\n";
        
        System.out.println( welcome );
        
        // La suite du programme
                
    }
    
}
Exemple de définition d'une chaîne multilignes sans utilisation d'un Text Block
remarquez bien l'utilisation des séquences \n pour introduire les retours à la ligne dans la chaîne ainsi que les différentes concaténations.

Il me semble donc que la nouvelle syntaxe est bien plus sympathique et simple d'emploi ! En vous, qu'en pensez-vous ?

La nouvelle syntaxe « Text Blocks »

Afin de correctement utiliser cette nouvelle syntaxe, il est important de se rappeler ces différents points.

Ce qui affiche sur la console le message suivant :

First line

Third line
END

Quelques situations ou cette nouvelle syntaxe pourra vous être utile

Il existe plein de cas ou cette nouvelle syntaxe pourra être très pratique. J'ai souhaité mettre l'accent sur les scénarios suivants.

si ces sujets ne vous parlent pas encore, ce n'est pas grave et vous pouvez passer au chapitre suivant. Nous reviendrons sur ces possibilités bien plus tard dans ce tutoriel Java.

Définition d'une requête SQL

SQL (Structured Query Language) est le langage supporté par les moteurs de bases de données relationnelles qui permet la manipulation des données stockées dans une base. Avec le langage Java, on exécute un ordre SQL via l'API JDBC (Java DataBase Connectivity).

Il est fréquent qu'une requête SQL requière plusieurs lignes de code. Un text block est donc tout approprié pour définir un tel ordre SQL.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
try ( Connection connection = DriverManager.getConnection( url, login, password ) {
    String sql = """
            SELECT * From Table1 tb1
                INNER JOIN Table2 tb2 ON tb1.foreignKey = tb2.primaryKey
                INNER JOIN Table3 tb3 ON tb1.foreignKey2 = tb3.primaryKey
            WHERE tb1.primaryKey = ?
            ORDERED BY tb1.aColumn
            """;
    try ( PreparedStatement statement = connection.prepareStatement( sql ) ) {
        statement.setInt( 1, identifier );
        try ( ResultSet results = statement.executeQuery() ) {
            // Exploiter les données sélectionnées
        }
    }
} catch ( SQLException exception ) {
    System.err.println( "Cannot access to the database" );
    exception.printStackTrace();
}
Exemple de définition d'un ordre SQL via un text block
pour de plus amples informations sur l'accès aux données via l'API JDBC, vous pouvez consulter notre tutoriel sur le sujet.

Définition d'une requête JPQL

De manière très similaire, les text blocks sont pratiques pour définir les requêtes JPQL (Java Persistance Query Language). JPQL peut être vu comme une couche d'abstraction sur SQL, en permettant de lier les données sélectionnées avec des objets Java en mémoire. La plupart du temps, une requête JPQL se place dans des annotations @NamedQuery proposées par l'API Jakarta Persistence (anciennement, JPA).

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
@Entity  @Table(name="T_Commands")
@NamedQuery( name="selectCommandById", query="""
        from command c
            inner join fetch c.user
            inner join fetch c.lines cl
            inner join fetch cl.article
            inner join fetch c.payment
        where c.idCommand = ?
        """)
public class Command {

    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int idCommand;
    
    @ManyToOne @JoinColumn(name="idUser", nullable=false)
    private User user;
    
    private Date commandDate;
    
    @OneToMany(targetEntity=CommandLine.class, mappedBy="command", cascade=CascadeType.ALL)
    private Set<CommandLine> lines = new HashSet<CommandLine>();
    
    @OneToOne( mappedBy = "command" )
    private Payment payment;
    
    public Command() {}
    
    // Suite de la définition de la classe Command
}
Exemple de définition d'une requête JPQL via un text block
pour de plus amples informations sur l'accès aux données via JPQL, vous pouvez consulter notre tutoriel sur le sujet.

Définition d'un contenu JSON

JSON (JavaScript Object Notation) est un formalisme textuel permettant de structurer des données complexes. Ce formalisme est très utilisé dans le cadre d'un développement Web et bien qu'il existe des parseurs et des générateurs JSON, il est parfois nécessaire de définir un bloc JSON dans un programme Java.

Un flux JSON étant souvent conséquent, encore une fois les text blocks sont très pratiques dans cette situation.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
String json = """
        {
            "attr1": "A simple value",
            "attr2": 30.5,
            "attr3": [10, 20, 30, 40, 50],
            "attr4: {
                "part1": "data1",
                "part2": "data2"
            }
        }
        """;
Exemple de définition d'un contenu JSON
de manière très similaire, il est aussi possible de définir un contenu XML dans un text block Java.


Les chaînes de caractères StringBuilder / StringBuffer