Prefácio
O SSH não é uma estrutura, mas uma integração de várias estruturas (struts+mola+hibernato). Atualmente, é uma estrutura popular de integração de código aberto para aplicativos da Web, usado para criar aplicativos da Web flexíveis e fáceis de escalar as várias camadas.
O sistema que integra a estrutura SSH é dividido em quatro camadas em termos de responsabilidade: camada de apresentação, camada de lógica de negócios, camada de persistência de dados e camada de módulo de domínio (camada de entidade).
Como infraestrutura geral do sistema, o STRuts é responsável pela separação do MVC. Na parte do modelo da estrutura do Struts, ele controla saltos de negócios e usa a estrutura Hibernate para fornecer suporte à camada de persistência. Por um lado, o Spring é um contêiner leve IOC, responsável por encontrar, posicionar, criar e gerenciar dependências entre objetos e objetos e, por outro lado, pode melhorar o trabalho e o hibernato.
Use o Myeclipse para integrar as três principais estruturas SSH e implementar uma demonstração que simula o registro do usuário, correspondente à versão:
Versão de struts: 2.1;
Versão da primavera: 3.1;
Versão de hibernato: 3.3;
1. Preparação antes da integração
1. Crie um projeto da web da seguinte maneira:
Nota: O nome do pacote que suporta a ação deve ser "ação", e a classe de ação deve terminar com ação, ou seja, a forma é como xxxação, como mostrado na figura acima
2. Crie um banco de dados e tabela:
Criar banco de dados sshdemo; Crie Tabela T_User (ID int Primary Key, Nome de usuário Varchar (10), Senha Varchar (20))
3. Importe o pacote do pool de conexão com o banco de dados C3P0JAR, clique para baixar:
C3P0-0.9.2-PRE1.JAR, MYSQL-CONNECTOR-JAVA-5.1.13-BIN.JAR
2. Configuração da estrutura do Struts:
1. Selecione o projeto e clique com o botão direito do mouse para selecionar: Myeclipse -> Facets do projeto [Recursos] -> Instale a faceta Apache Struts (2.x), como segue:
2. Selecione a versão, aqui escolhi 2.1, clique em "Acabamento", como segue:
3. Depois de concluir as etapas acima, você descobrirá que há um arquivo extra.xml no diretório SRC, com o seguinte conteúdo:
<? xml versão = "1.0" coding = "utf-8"?> <! Doctype suporta public "-// Apache Software Foundation // DTD Struts Configuration 2.1 //" "http://struts.apache.org/dtds/struts-2.1.dtd"> <stuts.apache.org/dtds/struts-2.1.dtd "
4. No arquivo web.xml no diretório da Web-Inf, há uma seção adicional do código de configuração para filtros Struts, como segue:
5. Consulte a figura acima, modifique *.Action para "/ *", e a estrutura do struts está configurada neste momento;
3. Configuração da estrutura da mola:
1. Consulte a configuração dos suportes, selecione o projeto, clique com o botão direito do mouse e selecione: Myeclipse -> Project Facets [Recursos] -> Instale a faceta da mola, selecione a versão e selecione 3.1 da seguinte forma:
2. Clique em "Concluir" e você descobrirá que existe um arquivo ApplicationContext.xml no diretório SRC, um arquivos Spring-Form.TLD e Spring.TLD no diretório Web-Inf e um pedaço de código relacionado à configuração do Spring é adicionado no arquivo web.xml. A construção da estrutura da primavera foi basicamente concluída (a introdução do espaço para nome será discutida mais adiante), como mostrado abaixo:
4. Configuração da estrutura de hibernato:
1. Consulte a configuração de struts, selecione o projeto, clique com o botão direito do mouse e selecione: Myeclipse -> Project Facets [Recursos] -> Instale o HibernateFacet, selecione a versão e selecione 3.3 aqui da seguinte forma:
2. Clique em "Concluir" e você descobrirá que existe um pacote padrão adicional no diretório SRC (pode ser excluído) e um pedaço de código no arquivo web.xml (ele será reconfigurado posteriormente), como mostrado abaixo:
3. Importar pacotes de jar que suportam a anotação "@Entity": selecione o projeto, clique com o botão direito do mouse para selecionar: Myeclipse -> Facets do projeto [Recursos] -> Gerenciar ... e siga as etapas na figura a seguir:
Depois de concluir as etapas acima, as três principais estruturas são basicamente construídas e, em seguida, são integradas.
5. Integração
1. Para impedir que o ApplicationContext.xml pareça muito inchado e fácil de gerenciar, salvamos a configuração relacionada ao hibernato em outro arquivo .xml e o importamos no ApplicationContext.xml. As etapas específicas:
(1) Crie um arquivo chamado HibernatEContext.xml no diretório SRC (mesmo nível que ApplicationContext.xml), copie o conteúdo do ApplicationContext.xml e faça alterações;
(2) Conteúdo no arquivo HibernateContext.xml:
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd"> <!-Configuração de sessionfactory-> <bean id = "sessionFactory"> <!-A propriedade DataSource será configurada no arquivo ApplicationContext.xml. Consulte aqui primeiro-> <propriedade name = "DataSource" ref = "DataSource"> </Property> <!-Defina itens de configuração relacionados ao hibernato-> <propriedades name = "hibernateproperties"> <!-Propções TAG é injetar propriedades das propriedades do tipo- key = "hibernate.dialect"> org.hibernate.dialect.mysqldialect </prop> <!-show_sql é o objetivo de imprimir instruções sql-> <prop key = "hibernate.show_sql"> true </prop> <!-embelezar o formato de impressão de QL-> <!-a) Create-Drop: Crie uma tabela de dados ao executar o programa e exclua a tabela após a execução. In actual development, it is often used for testing b) create: Recreate the data table every time the program is executed c) update: When executing the program, it will be judged that if there is, the table will not be created, otherwise the data table will be created, and the fields in the data table will be automatically added according to the increase of attributes in the entity class (development environment) d) validate: When executing the program, if the attributes in the entity class are inconsistent Com os campos na tabela, será relatado um erro (ambiente de produção)-> <prop key = "hibernate.hbm2ddl.auto"> validar </pup> </sports> </property> <!-configurar a classe de entidade de hibernato-> <names = "de pacotecan"> <!-listar é usado para ser usado para a tag. Seu valor é geralmente o nome completo do pacote de feijão correspondente, e as classes no pacote de feijão geralmente correspondem à tabela no banco de dados-> <list> <Value> com.beauxie.bean </value> </list> </sensfating> </i bean> <!-Configure o Hibernatetemplate Matplate-"<ierghemge>" REF = "SessionFactory"> </Property> </sien> </sheans>
(3) Exclua a configuração do "SessionFactory" no ApplicationContext.xm (porque foi configurado em hibernateContext.xml) e, em seguida, importe o conteúdo modificado de hibernateContext.xml. Após a importação, o conteúdo do 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:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd"> <bean id = "DataSource"> </ Bean> <!- importe outros arquivos de configuração de primavera. Se eles forem colocados em um arquivo, eles ficarão inchados -> <importar resource = "hibernateContext.xml"/> </beans>
2. Com base no DataSource original no arquivo ApplicationContext.xm, modifique sua configuração (nome do banco de dados, nome de usuário, senha, etc.) ( Nota: A tag Valor não deve conter espaços ou entrar !! ), como mostrado abaixo:
<bean id = "DataSource"> <propriedade name = "jdbcurl"> <!-Se você usar o atributo de valor diretamente em vez da tag de valor, precisará escapar "&" e usar a tag de valor. A tag <span style = "cor:#ff0000;"> não deve conter espaços ou retorno do carro, porque converterá os espaços em "" </span>, resultando no fato de o banco de dados não conseguir se conectar, a menos que a fonte de dados seja reescrita-> <Value> <! [CDATA [JDBC: mySQL: // localhost: 3306/sshdemo? useunicode = true & caracterEncoding = utf8 & useRerverPrepstmts = t rue & prepstmtcachesqllimit = 256 & cachePrepStmts = true & prepstmtcachesize = 256 & rewriteBatchedStatements = true]]> </valor> </propriedade> <propriedade name = "driverclass" value = "com.mysql.jdbc.driver"> </propriedade> <propriedade name = "user" value = "root"> </propriedade> <names name = "value" value = "root"> </propriedade> <nome da propriedade = "adquiririnlement" = "3"> </propriedade "> </propriedade"> </propriedade> <names = "adquirir" = "3"> </imobiliário " name = "MinPoolSize" value = "2"> </ouse> <propriedade name = "maxpoolsize" value = "10"> </property> </i bean>
3. No ApplicationContext.xm, configure o scanner de mola, de modo a adicionar anotações de componentes da mola à nossa classe e o feijão pode ser carregado automaticamente. As etapas específicas são as seguintes: (1) Introduzir o espaço para nome de contexto, apoiar a tag de contexto, clique em "Namespaces" na parte inferior e, em seguida, verifique o item de contexto:
(2) Configure o scanner da primavera:
<!-Configure o scanner de primavera e adicione anotações de componentes da mola à nossa classe para carregar automaticamente grãos->
<Contexto: Componente-Scan Base-Package = "com.beauxie.action, com.beauxie.service, com.beauxie.dao">
</contexto: componente-varejo>
Nesse ponto, os três principais ambientes de estrutura SSH foram construídos e a próxima etapa é implementar o registro do usuário com base na estrutura SSH.
6. Caso: imitação simples do registro do usuário
1. Código da página de registro da recepção, index.jsp:
<%@ página de página = "java" import = "java.util.*" pageEncoding = "utf-8"%> <%string path = request.getContextPath (); String basalepath = request.getScheme () + ": //" + request.getServername () + ":" + request.getServerport () + path + "/"; %> <! Doctype html public "-// w3c // dtd html 4.01 transitória // pt"> <html> <head> <base href = "<%= basepath%>"> <title> bem-vindo ao registro </title <meta http-bealiV = "metagma" contention = " http-equiv = "cache-control" content = "no-cache"> <meta http-equiv = "expire" content = "0"> <meta http-equiv = "palavras-chave" content = "keyword1, keyword2, palavra-chave"> <magle http-equiv = "descrição" "content1, keyword2, palavra-chave"> <magle http-ouquiv = "descrição" " type = "text/css" href = "styles.css">-> </head> <body> <formulário de forma = "$ {PageContext.request.ContextPath}/User/Regist" Method = "Post"> <!-Você também pode usar o usuário. type = "text" name = "nome de usuário"> <br> Senha: <input type = "senha" name = "senha"> <br> <input type = "submit" value = "registro"> </mand> </body> </html>2. Código de classe do usuário:
pacote com.beauxie.bean; importar javax.persistence.Entity; importar javax.persistence.id; importar javax.persistence.table; /** * @Author Beauxie * Aqui as propriedades do usuário devem ser as mesmas que os campos na tabela T_USER, * caso contrário, você precisa especificar manualmente os campos na tabela correspondente para diferentes propriedades */ @entidade // mapa tabela de dados, a tabela @table = "t_user") // não a classificação adicional // mapa, a tabela @table (names t_user ") // não t_user tabela private int id; // idoc private string nome de usuário; // nome de usuário private string senha; // senha public int getId () {return id; } public void setId (int id) {this.id = id; } public string getUserName () {return userName; } public void setUserName (string userName) {this.username = nome de usuário; } public string getPassword () {return senha; } public void setPassword (string senha) {this.password = senha; }} 3.Userdao Código de classe:
pacote com.beauxie.dao; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.orm.hibernate3.HibernateTemplate; importar org.springframework.tereotype.repository; importação com.beauxie.bean.user; /*** @Author Beauxie* Dao Camada, opere no banco de dados*/ @repositório // Esta propriedade corresponde à camada de persistência (geralmente camada dao), o que significa que é entregue ao gerenciamento da mola e o nome de classe correspondente, não tem uma classe que não tem uma classe pública para o usuário, não tem o que não tem uma classe, não tem um slut de slutued, que não tem uma classe, não tem um nome de sin. no arquivo de configuração da primavera; /*** Registro do usuário, ou seja, adicione um novo registro à tabela* @param User*/public void adduser (usuário do usuário) {// Adicione um dados no banco de dados e você pode obter o modelo.Save (usuário); }} 4. UserSerService Código de classe:
pacote com.beauxie.service; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.tereotype.service; importação com.beauxie.bean.user; importação com.beauxie.dao.userdao; /*** @Author Beauxie* Camada de serviço*/ @Service // Esta propriedade corresponde à camada de serviço geralmente é a camada de serviço), o que significa que é entregue ao gerenciamento da primavera, e o nome da classe correspondente também terá uma classe pública Uservice de uma classe pública { @ @automaticamente // também injetará automaticamente o usuário privado userdao; public void adduser (usuário do usuário) {// chamando o método addUser do dAo camada userdao.adduser (usuário); }} 5. Código de classe doseRaction:
pacote com.beauxie.action; importar javax.servlet.http.httpServletRequest; importar org.apache.struts2.ServletActionContext; importar org.apache.struts2.convention.annotation.action; importar org.apache.struts2.convention.annotation.namespace; importar org.apache.struts2.convention.annotation.results; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.context.annotation.Scope; importar org.springframework.tereotype.controller; importação com.beauxie.bean.user; importação com.beauxie.service.userService; /** * @author beauxie * */ @controlador // usado para anotar o componente da camada de controle @namespace ("/user") // url prefix @scope ("prototype") // ação é um singleton por padrão, mas no desenvolvimento real, geralmente é múltiplo, porque geralmente uma ação pode se corresponder a múltiplas solicitações diferentes // O padrão é "Struts-Default", então @Results ({@Result (name = "Registsuccess", Location = "/msg.jsp")}) public class Useraction { @autowired // injetar automaticamente o serviço privado UserService; // suporta os padrões para interceptar ".Action e sem sufixo" @Action (value = "regist") // Access: /user/regist.action ou/user/regist public string regist () {// obtenha solicitação httpServletRequest request = servLeActionContext.GeTequest (); // obtenha o formulário de dados enviado String userName = request.getParameter ("nome de usuário"); String senha = request.getParameter ("senha"); // encapsula o usuário do usuário usuário = new User (); user.setId (1000); user.setUserName (nome de usuário); user.setPassword (senha); // Ligue para o método da camada de serviço para adicionar um registro ao serviço de banco de dados.adduser (usuário); // Salve as informações solicitadas no domínio da solicitação e request. retornar "Registsuccess"; }} 6. Interface do prompt de mensagem: MSG.JSP Código, como segue:
<%@ página de página = "java" import = "java.util.*" pageEncoding = "utf-8"%> <%string path = request.getContextPath (); String basalepath = request.getScheme () + ": //" + request.getServername () + ":" + request.getServerport () + path + "/"; %> <! Doctype html public "-// w3c // dtd html 4.01 transitória // pt"> <html> <head> <base href = "<%= basepath%>"> <title> prompt </title> <meta http-equiv = "metagma"> " content = "sem cache"> <meta http-equiv = "expire" content = "0"> <meta http-equiv = "palavras-chave" content = "keyword1, palavra-chave2, palavra-chave3"> <meta http-equiv = "descrição" content = "this é minha página"> <! href = "styles.css"> -> </adhead> <body> $ {msg} </body> </html>7. Adicione o projeto ao servidor, inicie o serviço, abra o navegador e visite: http: // localhost/sshdemo/user/regist
8. Digite o nome de usuário e a senha, clique em "Registrar" para exibir os resultados:
9. O console produz a instrução SQL (a saída foi configurada e a instrução SQL foi embelezada no arquivo hibernateContext.xml):
10. Ver Resultados do banco de dados:
Este caso simples terminou. Não há problema com a verificação dos dados de envio do formulário e o código ilegal. Deve ser atualizado no futuro.
7. Resumo:
1. A integração das três principais estruturas deve ser introduzida primeiro e depois integrada;
2. Lembre -se de importar o pacote JAR do banco de dados;
3. A classe de ação deve ser colocada no nome do pacote "Ação", e o nome da classe deve terminar com ação, como "xxxaction";
4. Ao configurar o Hibernate, certifique -se de importar pacotes JAR que suportam a anotação "@Entity";
5. Você pode definir o tipo de solicitação para struts interceptados no arquivo STRUTS.xml, que padroniza para .Action e sem sufixos.
6. Você pode definir o tipo de filtro do filtro STUTS no arquivo web.xml. O padrão é *.Ação e deve ser alterado para / *;
7. No arquivo ApplicationContext.xm, você precisa configurar cinco partes: SessionFactory, Hibernate Entity Class, Hibernatetemplate Modelo, DataSource da fonte de dados e scanner de primavera (incluindo hibernateContext.xml);
8. Cada classe deve adicionar anotações correspondentes e os métodos em ação também devem ser adicionados.
Faça o download do código fonte da instância: http://xiazai.vevb.com/201610/yuanma/sshzhuce(vevb.com).rar
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.