1. HttpServletRequest est une interface avec un nom complet : Jakarta.servlet.http.HttpServletRequest
2. L'interface HttpServletRequest est membre de la spécification Servlet.
3. L'interface parent de l'interface HttpServletRequest : ServletRequest
public interface HttpServletRequest extends ServletRequest {}4. Qui a écrit la classe d'implémentation de l'interface HttpServletRequest ? Qui a créé l'objet HttpServletRequest ?
(1) Test réussi : org.apache.catalina.connector.RequestFacad implémente l'interface HttpServletRequestji.
public class RequestFacade implements HttpServletRequest{}(2) Description du résultat du test : le serveur Tomcat (serveur Web, conteneur Web) implémente l'interface HttpServletRequest et montre également que le serveur Tomcat implémente la spécification Servlet. Pour nous, programmeurs Web Java, nous n'avons pas vraiment besoin de nous en soucier, nous n'avons qu'à programmer l'interface. Ce qui nous intéresse, ce sont les méthodes de l'interface HttpServletRequest et les fonctions que ces méthodes peuvent exécuter.
5. Quelles informations se trouvent dans l'objet HttpServletRequest ? Quelles informations sont emballées ?
(1) L'objet HttpServletRequest est créé par le serveur Tomcat. Les informations encapsulées dans cet objet scellent le protocole de requête HTTP.
(2) En fait, lorsque l'utilisateur envoie une requête, il suit le protocole HTTP et envoie le protocole de requête HTTP. Le serveur Tomcat analyse toutes les informations et données dans le protocole HTTP, puis le serveur Tomcat encapsule les informations dans le HttpServletRequest Transmettez-le à nous, programmeurs JavaWeb.
(3) programme de programmeurs Web Java pour l'interface HttpServletRequest, et les informations demandées peuvent être obtenues en appelant la méthode.
6. Quel est le cycle de vie des objets de requête et de réponse ?
(1) objets de demande et de réponse, l'un est l'objet de demande et l'autre est l'objet de réponse. Ces deux objets ne sont valides que dans la requête en cours.
(2) Une demande correspond à une demande
(3) Deux requêtes correspondent à deux requêtes
7. Quelles sont les méthodes couramment utilisées dans l'interface HttpServletRequest ?
(1) Comment obtenir les données soumises par l'utilisateur du navigateur frontal ?
Map<String,String[]> getParmeterMap() // 这个是获取Map Enumeration<String> getParameterNames() // 这个是获取Map集合中所有的key String[] getParameterValus(String name) // 根据key获取Map集合的value String getParamenter(String name) // 获取value这个一维数组当中的第一个元素，这个方法很常用
(2) Réflexion : Si c'est vous, une fois que le formulaire frontal a soumis les données, comment prévoyez-vous de stocker les données et quelle structure de données prévoyez-vous d'utiliser pour stocker les données ?
a. Le format de données soumis par le frontal : sername=abc&userpwd=111&aihao=s&aihao=d&aihao=tt
b. J'utiliserai la collection Map pour stocker :
L'idée de la clé Map<String,String>
stockant
la valeur String stockant la chaîne
est-elle correcte ? faux.
Si vous utilisez le stockage de structure de données ci-dessus, vous constaterez que la valeur est écrasée lorsque la clé est répétée.
valeur clé
---------------------
nom d'utilisateur abc
userpwd 111
aihao s
aihao d
aihao tt
Ce n'est pas possible, car la clé de la carte ne peut pas être répétée.
Map<String, String[]>
la clé stocke la valeur de la chaîne stocke la valeur de la clé
String[] ------------------------------- nom d'utilisateur {"abc"} userpwd {"111"} aihao {"s","d","tt"}
(3) Remarque : Lorsque le formulaire frontal soumet des données, on suppose qu'un "nombre" tel que 120 est soumis, mais il est en fait soumis sous la forme d'une chaîne "120", de sorte que le serveur doit obtenir une chaîne de "120" " au lieu d'un nombre. (Le frontal soumet toujours des chaînes et le back-end obtient toujours des chaînes.)
(4), pratiquer quatre méthodes courantes de demande
/**
* 总结一下，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) Résultats en cours d'exécution
8. L'objet de requête est en fait appelé "champ de requête".
(1) Qu'est-ce que l'objet de domaine d'application ?
a, ServletContext (objet de contexte de servlet)
b. Dans quelles circonstances envisageriez-vous de lier des données au domaine d'application ServletContext ?
Premièrement : des données partagées par tous les utilisateurs.
Deuxièmement : la quantité de données partagées.
Troisièmement : ces données partagées modifient rarement les opérations.Lorsque les trois conditions ci-dessus sont remplies, l'utilisation de cet objet de domaine d'application peut grandement améliorer l'efficacité de l'exécution de notre programme.
En fait, lier des données au domaine d'application équivaut à mettre les données dans le cache (Cache), puis à les extraire directement du cache lorsque l'utilisateur y accède, réduisant ainsi les opérations d'E/S et améliorant considérablement les performances du système, donc la mise en cache technologie est d'améliorer la mesure importante de la performance du système.
Quelles techniques de mise en cache avez-vous vues ?
pool de constantes de chaîne
Pool constant entier [-128~127], mais tous les objets Integer de cette plage ne créeront pas de nouveaux objets et seront directement obtenus à partir de ce pool constant entier. Améliorer considérablement les performances du système.
Pool de connexion à la base de données (créez N objets de connexion à l'avance, placez les objets de connexion dans la collection et récupérez-les directement du cache lors de l'utilisation des objets de connexion. Le processus de création d'objets de connexion est omis. L'efficacité est améliorée.)
Pool de threads (le serveur Tomcat prend en charge le multi-threading. Le soi-disant pool de threads consiste à créer N objets thread à l'avance, à stocker les objets thread dans la collection, puis à obtenir les objets thread directement à partir du pool de threads après les demandes de l'utilisateur, et prendre directement à utiliser. Améliorer les performances du système)
Plus tard, vous apprendrez plus de technologies de mise en cache, telles que : redis, mongoDB.....
(2) Il existe trois méthodes d'exploitation des domaines dans 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) Objet "Demander un domaine"
a. L'objet "domaine de demande" est beaucoup plus petit que l'objet "domaine d'application". Le cycle de vie est beaucoup plus court. Le champ de requête n'est valide que dans une seule requête.
b. Une requête d'objet de requête correspond à un objet de domaine de requête. Après la fin d'une requête, le champ de requête est détruit.
c. L'objet de domaine de requête a également ces trois méthodes :
void setAttribute(String name, Object obj); // 向域当中绑定数据。 Object getAttribute(String name); // 从域当中根据name获取数据。 void removeAttribute(String name); // 将域当中绑定的数据移除d. Quel est le principe de sélection du domaine de requête et du domaine d'application ?
Essayez d'utiliser de petits objets de domaine, car les petits objets de domaine occupent moins de ressources
(4) Sauter
a. Transférer (une demande)
// 第一步：获取请求转发器对象 RequestDispatcher dispatcher = request.getRequestDispatcher("/b"); // 第二步：调用转发器的forward方法完成跳转/转发 dispatcher.forward(request,response); // 第一步和第二步代码可以联合在一起。 request.getRequestDispatcher("/b").forward(request,response);b. Comment deux servlets partagent-ils des données ?
Il est bien sûr possible de mettre des données dans le domaine d'application ServletContext, mais la portée du domaine d'application est trop grande et consomme trop de ressources. Non recommandé pour l'utilisation.
Vous pouvez mettre les données dans le champ de requête, puis AServlet les transmet à BServlet pour vous assurer qu'AServlet et BServlet sont dans la même requête, afin que deux Servlets ou plusieurs Servlets puissent partager les mêmes données.
c. La prochaine ressource transmise doit-elle être une servlet ?
Pas nécessairement, tant qu'il s'agit d'une ressource légale sur le serveur Tomcat, elle peut être transmise. Par exemple : html....
Remarque : Lors de la redirection, faites attention à l'écriture du chemin. Le chemin de redirection commence par "/" sans ajouter le nom du projet.
d. À propos de deux méthodes très déroutantes dans l'objet de requête :
// uri?username=zhangsan&userpwd=123&sex=1 String username = request.getParameter("username"); // 之前一定是执行过：request.setAttribute("name", new Object()) Object obj = request.getAttribute("name"); // 以上两个方法的区别是什么？ // 第一个方法：获取的是用户在浏览器上提交的数据。 // 第二个方法：获取的是请求域当中绑定的数据。
(5) Autres méthodes courantes de l'interface 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