2018.12.16 Ergänzung: In diesem Artikel wird es mit "Tomcat-Projekt" erstellt. Im Übrigen ist es jedoch besser, es durch "Angabe von" Maven-Archetyp-Webapp "in Maven-Projekt" zu erstellen. (Oder in einem "dynamischen Webprojekt")
Referenz
Ich weiß nicht, welche Nummer ich brauen soll, aber ich habe ein wenig an der internen Java-Einführungssitzung genagt, um sie zu überprüfen und vorzubereiten. (Außerdem frage ich mich, ob beim Ausführen einer Webanwendung + DB-Anwendung nach dem Erstellen einer kleinen Umgebung etwas zu tun ist.)
Jede Version
Heutzutage wird es unter Verwendung verschiedener Frameworks entwickelt, aber ich würde gerne sehen, welche Art von Implementierung und Verarbeitung an der primitiven Stelle erfolgt, also mache ich es hier mit einfachem JSP + Servlet.
Erstellen Sie ein Java | Tomcat-Projekt
Der Projektname lautet "memoapp"
Der Kontextname lautet (Standard) / memoapp
Dadurch wird das Projekt erstellt
Erstellen Sie eine JSP-Datei für den UI-Teil. Wählen Sie eine JSP-Datei aus dem neuen Eclipse-Menü.
Wählen Sie "WEB-INF / jsp" als Erstellungsordner (andernfalls wird es durch manuelle Eingabe erstellt). Der Dateiname ist leicht zu verstehen.
Wählen Sie "Neue JSP-Datei (HTML)" als Vorlage
Dadurch wird eine JSP-Datei erstellt
Bearbeiten Sie "
index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Memo App</title>
</head>
<body>
<h1>memo app</h1>
</body>
</html>
Erstellen Sie eine Servlet-Klasse, die den Datenaustausch mit der erstellten JSP verarbeitet.
Die Quelle zum Zeitpunkt der automatischen Generierung ist nur die Klassendefinition und es gibt keinen Konstruktor, aber doGet ()
ist wie folgt definiert. (Erstellen Sie eine Methode, die aufgerufen wird, wenn eine GET-Anforderung vorliegt.)
MemoAppMain.java
package jp.example.org;
import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/")
public class MemoAppMain extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
String view = "/WEB-INF/jsp/index.jsp";
RequestDispatcher dispatcher = req.getRequestDispatcher(view);
dispatcher.forward(req, resp);
}
}
doGet ()
liest die JSP-Datei in / WEB-INF / jsp / index.jsp
und verwendet die Vorwärtsverarbeitung, um den Inhalt der JSP im Browser anzuzeigen.
Darüber hinaus scheint es beim Bildschirmübergang von Servlet Vorwärts- und Umleitungsfunktionen zu geben: [Kennen Sie den Unterschied zwischen Umleitung und Weiterleitung: JavaTips ~ JSP / Servlet-Version- @ IT](http://www.atmarkit.co.jp/ait/ Artikel / 0407/06 / news077.html)
Wenn Sie nun Tomcat starten und "Kontextdefinition aktualisieren", sollten Sie den Inhalt der JSP sehen, wenn Sie über Ihren Browser darauf zugreifen.
Dies ist normalerweise ein HTML-Formular-Tag. Ungefähr so.
index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Memo App</title>
</head>
<body>
<h1>memo app</h1>
<form method="post">
<input type="text" name="title" size="50"/>
<br/>
<textarea rows="5" cols="80" name="memo"></textarea>
<br/>
<input type="submit"/>
</form>
</body>
</html>
Normalerweise verwendet das Formular-Tag das Attribut "action", um das Ziel der Eingabedaten zu beschreiben. Diesmal wird es jedoch weggelassen, da es für sich selbst bereitgestellt wird.
Wenn es angezeigt wird (weil es keine Dekoration gibt), sieht es so aus. (Ich möchte etwas mit Bootstrap machen ...)
Da ich die Aktion nicht in der in JSP beschriebenen Form geschrieben habe, bin ich das Post-Ziel. Mit anderen Worten, Sie können einen POST-Empfangsprozess in der bereits erstellten "MemoAppMain" -Klasse erstellen.
MemoAppMain
hat doGet ()
, um die erstellte GET-Anfrage zu verarbeiten, aber createdoPost ()
, um die POST-Anfrage auf die gleiche Weise zu verarbeiten.
Vorerst sieht es so aus
MemoAppMain.java
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
req.setCharacterEncoding("UTF-8");
System.out.println("title: " + req.getParameter("title"));
System.out.println("memo: " + req.getParameter("memo"));
// --Hier in DB speichern--
resp.sendRedirect(".");
}
Diese Methode wird aufgerufen, wenn eine POST-Anforderung vorliegt. Wie der Name schon sagt, werden POST-Parameter (HTTP-Anforderungen) im Objekt "req" festgelegt und können mit "getParameter (String)" aufgerufen werden. Der "Titel" und das "Memo" der durch diesen "getParameter (String)" angegebenen Zeichenfolge sind die Zeichenfolgen des Formularnamens des HTML-Formulars.
Im Moment greife ich nur auf die POST-Textdaten zu, daher erstelle ich einen Prozess, um diese in der Datenbank zu speichern.
setCharacterEncoding (" UTF-8 ");
ist ein Maß gegen verstümmelte Zeichen.
Referenz: Entsprechung japanischer Parameter (setCharacterEncoding) - Anforderungsinformationen abrufen - Einführung in Servlets
Wenn der Speichervorgang abgeschlossen ist, rufe ich "sendRedirect (". ")" Auf, um den Bildschirm zu mir selbst umzuleiten und neu zu laden.
Todo: Erklärt nicht, wie Tomcat startet und endet und wie die App zu diesem Zeitpunkt funktioniert.
Verwenden Sie MySQL.
Erstellen Sie einen Prozess zum Speichern der im Formular eingegebenen Daten als DB. Richten Sie zuvor JDBC ein, um DB-Vorgänge in Java-Anwendungen auszuführen.
Sie können die JDBC-Einstellungen manuell konfigurieren (den JDBC-Treiber in Ihre Anwendung einbetten), aber hier verwenden wir Maven, um ihn zu installieren.
Maven ist ... Gugu ♡
Wählen Sie im Kontextmenü des Projekts [Konfiguration] -> [In Maven-Projekt konvertieren].
Das Dialogfeld "Neues POM erstellen" wird angezeigt. Übernehmen Sie den Standardinhalt und klicken Sie auf [Fertig stellen] OK
Dadurch wird eine pom.xml-Datei (und ein Zielverzeichnis für die Ausgabe) generiert.
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>memoapp</groupId>
<artifactId>memoapp</artifactId>
<version>0.0.1-SNAPSHOT</version>
<build>
<sourceDirectory>WEB-INF/src</sourceDirectory>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source/>
<target/>
</configuration>
</plugin>
</plugins>
</build>
</project>
Wenn Sie in ein Maven-Projekt konvertieren, werden einige Einstellungen wie die JRE-Version und das Build-Ziel neu geschrieben. Korrigieren Sie sie daher.
Auf der Registerkarte [Quelle] von [Java Build Path] in den Projekteigenschaften lautet der "Standardausgabeordner" [
Wählen Sie nach dem Ändern des Standardwerts den Ausgabeordner von
Stellen Sie die Ausgabeordnereinstellung auf "Standardausgabeordner des Projekts" ein.
Wenn Sie die Einstellungen aktualisieren, werden Sie aufgefordert, das Löschen der Datei vor der Änderung zu bestätigen. Klicken Sie daher auf [Ja], um sie zu löschen.
Wenn unter "Arbeit" eine unbekannte Datei generiert wird, können Sie diese ebenfalls löschen.
Greifen Sie mit einem Browser auf das Maven-Repository zu und suchen Sie die gewünschte Datei.
Maven Repository: Search/Browse/Explore
Suchen Sie diesmal mit mysql jdbc
.
Dann wird [MySQL Connector / J] getroffen, also Open Link
https://mvnrepository.com/artifact/mysql/mysql-connector-java
Wenn Sie den Link öffnen, wird eine Liste der Versionen angezeigt. Wählen Sie daher grundsätzlich dieselbe Version wie MySQL aus. Dieses Mal verwende ich MySQL 8.0.13, wählen Sie also dieselbe Version aus.
Ein Beschreibungsbeispiel der Quelle wird am Verbindungsziel beschrieben. Veröffentlichen Sie den auf dieser Registerkarte [Maven] angezeigten Inhalt in "<Abhängigkeiten> ~ </ Abhängigkeiten>" in der Datei "pom.xml" des Projekts.
Da das Tag "
Geben Sie den auf Mavens Site angezeigten Wert im unten gezeigten Dialogfeld zur Abhängigkeitsauswahl ein und drücken Sie [OK].
Und mysql-connector-java wird hinzugefügt, also speichern Sie die Datei.
Gleichzeitig mit dem Speichern wird das Herunterladen und Erstellen der erforderlichen Dateien gestartet. Nach Abschluss des Builds werden Dateien wie "Maven-Abhängigkeit" zur Projektkonfiguration hinzugefügt.
Zu diesem Zeitpunkt sieht der Inhalt von pom.xml folgendermaßen aus
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>memoapp</groupId>
<artifactId>memoapp</artifactId>
<version>0.0.1-SNAPSHOT</version>
<build>
<sourceDirectory>WEB-INF/src</sourceDirectory>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source/>
<target/>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.13</version>
</dependency>
</dependencies>
</project>
Erstellen Sie eine Datenbank und einen Benutzer, die in der Anwendung verwendet werden sollen. Dies erfolgt unter MySQL, unabhängig von Tomcat oder Java.
C:\Users\zaki>mysql -u root -p
Enter password: ********
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 9
Server version: 8.0.13 MySQL Community Server - GPL
Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
mysql>
mysql> create database memoapp_db;
Query OK, 1 row affected (0.06 sec)
mysql> create user memoapp identified by "memoapp";
Query OK, 0 rows affected (0.13 sec)
mysql> grant all on memoapp_db.* to memoapp;
Query OK, 0 rows affected (0.03 sec)
mysql>
// --Hier in DB speichern--
Connection con = null;
Statement smt = null;
String url = "jdbc:mysql://localhost:3306/memoapp_db";
String user = "memoapp";
String pass = "memoapp";
try {
con = DriverManager.getConnection(url, user, pass);
smt = con.createStatement();
System.out.println("smt: " + smt);
} catch (SQLException e) {
e.printStackTrace();
}
finally {
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
// --DB-Verarbeitung bis hierher--
Wenn ich jetzt versuche, Daten aus dem Formular zu registrieren, tritt eine Ausnahme auf
java.sql.SQLException: No suitable driver found for jdbc:mysql://localhost:3306/memoapp_db
at java.sql.DriverManager.getConnection(DriverManager.java:689)
at java.sql.DriverManager.getConnection(DriverManager.java:247)
at jp.example.org.MemoAppMain.doPost(MemoAppMain.java:44)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:648)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:729)
:
:
Dies ist kein Problem, da auf die von Maven eingeführte JDBC-JAR-Datei zum Zeitpunkt des Aufbaus auf Eclipse verwiesen werden kann, der Pfad der JDBC-JAR-Datei jedoch bei der Ausführung mit Tomcat nicht festgelegt wird.
Wenn Sie in den Projekteigenschaften in den Projekteigenschaften die Option [SMART! Maven-Klassenpfad verwenden] im Bildschirm "Klassenpfad des Entwicklungsklassenladers" aktivieren, werden die Bibliotheken von Maven auch beim Ausführen von Tomcat referenziert ...?
Ich dachte, aber Tomcat hat einen Fehler bekommen und memoapp funktioniert nicht
Ernst: Begin event threw exception [Sa 12 01 13:38:19 JST 2018]
Ernst: Parse error in context.xml for /memoapp [Sa 12 01 13:38:19 JST 2018]
Ernst:Trat in Zeile 126, Spalte 2 auf[Sa 12 01 13:38:19 JST 2018]
Ernst:Markieren Sie diese Anwendung aufgrund eines vorherigen Fehlers als nicht verfügbar[Sa 12 01 13:38:19 JST 2018]
Ernst: One or more components marked the context as not correctly configured [Sa 12 01 13:38:19 JST 2018]
Ernst:Der Kontextstart ist aufgrund eines vorherigen Fehlers fehlgeschlagen[/memoapp] [Sa 12 01 13:38:19 JST 2018]
Wenn Sie diese Einstellung vornehmen und die Kontextdefinition aktualisieren, sieht memoapp.xml übrigens so aus
memoapp.xml
<Context path="/memoapp" reloadable="true" docBase="C:\Users\zaki\src\2018b-java-study\memoapp" workDir="C:\Users\zaki\src\java-study\memoapp\work" >
<Loader className="org.apache.catalina.loader.DevLoader" reloadable="true" debug="1" useSystemClassLoaderAsParent="false" />
</Context>
Als ich nachgeschlagen habe, habe ich einige Informationen gefunden, die "Umbenennen und Kopieren der im Tomcat-Plug-In enthaltenen Datei" DevLoader.zip "in TOMCAT_HOME / server / lib in jar".
In Eclipse Tomcat Plugin 9.13 ab Dezember 2018 ist die Datei DevLoader.zip nicht direkt enthalten, sondern in der Datei net.sf.eclipse.tomcat_9.1.3.jar
(schwer zu verstehen!)
Da es sich bei der JAR-Datei tatsächlich um eine Zip-Datei handelt, benennen Sie die Erweiterung um und erweitern Sie sie. Extrahieren Sie dann die Datei "DevloaderTomcat7.jar". Gibt es nur Tomcat7?
Als ich diese Datei tatsächlich verwendete, funktionierte sie unter Tomcat 8 nicht.
Ernst: Begin event threw error [Sa 12 01 14:48:25 JST 2018]
Ernst: ContainerBase.addChild: start: [Sa 12 01 14:48:25 JST 2018]
Ernst:Konfigurationsdeskriptor C.:\pleiades\pleiades\tomcat\8\conf\Catalina\localhost\memoapp.Fehler beim Bereitstellen von XML[Sa 12 01 14:48:25 JST 2018]
Das Tomcat-Plug-In von Eclipse enthält anscheinend keine erforderlichen Dateien. Laden Sie es daher aus dem Internet herunter.
https://sourceforge.net/projects/tomcatplugin/files/additional/ ↑ Es passiert nicht ... Also von hier aus. https://github.com/his-eg/tomcatplugin/blob/master/net.sf.eclipse.tomcat/DevLoaderTomcat8.jar
Kopieren Sie diese Datei in das lib-Verzeichnis von Tomcat. (Für Plejaden um pleiades \ tomcat \ 8 \ lib \ DevloaderTomcat7.jar
)
Dies sollte funktionieren, wenn ich Tomcat neu starte ... aber ich bekomme immer noch den gleichen Fehler
java.sql.SQLException: No suitable driver found for jdbc:mysql://localhost:3306/memoapp_db
(Stellen Sie sich vor) Dieser Fehler schlägt fehl, "DriverManager.getConnection ()", der ohne das jdbc-JAR nicht ausgeführt werden kann, da DevLoader nicht festgelegt hat, welche Klasse zum Zeitpunkt der Ausführung geladen werden soll.
Kurz zuvor können Sie das JDBC-JAR laden.
Dann machen Sie Class.forName (" com.mysql.cj.jdbc.Driver ");
// --Hier in DB speichern--
Connection con = null;
Statement smt = null;
//String url = "jdbc:mysql://localhost:3306/memoapp_db?useSSL=false&useUnicode=true&serverTimezone=UTC";
String url = "jdbc:mysql://localhost:3306/memoapp_db";
String user = "memoapp";
String pass = "memoapp";
try {
Class.forName("com.mysql.cj.jdbc.Driver");
con = DriverManager.getConnection(url, user, pass);
smt = con.createStatement();
System.out.println("smt: " + smt);
} catch (SQLException | ClassNotFoundException e) {
e.printStackTrace();
}
finally {
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
// --DB-Verarbeitung bis hierher--
Der Code des DB-Verbindungsteils sieht also so aus. Beachten Sie, dass der Klassenname des Arguments von "forName ()", das häufig im Beispielcode vorkommt, "com.mysql .__ cj __. Jdbc.Driver" lautet, da FQCN in der aktuellen Version geändert wurde (cj wurde hinzugefügt). Teru)
Außerdem musste ich den Pfad der Loader-Klasse für Entwicklungsklassen "org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER" hinzufügen.
Abgesehen davon dauerte es eine Woche, bis die DB-Verbindung abgeschlossen war ...
mysql-connector-java-8.0.13.jar
und protobuf-java-3.6.1.jar
direkt unter das Verzeichnis lib
für die Tomcat-Bibliothek kopieren. Es funktioniert ohne irgendetwas.Klicken Sie hier für eine kurze Zusammenfassung der MySQL-Operationen. [(Los und aktualisiert) MySQL / SQL-Memo](Qiita https://qiita.com/zaki-lknr/items/4d330b64e1d8cdd9ce59)
Einfach, weil es ein Beispiel ist
field | type | size | not null | comment | etc |
---|---|---|---|---|---|
memo_id | int | 11 | ✓ | ID | auto_increment |
category | int | 11 | Kategorie | ||
title | varchar | 64 | Titel | ||
memo | text | Memo | |||
create_date | datetime | Erstellungsdatum | |||
modified_date | datetime | Aktualisierungsdatum |
Erstellen von SQL zum Erstellen einer Tabelle
create table if not exists memo_data (
memo_id INT(11) auto_increment not null comment 'ID',
category INT(11) comment 'Kategorie',
title VARCHAR(64) comment 'Titel',
memo TEXT comment 'Memo',
create_date DATETIME comment 'Erstellungsdatum',
modified_date DATETIME comment 'Aktualisierungsdatum',
primary key (memo_id)
)
Java-Code zum Erstellen einer Tabelle (obwohl etwas angemessen)
con = DriverManager.getConnection(url, user, pass);
smt = con.createStatement();
System.out.println("smt: " + smt);
String create_table = "create table if not exists memo_data (" +
"memo_id INT(11) auto_increment not null comment 'ID'," +
"category INT(11) comment 'Kategorie'," +
"title VARCHAR(64) comment 'Titel'," +
"memo TEXT comment 'Memo'," +
"create_date DATETIME comment 'Erstellungsdatum'," +
"modified_date DATETIME comment 'Aktualisierungsdatum'," +
"primary key (memo_id)" + ")";
// create table
smt.executeUpdate(create_table);
Führen Sie es nun aus und die Tabelle wird erstellt
mysql> show tables;
+----------------------+
| Tables_in_memoapp_db |
+----------------------+
| memo_data |
+----------------------+
1 row in set (0.01 sec)
mysql> describe memo_data;
+---------------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+---------------+-------------+------+-----+---------+----------------+
| memo_id | int(11) | NO | PRI | NULL | auto_increment |
| category | int(11) | YES | | NULL | |
| title | varchar(64) | YES | | NULL | |
| memo | text | YES | | NULL | |
| create_date | datetime | YES | | NULL | |
| modified_date | datetime | YES | | NULL | |
+---------------+-------------+------+-----+---------+----------------+
6 rows in set (0.00 sec)
mysql>
Erstellen Sie einen Prozess zum Speichern der Formulareingabedaten, auf die durch "req.getParameter (" title ")" und "req.getParameter (" memo ")" in der Methode "doPost ()" in der Tabelle verwiesen werden kann.
String form_title = req.getParameter("title");
String form_memo = req.getParameter("memo");
Und erhalten Sie es in einer Variablen, und die INSERT-Anweisung sieht wie folgt aus.
insert into memo_data (
category, title, memo, create_date, modified_date
) values (
0,
form_title,
form_memo,
cast(now() as datetime),
cast(now() as datetime)
);
Java-Code zum Speichern von Datensätzen
con = DriverManager.getConnection(url, user, pass);
smt = con.createStatement();
String form_title = req.getParameter("title");
String form_memo = req.getParameter("memo");
System.out.println("title: " + form_title);
System.out.println("text: " + form_memo);
String insert_memo = "insert into memo_data (" +
"category, title, memo, create_date, modified_date" +
") values (" +
"0," +
"'" + form_title + "'," +
"'" + form_memo + "'," +
"cast(now() as datetime)," +
"cast(now() as datetime) " +
");";
//Datensatz speichern
smt.executeUpdate(insert_memo);
Wenn Sie nun Text über den Browser eingeben und senden, wird der Inhalt in der Datenbank gespeichert.
(Es ist schwer mit Zeilenumbrüchen zu sehen) So.
mysql> select * from memo_data;
+---------+----------+--------+----------------------------+---------------------+---------------------+
| memo_id | category | title | memo | create_date | modified_date |
+---------+----------+--------+----------------------------+---------------------+---------------------+
| 1 | 0 |Einkaufen| -Curry
-Einfach
-Niku| 2018-12-02 09:52:07 | 2018-12-02 09:52:07 |
+---------+----------+--------+----------------------------+---------------------+---------------------+
1 row in set (0.00 sec)
mysql>
Erstellen Sie einen Prozess, um die zuletzt gespeicherten Memodaten auf dem Bildschirm anzuzeigen. Da es angezeigt wird, wird der Speicherort mit "doGet ()" ausgeführt.
Die Spalte, die vorerst angezeigt werden soll
--Titel --Memo --Aktualisiert
Mit drei.
Zunächst die SELECT-Anweisung
select title, memo, modified_date from memo_data;
Im Gegensatz zum Erstellen und Einfügen erstellen Java-Quellen auch Prozesse, die Ausführungsergebnisse erhalten.
con = DriverManager.getConnection(url, user, pass);
smt = con.createStatement();
String select_memo = "select title, memo, modified_date from memo_data;";
ResultSet result = smt.executeQuery(select_memo);
while (result.next()) {
System.out.println("title: " + result.getString("title"));
System.out.println("memo: " + result.getString("memo"));
System.out.println("modify: " + result.getString("modified_date"));
}
Jetzt können Sie die Datensatzinformationen abrufen. Übergeben Sie als Nächstes die aus der Datenbank abgerufenen Memodaten an den Bildschirm (JSP).
Erstellen Sie dieses Mal einen Prozess zum Übergeben von Daten von Servlet an JSP (siehe den von Servlet in JSP empfangenen Wert).
Erstens kann das Ergebnis von "executeQuery ()" nicht verwendet werden, nachdem die Verbindung so wie sie ist geschlossen wurde. Erstellen Sie daher eine Variable zum Übergeben und kopieren Sie die Datensatzinformationen in diese.
ArrayList<HashMap<String, String>> record_list = new ArrayList<>();
//Unterlassung
ResultSet result = smt.executeQuery(select_memo);
while (result.next()) {
HashMap<String, String> record = new HashMap<>();
record.put("title", result.getString("title"));
record.put("memo", result.getString("memo"));
record.put("modified_date", result.getString("modified_date"));
record_list.add(record);
}
Um diese "record_list" an die JSP zu übergeben, setzen Sie den Wert in der Anforderungsvariablen von Servlet mit "setAtribute ()" (wie bei HashMap können Sie die Datenstruktur im Schlüsselwertformat übergeben).
req.setAttribute("record_list", record_list);
String view = "/WEB-INF/jsp/index.jsp";
RequestDispatcher dispatcher = req.getRequestDispatcher(view);
dispatcher.forward(req, resp);
Jetzt können Sie in JSP mit dem Schlüsselnamen record_list
darauf verweisen.
Der durch "setAttribute (KEY)" im Servlet festgelegte Wert kann über "request.getAttribute (KEY)" abgerufen werden.
ArrayList<HashMap<String, String>> list = (ArrayList<HashMap<String, String>>) request.getAttribute("record_list");
Nach dem Extrahieren wird es wie die normale Java-Codierung im HTML-Format ausgegeben.
Iterator<HashMap<String, String>> i = list.iterator();
while (i.hasNext()) {
HashMap map = i.next();
out.println("<hr/>");
out.println("<div>" + map.get("title") + "</div>");
out.println("<div>" + map.get("modified_date") + "</div>");
out.println("<div>" + ((String) map.get("memo")).replace("\n", "<br/>") + "</div>");
}
Ich brauche auch zuerst eine Importanweisung
<%@page import="java.util.Iterator"%>
<%@page import="java.util.ArrayList"%>
<%@page import="java.util.HashMap"%>
Die ganze Quelle sieht so aus
<%@page import="java.util.Iterator"%>
<%@page import="java.util.ArrayList"%>
<%@page import="java.util.HashMap"%>
<%@page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Memo App</title>
</head>
<body>
<h1>Memo App</h1>
<form method="post">
<input type="text" name="title" size="50" /> <br />
<textarea rows="5" cols="80" name="memo"></textarea>
<br /> <input type="submit" />
</form>
<%
ArrayList<HashMap<String, String>> list = (ArrayList<HashMap<String, String>>) request
.getAttribute("record_list");
Iterator<HashMap<String, String>> i = list.iterator();
while (i.hasNext()) {
HashMap map = i.next();
out.println("<hr/>");
out.println("<div>" + map.get("title") + "</div>");
out.println("<div>" + map.get("modified_date") + "</div>");
out.println("<div>" + ((String) map.get("memo")).replace("\n", "<br/>") + "</div>");
}
%>
</body>
</html>
Bildschirmanzeige
Ich konnte es anzeigen und speichern.
Recommended Posts