Mitarbeiterinformationenabfrage mit MVC und Servlet

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

Skills Graph

Sucheingabefeld erstellen

In diesem Schritt wirst du auf der Startseite ein Sucheingabefeld erstellen, in dem Benutzer die Mitarbeiter-ID eingeben können, um danach zu suchen.

1. Öffne die Datei index.jsp im Verzeichnis EmployeeInfo/src/main/webapp.

2. 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.

1. Öffne die Datei Employee.java im Verzeichnis EmployeeInfo/src/main/java/org/labex/entity.

2. 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.

1. Öffne die Datei JdbcUtil.java im Verzeichnis EmployeeInfo/src/main/java/org/labex/jdbc.

2. 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.

1. Öffne die Datei EmployeeDao.java im Verzeichnis EmployeeInfo/src/main/java/org/labex/dao.

2. 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.

1. Öffne die Datei EmployeeController.java im Verzeichnis EmployeeInfo/src/main/java/org/labex/controller.

2. Füge den folgenden Code hinzu, um die Methoden doGet() und doPost() 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.

1. Öffne die Datei info.jsp im Verzeichnis EmployeeInfo/src/main/webapp.

2. 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.

3. Wechsel in das Verzeichnis EmployeeInfo und 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.