- Die Vorstellung
- Die Grundsätze bei der Programmierung vom Servlet + JSP
- Demo der Web Applikation machen
- Die Database vorbereiten
- WebApp Project erstellen
- Runtime Environment konfigurieren
- Die Durchführung zum ersten Mal
- Die Bibliothek JDBC herunterladen und erklären
- Die Bibliothek JSTL herunterladen und erklären
- Die Klasse javabeans zur Illustration der Tabelle in DB
- Die Ultility-Klasse zur Verbindung mit Database
- Die UtilityKlasse und die Datenmanipulation
- Die Erstellung vom Servlet Filter mit database
- Servlet Filter liest Cookie zur automatischen Anmeldung
- EncodingFilter Servlet
- Die Seite zur Wiederbenutzung
- Die Hauptseite
- LoginServlet
- Die Seite der Produktsliste
- Das Produkt einfügen
- Die Information des Produkt ändern
- Das Produkt löschen
Erstellen Sie eine einfache Java Web Application mit Servlet, JSP und JDBC
1. Die Vorstellung
Das Dokument wird geschrieben auf die Basic von ...
- Eclipse 4.5 MARS
- Tomcat 8.x
Im Dokument führe ich Schritt für Schritt eine einfache WebApplikation mit der Verbindung von Servlet + JSP + Filter + JSP EL + JDBC zu erstellen. Stellen Sie sicher, dass Sie Servlet, JSP und Filter und JDBC vor dem Beginn beherrschen. Wenn nicht, können Sie lesen in ...
Achtung: Im Unterricht stelle ich nur die Funktion CRUD, Login" und "Remember Me" vor und behandle nicht die Sicherheit der Seite. Wenn Sie eine sichere Applikation haben, lesen Sie mal die Unterricht unten
2. Die Grundsätze bei der Programmierung vom Servlet + JSP
Das sind die Grundsätze, die Sie sich erinnern sollen, um eine WebApplikation mit der Verbindung Servlet + JSP zu erstellen, die die Kriterien befriedigen: einfache und verständliche Kodierung und leichte Wartung
Die Grundsätze:
- Lassen Sie nie, dass der Benutzer Ihre JSP Seite direkt zugreifen.
- Sehen Sie JSP nur als eine Dinge zum Anzeigen der Interface.
- Servlet spielt eine Rolle als der Threadsteuer der Applikation und die Behandlung der Programmslogik.
- Öffnung der JDBC Verbindung und Management der Transaktion in Filter (nicht obligatorisch).
Nach dem Grundsatz 1:
lassen Sie nie, der Benutzer Ihre JSP Seite direkt zugreifen. Das heißt, dass alle Anforderungen des Benutzer normalerweise sind :
- Eine statische Datenquelle (image, css, js,...)
- Oder ein Servlet.
Wenn die Anforderung des Benutzer in Servlet geschickt wird, handelt es die Anforderung des Benutzer, zum Beispiel Insert, update und Datenabfrage und zum letzten in JSP Seite weiterleiten um die Daten anzuzeigen. So hat jeder Servlet 0 oder viele entsprechenden JSP Seite ( oft nur 1 brauchen).
Principle 2:
JSP gilt nur als die Datenanzeige: das heißt, Sie sollen die Logik der Applikation auf JSP nicht behandeln wie update, insert, delete,.., und keine Navagation auf die Seite JSP.
4. Die Database vorbereiten
Im Dokument führe ich Ihnen, mit einer der 3 Datenbank Oracle, MySQL oder SQL Server zu arbeiten. Sie sollen die script laufen, um einige notwendigen Tabellen und Daten für das Beispiel zu erstellen
ORACLE:
-- Create table
create table USER_ACCOUNT
(
USER_NAME VARCHAR2(30) not null,
GENDER VARCHAR2(1) not null,
PASSWORD VARCHAR2(30) not null,
primary key (USER_NAME)
);
-- Create table
create table PRODUCT
(
CODE VARCHAR2(20) not null,
NAME VARCHAR2(128) not null,
PRICE FLOAT not null,
primary key (CODE)
) ;
-- Insert data: ---------------------------------------------------------------
insert into user_account (USER_NAME, GENDER, PASSWORD)
values ('tom', 'M', 'tom001');
insert into user_account (USER_NAME, GENDER, PASSWORD)
values ('jerry', 'M', 'jerry001');
insert into product (CODE, NAME, PRICE)
values ('P001', 'Java Core', 100);
insert into product (CODE, NAME, PRICE)
values ('P002', 'C# Core', 90);
-- Commit
Commit;MYSQL:
-- Create table
create table USER_ACCOUNT
(
USER_NAME VARCHAR(30) not null,
GENDER VARCHAR(1) not null,
PASSWORD VARCHAR(30) not null,
primary key (USER_NAME)
);
-- Create table
create table PRODUCT
(
CODE VARCHAR(20) not null,
NAME VARCHAR(128) not null,
PRICE FLOAT not null,
primary key (CODE)
) ;
-- Insert data: ---------------------------------------------------------------
insert into user_account (USER_NAME, GENDER, PASSWORD)
values ('tom', 'M', 'tom001');
insert into user_account (USER_NAME, GENDER, PASSWORD)
values ('jerry', 'M', 'jerry001');
insert into product (CODE, NAME, PRICE)
values ('P001', 'Java Core', 100);
insert into product (CODE, NAME, PRICE)
values ('P002', 'C# Core', 90);SQL SERVER:
-- Create table
create table USER_ACCOUNT
(
USER_NAME VARCHAR(30) not null,
GENDER VARCHAR(1) not null,
PASSWORD VARCHAR(30) not null,
primary key (USER_NAME)
);
-- Create table
create table PRODUCT
(
CODE VARCHAR(20) not null,
NAME VARCHAR(128) not null,
PRICE FLOAT not null,
primary key (CODE)
) ;
-- Insert data: ---------------------------------------------------------------
insert into user_account (USER_NAME, GENDER, PASSWORD)
values ('tom', 'M', 'tom001');
insert into user_account (USER_NAME, GENDER, PASSWORD)
values ('jerry', 'M', 'jerry001');
insert into product (CODE, NAME, PRICE)
values ('P001', 'Java Core', 100);
insert into product (CODE, NAME, PRICE)
values ('P002', 'C# Core', 90);5. WebApp Project erstellen
Auf die Eclipse wählen Sie:
- File/New/Other...
Das Project wurde erstellt
fügen Sie die File index.html hinzu
index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Simple Web Application</title>
</head>
<body>
<h2>Simple Login Web Application using JSP/Servlet</h2>
<ul>
<li><a href="home">Home</a></li>
<li><a href="login">Login</a></li>
<li><a href="productList">Product List</a>
</ul>
</body>
</html>6. Runtime Environment konfigurieren
Die Applikation sollen in einem WebServer laufen, zum Beispiel Tomcat Server. Sie können das Dokument für die Hinweise der Herunterladung und Anmeldung von Server Tomcat in Eclipse lesen bei :
Klicken Sie auf die Rechtmaustaste in das Project SimpleWebApp und wählen Sie Properties.
7. Die Durchführung zum ersten Mal
Klicken Sie auf die Rechtmaustaste im Project SimpleWebApp, wählen Sie :
- Run As/Run on Server
Die Applikation wird geläuft
OK, Alles is bisher in Ordnung. Wir werden eine eigentliche Webapplikation programmieren.
8. Die Bibliothek JDBC herunterladen und erklären
Sie sollen die Bibliothek JDBC herunterladen um die Verbindung mit Database zu steuern. Im Dokument lade ich 3 JDBC Bibliothek für Oracle, MySQL, SQL Server herunter. In der Praxis brauchen Sie nur JDBC Bibliothek, die Ihre Database Sie benutzen entspricht
Sie können die Hinweise der Herunterladung von JDBC driver sehen bei :
Oder Herunterladung der JDBC Bibliothek für MySQL, Sql Server, Oracle bei hier ...:
Das Ergebnis von der Herunterladung:
Kopieren Sie diese Bibliothek ins WEB-INF/lib:
9. Die Bibliothek JSTL herunterladen und erklären
Sie brauchen 2 JSTL Bibliothek herunterzuladen um sie in JSP zu benutzen
- javax.servlet.jsp.jstl-*.jar
- javax.servlet.jsp.jslt-api-*.jar
Kopieren Sie 2 heruntergeladeten File Jar in den Ordner /WEB-INF/lib:
10. Die Klasse javabeans zur Illustration der Tabelle in DB
Erstellen Sie einige Class Javabean, jede Class bezeicht eine Tabelle in Database
UserAccount.java
package org.o7planning.simplewebapp.beans;
public class UserAccount {
public static final String GENDER_MALE ="M";
public static final String GENDER_FEMALE = "F";
private String userName;
private String gender;
private String password;
public UserAccount() {
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}Product.java
package org.o7planning.simplewebapp.beans;
public class Product {
private String code;
private String name;
private float price;
public Product() {
}
public Product(String code, String name, float price) {
this.code = code;
this.name = name;
this.price = price;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
}11. Die Ultility-Klasse zur Verbindung mit Database
MySQLConnUtils.java
package org.o7planning.simplewebapp.conn;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class MySQLConnUtils {
public static Connection getMySQLConnection()
throws ClassNotFoundException, SQLException {
// Achtung: Den Verbindungsparameter anpassen.
String hostName = "localhost";
String dbName = "mytest";
String userName = "root";
String password = "12345";
return getMySQLConnection(hostName, dbName, userName, password);
}
public static Connection getMySQLConnection(String hostName, String dbName,
String userName, String password) throws SQLException,
ClassNotFoundException {
Class.forName("com.mysql.jdbc.Driver");
// Die Struktur URL Connection für MySQL:
// Zum Beispiel:
// jdbc:mysql://localhost:3306/simplehr
String connectionURL = "jdbc:mysql://" + hostName + ":3306/" + dbName;
Connection conn = DriverManager.getConnection(connectionURL, userName,
password);
return conn;
}
}OracleConnUtils.java
package org.o7planning.simplewebapp.conn;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class OracleConnUtils {
public static Connection getOracleConnection()
throws ClassNotFoundException, SQLException {
// Achtung: Den Verbindungsparameter anpassen.
String hostName = "localhost";
String sid = "db12c";
String userName = "mytest";
String password = "12345";
return getOracleConnection(hostName, sid, userName, password);
}
public static Connection getOracleConnection(String hostName, String sid,
String userName, String password) throws ClassNotFoundException,
SQLException {
Class.forName("oracle.jdbc.driver.OracleDriver");
// Die Struktur URL Connection für Oracle
// Zum Beispiel:
// jdbc:oracle:thin:@localhost:1521:db11g
// jdbc:oracle:thin:@//HOSTNAME:PORT/SERVICENAME
String connectionURL = "jdbc:oracle:thin:@" + hostName + ":1521:" + sid;
Connection conn = DriverManager.getConnection(connectionURL, userName,
password);
return conn;
}
}SQLServerConnUtils_JTDS.java
package org.o7planning.simplewebapp.conn;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class SQLServerConnUtils_JTDS {
// In SQL Server binden.
// (Die Biliothek JDTS benutzen)
public static Connection getSQLServerConnection_JTDS() //
throws SQLException, ClassNotFoundException {
// Achtung: die Verbindungsparameter anpassen
String hostName = "localhost";
String sqlInstanceName = "SQLEXPRESS";
String database = "mytest";
String userName = "sa";
String password = "12345";
return getSQLServerConnection_JTDS(hostName, sqlInstanceName, database, userName, password);
}
// Die Verbindung zum SQL Server durch die Bibliothek JTDS.
private static Connection getSQLServerConnection_JTDS(String hostName, //
String sqlInstanceName, String database, String userName, String password)
throws ClassNotFoundException, SQLException {
Class.forName("net.sourceforge.jtds.jdbc.Driver");
// Die Struktur von URL Connection für SQL Server:
// Zum Beispiel:
// jdbc:jtds:sqlserver://localhost:1433/simplehr;instance=SQLEXPRESS
String connectionURL = "jdbc:jtds:sqlserver://" + hostName + ":1433/" //
+ database + ";instance=" + sqlInstanceName;
Connection conn = DriverManager.getConnection(connectionURL, userName, password);
return conn;
}
}SQLServerConnUtils_SQLJDBC.java
package org.o7planning.simplewebapp.conn;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class SQLServerConnUtils_SQLJDBC {
// Die Verbindung zum SQL Server.
// (die Bibliothek SQLJDBC benutzen)
public static Connection getSQLServerConnection_SQLJDBC() //
throws ClassNotFoundException, SQLException {
// Die Achtung: die Verbindungsparameter anpassen.
String hostName = "localhost";
String sqlInstanceName = "SQLEXPRESS";
String database = "mytest";
String userName = "sa";
String password = "12345";
return getSQLServerConnection_SQLJDBC(hostName, sqlInstanceName, database, userName, password);
}
// Zum SQL Server verbinden, SQLJDBC benutzen.
private static Connection getSQLServerConnection_SQLJDBC(String hostName, //
String sqlInstanceName, String database, String userName, String password)//
throws ClassNotFoundException, SQLException {
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
// Die Struktur URL Connection für SQLServer
// Zum Beispiel:
// jdbc:sqlserver://ServerIp:1433/SQLEXPRESS;databaseName=simplehr
String connectionURL = "jdbc:sqlserver://" + hostName + ":1433" //
+ ";instance=" + sqlInstanceName + ";databaseName=" + database;
Connection conn = DriverManager.getConnection(connectionURL, userName, password);
return conn;
}
}ConnectionUtils.java
package org.o7planning.simplewebapp.conn;
import java.sql.Connection;
import java.sql.SQLException;
public class ConnectionUtils {
public static Connection getConnection()
throws ClassNotFoundException, SQLException {
// Hier verbinde ich zur Oracle Database.
// (Sie können die anderen DB benutzen).
return OracleConnUtils.getOracleConnection();
// return OracleConnUtils.getOracleConnection();
// return MySQLConnUtils.getMySQLConnection();
// return SQLServerConnUtils_JTDS.getSQLServerConnection_JTDS();
// return SQLServerConnUtils_SQLJDBC.getSQLServerConnection_SQLJDBC();
// return PostGresConnUtils.getPostGresConnection();
}
public static void closeQuietly(Connection conn) {
try {
conn.close();
} catch (Exception e) {
}
}
public static void rollbackQuietly(Connection conn) {
try {
conn.rollback();
} catch (Exception e) {
}
}
}12. Die UtilityKlasse und die Datenmanipulation
MyUtils.java
package org.o7planning.simplewebapp.utils;
import java.sql.Connection;
import javax.servlet.ServletRequest;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.o7planning.simplewebapp.beans.UserAccount;
public class MyUtils {
public static final String ATT_NAME_CONNECTION = "ATTRIBUTE_FOR_CONNECTION";
private static final String ATT_NAME_USER_NAME = "ATTRIBUTE_FOR_STORE_USER_NAME_IN_COOKIE";
// Die Connection in Attribute von dem Request.
// Die Information zur Speicherung existiert nur während der Anforderung (request)
// zum wenn die Daten in dem Benutzer zurückgegeben.
public static void storeConnection(ServletRequest request, Connection conn) {
request.setAttribute(ATT_NAME_CONNECTION, conn);
}
// Das Objekt Connection entnehmen, das in Attribute des Request gespeichert wird.
public static Connection getStoredConnection(ServletRequest request) {
Connection conn = (Connection) request.getAttribute(ATT_NAME_CONNECTION);
return conn;
}
// Die Information, die der Benutzer in Session angemeldet hat (login), archivieren.
public static void storeLoginedUser(HttpSession session, UserAccount loginedUser) {
// Auf JSP durch ${loginedUser} zugreifen
session.setAttribute("loginedUser", loginedUser);
}
// Die in Session gespeicherten Information entnehmen.
public static UserAccount getLoginedUser(HttpSession session) {
UserAccount loginedUser = (UserAccount) session.getAttribute("loginedUser");
return loginedUser;
}
// Die Information vom Benutzer in Cookie speichern.
public static void storeUserCookie(HttpServletResponse response, UserAccount user) {
System.out.println("Store user cookie");
Cookie cookieUserName = new Cookie(ATT_NAME_USER_NAME, user.getUserName());
// Ein Tag (in die Sekunde wechseln)
cookieUserName.setMaxAge(24 * 60 * 60);
response.addCookie(cookieUserName);
}
public static String getUserNameInCookie(HttpServletRequest request) {
Cookie[] cookies = request.getCookies();
if (cookies != null) {
for (Cookie cookie : cookies) {
if (ATT_NAME_USER_NAME.equals(cookie.getName())) {
return cookie.getValue();
}
}
}
return null;
}
// das Cookie des Benutzer löschen
public static void deleteUserCookie(HttpServletResponse response) {
Cookie cookieUserName = new Cookie(ATT_NAME_USER_NAME, null);
// 0 Sekunde. (Cookie wird sofort ungültig)
cookieUserName.setMaxAge(0);
response.addCookie(cookieUserName);
}
}DBUtils.java
package org.o7planning.simplewebapp.utils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.o7planning.simplewebapp.beans.Product;
import org.o7planning.simplewebapp.beans.UserAccount;
public class DBUtils {
public static UserAccount findUser(Connection conn, //
String userName, String password) throws SQLException {
String sql = "Select a.User_Name, a.Password, a.Gender from User_Account a " //
+ " where a.User_Name = ? and a.password= ?";
PreparedStatement pstm = conn.prepareStatement(sql);
pstm.setString(1, userName);
pstm.setString(2, password);
ResultSet rs = pstm.executeQuery();
if (rs.next()) {
String gender = rs.getString("Gender");
UserAccount user = new UserAccount();
user.setUserName(userName);
user.setPassword(password);
user.setGender(gender);
return user;
}
return null;
}
public static UserAccount findUser(Connection conn, String userName) throws SQLException {
String sql = "Select a.User_Name, a.Password, a.Gender from User_Account a "//
+ " where a.User_Name = ? ";
PreparedStatement pstm = conn.prepareStatement(sql);
pstm.setString(1, userName);
ResultSet rs = pstm.executeQuery();
if (rs.next()) {
String password = rs.getString("Password");
String gender = rs.getString("Gender");
UserAccount user = new UserAccount();
user.setUserName(userName);
user.setPassword(password);
user.setGender(gender);
return user;
}
return null;
}
public static List<Product> queryProduct(Connection conn) throws SQLException {
String sql = "Select a.Code, a.Name, a.Price from Product a ";
PreparedStatement pstm = conn.prepareStatement(sql);
ResultSet rs = pstm.executeQuery();
List<Product> list = new ArrayList<Product>();
while (rs.next()) {
String code = rs.getString("Code");
String name = rs.getString("Name");
float price = rs.getFloat("Price");
Product product = new Product();
product.setCode(code);
product.setName(name);
product.setPrice(price);
list.add(product);
}
return list;
}
public static Product findProduct(Connection conn, String code) throws SQLException {
String sql = "Select a.Code, a.Name, a.Price from Product a where a.Code=?";
PreparedStatement pstm = conn.prepareStatement(sql);
pstm.setString(1, code);
ResultSet rs = pstm.executeQuery();
while (rs.next()) {
String name = rs.getString("Name");
float price = rs.getFloat("Price");
Product product = new Product(code, name, price);
return product;
}
return null;
}
public static void updateProduct(Connection conn, Product product) throws SQLException {
String sql = "Update Product set Name =?, Price=? where Code=? ";
PreparedStatement pstm = conn.prepareStatement(sql);
pstm.setString(1, product.getName());
pstm.setFloat(2, product.getPrice());
pstm.setString(3, product.getCode());
pstm.executeUpdate();
}
public static void insertProduct(Connection conn, Product product) throws SQLException {
String sql = "Insert into Product(Code, Name,Price) values (?,?,?)";
PreparedStatement pstm = conn.prepareStatement(sql);
pstm.setString(1, product.getCode());
pstm.setString(2, product.getName());
pstm.setFloat(3, product.getPrice());
pstm.executeUpdate();
}
public static void deleteProduct(Connection conn, String code) throws SQLException {
String sql = "Delete From Product where Code= ?";
PreparedStatement pstm = conn.prepareStatement(sql);
pstm.setString(1, code);
pstm.executeUpdate();
}
}13. Die Erstellung vom Servlet Filter mit database
Im JDBCFilter prüfe ich, welche Anforderung in einem Servlet wirklich aufruft. Um mehr zu verstehen, können Sie die folgende Image sehen. Das bezeichnet die Beziehung zwischen die Definitionen von Servlet.
JDBCFilter mit der Anmeldung url-pattern = /*, das bedeutet, dass alle Anforderung des Benutzers durch den Filter gehen müssen. JDBCFilter soll die Anforderung prüfen, um die Öffnung der JDBC Verbindung für die notwendigen Anforderungen zu guarantieren. Zum Beispiel für den Servlet: keine Öffnung der JDBC Verbindung mit der normalen Anforderungen wie image, css, js, html.
JDBCFilter.java
package org.o7planning.simplewebapp.filter;
import java.io.IOException;
import java.sql.Connection;
import java.util.Collection;
import java.util.Map;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import org.o7planning.simplewebapp.conn.ConnectionUtils;
import org.o7planning.simplewebapp.utils.MyUtils;
@WebFilter(filterName = "jdbcFilter", urlPatterns = { "/*" })
public class JDBCFilter implements Filter {
public JDBCFilter() {
}
@Override
public void init(FilterConfig fConfig) throws ServletException {
}
@Override
public void destroy() {
}
// Prüfen, ob das Zweck der momentane Anforderungen ein Servlet ist?
private boolean needJDBC(HttpServletRequest request) {
System.out.println("JDBC Filter");
//
// Servlet Url-pattern: /spath/*
//
// => /spath
String servletPath = request.getServletPath();
// => /abc/mnp
String pathInfo = request.getPathInfo();
String urlPattern = servletPath;
if (pathInfo != null) {
// => /spath/*
urlPattern = servletPath + "/*";
}
// Key: servletName.
// Value: ServletRegistration
Map<String, ? extends ServletRegistration> servletRegistrations = request.getServletContext()
.getServletRegistrations();
// Alle Servlet in Ihrem WebApp sammeln.
Collection<? extends ServletRegistration> values = servletRegistrations.values();
for (ServletRegistration sr : values) {
Collection<String> mappings = sr.getMappings();
if (mappings.contains(urlPattern)) {
return true;
}
}
return false;
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) request;
// Die Verbindung für die Request mit den besonderen Pfad öffnent (Zum Beispiel: den Pfad zum servlet, jsp, ..)
// Vermeiden, die Connection mit den normalen Anforderungen zu öffnen (z.B image, css, javascript,... )
if (this.needJDBC(req)) {
System.out.println("Open Connection for: " + req.getServletPath());
Connection conn = null;
try {
// Das Connection Objekt zur Verbindung mit Database erstellen
conn = ConnectionUtils.getConnection();
// Automatisch commit false einstellen um aktiv zu kontrollieren.
conn.setAutoCommit(false);
// Das Objekt Connection in Attribute des Request archivieren.
MyUtils.storeConnection(request, conn);
// Erlauben, die Request weiter zu gehen.
// (zum nächsten Filter oder zum Zweck gehen).
chain.doFilter(request, response);
// Die Methode commit() aufrufen um die Transaction mit DB zu erledigen
conn.commit();
} catch (Exception e) {
e.printStackTrace();
ConnectionUtils.rollbackQuietly(conn);
throw new ServletException();
} finally {
ConnectionUtils.closeQuietly(conn);
}
}
// Mit den normalen Request (image,css,html,..) brauchen die Connection zu öffnen.
else {
// Die Request weiter zu gehen erlauben (zum nächsten Filter oder zum Zweck gehen).
chain.doFilter(request, response);
}
}
}14. Servlet Filter liest Cookie zur automatischen Anmeldung
Falls der Benutzer angemeldet hat und die Information der letzten Anmeldung gespeichert wird (z.B am Vortag). Und wenn der Benutzer zurück ist , prüft der Filter die Informationen, die Cookie durch die Browser gespeichert hat, und automatisch login
CookieFilter.java
package org.o7planning.simplewebapp.filter;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.o7planning.simplewebapp.beans.UserAccount;
import org.o7planning.simplewebapp.utils.DBUtils;
import org.o7planning.simplewebapp.utils.MyUtils;
@WebFilter(filterName = "cookieFilter", urlPatterns = { "/*" })
public class CookieFilter implements Filter {
public CookieFilter() {
}
@Override
public void init(FilterConfig fConfig) throws ServletException {
}
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) request;
HttpSession session = req.getSession();
UserAccount userInSession = MyUtils.getLoginedUser(session);
//
if (userInSession != null) {
session.setAttribute("COOKIE_CHECKED", "CHECKED");
chain.doFilter(request, response);
return;
}
// Die Connection wird in JDBCFilter erstellt.
Connection conn = MyUtils.getStoredConnection(request);
// Die Flagge (flag) zur Cookie-Prüfung.
String checked = (String) session.getAttribute("COOKIE_CHECKED");
if (checked == null && conn != null) {
String userName = MyUtils.getUserNameInCookie(req);
try {
UserAccount user = DBUtils.findUser(conn, userName);
MyUtils.storeLoginedUser(session, user);
} catch (SQLException e) {
e.printStackTrace();
}
// markieren, Cookie schon zu prüfen
session.setAttribute("COOKIE_CHECKED", "CHECKED");
}
chain.doFilter(request, response);
}
}NOTIZJDBCFilter & CookieFilter haben die gleichen url-pattern =/*, Sie sollen konfigurieren zu guarantieren, dass JDBCFilter vorher getun wird. Deshalb sollen Sie die Reihefolfen in Web.xml anmelden (keine Anmeldung der Reihenfolge durch die Annotation).
<filter-mapping>
<filter-name>jdbcFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>cookieFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>See full web.xml:
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id="WebApp_ID" version="3.0">
<display-name>SimpleWebApp</display-name>
<filter-mapping>
<filter-name>jdbcFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>cookieFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>home</welcome-file>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>15. EncodingFilter Servlet
EncodingFilter.java
package org.o7planning.simplewebapp.filter;
import java.io.IOException;
import java.sql.Connection;
import java.util.Collection;
import java.util.Map;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import org.o7planning.simplewebapp.conn.ConnectionUtils;
import org.o7planning.simplewebapp.utils.MyUtils;
@WebFilter(filterName = "encodingFilter", urlPatterns = { "/*" })
public class EncodingFilter implements Filter {
public EncodingFilter() {
}
@Override
public void init(FilterConfig fConfig) throws ServletException {
}
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
request.setCharacterEncoding("UTF-8");
chain.doFilter(request, response);
}
}16. Die Seite zur Wiederbenutzung
Einige JSP Seite wird benutzt, um in anderen Seite bei der Zeitpunkt von Runtime einzubetten durch die Anwendung von:
<jsp:include page="_header.jsp"></jsp:include>
<jsp:include page="_menu.jsp"></jsp:include>
<jsp:include page="_footer.jsp"></jsp:include>
/WEB-INF/views/_header.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<div style="background: #E0E0E0; height: 55px; padding: 5px;">
<div style="float: left">
<h1>My Site</h1>
</div>
<div style="float: right; padding: 10px; text-align: right;">
<!-- User store in session with attribute: loginedUser -->
Hello <b>${loginedUser.userName}</b>
<br/>
Search <input name="search">
</div>
</div>/WEB-INF/views/_menu.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<div style="padding: 5px;">
<a href="${pageContext.request.contextPath}/">Home</a>
|
<a href="${pageContext.request.contextPath}/productList">Product List</a>
|
<a href="${pageContext.request.contextPath}/userInfo">My Account Info</a>
|
<a href="${pageContext.request.contextPath}/login">Login</a>
</div>/WEB-INF/views/_footer.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<div
style="background: #E0E0E0; text-align: center; padding: 5px; margin-top: 10px;">
@Copyright o7planning.org
</div>17. Die Hauptseite
Wenn Sie den standardmäßigen Pfad typen, z.B Beim Typen des Domain- Namen der Webseite zeigt es die Hauptseite an (Fall contextPath = "") sollen Sie die Hauptseite in <welcome-file-list> von web.xml anmelden
Der folgende Pfad zeigt momentan die Inhalt von der Seite index.html an
Sie sollen eine Hauptseite als JSP entwerfen, um die dynamischen Informationen statt einer Seite html mit der statischen Informationen zu schaffen
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id="WebApp_ID" version="3.0">
<display-name>SimpleWebApp</display-name>
<filter-mapping>
<filter-name>jdbcFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>cookieFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>home</welcome-file>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>Die Vorlage der Hauptseite
HomeServlet.java
package org.o7planning.simplewebapp.servlet;
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(urlPatterns = { "/home"})
public class HomeServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
public HomeServlet() {
super();
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Forward to /WEB-INF/views/homeView.jsp
// (Users can not access directly into JSP pages placed in WEB-INF)
RequestDispatcher dispatcher = this.getServletContext().getRequestDispatcher("/WEB-INF/views/homeView.jsp");
dispatcher.forward(request, response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}/WEB-INF/views/homeView.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Home Page</title>
</head>
<body>
<jsp:include page="_header.jsp"></jsp:include>
<jsp:include page="_menu.jsp"></jsp:include>
<h3>Home Page</h3>
This is demo Simple web application using jsp,servlet & Jdbc. <br><br>
<b>It includes the following functions:</b>
<ul>
<li>Login</li>
<li>Storing user information in cookies</li>
<li>Product List</li>
<li>Create Product</li>
<li>Edit Product</li>
<li>Delete Product</li>
</ul>
<jsp:include page="_footer.jsp"></jsp:include>
</body>
</html>Starten Sie Ihre Applikation wieder und probieren Sie 2 Pfade
Notiz: Wenn aus irgendeinem Grund der Pfad http://localhost:8080/SimpleWebApp/ noch auf index.html umschaltet, können Sie den Name von der File index.html löschen oder ändern, z.B zur _index.html ändern
18. LoginServlet
No ADS
Das ist die Vorlage von der Funktion Login
LoginServlet.java
package org.o7planning.simplewebapp.servlet;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
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;
import javax.servlet.http.HttpSession;
import org.o7planning.simplewebapp.beans.UserAccount;
import org.o7planning.simplewebapp.utils.DBUtils;
import org.o7planning.simplewebapp.utils.MyUtils;
@WebServlet(urlPatterns = { "/login" })
public class LoginServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
public LoginServlet() {
super();
}
// Die Seite Login anzeigen.
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// nach der Seite /WEB-INF/views/loginView.jsp weiterleiten (forward)
// (Der Benutzer kann direkt in die Seite JSP in dem Verzeichnis WEB-INF nicht zugreifen).
RequestDispatcher dispatcher //
= this.getServletContext().getRequestDispatcher("/WEB-INF/views/loginView.jsp");
dispatcher.forward(request, response);
}
// Wenn der Benutzer userName & password anmelden, und klicken auf Submit.
// Die Methode wird implementiert.
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String userName = request.getParameter("userName");
String password = request.getParameter("password");
String rememberMeStr = request.getParameter("rememberMe");
boolean remember = "Y".equals(rememberMeStr);
UserAccount user = null;
boolean hasError = false;
String errorString = null;
if (userName == null || password == null || userName.length() == 0 || password.length() == 0) {
hasError = true;
errorString = "Required username and password!";
} else {
Connection conn = MyUtils.getStoredConnection(request);
try {
// Den user in DB finden.
user = DBUtils.findUser(conn, userName, password);
if (user == null) {
hasError = true;
errorString = "User Name or password invalid";
}
} catch (SQLException e) {
e.printStackTrace();
hasError = true;
errorString = e.getMessage();
}
}
// In der Fall vom Fehler zum /WEB-INF/views/login.jsp weiterleiten
if (hasError) {
user = new UserAccount();
user.setUserName(userName);
user.setPassword(password);
// Die Information in request attribute vor dem forward speichern
request.setAttribute("errorString", errorString);
request.setAttribute("user", user);
// Nach der Seite /WEB-INF/views/login.jsp weiterleiten
RequestDispatcher dispatcher //
= this.getServletContext().getRequestDispatcher("/WEB-INF/views/loginView.jsp");
dispatcher.forward(request, response);
}
// Falls es keinen Fehler gibt.
// Die Information des Benutzer in Session speichern und nach der Seite userInfo weiterleiten.
else {
HttpSession session = request.getSession();
MyUtils.storeLoginedUser(session, user);
// Wenn der Benutzer die Funktion "Remember me" wählen.
if (remember) {
MyUtils.storeUserCookie(response, user);
}
// Umgekehrt löschen Cookie
else {
MyUtils.deleteUserCookie(response);
}
// Nach der Seite /userInfo weiterleiten (redirect).
response.sendRedirect(request.getContextPath() + "/userInfo");
}
}
}UserInfoServlet.java
package org.o7planning.simplewebapp.servlet;
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;
import javax.servlet.http.HttpSession;
import org.o7planning.simplewebapp.beans.UserAccount;
import org.o7planning.simplewebapp.utils.MyUtils;
@WebServlet(urlPatterns = { "/userInfo" })
public class UserInfoServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
public UserInfoServlet() {
super();
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
HttpSession session = request.getSession();
// Prüfen, ob der Benutzer angemeldet hat oder nicht.
UserAccount loginedUser = MyUtils.getLoginedUser(session);
// Wenn nicht, anmelden (login).
if (loginedUser == null) {
// Redirect zur Seite login.
response.sendRedirect(request.getContextPath() + "/login");
return;
}
// Die Information in request attribute vor dem forward (weiterleiten) speichern
request.setAttribute("user", loginedUser);
// Wenn der Benutzer angemeldet hat (login),
// dann nach die Seite /WEB-INF/views/userInfoView.jsp weiterleiten
RequestDispatcher dispatcher //
= this.getServletContext().getRequestDispatcher("/WEB-INF/views/userInfoView.jsp");
dispatcher.forward(request, response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
/WEB-INF/views/loginView.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Login</title>
</head>
<body>
<jsp:include page="_header.jsp"></jsp:include>
<jsp:include page="_menu.jsp"></jsp:include>
<h3>Login Page</h3>
<p style="color: red;">${errorString}</p>
<form method="POST" action="${pageContext.request.contextPath}/login">
<table border="0">
<tr>
<td>User Name</td>
<td><input type="text" name="userName" value= "${user.userName}" /> </td>
</tr>
<tr>
<td>Password</td>
<td><input type="text" name="password" value= "${user.password}" /> </td>
</tr>
<tr>
<td>Remember me</td>
<td><input type="checkbox" name="rememberMe" value= "Y" /> </td>
</tr>
<tr>
<td colspan ="2">
<input type="submit" value= "Submit" />
<a href="${pageContext.request.contextPath}/">Cancel</a>
</td>
</tr>
</table>
</form>
<p style="color:blue;">User Name: tom, password: tom001 or jerry/jerry001</p>
<jsp:include page="_footer.jsp"></jsp:include>
</body>
</html>/WEB-INF/views/userInfoView.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>User Info</title>
</head>
<body>
<jsp:include page="_header.jsp"></jsp:include>
<jsp:include page="_menu.jsp"></jsp:include>
<h3>Hello: ${user.userName}</h3>
User Name: <b>${user.userName}</b>
<br />
Gender: ${user.gender } <br />
<jsp:include page="_footer.jsp"></jsp:include>
</body>
</html>Starten Sie Ihre Applikation
19. Die Seite der Produktsliste
Die Vorlage
ProductListServlet.java
package org.o7planning.simplewebapp.servlet;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
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;
import org.o7planning.simplewebapp.beans.Product;
import org.o7planning.simplewebapp.utils.DBUtils;
import org.o7planning.simplewebapp.utils.MyUtils;
@WebServlet(urlPatterns = { "/productList" })
public class ProductListServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
public ProductListServlet() {
super();
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Connection conn = MyUtils.getStoredConnection(request);
String errorString = null;
List<Product> list = null;
try {
list = DBUtils.queryProduct(conn);
} catch (SQLException e) {
e.printStackTrace();
errorString = e.getMessage();
}
// Die Information in Request attribute vor dem Weiterleiten nach views speichern.
request.setAttribute("errorString", errorString);
request.setAttribute("productList", list);
// Zum /WEB-INF/views/productListView.jsp weiterleiten (forward)
RequestDispatcher dispatcher = request.getServletContext()
.getRequestDispatcher("/WEB-INF/views/productListView.jsp");
dispatcher.forward(request, response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}/WEB-INF/views/productListView.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Product List</title>
</head>
<body>
<jsp:include page="_header.jsp"></jsp:include>
<jsp:include page="_menu.jsp"></jsp:include>
<h3>Product List</h3>
<p style="color: red;">${errorString}</p>
<table border="1" cellpadding="5" cellspacing="1" >
<tr>
<th>Code</th>
<th>Name</th>
<th>Price</th>
<th>Edit</th>
<th>Delete</th>
</tr>
<c:forEach items="${productList}" var="product" >
<tr>
<td>${product.code}</td>
<td>${product.name}</td>
<td>${product.price}</td>
<td>
<a href="editProduct?code=${product.code}">Edit</a>
</td>
<td>
<a href="deleteProduct?code=${product.code}">Delete</a>
</td>
</tr>
</c:forEach>
</table>
<a href="createProduct" >Create Product</a>
<jsp:include page="_footer.jsp"></jsp:include>
</body>
</html>Starten Sie die Applikation wieder
20. Das Produkt einfügen
No ADS
Die Vorlage der Funktion Produkte hinzufügen
CreateProductServlet.java
package org.o7planning.simplewebapp.servlet;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
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;
import org.o7planning.simplewebapp.beans.Product;
import org.o7planning.simplewebapp.utils.DBUtils;
import org.o7planning.simplewebapp.utils.MyUtils;
@WebServlet(urlPatterns = { "/createProduct" })
public class CreateProductServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
public CreateProductServlet() {
super();
}
// Die Seite der Produktserstellung anzeigen.
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
RequestDispatcher dispatcher = request.getServletContext()
.getRequestDispatcher("/WEB-INF/views/createProductView.jsp");
dispatcher.forward(request, response);
}
// Wenn der Benutzer die Produktsinformation eingeben und klicken Sie auf Submit.
// Die Methode wird aufgeruft.
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Connection conn = MyUtils.getStoredConnection(request);
String code = (String) request.getParameter("code");
String name = (String) request.getParameter("name");
String priceStr = (String) request.getParameter("price");
float price = 0;
try {
price = Float.parseFloat(priceStr);
} catch (Exception e) {
}
Product product = new Product(code, name, price);
String errorString = null;
// Die Produktscode muss ein String [a-zA-Z_0-9] sein, das mindesten ein Zeichen hat
String regex = "\\w+";
if (code == null || !code.matches(regex)) {
errorString = "Product Code invalid!";
}
if (errorString == null) {
try {
DBUtils.insertProduct(conn, product);
} catch (SQLException e) {
e.printStackTrace();
errorString = e.getMessage();
}
}
// Die Information in Request attribute vor dem Weiterleiten nach views speichern.
request.setAttribute("errorString", errorString);
request.setAttribute("product", product);
// Im Fall vom Fehler leiten zur Seite 'edit' weiter.
if (errorString != null) {
RequestDispatcher dispatcher = request.getServletContext()
.getRequestDispatcher("/WEB-INF/views/createProductView.jsp");
dispatcher.forward(request, response);
}
// Wenn alles in Ordnung ist, leit zur Seite der Produktsliste weiter (redirect)
else {
response.sendRedirect(request.getContextPath() + "/productList");
}
}
}/WEB-INF/views/createProductView.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Create Product</title>
</head>
<body>
<jsp:include page="_header.jsp"></jsp:include>
<jsp:include page="_menu.jsp"></jsp:include>
<h3>Create Product</h3>
<p style="color: red;">${errorString}</p>
<form method="POST" action="${pageContext.request.contextPath}/createProduct">
<table border="0">
<tr>
<td>Code</td>
<td><input type="text" name="code" value="${product.code}" /></td>
</tr>
<tr>
<td>Name</td>
<td><input type="text" name="name" value="${product.name}" /></td>
</tr>
<tr>
<td>Price</td>
<td><input type="text" name="price" value="${product.price}" /></td>
</tr>
<tr>
<td colspan="2">
<input type="submit" value="Submit" />
<a href="productList">Cancel</a>
</td>
</tr>
</table>
</form>
<jsp:include page="_footer.jsp"></jsp:include>
</body>
</html>
21. Die Information des Produkt ändern
Die Vorlage von der Funktion die Information der Produkt ändern
EditProductServlet.java
package org.o7planning.simplewebapp.servlet;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
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;
import org.o7planning.simplewebapp.beans.Product;
import org.o7planning.simplewebapp.utils.DBUtils;
import org.o7planning.simplewebapp.utils.MyUtils;
@WebServlet(urlPatterns = { "/editProduct" })
public class EditProductServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
public EditProductServlet() {
super();
}
// Die Seite der Produktsänderung anzeigen.
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Connection conn = MyUtils.getStoredConnection(request);
String code = (String) request.getParameter("code");
Product product = null;
String errorString = null;
try {
product = DBUtils.findProduct(conn, code);
} catch (SQLException e) {
e.printStackTrace();
errorString = e.getMessage();
}
// Keine Fehler.
// Das Produkt existiert nicht zur Bearbeitung (edit).
// Redirect zur Seite der Produktsliste
if (errorString != null && product == null) {
response.sendRedirect(request.getServletPath() + "/productList");
return;
}
// Die Information in Request attribute vor dem Weiterleiten nach views speichern.
request.setAttribute("errorString", errorString);
request.setAttribute("product", product);
RequestDispatcher dispatcher = request.getServletContext()
.getRequestDispatcher("/WEB-INF/views/editProductView.jsp");
dispatcher.forward(request, response);
}
// Nachdem der Benutzer die Produktsinformation ändert und klickt auf Submit.
// Die Methode wird implementiert.
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Connection conn = MyUtils.getStoredConnection(request);
String code = (String) request.getParameter("code");
String name = (String) request.getParameter("name");
String priceStr = (String) request.getParameter("price");
float price = 0;
try {
price = Float.parseFloat(priceStr);
} catch (Exception e) {
}
Product product = new Product(code, name, price);
String errorString = null;
try {
DBUtils.updateProduct(conn, product);
} catch (SQLException e) {
e.printStackTrace();
errorString = e.getMessage();
}
// Die Information in Request attribute vor dem Weiterleiten nach views speichern.
request.setAttribute("errorString", errorString);
request.setAttribute("product", product);
// Im Fall vom Fehler, forward zum Edit-Seite.
if (errorString != null) {
RequestDispatcher dispatcher = request.getServletContext()
.getRequestDispatcher("/WEB-INF/views/editProductView.jsp");
dispatcher.forward(request, response);
}
// Wenn Alles in Ordnung ist, redirect zur Seite der Produktsliste
else {
response.sendRedirect(request.getContextPath() + "/productList");
}
}
}/WEB-INF/views/editProductView.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Edit Product</title>
</head>
<body>
<jsp:include page="_header.jsp"></jsp:include>
<jsp:include page="_menu.jsp"></jsp:include>
<h3>Edit Product</h3>
<p style="color: red;">${errorString}</p>
<c:if test="${not empty product}">
<form method="POST" action="${pageContext.request.contextPath}/editProduct">
<input type="hidden" name="code" value="${product.code}" />
<table border="0">
<tr>
<td>Code</td>
<td style="color:red;">${product.code}</td>
</tr>
<tr>
<td>Name</td>
<td><input type="text" name="name" value="${product.name}" /></td>
</tr>
<tr>
<td>Price</td>
<td><input type="text" name="price" value="${product.price}" /></td>
</tr>
<tr>
<td colspan = "2">
<input type="submit" value="Submit" />
<a href="${pageContext.request.contextPath}/productList">Cancel</a>
</td>
</tr>
</table>
</form>
</c:if>
<jsp:include page="_footer.jsp"></jsp:include>
</body>
</html>22. Das Produkt löschen
No ADS
Die Vorlage der Funktion die Produkte löschen
DeleteProductServlet.java
package org.o7planning.simplewebapp.servlet;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
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;
import org.o7planning.simplewebapp.utils.DBUtils;
import org.o7planning.simplewebapp.utils.MyUtils;
@WebServlet(urlPatterns = { "/deleteProduct" })
public class DeleteProductServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
public DeleteProductServlet() {
super();
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Connection conn = MyUtils.getStoredConnection(request);
String code = (String) request.getParameter("code");
String errorString = null;
try {
DBUtils.deleteProduct(conn, code);
} catch (SQLException e) {
e.printStackTrace();
errorString = e.getMessage();
}
// Im Falle von Fehler, forward nach der Seite von Fehleranmeldung.
if (errorString != null) {
// Die Information in Request attribute vor dem Weiterleiten nach views speichern.
request.setAttribute("errorString", errorString);
//
RequestDispatcher dispatcher = request.getServletContext()
.getRequestDispatcher("/WEB-INF/views/deleteProductErrorView.jsp");
dispatcher.forward(request, response);
}
// Wenn Alles in Ordnung ist, redirect zur Seite der Produktsliste
else {
response.sendRedirect(request.getContextPath() + "/productList");
}
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}/WEB-INF/views/deleteProductErrorView.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Delete Product</title>
</head>
<body>
<jsp:include page="_header.jsp"></jsp:include>
<jsp:include page="_menu.jsp"></jsp:include>
<h3>Delete Product</h3>
<p style="color: red;">${errorString}</p>
<a href="productList">Product List</a>
<jsp:include page="_footer.jsp"></jsp:include>
</body>
</html>No ADS
Anleitungen Java Servlet/JSP
- Installieren Sie Tomcat Server für Eclipse
- Installieren Sie Glassfish Web Server unter Windows
- Führen Sie die Maven Java-Webanwendung im Tomcat Maven Plugin aus
- Führen Sie die Maven Java-Webanwendung im Jetty Maven Plugin aus
- Ausführen einer Hintergrundaufgabe in der Java Servlet-Anwendung
- Die Anleitung zum Java Servlet für den Anfänger
- Die Anleitung zu Java Servlet Filter
- Die Anleitung zum Java JSP für den Anfänger
- Die Anleitung zu Java JSP Standard Tag Library (JSTL)
- Installieren Sie WebToolsPlatform für Eclipse
- Erstellen Sie eine einfache Anmeldeanwendung und sichere Seiten mit Java Servlet Filter
- Erstellen Sie eine einfache Java Web Application mit Servlet, JSP und JDBC
- Hochladen und Herunterladen von Dateien die auf der Festplatte mit Java Servlet gespeichert sind
- Laden Sie mit Java Servlet Dateien aus der Datenbank hoch und laden Sie sie herunter
- Bild von Datenbank mit Java Servlet anzeigen
- Redirect 301 Permanentes Umleiten in Java Servlet
- Wie automatisch http auf https in einer Web-Anwendung Java umleiten?
- Verwenden Sie Google reCAPTCHA in der Java-Webanwendung
Show More