6. HTTP-Clients für den Steuerberechnungsdienst

6.1. Einführung
Dieses Kapitel gibt ohne strukturelle Änderungen die drei aufeinander folgenden Client-Schichten wieder, die im TypeScript-Kurs aufgebaut wurden und von denen jede die vorherige verfeinert: einen ersten CLI-Client, bei dem alle Berechnungen serverseitig bleiben; einen zweiten CLI-Client, bei dem die Berechnung auf die Clientseite wandert (Schicht [business]); einen dritten, für den BROWSER kompilierten Client; und schließlich einen vollständigen HTML-Client mit eigenen Views. Alle vier stützen sich auf denselben NestJS-Server, der im vorigen Kapitel installiert wurde.
6.2. HTTP-Client 1

6.2.1. Die Schicht [dao]
6.2.2. Skript [dao1]
| // dao1.dart
// Portiert Dao1.ts: Die [dao]-Schicht (Data Access Object) kapselt alle
// Details der HTTP-Kommunikation mit dem Steuerberechnungsserver (URL,
// Methode, Sitzungs-Cookie) hinter einfachen fachlichen Methoden
// (initSession, authenticateUser, calculateTax...).
import 'package:dio/dio.dart';
class Dao1 {
final Dio _dio;
final String _sessionCookieName;
String _sessionCookie = '';
// Konstruktor - erhält die zu verwendende Dio-Instanz, so wie das TypeScript-
// Skript die axios-Instanz als Parameter erhielt
Dao1(this._dio) : _sessionCookieName = "connect.sid";
// Sitzung initialisieren
Future<dynamic> initSession() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'init-session', 'type': 'json'},
);
}
Future<dynamic> authenticateUser(String user, String password) {
return _getRemoteData(
'main.php',
method: 'POST',
queryParameters: {'action': 'authenticate-user'},
data: {'user': user, 'password': password},
contentType: Headers.formUrlEncodedContentType,
);
}
// Steuerberechnung
Future<dynamic> calculateTax(String married, int children, int salary) {
return _getRemoteData(
'main.php',
method: 'POST',
queryParameters: {'action': 'calculate-tax'},
data: {'married': married, 'children': children, 'salary': salary},
contentType: Headers.formUrlEncodedContentType,
);
}
// Liste der Simulationen
Future<dynamic> listSimulations() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'list-simulations'},
);
}
// eine Simulation löschen
Future<dynamic> deleteSimulation(int index) {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'delete-simulation', 'number': index},
);
}
Future<dynamic> _getRemoteData(
String path, {
required String method,
Map<String, dynamic>? queryParameters,
Object? data,
String? contentType,
}) async {
// für das Sitzungs-Cookie
final options = Options(
method: method,
contentType: contentType,
headers: {'Cookie': _sessionCookie},
validateStatus: (_) => true,
);
// Ausführung der HTTP-Anfrage
final response = await _dio.request(
path,
queryParameters: queryParameters,
data: data,
options: options,
);
// wir lesen das Sitzungs-Cookie aus, falls vorhanden
final setCookie = response.headers['set-cookie'];
if (setCookie != null) {
for (final header in setCookie) {
final result = RegExp('^($_sessionCookieName.+?);').firstMatch(header);
if (result != null) {
_sessionCookie = result.group(1)!;
break;
}
}
}
// die Antwort des Servers steht in [response.data]
return response.data;
}
}
|
Kommentieren wir diesen Code:
- Zeile 48: Die Schicht [dao] (Data Access Object) kapselt alle Details der HTTP-Kommunikation (URL, Methode, Sitzungs-Cookie) hinter einfachen fachlichen Methoden - [initSession], [authenticateUser], [calculateTax], [listSimulations], [deleteSimulation] (Zeile 57).
- Zeile 15: [Dao1(this._dio)] erhält die zu verwendende [Dio]-Instanz als Konstruktorparameter, genau wie das TypeScript-Skript die [axios]-Instanz erhielt.
- Zeile 65: [_getRemoteData] (privat, Präfix [_]) zentralisiert die manuelle Verwaltung des Sitzungs-Cookies ([response.headers['set-cookie']], [RegExp] (Zeile 90)), die bereits in dart_dio_03.dart vorkam: Jede öffentliche Methode des DAO stützt sich auf dieselbe private Methode.
6.2.3. Das Programm [main1]
6.2.4. Skript [main1]
| // main1.dart
// Portiert main1.ts.
import 'dart:convert';
import 'package:dio/dio.dart';
import 'dao1.dart';
Future<void> main() async {
// Dio-Konfiguration - globale baseUrl/globaler timeout, wie axios.defaults in
// TypeScript
final dio = Dio(BaseOptions(
baseUrl: 'http://localhost:3000/',
connectTimeout: const Duration(seconds: 2),
receiveTimeout: const Duration(seconds: 2),
));
// Instanziierung der [dao]-Schicht
final dao = Dao1(dio);
// Verwendung der [dao]-Schicht
try {
// Sitzung initialisieren
log("-----------init-session");
dynamic response = await dao.initSession();
log(response);
// Authentifizierung
log("-----------authenticate-user");
response = await dao.authenticateUser("admin", "admin");
log(response);
// Steuerberechnungen - Future.wait ist das Dart-Äquivalent zu Promise.all
// (bereits gesehen in async_05.dart)
log("-----------calculate-tax x 3");
response = await Future.wait([
dao.calculateTax("yes", 2, 45000),
dao.calculateTax("no", 2, 45000),
dao.calculateTax("no", 1, 30000),
]);
log(response);
// Liste der Simulationen
log("-----------list-of-simulations");
response = await dao.listSimulations();
log(response);
// Löschen einer Simulation
log("-----------deleting simulation no. 1");
response = await dao.deleteSimulation(1);
log(response);
} catch (error) {
// wir protokollieren den Fehler
print("error=$error");
}
}
// JSON-Protokoll
void log(Object? object) {
const JsonEncoder encoder = JsonEncoder.withIndent(' ');
print(encoder.convert(object));
}
|
Kommentieren wir diesen Code:
- Zeile 16: [final dao = Dao1(dio);]: Die Schicht [dao] wird nur einmal instanziiert und dann für die gesamte Aufrufsequenz wiederverwendet (init-session, Authentifizierung, Berechnungen, Liste, Löschen).
- Zeilen 30–31: [Future.wait([dao.calculateTax(...), ...])]: Die drei Steuerberechnungen werden PARALLEL gestartet, das Dart-Äquivalent zu [Promise.all], dem wir bereits in async_05.dart begegnet sind.
- Zeilen 52–53: [JsonEncoder.withIndent(' ').convert(object)]: Die Hilfsfunktion [log] bildet die eingerückte Ausgabe von [JSON.stringify(x, null, 2)] nach.
Das Ergebnis der Ausführung lautet:
| "-----------init-session"
{
"action": "init-session",
"status": 700,
"response": "session started with type [json]"
}
"-----------authenticate-user"
{
"action": "authenticate-user",
"status": 200,
"response": "Authentication successful [admin, admin]"
}
"-----------calculate-tax x 3"
[
{
"action": "calculate-tax",
"status": 300,
"response": {
"married": "yes",
"children": 2,
"salary": 45000,
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
}
},
{
"action": "calculate-tax",
"status": 300,
"response": {
"married": "no",
"children": 2,
"salary": 45000,
"tax": 3250,
"surcharge": 370,
"discount": 0,
"reduction": 0,
"rate": 0.3
}
},
{
"action": "calculate-tax",
"status": 300,
"response": {
"married": "no",
"children": 1,
"salary": 30000,
"tax": 1687,
"surcharge": 0,
"discount": 0,
"reduction": 0,
"rate": 0.14
}
}
]
"-----------list-of-simulations"
{
"action": "list-simulations",
"status": 500,
"response": [
{
"married": "yes",
"children": 2,
"salary": 45000,
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
},
{
"married": "no",
"children": 1,
"salary": 30000,
"tax": 1687,
"surcharge": 0,
"discount": 0,
"reduction": 0,
"rate": 0.14
}
]
}
"-----------deleting simulation no. 1"
{
"action": "delete-simulation",
"status": 600,
"response": [
{
"married": "yes",
"children": 2,
"salary": 45000,
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
}
]
}
|
6.3. HTTP-Client 2

Dieser zweite Client verlagert die Steuer-BERECHNUNG vom Server auf den Client: Der Server liefert jetzt nur noch einmal über [get-admindata] die rohen Steuerdaten (Sätze, Schwellenwerte usw.), und die Schicht [business] führt nun die Berechnungen durch.
6.3.1. Die Klasse [Business]
6.3.2. Skript [business]
| // business.dart
// Portiert Business.ts: Die Steuerberechnung erfolgt vollständig auf Client-Seite
// (in TypeScript im Browser, hier im Dart-Programm), ausgehend von
// den rohen Steuerdaten, die nur einmal über
// [Dao2.getAdminData] vom Server geholt werden (siehe dao2.dart).
class Business {
// [dynamic]: Die genaue Struktur der vom Steuer-
// Server gesendeten Daten (Sätze, Obergrenzen...) ist hier nicht dokumentiert; wie in
// TypeScript bleiben wir bei diesem Typ bewusst flexibel
final Map<String, dynamic> taxAdminData;
Business(this.taxAdminData);
// Steuerberechnung
// --------------------------------------------------------------------------
// married: ja, nein
// children: Anzahl der Kinder
// salary: Jahresgehalt
Map<String, dynamic> calculateTax(String married, int children, num salary) {
// Steuerberechnung mit Kindern
final result1 = _calculateTax2(married, children, salary);
final tax1 = result1['tax'] as num;
// Steuerberechnung ohne die Kinder
Map<String, dynamic> result2;
num tax2;
num halfShareCeiling;
if (children != 0) {
result2 = _calculateTax2(married, 0, salary);
tax2 = result2['tax'] as num;
// Anwendung der Obergrenze des Familienquotienten
halfShareCeiling = taxAdminData['halfShareQfCeiling'] as num;
if (children < 3) {
// halfShareCeiling für die ersten 2 Kinder
tax2 = tax2 - children * halfShareCeiling;
} else {
// halfShareCeiling für die ersten 2 Kinder, doppelt für die folgenden
tax2 = tax2 - 2 * halfShareCeiling - (children - 2) * 2 * halfShareCeiling;
}
} else {
// keine Neuberechnung der Steuer
tax2 = tax1;
result2 = result1;
}
// wir nehmen die höhere Steuer aus [tax1, tax2]
num tax;
num rate;
num surcharge;
if (tax1 > tax2) {
tax = tax1;
rate = result1['rate'] as num;
surcharge = result1['surcharge'] as num;
} else {
surcharge = tax2 - tax1 + (result2['surcharge'] as num);
tax = tax2;
rate = result2['rate'] as num;
}
// Berechnung eines möglichen Nachlasses
final discount = _getDiscount(married, tax);
tax -= discount;
// Berechnung einer möglichen Steuerermäßigung
final reduction = _getReduction(married, salary, children, tax);
tax -= reduction;
// Ergebnis
return {
'tax': tax.floor(),
'surcharge': surcharge,
'discount': discount,
'reduction': reduction,
'rate': rate,
};
}
// --------------------------------------------------------------------------
Map<String, dynamic> _calculateTax2(String married, int children, num salary) {
// Anzahl der Anteile
married = married.toLowerCase();
num shares;
if (married == "yes") {
shares = children / 2 + 2;
} else {
shares = children / 2 + 1;
}
// 1 Anteil pro Kind ab dem 3.
if (children >= 3) {
// ein zusätzlicher halber Anteil für jedes Kind ab dem 3.
shares += 0.5 * (children - 2);
}
// zu versteuerndes Einkommen
final taxableIncome = _getTaxableIncome(salary);
// Zuschlag
num surcharge = (taxableIncome - 0.9 * salary).floor();
// wegen Rundungsproblemen
if (surcharge < 0) {
surcharge = 0;
}
// Familienquotient
final quotient = taxableIncome / shares;
// Steuerberechnung
final List<num> limits = List<num>.from(taxAdminData['limits'] as List);
final List<num> coeffR = List<num>.from(taxAdminData['coeffR'] as List);
final List<num> coeffN = List<num>.from(taxAdminData['coeffN'] as List);
// wird ans Ende der Liste [limits] gesetzt, um die folgende Schleife zu stoppen
limits[limits.length - 1] = quotient;
// Suche nach dem Steuersatz
var i = 0;
while (quotient > limits[i]) {
i++;
}
// da wir quotient ans Ende von limits gesetzt haben, kann die vorherige
// Schleife nicht über die Liste limits hinausgehen
// jetzt können wir die Steuer berechnen
final tax = (taxableIncome * coeffR[i] - shares * coeffN[i]).floor();
// Ergebnis
return {'tax': tax, 'surcharge': surcharge, 'rate': coeffR[i]};
}
// taxableIncome = annualSalary - allowance (der Freibetrag hat ein Minimum und ein Maximum)
num _getTaxableIncome(num salary) {
// Freibetrag von 10 % des Gehalts
num allowance = 0.1 * salary;
// dieser Freibetrag darf tenPercentAllowanceMax nicht überschreiten
final allowanceMax = taxAdminData['tenPercentAllowanceMax'] as num;
if (allowance > allowanceMax) {
allowance = allowanceMax;
}
// der Freibetrag darf nicht unter tenPercentAllowanceMin liegen
final allowanceMin = taxAdminData['tenPercentAllowanceMin'] as num;
if (allowance < allowanceMin) {
allowance = allowanceMin;
}
// zu versteuerndes Einkommen
final taxableIncome = salary - allowance;
return taxableIncome.floor();
}
// berechnet einen möglichen Nachlass
num _getDiscount(String married, num taxes) {
// zunächst ein Nachlass von null
num discount = 0;
// maximaler Steuerbetrag, um den Nachlass zu erhalten
final taxCeilingForDiscount = married == "yes"
? taxAdminData['coupleTaxCeilingForDiscount'] as num
: taxAdminData['singleTaxCeilingForDiscount'] as num;
if (taxes < taxCeilingForDiscount) {
// maximaler Betrag des Nachlasses
final discountCeiling = married == "yes"
? taxAdminData['coupleDiscountCeiling'] as num
: taxAdminData['singleDiscountCeiling'] as num;
// theoretischer Nachlass
discount = discountCeiling - 0.75 * taxes;
// der Nachlass darf den Betrag der Steuer nicht überschreiten
if (discount > taxes) {
discount = taxes;
}
// kein Nachlass < 0
if (discount < 0) {
discount = 0;
}
}
// Ergebnis - ceil() ist das Dart-Äquivalent zu Math.ceil()
return discount.ceil();
}
// berechnet eine mögliche Ermäßigung
num _getReduction(String married, num salary, int children, num taxes) {
// die Einkommensgrenze, bis zu der Anspruch auf die Ermäßigung von 20 % besteht
num incomeCeilingForReduction = married == "yes"
? taxAdminData['coupleIncomeCeilingForReduction'] as num
: taxAdminData['singleIncomeCeilingForReduction'] as num;
final halfShareReductionValue = taxAdminData['halfShareReductionValue'] as num;
incomeCeilingForReduction += children * halfShareReductionValue;
if (children > 2) {
incomeCeilingForReduction += (children - 2) * halfShareReductionValue;
}
// zu versteuerndes Einkommen
final taxableIncome = _getTaxableIncome(salary);
// Ermäßigung
num reduction = 0;
if (taxableIncome < incomeCeilingForReduction) {
// Ermäßigung von 20 %
reduction = 0.2 * taxes;
}
return reduction.ceil();
}
}
|
Analysieren wir diesen Code:
- Zeile 12: [Business(this.taxAdminData)]: Der Konstruktor erhält die vom DAO nur einmal abgerufenen rohen Steuerdaten — danach sind keine weiteren Netzwerkaufrufe mehr nötig, um eine Steuer zu berechnen.
- Zeile 19: [Map<String, dynamic> calculateTax(String married, int children, num salary)]: eine getreue, zeilenweise Portierung des TypeScript-Algorithmus — dieselben Schritte ([_calculateTax2], [_getTaxableIncome], [_getDiscount], [_getReduction]), dieselbe Logik zur Begrenzung des Familienquotienten.
- [.floor()]/[.ceil()] (Methoden von [num]) ersetzen [Math.floor(...)]/[Math.ceil(...)]: In Dart sind dies Instanzmethoden der Zahl selbst und keine statischen Methoden einer Hilfsklasse.
- Die SCHLÜSSEL der zurückgegebenen [Map] ([tax], [surcharge], [discount], [reduction]...) haben dieselben schlichten ASCII-Namen wie die Dart-BEZEICHNER (Variablen- und Parameternamen) — ein String darf in Dart Akzente enthalten, ein Bezeichner jedoch nicht (siehe simulation.dart weiter unten in diesem Kapitel).
6.3.3. Die Klasse [Dao2]
6.3.4. Skript [dao2]
| // dao2.dart
// Portiert Dao2.ts: identisch mit dao1.dart bei initSession und
// authenticateUser, stellt aber [getAdminData] statt
// [calculateTax]/[listSimulations]/[deleteSimulation] bereit - die Berechnung und
// die Liste der Simulationen werden nun auf der CLIENT-Seite von der
// [business]-Schicht erledigt (siehe business.dart), der Server dient nur noch dazu, die
// rohen Steuerdaten (Sätze, Obergrenzen...) zu liefern.
import 'package:dio/dio.dart';
class Dao2 {
final Dio _dio;
final String _sessionCookieName;
String _sessionCookie = '';
Dao2(this._dio) : _sessionCookieName = "connect.sid";
Future<dynamic> initSession() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'init-session', 'type': 'json'},
);
}
Future<dynamic> authenticateUser(String user, String password) {
return _getRemoteData(
'main.php',
method: 'POST',
queryParameters: {'action': 'authenticate-user'},
data: {'user': user, 'password': password},
contentType: Headers.formUrlEncodedContentType,
);
}
Future<dynamic> getAdminData() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'get-admindata'},
);
}
Future<dynamic> _getRemoteData(
String path, {
required String method,
Map<String, dynamic>? queryParameters,
Object? data,
String? contentType,
}) async {
final options = Options(
method: method,
contentType: contentType,
headers: {'Cookie': _sessionCookie},
validateStatus: (_) => true,
);
final response = await _dio.request(
path,
queryParameters: queryParameters,
data: data,
options: options,
);
final setCookie = response.headers['set-cookie'];
if (setCookie != null) {
for (final header in setCookie) {
final result = RegExp('^($_sessionCookieName.+?);').firstMatch(header);
if (result != null) {
_sessionCookie = result.group(1)!;
break;
}
}
}
return response.data;
}
}
|
Kommentieren wir diesen Code:
- Zeile 4: Identisch mit [Dao1] für [initSession] und [authenticateUser], stellt aber [getAdminData] anstelle von [calculateTax]/[listSimulations] (Zeile 4)/[deleteSimulation] (Zeile 4) bereit: Diese drei Operationen werden nun auf der CLIENT-Seite von der soeben eingeführten Schicht [business] übernommen.
6.3.5. Das Programm [main2]
6.3.6. Skript [main2]
| // main2.dart
// Portiert main2.ts.
import 'dart:convert';
import 'package:dio/dio.dart';
import 'dao2.dart';
import 'business.dart';
Future<void> main() async {
// Dio-Konfiguration
final dio = Dio(BaseOptions(
baseUrl: 'http://localhost:3000/',
connectTimeout: const Duration(seconds: 2),
receiveTimeout: const Duration(seconds: 2),
));
// Instanziierung der [dao]-Schicht
final dao = Dao2(dio);
// HTTP-Anfragen
Map<String, dynamic> taxAdminData;
try {
// Sitzung initialisieren
log("-----------init-session");
dynamic response = await dao.initSession();
log(response);
// Authentifizierung
log("-----------authenticate-user");
response = await dao.authenticateUser("admin", "admin");
log(response);
// Steuerdaten
log("-----------get-admindata");
response = await dao.getAdminData();
log(response);
taxAdminData = response['response'] as Map<String, dynamic>;
} catch (error) {
// wir protokollieren den Fehler
print("error=$error");
// Ende
return;
}
// Instanziierung der [business]-Schicht
final business = Business(taxAdminData);
// Steuerberechnungen
log("-----------calculate-tax x 3");
final List<Map<String, dynamic>> simulations = [];
simulations.add(business.calculateTax("yes", 2, 45000));
simulations.add(business.calculateTax("no", 2, 45000));
simulations.add(business.calculateTax("no", 1, 30000));
// Liste der Simulationen
log("-----------list-of-simulations");
log(simulations);
// Löschen einer Simulation
log("-----------deleting simulation no. 1");
simulations.removeAt(1);
log(simulations);
}
// JSON-Protokoll
void log(Object? object) {
const JsonEncoder encoder = JsonEncoder.withIndent(' ');
print(encoder.convert(object));
}
|
Kommentieren wir diesen Code:
- Zeile 41: [final business = Business(taxAdminData);]: Die Schicht [business] wird nur EINMAL instanziiert, unmittelbar nach dem Abruf der Steuerdaten vom Server.
- [simulations.add(business.calculateTax(...));]: Die Steuerberechnungen erfordern KEINEN Netzwerkaufruf mehr — anders als in main1.dart, wo jede Berechnung eine eigene HTTP-Anfrage war.
Das Ergebnis der Ausführung lautet:
| "-----------init-session"
{
"action": "init-session",
"status": 700,
"response": "session started with type [json]"
}
"-----------authenticate-user"
{
"action": "authenticate-user",
"status": 200,
"response": "Authentication successful [admin, admin]"
}
"-----------get-admindata"
{
"action": "get-admindata",
"status": 1000,
"response": {
"limits": [
9964,
27519,
73779,
156244,
0
],
"coeffR": [
0,
0.14,
0.3,
0.41,
0.45
],
"coeffN": [
0,
1394.96,
5798,
13913.69,
20163.45
],
"halfShareQfCeiling": 1551,
"singleIncomeCeilingForReduction": 21037,
"coupleIncomeCeilingForReduction": 42074,
"halfShareReductionValue": 3797,
"singleDiscountCeiling": 1196,
"coupleDiscountCeiling": 1970,
"coupleTaxCeilingForDiscount": 2627,
"singleTaxCeilingForDiscount": 1595,
"tenPercentAllowanceMax": 12502,
"tenPercentAllowanceMin": 437
}
}
"-----------calculate-tax x 3"
"-----------list-of-simulations"
[
{
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
},
{
"tax": 3250,
"surcharge": 370,
"discount": 0,
"reduction": 0,
"rate": 0.3
},
{
"tax": 1687,
"surcharge": 0,
"discount": 0,
"reduction": 0,
"rate": 0.14
}
]
"-----------deleting simulation no. 1"
[
{
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
},
{
"tax": 1687,
"surcharge": 0,
"discount": 0,
"reduction": 0,
"rate": 0.14
}
]
|
6.4. HTTP-Client 3

6.4.1. Entwicklung der Werkzeuge seit 2019
Dieser dritte Client verwendet dasselbe Paar [dao]/[business] wie HTTP-Client 2, wird aber FÜR DEN BROWSER KOMPILIERT, statt von der Kommandozeile ausgeführt zu werden. Wie bei TypeScript erfordert dieser Build webpack und babel sowie Polyfills ([core-js/stable], [regenerator-runtime/runtime]), damit moderner Code auch in älteren Browsern funktioniert. Auf der Dart-Seite bringt das SDK seinen eigenen Web-Compiler mit ([dart compile js]): Es sind keine Polyfills nötig; [Future]/[async]/[await], Records, Patterns usw. werden unabhängig vom Ziel direkt in das entsprechende JavaScript kompiliert.
6.4.2. Kompilieren und Ausführen des Projekts
Aus dem Ordner [http client 3]:
Der Entwicklungsserver [webdev serve] wird nicht mit dem Dart-SDK mitgeliefert: Das Paket [webdev] muss zuvor einmalig global mit [dart pub global activate webdev] installiert werden.
Dieser Befehl installiert die ausführbare Datei [webdev] im globalen Pub-Cache, einem Ordner, der nicht automatisch im Windows-PATH enthalten ist. Um ihn dort ein für alle Mal (für den aktuellen Benutzer) hinzuzufügen, öffnen Sie ein PowerShell-Terminal und führen Sie Folgendes aus:
| [Environment]::SetEnvironmentVariable("Path", $env:Path + ";$env:LOCALAPPDATA\Pub\Cache\bin", "User")
|
Anschließend müssen Sie das Terminal (oder VSCode) schließen und neu öffnen, damit der neue PATH wirksam wird. Dann, weiterhin im Ordner [http client 3]:
| dart pub get
webdev serve
|
Während der Entwicklung startet [webdev serve] einen Server, der bei jeder Änderung automatisch neu kompiliert (Hot Reload): Das Terminal zeigt die URL an, die im Browser geöffnet werden soll (Standard: http://localhost:8080). Für einen Produktions-Build steht weiterhin der Befehl [dart compile js web/main.dart -o web/main.dart.js] zur Verfügung: Die Seite [web/index.html] lädt dann [main.dart.js], um das Ergebnis zu testen — dasselbe Konzept wie der minimale Einstiegspunkt [src/index.ts] im TypeScript-Kurs.
6.4.3. Das Skript [main3]
6.4.4. Skript [main3]
| // main3.dart
// Portiert main3.ts.
//
// [WARNUNG, grundlegender Unterschied zu TypeScript] main3.ts brauchte
// zwei Polyfills (core-js/stable, regenerator-runtime), damit
// async/await und neuere JavaScript-Funktionen in
// alten Browsern funktionieren, nachdem sie von babel/webpack transpiliert wurden. Der
// Dart-Compiler für das Web (`dart compile js`) braucht KEINEN
// Polyfill dieser Art: Future/async/await, Records, Patterns...
// werden direkt in äquivalentes JavaScript oder WebAssembly kompiliert,
// egal welches Ziel - ein direkter Vorteil davon, aus
// einer einheitlichen Sprache und Toolchain zu kompilieren, statt
// "modernes" JavaScript in "altes" JavaScript zu transpilieren.
import 'dart:convert';
import 'package:http/browser_client.dart';
import 'dao3.dart';
import 'business.dart';
Future<void> main() async {
// browserspezifischer HTTP-Client mit withCredentials=true -
// das Dart-Äquivalent zu "axios.defaults.withCredentials = true"
final client = BrowserClient()..withCredentials = true;
final dao = Dao3(client, 'http://localhost:3000');
Map<String, dynamic> taxAdminData;
try {
log("-----------init-session");
Map<String, dynamic> response = await dao.initSession();
log(response);
if (response['status'] != 700) {
throw Exception(jsonEncode(response['response']));
}
log("-----------authenticate-user");
response = await dao.authenticateUser("admin", "admin");
log(response);
if (response['status'] != 200) {
throw Exception(jsonEncode(response['response']));
}
log("-----------get-admindata");
response = await dao.getAdminData();
log(response);
if (response['status'] != 1000) {
throw Exception(jsonEncode(response['response']));
}
taxAdminData = response['response'] as Map<String, dynamic>;
} catch (error) {
print("error=$error");
return;
} finally {
client.close();
}
// Instanziierung der [business]-Schicht
final business = Business(taxAdminData);
log("-----------calculate-tax x 3");
final List<Map<String, dynamic>> simulations = [];
simulations.add(business.calculateTax("yes", 2, 45000));
simulations.add(business.calculateTax("no", 2, 45000));
simulations.add(business.calculateTax("no", 1, 30000));
log("-----------list-of-simulations");
log(simulations);
log("-----------deleting simulation no. 1");
simulations.removeAt(1);
log(simulations);
}
// JSON-Protokoll
void log(Object? object) {
const JsonEncoder encoder = JsonEncoder.withIndent(' ');
print(encoder.convert(object));
}
|
Kommentieren wir diesen Code:
- Zeile 22: [final client = BrowserClient()..withCredentials = true;]: [BrowserClient] ([package:http/browser_client.dart]) existiert nur, wenn der Code für das Web kompiliert wird; seine Option [withCredentials] ist das Dart-Äquivalent zu [axios.defaults.withCredentials = true] — der BROWSER verwaltet dann das Sitzungs-Cookie selbstständig.
- Der Dart-Web-Compiler benötigt KEINERLEI Polyfill (anders als main3.ts): [Future]/[async]/[await] und neuere Sprachfeatures werden direkt kompiliert — ein unmittelbarer Vorteil, wenn man mit einer einheitlichen Sprache und Werkzeugkette beginnt, statt modernes JavaScript in älteres JavaScript zu transpilieren.
6.4.5. Die Klasse [Dao3]
6.4.6. Skript [dao3]
| // dao3.dart
// Portiert tax client/http client 3/src/Dao3.ts.
//
// Unterschied zu dao2.dart: Diese Datei ist dafür gedacht, für den
// BROWSER kompiliert zu werden (mit `dart compile js`, siehe die README dieses Ordners), nicht
// auf der CLI mit `dart run` ausgeführt zu werden. In einem Browser wird das
// SITZUNGS-COOKIE vom Browser selbst automatisch verwaltet (wie bei jeder
// Webseite), sobald das Senden erlaubt ist - es ist also nicht mehr
// nötig, die in dao1.dart/dao2.dart von Hand erfolgende MANUELLE Cookie-Verwaltung
// durchzuführen (genau die bereits vorhandene Überlegung, die es Dao3.ts erlaubte,
// den gesamten Cookie-Code von Dao2.ts zu entfernen).
//
// [Zuordnung zu TypeScript] "axios.defaults.withCredentials = true"
// (in main3.dart gesetzt, nicht hier) entspricht auf Seiten des Dart-Pakets [http]
// der Option [withCredentials] des webspezifischen Clients
// [BrowserClient] (package:http/browser_client.dart) - einer Klasse, die
// NUR beim Kompilieren für das Web existiert, anders als
// http.Client, der überall funktioniert.
import 'dart:convert';
import 'package:http/http.dart' as http;
class Dao3 {
final http.Client _client;
final String _baseUrl;
Dao3(this._client, this._baseUrl);
Future<dynamic> initSession() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'init-session', 'type': 'json'},
);
}
Future<dynamic> authenticateUser(String user, String password) {
return _getRemoteData(
'main.php',
method: 'POST',
queryParameters: {'action': 'authenticate-user'},
body: {'user': user, 'password': password},
);
}
Future<dynamic> getAdminData() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'get-admindata'},
);
}
Future<dynamic> _getRemoteData(
String path, {
required String method,
Map<String, dynamic>? queryParameters,
Map<String, String>? body,
}) async {
final uri = Uri.parse('$_baseUrl/$path').replace(
queryParameters: queryParameters?.map((k, v) => MapEntry(k, '$v')),
);
final http.Response response;
if (method == 'POST') {
response = await _client.post(uri, body: body);
} else {
response = await _client.get(uri);
}
// [Unterschied zum CLI-Client] kein manuelles Auslesen des Headers set-cookie
// hier: In einem Browser legt response.headers ihn gar nicht offen
// (vom Browser geschützter Header, unsichtbar für den
// JavaScript-/Dart-Code, gerade weil er bereits vom Browser selbst verarbeitet wird)
return jsonDecode(response.body);
}
}
|
Kommentieren wir diesen Code:
- KEINE manuelle Verwaltung des Sitzungs-Cookies mehr (anders als bei [Dao1]/[Dao2]): In einem Browser wird das Sitzungs-Cookie automatisch vom Browser selbst verwaltet, sofern das Senden von Cookies erlaubt ist ([withCredentials], in main3.dart gesetzt).
- [response.headers] stellt den Header [set-cookie] in einem Browser nicht einmal mehr bereit: ein geschützter Header, für den clientseitigen JavaScript-/Dart-Code unsichtbar, gerade weil er bereits eigenständig verwaltet wird.
6.4.7. Kompilierung und Ausführung
Siehe den Abschnitt [Compiling and Running the Project] oben: Derselbe Befehl [dart compile js] kompiliert [web/main.dart], das an [main3.dart] delegiert.
Starten Sie den Entwicklungsserver, um die Webanwendung des Http3-Clients auszuführen:
| PS C:\Data\st-2026\dev\dart-sept-2026-scripts\dart-fundamentals\tax-client\dart-fundamentals\tax client\http client 3> webdev serve
[INFO] Serving `web` on http://127.0.0.1:8080
[INFO] ------------------------------------------------------------------------------------
[INFO] Injected debugging metadata for entrypoint at http://127.0.0.1:8080/main.dart.bootstr
[INFO] Injected debugging metadata for entrypoint at http://localhost:8080/main.dart.bootstrap.js
|
Das Ergebnis der Ausführung lautet:

- In [1] öffnen Sie einen Browser und rufen die URL [http://localhost:8080] auf;
- in [2] der von der aufgerufenen Seite angezeigte Text;
- in [3] finden Sie das Ergebnis der Ausführung in der Browserkonsole (F12, dann die Option Console). Wir erhalten dasselbe Ergebnis wie zuvor, diesmal jedoch in einem Browser;
6.5. HTML-Client

6.5.1. Lösungsarchitektur
Dieser vierte und letzte Client setzt auf HTTP-Client 3 eine echte HTML-Oberfläche auf: Die Schichten [dao] ([Dao3]) und [business] ([Business]) werden UNVERÄNDERT WIEDERVERWENDET, und es kommen zwei neue Schichten hinzu — VIEWS (Aufbau des DOM) und CONTROLLER (Orchestrierung). Das Projekt ist in zwei Ordner gegliedert, [web/] (Einstiegspunkt, HTML, CSS) und [lib/] (gemeinsamer Code), gemäß der Konvention eines Standard-Dart-Webprojekts — Details zu dieser Konvention finden Sie in der README.md in diesem Ordner.
6.5.2. Das HTML-Template: die Datei [web/index.html]
Exakt aus [src/index.html] kopiert (dieselben CSS-Klassen: [banner], [menu], [content], [section-title], [field-row], [result], [error], [simulations]...), mit einem kleinen Unterschied: Das geladene Skript ist [main.dart.js] (ein FESTER, vom Dart-Webwerkzeug vorgegebener Name), während [index.html] aus Views.ts ein Webpack-Bundle mit einem Namen mit HASH ([main.a44f6e1c12ab338daedc.js]) geladen hat.
6.5.3. Die geänderte Konfiguration [webpack.config.js]
Auf der Dart-Seite ist nichts Vergleichbares nötig: Es muss keine Konfigurationsdatei für einen Bundler geschrieben werden. [web/main.dart] übernimmt allein durch seine POSITION im Verzeichnisbaum (direkt unter [web/]) die Rolle, die die Zeile [entry: './src/main3.ts'] für [webpack.config.js] spielte — eine Namens- und Ortskonvention ersetzt eine ganze Konfigurationsdatei.
6.5.4. Die Schichten [dao] und [business]: zwei unverändert wiederverwendete Dateien
[lib/dao3.dart] und [lib/business.dart] sind EXAKTE Kopien der gleichnamigen Dateien aus HTTP-Client 3 - dieselbe Wiederverwendung ohne jede Änderung, wie sie Views.ts und AppHtml.ts für [Dao3.ts] und [Business.ts] vornahmen.
6.5.5. Die Schicht [views]: die Datei [Views.ts]
6.5.6. Skripte [simulation, views]
Die Views-Schicht stützt sich auf DREI Dateien: simulation.dart (die angezeigten Daten), views.dart (der Aufbau des DOM) und app_html.dart (der Controller, der im nächsten Abschnitt behandelt wird). Beginnen wir mit simulation.dart:
| // simulation.dart
// Das Ergebnis einer Steuerberechnung, wie es von business.dart geliefert wird,
// ergänzt um die eingegebenen Parameter. Portiert das Interface [Simulation] aus Views.ts.
//
// [NEU, Dart 3] hier verwenden wir einen benannten RECORD (siehe
// dart-fundamentals/dart3/dart3_01_records.dart) statt einer Klasse: ein
// einfacher Typalias [typedef], ohne Konstruktor oder eigene Datei,
// für Daten, die nur ein schlichtes "Bündel" von Feldern sind, ohne
// zugehöriges Verhalten - genau im Geist des ursprünglichen TypeScript-
// Interface.
//
// [HINWEIS zu Feldnamen] Anders als in TypeScript/JavaScript, wo
// ein Bezeichner Buchstaben mit Akzenten enthalten darf (im ursprünglichen
// französischen Kurs durchgehend verwendet), beschränkt Dart
// Bezeichner auf ASCII-Buchstaben: Akzente sind nur in
// ZEICHENKETTEN möglich, nie im Namen einer
// Variablen, eines Felds, einer Klasse oder eines Records. Jedenfalls verwendet dieser
// Kurs überall schlichte englische ASCII-Namen (married, tax, discount...):
// Die Felder des Records unten heißen genauso wie die Map-Schlüssel von
// business.dart.
typedef Simulation = ({
String married,
int children,
num salary,
num tax,
num surcharge,
num discount,
num reduction,
num rate,
});
|
Analysieren wir diesen Code:
- Zeilen 21–24: [typedef Simulation = ({String married, int children, num salary, ...});]: Während Views.ts ein INTERFACE [Simulation] deklarierte, verwendet diese Datei ein BENANNTES Record aus Dart 3 (siehe dart3_01_records.dart) — ein einfacher Typalias ohne Konstruktor und ohne eigene Datei, für rein beschreibende Daten.
- Die Feldnamen sind schlichtes ASCII ([married], [tax], [discount]...): Dart-BEZEICHNER sind auf ASCII-Buchstaben beschränkt, anders als in TypeScript/JavaScript, wo Namen mit Akzenten wie [marié]/[impôt] (im ursprünglichen französischen Kurs verwendet) gültige Feldnamen sind.
[lib/views.dart], das auf DOM und [package:web] aufbaut:
| // views.dart
// Portiert Views.ts: Aufbau der Views (DOM) der Anwendung - Authentifizierungs-View,
// View der Steuerberechnung, View der Liste der Simulationen. Dieses
// Modul führt keinen Netzwerkaufruf aus: Es baut das DOM auf und delegiert die
// Aktionen des Benutzers an Callback-Funktionen, die vom
// Controller bereitgestellt werden (siehe app_html.dart).
//
// [technische Entscheidung] hier verwenden wir [package:web] (pub.dev/packages/web),
// den modernen Ersatz für das alte dart:html: Es stellt eine DOM-API bereit, die dem
// von Views.ts verwendeten Standard-DOM sehr nahekommt (document.createElement,
// .textContent, .addEventListener...). Ein oberflächlicher Unterschied, den man
// kennen sollte: Ein Dart-Ereignishandler (eine einfache Funktion) muss
// mit [.toJS] (Erweiterung von
// dart:js_interop) in eine JavaScript-Funktion umgewandelt werden, bevor er an [addEventListener] übergeben wird - die "Brücke"
// zwischen der Dart-Welt und der JavaScript-Welt, hier explizit gemacht, während
// TypeScript keine Umwandlung braucht (dort ist alles bereits
// JavaScript).
import 'dart:js_interop';
import 'package:web/web.dart' as web;
import 'simulation.dart';
// eine generische Dekoration (nicht das Foto des ursprünglichen PHP-Servers)
const String _logoSvg = '''
<svg width="60" height="60" viewBox="0 0 60 60" xmlns="http://www.w3.org/2000/svg">
<circle cx="30" cy="30" r="29" fill="#eef1ec" stroke="#ccc" />
<g fill="none" stroke="#8a9a7a" stroke-width="2">
<path d="M30 46 C30 32 22 28 17 19" />
<path d="M30 46 C30 30 39 26 44 17" />
<path d="M30 46 C30 37 30 30 30 21" />
</g>
<g fill="#b9c9a6">
<circle cx="17" cy="19" r="4.5" />
<circle cx="44" cy="17" r="4.5" />
<circle cx="30" cy="19" r="4.5" />
</g>
</svg>''';
// Callbacks der View [authentication] - [Unterschied zu TypeScript]
// ein TypeScript-Interface mit Callbacks lässt sich in Dart natürlich in ein
// RECORD von Funktionen übersetzen (siehe simulation.dart): leichter als eine
// Klasse, für eine einfache Gruppe von Funktionen
typedef AuthenticationCallbacks = ({void Function(String user, String password) onSubmit});
typedef CalculationCallbacks = ({
void Function(String married, int children, int salary) onSubmit,
void Function() onList,
void Function() onEndSession,
});
typedef ListCallbacks = ({
void Function(int number) onDelete,
void Function() onCalculation,
void Function() onEndSession,
});
class Views {
final web.HTMLElement root;
late web.HTMLDivElement _banner;
late web.HTMLDivElement _menu;
late web.HTMLDivElement _content;
// baut die feste Struktur der Seite auf (Banner + Menü-/Inhaltsbereich)
// innerhalb des Elements [root]
Views(this.root) {
// [WARNUNG] Anders als gewöhnliche DOM-Eigenschaften (textContent,
// value...) erwartet der Setter [innerHTML] von package:web ein [JSAny], keinen
// rohen Dart-[String] - eine Eigenheit seiner Generierung, die mit dem
// WebIDL-Attribut [LegacyNullToEmptyString] des Standard-DOM zusammenhängt: Wir
// müssen also immer mit [.toJS] umwandeln.
root.innerHTML = ''.toJS;
_banner = _div()..className = 'banner';
final logo = _div()..className = 'logo';
logo.innerHTML = _logoSvg.toJS;
final title = web.document.createElement('h1') as web.HTMLHeadingElement;
title.textContent = 'Calculate your tax';
_banner
..appendChild(logo)
..appendChild(title);
final body = _div()..className = 'page-body';
_menu = _div()..className = 'menu';
_content = _div()..className = 'content';
body
..appendChild(_menu)
..appendChild(_content);
root
..appendChild(_banner)
..appendChild(body);
}
// --------------------------------------------------------------------
// Werkzeuge zum Aufbau des DOM
// --------------------------------------------------------------------
web.HTMLDivElement _div() => web.document.createElement('div') as web.HTMLDivElement;
void _clearMenu() {
_menu.innerHTML = ''.toJS;
_menu.style.display = 'none';
_content.classList.add('full-width');
}
web.HTMLAnchorElement _menuLink(String text, void Function() onClick) {
final a = web.document.createElement('a') as web.HTMLAnchorElement;
a.textContent = text;
a.addEventListener('click', ((web.Event event) => onClick()).toJS);
return a;
}
void _showMenu(List<web.HTMLAnchorElement> links) {
_menu.innerHTML = ''.toJS;
_menu.style.display = '';
_content.classList.remove('full-width');
for (final link in links) {
_menu.appendChild(link);
}
}
web.HTMLElement? _errorBanner(String? message) {
if (message == null) return null;
final div = _div()..className = 'error';
div.textContent = message;
return div;
}
// eine Formularzeile [Label + Text-/Passwort-/Zahlenfeld]
(web.HTMLDivElement row, web.HTMLInputElement input) _fieldRow(
String labelText,
String type,
String initialValue, {
String? help,
}) {
final row = _div()..className = 'field-row';
final label = web.document.createElement('label') as web.HTMLLabelElement;
label.textContent = labelText;
final field = _div()..className = 'field';
final input = web.document.createElement('input') as web.HTMLInputElement;
input.type = type;
input.value = initialValue;
if (type == 'number') {
input.min = '0';
}
field.appendChild(input);
if (help != null) {
final div = _div()..className = 'help';
div.textContent = help;
field.appendChild(div);
}
row
..appendChild(label)
..appendChild(field);
return (row, input);
}
// --------------------------------------------------------------------
// View [authentication]
// --------------------------------------------------------------------
void authenticationView(String? error, AuthenticationCallbacks callbacks) {
_clearMenu();
_content.innerHTML = ''.toJS;
final title = _div()
..className = 'section-title'
..textContent = 'Please authenticate';
_content.appendChild(title);
final banner = _errorBanner(error);
if (banner != null) _content.appendChild(banner);
final userField = _fieldRow("Username", 'text', 'admin');
final passwordField = _fieldRow('Password', 'password', '');
_content
..appendChild(userField.$1)
..appendChild(passwordField.$1);
final button = web.document.createElement('button') as web.HTMLButtonElement;
button.textContent = 'Submit';
button.addEventListener(
'click',
((web.Event event) {
callbacks.onSubmit(userField.$2.value.trim(), passwordField.$2.value);
}).toJS,
);
_content.appendChild(button);
}
// --------------------------------------------------------------------
// View [tax calculation]
// --------------------------------------------------------------------
void calculationView(Simulation? result, String? error, CalculationCallbacks callbacks) {
_showMenu([
_menuLink('List of simulations', callbacks.onList),
_menuLink('End of session', callbacks.onEndSession),
]);
_content.innerHTML = ''.toJS;
final title = _div()
..className = 'section-title'
..textContent = 'Fill in the form below and then submit it';
_content.appendChild(title);
final banner = _errorBanner(error);
if (banner != null) _content.appendChild(banner);
// Zeile der Radiobuttons für [married]
final marriedRow = _div()..className = 'field-row';
final marriedLabel = web.document.createElement('label') as web.HTMLLabelElement;
marriedLabel.textContent = 'Are you married or in a civil partnership?';
final marriedField = _div()..className = 'field radios';
final radioYes = web.document.createElement('input') as web.HTMLInputElement;
radioYes.type = 'radio';
radioYes.name = 'married';
radioYes.value = 'yes';
radioYes.checked = true;
final labelYes = web.document.createElement('label') as web.HTMLLabelElement;
labelYes.appendChild(radioYes);
labelYes.appendChild(web.document.createTextNode(' Yes'));
final radioNo = web.document.createElement('input') as web.HTMLInputElement;
radioNo.type = 'radio';
radioNo.name = 'married';
radioNo.value = 'no';
final labelNo = web.document.createElement('label') as web.HTMLLabelElement;
labelNo.appendChild(radioNo);
labelNo.appendChild(web.document.createTextNode(' No'));
marriedField
..appendChild(labelYes)
..appendChild(labelNo);
marriedRow
..appendChild(marriedLabel)
..appendChild(marriedField);
_content.appendChild(marriedRow);
final childrenField = _fieldRow("Number of dependent children", 'number', '0');
_content.appendChild(childrenField.$1);
final salaryField = _fieldRow(
'Annual salary',
'number',
'',
help: "Round down to the nearest euro",
);
_content.appendChild(salaryField.$1);
final button = web.document.createElement('button') as web.HTMLButtonElement;
button.textContent = 'Submit';
button.addEventListener(
'click',
((web.Event event) {
final married = radioYes.checked ? 'yes' : 'no';
final children = int.tryParse(childrenField.$2.value) ?? 0;
final salary = int.tryParse(salaryField.$2.value) ?? 0;
callbacks.onSubmit(married, children, salary);
}).toJS,
);
_content.appendChild(button);
// Ergebnis der letzten Simulation (grünes Feld), falls vorhanden
if (result != null) {
final box = _div()..className = 'result';
final ratePercent = (result.rate * 100).round();
box.innerHTML = ("Tax amount: ${result.tax} euros<br>"
"Discount: ${result.discount} euros<br>"
"Reduction: ${result.reduction} euros<br>"
"Surcharge: ${result.surcharge} euros<br>"
"Tax rate: $ratePercent %")
.toJS;
_content.appendChild(box);
}
}
// --------------------------------------------------------------------
// View [list of simulations]
// --------------------------------------------------------------------
void listView(List<Simulation> simulations, String? error, ListCallbacks callbacks) {
_showMenu([
_menuLink("Tax calculation", callbacks.onCalculation),
_menuLink('End of session', callbacks.onEndSession),
]);
_content.innerHTML = ''.toJS;
final title = _div()
..className = 'section-title'
..textContent = 'List of your simulations';
_content.appendChild(title);
final banner = _errorBanner(error);
if (banner != null) _content.appendChild(banner);
if (simulations.isEmpty) {
final empty = _div()
..className = 'simulations-empty'
..textContent = 'No simulation recorded.';
_content.appendChild(empty);
return;
}
final table = web.document.createElement('table') as web.HTMLTableElement;
table.className = 'simulations';
final thead = web.document.createElement('thead') as web.HTMLTableSectionElement;
thead.innerHTML = ("<tr><th>#</th><th>Married</th><th>Number of children</th>"
"<th>Annual salary</th><th>Tax amount</th><th>Surcharge</th>"
"<th>Discount</th><th>Reduction</th><th>Rate</th><th></th></tr>")
.toJS;
table.appendChild(thead);
final tbody = web.document.createElement('tbody') as web.HTMLTableSectionElement;
for (var number = 0; number < simulations.length; number++) {
final simulation = simulations[number];
final tr = web.document.createElement('tr') as web.HTMLTableRowElement;
final ratePercent = (simulation.rate * 100).round();
tr.innerHTML = ("<td>$number</td>"
"<td>${simulation.married}</td>"
"<td>${simulation.children}</td>"
"<td>${simulation.salary}</td>"
"<td>${simulation.tax}</td>"
"<td>${simulation.surcharge}</td>"
"<td>${simulation.discount}</td>"
"<td>${simulation.reduction}</td>"
"<td>$ratePercent %</td>")
.toJS;
final tdDelete = web.document.createElement('td') as web.HTMLTableCellElement;
final deleteLink = web.document.createElement('a') as web.HTMLAnchorElement;
deleteLink.className = 'delete';
deleteLink.textContent = 'Delete';
deleteLink.addEventListener(
'click',
((web.Event event) => callbacks.onDelete(number)).toJS,
);
tdDelete.appendChild(deleteLink);
tr.appendChild(tdDelete);
tbody.appendChild(tr);
}
table.appendChild(tbody);
_content.appendChild(table);
}
}
|
Analysieren wir diesen Code:
- Zeile 19: [import 'package:web/web.dart' as web;]: der moderne Ersatz für das alte [dart:html], mit einer API und einem DOM, die dem von Views.ts verwendeten Standard-DOM sehr ähnlich sind ([document.createElement], [.textContent], [.addEventListener]...).
- Zeilen 44–45: [typedef CalculationCallbacks = ({void Function(...) onSubmit, ...});]: Ein TypeScript-Callback-Interface lässt sich in Dart 3 ganz natürlich als RECORD VON FUNKTIONEN umsetzen — leichter als eine Klasse für eine einfache Gruppe von Funktionen.
- Zeile 108: [a.addEventListener('click', ((web.Event event) { ... }).toJS);]: Ein Dart-Ereignishandler (eine einfache Funktion) muss mit [.toJS] (einer Erweiterung von [dart:js_interop]) in die JavaScript-Funktion umgewandelt werden, bevor er an [addEventListener] übergeben wird - die „Brücke“ zwischen der Dart-Welt und der JavaScript-Welt wird explizit gemacht, während TypeScript keine Konvertierung erfordert.
- Zeile 141: [input.value = initialValue;], [title.textContent = '...';] (Zeile 76): Die meisten Eigenschaften vom Typ String bleiben einfache Dart-Strings, ohne dass eine Konvertierung nötig ist. [innerHTML] ist die AUSNAHME: [dart analyze] meldet dies, wenn ihm direkt ein [String] zugewiesen wird — sein Setter erwartet ein [JSAny] (eine Besonderheit seiner Generierung im Zusammenhang mit dem WebIDL-Attribut [LegacyNullToEmptyString] des Standard-DOM) — daher [root.innerHTML = ''.toJS;]: eine zusätzliche Konvertierung mit [.toJS], die über die Funktionen allein hinausgeht und die man bei jedem Umgang mit [innerHTML] im Kopf behalten muss.
- Zeile 129: [(web.HTMLDivElement row, web.HTMLInputElement input) _fieldRow(...)]: ein positionaler RECORD als Rückgabetyp, um zwei DOM-Elemente auf einmal ohne Zwischenklasse zurückzugeben – eine weitere praktische Anwendung der Records von Dart 3.
6.5.7. Der Controller: die Datei [AppHtml.ts]
6.5.8. Skript [app_html]
| // app_html.dart
// Portiert AppHtml.ts: der Controller der HTML-Anwendung. Er orchestriert die
// Aufrufe des Servers ([dao]-Schicht, dao3.dart), die Berechnungen
// ([business]-Schicht, business.dart) und die Anzeige der Views ([views]-Schicht,
// views.dart).
//
// Wie main3.dart ruft dieser Client den NestJS-Server nur für drei
// Aktionen auf: [init-session], [authenticate-user] und [get-admindata].
// Sobald die Steuerdaten (Sätze, Obergrenzen...) mit
// [get-admindata] geholt wurden, berechnet die [business]-Schicht die Steuer im
// Browser, ohne neuen Netzwerkaufruf. Die Liste der Simulationen wird ebenfalls
// nur im Browser gehalten (Feld [simulations]),
// genau wie main3.dart es mit seiner lokalen Variablen
// [simulations] tut (`simulations.add(...)`, `simulations.removeAt(...)`).
import 'dart:js_interop';
import 'package:http/browser_client.dart';
import 'dao3.dart';
import 'business.dart';
import 'simulation.dart';
import 'views.dart';
import 'package:web/web.dart' as web;
class AppHtml {
final Dao3 dao;
final Views views;
// [business]-Schicht: existiert erst, wenn die Steuerdaten geholt wurden
// (nach erfolgreicher Authentifizierung) - siehe [_initBusiness]. Ein
// NULLBARES Feld (Business?), kein spätes Feld ([late]): Anders als in
// Views.ts, wo [business?: Business] einfach "undefined" bleibt, solange
// nichts zugewiesen wird, würde ein Dart-Feld [late] einen Fehler auslösen, wenn es
// VOR der Zuweisung GELESEN würde (genau das tut [_endSession] beim
// Zurücksetzen) - der nullbare Typ ist hier also die richtige Wahl, nicht
// bloß eine Stilfrage.
Business? _business;
// Liste der bereits berechneten Simulationen, im Browser gehalten
List<Simulation> _simulations = [];
// [Unterschied zu TypeScript] AppHtml.ts konfiguriert eine GLOBALE axios-
// Instanz (axios.defaults.timeout/baseURL/withCredentials) und übergibt sie dann
// dem Dao. Hier trägt [BrowserClient] (package:http/browser_client.dart, bereits
// in main3.dart begegnet) das Äquivalent zu
// "axios.defaults.withCredentials = true"; ein direktes
// Äquivalent eines "globalen Timeouts" gibt es bei http.Client nicht - er würde im Einzelfall
// mit `.timeout(Duration(...))` bei jedem Aufruf angewendet, wie im Kapitel
// zu [http] (dart_fetch_01.dart).
AppHtml()
: dao = Dao3(
BrowserClient()..withCredentials = true,
'http://localhost:3000',
),
views = Views(web.document.getElementById('app') as web.HTMLElement);
// Einstiegspunkt der Anwendung
Future<void> start() async {
try {
// Sitzung initialisieren - zwingend vor jeder anderen Aktion (siehe main.php)
final response = await dao.initSession() as Map<String, dynamic>;
if (response['status'] != 700) {
views.authenticationView(
_formatError(response['response']),
(onSubmit: (user, password) => _authenticate(user, password)),
);
return;
}
} catch (error) {
views.authenticationView(
"Unable to contact the server ($error)",
(onSubmit: (user, password) => _authenticate(user, password)),
);
return;
}
// Sitzung initialisiert: wir zeigen die Authentifizierung an
_showAuthentication();
}
// --------------------------------------------------------------------
// View [authentication]
// --------------------------------------------------------------------
void _showAuthentication([String? error]) {
views.authenticationView(
error,
(onSubmit: (user, password) => _authenticate(user, password)),
);
}
Future<void> _authenticate(String user, String password) async {
try {
final response = await dao.authenticateUser(user, password)
as Map<String, dynamic>;
if (response['status'] == 200) {
// erfolgreiche Authentifizierung: wie in main3.dart holen wir jetzt ein für alle Mal die
// Steuerdaten,
// die die [business]-Schicht benötigt
await _initBusiness();
} else {
// Fehlschlag (falsches Login/Passwort oder fehlende Parameter)
_showAuthentication(_formatError(response['response']));
}
} catch (error) {
_showAuthentication("Unable to contact the server ($error)");
}
}
// holt die Daten der Steuerverwaltung und instanziiert die
// [business]-Schicht mit diesen Daten - ein einziger Serveraufruf für die ganze
// Sitzung, genau wie in main3.dart
Future<void> _initBusiness() async {
try {
final response = await dao.getAdminData() as Map<String, dynamic>;
if (response['status'] == 1000) {
_business = Business(response['response'] as Map<String, dynamic>);
// neue Arbeitssitzung: wir beginnen wieder mit einer leeren Liste
_simulations = [];
_showCalculation();
} else {
_showAuthentication(_formatError(response['response']));
}
} catch (error) {
_showAuthentication("Unable to contact the server ($error)");
}
}
// --------------------------------------------------------------------
// View [tax calculation]
// --------------------------------------------------------------------
void _showCalculation([Simulation? result, String? error]) {
views.calculationView(
result,
error,
(
onSubmit: (married, children, salary) =>
_calculate(married, children, salary),
onList: () => _showList(),
onEndSession: () => _endSession(),
),
);
}
// Steuerberechnung vollständig im Browser ([business]-
// Schicht): kein Aufruf des Servers, anders als in der ersten Version
// dieses Clients (http client 1 / http client 2)
void _calculate(String married, int children, int salary) {
// _business wurde zwingend initialisiert: Wir gelangen erst nach _initBusiness zur View [calculation]
// (das [!] ist hier also sicher, wie das [!] in TypeScript
// bei [this.business!])
final result = _business!.calculateTax(married, children, salary);
// [Unterschied zu TypeScript] Views.ts baut die Simulation mit einem
// einfachen Objekt-Spread: `{ married, children, salary, ...result }`.
// Hier ist [Simulation] ein RECORD (simulation.dart), keine Map: Ein Record
// lässt sich nicht durch Spreaden einer Map "ergänzen", und
// seine Felder sind typisiert (num, int...), während
// [result], von business.dart geliefert, eine untypisierte Map ist, deren Schlüssel
// lediglich dieselben Namen HABEN ('tax', 'surcharge'..., siehe business.dart). Also
// bauen wir den Record Feld für Feld neu auf - etwas ausführlicher
// als ein Spread, aber vollständig vom Compiler geprüft (ein vergessenes
// oder falsch typisiertes Feld ist ein Kompilierfehler, keine Überraschung zur
// Laufzeit).
final Simulation simulation = (
married: married,
children: children,
salary: salary,
tax: result['tax'] as num,
surcharge: result['surcharge'] as num,
discount: result['discount'] as num,
reduction: result['reduction'] as num,
rate: result['rate'] as num,
);
// Speicherung im Browser (wie `simulations.add(...)` in
// main3.dart)
_simulations.add(simulation);
_showCalculation(simulation);
}
// --------------------------------------------------------------------
// View [list of simulations]
// --------------------------------------------------------------------
// keine Serveraufrufe mehr hier: Die Liste liegt bereits vollständig in
// [_simulations]
void _showList([String? error]) {
views.listView(
_simulations,
error,
(
onDelete: (number) => _deleteSimulation(number),
onCalculation: () => _showCalculation(),
onEndSession: () => _endSession(),
),
);
}
void _deleteSimulation(int number) {
// lokales Löschen aus [_simulations], wie
// `simulations.removeAt(number)` in main3.dart - weiterhin kein
// Serveraufruf
_simulations.removeAt(number);
_showList();
}
// --------------------------------------------------------------------
// Ende der Sitzung
// --------------------------------------------------------------------
void _endSession() {
// Ende der Sitzung nur auf Client-Seite: wir vergessen die [business]-Schicht
// (und damit die Steuerdaten) und die bereits berechneten Simulationen, dann
// kehren wir zum Authentifizierungsbildschirm zurück. Dieser Client muss dafür den Server nicht
// aufrufen.
_business = null;
_simulations = [];
_showAuthentication();
}
// --------------------------------------------------------------------
// formatiert das Feld [response] einer Fehlerantwort des Servers, das
// entweder ein String oder eine Liste von Strings ist (siehe PHP-Controller)
// --------------------------------------------------------------------
String _formatError(Object? response) {
if (response is List) {
return response.join(' ; ');
}
return '$response';
}
}
// Ausführung - [Unterschied zu TypeScript] der an addEventListener übergebene Ereignishandler
// muss mit
// [.toJS] in eine JavaScript-Funktion umgewandelt werden (siehe views.dart); das ist nur die Version
// derselben Regel für den "Einstiegspunkt".
void main() {
web.window.addEventListener(
'DOMContentLoaded',
((web.Event event) {
AppHtml().start();
}).toJS,
);
}
|
Kommentieren wir diesen Code:
- Zeilen 46–51: [AppHtml() : dao = Dao3(BrowserClient()..withCredentials = true, ...), views = Views(...)]: Konstruktion des DAO und der VIEWS in einer INITIALISIERUNGSLISTE – dasselbe Konzept wie der TypeScript-Konstruktor, aber mit der Dart-spezifischen Syntax [: field1 = ..., field2 = ...].
- Zeile 34: [Business? _business;]: ein NULLABLE-Feld, wo AppHtml.ts zuvor [business?: Business] verwendete – dasselbe Konzept („noch nicht initialisiert“), mit demselben Operator [!], um zu bestätigen, dass das Feld an einer bestimmten Stelle im Code tatsächlich gefüllt ist.
- Zeilen 158–162: [final Simulation simulation = (married: married, ..., tax: result['tax'] as num, ...);]: anders als der einfache Spread [{ married, children, salary, ...result }] in AppHtml.ts lässt sich ein RECORD nicht per Spread aus einer [Map] vervollständigen – der Record wird daher FELD FÜR FELD neu aufgebaut, was etwas ausführlicher, aber vollständig vom Compiler geprüft ist.
- Zeilen 229–233: [web.window.addEventListener('DOMContentLoaded', ((web.Event event) { AppHtml().start(); }).toJS);]: derselbe Einstiegspunkt wie in AppHtml.ts, mit derselben Callback-Konvertierung ([.toJS]) wie in views.dart.
6.5.9. Kompilierung und Ausführung
Siehe README.md in diesem Ordner: [dart pub get], gefolgt von [webdev serve] für die Entwicklung (einschließlich Hot Reloading), oder [dart compile js web/main.dart -o web/main.dart.js] für einen Produktions-Build – das Dart-Äquivalent zu [npm run build], ohne vorherige Konfigurationsschritte für einen Bundler.
Läuft der Server [webdev serve] für die Webanwendung [http client 3] noch, müssen Sie ihn beenden (Strg-C im Terminal, in dem er gestartet wurde). Öffnen Sie dann in einem Terminal im Verzeichnis [html client]:
| dart pub get
webdev serve
|
Zeile 2 startet den Webserver, der die HTML-Client-Anwendung bereitstellt:

- In [1] rufen Sie in einem Browser die URL [http://localhost:8080] auf;
- in [2-3] geben Sie die Zugangsdaten admin / admin ein;
- In [4] senden Sie die Seite ab;

- In [2] füllen Sie die Felder aus;
- In [3] senden Sie die Seite ab;

Der Steuerbetrag wird in [1] angezeigt. Führen Sie mehrere Simulationen durch und rufen Sie dann in [2] die Liste ab;

- In [1] löschen Sie eine Simulation;

- in [1] beenden Sie die Sitzung;

6.6. Fazit
Die vier Clients dieses Kapitels veranschaulichen mit Dart exakt dieselbe Entwicklung wie mit TypeScript: von der serverseitigen Verarbeitung zur clientseitigen Verarbeitung, dann vom CLI-Skript zum vollständigen Web-Client. Die wichtigsten Unterschiede sind die manuelle Verwaltung des Sitzungs-Cookies (in der CLI notwendig, im Browser überflüssig), die von [dart:js_interop] erzwungene Konvertierung [.toJS], um in den Views die Grenze zwischen Dart und JavaScript zu überbrücken, und das völlige Fehlen von Polyfills bei der Webkompilierung – ein klarer Vorteil der Dart-Toolchain gegenüber der webpack/babel-Pipeline.