Un simple tutorial sobre cómo comenzar
El código fuente de esta instancia y el fras en la instancia
Código fuente: http://xiazai.vevb.com/201612/yuanma/springmvc_jb51.zip
Jar requerido: http://xiazai.vevb.com/201612/yuanma/springmvcjar_jb51.zip
Otro artículo sobre la carga de archivos SpringMVC, carga de múltiples archivos: //www.vevb.com/article/100491.htm
Ejemplos de configuración de anotación simple:
1. Crea un proyecto:
1. Cree un nuevo proyecto web dinámico:
2. Nombra el proyecto: SpringMVC_01
3. Agregue la biblioteca/biblioteca de dependencia de tiempo de ejecución Tomcat. Si es myeclipse, este paso no es necesario al crear un proyecto web.
Haga clic con el botón derecho en el proyecto y haga clic en Build Rath-> Agregar bibliotecas:
Después de agregar, habrá paquetes adicionales de Tomcat Servlet
4. Finalmente, agregue los frascos requeridos para Spring y SpringMVC, y agrego los siguientes frascos al proyecto
2. Archivo de configuración:
1. Primero configure un despachador de servicio en Web.xml y especifique la URL que debe interceptarse a través de <Servlet-Mapping>. El siguiente XML configura una URL interceptadora con sufijo.html.
< <Amam-name> contextConfigLocation </param-name> <param-value> /web-inf/classes/mvc*.* </param-value> </ init-param> <load-on-startup> 1 </load on-startup> </servlet> <! <Servlet-name> mvc </servlet-name> <url-pattern>*. html </sl-pattern> </servlet-mapping>
Primero configure un servlet y luego cargue el archivo SpringMVC XML en el contexto de resorte. Luego, configure el mapeo de servlet, el nombre de servlet es el nombre configurado en el servlet justo ahora, y luego especifique que la URL se interceptará es *.html
2. Configure el oyente de contexto de Spring y especifique la ruta al archivo de configuración XML de Spring.
< <Amam-Value> classpath: root-Context.xml </param-value> </context-param>
La ruta classpath especificada aquí está en el archivo classpath después de compilar el proyecto.
Contenido final del archivo web.xml:
<? xml versión = "1.0" encoding = "utf-8"?> <web-app versión = "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/xml/ns/javaee/web-app_3_0.xsd"> <wlectSD " Listener> <listener-class> org.springframework.web.context.ContextLoaderListener </listener-class> </listener> <!-- Loading the spring xml configuration file into the spring context container --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:root-context.xml</param-value> </context-param> <!-Configurar Spring MVC DispatcherServlet-> <servlet> <servlet-name> mvc </servlet-name> <ervlet-class> org.springframework.web.servlet.dispatcherservlet </servlet-class> <!-Parámetros de inicialización-> <init-param> <! <Amam-name> contextConfigLocation </param-name> <param-value> /web-inf/classes/mvc*.* </param-value> </ init-param> <load-on-startup> 1 </load on-startup> </servlet> <! <Servlet-name> mvc </servlet-name> <url-pattern>*. html </sl-pattern> </servlet-mapping> <beating-file-list> <levle-file> index.html </selcome-file> </bienvenido-file-list> </web-app>
3. Cree el archivo XML requerido para SpringMVC y el archivo XML de ApplicationContext. Aquí, dado que el formato requerido para Init-Param en el servlet configurado en el primer paso es: MVC*.*. Es encontrar un archivo que comience con MVC, por lo que al crear el archivo XML de SpringMVC, debo comenzar con MVC. Lo llamé: mvc-context.xml, y de acuerdo con la configuración en context-param, nombra el archivo applicationContext: rootcontext.xml;
4. Configurar MVC-Context.xml:
Primero importe root-Context.xml a través de la etiqueta de importación y luego escanee el nombre del paquete especificado a través de la etiqueta de escaneo de componentes para hacer que la anotación de primavera de todas las clases de Java en el paquete surtiera.
Luego, configure la vista de la vista de SpringMVC, para que su prefijo sea/página/y su sufijo sea .jsp, de modo que las rutas que SpringMVC debe renderizar se puede encontrar en/página/return value.jsp.
< Base-Package = "org.swinglife.controller"> </context: component-scan> <!-Configurar el renderizador de vista de SpringMVC, con su prefijo como:/page/y su sufijo como .jsp render la vista a/page/<method return value> .jsp-> <frijoles: bean p: prefix = "/" p: sufix = ". jsp">.
Finalmente, MVC-Context.xml y Root-Context.xml son:
mav-Context.xml:
<? xml versión = "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.springfring.org/schema/schema" xmlns: contexty = "http://www.springframework.org/schema/context" xsi: schemalocation = "http://www.springframework.org/schema/mvc http://www.springframwork.org/schema/schema/Schema http://www.springframework.org/schema/aop http://www.springframework.org/schema/beans http://www.springframework.org/schema/Beans/spring-beanss.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Cargar el archivo de configuración global de Spring-> <behans: importar recursos =" root-context.xml "/> <! Todas las clases en org.swinglife.controller a través de Component-scan para hacer que las anotaciones de código de Spring entren en vigencia-> <context: Component-Scan base-Package = "org.swinglife.controller"> </ context: componente-scan> <!-Configure el renderador de visión de SpringMVC, con su prefijo:/ con un sufre. Renderizar la vista en/página/<Valor de retorno del método> .jsp-> <frijoles: bean p: prefix = "/page/" p: suffix = ". Jsp"> </frijoles: frijoles>
root-Context.xml:
<? 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: context = "http://www.springframework.org/schema/context" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/sbeans/spring-beat-3. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd "> <!-contexto raíz: define los recursos compartidos visibles para todos los demás componentes web-> </beans>
3. Controlador de escritura
1. Cree el paquete org.swinglife.controller para almacenar la clase de controlador, y luego cree un nuevo homecontroller.java para escribir el controlador en la página de inicio
2. Use la anotación @Controller para definir la clase HomeController como un controlador y use @RequestMapping ("valor") para especificar la ruta o el nombre del método para acceder en el método. SpringMVC puede convertir un POJO en un controlador que maneja la solicitud a través de una anotación @Controller y especificar qué solicitudes se requieren para el controlador a través de @RequestMapping.
@Controller public class Homecontroller { /**** Página de inicio Regreso a /page/home.jsp página* @return* /@requestmapping ("index") public modelandView index () {// Crear modelo y ver para representar la página. Y especifique que la página a devolver es la página de inicio ModelAndView mav = new ModelAndView ("Inicio"); regresar mav; }}El objeto ModelAndView se define en el método. A través de este objeto, la vista a representar se especifica como Inicio y finalmente devuelve ModelAndView. Renderiza la página en Home.jsp.
3. Finalmente, cree /page/home.jsp en el directorio webcontent para que SpringMVC pueda encontrar y renderizar la vista de página.
<%@ page lenguaje = "java" contentType = "text/html; charset = gb18030" pageEncoding = "gb18030"%> <! DocType html público "-// w3c // dtd html 4.01 transición // es" " "http://www.w3.org/tr/html4/loose.dtd"> <html> <fead> <meta http-equiv = "content-type" content = "text/html; charset = gb18030"> <title> home </title> </fead> <body> <hbod> <h2> spring mvc instance </h2e </html>
Ahora se ha construido un modo SpringMVC completo, puede ejecutar el proyecto para las pruebas.
4. Escriba la presentación y entrega de parámetros:
1. Escriba una nueva clase de UserController para asumir que el usuario ha iniciado sesión, envíe el nombre de usuario y la contraseña al controlador para su procesamiento, y después de iniciar sesión, el nombre de usuario y la contraseña se pasan a la página exitosa.
Crear userController.java
Create /page/succ.jsp página como página de inicio de sesión exitosa del usuario
Código en UserController:
@Controller public class UserController { /**** Iniciar sesión de usuario* <p> Configuración de la anotación, solo la publicación puede enviar a este método* @param username* @param contraseña* @return* /@requestmapping (valor = "login", método = requestmethod.post) public modelandView login (string username, string contraseña) {// VERLET a los que se corrige. la página de inicio de sesión. if (this.checkParams (new String [] {UserName, Password})) {// Especifique la página que se devuelve como succ.jsp modelandView mav = new ModelAndView ("succ"); // devuelve el parámetro a la página mav.addoBject ("nombre de usuario", nombre de usuario); mav.addoBject ("contraseña", contraseña); regresar mav; } return New ModelAndView ("Inicio"); } / **** Verifique si el parámetro está vacío* @param params* @return* / private boolean checkparams (string [] params) {for (string param: params) {if (param == "" || param == null || param.isEmpty () {return false; }} return verdadero; } Primero especifique @Controller y luego especifique @RequestMapping como método de inicio de sesión;
Cabe señalar que esta vez, el modo del método de página se especifica en @RequestMapping que el modo del método de página debe ser el modo Post, de lo contrario no será accesible. En segundo lugar, el parámetro de valor especifica la ruta de acceso.
Y establezca el parámetro en el método de inicio de sesión, y el parámetro es el atributo de nombre en el formulario.
Luego agregue parámetros a la solicitud a través del método AddObject de ModelAndView, para que estos parámetros se puedan mostrar en la página devuelta.
Hay otras formas de pasar parámetros a la página además de esto:
/**** Otra forma de parámetro Paso* Proceso los parámetros solicitados. * @param username * @param contraseña * @param request * @return */ @requestmapping (valor = "login", método = requestmethod.post) public modelandView login (String UserName, String Password, HttpservletRequest Request) {request.setAttribute ("UserName", UserName); request.setAttribute ("contraseña", contraseña); devolver nuevo ModelAndView ("Succ"); }El método anterior se usa directamente agregando parámetros a la solicitud.
2. Escriba la página y la página del formulario Succ.jsp:
suc.jsp:
<Body> <H2> Login </h2> UserName: $ {username} <p> contraseña: $ {contraseña} </body> form: <form de acción = "login.html" método = "post"> username: <input type = "text" name = "usernerN /> </form> 3. Finalmente, ejecute el proyecto para probar:
Ok está todo hecho. Lo anterior es un ejemplo relativamente simple de SpringMVC.
En el código fuente dado, hay otro método para usar directamente la cadena como el valor de retorno para especificar la página de visualización.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.