1. Comenzando con los conceptos básicos de SpringMVC, cree un programa Helloworld
1. Primero, importe el paquete JAR requerido por SpringMVC.
2. Agregue la configuración sobre SpringMVC en el archivo de configuración web.xml
< <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. Agregue el archivo de configuración SpringMvc-Servlet.xml en SRC
<? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: contexte = "http://www.springframework.org/schema/context" xmlns: mvc = "http://www.springframework.org/schema/mvc" xsi: schemalocation http://www.springframework.org/schema/Beans/spring-Beans.xsd http://www.springframework.org/schema/context http://www.springfframeWork http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd "> <!-escanear el paquete y el subpacaje-> <context: component-scan-package =" test.springmvc "/" recursos-> <mvc: default-servlet-handler /> <!-Si utiliza la anotación, debe configurar la siguiente configuración-> <mvc: annotation-conduct /> <!-Configurar el interneourceViewResolver-> <bean id = "internalresourceViewresOlver"> <!-prefix-> <name de propiedad = "prefix" valor = "valor =" /"" /" /" <!-Suffix-> <Property Name = "Suffix" Value = ". JSP"/> </le bean> </beans>
4. Cree una carpeta llamada JSP en la carpeta Web-INF para almacenar la vista JSP. Cree un Hello.jsp y agregue "Hello World" a su cuerpo.
5. Cree paquete y controlador como se muestra a continuación
6. Escribir código del controlador
@Controlador @requestmapping ("/mvc") public class mvcController {@RequestMapping ("/Hello") public String Hello () {return "Hello"; }}7. Inicie el servidor y escriba http: // localhost: 8080/name de proyecto/mvc/hello
1.Dispatcherservlet
DispatcherServlet es un pre-controlador configurado en el archivo web.xml. Interceptando solicitudes coincidentes. Las reglas de coincidencia de interceptación de servlet deben definirse por sí mismas. Las solicitudes interceptadas se distribuyen al controlador objetivo de acuerdo con las reglas correspondientes para el procesamiento. Este es el primer paso para configurar Spring MVC.
2.internalresourceViewResolver
Ver resolución de nombre
3. Las anotaciones anteriores
@Controller es responsable de registrar un bean en el contexto de primavera
@RequestMapping Annotation especifica qué solicitudes de URL se pueden procesar para el controlador
@Controlador
Responsable de registrar un frijol en el contexto de primavera
@RequestMapping
La anotación especifica qué solicitudes de URL se pueden procesar para el controlador
@Requestbody
Esta anotación se utiliza para leer parte de los datos del cuerpo de la solicitud de solicitud, use el httpmessageConverter configurado por el sistema para el análisis, y luego vincular los datos correspondientes al objeto que se devuelve y luego unir los datos del objeto devuelto por httpMessageConverter
@ResponseBody
Esta anotación se utiliza para escribir el objeto devuelto por el método del controlador al área de datos del cuerpo del objeto de respuesta después de convertirlo en el httpMessageConverter apropiado al formato especificado
@Modelattribute
Use @ModelAttribute Annotation en la definición del método: Spring MVC antes de llamar al método de procesamiento de destino, el método que anota @modelattribute en el nivel de método se llamará uno por uno.
Use la anotación de @modelattribute antes de ingresar el parámetro del método: puede obtener el objeto del objeto implícito, unir los parámetros de solicitud al objeto y luego pasar el método al objeto parámetro para agregar el método al modelo.
@RequestParam
Use @RequestParam para pasar los parámetros de solicitud al método de solicitud
@PathVariable
Atar el parámetro de entrada a la URL al parámetro de entrada
@ExceptionHandler
Anotado en el método, el método se ejecutará cuando ocurra una excepción
@ControllerAdvice
Haga de un controlador una clase de manejo de excepciones globales. El método anotado con el método @ExceptionHandler en la clase puede manejar todas las excepciones que ocurren en los controladores.
// coincide automáticamente @RQUESTMAPPing ("/persona") public String toperson (nombre de cadena, doble edad) {system.out.println (nombre+""+edad); devolver "hola"; }1. Escribe una clase de entidad de persona
paquete test.springmvc.model; public class Person {public String getName () {return name; } public void setName (nombre de cadena) {this.name = name; } public int getAge () {return Age; } public void setAge (int Age) {this.age = edad; } nombre de cadena privada; edad privada int; }2. Escribir métodos en el controlador
// boxeo automáticamente @RequestMapping ("/persona1") public String toperson (persona p) {system.out.println (p.getName ()+""+p.getage ()); devolver "hola"; } // El parámetro se convirtió en initBinder @RequestMapping ("/fecha") Fecha de cadena pública (fecha de fecha) {System.out.println (fecha); devolver "hola"; } // En el momento de la inicialización, convierta el tipo de "cadena" a tipo "fecha" @initbinder public void initBinder (ServLetRequestDatabinder Binder) {binder.registerCustomEditor (date.class, new CustomDateEditor (nuevo SimpledAformat ("Yyyy-MM-DD"), verdadero)); } // Pase los parámetros a front-end @RequestMapping ("/show") public String showperson (map <string, object> map) {persona p = nueva persona (); map.put ("p", p); P.Setage (20); p.setName ("Jayjay"); regresar "show"; }La recepción puede obtener "P" en el dominio de solicitud
// Pase los parámetros al front-end usando ajax @requestmapping ("/getperson") public void getperson (nombre de cadena, printwriter pw) {pw.write ("hola"+nombre); } @RequestMapping ("/name") public String Sayshello () {return "name"; }La recepción lo llama con el siguiente código jQuery
$ (function () {$ ("#btn"). click (function () {$ .post ("mvc/getperson", {name: $ ("#name"). val ()}, function (data) {alerta (data);});});}); // redirect @requestmapping ("/redirect") public string redirect () {return "redirect: hello"; }1. Dos paquetes de jares deben importarse
2. Agregue el archivo de configuración de SpringMVC
<
3. Código de método
@RequestMapping (valor = "/upload", método = requestmethod.post) public string upload (httpservletRequest req) lanza la excepción {multipThttPservletRequest mreq = (multiphttpServletRequest) req; Archivo múltiple = mreq.getfile ("archivo"); Cadena filename = file.getOriginalFileName (); 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 (); devolver "hola"; }4. Formulario de recepción
<form de acción = "mvc/upload" método = "post" enctype = "multipart/form-data"> <input type = "file" name = "file"> <br> <input type = "shit" value = "enviar"> </form>
@Controlador @requestmapping ("/test") public class mvcController1 {@RequestMapping (valor = "/param") public String testRequestParam (@RequestParam (value = "id") ID integer, @RequestParam (value = "Nombre") String Name) {System.println (id+"+nombre); regresar "/hola"; }}1.restcontroller
@Controlador@requestmapping ("/REST") public class RestController {@RequestMapping (valor = "/user/{id}", método = requestmethod.get) public string get (@PathVariable ("id") ID de entero) {System.Println ("get"+id); regresar "/hola"; } @RequestMapping (value = "/user/{id}", método = requestmethod.post) public String post (@PathVariable ("id") ID entero) {system.out.println ("post"+id); regresar "/hola"; } @RequestMapping (value = "/user/{id}", método = requestmethod.put) public String put (@PathVariable ("id") ID entero) {System.out.println ("Put"+id); regresar "/hola"; } @RequestMapping (value = "/user/{id}", método = requestmethod.delete) public String delete (@PathVariable ("id") ID entero) {System.out.println ("delete"+id); regresar "/hola"; }}2. Formulario de formación envía solicitudes Put y Eliminar
Configurar en Web.xml
< <filter-name> Hiddenhttpmethodfilter </filter-name> <url-pattern>/*</url-Pattern> </filtro-mapping>
En primer plano, puede usar el siguiente código para generar una solicitud
<form de acción = "REST/USER/1" Method = "Post"> <input type = "Hidden" name = "_ Method" value = "put"> <input type = "Subt" value = "put"> </form> <form de action = "rest/user/1" método = "post"> <input type = "Subt" Value = "Post"> </form> <Formul value = "get"> </form> <form de acción = "REST/USER/1" Method = "Post"> <input type = "Hidden" name = "_ Method" Value = "Eliminar"> <input type = "Envit" Value = "Eliminar"> </form>
1. Importe el siguiente paquete de jar
2. Código de método
@Controlador @requestmapping ("/json") public class JsonController {@ResponseBody @RequestMapping ("/User") Public User get () {user u = new User (); U.SetId (1); U.SetName ("Jayjay"); U.SetBirth (nueva fecha ()); devolver u; }}1. Manejar las excepciones locales (en el controlador)
@ExceptionHandler public ModelAndView ExceptionHandler (Exception Ex) {ModelAndView mv = new ModelAndView ("Error"); MV.AdDObject ("Excepción", Ex); System.out.println ("en testExceptionHandler"); regresar MV; } @RequestMapping ("/Error") Public String Error () {int i = 5/0; devolver "hola"; }2. Manejar las excepciones globales (todos los controladores)
@ControllerAdVicePublic TestControllerAdVice {@ExceptionHandler ModelAndView ExceptionHandler (Exception Ex) {ModelAndView mv = new ModelAndView ("Error"); MV.AdDObject ("Excepción", Ex); System.out.println ("en testControllerAdVice"); regresar MV; }}3. Otra forma de lidiar con las excepciones globales
Configurar en el archivo de configuración de SpringMVC
<!-Configurar simplomingExpingExceptionResolver-> <Bean> <Property Name = "ExceptionMappings"> <props> <prot Key = "java.lang.arithmeticException"> Error </prop> </props> </property> </bean>
El error es una página de error
1. Cree una clase myInterceptor e implementa la interfaz HandlerInterceptor
clase pública MyInterceptor implementa HandlerInterceptor {@Override public void AfterComppletion (httpservletRequest arg0, httpServletResponse Arg1, object arg2, excepción arg3) arroja excepción {System.out.println ("Aftercompletion"); } @Override public void postthandle (httpservletrequest arg0, httpservletResponse arg1, object arg2, modelandview arg3) lanza la excepción {System.out.println ("posthandle"); } @Override public Boolean PreHandle (httpservletRequest arg0, httpServletResponse Arg1, objeto arg2) lanza la excepción {System.out.println ("prehandle"); devolver verdadero; }}2. Configurar en el archivo de configuración de SpringMVC
<!-Configuración del interceptor-> <mvc: interceptores> <mvc: interceptor> <mvc: mapping ruta = "/mvc/**"/> <bean> </bean> gt; </mvc: interceptor> </mvc: interceptores>
3. Orden de ejecución del interceptor
1. Importe el paquete jar requerido por hibernato-validato
(No seleccionado, no necesita importar)
2. Escribir el usuario de la clase de entidad y agregar anotaciones de verificación
Usuario de clase pública {public int getId () {return id; } public void setid (int id) {this.id = id; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } Fecha pública GetBirth () {Return Birth; } public void setBirth (fecha de nacimiento) {this.birth = nacimiento; } @Override public String toString () {return "user [id =" + id + ", name =" + name + ", birth =" + birth + "]"; } private int id; @Notempty Nombre de cadena privada; @Past @DatetimeFormat (Pattern = "yyyy-mm-dd") Private Fecha de nacimiento;}PD: @past significa que el tiempo debe ser un valor pasado
3. Use el formulario de SpringMVC en JSP
<form: form: form de acción = "form/add" método = "post" modelattribute = "user"> id: <form: input path = "id"/> <form: errores path = "id"/> <br> name: <form: input path = "name"/> <form de errores Path = "Birth"/> <Form: errores Path = "Birth"/> <Form: errores Path = "Birth"/> <Input type = "Subt" Value = "Subt"> </Form: Form>
PD: la ruta correspondiente al nombre
4. Código en el controlador
@Controlador@requestmapping ("/form") public class FormController {@RequestMapping (value = "/add", método = requestmethod.post) public string String add (@Valid User U, BindingResult BR) {if (BR.GetErrorCount ()> 0) {return "Adduser"; } return "showUser"; } @RequestMapping (valor = "/add", método = requestmethod.get) public string add (map <string, object> map) {map.put ("user", new user ()); devolver "adduser"; }}PD:
1. Debido a que el atributo ModelAttribute se usa en JSP, debe haber un "usuario" en el dominio de solicitud.
2.@válido medios verificar los parámetros de acuerdo con la anotación marcada en la entidad
3. Regrese a la página original para volver a expresar, y el formulario también volverá a expresar.
5. Personalizar el mensaje de error
Agregar locale.properties en el directorio SRC
Notempty.user.name = name no se puede no ser vaciador.
Configurar en el archivo de configuración de SpringMVC
<!-Configurar el recurso local-> <bean id = "Messagesource"> <Property Name = "Basename" value = "locale"> </property> </le bean>
6. Exhibición internacional
Agregar lugar_zh_cn.properties en SRC
nombre de usuario = contraseña de cuenta = contraseña
Agregado en locale.properties
nombre de usuario = usuario NamePassword = contraseña
Crea un lugare.jsp
<body> <fmt: mensaje Key = "UserName"> </fmt: mensaje> <fmt: mensaje clave = "contraseña"> </fmt: mensaje> </body>
Configurar en SpringMVC
<!-Hacer que la página JSP se pueda visitar-> <mvc: ver-Controller ruta = "/locale" View-Name = "locale"/>
Deje que se accedan directamente a locale.jsp en Web-INF
Finalmente, visite locale.jsp, cambie el idioma del navegador y el idioma que puede ver la cuenta y la contraseña también se ha cambiado.
1. Cree un paquete Test.SpringMVC.Ingate para demostrar la integración y crear varios tipos
2. Clase de entidad del usuario
Usuario de clase pública {public int getId () {return id; } public void setid (int id) {this.id = id; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } Fecha pública GetBirth () {Return Birth; } public void setBirth (fecha de nacimiento) {this.birth = nacimiento; } @Override public String toString () {return "user [id =" + id + ", name =" + name + ", birth =" + birth + "]"; } private int id; @Notempty Nombre de cadena privada; @Past @DatetimeFormat (Pattern = "yyyy-mm-dd") Private Fecha de nacimiento;}3. Clase de servicio de usuarios
@ComponentPublic de clase UserService {public Userservice () {System.out.println ("UserService Constructor .../N/N/N/N/N/N/N/N/N/N"); } public void save () {System.out.println ("Save"); }}4.serigrollador
@Controlador @requestmapping ("/integrate") Clase pública UserController {@aUtoWired private UserService UserService; @RequestMapping ("/User") public String saveUser (@RequestBody @modelattribute User U) {System.out.println (u); UserService.save (); devolver "hola"; }}5. Archivo de configuración de Spring
Crear archivo de configuración SpringioC ApplicationContext.xml en el directorio SRC
<? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "xmlns: util =" http://www.springframe.org/schema/util " xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/context"> <context: component-scan base-package = "test.springmvc.iNtegate"> <<cuentation "contextation". Expression = "org.springframework.steretype.controller"/> <context: exclute-filter type = "annotation" expresion = "org.springframework.web.bind.annotation.controllerAdvice"/> </context: component-scan> </arrera>
Agregar configuración en web.xml
<!-Configure el SpringIOC-> <Oyerer> <Oyerer-class> org.springframework.web.context.contextLoaderListener </oyear-class> </oyeyer> <xtute-param> <amamname> contextCigLocation </amamname-name> <amarr-value> classpath: application
6. Haga una configuración en SpringMVC para evitar que SpringMVC y SpringioC se superpongan a la gestión del mismo objeto
< Expression = "org.springframework.web.bind.annotation.controllerAdvice"/> </context: component-scan>
1. SpringMVC se desarrolla en función del método, y Struts2 se desarrolla en función de la clase. SpringMVC mapea la URL y el método en el controlador. Después de que el mapeo sea exitoso, SpringMVC genera un objeto de controlador, que solo incluye un método. La ejecución del método termina y los datos de parámetros formales se destruyen. El desarrollo del controlador de SpringMVC es similar al desarrollo de servicios web.
2. SpringMVC puede realizar el desarrollo de Singleton, y se recomienda utilizar el desarrollo de Singleton. STRUTS2 recibe parámetros a través de las variables miembros de la clase. Singleton no se puede usar, solo se pueden usar múltiples casos.
3. Después de las pruebas reales, Struts2 es lento, porque usa etiquetas Struts. Si usa Struts, se recomienda usar JSTL.