Este artículo comienza con un proyecto de centro comercial en línea, comenzando con la construcción del entorno e integrando S2SH paso a paso. Esta publicación de blog resume principalmente cómo integrar Struts2, Hibernate4.3 y Spring4.2.
Para integrar los tres marcos principales, primero debe comenzar construyendo varios entornos, es decir, primero, debe construir los entornos de primavera, hibernación y struts2 para garantizar que no tengan problemas y luego integrarlos. El orden en el que sigue esta publicación de blog es: Primero construya el entorno de primavera -> luego construya el entorno Hibernate -> Integrar Spring y Hibernate -> Construir el entorno Struts2 -> Integrar Spring y Struts2.
1. Gestión de todo el paquete de proyectos de proyectos
La primavera tiene muchos paquetes de frasco. Se recomienda clasificarlos en una categoría y luego agregarlos a la biblioteca de usuarios a su vez para una fácil gestión y claro de un vistazo. Aquí resumiré los paquetes básicos de JAR requeridos para todo el SSH y veré la siguiente imagen:
Como se puede ver en la figura, en primer lugar, los frascos de primavera se dividen en cuatro categorías: Spring-4.2.4-núcleo, Spring-4.2.4-AOP, Spring-4.2.4-Persistencia y Spring-4.2.4-Web. Ponga todos los paquetes centrales de Spring en el núcleo, ponga todo relacionado con AOP en AOP, ponga todo relacionado con la persistencia (integrado con Hibernate) en persistencia y ponga todo relacionado con la web (integrado con Struts2) en la web. ¿Qué paquetes de jares tienen cada parte? Consulte la captura de pantalla a continuación:
Nota: Los paquetes en cada categoría anterior no contienen todos los frascos en el paquete original. No se utilizan algunos archivos JAR. Simplemente agréguelos cuando el proyecto específico lo necesite. La imagen de arriba es el paquete JAR más básico requerido para garantizar que el entorno del proyecto pueda construir el paquete JAR más básico.
2. Construya un entorno de primavera
La captura de pantalla anterior del paquete JAR son todos los paquetes JAR que se integraron en la última vez. Cuando construye por primera vez el entorno, no necesita agregarlos todos a la vez. Puedes agregarlos bit a bit. Esto también es más propicio para comprender lo que tienen los paquetes JAR en cada parte. Por supuesto, también es posible agregarlos todos a la vez.
2.1 Agregue el archivo de configuración frijoles.xml y los paquetes JAR correspondientes
Cree un nuevo proyecto y luego agregue su propia biblioteca a la biblioteca de usuario. Aquí hay dos principales, a saber, Spring-4.2.4-core y Spring4.2.4-AOP. No entraré en detalles sobre cómo agregar paquetes de jar. Después de agregar, agregue el archivo frijoles.xml en el directorio SRC. Hay muchas plantillas para este archivo en línea, y también hay ejemplos proporcionados por Spring. Solo toma una copia, vea la siguiente imagen:
2.2 Prueba el entorno del COI de la primavera
Escribamos una clase Java Java.UTIL normal de Java para probar si Spring IOC es normal. Si se puede inyectar normalmente en el programa de prueba, significa que el entorno del COI de Spring se construye con éxito. Vamos a escribir un caso de prueba a continuación:
/** * @Description TODO (utilizando la depuración de anotaciones de Spring, solo admite Spring3.1 y superior) * @author ni shengwu * * / / * * Después de Spring3.1, hay una prueba de primavera adicional-4.2.4.release.jar. Este paquete JAR se usa especialmente para admitir pruebas basadas en anotaciones JUNIT. El paquete JAR está en Spring-4.2.4-core * Hay un SpringJunit4ClassRunner.class en este paquete JAR, y puede agregarlo con la anotación @Runwith * * anotación @ContextConfiguration significa inyectar el objeto de ClassContext. @ContextConfiguration (ubicaciones = "classpath: beans.xml") public class sshtest {@Resource Fecha de fecha privada; @Test // Prueba el entorno de desarrollo de Spring IOC public void SpringioC () {System.out.println (fecha); }} Finalmente, puede emitir normalmente: jueves 28 de abril 22:45:13 CST 2016. Esto indica que el objeto de fecha ha sido inyectado por Spring, lo que verifica que la función del IOC de resorte es normal. Por esta razón, el entorno de primavera está construido.
3. Construya un entorno hibernado
La construcción del entorno de Hibernate es más complicada que la primavera porque utiliza ingeniería inversa en Myeclipse. Seguimos los siguientes pasos para construir el entorno de desarrollo hibernado:
3.1 Agregue el paquete jar correspondiente
Aquí agregamos principalmente dos paquetes JAR a la biblioteca de usuario: Hibernate4.3.11 y el paquete de controladores MySQL MySQL-Connector-Java-5.1.26, que no se describirá en detalle.
3.2 Crear una nueva base de datos y una tabla
Drop Base de datos si existe la tienda; Crear base de datos Tienda de caracteres predeterminado Conjunto de caracteres UTF8; usar tienda; Tabla de caída si existe la categoría; Crear categoría de tabla ( /* Número de categoría, crecimiento automático* / id int no nulo Auto_incement, /* Categoría Nombre* / Tipo Varchar (20), /* Si la categoría es una categoría caliente, la categoría caliente puede mostrarse en la página de inicio* / Hot Bool predeterminado Falso, /* Establezca el número de categoría en la clave principal* / Key primaria (ID));
3.3 DB El navegador se conecta a la base de datos MySQL
El navegador DB se refiere a una ventana de vista en Myeclipse. Puede ver intuitivamente qué bases de datos y tablas están en MySQL. El método para abrir el navegador DB: Window-> Open Perspective-> DB Browser abre la ventana de trabajo del navegador DB. Si no hay un navegador DB, siga lo siguiente: Window-> Show View-> Otro-> Ingrese el navegador DB y busque que lo abra.
Después de abrir, comenzamos a conectarnos a la base de datos MySQL. Haga clic derecho -> Nuevo en el espacio en blanco de la ventana del navegador DB, y aparecerá el siguiente cuadro de diálogo:
Después de completar, haga clic en el controlador de prueba para probarlo. La prueba pasa la prueba e indica que el controlador de conexión de la base de datos se ha configurado y luego la finaliza. De esta manera, podemos ver la base de datos MySQL 5.6 en la ventana del navegador DB. Haga clic derecho para abrirlo para ver las bibliotecas y tablas existentes en la base de datos, de la siguiente manera:
3.4 Crear archivo de asignación XML y sessionFactory
SessionFactory se usa para crear sesiones. Los creamos de la siguiente manera: haga clic derecho en el nombre del proyecto-> myeclipse-> Agregar capacidades de hibernación. Si no hay capacidades Hibernate Agregar, haga clic en Facets del proyecto-> Instalar facetas Hibernate y aparecerá la siguiente ventana:
A continuación, agregue el soporte Hibernate, es decir, hibernate.cfg.xml Archivo de asignación y SessionFactory en MyEClipse. Aquí creamos principalmente un paquete para SessionFactory, y el paquete predeterminado no se puede usar.
A continuación, agregue un controlador. Como hemos configurado un controlador antes, podemos seleccionar directamente el controlador recién configurado aquí.
A continuación, dado que hemos agregado nuestra propia reserva de jar antes, no hay necesidad de elegir aquí, simplemente termínelo directamente.
De esta manera, completamos la creación del archivo de configuración Hibernate y SessionFactory. Echemos un vistazo a lo que hay en la Factory de Session creada por MyEClipse:
clase pública HibernatesessionFactory {private Static final ThreadLocal <essess> ThreadLocal = new ThreadLocal <session> (); // SessionFactory se usa en sessionFactory private static org.hibernate.sessionFactory sessionFactory; // SessionFactory: cree una fábrica para la configuración de configuración estática privada privada = nueva configuración (); Servicio de administración privada de ServiceRegistry; static {// inicializar sessionFactory try {configuration.configure (); ServiceRegistry = new ServiceRegistryBuilder (). ApplySettings (Configuration.getProperties ()). BuildServiceRegistry (); sessionFactory = Configuration.BuildSessionFactory (ServiceRegistry); // Método para crear SessionFactory en Hibernate4} Catch (Exception e) {System.err.println ("%%%%% Error creando sessionFactory %%%%%omin"); E.PrintStackTrace (); }} Private HibernatesessionFactory () {// El método de constructor privado evita que se publiquen nuevos objetos, asegurando que SessionFactory Singleton} public static session getSession () lanza HibernateException {Session Session = (Session) ThreadLocal.get (); // Obtener sesión desde el grupo de hilos if (session == null || // Si la Factory de Session está vacía, crea nuevamente, lo mismo que la parte estática} session = (sessionFactory! = Null)? sessionFactory.opensession (): nulo; // SessionFactory no está vacío, cree una sesión ThreadLocal.set (sesión); // luego coloque esta sesión en el grupo de subprocesos y obtenga la próxima vez} Sesión de retorno; } public static void RebuildSessionFactory () {try {Configuration.Configure (); ServiceRegistry = new ServiceRegistryBuilder (). ApplySettings (Configuration.getProperties ()). BuildServiceRegistry (); sessionFactory = Configuration.BuildSessionFactory (ServiceRegistry); } catch (Exception e) {System.err.println ("%%%%% Error creando sessionFactory %%%%%omin"); E.PrintStackTrace (); }} public static void Closesession () lanza HibernateException {Session Session = (Session) ThreadLocal.get (); ThreadLocal.set (nulo); if (session! = null) {session.close (); }} public static org.hibernate.SessionFactory getSessionFactory () {// Proporcione una interfaz pública para permitir que el mundo exterior obtenga este sessionFactory de sessionFactory sessionFactory; } Configuración estática pública getConfiguration () {Configuración de retorno; }} Se puede ver desde HibernatesessionFactory creado que el patrón singleton y la tecnología de agrupación de hilos se utilizan principalmente. No es difícil de entender.
3.5 Generar archivos de mapeo de modelo y ORM a través de la ingeniería inversa
A continuación, comenzaremos a usar la ingeniería inversa para crear un objeto de instancia, es decir, el modelo correspondiente a la tabla de la base de datos. En la ventana DB Browsera, haga clic con el botón derecho en la tienda de mesa que acabamos de crear y seleccionamos Ingeniería inversa de Hibernate para comenzar a crear:
Hay dos formas de crearlo, según los archivos de configuración y en función de las anotaciones. Depende del estado de ánimo del desarrollador. Puedes elegir:
Luego, en el siguiente paso, seleccione el método de autoincremento de la clave primaria nativa y luego complete la ingeniería inversa para crear modelo y mapeo ORM.
Después de la finalización, se generará el modelo de categoría, y las asignaciones correspondientes también se generarán en el archivo hibernate.cfg.xml. Las asignaciones anteriores basadas en archivos de configuración y anotaciones basadas en anotaciones serán diferentes.
3.6 Prueba de la base de datos persistente de hibernación
Debido a que no se ha integrado con la primavera, es solo una construcción simple del entorno de desarrollo hibernado, por lo que no necesitamos usar anotaciones. Ejecutamos la entrada de datos en la base de datos mediante un servicio directamente nuevo.
Primero escriba la interfaz CategoryService y la clase de implementación:
Interfaz pública CategyService {public void save (categoría de categoría); // Usar para probar el entorno Hibernate} CategyServiceImpl implementa CategyService {@Override // No hay integración con Spring public Void Save (categoría de categoría) {// Get Session Session Session = HibernatesessionFactory.getSession (); intente {// transacción manual session.getTransaction (). begin (); // ejecutar negocios lógico session.save (categoría); // Envíe manualmente session.getTransaction (). Commit (); } catch (excepción e) {session.getTransaction (). Rollback (); tirar nueva runtimeException (e); } finalmente {hibernatesessionFactory.clossesessession (); }}} Lo siguiente es agregar la prueba de Hibernate en el caso de prueba en este momento:
@RunWith (SpringJunit4ClassRunner.class) @ContextConfiguration (ubicaciones = "classpath: beans.xml") clase pública sshtest {@resource fecha privada fecha; @Test // Prueba el entorno de desarrollo de Spring IOC public void SpringioC () {System.out.println (fecha); } @Test // prueba /prueba el entorno de desarrollo de Hibernate, porque no hay integración, puede ser directamente nuevo Void Hihernate () {CategyService CategyService = new CategyServiceImpl (); Categoría Categoría = nueva categoría ("Casual de hombres", verdadero); categoryService.save (categoría); }}Verificamos la base de datos y descubrimos que había demasiados elementos que acababan de insertar, lo que significa que no había problema con el entorno hibernado. En este punto, hemos construido el entorno de desarrollo hibernado.
4. Integrar primavera e hibernar
Después de construir el entorno de desarrollo para Spring y Hibernate, comenzamos a integrar los dos. Después de integrar Spring y Hibernate, puede usar AOP para dejar que Spring administre las transacciones de Hibernate. La integración de Spring y Hibernate comienza principalmente desde dos aspectos: uno es importar los paquetes JAR necesarios, y el otro es configurar el archivo frijoles.xml. A continuación integramos la primavera y la hibernación paso a paso.
4.1 Importar el paquete JAR correspondiente
Hay dos paquetes de JAR principales que deben importarse al integrar Spring e Hibernate, Spring4.2.4-Persistencia y C3P0-0.9.5.1. Para los archivos JAR específicos en cada paquete JAR, consulte la captura de pantalla anterior y no se describirá aquí. Ahora comenzaremos a configurar el archivo beans.xml.
4.2 Configuración de la fuente de datos de la fuente de datos
Primero configure el DataSource, y luego la parte correspondiente en Hibernate.cfg.xml se puede matar. Debido a que está configurado en Spring, Spring inicializará esta fuente de datos, lo que significa que esto se deja para completarse, y la parte correspondiente en Hibernate.cfg.xml se puede eliminar. como sigue:
<!-com.mchange.v2.c3p0.combopooleddataSource La clase está en el paquete com.mchange.v2.c3p0 de C3P0-0-0.9.5.1.JAR PACPACK-> <Bean Id = "DataSource"> <Property Name = "DriverClass" Value = "Com.mysql.jdbc.Driver" /> <Property Name = "JDBCURL" valor = "jdbc: mysql: // localhost: 3306/shop"/> <propiedad name = "user" value = "root"/> <propiedad name = "contraseña" value = "root"/> </bean>
La parte que debe ser asesinada en hibernate.cfg.xml:
4.3 Configuración de SessionFactory
El SessionFactory está configurado para generar una sesión. Además, HibernateTemplate también es posible. Sin embargo, el SessionFactory se usa aquí en lugar de HibernateTemplate porque la primavera proporciona HibernateTemplate y depende de la primavera. Si no se usa la primavera un día, se informará un error. Y Hibernate proporciona la Factory de Session, no hay problema. HibernateTemplate es demasiado dependiente. Echemos un vistazo a la configuración específica:
< value = "classpath: hibernate.cfg.xml" /> <!-Cargar archivo de configuración de hibernate-> < /bean>
Acabamos de utilizar el DataSource en SessionFactory para hacer referencia al DataSource con el atributo REF. Ya no estamos utilizando el ConfigLocation aquí. Cargamos directamente el archivo hibernate.cfg.xml y usamos la configuración en el archivo de configuración Hibernate para que sea más conciso y conveniente.
4.4 Configuración del administrador de transacciones
El Administrador de transacciones de configuración se utiliza para administrar SessionFactory, de modo que todas las sesiones generadas por SessionFactory se administrarán declarativamente. La configuración es la siguiente:
<
Del mismo modo, podemos usar SessionFactory acaba de configurar y hacer referencia con el atributo REF. En este punto, encontrará que todo el camino desde arriba es una serie de operaciones, citándolas una por una.
4.5 Configurar consejos (notificación)
El propósito de configurar el consejo es especificar qué métodos requieren qué tipo de modo de transacción. Ver la configuración:
<tx: consejo id = "consejo" transaccion-ganager = "transactionManager"> <tx: atributes> <tx: método name = "save*" propagation = "requerido"/> <tx: atributes> </tx: atributes> </tx: consejo>
Requerido significa que si hay una transacción, la transacción actual es compatible. Si no hay, se crea una nueva transacción. Este modo de transacción se aplica a todos los métodos que comienzan con Guardar, Actualizar y Eliminar, es decir, se requiere soporte de transacción al agregar, eliminar y modificar la base de datos. Los soportes significa que si hay una transacción, la transacción actual es compatible, y si no hay nadie, estará bien.
4.6 Configuración de facetas AOP
<aop:config> <!-- Configure which package classes to enter the transaction--> <aop:pointcut id="pointcut" expression="execution(* cn.it.shop.service.impl.*.*(..))" /> <aop:advisor advice-ref="advice" pointcut-ref="pointcut"/><!-- Connect the advice on the <span style="font-family:Microsoft Yahei; "> y el punto de vista arriba-> <!-AOP: PointCut debe escribirse en el asesor AOP: de lo contrario se informará un error-> </aop: config>
AOP es la programación orientada a tangentes. AOP: Pointcut define una tangente. La configuración en la propiedad de expresión significa que todos los métodos en el paquete cn.it.shop.service.impl, independientemente del valor de retorno y los parámetros, deben ingresar la transacción. Este paquete pertenece a la capa DAO y opera directamente la base de datos. AOP: El consejo combina notificaciones y secciones. Podemos usar directamente el consejo y el punto de vista configurado anteriormente para presentarlos. Después de esta configuración, significa que todos los métodos bajo el paquete CN.IT.Shop.Service.ImPL deben ingresar a la administración de transacciones. Específicamente, los métodos que comienzan con Guardar, Actualizar y Eliminar usan el método requerido, y otros métodos usan el método de soporte. Esto hace que sea fácil entender el significado de esta configuración.
4.7 Resultados de la integración de pruebas
Cuando construimos el entorno hibernado antes, probamos que dimos un servicio directamente nuevo para operar la base de datos, porque no se había integrado con la primavera en ese momento. Ahora, después de configurar frijoles, xml, Spring puede administrar transacciones hibernadas. Por lo tanto, la prueba actual debe entregar el servicio a la administración de primavera, inyectarlo hasta la primavera y confiar en SessionFactory. Si los datos se pueden insertar en la base de datos, significa que la transacción está bien.
Primero, necesitamos hacer coincidir este servicio en el archivo de configuración de Spring, xml:
Copie el código de la siguiente manera: <bean id = "categoryService">
<Property Name = "SessionFactory" ref = "sessionFactory" /> <!-La dependencia sessionFactory usa el sessionFactory que habíamos equipado previamente->
</bean>
En segundo lugar, necesitamos agregar un método a la interfaz CategorialService y su clase de implementación CategyServiceImpl para probar la situación de integración:
Interfaz pública CategyService {public void save (categoría de categoría); // utilizado para probar la actualización de Hibernate Environment Public Void (categoría de categoría); // Se utiliza para probar la integración de Spring e Hibernate} Categy CategyServiceImpl implementa CategyService {@Override // La situación en la que no hay integración con Spring Public void Save (categoría de categoría) {// Get Session Session Session = HibernatesSessionFactory.getSession (); intente {// transacción manual session.getTransaction (). begin (); // ejecutar negocios lógico session.save (categoría); // Envíe manualmente session.getTransaction (). Commit (); } catch (excepción e) {session.getTransaction (). Rollback (); tirar nueva runtimeException (e); } finalmente {hibernatesessionFactory.clossesessession (); }} /*Spring e hibernate todo el* / privado sessionFactory sessionFactory; // Definir una sesión de sesión // Cuando necesite usar SessionFactory, Spring inyectará SessionFactory en public void setSessionFactory (sessionFactory sessionFactory) {this.sessionFactory = sessionFactory; } Sesión protegida getSession () {// Obtener sesión desde el hilo actual. Si no, cree una nueva sesión de retorno SessionFactory.getCurrentSession (); } @Override // La situación después de Spring y Hibernate es una actualización integrada de publicidad publicitaria (categoría de categoría) {getSession (). Update (categoría); }} Ahora podemos agregar métodos de prueba a la clase de prueba para probar los resultados después de la integración de Spring y Hibernate:
@RunWith (SpringJunit4ClassRunner.class) @ContextConfiguration (ubicaciones = "classpath: beans.xml") clase pública sshtest {@resource fecha privada fecha; @Resource Categoría privada CategyService; @Test // Test Spring IOC Development Environment Public void SpringioC () {System.out.println (fecha); } @Test // prueba // prueba el entorno de desarrollo de Hibernate, debido a que no hay integración, puede directamente nuevo público vacío hihernate () {categoryService categoryService = new CategyServiceImpl (); Categoría Categoría = nueva categoría ("Casual de hombres", verdadero); categoryService.save (categoría); } @Test // prueba public void hibernateAndspring () {categoryService.Update (nueva categoría (1, "mujer casual", verdadero)); // CategoryService inyectado desde arriba hasta Spring}}Luego verificamos la base de datos y descubrimos que la categoría con ID = 1 se ha modificado en el estilo de una mujer casual, lo que significa que la actualización fue exitosa. En este punto, Spring y Hibernate se han integrado con éxito.
5. Construya un entorno Struts2
5.1 Agregue la configuración correspondiente y los paquetes JAR
Puse el paquete JAR requerido para que Struts2 se ejecute en la biblioteca de Struts2.3.41, para que pueda presentarlo directamente, y no lo repetiré. Además, el archivo web.xml debe configurarse de la siguiente manera:
<? xml versión = "1.0" encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" " xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" <Spant-Name> e_shop </sipplay-name> <beeding-file-list> <calle-file> index.jsp </leadde-file> </bienvenido-file-list> <filter> <filter-name> struts2 </filtre-name> <filter-class> org.apache.struts2.dispatcher.ng.filter.strutsprepeReanDexEcutefilter </filter> filter> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filter> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtreeS <filter-mapping> <filter-name> struts2 </filtre-name> <url-pattern>*. Action </sl-Pattern> </filtre-mapping> </beb-app>
Como se indicó anteriormente, configuramos un filtro StrutsPrepareAnDexCuteFilter y establecimos el patrón de URL del filtro en *.action, es decir, todos los sufijos de acción pasarán primero a través de este filtro, que también es la entrada a Struts2.
5.2 Crear acción y configurarla en el archivo Struts.xml
Creamos una acción de la siguiente manera:
La categoría de clase pública extiende ActionSupport {private CategyService CategyService; // CategyService está configurado para ver intuitivamente las diferencias antes y después de la integración con Spring public void setCategoryService (categoryService CategyService) {this.CategoryService = CategyService; } public String Update () {System.out.println ("----- Update ----"); System.out.println (categoryService); // emitir diferentes retornos "índice"; } public String Save () {System.out.println ("---- save ----"); System.out.println (categoryService); // Abra diferente devoluciones "índice" antes y después de la integración; }} Luego configuramos el archivo Struts.xml, que se coloca en el directorio SRC:
<? xml versión = "1.0" encoding = "utf-8"?> <! Doctype Struts public "-// Apache Software Foundation // Dtd Struts Configuration 2.3 // en" "http://struts.apache.org/dtds/struts-2.3.dtdd"> <truts> <pack name = "shop" Extends = "struts" struts "struts">! category_update.actiocan: método de actualización de acceso de acceso-> <Action name = "category_*" método = "{1}"> <resultado name = "index">/index.jsp </resultado> </acción> </paquete> </struts> 5.3 Prueba del entorno Struts2
El método de prueba es: escribir una acción de acceso JSP, y si la acción se puede crear, significa que el entorno Struts2 está bien. Es decir, una serie de procesos en Struts2 se puede completar normalmente: JSP-> Struts.xml-> Action-> Struts.xml-> JSP, de modo que el entorno de Struts2 esté listo. Escribamos un simple index.jsp
<%@ page lenguaje = "java" import = "java.util.*" pageEncoding = "utf-8"%> <! DocType html público "-// w3c // dtd html 4.01 transitional // en"> <html> <cead> <title> my jsp 'Índice.jsp' Page inicial </title> </head> <sead> <! se accederá a-> </span> <a href = "$ {pageContext.request.contextpath} /category_update.action"> Access Update </a> <a href = "category_save.action"> Access Save </a> </body> </html> Luego implementamos el siguiente proyecto, abrimos el servidor Tomcat, ingresamos: http: // localhost: 8080/e_shop/index.jsp En el navegador, aparecerá la página JSP normal, luego hará clic en dos botones y aún saltamos a index.jsp, y luego observamos la información de salida de la consola:
---actualizar---
nulo
---ahorrar---
nulo
Esto muestra que se ha completado una línea de Struts2 y no hay problema con el entorno. En este punto, se ha construido el entorno de desarrollo Struts2.
Vemos que la consola sale nula, lo que significa que el servicio de categoría está vacío, lo que significa que no tenemos el servicio de categorías, porque no nos hemos integrado con la primavera y no hemos sido inyectados, por lo que nulo es normal. Voltamos a lo largo de la salida de información de la consola y encontraremos un mensaje: elegir frijoles (puntales) para (com.opensymphony.xwork2.ObjectFactory). Los paréntesis dicen que los puntales son generados por Struts2 antes de integrarse con la primavera.
6. Integración de primavera y struts2
6.1 Agregue el paquete jar correspondiente
Cuando se integran Spring y Struts2, el paquete JAR está principalmente en Spring4.2.4-Web, incluido Struts2-Spring-Plugin-2.3.24.1.Jar. El paquete de guía no se describirá nuevamente.
6.2 Dejar la acción y sus dependencias a la gestión de primavera
Configure la acción y sus dependencias en el archivo de configuración de Spring frijoles.xml. Actualmente tenemos solo una acción, que está configurada de la siguiente manera:
<bean id = "date" /> <bean id = "categoryAction" scope = "Prototype"> <Property Name = "CategyService" ref = "CategoryService" /> <!-El servicio de categoría dependiente está configurado al integrar el anterior y Hibercernate-> < /bean>
6.3 Modificar la configuración en Struts.xml
Resulta que en Struts.xml, el atributo de clase corresponde al nombre totalmente calificado de la acción específica. Ahora cambie el valor del atributo de clase al valor de identificación de la acción configurada en la primavera, es decir, categoryAction, como sigue:
<Struts> <paquete name = "shop" extends = "struts-default"> <!-La clase corresponde al valor de identificación de la acción configurada en Spring, porque se debe entregar a Spring Management-> <Action Name = "Category_*" Method = "{1}"> <Result Name = "Index">/índice.jsp </sult> </porty> </pacio> </truts> 6.4 Configura el oyente
Configure el contexto del oyente LogloaderListener en Web.xml para que los archivos de configuración de Spring se puedan cargar cuando se inicia el servidor. como sigue:
<? xml versión = "1.0" encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" " xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" <Spant-Name> e_shop </sipplay-name> <beeding-file-list> <calle-file> index.jsp </leadde-file> </bienvenido-file-list> <filter> <filter-name> struts2 </filtre-name> <filter-class> org.apache.struts2.dispatcher.ng.filter.strutsprepeReanDexEcutefilter </filter> filter> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filter> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtre> filtreeS <filter-mapping> <filter-name> struts2 </sille-name> <url-pattern>*. Action </url-Pattern> </filter-mapping> <!-La prioridad de inicio del oyente en Web.xml es más alta que la de los filtros, por lo que no importa si se combina a continuación-> <Oyear>> <Oyerer-class> org.springframework.web.context.contextloaderListener </oyer-class> </oyeyer> <text-param> <amamname> contextconfiglocation </amamname> <amam-value> classpath: beans.xml </param-value> </aux-param> </webapp>
6.5 Resultados de la integración de pruebas
Agregamos una nueva declaración a la acción para actualizar la base de datos, de la siguiente manera:
La categoría de clase pública extiende ActionSupport {Categoría de categoría privada; // Establezca una variable de miembro privado para recibir parámetros traídos por la URL. Tenga en cuenta que los métodos GET y SET deben escribirse a continuación. Categoría privada Categoría de categoría; public void setCategoryService (categoryService CategoryService) {this.CategoryService = CategyService; } public String Update () {System.out.println ("--- Update ---"); System.out.println (categoryService); // Debido a que se ha integrado con Spring, puede obtener esta categoría de servicio. No es nulo después de imprimirlo categoryService.update (categoría); // Agregue una nueva declaración para actualizar el "Índice de la base de datos"; } public String Save () {System.out.println (categoryService); devolver "índice"; } Categoría pública getCategory () {categoría de retorno; } public void setCategory (categoría de categoría) {this.category = category; }} Luego modificamos el archivo index.jsp, como sigue:
<%@ page lenguaje = "java" import = "java.util.*" pageEncoding = "utf-8"%> <! DocType html público "-// w3c // dtd html 4.01 transitional // en"> <html> <fead> <title> my jsp 'index.jsp' Página inicial </title> <bead> <scal <body <body <s Boder> <Avalor href = "$ {PageContext.Request.ContextPath} /Category_Update.Action?category.id=2&category.type=gga&category.hot=false"> Access Update </a> <a href = "category_save.action"> Access Save </a> </body> </html> Luego implementamos el siguiente proyecto, abrimos el servidor Tomcat, ingresamos: http: // localhost: 8080/e_shop/index.jsp En el navegador, aparecerá la página JSP normal, luego haga clic en el botón "Acceder a actualización" y aún saltar a index.jsp, y luego analizamos la información de salida del consola:
--- Actualización --- cn.it.shop.service.impl.categoryserviceImpl@7c5ecf80 Hibernate: actualización de categoría establecer hot =?, type =? donde id =?
Podemos generar la información del objeto CategoryService y también podemos generar la instrucción SQL al ejecutar la instrucción de actualización. Luego consultamos la base de datos y encontramos que el tipo de datos con id = 2 se ha actualizado a GGA y HOT se ha actualizado a FALSO. Volcamos la salida de información de la consola hacia arriba y encontraremos un mensaje: elegir frijol (resorte) para (com.opensymphony.xwork2.ObjectFactory), con los soportes de soporte. En comparación con la situación anterior, podemos ver que después de que Struts2 se integra con la primavera, la acción se entrega a Spring para la gestión.
En este punto, la integración de Struts2, Hibernate4 y Spring4 se ha completado, ¡y podemos desarrollarla en el entorno SSH a continuación!
El paquete JAR completo requerido para la integración SSH presentada en este artículo: Descarga gratuita
La dirección de descarga del código fuente de todo el proyecto: //www.vevb.com/article/86099.htm
Dirección original: http://blog.csdn.net/eson_15/article/details/51277324
(Nota: ¡al final, se proporciona la descarga del código fuente de todo el proyecto! Todos son bienvenidos a recopilar o seguir)
Lo anterior es todo el contenido de este artículo. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.