Integração da estrutura SSH
Prefácio: Algumas pessoas dizem que a estrutura convencional ainda é popular agora, e o SSM está fora há muito tempo, muito menos SSH. Eu não acho. Atualmente, muitas empresas ainda usam o SSH e, se mudarem para estruturas convencionais, isso custará. Por exemplo, no campo de TI financeiro, é recomendável usar o Hibernate na camada de banco de dados, pois pode ser desenvolvido rapidamente, a menos que seja a Internet. Como envolve alta simultaneidade, a camada de banco de dados usa MyBatis, que possui uma eficiência de interação de dados mais rápida. Portanto, o SSH não pode ser ignorado.
1. O que é SSH
O SSH é uma estrutura integrada de Struts+Spring+Hibernate e atualmente é uma estrutura popular de código aberto para aplicativos da Web.
O sistema que integra a estrutura SSH é dividido em quatro camadas em termos de responsabilidades: camada de apresentação, camada lógica de negócios, camada de persistência de dados e camada de módulo de domínio para ajudar os desenvolvedores a criar aplicativos da Web com estrutura clara, boa reutilização e manutenção conveniente a curto prazo. Entre eles, os suportes são usados como a infraestrutura geral do sistema, responsável pela separação do MVC, e na parte modelo da estrutura do Struts, controlando saltos de negócios, usando a estrutura do hibernato para fornecer suporte à camada de persistência, a primavera gerencia, gerencia as suportes e o hibernato. A abordagem específica é: use métodos de análise orientados a objetos para propor alguns modelos de acordo com as necessidades, implemente esses modelos como objetos Java básicos e, em seguida, escreva a interface BASIC DAO (Data Access Objects) e forneça a implementação do Hibernato do DAO. A classe DAO implementada pela arquitetura Hibernate é usada para realizar a conversão e o acesso entre classes e bancos de dados Java. Finalmente, a primavera gerencia e gerencia suportes e hiberna.
---------- Enciclopédia Baidu
2. As peças envolvidas no SSH
3. Rápida implantação do meio ambiente
Aqui usamos uma pequena demonstração para salvar os clientes para demonstrar a integração do SSH
1. Importe o pacote de jar exigido
1). Estrutura de struts2
* Struts-2.3.24/APPS/STRUTS2-BLANK/WEB-INF/LIB/* JAR-Todos os pacotes JAR exigidos por Struts2
* struts2-spring-plugin-2.3.24.jar --- struts2 integra
2). Estrutura de hibernação
* Hibernate-lançamento-5.0.7.final/lib/required/*.jar-pacote JAR exigido pela Hibernate Framework
* slf4j-api-1.6.1.jar-interface de log
* SLF4J-LOG4J12-1.7.2.JAR-Implementação de log
* MySQL-Connector-Java-5.1.7-bin.jar-pacote de driver MySQL
3). Estrutura de primavera
* Pacote principal do IOC
* AOP Core Package
* Modelos JDBC e pacotes de núcleo de transação
* Spring integra o pacote de teste Junit
* A primavera integra o pacote de núcleo de hibernato
* Spring integra o pacote de núcleo STRUTS2
2. Configure o código relacionado à mola e as suportes em web.xml
1) Configurar o filtro de núcleo do Struts2
Isso é definido como interceptar tudo
<!-Configure o filtro do núcleo-> <filter> <filter-name> struts2 </filter-name> <filter-class> org.apache.struts2.dispatcher.ng.filter.strutsprepareandExecuteFilter </filter-Class> </filter> <filtro-mapping> <filtroname> struts2 </nir-cass> <lter-spaging> <filter-Mapping> <filter-Name> <url-pattern>/*</url-tattern> </filter-Mapping>
2) Configure o ouvinte da primavera
Quando o serviço começar, o arquivo de configuração da mola será carregado primeiro
<!-Configure o ouvinte para a estrutura da mola integração da Web-> <Ilvier> <lister-class> org.springframework.web.context.contextloaderListener </lister-class> </sincener>
3) Configure o caminho de carregamento padrão
<!-O ouvinte carrega o arquivo Web-Inf por padrão. Você precisa configurar parâmetros para carregar o arquivo especificado-> <Context-param> <amam-name> contextConfigLocation </param-name> <amam-value> classPath: ApplicationContext.xml </param-value> </context-param>
Resumo: Todos os códigos para web.xml são
<!-Configure o ouvinte que integra a Web na estrutura da primavera-> <Ilvier> <lister-class> org.springframework.web.context.contextloaderListener </ouvinte-class </ouvinte> <!-o arquivo de ladra do ladrão o arquivo web-inf por default e requer a configuração para a configuração para carregar o arquivo de ladrão para o ladiro para o ladiro, e requer a configuração do ladrão para o ladrão do ladrão do ladrão, e requer a configuração do arquivo de ladrão e requer que seja o ladiro para o ladrão do arquivo web-inf. <amam-name> contextConfigLocation </param-name> <amam-value> ClassPath: ApplicationContext.xml </param-value> </context-param> <!-Configure Filters Core-> <filter> <filter-Name> struts2 </filter-name> <filter-class> org.apache.struts2.dispatcher.ng.filter.strutsprepareAndExecuteFilter </filter-Class> </ftrhter> <filter-mapping> <filter-name> struts2 </ftrhter-name> <url-pattern>/*</url-pattern> </filter-mapping>
2. Escreva arquivos de configuração relevantes em SRC
1) Spring: ApplicationContext.xml
Importar restrições relacionadas
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context 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) Hibernato: hibernate.cfg.xml
Importar restrições relevantes e configurar o banco de dados
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration> <Session-Factory> <!-deve configurar-> <propriedade name = "hibernate.connection.driver_class"> com.mysql.jdbc.driver </property> <names name = hibernate.connection.url "> jdbc: mysql: //192.168.174.1740: name = "hibernate.connection.username"> root </propriedade> <propriedade name = "hibernate.connection.password"> root </propriedade> <propriedade name = "hibernate.dialect"> org.hibernate.dialect.mysqldialect </propriedades> <! name = "hibernate.format_sql"> true </propriedade> <propriedade name = "hibernate.hbm2ddl.auto"> update </propriedade> <!-configure pool de conexão para c3p0-> <propriedades name = "conexão.Provider_class"> org.ibernate.connection.c3p0s) -> <!-Arquivo de configuração de mapeamento-> <Mapping Resource = "com/clj/domain/cliente.hbm.xml"/> </session-factory> </hibernate-configuration>
3) Configure log4j.properties
### Mensagens de log direto para stdout ###log4j.appender.stdout=org.apache.log4j.ConsoleAppenderlog4j.appender.stdout.Target=System.errlog4j.appender.stdout.layout=org.apache.log4j.PatternLayoutlog4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %C {1}: %L - %M %N ### Mensagens diretas para arquivar MyLog.log ### log4j.appender.file = org.apache.log4j.FileAppenderLog4j.appender.file.file = c/: mylog.loglog4j.appender.file.pender.file = org.apache.log4j.patternLayoutLog4j.pender.files %C {1}: %L - %M %N ### Defina os níveis de log - para mais alterações detalhadas do log 'info' para 'Debug' ### log4j.rootlogger = info, stdout4) Struts2: struts.xml
Importar restrições relacionadas
<? xml versão = "1.0" coding = "utf-8"?> <! Doctype suporta public "-// Apache Software Foundation // DTD Struts Configuration 2.1 // en" "http://struts.apache.org/dds/stuts-2.3.dtd"> <strts>
Resumo: O arquivo de configuração exigido pelo SRC é mostrado na figura
3. Configure a camada DAO
Defina uma interface e sua classe de implementação
interface pública CustomerDao {public void Save (cliente do cliente);} public class CustomerDaoImpl implementa CustomerDao {public void Save (cliente do cliente) {}}4. Defina a interface da camada de negócios e a classe de implementação
pacote com.clj.service; importar com.clj.domain.customer; interface pública CustomerService {public void save (cliente cliente);}pacote com.clj.service; importar org.springframework.transaction.annotation.transaction; import com.clj.dao.customerdao; importar com.clj.domain.customer;/** ** * Customer's Business Cayer * @Author Administrator */public class CustomersPlemmentsMplements; }}
5. Defina a aula de Pojo
O Hibernate opera tabelas de banco de dados, operando as classes de Pojo para alcançar o mapeamento de objeto-relacional
pacote com.clj.Domain; public class Customer {private Long cust_id; String privada cust_name; Private longo cust_user_id; Private longo cust_create_id; String privada cust_source; String privada cust_industry; String privada cust_level; String privada cust_linkman; String privada cust_phone; String 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 "client [cust_id =" + cust_id + ", cust_name =" + cust_name + ", cust_user_id =" + custc_user_id + ", cust_create_id =" + custe_create_id + ", custe_source =" +_source_id = " +" + "ind + "," + cust_level + ", cust_linkman =" + cust_linkman + ", cust_phone =" + cust_phone + ", cust_mobile =" + cust_mobile + "]"; }}6. Defina o cliente.hbm.xml
Este arquivo de configuração está relacionado à classe Pojo do cliente. Este arquivo precisa ser colocado no mesmo pacote que a classe Pojo do cliente
<? xml versão = "1.0" coding = "utf-8"?> <! name = "com.clj.domain.customer" tabela = "cst_customer"> <id name = "custe_id" column = "cust_id"> <gerator/> </dod> <names_useat_id_id "column =" cusp_name "/> <names =" cust_useat_id "column = cust =" column="cust_create_id"/> <property name="cust_source" column="cust_source"/> <property name="cust_industry" column="cust_industry"/> <property name="cust_level" column="cust_level"/> <property name="cust_linkman" column="cust_linkman"/> <property name="cust_linkman"/> <property name = "cust_phone" column = "cust_phone"/> <propriedade name = "cust_mobile" colun = "cust_mobile"/> </class> </hibernate-mapping>
Diagrama de construção do projeto
4. Demonstração preliminar de demonstração para preservação de clientes
Aqui, primeiro definimos a camada de persistência para Heibernate, a camada de negócios para Struts2 e a instância de criação para a primavera
1. Defina uma interface para salvar os clientes e usar o formulário para enviar dados
De acordo com o nome de domínio, podemos ver que o método curinga do STRUTS2 é usado para acesso.
<Form id = form1 name = form1 action = "$ {PageContext.request.ContextPath} /customer_add.action" Method = post> <!-Parte da tabela omitida-> </morm>2. Configurar aceitar solicitações no struts.xml, pule para a ação especificada de acordo com o nome e o método da ação e execute o método especificado
Spring integra o método STRUTS2 One: Ação é gerenciada pela estrutura STRUTS2
* Como o pacote importado STRUTS2-SPRING-PLUGIN-2.3.24.JAR vem com um arquivo de configuração Struts-plugin.xml, o código a seguir é incluído no arquivo de configuração
* <nome constante = "structs.ObjectFactory" value = "spring" /> ligue uma constante. Se a constante estiver ligada, a seguinte constante poderá ser usada
* struts.ObjectFactory.spring.autowire = nome, esta constante é uma classe que permite que a ação monte automaticamente os objetos de feijão!
<? xml versão = "1.0" coding = "utf-8"?> <! Doctype suporta public "-// Apache Software Foundation // DTD Struts Configuration 2.1 // pt" "http://struts.apache.org/dts/struts-2.3.dtp" <stuts> <Struts> <! estends = "Struts-Default" Namespace = "/"> <!-Configurar Ação do Cliente-> <!-Método 1: O ACiton é gerenciado pelo Struts2 Framework-> <Action Name = "Customer_*" Method = "{1}"/> </catury> </truts>3. Configure os feijões e transações correspondentes no Spring ApplicationContext.xml
Aqui, usando o recurso IOC (Control Inversão) na primavera, a tarefa de criar uma instância é entregue ao Spring Framework Management
<bean id = "CustomerService"> <Propriedade name = "CustomerDao" ref = "CustomerDao"> </Property> </bean> <bean id = "CustomerDao"> <Nome da propriedade "HIBERNATETEMPLATE" RefR = "Hibernatetemplate"/> </Bean> <Bean ID = "Hibernatetem. </ Bean> </ Beans>
4. Escreva o código relacionado à classe de implementação da camada de persistência
Aqui, a classe de modelo fornecida pelo Hibernate é usada para incluir a sessão internamente, para que o método na sessão possa ser chamado.
/** * Camada de persistência * * @Author Administrator * */public class CustomerDaoImpl implementa CustomerDao {// Salvar dados no banco de dados (classe de modelo de chamada (fornecida por hibernação, sessão encapsulada internamente)) private HibernateTemplate hibernateMplate; public void Sethibernatetemplate (hibernateTemplate hibernatetemplate) {this.hibernateTemplate = hibernateTEMplate; } / *** Salvar cliente* / public void Save (cliente do cliente) {System.out.println ("Camada permanente: salvar cliente"); hibernateTemplate (). salvar (cliente); }}5. Escreva o código relacionado à classe de implementação de camadas de negócios
pacote com.clj.service; importar org.springframework.transaction.annotation.transaction; importação public void setCustomerDao (CustomerDao CustomerDao) {this.customerdao = CustomerDao; } // usado para salvar o cliente vazio público (cliente) {System.out.println ("camada de negócios, salve o cliente"); Customerdao.save (Cliente); }}6. Escreva o código relacionado à ação
Aqui está a classe de modelo de struts2
pacote com.clj.web.action; importar org.apache.struts2.ServletActionContext; importar org.springframework.web.context.webapplicationcontext; import.springframework.web.context.support.webplicationContetworks; com.clj.service.customerService; import com.opensymphony.xwork2.actionupport; importar com.opensymphony.xwork2.modeldriven;/** * Customer da camada de controle do cliente * @Author Administrator * */public class CustomerAction Ações Ações suportes) (cliente) (cliente; cliente público getModel () {retornar cliente; } // Forneça atributos do membro de serviço e fornece método de conjunto de clientes privados Customers Service; public void setCustomerService (CustomerService CustomerService) {this.customerService = CustomerService; } / *** Salvar o cliente* @return* / public string add () {System.out.println ("camada da web, salve o cliente"); // Método 1: Crie a fábrica da web (ação é criada por struts2) webApplicationContext context = webApplicationContextutils.getwebApplicationContext (servletActionContext.getServletContext ()); CustomerService CS = (CustomerService) Context.getBean ("CustomerService"); // Método de chamada CS.Save (Cliente); retornar nenhum; }}5. Integração da otimização do projeto
1. Spring Integration Struts2 Método 2: A ação é gerenciada pela Spring Framework
Coloque o arquivo de configuração da classe de ação específico ApplicatonContext.xml no arquivo de configuração, mas note: struts.xml precisa ser modificado
<Truts> <!-Configurar a estrutura do pacote-> <names do pacote = "Crm" estends = "struts-Default" Namespace = "/"> <!-Configurar a ação do cliente-> <!-Método 1: ACiton é gerenciado por Struts2 Framework <Ação = "Customer_*": "" {1} "/> O feijão de configuração é necessário na tag de classe-> <ação name = "cliente_*" method = "{1}"> </action> </package> </stuts>2. Configure a classe de ação em ApplicationContext.xml
NOTA: 1) A estrutura da mola gera o clienteamento por padrão, enquanto a estrutura do STRUTS2 é múltipla. Então você precisa configurar Scope = "Prototype"
2) Não há montagem automática de Struts2 neste momento. Em ação, você precisa configurar manualmente a propriedade CustomerService e gerar o método definido na classe de ação.
<!-Configurar o módulo do cliente-> <!-enfatizar: o Aciton configurado deve ser multi-coluna-> <bean id = "CustomerAction" scope = "protótipo"> <!-Nota: Quando os struts gerenciam as ações, com base em um pacote de jar com suporte. Você só precisa fornecer um método definido. No entanto, a ação é gerenciada pela primavera e a montagem automática é inválida; portanto, você precisa executar manualmente a injeção de configuração-> <nome da propriedade = "CustomerService" ref = "CustomerService"> </propriedade> </i bean>
3. Configure transações
A primavera integra o método Hibernate um: (arquivo de configuração com hibernate.cfg.xml.
No passado, ao tocar hibernato, o hibernate.cfg.xml era gerenciado pela estrutura do hibernato. Seu arquivo de configuração pode gerar sessionFactory. A camada de persistência carrega esse arquivo de configuração para obter o SessionFactory, criando assim uma sessão gerada por fábrica, adicionando, excluindo e transformando dados. No momento, seu arquivo de configuração deve ser entregue ao gerenciamento da primavera, fazendo pleno uso das características do COI da primavera.
A estrutura da primavera fornece uma classe de ferramentas HibernatedAosupport, que pode ser herdada no futuro por Dao! ! Antes de introduzir o arquivo de configuração do núcleo do hibernato, a camada DAO deve herdar uma classe pai Hibernatedaosupport, que encapsula o modelo de transação internamente.
Veja o código -fonte:
1) Modifique a classe de implementação da camada de persistência correspondente e deixe -a herdar HibernateAosupport
pacote com.clj.dao; importar org.springframework.orm.hibernate5.hibernatetemplate; importar org.springframework.orm.hibernate5.support.hibernateDaosupport; importematiBertAtEnSUBNURITSUNDERASTERASTERASURITESMIBRANDORES HIBERNATHEROSSUMIRAIRITESSUMBERNATHEROSTEROS HIBERNATHERASURITOS HIBERNATHOROSSUBRANDORES (** ** **) @Author Administrator * * /classe pública CustomerDaoImpl estende o Hibernatedaosupport implementa o cliente {// salve os dados no banco de dados (ligue para a classe de modelo (fornecida por hibernato, sessão encapsulada)) / *Private Hibernatetemplate hibernateMplate; public void Sethibernatetemplate (hibernateTemplate hibernatetemplate) {this.hibernateTemplate = hibernateTEMplate; }*// ***salve o cliente*/ public void save (cliente cliente) {System.out.println ("Camada permanente: salve o cliente"); this.gethibernateTemplate (). salvar (cliente); }}2) Modificar a camada de negócios e ativar as anotações de transações
pacote com.clj.service; importar org.springframework.transaction.annotation.transaction; importação public void setCustomerDao (CustomerDao CustomerDao) {this.customerdao = CustomerDao; } // usado para salvar o cliente vazio público (cliente) {System.out.println ("camada de negócios, salve o cliente"); Customerdao.save (Cliente); }}3) Modifique o arquivo ApplicationContext.xml
Apresente o arquivo de configuração do hibernato primeiro
<!-Escreva feijões, os nomes são corrigidos, fornecidos pela primavera, usados para carregar o arquivo de configuração do hibernate.cfg.xml-> <bean id = "sessionFactory"> <!-Caminho de configuração: Quando o servidor é iniciado, o objeto será criado, o objeto é criado assim, o objeto de sessão: "File" " value = "ClassPath: hibernate.cfg.xml"/> </i bean>
Configure o gerenciamento de transações da plataforma: usado para gerenciar transações. Observe que a estrutura Hibernate agora é usada, portanto, é necessário o gerente de transação da estrutura do hibernato.
<!-Configurar o gerenciador de transações da plataforma First-> <bean id = "transactionManager"> <!-Injetar transações, a sessão pode gerenciar transações e a fábrica pode criar sessão-> <names name = "sessionFactory" ref = "sessionFactory"/> </ Bean>
Anotação de transação aberta
<!-anotação para ativar a transação-> <tx: transação orientada por anotação-manager = "transactionManager"/>
Remova a configuração da classe de modelo e configure o SessionFactory para camada de persistência
<!-- 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"/> </i Bean>
Todos os códigos são os seguintes
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context 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 "> <!-Write Beans, os nomes são fixados e são fornecidos pela primavera-> FILHO DO HIBN" <!-Caminho de configuração: Quando o servidor for iniciado, o objeto será criado, carregando assim o arquivo hibernate.cfg.xml, gerando assim o objeto SessionFactory-> <propriedades name = "configLocation" value = "Classpath: hibernate.cfg.xml"/> </bEAN> <!-Configure Managester The Platforming the Platforming the Platforming the Platformin " Transações, a sessão pode gerenciar transações e a fábrica pode criar sessão-> <propriedade name = "sessionFactory" ref = "sessionFactory"/> </i bean> <!-anotação para ativar transações-> <tx: anotation-driven transaction-manager = "transação id = "CustomerAction" scope = "prototype"> <!-Nota: Quando o Struts gerencia ações, com base em um pacote de jar com suportes-plugin, um struts constante. Você só precisa fornecer um método definido. 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> <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> <!-- The template class (property name="sessionFactory"/> is provided to spring management at this time. If the persistence layer herda o Hibernatedaosupport, não há necessidade de configurar-> <!-<bean id = "hibernateTemplate"> injetar sessionFactory <propriedades name = "sessionFactory"/> </i bean>-> </ Beans>
4) Modifique a classe de ação
Como a classe de implementação da camada de negócios é injetada, o método da camada de negócios pode ser chamado diretamente neste momento sem carregar o feijão
pacote com.clj.web.action; importar org.apache.struts2.ServletActionContext; importar org.springframework.web.context.webapplicationcontext; import.springframework.web.context.support.webplicationContetworks; com.clj.service.customerService; import com.opensymphony.xwork2.actionupport; importar com.opensymphony.xwork2.modeldriven;/** * Customer da camada de controle do cliente * @Author Administrator * */public class CustomerAction Ações Ações suportes) (cliente) (cliente; cliente público getModel () {retornar cliente; } // Forneça atributos do membro de serviço e fornece método de conjunto de clientes privados Customers Service; public void setCustomerService (CustomerService CustomerService) {this.customerService = CustomerService; } / *** Salvar o cliente* @return* / public string add () {System.out.println ("camada da web, salve o cliente"); // Método 1: Crie a fábrica da web (a ação é criada por struts2) /*webApplicationContext context = webApplicationContextutils.getwebApplicationContext (servletActionContext.getServletContext ()); CustomerService CS = (CustomerService) Context.getBean ("CustomerService"); // Método de chamada CS.Save (Cliente); */ CustomerService.Save (Cliente); retornar nenhum; }}Integração da mola Hibernate Método dois: (arquivo de configuração sem hibernate.cfg.xml)
Aqui vamos excluir o arquivo de configuração principal do Hibernate. Antes de excluir, você precisa configurar o conteúdo relevante em seu arquivo de configuração para o arquivo ApplicationIncOntext.xml do Spring Application.xml para obtê -lo.
1. Verifique o conteúdo relevante no arquivo hibernate.cfg.xml
* Parâmetros básicos da conexão do banco de dados (4 parâmetros principais)
* Propriedades relacionadas ao hibernato
* Pool de conexão
* Arquivos de mapa
2. Introduzir configuração
Introduzir pool de conexões
<!-Configure o pool de conexão para C3P0 primeiro-> <bean id = "DataSource"> <propriedade name = "driverclass" value = "com.mysql.jdbc.driver"/> <nome da propriedade = "jdbcurl" = "jdbc: mysql: //192.18.177.1740:" value = "root"/> <names name = "senha" value = "root"/> </bean>
Modifique a sessão correspondente: como não há arquivo de configuração para hibernate.cfg.xml, você precisa modificar a configuração e injetar o pool de conexão.
Introduzir Arquivo de mapeamento de objetos: porque o arquivo de configuração do hibernate.cfg.xml não é mais digitalizado e o arquivo de configuração precisa ser injetado.
<!-- Write beans, the names are fixed, and are provided by spring to load the configuration file of hibernate.cfg.xml --> <bean id="sessionFactory"> <!--Load the connection pool first-> <property name="dataSource" ref="dataSource"/> <!--Load dialect, load options--> <property name="hibernateProperties"> <props> <prop key = "hibernate.dialect"> org.hibernate.dialect.mysqldialect </prop> <propra "" hibernate.show_sql "> true </pp> <prop) </key =" hibernate.format_sql "> true </prop> <pr key =" hibernate.hbm2dddddddddddddddddddddt_sql "> <!-Introduzir arquivos de configuração de mapeamento-> <propriedade name = "mappingResources"> <lista> <valor> com/clj/domain/alteração.hbm.xml </value> </list> </ferirs> </ean>
Agora: o código ApplicationContext.xml é o seguinte
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context 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/springs-tx.xsd "> <!-Configure o pool de conexão para C3P0 primeiro-> <Bean id =" value = "com.mysql.jdbc.driver"/> <propriedade name = "jdbcurl" value = "jdbc: mysql: //192.168.174.130: 3306/ssh"/> <nome da propriedade = "user" = "root"/> <nomes = "senha" "" "" "/>"), que ",", ", o nome do ssh", o que é o que é o que é o que você está fazendo. Mola para carregar o arquivo de configuração de hibernate.cfg.xml-> <bean id = "sessionFactory"> <!-Carregue o pool de conexões primeiro-> <name da propriedade = "DataSource" ref = "DataSource"/> <!-Carregar dialeto, carregar opções-> <nome da propriedade = "hibernateProPerts" <! key = "hibernate.dialect"> org.hibernate.dialect.mysqldialect </prop> <propra "" hibernate.show_sql "> true </pp> <prop) </key =" hibernate.format_sql "> true </prop> <pr key =" hibernate.hbm2dddddddddddddddddddddt_sql "> <!-Injete o arquivo de configuração de mapeamento-> <propriedade name = "mappingResources"> <list> <value> com/clj/domain/alteração.hbm.xml </value> </list> </propriedade> </bean> <!-configure a plataforma gerenciador de transação, <ban id = "transactmanager"> <! -> <propriedade name = "sessionFactory" ref = "sessionFactory"/> </ Bean> <!-anotação para abertura da transação-manager = "transactionManager"/> <!-Configurar o módulo do cliente-> <!-Strato "strato: o sloType", com o pacote de um rótulo. Struts-plugin, um struts constante. Você só precisa fornecer o método de conjunto. No entanto, a ação é gerenciada pela primavera e a montagem automática é inválida; portanto, você precisa executar manualmente a injeção de configuração-> <nome da propriedade = "CustomerService" ref = "CustomerService"> </silomer HibernateDaosuport e injete sessionfactory-> <bean id = "CustomerDao"> <!-<propriedade name = "hibernateTemplate" ref = "hibernateTemplate"/>-> <!-a classe de modelo não está injetada aqui, mas a sessão de sessão, porque a sessão de sessão "<! <!- Configure a classe de modelo (fornecida pela estrutura Hibernate, sessão encapsulada) e é entregue ao gerenciamento da primavera neste momento. 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）插入：
Camada 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); }}Camada de negócios
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）以下为指定查询、查询所有、离线查询代码
Camada 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; }}Camada de negócios
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; } // Used 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;/** * 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); } /** * Test query the specified customer*/ @Test public void run2(){ Customer customer=customerService.getById(2L); System.out.println(customer); } /** * Query all customers*/ @Test public void run3(){ List<Customer> list=customerService.findAll(); System.out.println (list); } /** * QBC(offline query) */ @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. Solução
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方法，此方法时延迟加载的
/** * Lazy load*/ @Override public Customer loadById(long id) { // TODO Auto-generated method stub return this.getHibernateTemplate().load(Customer.class, id); }Camada de negócios
@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); }O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.