ToB企服应用市场:ToB评测及商务社交产业平台

标题: Servlet [打印本页]
作者: 民工心事    时间: 2025-1-4 18:37
标题: Servlet
Servlet 本身不能独立运行，需要在一个web应用中运行的
而一个web应用是摆设在服务器中的,比如服务器tomcat。
1.获取参数

创建一个LoginServlet
因为浏览器中的form的method是post,所以LoginServlet需要提供一个doPost方法
在doPost方法中，通过request.getParameter 根据name取出对应的账号和密码
然后用System.out.println() 打印在控制台
本测试例子只是控制台输出，后面例子网页显示。
后台代码：LoginServlet  继承  HttpServlet

  1. import java.io.IOException;
  3. import javax.servlet.ServletException;
  4. import javax.servlet.http.HttpServlet;
  5. import javax.servlet.http.HttpServletRequest;
  6. import javax.servlet.http.HttpServletResponse;
  8. public class LoginServlet extends HttpServlet {
  9.     protected void doPost(HttpServletRequest request, HttpServletResponse response)
  10.             throws ServletException, IOException {
  11.         String name = request.getParameter("name");
  12.         String password = request.getParameter("password");
  14.         System.out.println("name:" + name);
  15.         System.out.println("password:" + password);
  16.     }
  17. }
复制代码
后台配置文件： web.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app>
  3.        
  4.         <servlet>  # 定义了一个名为 LoginServlet 的 Servle
  5.                 <servlet-name>LoginServlet</servlet-name>
  6.                 <servlet-class>LoginServlet</servlet-class>
  7.         </servlet>
  9.         <servlet-mapping>
  10. #  Servlet 与 URL /login 进行绑定。用户访问 http://xx/login 时，LoginServlet 会处理该请求
  11.                 <servlet-name>LoginServlet</servlet-name>
  12.                 <url-pattern>/login</url-pattern>
  13.         </servlet-mapping>       
  15. </web-app>
复制代码
前台文件login.html
  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>登录页面</title>
  6. </head>
  7. <body>
  9. <form action="login" method="post">
  10. 账号: <input type="text" name="name"> <br>
  11. 密码: <input type="password" name="password"> <br>
  12. <input type="submit" value="登录">
  13. </form>
  15. </body>
  16. </html>
复制代码
启动项目后，访问页面http://127.0.0.1/login.html 控制台会输出 账户、密码.
留意：前台action=login ,后台web配置中 <url-pattern>/login</url-pattern>  ，再到对应的LoginServlet
2.返回相应

本次将数据返回给前台页面展示
要求：
判断账号、密码是否为 admin 、123，如果是就打印successful 否则就打印 fail
根据账号密码，创建对应的html字符串。
然后通过response.getWriter().println() 发送到浏览器。
留意：显示successful 不是中文，下个例子防止浏览器因中文显示乱码。
  1. import java.io.IOException;
  2. import java.io.PrintWriter;
  3. import javax.servlet.ServletException;
  4. import javax.servlet.http.HttpServlet;
  5. import javax.servlet.http.HttpServletRequest;
  6. import javax.servlet.http.HttpServletResponse;
  7. public class LoginServlet extends HttpServlet {
  9.     protected void doPost(HttpServletRequest request, HttpServletResponse response)
  10.             throws ServletException, IOException {
  12.         String name = request.getParameter("name");
  13.         String password = request.getParameter("password");
  15.         String html = null;
  17.         if ("admin".equals(name) && "123".equals(password))
  18.             html = "<div style='color:green'> Login Successful</div>";
  19.         else
  20.             html = "<div style='color:red'>Login Fail</div>";
  22.         PrintWriter pw = response.getWriter();
  23.         pw.println(html);
  24. // 或者显示==========
  25.     out.println("<html><body>");
  26.         out.println("<h1>Login Successful</h1>");
  27.         out.println("</body></html>");
  28. // ===========================
  29.     }
  31. }
复制代码
3.中文问题

   为了成功获取中文参数，需要做如下操作
1. login.html中加上
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
这句话的目的是告诉浏览器，等下发消息给服务器的时候，使用UTF-8编码

2. login.html
form的method修改为post

3. 在servlet进行解码和编码
  byte[] bytes= name.getBytes("ISO-8859-1");
  name = new String(bytes,"UTF-8");
  
先根据ISO-8859-1解码，然后用UTF-8编码
如许就可以得到正确的中文参数了

如许需要对每一个提交的数据都进行编码息争码处理惩罚，如果觉得麻烦，也可以使用一句话代替：
  request.setCharacterEncoding("UTF-8");
并且把这句话放在request.getParameter()之前
 
  通俗讲：字符串  小明  ，浏览器将其按规则A编码，后台获取后 也要按照规则A解码。
  即编码、解码 规则一致就不会乱码【一样平常针对的是中文】。
  login.html
  2. <!DOCTYPE html>
  4. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  6. <form action="login" method="post">
  7.         账号 ： <input type="text" name="name"> <br> 密码: <input
  8.                 type="password" name="password"> <br> <input
  9.                 type="submit" value="登录">
  10. </form>
复制代码
LoginServlet.java
  1. public class LoginServlet extends HttpServlet {
  3.     protected void doPost(HttpServletRequest request, HttpServletResponse response)
  4.             throws ServletException, IOException {
  5. // 该方法中统一设置解码
  6.         request.setCharacterEncoding("UTF-8");
  7.         String name = request.getParameter("name");
  9.         // byte[] bytes = name.getBytes("ISO-8859-1");
  10.         // name = new String(bytes, "UTF-8");
  12. // 浏览器和网页编码的发展经历了几个阶段，ISO-8859-1、GBK 和 UTF-8 是其中非常关键的几个编码方式，它们代表了不同的历史阶段和全球化需求
  13.         String password = request.getParameter("password");
  15.         System.out.println("name:" + name);
  17. // 返回中文的响应 ,也要设置
  18.         response.setContentType("text/html; charset=UTF-8");
  20.         PrintWriter pw = response.getWriter();
  21.         pw.println("登陆成功！");
  22.     }
  24. }
复制代码
response.setContentType("text/html; charset=UTF-8"); 
作用是设置 HTTP 相应的内容类型和字符编码。【告诉客户端（如浏览器）相应内容的类型以及它的字符编码】

4.调用流程



还原一下颠末：
1.客户发送http://127.0.0.1/login.html，打开静态页面，里面填写账户、密码 ，以POST方式提交到 /login 路径。
2.tomcat吸收请求，http://127.0.0.1/login 与web配置文件匹配，找到对应的类LoginServlet。
3.tomcat发现没有LoginServlet存在，就调用无参构造方法实例化一个LoginServlet对象
4.tomcat拿到LoginServlet实例之后，根据方法类型 POST找到对应的doPost方法
5.通过request 获取参数，response 设置相应。
       protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
// 该方法中同一设置解码
        request.setCharacterEncoding("UTF-8");
  // 获取 姓名  密码
        String name = request.getParameter("name");
        String password = request.getParameter("password");
 
        System.out.println("name:" + name);
 
        PrintWriter pw = response.getWriter();
// 返回中文的相应 ,也要设置 
        response.setContentType("text/html; charset=UTF-8");
  String result ="登陆成功！";
        pw.println(result);
    }
  6. tomcat 将 相应内容传递给浏览器。
        在Servlet完成工作之后，tomcat拿到被Servlet修改过的response，根据这个response天生result字符串，然后再通过HTTP协议，把result字符串，复兴给浏览器，浏览器再根据HTTP协议获取这个result字符串，并渲染在界面上。
5.生命周期

一个 Servlet 的生命周期由 Web 容器管理，重要包括 加载\实例化、初始化、请求处理惩罚\提供服务 和 销毁 四个阶段。
1.实例化-加载         反射
        初次吸收到请求时，Web 容器会根据配置文件（如 web.xml）或注解（如 @WebServlet）加载 Servlet 类，此时Servlet会被实例化。【只实行一次！Servlet是单例的！】可以无参构造中打印一条语句检察验证。
2.初始化           init（）方法
        LoginServlet 继承了HttpServlet，HttpServlet继承了GenericServlet。所以LoginServlet也继承了init(ServletConfig) 方法。
init 方法是一个实例方法，所以会在构造方法实行后实行。无论访问了多少次LoginSerlvet
init初始化 只会实行一次
3.请求处理惩罚\提供服务         service()方法
        接下来就是实行service()方法，然后通过浏览器传递过来的信息进行判断，是调用doGet()还是doPost()方法来相应请求。
4.销毁        destroy()方法
        当容器关闭或卸载 Servlet 时，调用 destroy() 方法。该方法用于释放 Servlet 使用的资源，如关闭数据库连接、释放文件句柄等
1.Servlet所在的web应用重启
   <Context path="/" docBase="e:\\project\\j2ee\\web" debug="0" reloadable="false" />
  如果把 reloadable="false" 改为reloadable="true" 就表现有任何类发生的更新，web应用会主动重启
当web应用主动重启的时候，destroy()方法就会被调用。【重启前先卸载容器内的servlet】
  Web 应用主动重启通常发生在以下几种环境：
    2.关闭tomcat的时候 destroy()方法会被调用，但是这个一样平常都发生的很快，不易被发现
6.跳转

页面跳转是开辟一个web应用常常会发生的事变。比如登录成功或是失败后，分别会跳转到不同的页面。

跳转的方式有两种，服务端跳转和客户端跳转
   首先在web目录下准备两个页面 success.html,fail.html
分别用于显示登录成功 或者登录失败

如果登录成功了，服务端跳转到success.html

如果登录失败了，客户端跳转到fail.html
  
success.htmlfail.html
<div style="color:green">login success</div><div style="color:red">login fail</div>
request.getRequestDispatcher("success.html").forward(request, response);response.sendRedirect("fail.html");
服务端跳转可以看到浏览器的地址依然是/login 路径，并不会变成success.html  仍是xx/login
客户端跳转，浏览器地址发生了变化
原先地址xx/login变为了xx/fail.html
  1. public class LoginServlet extends HttpServlet {
  3.     private static final long serialVersionUID = 1L;
  5.     protected void service(HttpServletRequest request, HttpServletResponse response)
  6.             throws ServletException, IOException {
  8.         String name = request.getParameter("name");
  9.         String password = request.getParameter("password");
  11.         if ("admin".equals(name) && "123".equals(password)) {
  12. // 服务端跳转 也叫  转发 浏览器表面看不出来变化
  13.             request.getRequestDispatcher("success.html").forward(request, response);
  14.         } else{
  15. // 客户端跳转  也叫 重定向
  16.             response.sendRedirect("fail.html");
  17.         }
  20.     }
  22. }
复制代码

  7.自启动

有的时候会有如许的业务需求：
tomcat一启动，就需要实行一些初始化的代码，比如校验数据库的完备性等。
但是Servlet的生命周期是在用户访问浏览器对应的路径开始的。如果没有用户的第一次访问，就无法实行相关代码。怎么办？Servlet实现自启动
很简单：web.xml中添加     <load-on-startup>10</load-on-startup>
取值范围是1-99   数字越小，启动的优先级越高

即表明该Servlet会随着Tomcat的启动而初始化。

同时，为HelloServlet提供一个init(ServletConfig) 方法，验证自启动
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app>
  4.         <servlet>
  5.                 <servlet-name>LoginServlet</servlet-name>
  6.                 <servlet-class>LoginServlet</servlet-class>
  7.         <load-on-startup>10</load-on-startup>
  8.         </servlet>
  10.         <servlet-mapping>
  11.                 <servlet-name>LoginServlet</servlet-name>
  12.                 <url-pattern>/login</url-pattern>
  13.         </servlet-mapping>       
  15. </web-app>
复制代码
  1. public class HelloServlet extends HttpServlet{
  2.      
  3.     public void init(ServletConfig config){
  4.         System.out.println("init of Hello Servlet");
  5.     }
  7.     public void doGet(HttpServletRequest request, HttpServletResponse response){
  8.          
  9.         try {
  10.             response.getWriter().println("<h1>Hello Servlet!</h1>");
  11.             response.getWriter().println(new Date().toLocaleString());
  12.         } catch (IOException e) {
  13.             // TODO Auto-generated catch block
  14.             e.printStackTrace();
  15.         }
  16.     }
  17.      
  18. }
复制代码
8.request常见方法

   request.getRequestURL(): 浏览器发出请求时的完备URL，包括协议 主机名 端口(如果有)"
request.getRequestURI(): 浏览器发出请求的资源名部分，去掉了协媾和主机名"
request.getQueryString(): 请求行中的参数部分，只能显示以get方式发出的参数，post方式的看不到
request.getRemoteAddr(): 浏览器所处于的客户机的IP地址
request.getRemoteHost(): 浏览器所处于的客户机的主机名
request.getRemotePort(): 浏览器所处于的客户机使用的网络端口
request.getLocalAddr(): 服务器的IP地址
request.getLocalName(): 服务器的主机名
request.getMethod(): 得到客户机请求方式一样平常是GET或者POST
  1. <!DOCTYPE html>
  3. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  5. <form action="register" method="get">
  6.         账号 ： <input type="text" name="name"> <br>
  7.         爱好 ： LOL<input type="checkbox" name="hobits" value="lol">
  8.                 DOTA<input type="checkbox" name="hobits" value="dota"> <br>
  9.           
  10.                  <input type="submit" value="注册">
  11. </form>
复制代码

  获取参数
request.getParameter(): 是常见的方法，用于获取单值的参数
request.getParameterValues(): 用于获取具有多值的参数，比如注册时候提交的 "hobits"，可以是多选的。
request.getParameterMap(): 用于遍历所有的参数，并返回Map类型。
前台
  1. <!DOCTYPE html>
  3. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  5. <form action="register" method="get">
  6.         账号 ： <input type="text" name="name"> <br>
  7.         爱好 ： LOL<input type="checkbox" name="hobits" value="lol">
  8.                 DOTA<input type="checkbox" name="hobits" value="dota"> <br>
  9.           
  10.                  <input type="submit" value="注册">
  11. </form>
复制代码
后台
  1. public class RegisterServlet extends HttpServlet {
  3.     protected void service(HttpServletRequest request, HttpServletResponse response)
  4.             throws ServletException, IOException {
  6.         System.out.println("获取单值参数name:" + request.getParameter("name"));
  8. // 前台type=checkbox 可多选，后台得到数组
  9.         String[] hobits = request.getParameterValues("hobits");
  10.         System.out.println("获取具有多值的参数hobits: " + Arrays.asList(hobits));
  12.         System.out.println("通过 getParameterMap 遍历所有的参数： ");
  13.         Map<String, String[]> parameters = request.getParameterMap();
  15.         Set<String> paramNames = parameters.keySet();
  16.         for (String param : paramNames) {
  17.             String[] value = parameters.get(param);
  18.             System.out.println(param + ":" + Arrays.asList(value));
  19.         }
  21.     }
  23. }
复制代码
web.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app>
  4.         <servlet>
  5.                 <servlet-name>LoginServlet</servlet-name>
  6.                 <servlet-class>LoginServlet</servlet-class>
  7.         <load-on-startup>10</load-on-startup>
  8.         </servlet>
  10.         <servlet-mapping>
  11.                 <servlet-name>LoginServlet</servlet-name>
  12.                 <url-pattern>/login</url-pattern>
  13.         </servlet-mapping>       
  14.         <servlet>
  15.                 <servlet-name>RegisterServlet</servlet-name>
  16.                 <servlet-class>RegisterServlet</servlet-class>
  17.         </servlet>
  19.         <servlet-mapping>
  20.                 <servlet-name>RegisterServlet</servlet-name>
  21.                 <url-pattern>/register</url-pattern>
  22.         </servlet-mapping>       
  24. </web-app>
复制代码
9.获取头信息

           request.getHeader() 获取浏览器传递过来的头信息。
  比如getHeader("user-agent") 可以获取浏览器的根本资料，如许就能判断是firefox、IE、chrome、或者是safari浏览器
        request.getHeaderNames() 获取浏览器所有的头信息名称，根据头信息名称就能遍历出所有的头信息

host: 主机地址
user-agent: 浏览器根本资料
accept: 表现浏览器接受的数据类型
accept-language: 表现浏览器接受的语言
accept-encoding: 表现浏览器接受的压缩方式，是压缩方式，并非编码
connection: 是否保持连接
cache-control: 缓存时限
  
 
  1. import java.io.IOException;
  2. import java.util.Date;
  3. import java.util.Enumeration;
  5. import javax.servlet.ServletConfig;
  6. import javax.servlet.http.HttpServlet;
  7. import javax.servlet.http.HttpServletRequest;
  8. import javax.servlet.http.HttpServletResponse;
  10. public class HelloServlet extends HttpServlet{
  11.        
  12.         public void init(ServletConfig config){
  13.                 System.out.println("init of Hello Servlet");
  14.         }
  16.         public void doGet(HttpServletRequest request, HttpServletResponse response){
  17.        
  18.                 Enumeration<String> headerNames= request.getHeaderNames();
  19.                 while(headerNames.hasMoreElements()){
  20.                         String header = headerNames.nextElement();
  21.                         String value = request.getHeader(header);
  22.                         System.out.printf("%s\t%s%n",header,value);
  23.                 }
  24.                
  25.                 try {
  26.                         response.getWriter().println("<h1>Hello Servlet!</h1>");
  27.                         response.getWriter().println(new Date().toLocaleString());
  28.                 } catch (IOException e) {
  29.                         // TODO Auto-generated catch block
  30.                         e.printStackTrace();
  31.                 }
  32.         }
  33.        
  34. }
复制代码

  10.服务端传参

setAttribute和getAttribute可以用来在进行服务端跳转的时候，在不同的Servlet之间进行数据共享。
在 Servlet 中，可以通过多种方式将数据传递给客户端或在不同的请求间共享数据：

  1. 1. 通过 URL 参数传递数据 (GET 请求)
  2. 当客户端发送一个 GET 请求时，服务端可以通过 URL 参数传递数据。这些参数会附加在 URL 后面。
  4. 客户端请求：
  6. <a href="myServlet?name=John&age=30">Click me</a>
  7. 服务端接收：
  9. @WebServlet("/myServlet")  省去配置web.xml  
  10. public class MyServlet extends HttpServlet {
  11.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  12.         String name = request.getParameter("name");  // 获取 "name" 参数
  13.         String age = request.getParameter("age");    // 获取 "age" 参数
  15.         response.getWriter().write("Name: " + name + ", Age: " + age);
  16.     }
  17. }
  19. 2. 通过表单提交数据 (POST 请求)
  20. 客户端也可以通过 HTML 表单提交数据到服务端。表单数据通常通过 POST 请求发送到指定的 URL。
  22. 客户端 HTML 表单：
  24. <form action="myServlet" method="post">
  25.     <input type="text" name="username" />
  26.     <input type="password" name="password" />
  27.     <input type="submit" value="Submit" />
  28. </form>
  29. 服务端接收：
  31. @WebServlet("/myServlet")
  32. public class MyServlet extends HttpServlet {
  33.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  34.         String username = request.getParameter("username");
  35.         String password = request.getParameter("password");
  37.         response.getWriter().write("Username: " + username + ", Password: " + password);
  38.     }
  39. }
  41. 3. 通过 HttpSession 传递数据
  42. HttpSession 对象允许在多个请求之间存储数据，从而实现跨请求的数据传递。它通常用于在一个用户会话中保存数据。
  44. 设置 Session 数据：
  46. @WebServlet("/setSession")
  47. public class SetSessionServlet extends HttpServlet {
  48.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  49.         HttpSession session = request.getSession();
  50.         session.setAttribute("username", "John");  // 保存数据到 Session
  52.         response.getWriter().write("Session data set.");
  53.     }
  54. }
  55. 获取 Session 数据：
  57. @WebServlet("/getSession")
  58. public class GetSessionServlet extends HttpServlet {
  59.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  60.         HttpSession session = request.getSession();
  61.         String username = (String) session.getAttribute("username");  // 获取 Session 数据
  63.         response.getWriter().write("Session data: " + username);
  64.     }
  65. }
  68. 4. 通过 ServletContext 传递数据
  69. ServletContext 是一个全局对象，它可以在同一 Web 应用中的所有 Servlet 和 JSP 页面之间共享数据。不同的 Servlet 可以通过 ServletContext 存取全局范围的数据。
  71. 设置 ServletContext 数据：
  73. @WebServlet("/setContext")
  74. public class SetContextServlet extends HttpServlet {
  75.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  76.         ServletContext context = getServletContext();
  77.         context.setAttribute("company", "TechCorp");  // 保存数据到 ServletContext
  79.         response.getWriter().write("ServletContext data set.");
  80.     }
  81. }
  82. 获取 ServletContext 数据：
  84. @WebServlet("/getContext")
  85. public class GetContextServlet extends HttpServlet {
  86.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  87.         ServletContext context = getServletContext();
  88.         String company = (String) context.getAttribute("company");  // 获取 ServletContext 数据
  90.         response.getWriter().write("ServletContext data: " + company);
  91.     }
  92. }
  94. 5. 通过 RequestDispatcher 转发请求并传递数据
  95. RequestDispatcher 用于请求转发，服务端可以通过 RequestDispatcher 将请求转发给另一个 Servlet，并传递请求数据。
  97. 请求转发并传递数据：
  99. @WebServlet("/forwardRequest")
  100. public class ForwardRequestServlet extends HttpServlet {
  101.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  102.         request.setAttribute("message", "Hello from the first servlet!");
  104.         RequestDispatcher dispatcher = request.getRequestDispatcher("/receiveRequest");
  105.         dispatcher.forward(request, response);
  106.     }
  107. }
  108. 接收转发的请求：
  110. @WebServlet("/receiveRequest")
  111. public class ReceiveRequestServlet extends HttpServlet {
  112.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  113.         String message = (String) request.getAttribute("message");
  115.         response.getWriter().write("Received message: " + message);
  116.     }
  117. }
复制代码
11.response 用法

        response是HttpServletResponse的实例，用于提供给浏览器的相应信息
1.设置相应内容
   PrintWriter pw= response.getWriter();
通过response.getWriter(); 获取一个PrintWriter 对象
可以使用println(),append(),write(),format()等等方法设置返回给浏览器的html内容。
  pw.println("<h1>Hello Servlet</h1>");
  2.设置相应格式
   response.setContentType("text/html");
  "text/html" 是即格式 ，在request获取头信息 request获取头信息 中对应的request.getHeader("accept").
"text/html" 是存在的，表现浏览器可以辨认这种格式，如果换一个其他的格式， 比如 "text/lol" ，浏览器不能辨认，那么打开此servlet就会弹出一个下载的对话框。
  3.设置相应编码
   设置相应编码有两种方式
  1. response.setContentType("text/html; charset=UTF-8");
          设置字符编码，还设置了相应内容的类型。浏览器在吸收到该相应时，会根据 Content-Type 来判断该如那边理数据。
  2. response.setCharacterEncoding("UTF-8");  只设置字符编码，不指定内容类型
  这两种方式都需要在response.getWriter调用之前实行才华见效。
最佳实践：通常环境下，为了确保相应体在不同浏览器中都能正确显示，建议同时设置这两者。
  4.设置不使用缓存
   使用缓存可以加快页面的加载，降低服务端的负担。但是也可能看到过时的信息，可以通过如动手段关照浏览器不要使用缓存
    response.setDateHeader("Expires", 0); // [告诉浏览器相应内容已过期。]
    response.setHeader("Cache-Control", "no-cache");//[确保每次请求都验证缓存的有用性]
    response.setHeader("pragma", "no-cache");// [Pragma 头是 HTTP/1.0 中用于禁用缓存的头，它在较新的 HTTP/1.1 中被 Cache-Control 头代替，但为了兼容旧版浏览器，通常仍会一起使用。]
    response.getWriter().println("<h1>Hello Servlet!</h1>");
    response.getWriter().println(new Date().toLocaleString());
  12.上传文件

前台：
  1. <!DOCTYPE html>
  3. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  4. <form action="uploadFile" method="post" enctype="multipart/form-data">
  5.   名称:<input type="text" name="name" /> <br>
  6.   上传 : <input type="file" name="filepath" /> <br>
  7.   <input type="submit" value="上传">
  8. </form>
复制代码
留意:
1. form 的method必须是post的，get不能上传文件。 还需要加上enctype="multipart/form-data" 表现提交的数据是二进制文件
后台：
         需要用到两个第三方的jar包，commons-io-1.4.jar和commons-fileupload-1.2.2.jar。 在右侧下载，并放在WEB-INF/lib下
  1. import java.io.File;
  2. import java.io.FileNotFoundException;
  3. import java.io.FileOutputStream;
  4. import java.io.InputStream;
  5. import java.io.PrintWriter;
  6. import java.util.Iterator;
  7. import java.util.List;
  9. import javax.servlet.ServletException;
  10. import javax.servlet.http.HttpServlet;
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  14. import org.apache.commons.fileupload.FileItem;
  15. import org.apache.commons.fileupload.FileUploadException;
  16. import org.apache.commons.fileupload.disk.DiskFileItemFactory;
  17. import org.apache.commons.fileupload.servlet.ServletFileUpload;
  19. public class UploadPhotoServlet extends HttpServlet {
  21.     public void doPost(HttpServletRequest request, HttpServletResponse response) {
  23.         String filename = null;
  24.         try {
  26. //使用 DiskFileItemFactory 和 ServletFileUpload 来解析上传的请求：
  27.             DiskFileItemFactory factory = new DiskFileItemFactory();
  28.             ServletFileUpload upload = new ServletFileUpload(factory);
  29.             // 设置上传文件的大小限制为1M
  30.             factory.setSizeThreshold(1024 * 1024);
  31.             
  32.             List items = null;
  33.             try {
  34. // 解析请求，得到所有表单项
  35.                 items = upload.parseRequest(request);
  36.             } catch (FileUploadException e) {
  37.                 e.printStackTrace();
  38.             }
  40.             Iterator iter = items.iterator();
  41.             while (iter.hasNext()) {
  43. //每个 FileItem 对象代表请求中的一个字段（可能是文件或表单数据）。
  44.                 FileItem item = (FileItem) iter.next();
  45.                 if (!item.isFormField()) {// 如果不是表单字段（即文件上传字段）
  47.                     // 根据时间戳创建头像文件
  48.                     filename = System.currentTimeMillis() + ".jpg";
  49.                     
  50.                     //通过getRealPath获取上传文件夹，如果项目在e:/project/j2ee/web,那么就会自动获取到 e:/project/j2ee/web/uploaded
  51.                     String photoFolder =request.getServletContext().getRealPath("uploaded"); // 获取上传目录路径
  52.                     
  53.                     File f = new File(photoFolder, filename);
  54.                     f.getParentFile().mkdirs();
  56.                     // 通过item.getInputStream()获取浏览器上传的文件的输入流
  57.                     InputStream is = item.getInputStream();
  59.                     // 复制文件
  60.                     FileOutputStream fos = new FileOutputStream(f);
  61.                     byte b[] = new byte[1024 * 1024];
  62.                     int length = 0;
  63.                     while (-1 != (length = is.read(b))) {
  64.                         fos.write(b, 0, length);
  65.                     }
  66.                     fos.close();
  68.                 } else {
  69.                         System.out.println(item.getFieldName());
  70.                     String value = item.getString();
  71.                     value = new String(value.getBytes("ISO-8859-1"), "UTF-8");
  72.                     System.out.println(value);
  73.                 }
  74.             }
  75.             
  76.             String html = "<img width='200' height='150' src='uploaded/%s' />";
  77.             response.setContentType("text/html");
  78.             PrintWriter pw= response.getWriter();
  79.             
  80.             pw.format(html, filename);
  81.             
  82.         } catch (FileNotFoundException e) {
  83.             // TODO Auto-generated catch block
  84.             e.printStackTrace();
  85.         } catch (Exception e) {
  86.             // TODO Auto-generated catch block
  87.             e.printStackTrace();
  88.         }
  89.     }
  90. }
复制代码
web.xml
  1.         <servlet>
  2.                 <servlet-name>UploadFileServlet</servlet-name>
  3.                 <servlet-class>UploadPhotoServlet</servlet-class>
  4.         </servlet>
  6.         <servlet-mapping>
  7.                 <servlet-name>UploadFileServlet</servlet-name>
  8.                 <url-pattern>/uploadFile</url-pattern>
  9.         </servlet-mapping>       
复制代码
上传测试：
重启tomcat, 打开页面进行上传       http://127.0.0.1/upload.html
如那边理其他非File字段？
   因为浏览器指定了以二进制的情势提交数据，那么就不能通过常规的手段获取非File字段：
  request.getParameter("name")
  

  在遍历Item时(Item即对应浏览器提交的字段)，可以通过
item.isFormField  true 是常规表单字段。
  通过item.getFieldName()和item.getString()就知道分别是哪个字段，以及字段的值了。
  13.Servlet无法配置Tomcat

重要针对Eclipse,idea自带内置服务器方便调试。
办理办法：定位到你自身安转的  盘:\project\.metadata\.plugins\org.eclipse.core.runtime\.settings
删除：
org.eclipse.wst.server.core.prefs
org.eclipse.jst.server.tomcat.core.prefs
删除后重启即可。
14.无法启动Tomcat

办理办法粗暴一点：菜单-Window->Show View->Other->Server->Servers 此时会出现如图所示的Tomcat v7.0 Server....
右键点击，选择Delete
然后再重新配置 通过Eclipse启动Tomcat-Run On Server 即可~
留意：

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4