5 Brug af databaser

En overordnet forståelse af databaser forudsættes i store dele af resten af bogen. Kapitlet forudsætter kapitel 3, Interaktive sider og lidt kendskab til databaser.

5.1 Strategier til databaseadgang

I dette kapitel vil vi se på, hvordan man kommunikerer med en database fra Java og JSP.

Der er rigtig mange muligheder for, hvordan databasekommunikationen kan foregå. De fleste muligheder involverer JDBC (Java DataBase Connectivity), som bliver gennemgået i dette kapitel.

Nogle af mulighederne er:

• At bruge JDBC direkte fra JSP-siderne (som beskrevet i f.eks. dette kapitel i afsnit 5.5, Eksempel - gæstebog)

• At bruge JDBC fra Java-klasser, der så bruges fra JSP-siderne (beskrevet i det følgende, se kapitel 9, Javabønner i JSP-sider, hvordan klasser kan bruges fra JSP-sider)

• At bruge JSTLs databasefunktioner fra JSP (se afsnit 6.3, JSTL og databaser (<sql: >))

• At bruge JDBC RowSet (se afsnit 5.9, JDBC RowSet), herunder:

• Bruge CachedRowSet direkte fra JSP-sider (eller Java-klasser)

• Bruge WebRowSet til at producere XML, der derpå kan transformeres

• med XSL (XML Style Sheet - ikke beskrevet i denne bog, men se afsnit 11.1.4)

• med JSTLs XML-tags (se et eksempel i afsnit 6.4.3)

• At bruge EJB - Enterprise JavaBeans (se kapitel 12) med containerstyret persistens.

• At bruge JDO (Java Data Objects - ikke beskrevet i denne bog)

Hvilken løsning der er bedst afhænger af, hvor omfattende ens webapplikation er og hvor meget man forventer den senere skal vedligeholdes. Dette vil blive diskuteret nærmere i afsnit 10.2, Model 1 og model 2-arkitekturer.

Er du begynder og skal til at lave din første webapplikation, anbefales det, at du bruger en af de to første muligheder (JDBC enten fra JSP eller Java-klasser). Du kan så kigge på de andre muligheder på et senere tidspunkt.

5.1.1 Hvilken database skal man vælge

Det første skridt for at komme i gang med databaser er naturligvis, at installere en database, man kan kommunikere med.

Bruger du Windows og har du Microsoft Office-pakken installeret, kan du vælge at bruge Microsoft Access-databasen. Den er dog ikke særlig velegnet til større projekter. Har du adgang til en anden kommerciel database, såsom Oracle, kan du med fordel bruge den.

Her i bogen vil vi bruge MySQL, som er en meget populær database med Åben Kildekode (eng.: Open Source), der er gratis tilgængelig fra http://mysql.com.

Under Linux er den højst sandsynligt med i din distribution, så du skal blot aktivere den i kontrolpanelet, så vil den automatisk blive installeret.

Bruger du et andet styresystem (f.eks. Windows eller Mac) må du selv hente den ned fra http://mysql.com og installere den.

5.2 I gang med databaser og MySQL

Når man kommunikerer med en database, bruger man som regel sproget SQL (Structured Query Language).

5.2.1 SQL-kommandoer og forespørgsler

Det følgende viser nogle eksempler på SQL-sproget.

For at oprette en tabel kaldet kunder med to kolonner, et navn som er en tekst og en kredit som er et tal, skriver man:

CREATE TABLE kunder (navn varchar(32), kredit float);

Tabellen er tom til at starte med. For at tilføje to kunder skriver man:

INSERT INTO kunder VALUES('Jacob', -1799);
INSERT INTO kunder(navn,kredit) VALUES('Brian', 0);

Nu er der to rækker (poster) i tabellen. Da vi tilføjede 'Brian' skrev vi også kolonnenavnene (hvis man ikke kender rækkefølgen eller der måske er flere kolonner er det en god idé).

Nu ville tabellen se ud som følger:

Hele tabellen kunne udskrives med SQL-forespørgslen

SELECT * FROM kunder;

Denne forespørgsel kunne forfines, f.eks. til at fremsøge navne, hvor kreditten er negativ:

SELECT navn FROM kunder WHERE kredit > 0;

Der som svar blot giver 'Jacob'.

Man kan naturligvis også opdatere tabellen. Lad os rette i Brians kredit:

UPDATE kunder SET kredit=10 WHERE navn='Brian';

Man kan slette. Her sletter f.eks. vi rækken (eller rækkerne) hvor navnet er Jacob:

DELETE FROM kunder WHERE navn='Jacob';

Vi kunne også slette hele tabellen med:

DROP TABLE kunder;

Her er alle kommandoerne samlet:

-- Filnavn: sqleksempler.sql
-- Kan bruges fra kommandolinjen med: mysql test < sqleksempler.sql

CREATE TABLE kunder (navn varchar(32), kredit float); -- opret tabel
INSERT INTO kunder VALUES('Jacob', -1799);          -- indsæt række
INSERT INTO kunder(navn,kredit) VALUES('Brian', 0); -- do, med navngivne kolonner
UPDATE kunder SET kredit=10 WHERE navn='Brian';     -- sæt Brians kredit til 10 kr
DELETE FROM kunder WHERE navn='Jacob';              -- slet række om Jacob
SELECT * FROM kunder;                               -- vis hele tabellen
DROP TABLE kunder;                                  -- slet tabellen igen

5.2.2 Administrere databasen fra kommandolinjen

Efter at MySQL er blevet installeret, skal den startes op. Det kan enten gøres ved at installere den som en tjeneste, der startes automatisk, når computeres starter op eller ved at starte programmet 'mysqld' manuelt (som superbruger).

Når MySQL installeres, opretter den som standard en tom database med navnet 'test', der kan tilgås af alle brugere.

Somme tider kan det være nødvendigt at arbejde med databasen fra kommandolinjen, måske fordi man ikke har adgang til en grafisk brugergrænseflade.

Man kan logge på test-databasen med kommandoen

  mysql test

Her er et fuldt eksempel på, hvordan kommunikation med MySQL fra kommandolinjen kunne se ud. Det brugeren skriver er i fed:

$> mysql test
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 7 to server version: 4.0.15

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> CREATE TABLE kunder (navn varchar(32), kredit float);
Query OK, 0 rows affected (0.32 sec)

mysql> INSERT INTO kunder VALUES('Jacob', -1799);
Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO kunder(navn,kredit) VALUES('Brian', 0);
Query OK, 1 row affected (0.00 sec)

mysql> UPDATE kunder SET kredit=10 WHERE navn='Brian';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT * FROM kunder;
+-------+--------+
| navn  | kredit |
+-------+--------+
| Jacob |  -1799 |
| Brian |     10 |
+-------+--------+
2 rows in set (0.00 sec)

mysql> show tables;
+-----------------+
| Tables_in_test  |
+-----------------+
| kunder          |
+-----------------+
1 rows in set (0.00 sec)

mysql> exit
Bye

Sammenlign med afsnit 5.2.1, SQL-kommandoer og forespørgsler. Se også MySQL-manualen (http://mysql.com/doc/ under ' Tutorial') for en introduktion til SQL og MySQL.

Brugere i databasen

Som udgangspunkt findes databasebrugeren '' (intet brugernavn) og brugeren 'root' i MySQL. Begge brugere kan kun logge på fra den lokale maskine uden adgangskode.

Ovenfor har vi brugt brugeren med et tomt brugernavn, der kun kan se databasen 'test' og ikke kan oprette nye databaser.

Ønsker man at bruge en anden databasebruger og/eller adgangskode skriver man:

  mysql -u brugernavn -p

og indtaster adgangskoden (-p angiver at adgangskoden skal læses fra tastaturet). For en bruger uden adgangskode, f.eks. bruger 'root' skriver man:

  mysql -u root

Oprette en database

Ønsker man at oprette en anden database kan det gøres fra kommandolinjen med:

  mysqladmin -u root create jspdb

Nu er databasen 'jspdb' oprettet. Derefter kan man gå ind i den med:

  mysql -u root jspdb

5.2.3 Administrere databasen med MySQLCC

Fra MySQL.com kan man også hente MySQL Control Center (MySQLCC), som kan hjælpe med at administrere ens database, herunder oprette og ændre i databaser og tabeller samt selvfølgelig indsætte, slette og søge i tabellerne:

MySQLCC findes til Linux og Windows. Herover er det vist under Linux.

Værktøjet er meget pædagogisk, idet man kan vælge at få vist præcist hvilke SQL-kommandoer, der udføres (nederst på billedet). Dette kan man så bruge til selv at lære SQL.

5.2.4 Administrere fra et udviklingsværktøj

De fleste udviklingsværktøjer har mere eller mindre sofistikerede SQL-værktøjer.

En af de mest raffinerede er Oracle JDeveloper, der lader en designe tabellerne visuelt:

... og senere hen vise (og, hvis det er en Oracle-database, også redigere) tabellen:

5.3 Kontakt til database fra Java (JDBC)

Adgang til en database fra Java sker gennem et sæt klasser, der under et kaldes JDBC (Java DataBase Connectivity). Disse klasser ligger i pakken java.sql.

JSP-sider, der arbejder med databaser skal derfor importere denne pakke i starten:

<%@ page language="java" import="java.sql.*" %>

Tilsvarende skal der i starten af Java-filer, der arbejder med databaser, stå:

import java.sql.*;

At få kontakt til en database fra Java kræver to skridt:

1. Indlæse databasedriveren

2. Etablere forbindelsen

Indlæsning af driveren sker, ved at bede systemet indlæse den pågældende klasse, der derefter registrerer sig selv i JDBC-systemets driver-manager.

Ofte skal man have en JAR-fil (et Java-ARkiv, en samling klasser pakket i ZIP-formatet) med en driver fra producenten. På http://java.sun.com/jdbc kan man finde over 200 drivere til forskellige databaser.

5.3.1 Kontakt gennem ODBC under Windows

Med Java under Windows følger en standard JDBC-ODBC-bro med, så man kan kontakte alle datakilder defineret under ODBC. Denne driver indlæses med:

  Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

Når forbindelsen oprettes, angiver man den ønskede datakildes navn.

  Connection con = DriverManager.getConnection("jdbc:odbc:datakilde1");

Husk, at datakildens navn (her "datakilde1") først skal være defineret i Windows' Kontrolpanel under ODBC. Datakilden kan være en fil, f.eks. en Microsoft Access-fil (.mdb) eller en rigtig database.

Bemærk, at ODBC er en ret langsom protokol, der ikke understøtter ret mange af de mere avancerede ting. Har du brug for bedre ydelse bør du finde en driver, der kommunikerer direkte med databasen/filen, i stedet for at bruge JDBC-ODBC.

5.3.2 Kontakt til MySQL-database

På http://mysql.com kan hentes en JDBC-driver til MySQL (kaldet Connector/J).

Driver-filen hedder typisk noget a la mysql-connector-java-3.0.9-bin.jar. Den skal ligge i CLASSPATH eller kopieres over i mappen java/jre/lib/ext/ så Java kender til driveren¹.

I kildeteksten skriver man:

Class.forName("com.mysql.jdbc.Driver");
Connection con = DriverManager.getConnection("jdbc:mysql:///test");

hvorefter man skulle have kontakt til databasen 'test' på den lokale maskine (følger som standard med i MySQL), som anonym bruger.

Ønsker man at bruge en anden database, som en anden bruger, skriver man f.eks.:

Connection con = DriverManager.getConnection("jdbc:mysql:///jspdb","j","hemli");

hvorefter man skulle have oprettet forbindelsen til databasen 'jspdb' på den lokale maskine med brugernavn 'j' og adgangskode 'hemli'.

5.3.3 Kontakt til en Oracle-database

Ønsker man kontakt til en Oracle-database skriver man:

  Class.forName("oracle.jdbc.driver.OracleDriver");

Driver-filen hedder classes12.zip og passer til en bestemt udgave af Oracle-databasen. Den skal ligge i CLASSPATH eller kopieres over i mappen java/jre/lib/ext/ så Java kender driveren.

Herefter kan man oprette forbindelsen med f.eks.:

  Connection con = DriverManager.getConnection(
    "jdbc:oracle:thin:@ora.javabog.dk:1521:student","j","hemli");

Første parameter er en URL til databasen. Den består af en protokol (jdbc), underprotokol (oracle) og noget mere, der afhænger af underprotokollen. I dette tilfælde angiver det, at databasen ligger på maskinen ora.javabog.dk port 1521 og hedder student. Anden og tredje parameter er brugernavn og adgangskode.

5.4 Kommunikation med database fra Java

Når vi har en forbindelse, kan vi oprette et "statement"-objekt, som vi kan sende kommandoer og forespørgsler til databasen med:

  Statement stmt = con.createStatement();

Der kan opstå forskellige undtagelser af typen SQLException, der skal håndteres.

For at opnå 'hul igennem' er det ofte en god idé at tage ét skridt ad gangen. Eksemplerne i det følgende er derfor skrevet som almindelige Java-klasser med en main()-metode, sådan at man kan prøve dem fra kommandolinjen eller i et udviklingsværktøj, uden for webserveren.

På http://java.sun.com/docs/books/tutorial/jdbc/ kan du få yderligere information om JDBC og databasekommunikation fra Java.

5.4.1 SQL-kommandoer og forespørgsler fra Java

SQL-kommandoer, der ikke giver et svar tilbage i form af data, såsom INSERT, UPDATE, DELETE, CREATE TABLE og DROP TABLE, sendes med executeUpdate()-metoden.

Her opretter vi f.eks. tabellen "kunder" og indsætter et par rækker med en database defineret som 'datakilde1' i Windows' ODBC-kontrolpanel.

import java.sql.*;
public class TestDatabaseforbindelseODBC
{
  public static void main(String[] arg) throws Exception
  {
    Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
    Connection con = DriverManager.getConnection("jdbc:odbc:datakilde1");
    Statement stmt = con.createStatement();

    stmt.executeUpdate("CREATE TABLE kunder (navn varchar(32), kredit float)" );
    stmt.executeUpdate("INSERT INTO kunder VALUES('Jacob', -1799)");
    stmt.executeUpdate("INSERT INTO kunder (navn,kredit) VALUES('Brian', 0)");
  }
}

Tilsvarende med en MySQL-database:

import java.sql.*;
public class TestDatabaseforbindelseMySQL
{
  public static void main(String[] arg) throws Exception
  {
    Class.forName("com.mysql.jdbc.Driver");
    Connection con = DriverManager.getConnection("jdbc:mysql:///test");
    Statement stmt = con.createStatement();

    stmt.executeUpdate("CREATE TABLE kunder (navn varchar(32), kredit float)" );
    stmt.executeUpdate("INSERT INTO kunder VALUES('Jacob', -1799)");
    stmt.executeUpdate("INSERT INTO kunder(navn,kredit) VALUES('Brian', 0)");
  }
}

Forespørgsler

SQL-forespørgslen SELECT udføres med metoden executeQuery():

  ResultSet rs;
  rs = stmt.executeQuery("SELECT navn, kredit FROM kunder WHERE navn='Jacob'");

Den giver et ResultSet-objekt, der repræsenterer svaret på forespørgslen (for at få alle kolonner kunne vi også skrive "SELECT * FROM kunder").

Data hentes fra ResultSet-objektet således:

  while (rs.next())
  {
    String navn = rs.getString("navn");
    double kredit = rs.getDouble("kredit");
    System.out.println(navn+" "+kredit);
  }

Man kalder altså next() for at få næste række i svaret, læser de enkelte celler ud fra kolonnenavnene (eller kolonnenumrene, regnet fra 1 af), hvorefter man går videre til næste række med next() osv. Når next() returnerer false, er der ikke flere rækker at læse.

SQL med data fra variabler

Ofte er data gemt i variabler og kommer fra brugeren f.eks. fra request-objektet:

    String navn = request.getParameter("navn");

Så må man sætte en streng sammen, der giver den ønskede SQL-kommando:

    int kredit = 500;

    // indsæt data fra variablerne navn og kredit
    stmt.executeUpdate("INSERT INTO kunder VALUES('"+navn+"', "+kredit+")");

Her ville den resulterende streng blive (hvis variablen navn indeholdt værdien "Hans") "INSERT INTO kunder VALUES('Hans', 500)" og databasen ville indsætte denne række.

På fuldstændig samme måde som med SQL-kommandoer, kan SQL-forespørgsler laves, ved at sætte en passende SQL-streng sammen ud fra en variabel:

  rs = stmt.executeQuery("SELECT navn, kredit FROM kunder WHERE navn='"+navn+"'");

Vær dog opmærksom på ikke, at introducere nogle sikkerhedsproblemer. I længden er det bedre at bruge på forhånd forberedt SQL, i stedet for at stykke en streng sammen med SQL-kommandoen.

5.4.2 På forhånd forberedt SQL

I koden vist ovenfor er der nogle problemer:

1. Ved hvert kald bruges noget tid på at sætte en SQL-streng sammen, som databasen derefter skal fortolke for at udføre SQL-kommandoen.

2. Hvis navnet indeholder et ' går SQL-kommandoen galt. F.eks. hvis navn havde værdien "Hans' venner" ville SQL-strengen blive:
   "INSERT INTO kunder VALUES('Hans' venner', 500)"
   som er ugyldig fordi den indeholder tre '-er.

3. Endnu værre er det med sikkerheden. Det er nemlig muligt at injicere SQL (eng.: SQL injection): Hvis brugeren er så smart, at han angiver et meget specielt navn, f.eks. navn="Hans', 1000000) --". Da vil SQL-strengen blive:
   "INSERT INTO kunder VALUES('Hans', 1000000) --', 500)"
   som er gyldigt SQL (-- angiver at resten af linjen er en kommentar). På den måde kunne brugeren oprette sig selv i databasen med vilkårligt store summer i kredit!
   Se afsnit 8.5 for en generel diskussion af sikkerhed.

I stedet for at oprette en SQL-kommandolinje med createStatement(), bør man derfor bruge metoden prepareStatement(), hvor man angiver SQL-kommandoen én gang og derefter kan udføre kommandoen med forskellige data mange gange.

I SQL-kommandoen skrives så et ?-tegn for hver stump data, der kan variere. Før hvert kald sættes data med en set-metode og nummeret på stumpen (regnet fra og med 1):

import java.sql.*;
public class ForberedtSQL
{
  public static void main(String[] arg) throws Exception
  {
    Class.forName("com.mysql.jdbc.Driver");
    Connection con = DriverManager.getConnection("jdbc:mysql:///test");

    // Forbered kommandoerne til databasen, f.eks. i starten af programmet:

    PreparedStatement indsætPstm = con.prepareStatement(
                                "INSERT INTO kunder (navn,kredit) VALUES(?, ?)");

    PreparedStatement hentPstm = con.prepareStatement(
                                "SELECT navn, kredit FROM kunder WHERE navn=?");

    // under programudførelsen kan de forberedte kommandoer udføres mange gange:
    for (int i=0; i<100; i++) 
    {
      indsætPstm.setString(1, "Brian");
      indsætPstm.setInt(2, i);
      indsætPstm.execute();

      indsætPstm.setString(1, "Hans' venner");  // bemærk ' i strengen
      indsætPstm.setInt(2, 1042+i);
      indsætPstm.execute();


      hentPstm.setString(1, "Hans' venner");    // bemærk ' i SQL-forespørgslen
      ResultSet rs = hentPstm.executeQuery();

      // man løber igennem svaret som man plejer
      while (rs.next())
      {
        String navn = rs.getString(1);
        double kredit = rs.getDouble(2);
        System.out.println(navn+" "+kredit);
      }
    }
  }
}

Øvelse

Skriv ovenstående program om, til at bruge et almindeligt statement-objekt. Hvor stor er forskellen i udførelseshastighed (fjern kaldet til System.out.println() for at få en klar måling)?

Om optimering

Ovenstående forbedrer ganske vist ydelsen en del (afhængig af JDBC-driveren), men det vigtigste er, at ' i strengene håndteres, den øgede sikkerhed og (efter forfatterens smag) den øgede overskuelighed.

Læs mere om optimering i afsnit 5.8.

5.5 Eksempel - gæstebog

Et eksempel på databasekommunikation kunne være en gæstebog, hvor brugerne kan se alle andre brugere og hvad de har skrevet ind.

5.5.1 Oprette tabellen i databasen

Først skal tabellen i databasen oprettes. Hver række har en unik id, navnet på brugeren, beskedens tekst og datoen hvor beskeden blev oprettet. IP-adressen bliver af sikkerhedshensyn også noteret. Her er SQL-koden til at oprette tabellen:

-- Filnavn: gaestebogsoprettelse.sql
-- Kan bruges fra kommandolinjen med: mysql test < gaestebogsoprettelse.sql

CREATE TABLE gaestebog (
  id      int  not null  primary key  auto_increment,
  navn    varchar(20),
  besked  varchar(255),
  dato    datetime,
  ip      varchar(16)
);

Denne SQL kan udføres som beskrevet i afsnit 5.2.2, Administrere databasen fra kommandolinjen, eller man kan lave et lille program, der opretter tabellen:

import java.sql.*;
public class Gaestebogsoprettelse
{
  public static void main(String[] arg) throws Exception
  {
    Class.forName("com.mysql.jdbc.Driver");
    Connection con = DriverManager.getConnection("jdbc:mysql:///test");

    Statement stmt = con.createStatement();

    stmt.executeUpdate(
      "CREATE TABLE gaestebog ("
      +"id      int  not null  primary key  auto_increment,"
      +"navn    varchar(20),"
      +"besked  varchar(255),"
      +"dato    datetime),"
      +"ip      varchar(16)");
  }
}

5.5.2 Visning af gæstebogen (gaestebog.jsp)

Her er siden, der viser gæstebogen:

gaestebog.jsp

<%@ page language="java" import="java.sql.*" %>
<html>
<head><title>Gæstebog</title></head>
<body>

<h1>Gæstebog</h1>
Velkommen til min lille gæstebog.<br>
Du kan skrive dig ind <a href="indskriv_i_gaestebog.jsp">her</a>.

<%
  // Udskriv gæstebogen
  Class.forName("com.mysql.jdbc.Driver");
  Connection con = DriverManager.getConnection("jdbc:mysql:///test");
  Statement stmt = con.createStatement();
  ResultSet rs = stmt.executeQuery("SELECT navn, besked, dato FROM gaestebog");

  while(rs.next()) {
    %>
    <hr>
      <%= rs.getString("navn") %> skrev den <%= rs.getDate("dato") %> 
      det følgende indlæg:<br>
      <%= rs.getString("besked") %>
    <p>
    <%
  } // slut på while-løkke

  // oprydning
  rs.close();
  stmt.close();
  con.close();
%>
</body>
</html>

5.5.3 Indskrivning (indskriv_i_gaestebog.jsp)

Vælger brugeren at indskrive sig, kommer han til følgende side:

indskriv_i_gaestebog.jsp

<%@ page language="java" import="java.sql.*" %>
<html>
<head><title>Indskriv i gæstebog</title></head>
<body>

<h1>Skriv dig ind i min gæstebog</h1>

<form>           <img src="../kapitel_02/billede_med_avatar.jsp" align="right">
Navn: <br>
<input type="text" name="navn" size=20><br>
Besked: <br>
<textarea name="besked" width="50" height="10"></textarea><br>
<input type="submit" value="OK">
</form>

<%
  // Se om der kommer nogen data fra formularen
  String navn = request.getParameter("navn");
  String besked = request.getParameter("besked");

  if (navn != null && besked != null)
  {
    // OK, vi har fået en indtastning. Tjek om brugeren reelt har tastet noget.
    if (navn.length() < 3 || besked.length() < 3)
    {
      out.write("Indtast venligst dit fulde navn og en besked.");
    } 
    else 
    {
      // OK, beskedden er gyldig. Indsæt den i databasen
      Class.forName("com.mysql.jdbc.Driver");
      Connection con = DriverManager.getConnection("jdbc:mysql:///test");

      PreparedStatement pstmt = con.prepareStatement(
        "INSERT INTO gaestebog (navn, besked, dato, ip) VALUES(?,?,?,?)");
      pstmt.setString(1, navn);
      pstmt.setString(2, besked);
      pstmt.setDate(3, new java.sql.Date(System.currentTimeMillis()));
      pstmt.setString(4, request.getRemoteAddr());
      pstmt.executeUpdate();  
      pstmt.close();
      con.close();

      // alt gik godt. Send brugeren tilbage til gæstebogen
      response.sendRedirect("gaestebog.jsp");
    }
  }
%>
</body>
</html>

5.6 Test dig selv

5.7 Resumé

5.8 Avanceret: Optimering

5.8.1 Bruge den rigtige databasedriver

5.8.2 På forhånd forberedt SQL

5.8.3 Lægge opdateringer i kø (batch)

5.8.4 Lægge 'stored procedures' i databasen

5.8.5 Forbindelsespuljer (Connection pooling)

5.8.6 Metadata

5.8.7 Eksempel: Webgrænseflade til database

5.9 Avanceret: JDBC RowSet

5.9.1 JdbcRowSet

5.9.2 CachedRowSet

5.9.3 FilteredRowSet og JoinRowSet

5.9.4 WebRowSet

5.9.5 Mere information