1. Começando com o básico do Springmvc, crie um programa Helloworld
1. Primeiro, importe o pacote JAR exigido pelo Springmvc.
2. Adicione a configuração sobre Springmvc no arquivo de configuração web.xml
<!-Configure a configuração de SpringmvcdispatcherServlet e configure o mapeamento-> <Vertlet> <Servlet-name> springmvc </servlet-name> <sivetl-class> org.springframework.web.servlet.dispatcherStlet </servlet-class> <inic---------Mirating.web.vlet.dispatchesertlet </servlet-class> <ing----Param> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <!-- <load-on-startup>1</load-on-startup> --> </servlet> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping>
3. Adicione o arquivo de configuração Springmvc-ervlet.xml em SRC
<? 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" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/Context http://wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwtingframesaramente http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd "> <!! Recurso estático-> <MVC: Padrão-Servlet-Handler/> <!-Se você usar anotação, deverá configurar a seguinte configuração-> <mvc: anotação-driven/> <!-configure o internalResourCeViewResolver-> <bean id = "ResourceViewResolver "> <!-prefix-> /> <!-sufixo-> <propriedade name = "sufix" value = ".
4. Crie uma pasta chamada JSP na pasta Web-Inf para armazenar a visualização JSP. Crie um hello.jsp e adicione "Hello World" ao seu corpo.
5. Crie pacote e controlador como mostrado abaixo
6. Código do controlador de gravação
@Controlador @requestmapping ("/mvc") classe pública mvcController {@RequestMapping ("/hello") public string hello () {return "hello"; }}7. Inicie o servidor e digite http: // localhost: 8080/nome do projeto/mvc/hello
1.dispatcherServlet
DispatcheserServlet é um pré-controlador configurado no arquivo web.xml. Interceptar solicitações correspondentes. O servlet interceptando regras correspondentes deve ser definido por si mesmo. As solicitações interceptadas são distribuídas ao controlador de destino de acordo com as regras correspondentes para processamento. Este é o primeiro passo na configuração do Spring MVC.
2.InternalResourceViewResolver
Exibir o resolvedor de nome
3. As anotações acima
@Controller é responsável por registrar um feijão no contexto da primavera
@RequestMapping Anotation Especifica quais solicitações de URL podem ser processadas para o controlador
@Controlador
Responsável por registrar um feijão no contexto da primavera
@RequestMapping
Anotação especifica quais solicitações de URL podem ser processadas para o controlador
@Requestbody
Esta anotação é usada para ler parte dos dados do corpo da solicitação de solicitação, use o httpmessageConverter configurado pelo sistema para análise e, em seguida, vincule os dados correspondentes ao objeto a ser retornado e, em seguida, vincular os dados do objeto retornados pelo httpMessageConverter aos parâmetros do método no controlador
@ResponseBody
Esta anotação é usada para escrever o objeto retornado pelo método do controlador para a área de dados do corpo do objeto de resposta depois de convertê -lo no httpmessageConverter apropriado para o formato especificado
@Modelattribute
Use @Modelattribute Anotation on Method Definição: Spring MVC Antes de chamar o método de processamento de destino, o método que anota @modelattribute no nível do método será chamado um por um.
Use a anotação @modelattribute antes de inserir o parâmetro do método: você pode obter o objeto do objeto implícito, vincular os parâmetros de solicitação ao objeto e depois passar o método para o objeto de parâmetro para adicionar o método ao modelo.
@RequestParam
Use @RequestParam para passar os parâmetros de solicitação para o método de solicitação
@Pathvariable
Vincular o parâmetro de espaço reservado URL ao parâmetro de entrada
@ExceptionHandler
ANOTADO NO MÉTODO, o método será executado quando ocorrer uma exceção
@Controlleradvice
Faça de um controlador uma aula de manuseio de exceção global. O método anotado com o método @ExceptionHandler na classe pode lidar com todas as exceções que ocorrem nos controladores.
// corresponde automaticamente @RequestMapping ("/Pessoa") public String Topeson (nome da string, idade dupla) {System.out.println (nome+""+idade); retornar "Olá"; }1. Escreva uma aula de entidade pessoal
pacote test.springmvc.model; public class Pessoa {public String getName () {Return Name; } public void setName (nome da string) {this.name = name; } public int getage () {Age de retorno; } public void setage (int Age) {this.age = Age; } nome de string privado; private Int Age; }2. Métodos de gravação no controlador
// boxe automaticamente @ReQuestMapping ("/Person1") public String toperson (Pessoa P) {System.out.println (p.getName ()+""+p.getage ()); retornar "Olá"; } // O parâmetro foi convertido em initbinder @RequestMapping ("/date") public string data (data da data) {System.out.println (data); retornar "Olá"; } // No momento da inicialização, converta o tipo "string" em digite "date" @initbinder public void initbinder (servletRequestDatabinder Binder) {Binder.RegisterCustomeditor (DATE.Class, novo CustomDateEditor (novo simplificado ("Yyyyy-mm-dd"), True); } // Passe os parâmetros para a frente @RequestMapping ("/show") public String ShowPerson (map <string, object> map) {pessoa p = new Person (); map.put ("P", P); p.setage (20); p.setName ("Jayjay"); retornar "show"; }A recepção pode obter "P" no domínio da solicitação
// Passe os parâmetros para o final da frente usando ajax @requestMapping ("/getPerson") public void getPerson (nome da string, printwriter pw) {pw.write ("hello"+nome); } @ReQuestMapping ("/nome") public string dizhello () {return "name"; }A recepção chama isso com o seguinte código jQuery
$ (function () {$ ("#btn"). Clique (function () {$ .Post ("mvc/getPerson", {name: $ ("#name"). val ()}, function (dados) {alert (dados);});});}); // redirecionar @requestMapping ("/redirect") public string redirect () {return "redirect: hello"; }1. Dois pacotes JAR precisam ser importados
2. Adicione o arquivo de configuração Springmvc
<!-Carregar configurações-> <bean id = "multipartresolver"> <propriedade name = "maxuploadsize" value = "102400000"> </ouse> </sien>
3. Código do método
@RequestMapping (value = "/upload", método = requestmethod.post) public string upload (httpServletRequest req) lança exceção {multiparthttpServletRequest mreq = (multipartttpServletRequest) req; Arquivo multipart -arquivo = mreq.getfile ("arquivo"); String filename = FILE.GETORGINALFILENAME (); SimpledateFormat sdf = new SimpleDateFormat ("yyyymmddhhmmss"); FileOutputStream fos = new FileOutputStream (req.getSession (). GetServletContext (). GetRealPath ("/")+"upload/"+sdf.format (new Date ())+filename.substring (filename.lastIndexof ('.'))); fos.write (file.getBytes ()); fos.flush (); fos.close (); retornar "Olá"; }4. Formulário da recepção
<form ação = "mvc/upload" method = "post" rtype = "multipart/form-data"> <input type = "file" name = "file"> <br> <input type = "submit" value = "submit"> </morm>
@Controlador @requestmapping ("/test") classe pública mvcController1 {@RequestMapping (value = "/param") public String testRequestParam (@RequestParam (value = "id") integer id, @RequestParam (value = "name) name) {Sistema") retornar "/hello"; }}1.RestController
@Controlador@requestmapping ("/REST") classe pública RestController {@RequestMapping (value = "/user/{id}", método = requestmethod.get) public string get (@pathvariable ("id") integer id) {system.out.println ("get"+id); retornar "/hello"; } @RequestMapping (value = "/user/{id}", métod = requestMethod.post) public string post (@pathvariable ("id") integer id) {system.out.println ("post"+id); retornar "/hello"; } @RequestMapping (value = "/user/{id}", métod = requestMethod.put) public string put (@pathvariable ("id") integer id) {system.out.println ("put"+id); retornar "/hello"; } @ReQuestMapp (value = "/user/{id}", métod = requestMethod.Delete) public String Delete (@PathVariable ("id") Id ID) {System.out.println ("delete"+id); retornar "/hello"; }}2. o formulário da forma envia solicitações de put e excluir
Configure no web.xml
<!-Configure o HiddenHttpMethodfilter, converta o método de postagem para colocar ou excluir-> <filter> <filter-name> hiddenhttpmethodfilter </filter-name> <filter-class> org.springframework.web.filter.hiddenhtTttThodfilter </filterwilter </filterwringwork.web.filter.hiddenhttttTethfilter </filterwilter </filterwringwork.web.filter.hiddenhttttTethfilter </filterwilter </filterframework.web.filter.hidden> <Filter-Name> hiddenhttpmethodfilter </filter-name> <url-tattern>/*</url-tattern> </filter-Mapping>
Em primeiro plano, você pode usar o seguinte código para gerar uma solicitação
<form action = "REST/User/1" Method = "post"> <input type = "Hidden" name = "_ Method" value = "put"> <input type = "submit" value = "put"> </form> <form ação = "REST/1" Método = "Post"> <input Type = "submit"/"Post"> </forma type = "submeter" value = "get"> </morm> <form ação = "REST/user/1" method = "post"> <input type = "hidden" name = "_ method" value = "delete"> <input type = "submit" value = "delete"> </form>
1. Importe o seguinte pacote JAR
2. Código do método
@Controlador @requestmapping ("/json") classe pública JSONCONTROLLER {@ResponseBody @RequestMapping ("/usuário") public user get () {user u = new User (); U.SetId (1); u.setName ("Jayjay"); U.setBirth (new Date ()); devolver u; }}1. Lidar com exceções locais (no controlador)
@ExceptionHandler public ModelAndView ExceptionHandler (Exceção ex) {ModelAndView MV = new ModelAndView ("Error"); mv.adDObject ("Exception", ex); System.out.println ("In testExceptionHandler"); retornar MV; } @RequestMapping ("/Error") public string error () {int i = 5/0; retornar "Olá"; }2. Lidar com exceções globais (todos os controladores)
@ControllerAdvicePublic Classe testControlleRadvice {@ExceptionHandler public ModelAndView ExceptionHandler (Exceção ex) {ModelAndView MV = new ModelAndView ("Error"); mv.adDObject ("Exception", ex); System.out.println ("in testControlleradvice"); retornar MV; }}3. Outra maneira de lidar com exceções globais
Configurar no arquivo de configuração Springmvc
<!-Configure SimpleMappingExceptionResolver-> <Bean> <propriedade name = "ExceptionMappings"> <PRESPS> <Prop key = "java.lang.arithmeticexception"> Erro </sil
erro é uma página de erro
1. Crie uma classe MyInterceptor e implemente a interface HandlerInterceptor
public class MyIntercept implementa HandlerInterceptor {@Override public void Aftercompletion (httpServletRequest arg0, httpServletResponse arg1, objeto arg2, exceção arg3) lança exceção {System.out.println ("Aftercompletion"); } @Override public void PostHandle (httpServletRequest arg0, httpServletResponse arg1, objeto arg2, modelAndview arg3) lança exceção {System.out.println ("Posthandle"); } @Override public boolean prehandle (httpServletRequest arg0, httpServletResponse arg1, objeto arg2) lança exceção {System.out.println ("prehandle"); retornar true; }}2. Configure no arquivo de configuração Springmvc
<!-Configuração do interceptador-> <mvc: interceptores> <mvc: interceptor> <mvc: mapeando path = "/mvc/**"/> <ean> </ean> gt; </mvc: interceptador> </mvc: interceptores>
3. Ordem de execução do interceptador
1. Importar o pacote JAR exigido pelo Hibernate-Validate
(Não selecionado, não precisa importar)
2. Escreva o usuário da classe de entidade e adicione anotações de verificação
public class User {public int getId () {return id; } public void setId (int id) {this.id = id; } public string getName () {return name; } public void setName (nome da string) {this.name = name; } public data getBirth () {retornar nascimento; } public void Setbirth (data de nascimento) {this.birth = nascimento; } @Override public string tostring () {return "user [id =" + id + ", name =" + name + ", nascimento =" + nascimento + "]"; } private int id; @NotEmpty Private String Name; @Past @DateTimeFormat (Pattern = "yyyy-mm-dd") Partido privado;}PS: @Past significa que o tempo deve ser um valor passado
3. Use o formulário de Springmvc em JSP
<form:form action="form/add" method="post" modelAttribute="user"> id:<form:input path="id"/><form:errors path="id"/><br> name:<form:input path="name"/><form:errors path="name"/><br> birth:<form:input path="birth"/><form:errors path="birth"/><form:errors PATH = "NASCIMENTO"/> <FORME: ERROS PATH = "BIMADE"/> <form: erros path = "nascimento"/> <input type = "submite" value = "submit"> </form: formulário>
PS: Caminho correspondente ao nome
4. Código no controlador
@Controlador@requestmapping ("/form") classe public FormController {@RequestMapping (value = "/add", métod = requestMethod.post) public string add (@valid user u, bindingResult Br) {if (BR.GETERRORCOUNT ()> 0) {return "addUser"; } retornar "showUser"; } @ReQuestMapping (value = "/add", método = requestMethod.get) public string add (map <string, object> map) {map.put ("user", new user ()); retornar "adduser"; }}PS:
1. Como o atributo ModelAttribute é usado no JSP, deve haver um "usuário" no domínio da solicitação.
2.@válido significa verificar parâmetros de acordo com a anotação marcada na entidade
3. Retorne à página original para re-Express e o formulário também será re-Express.
5. Personalize a mensagem de erro
Adicione Locale.Properties no diretório SRC
NotEmpty.User.Name = Nome não não pode ser esvaziado.User.Birth = Birth deve ser um passado valueDateTimeFormat.User.birth = O formato da entrada é errado
Configurar no arquivo de configuração Springmvc
er
6. Exibição internacional
Adicionar loce_zh_cn.properties sob SRC
nome de usuário = senha da conta = senha
Adicionado no Locale.properties
nome de usuário = usuário namePassword = senha
Crie um Locale.jsp
<body> <fmt: message key = "nome de usuário"> </fmt: message> <fmt: message key = "senha"> </fmt: message> </body>
Configure no Springmvc
<!-Faça a página JSP pode ser visitada-> <MVC: View-Controller Path = "/Locale" View-name = "Locale"/>
Deixe Locale.jsp ser acessado diretamente em Web-Inf
Por fim, visite Locale.jsp, alterne o idioma do navegador e o idioma que pode ver a conta e a senha também foram alterados.
1. Crie um pacote de teste.springmvc.integrate para demonstrar integração e criar vários tipos
2. Classe de entidade do usuário
public class User {public int getId () {return id; } public void setId (int id) {this.id = id; } public string getName () {return name; } public void setName (nome da string) {this.name = name; } public data getBirth () {retornar nascimento; } public void Setbirth (data de nascimento) {this.birth = nascimento; } @Override public string tostring () {return "user [id =" + id + ", name =" + name + ", nascimento =" + nascimento + "]"; } private int id; @NotEmpty Private String Name; @Past @DateTimeFormat (Pattern = "yyyy-mm-dd") Partido privado;}3.USERSERVICE CLASSE
@ComPonentPublic Class UserService {public UserService () {System.out.println ("Uservice Constructor .../N/N/N/N/N/N/N/N/N"); } public void save () {System.out.println ("salvar"); }}4.UserController
@Controller @requestmapping ("/integrate") classe pública UserController {@AUTOWIRed Private UserService UserService; @RequestMapping ("/Usuário") public String saveUser (@requestbody @modelattribute user u) {System.out.println (u); userService.Save (); retornar "Olá"; }}5. Arquivo de configuração da prole
Crie Springioc Configuration File ApplicationContext.xml no diretório SRC
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/util http://www.springframe- http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd " xmlns:util="http://www.springframework.org/schema/util" xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/Context" FextEnGen-scan type = "annotation" expressão = "org.springframework.steretype.controller"/> <Contexto: exclude filter type = "anotação" expressão = "org.springframework.web.bind.annotation.ControlleradVice"/> Contexto: componente-scan> </bans>
Adicionar configuração em web.xml
<!-- configure the springIOC --> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext.xml</param-value> </context-param>
0
<!-Digitam o pacote e o sub-pacote-> <Contexto: Componente-Scan Base-Package = "test.springmvc.integrate"> <Contexto: incluir filtro type = "anotação" expressão = "org.springframework.steretype.controller"/> context: incluir-filter type = "anotação" expressão = "org.springframework.web.bind.annotation.controlleradvice"/> </context: component-scan>
1. SpringMVC é desenvolvido com base no método e o STRUTS2 é desenvolvido com base na classe. SpringMVC mapeia o URL e o método no controlador. Depois que o mapeamento é bem -sucedido, o SpringMVC gera um objeto de manipulador, que inclui apenas um método. A execução do método termina e os dados formais dos parâmetros são destruídos. O desenvolvimento do controlador da SpringMVC é semelhante ao desenvolvimento de serviços da Web.
2. SpringMVC pode realizar o desenvolvimento de singleton e é recomendável usar o desenvolvimento de singleton. O STRUTS2 recebe parâmetros através das variáveis de membro da classe. Singleton não pode ser usado, apenas vários casos podem ser usados.
3. Após o teste real, o Struts2 é lento, porque usa tags de suportes. Se você usar suportes, é recomendável usar o JSTL.