Hola bienvenidos a esta elección.
A continuación vamos a revisar el tema de manejo de cabeceros utilizando el lápiz de los cables están
listos.
Vamos bien lo primero que vamos a hacer es cerrar este proyecto y derecho Clowes posteriormente vamos
a crear nuestro nuevo proyecto.
En fin mi proyecto ya va huid maybe Web Application y el nombre del proyecto se va a llamar manejo cabeceros
lo depositamos en la ruta de cursos diagonal servlets.
Posteriormente el grupo Heydi MX con G.M. globalmente con la versión 1.0 y el nombre del paquete lo
vamos a dejar vacío.
Damos clic en Siguiente dejamos los valores por default y damos siguen finalizar
bien vamos a los packages.
Si no se agregó este código vamos a eliminarlo ya que no lo vamos a necesitar y posteriormente lo que
vamos a hacer es modificar nuestro archivo de Index.
Vamos a entrar en esta página y modificamos el título
El título va a ser ejemplo cabeceros y también modificamos el H1
también se va a llamar ejemplo cabeceros y agregamos un link para hacer la llamada del lado del servidor
agregamos el HR-V
debe de ser el nombre del proyecto Manejo cabeceros y posteriormente el nombre del componente.
En este caso del servlet que a continuación lo vamos a configurar y vamos a agregar el texto
Link al servlet Gers.
Eso es todo lo que va a tener nuestro archivo índex punto HTML.
Ahora vamos a cambiar el nombre de este proyecto vamos a dar clic derecho reanime los renombrando si
damos siguen ok ahora vamos a negar nuestro componente de Servlet damos clic derecho new Java class
el nombre de componentes se va a llamar servlet y lo depositamos en el paquete web.
Damos fuguen en finalizar quitamos estos comentarios si lo deseamos y vamos a configurar nuestra clase
que es un Servlet agregamos la anotación de web servlet y especificamos el PATH
según hemos indicado dentro del documento HTML debe de llamarse exactamente igual servlet Gers bien
con eso estamos comprobando que se llame igual.
Importamos esta notación y para que sea un Servlet debe de extender la clase HTTPS.
Importamos esta clase y ahora vamos a definir el método que va a procesar esta petición que va a ser
el método Duguech es protected de tipo Veidt y se llama Duguech recibimos el objeto HTTP Server request
y también el objeto Cerberus Response importamos estas clases y debido a que van a ser varias claves
de este mismo paquete ponemos punto asterisco y ahora vamos a agregar la respuesta.
El tipo de respuesta con el método shed contentarme
y agregamos la cadena text html Punto y Coma Char C.T TDF y un medio 8.
Esto es lo mismo que ya hemos trabajado en elecciones anteriores y posteriormente declaramos nuestro
objeto de tipo print Reiter la variable llamada ATT y por medio del objeto respondés solicitamos el
método de Widder importamos esta clase y también reportamos esta posible excepción.
Bien ahora vamos a procesar los cabeceros relacionados con la información de esta petición.
Declaramos una variable llamada método HTTP y por medio de la variable recuesto solicitamos el tipo
de método HTTP que se está ejecutando en esta petición vamos a imprimir este valor.
Para empezar a imprimir vamos a crear nuestro documento HTML abrimos nuestro documento
agregamos el Get
posteriormente agregamos un título
llamado Geddes HTTP y cerramos el tag de teito
posteriormente cerramos en su tag de Get
y ahora abrimos el tag de Body
y vamos a agregar el título H1 Gers HTTP
y ahora si vamos a agregar el tipo de método
método HTTP que estamos recibiendo.
Vamos a ver cuál es el método que está realizando esta petición.
Imprimimos la variable método HTTP
posteriormente cerramos el Bodin punto y coma y finalmente cerramos el documento HTML
y cerramos nuestro objeto el primero Leiter de cualquier manera si no cerramos este objeto al terminar
de ejecutarse este método Duguech se va a cerrar también este objeto.
Pero es buena práctica agregarlo al final cerrar este objeto de tipo print Reiter bien vamos a guardar
cambios.
Debemos asegurarnos que esté detenido.
De lo contrario lo detenemos en este caso está encendido.
Damos clic derecho stop y una vez que se ha detenido podemos observar que en este momento ya no se está
ejecutando así que ahora hacemos clic en Videos de nuestro proyecto
y ejecutamos el proyecto click derecho y esperamos a que termine de levantarse las
y ya tenemos nuestro documento en el título ejemplo cabeceros el jet ejemplo cabeceros y la llamada
al componente del servlet vamos a dar clic y podemos ver que ya no está regresando la respuesta Geddes
http: pero vamos a revisar ya que algo está mal.
Aquí me faltó cerrar el título
H1 y posteriormente agregar un salto de línea
agregamos un elemento verde para que este método HTTP se imprima en la siguiente línea.
Guardamos cambios refrescamos y podemos observar ya hasta el título Geddes HTTP y el método que se está
ejecutando de tipo HTTP.
Es el método guetto debido a que estamos haciendo la llamada al componente del lado del cliente utilizando
un link.
Así que los links hacen una petición hacia el servidor de tipo gheto así que el método HTTP que está
ejecutando es una petición de tipo Guetto.
Ese es el primer cabeceros que estamos imprimiendo pero vamos a ver otros tipos de cabeceros así que
antes de cerrar el bodhi vamos a hacer lo siguiente Vamos a agregar ahora la URI que se está utilizando
así que definimos una variable llamada hurry y lo que vamos a hacer es por medio de nuestro objeto Ricketts
mandamos a llamar el método GET recuesto hurry
tomamos el verde y también la línea de la impresión del método.
Pero ahora vamos a imprimir la Uri
Uri solicitada y mandamos a imprimir la variable Uri.
Guardamos cambios esto en automático está haciendo un diploide nuestra aplicación así que cualquier
cambio en cuanto guardemos el documento se van a reflejar los cambios en su servidor y también por lo
tanto la respuesta que se va a enviar hacia el cliente refrescamos y podemos observar estos cambios.
Sin embargo esto es debido a que son componentes relativamente simples todavía pero si nuestra aplicación
crece en tamaño o el tipo de componentes que se está utilizando suele ser más complejo.
Entonces lo recomendable es detener la aplicación volver a hacer un clic cambio y volver a levantar
el servidor ejecutando nuevamente nuestra aplicación ya que cambios mayores podrían no verse reflejados
de manera automática.
Pero en este caso como son cambios simples entonces podría ser que así se reflejen de manera automática.
Así que podemos observar la URI solicitada es diagonal manejo cabeceros diagonal servlet Gers así que
es otro tipo de cabecera que podemos observar.
Recordemos que todos son cabeceros de tipo HTTP
y ahora vamos a imprimir todos los cabeceros que tenemos disponibles en esta petición así que vamos
a hacer lo siguiente imprimimos
todos los cabeceros disponibles vamos a cerrar este tabulador para tener espacio y lo que vamos a hacer
es definir una variable llamada enumeración el número Audition se va a llamar cabeceros y por medio
de la variable recuesto vamos a mandar a llamar.
El método G.G.A. de Arnheim y eso nos va a regresar todos los cabeceros que tenemos disponibles en esta
petición HTTP.
Importamos esta clase de IAVA punto y útil y posteriormente vamos a utilizar un ciclo CUIL para iterar
cada uno de estos elementos así que utilizamos nuestra variable cabeceros
y utilizamos el método Ashmore elements para saber si tenemos más elementos que iterar y en dado caso
de que tengamos elementos iterar lo vamos a ir asignando a esta variable.
Nombre cabeceros
y por medio de la enumeración cabeceros solicitamos el siguiente elemento así que eso nos va a regresar
el nombre del cabeceros que se está procesando en este momento pero como es de tipo Object si ponemos
punto al final de la llamada a este método podemos observar que el tipo que está regresando es un tipo
obvie.
Por lo tanto no podemos asignar directamente un tipo Object a una variable de tipo string así que vamos
a hacer un caso que nos recomienda en este caso el IDE hacemos un cast para convertirlo de obvie a tipo
String.
Y ahora vamos a imprimir cada uno de estos cabeceros que estamos alterando ponemos en negritas el nombre
de este cabecero
para que haga una diferencia con el valor de este cabecero
y cerramos también la fuente de tipo Bold fuente en negritas
y posteriormente lo que vamos a hacer es imprimir cada uno de los valores del cabecero así que ponemos
recuesto punto Guez Jeter y posteriormente proporcionamos el nombre del cabecero
así que por medio del método Gettier y proporcionando el nombre del cabecero es que vamos a poder obtener
el valor del cabecero que estamos proporcionando y finalmente imprimimos un salto de línea
un B.R. antes de empezar a imprimir.
También vamos a imprimir otro B.R para que no se junten las líneas que ya hemos impreso hasta el momento
agregamos dos Berres para que podamos observar cada uno de los cabeceros que se está procesando bien
guardamos cambios y en automático se deben de cargar los cambios hacemos refresh y podemos llevar cada
uno de los cabeceros que tenemos disponibles en esta petición.
Podemos llevar el cabecero de Jost cuyo valor es local Jost 2 puntos 80 80.
Ese es el nombre del equipo local Jost y el nombre del puerto 80 80.
El tipo de conexión que se está utilizando con el valor de equipo Life caché control en este caso con
el valor de Max es igual a cero ya si tenemos todos estos cabeceros disponibles por ejemplo también
cabeceros de User Agent nos permite saber el tipo de navegador que estamos utilizando.
Posteriormente el cabecero de Accept nos indica el tipo de contenido que acepta este navegador referee
nos indica la URI que se está utilizando para realizar esta petición.
A este componente podemos ver que tenemos HTTP local Jost 80 80.
Posteriormente el nombre del proyecto pero ya no se incluye el nombre del componente así que se excluye
el generes únicamente la referencia padre.
Posteriormente el tipo de compresión que acepta el tipo de lenguaje que acepta y también el concepto
de kuki.
Esto lo vamos a ver posteriormente en el tema de manejo de sesiones.
Los valores que se nos muestran podrían ser distintos debido al sistema operativo y también al navegador
que se está utilizando.
Así que si no obtienen exactamente los mismos resultados no hay ningún problema simplemente estamos
revisando los tipos de cabeceros que estamos obteniendo en nuestra petición del lado del servidor bien
así que como conclusión en este ejercicio hemos puesto en práctica el manejo de cabeceros utilizando
el API de los servlets vimos cómo procesar los cabeceros HTTP y dependiendo de la situación que se nos
presente nos pueden ser útiles para tomar ciertas decisiones según el cabecero que estemos procesando
o que necesitemos todo por esta elección y nos vemos en el siguiente vídeo.
Saludos.