java web笔记

Servlet

1、Servlet功能：

· 创建并返回基于客户请求的动态HTML页面及数据

· 与数据库进行通信

2、使用Servlet

· Servlet本身是一组接口，包含在javax.Servlet包内。

· 首先要实现Servlet接口，主要在service方法中进行业务处理

3、访问路径配置：

1、基于xml文件的配置

不常用

<servlet>
        <servlet-name>MyServlet</servlet-name>
        <servlet-class>Servlet01.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
        <servlet-name>MyServlet</servlet-name>
        <url-pattern>myservlet</url-pattern>
</servlet-mapping>

2、基于注解的配置

@WebServlet("/myServle")
public class MyServlet implements Servlet{
}

4、Servlet的生命周期

过程：

1、浏览器请求Servlet时，Tomcat会查询该Servlet是否存在，不存在，就通过反射机制创建对象；存在，直接执行第三部。

2、调用init()方法完成初始化

3、调用service方法完成业务逻辑操作

4、关闭Tomcat时，会调用destroy方法，释放当前资源

Servlet的声明周期方法：无参构造，Init（），service（），destroy（）；

1、无参构造函数只调用一次，创建对象

2、init只调用一次，初始化对象

3、service调用N次，执行业务逻辑，执行几次，调用几次

4、destroy只调用一次，卸载对象

5、ServletConfig

该接口用于描述Servlet的基本信息

getServletName（）：获取Servlet的名字

getInitParameter（）：获取初始化参数（web.xml)

getInitParameterNames（）：获取所有的初始化initParameter的name值，一般用作遍历初始化参数

getServletContex（）：返回ServletContex对象，他是Servlet的上下文，是整个Servlet的 管理者

6、ServletConfig和ServletContex的区别

1、ServletConfig作用于某个Servlet实例，每个Servlet都有对应的ServletConfig

2、ServletContex作用于整个儿Web应用，一个Web应用对应一个ServletContex，多个Servlet对应一个ServletContex；（ServletContex由ServletConfig调用getServletContex（）获取）**

3、一个是局部对象，一个是全局对象

7、Servlet的层次结构

Servlet——>GenericServlet——>HttpServlet

常用继承HttpServlet，重写doGet（）和doPost（）进行业务处理

HTTP请求有很多类型，常用的有四种：

GET 读取

POST 保存

PUT 修改

DELETE 删除

GenericServlet

实现Servlet接口，重写了service方法，同时屏蔽了不常用的方法

HttpServlet

继承了GenericServlet类，重写了service方法，同时根据发出请求的方式，自定义doGet，doPost，等方法

JSP

jsp本质是一个Servlet，但是拥有与用户交互的功能

单纯从开发的角度看：JSP就是HTML内嵌入Java代码

一、嵌入方式

1、JSP脚本：执行java逻辑代码

<% 
	Java代码 
%>

2、JSP声明：定义java方法

 <%!
         声明Java方法
  %>

3、JSP表达式：把java对象直接输出到HTML页面中

<%=java变量 %>

<%
  String str = "jspHello";
  %>
  <%!
    public String test(){
        return "121,121";
    }
  %>
  <%
    System.out.println(test());
  %>

 <a href="/hello"><%=str%></a>

二、JSP内置对象

request: 表示一次请求 HttpServletRequest

response:表示一次响应 HttpServletResponse

pageContext:页面上下文，获取页面信息 pageContext

session:表示一次会话，保存用户信息 HttpSession

application:表示当前的web应用 ServletContext

config:当前 Jsp 对应的ServletConfig对象，获取当前Servlet的信息

out:向浏览器输出数据 JspWriter

page:当前Jsp对应的Servlet对象，Servlet

excerption:当前Jsp页面的异常，Exception

常用：request 、response、 session 、 application、 pageContext

三、request常用方法:

1、String getParameter(String key)：获取客户端传来的参数。

2、void setAttribute(String key,0bject value)：通过键值对的形式保存数据。

**3、Object getAttribute(String key)：**通过 key取出value.

4、RequestDispatcher getRequestDispatcher(String path)：返回一个RequestDispatcher对象，该对象的forward方法用于请求转发。

5、String0] getParameterValues)：获取客户端传来的多个同名参数。

6、void setCharacterEncoding(String charset)：指定每个请求的编码。

四、HTTP请求状态码

200:正常
404:资源找不到
400:请求类型不匹配
500: Java 程序抛出异常.

五、Response常用方法

1、sendRedirect(String path)重定向，页面之间的跳转。
转发getRequestDispatcher和重定向sendRedirect的区别:
转发是将同一个请求传给下一个页面，重定向是创建一个新的请求传给下一 -个页面，之前的请求结束生命周期。
转发:同一个请求在服务器之间传递，地址栏不变,也叫服务器跳转。
重定向:由客户端发送一次新的请求来访问跳转后的目标资源，地址栏改变，也叫客户端跳转。
如果两个页面之间需要通过request来传值，则必须使用转发，不能使用重定向。

六、Session和Cookie

1、Session

用户会话
服务器无法识别每一-次 HTTP请求的出处(不知道来自于哪个终端)，它只会接受到一个请求信号，所以就存在一
个问题:将用户的响应发送给其他人，必须有一种技术来让服务器知道请求来自哪，这就是会话技术。
**会话:**就是客户端和服务器之间发生的一系列连续的请求和响应的过程，打开浏览器进行操作到关闭浏览器的过
程。
**会话状态:**指服务器和浏览器在会话过程中产生的状态信息，借助于会话状态，服务器能够把属于同一次会话的一
系列请求和响应关联起来。

实现会话有两种方式:
●session
●cookie

属于同一次会话的请求都有一一个相同的标识符, sessionlD
session常用的方法:
String getld(） 获取sessionID
void setMaxInactivelnterval(int interval) 设置session的失效时间，单位为秒
int getMaxinactivelnterval（） 获取当前session的失效时间
void invalidate() 设置session立即失效
void setAttribute(String key,Object value) 通过键值对的形式来存储数据
object getributeSring key) 通过键获取对应的数据
void removeAttribute(String key) 通过键删除对应的数据

登录拦截案例：

**1、request拦截：**根据request是否登录后的请求不同进行拦截，直接访问拿不到用户信息

	    String userName = req.getParameter("userName");
        String password = req.getParameter("password");
        if (userName.equals("admin")&&password.equals("123123")){
            /*
            * 拦截原理：
            *   未登录状态下，请求是不含有userName的，所以只会有一个默认值，而非设置的存储
            *   */
            req.setAttribute("userName",userName);
            req.getRequestDispatcher("welcome.jsp").forward(req,resp);//请求转发
        }else {
            resp.sendRedirect("Login.jsp");//重定向
        }
    }

<h1>
    欢迎您，<%=request.getAttribute("userName")%>

</h1>

2、Session拦截：根据会话的时长周期进行拦截

	    String userName = req.getParameter("userName");
        String password = req.getParameter("password");
        HttpSession session = req.getSession();
        if (userName.equals("admin")&&password.equals("123123")){
            session.setAttribute("userName",userName);
            req.getRequestDispatcher("welcome.jsp").forward(req,resp);
        }else {
            resp.sendRedirect("Login.jsp");
    }

<h1>    欢迎您，<%=session.getAttribute("userName")%></h1>
<a href="/logout">退出</a>

点击退出操作：

  		HttpSession session = req.getSession();
        session.invalidate();//销毁Session
        resp.sendRedirect("loginSession.jsp");

2、Cookie

Cookie是服务端在HTTP响应中附带传给浏览器的-一个小文本文件，一旦浏览器保存了某个Cookie,在之后的请
求和响应过程中，会将此Cookie来回传递，这样就可以通过Cookie这个载体完成客户端和服务端的数据交互。
Cookie
●创建Cookie

Cookie cookie = new Cookie("name" ,”tom" );
response。addCookie(cookie);

●读取Cookie

Cookie[] cookies = request. getCookies();
for (Cookie cookie cookies){
out .write(ookie。getName()+" :"+cookie. getvalue()+"<br/>");
}

Cookie常用的方法
void setMaxAge(int age)：设置Cookie的有效时间，单位为秒
int getMaxAge（）：获取Cookie的有效时间
String getName（）：获取Cookie的name
String getValue（）：获取Cookie的value

Session和Cookie的区别
**session:**保存在服务器

​ 保存的数据是Object

​ 会随着会话的结束而销毁

​ 保存重要信息

cookie: 保存在浏览器

​ 保存的数据是String

​ 可以长期保存在浏览器中，无会话无关

​ 保存不重要信息

3、存储用户信息:

session: setAttribute(“name”,“admin”) 存
getAttribute(“name”) 取
**生命周期:**服务端:只要WEB应用重启就销毁，客户端:只要浏览器关闭就销毁,

**退出登录：**invalidate()

cookie: response .addCookie(new Cookie(name,“admin”)) 存

Cookie[l cookies = request. getCookies();
for (Cookie cookie :cookies){
if(cookie. getlame() . equals("name")){
out.write("欢迎回来,"+cookie. getvalue());
}
}

取
**生命周期:**不随服务端的重启而销毁，客户端:默认是只要关闭浏览器就销毁,我们通过setMaxAge0方法设置
有效期，一旦设置了有效期，则不随浏览器的关闭而销毁，而是由设置的时间来决定。

**退出登录：**setMaxAge(0)；

七、JSP内置对象作用域

4个：page. request. session. application
共同点：都有 setAttribute, getAttribute 方法。
**page作用域:**对应的内置对象是pageContext.
**request作用域:**对应的内置对象是request.
**session作用域:**对应的内置对象是session。
**application作用域:**对应的内置对象是application。
page < request < session < application

作用域：

page只在当前页面有效。
request在一次请求内有效。
session在一次会话内有效。
application对应整个WEB应用的。（Tomcat没重启或关闭，就一直存在）

●网站访问量统计

<%
Integer count = (Integer) application. getattribute(”count");
if(count == null){
count = 1;
applicat ion. setAttribute( " count" ,count);
}e1se{
count++;
application。setAttributel"count" ,count);

%>

您是当前的第<%=count%>位访客

八、EL 表达式

Expression Language表达式语言，替代JSP页面中数据访问时的复杂编码，可以非常便捷地取出域对象
(pageContext. request. session. application) 中保存的数据，前提是-定要先 setAttribute, EL就相当于
在简化getAttribute
${变量名} 变量名就是setAttribute对应的key值。

1. EL对于4种域对象的默认查找顺序:
   pageContext -> request) -> session -> application
   按照上述的顺序进行查找，找到立即返回，在application中也无法找到，则返回null
2. 指定作用域进行查找
   pageContext: ${pageScope.name}
   request: ${requestScope.name}
   session: ${sessionScope.name}
   application: $applicationScope.name}

数据级联:

<%
//pageContext. setAttribute( "name" , "page");
//request.setAttribute( "name ,"request");
//session. setAttribute( "name","ession");
//application.setAttribute( "name"," aplication");
User user - new User(1,“张三”,86.5,new Address(1,"小寨”));
System. out.pr intln(user。tostring(0);
pageContext . setAttribute("user" ,user);
%>
<table>
<tr>
<th>编号</th>
<th>姓名</th>
<th>成绩</th>
<th>地址</th>
</tr>
<tr>
<td>${user.id}</td>
<td>${user.name}</td>
<td>${user.score}</td>
<td>${user.address}</td>
</tr>
</table>

${user"id")] == ${user.id} (常用后者)

EL执行表达式

${num1 || num2}

&&  ||  !  <   >  <=  >=  ==
&&     and
II     or
!      not
==     eq
!=     ne
<      lt
>      gt
<=     le
>=     ge
empty  变量为null, 长度为0的String, size为0的集合

九、JSTL

JSP Standard Tag LibraryJSP标准标签库, JSP为开发者提供的一系列的标签,使用这些标签可以完成-些逻辑处
理，比如循环遍历集合，让代码更加简洁，不再出现JSP脚本穿插的情况。
实际开发中EL和JSTL结合起来使用, JSTL 侧重于逻辑处理，EL负责展示数据。

JSTL的使用：

​ 1.需要导入jar 包(两个jstl.jar standard.jar)
​ 2.在JSP页面开始的地方导入JSTL标签库

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

​ 3、在需要的地方使用工

    <c:forEach items="${list}" var="user">
        <tr>
            <td>${user.name}</td>
            <td>${user.age}</td>
        </tr>
    </c:forEach>

JSTL优点:

​ 1、提供了统一的标签
​ 2.可以用于编写各种动态功能

常用标签:

●set、out. remove. catch

**set:**向域对象中添加数据

<c:set var = "name" value="tom" scope="request"></c:set>
${requestScope.name}
<c:out value="${name}" default="未定义"></c:out>

<%
    request.setAttribute("user",new User());//如果存储对象时，先要存储一个空对象
%>
<c:set target="${user}" property="name" value="李四"></c:set><%--给空对象添加属性值--%>
${user.name}
<c:out value="${user.name}" default="未定义"></c:out>

**out:**输出域对象中的数据

<c:set var=" name" value=" tom"></c:set>
<c:out value="${name}" default="未定义"></c:out>

**remove:**删除域对象中的数据

<c:remove var="name" scope="request"></c:remove>
<c:out value="${name}" default="未定义"></c:out> <br>

**catch:**捕获异常

<c:catch var="error">
<%
int a=10/0;
%>
</c:catch>
${error}

●条件标签: if choose

条件标签：<br>

<c:set var="num1" value="1"></c:set>
<c:set var="num2" value="2"></c:set>
if:
<c:if test="${num1>num2}">ok</c:if>
<c:if test="${num1<num2}">fail</c:if> <br>
choose:
<c:choose>
    <c:when test="${num1>num2}">ok</c:when>
    <c:otherwise>fail</c:otherwise>
</c:choose>

1、格式化标签库：

· 导入格式化标签库：

<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

· 常用标签：

<%
    request.setAttribute("date", new Date());
%>
<fmt:formatDate value="${date}" pattern="YYYY-MM-DD hh:mm:ss"></fmt:formatDate> <br>
<fmt:formatNumber value="1234.5678" maxIntegerDigits="2" maxFractionDigits="3"></fmt:formatNumber> <br>

2、函数标签库

· 导入格式化标签库：

<%@taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>

· 常用标签：

<%
    request.setAttribute("info", "java,c");
%>
${fn:contains(info,"python" )} <br>
${fn:startsWith(info, "java")} <br>
${fn:endsWith(info,"c" )} <br>
${fn:indexOf(info, va)} <br>
${fn:replace(info, "c", "python")} <br>
${fn:substring(info, 2, 3)} <br>
${fn:split(info, ",")[0]}-${fn:split(info, ",")[1]} <br>

十、过滤器

Filter

功能:

​ 1.用来拦截传入的请求和传出的响应。
​ 2、修改或以某种方式处理正在客户端和服务端之间交换的数据流。

如何使用?

​ 与使用Servlet类似，Filter 是Java WEB提供的-一个接口,开发者只需要自定义-一个类并且实现该接口即可。

@WebFilter(urlPatterns = {"/login","/submit"})
public class CharacterFilter implements Filter {


    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("UTF-8");
        servletResponse.setCharacterEncoding("UTF-8");
        filterChain.doFilter(servletRequest,servletResponse);//放行
    }


}

注意：

​ 1、Filter接口中的init方法和destroy方法被default关键字修饰过，所以在实现接口时，可以不重写该方法

​ 2、doFilter方法处理完业务逻辑后，一定要执行 filterChain.doFilter(servletRequest,servletResponse);//放行

​ 否则，程序就不往下跑了

​ 3、如果写了过滤器，但是Tomcat启动不起来时，去重写init方法

web.xml中配置Filter

<filter>
<filter-name>charcater</filter-name>
<filter-class>com. southwind. filter . CharacterFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>charcater</filter-name>
<urn-pattern>/1ogin</url-pattern>
<url-pattern> /test</url-pattern>
</filter-mapping>

Filter生命周期

当Tomcat启动时，通过反射机制调用Filter的无参构造函数创建实例化对象，同时调用init方法实现初始化
doFilter方法调用多次，当Tomcat服务关闭的时候，调用destroy来销毁Filter 对象。

无参构造函数: 只调用一次，当Tomcat启动时调用(Filter - -定要进行配置)
init方法: 只调用—次，当Filter的实例化对象创建完成之后调用
doFilter: 调用多次，访问Filter的业务逻辑都写在Filter 中
destory: 只调用一次， Tomcat 关闭时调用。

同时配置多个Filter，Filter的调用方式由web.xml文件中自上而下的书写方式决定。

但是，注解的顺序是随机的，也就是无序的。

实际开发中Filter的使用场景:
1.统一处理中文乱码。
2、屏蔽敏感词。

@WebFilter("/test")
public class WordFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    String name = servletRequest.getParameter("name");
    name = name.replace("敏感词","***");
    servletRequest.setAttribute("name",name);
    filterChain.doFilter(servletRequest,servletResponse);
    }
}

3、控制资源的访问权限。

package com. southwind.filter;
import javax. servlet. *:
import javax. servlet。annotat ion. WebFilter;
import javax. servlet .http。HttpServletRequest;
import javax.servlet .http。HttpServletResponse;
import javax. servlet .http。HttpSession;
import java. io. IOException;
@WebFilter("/download.jsp")
public class DowmloadFilter implements Filter {
@override
public void doFilter (ServletRequest servletRequest, ServletResponse servletResponse,
FilterChain filterChain) throws I0Exception, ServletException {
HttpServletRequest request = (HttpServletRequest) servletRequest;
HttpServletResponse response 上(HttpServletResponse) servletResponse ;
HttpSession session = request . getSession();
String name = (String) session. getAttribute( "name"): 
if(name == nu11){
//不是登录状态
response . sendRedirect("/login.jsp");
}else{
filterChain. doFilter (servletRequest, servletResponse);
}

十一、文件上传下载

1、文件上传

乱码强转：

   byte[] temp = string.getBytes("GBK");
   String result =  new String(temp,"utf-8");

web常用乱码转换：

 request.setCharacterEncoding("UTF-8");
 response.setContentType("text/html;charset=UTF-8");

● 第一步对于JSP

1. input的type设置为file
2. form 表单的method设置post, get 请求会将文件名传给服务端，而不是文件本身
3. form 表单的enctype设置multipart/form-data,以二进制的形式传输数据

 <form action="/upload" method="post" enctype="multipart/form-data">
   <input type="file" name="photo">
   <input type="submit" value="上传">
 </form>

● 第二步（方式一）Servle(普通方式，不常用)

//通过输入流获取客户传来的数据流
        InputStream inputStream = req.getInputStream();
        Reader reader = new InputStreamReader(inputStream);
        BufferedReader bufferedReader = new BufferedReader(reader);
        String str = "";
        //获取输出流
        String path = req.getServletContext().getRealPath("file/copy.txt");
        OutputStream outputStream = new FileOutputStream(path);
        Writer writer = new OutputStreamWriter(outputStream);
        BufferedWriter bufferedWriter = new BufferedWriter(writer);


        while ((str = bufferedReader.readLine()) != null) {

            byte[] temp = str.getBytes("GBK");
            String result = new String(temp, "utf-8");
            bufferedWriter.write(result);
            System.out.println(result);
        }
        bufferedWriter.close();
        writer.close();
        outputStream.close();
        bufferedReader.close();
        reader.close();
        inputStream.close();

● 第二步（方式二）使用Apache携带的FileUpload组件

1、首先导报：commons-io-2.11.0.jar commons-fileupload-1.4.jar

2、代码：

   		DiskFileItemFactory fileItemFactory =new DiskFileItemFactory();//创建工厂
        ServletFileUpload servletFileUpload = new ServletFileUpload(fileItemFactory);//通过工厂获取servletFileUpload组件
        try {
            List<FileItem> list = servletFileUpload.parseRequest(req);
            for (FileItem fileItem : list) {
               if (fileItem.isFormField()){//不是文件
                   String name = fileItem.getFieldName();
                   String value = fileItem.getString("UTF-8");
                   System.out.println(name+":"+value);
               }else {//是文件
                   String fileName =fileItem.getName();
                   long size = fileItem.getSize();
                   System.out.println(fileName+":"+size+"byte");

                   InputStream inputStream = fileItem.getInputStream();
                   BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);

                   String path = req.getServletContext().getRealPath("file/"+fileName);
                   OutputStream outputStream = new FileOutputStream(path);
                   BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);

                   int temp =0;
                   while ((temp = bufferedInputStream.read())!=-1){
                       bufferedOutputStream.write(temp);
                   }
                   bufferedInputStream.close();
                   bufferedOutputStream.close();
                   inputStream.close();
                   outputStream.close();
                   System.out.println("上传成功");
               }
            }
        } catch (FileUploadException e) {
            e.printStackTrace();
        }

优点：

 		1. 与第一种方式相比，没有了浏览器自带的一些信息写进上传的文件中
          		2. 与第一种方式相比，自己进行了换行操作，而不是统一都是一行
            		3. 乱码问题没发现
              		4. 可以读取文件和文本框的内容

2、文件下载

jsp内容：

<a href="/download?type=png">1.png</a>
<a href="/download?type=txt">1.txt</a>

servlet内容：

package Servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;


@WebServlet("/download")
public class DownLoadServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //设置响应方式
        resp.setContentType("application/x-msdownload");

        String type = req.getParameter("type");
        String  fileName = "";
        switch (type){
            case "png":
                fileName = "1.png";break;
            case "txt":
                fileName = "1.txt";break;
        }
        //设置下载文件名
        resp.setHeader("Content-Disposition","attachment;filename="+fileName);
        //获取输出流
        OutputStream outputStream = resp.getOutputStream();
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
        
        //获取文件路径，并未知搭配输入流
        String path = req.getServletContext().getRealPath("file/"+fileName);
        InputStream inputStream = new FileInputStream(path);
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        
        int temp = 0;
        while ((temp = bufferedInputStream.read())!=-1){
            bufferedOutputStream.write(temp);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
        inputStream.close();
        outputStream.close();

    }
}

十二、Ajax

Asynchronous JavaScript And XML:异步的JavaSript和XML
AJAX不是新的编程，指的是一种交互方式， 异步加载，客户端和服务器的数据交互更新在局部页面的技术，不需
要刷新整个页面(周部刷新)

1、优点:

1、局部刷新，效率更高
2、用户体验更好

2、基于JQuery的Ajax

1、jsp内容：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
    <script type="text/javascript" src="js/jQuery.js"></script>
  </head>


  <body>
  ${str}
  <form action="/test" method="post" id="form">
    <input type="text" id="text" name="name"><br>
    <input type="button" οnclick="submit" id="btn" value="提交">
  </form>
  </body>



  <script type="text/javascript">
    function  submit() {
        $("#form").submit();
    }
    $(function () {
        var btn = $("#btn");
        btn.click(function () {
            $.ajax({
                url:"/test",
                type:"post",
                data:"id=1",
                dataType:"text",
                success:function (data) {
                    $("#text").before("<div>"+data+"</div>");
                }
            })
        })
        })
  </script>
</html>

2、Servlet内容：

package Servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/test")
public class TestServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String idStr = (String)req.getParameter("id");
        int id =(idStr == null)?0:Integer.parseInt(idStr);
        String name = (String) req.getParameter("name");


        try {
            Thread.sleep(3000);//休眠3秒，更容易体现异步处理
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        String str = "hello world !!";
        resp.getWriter().write(str);


    }
}

3、注意：

​ 1、 局部刷新时，千万不要使用重定向或者请求转发，否则会全部刷新，用resp.getWriter().write(str);

​ 2、局部刷新时，要注意表单不要有submit属性，可用onclick绑定事件，否则页面碰到submit就会跳转

3、比较

●客户端请求的方式不同:
传统，浏览器发送同步请求(form. a)
AJAX,异步引擎对象发送异步请求
●服务器响应的方式不同:
传统，响应一个完整JSP页面(视图)
AJAX,响应需要的数据
●客户端处理方式不同:
传统:需要等待服务器完成响应并且重新加载整个页面之后，用户才能进行后续的操作
AJAX:动态更新页面中的局部内容,不影响用户的其他操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZqkYiOjJ-1646561578168)(C:/Users/23746/AppData/Roaming/Typora/typora-user-images/1643896777488.png)]

4、基于JQuery的Ajax语法：

$.ajax({属性})

常用的属性参數:
url: 请求的后端服务地址
type: 请求方式，默认get
data: 请求参数
dataType: 服务器返回的数据类型，text/json
success: 请求成功的回调函数
error: 请求失败的回调函数
complete: 请求完成的回调函数(无论成功或者失败，都会调用)

5、Ajax传输对象：

1、jsp内容

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
    <script type="text/javascript" src="js/jQuery.js"></script>
  </head>


  <body>

  <form action="/test" method="post" id="form">
    编号：<input type="text" id="id"> <br>
    姓名：<input type="text" id="name"> <br>
    年龄：<input type="text" id="age"> <br>
    <input type="button" οnclick="submit" id="btn" value="查询">
  </form>
  </body>



  <script type="text/javascript">
    function  submit() {
        $("#form").submit();
    }
    $(function () {
        var btn = $("#btn");
        btn.click(function () {
            $.ajax({
                url:"/test",
                type:"post",
                data:"id=1",
                dataType:"json",
                success:function (data) {
                  $("#id").val(data.id);
                  $("#name").val(data.name)
                  $("#age").val(data.age)
                }
            })
        })
        })
  </script>
</html>

2、Servlet内容

@WebServlet("/test")
public class TestServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        User user = new User(1001,"小明",22);
       String userStr = user.toString();
        System.out.println(userStr);
        JSONObject jsonObject = new JSONObject(user.toString());

        resp.setContentType("text/html;charset=utf-8");
        resp.getWriter().write(jsonObject.toString());


    }
}

3、注意

​ 1、传输的并不是真正的对象，而是由对象产生的json，并将json转为字符串转给前端

​ 2、由于没准备好jar报：不能使用JSONObject.formObject(Object object)方法，就使用了上述方法，但是在实体类中必须更改toString重写后方法的内容，过于繁琐，使用maven后一定在写一次