Página de inicio de sesión JSP real de JBuilder2005 (2)

Autor：Eve Cole Fecha de actualización：2009-07-02 17:10:51

A través de Archivo->Nuevo...->Web->haga doble clic en el icono JSP, aparecerá el cuadro de diálogo para crear un asistente JSP, como se muestra en la siguiente figura:

Figura 3 Crear login.jsp mediante el asistente

·Módulo web: si hay varios módulos web en un proyecto, puede especificar aquí el módulo web al que se agrega JSP. Debido a que solo hay un módulo web en nuestro proyecto, el asistente lo configurará como módulo web de forma predeterminada.

·Nombre: escriba el nombre del archivo JSP. Puede escribir el sufijo .jsp o puede escribir iniciar sesión directamente sin el sufijo.

Después de marcar la opción Generar bean de muestra, JBuilder generará un Bean de muestra y lo introducirá en el JSP. Para los principiantes, pueden usar esta opción para ver cómo JSP hace referencia a un Bean, y la opción Generar página de error creará automáticamente un archivo JSP de manejo de errores coincidente para JSP. Aquí, no los verificamos.

Haga clic en Finalizar directamente para crear login.jsp. El archivo login.jsp aparece en el compilador del panel de contenido, como se muestra en la siguiente figura:

Figura 4 Archivo JSP creado por el asistente

Hay uno en los lados izquierdo y derecho de la ventana de compilación JSP que se puede pasar

La barra vertical controlada por botones. La columna izquierda es un panel para colocar etiquetas JSP y etiquetas HTML. Puede arrastrar y soltar varias etiquetas en el archivo JSP como en el diseñador de interfaz de usuario visual. formulario del panel. Las etiquetas HTML se colocan en el archivo login.jsp.

La columna vertical de la derecha es el compilador de atributos de la etiqueta donde se encuentra el cursor actual en el archivo JSP, como se muestra en la siguiente figura:

Figura 5 Establecer editor de atributos de etiquetas JSP

El editor de propiedades es dinámico. Cuando el cursor se mueve a diferentes etiquetas, el editor de propiedades muestra todas las propiedades configurables de esta etiqueta. Como se muestra en la figura anterior, corresponde al editor de atributos de la etiqueta del formulario HTML. Configuramos su atributo de acción en switch.jsp y especificamos usar POST para enviar los datos de la solicitud.

Proporcionamos un cuadro desplegable de nombre de usuario, un cuadro de entrada de contraseña y un botón de envío de inicio de sesión en login.jsp. El código es el siguiente:

Listado de Código 4 login.jsp

1. ＜%@página contentType="text/html; charset=GBK" %＞
2. ＜html＞
3. ＜cabeza＞
4. ＜título＞iniciar sesión＜/título＞
5. ＜/cabeza＞
6. ＜cuerpo bgcolor="#ffffff"＞
7. ＜Nombre del formulario="Formulario 1" método="post" acción="switch.jsp"＞
8. Nombre de usuario: <seleccione nombre="userId">
9. ＜valor de opción="" seleccionado＞--Usuario de inicio de sesión--＜/opción＞
10. ＜valor de opción="100000"＞Jiang Ziya＜/opción＞
11. ＜valor de opción="100001"＞Bao Shuya＜/opción＞
12. ＜opción valor="100002"＞Dientes verticales＜/opción＞
13. ＜/seleccionar＞
14. Contraseña: <nombre de entrada="contraseña" tipo="contraseña">
15. ＜tipo de entrada="enviar" nombre="Enviar" valor="Iniciar sesión"＞
16. ＜/formulario＞
17. ＜/cuerpo＞
18. ＜/html＞

La etiqueta de formulario representa un formulario en una página web. El formulario puede contener varios componentes. Una vez enviado el formulario web, los datos de estos componentes se envían al archivo JSP especificado por el atributo de acción a través del protocolo HTTP para su procesamiento. Los datos del formulario generalmente se envían mediante POST. El método de envío POST no tiene límite en la cantidad de datos y es más confidencial.

La página de efectos de login.jsp se muestra a continuación:

Figura 6 página de entrada de login.jsp

Experiencia práctica:

El código del archivo JSP contiene partes estáticas y dinámicas, es decir, una parte es código HTML y la otra parte son etiquetas JSP y código Scriptlet. JSP es generalmente una página web con lógica dinámica. JBuilder admite muy bien partes de código dinámico, como etiquetas JSP y Scriptlets. Puede utilizar herramientas como CodeInsight y TagInsight para completar la codificación de forma rápida y correcta, y también puede compilar y depurar JSP. En términos de escritura de código HTML estático y diseño visual JSP, JBuilder parece ser inadecuado, obviamente, mejor que JBuilder en código estático y diseño visual.

La complejidad de las cosas promueve la división del trabajo, y la fina división del trabajo promueve el desarrollo profesional. Al escribir JSP, no es que una vez que tenga JBuilder no tendrá nada más que hacer. Han Xinshanbing y Xiao Heshanmou, si pueden combinar Dreamweaver y JBuilder, usar Dreamweaver para desarrollar la parte visual de JSP y usar JBuilder para desarrollar la parte de código dinámico de JSP, los dos se complementarán y complementarán entre sí, y el JSP El trabajo de desarrollo se simplificará.

Cambiar la lista de usuarios a dinámica

El login.jsp creado actualmente tiene un defecto. Se supone que al agregar otros usuarios a la tabla T_USER en el fondo de la base de datos, debido a que el cuadro desplegable de nombre de usuario es un código estático, el usuario recién creado no aparecerá en la página. es necesario agregar el usuario. La lista de nombres se cambia a código dinámico y los registros de la tabla de la base de datos T_USER se utilizan para generar dinámicamente los datos del cuadro desplegable.

Completamos este trabajo a través de la clase UserList.ava y creamos UserList.java en el proyecto. El código es el siguiente:

Listado de Código 5 UserList.java

1. librería de paquetes;
2. importar java.sql.*;
3.
4. Lista de usuarios de clase pública
5. {
6. //Obtener el código de la lista de usuarios del cuadro desplegable HTML
7. Cadena estática pública getUserListHTML() {
8. Conexión de conexión = nula;
9. StringBuffer sBuf = nuevo StringBuffer();
10. prueba {
11. conexión = DBConnection.getConnection();
12. Declaración preparada pStat = conn.prepareStatement (
13. "seleccione USER_ID,USER_NAME de T_USER");
14. Conjunto de resultados rs = pStat.executeQuery();
15. mientras (rs.siguiente()) {
16. sBuf.append("<valor de opción='" + rs.getString("USER_ID") + "'＞" +
17. rs.getString("NOMBRE_USUARIO") + "＜/opción＞n");
18. }
19. devolver sBuf.toString();
20. } captura (SQLException ex) {
21. ex.printStackTrace();
22. devolver "";
23. } finalmente {
24. prueba {
25. si (conexión! = nulo) {
26. conexión.cerrar();
27. conexión = nulo;
28. }
29. } captura (SQLException ex1) {
30. }
31. }
32. }
33. }

UserList.java solo proporciona un método estático getUserListHTML(), que obtiene registros de usuario de la tabla T_USER en la base de datos backend y genera el código de opción para el componente de selección HTML, como se muestra en las líneas 16 a 17.

Después de crear esta clase, nos referimos a esta clase para ajustar el código de login.jsp. Primero, hacemos referencia a la clase UserList a través del atributo de importación en la etiqueta de instrucción de la página y luego ajustamos el contenido en la opción de selección al valor devuelto por. método getUserListHTML(), como se muestra en la siguiente figura Mostrar:

Figura 7 Escritura de código a través de CodeInsight

Reemplace el código HTML estático original mediante etiquetas de expresión. Vale la pena mencionar que también puede usar CodeInsight para ingresar código en JSP como si estuviera escribiendo clases generales de Java. El código para el login.jsp ajustado es el siguiente, en negrita:

Listado de Código 6: Código login.jsp ajustado

1. ＜%@page contentType="text/html; charset=GBK" import="librería.UserList" %＞
2. ＜html＞
3. ＜cabeza＞
4. ＜título＞iniciar sesión＜/título＞
5. ＜/cabeza＞
6. ＜cuerpo bgcolor="#ffffff"＞
7. <Form name="Formulario 1" método="post" action="switch.jsp">Nombre de usuario:
8. ＜seleccione nombre="userId"＞
9. ＜valor de opción="" seleccionado＞--Usuario de inicio de sesión--＜/opción＞
10. ＜%=UserList.getUserListHTML()%＞
11. ＜/seleccionar＞
12. Contraseña: <nombre de entrada="contraseña" tipo="contraseña">
13. ＜tipo de entrada="enviar" nombre="Enviar" valor="Iniciar sesión"＞
14. ＜/formulario＞
15. ＜/cuerpo＞
16. ＜/html＞

Después de guardar login.jsp, haga clic derecho en la etiqueta del archivo login.jsp en el panel de contenido y seleccione Ejecutar web usando los valores predeterminados. JBuilder iniciará el servidor de aplicaciones Tomcat 5.0, lo ejecutará en el puerto 8080, compilará y ejecutará el archivo login.jsp. como se muestra en la siguiente figura Mostrar:

Figura 8 Ejecutando login.jsp en JBuilder

JBuilder cambia automáticamente a la página Vista web para mostrar el efecto de ejecución de la página. Sin embargo, el navegador de JBuilder tiene un soporte muy débil para páginas web y no admite scripts JavaScript. Por lo tanto, después de ejecutar login.jsp, es mejor ver el efecto de la página web a través de IE. Solo necesita abrir IE y copiar la dirección de acceso login.jsp en JBuilder a la barra de direcciones de IE, como se muestra en la figura. figura a continuación:

Figura 9 Utilice IE para acceder a login.jsp ejecutándose en JBuilder

En este momento, los usuarios en el cuadro desplegable del nombre de usuario ya están en la lista de usuarios dinámicos. Cuando se agregan o eliminan usuarios en la tabla T_USER, los usuarios en el cuadro desplegable también cambiarán en consecuencia.

Antes de ejecutar JSP, es mejor compilar este archivo JSP por separado: haga clic derecho en la etiqueta del archivo JSP en el panel de contenido y seleccione crear "xxx.jsp" en el menú emergente para completar la compilación del archivo JSP y descubrir a tiempo. Al editar archivos JSP y archivos Java, la mayor diferencia es que cualquier error en los archivos de programa Java se enumerará en el editor y en el panel de estructura, pero algunos errores en los archivos JSP deben compilarse para poder descubrirse.

pista:

Dado que compilar un archivo JSP requiere primero convertirlo en un archivo Servlet y luego compilar el archivo Servlet intermedio. Si ocurre un error, se redirigirá al archivo JSP. Por lo tanto, compilar un archivo JSP requiere más tiempo y, a menudo, requiere más tiempo. más que compilar un archivo Java Varias veces más. De forma predeterminada, al compilar un proyecto, se compilarán todos los JSP de todo el proyecto, lo que lleva mucho tiempo. Por lo tanto, es mejor cancelar la configuración de compilación de archivos JSP junto con el proyecto de compilación: a través de Proyecto->Propiedades del proyecto...->Construir-> cancele la opción Comprobar JSP en busca de errores en el momento de la compilación en la página de configuración de compilación. Marque esta opción cuando realmente la necesite y cancele esta opción inmediatamente después de la compilación. Esta configuración le permitirá ganar mucho tiempo valioso en el desarrollo.