`
实学实战
  • 浏览: 15612 次
  • 性别: Icon_minigender_1
  • 来自: 青岛
文章分类
社区版块
存档分类
最新评论

SpringMVC入门到理解之开门篇

 
阅读更多

我看很多大神级别的博客、都是大神级别的！发现很多写很多！也没有什么注释什么的！新手很难理解！新手一看什么都不懂（懵逼了）。

作为刚入门的程序员、小白是这样去学习编程：

——Do it first! ——先去做！
——How to do it! ——怎么做！
——Look at the source code! ——看源代码！（废话不多说、来吧！先看看springmvc简介！）


一、SpringMVC简介

Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面，Spring 框架提供了构建Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的SpringMVC框架或集成其他MVC开发框架，如Struts1，Struts2等。

Spring web mvc和Struts2都属于表现层的框架,它是Spring框架的一部分,我们可以从Spring的整体结构中看得出来：


二、先来个入门的 hello word 来体验一下！maven项目！

——前提是安装maven！不安装的话自己导包就可以了！

——不会maven的看看这篇文章：maven教程

1、看看我们第一个controller(后面再讲controller、后续在详谈。我看过大神级别的说过、我们编程都是先做！在研究怎么做！)
package cn.czy.com.spring.web.mvc.hello;


import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;

//控制器
@Controller
public class HelloController{
	
	//用注解的方式写第一个springmvc hello world例子
	@RequestMapping(value="/hello")
	public String hello(HttpServletRequest request){
		request.setAttribute("message1", "Hello Spring MVC Framework!");
		request.setAttribute("message2", "chen zheng you !");
		System.out.println(" hello , ChenZhengYou !");
		return "hello/hello";
	}

}
2、看看我们的hello.jsp页面
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
		
		<h1>第一个参数：${message1 }</h1>
		<h1>第二个参数：${message2}</h1>
</body>
</html>
3、看看我们的web.xml文件
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_0.xsd"
         version="3.1">


<welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>default.html</welcome-file>
        <welcome-file>default.htm</welcome-file>
        <welcome-file>default.jsp</welcome-file>
    </welcome-file-list>

    <!-- 前端控制器 -->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath*:spring/spring-*.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--第一种：*.action，访问以.action结尾 由DispatcherServlet进行解析 -->
    <!--第二种：/，所以访问的地址都由DispatcherServlet进行解析，对于静态文件的解析需要配置不让DispatcherServlet进行解析 -->
    <!-- 使用此种方式可以实现 RESTful风格的url -->
    <!--第三种：/*，这样配置不对，使用这种配置，最终要转发到一个jsp页面时， 仍然会由DispatcherServlet解析jsp地址， -->
    <!-- 不能根据jsp页面找到handler，会报错。 -->
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>




    <!-- 解决post请求乱码问题 -->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>
4、看看我们的spring-mvc配置文件
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
		http://www.springframework.org/schema/mvc 
		http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd 
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-3.2.xsd 
		http://www.springframework.org/schema/aop 
		http://www.springframework.org/schema/aop/spring-aop-3.2.xsd 
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">


    <!-- 第一个hello word ！注解的方式实现！ -->
    <context:component-scan base-package="cn.czy.com.spring.web.mvc" />

    <!--核心学点1 -->
    <!--注解映射器 -->
    <!-- <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/> -->
    <!--注解适配器 -->
    <!-- <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/> -->

    <!-- 使用 mvc:annotation-driven代替上边注解映射器和注解适配器配置 -->
    <!-- mvc:annotation-driven默认加载很多的参数绑定方法， -->
    <!-- 比如json转换解析器就默认加载了，如果使用mvc:annotation-driven， -->
    <!-- 不用配置上边的RequestMappingHandlerMapping和RequestMappingHandlerAdapter， -->
    <!-- 实际开发时使用mvc:annotation-driven   -->
    <mvc:annotation-driven></mvc:annotation-driven>

    <!-- 核心学点2 -->
    <!-- 视图解析器 -->
    <!-- 解析jsp解析，默认使用jstl标签，classpath下的得有jstl的包-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 配置jsp路径的前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!-- 配置jsp路径的后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>
5、看看我们的目录结构吧！

6、我们的pom.xml文件（可能我的依赖很多、那是因为我整合了mybatis、日志什么的！其实springmvc只需要一个包就好《前提是maven！spring-mvc依赖包、那就自动下载很多了、比如spring-context等等！）
还有这个<!-- maven 编译部署src/main/java下的资源文件 -->是我用idea开发的、默认不加载！
<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>
    <groupId>org.com</groupId>
    <artifactId>ssm.com</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>ssm.com Maven Webapp</name>
    <url>http://maven.apache.org</url>


    <properties>
        <!-- maven依赖-->
        <junit.version>3.8.1</junit.version>
        <jstl.version>1.2</jstl.version>
        <cglib.version>2.2.2</cglib.version>
        <standard.version>1.1.2</standard.version>
        <servlet.version>3.1.0</servlet.version>
        
        <spring-webmvc.version>4.2.2.RELEASE</spring-webmvc.version>
        <spring-orm.version>4.3.3.RELEASE</spring-orm.version>
        <spring-test.version>4.3.3.RELEASE</spring-test.version>
      
        <log4j.version>1.2.17</log4j.version>
        <slf4j-api.version>1.7.20</slf4j-api.version>
        <org.slf4j.version>1.7.7</org.slf4j.version>
        <commons-dbutils.version>1.6</commons-dbutils.version>
    </properties>
    <dependencies>

        <!-- 1)junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>

        <!-- 2)jstl -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>${jstl.version}</version>
        </dependency>
        <!-- standard -->
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>${standard.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- 3)servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlet.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring-webmvc.version}</version>
        </dependency>

        <!-- spring-test-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring-test.version}</version>
            <type>jar</type>
            <scope>test</scope>
        </dependency>
       
        <!-- spring-orm -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring-orm.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j-api.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${org.slf4j.version}</version>
        </dependency>

    </dependencies>


    <build>

        <!-- 项目id -->
        <finalName>${project.artifactId}</finalName>

        <plugins>
            <!-- java编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>${maven-java-compiler-plugin}</source>
                    <target>${maven-java-compiler-plugin}</target>
                    <encoding>${maven-java-compiler-plugin-encoding}</encoding>
                </configuration>
            </plugin>
        </plugins>

        <!-- maven 编译部署src/main/java下的资源文件 -->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>

    </build>


</project>
7、你就可以成功运行你的第一hello word 了！页面效果图！

三、接下来我们来分析一下传统的mvc和springmvc的架构！（小白勿喷）

1.1 传统的Web MVC架构图（自己用画图画的、小白勿喷！）

mvc设计模式在b/s系统下应用：


1、用户发起request请求至控制器(Controller)

—控制接收用户请求的数据，委托给模型进行处理

2、控制器通过模型(Model)处理数据并得到处理结果

—模型通常是指业务逻辑

3、模型处理结果返回给控制器

4、控制器将模型数据在视图(View)中展示

—web中模型无法将数据直接在视图上显示，需要通过控制器完成。如果在C/S应用中模型是可以将数据在视图中展示的。

5、控制器将视图response响应给用户

—通过视图展示给用户要的数据或处理结果。

1.2 Springmvc 架构图

四、接下来我们来分析一下springmvc的流程！（小白勿喷）

4.1springmvc架构流程

1、用户发送请求至前端控制器DispatcherServlet

2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器

(如果有则生成)一并返回给DispatcherServlet。

4、DispatcherServlet通过HandlerAdapter处理器适配器

5、执行处理器(Controller，也叫后端控制器)。

6、Controller执行完成返回ModelAndView

7、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet

8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器

9、ViewReslover解析后返回具体View

10、DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。

11、DispatcherServlet响应用户

4.2 组件说明

以下组件通常使用框架提供实现：

——》DispatcherServlet：前端控制器

用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。


——》HandlerMapping：处理器映射器

HandlerMapping负责根据用户请求找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。


——》Handler：处理器

Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。

由于Handler涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。

——》HandlAdapter：处理器适配器

通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

——》View Resolver：视图解析器

View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。 springmvc框架提供了很多的View视图类型，包括：jstlView、freemarkerView、pdfView等。

一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。


五、这就是springmvc的入门程序！

总结：通过入门程序理解

springmvc前端控制器（web.xml文件）、

处理器映射器（spring-mvc.xml文件里有注释）、

处理器适配器（spring-mvc.xml文件里有注释）、

视图解析器（spring-mvc.xml文件里有注释）用法。

实际开发我们真正需要掌握的是！

处理器映射器：

非注解处理器映射器（了解）

注解的处理器映射器（掌握）

对标记@Controller类中标识有@RequestMapping的方法进行映射。在@RequestMapping里边定义映射的url。使用注解的映射器不用在xml中配置url和Handler的映射关系。

处理器适配器：

非注解处理器适配器（了解）

注解的处理器适配器（掌握）

注解处理器适配器和注解的处理器映射器是配对使用。理解为不能使用非注解映射器进行映射。


后续会更新文章！（小白勿喷）

第二篇：SpringMVC入门到理解之谈控制器







分享到：
| linux上安装jdk
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    尚硅谷SpringMVC入门到精通

    尚硅谷SpringMVC入门到精通，涵盖数据绑定、异常处理以及与Spring的基本整合

    maven + springmvc 入门实例

    通过这个"maven + springmvc 入门实例"，你可以快速地搭建起一个基于Maven和SpringMVC的Web应用，并理解它们如何协同工作。继续深入学习，你还可以掌握Spring Security、Spring Data JPA等扩展，进一步提升你的Web...

    SpringMVC入门jar包

    在这个"SpringMVC入门jar包"中，包含了一系列必要的库文件，它们是构建基于SpringMVC的应用的基础。 首先，SpringMVC的核心组件包括DispatcherServlet，它是SpringMVC的前端控制器，负责接收HTTP请求，并将其分发到...

    springmvc的入门例子

    这个入门例子是为初学者设计的，旨在帮助他们快速理解和上手Spring MVC。 首先，我们需要理解Spring MVC的基本组件： 1. **DispatcherServlet**：这是Spring MVC的核心组件，作为前端控制器接收所有的HTTP请求，并...

    SpringMVC入门很简单之格式化显示

    SpringMVC入门很简单之格式化显示,具体参考博文：http://www.cnblogs.com/liukemng/tag/SpringMVC/

    springMvc入门级教材

    刚接触springMvc时参考的教材，理论和操作兼顾，写的很好，对于springMvc的初学者帮助很大

    springmvc入门程序(下载后你不会后悔的)

    入门程序的主要目的是帮助开发者理解SpringMVC的核心组件及其工作流程，特别是前端控制器、处理器映射器、处理器适配器和视图解析器。 ##### 2. 实现方式 - **非注解的方式**：通过XML配置文件指定处理方法和URL...

    Maven+SpringMVC的入门级HelloWorld实例

    在IT行业中，Maven和SpringMVC是两个非常重要的组件，它们分别是项目管理和Web应用程序开发的核心...通过这个入门级的HelloWorld实例，我们可以快速理解这两个工具的基本用法，为进一步深入学习和实践打下坚实的基础。

    SpringMVC入门很简单之异常处理

    SpringMVC入门很简单之异常处理，具体参考博文：http://www.cnblogs.com/liukemng/tag/SpringMVC/

    SpringMVC入门demo

    下面将详细介绍SpringMVC的主要组件、工作流程以及如何设置一个入门项目。 **1. SpringMVC组件** - **DispatcherServlet**：它是SpringMVC的核心组件，作为前端控制器接收所有HTTP请求，并负责分发到相应的处理器...

    SpringMVC入门案例源码

    本入门案例源码适用于Eclipse和MyEclipse，提供了完整的项目配置和运行环境，便于初学者快速理解和上手SpringMVC。 在SpringMVC中，核心概念包括DispatcherServlet、Controllers、Models、Views以及各种配置文件。...

    SpringMVC入门很简单之数据验证

    在这个"SpringMVC入门很简单之数据验证"的主题中，我们将深入探讨如何在SpringMVC中实现数据验证。 在Web应用中，数据验证是必不可少的一环，它确保了用户提交的数据符合预设的规则和格式，防止非法或无效的数据...

    SpringMVC入门最简洁工程

    这个"SpringMVC入门最简洁工程"是一个针对初学者精心设计的项目，它包含了必要的配置文件和最少的依赖包，以便快速理解和上手SpringMVC。 **1. MVC架构** 在Web开发中，MVC架构是一种常用的分层设计模式。Model...

    SpringMVC入门很简单之表单标签

    本篇主要介绍SpringMVC中与表单处理相关的知识点，帮助初学者快速入门。 1. **表单标签**：在SpringMVC中，我们通常使用JSP或Thymeleaf等模板引擎来处理前端视图。对于JSP，Spring提供了一组自定义的JSTL标签，如`...

    SpringMVC 入门小程序

    本入门程序旨在帮助初学者理解并掌握SpringMVC的基本概念和工作流程，通过实现用户在前端页面注册信息并显示的功能，来深入剖析其核心机制。 ### 1. SpringMVC框架概述 SpringMVC是Spring框架的一部分，提供了一个...

    springMVC入门实例

    在这个入门实例中，我们将深入理解SpringMVC的核心概念，以及如何通过`springmvc_demo_02`这个项目来创建一个简单的应用。 1. **SpringMVC架构** SpringMVC由几个关键组件组成：DispatcherServlet、Controller、...

    SpringMvc入门工程源码

    SpringMvc入门工程源码是一个适合初学者了解和学习Spring MVC框架的项目。Spring MVC是Spring框架的一个模块，专门用于构建Web应用程序。它提供了一个模型-视图-控制器（MVC）架构，帮助开发者将业务逻辑、数据处理...

    SpringMVC专栏 002 SpringMVC入门项目搭建

    SpringMVC专栏 002 SpringMVC入门项目搭建

    SpringMVC学习(一)——SpringMVC入门小程序

    在“SpringMVC学习(一)——SpringMVC入门小程序”中，我们首先会接触到SpringMVC的基本概念。这通常包括以下几个核心组件： 1. **DispatcherServlet**：这是SpringMVC的前端控制器，负责接收HTTP请求，并根据配置...

    SpringMVC 快速入门

    在这个快速入门教程中，我们将深入理解 SpringMVC 的核心概念、配置以及如何创建一个简单的应用程序。 1. **MVC 模式** MVC 模式是一种设计模式，将应用程序分为三个主要部分：模型（Model）、视图（View）和控制...

Magicbox
Global site tag (gtag.js) - Google Analytics