Supplément 2018.12.16: Dans cet article, il est créé en utilisant "Tomcat project", mais compte tenu du reste, il est préférable de le créer en "spécifiant maven-archetype-webapp
dans le projet Maven". (Ou dans un "projet web dynamique")
référence
Je ne sais pas quel numéro préparer, mais j'ai rongé un peu lors de la session d'étude d'introduction à Java en interne, donc pour examen et préparation. (Aussi, je me demande s'il y a quelque chose à faire lors de l'exécution d'une application Web + application DB après avoir créé un petit environnement)
Chaque version
De nos jours, il est développé à l'aide de divers frameworks, mais j'aimerais voir quel type d'implémentation et de traitement est effectué à la place primitive, alors je le fais ici avec JSP + Servlet.
Créer Java | Tomcat Project
Le nom du projet est memoapp
Le nom du contexte est (par défaut) / memoapp
Cela créera le projet
Créez un fichier JSP pour la partie UI. Sélectionnez un fichier JSP dans le nouveau menu Eclipse.
Sélectionnez WEB-INF / jsp
comme dossier de création (sinon il sera créé en l'entrant manuellement)
Le nom du fichier est facile à comprendre.
Sélectionnez "Nouveau fichier JSP (html)" comme modèle
Cela créera un fichier JSP
Modifiez «
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>
Créez une classe de servlet qui traite l'échange de données avec la JSP créée.
La source au moment de la génération automatique est seulement la définition de classe et il n'y a pas de constructeur, mais doGet ()
est défini comme suit. (Créez une méthode appelée lorsqu'il y a une requête GET)
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 ()
lit le fichier JSP dans / WEB-INF / jsp / index.jsp
et utilise le traitement en avant pour afficher le contenu de la JSP sur le navigateur.
De plus, il semble qu'il y ait des transferts en avant et en redirection dans la transition d'écran de Servlet: [Connaître la différence entre redirection et transfert: JavaTips ~ JSP / Version Servlet- @ IT](http://www.atmarkit.co.jp/ait/ articles / 0407/06 / news077.html)
Maintenant, lorsque vous démarrez Tomcat et "Mettre à jour la définition du contexte", vous devriez voir le contenu de la JSP lorsque vous y accédez depuis votre navigateur.
Il s'agit généralement d'une balise de formulaire html. À peu près comme ça.
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>
Normalement, la balise form utilise l'attribut ʻaction` pour décrire la destination des données d'entrée, mais cette fois, il est omis car il est fait pour se poster.
Lorsqu'il est affiché (car il n'y a pas de décoration), il ressemble à ceci. (Je veux faire quelque chose avec Bootstrap ...)
Comme je n'ai pas écrit l'action sous la forme décrite dans JSP, la destination de la publication est moi-même.
En d'autres termes, vous pouvez créer un processus de réception POST dans la classe MemoAppMain
déjà créée.
MemoAppMain
a doGet ()
pour gérer la requête GET créée, mais createdoPost ()
pour gérer la requête POST de la même manière.
Pour le moment, ça ressemble à ça
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"));
// --Enregistrer dans DB ici--
resp.sendRedirect(".");
}
Cette méthode est appelée lorsqu'il y a une requête POST.
Comme son nom l'indique, les paramètres POST (requêtes HTTP) sont définis dans l'objet req
et sont accessibles avec getParameter (String)
.
Le "titre" et le "mémo" de la chaîne de caractères spécifiée par ce getParameter (String)
sont les chaînes de caractères du nom de formulaire du formulaire html.
Pour le moment, j'accède uniquement aux données texte POSTÉES, je vais donc créer un processus pour enregistrer cela dans la base de données.
setCharacterEncoding (" UTF-8 ");
est une mesure contre les caractères déformés.
Référence: Correspondance des paramètres japonais (setCharacterEncoding) --Obtenir des informations sur la requête --Introduction aux servlets
Lorsque le processus de sauvegarde est terminé, j'appelle sendRedirect (". ");
Pour rediriger l'écran vers moi et le recharger.
Todo: n'explique pas comment Tomcat démarre et se termine et comment l'application fonctionne à ce stade.
Utilisez MySQL.
Créez un processus pour enregistrer les données saisies dans le formulaire en tant que DB. Avant cela, configurez d'abord JDBC pour effectuer des opérations de base de données à partir d'applications Java.
Vous pouvez configurer manuellement le JDBC (pilote JDBC intégré à l'application), mais ici nous utiliserons Maven pour l'installer.
Maven est ... Gugu ♡
Sélectionnez [Configuration] -> [Convertir en projet Maven] dans le menu contextuel du projet.
La boîte de dialogue Créer un nouveau POM s'affiche. Laissez le contenu par défaut et cliquez sur [Terminer] OK
Cela générera un fichier pom.xml (et un répertoire target
pour la sortie).
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>
De plus, si vous convertissez en projet Maven, certains paramètres tels que la version JRE et la destination de construction seront réécrits, donc corrigez-le.
Dans l'onglet [Source] de [Java Build Path] dans les propriétés du projet, le "Dossier de sortie par défaut" est [
Après avoir changé la valeur par défaut, sélectionnez le dossier de sortie de <nom_projet> / WEB-INF / src dans la liste de [Dossier source sur le chemin de construction] et appuyez sur [Modifier].
Définissez le paramètre du dossier de sortie sur "Dossier de sortie par défaut du projet"
Lorsque vous mettez à jour les paramètres, il vous sera demandé de confirmer la suppression du fichier avant la modification, cliquez donc sur [Oui] pour le supprimer.
Si un fichier inconnu est généré sous work
, vous pouvez également le supprimer.
Accédez au référentiel Maven avec un navigateur et trouvez le fichier dont vous avez besoin.
Maven Repository: Search/Browse/Explore
Cette fois, recherchez avec mysql jdbc
.
Ensuite, [MySQL Connector / J] sera frappé, donc Open Link
https://mvnrepository.com/artifact/mysql/mysql-connector-java
Lorsque vous ouvrez le lien, une liste de versions sera affichée, donc sélectionnez fondamentalement la même version que MySQL. Cette fois, j'utilise MySQL 8.0.13, alors sélectionnez la même version.
Un exemple de description de la source est décrit à la destination du lien. Publiez le contenu affiché sur cet onglet [Maven] dans <dependencies> ~ </ dependencies>
dans le fichier pom.xml
du projet.
Cependant, comme la balise <dependencies>
n'existe pas dans l'état initial, comme immédiatement après la conversion en projet Maven, entrez-la dans l'interface utilisateur à partir de l'onglet dépendances (soit manuellement).
Entrez la valeur affichée sur le site de Maven dans la boîte de dialogue de sélection des dépendances comme indiqué ci-dessous et appuyez sur [OK].
Et mysql-connector-java sera ajouté, donc enregistrez le fichier.
En même temps que l'enregistrement, le téléchargement et la construction des fichiers nécessaires sont lancés, et lorsque la construction est terminée, des fichiers tels que «Dépendance Maven» sont ajoutés à la configuration du projet.
À ce stade, le contenu de pom.xml ressemble à ceci
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>
Créez une base de données et un utilisateur à utiliser dans l'application. Cela se fait sur MySQL, indépendamment de Tomcat ou 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>
// --Enregistrer dans DB ici--
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();
}
}
// --Traitement DB jusqu'à ici--
Maintenant, lorsque j'essaie d'enregistrer des données à partir d'un formulaire, une exception se produit
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)
:
:
Ce n'est pas un problème car le fichier jar JDBC introduit par Maven peut être référencé au moment de la construction sur Eclipse, mais le chemin du fichier jar JDBC n'est pas défini lors de l'exécution avec Tomcat.
Si vous cochez [Utiliser le chemin de classe SMART! Maven] sur l'écran "Chemin de classe du chargeur de classe de développement" des paramètres Tomcat dans les propriétés du projet, les bibliothèques de Maven seront également référencées lors de l'exécution de Tomcat ...?
J'ai pensé, mais Tomcat a eu une erreur et memoapp ne fonctionne pas
Sérieux: Begin event threw exception [Sam 12 01 13:38:19 JST 2018]
Sérieux: Parse error in context.xml for /memoapp [Sam 12 01 13:38:19 JST 2018]
Sérieux:Survenu à la ligne 126, colonne 2[Sam 12 01 13:38:19 JST 2018]
Sérieux:Marquer cette application comme indisponible en raison d'une erreur précédente[Sam 12 01 13:38:19 JST 2018]
Sérieux: One or more components marked the context as not correctly configured [Sam 12 01 13:38:19 JST 2018]
Sérieux:Le lancement du contexte a échoué en raison d'une erreur précédente[/memoapp] [Sam 12 01 13:38:19 JST 2018]
À propos, si vous définissez ce paramètre et mettez à jour la définition de contexte, memoapp.xml ressemble à ceci
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>
Quand je l'ai recherché, j'ai trouvé des informations qui "Renommez et copiez le fichier DevLoader.zip
inclus dans le plug-in Tomcat dans TOMCAT_HOME / server / lib dans jar.
Dans Eclipse Tomcat Plugin 9.13 à partir de décembre 2018, le fichier DevLoader.zip n'est pas inclus directement, mais dans le fichier net.sf.eclipse.tomcat_9.1.3.jar
(difficile à comprendre!)
Puisque le fichier jar est en fait un zip, renommez l'extension et développez-la, puis extrayez le DevloaderTomcat7.jar
à l'intérieur ... ça? N'y a-t-il que Tomcat7?
Lorsque j'ai utilisé ce fichier, cela ne fonctionnait pas sur Tomcat 8.
Sérieux: Begin event threw error [Sam 12 01 14:48:25 JST 2018]
Sérieux: ContainerBase.addChild: start: [Sam 12 01 14:48:25 JST 2018]
Sérieux:Descripteur de configuration C:\pleiades\pleiades\tomcat\8\conf\Catalina\localhost\memoapp.Erreur lors du déploiement de xml[Sam 12 01 14:48:25 JST 2018]
Il semble n'y avoir aucun fichier requis dans le plug-in Tomcat d'Eclipse, alors téléchargez-le sur le net.
https://sourceforge.net/projects/tomcatplugin/files/additional/ ↑ Cela n'arrive pas ... Donc d'ici. https://github.com/his-eg/tomcatplugin/blob/master/net.sf.eclipse.tomcat/DevLoaderTomcat8.jar
Copiez ce fichier dans le répertoire lib de Tomcat. (Pour les Pléiades, autour de pleiades \ tomcat \ 8 \ lib \ DevloaderTomcat7.jar
)
Cela devrait fonctionner si je redémarre Tomcat ... mais j'obtiens toujours la même erreur
java.sql.SQLException: No suitable driver found for jdbc:mysql://localhost:3306/memoapp_db
(Imaginez) Cette erreur échoue DriverManager.getConnection ()
qui ne peut pas être exécuté sans le jdbc jar car DevLoader n'a pas déterminé la classe à charger au moment de l'exécution.
Donc juste avant cela, vous pouvez charger le fichier jdbc.
Puis faites Class.forName (" com.mysql.cj.jdbc.Driver ");
// --Enregistrer dans DB ici--
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();
}
}
// --Traitement DB jusqu'à ici--
Le code de la partie connexion à la base de données ressemble donc à ceci.
Notez que le nom de classe de l'argument de forName ()
qui apparaît souvent dans l'exemple de code est "com.mysql .__ cj __. Jdbc.Driver" car FQCN a été modifié dans la version actuelle (cj a été ajouté). Teru)
J'ai également dû ajouter le chemin de classe du chargeur de classe de développement, ʻorg.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER`.
En passant, il a fallu une semaine pour atteindre l'achèvement de la connexion à la base de données ...
mysql-connector-java-8.0.13.jar
et protobuf-java-3.6.1.jar
directement sous le répertoire lib
de la bibliothèque Tomcat, les paramètres du côté Eclipse seront modifiés. Cela fonctionne sans rien.Cliquez ici pour un bref résumé des opérations MySQL. [(Loose and updated) MySQL / SQL mémo](Qiita https://qiita.com/zaki-lknr/items/4d330b64e1d8cdd9ce59)
Simple car c'est un échantillon
field | type | size | not null | comment | etc |
---|---|---|---|---|---|
memo_id | int | 11 | ✓ | ID | auto_increment |
category | int | 11 | Catégorie | ||
title | varchar | 64 | Titre | ||
memo | text | Note | |||
create_date | datetime | Date de création | |||
modified_date | datetime | Date de mise à jour |
Création de SQL pour créer une table
create table if not exists memo_data (
memo_id INT(11) auto_increment not null comment 'ID',
category INT(11) comment 'Catégorie',
title VARCHAR(64) comment 'Titre',
memo TEXT comment 'Note',
create_date DATETIME comment 'Date de création',
modified_date DATETIME comment 'Date de mise à jour',
primary key (memo_id)
)
Code Java pour créer une table (bien qu'un peu approprié)
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 'Catégorie'," +
"title VARCHAR(64) comment 'Titre'," +
"memo TEXT comment 'Note'," +
"create_date DATETIME comment 'Date de création'," +
"modified_date DATETIME comment 'Date de mise à jour'," +
"primary key (memo_id)" + ")";
// create table
smt.executeUpdate(create_table);
Maintenant, lancez-le et la table sera créée
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>
Créez un processus pour enregistrer les données d'entrée du formulaire qui peuvent être référencées par req.getParameter (" title ")
et req.getParameter (" memo ")
dans la méthode de doPost ()
dans le tableau.
String form_title = req.getParameter("title");
String form_memo = req.getParameter("memo");
Et obtenez-le dans une variable, et l'instruction INSERT ressemble à ce qui suit.
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)
);
Code Java pour sauvegarder les enregistrements
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) " +
");";
//Enregistrer l'enregistrement
smt.executeUpdate(insert_memo);
Désormais, lorsque vous saisissez du texte depuis le navigateur et que vous le soumettez, le contenu est enregistré dans la base de données.
(C'est difficile à voir avec les sauts de ligne) Comme ça
mysql> select * from memo_data;
+---------+----------+--------+----------------------------+---------------------+---------------------+
| memo_id | category | title | memo | create_date | modified_date |
+---------+----------+--------+----------------------------+---------------------+---------------------+
| 1 | 0 |achats| -curry
-Facile
-Niku| 2018-12-02 09:52:07 | 2018-12-02 09:52:07 |
+---------+----------+--------+----------------------------+---------------------+---------------------+
1 row in set (0.00 sec)
mysql>
Créez un processus pour afficher les dernières données de mémo enregistrées à l'écran.
Puisqu'il est affiché, l'emplacement est exécuté avec doGet ()
.
La colonne à afficher pour le moment
--Titre --Note --Mis à jour
Avec trois.
Tout d'abord, l'instruction SELECT
select title, memo, modified_date from memo_data;
Contrairement à la création et à l'insertion, les sources Java créent également des processus qui reçoivent les résultats de l'exécution.
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"));
}
Vous pouvez maintenant obtenir les informations d'enregistrement. Ensuite, transmettez les données de mémo extraites de la base de données à l'écran (JSP).
Cette fois, créez un processus pour transmettre les données du servlet à JSP (reportez-vous à la valeur reçue du servlet dans JSP).
Premièrement, le résultat de ʻexecuteQuery () `ne peut pas être utilisé après la fermeture de la connexion, donc créez une variable pour passer et copiez-y les informations d'enregistrement.
ArrayList<HashMap<String, String>> record_list = new ArrayList<>();
//Omission
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);
}
Ensuite, pour passer cette liste_enregistrements
à la JSP, définissez la valeur dans la variable de demande de Servlet avec setAtribute ()
(comme HashMap, vous pouvez transmettre la structure de données au format clé-valeur).
req.setAttribute("record_list", record_list);
String view = "/WEB-INF/jsp/index.jsp";
RequestDispatcher dispatcher = req.getRequestDispatcher(view);
dispatcher.forward(req, resp);
Vous pouvez maintenant vous y référer dans JSP avec le nom de clé record_list
.
La valeur définie par setAttribute (KEY)
dans Servlet peut être récupérée par request.getAttribute (KEY)
.
ArrayList<HashMap<String, String>> list = (ArrayList<HashMap<String, String>>) request.getAttribute("record_list");
Après l'extraction, il est sorti au format html de la même manière que le codage Java normal.
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>");
}
J'ai également besoin d'une déclaration d'importation en premier
<%@page import="java.util.Iterator"%>
<%@page import="java.util.ArrayList"%>
<%@page import="java.util.HashMap"%>
La source entière ressemble à ceci
<%@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>Application mémo</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>
Écran d'affichage
J'ai réussi à le visualiser et à le sauvegarder.
--Parce que la spécification d'adresse du serveur de base de données est codée en dur, elle doit être reconstruite à chaque fois que l'environnement change.
maven
avec apt, vous pouvez créer un fichier war en exécutant mvn package
dans le répertoire avec pom.xml
.Recommended Posts