Um tutorial simples sobre como começar
O código -fonte desta instância e o frasco na instância
Código fonte: http://xiazai.vevb.com/201612/yuanma/springmvc_jb51.zip
Jar necessário: http://xiazai.vevb.com/201612/yuanma/springmvcjar_jb51.zip
Outro artigo sobre o upload de arquivos Springmvc, upload de vários arquivos: //www.vevb.com/article/100491.htm
Exemplos de configuração simples de anotação:
1. Crie um projeto:
1. Crie um novo projeto dinâmico da Web:
2. Nome o projeto: springmvc_01
3. Adicione o TomCat Runtime Environment/Dependence Library. Se for o Myeclipse, esta etapa não é necessária ao criar um projeto da Web.
Clique com o botão direito do mouse no projeto e clique em Build Path-> Adicionar bibliotecas:
Depois de adicionar, haverá pacotes adicionais de servlet Tomcat
4. Finalmente, adicione os frascos necessários para a primavera e o springmvc, e eu adiciono os seguintes frascos ao projeto
2. Arquivo de configuração:
1. Primeiro configure um DispatcheserServlet no web.xml e especifique a URL que precisa ser interceptada através de <Servlet-Mapping>. O XML a seguir configura um URL intercepto com sufixo.html.
<!-Configure a mola MVC DispatcheserServlet-> <Verlet> <Verlet-name> mvc </servlet-name> <Servlet-class> org.springframework.web.servlet.dispatcherServlet </servlet-class> <!! <amam-name> contextConfigLocation </amam-name> <amam-value> /web-inf/classes/mvc**.* </amam-value> </irit-param> <lound-on-startup> 1 </olload-on-startup> </servlet> <! <Verlet-name> mvc </vetlet-name> <url-tattern>*. html </url-tattern> </servlet-mapping>
Primeiro, configure um servlet e depois carregue o arquivo xml springmvc no contexto da mola. Em seguida, configure o mapeamento de servlet, o servlet-name é o nome configurado no servlet agora e depois especificar que o URL a ser interceptado é *.html
2. Configure o ouvinte de contexto da Spring e especifique o caminho para o arquivo de configuração XML da Spring.
<!-Ouça o contêiner de contexto da primavera-> <Ilvier> <ouvinte-class> org.springframework.web.context.contextLoaderListener </lister-class> </ouvinte> <!-Carregue o arquivo de configuração da primavera xml no contexto da mola-> <mam.Mam> <Param-Name> contextflflclflconl. <amam-value> ClassPath: root-context.xml </param-value> </context-param>
O caminho do caminho especificado aqui está no arquivo de patê de classe após a compilação do projeto.
Conteúdo final do arquivo web.xml:
<?xml version="1.0" encoding="UTF-8"?> <web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xmls/javaee/http://java.sun.com/xmls/javaee/web--/namp_web-/java.sun.com/xmls/javaee/http://java.sun.com/xmls/javaee/web-web--/java.sun.com/xmls/javaee/web--/nam-nam-nam-nam-nam-nam-nam-nam-slits/ Ouvinte> <Ilvier-Class> org.springframework.web.context.contextLoaderListener </ouvinte-class> </ouvinte> <!-Carregando o arquivo de configuração xml spring no copter em contêiner de primavera-> <mamelue ClassClinath) <-tam-name> <-paramMexTenTeMexeTlue <-tamnMexTeMextEnTeMexextclinTenTenTeMextClinTenTenTeMextClinTenTenTeTlextclinating <-param-namesTenTeMext.TamexTenTeMextClinTentExtclinxt) <-paramname>: </context-param> <!-Configure mring mvc despachoserServlet-> <ervlet> <Servlet-name> mvc </servlet-name> <Servlet-class> org.springframework.web.servlet.dispatherServlet </servlet> <!-Parâmetros de inicialização-> <ings- ^ <amam-name> contextConfigLocation </amam-name> <amam-value> /web-inf/classes/mvc**.* </amam-value> </irit-param> <lound-on-startup> 1 </olload-on-startup> </servlet> <! <Verlet-name> mvc </servlet-name> <url-tattern>*. html </url-tattern> </servlet-mapping> <lorde-fil-list> <lorde-file> index.html </chak-File> </-Welcome-File-List>
3. Crie o arquivo XML necessário para Springmvc e o arquivo XML do ApplicationContext. Aqui, como o formato necessário para o init-param no servlet configurado na primeira etapa é: MVC*.*. É para encontrar um arquivo começando com o MVC; portanto, ao criar o arquivo XML do springmvc, devo começar com o MVC. Eu o nomei: mvc-context.xml e, de acordo com a configuração no contexto-param, nomeie o arquivo ApplicationContext: root-context.xml;
4. Configure MVC-Context.xml:
Primeiro Importar root-context.xml através da tag de importação e, em seguida, digitalize o nome do pacote especificado através da tag de varredura de componente para fazer a anotação da primavera de todas as classes Java sob o pacote entrar em vigor.
Em seguida, configure o analisador de renderização de exibição do Springmvc, para que seu prefixo seja/página/e seu sufixo seja .jsp, de modo que os caminhos que o Springmvc precisa renderizar podem ser encontrados em/página/retorno value.jsp.
<!-Carregar o arquivo de configuração global do Spring-> <Beans: importar resource = "root-context.xml" /> <!-Springmvc Configuration-> <!-Deixe a mola a verificação de todas as classes em Org.swingLife.Controller através do componente, o que as anotações do código da primavera tomam efeito-> <Contexto: base-package = "org.swinglife.controller"> </context: component-scan> <!-Configure o renderizador de visualização do SpringMVC, com seu prefixo como:/página/e seu sufixo como .jsp renderize a exibição para/página/<dodod Return Value> .jsp-> <Bean: bEan P:.
Finalmente, MVC-Context.xml e root-context.xml são:
mav-context.xml:
<?xml version="1.0" encoding="UTF-8"?> <beans:beans xmlns="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:beans="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/sing-bean.xsd http://www.springframework.org/schema/Context http://www.springframework.org/schema/Context/spring-context.xsd "> <!-carregar o arquivo global da primavera-> <Beans> <Bontext.xsd "-COTMEXMEXMEXTEXTCETCETCETCETCETCE = SpringMert/! <!-Deixe a primavera digitalizar todas as classes sob org.swinglife.controller através da varredura de componentes para fazer com que as anotações de código da primavera entrem em vigor-> <Contexto: componente-Scan Base-Package = "org.swinglife.Controller"> </ context-scan> <!-Configure Springmvc. Renderize a visualização em/página/<Método Valor de retorno> .jsp-> <Beans: Bean P: prefix = "/Page/" P: sufix = ". JSP"> </ Beans: Beans>
root-context.xml:
<? 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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/Context/spring-context-3.2.xsd http://www.springframework.org/3.xsch http://www.springframework.org/3.xsch http://www.springframwerw.org/schema/10 http://www.springframework.org/schema/tx/spring-tx-3.2.xsd "> <!-Contexto raiz: define recursos compartilhados visíveis para todos os outros componentes da web-> </ Beans>
3. Escreva controlador
1. Create Org.swinglife.Controller Pacote para armazenar a classe Controller e, em seguida, crie um novo Homecontroller.java para escrever o controlador na página inicial
2. Use a anotação @Controller para definir a classe Homecontroller como um controlador e use @RequestMapping ("Value") para especificar o caminho do caminho ou método para acessar no método. O SpringMVC pode converter um pojo em um controlador que lida com a solicitação por meio de uma anotação @Controller e especifique quais solicitações são necessárias para o controlador através do @RequestMapping.
@Controller public class Class HomeController { /**** Página inicial retorna para /page/home.jsp página* @return* /@requestMapping ("index") public ModelAndView Index () {// Crie modelo e visualize para renderizar a página. E especifique que a página a ser retornada é o Home Page ModelAndView Mav = new ModelAndView ("Home"); retornar mav; }}O objeto ModelAndView é definido no método. Por meio desse objeto, a visualização a ser renderizada é especificada como casa e, finalmente, retorna o ModelAndView. Renderize a página em home.jsp.
3. Finalmente, Create /page/home.jsp no diretório da webContent para que o Springmvc possa encontrar e renderizar a visualização da página.
<%@ Page Language = "java" contentType = "text/html; charset = gb18030" PageEncoding = "GB18030"%> <! "http://www.w3.org/tr/html4/loose.dtd"> <html> <head> <meta http-equiv = "content-type" content = "text/html; charset = gb18030"> <//title </title </head> </html>
Agora, um modo SpringMVC completo foi construído, você pode executar o projeto para teste.
4. Escreva o envio e entrega de parâmetros:
1. Escreva uma nova classe UserController para assumir que o usuário está conectado, envie o nome de usuário e a senha ao controlador para processamento e, após o login, o nome de usuário e a senha são passados para a página de sucesso.
Crie UserController.java
Create /page/succ.jsp Página como página de login de sucesso do usuário
Código em UserController:
@Controller Public class UserController { /**** Login do usuário* <p> Configuração da anotação, apenas a postagem pode enviar a este método* @param userName* @param senha* @return* /@requestMapping (value = "login", métod = requestmethod.post) Public ModelAndView Login (stringnAming (UsernamEnking = "Login", Method = requestmethod.Post) Public ModelAndView Login (StringnEnk. para a página de login. if (this.checkParams (new String [] {nome de usuário, senha})) {// Especifique a página a ser retornada como succ.jsp modelAndView mav = new ModelandView ("succ"); // retorna o parâmetro para a página mav.addobject ("nome de usuário", nome de usuário); mav.addobject ("senha", senha); retornar mav; } retornar new ModelAndView ("Home"); } / **** Verifique se o parâmetro está vazio* @param params* @return* / private boolean checkparams (string [] params) {for (string param: params) {if (param == "" || param == null || param.isempty ()) {return); }} retornar true; } Primeiro especifique @Controller e, em seguida, especifique @RequestMapping como método de login;
Deve -se notar que, desta vez, o modo de método da página é especificado no @RequestMapping que o modo de método da página deve ser o modo de postagem, caso contrário, não estará acessível. Em segundo lugar, o parâmetro de valor especifica o caminho de acesso.
E defina o parâmetro no método de login, e o parâmetro é o atributo de nome no formulário.
Em seguida, adicione parâmetros à solicitação através do método AddObject do ModelAndView, para que esses parâmetros possam ser exibidos na página retornada.
Existem outras maneiras de passar os parâmetros para a página, além disso:
/**** Outra forma de passagem de parâmetros* Processe os parâmetros solicitados. * @param nome de usuário * @param senha * @param request * @return */ @RequestMapping (value = "login", método = requestmethod.post) public ModelAndView Login (nome de usuário da string, string senha, httpServletRequest request) {request.setAttribute ("username", USERNAME); request.setAttribute ("senha", senha); retornar novo ModelAndView ("Succ"); }O método acima é usado diretamente adicionando parâmetros à solicitação.
2. Escreva a página do Sc.JSP e da página do formulário:
succ.jsp:
<Body> <h2> login </h2> nome de usuário: $ {nome de usuário} <p> senha: $ {senha} </body> form: <formulário action = "login.html" method = "post"> userr input: <input type = "text" = "username"/> <p> senha: <input Type = " value = "submeter" /> </morm> 3. Finalmente execute o projeto para testar:
Ok está tudo pronto. O acima é um exemplo relativamente simples de SpringMVC.
No código -fonte fornecido, existe outro método para usar diretamente a String como o valor de retorno para especificar a página de exibição.
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.