五、JavaWeb基础(servlet、http协议、request和response请求详解、ServletContext对象)

一、Servlet：server applet 1. 概念：

运行在服务器端的小程序

Servlet就是一个接口，定义了Java类被浏览器访问到(tomcat识别)的规则。我们只要实现Servlet接口，复写其中的方法即可。

2. Servlet简单案例入门：

实现步骤：

创建JavaEE项目
定义一个类，实现Servlet接口
public class ServletDemo1 implements Servlet
实现接口中的抽象方法
配置Servlet

代码如下：

项目结构如下：
修改项目的虚拟请求路径

在web.xml中配置：



    
    
        
        demo
        
        com.kejizhentan.servlet.Demo
    
    
        
        demo
        /demo

Java代码：

public class Demo implements Servlet {

	
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("执行了init方法...");
    }
    
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

	 
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("hello servlet");
    }

	
    @Override
    public String getServletInfo() {
        return null;
    }

    
    @Override
    public void destroy() {
        System.out.println("执行了destroy方法...");
    }
}

请求和结果如下：

执行原理：
1. 当服务器接受到客户端浏览器的请求后，会解析请求URL路径，获取访问的Servlet的资源路径
2. 查找web.xml文件，是否有对应标签体内容。
3. 如果有，则在找到对应的全类名
4. tomcat会将字节码文件加载进内存，并且创建其对象
5. 调用其方法

3. Servlet中的生命周期方法： ⑴ 被创建：执行init方法，只执行一次 ① Servlet什么时候被创建？

默认情况下，第一次被访问时，Servlet被创建。
可以配置执行Servlet的创建时机。
在标签下配置

第一次被访问时，创建
的值为负数
在服务器启动时，创建
的值为0或正整数

Servlet的init方法，只执行一次，说明一个Servlet在内存中只存在一个对象，Servlet是单例的
多个用户同时访问时，可能存在线程安全问题。
解决：尽量不要在Servlet中定义成员变量。即使定义了成员变量，也不要对其修改值

② 提供服务：执行service方法，执行多次

每次访问Servlet时，Service方法都会被调用一次。

③ 被销毁：执行destroy方法，只执行一次

Servlet被销毁时执行。服务器关闭时，Servlet被销毁。只有服务器正常关闭时，才会执行destroy方法。 destroy方法在Servlet被销毁之前执行，一般用于释放资源。

4. Servlet3.0：支持注解配置。可以不需要web.xml了。

步骤：

创建JavaEE项目，选择Servlet的版本3.0以上，可以不创建web.xml
定义一个类，实现Servlet接口
复写方法
在类上使用@WebServlet注解，进行配置
@WebServlet("资源路径")

代码如下：

项目结构：
修改项目的虚拟请求路径

Java代码：

@WebServlet("/demo")
public class ServletDemo implements Servlet {
    
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("执行了init方法...");
    }
    
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("hello servlet");
    }

    
    @Override
    public String getServletInfo() {
        return null;
    }

    
    @Override
    public void destroy() {
        System.out.println("执行了destroy方法...");
    }
}

请求和结果如下：

@WebServlet注解详解：

5. IDEA与tomcat的相关配置 ⑴ IDEA会为每一个tomcat部署的项目单独建立一份配置文件

通过该配置文件可以找到tomcat部署的项目

Using CATALINA_base: “C:UsersAdministrator.IntelliJIdea2019.3systemtomcatTomcat_8_5_31_servlet-project_2”

根据控制台打印的路径，找到对应的文件夹

打开servlet.xml配置文件

⑵ 工作空间项目和 tomcat部署的web项目

tomcat真正访问的是“tomcat部署的web项目”，“tomcat部署的web项目"对应着"工作空间项目” 的web目录下的所有资源

WEB-INF目录下的资源不能被浏览器直接访问。

6. Servlet的体系结构

GenericServlet(一般不常用)：将Servlet接口中其他的方法做了默认空实现，只将service()方法作为抽象，将来定义Servlet类时，可以继承GenericServlet，实现service()方法即可。

HttpServlet(常用)：对http协议的一种封装，简化操作
定义类继承HttpServlet，复写doGet/doPost方法

7 Servlet相关配置 ⑴ urlpartten:Servlet访问路径 ① 一个Servlet可以定义多个访问路径： @WebServlet({"/d4","/dd4","/ddd4"}) ② 路径定义规则：

/xxx：路径匹配
/xxx/xxx:多层路径，目录结构
*.do：扩展名匹配(不能加‘/’)

二、HTTP：Hyper Text Transfer Protocol 超文本传输协议 1. 概念：

传输协议：定义了客户端和服务器端通信时发送数据的格式

2.特点：

基于TCP/IP的高级协议
默认端口号:80
基于请求/响应模型的:一次请求对应一次响应
无状态的：无状态是指协议对于事务处理没有记忆能力，简单说就是每次请求处理完断开后，没有记录信息，客户端再次请求，服务端也不能识别是否是同一个客户端。

历史版本：

1.0版本：每一次请求响应都会建立新的连接
1.1版本：复用连接

⑴ 请求消息数据格式 ① 请求行

请求方式请求url 请求协议/版本

例如：
GET /login.html HTTP/1.1

请求方式：
HTTP协议有7中请求方式，常用的有2种

GET：
1. 请求参数在请求行中，在url后。
2. 请求的url长度有限制的
3. 不太安全
POST：
1. 请求参数在请求体中
2. 请求的url长度没有限制的
3. 相对安全

② 请求头：客户端浏览器告诉服务器一些信息

请求头名称: 请求头值

常见的请求头：

User-Agent：浏览器告诉服务器，我访问你使用的浏览器版本信息
* 可以在服务器端获取该头的信息，解决浏览器的兼容性问题

Referer：http://localhost/login.html
* 告诉服务器，我(当前请求)从哪里来？
* 作用：
1. 防盗链：
2. 统计工作：

③ 请求空行

空行，就是用于分割POST请求的请求头，和请求体的。

④ 请求体(正文,get方法没有请求体)：

封装POST请求消息的请求参数的

请求消息数据格式以post为例：

POST /login.html	HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*
        String method = request.getMethod();
        System.out.println("请求的方式为："+method);
        System.out.println("***************************************************");
        String contextPath = request.getContextPath();
        System.out.println("请求的虚拟目录为："+contextPath);
        System.out.println("***************************************************");
        String servletPath = request.getServletPath();
        System.out.println("请求路径为："+servletPath);
        System.out.println("***************************************************");
        String queryString = request.getQueryString();
        System.out.println("请求参数为："+queryString);
        System.out.println("***************************************************");
        String requestURI = request.getRequestURI();
        System.out.println("请求uri为："+requestURI);
        System.out.println("***************************************************");
        StringBuffer requestURL = request.getRequestURL();
        System.out.println("请求url为："+requestURL);
        System.out.println("***************************************************");
        String protocol = request.getProtocol();
        System.out.println("协议版本号为"+protocol);
        System.out.println("***************************************************");
        String remoteAddr = request.getRemoteAddr();
        System.out.println("客户机的ip为:"+remoteAddr);
    }
}

请求如下：

结果如下：

2. 获取请求头数据
方法：

String getHeader(String name):通过请求头的名称获取请求头的值
Enumeration getHeaderNames():获取所有的请求头名称（返回值是个枚举，该枚举的获取和迭代器类似）

代码如下：

@WebServlet("/demo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       //获取请求头数据
        //1.获取所有的请求头名称
        Enumeration headerNames = request.getHeaderNames();
        //2.遍历请求头中的名称
        while(headerNames.hasMoreElements()){
            //获取请求头中的名称
            String name = headerNames.nextElement();
            //根据请求头的名称获取请求头名称对应的值
            String value = request.getHeader(name);
            System.out.print("请求头的名称为："+name);
            System.out.print("——>对应的值为："+value);
            System.out.println();
        }

        System.out.println("*******************************演示获取请求头数据：user-agent对应的值来判断请求的浏览器版本************************************");
        String agent = request.getHeader("user-agent");
        //判断浏览器的版本
        if(agent != null && agent.contains("Chrome")){
            //谷歌浏览器
            System.out.println("通过谷歌浏览器发起的访问！！！！");
        }else if(agent != null && agent.contains("Firefox")){
            System.out.println("通过火狐览器发起的访问！！！！");
        }
    }
}

请求如下：

结果如下：

防盗链的案例：
index.html页面



    
    模拟防盗链


点击播放电影

hello.html页面



    
    模拟防盗链


点击播放电影

实现防盗链的Servlet

@WebServlet("/demo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //演示获取请求头数据:referer
        String referer = request.getHeader("referer");
        System.out.println(referer);//如果通过地址栏直接访问，referer的值是null
        //防盗链
        if(referer != null ){
            if(referer.contains("/servlet/hello.html")){
                //正常访问
                response.setContentType("text/html;charset=utf-8");
                response.getWriter().write("播放电影....");
            }else{
                //盗链
                response.setContentType("text/html;charset=utf-8");
                response.getWriter().write("想看电影吗？来优酷吧...");
            }
        }else{
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write("直接访问referer的值为null...");
        }
    }
}

请求的演示如下：

打印的结果如下：

3. 获取请求体数据:
请求体：只有POST请求方式，才有请求体，在请求体中封装了POST请求的请求参数

步骤：
1. 获取流对象
* BufferedReader getReader()：获取字符输入流，只能操作字符数据
* ServletInputStream getInputStream()：获取字节输入流，可以操作所有类型数据（在文件上传知识点后讲解）
2. 再从流对象中拿数据

获取字符流的演示：

注册页面：regist.html



    
    注册界面



    姓名：
    密码：

ServletDemo.java代码

@WebServlet("/demo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取请求消息体--请求参数
        //1.获取字符流
        BufferedReader br = request.getReader();
        //2.读取数据
        String line = null;
        while((line = br.readLine()) != null) {
            System.out.println(line);
        }
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }
}

结果如下：

② 其他功能：

1.获取请求参数通用方式：
不论get还是post请求方式都可以使用下列方法来获取请求参数

String getParameter(String name):根据参数名称获取参数值 username=zs&password=123
String[] getParameterValues(String name):根据参数名称获取参数值的数组如：hobby=xx&hobby=game
Enumeration getParameterNames():获取所有请求的参数名称
Map getParameterMap():获取所有参数的map集合

中文乱码问题：
* get方式：tomcat 8 已经将get方式乱码问题解决了
* post方式：会乱码
解决：在获取参数前，设置request的编码request.setCharacterEncoding("utf-8");

例如：通过获取请求参数通用方式的演示

注册页面regist.html如下：



    
    注册界面



    用户名：

    密码：

    爱好：游戏
    学习

获取参数值的ServletDemo如下：

@WebServlet("/demo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.设置流的编码
        request.setCharacterEncoding("utf-8");
        
        //根据参数名称获取参数值
        String name = request.getParameter("username");
        System.out.println("根据参数名称获取参数值为："+name);
        System.out.println("-------------------根据参数名称获取参数值的数组-------------------------");
        //根据参数名称获取参数值的数组
        String[] hobbies = request.getParameterValues("hobby");
        for (String hobby : hobbies) {
            System.out.println(hobby);
        }
        System.out.println("------------------获取所有请求的参数名称和参数的值-------------------------------");
        //获取所有请求的参数名称
        Enumeration parameterNames = request.getParameterNames();
        while(parameterNames.hasMoreElements()){
            String param = parameterNames.nextElement();
            String str = request.getParameter(param);
            System.out.println("请求参数的名称为："+param+"——>对应的值为："+str);
        }
        System.out.println("---------------------------获取所有参数的map集合并且遍历取key和value----------------------------------------");
        Map parameterMap = request.getParameterMap();
        Set strings = parameterMap.keySet();
        for (String key : strings) {
            String[] values = parameterMap.get(key);
            for (String value : values) {
                System.out.println("参数key为："+key+"——>对应的值为："+value);
            }
        }
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //使用通用方式获取请求参数时，doPost和doGet可以通过下面的方式来只写一个就可以
        this.doPost(request,response);
    }
}

结果如下：

2. 请求转发：一种在服务器内部的资源跳转方式

步骤：

通过request对象获取请求转发器对象：RequestDispatcher getRequestDispatcher(String path)
使用RequestDispatcher对象来进行转发：forward(ServletRequest request, ServletResponse response)

特点：

浏览器地址栏路径不发生变化
只能转发到当前服务器内部资源中。
转发是一次请求

3.共享数据：

域对象：一个有作用范围的对象，可以在范围内共享数据
request域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据
方法：
void setAttribute(String name,Object obj):存储数据
Object getAttitude(String name):通过键获取值
void removeAttribute(String name):通过键移除键值对

案例：通过请求转发共享request域中的数据：
AServlet代码：

@WebServlet("/aServlet")
public class AServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("AServlet被访问了！！！");
        //存储数据到request域中
        request.setAttribute("msg","hello");
        //转发到BServlet资源
        
        request.getRequestDispatcher("/bServlet").forward(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

BServlet代码：

@WebServlet("/bServlet")
public class BServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取数据
        Object msg = request.getAttribute("msg");
        System.out.println("Aservlet的request域中存储的值为:"+msg);
        System.out.println("BServlet被访问了。。。");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

结果如下：

4. 获取ServletContext：
ServletContext getServletContext()
例如：

@WebServlet("/demo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        ServletContext servletContext = request.getServletContext();
        System.out.println(servletContext);
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //使用通用方式获取请求参数时，doPost和doGet可以通过下面的方式来只写一个就可以
        this.doPost(request,response);
    }
}

⑷ BeanUtils工具类，简化数据封装

用于封装JavaBean的

① JavaBean：标准的Java类

1. 要求：
1. 类必须被public修饰
2. 必须提供空参的构造器
3. 成员变量必须使用private修饰
4. 提供公共setter和getter方法
2. 功能：封装数据

② 概念：

1.成员变量：
javaBean中一般用private的变量
2.属性：
setter和getter方法截取后的产物
例如：getUsername() --> Username–> username

③BeanUtils工具类中的方法：

void setProperty()
String getProperty()
void populate(Object obj , Map map):将map集合的键值对信息，封装到对应的JavaBean对象中

例如：
项目结构：

BeanUtils依赖包
点击下载包

代码如下：
Student类

public class Student {
    private String username;
    private String password;
    private String[] hobby;
   	...
}

测试类：

public class Test {
    public static void main(String[] args) {
        try {
            Student student = new Student();
            BeanUtils.setProperty(student,"username","张三");
            System.out.println(student);
            Map maps = new HashMap<>();
            String[] str = {"张三"};
            String[] password = {"123456"};
            String[] hobby = {"学习","打游戏"};
            maps.put("username",str);
            maps.put("password",password);
            maps.put("hobby",hobby);
            BeanUtils.populate(student,maps);
            System.out.println(student);
            String username = BeanUtils.getProperty(student, "username");
            System.out.println(username);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

结果如下：

2. Response对象 ⑴ Response对象的功能：设置响应消息 ① 设置响应行

格式：HTTP/1.1 200 ok
设置状态码：setStatus(int sc)

② 设置响应头：

setHeader(String name, String value)

③ 设置响应体：

使用步骤：

获取输出流
* 字符输出流：PrintWriter getWriter()
* 字节输出流：ServletOutputStream getOutputStream()
使用输出流，将数据输出到客户端浏览器

⑵ 案例： ① 完成重定向

1. 重定向：资源跳转的方式

2. 代码实现：

//1. 设置状态码为302
response.setStatus(302);
//2.设置响应头location
response.setHeader("location","/day15/responseDemo2");
//简单的重定向方法(这种方式最常用)
response.sendRedirect("/day15/responseDemo2");

例如：
AServlet代码：

@WebServlet("/aServlet")
public class AServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("AServlet...");
        //响应重定向的方式一
        
        //响应重定向方式二(最常用的方式)
         //动态获取虚拟目录
        String contextPath = request.getContextPath();
        //响应重定向方式二(最常用的方式)
        response.sendRedirect(contextPath+"/bServlet");
        //response.sendRedirect("/servlet/bServlet");
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

BServlet代码

@WebServlet("/bServlet")
public class BServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("BServlet...");
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

结果如下：

forward 和 redirect 区别:

重定向的特点:redirect
1. 地址栏发生变化
2. 重定向可以访问其他站点(服务器)的资源
3. 重定向是两次请求。不能使用request对象来共享数据
转发的特点：forward
1. 转发地址栏路径不变
2. 转发只能访问当前服务器下的资源
3. 转发是一次请求，可以使用request对象来共享数据

路径写法：

相对路径：通过相对路径不可以确定唯一资源
* 如：./index.html
* 不以/开头，以.开头路径
* 规则：找到当前资源和目标资源之间的相对位置关系
* ./：当前目录
* ../:后退一级目录
绝对路径：通过绝对路径可以确定唯一资源
* 如：http://localhost/day15/responseDemo2(完整写法) /day15/responseDemo2（简写）
* 以/开头的路径
* 规则：判断定义的路径是给谁用的？判断请求将来从哪儿发出
* 给客户端浏览器使用：需要加虚拟目录(项目的访问路径)
* 建议虚拟目录动态获取：request.getContextPath()
例如： //动态获取虚拟目录
String contextPath = request.getContextPath();
//响应重定向方式二(最常用的方式)
response.sendRedirect(contextPath+"/bServlet");
* 如：,
, 重定向等路径需要使用绝对路径
* 给服务器使用：不需要加虚拟目录
* 转发路径:
如:request.getRequestDispatcher("/bServlet").forward(request,response);

② 服务器输出字符数据到浏览器

1. 步骤：
1. 获取字符输出流
2. 输出数据

注意：乱码问题：
1. PrintWriter pw = response.getWriter();获取的流的默认编码是ISO-8859-1
2. 设置该流的默认编码
3. 告诉浏览器响应体使用的编码
//简单的形式，设置编码，是在获取流之前设置
response.setContentType("text/html;charset=utf-8");

代码如下：

@WebServlet("/servletDemo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        //简单的形式，设置编码（最常用的方式）
        response.setContentType("text/html;charset=utf-8");
        //1.获取字符输出流
        PrintWriter pw = response.getWriter();
        //2.输出数据
        pw.write("你好 response");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

结果如下：

③ 服务器输出字节数据到浏览器

步骤：

获取字节输出流
输出数据

代码如下：

@WebServlet("/servletDemo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //简单的形式，设置编码（最常用的方式）
        response.setContentType("text/html;charset=utf-8");
        //1.获取字节输出流
        ServletOutputStream os = response.getOutputStream();
        //2.输出数据
        os.write("你好".getBytes("utf-8"));
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

结果如下：

④ 验证码

本质：图片
目的：防止恶意表单注册

验证码页面：regist.html




    
    Title
    



看不清换一张？

ServletDemo.java

@WebServlet("/servletDemo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //服务器通知浏览器不要缓存
        response.setHeader("pragma","no-cache");
        response.setHeader("cache-control","no-cache");
        response.setHeader("expires","0");

        //在内存中创建一个长80，宽30的图片，默认黑色背景
        //参数一：长
        //参数二：宽
        //参数三：颜色
        int width = 80;
        int height = 30;
        BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);

        //获取画笔
        Graphics g = image.getGraphics();
        //设置画笔颜色为灰色
        g.setColor(Color.GRAY);
        //填充图片
        g.fillRect(0,0, width,height);

        //产生4个随机验证码，12Ey
        String checkCode = getCheckCode();
        //将验证码放入HttpSession中
        request.getSession().setAttribute("CHECKCODE_SERVER",checkCode);

        //设置画笔颜色为黄色
        g.setColor(Color.YELLOW);
        //设置字体的小大
        g.setFont(new Font("黑体",Font.BOLD,24));
        //向图片上写入验证码
        g.drawString(checkCode,15,25);

        //设置画笔颜色为pink
        g.setColor(Color.white);
        //画十条干扰线
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            //随机生成线的的横坐标（坐标点不能超过图片的长和高）
            int x1 = random.nextInt(width);
            int x2 = random.nextInt(width);
            int y1 = random.nextInt(height);
            int y2 = random.nextInt(height);
            //开始画干扰线
            g.drawLine(x1,y1,x2,y2);
        }

        //将内存中的图片输出到浏览器
        //参数一：图片对象
        //参数二：图片的格式，如PNG,JPG,GIF
        //参数三：图片输出到哪里去
        ImageIO.write(image,"PNG",response.getOutputStream());
    }
    
    private String getCheckCode() {
        String base = "0123456789ABCDEFGabcdefg";
        int size = base.length();
        Random r = new Random();
        StringBuffer sb = new StringBuffer();
        for(int i=1;i<=4;i++){
            //产生0到size-1的随机值
            int index = r.nextInt(size);
            //在base字符串中获取下标为index的字符
            char c = base.charAt(index);
            //将c放入到StringBuffer中去
            sb.append(c);
        }
        return sb.toString();
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

效果如下：

四、ServletContext对象： 1. 概念：

代表整个web应用，可以和程序的容器(服务器)来通信

2. 获取：

通过request对象获取
request.getServletContext();
通过HttpServlet获取
this.getServletContext();

例如：

@WebServlet("/servletDemo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         
        //1. 通过request对象获取
        ServletContext context1 = request.getServletContext();
        //2. 通过HttpServlet获取
        ServletContext context2 = this.getServletContext();
        System.out.println(context1);
        System.out.println(context2);
        System.out.println(context1 == context2);//true
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

3. 功能：

获取MIME类型：
* MIME类型:在互联网通信过程中定义的一种文件数据类型
* 格式：大类型/小类型如： text/html和 image/jpeg
* 获取：String getMimeType(String file)
例如：

@WebServlet("/servletDemo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        

        // 通过HttpServlet获取
        ServletContext context = this.getServletContext();
        // 定义文件名称
        String filename = "a.jpg";
        //4.获取MIME类型
        String mimeType = context.getMimeType(filename);
        System.out.println(mimeType);//image/jpeg
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

2. 域对象：共享数据

setAttribute(String name,Object value)
getAttribute(String name)
removeAttribute(String name)

ServletContext对象范围：所有用户所有请求的数据

3.获取文件的真实(服务器)路径
方法：
String getRealPath(String path)

例如：
项目结构：

代码如下：

@WebServlet("/servletContextDemo")
public class ServletContextDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        

        // 通过HttpServlet获取
        ServletContext context = this.getServletContext();
        // 获取文件的服务器路径
        String b = context.getRealPath("/b.txt");//web目录下资源访问
        System.out.println(b);
        // File file = new File(realPath);
        String c = context.getRealPath("/WEB-INF/c.txt");//WEB-INF目录下的资源访问
        System.out.println(c);
        String a = context.getRealPath("/WEB-INF/classes/a.txt");//src目录下的资源访问
        System.out.println(a);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

结果如下：

注意：
1.类名.class.getClassLoader().getResourceAsStream(文件路径)；
该方式只能获取src下的资源，不能请求web下的资源
2.获取文件的真实(服务器)路径对应着服务器启动后配置文件中的路径：
E:projectservlet-contextoutartifactsservlet_context_war_exploded

4. 案例：文件下载

1.文件下载需求：

页面显示超链接
点击超链接后弹出下载提示框
完成图片文件下载

分析：
1. 超链接指向的资源如果能够被浏览器解析，则在浏览器中展示，如果不能解析，则弹出下载提示框。不满足需求
2. 任何资源都必须弹出下载提示框
3. 使用响应头设置资源的打开方式：
content-disposition:attachment;filename=xxx

2.步骤：

定义页面，编辑超链接href属性，指向Servlet，传递资源名称filename
定义Servlet
1. 获取文件名称
2. 使用字节输入流加载文件进内存
3. 指定response的响应头： content-disposition:attachment;filename=xxx
4. 将数据写出到response输出流

3.问题：
中文文件问题（用工具类解决）

解决思路：

获取客户端使用的浏览器版本信息
根据不同的版本信息，设置filename的编码方式不同

代码如下：
项目结构如下：

页面download.html代码：




    
    Title



图片

视频

图片
视频

解决中文名称文件乱码的工具类DownLoadUtils：

public class DownLoadUtils {

    public static String getFileName(String agent, String filename) throws UnsupportedEncodingException {
        if (agent.contains("MSIE")) {
            // IE浏览器
            filename = URLEncoder.encode(filename, "utf-8");
            filename = filename.replace("+", " ");
        } else if (agent.contains("Firefox")) {
            // firefox浏览器
            // firefox浏览器User-Agent字符串:
            // Mozilla/5.0 (Windows NT 6.1; WOW64; rv:36.0) Gecko/20100101
            // Firefox/36.0
            // 先去掉文件名称中的空格,然后转换编码格式为utf-8,保证不出现乱码,
            // 这个文件名称用于浏览器的下载框中自动显示的文件名
            filename = new String(filename.replaceAll(" ", "").getBytes("UTF-8"), "ISO8859-1");
        } else {
            // 其它浏览器
            filename = URLEncoder.encode(filename, "utf-8");
        }
        return filename;
    }
}

ServletContextDemo核心代码

@WebServlet("/downloadServlet")
public class ServletContextDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.获取请求参数，文件名称
        String filename = request.getParameter("filename");
        //2.使用字节输入流加载文件进内存
        //2.1找到文件服务器路径
        ServletContext servletContext = this.getServletContext();
        String realPath = servletContext.getRealPath("/img/" + filename);
        //2.2用字节流关联
        FileInputStream fis = new FileInputStream(realPath);

        //3.设置response的响应头
        //3.1设置响应头类型：content-type
        String mimeType = servletContext.getMimeType(filename);//获取文件的mime类型
        response.setHeader("content-type",mimeType);
        //3.2设置响应头打开方式:content-disposition
        //解决中文文件名问题
        //3.2.1获取user-agent请求头、
        String agent = request.getHeader("user-agent");
        //3.2.2使用工具类方法编码文件名即可
        filename = DownLoadUtils.getFileName(agent, filename);
        response.setHeader("content-disposition","attachment;filename="+filename);
        //4.将输入流的数据写出到输出流中
        ServletOutputStream sos = response.getOutputStream();
        byte[] buff = new byte[1024 * 8];
        int len = 0;
        while((len = fis.read(buff)) != -1){
            sos.write(buff,0,len);
        }
        fis.close();
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

效果如下：

五、JavaWeb基础(servlet、http协议、request和response请求详解、ServletContext对象)

Java相关栏目本月热门文章