Integración del marco SSH
Prefacio: Algunas personas dicen que el marco convencional sigue siendo popular ahora, y SSM ha estado fuera durante mucho tiempo, y mucho menos ssh. No me parece. Hoy en día, muchas compañías todavía usan SSH, y si cambian a los marcos convencionales, costará. Por ejemplo, en el campo de TI financiero, se recomienda usar Hibernate en la capa de base de datos porque se puede desarrollar rápidamente, a menos que sea Internet. Debido a que implica una alta concurrencia, la capa de base de datos usa mybatis, que tiene una eficiencia de interacción de datos más rápida. Por lo tanto, SSH no puede ser ignorado.
1. ¿Qué es SSH?
SSH es un marco integrado de Struts+Spring+Hibernate, y actualmente es un marco de código abierto popular para aplicaciones web.
El sistema que integra el marco SSH se divide en cuatro capas en términos de responsabilidades: capa de presentación, capa de lógica comercial, capa de persistencia de datos y capa de módulo de dominio para ayudar a los desarrolladores a construir aplicaciones web con estructura clara, buena reutilización y mantenimiento conveniente a corto plazo. Entre ellos, los Struts se usan como la infraestructura general del sistema, responsable de la separación de MVC y en la parte del modelo del marco de Struts, controlando saltos comerciales, utilizando el marco de hibernación para brindar apoyo para la capa de persistencia, Spring gana, gana Struts e Hibercernate. El enfoque específico es: utilizar métodos de análisis orientados a objetos para proponer algunos modelos según las necesidades, implementar estos modelos como objetos Java básicos, luego escribir la interfaz Básica DAO (Objetos de acceso a datos) y dar la implementación DAO de Hibernate. La clase DAO implementada por la arquitectura Hibernate se utiliza para realizar la conversión y el acceso entre las clases de Java y las bases de datos. Finalmente, Spring maneja y maneja puntales e hibernado.
---------- Baidu Encyclopedia
2. Las partes involucradas en SSH
3. Implementación rápida del entorno
Aquí utilizamos una pequeña demostración para ahorrar clientes para demostrar la integración de SSH
1. Importe el paquete jar requerido
1). Marco Struts2
* Struts-2.3.24/Apps/Struts2-Blank/Web-Inf/Lib/*. Jar-Todos los paquetes JAR requeridos por Struts2
* Struts2-Spring-Plugin-2.3.24.Jar --- Struts2 integra el paquete de complemento de Spring
2). Marco hibernado
* Hibernate-Release-5.0.7.final/lib/required/*.jar-Paquete jar requerido por Hibernate Framework
* SLF4J-API-1.6.1.JAR-Interfaz de registro
* SLF4J-LOG4J12-1.7.2.JAR-Implementación de registro
* MySQL-Connector-Java-5.1.7-Bin.jar-Paquete de controladores MySQL
3). Marco de primavera
* Paquete de núcleo del COI
* Paquete AOP Core
* Plantillas JDBC y paquetes de núcleo de transacción
* La primavera integra el paquete de prueba Junit
* Spring integra el paquete de núcleo Hibernate
* Spring integra el paquete Core Struts2
2. Configure el código relacionado con Spring y Struts en Web.xml
1) Configurar el filtro de núcleo Struts2
Esto se define como interceptando todo
< <Url-Pattern>/*</url-Pattern> </filt-mapping>
2) Configure el oyente de Spring
Cuando se inicia el servicio, el archivo de configuración de Spring se cargará primero
<
3) Configurar la ruta de carga predeterminada
<!-El oyente carga el archivo web-INF de forma predeterminada. Debe configurar los parámetros para cargar el archivo especificado-> <context-param> <amamname> contextConfiglocation </amamname> <amam-value> classpath: applicationContext.xml </amam-value> </ context-param>
Resumen: todos los códigos para Web.xml son
< <amamname> contextconfiglocation </amamname> <amam-value> classpath: applicationContext.xml </amam-value> </text-param> <!-Configurar filtros de núcleo-> <filter> <filter-name> struts2 </filter-name> <Stry-Class> org.apache.struts2.dispatcher.ng.filter.strutsprepareAnDexCuteFilter </filter-class> </filtre> <filter-mapping> <filter-name> struts2 </filter-name> <url-pattern>/*</url-pattern> </pter-mapping>
2. Escriba archivos de configuración relevantes en SRC
1) Spring: ApplicationContext.xml
Importar restricciones relacionadas con
<? 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: context = "http://www.springframework.org/schema/context" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: tx = "http://wwww.springframework.org/sChMing" " xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beanss.xsd http://www.springframework.org/schema/contextExt http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd "> </beans>
2) Hibernate: hibernate.cfg.xml
Importar restricciones relevantes y configurar la base de datos
<? xml versión = "1.0" encoding = "utf-8"?> <! DOCTYPE Hibernate-Configuration public "-// Configuración de Hibernate/Hibernate Dtd 3.0 // en" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtdd"> "hiacurator <Session-Factory> <!-Debe configurar-> <Property Name = "Hibernate.Connection.Driver_Class"> com.mysql.jdbc.driver </Property> <Property Name = "Hibernate.Connection.url"> jdbc: mysql: //192.168.174.130: 3306/ssh </propiedad> <Propiedad> <Propiedad> <propiedad name = "Hibernate.Connection.Username"> root </propiety> <Property name = "Hibernate.Connection.Password"> root </propiedad> <propiedad name = "hibernate.dialect"> org.hibernate.dialect.mysqldialect </propiedad> < name = "Hibernate.Format_Sql"> true </Property> <Property name = "Hibernate.hbm2ddl.auto"> update </propiet> <!-Configure el grupo de conexión para c3p0-> <Property name = "Connection.Provider_class"> org.hibernate.connection.C3p0connectionProvider </Property> <! -> <!-Archivo de configuración de asignación-> <Mapeing Resource = "com/clj/domain/customer.hbm.xml"/> </session-factory> </hibernate-configuration>
3) Configurar log4j.properties
### Mensajes de registro directo a stdout ### log4j.appender.stdout = org.apache.log4j.consoleppenderlog4j.appender.stdout.toRget = system.errlog4j.appender.stdout.layout = org.apache.log4j.patternlayoutlog4j.appender.stdout.conversionpattern = %d @ { %c {1}: %l - %m %n ### Mensajes directos para presentar mylog.log ##. %C {1}: %l - %m %n ### Establecer niveles de registro - Para un cambio de registro más detallado 'Info' a 'Debug' ### log4j.rootlogger = info, stdout4) Struts2: Struts.xml
Importar restricciones relacionadas con
<? xml versión = "1.0" encoding = "utf-8"?> <! DocType Struts public "-// Apache Software Foundation // Dtd Struts Configuration 2.1 // en" "http://struts.apache.org/dtds/struts-2.3.dtdd"> <truts> </struts>
Resumen: el archivo de configuración requerido por SRC se muestra en la figura
3. Configure la capa DAO
Definir una interfaz y su clase de implementación
interfaz pública CustomerDao {public void save (cliente cliente);} CLOSTER CLIENTEDAOMPL de clase pública implementa CustomerDao {public void save (cliente cliente) {}}4. Defina la interfaz de la capa de negocios y la clase de implementación
paquete com.clj.service; import com.clj.domain.customer; interfaz pública CustomerService {public void save (cliente cliente);} paquete com.clj.service; import org.springframework.transaction.annotation.transactional; import com.clj.dao.customerdao; import com.clj.domain.customer;/** * Customer's Business Layer * @Author Administrator * */Public ClasserServiceImpl Implements Implementservice {// Solía para solsar CLIENTES Void (Customer). }}5. Defina la clase POJO
Hibernate opera tablas de bases de datos mediante las clases de POJO operando para lograr el mapeo relacional de objetos
paquete com.clj.domain; public class Customer {private Long cust_id; Cadena privada cust_name; privado long cust_user_id; privado long cust_create_id; String private cust_source; String private cust_industry; cadena privada cust_level; cadena privada cust_linkman; String private Cust_phone; cadena privada cust_mobile; public Long getCust_id () {return cust_id; } public void setcust_id (long cust_id) {this.cust_id = cust_id; } public String getCust_Name () {return cust_name; } public void setCust_Name (string cust_name) {this.cust_name = cust_name; } public Long getCust_user_id () {return cust_user_id; } public void setcust_user_id (long cust_user_id) {this.cust_user_id = cust_user_id; } public Long getCust_Create_id () {return cust_create_id; } public void setcust_create_id (long cust_create_id) {this.cust_create_id = cust_create_id; } public String getCust_Source () {return cust_source; } public void setCust_Source (string cust_source) {this.cust_source = cust_source; } public String getCust_indUstry () {return cust_industry; } public void setcust_industry (string cust_industry) {this.cust_industry = cust_industry; } public String getCust_Level () {return cust_level; } public void setcust_level (String cust_level) {this.cust_level = cust_level; } public String getCust_linkman () {return cust_linkman; } public void setcust_linkman (string cust_linkman) {this.cust_linkman = cust_linkman; } public String getCust_phone () {return cust_phone; } public void setcust_phone (string cust_phone) {this.cust_phone = cust_phone; } public String getCust_Mobile () {return cust_mobile; } public void setCust_Mobile (string cust_mobile) {this.cust_mobile = cust_mobile; } @Override public String toString () {return "customer [cust_id =" + cust_id + ", cust_name =" + cust_name + ", cust_user_id =" + cust_user_id + ", cust_create_id =" + cust_create_id + ", cust_source =" + " cust_level = " + cust_level +", cust_linkman = " + cust_linkman +", cust_phone = " + cust_phone +", cust_mobile = " + cust_mobile +"] "; }}6. Defina Customer.hbm.xml
Este archivo de configuración está relacionado con la clase POJO del cliente. Este archivo debe colocarse en el mismo paquete que la clase POJO del cliente
<? xml versión = "1.0" encoding = "utf-8"?> <! DOCTYPE Hibernate-Mapping público "-// Hibernate/Hibernate Mapping Dtd 3.0 // en" http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd "> <hiCbernate-mapping name = "com.clj.domain.customer" table = "cst_customer"> <id name = "cust_id" column = "cust_id"> <generador/> </id> <propiedad = "cust_name" column = "cust_name"/> <propiedad = "cust_user_id" column = "cust_user_id"/> <sperty = "cust_crecye columna = "cust_create_id"/> <propiedad name = "cust_source" columna = "cust_source"/> <propiedad name = "cust_industry" column = "cust_industry"/> <propiedad name = "cust_level" column = "cust_level"/> <propiedad de propiedad = " name = "cust_phone" column = "cust_phone"/> <propiedad name = "cust_mobile" column = "cust_mobile"/> </class> </hibernate-mapping>
Diagrama de construcción del proyecto
4. Demostración preliminar de la demostración para la preservación de los clientes
Aquí primero definimos la capa de persistencia a Heibernate, la capa de negocios a Struts2 y la instancia de creación para primavera
1. Defina una interfaz para guardar a los clientes y usar formularios de formularios para enviar datos
Según el nombre de dominio, podemos ver que el método comodín de Struts2 se usa para el acceso.
<Form ID = Form1 name = form1 action = "$ {PageContext.Request.ContextPath} /Customer_add.Action" Method = Post> <!-Tabla Part omitida-> </form>2. Configure las solicitudes de aceptación en Struts.xml, salte a la acción especificada de acuerdo con el nombre y el método de la acción, y ejecute el método especificado
Spring integra el método Struts2 One: La acción se gestiona por Struts2 Framework
* Debido a que el struts2-spring-plugin-2.3.24.Jar importado viene con un archivo de configuración struts-plugin.xml, el siguiente código se incluye en el archivo de configuración
* <constant name = "structs.ObjectFactory" value = "spring" /> enciende una constante. Si la constante se enciende, se puede usar la siguiente constante
* struts.objectFactory.spring.aUtowire = nombre, ¡esta constante es una clase que permite que la acción ensamble automáticamente los objetos de frijoles!
<? xml versión = "1.0" encoding = "utf-8"?> <! DocType Struts public "-// Apache Software Foundation // Dtd Struts Configuration 2.1 // en" "http://struts.apache.org/dtds/struts-2.3.dtdd"> <truts> <!-Configure la estructura de paquete-> <name de paquete name "name de paquete" Extends = "Struts-Default" Namespace = "/"> <!-Configurar Acción del Cliente-> <!-Método 1: Aciton se gestiona por Struts2 Framework-> <Action Name = "Customer_*" Method = "{1}"/> </paquete> </struts>3. Configure los frijoles y transacciones correspondientes en Spring ApplicationContext.xml
Aquí, utilizando la función IOC (inversión de control) en Spring, la tarea de crear una instancia se entrega a la gestión del marco de Spring
<bean id = "cientservice"> <propiedad name = "customerdao" ref = "customerDao"> </property> </bean> <bean id = "customerDao"> <Property name = "HibernateTemplate" Ref = "HibernateTemplate"/> </bean> <bean id = "HibernatetEtEmlate"> <!-injectsfactory-> <sessperfactory " </bean> </beans>
4. Escriba el código relacionado con la clase de implementación de la capa de persistencia
Aquí, la clase de plantilla proporcionada por Hibernate se usa para encerrar la sesión internamente, de modo que se pueda llamar al método en la sesión.
/** * Capa de persistencia * * @Author Administrator * */public classDaoImpl implementa CustomerDao {// Guardar datos en la base de datos (clase de plantilla de llamada (proporcionada por Hibernate, sesión encapsulada internamente)) Private HibercerneTeMplate HiberNateTemplate; public void sethibernateTemplate (HibernateTemplate HibernateTemplate) {this.HiberNateTemplate = HibernateTemplate; } / *** Save Customer* / public void save (cliente cliente) {system.out.println ("capa permanente: guardar cliente"); hibernateTemplate (). Guardar (cliente); }}5. Escribir código relacionado con la clase de implementación de la capa comercial
paquete com.clj.service; import org.springframework.transaction.annotation.transactional; import com.clj.dao.customerdao; import com.clj.domain.customer;/** * Customer's Business Layer * @author administrador * */ @transaccionalPublic Public Public public void setCustomerDao (CustomerDao CustomerDao) {this.customerdao = customerDao; } // se usa para guardar el cliente public void save (cliente cliente) {System.out.println ("Layer de negocios, guardar el cliente"); CustomerDao.save (Cliente); }}6. Escribir código relacionado con la acción
Aquí está la clase de plantilla de Struts2
paquete com.clj.web.action; import org.apache.struts2.servletactionContext; import org.springframework.web.context.webapplicationContex com.clj.service.customerservice; import com.opensymphony.xwork2.ActionSupport; import com.opensymphony.xwork2.modeldriven;/** * Customer's Control Layer * @Author Administrator * */public CustomerAction extiende ActionSupport implementa modelos de modelador <Customer> {// no olvidarse de un nuevo cliente privado Manual. Public Customer getModel () {Return Customer; } // Proporcionar atributos de miembro del servicio y proporcionar método establecido Método PRIVADO CLIENTERSIVICE CLIENDESService; public void setCustomerService (CustomerService CustomerService) {this.customerservice = customerservice; } / *** Guardar el cliente* @return* / public string add () {System.out.println ("Web Layer, Guardar el cliente"); // Método 1: Crear la fábrica web (la acción es creada por Struts2) WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext (servletactionContext.getServletContext ()); CLIESSERVICE CS = (CLIENDSERVICE) Context.getBean ("CustomerService"); // Método de llamadas cs.Save (cliente); no devuelve ninguno; }}5. Integración de la optimización del proyecto
1. Spring Integration Struts2 Método 2: La acción se gestiona mediante Spring Framework
Ponga el archivo de configuración de clase de acción específico aplicatonContext.xml en el archivo de configuración, pero nota: Struts.xml debe modificarse
<struts> <!-- Configure package structure--> <package name="crm" extends="struts-default" namespace="/"> <!-- Configure customer's Action --> <!-- Method 1: Aciton is managed by struts2 framework<action name="customer_*" method="{1}"/>---> <!-- Method 2: Action is managed by spring, and only the ID value of the srping configuration Se requiere Bean en la etiqueta de clase-> <Action name = "Customer_*" Method = "{1}"> </olcion> </paquete> </truts>2. Configure la clase de acción en ApplicationContext.xml
Nota: 1) El marco de Spring genera CustomerAction de forma predeterminada, mientras que el marco Struts2 es múltiple. Por lo tanto, debe configurar Scope = "Prototipo"
2) No hay un ensamblaje automático de Struts2 en este momento. En acción, debe configurar manualmente la propiedad del servicio de clientes y generar el método establecido en la clase de acción.
< Solo necesita proporcionar un método establecido. Sin embargo, la acción es administrada por Spring, y el ensamblaje automático no es válido, por lo que debe realizar manualmente la inyección de configuración-> <Property Name = "CLIENSERVICE" REF = "CLIENSEVICE"> </property> </bean>
3. Configurar transacciones
Spring integra el método Hibernate One: (Archivo de configuración con Hibernate.cfg.xml. Enfatizar: la configuración que une el hilo actual no se puede agregar)
En el pasado, al jugar Hibernate, Hibernate.cfg.xml fue administrado por el marco Hibernate. Su archivo de configuración puede generar SessionFactory. La capa de persistencia carga este archivo de configuración para obtener SessionFactory, creando así una sesión generada por fábrica, agregando, eliminando y cambiando los datos. En este momento, su archivo de configuración debe entregarse a la administración de primavera, haciendo un uso completo de las características del COI de Spring.
¡El marco de Spring proporciona una clase de herramientas Hibernadaosupport, que DAO puede heredar en el futuro! ! Antes de introducir el archivo de configuración del núcleo de Hibernate, la capa DAO debe heredar una clase principal Hibernadaosupport, que encapsula la plantilla de transacción internamente.
Ver el código fuente:
1) Modifique la clase de implementación de la capa de persistencia correspondiente y déjela heredar hibernadaosupport
paquete com.clj.dao; import org.springframework.orm.hibernate5.HibernateTemplate; import org.springframework.orm.Hibernate5.support.HibernAdAsadaosupport; import HibernateTemplate internamente * @author Administrator * * /public classDaoImpl extiende Hibernadaosupport implementa CustomerDao {// Guarde los datos en la base de datos (llame a la clase de plantilla (proporcionada por Hibernate, sesión encapsulada) / * HiBernatetEplate de HiBernatepplate de HiBernate; privado; public void sethibernateTemplate (HibernateTemplate HibernateTemplate) {this.HiberNateTemplate = HibernateTemplate; }*// ***Guardar el cliente*/ public void save (cliente cliente) {system.out.println ("capa permanente: guardar el cliente"); this.gethibernateTemplate (). Save (Cliente); }}2) Modifique la capa de negocios y habilite las anotaciones de transacción
paquete com.clj.service; import org.springframework.transaction.annotation.transactional; import com.clj.dao.customerdao; import com.clj.domain.customer;/** * Customer's Business Layer * @author administrador * */ @transaccionalPublic Public Public public void setCustomerDao (CustomerDao CustomerDao) {this.customerdao = customerDao; } // se usa para guardar el cliente public void save (cliente cliente) {System.out.println ("Layer de negocios, guardar el cliente"); CustomerDao.save (Cliente); }}3) Modifique el archivo ApplicationContext.xml
Introduzca primero el archivo de configuración de Hibernate
< value = "classpath: hibernate.cfg.xml"/> </bean>
Configurar la gestión de transacciones de la plataforma: se usa para administrar las transacciones. Tenga en cuenta que el marco Hibernate ahora se usa, por lo que se necesita el administrador de transacciones del marco Hibernate.
<!-Configurar el administrador de transacciones de la plataforma primero-> <bean id = "transaccionManager"> <!-inyectas transacciones, la sesión puede administrar las transacciones y la fábrica puede crear session-> <propiedad name = "sessionFactory" ref = "sessionFactory"/> </ bean>
Anotación de transacción abierta
<
Eliminar la configuración de la clase de plantilla y configurar SessionFactory para la capa de persistencia
< ref = "SessionFactory"/> </bean>
Todos los códigos son los siguientes
<? 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: context = "http://www.springframework.org/schema/context" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: tx = "http://wwww.springframework.org/sChMing" " xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beanss.xsd http://www.springframework.org/schema/contextExt http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd "> <!-escribir frijoles, los nombres se arreglan y se proporcionan por la primavera para cargar el archivo de configuración de hibernate.cfg.xml-> < Ruta de configuración: cuando se inicia el servidor, se creará el objeto, cargando así el archivo hibernate.cfg.xml, generando así el objeto de sessionFactory-> <propiedad name = "configLocation" value = "classpath: hibernate.cfg.xml"/> </bean> <! Configurar la plataforma transaccion gerente primero- <<ran id = "transacciones"> <<!-sesions, la sesión puede administrar la sesión, la sesión puede administrar primero- Transacciones, y la fábrica puede crear Session-> <Property Name = "SessionFactory" ref = "sessionFactory"/> </bean> <!-Annotation para habilitar las transacciones-> <tx: anotación transaccion-ganager = "transacciones managentes"/> <!-Configurar módulos de clientes-> < Scope = "Prototype"> <!-Nota: cuando los puntales manejan las acciones, basado en un paquete JAR con Struts-Plugin, un Struts.ObjectFactory.spring.aUtowire = Name se cambia para activarlo, y se puede ensamblar automáticamente. Solo necesita proporcionar un método establecido. Sin embargo, la acción es administrada por Spring, y el ensamblaje automático no es válido, por lo que debe realizar manualmente la inyección de configuración-> <propiedad = "CustomerService" Ref = "CustomerService"> </Property> </Bean> <Bean Id = "CustomerService"> <Property Name = "CustomerDao" Ref = "CustomerDao"> </Property> </bean> <Bean Id = "CustomerDao" <! name = "HibernateTemplate" ref = "HibernateTemplate"/>-> <!-La clase de plantilla no se inyecta aquí, sino en SessionFactory, porque la plantilla necesita sesión (sesión encapsulada)-> <Property name = "sessionFactory" ref = "sessionFactory"/> </ bean> <!-la clase de plantilla (nombre de propiedad = "sessionfactory"/> es a la brailina a salling. La capa hereda Hibernadaosupport, no es necesario configurar-> <!-<bean id = "hibernateMplate"> inyect sessionFactory <propiedad name = "sessionFactory"/> </bean>-> </les>
4) Modificar la clase de acción
Debido a que se inyecta la clase de implementación de la capa de negocios, el método de la capa comercial se puede llamar directamente en este momento sin cargar el bean
paquete com.clj.web.action; import org.apache.struts2.servletactionContext; import org.springframework.web.context.webapplicationContex com.clj.service.customerservice; import com.opensymphony.xwork2.ActionSupport; import com.opensymphony.xwork2.modeldriven;/** * Customer's Control Layer * @Author Administrator * */public CustomerAction extiende ActionSupport implementa modelos de modelador <Customer> {// no olvidarse de un nuevo cliente privado Manual. Public Customer getModel () {Return Customer; } // Proporcionar atributos de miembro del servicio y proporcionar método establecido Método PRIVADO CLIENTERSIVICE CLIENDESService; public void setCustomerService (CustomerService CustomerService) {this.customerservice = customerservice; } / *** Guardar el cliente* @return* / public string add () {System.out.println ("Web Layer, Guardar el cliente"); // Método 1: Crear la fábrica web (la acción es creada por Struts2) /*WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext (servletactionContext.getServletContext ()); CLIESSERVICE CS = (CLIENDSERVICE) Context.getBean ("CustomerService"); // Método de llamadas cs.Save (cliente); */ CLIENDSERVICE.SAVE (Cliente); no devuelve ninguno; }}Spring Integration Hibernate Método dos: (archivo de configuración sin hibernate.cfg.xml)
Aquí vamos a eliminar el archivo de configuración central de Hibernate. Antes de eliminar, debe configurar el contenido relevante en su archivo de configuración en el archivo ApplicationInContext.xml de Spring para obtenerlo.
1. Verifique el contenido relevante en el archivo hibernate.cfg.xml
* Parámetros básicos de la conexión de base de datos (4 parámetros principales)
* Propiedades relacionadas con el hibernado
* Grupo de conexión
* Mapa de archivos
2. Introducir la configuración
Introducir el grupo de conexión
< <Property name = "Password" Value = "Root"/> </Bean>
Modifique la Factory de Session correspondiente: debido a que no hay un archivo de configuración para Hibernate.cfg.xml, debe modificar la configuración e inyectar el grupo de conexión.
Introducir el archivo de mapeo de objetos: porque el archivo de configuración de hibernate.cfg.xml ya no se escanea, y el archivo de configuración debe inyectarse.
< key = "Hibernate.dialect"> org.hibernate.dialect.mysqldialect </prop> <prot key = "hibernate.show_sql"> true </prop> <p pospil = "hibernate.format_sql"> true </prop> <prot Key = "Hibebernate.hbm2ddl.auto"> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </prop. <!-Introducir archivos de configuración de mapeo-> <propiedad name = "mappingResources"> <list> <value> com/clj/domain/customer.hbm.xml </valor> </list> </property> </bean>
Ahora: el código AplicationContext.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: context = "http://www.springframework.org/schema/context" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: tx = "http://wwww.springframework.org/sChMing" " xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beanss.xsd http://www.springframework.org/schema/contextExt http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd "> <!-Configure el grupo de conexión para c3p0 primero-> <bean id =" dataSource "> <name de propiedad =" controladorclass " value="com.mysql.jdbc.Driver"/> <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/> <property name="user" value="root"/> <property name="password" value="root"/> </bean> <!-- Write beans, the names are fixed, and are provided by spring to Cargue el archivo de configuración de hibernate.cfg.xml-> <bean id = "sessionFactory"> <!-Cargue el grupo de conexión primero-> <propiedad name = "dataSource" ref = "dataSource"/> <!-Cargue el dialecto, las opciones de carga-> <propiedad = "HibernateProperties"> <props> <Props> <Prop. key = "Hibernate.dialect"> org.hibernate.dialect.mysqldialect </prop> <prot key = "hibernate.show_sql"> true </prop> <p pospil = "hibernate.format_sql"> true </prop> <prot Key = "Hibebernate.hbm2ddl.auto"> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </props> </prop. <!-inyectar el archivo de configuración de asignación-> <propiedad name = "mappingResources"> <list> <alue> com/clj/domain/customer.hbm.xml </alon value> </list> </property> </bean> <!-Configurar el administrador de transacciones de plataforma name = "sessionFactory" ref = "sessionFactory"/> </ bean> <!-anotación para abrir transacciones-ganager = "transaccionManager"/> <!-Configure el módulo de cliente-> <!-enfatizar: el aciton configurado debe ser multi-columna múltiple-> <bean id = "customeraction" scope = "prototipo"> <! Notas: cuando se struts gestions, basado en las acciones, basadas en un paquete de jarras de jar, a los struts con un paquete de jarras de jars, a los struts con un paquete de jarras de jars, a los struts con un paquete de jarras de jars, a los struts con un paquete de jarras de jar, a los struts con un paquete de jarras de jars. constante struts.objectFactory.spring.autowire = El nombre se ha vuelto y puede ensamblarse automáticamente. Solo necesita proporcionar el método establecido. However, the action is managed by spring and the automatic assembly is invalid, so you need to manually perform configuration injection--> <property name="customerService" ref="customerService"></property> </bean> <bean id="customerService"> <property name="customerDao" ref="customerDao"></property> </bean> <!-- In the future, Dao needs to inherit HibernateDaoSupport and inject sessionFactory --> <bean id="customerDao"> <!--<property name="hibernateTemplate" ref="hibernateTemplate"/> -> <!-- The template class is not injected here, but sessionFactory, because the template needs session (encapsulated session)--> <property name="sessionFactory" ref="sessionFactory"/> </bean> <!-- Configure the template class (provided by the hibernate framework, encapsulated session) and is handed over to spring management at this time. If the persistence layer inherits HibernateDaoSupport, there is no need to configure --> <!-- <bean id="hibernateTemplate"> Inject sessionFactory <property name="sessionFactory"/> </bean>--></beans>
此时可以安心的删除hibernate.cfg.xml文件了
这样SSH整合完毕
六、Hibernate模板常用方法
注意：以下代码省略了接口中的演示(偷了个懒，相信初学者不会看不懂)
1）插入：
Capa persistente
package com.clj.dao;import java.util.List;import org.hibernate.criterion.DetachedCriteria;import org.springframework.orm.hibernate5.HibernateTemplate;import org.springframework.orm.hibernate5.support.HibernateDaoSupport;import com.clj.domain.Customer;/** * Persistence layer* Inherits HibernateDaoSupport and encapsulates HibernateTemplate internally * @author Administrator * */public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao { @Override public void update(Customer customer) { // TODO Auto-generated method stub this.getHibernateTemplate().update(customer); }}业务层
package com.clj.service;import java.util.List;import org.springframework.transaction.annotation.Transactional;import com.clj.dao.CustomerDao;import com.clj.domain.Customer;/** * Customer's business layer* @author Administrator * */@Transactionalpublic class CustomerServiceImpl implements CustomerService{ private CustomerDao customerDao; public void setCustomerDao(CustomerDao customerDao) { this.customerDao = customerDao; } @Override public void update(Customer customer) { // TODO Auto-generated method stub customerDao.update(customer); }}测试类
package com.clj.test;import java.util.List;import javax.annotation.Resource;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;import com.clj.domain.Customer;import com.clj.service.CustomerService;/** * Simple way to test Hiberante template class* @author Administrator * */@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext.xml")public class Demo1 { @Resource(name="customerService") private CustomerService customerService; /** * Test insert*/ @Test public void run1(){ Customer customer=new Customer(); customer.setCust_id(1L); customer.setCust_name("test"); customerService.update(customer); }}2）以下为指定查询、查询所有、离线查询代码
Capa persistente
package com.clj.dao;import java.util.List;import org.hibernate.criterion.DetachedCriteria;import org.springframework.orm.hibernate5.HibernateTemplate;import org.springframework.orm.hibernate5.support.HibernateDaoSupport;import com.clj.domain.Customer;/** * Persistence layer* Inherits HibernateDaoSupport and encapsulates HibernateTemplate internally * @author Administrator * */public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao { //Save data to the database (call template class (provided by hibernate, encapsulated session)) /*private HibernateTemplate hibernateTemplate; public void setHibernateTemplate(HibernateTemplate hibernateTemplate) { this.hibernateTemplate = hibernateTemplate; }*/ /** * Save customer*/ public void save(Customer customer) { System.out.println("Permanent layer: save customer"); this.getHibernateTemplate().save(customer); } @Override public void update(Customer customer) { // TODO Auto-generated method stub this.getHibernateTemplate().update(customer); } /** * Query by primary key*/ public Customer getById(Long id) { return this.getHibernateTemplate().get(Customer.class, id); } /** * Query all*/ @Override public List<Customer> findAll() { String sql="from Customer"; List<Customer> list=(List<Customer>) this.getHibernateTemplate().find(sql); return list; } /** * QBC offline query*/ @Override public List<Customer> findAllByQBC() { DetachedCriteria criteria=DetachedCriteria.forClass(Customer.class); List<Customer> list=(List<Customer>) this.getHibernateTemplate().findByCriteria(criteria); return list; }}业务层
package com.clj.service;import java.util.List;import org.springframework.transaction.annotation.Transactional;import com.clj.dao.CustomerDao;import com.clj.domain.Customer;/** * Customer's business layer* @author Administrator * */@Transactionalpublic class CustomerServiceImpl implements CustomerService{ private CustomerDao customerDao; public void setCustomerDao(CustomerDao customerDao) { this.customerDao = customerDao; } //Use to save customers public void save(Customer customer) { System.out.println("Business layer, save customer"); customerDao.save(customer); } @Override public void update(Customer customer) { // TODO Auto-generated method stub customerDao.update(customer); } @Override public Customer getById(Long id) { // TODO Auto-generated method stub return customerDao.getById(id); } @Override public List<Customer> findAll() { return customerDao.findAll(); } @Override public List<Customer> findAllByQBC() { // TODO Auto-generated method stub return customerDao.findAllByQBC(); }}测试类
package com.clj.test;import java.util.List;import javax.annotation.Resource;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;import com.clj.domain.Customer;import com.clj.service.CustomerService;/** * 测试Hiberante模板类的简单方法* @author Administrator * */@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext.xml")public class Demo1 { @Resource(name="customerService") private CustomerService customerService; /** * 测试插入*/ @Test public void run1(){ Customer customer=new Customer(); customer.setCust_id(1L); customer.setCust_name("测试"); customerService.update(customer); } /** * 测试查询指定的客户*/ @Test public void run2(){ Customer customer=customerService.getById(2L); System.out.println(customer); } /** * 查询所有的客户*/ @Test public void run3(){ List<Customer> list=customerService.findAll(); System.out.println(list); } /** * QBC(离线查询) */ @Test public void run4(){ List<Customer> list=customerService.findAllByQBC(); System.out.println(list); }}七、关于SSH延迟加载问题
1. 使用延迟加载的时候，再WEB层查询对象的时候程序会抛出异常！
* 原因是延迟加载还没有发生SQL语句，在业务层session对象就已经销毁了，所以查询到的JavaBean对象已经变成了托管态对象！
* 注意：一定要先删除javassist-3.11.0.GA.jar包（jar包冲突了）
2. 解决办法
Spring框架提供了一个过滤器，让session对象在WEB层就创建，在WEB层销毁。只需要配置该过滤器即可
* 但是：要注意需要在struts2的核心过滤器之前进行，spring监听器之后配置
<!-- 解决延迟加载的问题--> <filter> <filter-name>OpenSessionInViewFilter</filter-name> <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class> </filter> <filter-mapping> <filter-name>OpenSessionInViewFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
3、演示延迟加载
持久层：调用load方法，此方法时延迟加载的
/** * 延迟加载*/ @Override public Customer loadById(long id) { // TODO Auto-generated method stub return this.getHibernateTemplate().load(Customer.class, id); }业务层
@Override public Customer loadById(long id) { // TODO Auto-generated method stub return customerDao.loadById(id); }测试类
@Test public void run5(){ Customer customer=customerService.loadById(2L); System.out.println(customer); }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.