javaweb 基础详解

消失的年轮

已于 2024-08-08 15:01:47 修改

阅读量850

点赞数 31

分类专栏： JAVA框架文章标签： java jsp tomcat

于 2024-07-04 21:00:36 首次发布

本文链接：https://blog.csdn.net/happysmooth/article/details/140163363

版权

JAVA框架专栏收录该内容

6 篇文章 0 订阅

订阅专栏

重生之我在CSDN学java 第四天（javaweb 基础详解）

文章目录

重生之我在CSDN学java 第四天（javaweb 基础详解）

一、 Jsp

1.简介

JSP（全称Java Server Pages）是由Sun Microsystems公司主导创建的一种动态网页技术标准。JSP部署于网络服务器上，可以响应客户端发送的请求，并根据请求内容动态地生成HTML、XML或其他格式文档的Web网页，然后返回给请求者。JSP技术以Java语言作为脚本语言，为用户的HTTP请求提供服务，并能与服务器上的其它Java程序共同处理复杂的业务需求。
JSP将Java代码和特定变动内容嵌入到静态的页面中，实现以静态页面为模板，动态生成其中的部分内容。JSP引入了被称为“JSP动作”的XML标签，用来调用内建功能。另外，可以创建JSP标签库，然后像使用标准HTML或XML标签一样使用它们。标签库能增强功能和服务器性能，而且不受跨平台问题的限制。JSP文件在运行时会被其编译器转换成更原始的Servlet代码。JSP编译器可以把JSP文件编译成用Java代码写的Servlet，然后再由Java编译器来编译成能快速执行的二进制机器码，也可以直接编译成二进制码。

2.结构

B/S 浏览器/服务器

用户工作界面是通过WWW浏览器来实现，极少部分事务逻辑在前端(Browser)实现，但是主要事务逻辑在服务器端(Server)实现，形成所谓三层3-tier结构。这样就大大简化了客户端电脑载荷，减轻了系统维护与升级的成本和工作量，降低了用户的总体成本(TCO)。局域网建立B/S结构的网络应用，并通过Internet/Intranet模式下数据库应用，相对易于把握、成本也是较低的。它是一次性到位的开发，能实现不同的人员，从不同的地点，以不同的接入方式(比如LAN, WAN, Internet/Intranet等)访问和操作共同的数据库;它能有效地保护数据平台和管理访问权限，服务器数据库也很安全。
B/S结构采用星形拓扑结构建立企业内部通信网络或利用Internet虚拟专网（VPN）。前者的特点是安全、快捷、准确。后者则具有节省投资、跨地域广的优点。须视企业规模和地理分布确定。企业内部通过防火墙接入Internet，再整个网络采用TCP/IP协议。

C/S 客户端/服务器

大多数应用软件系统都是Client/Server形式的两层结构，由于软件应用系统正在向分布式的Web应用发展，Web和Client/Server应用都可以进行同样的业务处理，应用不同的模块共享逻辑组件;因此，内部的和外部的用户都可以访问新的和现有的应用系统，通过现有应用系统中的逻辑可以扩展出新的应用系统。这也就是应用系统的发展方向。
传统的C/S体系结构虽然采用的是开放模式，但这只是系统开发一级的开放性，在特定的应用中无论是Client端还是Server端都还需要特定的软件支持。由于没能提供用户真正期望的开放环境，C/S结构的软件需要针对不同的操作系统开发不同版本的软件，加之产品的更新换代十分快，已经很难适应百台电脑以上局域网用户同时使用。而且代价高，效率低。

3.Tomcat

Apache Tomcat 是一个开源的 Web 服务器和 Servlet 容器，它实现了 Java Servlet 和 JavaServer Pages (JSP) 规范。Tomcat 由 Apache 软件基金会管理，是 Java EE 规范的一部分，主要用于部署 Java Web 应用程序。

主要功能

1.Servlet 容器：Tomcat 作为 Servlet 容器，负责管理 Servlet 的生命周期，包括加载、初始化、调用以及销毁 Servlet。
2.JSP 引擎：Tomcat 提供了 JSP 引擎，可以将 JSP 页面转换为 Servlet，并执行它们。
3.Web 服务器：Tomcat 本身是一个轻量级的 Web 服务器，可以处理 HTTP 请求和响应。
4.支持 Java EE 规范：Tomcat 支持 Java Servlet、JSP、EL（Expression Language）、JSTL（JavaServer Pages Standard Tag Library）等 Java EE 规范。
5.配置和管理：Tomcat 提供了基于 XML 的配置文件（如 server.xml 和 web.xml），用于配置服务器和应用程序的参数。
6.安全性：Tomcat 提供了基本的安全性支持，包括用户认证和授权。
7.扩展性：Tomcat 可以通过添加额外的组件（如连接器、Valves、Realm 等）进行扩展。

使用场景

开发和测试：开发者可以使用 Tomcat 作为开发和测试 Java Web 应用程序的环境。
生产部署：Tomcat 可以部署到生产环境中，作为企业级应用程序的 Web 服务器。
微服务架构：在微服务架构中，Tomcat 可以作为独立的微服务的运行环境。

安装和配置

1.下载：访问 Apache Tomcat 官网下载适合的版本。
2.解压：将下载的压缩包解压到本地目录。
在这里插入图片描述

3.配置环境变量：设置 CATALINA_HOME 环境变量指向 Tomcat 的安装目录。
在这里插入图片描述

4.启动和停止：
启动

 bin/startup.sh（Linux/Mac）
 bin/startup.bat（Windows）

停止

bin/shutdown.sh 
bin/shutdown.bat

5.访问管理界面（默认）
http://localhost:8080
在这里插入图片描述
6.部署应用程序：将 Web 应用程序的 WAR 文件或目录复制到 webapps 目录下，Tomcat 会自动部署。
Tomcat 的高级配置
连接器配置：通过修改 server.xml 文件中的元素来配置 HTTP 连接器，包括端口、协议、SSL 支持等。
在这里插入图片描述

上下文配置：通过 web.xml 或 context.xml 文件配置 Web 应用程序的参数。
日志配置：通过 conf/logging.properties 文件配置日志记录。

4.IDEA中配置 Tomcat

在这里插入图片描述

5.JSP中创建 HelloWorld

创建一个java项目，点击File-> new -> project
在这里插入图片描述

创建 classess 和 lib ,并且把你安装的tomcat目录下lib下的serclet-api.jar包复制一份

点击快捷键 Ctrl + Shift + Alt + S 打开java项目配置目录，配置访问的 jsp和jar

完整目录

启动项目

二、 JSP 基本语法

1.page 指令

Language：定义要使用的脚本语言，默认为 java
contentType：定义 jsp 字符的编码和页面相应的 MIME 类型
pageEncodeing：定义 Jsp 页面的字符集编码

<%@ page language="java" contentType="text/html; charset=UTF-8" 
	pageEncoding="UTF-8" import="java.util.*,java.util.ArrayList" %>

2.ScriptLet 标签

jsp表达式用于向页面输出信息：	
<%= 表达式 %> ：在 Jsp 中嵌入 Java 代码
<%! %>：定义全局变量、方法、类
<% %>：定义局部变量、编写语句

在这里插入图片描述启动项目

3.JSP 中的注释

<!--注释内容-->：客户端可见
<%-- 注释内容--%>：客户端不可见

4.JSP 中的包含指定

静态包含：<%@unclude file=”文件地址”%>，先包含，再编译处理

<%@ include file="./WEB-INF/common/head.html"%>

动态包含：<jsp:include page=”文件地址”>，先编译处理，再包含

<jsp:include page="./WEB-INF/common/left.jsp">

5.JSP 中的跳转指令

<jsp:forward>
<jsp:param value=”” name=””>
</jsp:forward>

启动页面 index.js

<%@ page language="java" contentType="text/html; charset=utf-8"
         pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Insert title here</title>
</head>
<body>
<jsp:forward page="main.jsp">
    <jsp:param value="zhangsan" name="userName"/>
    <jsp:param value="123456" name="passWord"/>
</jsp:forward>
</body>
</html>

跳转页面 mian.jsp

<%@ page language="java" contentType="text/html; charset=utf-8"
         pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <title>Insert title here</title>
</head>
<body>
服务器跳转后的主页<br/>
<!-- 进行取值 -->
姓名:<%= request.getParameter("userName") %><br/>
密码:<%= request.getParameter("passWord") %><br/>
</body>
</html>

启动tomcat服务

在这里插入图片描述

三章、 JSP 作用域与内置对象

1.JSP内置对象

JSP 提供九个内置对象，这些内置对象由容器初始化，用户可以直接使用，他们
分别是：request 对象、response 对象、session 对象、application 对象、out
对象、pageContext 对象、config 对象、page 对象、exception 对象，常用的是前面 5 个；

2.JSP 四大作用域

在 Jsp 开发中，可以保存数据，Jsp 提供了四种数据保存范围；分别是 page，request，session，application;
1、application 作用域有效范围是整个应用。整个应用是指从应用启动，到应用结束。

application值设置

<%
    application.setAttribute("name", "application Tom");
    application.setAttribute("age",22);
%>

取值

<%
    String name=(String)application.getAttribute("name");
    int age=(Integer)application.getAttribute("age");
%>
<font>姓名:<%=name %></font>
<font>年龄:<%=age %></font>

2、session 作用域
有效范围是当前会话。所谓当前会话，就是指从用户打开浏览器开始，到用户关
闭浏览器这段时间
session值设置

<%
session.setAttribute("name", "session Tom");
session.setAttribute("age",22);
%>

取值

<%
    String name=(String)session.getAttribute("name");
    int age=(Integer)session.getAttribute("age");
%>
<font>姓名:<%=name %></font>
<font>年龄:<%=age %></font>

3、request 作用域
有效范围是一次请求（一次请求可能包含一个页面，也可能包含多个页面，比如页面 A 请求转发到页面 B）

request值设置

<%
request.setAttribute("name", "request Tom");
request.setAttribute("age",22);
%>

取值

<jsp:forward page="requestTarget.jsp"></jsp:forward>
接收请求
<font>姓名:<%=request.getAttribute("name")%></font>
<font>年龄:<%=equest.getAttribute("age")%></font>

4、page 作用域
作用范围仅限于用户请求的当前页面

<%
    //设置两个page范围内的数据，key -> value
    pageContext.setAttribute("name", "Tom");
    pageContext.setAttribute("age",22);
%>
<%
    //取值
    String name=(String)pageContext.getAttribute("name");
    int age=(Integer)pageContext.getAttribute("age");
%>
<font>姓名:<%=name %></font>
<font>年龄:<%=age %></font>

3.JSP 九大内置对象之 response

1.response
代表的是对客户端的响应，主要是将 JSP 容器处理过的对象传回到客
户端。response 对象也具有作用域，它只在 JSP 页面内有效。
自动刷新应用、页面重定向、操作 cookie
GET 方式提交与 POST 方式提交的区别：
1、post 方式比 get 方式安全；
2、Get 方式 url 后面会带上参数，而 post 是将参数放在数据包中传递过去，所
以 url 里面看不到；
3、Get 方式带参数容量很小，而 post 很大

response 值设置

//设置两个request范围内的数据，key -> value
request.setAttribute("name", "request Tom");
request.setAttribute("age",22);
%>

取值

<%
    String name=(String)request.getAttribute("name");
    int age=(Integer)request.getAttribute("age");
%>
<font>姓名:<%=name %></font>
<font>年龄:<%=age %></font>

4.JSP 九大内置对象之 out

out 对象用于在 Web 浏览器内输出信息，并且管理应用服务器上的输出缓冲区。
在使用 out 对象输出数据时，可以对数据缓冲区进行操作，及时清除缓冲区中
的残余数据，为其他的输出让出缓冲空间。待数据输出完毕后，要及时关闭输出
流。

<%
out.println("<h1>");
out.println("Hello Jsp Servlet");
out.println("</h1>");
%>

5.JSP 九大内置对象之 pageContext

pageContext 对象的作用是取得任何范围的参数，通过它可以获取 JSP 页面的
out、request、reponse、session、application 等对象。pageContext 对象的
创建和初始化都是由容器来完成的，在 JSP 页面中可以直接使用 pageContext
对象。

6.JSP 九大内置对象之 config

config 对象的主要作用是取得服务器的配置信息。通过 pageConext 对象的
getServletConfig() 方法可以获取一个 config 对象。当一个 Servlet 初始化
时，容器把某些信息通过 config 对象传递给这个 Servlet。 开发者可以在
web.xml 文件中为应用程序环境中的 Servlet 程序和 JSP 页面提供初始化参数。

7JSP 九大内置对象之 exception

exception 对象的作用是显示异常信息，只有在包含 isErrorPage=“true” 的页
面中才可以被使用，在一般的 JSP 页面中使用该对象将无法编译 JSP 文件。
exception 对象和 Java 的所有对象一样，都具有系统提供的继承结构。exception
对象几乎定义了所有异常情况。在 Java 程序中，可以使用 try/catch 关键字来
处理异常情况；如果在 JSP 页面中出现没有捕获到的异常，就会生成 exception
对象，并把 exception 对象传送到在 page 指令中设定的错误页面中，然后在错
误页面中处理相应的 exception 对象。

调用

<%@ page errorPage="error.jsp"%>
%>

<%
if(exception!=null){
out.println("程序错误信息:");
out.println(exception.getMessage());
}

四、 JavaBean 组件

1.JavaBean 组件引入

JavaBean 是使用 Java 语言开发的一个可重用的组件，在 JSP 开发中可以使用
JavaBean 减少重复代码，使整个 JSP 代码的开发更加灵活简洁

传统地引入对象是先建一个model，再引入对象路径：
Student类:

package com.java.model;
public class Student {
    private String name;
    private int age;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
}

javabean.jsp代码引入对象路径

<%
    Student student=new Student();
    student.setName("OPPO");
    student.setAge(20);
%>
<h1>姓名:<%= student.getName() %></h1>
<h1>年龄:<%= student.getAge() %></h1>

2.创建 JavaBean

<jsp:userBean id=”实例化对象的名称” scope=”保存范围” class=”类完整名称”/> Scope:作用范围，page，request，session，application，默认是 page。

<jsp:useBean id="student" scope="page" class="com.java.model.Student"></jsp:useBean>
<%
    student.setName("华为");
    student.setAge(22);
%>
<h1>姓名:<%= student.getName() %></h1>
<h1>年龄:<%= student.getAge() %></h1>

3.设置属性值

<jsp:setProperty property=”属性名称” name=”实例化对象的名称” value=”属性的值” param=”参数名称”/> Property=”*” 匹配所有的属性

<!-- 用jsp:useBean组件创建JavaBean -->
<jsp:useBean id="student" scope="page" class="com.java.model.Student"></jsp:useBean>
<!-- 用jsp:setProperty来设置javaBean属性值 -->
<jsp:setProperty property="name" name="student"/>
<!-- 这里我们将年龄的值设定为100，即前台年龄不管输入多少，后台始终接受的是100 -->
<jsp:setProperty property="age" name="student" value="100"/>
<h1>姓名:<%= student.getName() %></h1>
<h1>年龄:<%= student.getAge() %></h1>

4.获取属性值

<jsp:getProperty property=”属性名称” name=”实例化对象的名称”/>

<!-- 用jsp:useBean组件创建JavaBean -->
<jsp:useBean id="student" scope="page" class="com.java.model.Student"></jsp:useBean>
<!-- 用jsp:setProperty来设置javaBean属性值 ，并且加入param属性来配对前台的userName属性-->
<jsp:setProperty property="name" name="student" param="userName"/>
<!-- 这里我们将年龄的值设定为100，即前台年龄不管输入多少，后台始终接受的是100 -->
<jsp:setProperty property="age" name="student" value="100"/>
<h1>姓名:<%= student.getName() %></h1>
<h1>年龄:<%= student.getAge() %></h1>

5.JavaBean 的保存范围

page，request，session，application

request范围

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<%
	request.setCharacterEncoding("utf-8");
%>
<!-- 用jsp:useBean组件创建JavaBean -->
<jsp:useBean id="student" scope="request" class="com.java.model.Student"></jsp:useBean>
<!-- 用jsp:setProperty来设置javaBean属性值 -->
<jsp:setProperty property="name" name="student" value="小米1"/>
<jsp:setProperty property="age" name="student" value="55"/>
<jsp:forward page="target1.jsp"/>
</body>
</html>

jsp

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<!-- 用jsp:useBean组件创建JavaBean -->
<jsp:useBean id="student" scope="request" class="com.java.model.Student"></jsp:useBean>
<!-- jsp:getProperty 获取javaBean 属性值 -->
<h1>姓名:<jsp:getProperty property="name" name="student"/></h1>
<h1>年龄:<jsp:getProperty property="age" name="student"/></h1>
</body>
</html>

session范围

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<%
	request.setCharacterEncoding("utf-8");
%>
<!-- 用jsp:useBean组件创建JavaBean -->
<jsp:useBean id="student" scope="session" class="com.java.model.Student"></jsp:useBean>
<!-- 用jsp:setProperty来设置javaBean属性值 -->
<jsp:setProperty property="name" name="student" value="小米2"/>
<jsp:setProperty property="age" name="student" value="55"/>
<h1>session数据设置完毕!</h1>
</body>
</html>

jsp

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<!-- 用jsp:useBean组件创建JavaBean -->
<jsp:useBean id="student" scope="session" class="com.java.model.Student"></jsp:useBean>
<h1>session中取值完毕！</h1>
<!-- jsp:getProperty 获取javaBean 属性值 -->
<h1>姓名:<jsp:getProperty property="name" name="student"/></h1>
<h1>年龄:<jsp:getProperty property="age" name="student"/></h1>
</body>
</html>

application范围

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<%
	request.setCharacterEncoding("utf-8");
%>
<!-- 用jsp:useBean组件创建JavaBean -->
<jsp:useBean id="student" scope="application" class="com.java.model.Student"></jsp:useBean>
<!-- 用jsp:setProperty来设置javaBean属性值 -->
<jsp:setProperty property="name" name="student" value="小米3"/>
<jsp:setProperty property="age" name="student" value="52"/>
<h1>application数据设置完毕!</h1>
</body>
</html>

jsp

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<!-- 用jsp:useBean组件创建JavaBean -->
<jsp:useBean id="student" scope="application" class="com.java.model.Student"></jsp:useBean>
<h1>application中取值完毕！</h1>
<!-- jsp:getProperty 获取javaBean 属性值 -->
<h1>姓名:<jsp:getProperty property="name" name="student"/></h1>
<h1>年龄:<jsp:getProperty property="age" name="student"/></h1>
</body>
</html>

6.JavaBean 的删除

作用域对象.removeAttribute(“javabean 的名称”);

<jsp:useBean id="student" scope="session" class="com.java.model.Student"></jsp:useBean>
<!-- 用jsp:setProperty来设置javaBean属性值 -->
<jsp:setProperty property="name" name="student" value="小米"/>
<jsp:setProperty property="age" name="student" value="55"/>

删除

<%
session.removeAttribute("student");
%>

五、 Servlet 开发

1.Servlet 简介

Servlet（Server Applet）是Java Servlet的简称，称为小服务程序或服务连接器，用Java编写的服务器端程序，具有独立于平台和协议的特性，主要功能在于交互式地浏览和生成数据，生成动态Web内容。
狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况下，人们将Servlet理解为后者。Servlet运行于支持Java的应用服务器中。从原理上讲，Servlet可以响应任何类型的请求，但绝大多数情况下Servlet只用来扩展基于HTTP协议的Web服务器。
最早支持Servlet标准的是JavaSoft的Java Web Server，此后，一些其它的基于Java的Web服务器开始支持标准的Servlet。

2.创建一个HelloWorld

创建HelloWorldServlet类继承HttpServelt，重写方法doGet()和doPost()

package com.java.web;
 
import java.io.IOException;
import java.io.PrintWriter;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class HelloWorldServlet extends HttpServlet{
 
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
 
	@Override
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//用户请求doGet时交给doPost去处理
		this.doPost(request, response);
	}
 
	@Override
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//设置默认编码为gbk
		response.setCharacterEncoding("gbk");
		PrintWriter out=response.getWriter();
		out.println("<html>");
		out.println("<head><title>简单的Servlet程序</title></head>");
		out.println("HelloWorld!你好！");
		out.println("</html>");
		out.close();
	} 

}

修改配置文件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_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>HelloWorldServlet</display-name>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
     
  <servlet>
  	<servlet-name>HelloWorldServlet</servlet-name>
  	<servlet-class>com.java.web.HelloWorldServlet</servlet-class>
  </servlet>
  
  <servlet-mapping>
  	<servlet-name>HelloWorldServlet</servlet-name>
  	<url-pattern>HelloWorld</url-pattern>
  </servlet-mapping>
</web-app>

运行tomcat

在这里插入图片描述
原理：首先浏览器请求HelloWorld，然后找到匹配的name（即HelloWorldServlet）；然后name去找Servlet里面相匹配的name，请求其中的class，然后根据返回的get请求，找到doPost()方法，运行其中的代码就完成了！

3.Servlet 的生命周期

概括为四步：servlet 类加载—>实例化—>服务—>销毁。
测试类TestServlet

package com.java.web;
 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class TestServlet extends HttpServlet{
 
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
 
	@Override
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("service");
	}
 
	@Override
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("service");
	}
 
	@Override
	public void destroy() {
		System.out.println("Servlet销毁");
	}
 
	@Override
	public void init() throws ServletException {
		System.out.println("Servlet初始化");
	}
	
}

配置文件web.xml 中添加相关配置

  <servlet-mapping>
  	<servlet-name>HttpServlet</servlet-name>
  	<url-pattern>/test</url-pattern>
  </servlet-mapping>

运行http://localhost:8080/HelloWorldServlet/test

在这里插入图片描述
总结：Servlet的生命周期分为四步：
1.调用LifeServlet时会进行类加载；
2.Servlet初始化时会进行实例化，并调用init()方法；
3.请求要求时会有服务service；
4.长时间不用或者关闭LifeServlet就会销毁Servlet！并调用destroy()方法；

4.两种页面跳转方式

客户端跳转
客户端跳转也叫重定向（外部跳转），是调用HttpServletResponse对象中的sendRedirect()方法；
这是一个响应对象的方法，调用这个方法表明整个请求已经结束，服务器开始向客户端返回执行的结果；

//客户端跳转response
response.sendRedirect("target.jsp");

注意：
此跳转只能传递session和application范围的属性，而无法传递request范围的属性；
客户端会发送两个请求，并且页面的路径会改变。
重定向可以访问自己web应用以外的资源。在重定向的过程中，传输的信息会被丢失。
向过程：

（1）客户浏览器发送http请求
（2）web服务器接受后发送302状态码响应及对应新的location给客户浏览器
（3）客户浏览器发现是302响应，则自动再发送一个新的http请求，请求url是新的location地址
（4）服务器根据此请求寻找资源并发送给客户。
在这里location可以重定向到任意URL，既然是浏览器重新发出了请求，则就没有什么request传递的概念了。在客户浏览器路径栏显示的是其重定向的路径，客户可以观察到地址的变化的。重定向行为是浏览器做了至少两次的访问请求的。

服务端跳转
服务端跳转也叫请求转发（内部跳转），是RequestDispatcher接口的forward()方法来实现的；
而RequestDispatcher是通过调用HttpServletRequest对象的getRequestDispatcher()方法得到的。

//服务器跳转，调用RequestDispatcher接口
RequestDispatcher rd=request.getRequestDispatcher("target.jsp");
rd.forward(request, response);

注意：
服务器端跳转页面的路径不会发生改变，所以可以request范围的属性。
传输的信息不会丢失。
转发过程：

转发过程：
（1）客户浏览器发送http请求
（2）web服务器接受此请求
（3）调用内部的一个方法在容器内部完成请求处理和转发动作
（4）将目标资源发送给客户；
在这里，转发的路径必须是同一个web容器下的url，其不能转向到其他的web路径上去，中间传递的是自己的容器内的request。在客户浏览器路径栏显示的仍然是其第一次访问的路径，也就是说客户是感觉不到服务器做了转发的。转发行为是浏览器只做了一次访问请求。
区别
转发是服务器行为，重定向是客户端行为。
（1）转发的速度快，重定向的速度慢；
（2）转发不会执行转发后的代码，重定向会执行重定向之后的代码
（3）转发必须是在同一台服务器下完成，重定向可以在不同的服务器下完成

5.JSP&Servlet 实现用户登录

在这里插入图片描述

创建一个t_user表
在这里插入图片描述
实体model

package com.java.model;
 
public class User {
 
	//User表中各属性
	private int id;
	private String userName;
	private String password;
	
	public User() {
		super();
	}
	
	
	public User(String userName, String password) {
		super();
		this.userName = userName;
		this.password = password;
	}
 
 
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
}

工具类 DbUtil

package com.java.util;
 
import java.sql.Connection;
import java.sql.DriverManager;
 
public class DbUtil {
 
	//数据库连接地址
	private String dbUrl="jdbc:mysql://localhost:3306/db_jsp";
	
	//用户名
	private String dbUserName="root";
	
	//密码
	private String dbPassword="123456";
	
	//驱动名称
	private String jdbcName="com.mysql.jdbc.Driver";
	
	//数据库连接方法
	public Connection getCon() throws Exception{
		Class.forName(jdbcName);
		Connection con=DriverManager.getConnection(dbUrl, dbUserName, dbPassword);
		return con;
	}
	
	//数据库关闭方法
	public void closeCon(Connection con) throws Exception{
		if(con!=null){
			con.close();
		}
	}
	
	//测试方法
	public static void main(String[] args) {
		DbUtil dbUtil=new DbUtil();
		try {
			dbUtil.getCon();
			System.out.println("数据库连接成功！");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println("数据库连接失败！");
		}
	}
}

数据访问层 UserDao

package com.java.dao;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
 
import com.java.model.User;
 
public class UserDao {
 
	//登录功能实现
	public User Login(Connection con,User user)throws Exception{
		User resultUser=null;
		String sql="select * from t_user where userName=? and password=? ";
		PreparedStatement pstmt=con.prepareStatement(sql);
		pstmt.setString(1, user.getUserName());
		pstmt.setString(2, user.getPassword());
		ResultSet rs=pstmt.executeQuery();
		if(rs.next()){
			resultUser=new User();
			resultUser.setUserName(rs.getString("userName"));
			resultUser.setPassword(rs.getString("password"));
		}
		return resultUser;
	}
}

处理层 LoginServlet

package com.java.web;
 
import java.io.IOException;
import java.sql.Connection;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
 
import com.java.dao.UserDao;
import com.java.model.User;
import com.java.util.DbUtil;
 
public class LoginServlet extends HttpServlet{
	
	private DbUtil dbUtil=new DbUtil();
	private UserDao userDao=new UserDao();
 
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
 
	@Override
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//用户请求doGet时交给doPost去处理
		this.doPost(request, response);
	}
 
	@Override
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//获取输入的信息
		String userName=request.getParameter("userName");
		String password=request.getParameter("password");
		
		//获取数据库连接
		Connection con=null;
		try {
			con=dbUtil.getCon();
			//将用户名和密码进行封装
			User user=new User(userName,password);
			//调用登录方法
			User currentUser=userDao.Login(con, user);
			if(currentUser==null){
				request.setAttribute("error", "用户名或密码错误");
				//将用户所填的信息传回给用户看
				request.setAttribute("userName", userName);
				request.setAttribute("password", password);
				//跳转到服务器
				request.getRequestDispatcher("login.jsp").forward(request, response);
			}else{
				//获取session
				HttpSession session=request.getSession();
				//给session 设置值
				session.setAttribute("currentUser", currentUser);
				//客户端跳转，重定向
				response.sendRedirect("main.jsp");
				
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

web.xml配置信息

 <servlet-mapping>
  	<servlet-name>loginServlet</servlet-name>
  	<servlet-class>com.java.web.LoginServlet</servlet-class>
  </servlet-mapping>
  <servlet-mapping>
  	<servlet-name>LoginServlet</servlet-name>
  	<url-pattern>/login</url-pattern>
  </servlet-mapping>

Login.jsp

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<form action="login" method="post">
<table>
	<tr>
		<th colspan="2">用户登录</th>
	</tr>
	<tr>
		<td>用户名:</td>
		<td><input type="text" id="userName" name="userName" value="${userName }"/></td>
	</tr>
	<tr>
		<td>密码:</td>
		<td><input type="text" id="password" name="password" value="${password }"/></td>
	</tr>
	<tr>
		<td><input type="submit" value="登录"/></td>
		<td><font color="red">${error }</font></td>
	</tr>
</table>
</form>
</body>
</html>

main.jsp

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
主页:当前登录用户:${currentUser.userName }
</body>
</html>

运行结果
在这里插入图片描述

6.Servlet 过滤器

1.Servlet过滤器

主要是过滤用户请求

在前面的Login.jsp访问页面时，会出现登陆界面；
那么我们直接访问main.jsp主页面时，就直接出现了主页面的内容，这样Logi.jsp就没起到作用了；
为了防止这种情况，Servlet里面有一个过滤器Filter，可以过滤掉直接访问main.jsp就出现主页面的情况；

package com.java.filter;
 
import java.io.IOException;
 
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.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
 
public class LoginFilter implements Filter{
 
	public void destroy() {
		// TODO Auto-generated method stub
		
	}
 
	public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
			throws IOException, ServletException {
		//将ServletRequest强转成HttpServletRequest
		HttpServletRequest request=(HttpServletRequest)servletRequest;
		//获取session
		HttpSession session=request.getSession();
		//获取当前用户登录信息
		Object o=session.getAttribute("currentUser");
		//将正确用户登录去除掉
		String path=request.getServletPath();
		if(o==null&&path.indexOf("login")<0){
			//重定向返回到登录界面
			request.getRequestDispatcher("login.jsp").forward(servletRequest, servletResponse);
		}else{
			//递归，重新返回到判断过程
			filterChain.doFilter(servletRequest, servletResponse);
		}
	}
 
	public void init(FilterConfig arg0) throws ServletException {
		// TODO Auto-generated method stub
		
	}
 
}

web.xml配置信息

 <servlet-mapping>
  	<servlet-name>loginFilter</servlet-name>
  	<servlet-class>com.java.filter.LoginFilter</servlet-class>
  </servlet-mapping>
    <servlet-mapping>
  	<servlet-name>loginFilter</servlet-name>
  	<url-pattern>/*</url-pattern>
  </servlet-mapping>

这里是过滤掉了所有非访问请求！这时我们直接访问mian.jsp时：
在这里插入图片描述
直接返回到了登录界面！

2.Servlet监听器

监听 web 事件；如 application,session,request

package com.java.listener;
 
import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;
 
public class SessionAttributeListener implements HttpSessionAttributeListener{
 
	public void attributeAdded(HttpSessionBindingEvent httpSessionBindingEvent) {
		// TODO Auto-generated method stub
		System.out.println("添加的属性名:"+httpSessionBindingEvent.getName()+", 属性值:"+httpSessionBindingEvent.getValue());
	}
 
	public void attributeRemoved(HttpSessionBindingEvent httpSessionBindingEvent) {
		// TODO Auto-generated method stub
		System.out.println("删除的属性名:"+httpSessionBindingEvent.getName()+", 属性值:"+httpSessionBindingEvent.getValue());
	}
 
	public void attributeReplaced(HttpSessionBindingEvent httpSessionBindingEvent) {
		// TODO Auto-generated method stub
		
	}
 
	
}

web.xml配置信息
在这里插入图片描述

<listener>
<listener-class>com.java.listener.SessionAttributeListener</listener-class>
</listener>

我们重回浏览器进行登录，登录成功之后会发现已经监听到了登录信息
在这里插入图片描述

六、 EL 表达式

1.EL 表达式简介

EL（Expression Language）是为了使JSP写起来更加简单。表达式语言的灵感来自于 ECMAScript 和 XPath 表达式语言，它提供了在 JSP 中简化表达式的方法，让Jsp的代码更加简化。

2.EL 表达式内置对象

	说明	表达式内置对象
1	pageContext	表示 javax.servlet.jsp.PageContext 对象
2	pageScope	表示从 page 属性范围查找输出属性
3	requestScope	表示从request属性范围查找输出属性
4	sessionScope	表示从session 属性范围查找输出属性
5	applicationScope	表示从 application属性范围查找输出属性
6	param	接收传递到本页面的参数
7	paramValues	接收传递到本页面的一组参数
8	header	取得一个头信息数据
9	headerValues	取出一组头信息数据
10	cookie	取出cookie 中的数据
11	initParam	取得配置的初始化参数

3.EL 表达式访问范围属性

寻找值的顺序：page->request->session->application

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<%
	pageContext.setAttribute("info1", "page范围");
	request.setAttribute("info1", "request范围");
	session.setAttribute("info1", "session范围");
	application.setAttribute("info1", "application范围");
%>
<!-- 最后取的是page范围的值 -->
<h1>${info1 }</h1>
</body>
</html>

运行结果
在这里插入图片描述

4.EL 表达式接受请求参数

param：单个参数；paramValues：数组参数

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<!-- param一个参数传值 -->
<form action="el2.jsp" method="post">
	<input type="text" name="name"/>
	<input type="submit" name="提交el2.jsp"/>
</form>
<!-- paramValues一组参数传值 -->
<form action="el2.jsp" method="post">
	<input type="checkbox" name=hobby value="C语言"/>C语言
	<input type="checkbox" name=hobby value="Java语言"/>Java语言
	<input type="checkbox" name=hobby value="C++语言"/>C++语言
	<input type="submit" name="提交el2.jsp"/>
</form>
</body>
</html>

el2.jsp代码:

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<!-- 设置默认编码 -->
<%
	request.setCharacterEncoding("utf-8");
%>
<h1>姓名:${param.name }</h1>
<h1>爱好1:${paramValues.hobby[0] }</h1>
<h1>爱好2:${paramValues.hobby[1] }</h1>
<h1>爱好3:${paramValues.hobby[2] }</h1>
</body>
</html>

运行结果
在这里插入图片描述

5.EL 表达式对象操作

创建People类

package com.java.model;
 
public class People {
 
	private int id;
	private String name;
	private int age;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<%@page import="com.java.model.People" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<%
	People p=new People();
	p.setId(5);
	p.setName("张三");
	p.setAge(20);
	request.setAttribute("p", p);
%>
<h1>姓名:${p.name }</h1>
<h1>编号:${p.id }</h1>
<h1>年龄:${p.age }</h1>
</body>
</html>

6.EL 表达式集合操作

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<%@page import="java.util.*" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<%
	List all=new LinkedList();
	all.add(0,"元素1");
	all.add(1,"元素2");
	all.add(2,"元素3");
	request.setAttribute("all", all);
%>
<h1>${all[0] }</h1>
<h1>${all[1] }</h1>
<h1>${all[2] }</h1>
</body>
</html>

消失的年轮

关注

31
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
javaweb 基础详解

JSP（全称Java Server Pages）是由Sun Microsystems公司主导创建的一种动态网页技术标准。JSP部署于网络服务器上，可以响应客户端发送的请求，并根据请求内容动态地生成HTML、XML或其他格式文档的Web网页，然后返回给请求者。JSP技术以Java语言作为脚本语言，为用户的HTTP请求提供服务，并能与服务器上的其它Java程序共同处理复杂的业务需求。JSP将Java代码和特定变动内容嵌入到静态的页面中，实现以静态页面为模板，动态生成其中的部分内容。
复制链接

扫一扫

专栏目录