Tabla de contenido
| Ciclo de vida del objeto de solicitud y del objeto de respuesta
| Llamadas mutuas entre Servlets
Resumen básico de llamadas Servlet
Solicitud de reenvío de llamadas de servlet
| Intercambio de datos entre Servlets
Descripción general básica del uso compartido de datos de Servlet
Intercambio de datos de la interfaz ServletContext
Intercambio de datos de clase de cookies
Uso compartido de datos de la interfaz HttpSession
Intercambio de datos de la interfaz HttpServletRequest
| Ciclo de vida del objeto de solicitud y del objeto de respuesta
1. Después de que el servidor HTTP recibe el [Paquete de protocolo de solicitud HTTP] enviado por el navegador, genera automáticamente un [Objeto de solicitud] y un [Objeto de respuesta] para el [Paquete de protocolo de solicitud HTTP] actual.
2. Cuando el servidor Http llama al método doGet/doPost, es responsable de pasar [objeto de solicitud] y [objeto de respuesta] como parámetros reales al método para garantizar que doGet/doPost se ejecute correctamente.
3. Antes de que el servidor Http se prepare para enviar el paquete del protocolo de respuesta Http, es responsable de destruir el [Objeto de solicitud] y el [Objeto de respuesta] asociados con esta solicitud.
4. El ciclo de vida de [Objeto de solicitud] y [Objeto de respuesta] se ejecuta a través del procesamiento de una solicitud
5. Hablando visualmente: [Objeto de solicitud] y [Objeto de respuesta] son equivalentes al portavoz del usuario en el lado del servidor
| Llamadas mutuas entre Servlets
Resumen básico de llamadas Servlet
-
Algunas solicitudes del navegador a menudo requieren el procesamiento coordinado de múltiples Servlets en el lado del servidor.
-
El propósito fundamental de llamar entre múltiples Servlets es mejorar la experiencia del usuario.Reglas: No importa cuántos Servlets estén involucrados en esta solicitud, el usuario solo necesita notificar [manualmente] al navegador para iniciar una solicitud.
-
Reglas de llamada entre múltiples Servlets: solución de redirección, solución de reenvío de solicitudes
Redirigir llamadas de Servlet
principio
-
Por primera vez, el usuario notifica al navegador para acceder a OneServlet a través de [método manual].Después de que OneServlet termine de funcionar, escriba la dirección de TwoServlet en el atributo de ubicación del encabezado de respuesta.
Escriba el código de estado 302 en la línea de estado. Después de que el navegador verifica el estado 302, busca la ubicación en el encabezado de respuesta y luego inicia automáticamente una segunda solicitud al servidor inmediatamente.
-
Es decir: el navegador envía al menos dos solicitudes, pero el usuario solo envía manualmente la primera solicitud, y el navegador envía automáticamente las solicitudes posteriores
-
En la solución de redirección, se notifica al navegador que inicie la siguiente solicitud a través de la barra de direcciones, por lo que el método de solicitud recibido por el archivo de recursos invocado a través de la solución de redirección debe ser [GET]
-
Desventajas: La solución de redirección requiere múltiples viajes de ida y vuelta entre el navegador y el servidor, lo que consume mucho tiempo en la cantidad de viajes de ida y vuelta y aumenta el tiempo de espera del usuario por el servicio.
gramática
response.sendRedirect("请求地址"); //将地址写入到响应包中响应头中location属性-
La dirección de solicitud puede ser: la URL del sitio web externo/el alias del objeto de clase de implementación de Servlet dentro del servidor (es decir, recursos dinámicos)/los recursos estáticos internos
-
Si es un recurso interno, la composición de la URL es: /nombre del sitio/alias correspondiente al objeto Servlet
ejemplo
<html>
<head>
<title>$Title$</title>
</head>
<body>
<form action="/web4/s1" method="post">
<input type="submit" value="重定向">
</form>
</body>
</html> 
(Los códigos de Servlet1 y Servlet2 son exactamente iguales, pero los números son diferentes. Aquí solo se muestra el código de Servlet1)
public class Servlet1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//...
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("text/html;charset=utf-8"); //设置content-Type中的字符规则为UTF-8，以保证显示到网页为中文
PrintWriter out = resp.getWriter(); //获取输出流
//提示S1的 POST被调用
System.out.println("Servlet1 POST 被调用");
//重定向到S2
System.out.println("重定向到 /web4/s2");
resp.sendRedirect("/web4/s2");
}
} 
public class Servlet2 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("text/html;charset=utf-8"); //设置content-Type中的字符规则为UTF-8，以保证显示到网页为中文
PrintWriter out = resp.getWriter(); //获取输出流
//提示S2的 GET被调用
System.out.println("Servlet2 GET被调用");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//...
}
} 
<?xml version="1.0" encoding="UTF-8"?>
<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_4_0.xsd"
version="4.0">
<!--Servlet1实现类 注册-->
<servlet>
<servlet-name>servlet1</servlet-name>
<servlet-class>Servlet1</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>servlet1</servlet-name>
<url-pattern>/s1</url-pattern>
</servlet-mapping>
<!--Servlet2实现类 注册-->
<servlet>
<servlet-name>servlet2</servlet-name>
<servlet-class>Servlet2</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>servlet2</servlet-name>
<url-pattern>/s2</url-pattern>
</servlet-mapping>
</web-app> 
Conclusión: Las solicitudes iniciadas automáticamente por redirección son todas de tipo GET~
Solicitud de reenvío de llamadas de servlet
principio
-
La primera vez que el usuario solicita manualmente el navegador para acceder a OneServlet. Una vez que se completa el trabajo de OneServlet, se usa el objeto de solicitud actual en lugar del navegador para enviar una solicitud a Tomcat para solicitar llamar a TwoServlet.
Después de que Tomcat recibe esta solicitud, ingresa automáticamente a TwoServlet para completar las tareas restantes
-
En la solución de reenvío de solicitudes, el navegador solo envía un paquete de protocolo de solicitud Http. Todos los Servlets que participan en esta solicitud comparten el mismo paquete de protocolo de solicitud, por lo que el método de solicitud recibido por estos Servlets es coherente con el método de solicitud enviado por el navegador.
-
Número de solicitudes: durante el proceso de reenvío de solicitudes, el navegador solo envía una solicitud (sin importar cuántos Servlets estén involucrados en esta solicitud, el usuario solo necesita enviar manualmente una solicitud a través del navegador)
-
Ventajas: La llamada entre Servlets ocurre en la computadora del servidor, ahorrando el número de viajes de ida y vuelta entre el servidor y el navegador y aumentando la velocidad de procesamiento
gramática
RequestDispatcher report = request.getRequestDispatcher("/资源文件名"); //通过当前请求对象生成资源文件申请报告对象
report.forward(当前请求对象，当前响应对象); //将报告对象发送给Tomcat-
El reenvío de solicitudes es una programación interna de Tomcat, y Tomcat solo tiene poder de programación para los recursos dentro del sitio web actual, por lo que los nombres de los archivos de recursos solo pueden ser recursos estáticos/dinámicos dentro del servidor.
-
Preste atención a los detalles al escribir los nombres de los archivos de recursos:
-
Dado que Tomcat lo llama internamente, todos están en el mismo sitio web implementado, por lo que el nombre del archivo de recursos [no es necesario escribir el alias de implementación del sitio web]! [Escriba directamente el nombre estático/del recurso al que se debe acceder]. No omita la barra inclinada antes del nombre: /
-
Si escribe el nombre del sitio web, causará dos nombres de sitios web en la URL, error 404
-
ejemplo
-
El archivo de configuración de web.xml es coherente con "Redirección de llamada de servlet" en esta sección, por lo que no se mostrará aquí.
<html>
<head>
<title>$Title$</title>
</head>
<body>
<form action="/web4/s1" method="post">
<input type="submit" value="重定向">
</form>
<form action="/web4/s2" method="get">
<input type="submit" value="请求转发">
</form>
</body>
</html> 
public class Servlet1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("text/html;charset=utf-8"); //设置content-Type中的字符规则为UTF-8，以保证显示到网页为中文
PrintWriter out = resp.getWriter(); //获取输出流
//提示S1的 GET被调用
System.out.println("Servlet1 GET 被调用");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//...
}
} 
public class Servlet2 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("text/html;charset=utf-8"); //设置content-Type中的字符规则为UTF-8，以保证显示到网页为中文
PrintWriter out = resp.getWriter(); //获取输出流
//提示S2的 GET被调用
System.out.println("Servlet2 GET被调用");
//请求转发到S1
System.out.println("请求转发到 /web4/s1");
//重定向中的URL无需写部署在Tomcat的网站名（因为本来就是内部调用了），只需要写资源名即可
RequestDispatcher report = req.getRequestDispatcher("/s1"); //通过当前请求对象生成资源文件申请报告对象
//RequestDispatcher report = req.getRequestDispatcher("/web4/s1"); //错误写法！不需要写网站部署名web4
report.forward(req,resp); //将报告对象发送给Tomcat
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//...
}
} 
en conclusión:
El método de solicitud de otros Servlets invocados por el reenvío de solicitudes es GET (porque comparten un objeto de solicitud y respuesta)
La URL para solicitar el reenvío solo necesita escribir el nombre del recurso (debido a que está en el mismo sitio web, Tomcat escribe el alias de implementación del sitio web en la URL de forma predeterminada)
| Intercambio de datos entre Servlets
Descripción general básica del uso compartido de datos de Servlet
-
Qué es el intercambio de datos: una vez que se completa el trabajo de OneServlet, los datos generados se entregarán a TwoServlet para su uso
-
Cuatro esquemas de intercambio de datos:
-
Interfaz ServletContext [objeto de alcance global]
-
clase de galleta
-
Interfaz HttpSession [objeto de ámbito de sesión]
-
Interfaz HttpServletRequest [objeto de ámbito de solicitud]
-
Intercambio de datos de la interfaz ServletContext
introducción básica
-
ServletContext es una interfaz de la especificación Servlet, y su clase de implementación la proporciona el servidor Http
-
El objeto de la clase de implementación ServletContext se llama [objeto de alcance global]
-
Si varios Servlets pertenecen al mismo sitio web, puede usar este método para compartir datos de Servlet
Principio Descripción
-
Cada sitio web tiene un objeto de alcance global, que es compartido por todos los servlets del sitio web.
Por ejemplo: OneServlet puede almacenar datos en el objeto de alcance global, y otros Servlets en el sitio web actual pueden obtener estos datos del objeto de alcance global en este momento para su uso
Ciclo de vida del objeto de alcance global
-
Durante el inicio de Tomcat, se crea automáticamente un objeto de alcance global en la memoria para el sitio web actual
-
Durante la ejecución de Tomcat, un sitio web tiene solo un objeto de alcance global
-
Durante la ejecución de Tomcat, el objeto de alcance global siempre está vivo (el ciclo de vida del objeto de alcance global se ejecuta durante todo el período de ejecución del sitio web)
-
Cuando Tomcat está a punto de cerrarse, es responsable de destruir los objetos de alcance global en el sitio web actual.
gramática
-
K es cadena, V es objeto
//通过【请求对象】向Tomcat索要当前网站中【全局作用域对象】
ServletContext application = request.getServletContext();
//将数据添加到全局作用域对象作为【共享数据】
application.setAttribute("key1",数据);
//从全局作用域对象获取之前添加的共享数据【注意一下数据类型默认是Object，需要转换】
Object 数据 = application.getAttribute("key1");ejemplo
<html>
<head>
<title>$Title$</title>
</head>
<body>
<form action="/web5/S1" method="get">
<input type="text" name="v1">
<input type="submit" value="发送数据v1到S1">
</form>
</body>
</html> 
<?xml version="1.0" encoding="UTF-8"?>
<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_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>S1</servlet-name>
<servlet-class>S1</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>S1</servlet-name>
<url-pattern>/S1</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>S2</servlet-name>
<servlet-class>S2</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>S2</servlet-name>
<url-pattern>/S2</url-pattern>
</servlet-mapping>
</web-app> 
public class S1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String v1 = (String)req.getParameter("v1");
System.out.println("收到了来自index的参数 v1 = " + v1);
/*【把数据存入ServletContext】*/
ServletContext application = req.getServletContext(); //通过【请求对象】向Tomcat索要当前网站中【全局作用域对象】
application.setAttribute("key1",v1); //将数据添加到全局作用域对象作为【共享数据】
System.out.println("S1的数据成功存入全局作用域对象");
/*【请求转发跳转到S2】*/
System.out.println("正在从S1跳转到S2");
System.out.println("=========================================================");
RequestDispatcher report = req.getRequestDispatcher("/S2");
report.forward(req,resp);
}
}
public class S2 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("跳转到了S2");
//从全局作用域对象拿到S1存入的值
ServletContext application = req.getServletContext();
String v2Fromv1 = (String)application.getAttribute("key1");
System.out.println("S2拿到了从S1存入的数据： v2Fromv1 = " + v2Fromv1);
}
}Intercambio de datos de clase de cookies
introducción básica
-
Proviene de una clase de herramienta en la especificación Servlet, que existe en servlet-api.jar proporcionado por Tomcat
-
Si dos servlets provienen del mismo sitio web y brindan servicios para el mismo navegador/usuario , se recomienda utilizar el objeto Cookie para compartir datos.
Principio Descripción
-
El usuario envía una solicitud al sitio web MyWeb a través del navegador para solicitar OneServlet por primera vez, y OneServlet crea una cookie durante la operación para almacenar datos relacionados con el usuario actual.
Una vez que se completa el trabajo de OneServlet, [Cookie se escribe en el encabezado de respuesta] y se devuelve al navegador actual.Después de que el navegador recibe el paquete de respuesta, almacena la cookie en el caché del navegador.
Después de un período de tiempo, cuando el usuario envía una solicitud a [sitio web myWeb] para solicitar TwoServlet nuevamente a través de [el mismo navegador],
El navegador [escribirá incondicionalmente la cookie enviada previamente por el sitio web myWeb en el encabezado de la solicitud] y la enviará
En este momento, cuando se está ejecutando TwoServlet, puede obtener los datos compartidos proporcionados por OneServlet leyendo la información en la cookie en el encabezado de la solicitud.
ciclo vital
-
De forma predeterminada, el objeto Cookie se almacena en la memoria caché del navegador. Entonces, mientras el navegador esté cerrado, el objeto Cookie se destruirá
-
En el caso de configuraciones manuales, se puede requerir que el navegador almacene la Cookie recibida en el disco duro de la computadora del cliente y, al mismo tiempo, es necesario especificar el tiempo de supervivencia de la Cookie en el disco duro.
Dentro del rango de tiempo de supervivencia, cerrar el navegador, cerrar la computadora del cliente y cerrar el servidor no hará que se destruya la cookie.
Cuando se alcanza el tiempo de vida, la cookie se elimina automáticamente del disco duro
cookie.setMaxAge(60); //cookie在客户端硬盘存活时间（单位：秒） 在此期间用户即使关闭浏览器，也不会导致Cookie销毁gramática
-
Guardar datos: cree un objeto de cookie y guarde los datos compartidos (datos de usuario actuales) a través del método de construcción de cookies
-
Una cookie es equivalente a un mapa. Solo se puede almacenar un par clave-valor en una cookie
-
Tanto K como V solo pueden ser cadenas, y Key no puede ser chino, pero V puede ser chino
-
Cookie card = new Cookie("key1","V");
resp.addCookie(card); //将cookie写入到响应头，交给浏览器Obtenga datos de cookies en otros servlets: llame al objeto de solicitud para obtener la cookie devuelta por el navegador desde el encabezado de la solicitud
//1.调用请求对象从请求头得到浏览器返回的Cookie
Cookie cookieArray[] = request.getCookies();
//2.循环遍历数据得到每一个cookie的key 与 value
for(Cookie card:cookieArray){
String key = card.getName(); //读取key "key1"
String value = card.getValue(); //读取value "abc"
}ejemplo
La configuración de index y web.xml es la misma que la anterior, por lo que no se mostrará aquí.
public class S1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
Cookie card = new Cookie("key1","S1的值1");
Cookie card2 = new Cookie("key2","S1的值2");
Cookie card3 = new Cookie("key3","S1的值3");
resp.addCookie(card); //将cookie写入到响应头，交给浏览器
resp.addCookie(card2);
resp.addCookie(card3);
resp.sendRedirect("/web5/S2"); //将地址写入到响应包中响应头中location属性
}
} 
public class S2 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("跳转到了S2");
//1.调用请求对象从请求头得到浏览器返回的Cookie
Cookie cookieArray[] = req.getCookies();
//2.循环遍历数据得到每一个cookie的key 与 value
int i = 1;
for(Cookie card:cookieArray){
String key = card.getName(); //读取key "key1"
String value = card.getValue(); //读取value "abc"
System.out.println("数据" + i++ + ":" + key + " = " + value);
}
}
} 
Uso compartido de datos de la interfaz HttpSession
introducción básica
-
Desde la siguiente interfaz de la especificación Servlet. Existe en servlet-api.jar en Tomcat, y su clase de implementación la proporciona el servidor Http
-
Los desarrolladores están acostumbrados a referirse al objeto modificado de la interfaz HttpSession como [objeto de ámbito de sesión]
-
Si dos servlets provienen del mismo sitio web y brindan servicios para el mismo navegador/usuario , se recomienda usar el objeto HttpSession para compartir datos
Principio Descripción
-
La diferencia entre HttpSession y Cookie
-
[La ubicación de almacenamiento es diferente] Cookie: almacenada en la computadora del cliente (memoria del navegador/disco duro); HttpSession: almacenada en la memoria de la computadora del servidor
-
[Diferentes tipos de datos que se pueden almacenar] Cookie: K solo puede ser una cadena en inglés, V solo puede ser una cadena; HttpSession: la cadena de K puede contener chino y V puede almacenar cualquier tipo de objeto de datos compartidos
-
[Cantidad de datos] Un objeto Cookie solo puede almacenar un dato compartido; HttpSession usa una colección de mapas para almacenar datos compartidos, por lo que se puede almacenar cualquier cantidad de datos compartidos
-
-
HttpSession se almacena en la memoria del equipo servidor ¿Cómo sabe a qué usuario corresponden los diferentes objetos HttpSession?
-
HttpSession asocia usuarios con HttpSession a través de cookies
-
ciclo vital
-
Las cookies utilizadas cuando los usuarios se asocian con HttpSession solo se pueden almacenar en la memoria caché del navegador.
-
Cuando se cierra el navegador, significa que se corta la relación entre el usuario y su HttpSession
-
Dado que Tomcat no puede detectar cuándo se cierra el navegador, no hará que Tomcat destruya la HttpSession asociada con el navegador cuando se cierre el navegador.
Para resolver este problema, Tomcat establece [tiempo de inactividad] para cada objeto HttpSession y el tiempo de inactividad es de 30 minutos de forma predeterminada.
Si el objeto HttpSession actual está inactivo durante 30 minutos, Tomcat cree que el usuario ha abandonado su HttpSession y Tomcat destruirá la HttpSession.
-
Modifique manualmente el tiempo de inactividad de HttpSession:
Establecido en web.xml
<session-config><session-timeout>5</session-timeout></session-config>(unidad: minuto)
gramática
agregando datos
//1.调用请求对象向Tomcat索要当前用户在服务端的私人储物柜
HttpSession session = request.getSession(); //如果当前用户还没有session对象，则服务端创建一个新的
HttpSession session = request.getSession(false); //如果当前用户还没有session对象，则服务端不会创建新的，会返回一个null
//2.将数据添加到用户私人储物柜
session.setAttribute("key1",共享数据)recuperar datos
//1.调用请求对象向Tomcat索要当前用户在服务端的私人储物柜
HttpSession session = request.getSession();
HttpSession session = request.getSession(false); //如果当前用户还没有session对象，则服务端不会创建新的，会返回一个null
//2.从会话作用域对象得到OneServlet提供的共享数据
Object 共享数据 = session.getAttribute("key1");ejemplo
public class S1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1.调用请求对象向Tomcat索要当前用户在服务端的私人储物柜
HttpSession session = req.getSession(); //如果当前用户还没有session对象，则服务端创建一个新的
//2.将数据添加到用户私人储物柜
session.setAttribute("键1","值V1");
//转到Servlet1中
resp.sendRedirect("/web5/S2"); //将地址写入到响应包中响应头中location属性
}
} 
public class S2 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1.调用请求对象向Tomcat索要当前用户在服务端的私人储物柜
HttpSession session = req.getSession();
//2.从会话作用域对象得到OneServlet提供的共享数据
Object o1 = session.getAttribute("键1");
System.out.println(o1);
}
} 
Intercambio de datos de la interfaz HttpServletRequest
introducción básica
-
En el mismo sitio web, si se llama a dos servlets a través de [reenvío de solicitud] , comparten el mismo paquete de protocolo de solicitud entre sí.
Y un paquete de protocolo de solicitud corresponde a un solo objeto de solicitud, por lo que los servlets comparten el mismo objeto de solicitud,
En este punto, puede usar este objeto de solicitud para compartir datos entre los dos Servlets.
-
Cuando el objeto de solicitud implementa la función de intercambio de datos entre Servlets, el desarrollador se refiere al objeto de solicitud como [objeto de alcance de solicitud]
gramática
//将数据添加到【请求作用域对象】中attribute属性
req.setAttribute("key1",数据); //数据类型可以任意类型Object
//从当前请求对象得到OneServlet写入到共享数据【当前Servlet必须和之前的Servlet共用一个请求对象。即请求转发】
Object 数据 = req.getAttribute("key1");ejemplo
public class S1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setAttribute("键1","值V"); //数据类型可以任意类型Object
//请求转发
RequestDispatcher report = req.getRequestDispatcher("/S2"); //通过当前请求对象生成资源文件申请报告对象
report.forward(req,resp); //将报告对象发送给Tomcat
}
} 
public class S2 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("跳转到了S2");
Object o1 = req.getAttribute("键1");
System.out.println(o1);
}
} 