Este artigo apresenta as etapas detalhadas do Eclipse usando o Maven para criar o MVC do Spring para sua referência. O conteúdo específico é o seguinte
1. Configuração do ambiente
um). Java 1.7
b). Eclipse Luna
c). MAVEN3.2.5
d) .Spring 4.1.4
2. Crie um projeto Maven
um). Open Eclipse, Arquivo-> New-> Project-> Maven-> Maven Project
b). Próximo passo
c). Selecione o projeto criado como WebApp, Próxima etapa
d). Preencha o ID do grupo e o ID do artefato do projeto. De um modo geral, o ID do grupo escreve a ordem reversa do nome de domínio e o Artifact ID escreve o nome do projeto. Termine o último ponto.
e). Depois de construir inicialmente, a estrutura do diretório do projeto é a seguinte
f). Em diretórios gerais de projeto, no diretório Java Resources, existem três pastas de origem: SRC/Main/Java, SRC/Main/Test/Java e SRC/Main/Test/Recursos, que precisam ser criadas manualmente. Nas etapas a seguir, falaremos sobre como preencher esses três diretórios.
3. Modifique as configurações básicas do projeto
um). Clique com o botão direito do mouse no nome do projeto -> Propriedades -> Java Build Path e clique na tag de origem.
b). Prompt hello/src/main/java (ausente) e hello/src/test/java (ausente). Em diretórios gerais de projeto, no diretório Java Resources, também há uma pasta de origem SRC/Main/Test/Recursos. Exclua os desaparecidos primeiro e depois recrie -os e crie os desaparecidos diretamente. Clique com o botão direito do mouse na chave para excluir e adicionar.
c). Modifique -o completamente, o efeito é como mostrado na figura abaixo
d). Em seguida, modifique a configuração das bibliotecas, o JRE usa a versão 1.7. Selecione JRE System Library-> Editar para alterar a versão.
e). Altere a configuração em ordem e exporta novamente. O principal é ajustar a ordem de exibição desses quatro diretórios e ajustar a ordem que você gosta
f). Em seguida, modifique as facetas do projeto e primeiro modifique o Java para 1.7.
O módulo da Web dinâmico não pode ser modificado diretamente para 3.0 aqui. Você precisa abrir uma pasta .Sefettings no diretório do projeto, abrir org.eclipse.wst.common.project.facet.core.xml e fazer as seguintes modificações:
<instalação facet = "jst.web" versão = "3.0"/>
Reinicie o Eclipe e você verá que as mudanças entram em vigor.
4. Configuração do Maven no Eclipse
a) .Window-> Propriedades-> Maven, verifique as atualizações do índice de download do repositório na inicialização
5. Configuração simples do MVC da primavera
um). Abra o arquivo pom.xml no projeto, clique na guia Dependências e clique em Adicionar para adicionar para adicionar novas dependências
b). Se você conhece o ID do grupo de dependência e o ID do artefato, poderá preenchê -lo diretamente. Se você não estiver claro, pode inserir palavras -chave para consultar ou pesquisar em http://search.maven.org
c). As dependências que precisam ser adicionadas são: spring-webmvc, versão 4.1.4. LIBERAR. O conteúdo completo do arquivo pom.xml é o seguinte:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd "> <ModelVersion> 4.0.0 </modelVersion> <proupId> com.springStudy </fathagingId> <siSTIFACTID> Estudo </sTifactId> <satchaging> </</fatchaging> <versão> 0.0.1n1n.1n. <url>http://maven.apache.org</url> <properties> <spring.version>4.1.4.RELEASE</spring.version> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <Depencency> <voundid> org.springframework </frugiD> <TRAFACTID> spring-webmvc </artifactId> <versão> $ {spring.version} </versão </dependency> </dependências> <bruct> <inamename> estudar </finalName> </build> </projeto>d). Abra o arquivo SRC/Main/WebApp/Web-Inf/Web.xml e finalmente modifique-o 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" xmlns: web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd "id =" estudo "versão" "2.5"> <lame-name> arquiType Created Application </sisiber-name> <cription> sprintmc Ambiente </description> <!-Carregando Spring Configuration-File-> FILFIGUTURTURTURTURTURTURTURTURM> <MARAM-VALUE> CLASSPATH:/configs/spring-*. Xml </param-value> </context-param> <!-Spring Hearing-> <Ilvier> <lister-class> org.springframework.web.context.contextloaderListener </iather-class> </ouvier> <! </servlet-name> Dispatcher </servlet-name> <Servlet-class> org.springframework.web.servlet.dispatcherServlet </servlet-class> <!-personalize o nome do arquivo de configuração e o caminho da mola mvc-> <ing-param> <a Param-name> ContextConfigLocation </Park-Name> <MARAM-VALUE> ClassPath: configs/spring-ervlet.xml </param-value> </irit-param> <adarl-on-startup> 1 </olload-on-startup> </servlet> <!-Spring mvc Solicitação Suffix-> <arerlet-Mapping> <ver Servlet> Dispatcher </Servlet-Name> <url-Phrix-> <url-PAPPING> <sattertn> Dispatcher </Servlet-Name> <url-P-PLAPTN> <lorde-arquivo de boas-vindas> <lmed-fil-bile> index.jsp </chailt-fil-bile> </list-list> </web-app>
e). Crie uma pasta de configurações no diretório Java Recursos/Scr/Main/Recursos para armazenar o caminho de configuração declarado em web.xml
f). Crie Spring-Servlet.xml no diretório Java Resources/Scr/Main/Recursos/Configs, com o seguinte conteúdo:
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns:jee="http://www.springframework.org/schema/jee" xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation="http://www.springframework.org/schema/beans O http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.1.xsd http://ww.springframework.org/schema http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd "> <Contextation-config/> <Context-Scack-Pack-Pack-Pack-Package = <Contextation-Config/> <Context-S-Scack-Pack-PackGe-Package = <Contextation-config/> <context-scrase-Pack-Pack-Pack-Package = <Contextation-config/> <context-scrase-Pack-Pack-Packsd <mvc: anotação-driven/> <mvc: Recursos Mapping = "/Styles/**" Location = "/Styles/"/> <MVC: Recursos Mapping = "/Scripts/**" Location = "/Scripts/"/> <MVC: Recursos Mapping = "/Images/**" Location = "/Images/"/" value = "/web-inf/views/"/> <propriedade name = "sufix" value = ".
g). Crie o pacote do controlador. No arquivo Spring-Servlet.xml, o caminho foi especificado.
h). No diretório SRC/Main/WebApp/Web-Inf, crie o arquivo Views. No arquivo Spring-ervlet.xml, o caminho do arquivo de exibição foi especificado
eu). Crie o primeiro arquivo do controlador hellocontroller.java, o conteúdo completo do arquivo é o seguinte:
pacote com.springStudy.Controller; importar org.springframework.tereotype.controller; importar org.springframework.web.bind.annotation.requestmapping; importar org.springframework.web.servlet.modelandView; @Controller public class Classe Hellocontroller {@RequestMapping ("/hello") public ModelAndView hello () {ModelAndView MV = new ModelAndView (); MV.AddObject ("Spring", "Spring MVC"); mv.setViewName ("Hello"); retornar MV; }}j). Adicionar SRC/Main/WebApp/Web-Inf/Views/Hello.jsp, o conteúdo é o seguinte:
<! Doctype html> <html> <head> <meta charset = "utf-8"> <title> sprint hello </title> </head> <body> hello $ {spring}! </body> </html>6. Publique o projeto para Tomcat
um). Adicione o Tomcat 7 no eclipse;
b). Depois que o tomcat é adicionado, clique duas vezes para definir as configurações dos locais do servidor na guia Visão geral;
eu. Selecione Usar a instalação do Tomcat (assume o controle da instalação do Tomcat)
ii. Altere o conteúdo do caminho de implantação para: WebApps
iii.Save
c). Clique com o botão direito do mouse no tomcat, adicione e remova ..., adicione estudo
d). Iniciar o tomcat;
e). Aberto http: // localhost: 8080/estudo/olá no navegador e o acesso é bem -sucedido! Como mostrado na figura abaixo:
A operação acabou!
O exposto acima é todo o conteúdo do Eclipse usando o Maven para criar o MVC do Spring. Espero que possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.