Einführung
In diesem Projekt lernst du, wie du eine Funktion zur Abfrage von Mitarbeiterinformationen mit der MVC-Architektur und Servlet2.x implementierst. Du wirst auf der Startseite eine Suchbox erstellen, in der Benutzer die Mitarbeiter-ID eingeben können, um danach die Mitarbeiterinformationen auf einer separaten Seite anzuzeigen.
👀 Vorschau
🎯 Aufgaben
In diesem Projekt wirst du lernen:
- Wie du auf der Startseite eine Suchbox erstellst, um Benutzern die Möglichkeit zu geben, die Mitarbeiter-ID einzugeben
- Wie du die Entitätsklasse implementierst, um die Mitarbeiterdaten darzustellen
- Wie du die JDBC-Hilfsklasse implementierst, um eine Datenbankverbindung herzustellen
- Wie du die DAO-Klasse implementierst, um Mitarbeiterinformationen aus der Datenbank abzurufen
- Wie du die Controller-Klasse implementierst, um Anfragen zu verarbeiten und die Mitarbeiterdaten an die JSP-Seite weiterzuleiten
- Wie du die JSP-Seite implementierst, um die abgefragten Mitarbeiterinformationen anzuzeigen
🏆 Errungenschaften
Nach Abschluss dieses Projekts wirst du in der Lage sein:
- Die MVC-Architektur zur Strukturierung deiner Webanwendung zu verwenden
- Servlet2.x zum Verarbeiten von HTTP-Anfragen und -Antworten zu verwenden
- Mit einer Datenbank über JDBC zu interagieren
- JSP zum Anzeigen dynamischer Daten auf einer Webseite zu verwenden
Erstelle die Suchbox
In diesem Schritt wirst du auf der Startseite ein Sucheingabefeld erstellen, in dem Benutzer die Mitarbeiter-ID eingeben können, um danach zu suchen.
Öffne die Datei
index.jspim VerzeichnisEmployeeInfo/src/main/webapp.Füge den folgenden HTML-Code hinzu, um das Sucheingabefeld zu erstellen:
<form action="/findEmpByEid" method="get">
<input type="text" name="employeeId" /><input type="submit" value="suchen" />
</form>
Dieses Formular sendet einen GET-Anfrage an die URL /findEmpByEid mit dem Parameter employeeId, wenn der Benutzer auf die Schaltfläche "suchen" klickt.
Implementiere die Mitarbeiter-Entitätsklasse
In diesem Schritt wirst du die Entitätsklasse Employee.java basierend auf den Feldern in der Tabelle employees implementieren.
Öffne die Datei
Employee.javaim VerzeichnisEmployeeInfo/src/main/java/org/labex/entity.Füge den folgenden Code hinzu, um die Felder und deren zugehörige Getter- und Setter-Methoden zu definieren:
public class Employee {
private Integer id;
private String name;
private Integer gender;
private String phone;
private String email;
private String address;
// Getter- und Setter-Methoden
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// Implementiere die restlichen Getter- und Setter-Methoden
}
Implementiere die JDBC-Hilfsklasse
In diesem Schritt wirst du die Klasse JdbcUtil.java implementieren, um eine Methode zur Herstellung einer Datenbankverbindung bereitzustellen.
Öffne die Datei
JdbcUtil.javaim VerzeichnisEmployeeInfo/src/main/java/org/labex/jdbc.Füge den folgenden Code hinzu, um die Methode
getConn()zu implementieren:
public class JdbcUtil {
private static final String URL = "jdbc:mysql://localhost:3306/test";
private static final String BENUTZERNAME = "root";
private static final String PASSWORT = "";
static {
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static Connection getConn() {
Connection conn = null;
try {
conn = DriverManager.getConnection(URL, BENUTZERNAME, PASSWORT);
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
}
Diese Methode wird eine Datenbankverbindung zurückgeben, indem die bereitgestellte URL, der Benutzername und das Passwort verwendet werden.
Implementiere die DAO-Klasse
In diesem Schritt wirst du die Klasse EmployeeDao.java implementieren, um eine Methode zur Abfrage von Mitarbeiterinformationen bereitzustellen.
Öffne die Datei
EmployeeDao.javaim VerzeichnisEmployeeInfo/src/main/java/org/labex/dao.Füge den folgenden Code hinzu, um die Methode
getEmployee()zu implementieren:
public class EmployeeDao {
public Employee getEmployee(Integer employeeId) {
Connection conn = JdbcUtil.getConn();
String sql = "select * from employees where employee_id =?";
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
Employee employee = null;
try {
preparedStatement = conn.prepareStatement(sql);
preparedStatement.setInt(1, employeeId);
resultSet = preparedStatement.executeQuery();
if (resultSet.next()) {
employee = new Employee();
employee.setId(resultSet.getInt(1));
employee.setName(resultSet.getString(2));
employee.setGender(resultSet.getInt(3));
employee.setPhone(resultSet.getString(4));
employee.setEmail(resultSet.getString(5));
employee.setAddress(resultSet.getString(6));
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}
return employee;
}
}
Diese Methode verwendet die Methode getConn() aus JdbcUtil.java, um eine Datenbankverbindung herzustellen, und verwendet dann die von der Controller-Klasse übergebene Mitarbeiter-ID, um die Datenbank abzufragen und ein Employee-Objekt zurückzugeben.
Implementiere die Controller-Klasse
In diesem Schritt wirst du die Klasse EmployeeController.java implementieren, um die Anfragen zur Abfrage von Mitarbeiterinformationen zu verarbeiten.
Öffne die Datei
EmployeeController.javaim VerzeichnisEmployeeInfo/src/main/java/org/labex/controller.Füge den folgenden Code hinzu, um die Methoden
doGet()unddoPost()zu implementieren:
@WebServlet("/findEmpByEid")
public class EmployeeController extends HttpServlet {
EmployeeDao employeeDao = new EmployeeDao();
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String employeeId = req.getParameter("employeeId");
Employee employee = employeeDao.getEmployee(Integer.parseInt(employeeId));
req.setAttribute("employee", employee);
req.getRequestDispatcher("info.jsp").forward(req, resp);
}
}
Die doGet()-Methode erhält den Parameter employeeId aus der Anfrage, verwendet die Klasse EmployeeDao, um die Mitarbeiterinformationen abzurufen, speichert sie in der Anfrage und leitet dann die Anfrage an die Seite info.jsp weiter, um die Mitarbeiterinformationen anzuzeigen.
Implementiere die JSP-Seite
In diesem Schritt wirst du die Datei info.jsp implementieren, um die abgefragten Mitarbeiterinformationen anzuzeigen.
Öffne die Datei
info.jspim VerzeichnisEmployeeInfo/src/main/webapp.Füge den folgenden Code hinzu, um eine Tabelle zum Anzeigen der Mitarbeiterinformationen zu erstellen:
<%@ page import="org.labex.entity.Employee" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Mitarbeiterinformationen</title>
<style>
th, td {
border: 1px solid schwarz;
padding: 8px;
}
</style>
</head>
<body>
<% Object employeeObj = request.getAttribute("employee");
if (employeeObj!= null) {
Employee employee = (Employee) employeeObj; %>
<table>
<thead>
<tr>
<th>ID</th>
<th>Name</th>
<th>Geschlecht</th>
<th>Telefonnummer</th>
<th>E-Mail</th>
<th>Adresse</th>
</tr>
</thead>
<tbody>
<tr>
<td><%= employee.getId() %></td>
<td><%= employee.getName() %></td>
<td><%= employee.getGender() == 1? "mann" : "frau" %></td>
<td><%= employee.getPhone() %></td>
<td><%= employee.getEmail() %></td>
<td><%= employee.getAddress() %></td>
</tr>
</tbody>
</table>
<% } else { %>
<p>Informationen nicht gefunden.</p>
<% } %>
</body>
</html>
Diese JSP-Seite erhält das employee-Objekt aus der Anfrage und zeigt dann die Mitarbeiterinformationen in einer Tabelle an.
- Wechsel in das Verzeichnis
EmployeeInfound verwende den folgenden Befehl, um den Dienst zu starten.
cd ~/project/EmployeeInfo/
mvn clean tomcat7:run
Das erwartete Ergebnis der abgefragten Mitarbeiterinformationen ist wie folgt:
Zusammenfassung
Herzlichen Glückwunsch! Du hast dieses Projekt abgeschlossen. Du kannst in LabEx weitere Labore absolvieren, um deine Fähigkeiten zu verbessern.
