Prefacio
SSH no es un marco, sino una integración de múltiples marcos (Struts+Spring+Hibernate). Actualmente es un popular marco de integración de código abierto para aplicaciones web, utilizadas para construir aplicaciones web múltiples flexibles y fáciles de escala.
El sistema que integra el marco SSH se divide en cuatro capas en términos de responsabilidad: capa de presentación, capa lógica de negocios, capa de persistencia de datos y capa de módulo de dominio (capa de entidad).
Como la infraestructura general del sistema, Struts es responsable de la separación de MVC. En la parte del modelo del marco Struts, controla los saltos comerciales y utiliza el marco Hibernate para proporcionar apoyo para la capa de persistencia. Por un lado, Spring es un contenedor de COI liviano, responsable de encontrar, posicionar, crear y administrar dependencias entre objetos y objetos, y por otro lado, puede hacer que los puntales y la hibernación funcionen mejor.
Use MyEClipse para integrar los tres principales marcos SSH e implementar una demostración que simula el registro del usuario, correspondiente a la versión:
Versión de Struts: 2.1;
Versión de primavera: 3.1;
Versión de hibernación: 3.3;
1. Preparación antes de la integración
1. Cree un proyecto web de la siguiente manera:
Nota: El nombre del paquete que admite la acción debe ser "acción", y la clase de acción debe terminar con la acción, es decir, la forma es como xxxaction, como se muestra en la figura anterior
2. Cree una base de datos y una tabla:
Crear base de datos sshdemo; Crear tabla T_USER (ID int Prime Key, UserName Varchar (10), contraseña Varchar (20))
3. Importe el paquete de la conexión de la base de datos C3P0JAR, haga clic para descargar:
C3P0-0.9.2-Pre1.Jar, MySQL-Connector-Java-5.1.13-Bin.Jar
2. Configuración del marco de Struts:
1. Seleccione el proyecto y haga clic con el botón derecho para seleccionar: MyEClipse -> Facets del proyecto [Capacidades] -> Instale la faceta Apache Struts (2.x), como sigue:
2. Seleccione la versión, aquí elegí 2.1, haga clic en "Finalizar", como sigue:
3. Después de completar los pasos anteriores, encontrará que hay un archivo Struts.xml adicional en el directorio SRC, con los siguientes contenidos:
<? xml versión = "1.0" encoding = "utf-8"?> <! DocType Struts public "-// Apache Software Foundation // Dtd Struts Configuración 2.1 // en" "http://struts.apache.org/dtds/struts-2.1.dtdd"> <truts> </struts>
4. En el archivo web.xml en el directorio web-INF, hay una sección adicional del código de configuración para filtros Struts, de la siguiente manera:
5. Consulte la figura anterior, modifique *.action a "/ *", y el marco de Struts está configurado en este punto;
3. Configuración del marco de Spring:
1. Consulte la configuración de los puntales, seleccione el proyecto, haga clic con el botón derecho y seleccione: MyEClipse -> Project Facets [Capacidades] -> Instale la faceta Spring, seleccione la versión y seleccione 3.1 de la siguiente manera:
2. Haga clic en "Finalizar" y encontrará que hay un archivo ApplicationContext.xml en el directorio SRC, un archivo Spring-Form.tld y Spring.Tld en el directorio web-INF, y se agrega una pieza relacionada con la configuración de Spring en el archivo web.xml. La construcción del marco de primavera se ha completado básicamente (la introducción del espacio de nombres se discutirá más adelante), como se muestra a continuación:
4. Configuración del marco Hibernate:
1. Consulte la configuración de los puntales, seleccione el proyecto, haga clic con el botón derecho y seleccione: MyEClipse -> Project Facets [Capacidades] -> Instale HibernateFacet, seleccione la versión y seleccione 3.3 aquí de la siguiente manera:
2. Haga clic en "Finalizar" y encontrará que hay un paquete predeterminado adicional en el directorio SRC (se puede eliminar) y un código en el archivo web.xml (se reconfigurará más adelante), como se muestra a continuación:
3. Importar paquetes JAR que admiten la anotación "@Entity": seleccione el proyecto, haga clic con el botón derecho para seleccionar: MyEClipse -> Project Facets [Capacidades] -> Administrar ... y luego siga los pasos de la siguiente figura:
Después de completar los pasos anteriores, los tres marcos principales se construyen básicamente, y luego están integrados.
5. Integración
1. Para evitar que ApplicationContext.xml se vea demasiado hinchado y fácil de administrar, guardamos la configuración relacionada con Hibernate en otro archivo .xml y luego lo importamos en ApplicationContext.xml. Los pasos específicos:
(1) Cree un archivo llamado HibernateContext.xml en el directorio SRC (mismo nivel que ApplicationContext.xml), copie los contenidos en ApplicationContext.xml y luego realice cambios;
(2) Contenido en el archivo hibernateContext.xml:
<? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: p = "http://www.springframework.org/schema/p" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/Beans/spring-beansd" <!-SessionFactory Configuration-> <bean id = "sessionFactory"> <!-La propiedad de DataSource se configurará en el archivo ApplicationContext.xml. Consulte esto aquí primero-> <Property Name = "DataSource" ref = "DataSource"> </property> <!-Establezca elementos de configuración relacionados con Hibernate-> <propiedad name = "HibernateProperties"> <!-La etiqueta de props es para inyectar propiedades de las propiedades de tipo-> <!-Key debe ser Hibernate.prefix-> <Props> <props es para inyectar propiedades de los tipos-> < key = "Hibernate.dialect"> org.hibernate.dialect.mysqldialect </prop> <!-show_sql es el propósito de imprimir declaraciones sql-> <prot key = "hibernate.show_sql"> true </prop> <!-Beakify el formato de impresión de sql-> <propiLET = "Hiberce.format_format <!-a) Crear-DROP: Crear una tabla de datos al ejecutar el programa y eliminar la tabla después de la ejecución. In actual development, it is often used for testing b) create: Recreate the data table every time the program is executed c) update: When executing the program, it will be judged that if there is, the table will not be created, otherwise the data table will be created, and the fields in the data table will be automatically added according to the increase of attributes in the entity class (development environment) d) validate: When executing the program, if the attributes in the entity class are Inconsistente con los campos en la tabla, se informará un error (entorno de producción)-> <prop key = "hibernate.hbm2ddl.auto"> validar </prop> </props> </property> <!-Configure la clase de entidad de Hibernate-> <Nombre de propiedad = "Packagestoscan"> <!-La etiqueta de la lista se usa para inyectar la propiedad de la cadena [] Tipo [] Tipo. Su valor generalmente es el nombre completo del paquete de frijoles correspondiente, y las clases en el paquete de frijoles generalmente corresponden a la tabla en la base de datos-> <list> <valor> com.beauxie.bean </value> </list> </property> </bean> <!-Configurar el hibernateMate Template-> <bean id = "HiBERNATETEMPLATE"> <Nombre de propiedad = "Session Factorory" " ref = "SessionFactory"> </Property> </le bean> </beans>
(3) Elimine la configuración de "SessionFactory" en ApplicationContext.xm (porque se ha configurado en HibernateContext.xml) y luego importe el contenido modificado de HibernateContext.xml. Después de importar, el contenido de ApplicationContext.xml es el siguiente:
<? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: p = "http://www.springframework.org/schema/p" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/Beans/spring-beansd" <bean id = "dataSource"> </ bean> <!- Importar otros archivos de configuración de Spring. Si se colocan en un archivo, se verán hinchados -> <importe resource = "hibernateContext.xml"/> </beans>
2. Basado en la fuente de datos original en el archivo ApplicationContext.xm, modifique su configuración (nombre de la base de datos, nombre de usuario, contraseña, etc.) ( Nota: ¡La etiqueta de valor no debe contener espacios o ingresar! ), Como se muestra a continuación:
<bean id = "dataSource"> <propiedad name = "jdbcurl"> <!-Si usa el atributo de valor directamente en lugar de la etiqueta de valor, debe escapar "&" y usar la etiqueta de valor. La etiqueta <span style = "color:#ff0000;"> no debe contener espacios o retorno de carro, porque convertirá los espacios en "" </span>, lo que resulta en que la base de datos no pueda conectarse a menos que la fuente de datos se reescriba-> <value> <! [CDATA [JDBC: mysql: // localhost: 3306/sshdemo? useUnicode = true & caracterSencoding = utf8 & UsuserverPrepstmts = t rue & prepstmtcachesqllimit = 256 & cacheprepstmts = true & prepstmtCachesize = 256 & RewritebatchedStatements = true]]> </valor> </property> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="user" value="root"></property> <property name="password" value="root"></property> <property name="acquireIncrement" value="3"></property> <property name="initialPoolSize" value="10"></property> <property name = "MinpoolSize" Value = "2"> </Property> <Property Name = "MaxpoolSize" Value = "10"> </property> </bean>
3. En ApplicationContext.xm, configure el escáner de resorte, para agregar anotaciones de componentes de resorte a nuestra clase, y el bean se puede cargar automáticamente. Los pasos específicos son los siguientes: (1) Introducir el espacio de nombres de contexto, admitir la etiqueta de contexto, hacer clic en "espacios de nombres" en la parte inferior y luego verificar el elemento de contexto:
(2) Configure el escáner de resorte:
<!-Configure el escáner Spring y agregue anotaciones de componentes de Spring a nuestra clase para cargar automáticamente los frijoles->
<context: componente-escan-scan-backage = "com.beauxie.action, com.beauxie.service, com.beauxie.dao">
</context: componente-scan>
En este punto, se han construido los tres entornos de marco SSH principales, y el siguiente paso es implementar el registro de usuarios basado en el marco SSH.
6. Caso: Imitación simple del registro del usuario
1. Código de página de registro de recepción, index.jsp:
<%@ página lenguaje = "java" import = "java.util.*" pageEncoding = "utf-8"%> <%string path = requit.getContextPath (); String basepath = request.getScheme () + ": //" + request.getServerName () + ":" + request.getServerPort () + ruta + "/"; %> <! Doctype html público "-// w3c // dtd html 4.01 transitional // en"> <html> <fead> <base href = "<%= basepath%>"> <title> Bienvenido a registrarse </title> <meta http-equiv = "pragma" contenido = "no cache" http-equiv = "cache-confontrol" content = "no-cache"> <meta http-equiv = "expires" content = "0"> <meta http-equiv = "palabras clave" content = "keyword1, weyword 2, keyword3"> <meta http-oquiv = "descripción" Content = "esto es mi página" << type = "text/css" href = "styles.css">-> </head> <body> <form de action = "$ {pageContext.request.contextpath}/user/regist" método = "post"> <! también puede usar el valor de usuario para cargar automáticamente el atributo de usuario, pero no es el punto aquí, puede obtener su valor en el fondo, también puede obtener el fondo de fondo: type = "text" name = "username"> <br> contraseña: <input type = "contraseña" name = "contraseña"> <br> <input type = "enviar" value = "Registration"> </form> </body> </html>2. Código de clase del usuario:
paquete com.beauxie.bean; import javax.persistence.entity; import javax.persistence.id; import javax.persistence.table; /** * @author beauxie * Aquí las propiedades del usuario deben ser las mismas que los campos en la tabla t_user, * de lo contrario, debe especificar manualmente los campos en la tabla correspondiente para diferentes propiedades */ @entidad // mapa de la tabla de bases de datos @table (name = "t_user") T_USER TABLE private int id; // ID de usuario String private String UserName; // UserName Private String Password; // Password public int getId () {return id; } public void setid (int id) {this.id = id; } public String getUsername () {return UserName; } public void setUsername (String UserName) {this.Username = username; } public String getPassword () {return Password; } public void setPassword (String Password) {this.password = contraseña; }} 3. Userdao Código de clase:
paquete com.beauxie.dao; importar org.springframework.beans.factory.annotation.aUtowired; importar org.springframework.orm.Hibernate3.HiberNateTemplate; importar org.springframework.stereotype.repository; import com.beauxie.bean.user; /*** @author beauxie* dao capa, operar en la base de datos*/ @repositorio // Esta propiedad corresponde a la capa de persistencia (generalmente Dao capa), lo que significa que se entrega a la administración de primavera, y el nombre de clase correspondiente en el paquete también tendrá un "s" usuarios de clase pública { @ @autowired // autowired, no es necesario que estén valores de hibernidades privadas hibernaciones. configurado en el archivo de configuración de primavera; /*** Registro del usuario, es decir, agregue un nuevo registro a la tabla* @param user*/public void adduser (usuario de usuario) {// Agregue datos a la base de datos, y puede obtener plantlate.save (usuario); }} 4. Código de clase de servicio de usuarios:
paquete com.beauxie.service; importar org.springframework.beans.factory.annotation.aUtowired; importar org.springframework.stereotype.service; import com.beauxie.bean.user; import com.beauxie.dao.userdao; /*** @author Beauxie* Service Layer*/ @Service // Esta propiedad corresponde a la capa de servicio generalmente es la capa de servicio), lo que significa que se entrega a la administración de primavera, y el nombre de clase correspondiente también tendrá un servicio de usuarios de clase pública "s" { @ @autowired // también inyectará automáticamente usuarios de usuarios privados; public void adduser (usuario de usuario) {// llamando al método adduser de la capa DAO userdao.adduser (usuario); }} 5. Código de clase de UserAction:
paquete com.beauxie.action; import javax.servlet.http.httpservletRequest; importar org.apache.struts2.servletactionContext; importar org.apache.struts2.convention.annotation.action; importar org.apache.struts2.convention.annotation.namespace; importar org.apache.struts2.convention.annotation.results; importar org.springframework.beans.factory.annotation.aUtowired; importar org.springframework.context.annotation.scope; importar org.springframework.stereotype.controller; import com.beauxie.bean.user; import com.beauxie.service.userservice; /** * @author beauxie * */ @controlador // se usa para anotar el componente de la capa de control @namespace ("/user") // url prefix @scope ("prototype") // acción es un singleton de forma predeterminada, pero en desarrollo real, es generalmente múltiples casos múltiples, una acción puede corresponder a múltiples solicitudes // @ @parentPackage ("Struts-defefault") El valor predeterminado es "struts-default", por lo que @Results ({@Result (name = "RegistSuccess", ubicación = "/msg.jsp")}) clase pública de usuarios de usuarios { @autowired // inyectar automáticamente el servicio de servicio de usuarios privados; // Los puntales predeterminados se interceptaron ".action y sin ningún sufijo" @Action (value = "regist") // access: /user/regist.action o/user/regist public string regist () {// get request httpServletRequest request = servletactContext.getRequest (); // Obtener el formulario de datos enviado string username = request.getParameter ("UserName"); Cadena contraseña = request.getParameter ("contraseña"); // Encapsular UserBean User = New User (); user.setID (1000); user.setUsername (nombre de usuario); user.setPassword (contraseña); // Llame al método de la capa de servicio para agregar un registro al servicio de la base de datos.adduser (usuario); // Guardar la información de solicitud en el dominio de solicitud y mostrar solicitud.SetAttribute ("msg", "Felicitaciones, el registro es exitoso! <br> Nombre de registro:"+nombre de usuario); regreso "Registsuccess"; }} 6. Interfaz de mensaje de mensaje: código msg.jsp, como sigue:
<%@ página lenguaje = "java" import = "java.util.*" pageEncoding = "utf-8"%> <%string path = requit.getContextPath (); String basepath = request.getScheme () + ": //" + request.getServerName () + ":" + request.getServerPort () + ruta + "/"; %> <! DocType html público "-// w3c // dtd html 4.01 Transitional // en"> <html> <fead> <base href = "<%= basepath%>"> <title> mensaje de mensaje </title> <meta http-oquiv = "pragma" content = "no cache" "<s meta httptptptptp =" CACHOL "CACHOL" content = "no-cache"> <meta http-equiv = "expires" content = "0"> <meta http-equiv = "palabras clave" content = "Keyword1, Keyword2, Keyword3"> <meta http-equiv = "Descripción" Content = "Esta es mi página"> <!-<Link Rel = "Stylesheet" Type = "Text/csss" href = "styles.css"> -> </head> <body> $ {msg} </body> </html>7. Agregue el proyecto al servidor, inicie el servicio, abra el navegador y visite: http: // localhost/sshdemo/user/regist
8. Ingrese el nombre de usuario y la contraseña, haga clic en "Registrarse" para mostrar los resultados:
9. La consola sale de la instrucción SQL (la salida se ha configurado y la instrucción SQL se ha embellecido en el archivo hibernateContext.xml):
10. Ver resultados de la base de datos:
Este simple caso ha terminado. No hay problema con la verificación de datos de envío del formulario y el código de confusión. Debe actualizarse en el futuro.
7. Resumen:
1. La integración de los tres marcos principales debe introducirse primero y luego integrarse;
2. Asegúrese de recordar importar el paquete JAR de la base de datos;
3. La clase de acción debe colocarse bajo el nombre del paquete "Acción", y el nombre de la clase debe terminar con la acción, como "xxxaction";
4. Al configurar Hibernate, asegúrese de importar paquetes JAR que admitan la anotación "@Entity";
5. Puede definir el tipo de solicitud de puntales interceptados en el archivo Struts.xml, que es predeterminado a .action y sin sufijos.
6. Puede definir el tipo de filtro del filtro de puntales en el archivo web.xml. El valor predeterminado es *.Action, y debe cambiarse a / *;
7. En el archivo ApplicationContext.xm, debe configurar cinco partes: SessionFactory, Hibernate Entity Class, HibernateTemplate Plantilla, Data Source DataSource y Spring Scanner (incluido HibernateContext.xml);
8. Cada clase debe agregar anotaciones correspondientes, y los métodos en acción también deben agregarse.
Descargue el código fuente de la instancia: http://xiazai.vevb.com/201610/yuanma/sshzhuce(vevb.com).rar
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.