1. HttpServletRequest es una interfaz con un nombre completo: Jakarta.servlet.http.HttpServletRequest
2. La interfaz HttpServletRequest es miembro de la especificación Servlet.
3. La interfaz principal de la interfaz HttpServletRequest: ServletRequest
public interface HttpServletRequest extends ServletRequest {}4. ¿Quién escribió la clase de implementación de la interfaz HttpServletRequest? ¿Quién creó el objeto HttpServletRequest?
(1) Pasó la prueba: org.apache.catalina.connector.RequestFacad implementa la interfaz HttpServletRequestji.
public class RequestFacade implements HttpServletRequest{}(2) Descripción del resultado de la prueba: el servidor Tomcat (servidor web, contenedor web) implementa la interfaz HttpServletRequest y también muestra que el servidor Tomcat implementa la especificación Servlet. Para nosotros, los programadores web de Java, en realidad no necesitamos preocuparnos por esto, solo necesitamos programar para la interfaz. Lo que nos importa son los métodos en la interfaz HttpServletRequest y qué funciones pueden realizar estos métodos.
5. ¿Qué información hay en el objeto HttpServletRequest? ¿Qué información se empaqueta?
(1) El servidor Tomcat crea el objeto HttpServletRequest. La información que se encapsula en este objeto sella el protocolo de solicitud HTTP.
(2) De hecho, cuando el usuario envía una solicitud, sigue el protocolo HTTP y envía el protocolo de solicitud HTTP. El servidor Tomcat analiza toda la información y los datos en el protocolo HTTP, y luego el servidor Tomcat encapsula la información en HttpServletRequest. Pásalo a nosotros los programadores de JavaWeb.
(3) Programa de programadores web Java para la interfaz HttpServletRequest, y la información solicitada se puede obtener llamando al método.
6. ¿Cuál es el ciclo de vida de los objetos de solicitud y respuesta?
(1) objetos de solicitud y respuesta, uno es el objeto de solicitud y el otro es el objeto de respuesta. Estos dos objetos solo son válidos en la solicitud actual.
(2) Una solicitud corresponde a una solicitud
(3) Dos solicitudes corresponden a dos solicitudes
7. ¿Cuáles son los métodos comúnmente utilizados en la interfaz HttpServletRequest?
(1) ¿Cómo obtener los datos enviados por el usuario del navegador front-end?
Map<String,String[]> getParmeterMap() // 这个是获取Map Enumeration<String> getParameterNames() // 这个是获取Map集合中所有的key String[] getParameterValus(String name) // 根据key获取Map集合的value String getParamenter(String name) // 获取value这个一维数组当中的第一个元素，这个方法很常用
(2) Pensamiento: si es usted, después de que el formulario front-end envíe los datos, ¿cómo planea almacenar los datos y qué estructura de datos planea usar para almacenar los datos?
a. El formato de datos enviado por el front-end: sername=abc&userpwd=111&aihao=s&aihao=d&aihao=tt
b. Usaré la colección de mapas para almacenar:
¿Es correcta la idea de que la clave Map<String,String>
almacene
el valor de cadena que almacene la cadena ?
equivocado.
Si utiliza el almacenamiento de la estructura de datos anterior, encontrará que el valor se sobrescribe cuando se repite la clave.
valor clave
---------------------
nombre de usuario abc
contraseña de usuario 111
aihao s
aihao d
aihao tt
Esto no es posible, porque la clave del mapa no se puede repetir.
Map<String, String[]>
clave almacena el valor de la cadena almacena el valor de la clave
String[] ------------------------------- nombre de usuario {"abc"} contraseña de usuario {"111"} aihao {"s","d","tt"}
(3) Nota: cuando el formulario front-end envía datos, se supone que se envía un "número" como 120, pero en realidad se envía en forma de cadena "120", por lo que el servidor debe obtener una cadena de "120" " en lugar de un número. (El front-end siempre envía cadenas y el back-end siempre obtiene cadenas).
(4), practicar cuatro métodos comunes de solicitud
/**
* 总结一下，request接口中四个非常常用的方法
* Map<String,String[]> parameterMap = request.getParameterMap();
* Enumeration<String> names = request.getParameterNames();
* String[] values = request.getParameterValues("name");
* String value = request.getParameter("name"):
*/
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// 面向接口编程：HttpServletRequest接口
// 获取前端提交的接口
// 前端会传递什么数据呢？
// username=zhangshan&password=123&interest=s&interest=d
// 以上的数据被小猫咪封装到request对象中。
// 获取参数的Map集合
Map<String,String[]> parameterMap = request.getParameterMap();
System.out.println("------------------1----------------------");
// 1、使用迭代器遍历集合（获取Map集合中所有的key,遍历）
Set<String> keys = parameterMap.keySet();
Iterator<String> it = keys.iterator();
while (it.hasNext()){
String key = it.next();
// 通过key获取value
String[] values = parameterMap.get(key);
// 遍历一维数组
System.out.print(key + "=");
for(String value:values){
System.out.print(value + ",");
}
// 换行
System.out.println();
}
System.out.println("------------------2----------------------");
// 2、直接通过getParameterNames()这个方法，可以直接获取这个Map集合的所有key
Enumeration<String> names = request.getParameterNames();
while (names.hasMoreElements()){
// 获取key
String name = names.nextElement();
System.out.println(name);
}
System.out.println("------------------3----------------------");
// 3、直接通过name获取value这一个一维数组
String[] usernames = request.getParameterValues("username");
String[] passwords = request.getParameterValues("password");
String[] interests = request.getParameterValues("interest");
// 遍历一维数组
for(String username:usernames){
System.out.print("username=" + username + " ");
}
for(String password:passwords){
System.out.print("password=" + password + " ");
}
for(String interest:interests){
System.out.print("interest=" + interest + " ");
}
System.out.println();
System.out.println("------------------4----------------------");
// 4、通过name获取value这一个一维数组的第一个元素
// 这个方法使用最多，因为这个一维数组中一般只有一个元素
String username = request.getParameter("username");
String password = request.getParameter("password");
// String interest = request.getParameter("interest");
// 既然是checkbox,调用方法request.getParameterValues("interest")'
String[] interestes = request.getParameterValues("interest");
System.out.println("username=" + username);
System.out.println("password=" + password);
// System.out.println(interest);
for(String interest:interestes){
System.out.print("interest=" + interest + " ");
}
}(5) Resultados de ejecución
8. El objeto de solicitud en realidad se llama "campo de solicitud".
(1) ¿Qué es el objeto de dominio de aplicación?
a, ServletContext (objeto de contexto de Servlet)
b. ¿Bajo qué circunstancias consideraría vincular datos al dominio de la aplicación ServletContext?
Primero: datos compartidos por todos los usuarios.
Segundo: la cantidad de datos compartidos.
Tercero: estos datos compartidos rara vez modifican las operaciones.Cuando se cumplen las tres condiciones anteriores, el uso de este objeto de dominio de aplicación puede mejorar en gran medida la eficiencia de la ejecución de nuestro programa.
De hecho, vincular datos al dominio de la aplicación es equivalente a poner los datos en el caché (Caché) y luego obtenerlos directamente del caché cuando el usuario accede a ellos, lo que reduce las operaciones de E/S y mejora en gran medida el rendimiento del sistema, por lo que el almacenamiento en caché tecnología es mejorar una medida importante del rendimiento del sistema.
¿Qué técnicas de almacenamiento en caché has visto?
grupo de constantes de cadena
Conjunto de constantes de enteros [-128~127], pero todos los objetos de enteros en este rango no crearán nuevos objetos y se obtendrán directamente de este conjunto de constantes de enteros. Mejora en gran medida el rendimiento del sistema.
Grupo de conexiones de la base de datos (Cree N objetos de conexión por adelantado, coloque los objetos de conexión en la colección y tómelos directamente de la caché cuando use los objetos de conexión. Se omite el proceso de creación de objetos de conexión. Se mejora la eficiencia).
Grupo de subprocesos (el servidor Tomcat admite subprocesos múltiples. El llamado grupo de subprocesos es para crear N objetos de subprocesos por adelantado, almacenar los objetos de subprocesos en la colección y luego obtener los objetos de subprocesos directamente del grupo de subprocesos después de que el usuario lo solicite, y tomar directamente Para usar Mejorar el rendimiento del sistema)
Más adelante aprenderá más tecnologías de almacenamiento en caché, como: redis, mongoDB...
(2) Hay tres métodos para operar dominios en ServletContext:
void setAttribute(String name, Object obj); // 向域当中绑定数据。 Object getAttribute(String name); // 从域当中根据name获取数据。 void removeAttribute(String name); // 将域当中绑定的数据移除 // 以上的操作类似于Map集合的操作。 Map<String, Object> map; map.put("name", obj); // 向map集合中放key和value Object obj = map.get("name"); // 通过map集合的key获取value map.remove("name"); // 通过Map集合的key删除key和value这个键值对。
(3) Objeto "Solicitar dominio"
R. El objeto "dominio de solicitud" es mucho más pequeño que el objeto "dominio de aplicación". El ciclo de vida es mucho más corto. El campo de solicitud solo es válido dentro de una solicitud.
b.Una solicitud de objeto de solicitud corresponde a un objeto de solicitud de dominio. Una vez que finaliza una solicitud, el campo de solicitud se destruye.
C. El objeto de dominio de solicitud también tiene estos tres métodos:
void setAttribute(String name, Object obj); // 向域当中绑定数据。 Object getAttribute(String name); // 从域当中根据name获取数据。 void removeAttribute(String name); // 将域当中绑定的数据移除D. ¿Cuál es el principio de selección del dominio de solicitud y el dominio de aplicación?
Intente usar objetos de dominio pequeño, porque los objetos de dominio pequeño ocupan menos recursos
(4) Saltar
a. Reenviar (una solicitud)
// 第一步：获取请求转发器对象 RequestDispatcher dispatcher = request.getRequestDispatcher("/b"); // 第二步：调用转发器的forward方法完成跳转/转发 dispatcher.forward(request,response); // 第一步和第二步代码可以联合在一起。 request.getRequestDispatcher("/b").forward(request,response);b.¿Cómo comparten datos dos servlets?
Por supuesto, es posible colocar datos en el dominio de la aplicación ServletContext, pero el alcance del dominio de la aplicación es demasiado grande y consume demasiados recursos. No recomendado para su uso.
Puede colocar los datos en el campo de solicitud y luego AServlet los reenvía a BServlet para garantizar que AServlet y BServlet estén en la misma solicitud, de modo que dos Servlets o varios Servlets puedan compartir los mismos datos.
c. ¿El siguiente recurso que se reenvía debe ser un Servlet?
No necesariamente, siempre que sea un recurso legal en el servidor Tomcat, se puede reenviar. Por ejemplo: html....
Nota: Al reenviar, preste atención a la escritura de la ruta. La ruta de reenvío comienza con "/" sin agregar el nombre del proyecto.
D. Acerca de dos métodos muy confusos en el objeto de solicitud:
// uri?username=zhangsan&userpwd=123&sex=1 String username = request.getParameter("username"); // 之前一定是执行过：request.setAttribute("name", new Object()) Object obj = request.getAttribute("name"); // 以上两个方法的区别是什么？ // 第一个方法：获取的是用户在浏览器上提交的数据。 // 第二个方法：获取的是请求域当中绑定的数据。
(5) Otros métodos comunes de la interfaz HttpServletRequest:
// 获取客户端的IP地址 String remoteAddr = request.getRemoteAddr(); // get请求在请求行上提交数据。 // post请求在请求体中提交数据。 // 设置请求体的字符集。（显然这个方法是处理POST请求的乱码问题。这种方式并不能解决get请求的乱码问题。） // Tomcat10之后，request请求体当中的字符集默认就是UTF-8，不需要设置字符集，不会出现乱码问题。 // Tomcat9前（包括9在内），如果前端请求体提交的是中文，后端获取之后出现乱码，怎么解决这个乱码？执行以下代码。 request.setCharacterEncoding("UTF-8"); // 在Tomcat9之前（包括9），响应中文也是有乱码的，怎么解决这个响应的乱码？ response.setContentType("text/html;charset=UTF-8"); // 在Tomcat10之后，包括10在内，响应中文的时候就不在出现乱码问题了。以上代码就不需要设置UTF-8了。 // 注意一个细节 // 在Tomcat10包括10在内之后的版本，中文将不再出现乱码。（这也体现了中文地位的提升。） // get请求乱码问题怎么解决？ // get请求发送的时候，数据是在请求行上提交的，不是在请求体当中提交的。 // get请求乱码怎么解决 // 方案：修改CATALINA_HOME/conf/server.xml配置文件 <Connector URIEncoding="UTF-8" /> // 注意：从Tomcat8之后，URIEncoding的默认值就是UTF-8，所以GET请求也没有乱码问题了。 // 获取应用的根路径 String contextPath = request.getContextPath(); // 获取请求方式 String method = request.getMethod(); // 获取请求的URI String uri = request.getRequestURI(); // /servlet04/testRequest // 获取请求的URL StringBuffer requestURL = request.getRequestURL(); // /http://localhost:8080/servlet04/testRequest // 获取servlet path String servletPath = request.getServletPath(); // /testRequest