Java 如何在没有JSTL和EJB的情况下将数据从servlet输出到jsp

我的任务如下： 1.用户输入他们的登录名和密码。为此，我做了以下工作：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<div id="main">
    <aside class="leftAside">
        <h2>Authorization section</h2>
        <p>Please enter your login and password and press "Go!"</p>
    </aside>
    <section>
        <article>
            <h1>Authorization</h1>
            <div class="text">
                <form method="GET" action="authorization">
                    <p>
                        <label for="login">Login</label>
                        <input type="text" name="login" id="login"/>
                    </p>
                    <p>
                        <label for="password">Password</label>
                        <input type="password" name="password" id="password"/>
                    </p>
                    <p>
                        <button type="submit">Go!</button>
                    </p>
                </form>
            </div>
        </article>
    </section>
</div>

授权科
请输入您的登录名和密码，然后按“开始！”

授权

登录


密码


走！

如果确定，他们将返回访问历史记录，如果不确定，则再次登录页面，并标记授权失败。 我创建了所有连接和查询，但是如何管理它以及如何将所有数据输出到jsp？我不应该使用bean和jstl，而应该使用纯servlet

下面是我的servlet，我也不知道如何获取passwd并从用户处登录以进一步发送它

package Controller;

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 java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.sql.*;


@WebServlet(name = "controller", loadOnStartup=1, urlPatterns = {"/"})
public class web_controller extends HttpServlet {

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        String userPath=request.getServletPath();
        if ("/".equals(userPath)){
            request.getRequestDispatcher("/index.jsp").forward(request, response);
        }
        else {}
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        processRequest(request, response);

    }
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        processRequest(request, response);

    }
    private static Connection getSQLConnection() {
        Connection connection = null;
        String dbUser = "root";
        String dbPwd = "root";
        String dbUrl = "jdbc:mysql://localhost:3306/test";
        try {
            Class.forName("com.mysql.jdbc.Driver");
        }
        catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try {
            connection = DriverManager.getConnection(dbUrl, dbUser, dbPwd);
            return connection;
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }

    private static ResultSet history(Connection connection, String user) {
        ResultSet result = null;
        int userID = 0;
        try{
            PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM users WHERE login=?");
            preparedStatement.setString(1, user);
            result = preparedStatement.executeQuery();
            if (result.next()) {
                userID = result.getInt("id");
            }
            result = null;
        }
        catch (SQLException e) {
            e.printStackTrace();
        }

        try{
            PreparedStatement history = connection.prepareStatement("SELECT * FROM history WHERE login=?");
            getHistory.setInt(1, userID);
            result = history.executeQuery();
            return result;
        }
        catch (SQLException e) {
            e.printStackTrace();
        }

        return result;
    }
    }

    private static int USER_NOT_FOUND = 2;
    private static int WRONG_PWD = 0;
    private static int SUCCESS = 1;

    private static int checkUser(Connection connection, String user, String passwd) {
        ResultSet result = null;
        String pwdMD5 = getMD5(passwd);
        try{
            PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM users WHERE login=?");
            preparedStatement.setString(1, user);
            result = preparedStatement.executeQuery();
            if (result.next()) {
                String storedPwd = result.getString("passwd");
                if (storedPwd.equals(pwdMD5)) {
                    return SUCCESS;
                }
                else return WRONG_PWD;
            } else return USER_NOT_FOUND;
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }

    private static void addEntry(HttpServletRequest request, Connection connection, String user, String passwd, int success) {
        int userID = 0;

        try{
            PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM users WHERE login=?");
            preparedStatement.setString(1, user);
            ResultSet result = preparedStatement.executeQuery();
            result.next();
            userID = result.getInt("id");
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
        try{
            PreparedStatement updHistory = connection.prepareStatement("INSERT INTO history (user_id, success, ipaddr) VALUES (?,?,?,?)");
            updHistory.setInt(1, userID);
            updHistory.setInt(2, success);
            updHistory.setString(3, request.getRemoteAddr());
            ResultSet result = updHistory.executeQuery();
            result = updHistory.executeQuery();
        }
        catch (SQLException e) {
            e.printStackTrace();
        }

    }

    private static String getMD5(String pwd) {
        String generatedMD5 = null;
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(pwd.getBytes());
            byte[] bytes = md.digest();
            StringBuilder sbuilder = new StringBuilder();
            for(int i=0; i< bytes.length ;i++)
            {
                sbuilder.append(Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1));
            }
            generatedMD5 = sbuilder.toString();
        }
        catch (NoSuchAlgorithmException e)
        {
            e.printStackTrace();
        }
        return generatedMD5;

    }
}

包装控制器；
导入javax.servlet.ServletException；
导入javax.servlet.annotation.WebServlet；
导入javax.servlet.http.HttpServlet；
导入javax.servlet.http.HttpServletRequest；
导入javax.servlet.http.HttpServletResponse；
导入java.io.IOException；
导入java.security.MessageDigest；
导入java.security.NoSuchAlgorithmException；
导入java.sql.*；
@WebServlet（name=“controller”，loadOnStartup=1，urlPatterns={”/“}）
公共类web_控制器扩展HttpServlet{
受保护的void processRequest（HttpServletRequest请求、HttpServletResponse响应）
抛出ServletException、IOException{
setContentType（“text/html；charset=UTF-8”）；
字符串userPath=request.getServletPath（）；
如果（“/”.equals（userPath））{
request.getRequestDispatcher（“/index.jsp”）.forward（请求，响应）；
}
else{}
}
@凌驾
受保护的void doPost（HttpServletRequest请求、HttpServletResponse响应）引发ServletException、IOException{
processRequest（请求、响应）；
}
@凌驾
受保护的void doGet（HttpServletRequest请求，HttpServletResponse响应）抛出ServletException，IOException{
processRequest（请求、响应）；
}
私有静态连接getSQLConnection（）{
连接=空；
字符串dbUser=“root”；
字符串dbPwd=“root”；
String dbUrl=“jdbc:mysql://localhost:3306/test";
试一试{
Class.forName（“com.mysql.jdbc.Driver”）；
}
catch（classnotfounde异常）{
e、 printStackTrace（）；
}
试一试{
connection=DriverManager.getConnection（dbUrl、dbUser、dbPwd）；
回路连接；
}
捕获（SQLE异常）{
e、 printStackTrace（）；
}
回路连接；
}
私有静态结果集历史记录（连接、字符串用户）{
ResultSet result=null；
int userID=0；
试一试{
PreparedStatement PreparedStatement=connection.prepareStatement（“从登录名为？）的用户中选择*”；
preparedStatement.setString（1，用户）；
结果=preparedStatement.executeQuery（）；
if（result.next（））{
userID=result.getInt（“id”）；
}
结果=空；
}
捕获（SQLE异常）{
e、 printStackTrace（）；
}
试一试{
PreparedStatement history=connection.prepareStatement（“从历史记录中选择*登录=？”；
setInt（1，userID）；
结果=history.executeQuery（）；
返回结果；
}
捕获（SQLE异常）{
e、 printStackTrace（）；
}
返回结果；
}
}
私有静态int用户未找到=2；
私有静态int错误_PWD=0；
私有静态int SUCCESS=1；
私有静态int checkUser（连接、字符串用户、字符串密码）{
ResultSet result=null；
字符串pwdMD5=getMD5（passwd）；
试一试{
PreparedStatement PreparedStatement=connection.prepareStatement（“从登录名为？）的用户中选择*”；
preparedStatement.setString（1，用户）；
结果=preparedStatement.executeQuery（）；
if（result.next（））{
String storedPwd=result.getString（“passwd”）；
if（存储的WD.equals（pwdMD5））{
回归成功；
}
否则返回错误的\u PWD；
}否则返回未找到的用户；
}
捕获（SQLE异常）{
e、 printStackTrace（）；
}
返回0；
}
私有静态void addEntry（HttpServletRequest请求、连接、字符串用户、字符串passwd、int success）{
int userID=0；
试一试{
PreparedStatement PreparedStatement=connection.prepareStatement（“从登录名为？）的用户中选择*”；
preparedStatement.setString（1，用户）；
ResultSet result=preparedStatement.executeQuery（）；
result.next（）；
userID=result.getInt（“id”）；
}
捕获（SQLE异常）{
e、 printStackTrace（）；
}
试一试{
PreparedStatement updHistory=connection.prepareStatement（“插入历史记录（用户id、成功、ipaddr）值（？，？，？）”；
setInt（1，userID）；
updHistory.setInt（2，成功）；
setString（3，request.getRemoteAddr（））；
ResultSet result=updHistory.executeQuery（）；
结果=updHistory.executeQuery（）；
}
捕获（SQLE异常）{
e、 printStackTrace（）；
}
}
私有静态字符串getMD5（字符串pwd）{
字符串generatedMD5=null；
试一试{
MessageDigest md=MessageDigest.getInstance（“MD5”）；
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    processRequest(request, response);

    String login = request.getParameter("login");
    String password = request.getParameter("password");
}

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    processRequest(request, response);

    String login = request.getParameter("login");
    String password = request.getParameter("password");
}