Primeiro de tudo, o Eclipse precisa instalar o plug-in do Maven, endereço: http://m2eclipse.sonatype.org/sites/m2e.
Usando o Myeclipse para instalar o plug-in maven, existem alguns problemas com o projeto MAVEN que você criou. Primeiro, os recursos nunca serão publicados no Tomcat ao publicar Tomcat; Segundo, altere as classes em Web-Inf para as classes do Target, mas não sei por que o Myeclipse ainda gera classes no Web-Inf. Ou eu realmente não gero aulas no Web-Inf, mas quando publico o Tomcat, não vou publicar nenhum arquivo de classe para você, o que é super deprimente. Mas depois de usar o Eclipse para criar um projeto Maven, ficará bem em abri -lo com o Myeclipse.
Os benefícios do uso do MAVEN: sinto que o mais importante é baixar automaticamente o pacote JAR e o pacote de que depende, o que pode garantir o problema de diferentes versões JAR quando várias pessoas se desenvolverem. Além disso, a estrutura do arquivo é clara e os arquivos Java, arquivos de recursos e arquivos de teste são todos claramente divididos.
Dois métodos serão introduzidos: um, estabelecerá diretamente o método do projeto MAVEN; Segundo, estabeleça o método dinâmico de projeto da web para convertê -lo no método do projeto MAVEN.
1. Estabeleça diretamente o método do projeto Maven
1. Estabeleça um projeto Maven
Em seguida, use o Maven do Eclipse para construir um projeto da web, tomando o projeto Springmvc como exemplo:
1.1 Selecione Criar Projeto Maven
Selecione Arquivo -> Novo -> Outros e selecione MAVEN -> MAVEN Project na nova janela. Clique em Avançar.
1.2 Selecione o caminho do projeto
Use o espaço de trabalho padrão do espaço de trabalho padrão.
1.3 Selecione o tipo de projeto
Selecione Maven-Arquetype-Webapp em ID de artefato
1.4 Digite ID do grupo e ID do artefato, bem como o pacote
O ID do grupo é geralmente escrito com o nome do grande projeto. O ID do artefato é o nome do subprojeto.
Por exemplo, o pacote da Web da Spring, ID do grupo: org.springframework, ArtifactId: Spring-web.
O pacote é o pacote padrão para você e não há problema em não escrever.
1.5 A estrutura de arquivos recém -estabelecida é a seguinte
Se houver muito conteúdo exibido aqui, geralmente é um problema nas configurações de filtros. Ou a perspectiva é o modo Javaee, basta alterá -lo para o modo Java.
2. Configure o projeto Maven
Em seguida, muitas configurações precisam ser alteradas.
2.1 Adicione a pasta de origem
Em seguida, você precisa adicionar três pastas: src/main/java, src/test/java e src/test/recursos. Clique com o botão direito do mouse no diretório raiz do projeto e clique em New -> Pasta de origem.
Crie essas três pastas. Observe que não é uma pasta normal, mas uma pasta de origem.
2.2 Mudar o caminho da classe
Clique com o botão direito do mouse no projeto, Java Build Path -> fonte
Deve haver 4 pastas abaixo. src/main/java, src/main/recursos, src/test/java, src/test/recursos.
Clique duas vezes na pasta de saída para cada pasta e selecione o caminho.
src/main/java, src/main/recursos, selecione Target/Classes;
src/test/java, src/teste/recursos, selecione as classes de destino/teste;
Selecione Permitir pastas de saída para pastas de origem.
Também mude aqui:
Altere a ordem em que as pastas são exibidas: clique em encomendar e exportar.
Altere a versão JDK: clique duas vezes na biblioteca do sistema JRE nas bibliotecas para a versão 1.6.
2.3 Transforme um projeto em um projeto dinâmico da Web
2.3.1 Clique com o botão direito do mouse no projeto, selecione Facets do projeto e clique em converter para facetados de
2.3.2 Configurando as facetas do projeto
Altere a versão do módulo da web dinâmico para 2.5. (3.0 é Java7).
Se um erro for solicitado, pode ser necessário definir o nível de conformidade do compilador como 1.6 no compilador Java. Ou você precisa alterar a versão Java desta janela para 1.6.
2.3.3 Configurando o projeto Faceted
Clique na configuração adicional disponível… para aparecer a janela Modify Faceted Project
Aqui está o caminho para definir o arquivo web.xml e inserimos SRC/Main/WebApp.
Gereate Web.xml O descritor de implantação gera automaticamente o arquivo web.xml, opcional ou não.
2.4 Configuração do conjunto de implantação (Assembléia de implantação da Web)
Depois que as etapas acima forem configuradas, clique em OK e a janela Propriedades será fechada. Clique com o botão direito do mouse no projeto para abrir esta janela. Uma montagem de implantação aparecerá na lista à esquerda. Depois de clicar, como mostrado abaixo:
Aqui a lista é o caminho para a liberação do arquivo quando o projeto é implantado.
1. Excluímos os dois itens de teste porque o teste é usado para teste e não requer implantação.
2. Configure o pacote Maven Jar como Lib.
Adicionar -> entradas de caminho de construção java -> dependências maven -> acabamento
Defina a renderização acabada
3. Adicione o pacote JAR ao projeto Maven
O Maven pode gerenciar pacotes JAR de que o projeto depende e pode determinar exclusivamente um pacote de jar através do GroupID, ArtifactId e número da versão. Isso pode impedir o problema de pacotes de jar inconsistentes em Web-Inf/Lib em projetos antigos da Web. Além disso, o Maven baixará automaticamente os pacotes JAR que são confiados pelo pacote de jar adicionado.
3.1 Adicione o pacote JAR necessário em pom.xml
Use o editor do MAVEN POM para abrir o arquivo POM.XML no projeto, selecione dependências, clique em Adicionar na coluna Dependências e um botão de pesquisa aparece primeiro, por exemplo, digite a Web Spring e ele procurará automaticamente o pacote JAR relacionado à Web Web. Selecionamos a versão 3.0.5 da primavera. Adicione todos os pacotes de primavera. Outros pacotes JAR que precisam ser adicionados incluem: Junit, JSTL. Ou clique em Pom.xml para editar o arquivo pom.xml diretamente. Dessa forma, você pode copiar o conteúdo de dependências diretamente.
3.2 Defina o escopo do pacote JAR
Ao adicionar a um pacote JAR, existem algumas propriedades que precisam ser definidas. O mais importante é o escopo, que possui os seguintes valores:
1.Compile, o valor padrão se aplica a todas as etapas e será lançado junto com o projeto.
2. Fornecido, semelhante à compilação, espera que o JDK, o contêiner ou o usuário forneça essa dependência. Como servlet.jar.
3. Runtime, usado apenas em tempo de execução, como o driver JDBC, adequado para etapas de execução e teste.
4.Teste, usado apenas ao testar, é usado para compilar e executar o código de teste. Não será lançado com o projeto.
5. O sistema, semelhante ao fornecido, requer explicitamente um frasco que contenha dependências, e o Maven não o procurará no repositório.
Geralmente, o pacote JAR de escopo necessário para os projetos Springmvc é o seguinte:
Às vezes, acho que o servlet-api ainda está embalado sob a lib e um erro será definitivamente relatado no momento. Você também precisa instalar o WTP no plug -in maven.
Caminho de instalação on-line do Eclipse: http://m2eclipse.sonatype.org/sites/m2e-extras. Selecione para Eclipse WTP.
4. Construa a estrutura Springmvc
4.1 Editar o arquivo web.xml
Você precisa adicionar log4j, filtragem de caracteres, despachante de mola, etc.
O código webx.xml é o seguinte:
<? xml versão = "1.0" coding = "utf-8"?> <web-app xmlns = "http://java.sun.com/xml/ns/javaee" xmlns: xsi = "http:/wwww.w3 xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaeeeeey http://java.sun.com/xmls/javaee/web-web-web-web-web-2) Evite os nomes de duplicar padrão-> <Context-param> <amam-name> webApApprootKey </amam-name> <amam-value> maven.example.root </amam-value> </context--param> <!-Log4J do spring 4j-lister-> ouvinte> classg-class> org.sPringFramweb.weberb.weber- </ouvinte> <!-Definição de caracteres Filter-> <filter> <filter-name> caracterencodingfilter </ftrhter-name> <filter-Class> org.springframework.web.filter.characterencodingfilter </filter-class> <iit-param> <amam-name> Encoding </paramname> <init-param> <param-name>forceEncoding</param-name> <param-value>true</param-value> </init-param> </filter> <filter-mapping> <filter-name>CharacterEncodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <!-- Spring view distributor--> <servlet> <Verlet-Name> Dispatcher </vetlet-name> <Servlet-class> org.springframework.web.servlet.dispatcherServlet </servlet-class> <iit-param> <ama Paramname> contextconfiglocation </amam-Name> <ama Param-value> /web-nfispatcher-fliglocation </iram-Name> <a param-value> /web-nfispcher-Servlet.xervlet.x-e <amamervlet.xervlet.x --pamervlet.x --pamervlet.x --pamervlet.xervlet.x --pamervlet.xervlet.xervlet.xervlet.xervlet.xervlet. <Oad-on-startup> 1 </load-on-startup> </servlet> <Servlet-Mapping> <Servlet-Name> Dispatcher </vletname> <url-Pattern>*. do </url-pattern> </servlet-mapping> </web-app>
4.2 Escreva Arquivo de Configuração do Spring Dispatcher-Servlet.xml
Por exemplo, você deseja adicionar driver MVC, detecção de anotação, análise de visualização etc. O código Dispatcher-Servlet.xml é o seguinte:
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: aop = "http://www.springframework.orgog/schema xmlns: context = "http://www.springframework.org/schema/context" xmlns: mvc = "http://www.springframework.org/schema/mvc" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: xsi = "http://www.w3.org/2001/xmlschema-nstance" xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd http://www.springframwerw.org/schema http://wwwww.springframew.org/schema http://wwwww.springfring-schema/schema/ttp://wwwww.springframew.org/schema.xsd http:/wwwww.springframew.org/fhema.xsd/www.springfring.org/schema.xshd/ww.springframw.org/schema http://www.springframework.org/schema/tx/spring-tx-3.0.xsd "> <mvc: anotação-driven/> <contexto: component-scan value = ".
4.3 Escreva uma classe de teste de camada de controlador
Escreva uma classe de teste da camada do controlador Springmvc. Existe apenas um método para mapeamento de endereços e passa os dados para a página. O código é o seguinte:
pacote liming.maven.example.view; importar org.springframework.tereotype.controller; importar org.springframework.ui.model; importar org.springframework.web.bind.annotation.requestmapping; @Controller public class GeralController {@RequestMapping (value = "index.do") public void index_jsp (modelo modelo) {Model.addattribute ("Liming", "Hello Dawn"); System.out.println ("index.jsp"); }}4.4 Write Index.jsp Página
Primeiro, crie visualizações de pasta em SRC/Main/WebApp/Web-Inf. Aqui está o caminho do atributo prefixo no arquivo de configuração Dispatcher-Servlet.xml.
Criar arquivo index.jsp em visualizações
Usamos o JSTL para obter os dados do controleradd.
O código da página JSP é o seguinte:
<%@ página linguagem = "java" contentType = "text/html; charset = utf-8" pageEncoding = "utf-8"%> <%@ taglib prefix = "c" uri = "http://java.sun.com/jstl/core" http://java.sun.com/jstl/core "/! 4.01 Transição // pt "" http://www.w3.org/tr/html4/loose.dtd "> <html> <head> <meta http-equiv =" content-type "content =" text/html; value = "$ {liming}"> </c: out> </body> </html>5. Publique no tomcat
Não há nada a dizer sobre isso.
6. Teste
Endereço de acesso: http: // localhost: 8080/liming.maven.example/index.do
Aqui está uma captura de tela do resultado da visita:
2. Crie um projeto dinâmico da web para convertê -lo em um projeto Maven
7. O segundo método é converter o projeto DynamicWeb em Mavan
7.1 Crie um novo projeto dinâmico da Web
Selecione Arquivo -> Novo -> Outros. Na nova janela, selecione Dynamic Web Project na web. Clique em Avançar.
7.2 Configurar informações do projeto
7.2.1 Insira as informações do projeto
Primeiro insira o nome do projeto.
O tempo de execução do Target geralmente escolhe qual contêiner usar, Tomcat e assim por diante. Você não pode escolher primeiro.
Versão dinâmica do módulo da web. Esse é o número da versão. Escolha 2.5 (3.0 é Java7's).
A configuração é uma configuração fácil de escolher. Se o Target Runtime selecionar Tomcat. Isso corresponde à escolha do tomcat.
Próximo.
7.2.2 Configure a pasta de fonte e saída
Esta janela entra nas pastas de origem que você deseja criar. e pasta de saída padrão.
Adicionamos isso depois de construir o projeto.
A pasta de saída pode ser alterada para o destino/classes.
7.2.3 Configure o caminho para o arquivo web.xml
7.3 Converter para o Maven Project
Depois que o projeto dinâmico da Web for estabelecido, primeiro converta -o em um projeto MAVEN.
Clique com o botão direito do mouse neste item e selecione Maven -> Ativar gerenciamento de dependência. A janela pop-up acabou de terminar.
7.4 Outras configurações
O trabalho de configuração a seguir é basicamente o mesmo de antes.
Por favor, consulte o acima.
2.1 Adicione a pasta de origem
2.2 Altere o caminho da classe.
2.3.3 Configurando o projeto Faceted
2.4 Configuração do conjunto de implantação (Assembléia de implantação da Web)
Em seguida, é construir a estrutura Springmvc, publicá -la no tomcat e testá -la.
Download de anexo:
liming.Maven.Example.zip
liming.dynamic.example.zip