servlet -6

servlet

maven介绍
http请求
	Request
	Response
ServletContext
会话技术
	session
	cookie
过滤器&监听器
JSP
ajax+json
	fastjson
	gson
数据库连接池
	druid(重点)
	dbcp
	c3p0
redis
前后分离
	跨域
	JWT

maven介绍

maven是目前比较流行的java项目管理工具
maven主要使用项目对象模型(POM project object model)，可以通过一小段的描述信息去管理整个项目的生命周期(构建，报告，文档等)
	maven 主要可以用来管理依赖，编译，测试，打包等功能
	maven官网: maven.apache.org

安装maven

解压到指定的目录，一般不建议路径上有中文和空格
解压完成后需要去配置一下环境变量
新建一个环境变量 MAVEN_HOME 值就是maven的根目录
然后在Path上添加 %MAVEN_HOME%\bin
然后在cmd下输入命令 mvn -version 能够查看版本信息就表示当前maven安装成功

配置maven

在conf/setting.xml文件中

配置本地仓库

<localRepository>E:/repository</localRepository>

配置远程仓库

 <mirrors>
    <!-- mirror
     | Specifies a repository mirror site to use instead of a given repository. The repository that
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
     |
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
     -->
	 <mirror>
      <id>alimaven</id>
      <name>aliyun maven</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <mirrorOf>central</mirrorOf>
    </mirror>
  </mirrors>

将maven整合到idea中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KWQsmf2N-1681800564813)(servlet.assets/image-20220401103512861.png)]

按上图进行配置即可

使用idea来创建maven的项目

idea创建maven的java项目

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ouyl7yty-1681800564813)(servlet.assets/image-20220401103753211.png)]

点击下一步出现

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fxyKIyUx-1681800564814)(servlet.assets/image-20220401103912123.png)]

GroupId叫做组号， 一般是包名 可以为域名倒写

ArtifactId 一般是项目名

Version 版本

上面这三个内容组成了项目的坐标

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4TphcRgL-1681800564814)(servlet.assets/image-20220401104156936.png)]

选择完环境以后

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dtZQUKol-1681800564815)(servlet.assets/image-20220401104221371.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QKrEFTdH-1681800564815)(servlet.assets/image-20220401105144294.png)]

上图描述了一个标准的maven项目结构

idea创建maven的web项目

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sWvNuf2H-1681800564815)(servlet.assets/image-20220401105705467.png)]

当创建好项目后，自动生成的web.xml版本很老，可以改成自己的版本

因为当前使用的tomcat是8.5的版本，里面servlet的版本是3.1，按照下面去改一下版本即可

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1"
         metadata-complete="true">  //这个改为false 才支持servlet的注解
  <display-name>Archetype Created Web Application</display-name>
</web-app>

idea 整合tomcat

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IPxr4n1w-1681800564816)(servlet.assets/image-20220401143024122.png)]

点击右上角的Add configuration

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-13HeGkR2-1681800564816)(servlet.assets/image-20220401143101719.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QWGI2GoT-1681800564816)(servlet.assets/image-20220401143151432.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8hxBnmfi-1681800564817)(servlet.assets/image-20220401143210778.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p7QAdhz6-1681800564817)(servlet.assets/image-20220401143321517.png)]

点击ok即可

或者在pom.xml文件中去配置tomcat插件

<build>
    <finalName>webtest2</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
		<!-- 访问路径 -->
          <path>/</path>
            <!--访问端口-->
          <port>8080</port>
          <server>tomcat7</server>
        </configuration>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>run</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

创建Servlet

maven搜索依赖的地址

https://mvnrepository.com/

需要在pom.xml文件中引入servlet的依赖

<dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <!--
        compile：默认的scope，运行期有效，需要打入包中
        provided：编译期有效，运行期不需要提供，不会打入包中
        runtime：编译不需要，在运行期有效，需要导入包中。（接口与实现分离）
        test：测试需要，不会打入包中
        system：非本地仓库引入、存在系统的某个路径下的jar。（一般不使用）
      -->
      <scope>provided</scope>
    </dependency>

在main/java/包 中创建了一个Servlet的类

package com.controller;

import java.io.IOException;

public class UserController extends javax.servlet.http.HttpServlet {

    /**
     * 如果请求是post请求会执行doPost
     * @param request
     * @param response
     * @throws javax.servlet.ServletException
     * @throws IOException
     */
    protected void doPost(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, IOException {
        response.getWriter().println("doPost");
    }

    /**
     * 如果请求是get请求会执行doPost
     * @param request
     * @param response
     * @throws javax.servlet.ServletException
     * @throws IOException
     */
    protected void doGet(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, IOException {
        response.getWriter().println("doGet");
    }
}

在web.xml文件中进行配置

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1"
         metadata-complete="true">
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
    <servlet-name>UserController</servlet-name>
    <servlet-class>com.controller.UserController</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>UserController</servlet-name>
    <url-pattern>/user</url-pattern>
  </servlet-mapping>
</web-app>

如果不使用xml配置而是使用注解配置

Servlet的类如下

类上面添加注解：@WebServlet

package com.controller;

import javax.servlet.annotation.WebServlet;
import java.io.IOException;

@WebServlet("/user")
public class UserController extends javax.servlet.http.HttpServlet {

    /**
     * 如果请求是post请求会执行doPost
     * @param request
     * @param response
     * @throws javax.servlet.ServletException
     * @throws IOException
     */
    protected void doPost(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, IOException {
        response.getWriter().println("doPost");
    }

    /**
     * 如果请求是get请求会执行doPost
     * @param request
     * @param response
     * @throws javax.servlet.ServletException
     * @throws IOException
     */
    protected void doGet(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, IOException {
        response.getWriter().println("doGet");
    }
}

servlet配置

xml配置

访问路径配置

<!--可以配置多个访问路径
  配置多个servlet-mapping即可
  -->
  <servlet-mapping>
    <servlet-name>UserController</servlet-name>
    <!--访问路径的配置
      /路径  /xxx/xxx  可以配置单重或者多重路径  /user  /user/login
      通配符 /开头  /*结尾   /user/*  /*  如果一个路径 能够匹配多个servlet的访问路径时 越相似越优先匹配
      后缀方式 *.html 伪静态 *.do  *.action  匹配优先级最低
      / 匹配所有路径
    -->
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
  <!--<servlet-mapping>
    <servlet-name>UserController</servlet-name>
    <url-pattern>/aaa</url-pattern>
  </servlet-mapping>-->

生命周期

servlet的对象默认情况下是第一次请求访问这个servlet的时候才会去创建对象

配置servlet的对象在服务器启动的时候就创建
<servlet>
    <servlet-name>UserController</servlet-name>
    <servlet-class>com.controller.UserController</servlet-class>
    <!--配置servlet在服务器启动的时候创建对象
    里面的数字代表的是servlet的启动顺序 数字越小越优先创建对象  不能为负数
    -->
    <load-on-startup>1</load-on-startup>
  </servlet>

初始化参数

<servlet>
    <servlet-name>UserController</servlet-name>
    <servlet-class>com.controller.UserController</servlet-class>
    <!--初始化参数
      在servlet中可以读取这些初始化参数
    -->
    <init-param>
      <param-name>aaa</param-name>
      <param-value>bbb</param-value>
    </init-param>
    <init-param>
      <param-name>ccc</param-name>
      <param-value>ddd</param-value>
    </init-param>
    <init-param>
      <param-name>charset</param-name>
      <param-value>utf-8</param-value>
    </init-param>

    <!--配置servlet在服务器启动的时候创建对象
    里面的数字代表的是servlet的启动顺序 数字越小越优先创建对象  不能为负数
    -->
    <load-on-startup>1</load-on-startup>
  </servlet>

获取初始化参数值

protected void doGet(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, IOException {
        System.out.println("UserController");
        ServletConfig servletConfig = getServletConfig();//获取servlet的配置对象
        //初始化参数就可以通过这个对象来获取
        String aaa = servletConfig.getInitParameter("aaa");
        System.out.println(aaa);
        //获取所有的初始化参数
        Enumeration<String> initParameterNames = servletConfig.getInitParameterNames();
        while(initParameterNames.hasMoreElements()){
            //初始化参数名
            String name = initParameterNames.nextElement();
            //初始化参数值
            System.out.println(servletConfig.getInitParameter(name));

        }
    }

注解配置

@WebServlet(value = {"/user/*","/aaa"},loadOnStartup = 1,initParams = {
        @WebInitParam(name = "aa",value="bbb1"),
        @WebInitParam(name = "bb",value="bbb2"),
        @WebInitParam(name = "cc",value="bbb3"),
        @WebInitParam(name = "dd",value="bbb4"),
})

请求HttpServletRequest

http 协议
	超文本传输协议(HyperText Transfer protocal)   传输数据的协议
	http 协议是一个简单的请求-响应协议，通常运行在tcp协议之上，指定了客户端给服务器发送什么消息和得到什么消息
	特点：
		1.基于tcp协议
		2.缺省端口80，https基于http协议的基础上再次加密，缺省端口是443
		3.基于请求-响应模型：一次请求一定对应一次响应；请求和响应都存在的时候才可以叫做一次完整的http请求
		4.无状态：请求之间是相互独立的，不能互相交互数据
	版本：
		1.0 每次请求和响应都会去创建单独的连接
		1.1 复用连接
	请求消息的格式
	1.请求行
	请求方式 请求url 请求协议/版本
		请求方式:
			GET:
				1.参数会直接显示在请求行中，会在url后面暴露出来
				2.相对不安全，效率更高一些
				3.因为url的长度是有限的，类型为字符串
					Chrome的url长度是8182个字符，超过后就返回错误
					IE的长度限制2083,超过以后就自动截断(如果使用form那么提交按钮就不会起效果)
					Apache 服务器 接收长度限制为8192
					tomcat 通过配置Connector的maxParamterCount属性去配置长度，默认值是10000
						maxPostSize post请求的最大值
					nginx 服务器 可以通过修改配置来改变url请求的长度限制
					client_header_buffer_size 默认值为1K
					large_client_header_buffers 默认值是8k
			POST:
				1.参数在请求体中
				2.请求url长度和get一样，因为参数不在url中，所以参数大小无限制，参数类型无限制(文件上传的时候选择post请求)
				3.相对安全，效率相对低一些
	2.请求头
	浏览器告诉服务器的一些信息
	请求头名称:请求头的值
	能够接收的数据类型
	Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
	接收的编码
    Accept-Encoding: gzip, deflate, br
    接收的语言
    Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
    缓存控制
    Cache-Control: max-age=0
    
    连接
    Connection: keep-alive
    主机
    Host: localhost:9999
    上一次修改时间
    If-Modified-Since: Sat, 2 Apr 2022 02:59:03 GMT
    告诉服务器是什么浏览器
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.84 Safari/537.36
    请求从哪个页面来的  防盗链
    Referer:http://localhost:9999/webtest2/src/main/webapp/html.html?_ijt=3i9lt5rekp2v2873kk36q35b21
    3.请求体
    封装post请求的参数

服务器获取请求中的数据

 /**
     * 如果请求是get请求会执行doPost
     * @param request
     * @param response
     * @throws javax.servlet.ServletException
     * @throws IOException
     */
    protected void doGet(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, IOException {
        String method = request.getMethod();//获取请求方式
        System.out.println(method);
        //uri 和url的区别是什么
        /*
        URI=/aaa
        URL=http://localhost:8080/aaa
         */
        String requestURI = request.getRequestURI();
        System.out.println("URI=" + requestURI);
        StringBuffer requestURL = request.getRequestURL();
        System.out.println("URL=" + requestURL);
        //获取参数
        String aa = request.getParameter("aa");
        //一个参数名多个参数值
        //http://localhost:8080/aaa?aa=b&a=b&a=c&a=d
        String[] as = request.getParameterValues("a");
        //获取所有的参数名
        Enumeration<String> parameterNames = request.getParameterNames();
        //将所有的参数封装到一个Map中
        Map<String, String[]> parameterMap = request.getParameterMap();
        //获取请求协议  HTTP/1.1
        String protocol = request.getProtocol();
        System.out.println(protocol);
        //获取协议  http
        String scheme = request.getScheme();
        System.out.println(scheme);
        //获取请求头
        String accept = request.getHeader("Accept");
        System.out.println(accept);
        //获取所有请求头的名称
        Enumeration<String> headerNames = request.getHeaderNames();
        //一个头多个值
        Enumeration<String> accept1 = request.getHeaders("Accept");
        //获取客户端的一些信息
        String remoteAddr = request.getRemoteAddr();//客户端的地址
        String remoteHost = request.getRemoteHost();//客户端的主机名
        int remotePort = request.getRemotePort();//客户端发送请求的端口 随机的
        String localAddr = request.getLocalAddr();//服务器的地址
        int localPort = request.getLocalPort();//服务器占用的端口 8080
        // http://localhost:8080/aaa
        String contextPath = request.getContextPath();//上下文路径 一般是项目访问路径
        System.out.println(contextPath);
        String queryString = request.getQueryString();//请求路径上?后面的部分
        System.out.println(queryString);
    }

请求转发forward

在服务器的后台想要实现页面的跳转：请求转发和重定向

请求转发是服务器内部页面跳转的一种方式

当客户端的请求到达服务器以后，根据url的路径部分在服务器的内部去寻找对应的资源，这个资源可以将请求转发给另一个资源下面去，这个转发是在服务器的内部完成的。所以这个跳转对于浏览器而言是不知道的，浏览器不知道服务器的内部发生过跳转的操作。所以浏览器的地址栏是不会发生改变 的。因为转发发生在服务器的内部，所以路径上不建议写项目名。转发到达目标资源后，由目标资源进行处理，最后响应给浏览器。整个过程只有一次请求和响应，所以转发是一次完整的http请求。

特点：

1.路径不会发生改变

2.只能转发给服务器的内部资源

3.转发只有一次请求

//获取请求转发器，参数就是需要转发到的目的地
        RequestDispatcher requestDispatcher = request.getRequestDispatcher("/my");
        //执行转发
        requestDispatcher.forward(request,response);

转发时的数据共享

主要是通过域对象(作用域) 来共享数据

request（作用域）: 在一次http请求中可以共享数据

//需要将数据放入作用域中
        request.setAttribute("list",list);
//java代码
    List<User> list = (List<User>) request.getAttribute("list");
//移除指定的数据
request.removeAttribute("list");
        //获取作用域中所有key的名称 可以通过遍历获取作用域中的所有数据
Enumeration<String> attributeNames = request.getAttributeNames();

注意：request作用域只能作用在同一个请求中，不同的请求中是不能共享数据的

请求乱码处理

客户端发送中文到服务器后，服务器接收到中文可能出现乱码的情况

//get请求乱码
filename = new String(filename.getBytes("ISO-8859-1"),"UTF-8");
// post请求 乱码 这句话必须放在获取参数之前
request.setCharacterEncoding("UTF-8");

响应HttpServletResponse

响应消息，服务器发送给客户端的消息

1. 响应行
    协议/版本 响应状态码 状态码描述
    HTTP/1.1 200 ok
    响应状态码
    	服务器发送给客户端用来描述这次请求的一个数字
    	状态码一般是3位数
    	1. 1xx 服务器接收到客户端的消息，但是还没有接收完成，等待一段时间后，发送多个1xx的代码
    	2. 2xx 表示成功 常见200
    	3. 3xx 表示请求的资源已经转移到新的地方，需要客户端去访问新的地址 常见302(资源被临时转移)  301(资源被永久转移) 304(资源被缓存)
    	4. 4xx 表示客户端的请求错误 常见404(资源未找到) 403(请求参数错误) 405(请求方式错误)
    	5. 5xx 服务器错误 常见500(服务器内部错误)
2. 响应头
	响应头名称:响应头的值
	常见的响应头:
	Content-Length: 836 内容长度
    Content-Type: text/html; utf-8=;charset=UTF-8 内容类型
    Date: Wed, 06 Apr 2022 02:30:35 GMT  响应时间
    Server: Apache-Coyote/1.1 服务器
    Set-Cookie: JSESSIONID=04FDEF35B648BDC71D4E4544BDB96439; Path=/webtest2/; HttpOnly 响应的cookie
    
    Location: 重定向以后的地址
    Content-Disposition: 告诉浏览器响应的内容以什么方式打开
    	in-line: 默认值，直接在当前页打开
    	attachment;filename=xxxx  告诉浏览器响应的内容包含了附件 附件名为xxxx 需要以文件下载的方式打开
    cache-control: 缓存控制 no-cache 不需要缓存
    Refresh: 刷新界面 Refresh:5;url=xxxx 5s后跳转到url指定的路径上去
    从上面可以观察到，响应头可以控制浏览器的一部分行为
    
3. 响应体
	服务器响应给客户端的数据

response对象

这个对象主要是针对服务器对客户端的响应进行封装的

 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("myServlet");
        //服务器响应的数据乱码，加这一句就可以解决
        response.setContentType("text/html;charset=utf-8");//设置响应的数据类型
        //重定向
        /*response.sendRedirect("https://www.baidu.com");//服务器外部
        response.setStatus(302);
        response.setHeader("Location","https://www.baidu.com");
        //服务器内部  前面从项目名开始去进行访问
        response.sendRedirect("/webtest2/user/aaa?a=b");*/

        //缓存控制
        response.setHeader("Cache-Control","no-cache");
        response.setHeader("Pragma","no-cache");
        //IE 缓存1小时 如果不缓存就直接写0
        response.setDateHeader("Expires",System.currentTimeMillis() + 1000 * 60 * 60);

        //获取两个输出流 两个流不能同时使用
        PrintWriter writer = response.getWriter();//字符流
        ServletOutputStream outputStream = response.getOutputStream();//字节流

        boolean b = response.containsHeader("");//判断是否包含某个头
//        response.encodeRedirectUrl("")//URL重写
        Collection<String> headerNames = response.getHeaderNames();//获取所有响应头名称
    }

重定向

客户端发送请求到达服务器后，服务器检查对应的资源被转移了，给客户端响应302和Location回去，客户端检查状态码为302，再去获取Location的值，然后浏览器就会发送请求到新的地址去。浏览器知道页面跳转，地址栏会发生改变，请求至少两次。

特点：

1. 至少两次请求
2. 地址栏会发生改变
3. 可以请求到服务器外部的资源

response.sendRedirect("https://www.baidu.com");//服务器外部
        response.setStatus(302);
        response.setHeader("Location","https://www.baidu.com");
        //服务器内部  前面从项目名开始去进行访问
        response.sendRedirect("/webtest2/user/aaa?a=b");

面试题：重定向和转发的区别
重定向: 至少两次请求，浏览器地址栏发生改变，可以请求外部资源
转发: 只有一次请求，浏览器地址栏不改变，不能请求外部资源

文件下载

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //先告诉浏览器响应了附件
        //文件名包含中文后，下载的时候文件名会出问题
//        String filename = "java常用词汇.doc";
        String filename = request.getParameter("filename");
        String filename2 = URLEncoder.encode(filename, "UTF-8");
        System.out.println(filename2);
        response.setHeader("Content-Disposition","attachment;filename=" + filename2);
        //通过流将文件数据响应给客户端
        //webapp下面的文件都是这样来找  返回对应文件的绝对路径
        String realPath = request.getServletContext().getRealPath("/files/" + filename);
        InputStream is = new FileInputStream(realPath);
        ServletOutputStream os = response.getOutputStream();
        int len = 0;
        byte [] bytes = new byte[2048];
        while ((len = is.read(bytes)) != -1){
            os.write(bytes,0,len);
        }
        os.close();
        is.close();
    }

图形验证码

 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //确定响应给客户端的内容类型
        response.setContentType("image/jpeg");
        //创建一个图片 默认是全黑的
        BufferedImage image = new BufferedImage(80,20,BufferedImage.TYPE_INT_RGB);
        //得到画笔
        Graphics2D graphics = image.createGraphics();
        //先绘制一个背景颜色
        int br = (int)(Math.random() * 128);
        int bg = (int)(Math.random() * 128);
        int bb = (int)(Math.random() * 128);
        //设置画笔的颜色
        graphics.setColor(new Color(br,bg,bb));
        //填充一个矩形
        graphics.fillRect(0,0,80,20);
        //得到一个随机的字符串
        String s = StringUtil.randomStr(4);
        System.out.println(s);
        //设置画笔颜色
        int fr = (int)(Math.random() * 128) + 128;
        int fg = (int)(Math.random() * 128) + 128;
        int fb = (int)(Math.random() * 128) + 128;
        graphics.setColor(new Color(fr,fg,fb));
        //设置字体
        graphics.setFont(new Font("微软雅黑",Font.PLAIN,16));
        //旋转内容
//        graphics.rotate(Math.sin(Math.PI * 0.1));
        for (int i = 0; i < s.length(); i++) {
            graphics.drawString(s.charAt(i) + "",2 + i * 20,18);
        }
        //绘制障碍物
        for (int i = 0; i < 5; i++) {
            //随机绘制线条
            int r = (int)(Math.random() * 128) + 128;
            int g = (int)(Math.random() * 128) + 128;
            int b = (int)(Math.random() * 128) + 128;
            graphics.setColor(new Color(r,g,b));
            //随机线条
            int x = (int) (Math.random() * 80);
            int y = (int) (Math.random() * 20);
            int x1 = (int) (Math.random() * 80);
            int y1 = (int) (Math.random() * 20);
            graphics.drawLine(x,y,x1,y1);
        }
        //绘制雪花
        for (int i = 0; i < 5; i++) {
            graphics.setColor(Color.white);
            int x = (int) (Math.random() * 80);
            int y = (int) (Math.random() * 20);
            graphics.drawString("*",x,y);
        }
        graphics.dispose();//销毁画笔
        //响应图片给客户端
        ImageIO.write(image,"jpg",response.getOutputStream());
    }

ServletContext对象

ServletContext 是整个应用的上下文，一个web程序只有一个ServletContext对象，在服务器启动的时候这个对象就会创建，服务器关闭的时候这个对象会销毁
    获取对象
        ServletContext servletContext = request.getServletContext();
        //在HttpServlet中可以直接获取
        ServletContext servletContext1 = this.getServletContext();
        //通过session获取
        ServletContext servletContext2 = request.getSession().getServletContext();
	功能
        1. 获取webapp目录下的文件的绝对路径
        String realPath = servletContext.getRealPath("/files/" + filename);
		2. 作用域  作用范围是整个项目 只要在这个项目中就都可以获取得到
            //需要将数据放入作用域中
        servletContext.setAttribute("list",list);
        //java代码
            List<User> list = (List<User>) servletContext.getAttribute("list");
        //移除指定的数据
        servletContext.removeAttribute("list");
        //获取作用域中所有key的名称 可以通过遍历获取作用域中的所有数据
        Enumeration<String> attributeNames = servletContext.getAttributeNames();
        3. 获取文件的MIME类型
            String mimeType = servletContext.getMimeType(realPath);
		4. 获取全局的初始化参数
            在web.xml文件中去配置全局初始化参数
            <!--全局的初始化参数-->
              <context-param>
                <param-name>aaa</param-name>
                <param-value>bbb</param-value>
              </context-param>
            可以通过ServletContext来获取
            //获取全局初始化参数
            String aaa = servletContext.getInitParameter("aaa");
            //获取所有的名称
            Enumeration<String> initParameterNames = servletContext.getInitParameterNames();
            //遍历名称在通过上述方法即可获取所有的初始化参数

指定的数据
servletContext.removeAttribute(“list”);
//获取作用域中所有key的名称 可以通过遍历获取作用域中的所有数据
Enumeration attributeNames = servletContext.getAttributeNames();
3. 获取文件的MIME类型
String mimeType = servletContext.getMimeType(realPath);
4. 获取全局的初始化参数
在web.xml文件中去配置全局初始化参数


aaa
bbb

可以通过ServletContext来获取
//获取全局初始化参数
String aaa = servletContext.getInitParameter(“aaa”);
//获取所有的名称
Enumeration initParameterNames = servletContext.getInitParameterNames();
//遍历名称在通过上述方法即可获取所有的初始化参数