逐步理解SpringMVC

时间  2019-11-26
标签 逐步 理解 springmvc 栏目 Spring 繁體版
原文   原文链接

1.MVC(Model-View-Controller)css

用慕课网上的一个图来看看MVChtml

Front Controller（前端控制器）：把客户的请求分发给不一样的控制器去生成业务数据，将生成的业务数据分发给恰当的视图模板生成咱们最终的图形界面前端

Controller（控制层）：实现业务数据的抽取，Controller-->Service-->dao-->ORM-->数据持久化java

Model（模型层）：我认为像是一个中间件，若是须要数据持久化的时候，model将会成为PO（persistant object），和dao层进行数据持久化；若是须要给View层展现的话，model将会成为VO（value object），不必定和数据库中的表对应，将View须要的数据封装传过去；有时候一个VO可能知足不了View层的需求，因此BO（business objec）就出来了；最后就是Pojo了，VO和PO应该都属于它。 java的几种对象(PO,VO,DAO,BO,POJO)解释web

View（视图层）：显示呗spring

2.SpringMVC数据库

a.DispatcherServletexpress

SpringMVC很好的体现了MVC的核心风格：业务数据抽取同业务数据呈现相分离，只不过DispatcherServlet成了咱们（1）中提出的前端控制器。DispatcherServlet拦截了咱们的请求，将请求分发给不一样的Controller，但他是怎么知道不一样的Controller的呢？因此有一个东西出现了apache

b.HandlerAdapterjson

 

HandlerAdapter是一个接口，有5个实现类，咱们在springMVC中大多数用的是@Controller，因此咱们看看它的实现类SimpleControllerHandlerAdapter，在Dispatcher中咱们看一下这个：

/**
     * Initialize the HandlerAdapters used by this class.
     * <p>If no HandlerAdapter beans are defined in the BeanFactory for this namespace,
     * we default to SimpleControllerHandlerAdapter.（若是工厂中没有这个handlerAdapter这个命名空间的话，咱们就默认使用SimpleControllerHandlerAdapter）
     */
    private void initHandlerAdapters(ApplicationContext context) {
        this.handlerAdapters = null;

        if (this.detectAllHandlerAdapters) {
            // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
            Map<String, HandlerAdapter> matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerAdapters = new ArrayList<HandlerAdapter>(matchingBeans.values());
                // We keep HandlerAdapters in sorted order.
                OrderComparator.sort(this.handlerAdapters);
            }
        }
        else {
            try {
                HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
                this.handlerAdapters = Collections.singletonList(ha);
            }
            catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we'll add a default HandlerAdapter later.
            }
        }

        // Ensure we have at least some HandlerAdapters, by registering
        // default HandlerAdapters if no other adapters are found.
        if (this.handlerAdapters == null) {
            this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
            if (logger.isDebugEnabled()) {
                logger.debug("No HandlerAdapters found in servlet '" + getServletName() + "': using default");
            }
        }
    }

就这样知道了咱们写的Controller，本人小白，理解有误，请大神指点！

c.HandlerInterceptor

接口，在调用Controller以前或者以后干点什么，相似AOP的思想。

d.HandlerMapping

既然用HandlerAdapter知道了那个对应的那个Controller，这个HandlerMapping就是分发请求的啦

e.HandlerExecutionChain

 

这个就是controller处理完与HandlerInterceptor生成handler传给DispatcherServlet

f.ModeAndView

Model的具体表现，咱们在controller中使用map或者model，这个东西的做用就是将全部的东西转换成modelandview

g.ViewResolver

视图解析器，决定要用那个对象，如jstl，json

来，咱们上个图理解一下：

 

总结一下：当请求传到DispatcherServlet上的时候，由HandlerMapping分发请求到Controller，Controller处理完相应的操做，如业务逻辑，数据的持久化啊等等，而后和HandlerInterceptor把结果生成ModelandView返还给DispatcherServlet，而后DispatcherServlet决定用那个Resolver来解析数据，如jstl，xml，json啊等等，最后让view层显示就好了。

3.SpringMVC中的过程具体实操

a.先看看demo结构

b.上码

a.web.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 若是为2.4版本的，就会默认支持EL -->
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  <display-name>Archetype Created Web Application</display-name>
  
  <!-- Spring的应用上下文，理解层次化的ApplicationContext -->
  <!-- 定时任务都建议放在全局监听的<context-param>中,而不建议放在<servlet>的<init-param>中. -->
  <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>/WEB-INF/configs/spring/applicationContext*.xml</param-value>
  </context-param>
  
  <listener>
  <listener-class>
  org.springframework.web.context.ContextLoaderListener
  </listener-class>
  </listener>
  
  
  
  <!-- DispatcherServlet,Spring MVC的核心 -->
  <servlet>
  <servlet-name>mvc-dispatcher</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <!-- DispatcherServlet对应的上下文配置，若是不配置下面的<init-param>,默认为/WEB-INF/${servlet-name}-servlet.xml -->
  <init-param>
  <!-- contextConfigLocation为固定的写法 -->
  <param-name>contextConfigLocation</param-name>
  <param-value>/WEB-INF/configs/spring/mvc-dispatcher-servlet.xml</param-value>
  
  </init-param>
   <!-- 1)load-on-startup元素标记容器是否在启动的时候就加载这个servlet(实例化并调用其init()方法)。
        2)它的值必须是一个整数，表示servlet应该被载入的顺序
        2)当值为0或者大于0时，表示容器在应用启动时就加载并初始化这个servlet；
        3)当值小于0或者没有指定时，则表示容器在该servlet被选择时才会去加载。
        4)正数的值越小，该servlet的优先级越高，应用启动时就越先加载。
        5)当值相同时，容器就会本身选择顺序来加载。 -->
  <load-on-startup>1</load-on-startup>
  </servlet>
  
  <servlet-mapping>
  <servlet-name>mvc-dispatcher</servlet-name>
  <!-- 表示拦截全部请求 -->
  <url-pattern>/</url-pattern>
  </servlet-mapping>
  
  
</web-app>

b.mvc-dispatcher-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 本配置文件是工名为mvc-dispatcher的DispatcherServlet使用，提供与其相关的Spring MVC的配置 -->

    <!--标签支持，生命周期的管理 ，激活了咱们spring关于annotation的DI,当自动扫描启动后,该配置能够去掉-->
    <context:annotation-config />

    <!-- 自动扫描，只搜索@Controller标注的类，不搜索其余标注的类 -->
    <context:component-scan base-package="com.huhu.spring">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>



    <!--HandlerMapping，会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter两个bean,
                是spring MVC为@Controllers分发请求所必须的，无需配置，spring MVC能够默认启动
      RequestMappingHandlerMapping   处理@RequestMapping注解的
      RequestMappingHandlerAdapter   处理@Controller注解的控制器类-->
    <!-- 扩充了注解驱动，能够将请求参数绑定到控制器参数 （也就是说，URL查询参数的某一个变量能够直接映射到@Controller的某个方法的输入参数）-->
    <mvc:annotation-driven />
    
   <!-- 静态资源处理，css,js,images -->
   <!-- 
   <mvc:resources mapping="/resources/**" location="/resources/"/>
    -->
    
    <!--配置ViewResolver，可使用多个ViewResolver，使用order排序，可是InternalResourceViewResolver放在最后-->
    <!-- ViewResolver用那个viewresolver来获取bean -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
    <property name="prefix" value="/WEB-INF/jsps/"></property>
    <property name="suffix" value=".jsp"></property>
    </bean>
    
    
    <!-- 文件上传 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="10485760"/> <!-- 10m -->
        <property name="maxInMemorySize" value="4096" />
        <property name="defaultEncoding" value="UTF-8"></property>
    </bean>
    
    <!-- viewResolver -->
    <bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">    
    <property name="mediaTypes">    
      <map>    
        <entry key="html" value="text/html"/>    
        <entry key="xml" value="application/xml"/>  
        <entry key="json" value="application/json"/>    
      </map>    
    </property> 
    <!-- ViewResolver 负责怎么去解析， 而View只表明一种 视图层的技术 --> 
    <!--<property name="viewResolvers"> <list>   </list>  </property>-->
    <property name="defaultViews">  
        <list>  
            <bean class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>  
        </list>  
    </property>  
</bean>  
    
</beans>

c.applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"  
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util" xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
    xmlns:cache="http://www.springframework.org/schema/cache"  
    xsi:schemaLocation="  
    http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context.xsd  
    http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans.xsd  
    http://www.springframework.org/schema/mvc  
    http://www.springframework.org/schema/mvc/spring-mvc.xsd" default-autowire="byName">  
  
    <!--
                    自动扫描web包 ,将带有注解的类 归入spring容器管理 
                    默认执行<context:annotation-config /> 
    -->  
    <context:component-scan base-package="com.huhu" >
    <!-- 不把@Controller归入到spring容器中 -->
    <context:exclude-filter type="annotation" 
    expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
     
    
    

</beans>

具体的xml语句的含义在文件注释中已经标注，我想谈谈xml语句的运行流程：

web.xml的运行流程（context-param >> listener  >> fileter  >> servlet）：

  1. 在启动Web项目时，容器(好比Tomcat)会读web.xml配置文件中的两个节点<listener>和<contex-param>。
  2. 接着容器会建立一个ServletContext(上下文),应用范围内即整个WEB项目都能使用这个上下文。
  3. 接着容器会将读取到<context-param>转化为键值对,并交给ServletContext。
  4. 容器建立<listener></listener>中的类实例,即建立监听（备注：listener定义的类能够是自定义的类但必须须要继承ServletContextListener）。
  5. 在监听的类中会有一个contextInitialized(ServletContextEvent event)初始化方法，在这个方法中能够通event.getServletContext().getInitParameter("contextConfigLocation"来获得context-param 设定的值。在这个类中还必须有一个contextDestroyed(ServletContextEvent event) 销毁方法.用于关闭应用前释放资源，好比说数据库链接的关闭。
  6. 获得这个context-param的值以后,你就能够作一些操做了.注意,这个时候你的WEB项目尚未彻底启动完成.这个动做会比全部的Servlet都要早

web.xml中的bean加载（ContextLoaderListener，ContextLoaderServlet，servlet.DispatcherServlet）：

  1. ContextLoaderListener 和 ContextLoaderServlet : 本质上是等同的，都是调用ContextLoader来加载web程序的上下文，加载完成之后，都是在ServletContext中，只不过listener须要Servlet2.3及以上支持。
  2. ContextLoaderListene与DispatcherServlet : 用DispatcherServlet载入的Bean是隶属于此Servlet的（因此spring能够配置多个分别拥有各自环境的DispatcherServlet），所以其余servlet没法获取到该Context。

d.TestController.java

@Controller
@RequestMapping("/test")
public class TestController {
    
    private static Logger logger =LoggerFactory.getLogger(TestController.class);
    @Autowired
    private TestService testService;
    
   @RequestMapping("/{s}")
   @ResponseBody
   public String test(@PathVariable("s") String s) {
       logger.info(s);
       String str1 = testService.test(s);
       return str1;
   }
   
   //用于文件上传，须要在pom.xml中添加依赖commons-fileupload
   
   @RequestMapping("/upload")
   public String upLoad(@RequestParam("file") MultipartFile file) throws IOException {
       if(!file.isEmpty()) {
           FileUtils.copyInputStreamToFile(file.getInputStream(), new File("D:\\demo\\image",System.currentTimeMillis()+".jpg"));   
       }
       return "success";
       
   }
   
   //json测试，须要在pom.xml中添加依赖jackson-databind
   @RequestMapping(value="/json/{id}",method=RequestMethod.GET)
   @ResponseBody
   public Map<String,String> json(@PathVariable("id") String id ) {
       
    Map<String, String> map=testService.jsonTest();

        return map;

   }
    
}

e.TestService.java

public interface TestService {
    public String test(String s);
    Map<String, String>  jsonTest();
}

f.TestServiceImpl.java

@Service("testService")
public class TestServiceImpl implements TestService{

    public String test(String s) {
        
        return "hello"+s;
    }
    
    public Map<String, String>  jsonTest(){
        Map<String, String> map=new HashMap();
        map.put("id", "1");
        map.put("name", "huhu");
        map.put("age", "23");
        return map;
    }
    
    
}

g.pom.xml

<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>huhu</groupId>
    <artifactId>test</artifactId>
  <version>1.0-SNAPSHOT</version>
  <name>test Maven Webapp</name>
  <url>http://maven.apache.org</url>
  
  <!-- 变量，来替代一些工程版本 -->
  <properties>
  <commons-lang.version>2.6</commons-lang.version>
  <slf4j.version>1.7.6</slf4j.version>
  <spring.version>4.1.3.RELEASE</spring.version>
  </properties>
  
  <!-- 统一管理jar包的版本 -->
  <dependencyManagement>
  <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-framework-bom</artifactId>
            <version>${spring.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
     </dependencies>
  </dependencyManagement>

  <dependencies>
  <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
   <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>${slf4j.version}</version>
   </dependency>
  
  <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    </dependency>
  
    <dependency>
      <groupId>commons-lang</groupId>
      <artifactId>commons-lang</artifactId>
      <version>${commons-lang.version}</version>
    </dependency>
    
    <dependency>    
   <groupId>javax.servlet</groupId>    
   <artifactId>jstl</artifactId>    
   <version>1.2</version>    
   <scope>runtime</scope>    
    </dependency> 
    
    <!-- 文件上传须要依赖的包-->
    <dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
    </dependency>
    
    <!-- viewResolver中所须要的json -->
    <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.8.5</version>
    </dependency>

  </dependencies>
  
  <!-- 运行项目的插件  如mvn jetty:run -->
  <build>
  <!-- https://mvnrepository.com/artifact/org.eclipse.jetty/jetty-maven-plugin -->
    <plugins>
      <plugin>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-maven-plugin</artifactId>
    <version>9.2.2.v20140723</version>
      </plugin>
     </plugins>
  </build>

</project>

文件都上传了，练练手吧！

4.SpringMVC中的数据绑定

a.什么是数据绑定？
将界面用户所填的属性和程序内部设定的类型绑定
b.基本类型和包装类型
1.基本类型
key是必须传的，只能是int类型
2.包装类型
能够不传key，能够经过注解@RequestParam()能够指定默认值
@RequestParam()：
value() 对传入参数指定名称例如ecif
required() @RequestParam配置的传入参数是否必定要传
required=false表示能够不传，默认给参数赋值为null注意（参数为基本的数据类型int时不能使用 由于null不能赋值给int ）
required=true 就是必需要有传入参数，不传会报400参数错误
value与required配合使用如没有配置任何信息为默认值 必须输入对应参数名
3.数组
页面能够传相同属性的多个值，如name=qw&name=er
c.简单对象，多层级对象，同属性对象
简单对象绑定：地址栏传对象的属性就行了
多层级对象（对象中含有一个属性是另一种对象）绑定：只须要地址栏中输入对象的属性.属性就能够了
同属性对象（拥有相同属性的对象，地址栏该怎么输入呢）：使用@InitBinder("")
函数体为：
@InitBinder("user")
public void initUser(WebDataBinder binder){
binder.setFieldDefaultPrefix("user.");
}
ps:若是没有使用@InitBinder("")，那么同属性对象该怎么赋值呢

d.list，set，map的数据绑定
1.list
能够经过索引下标进行绑定，地址栏直接写对象的属性，如users[0].name=qw&users[1].name=er
若是前台请求，users[0].name=qw&users[20].name=er的时候，中间会出现一些空的对象，浪费资源空间，因此当咱们请求的时候注意索引下标
2.set
ps:set须要在运行的时候进行初始化，主要做用是在实际运用中进行对象的重复判断，以及排除重复
直接请求会出现500错误，说set of size 0，建立对象的时候给他申请空间
set须要重写equals()和hashcode()方法，无序，不重复，hashcode是惟一的，可是不符合实际，因此重写object的hashcode()方法，重写的话会出现相同属性的对象产生相同的hashcode()，因此还要经过equals()方法来判断是不是同一个对象。
3.map
经过键值对来存储值
场景：一个班级，不须要重名的
URL请求：map.do?users['X'].name=qw&users['X'].age=23

 

------------------------------------------------------------------------------------------------补充-----------------------------------------------------------------------------

1.是谁关联了****Mapper.xml和****.java的？

固然是经过xml关联的，下面放一个mybatis.xml的配置文件。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 读入properties配置文件 -->
    <properties resource="init.properties">

    </properties>
    <!-- 对象别名 -->
    <typeAliases>
        <typeAlias type="com.huhu.pojo.Person" alias="Person"/>
    </typeAliases>
    <!-- 数据源配置 -->
    <environments default="development">
        <environment id="development">
            <!-- 事务类型 -->
            <transactionManager type="JDBC"/>
            <!-- 数据源 -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 注册xml文件 -->
    <mappers>
        <!-- 注册PersonMapper.xml文件，PersonMapper.xml位于com.huhu.dao.mapper这个包下，
            因此resource写成com/huhu/dao/mapper/PersonMapper.xml-->
        <mapper resource="com/huhu/dao/mapper/PersonMapper.xml"/>
        <!-- 将map下的*.java和*.xml都注册到SqlSession实例中 -->
        <package name="com.huhu.dao.PersonMapper"/>
    </mappers>
</configuration>

2.那是谁注入了mybatis.xml呢？

web.xml中注入的

<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>
    classpath:spring/applicationContext.xml,
    classpath:mybatis/mybatis.xml
  </param-value>
</context-param>

真正的加载顺序为：context-param -> listener -> filter -> servlet

 

参考资料：

慕课网-Spring MVC起步

pring3.0中返回Json

spring web.xml 难点配置总结【转】

解析mediaTypes+viewResolvers+viewResolvers

谢谢你们的阅读，博客不易，请转载注明地址：http://www.cnblogs.com/huhu1203/p/7633060.html

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程