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

Les chaînes de caractères StringBuilder / StringBuffer

Accès rapide :
La vidéo
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

La vidéo

Cette vidéo vous montre comment utiliser des chaînes de caractères de type "Text Block". Il s'agit de chaînes de caractères multi-lignes.

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 class Sample {
    
    public static void main( String[] args ) {
        
        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
                
    }
    
}

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

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 class Sample {
    
    public static void main( String[] args ) {
        
        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
                
    }
    
}

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.

• On débute un text block par la séquence """ et on le termine par la même séquence. Il est important de noter qu'un retour à la ligne est imposé après la séquence de caractères d'ouverture du text block.

  On utilise trois doubles quotes pour introduire et terminer un text block.

  1 2 3 4 5

  String textBlock = """ First line Second line """; System.out.print( textBlock );

  Ce qui affiche sur la console le message suivant :

  First line
  Second line

• Il est possible d'indenter le contenu d'un text block, mais il faut respecter deux règles. Premièrement, les indentations de chaque ligne du text block doivent être constituées des mêmes caractères (le langage Java fait la distinction entre espaces et tabulations) : si les retraits ne sont pas constitués des mêmes séquences, ils seront tout ou en parti considéré comme faisant partie du text block. Ensuite, si les indentations sont de tailles différentes d'une ligne à une autre, c'est la ligne commençant le plus tôt qui sera considérée pour déterminer la colonne à partir de laquelle doit commencer le text block.

  Il est possible d'indenter le contenu d'un text block.

  1 2 3 4 5 6

  String textBlock = """ First line Second line Third line """; System.out.print( textBlock );

  Ce qui affiche sur la console le message suivant :

      First line
  Second line
    Third line

• Tous les retours à la ligne présents dans le « Text Block » seront conservés dans la chaîne finale, y compris celui juste avant la fermeture du text block, s'il est présent.

  Les retours à la ligne sont conservés dans un text block.

  1 2 3 4 5 6

  String textBlock = """ First line Third line (the second is empty) """; System.out.print( textBlock + "END" );

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.

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();
}

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
}

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"
            }
        }
        """;

Les chaînes de caractères StringBuilder / StringBuffer