Este artigo começa com um projeto de shopping online, começando com a construção do meio ambiente e integrando o S2SH passo a passo. Esta postagem do blog resume principalmente como integrar STRUTS2, Hibernate4.3 e Spring4.2.
Para integrar as três principais estruturas, você deve primeiro começar a construir vários ambientes, ou seja, primeiro, você deve construir os ambientes da primavera, Hibernate e Struts2 para garantir que eles não tenham problemas e depois as integrem. A ordem em que esta postagem do blog se segue é: primeiro construa o ambiente da primavera -> depois construa o ambiente de hibernato -> integrar a primavera e hibernar -> construir o ambiente STRUTS2 -> integrar a primavera e as struts2.
1. Gerenciamento de todo o pacote JAR
A primavera tem muitos pacotes JAR. Recomenda -se classificá -los em uma categoria e, em seguida, adicione -os à biblioteca do usuário, por sua vez, para facilitar o gerenciamento e limpar rapidamente. Aqui vou resumir os pacotes básicos de jar necessários para todo o SSH e ver a figura a seguir:
Como pode ser visto na figura, primeiro, os frascos de mola são divididos em quatro categorias: Spring-4.2.4-Core, Spring-4.2.4-AOP, Spring-4.2.4-Persistência e Spring-4.2.4-Web. Coloque todos os pacotes principais de primavera no núcleo, coloque tudo relacionado à AOP em AOP, coloque tudo relacionado à persistência (integrado ao hibernado) em persistência e coloque tudo relacionado à Web (integrado ao Struts2) na Web. Quais pacotes de jar cada peça têm? Por favor, veja a captura de tela abaixo:
Nota: Os pacotes em cada categoria acima não contêm todos os frascos no pacote original. Alguns arquivos JAR não são usados. Basta adicioná -los quando o projeto específico precisar. A imagem acima é o pacote mais básico de jar necessário para garantir que o ambiente do projeto possa criar o pacote mais básico do JAR.
2. Construa um ambiente de primavera
A captura de tela acima do pacote JAR são todos os pacotes JAR que foram integrados na última vez. Quando você constrói o ambiente pela primeira vez, não precisa adicioná -los de uma só vez. Você pode adicioná -los pouco a pouco. Isso também é mais propício para entender o que os pacotes JAR em cada parte têm. Obviamente, também é possível adicioná -los todos de uma vez.
2.1 Adicione o arquivo de configuração Beans.xml e pacotes de jar correspondentes
Crie um novo projeto e adicione sua própria biblioteca à biblioteca de usuários. Aqui estão dois principais, a saber, primavera-4.2.4-core e spring4.2.4-AOP. Não vou entrar em detalhes sobre a adição de pacotes JAR. Depois de adicionar, adicione o arquivo beans.xml no diretório SRC. Existem muitos modelos para este arquivo on -line e também existem exemplos fornecidos pela primavera. Basta pegar uma cópia, veja a seguinte foto:
2.2 Teste o ambiente do COI da primavera
Vamos escrever uma classe Java.util.tate de classe java normal para testar se o COI da primavera é normal. Se puder ser injetado normalmente no programa de teste, significa que o ambiente do COI da primavera é construído com sucesso. Vamos escrever um caso de teste abaixo:
/** * @Description TODO (Usando a depuração da anotação da primavera, suporta apenas Spring3.1 e acima) * @author ni shengwu * * / / * * Após o Spring3.1, há um pacote adicional de primavera-teste-4.2.4.release.jar. Este pacote JAR é usado especialmente para oferecer suporte a testes baseados em anotação do Junit. O pacote JAR está em Spring-4.2.4-Core * Existe um SpringJunit4ClassRunner.Class neste pacote JAR, e você pode adicioná-lo com o @Runwith Anotation * * AnoTation @ContextConfiguration significa injetar o objeto ApplicationContext, você não precisa de novo no programa de teste, como antes, use */ @runwith (Springnwith (Springnn (Springnnnwrnwrnwith (SpringnUrnUnnUrnUnN4) @ContextConfiguration (Locations = "ClassPath: beans.xml") Public class sshtest {@Resource Data privada data; @Test // Teste o ambiente de desenvolvimento do IOC da primavera Void Springioc () {System.out.println (data); }} Finalmente, ele pode produzir normalmente: qui 28 de abril 22:45:13 CST 2016. Isso indica que o objeto de data foi injetado na primavera, o que verifica se a função do COI da mola é normal. Por esse motivo, o ambiente da primavera é construído.
3. Construa um ambiente de hibernação
A construção do ambiente do Hibernate é mais complicada que a primavera porque usa engenharia reversa no Myeclipse. Seguimos as etapas a seguir para construir o ambiente de desenvolvimento de hibernados:
3.1 Adicione o pacote JAR correspondente
Aqui, adicionamos principalmente dois pacotes JAR à biblioteca de usuários: Hibernate4.3.11 e o pacote de driver MySQL MySQL-Connector-Java-5.1.26, que não será descrito em detalhes.
3.2 Crie um novo banco de dados e tabela
soltar o banco de dados se existir compra; Criar conjunto de caracteres padrão da loja de banco de dados Conjunto de caracteres UTF8; usar loja; Tabela de soltar se existe categoria; Criar categoria de tabela ( /* Número da categoria, crescimento automático* / id não nulo auto_increment, /* nome da categoria* / tipo varchar (20), /* se a categoria é uma categoria quente, a categoria quente pode ser exibida na página inicial* / hot bool padrão false, /* Defina o número da categoria para a chave primária* / Primária (id);
3,3 db de navegador se conecta ao banco de dados MySQL
O navegador de banco de dados refere -se a uma janela de visualização no myeclipse. Você pode ver intuitivamente quais bancos de dados e tabelas estão no MySQL. O método para abrir o navegador de banco de dados: Window-> Open Perspective-> DB navegador abre a janela de trabalho do navegador de banco de dados. Se não houver navegador de banco de dados, siga o seguinte: Window-> Show View-> Other-> Digite o navegador DB e encontre-o para abri-lo.
Após a abertura, começamos a nos conectar ao banco de dados MySQL. Clique com o botão direito do mouse -> novo no espaço em branco da janela do navegador de banco de dados, e a seguinte caixa de diálogo será exibida:
Depois de preencher, clique em Test Driver para testá -lo. O teste passa no teste e indica que o driver de conexão do banco de dados foi configurado e o termina. Dessa forma, podemos ver o banco de dados MySQL 5.6 na janela do navegador DB. Clique com o botão direito do mouse para abri-lo para ver as bibliotecas e tabelas existentes no banco de dados, como segue:
3.4 Crie arquivo de mapeamento XML e SessionFactory
SessionFactory é usado para criar sessões. Nós os criamos da seguinte maneira: clique com o botão direito do mouse no nome do projeto-> Myeclipse-> Adicionar recursos de hibernato. Se não houver recursos de hibernato, clique em Facets do Projeto-> Instale as facetas do Hibernate e a seguinte janela será exibida:
Em seguida, adicione o suporte de hibernato, ou seja, o arquivo de mapeamento hibernate.cfg.xml e o SessionFactory no myeclipse. Aqui, criamos principalmente um pacote para o SessionFactory e o pacote padrão não pode ser usado.
Em seguida, adicione um motorista. Como já configuramos um driver antes, podemos selecionar diretamente o driver recém -configurado aqui.
Em seguida, como já adicionamos nossa própria reserva de jar antes, não há necessidade de escolher aqui, basta terminar diretamente.
Dessa forma, concluímos a criação do arquivo de configuração do hibernato e da SessionFactory. Vamos dar uma breve olhada no que está no Factory Session criado por Myeclipse:
classe pública HibernatesessionFactory {private Static Final ThreadLocal <Session> threadlocal = new Threadlocal <Session> (); // SessionFactory é usado na sessão de sessões privadas org.hibernate.SessionFactory SessionFactory; // SessionFactory: Crie uma fábrica para configuração estática privada de sessão Configuração = new Configuration (); Serviço estático privado Serviceregistry; static {// Initialize sessionFactory Try {Configuration.configure (); serviceregistry = new ServiceRegistryBuilder (). ApplySettings (Configuration.getProperties ()). BuildServiceregistry (); sessionFactory = Configuration.BuildSessionFactory (Serviceregistry); // Método para criar sessionFactory no hibernate4} catch (Exceção e) {System.err.println ("%%%%dor Erro criando sessionFactory %%%%%"); E.PrintStackTrace (); }} private hibernatesessionFactory () {// O método do construtor privado impede que novos objetos sejam lançados, garantindo que a sessão de sessionFactory singleton} public static session getSession () lança hibernateException {sessão session = (session) threadlocal.get (); // Obtenha sessão no pool de threads if (session == null ||! Session.isopen ()) {// se o pool de threads estiver vazio, ou a abertura da sessão falhar se (sessionFactory == NULL) {RebuildSessionFactory (); // Se o SessionFactory estiver vazio, crie -o novamente, o mesmo que a parte estática} session = (sessionFactory! = NULL)? sessionfactory.opensssess (): null; // sessionfactory não está vazio, crie um threadlocal.set (sessão); // Coloque esta sessão no pool de threads e obtenha -o na próxima vez} Sessão de retorno; } public static void RebuildSessionFactory () {try {Configuration.configure (); serviceregistry = new ServiceRegistryBuilder (). ApplySettings (Configuration.getProperties ()). BuildServiceregistry (); sessionFactory = Configuration.BuildSessionFactory (Serviceregistry); } catch (Exceção e) {System.err.println ("%%%%% Erro criando sessionFactory %%%%% jogada"); E.PrintStackTrace (); }} public static void clossession () lança hibernateException {session session = (session) threadlocal.get (); threadlocal.set (nulo); if (session! = null) {session.close (); }} public static org.hibernate.SessionFactory getSessionFactory () {// Forneça uma interface pública para permitir que o mundo exterior obtenha essa sessão de sessão de singleton Factory; } configuração estática pública getConfiguration () {return Configuration; }} Pode ser visto a partir do HibernatesessionFactory criado que o padrão de singleton e a tecnologia de pool de threads são usados principalmente. Não é difícil de entender.
3.5 Gere arquivos de mapeamento de modelo e ORM por meio de engenharia reversa
Em seguida, começaremos a usar a engenharia reversa para criar um objeto de instância, ou seja, o modelo correspondente à tabela de banco de dados. Na janela Browsera de banco de dados, clique com o botão direito do mouse na loja de mesa que acabamos de criar e selecionar a engenharia reversa do Hibernate para começar a criar:
Existem duas maneiras de criá -lo, com base em arquivos de configuração e com base em anotações. Depende do humor do desenvolvedor. Você pode escolher:
Em seguida, na próxima etapa, selecione o método de autoin -crement da chave primária nativa e, em seguida, preencha a engenharia reversa para criar o mapeamento de modelo e ORM.
Após a conclusão, o modelo da categoria será gerado e os mapeamentos correspondentes também serão gerados no arquivo hibernate.cfg.xml. Os mapeamentos anteriores com base em arquivos de configuração e anotações baseados em anotações serão diferentes.
3.6 Testando o banco de dados persistente de hibernação
Como não foi integrado à primavera, é apenas uma simples construção do ambiente de desenvolvimento de hibernato, por isso não precisamos usar anotações. Executamos a entrada de dados no banco de dados por serviço diretamente novo.
Primeiro, escreva a interface e a classe de implementação da CategoryService:
Public Interface CategoryService {public void Save (categoria Categoria); // Use para testar o ambiente Hibernate} Categoria Public CategoryServiceImpl implementa CategoryService {@Override // Não há integração com a primavera pública void salvar (categoria categoria) {// Obter sessão sessão session = hibernatesessionFactory.getSession (); tente {// sessão de transação manual.gettransaction (). BEGIN (); // executar lógica de negócios session.save (categoria); // Enviar manualmente session.gettransaction (). Commit (); } catch (Exceção e) {session.gettransaction (). rollback (); lançar nova execução de tempo de execução (e); } finalmente {hibernatesessionFactory.ClosSession (); }}} O seguinte é adicionar o teste de Hibernate no caso de teste agora:
@Runwith (springjunit4classrunner.class) @contextConfiguration (locations = "classPath: beans.xml") classe pública sshtest {@Resource Data privada data; @Test // Teste o ambiente de desenvolvimento do IOC da primavera Void Springioc () {System.out.println (data); } @Test // test /teste o ambiente de desenvolvimento do hibernato, porque não há integração, você pode diretamente novo public void hiHernate () {categoryService categoryService = nova categoryServiceImpl (); Categoria categoria = nova categoria ("casual masculino", verdadeiro); categoryService.Save (categoria); }}Verificamos o banco de dados e descobrimos que havia muitos itens que foram inseridos, o que significa que não havia nenhum problema com o ambiente de hibernação. Nesse ponto, construímos o ambiente de desenvolvimento de hibernados.
4. Integrar a primavera e hibernar
Depois de construir o ambiente de desenvolvimento para a primavera e o hibernado, começamos a integrar os dois. Depois de integrar a primavera e o hibernato, você pode usar a AOP para permitir que a mola gerencie transações de hibernato. A integração da primavera e da hibernação começa principalmente a partir de dois aspectos: um é importar os pacotes JAR necessários, e o outro é configurar o arquivo beans.xml. Abaixo, integramos a primavera e a hibernamos passo a passo.
4.1 Importar o pacote JAR correspondente
Existem dois pacotes de JAR principais que precisam ser importados ao integrar a primavera e a hibernação, Spring4.2.4-persistência e C3P0-0.9.5.1. Para os arquivos JAR específicos em cada pacote JAR, consulte a captura de tela acima e não será descrito aqui. Agora começaremos a configurar o arquivo beans.xml.
4.2 Configurando o DataSource da fonte de dados
Primeiro, configure o DataSource e, em seguida, a parte correspondente no hibernate.cfg.xml pode ser morta. Por ser configurado na primavera, a primavera inicializará essa fonte de dados, o que significa que isso é deixado para a primavera para ser concluído e a parte correspondente no hibernate.cfg.xml pode ser excluída. do seguinte modo:
<!-com.mchange.v2.c3p0.combopooledDataSource A classe está no pacote com.mchange.v2.c3p0 de c3p0-0.9.5.1.jar pacote-> <bEan id = "DataSource"> <nome da propriedade "driver" = "com.mysql.jdbc.niver"> value = "jdbc: mysql: // localhost: 3306/shop"/> <propriedades name = "user" value = "root"/> <propriedade name = "senha" value = "root"/> </i bean>
A parte que precisa ser morta em hibernate.cfg.xml:
4.3 Configurando a SessionFactory
O SessionFactory é configurado para gerar uma sessão. Além disso, o hibernateTemplate também é possível. No entanto, o SessionFactory é usado aqui em vez de hibernatetemplate porque o hibernatetemplate é fornecido pela primavera e depende da primavera. Se a primavera não for usada um dia, um erro será relatado. E o SessionFactory é fornecido pelo Hibernate, sem problemas. O hibernatetemplate é muito dependente. Vamos dar uma olhada na configuração específica:
<!-org.springframework.orm.hibernate4.localsessionFactoryBean Classe em org.springframework.orm.hibernate4 pacote de spring-orm-4.2.4.release.jar value = "ClassPath: hibernate.cfg.xml" /> <!-Carregue o arquivo de configuração de hibernato-> </i bean>
Acabamos de usar o DataSource no SessionFactory para fazer referência ao DataSource com o atributo Ref. Não estamos mais usando a configuração aqui. Carregamos diretamente o arquivo hibernate.cfg.xml e usamos a configuração no arquivo de configuração de hibernato para torná -lo mais conciso e conveniente.
4.4 Configurando o gerente de transação
O gerenciador de transações de configuração é usado para gerenciar o SessionFactory, para que todas as sessões geradas pelo SessionFactory sejam gerenciadas declarativamente. A configuração é a seguinte:
<!-org.springframework.orm.hibernate4.hibernateTransactionManager Classe Spring-Aorm-4.2.4.Release.Jar
Da mesma forma, podemos usar o SessionFactory apenas configurado e referenciá -lo com o atributo REF. Neste ponto, você descobrirá que o tempo acima é uma série de operações, citando -as uma a uma.
4.5 Configurar conselhos (notificação)
O objetivo de configurar o conselho é especificar quais métodos exigem que tipo de modo de transação. Veja a configuração:
<tx: conselhos id = "conselhos" transação-manager = "transactionManager"> <tx: atributes> <tx: método name = "save*" propagation = "requerir"/> <tx: attritutes> </tx: atributes> </tx: conselhos>
Necessário significa que, se houver uma transação, a transação atual será suportada. Se não houver, uma nova transação será criada. Esse modo de transação é aplicado a todos os métodos que começam com salvar, atualizar e excluir, ou seja, o suporte à transação é necessário ao adicionar, excluir e modificar o banco de dados. Suporta significa que, se houver uma transação, a transação atual será suportada e, se não houver ninguém, tudo bem.
4.6 Configurando facetas AOP
<AoP: config> <!-Configure quais classes de embalagem entrar na transação-> <aop: Pointcut id = "Pointcut" Expression = "Execution (*cn.it.shop.service.impl.*.*. style = "Fonte-família: Microsoft yahei;"> e o ponto acima-> <!-AOP: Pointcut deve ser escrito no AOP: Advisor, caso contrário, será relatado um erro-> </aOP: config>
AOP é a programação orientada a tangente. AOP: Pointcut define uma tangente. A configuração na propriedade Expression significa que todos os métodos no pacote CN.it.shop.service.impl, independentemente do valor de retorno e dos parâmetros, devem entrar na transação. Este pacote pertence à camada DAO e opera diretamente o banco de dados. AOP: O conselho combina notificações e seções. Podemos usar diretamente os conselhos e o Pointcut configurado acima para apresentá -los. Após essa configuração, significa que todos os métodos do pacote CN.it.shop.service.impl precisam entrar em gerenciamento de transações. Especificamente, os métodos que começam com salvar, atualizar e excluir usam o método requisitado e outros métodos usam o método de suporte. Isso facilita o entendimento do significado dessa configuração.
4.7 Resultados de integração de teste
Quando construímos o ambiente Hibernate antes, testamos que diretamente um serviço diretamente para operar o banco de dados, porque ele não havia sido integrado à primavera naquele momento. Agora, depois de configurar o Beans.xml, a Spring pode gerenciar transações de hibernato. Portanto, o teste atual precisa entregar o serviço ao gerenciamento da primavera, injetar -o até a primavera e confiar no SessionFactory. Se os dados puderem ser inseridos no banco de dados, significa que a transação está OK.
Primeiro, precisamos corresponder a este serviço no arquivo de configuração da primavera Beans.xml:
Copie o código da seguinte forma: <bean id = "categoryService">
<propriedade name = "sessionFactory" ref = "sessionFactory" /> <!-A sessão de dependência usa o Factory Session que tínhamos equipado anteriormente->
</ Bean>
Em segundo lugar, precisamos adicionar um método à interface CategoryService e sua classe de implementação CategoryServiceImpl para testar a situação de integração:
Public Interface CategoryService {public void Save (categoria Categoria); // usado para testar o ambiente de hibernato public void update (categoria de categoria); // usado para testar a integração de Spring e Hibernate} Categoria Public CategoryServiceImpl implementa categoryService {@Override // A situação em que não há integração com a primavera pública void salvar (categoria categoria) {// obter sessão de sessão session = hibernateSessionFactory.getSession (); tente {// sessão de transação manual.gettransaction (). BEGIN (); // executar lógica de negócios session.save (categoria); // Enviar manualmente session.gettransaction (). Commit (); } catch (Exceção e) {session.gettransaction (). rollback (); lançar nova execução de tempo de execução (e); } finalmente {hibernatesessionFactory.ClosSession (); }} /*Mola e hiberna toda a sessão* / privada Session SessionFactory; // Defina um sessionFactory // Quando você precisar usar o SessionFactory, a primavera injetará sessionFactory no público void SetSessionFactory (SessionFactoryFactory) {this.SessionFactory = SessionFactory; } Sessão protegida getSession () {// Obtenha sessão do thread atual. Caso contrário, crie uma nova sessão de retorno sessionFactory.getCurrentSession (); } @Override // A situação após a primavera e o hibernato é integrada public void update (categoria categoria) {getSession (). Update (categoria); }} Agora, podemos adicionar métodos de teste à classe de teste para testar os resultados após a integração da primavera e Hibernate:
@Runwith (springjunit4classrunner.class) @contextConfiguration (locations = "classPath: beans.xml") classe pública sshtest {@Resource Data privada data; @Resource Private CategoryService CategoryService; @Test // Test Spring IOC Development Ambiente public void springioc () {System.out.println (data); } @Test // Test // Teste o ambiente de desenvolvimento da Hibernate, porque não há integração, você pode diretamente novo public void hiHernate () {categoryService categoryService = nova categoryServiceImpl (); Categoria categoria = nova categoria ("casual masculino", verdadeiro); categoryService.Save (categoria); } @Test // teste public void hibernateandpring () {categoryservice.update (nova categoria (1, "feminino casual", verdadeiro)); // CategoryService injetado de cima até a primavera}}Em seguida, verificamos o banco de dados e descobrimos que a categoria com ID = 1 foi modificada em um estilo de mulher casual, o que significa que a atualização foi bem -sucedida. Neste ponto, a primavera e o hibernato foram integrados com sucesso.
5. Construa um ambiente STRUTS2
5.1 Adicione pacotes de configuração e jar correspondentes
Coloquei o pacote JAR necessário para que o Struts2 seja executado na Biblioteca do Struts2.3.41, para que eu possa apenas apresentá -lo diretamente e não o repetirei. Além disso, o arquivo web.xml precisa ser configurado da seguinte forma:
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xmls/javaee/web-web-web-web-web--/java.sun.com/xmls/javaeeeee/web-web-web-web-web-web-web-web-web-web-web-web-web-web-web-/java.sun.com/ <libe-name> e_shop </sisplay-name> <lmed-fil-list> <lmed-File> index.jsp </limk-File> </lorth-File-List> <filter> <filter-name> struts2 </filter-name> filter-classpôs) org.apache.struts2.dispather.ng.fterilter.strutspreserspreserspreserspresean <Filter-Name> struts2 </filter-name> <url-tattern>*. Ação </rl-tattern> </filter-mapping> </web-app>
Como acima, configuramos um filtro StrutSPepareAndExecuteFilter e definimos o padrão de URL do filtro como *.Ação, ou seja, todos os sufixos de ação passarão por esse filtro primeiro, que também é a entrada para os struts2.
5.2 Crie ação e configure -a no arquivo struts.xml
Criamos uma ação da seguinte maneira:
Categoria de classe pública estende o ACOCIONSupport {private CategoryService CategoryService; // CategoryService é definido como ver intuitivamente as diferenças antes e após a integração com a primavera do Void SetCategoryService (categoryService CategoryService) {this.categoryService = categoryService; } public string update () {System.out.println ("---- Update ----"); System.out.println (CategoryService); // Saída de retorno diferente "índice"; } public string save () {System.out.println ("---- SALVA ----"); System.out.println (categoryService); // Abra diferentes retornos "índice" antes e após a integração; }} Em seguida, configuramos o arquivo struts.xml, que é colocado no diretório SRC:
<? xml versão = "1.0" Encoding = "utf-8"?> <! Doctype suporta public "-// Apache Software Foundation // DTD Struts Configuration 2.3 // en" "http://struts.apache.org/dts/Struts-2.3.dtp"> <stuts.apache.org/dts/Struts-2.3.dtd "> <stuts> <package! category_update.actiocan: Access Update Method-> <action name = "category_*" method = "{1}"> <resultado name = "index">/index.jsp </resultado> </action> </catury> </stuts> 5.3 Testando o ambiente STRUTS2
O método de teste é: Escreva uma ação de acesso JSP e, se a ação puder ser criada, significa que o ambiente STRUTS2 está ok. Ou seja, uma série de processos no STRUTS2 pode ser concluída normalmente: jsp-> struts.xml-> ação-> struts.xml-> jsp, para que o ambiente do Struts2 esteja pronto. Vamos escrever um simples index.jsp
<%@ página linguagem = "java" import = "java.util.*" PageEncoding = "utf-8"%> <! ser acessado-> </span> <a href = "$ {PageContext.Request.ContextPath} /category_update.action"> Access Update </a> <a href = "category_save.action"> access Salvar </a> </body> </html> Em seguida, implantamos o seguinte projeto, abrimos o servidor Tomcat, digite: http: // localhost: 8080/e_shop/index.jsp no navegador, a página JSP normal aparecerá e, em seguida, clicamos em dois botões e ainda pulamos para index.jsp, e depois examinamos as informações de saída do console:
---atualizar---
nulo
---salvar---
nulo
Isso mostra que uma linha de struts2 foi concluída e não há problema com o ambiente. Neste ponto, o ambiente de desenvolvimento do STRUTS2 foi construído.
Vemos que o console sai nulo, o que significa que o serviço de categoria está vazio, o que significa que não temos o serviço de categoria, porque não integramos com a primavera e não fomos injetados, portanto, o nulo é normal. Viramos ao longo da saída de informações do console e encontraremos uma mensagem: Escolha o feijão (struts) para (com.opensymphony.xwork2.ObjectFactory). Os colchetes dizem que os suportes são gerados pelo Struts2 antes de serem integrados à primavera.
6. Integração de primavera e struts2
6.1 Adicione o pacote JAR correspondente
Quando o Spring e o Struts2 são integrados, o pacote JAR está principalmente em Spring4.2.4-Web, incluindo Struts2-Spring-Plugin-2.3.24.1.jar. O pacote de guia não será descrito novamente.
6.2 Deixar ação e suas dependências para a gerência da primavera
Configure a ação e suas dependências no arquivo de configuração do Spring Beans.xml. Atualmente, temos apenas uma ação, que está configurada da seguinte maneira:
<bean id = "date" /> <bean id = "categoryaction" scope = "prototype"> <propriedade name = "categoryService" ref = "categoryService" /> <!-A categoria dependente é configurada ao integrar o acima e o hibernato-> </ Bean>
6.3 Modifique a configuração em struts.xml
Acontece que no Struts.xml, o atributo de classe corresponde ao nome totalmente qualificado da ação específica. Agora altere o valor do atributo de classe para o valor de identificação da ação configurada na primavera, ou seja, categoryActionAction, da seguinte forma:
<Truts> <pacote name = "shop" estends = "struts-default"> <!-classe corresponde ao valor de identificação da ação configurada na primavera, porque deve ser entregue ao gerenciamento da mola-> <ação name = "category_*" "Method =" {1} "> <nome do nome =" Índice "/Index. 6.4 Configure o ouvinte
Configure o ouvinte ContextLoaderListener em web.xml para que os arquivos de configuração do Spring possam ser carregados quando o servidor iniciar. do seguinte modo:
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xmls/javaee/web-web-web-web-web--/java.sun.com/xmls/javaeeeee/web-web-web-web-web-web-web-web-web-web-web-web-web-web-web-/java.sun.com/ <libe-name> e_shop </sisplay-name> <lmed-fil-list> <lmed-File> index.jsp </limk-File> </lorth-File-List> <filter> <filter-name> struts2 </filter-name> filter-classpôs) org.apache.struts2.dispather.ng.fterilter.strutspreserspreserspreserspresean <Filter-Name> struts2 </filter-name> <url-tattern>*. Action </url-tattern> </filter-Mapping> <!-A prioridade de inicialização do ouvinte em web.xml é maior que a dos filtros, por isso não importa se é correspondido abaixo-> <Iliraber> <Ilvier-class-class> org.springframework.web.context.contextLoaderListener </lister-class-class> </irvier> <Context-paparam> <amam-name> contextCenfigLocation </param-name> <amon-value> classe: beans.xml </param-value> </contentm-partam <mame-value> ClassPath: beans.xml </param-value>
6.5 Resultados de integração de teste
Adicionamos uma nova declaração à ação para atualizar o banco de dados, como segue:
Categoria de classe pública estende a ação da ação {categoria privada; // Defina uma variável de membro privado para receber parâmetros trazidos pelo URL. Observe que os métodos GET e Set devem ser escritos abaixo. CategoryService CategoryService; public void setCategoryService (categoryService CategoryService) {this.categoryService = categoryService; } public string update () {System.out.println ("--- update ---"); System.out.println (categoryService); // Por ter sido integrado à primavera, você pode obter esse serviço de categoria. Não é nulo depois de imprimi -lo categoryService.Update (categoria); // Adicione uma nova instrução para atualizar o retorno do banco de dados "índice"; } public string save () {System.out.println (categoryService); retornar "índice"; } categoria pública getCategory () {Categoria de retorno; } public void setCategory (categoria categoria) {this.category = category; }} Em seguida, modificamos o arquivo index.jsp, como segue:
<%@ Page Language = "java" import = "java.util.*" PageEncoding = "utf-8"%> <! href = "$ {PageContext.Request.ContextPath} /category_update.action?category.id=2&category.type=gga&category.hot=false"> Acesso Atualização </a> <a href = "category_save.action"> acessar </aa> Em seguida, implantamos o seguinte projeto, abrimos o servidor Tomcat, digite: http: // localhost: 8080/e_shop/index.jsp no navegador, a página JSP normal aparecerá e, em seguida, clicamos no botão "Access Update" e ainda pulamos para index.jsp e, em seguida, analisamos as informações de saída do console:
--- UPDATE --- CN.IT.SHOP.SERVICE.IMPL.CategoryServiceImpl@7C5ecf80 Hibernato: categoria de atualização Definir hot =?, tipo =? onde id =?
Podemos produzir as informações do objeto CategoryService e também podemos produzir a instrução SQL ao executar a instrução Atualizar. Em seguida, consultamos o banco de dados e descobrimos que o tipo de dados com id = 2 foi atualizado para GGA e o HOT foi atualizado para False. Viramos a saída de informações do console para cima e encontraremos uma mensagem: Escolhendo Bean (primavera) para (com.opensymphony.xwork2.ObjectFactory), com a mola dos colchetes. Comparado com a situação acima, podemos ver que, depois que o Struts2 é integrado à primavera, a ação é entregue à primavera para o gerenciamento.
Neste ponto, a integração de Struts2, Hibernate4 e Spring4 foi concluída, e podemos desenvolvê -lo no ambiente SSH a seguir!
O pacote completo de jar necessário para a integração SSH introduzida neste artigo: Download grátis
O endereço de download do código -fonte de todo o projeto: //www.vevb.com/article/86099.htm
Endereço original: http://blog.csdn.net/eson_15/article/details/51277324
(Nota: No final, o download do código -fonte de todo o projeto é fornecido! Todos são bem -vindos para coletar ou seguir)
O acima é o conteúdo inteiro deste artigo. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.