精华内容
下载资源
问答
  • servlet需要什么基础
    万次阅读
    2020-12-21 15:18:53

    Servlet 基础


    简述

    什么是Servlet?
    Servlet是用Java语言编写应用到Web服务器端的扩展技术,他先于JSP产生,可以方便地对Web应用中的HTTP请求进行处理。在JavaWeb程序开发中,Servlet主要用于处理各种业务逻辑,它比JSP更具有业务逻辑层的意义,而且Servlet在安全性,扩展性以及性能方面都十分优秀,它在JavaWeb程序开发以及MVC框架的应用方面起到了极其重要的作用。

    结构体系

    HttpServlet类继承GenericServlet类,GennericServlet类继承三个接口,分别是Servlet接口,ServletConfig接口,Serializable接口。其中Serializable接口是java.io包中的序列化接口;Sevlet接口和ServletConfig接口是java.servlet包中定义的对象,其中,Servlet接口定义了Servlet的基本方法,ServletConfig接口封装了相关配置信息;GennericServlet是一个抽象类,它只是对上面继承的三个接口部分实现,但没有实现POST,GET等方法,而这些实现都是通过其子类HttpServlet类实现。

    优势

    • 1.功能强大
      Servlet采用Java编写,它可以调用Java的API。
    • 2.可移植
      Java语言是跨平台的,也与协议无关,而由Java编写的Servlet继承了Java的优点。
    • 3.性能高效
      Servlet对象在Servlet容器启动时初始化,但第一次被请求时,Servlet容器将被实例化,此时它储存于内存中。如果存在多个请求,Servlet不会再被实例化,仍然由此Servlet容器对其进行处理。每一个请求是一个线程,而不是一个进程,因此,Servlet容器对请求处理的性能是十分高效的。
    • 4.安全性高
      Servlet使用了Java的安全框架,同时Servlet容器还扩展了功能。
    • 5.可扩展
      Java语言是面向对象的编程语言,Servlet由Java语言编写,所以它继承了Java语言的面向对象的优点,在业务逻辑处理中,可以通过封装、继承等来扩展实际的业务需求。

    Servlet方法执行过程:

    package com.wu.ServletDemo;
    
    import java.io.IOException;
    
    import javax.servlet.Servlet;
    import javax.servlet.ServletConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.annotation.WebServlet;
    
    @WebServlet(name =  "myservlet",urlPatterns = "/demo")
    public class Myservlet implements Servlet{
    
    	@Override
    	public void destroy() {
    		System.out.println("最后执行,且每次关闭Tomcat都有且只会执行一次");
    	}
    
    	@Override
    	public ServletConfig getServletConfig() {
    		return null;
    	}
    
    	@Override
    	public String getServletInfo() {
    		return null;
    	}
    
    	@Override
    	public void init(ServletConfig arg0) throws ServletException {
    		System.out.println("最先执行,且每次启动Tomcat都有且只会执行一次");
    	}
    	@Override
    	public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
    		System.out.println("每次客户端发送一次请求就执行一次");
    	}
    }
    
    

    结果:

    在这里插入图片描述
    servlet生命周期:

    • 1.但浏览器访问Servlet的时候,Tomcat会先判断是否存在Servlet实例化对象,如果不存在,则通过反射机制实例化Servlet对象,否则进入直接执行service方法
    • 2.调用init方法完成初始化操作
    • 3.调用service方法完成业务操作
    • 4.关闭Tomcat时,调用destroy方法,释放当前对象的资源

    Servlet示例

    1.通过XML配置文件方式访问Servlet

    index.jsp:

    <%@ page language="java" contentType="text/html; charset=utf-8"
        pageEncoding="utf-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    	<meta charset="utf-8">
    	<title>MyServlet 实验</title>
    	<script src = "JQuery/jquery-3.2.1.js"></script>
    	<script type = "text/javascript">
    		var httpRequest; // 创建ajax请求对象
    		function createXMLHttpRequest(){
    			httpRequest =  new XMLHttpRequest();
    		}
    		function sendRequest(){
    			createXMLHttpRequest();
    			try{
    				httpRequest.onreadystatechange = handleState; // 绑定函数
    				httpRequest.open("get","demo",true); // 初始请求参数
    				httpRequest.send(null); // 发送请求
    			}catch(e){
    				alert("您访问的资源不存在!");
    			}
    		}
    		function handleState(){
    			if(httpRequest.readyState == 4 && httpRequest.status == 200){
    				var data = httpRequest.responseText;
    				var divObj = document.getElementById("mydiv");
    				divObj.innerHTML = data;
    				console.log("服务器已收到消息");
    			}
    		}
    		$(function(){
    			var h  = document.getElementById("h2");
    			h.onclick = function(){
    				sendRequest();
    			}
    		});
    	</script>
    </head>
    <body>
    	<div id = "mydiv"  align = "center"  style = "color:blue"><h2 id = "h2" >Hello Servlet !</h2></div>
    </body>
    </html>
    

    MyServlet:

    package com.wu.ServletDemo;
    
    import java.io.IOException;
    
    import javax.servlet.Servlet;
    import javax.servlet.ServletConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    
    public class Myservlet implements Servlet{
    
    	@Override
    	public void destroy() {
    	}
    
    	@Override
    	public ServletConfig getServletConfig() {
    		return null;
    	}
    
    	@Override
    	public String getServletInfo() {
    		return null;
    	}
    
    	@Override
    	public void init(ServletConfig arg0) throws ServletException {
    	}
    
    	@Override
    	public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		System.out.println("客户端访问servlet成功!");
    		response.setContentType("text/html;charset=utf-8");
    		response.getWriter().write("<h2>Hello Browser !</h2>");
    	}
    }
    
    

    web.xml:

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">
      <display-name>web2</display-name>
      <welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>default.html</welcome-file>
        <welcome-file>default.htm</welcome-file>
        <welcome-file>default.jsp</welcome-file>
      </welcome-file-list>
      <servlet>
      	<servlet-name>servletDemo</servlet-name>
      	<servlet-class>com.wu.ServletDemo.Myservlet</servlet-class>
      </servlet>
      <servlet-mapping>
      	<servlet-name>servletDemo</servlet-name>
      	<url-pattern>/demo</url-pattern>
      </servlet-mapping>
    </web-app>
    

    2.通过注解方式访问Servlet

    删除web.xml文件,在Myservlet中添加以下语句:

    import javax.servlet.annotation.WebServlet;
    @WebServlet(name =  "myservlet",urlPatterns = "/demo")
    

    也可以具有完全一样的效果,简化了操作,因此一般都是采用注解方式。

    ServletConfig接口

    public String getInitParameter(String name) // 获取String类型的初始化参数
    public Enumeration getInitParameterNames() // 获取所有参数初始化枚举集合
    public ServletContext getServletContext() // 用于获取Servlet上下文对象
    public String getServletName() // 返回Servlet对象的实例名
    

    HttpServletRequest接口

    public String getContextPath() // 返回请求的上下文路径
    public Cookie[] getCookies() // 返回请求中发送的所有Cookie对象,返回值为Cookie数组
    public String getMethod() // 返回请求所使用的HTTP类型
    public String getQueryString()  // 返回请求中参数的字符串形式
    public String getRequestURI() // 返回主机名到请求参数的字符串形式
    public StringBuffer getRequestURL() // 返回请求URL,类型为StringBuffer
    public String getServletPath() // 返回请求中URI中的Servlet路径字符串
    public HttpSession getSession() // 返回与请求关联的HttpSession对象
    

    HttpServletResponse接口

    public void addCookie(Cookie cookie) // 向客户端写入Cookie信息
    public void sendError(int sc) // 发送一个错误状态码为sc的错误响应到客户端
    public void sendRedirect(String location) // 使用客户端重定向到新的URL,参数为新的地址
    

    HttpServlet代码结构

    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 MyServlet extends HttpServlet{
    	
    	private static final long serialVersionUID = 1L;
    	
    	// 初始化方法
    	public void init() throws ServletException{
    		
    	}
    	// 处理HTTP GET请求
    	public void doGet(HttpServletRequest request , HttpServletResponse response) throws 
    	ServletException , IOException{
    		
    	}
    	// 处理HTTP POST请求
    	public void doPost(HttpServletRequest request , HttpServletResponse response) throws
    	ServletException , IOException{
    		
    	}
    	// 处理HTTP PUT请求
    	public void doPut(HttpServletRequest request , HttpServletResponse response) throws
    	ServletException , IOException{
    		
    	}
    	// 处理HTTP DELETE请求
    	public void doDelete(HttpServletRequest request , HttpServletResponse response) throws
    	ServletException , IOException{
    		
    	}
    	// 销毁方式
    	public void destroy() {
    		super.destroy(); // 调用HttpServlet类的销毁方式
    	}
    }
    

    Servlet过滤器

    package com.wu.FilterDemo;
    
    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.annotation.WebFilter;
    
    public class MyFilter implements Filter{
    	// 初始化处理
    	@Override
    	public void init(FilterConfig filterConfig) throws ServletException{
    	}
    	// 过滤器处理方法
    	@Override
    	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    			throws IOException, ServletException {
    		chain.doFilter(request, response); // 过滤处理
    	}
    	// 销毁方法
    	@Override
    	public void destroy() {
    	}
    }
    

    基于注解方式的多个过滤器执行过程:

    MyFilterA:

    package com.wu.FilterDemo;
    
    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.annotation.WebFilter;
    
    @WebFilter(filterName = "myfilterA" , urlPatterns = "/demo")
    public class MyFilterA implements Filter{
    	// 初始化处理
    	@Override
    	public void init(FilterConfig filterConfig) throws ServletException{
    	}
    	// 过滤器处理方法
    	@Override
    	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    			throws IOException, ServletException {
    		System.out.println("每次客户端发送一次请求FilterA就执行一次");
    		chain.doFilter(request, response); // 过滤处理
    		System.out.println("每次服务器发送一次响应FilterA就执行一次");
    	}
    	// 销毁方法
    	@Override
    	public void destroy() {
    	}
    }
    

    MyFilterB:

    package com.wu.FilterDemo;
    
    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.annotation.WebFilter;
    
    @WebFilter(filterName = "myfilterB" , urlPatterns = "/demo")
    public class MyFilterB implements Filter {
    	// 初始化处理
    		@Override
    		public void init(FilterConfig filterConfig) throws ServletException{
    		}
    		// 过滤器处理方法
    		@Override
    		public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    				throws IOException, ServletException {
    			System.out.println("每次客户端发送一次请求FilterB就执行一次");
    			chain.doFilter(request, response); // 过滤处理
    			System.out.println("每次服务器发送一次响应FilterB就执行一次");
    		}
    		// 销毁方法
    		@Override
    		public void destroy() {
    		}
    }
    

    MyServlet:

    package com.wu.ServletDemo;
    
    import java.io.IOException;
    
    import javax.servlet.Servlet;
    import javax.servlet.ServletConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.annotation.WebServlet;
    
    @WebServlet(name =  "myservlet",urlPatterns = "/demo")
    public class MyServlet implements Servlet{
    
    	@Override
    	public void destroy() {
    		System.out.println("最后执行,且每次关闭Tomcat都有且只会执行一次");
    	}
    
    	@Override
    	public ServletConfig getServletConfig() {
    		return null;
    	}
    
    	@Override
    	public String getServletInfo() {
    		return null;
    	}
    
    	@Override
    	public void init(ServletConfig arg0) throws ServletException {
    		System.out.println("最先执行,且每次启动Tomcat都有且只会执行一次");
    	}
    	@Override
    	public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
    		System.out.println("每次客户端发送一次请求Servlet就执行一次");
    	}
    }
    
    

    index.jsp:

    <%@ page language="java" contentType="text/html; charset=utf-8"
        pageEncoding="utf-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    	<meta charset="utf-8">
    	<title>Filter Demo</title>
    </head>
    <body>
    	<form action = "demo" method = "get">
    		<div align = "center"> 
    		<table>
    		<tr>
    			<td>用户名:</td>
    			<td><input type = "text" name = "username"></td>
    		</tr>
    		<tr>
    			<td>密码:</td>
    			<td><input type = "password" name = "password"></td>
    		</tr>
    		<tr>
    		 	<td colspan = "2" align = "center"><input type = "submit"  value= "提交"></td>
    		</tr>
    		</table>
    		</div>
    	</form>
    </body>
    </html>
    

    结果:

    在这里插入图片描述



    更多相关内容
  • Servlet基础知识总结

    2017-12-17 22:37:59
    Servlet基础知识进行总结,适合新手入门用,里面详细的介绍了Servlet运行原理以及如何创建等
  • JSP Servlet基础知识测试题
  • 主要介绍了浅谈Servlet开发技术基础,具有一定借鉴价值,需要的朋友可以参考下。
  • Servlet基础详解

    万次阅读 多人点赞 2022-02-14 17:02:51
    Servlet的基本概念及使用规范

    目录

    前言

    一、Servlet简介

    二、Servlet的作用

    三、Servlet处理的信息是什么

    四、Servlet的开发流程

    (一)、实现Servlet接口或者继承HttpServlet类

    (二)、重写HttpServlet类的doGet()和doPost()方法

    (三)、配置web.xml文件或者使用注解对servlet进行配置

    五、Servlet的生命周期

    (一)、通过web.xml文件来配置load-on-startup(启动时加载)优先级

    ​(二)、通过注解来配置load-on-startup(启动时加载)优先级

    六、Servlet获取参数的方法

    (一)、单个获取请求参数的方法

    ​(二)、获取键值对形式的请求参数的方法

    ​(三)、get特有的查询字符串的方法以及post以流的形式查询字符串的方法。

    七、Servlet响应页面和数据

    (一)、Servlet响应页面

    (二)、Servlet响应数据

    ​八、Web项目的初始化参数

    (一)、Servlet中的初始化参数如何配置及如何获取

    ​(二)、application在应用中初始化参数如配放置如何获取

    ​(三)、tomcat中初始化参数如何配置如何获取

    ​九、Servlet的线程安全问题

    总结



    前言

    Servlet是开发动态Web资源的一项技术,在整个开发架构中主要承担控制器(Controller)的作用,刚开始本章主要学习了解Servlet的基础概念及使用规范。


    一、Servlet简介

    Servlet是Server Applet的简称,翻译过来就是服务程序。是由sun公司提供的一门用于开发动态Web资源的技术。简单的讲,Servlet就是运行在服务器上的一个小程序,用来处理服务器接收到的请求。

    比如一般的网页程序,是由我们通过浏览器来访问实现的,在这个过程中,我们的浏览器发送访问请求,服务器接收到请求,并对浏览器的请求做出相应的处理,这就是我们熟悉的B/S模型(浏览器—服务器模型)。而Servlet就是对请求做出处理的组件,运行于支持java的应用服务器中。

    Servlet从狭义上说白了就是个接口,从广义上说就是实现了这个接口的所有的子类。

    附加:我们打开项目目录下的JSP文件查看其源码,可以发现JSP底层也是实现了Servlet接口的,所以JSP它本质上就是一个Servlet。

    二、Servlet的作用

    在Servlet刚刚出现的年代,Servlet的作用十分复杂,即承担了处理数据的作用,又承担了展示页面的作用,导致代码的耦合性过高,不易于维护。随着时间的推移,出现了MVC思想,也就是模型 - 界面 - 控制器思想,极大的简便了开发,也明确了Servlet的作用。

    附加:最经典的MVC模型是:JSP+JavaBean+Servlet开发模式。

     根据上图我们可以知道,Servlet在其中承担的作用是Controller(控制器),起到对数据进行操作的作用。

    三、Servlet处理的信息是什么

    如图:我们查找Servlet底层的实现类以及实现类的子类。

    除了自定义的实现类以外,还有GenericServlet实现类,该实现类中的service()方法没有实现接口中对应的方法,而是继续抽象下去。

    继续查找service()方法是在哪个类中实现的。随之就找到了HttpServlet这个子类。如图:

    HttpServlet是直接继承的GenericServlet,从上图所见,客户端发送到服务器的请求类型是多样化的,而Servlet作为控制器处理的就是这些请求报文(request)

    如下图:对客户端传过来的请求类型进行判断,更具传过来的类型执行对应的处理请求数据的方法。

    注意:我们的Web应用完全是基于http协议的。而http有请求报文(request)和响应报文(response),请求报文就是浏览器向服务器发送的数据形成的数据对象,同理,响应报文就是服务器向浏览器发送的数据形成的数据对象,而http有两个重要的方法,也就是上图中HttpServlet中的doPost()和doGet()方法。这两个方法对应的post和get,就是前端表单中使用的。比如你登录某网站首页时,提交用户名和密码,就是被http协议封装成请求报文的形式发送到服务器的,这样,servlet就能够读取请求报文的类容,并对报文进行处理。

    四、Servlet的开发流程

    (一)、实现Servlet接口或者继承HttpServlet类

    注:继承HttpServlet类更简洁更常用。

    (二)、重写HttpServlet类的doGet()和doPost()方法

    (三)、配置web.xml文件或者使用注解对servlet进行配置

    1、首先在maven配置文件pom.xml中导入Servlet - API的依赖

    2、使用web.xml配置servlet访问路径

    3、使用注解配置servlet访问路径

    注意:配置访问路径,注解和web.xml两者二选一即可,避免混淆!

    五、Servlet的生命周期

    我们通过去实现Servlet接口的方式观察Servlet的生命周期。如图:

    所谓生命周期,就是Servlet什么时候创建,调用了何种方法,最后在什么时候被销毁。我们之前学过的对象都是自己手动创建的,最后由JVM来销毁,而Servlet的整个生命周期,都是由tomcat服务器来控制的。

    由上图所示,程序运行后得出结论,Servlet的生命周期是:

    实例化 --》初始化 --》多次调用service服务 --》 tomcat容器关闭时销毁

    • 默认情况下Servlet是在第一次访问的时候实例化和初始化的
    • 第一次访问就会调用service()服务方法
    • 直到关闭服务器时,Servlet才会被销毁

    除了默认情况,我们也可以通过load-on-startup来控制Servlet在服务器启动的时候就加载(实例化+初始化)

    (一)、通过web.xml文件来配置load-on-startup(启动时加载)优先级

    (二)、通过注解来配置load-on-startup(启动时加载)优先级

    注意:配置load-on-startup启动时加载时,web.xml和注解两种方式,二选一即可。

    六、Servlet获取参数的方法

    这里主要解析Servlet获取get和post参数的方式,主要有三种:

    1. 使用getParameter()获取参数方法,单个获取。
    2. 使用getParameterMap()获取Map键值对参数的方法。
    3. get特有的查询字符串的方法以及post以流的形式查询字符串的方法。

    (一)、单个获取请求参数的方法

    (二)、获取键值对形式的请求参数的方法

    注意该方法获取到的请求参数是以Map键值对的形式存在的,并且在构造实体时,我们还需要将获取到的Map类型的参数通过BeanUtils工具类转换为需要的实体类类型进行构造。所以需要先导入BeanUtils的依赖。

    1、在maven配置文件中导入BeanUtils工具类的依赖

    2、获取参数,构造实体

    (三)、get特有的查询字符串的方法以及post以流的形式查询字符串的方法。

    这两种获取字符串的方式比较特别,get获取的是浏览器中URL地址栏访问路径?后面的参数,而post是从请求体中获取参数,这两者获取到的字符串参数都是URL编过码的,所以在获取参数时候都需要解码

    1、get请求特有的查询字符串方法

    2、post请求以流的形式获取请求体中的字符串参数

    在使用该方法前,我们需要先简单了解下tomcat的工作原理:

    如图所示,整个过程都是以流的形式传输的,所以在post请求中要获取请求体中的字符串参数,就需要先获取到这条输入流。

    注意:获取流查询字符串参数的方式要放在最前面执行,因为流是只能消耗一次,放在其它操作过流的方法后面该方法就获取不到数据了,因为流被消耗了。

    七、Servlet响应页面和数据

    (一)、Servlet响应页面

    响应页面,也就是收到前端的请求响应需要跳转的页面。Servlet响应页面有转发重定向两种方式(之前JSP的章节也讲过):

    1、转发 — 也就是携带客户端发送的请求转发跳转到下一个页面,使用的是request请求对象。

    //转发可以将请求中的数据带到新的页面。
    //getRequestDispatcher():表示获取请求转发器的方法
    //forward():表示将请求及响应对象一并转发到下一个新页面
    request.getRequestDispatcher("跳转页面路径").forward(request,response);

    2、重定向 — 服务器接收到前端请求,通过响应将要跳转的页面地址响应给客户端,客户端再重新发送请求跳转到目标页面。

    //重定向是将要跳转的页面路径交给前端重新发送请求跳转页面。
    //相当于客户端发送了两次请求,所以原来请求中的数据就没有了。
    response.sendRedirect("响应的页面路径")

    (二)、Servlet响应数据

    响应数据也是通过流的方式响应给前端,这里主要用到的是一条打印流(也就是之前JSP中的内置对象out).响应数据一般都是响应的json格式的数据,前端获取到json格式的数据就相当于拿到了一个对象,通过对象的方式去获取数据。

    1、获取到打印流响应普通数据(注意:有乱码要设置编码格式)

    2、响应json字符串格式的数据

    • 首先我们需要先在maven中导入json的依赖,如图:

    • 响应json格式数据

    八、Web项目的初始化参数

    在web项目中初始化参数有三种:

    1. 每个Servlet可以有自己的初始化参数。
    2. 一个应用程序application也有自己的初始化参数
    3. 一个tomcat也有自己的初始化参数。

    (一)、Servlet中的初始化参数如何配置及如何获取

    1、配置Servlet初始化参数

    2、获取Servlet初始化参数

    • 通过Servlet对象本身this获取Servlet初始化参数

    • 通过Servlet的初始化方法中的config配置对象获取Servlet初始化参数

    (二)、application在应用中初始化参数如配放置如何获取

    1、配置应用中的初始化参数

    2、获取application应用中的初始化参数

    (三)、tomcat中初始化参数如何配置如何获取

    配置tomcat的初始化参数,需要到tomcat的conf文件目录中找到context.xml文件源码进行配置。

    这里会使用到jndi规范(java naming directory interface译:java命名目录接口)进行配置。jndi也就是通过命名和资源关联起来的一种编程规范。

    1、配置tomcat的初始化参数

    2、获取tomcat的初始化参数

    九、Servlet的线程安全问题

    同一个Servlet在服务器中只会存在一个实例,不论是多少个访问,都调用的是同一个实例,也就是Servlet是单实例多线程的。这就存在着一定的线程安全问题,如果在Servlet中定义一个全局变量,那么程序运行这个变量的值很有可能会不是我们所预期的,所以在Servlet中要尽量避免使用全局变量。

    运行如下程序实例Servlet的线程安全问题:

    运行结果反应出Servlet中出现成员变量导致线程不安全:

    所以Servlet中尽量避免出现成员变量。


    总结

    Servlet的基础概念及使用规范,还有上篇讲的JSP技术都是为开发Web项目做准备。后续还会更新过滤器以及MVC和三层架构等……

    展开全文
  • Servlet基础Demo

    2017-05-24 10:06:34
    Servlet基础Demo
  • Servlet基础

    2018-09-09 17:15:55
    Servlet基础 Tomcat 是Web应用服务器,是一个Servlet/JSP容器.Tomcat 作为Servlet容器,负责处理客户请求,把请求传送给Servlet,并将Servlet的响应传送回给客户.而Servlet是一种运行在支持Java语言的服务器上的组件. ...
  • 主要为大家详细介绍了servlet基础的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Servlet基础补充案例 习题.doc
  • Servlet基础笔记.md

    2021-09-26 22:09:08
    Servlet基础介绍及五大对象
  • Servlet基础 Servlet基础 Servlet基础 Servlet基础 Servlet基础
  • servlet基础

    2018-01-18 16:25:19
    servlet基础简介,通过从文档了解servlet的基础,学习起来更方便
  • servlet基础笔记

    2015-06-27 14:33:23
    servlet 基础笔记 servlet基础 servlet入门
  • 本文将使用 javax.servlet.http 包中的类 ,javax.servlet.http 包不在JDK 的核心类库中, 因此需要将 Tomcat 安装目录lib 子目录中的servlet-api.jar 文件复制到 Tomcat服务器所使用的JDK的扩展目录中,比如,复制...
  • servlet 8个最基础demo

    2014-06-23 11:36:10
    服务器上需要一些程序,常常是根据用户输入访问数据库的程序。这些通常是使用公共网关接口(CGI(Common Gateway Interface))应用程序完成的。然而,在服务器上运行Java,这种程序可使用Java编程语言实现。在通信量...
  • servlet基础及快速入门

    2021-09-08 18:20:54
    Servlet
  • 主要介绍了Java基础 Servlet监听器详解的相关资料,需要的朋友可以参考下
  • Servlet基础源代码

    2017-12-20 21:18:20
    java web 的学习最基础篇章,全部是基础代码,通俗易懂。 *
  • Servlet基础.docx

    2021-12-17 16:53:55
    Servlet基础
  • Servlet 教程 Servlet 为创建基于web 的应用程序提供了基于组件独立于平台的方法可以不受CGI 程序的性能限制...现在开始学习Servlet 谁适合阅读本教程 本教程是专为Java 程序员设计的在阅读本教程之前需要先了解Ja
  • 本文从Java Web开发中较为基础的概念出发,逐步介绍Servlet的相关内容。 包括ServletAPI简单解析,最常用的相关功能到JSP与Servlet的关系。 力求从最简单的、最基础的概念出发,利用丰富多彩的图片详细的描述这些...


    一、Servlet是什么

    1.1 Servlet

    Servlet(Server Applet)是Java Servlet的简称,称为小服务程序或服务连接器,泛指用 Java编写的服务器端程序。在编程过程中也指一切 实现了Servlet接口的类(约定以Servlet结尾命名)。

    1.2 Servlet API

    JAVA Servlet 作为JAVA EE中Web开发的重要技术之一,也是理解各种Java Web开发框架的重要基础,接下来看一下Servlet-api中主要包含哪些结构:

    • javax.servlet
      -作为servlet API的基础,包含Servlet类基类和Servlet与Servlet容器的契约
    • javax.servlet.annotation
      -包含标注信息,提供简单部署的方式
    • javax.servlet.descrptor
      -包含提供程序化登录Web应用程序的配置信息的类型
    • javax.servlet.http
      -包含HttpServlet,Servlet对Http协议的变体

    在这里插入图片描述

    二、Servlet的主要功能

    2.1 Servlet的简单运用流程展示

    Servlet 的主要功能在于交互式地浏览和修改数据,生成动态 Web 内容。这个过程为:

    1. 客户端发送请求至服务器端
    2. 服务器将请求信息发送至 Servlet
    3. Servlet 生成响应内容并将其传给服务器,响应内容动态生成
    4. 服务器将响应返回给客户端

    Servlet 看起来像是通常的 Java 程序。Servlet 导入特定的属于 Java Servlet API 的包。
    一个 Servlet 就是 Java 编程语言中的一个类,它被用来扩展服务器的性能,服务器上驻留着可以通过“请求-响应”编程模型来访问的应用程序。虽然 Servlet 可以对任何类型的请求产生响应,但通常只用来扩展 Web 服务器的应用程序。
    在这里插入图片描述
    下面是一个简单实现的代码:

    import javax.servlet.*;
    import javax.servlet.annotation.WebServlet;
    import java.io.IOException;
    import java.io.PrintWriter;
    @WebServlet(urlPatterns = "/myservlet")//注解部署-javax.servlet.annotation部分
    public class MyServlet implements Servlet {//Servlet属于javax.servlet核心部分
        @Override
        public void init(ServletConfig servletConfig) throws ServletException {
        }
        @Override
        public ServletConfig getServletConfig() {
            return null;
        }
    		//主要的功能函数-实现Request请求解析,以及进行处理和响应请求
        @Override
        public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
            String message=req.getParameter("message");
            res.setContentType("text/html");
            PrintWriter out=res.getWriter();
            out.print("<html><head>MyServlet Return Page</head>");
            out.print("<body><p style='background-color: "+message+"'>"+message+"</p></body></html>");
        }
        @Override
        public String getServletInfo() {
            return null;
        }
        @Override
        public void destroy() {
        }
    }
    

    2.2 Servlet API常用功能概览

    简单的类接口和功能概括如下图:(其中HttpServlet在javax.servlet.http中,其余在javax.servlet中)
    在这里插入图片描述

    2.2.1 Servlet

    接口定义了如下5种方法:

    //初始化,传入Tomcat实例化的一个ServletConfig进行配置
    void init(ServletConfig config) throws ServletException
    //主要功能函数-传入Tomcat转发封装好的一个ServletRequest实例,
    //和封装好的出口ServletResponse输出即可
    void service(ServletRequest req,ServletResponse res)throws ServletException,IOException
    //在Servlet类销毁时调用,输出必要信息
    void destory()
    //以下略
    String getServletInfo()
    ServletConfig getServletConfig()
    
    2.2.2 GenericServlet

    该类是对于Servlet接口的简单实现:
    由于直接实现Servlet接口需要实现5个方法,但是一般我们只管service方法,为了减少不必要的实现,使用GenericServlet对其进行简单实现。
    继承GenericServlet的类只需要重写需要用到的方法即可

    2.2.3HttpServlet

    其作为更有效的扩展,是面对Http协议的专业Servlet封装:
    对于传入的ServletRequest,该类会自动解析其Http包,然后调用doGet/doPost/doHead等方法,因此在实现继承该类时,只需要实现相应的方法即可,具体如下:

    import *@WebServlet(urlPatterns = {"/books"})
    public class BookControServlet extends HttpServlet {
        private static final int serialVersionUID=-123;
        @Override
        public void doGet(HttpServletRequest req, HttpServletResponse res)throws ServletException, IOException{
            List<Book> books=new ArrayList<>();
            books.add(new Book("isbn-1","YOUR NAME",120));
            books.add(new Book("isbn-2","MY NAME",100));
            books.add(new Book("isbn-3","HIS NAME",60));
            books.add(new Book("isbn-4","HER NAME",250));
            //给Request添加一些属性
            req.setAttribute("books",books);
            req.setAttribute("now",new Date());
            //转发到另外一个Servlet处理
            RequestDispatcher rd=req.getRequestDispatcher("/books.jsp");
            rd.forward(req,res);
        }
    }
    
    2.2.4 ServletRequest和ServletResponse

    作为Servlet类(泛指)处理请求和输出的窗口
    ServletRequest类包含请求体的所有消息:

    +getContentLength():int//返回请求主体字节长度,未知返回-1
    +getContentType():String//返回请求主体类型
    +getProtocol():String//返回HTTP请求协议名
    
    +getParameter(String):String//最常用,返回请求参数值Get请求参数在url有显示,见上(简单实现)
    
    

    ServletResponse类包含相应请求的方式:

    +setContentType(String)//设置响应格式,如"text/html"
    +getWriter():java.io.PrintWriter//返回输出接口,具体见上(简单实现)
    
    2.2.5 ServletConfig和ServletContext

    ServletConfig作为Servlet类实例时的一个必要的配置信息,由服务器(容器)根据相关配置创建一个实例传入init(ServletConfig),实例如下:

    import javax.servlet.*;
    import javax.servlet.annotation.WebInitParam;
    import javax.servlet.annotation.WebServlet;
    import java.io.IOException;
    import java.io.PrintWriter;
    @WebServlet(name = "MyServlet", urlPatterns = "/myservlet",
            initParams = {
                    @WebInitParam(name="config_var_1",value = "value_1"),
                    @WebInitParam(name="config_var_2",value = "value_2")
            }//初始配置
    )
    public class MyServlet extends GenericServlet {
        @Override
        public void service(ServletRequest req,ServletResponse res)throws ServletException,IOException{
            ServletConfig servletconfig = getServletConfig();
            System.out.println(servletconfig.getInitParameter("config_var_1"));
            System.out.println(servletconfig.getInitParameter("config_var_2"));
        }
    }
    

    在这里插入图片描述
    ServletContext则是所有Servlet类的容器信息,包含一个Web应用内所有Servlet的注册信息,在高级操作中可以通过该类实现动态注册Servlet类。(初级略)

    2.2.5 RequestDispatcher和Filter

    在这里插入图片描述其中Filter需要单独部署,由设计者单独实现一个Filter类,并部署相关拦截条件。
    而RequestDispatcher则直接使用即可,见上(简单实现)

    三、JSP也是一个Servlet类

    3.1JSP(JavaServer Pages)的与众不同

    一个JSP页面如下:

    <%--//JSP指令--%>
    <%@ page import="java.text.DateFormat" %>
    <%@ page import="java.util.Date" %>
    <%@ page import="java.util.Enumeration" %>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    <%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
    <%--//纯HTML内容--%>
    <html>
    <head>
        <title>$Title$</title>
    </head>
    <style>
        body {
            /*EL表达式*/
            background-color: ${cookie.color.value};
        }
    </style>
    <body>
    <H1 style="background-color: darkgreen"><a href="books">BOOKS SHOW</a></H1>
    hello World!!!<br/>
    
    <%--//JSP动作--%>
    <jsp:include page="extend.html"/>
    
    <%--//标准标签--%>
    <c:set var="x" value="100"/>
    <c:out value="${x}"/>
    
    <%--//JSP脚本--%>
    <%
        DateFormat dateformat = DateFormat.getDateInstance(DateFormat.LONG);
        String s = dateformat.format(new Date());
        out.println("<br>Today is " + s + "<br>");
    %>
    <hr/>
    
    <%
        for (Enumeration<String> e = request.getHeaderNames();
             e.hasMoreElements(); ) {
            String header = e.nextElement();
            out.println(header + ": " + request.getHeader(header) + "<br>");
        }
    %>
    <hr/>
    
    <%
        out.println("BufferSize: " + response.getBufferSize() + "<br>");
        out.println("Session id: " + session.getId() + "<br>");
        out.println("Servlet name: " + config.getServletName() + "<br>");
        out.println("Server info: " + application.getServerInfo());
    %>
    </body>
    </html>
    
    

    在这里插入图片描述

    3.2 Servlet的缺点和JSP基本用法

    1. 在之前的Servlet学习中,不难发现,输出一个html页面已经是非常繁琐,需要写一长串字符串,修改麻烦而且结构混乱。
    2. 其次,Servlet每次修改完,都需要一次编码载入才能使用,在较大规模开发的时候十分不方便。

    于是诞生了JSP这种特殊的Servlet,他能够实现自动输出纯html语句,能够动态修改,不用每次修改都编译。

    JSP语法简单,能够一定程度上实现前后端分离的需要,具体的内容主要包含三个部分:

    3.2.1指令

    基础语法是

    <%@ introductName attribute1="value1" attribute2="value2"...%>
    <%-- 注释:比如导入相关包 --%>
    <%@ page import="java.util.Date" %>
    <%-- 注释:比如引入标准标签库 --%>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    
    3.2.2脚本元素

    脚本就是用<% … %>包含的Java语句,类比与HTML中的JavaScript脚本,比如:

    <%--//JSP脚本--%>
    <%
    		//输出当前日期
        DateFormat dateformat = DateFormat.getDateInstance(DateFormat.LONG);
        String s = dateformat.format(new Date());
        out.println("<br>Today is " + s + "<br>");
    %>
    
    3.2.3动作

    相当于JSP的函数,也可以看成标签具体如下:

    <%-- 标准标签,设置变量和输出变量 --%>
    <c:set var="x" value="100"/>
    <c:out value="${x}"/>
    <%-- 导入文件 --%>
    <jsp:include page="extend.html"/>
    
    3.2.4无需部署直接访问

    直接在浏览器输入url指向JSP文件即可获取JSP动态加载后的页面,如下:
    在这里插入图片描述

    求支持

    作者长期更新分享原创文章,如果觉得本文还算不错的话,请给我一个大大的赞!!!
    如果非常赞同这篇文章,请关注我,持续了解更多精彩博文!!!

    展开全文
  • Servlet 基础教程

    2014-07-31 12:45:20
    Servlet基础教程 http原理 request, response
  • servlet基础.pptx

    2019-06-06 22:59:40
    详细介绍了java servlet的运行过程,构成的元素,及其实现原理,
  • servlet基础与servlet容器模型
  • Servlet + MVC 基础

    2022-04-29 18:00:08
    Servlet + MVC 基础 文章目录Servlet + MVC 基础一、Servlet简介二、Servlet生命周期三、Servlet与JSP的区别四、MVC简介MVC Model 1:MVC Model 2:MVC的优缺点: 一、Servlet简介  Servlet,即Server&Applet...

    Servlet + MVC 基础



    一、Servlet简介

     Servlet,即Server&Applet,是在服务器上运行的小程序。一个Servlet就是一个Java类,并且可以通过“请求—相应”编程模型来访问的这个驻留在服务器内存里的Servlet程序。


    二、Servlet生命周期

     Servlet程序被访问后将执行以下的流程:

    1. 装载Servlet类并创造实例,执行其构造方法
    2. 调用 init 方法
    3. 调用 service 方法
    4. 调用 destroy 方法


    三、Servlet与JSP的区别

    • JSP本质为Servlet,Servlet可视为被编译后的JSP;
    • Servlet完全由Java代码组成,更利于逻辑控制,而JSP则更适用于页面显示;
    • Servlet的应用逻辑是在Java文件中,并且完全从表示层中的HTML里分离开来。而JSP是Java与Html组合成的一个扩展名为.jsp的文件;
    • Servlet中没有内置对象,JSP中的内置对象都是通过HttpServletRequest对象,HttpServletResponse对象以及HttpServlet对象得到;

    Servlet与JSP九大内置对象:


    四、MVC简介

     MVC模式:MVC(Model、View、Controller),旨在分离模型、控制、视图。是一种分层思想的体现。

    MVC Model 1:

     浏览器发出请求,被控制器(Controller,一般为Servlet)所接受,Servlet将实例化一个模型层(Model,一般为JavaBean)对象,接着Javabean调用数据库层(EIS),得到的结果可以返回给控制层或界面层(View,即JSP页面),最终将结果呈现给用户。


    MVC Model 2:

     JSP页面给控制层提交请求,控制层会实例化一个模型层对象或调用模型层的功能,随后模型层会访问数据库层读取数据并反馈给控制层,最终将结果呈现给用户。


    MVC的优缺点:

    MVC的优点:

    • 代码的重用性高
    • 可维护性高
    • 部署快
    • 利于开发人员间的分工合作

    MVC的缺点:

    • 代码的复杂性较高,对小型项目使用时可能会降低效率
    • 视图和控制层之间连接过于紧密
    • 访问效率较低
    展开全文
  • jsp/servlet基础课件

    2012-08-03 15:59:56
    jsp 与servlet基础学习 ppt课件
  • 02_Servlet基础;回顾;2.1 了解什么是Servlet --Servlet的工作机制;2.1 了解什么是Servlet --Servlet的工作机制;2.1 了解什么是Servlet --Servlet的工作机制;2.1 了解什么是Servlet --Servlet的工作机制;了解Servlet...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 208,020
精华内容 83,208
关键字:

servlet需要什么基础