{"id":697,"date":"2026-06-21T23:32:36","date_gmt":"2026-06-21T22:32:36","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=697"},"modified":"2026-07-07T23:33:01","modified_gmt":"2026-07-07T22:33:01","slug":"string-templates-in-java-21-typsichere-string-interpolation-und-sql-sicherheit","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=697","title":{"rendered":"String Templates in Java 21 \u2013 Typsichere String-Interpolation und SQL-Sicherheit"},"content":{"rendered":"\n

Java war lange die Sprache, in der man f\u00fcr formatierte Strings String.format()<\/code> oder umst\u00e4ndliche +<\/code>-Ketten schreiben musste. Mit Java 21 (JEP 430) kam endlich eine elegante L\u00f6sung: String Templates<\/strong>. Dieser Artikel zeigt die Syntax, erkl\u00e4rt eigene Template-Prozessoren und demonstriert, wie String Templates SQL-Injection-Angriffe zur Compile-Time verhindern.<\/p>\n\n\n\n

Wichtig vorab: String Templates sind in Java 21 (JEP 430) und 22 (JEP 459) ein Preview-Feature<\/strong>. Die f\u00fcr JDK 23 geplante Finalisierung (JEP 465) wurde zur\u00fcckgezogen (Status: Withdrawn<\/strong>). Das Feature ist daher ab JDK 23 nicht mehr verf\u00fcgbar und befindet sich im Redesign. Mit JDK 21\/22 und --enable-preview<\/code> ist es weiterhin nutzbar.<\/p>\n\n\n\n

Grundlagen: STR und FMT<\/h2>\n\n\n\n

Die Basis-Syntax ist PROZESSOR.\"Text \\{ausdruck}\"<\/code> \u2014 der Template-Prozessor STR<\/code> ersetzt \\{...}<\/code> mit dem Ergebnis des Ausdrucks:<\/p>\n\n\n

String<\/span> name = \"Lena\"<\/span>;\nint bestellungen = 42<\/span>;\n\nString<\/span> nachricht = STR.\"Hallo \\{name}, du hast \\{bestellungen} Bestellungen.\"<\/span>;\n<em<\/span>><\/span>\/\/ \"Hallo Lena, du hast 42 Bestellungen.\"<\/em<\/span>><\/span><\/span>\n\n<em<\/span>><\/span>\/\/ Ausdr\u00fccke sind vollst\u00e4ndig: Methodenaufrufe, Arithmetik, sogar andere Templates<\/em<\/span>><\/span><\/span>\nString<\/span> info = STR.\"Summe: \\{bestellungen * 2 + 10}\"<\/span>;\n<em<\/span>><\/span>\/\/ \"Summe: 94\"<\/em<\/span>><\/span><\/span>\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Der FMT<\/code>-Prozessor kombiniert Templates mit java.util.Formatter<\/code>-Spezifikationen:<\/p>\n\n\n
record Produkt(String name, double preis) {}\n\nProdukt[] produkte = {\n    new<\/span> Produkt(\"Tastatur\"<\/span>, 89.99<\/span>),\n    new<\/span> Produkt(\"Monitor\"<\/span>, 349.00<\/span>),\n    new<\/span> Produkt(\"Maus\"<\/span>, 24.50<\/span>)\n};\n\nString tabelle = FMT.\"\"<\/span>\"\n    %-15s\\{produkte[0].name}  %8.2f\\{produkte[0].preis}\n    %-15s\\{produkte[1].name}  %8.2f\\{produkte[1].preis}\n    %-15s\\{produkte[2].name}  %8.2f\\{produkte[2].preis}\n    \"<\/span>\"\"<\/span>;\n<em>\/\/ Tastatur           89.99<\/em><\/span>\n<em>\/\/ Monitor           349.00<\/em><\/span>\n<em>\/\/ Maus               24.50<\/em><\/span>\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Text Blocks (\"\"\"<\/code>) und Templates erg\u00e4nzen sich perfekt f\u00fcr mehrzeilige Strings:<\/p>\n\n\n
String json = STR.\"\"<\/span>\"\n    {\n        \"<\/span>name\": \"<\/span>\\{name}\",\n        \"<\/span>bestellungen\": \\{bestellungen}\n    }\n    \"<\/span>\"\"<\/span>;\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
RAW: Zugriff auf unverarbeitete Templates<\/h2>\n\n\n\n
Der RAW<\/code>-Prozessor liefert ein StringTemplate<\/code>-Objekt zur\u00fcck:<\/p>\n\n\n
int x = 10<\/span>, y = 20<\/span>;\nStringTemplate st = RAW.\"\\{x} plus \\{y} gleich \\{x + y}\"<\/span>;\n\nst.fragments();  <em<\/span>><\/span>\/\/ [\"\", \" plus \", \" gleich \", \"\"]<\/em<\/span>><\/span><\/span>\nst.values();     <em<\/span>><\/span>\/\/ [10, 20, 30]<\/em<\/span>><\/span><\/span>\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Wichtig: RAW<\/code> produziert absichtlich keinen<\/strong> String<\/code> \u2014 du musst das Template immer explizit durch einen Prozessor schicken, bevor ein String entsteht. Das verhindert versehentliche, ungepr\u00fcfte Interpolation.<\/p>\n\n\n\n
SQL-Injection mit String Templates verhindern<\/h2>\n\n\n\n
Dieses Beispiel zeigt, warum String Templates f\u00fcr Datenbankzugriffe so wertvoll sind. Angenommen, ein Angreifer gibt diesen Suchtext ein:<\/p>\n\n\n
String<\/span> suchbegriff = \"M\u00fcller' OR 1=1 --\"<\/span>;\n<em<\/span>><\/span>\/\/ Gef\u00e4hrliche String-Konkatenation:<\/em<\/span>><\/span><\/span>\nString<\/span> unsafe = \"SELECT * FROM kunden WHERE name = '\"<\/span> + suchbegriff + \"'\"<\/span>;\n<em<\/span>><\/span>\/\/ Ergebnis: SELECT * FROM kunden WHERE name = 'M\u00fcller' OR 1=1 --'<\/em<\/span>><\/span><\/span>\n<em<\/span>><\/span>\/\/ -> Gibt ALLE Datens\u00e4tze zur\u00fcck!<\/em<\/span>><\/span><\/span>\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Ein eigener Template-Prozessor ersetzt \\{...}<\/code>-Stellen mit JDBC-?<\/code>-Platzhaltern und \u00fcbergibt die Werte sicher via PreparedStatement<\/code>:<\/p>\n\n\n
import java.sql.*;\n\nrecord QueryProcessor(Connection conn)\n    implements StringTemplate.Processor<PreparedStatement, SQLException> {\n\n    public<\/span> PreparedStatement process(StringTemplate st) throws SQLException {\n        String query = String.join(\"?\"<\/span>, st.fragments());\n\n        PreparedStatement ps = conn.prepareStatement(query);\n        int index = 1<\/span>;\n        for<\/span> (Object value : st.values()) {\n            switch<\/span> (value) {\n                case<\/span> Integer i  -> ps.setInt(index++, i);\n                case<\/span> Long l     -> ps.setLong(index++, l);\n                case<\/span> Double d   -> ps.setDouble(index++, d);\n                case<\/span> Boolean b  -> ps.setBoolean(index++, b);\n                case<\/span> null<\/span>       -> ps.setNull(index++, Types.NULL<\/span>);\n                default<\/span>         -> ps.setString(index++, value.toString());\n            }\n        }\n        return<\/span> ps;\n    }\n}\n\n<em>\/\/ Verwendung:<\/em><\/span>\nvar<\/span> DB = new<\/span> QueryProcessor(connection);\nPreparedStatement stmt = DB.\"\"<\/span>\"\n    SELECT * FROM kunden WHERE name = \\{suchbegriff}\n    \"<\/span>\"\"<\/span>;\nResultSet rs = stmt.executeQuery();\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Selbst mit b\u00f6sartigem Input \u2014 M\u00fcller' OR 1=1 --<\/code> \u2014 entsteht daraus:<\/p>\n\n\n
SELECT * FROM kunden WHERE name = ?\n<\/code><\/span><\/pre>\n\n\n
mit suchbegriff<\/code> als gebundenem Parameter. Keine SQL-Injection m\u00f6glich.<\/p>\n\n\n\n
Eigener Template-Prozessor<\/h2>\n\n\n\n
Das Interface ist einfach: StringTemplate.Processor<R, E><\/code>. R<\/code> ist der R\u00fcckgabetyp, E<\/code> die m\u00f6gliche Exception. Hier ein Prozessor, der JSON produziert und gleichzeitig auf Injection pr\u00fcft:<\/p>\n\n\n
StringTemplate.Processor<String, IllegalArgumentException> JSON =\n    st -> {\n        String quote = \"\\\"\"<\/span>;\n        for<\/span> (Object value : st.values()) {\n            if<\/span> (value instanceof<\/span> String s && s.contains(quote)) {\n                throw<\/span> new<\/span> IllegalArgumentException(\n                    \"String-Wert enth\u00e4lt Anf\u00fchrungszeichen: \"<\/span> + s);\n            }\n        }\n        List<\/span><Object> safeValues = new<\/span> ArrayList<>();\n        for<\/span> (Object v : st.values()) {\n            if<\/span> (v instanceof<\/span> String s) {\n                safeValues.add(quote + s + quote);\n            } else<\/span> {\n                safeValues.add(v);\n            }\n        }\n        return<\/span> StringTemplate.interpolate(st.fragments(), safeValues);\n    };\n\n<em>\/\/ Nutzung:<\/em><\/span>\nString person = \"Lena\"<\/span>;\nint alter = 30<\/span>;\nString result = JSON.\"\"<\/span>\"\n    {\"<\/span>name\": \\{person}, \"<\/span>alter\": \\{alter}}\n    \"<\/span>\"\"<\/span>;\n<em>\/\/ {\"name\": \"Lena\", \"alter\": 30}<\/em><\/span>\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Preview-Feature aktivieren<\/h2>\n\n\n\n
F\u00fcr Java 21 oder 22 mit --enable-preview<\/code>:<\/p>\n\n\n
javac<\/span> --enable-preview<\/span> --release<\/span> 21 MeinProgramm<\/span>.java<\/span>\njava<\/span> --enable-preview<\/span> MeinProgramm<\/span>\n<\/code><\/span>Code-Sprache:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
In Maven:<\/p>\n\n\n
<plugin<\/span>><\/span>\n    <groupId<\/span>><\/span>org.apache.maven.plugins<\/groupId<\/span>><\/span>\n    <artifactId<\/span>><\/span>maven-compiler-plugin<\/artifactId<\/span>><\/span>\n    <configuration<\/span>><\/span>\n        <compilerArgs<\/span>><\/span>\n            <arg<\/span>><\/span>--enable-preview<\/arg<\/span>><\/span>\n        <\/compilerArgs<\/span>><\/span>\n    <\/configuration<\/span>><\/span>\n<\/plugin<\/span>><\/span>\n<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
Ausblick<\/h2>\n\n\n\n
Die f\u00fcr JDK 23 geplante Finalisierung der String Templates (JEP 465) wurde zur\u00fcckgezogen (Status: Withdrawn). Die enge Kopplung von Template-Erfassung und -Verarbeitung in der Syntax PROZESSOR.\"template\"<\/code> galt als problematisch. Stand Juli 2026 gibt es noch keinen Nachfolge-JEP; ein Redesign mit m\u00f6glicherweise getrennten Schritten f\u00fcr Capture und Processing wird in der Community diskutiert. In der Zwischenzeit bleibt JDK 21\/22 die einzige M\u00f6glichkeit, mit dieser Preview zu experimentieren.<\/p>\n\n\n\n
Die grundlegende Idee \u2014 typsichere, validierbare String-Interpolation mit anwendungsspezifischen Prozessoren \u2014 bleibt relevant, auch wenn das finale Design noch offen ist.<\/p>\n","protected":false},"excerpt":{"rendered":"
Java war lange die Sprache, in der man f\u00fcr formatierte Strings String.format() oder umst\u00e4ndliche +-Ketten schreiben musste. Mit Java 21 (JEP 430) kam endlich eine elegante L\u00f6sung: String Templates. Dieser Artikel zeigt die Syntax, erkl\u00e4rt eigene Template-Prozessoren und demonstriert, wie String Templates SQL-Injection-Angriffe zur Compile-Time verhindern. Wichtig vorab: String Templates sind in Java 21 (JEP 430) und 22 (JEP […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-697","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/697","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=697"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/697\/revisions"}],"predecessor-version":[{"id":698,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/697\/revisions\/698"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=697"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=697"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=697"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}