7、Java Servlet基础

已于 2023-04-04 15:45:27 修改
阅读量603 收藏 7
点赞数 1
分类专栏： Java-EE 文章标签： servlet java 前端
于 2023-04-04 00:24:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ezzbb/article/details/129941964
版权

目录

1、什么是Servlet?

2、Servlet开发步骤

3、Servlet的配置 

 3.1、注解配置--@WebServlet支持的常用属性

 3.2web.xml中配置Servlet

 4、 Servlet的生命周期

 4.1加载和实例化

4.2初始化 

4.3请求处理

4.4服务终止 

通过JSP页面访问Servlet

通过表单访问Servlet

通过超链接访问Servlet

doGet()和doPost()方法

5、在Servlet中获得JSP内置对象

获得 request 和 response 对象：

获得out对象：

中文乱码问题的解决：

获得 session 对象：

获得 application对象：

6、 Servlet跳转

重定向

服务器内跳转(请求转发方式跳转)

1、获得RequestDispatcher对象

2、使用RequestDispatcher对象调用forward0方法实现转发

7、在Java Servlet中使用session

8、在Servlet 中读取参数

为什么要在配置文件(如web.xml)设置参数?

参数的种类及设定

在Web.xml中配置全局参数(独立于Servlet)：

全局参数的获取方法：

在Web.xml中配置局部参数：

局部参数的获取方法：

使用注解在Servlet中配置局部参数：

9、设置欢迎页面

9.1设置欢迎页面的方法

10、基于Servlet的MVC模式

10.1MVC模式

例题： 使用JSP、Servlet、JavaBean 实现 MVC

10.2模型周期

（1）request周期的模型

(2)Session周期模型

(3)application周期的模型

1、什么是Servlet?

Servlet是用Java语言编写的服务器端小程序，驻留在web服务器中，并在其中运行，可以生成动态的  Web  页面。

JSP页面在执行时都要编译成Servlet。

JSP和Servlet两者可以实现同样的页面效果，不过，编写 JSP 和编写 Servlet 相比，JSP成本低得多。

 编写一个Servlet类，只要继承javax.servlet.http包中的HttpServlet类，并重写响应HTTP请求的方法即可。HttpServlet类实现了Servlet接口，实现了响应用户请求的接口方法。HttpServlet类的一个子类习惯的称为一个Servlet类，这样的子类创建的对象有称为Servlet对象。

编写第一个Servlet类

package servlet;

import jakarta.servlet.ServletConfig;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

public class firstServlet extends HttpServlet {
    private static final long serialVersionUTD = 1L;
    public  void init(ServletConfig config) throws ServletException{
        super.init(config);
    }

    @Override
    public void service(HttpServletRequest req, HttpServletResponse resp) throws  IOException {
        //设置响应的内容类型
        resp.setContentType("text/html;charset=utf-8");
        //获取输出的对象
        PrintWriter out  = resp.getWriter();
        out.println("<html><body>");
        //在浏览器中显示“第一个Servlet类”
        out.println("第一个Servlet类");
        out.println("</body></html>");
    }
}

在web.xml中部署Servlet：

<servlet>
        <servlet-name>firstServlet</servlet-name>
        <servlet-class>servlet.firstServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>firstServlet</servlet-name>
        <url-pattern>/firstServlet</url-pattern>
    </servlet-mapping>

运行！

编写Servlet时必须有包名。新建一个包，所有的Servlet类放在包中（src目录下的servlet包中）。

编写完Servlet累的源文件，并编译了源文件，需要部署Servlet才可以运行Servlet对象。

部署方法有两种：

1、在web.xml中部署Servlet；

2、基于注解的方式部署Servlet

2、Servlet开发步骤

1、创建Servlet文件(new/Create New Servlet)；

默认继承 javax.servlet.http.HttpServlet;

2、编写处理请求的方法

重写 HttpServlet 的 doGet()、doPost()方法;

或重写doService（）方法

3、配置Servlet

在web.xml中配置Servlet 或 采用注解方式配置Servlet

3、Servlet的配置 

从Servlet 3 开始，配置Servlet有两种方式

1、在Servlet类中使用@WebServlet注解进行配置

2、在web.xml中配置Servlet

注解配置示例

注解虽然方便了开发人员，但在后期会让维护和调试成本增加。为了方便后期维护,建议开发人员部署Servlet时把@WebServlet的属性urlPatterns 的值设置为Servlet类的名字。

@WebServlet(name ="secondServlet"，urlPatterns ={ "/secondServlet"}）
public class SecondServlet extends HttpServlet {

}

 3.1、注解配置--@WebServlet支持的常用属性

@WebServlet用于将一个类声明为Servlet对象,该注解将会在部署时被Web容器处理Web 容器根据具体属性将相应的类部署为 Servlet 对象。该注解具有一些常用属性，

表中的所有属性均为可选属性，但是value 或者urlPatterns通常是必需的，且二者不能共存，如果同时指定，通常是忽略 value 的取值。可使用简化注解，如@WebServlet("/secondServlet")，其中“/secondServlet”为请求的URL，即urlPatterns 属性值。

使用了@WebServlet注解部署后就不需要再使用web.xml部署了

注意：部署描述文件web.xml 的顶层标签 <web-app> 有一个 metadata-complete 属性，用于指定当前的部署描述文件是否是完全的。

如果设置为 true，则容器在部署时将只依赖部署描述文件，忽略所有的注解。

 3.2web.xml中配置Servlet

配置Servlet的名字：对应web.xml的<servlet/>元素。

配置Servlet的URL：对应web.xml的<servlet-mapping/>元素。

格式如下：

<servlet>
	<servlet-name>servlet名称</servlet-name>
	<servlet-class>servlet包名.类名</servlet-class>
</servlet>
<servlet-mapping>
	<servlet-name>servlet名称</servlet-name>
	<url-pattern>url映射名(访问路径)</url-pattern>
</servlet-mapping>

<servlet-name>：标记Web服务器创建Servlet对象的名字。web.xml可以有若干个<servlet>标记，但要求他们的<servlet-name>子标记的内容互不相同。

<servlet-class>：指定Web服务器用哪个类来创建Servlet对象；如果Servlet对象已经创建，那么Web服务器就不在使用指定的类创建。

<servlet-mapping>：和<servlet>标记成对出现。

<servlet-name>：标记Web服务器创建Servlet对象的名字。（改名字必须和<servlet>标记的子标记<servlet-name>的内容相同）

<url-patten>:指定用户用怎么样的方式请求Servlet对象。，例如，<url-pattern>子标记的内容是“/firstServlet”，用户需要请求服务器运行Servlet对象 firstServlet为其服务，那么可在浏览器的地址栏中输入“http://localhost:8080/ch6/firstServlet”。

示例：

<!--配置Servlet的名字-->  
<servlet>
        <servlet-name>WelcomeServlet</servlet-name>
        <servlet-class>servlet.WelcomeServlet</servlet-class>
</servlet>
< !--配置Servlet的URL--> 
<servlet-mapping>
      <servlet-name>WelcomeServlet</servlet-name>
	  <url-pattern>/welcomeServlet</url-pattern>
</servlet-mapping>

 4、 Servlet的生命周期

Servlet实际上是一个Java类，可以创建其实例，这些对象也有自己的生命周期。

包括以下4个阶段：

  1. 加载和实例化（一次，普通Servlet是用户第一次请求的时候实例化，但是load-on-startup是应用启动的时候实例化）当Servlet对象第一次被请求加载时，服务器会创建一个Servlet对象。
  2. 初始化：Servlet对象调用init()方法（一次，实例化之后执行）
  3. 请求处理：调用service()方法（每次请求执行一次）
  4. 服务终止：调用destroy()方法（一次，通常在关闭Web容器或将项目移除容器之时销毁Servlet）

 4.1加载和实例化

Servlet实例的创建和销毁等都不是由程序员决定的，而是由Web容器进行控制的。

创建Servlet实例的时机有两个：

  1. 客户端请求对应的Servlet时，创建Servlet实例：大部份的Servlet都是这种Servlet。
  2. Web应用启动时，立即创建Servlet实例：即load-on-startup Servlet。

注意：应用启动时就启动的Servlet，通常是用于某些后台服务的Servlet，或者拦截很多请求的Servlet。 

Servlet容器负责加载和实例化，是否在容器启动时自动加载Servlet，这由在web.xml中设置的<load-on-startup>属性决定或@WebServlet中loadOnStartup决定 

4.2初始化 

 调用init()方法在处理用户请求前完成初始化工作。若初始化失败，将抛出ServletException或UnavailableException异常，实例销毁。

4.3请求处理

  1. Servlet实例化后接收客户端请求、作出响应，都是通过调用service()方法来实现的。
  2. 由于Servlet采用多线程机制来提供服务，因此，该方法被同时、多次地调用，要注意线程安全。
  3. 用户在实现具体的Servlet时，web容器会根据请求方式的不同自动调用doGet()、doPost()方法，因此，只要重载对应的doXxx()即可，一般不重载service()方法。

4.4服务终止 

服务器通过调用destroy方法释放Servlet运行时所占用的资源，该方法不用抛出异常。

public void destroy( ) {
	//释放在init()中获得的资源，如关闭数据库的连接
	super.destroy( );
}

注意：不要将Servlet的销毁机制作为向磁盘上保存诸如访问计数或Cookie列表等状态的唯一机制。因为web容器有可能崩溃，destroy()方法不一定总被执行。

通过JSP页面访问Servlet

可以通过JSP页面的表单或者超链接请求某个Servlet。通过JSP页面访问Servlet的好处是：JSP页面负责的静态信息处理，而动态信息处理由Servlet完成。

通过表单访问Servlet

<form action="firstServlet" method="post">
    ...
</form>

该表单的处理程序 (action)就是一个 Servlet，为该 Servlet 部署时，@WebServlet
的urlPattemms属性值为“/firstServlet"

通过超链接访问Servlet

在JSP页面中，可以单击超链接访问 Servlet 对象，也可以通过超链接向 Servlet 提交信息，例如,

<ahref="loginServlet?user-taipingle&&pwd=zhenzuile">查看用户名和密码</a>“查看用户名和密码”这个超链接就将 user-taipingle和pwd=zhenzuile两个信息提交给Servlet 处理。

doGet()和doPost()方法

  1.         当服务器接收到一个 Servlet 请求时，就会产生一个新线程，在这个线程中Servlet 对象调用 service（）方法为请求做出响应。service（）方法首先检查 HTTP 请求类型(get 或post),然后在 service（）方法中根据用户的请求方式,对应地调用 doGet（）或doPost（）方法。
  2.         HTTP请求类型为 get 方式时，service（）方法调用doGet（）方法响应用户请求;
  3.         HTTP请求类型为 post 方式时，service(）方法调用doPost（）方法响应用户请求。因此，在 Servlet 类中，没有必要重写 service0方法，直接继承即可。
  4.         在Servlet类中重写doGet（）或doPost（）方法来响应用户的请求，这样可以增加响应的灵活性，同时减轻服务器的负担。
  5.         一般情况下，如果不论用户请求类型是 get 还是 post，服务器的处理过程完全相同,那么可以只在doPost（）方法中编写处理过程，而在doGet（）方法中再调用 doPost（）方法:或只在doGet（）方法中编写处理过程，而在 doPost（）方法中再调用 doGet（）方法。

例题：

inputLader.jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>inputLader.jsp</title>
</head>
<body>
<h2>输入矩形的长和宽，提交给servlet（post方式）求面积：</h2>
<form action="GetLengthOrAreaServlet" method="post">
    长：<input type="text" name="length"/><br>
    宽：<input type="text" name="width"/><br>
    <input type="submit" value="提交">

</form>
<br>
<h2>输入矩形的长和宽，提交给servlet（get方式）求周长：</h2>
<form action="GetLengthOrAreaServlet" method="get">
    长：<input type="text" name="length"/><br>
    宽：<input type="text" name="width"/><br>
    <input type="submit" value="提交">

</form>
</body>
</html>

GetLengthOrAreaServlet页面：
package servlet;

import jakarta.servlet.*;
import jakarta.servlet.http.*;
import jakarta.servlet.annotation.*;

import java.io.IOException;
import java.io.PrintWriter;

@WebServlet(name = "GetLengthOrAreaServlet", value = "/GetLengthOrAreaServlet")
public class GetLengthOrAreaServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();
        String l = request.getParameter("length");
        String w= request.getParameter("width");
        out.println("<html><body>");
        double m =0,n=0;
        try{
            m=Double.parseDouble(l);
            n=Double.parseDouble(w);
            out.println("矩形的周长是："+(m+n)*2);
        }catch (NumberFormatException e){
            out.println("请输入字符！");
        }
        out.println("</body></html>");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();
        String l = request.getParameter("length");
        String w= request.getParameter("width");
        out.println("<html><body>");
        double m =0,n=0;
        try{
            m=Double.parseDouble(l);
            n=Double.parseDouble(w);
            out.println("矩形的面积是："+m*n);
        }catch (NumberFormatException e){
            out.println("请输入字符！");
        }
        out.println("</body></html>");
    }
    }

结果：

5、在Servlet中获得JSP内置对象

1、JSP的内置对象在Servlet中不能直接使用，需自己创建；

2、获得JSP的内置对象方法：

获得 request 和 response 对象：

public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
	//将 request 参数当成 request 对象使用 
	//将 response 参数当成 response 对象使用 
}

获得out对象：

对应于javax.servlet.jsp.JspWriter类

PrintWriter out = response.getWriter();

中文乱码问题的解决：

把下列语句放在out输出语句之前

response.setContentType(“text/html;charset=utf-8”);

或 response.setChararcterEncoding(“utf-8”);

获得 session 对象：

对应于javax.servlet.http.HttpSession类

HttpSession session = request.getSession();

获得 application对象：

对应于javax.servlet. ServletContext类

ServletContext application = this.getServletContext(); 

6、 Servlet跳转

JSP的跳转方法：

response.sendRedirect( 目标路径 )

<jsp:forward  page=“目标路径” />

在Servlet 中也有类似功能的语句。

重定向

response.sendRedirect(“URL地址”)

服务器内跳转(请求转发方式跳转)

1、获得RequestDispatcher对象

当前 JSP页面或 Servlet 中，使用 request 对象调用

public RequestDispatchergetRequestDispatcher(String url)方法返回一个RequestDispatcher 对象，其中参数url就是要转发的JSP页面或Servlet的地址。例如:

RequestDispatcher dis=request.getRequestDispatcher("dologin");

2、使用RequestDispatcher对象调用forward0方法实现转发

获得RequestDispatcher 对象之后，就可以使用该对象调用public voidforward(ServletRequest request,ServletResponse response)方法将用户对当前JSP页面或Servlet的请求转发给 RequestDispatcher 对象所指定的JSP页面或Servlet。例如:

dis.forward(request,response)

总结如下：

//ServletContext application=this.getServletContext();

RequestDispatcher rd=application.getRequestDispatcher(“URL地址”);

rd.forward(request,response);

        转发是服务器行为，重定向是客户端行为。具体工作流程如下:

  1.         转发过程:客户浏览器发送 http 请求，Web 服务器接收此请求，调用内部的一个方法在容器内部完成请求处理和转发动作，将目标资源发送给客户，在这里，转发的路径必须是同一个 Web 容器下的URL，不能转向到其他的 Web 路径上去，中间传递的是自己的容器内的 request。在客户浏览器的地址栏中显示的仍然是其第一次访问的路径，也就是说客户是感觉不到服务器做了转发的。转发行为是浏览器只做了一次访问请求。
  2.         重定向过程:客户浏览器发送http 请求，Web 服务器接收后发送302状态码响应及对应新的 location 给客户浏览器，客户浏览器发现是 302 响应，则自动再发送一个新的 http请求，请求URL是新的location 地址，服务器根据此请求寻找资源并发送给客户。在这里，location 可以重定向到任意URL，既然是浏览器重新发出了请求，就没有什么request 传递的概念了。在客户浏览器的地址栏中显示的是其重定向的路径，客户可以观察到地址的变化。重定向行为是浏览器做了至少两次的访问请求。 

注意：两种方式URL地址写法不一样。

重定向，如果写绝对路径，必须将虚拟目录根目录写在里面，如“/Prj05/page.jsp”;

请求转发，不需将虚拟目录根目录写在里面，如“/page.jsp”。

7、在Java Servlet中使用session

在Servlet中获得当前请求的会话对象可通过调用 HttpServletRequest的getSession0方法实现，例如:

HttpSession session = request.getSession(true);//若存在会话则返回该会话，否则新建一个会话

 或者

HttpSession session = request,getSession(false);//若存在会话则返回该会话，否则返回null

通常情况下，通过第一种方式获得session，即指定getSession（）的参数为true。默认参数为 true，即request.getSession(true)等同于request.getSession（）。

例子：

 编写JSP页面useSession.jsp,在该页面中通过表单向名为useSession的Servlet对象(由UseSessionServlet类负责创建)提交用户名,useSession将用户名存入用户的session对象中，然后用户请求另一个Servlet 对象showName(由ShowNameServlet 类负责创建),showName从用户的session 对象中取出存储的用户名，并显示在浏览器中。程序运行效果如图所示。

useSession.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="sendMyName" method="post">
  <table>
    <tr>
      <td>用户名：</td>
      <td><input type="text" name="user"></td>
    </tr>
    <tr>
      <td><input type="submit" value="提交"></td>
    </tr>
  </table>
</form>
</body>
</html>

UseSessionServlet
package servlet;

import jakarta.servlet.*;
import jakarta.servlet.http.*;
import jakarta.servlet.annotation.*;

import java.io.IOException;
import java.io.PrintWriter;

@WebServlet(name = "UseSessionServlet", value = "/sendMyName")
public class UseSessionServlet extends HttpServlet {
    public void init(ServletConfig config) throws ServletException{
        super.init(config);
    }
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }


    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out=response.getWriter();
        request.setCharacterEncoding("utf-8");
        String name=request.getParameter("user");
        if(name==null||name.trim().length()==0){
            response.sendRedirect("userSession.jsp");
        }else{
            HttpSession session=request.getSession();
            session.setAttribute("myName",name);
            out.println("<html><body>");
            out.println("您请求的servlet对象是："+getServletName());
            out.println("<br>您的会话ID是"+session.getId());
            out.println("<a href='showMyName'>请求另一个servlet</a>");
            out.println("</body></html>");
        }
    }
}

ShowNameServlet
package servlet;

import jakarta.servlet.*;
import jakarta.servlet.http.*;
import jakarta.servlet.annotation.*;

import java.io.IOException;
import java.io.PrintWriter;

@WebServlet(name = "ShowNameServlet", value = "/showMyName")
public class ShowNameServlet extends HttpServlet {
    public void init(ServletConfig config) throws ServletException{
        super.init(config);
    }
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out=response.getWriter();
        HttpSession session=request.getSession(true);
        String name=(String) session.getAttribute("myname");

        out.println("<html><body>");
        out.println("您请求的servlet对象是："+getServletName());
        out.println("<br>您的会话ID是"+session.getId());
        out.println("<br>您会话中存储的用户名是："+name);
        out.println("</body></html>");
    }
}

8、在Servlet 中读取参数

为什么要在配置文件(如web.xml)设置参数?

  1. 若参数写定在程序中，这称为“硬编码”。用这种方法修改参数，需要修改源程序，重新编译。
  2. 在web.xml设置参数，web容器可以自动读取，成本较低。

参数的种类及设定

参数种类：有2种

全局参数：所有Servlet都可以访问(ServletContext对象)

局部参数：只有相应的Servlet才能访问(ServletConfig对象)

在Web.xml中配置全局参数(独立于Servlet)：

<context-param> 
	<param-name>参数名</param-name> 
	<param-value>参数值</param-value> 
</context-param>

全局参数的获取方法：

ServletContext application = this.getServletContext(); 
application.getInitParameter("参数名称");

在Web.xml中配置局部参数：

<servlet> 
	<servlet-name>Servlet 名称</servlet-name> 
	<servlet-class>Servlet 类路径</servlet-class> 
	<init-param> 
		<param-name>参数名</param-name> 
		<param-value>参数值</param-value> 
	</init-param> 
</servlet>

局部参数的获取方法：

this.getInitParameter("参数名称");

说明：此处的 this 是指 Servlet 本身 

使用注解在Servlet中配置局部参数：

@WebServlet(
	 initParams={
		@WebInitParam(name="url",    value="jdbc:mysql://localhost:3306/javaee"),
		@WebInitParam(name="user", value="sise"),		
        @WebInitParam(name="pass", value="123456")
	}
)

9、设置欢迎页面

为什么要设置欢迎页面?

在很多的门户网站中，都会把自己的首页作为网站的欢迎页面。设置完欢迎页面后，用户登录时输入的 URL 只需为该门户网站的虚拟路径时，就可以自动访问欢迎页面，不必输入访问的文件名。

   例如：http://www.sina.com.cn

这样做的好处是：用户不必知道首页的文件名，服务器端可以根据需要，在不同时间设置多个首页文件。

9.1设置欢迎页面的方法

<welcome-file-list> 
	<!--  所要设定的欢迎页面  --> 
	<welcome-file>welcome.jsp</welcome-file> 
	<welcome-file>index.jsp</welcome-file>
   </welcome-file-list>

规则：web.xml 可以同时设置多个欢迎页面，Web 容器会默认设置的第一个页面为欢迎页面，如果找不到最前面的页面，Web 容器将会依次选择后面的页面为欢迎页面。

10、基于Servlet的MVC模式

10.1MVC模式

（1）MVC的概念

MVC是Model、View、Controller 的缩写，分别代表 Web 应用程序中的3种职责。
1、模型:用于存储数据以及处理用户请求的业务逻辑。
2、视图:向控制器提交数据，显示模型中的数据。
3、控制器:根据视图提出的请求，判断将请求和数据交给哪个模型处理，处理后的有关结果交给哪个视图更新显示。

（2）基于Servlet的MVC模式

基于Servlet的MVC模式的具体实现如下。

  1.         模型:一个或多个JavaBean对象，用于存储数据(实体模型由JavaBean类创建)和处理业务逻辑(业务模型，由一般的Java类创建)。
  2.         视图:一个或多个JSP页面，向控制器提交数据和为模型提供数据显示，JSP页面主要使用HTML标记和JavaBean 标记来显示数据。
  3.         控制器:一个或多个 Servlet 对象，根据视图提交的请求进行控制，即将请求转发给处理业务逻辑的JavaBean,并将处理结果存放到实体模型 JavaBean 中,输出给视图显示。

例题： 使用JSP、Servlet、JavaBean 实现 MVC

使用MVC模式实现简单的用户登录验证程序，其中包括实体模型 User、业务模型 UserCheck、控制器 LoginCheckServlet 和两个视图页面，即登录页面和登录成功页面。

（1）定义实体模型来表示数据

User 类用于创建实体模型存储用户信息

package dto;

public class User {
    private String name;
    private  String pwd;
    public String getName(){
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

（2）定义业务模型来处理业务

UserCheck 类用于判断用户名和密码是否正确

package service;
import dto.User;
public class UserCheck {
    public boolean validate(User user){
        if (user!=null && user.getName().equals("JSPMVC")){
            if(user.getPwd().equals("MVC")){
                return  true;
            }
            return false;
        }
        return false;
    }
}

（3）编写Servlet处理请求

LoginCheckServlet 完成请求控制

package servlet;

import dto.User;
import jakarta.servlet.*;
import jakarta.servlet.http.*;
import jakarta.servlet.annotation.*;
import service.UserCheck;

import java.io.IOException;

@WebServlet(name = "LoginCheckServlet", value = "/LoginCheckServlet")
public class LoginCheckServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");
        String name = request.getParameter("name");
        String pwd=request.getParameter("pwd");
        User user = new User();//实例化实体模型user
        user.setName(name);//将数据存在模型user中
        user.setPwd(pwd);//将数据存在模型user中
        UserCheck uc  =new UserCheck();//实例化业务模型userCheck
        if(uc.validate(user)){
            //将装有数据的实体模型user存储到request范围内
            request.setAttribute("user" ,user);
            RequestDispatcher dis=request.getRequestDispatcher("loginSuccess.jsp");
            dis.forward(request,response);
        }else{
            response.sendRedirect("loginCheck.jsp");
        }


    }
}

(4)编写视图

登录页面loginCheck,jsp 的代码如下:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="LoginCheckServlet" method="post">
<table>
  <tr>
    <td>用户名：</td>
    <td><input type="text" name="name"/></td>
  </tr>
  <tr>
    <td>密码：</td>
    <td><input type="password" name="pwd"/></td>
  </tr>
  <tr>
    <td><input type="submit" value="提交"/></td>
    <td><input type="reset" value="重置"/></td>
  </tr>
</table>
</form>
</body>
</html>

登录成功页面loginSuccess.jsp 的代码如下

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<jsp:useBean id=" user" type="dto.User" scope="request"/>
恭喜<jsp:getProperty name=" user" property="name"/>登陆成功！
</body>
</html>

10.2模型周期

在基于Servlet的MVC模式中，控制器Servlet 创建的实体模型JavaBean也涉及生命周期，生命周期分别为request、session 和application。下面以例题中的实体模型user来讨论这三种生命周期的用法

（1）request周期的模型

创建模型并将数据保存到模型中

在Servlet中需要这样的代码:

User user=new User ();//实例化模型user
user:setName(name);//将数据存在模型user中
user.setPwd(pwd);//将数据存在模型user中

将模型保存到request对象中并转发给视图JSP

在Servlet中需要这样的代码:

request.setAttribute("user",user);//将装有数据的模型user输出给视图loginSuccess.jsp 页面

RequestDispatcher dis=request.getRequestDispatcher("loginSuccess.jsp");
dis.forward(request,response);

request.setAttribute(”user"，user)这句代码指定了查找 JavaBean 的关键字，并决定了
JavaBean的生命周期为 request。

视图更新
Servlet 所转发的页面，如 loginSuccessjsp 页面，必须使用 useBean 标记获得 Servlet所创建的JavaBean 对象(视图不负责创建JavaBean)

在JSP页面中需要使用这样的代码:

<jsp:useBean id="user" type="dto.User" scope="request"/>
<jsp:getProperty property="name" name="user"/>

标记中的id 就是 Servlet 所创建的模型 JavaBean，它和request 对象中的关键字对应。因为在视图中不创建JavaBean对象，所以在useBean标记中使用type属性，而不使用class属性。useBean标记中的scope必须和存储模型时的范围(request)一致。

(2)Session周期模型

创建模型并将数据保存到模型中

User user = new User();//实例化模型user
user.setName(name);/将数据存在模型user中
user.setPwd(pwd);//将数据存在模型user中

 将模型保存到session对象中并转发给视图JSP

session.setAttribute("user",user);//将装有数据的模型user输出给视图loginSuccess.jsp 页面

RequestDispatcher dis=request.getRequestDispatcher("loginSuccess.jsp");
dis.forward(request,response);

session.setAttribute("user"，user)这句代码指定了查找 JavaBean 的关键字，并决定了JavaBean的生命周期为 session。

视图更新

Servlet 所转发的页面，如 lginSuccess,jsp 页面，必须使用 useBean 标记获得 Servlet所创建的JavaBean对象(视图不负责创建 JavaBean)

<jsp:useBean id="user" type="dto.User" scope="session"/>
<jsp:getProperty property="name" name="user"/>

标记中的id就是 Servlet 所创建的模型JavaBean，它和session 对象中的关键字对应。因为在视图中不创建 JavaBean 对象，所以在 useBean 标记中使用type属性，而不使用class属性。useBean标记中的scope必须和存储模型时的范围(session)一致。

注:对于生命周期为 session 的模型，Servlet 不仅可以使用 RequestDispatcher 对象转发给JSP页面，还可以使用response 的重定向方法(sendRedirect0)定向到JSP页面

(3)application周期的模型

创建模型并将数据保存到模型中

User user = new User();//实例化模型user
user.setName(name);//将数据存在模型user中
user.setPwd(pwd);//将数据存在模型user中

将模型保存到application对象中并转发给视图JSP

application.setAttribute("user",user);//将装有数据的模型user输出给视图loginSuccess.jsp 页面

RequestDispatcher dis=request.getRequestDispatcher("loginSuccess.jsp");
dis.forward(request,response);

“application.setAttribute("user",user);这句代码指定了查找JavaBean的关键字，并决定了JavaBean的生命周期为application。

视图更新

Servlet 所转发的页面，例如 loginSuccess,jsp 页面，必须使用 useBean 标记获得 Servlet所创建的JavaBean对象(视图不负责创建JavaBean)。

<jsp:useBean id="user" type="dto.User" scope="application"/>
<jsp:getProperty property="name" name="user"/>

标记中的id 就是Servlet 所创建的模型JavaBean，它和application 对象中的关键字对应。因为在视图中不创建JavaBean对象，所以在 useBean标记中使用 type 属性，而不使用class 属性。useBean标记中的 scope 必须和存储模型时的范围(application)一致。

注:对于生命周期为session或application的模型，Servlet 不仅可以使用RequestDispatcher对象转发给JSP页面还可以使用response 的重定向方法(sendRedirect（）)）定向到JSP页面

Java Web程序设计课后习题答案 第四章
m0_61023501的博客
01-03 2649
1.如果当前Web资源不想处理请求， RequestDispatcher接口提供了一个 forward()方法，该方法可以将当前请求传递给其他Web资源对这些信息进行处理并响应给客户端,这种方式称为请求转发。3. 重定向指的是Web服务器接收到客户端的请求后，可能由于某些条件限制，不能访问当前请求URL所指向的Web资源，而是指定了一个新的资源路径，让客户端重新发送请求。1.程序中创建了一个Servlet，该Servlet重写了其父类的doGet()和doPost()方法，那么其父类可能是D。
Java Web基础 --- Servlet 综述(理论篇)
Rico's Blogs
03-09 7580
Web 技术成为当今主流的互联网Web应用技术之一，而Servlet是Java Web技术的核心基础。本文首先从请求/响应架构应用的大背景谈起Servlet的由来，明确Servlet的产生动机，揭示了Servlet的本质。紧接着讲述了Servlet族的继承结构，Servlet的生命周期、Servlet执行流程，Servlet与并发的联系，Servlet与 MVC 的联系等，使我们对Servlet有一个更深刻的认识。
java中的Servlet基础
雪落无痕的博客
08-30 368
Servlet基础Servlet 简介什么是ServletServlet与JSP的关系Servlet APIServlet 接口GebericServlet抽象类HttpServlet 抽象类ServletConfig接口ServletContext 接口ServletRequset 和HttpServletRequset 接口ServletResponse 和HttpServletResponse接口 Servlet 简介 什么是Servlet Servlet 是一个符合特定规范的Java程序，是一个基于
Java Web——Servlet基础
宁zz的博客
07-12 641
目录Servlet 是什么？Servlet 架构Servlet 任务Servlet 包Servlet 生命周期init() 方法service() 方法doGet() 方法doPost() 方法destroy() 方法架构图以下为生命周期的一个简单实例：Servlet 实例Servlet 表单数据GET 方法重定向总结：Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。使用
Java基础 - servlet(一)
java123456111的博客
04-11 1229
1、servlet应用实例 1、客户端提交一个表单数据访问服务端的整个流程图： ​ 客户端访问add.html页面并通过Http Request携带表单请求数据，通过web.xml中的映射关系，找到AddServlet类中的doPost方法，并执行该方法。 2、编写一个add.html表单提交页面 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title&
JavaWeb之Servlet基础（更新中）
qq_38596491的博客
07-05 269
一、概念 Servlet是JavaEE规范之一，规范就是接口； Servlet是JavaWeb三大组件之一，分别是Servlet程序、Filter过滤器、Listener监听器； Servlet是运行在服务器上的一个Java小程序，它可以接收客户端发送过来的请求，并响应数据给客户端。 二、具体实现 1、编写一个类去实现Servlet接口； 2、实现Servlet方法，处理请求，并响应数据； 3、到web.xml中去配置Servlet程序的访问地址。 /:斜杆在服务器解析的时候，表示地址为http://i
JavaServlet应用基础.rar_servlet
09-14
JavaServlet应用基础是一个针对初学者的教程，涵盖了JavaServlet的核心概念和基本用法。Servlet是Java编程语言中用于扩展Web服务器功能的接口，是构建动态Web应用的重要技术。本教程旨在帮助初学者理解和掌握Servlet...
第七章 Java Servlet基础（新）1
08-03
Java Servlet基础是Java Web开发中的核心概念，它是JSP技术的基础。Servlet是一种特殊的Java类，设计用于在服务器端处理HTTP协议请求。在第七章中，我们将深入理解Servlet的部署、创建、运行，以及如何通过JSP页面...
基于Java的servlet学习基础设计源码
最新发布
04-07
本项目是一个基于Java语言开发的servlet学习基础项目，包含25个文件，主要文件类型包括XML配置文件、Java源代码、JAR包、...系统设计旨在为用户提供一个servlet基础学习示例，以帮助用户更好地理解和掌握servlet技术。
JSP学习笔记 09 – Java Servlet基础
12-21
本文将使用 javax.servlet.http 包中的类 ，javax.servlet.http 包不在JDK 的核心类库中， 因此需要将 Tomcat 安装目录lib 子...因此， 学习JavaServlet的首要任务是掌握怎样编写创建servlet的类、怎样在 Tomcat服务
servlet基础知识_动力节点Java学院整理
08-29
Servlet 基础知识 Servlet 是一种专门用于开发动态 web 资源的技术，由 Sun 公司在其 API 中提供了一个 Servlet 接口。狭义的 Servlet 是指这个接口，广义的 Servlet 是指任何实现了这个 Servlet 接口的类。 ...
javabean+servlet+jsp实现圆的面积和周长计算，还有注册信息然后输出
10-18
javabean+servlet+jsp实现圆的面积和周长计算，还有注册信息然后输出
前端与Servlet交互 详解
weixin_69252724的博客
03-15 3703
浏览器不让从一个域名的网页去请求另一个域名网页的资源,这是浏览器的同源策略造成的, 是javaScript加的安全限制跨域的定义是: 只要协议 域名 端口 有任何一个不同 就是跨域 为什么要限制跨域访问万一是另外一个恶意网站响应的数据,会导致服务器出问题 为什么要跨域公司的不同子域需要相互调用资源时后端解决跨域后端可以实现过滤器接口,告诉浏览器此次的访问是安全的location.assign 并不会出现跨域问题, 他会重新开一个窗口,跟原服务器没关系如下图。
Servlet | HttpServlet源码分析、web站点的欢迎页面
m0_61933976的博客
11-16 870
Servlet | HttpServlet源码分析、web站点的欢迎页面
HttpServlet的response和request对象
wujingjing_crystal的专栏
11-24 1212
我们知道servlet 通常通过 HTTP协来接收和响应来自 Web 客户端的请求。 因此我们在使用中最常用的是Servlet接口的实现类HttpServlet类。HttpServlet类的方法的主要参数是HttpServletRequest和HttpServletResponse对象。通过合理地使用这两个对象，我们可以实现很多有用的功能，例如在界面输出数据、文件下载等。一、HttpServletR
【Servlet】HttpServletRequest、HttpServletResponse
qq_41233305的博客
06-29 2920
HttpServletRequest、HttpServletResponse、以及前后端交互案例：表白墙
Servlet中HttpServletResponse介绍
weixin_67630324的博客
02-06 1822
request和response对象，代表请求和响应：获取客户端数据，需要通过request对象；向客户端输出数据需要通过response对象。HttpServletResponse的主要功能用于服务器对客户端的请求进行响应，将web服务器处理后的结果返回给客户端。service方法中形参接收的是HttpServletResponse接口的实例化对象，这个对象中封装了向客户端发送数据，发送响应头，发送状态码的方法。getWrite（）获取字符流，只能响应回字符。
JavaWeb三大组件 —— Servlet
weixin_45326523的博客
08-05 2271
然而，从 Java EE 8 开始，Servlet API 的维护权转交给了 Eclipse Foundation 的 Jakarta EE 社区，因此，在最新的 Jakarta EE 版本中，Servlet API 的包名已经更改为 jakarta.servlet。综上所述，javax.servlet 和 jakarta.servlet 的区别仅在于包名的变化，代表了不同版本的 Java Servlet API。3.点击确定，就会看到如下图，idea自动给我们创建了web.xml。
java中，getRequestDispatcher是干什么的
weixin_58689039的博客
10-17 702
getRequestDispatcher是一个Java Servlet API中的方法，用于获取请求调度器。请求调度器用于将请求转发给其他资源（如Servlet、JSP或静态文件），以便处理该请求。通过使用getRequestDispatcher方法，可以将控制权从当前Servlet转发给其他资源，并在处理完该资源后返回到原来的Servlet。这个方法通常与forward或include方法一起使用，用于实现请求的转发和包含操作。
Java Web基础：Servlet详解
"Java Web基础教程，专注于Servlet的讲解，由北京传智播客教育提供，旨在培养高级软件人才的实作技能。课程涵盖了HTTP协议、URL结构、HTTP请求与应答格式、MIME类型以及Servlet技术的基础知识。" 本文档主要介绍了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值