Spring MVC学习笔记-01 初步使用

最新推荐文章于 2021-08-06 21:11:29 发布

WALL-SQ

最新推荐文章于 2021-08-06 21:11:29 发布

阅读量129

点赞数

分类专栏： Java开发-Spring MVC

本文链接：https://blog.csdn.net/qq_39304630/article/details/112604515

版权

Java开发-Spring MVC 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1. 三层架构模式(MVC)

A. 传统开发模式Model1

在早期的Java Web开发中，由JSP负责请求和响应、并调用JavaBean中的与数据库有关的方法，这被称为Model1模式。这种方式的架构足够简单，但是JSP的功能职责不单一，难以实现代码的复用。同时JSP和JavaBean之间还存在严重的耦合，这并不利于维护。

B. 传统开发模式Model2

为了解决上述问题，Servlet技术应运而生。用户的所有请求都会先被Servlet拦截，然后根据请求选择调用相应的Java Bean，并将结果交给JSP展示。

开发架构一般都是基于B/S(浏览器/服务器)、C/S(客户端/服务器)两种架构。在JavaEE开发中，几乎都是基于B/S架构的开发，标准的三层架构包括：表现层、业务层、持久层。

表现层：就是我们常说的web层，负责接收客户端请求包括请求参数，向客户端响应结果。通常客户端使用http协议请求web层，web层需要接收http请求，通过http响应向客户端做出应答。

表现层还可细划分为控制层、展示层：控制层负责接收请求及其参数，展示层负责结果的展示。

业务层：就是我们常说的service层，负责业务逻辑处理。业务层在进行业务处理时，可能会依赖持久层，如果要对数据持久化操作，则需要保证事物的一致性（事务应该放到业务层来控制）。

持久层：就是我们常说的dao层，负责进行数据持久化的操作。

MVC开发模式：

M：Model模型，在开发中实际就是我们用于存储数据的JavaBean对象。

V：View视图，用于展示结果的地方，如JSP、HTML。

C：Controller控制器，负责与用户交互、接收请求，如Servlet。

C. Spring MVC

Spring MVC是一款基于Java实现的MVC模式的请求驱动类型的轻量级Web框架，可以通过一套注解，让一个简单的Java类成为处理请求的控制器，而无须实现任何接口，同时还支持RESTful风格的请求。又因为它是Spring框架的后续产品，因此使用Spring整合非常容易。简单理解Spring MVC就是一个基于spring的框架，实对servlet的升级扩展。(web开发的底层都是servlet)

Spring MVC可以创建控制器对象，用于接收用户的请求并返回处理结果，放入到Spring MVC容器中。我们使用@Controller注解创建的控制器对象只是一个普通类的对象而不是servlet(servlet必须继承HttpServlet)，但是Spring MVC赋予了控制器对象接收参数、返回结果这些功能。

Spring MVC的入口是DispatcherServlet，所有的请求经由DispatcherServlet被转发给相应负责处理的Controller对象。

使用体验：

0. 新建一个web maven工程

如果使用maven自动构建，可以修改一下maven配置文件(settings.xml)，使用阿里云镜像：

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
                          https://maven.apache.org/xsd/settings-1.0.0.xsd">

      <mirrors>
        <mirror>  
            <id>alimaven</id>  
            <name>aliyun maven</name>  
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>  
            <mirrorOf>central</mirrorOf>          
        </mirror>  
      </mirrors>
</settings>

自动构建完成后，我们还需要手动加入main/java，main/resource，项目结构如下：

1. 导入依赖

由于自动构建的项目，往往与我们的使用环境存在差异，我们需要手动调整pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>SpringMVC-01</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!--JDK版本-->
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--servlet依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>
    <!--springmvc依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
  </dependencies>
</project>

2. 在web.xml中注册DispatcherServlet

maven自动构建的web项目，使用的web-app版本过低，我们更换为4.0。

DispatcherServlet前端控制器(也叫中央调度器)，是一个servlet，继承自HttpServlet；用于接收用户的请求，并调用负责处理该请求的控制器对象，返回处理结果；在DispatcherServlet的init()方法内部，创建了SpringMVC的容器对象，并放入ServletContext。

<?xml version="1.0" encoding="UTF-8"?>
<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_4_0.xsd"
         version="4.0">
    <!--注册DispatcherServlet,配置Tomcat启动后就创建-->
    <servlet>
        <!--SpringMVC容器创建时,读取的配置文件默认为<servlet-name>-servlet.xml-->
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <init-param>
            <!--自定义SpringMVC读取的配置文件的位置-->
            <param-name>contextConfigLocation</param-name>
            <!--类路径下的springmvc.xml文件(resources目录就是类路径)-->
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>

        <!--Tomcat启动后,创建对象的顺序-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <!--配置DispatcherServlet拦截哪些请求-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--
            使用框架时,url-pattern可以使用两种
            1. 扩展名  *代表通配符,匹配任意长度的路径  只看扩展名  *.do *.action 等
            2. 使用 "/"
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

3. 创建一个用于发起请求的页面 index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <p>第一个项目</p>
    <a href="some.do">发起请求</a>
</body>
</html>

4. 创建类控制器

1)使用@Controller声明这是一个控制器对象，注入Spring MVC容器中。

2)使用@RequestingMapping声明请求路径。使用@RequestingMapping修饰的方法称作处理器方法或控制器方法，用于处理请求，类似于servlet中的doGet，doPost，service方法。

3) Model ：存储请求处理完成后，要返回给用户的数据

View：存储用于展示数据的视图，如jsp

package com.zzt.Controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class MyController {

    @RequestMapping("/some.do")
    public ModelAndView doSome(){
        ModelAndView modelAndView = new ModelAndView();

        // 存放数据 框架会自动将数据放到request作用域
        modelAndView.addObject("msg","hello-word");

        // 指定视图的路径 框架会自动通过forward进行请求转发 request.getRequestDispatcher("/show.jsp").forward(..)
        modelAndView.setViewName("/show.jsp");

        return modelAndView;
    }

}

5. 创建一个用于展示结果的页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <p>请求的参数为:${requestScope.get("msg")}</p>
</body>
</html>

6. 创建SpringMVC的配置文件

由于我们使用@Controller注解标注控制器类，所以需要配置扫描器进行扫包，将实体类自动注入容器

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

    <!--声明组件扫描器-->
    <context:component-scan base-package="com.zzt.Controller"/>

</beans>

WALL-SQ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Spring MVC学习笔记-01 初步使用

1. 三层架构模式(MVC)A. 传统开发模式Model1 在早期的Java Web开发中，由JSP负责请求和响应、并调用JavaBean中的与数据库有关的方法，这被成为Model1模式。这种方式的架构足够简单，但是JSP的功能职责不单一，难以实现代码的复用。同时JSP和JavaBean之间还存在严重的耦合，这并不利于维护。B.传统开发模式Model2 为了解决上述问题，Servlet技术应运而生。用户的所有请求都会先被Servlet拦截，然后根据请求选择调用相应...
复制链接

扫一扫