精华内容
下载资源
问答
我要提问
  • springmvc项目实例
    2021-04-27 22:13:05

    SpringMVC

    springmvc：是spring中的一个web模块框架。遵循了mvc设计模式的。

MVC的概念：指的是软件的web层设计模式。
	M：Model 模型。 指的是通过Javabean封装数据
	V： View 视图。将Model中的数据进行展示，一般是使用jsp 、html。
	C： Controller 控制器。调用Model的数据给到View展示，或者将View中的数据给到model封装。

    springmvc开发流程：

    ​ 1.导入相关的jar包。除了导入springmvc的jar包之外，还需要导入spring的核心包。
    ​ 2.创建springmvc的配置文件 dispatcher-servlet.xml.

    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"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!--扫描包:在springmvc的配置文件中扫描的一般是controller包下带@Controller注解的类
    -->
    <context:component-scan base-package="com.myspringmvc.controller"/>
    <!--配置一个jsp的视图解析器-->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--/success.jsp-->
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

    @RequestMapping、springmvc封装的参数、请求的响应数据

    /*
* @RequestMapping注解
*   作用: 1. 映射前端的请求，顺据前端的url进行映射，映射之后会把对应的方法执行。
*   使用: 1. 可以用在类上，也可以在方法上
*           1.1在类上使用请求的地址第一一层级先映射到类上， 再根据第一层地址 寻找第二层地址
*           1.2 path属性私value属性写映射的地址
*           1.3 method属性规定映射到这个地址的请求方式必须是怎么样的。GET/POST PUT DELETE
*           1.44. params: params="username"如果是这个格式，要求请求中必须携带这个参数时params !="username"
* springmvc封装的参数
*   1.在对应的方法参数中，传入-个和前端发送的参数名一 样的参数即可拿到。
*   2.把请求参数封装在实体对象中，要求请求的参数必须和该对象的属性名保持一致。
*   3. @RequestParam注解映射参数。
*       3.1 name 属性和vaLue属性都是作用相同的，指定一个前端传递的参数名， 把这个参数赋值
*       3.2 required属性 如果赋值true,要求这个参数在请求的时候必须要携带。
*       3.3 defaultValue 当前端没有给这个参数传值时给一个默认 值。
*   4.传入原生的API获取参数:HttpServletRequest HttpServletResponse
* springmvc请求的响应数据：
*      1.给方法传入map，将响应的数据存入map中springmvc会将这个map存入request域对象中
*      2.给方法传入Model,调用model对象的ddAttribute存入数据，
*      3.给方法传入ModeLMap,调用modeLMap对象的addAttribute存入数据(key-value)
*springmvc中映射请求的处理方法返回值问题:
*   1.返回的是String类型，如果什么注解都不加的情况之下，这个返回值就是响应的地址。
*   2.返回的是void
*        2.1什么值都不响应
*        2.3需要响应一些数据，传入HttpServletResponse通过这个对象,调用输出流，响应到页面
*
 *
 **/

    UserController类

    package com.myspringmvc.controller;

import com.myspringmvc.pojo.Address;
import com.myspringmvc.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PipedWriter;
import java.io.PrintWriter;
import java.util.Map;


@Controller
@RequestMapping(path = "user"/*,method = RequestMethod.GET,params ="username"*/)
public class UserController {
    //创建一一个方法， 来处理请求
    @RequestMapping(path = "/mvctest")
    public String login(Address address,User user, @RequestParam(name = "sex",required = true,defaultValue = "1")String xingbie){
        System.out.println(user);
        System.out.println(address);
        System.out.println(xingbie);
        //接受参数调用业务层 返回结果
        return "success";//这个返回的结果并非是给到页面的数据，而是响应的页面地址
    }
    //map方式传值
    @RequestMapping(path = "/user1")
    public String test(Map<String,Object> data){
        data.put("name","qiyu");
        data.put("age","19");
        return "success";
    }
    //Model方式传值
    @RequestMapping(path = "/user2")
    public String test1(Map<String,Object> data, Model model){
        data.put("name","qiqi");
        data.put("age","19");
        model.addAttribute("phone","15273835396");
        model.addAttribute(data);
        return "success";
    }
    //ModeLMap方式传值
    @RequestMapping(path = "/user3")
    public String test2(Map<String,Object> data, Model model, ModelMap modelMap){
        data.put("name","qiqi");
        data.put("age","19");
       // model.addAttribute("phone","15273835396");
        model.addAttribute(data);
        modelMap.addAttribute("phone","15273835396");
        System.out.println(data.getClass());
        System.out.println(model.getClass());
        System.out.println(modelMap.getClass());
        return "success";
    }
    @RequestMapping(path = "/user4")
    @ResponseBody//在方法加上这个注解后，方法中响应的数据会直接放在Response对象中响应给浏览器
    // @ResponseBody注解一般搭配异步请求来使用
    public ModelAndView test3(ModelAndView modelAndView){
        //ModeLAndView类的对象封装响应的数据， 并且可以封装响应的视图地址
        modelAndView.setViewName("success");//添加响应地址
        modelAndView.addObject("phone","15273835396");
        return modelAndView;
    }
    @RequestMapping(path = "/user5")
    public void test4(HttpServletResponse response) throws IOException {
        // 如果这个方法在接受到请求之后。只需要处理，处理完之后不需要响应任何的数据或者页面。只需处理请求
        PrintWriter printWriter = response.getWriter();
        //数据存入响应体response对象中，浏览器会直接解析这些数据，放入新创建的页面当中
        printWriter.print("<h1>qiqi</h1>");
        printWriter.print("qiqi");
        System.out.println("调用业务层，不需要返回任何数据");
    }

}

    Address 类

    package com.myspringmvc.pojo;

public class Address {
    private String provinces;

    public String getProvinces() {
        return provinces;
    }

    public void setProvinces(String provinces) {
        this.provinces = provinces;
    }

    @Override
    public String toString() {
        return "Address{" +
                "provinces='" + provinces + '\'' +
                '}';
    }
}

    User类

    package com.myspringmvc.pojo;

public class User {
    private  String username;
    private  String phone;
    private String password;
    private  Address address;
    public User() {
    }

    public User(String username, String phone, String password) {
        this.username = username;
        this.phone = phone;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", phone='" + phone + '\'' +
                ", password='" + password + '\'' +
                ", address=" + address +
                '}';
    }
}

    inde.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  <a href="mvctest">SpringMVC</a><br>
  <a href="user/mvctest?username=zs&phone=15273835396&password=123456&xingbie=男&provinces=湖南">SpringMVC2</a><br>
  <a href="user/user1">SpringMVCUser1</a><br>
  <a href="user/user2">SpringMVCUser2</a><br>
  <a href="user/user3">SpringMVCUser3</a><br>
  <a href="user/user4">SpringMVCUser4</a><br>
  <a href="user/user5">SpringMVCUser5</a><br>
  </body>
</html>

    success.jsp
    ​

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <a>响应成功</a>
    <%
       /* out.print(pageContext.getAttribute("name"));
        out.print(request.getAttribute("name"));
        out.print(session.getAttribute("name"));
        out.print(application.getAttribute("name"));*/

        out.print(pageContext.getAttribute("phone"));
        out.print(request.getAttribute("phone"));
        out.print(session.getAttribute("phone"));
        out.print(application.getAttribute("phone"));
    %>
</body>
</html>

    ​

    ​

    mvc
    更多相关内容

  • SpringMvc项目实例

     2017-12-06 13:46:25
    这段时间在学习javaweb的一些知识，然后接触到了springmvc框架。框架的创建和配置一直是新手入门的一个难题，所以我就写一下我的配置过程，以供参考，另外因为spring4的新特性可以用java来配置，网上相关资料较少，...
    收起

  • springMVC项目实例

     2016-06-29 14:19:41
    java springMVC完整项目实例加mybatis，修改连接数据库地址可直接运行
    收起

  • Maven springMVC项目实例

     2016-06-29 14:22:54
    maven开发springMVC完整实例
    收起

  • SpringMVC项目实例.zip

     2020-09-12 18:37:51
    .............................................................
    收起
    spring

  • springmvc完整实例

     2018-12-06 22:00:56
    springmvc完整实例,包含完整jar包，以及配置文件适合初学者
    收起

  • maven springmvc 项目实例

     2013-03-21 11:41:04
    一个简单的Maven SpringMVC配置实例
    收起

  • springmvc实例

     2016-10-27 14:43:28
    spring mvc 参数传递 html访问 2种配置方法
    收起

  • 一个简单的springmvc实例

     2021-11-01 22:00:41
    springmvc简介：也叫spring web mvc ，是spring框架的一部分，专门做web开发的，是servlet的一个升级。 一、实现一个简单的spring web项目 1、新建maven web 项目 2、配置pom.xml文件 <?xml version="1.0" ...

    //本文章参看BliBli学习总结，感谢提供视频的北京动力节点，本文章仅分享供大家参考学习，没有商业用途，谢谢！
    springmvc简介：也叫spring web mvc ，是spring框架的一部分，专门做web开发的，是servlet的一个升级。

    一、实现一个简单的spring web项目

    1、新建maven web 项目

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CtJapyoE-1635775228730)(C:\Users\17216\AppData\Roaming\Typora\typora-user-images\image-20211028212411465.png)]

    2、配置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>com.bjpowernode</groupId>
  <artifactId>springmvc</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springmvc Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <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>
      <scope>provided</scope>
    </dependency>
    <!--springmvc依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <!-- 编码和编译和JDK版本 -->
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

    3、web.xml中注册中央调度器

    <?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">

    <!--声明，注册springmvc的核心对象DispatcherServlet
        需要在tomcat服务器启动后，创建DispatcherServlet对象的实例。
        为什么要创建DispatcherServlet对象的实例呢？
        因为DispatcherServlet在他的创建过程中， 会同时创建springmvc容器对象，
        读取springmvc的配置文件，把这个配置文件中的对象都创建好， 当用户发起
        请求时就可以直接使用对象了。

        servlet的初始化会执行init（）方法。 DispatcherServlet在init（）中{
           //创建容器，读取配置文件
           WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
           //把容器对象放入到ServletContext中
           getServletContext().setAttribute(key, ctx);
        }



        启动tomcat报错，读取这个文件 /WEB-INF/springmvc-servlet.xml（/WEB-INF/myweb-servlet.xml）
        springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml .
    -->
    <servlet>
        <servlet-name>myweb</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--自定义springmvc读取的配置文件的位置-->
        <init-param>
            <!--springmvc的配置文件的位置的属性-->
            <param-name>contextConfigLocation</param-name>
            <!--指定自定义文件的位置-->
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>

        <!--在tomcat启动后，创建Servlet对象
            load-on-startup:表示tomcat启动后创建对象的顺序。它的值是整数，数值越小，
                            tomcat创建对象的时间越早。 大于等于0的整数。
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>myweb</servlet-name>
        <!--
            使用框架的时候， url-pattern可以使用两种值
            1. 使用扩展名方式， 语法 *.xxxx , xxxx是自定义的扩展名。 常用的方式 *.do, *.action, *.mvc等等
               不能使用 *.jsp
               http://localhost:8080/myweb/some.do
               http://localhost:8080/myweb/other.do

            2.使用斜杠 "/"
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>



</web-app>

    4、main目录下新建Java目录和resources目录，并标记为相应的源码根和resources根

    5、java目录下，新键包com.bjpowernode.controller,并创建类MyController.java

    package com.bjpowernode.controller;

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

/*
* @Controller:创建处理器对象，对象放在springmvc容器中。
* 位置：在类的上面
* 和spring中的@Service,@Component
*
* 能处理请求的都是控制器(处理器)，MyController 能处理请求，
*                           叫做后端控制器（back controller）
*
* 没有注解之前，需要实现各种不同的接口才能做控制器使用
* */
@Controller
public class MyController {
    /*
    * 处理用户提交的请求，springmvc中是使用方法来处理的。
    * 方法是自定义的，可以又多种返回值，多种参数，方法名称自定义。
    * */
    /*
    *  准备使用doSome方法处理some.do请求。
    * @RequestMapping:请求映射，作用是把一个请求地址和一个方法绑定在一起。
    *                              一个请求指定一个方法处理。
    *       属性：1、value是一个String,表示请求的url地址的（some.do）
    *               value的值必须是唯一的，不能重复。在使用是，推荐地址以“/”
    *       位置：1、方法的上面，常用的。
    *            2、在类的上面
    * 说明：使用RequestMapping修饰的方法叫做处理器方法或控制器方法。
    * 使用@RequestMapping修饰的方法可以处理请求，类似Servlet中的doGet,doPost
    *
    *  返回值：ModelAndView 表示本次请求的处理结果
    * Model:数据，请求处理完成后，要显示给用户的数据
    * View:视图，比如jsp等等。
    * */
    @RequestMapping(value = {"/some.do","/first.do"})
    public ModelAndView doSome(){
        ModelAndView mv = new ModelAndView();
        //添加数据，框架在请求的最后把数据放入到request作用域。
        mv.addObject("msg","使用注解的SpingMvc应用");
        mv.addObject("fun","dosome");
        mv.setViewName("/Show.jsp");
        return mv;
    }
}

    6、resources目录下创建springmvc配置文件springmvc.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

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

    7、webapp目录下，修改index.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<p>第一个springmvc项目,some.do和first.do请求的都是同一个处理器方法doSome!!</p>
<p><a href="some.do">发起some.do的请求</a> </p>
<p><a href="first.do">发起first.do请求</a></p>
</body>
</html>

    8、webapp目录下，新建目标页面Show.jsp

    <%--
  Created by IntelliJ IDEA.
  User: 17216
  Date: 2021/10/28
  Time: 22:54
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>/Show.jsp从request作用域获取数据</h3><br/>
<h3>msg数据：${msg}</h3><br/>
<h3>fun数据：${fun}</h3>
</body>
</html>

    9、配置tomcat，发布运行即可！

    index.jsp页面显示：
    在这里插入图片描述
    some.do请求下的Show.jsp:
    在这里插入图片描述
    first.do请求下的Show.jsp:
    在这里插入图片描述

    二、视图解析器的引入(实例的升级)

    1、在springmvc.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

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

    <!--声明 springmvc框架中的视图解析器， 帮助开发人员设置视图文件的路径-->
    <bean  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀：视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/" />
        <!--后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

    2、把show.jsp页面放入/WEB-INF/view/路径中

    <%--
  Created by IntelliJ IDEA.
  User: 17216
  Date: 2021/10/28
  Time: 22:54
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>/Show.jsp从request作用域获取数据</h3><br/>
<h3>msg数据：${msg}</h3><br/>
<h3>fun数据：${fun}</h3>
</body>
</html>

    3、修改处理器MyController .java

    package com.bjpowernode.controller;

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

/*
* @Controller:创建处理器对象，对象放在springmvc容器中。
* 位置：在类的上面
* 和spring中的@Service,@Component
*
* 能处理请求的都是控制器(处理器)，MyController 能处理请求，
*                           叫做后端控制器（back controller）
*
* 没有注解之前，需要实现各种不同的接口才能做控制器使用
* */
@Controller
public class MyController {
    /*
    * 处理用户提交的请求，springmvc中是使用方法来处理的。
    * 方法是自定义的，可以又多种返回值，多种参数，方法名称自定义。
    * */
    /*
    *  准备使用doSome方法处理some.do请求。
    * @RequestMapping:请求映射，作用是把一个请求地址和一个方法绑定在一起。
    *                              一个请求指定一个方法处理。
    *       属性：1、value是一个String,表示请求的url地址的（some.do）
    *               value的值必须是唯一的，不能重复。在使用是，推荐地址以“/”
    *       位置：1、方法的上面，常用的。
    *            2、在类的上面
    * 说明：使用RequestMapping修饰的方法叫做处理器方法或控制器方法。
    * 使用@RequestMapping修饰的方法可以处理请求，类似Servlet中的doGet,doPost
    *
    *  返回值：ModelAndView 表示本次请求的处理结果
    * Model:数据，请求处理完成后，要显示给用户的数据
    * View:视图，比如jsp等等。
    * */
    @RequestMapping(value = {"/some.do","/first.do"})
    public ModelAndView doSome(){
        ModelAndView mv = new ModelAndView();
        //添加数据，框架在请求的最后把数据放入到request作用域。
        mv.addObject("msg","使用注解的SpingMvc应用");
        mv.addObject("fun","dosome");
       // mv.setViewName("/Show.jsp");
        mv.setViewName("Show");//当配置了视图解析器后，可以使用逻辑名称（文件名），指定相应的视图！
        return mv;
    }
}
    收起
    展开全文

  • springmvc简述及实例

     万次阅读 2022-04-19 10:39:46
    springmvc是spring的一个模块，一个“小弟”，用于web开发，可理解为servlet的升级版 所以了解springmvc必须先了解之前的开发模式 --------------------------------------------------------------------------...

    一、简述

    springmvc是spring的一个模块，一个“小弟”，用于web开发，可理解为servlet的升级版

    所以了解springmvc必须先了解之前的开发模式

    ---------------------------------------------------------------------------------------------------------------------------------

    Java web的发展历史

    一.Model I和Model II

    1.Model I开发模式

    Model1的开发模式是：JSP+JavaBean的模式，它的核心是Jsp页面，在这个页面中，Jsp页面负责整合页面和JavaBean（业务逻辑），而且渲染页面，它的基本流程如下：

     这样的设计模式到这一个jsp页面负责了视图的展示和业务流程（即html和servlet都是它干了）的控制高度耦合的结果是Jsp代码十分复杂，后期维护困难！

    2.Model II开发模式

    在Model II的模式下。利用jsp页面、servlet和JavaBean组件分工协作共同完成系统的所有任务。其中jsp负责数据显示逻辑任务，servlet负责程序的流程控制任务，JavaBean负责处理业务逻辑任务。它的基本流程如下：

    Model2：相对于Model1来说，职责分工更为明确，在Model1的基础上，抽取了Servlet层，体现了一个分层的思想，适合大型的项目开发！（当时的评判标准是适合大型项目开发的，现在看起来已经过时了！）

    二. MVC模式

    Spring mvc是基于Spring的一个模块，专门做web开发，可以理解为是Servlet的升级

    在Spring MVC框架当中，Controller替代Servlet担负控制器的职能，

    M：指model:模型层，指工程当中的Java Bean,作用是处理数据

    Java Bean分两类：

    • 一类是实体类Bean:专门存储业务数据的
    • 一类为业务处理Bean:指Servlet或Dao对象，专门处理业务逻辑和数据

    V:View,视图层指项目当中的html或jsp等页面，作用是与用户进程交互，展示数据

    C:Contoller,控制层，指工程当中的servlet,作用是接受请求和响应数据

    MAC思想不是那个语言所特有的设计模式，也不是web应用所特有的思想，而是一种规范。MVC思想将一个应用分成三个基本部分：Model(模型)、View(视图)和Controller(控制器)，这三个部分以最少的耦合协同工作，从而提高了应用的可扩展性和可维护性。他们三者的关系如下图所示

    简述完毕，接下来是实例。如何搭建springmvc 

     二、如何搭建springmvc

     名字

     配置到你的maven安装地方

     弄到你的自己setting.xml配置文件。我的可能跟你们不一样，我配到这里了

     来，我们继续

    在pom.xml里面配置安装依赖

    <!--版本锁定-->
<properties>
  <spring.version>5.0.2.RELEASE</spring.version>
</properties>

<dependencies>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <!--SpringMVC-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <!--servlet API-->
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
  </dependency>

  <dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.0</version>
    <scope>provided</scope>
  </dependency>

  <!--日志-->
  <dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
  </dependency>

  <dependency>
    <groupId>org.thymeleaf</groupId>
    <artifactId>thymeleaf-spring4</artifactId>
    <version>3.0.9.RELEASE</version>
  </dependency>

</dependencies>

     多等会，这个时间比较长，起码比mybaits和spring配置的时候依赖要多

    配置web.xml

    <web-app version="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/web-app_3_0.xsd">

</web-app>

    ④：配置DispatcheServlet

    Spring MVC是基于原生的servlet,通过强大的前端控制器DispatcheServlet，对请求和响应进行统一处理。

    Spring MVC的本质就是一个servlet,是对原生的servlet进行了封装。在以前我们浏览器的每一次请求都需要我们写一个对应的servlet,现在我们只需要将浏览器的请求和响应交给DispatcheServlet进行统一的处理。

    在web.xml配置文件中核心控制器DispatcherServlet

    (这个DispatcherServlet老牛逼了)

     （你看，绝大部分都要前端控制器进行交互操作）

     把这个放进去刚刚的web.xml里面

    <!--配置前端控制器，对浏览器发送的请求进行统一处理-->
<servlet>
  <servlet-name>dispatcherServlet</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <!--加载springmvc.xml配置文件的位置和名称，配置的是Spring配置-->
  <init-param>
    <!--contextConfigLocation:上下文配置路径，固定值-->
    <param-name>contextConfigLocation</param-name>
    <!--classpath:类路径，值得是Java和resources文件夹-->
    <!--springmvc.xml:指的是配置文件的名称：需要配置springmvc.xml，在下面-->
    <param-value>classpath:springmvc.xml</param-value>
  </init-param>
  <!--配置启动加载-->
  <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
  <servlet-name>dispatcherServlet</servlet-name>
  <url-pattern>*.do</url-pattern>
</servlet-mapping>

    有报错没关系，我们没创文件

    servlet-name：前端控制器的名字

    servlet-class：配置的类

    param-name：取的别名（跟每个人小名一样，天天叫姓名也麻烦）

    param-value：映射的配置文件

    load-on-startup：启动的先后顺序

    servlet-name：名字，一样的

    url-pattern：通配符

    来，说完我们继续。。。。。。。。。。。。。。。。。

    把java和resoures都弄上，不要弄错。在main里面弄

     创建springmvc.xml文件，看图看图

     配置springmvc.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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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">

    <context:component-scan base-package="com.qcby"></context:component-scan>
    <!--处理映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

    <!--处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

    <!--配置视图解析器-->
    <bean id="viewResolver" class="org.thymeleaf.spring4.view.ThymeleafViewResolver">
        <property name="order" value="1"/>
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateEngine" ref="templateEngine"/>
    </bean>
    <!-- templateEngine -->
    <bean id="templateEngine" class="org.thymeleaf.spring4.SpringTemplateEngine">
        <property name="templateResolver" ref="templateResolver"/>
    </bean>
    <bean id="templateResolver" class="org.thymeleaf.spring4.templateresolver.SpringResourceTemplateResolver">
        <property name="prefix" value="/html/" />
        <property name="suffix" value=".html" />
        <property name="templateMode" value="HTML5"/>
    </bean>
    <!--配置spring开启注解mvc的支持  默认就是开启的 ，要想让其他组件（不包含映射器、适配器、处理器）生效就必须需要配置了-->
    <mvc:annotation-driven></mvc:annotation-driven>
</beans>

    创建controller文件

     创建HelloController

    package com.qcby;

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

@Controller
public class HelloController {

    @RequestMapping(path = "/hello.do")
    public String sayHello(Model model){
        System.out.println("入门方法执行222");
        model.addAttribute("msg","hello,Springmvc");
        return "suc";
    }
}

    创建html和css页面

     

    <!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">

    <title>成功</title>
</head>
<body>
<h1>Hello <b th:text="${msg}"></b></h1>
</body>
<script>
</script>
</html>

    在web-app下创建index.html

    <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>入门程序</title>
</head>
<body>
<h3>入门</h3><a href="/SpringMvcTest/hello.do">入门程序</a>
</body>
</html>

    代码问题就解决了，现在再配置一个tomcat就行了

     

     选择“工件”

     欧克，等着再启动就行了

    三、SpringMVC原理

    SpringMVC中心控制器

    Spring的web框架围绕DispatcherServlet 【servlet调度】设计

    DispatcherServlet的作用是将请求发送到不同的处理器

    入门案例的执行流程

    1. 当启动Tomcat服务器的时候，因为配置了load-on-startup标签，所以会创建DispatcherServlet对象，就会加载springmvc.xml配置文件

    2. 开启了注解扫描，那么HelloController对象就会被创建

    3. 从index.jsp发送请求，请求会先到达DispatcherServlet核心控制器，根据配置@RequestMapping注解找到

    执行的具体方法

    4. 根据执行方法的返回值，再根据配置的视图解析器，去指定的目录下查找指定名称的JSP文件

    5. Tomcat服务器渲染页面，做出响应

    SpringMVC官方提供图形

    入门案例中的组件分析

    1. 前端控制器（DispatcherServlet）

    2. 处理器映射器（HandlerMapping）

    3. 处理器（Handler）

    4. 处理器适配器（HandlAdapter）

    5. 视图解析器（View Resolver）

    6. 视图（View）

    客户端（浏览器）发送请求，直接请求到DispatcherServlet。

    DispatcherServlet根据请求信息调用HandlerMapping，解析请求对应的Handler。

    解析到对应的Handler后，开始由HandlerAdapter适配器处理。

    HandlerAdapter会根据Handler来调用真正的处理器开处理请求，并处理相应的业务逻辑。

    处理器处理完业务后，会返回一个ModelAndView对象，Model是返回的数据对象，View是个逻辑上的View。

    ViewResolver会根据逻辑View查找实际的View。

    DispaterServlet把返回的Model传给View。

    通过View返回给请求者（浏览器）
     

    收起
    展开全文
    java

  • SpringMvc实例

     2014-10-29 14:27:39
    Java语言springMVC+jpa的开发环境
    收起

  • SpringMvc项目配置实例

     2017-12-06 13:43:46
    SpringMVC项目配置的Demo 分两种方式 框架的创建和配置一直是新手入门的一个难题，所以我就写一下我的配置过程，以供参考 另外spring4的新特性可以用java来配置
    收起

  • [SpringMVC]创建第一个基于maven的SpringMVC项目

     2021-04-07 19:51:45
    第一个SpringMVC项目 需求：用户在页面发起一个请求，请求交给springMVC的控制器对象， 并显示请求的处理结果(在结果页面显示一个欢迎语句) 实现步骤： 1.新建web maven工程 2.加入依赖 spring-webmvc依赖，直接把...

    第一个SpringMVC项目
    需求：用户在页面发起一个请求，请求交给springMVC的控制器对象，并显示请求的处理结果(在结果页面显示一个欢迎语句)
    实现步骤：
    1.新建web maven工程
    2.加入依赖
    spring-webmvc依赖，直接把spring的依赖都加入到项目
    加入jsp、servlet依赖
    3.重点：在web.xml中注册springMVC框架的核心对象DispatherServlet：（DispatherServlet：解决SpringMVC中没有servlet，也可以开发web项目）
    1)DispatcherServlet叫做中央调度器，是一个servlet，它的父类是继承HttpServlet
    2)DispatcherServlet也叫做前端控制器（front controller）
    3)DispatcherServlet负责接收用户提交的请求，调用其他的控制器对象，并将处理结果显示给用户
    4.创建一个发起请求的页面 index.jsp
    5.创建控制器类
    1）在类的上面加入@Controller注解，创建对象，并放入到springMVC容器中
    2）在类中的方法上面加入@RequestMapping注解
    6.创建一个作为结果的jsp,显示请求的处理结果

    7.创建springMVC的配置文件（Spring的配置文件一样）
    1）声明组件扫描器，指定@Controller注解所在的包名
    2)声明视图分析器。帮助处理视图

    具体步骤：
    1.新建web maven工程
    创建一个基于maven的SpringMVC工程
    2.在pom.xml文件中添加依赖

    修改pom.xml中项目的URL地址

    在这里插入图片描述

    在这里插入图片描述
    添加servlet和springMVC依赖。若出现报红线错误，则点击右上角的标志，maven便可以自动下载。在这里插入图片描述

     <!--servlet依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <!--springMVC依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.13.RELEASE</version>
    </dependency>

    3.在web.xml中注册springMVC框架的核心对象DispatherServlet

    在这里插入图片描述
    这时，启动tomcat时报错，读取这个文件/WEB-INF/myweb-servlet.xml.
    这是因为springmvc创建对象时，读取的配置文件默认位置是/WEB-INF/-servlet.xml
    需要对配置文件默认位置进行修改：
    在这里插入图片描述
    此时，classpath:springmvc.xml会报红线错误，只要在src/main/resources目录下新建一个springmvc.xml便不会报错。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    配置servlet-mapping文件
    在这里插入图片描述
    web.xml文件如下：

    <?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">
    <!--声明，注册springMVC的核心对象DispatcherServlet
    需要在tomcat服务器启动后，创建DispatcherServlet对象的实例。
    为什么要创建DispatcherServlet对象的实例呢？
    因为在DispatcherServlet的创建过程中，会同时创建springMVC容器对象
    读取springMVC的配置文件，把这个配置文件中的对象都创建好，当用户发起
    请求是就可以直接使用对象了

    即servlet的初始化会执行init（）方法。DispatcherServlet在init()
    中{
    //创建容器，读取配置文件
    webApplicationContext ctx=new ClassPathXmlApplicationContext("springmvc.xml");
    //把容器对象放入到ServletContext中
    getServletContext().setAtrribute(key,ctx);
    }
    -->
    <!--启动tomcat时报错，读取这个文件/WEB-INF/springmvc-servlet.xml
                                /WEB-INF/myweb-servlet.xml
      springmvc创建对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml
    -->
    <servlet>
        <!--<servlet-name>springmvc</servlet-name>-->
        <!-- <servlet-name>myweb</servlet-name>-->
        <servlet-name>myweb</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--自定义springMVC读取的配置文件的位置-->
        <init-param>
            <!--springMVC的配置文件的位置的属性-->
            <param-name>contextConfigLocation</param-name>
            <!--指定自定义文件的位置 这里是src/main/resources目录下-->
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>

        <!--在tomcat启动后，创建Servlet对象,
        load-on-startup表示在启动时进行加载
        load-on-startup:表示tomcat在启动后创建对象的顺序，值是大于0的整数，数值越小，
        tomcat创建对象的时间越早
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>myweb</servlet-name>
        <!--使用框架的时候，url-pattern可以使用2种值
        第一种：使用扩展名方式，语法*.xxx,xxx是自定义的扩展名。常用的方式*.do,*.action,*.mvc等等
        *.do表示凡是以.do结尾的请求都交给myweb这个servlet进行处理
        例如http://localhost:8080/myweb/some.do，
        第二种：使用斜杠“/”
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

</web-app>

    4.创建一个发起请求的页面 index.jsp。
    删除系统默认的index.jsp页面，这是因为它没有设置编码格式，所以需要，删除后，重现建立。
    在这里插入图片描述
    这里通过超链接，发起some.do的请求。

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

    编写 MyController.java
    在这里插入图片描述

    package controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
/*
@Controller:创建处理器对象，对象放在springMVC容器中。
位置：在类上面
和Spring中讲的@Service,@Component一样

能处理请求的都是控制器（处理器）：MyController能处理请求，叫做后端控制器（back controller）
 */

@Controller
public class MyController {
   /*
   处理用户提交的请求，springmvc中，是使用方法来处理的
   方法是自定义的，可以有多种返回值，多种参数，方法名称自定义
    */
    /*
    准备使用doSome方法处理some.do请求：
    @RequestMapping:请求映射，作用是把一个请求地址和一个方法绑定在一起
    即一个请求指定一个方法处理
    属性：1.value是一个String，表示请求的uri地址的（这里表示inde.jsp中的some.do请求）
    value的值必须是唯一的，不能重复。在使用时，推荐地址以“/”开头
    @RequestMapping的位置：1.在方法的上面，常用的
                           2.在类的上面
     说明：使用@RequestMapping:修饰的方法叫做处理器方法或者控制器方法
     使用@RequestMapping:修饰 的方法可以处理请求，类似于servle中的doGet,doPost

     返回值ModelAndView：表示本次请求的处理结果
     Model:数据，请求处理完成后，要显示给用户的数据
     View:视图，比如jsp等等
     */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(){//类似于doGet（）--->给service进行处理
        //处理some.do的请求,假设service已经处理完了
        ModelAndView modelAndView=new ModelAndView();
        //添加数据，框架在请求的最后，自动把把数据放入到request作用域中
        //request.setAtrribute("msg","欢迎使用springmvc做web开发")
        modelAndView.addObject("msg","欢迎使用springmvc做web开发");
        modelAndView.addObject("fun","执行DoSome方法");

        //指定视图，指定视图的完整路径
        //框架对视图执行的是请求转发操作，request.getRequestDispatcher("/show.jsp").forward(...)
        modelAndView.setViewName("/show.jsp");
        //返回modelAndView
        return modelAndView;
        //框架后面自动操作request.setAtrribute，request.getRequestDispatcher等操作
    }
}

    编写show.jsp页面

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
        <h3>show.jsp从request作用域中获取数据</h3>
        <h3>msg数据：${msg}</h3><br>
        <h3>fun数据：${fun}</h3><br>


   <% String msg=(String)request.getAttribute("msg");
    String fun=(String)request.getAttribute("fun");
    %>
        msg数据：<%=msg%><br>
        fun数据：<%=fun%><br>
</body>
</html>

    编写springmvc.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:context="http://www.springframework.org/schema/context"
       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">

    <!--声明注解扫描器-->
<context:component-scan base-package="controller"></context:component-scan>
</beans>

    运行结果如下图：
    在这里插入图片描述
    在这里插入图片描述

    收起
    展开全文
    spring java tomcat

  • 简单的SpringMVC小项目（适合刚刚学的）

     2019-02-27 21:03:24
    实现注册和登录的springmvc小项目。
    收起

  • SpringMVC项目实例代码（基础版），执行流程和三层架构类的代码
    @Repository public class SystemJobsDaoImpl implements SystemIJobsDao{ @Autowired public JdbcTemplate temple; @Override public List<Jobs> findAll() { return temple.query("select * from ...
    收起
    java

  • SpringMVC入门开发项目实例

     千次阅读 2020-02-23 23:49:14
    项目环境 IDE:InteliJ IDEA 2019.2.4 Maven : version 3.6.3 Tomcat: version 9.0.22 第一步：打开IDE新建一个Maven项目，在GoupId填入公司网址写，或以com.开头的名称如com.test,ArtifactId填入项目名称如：...
    收起
    java spring maven

  • springMVC入门实例

     2015-05-06 17:53:13
    关于SpringMVC入门级的实例demo
    收起

  • SpringMVC项目搭建

     2021-05-31 14:53:11
    退出当前项目： 将pom.xml文件改为如下： <?xml version="1.0" encoding="UTF-8"?> <project xmlns=...
    收起
    Springmvc

  • Idea创建maven管理的springmvc项目

     2018-11-23 17:36:57
    七、在弹框中找到spring选项，这里又有一个坑可能你的弹框中没有spring选项，这是因为你的project中可能已经有了springmvc的项目所以添加不了支持，可以在Project Structure中去掉该项目，也可把新创建的项目新建一...
    收起
    maven project

  • springMVC小项目实例

     2018-09-30 09:31:56
    <context:component-scan base-package="com.shiyanlou.springmvc.controller" /> <!-- 这两个类用来配置 annotation 类型的处理器映射器和处理器适配器 --> <!-- 配置视图解析器 --> ...
    收起

  • springmvc入门实例

     2018-12-14 16:16:28
    该资源是spring入门的最基础的小实例, 很适合于新手入门的小项目, 一看即懂, 是本人在学习过程中练习的. 包含springmvc 独立运行的jar包. 导入eclipse即可运行.
    收起

  • SpringMVC入门实例，手把手教你搭建项目

     2019-03-22 13:49:01
    手把手教你搭建SpringMVC，史上最详细的搭建教程，附赠jar和项目源码
    收起

  • springMVC搭建实例demo

     2017-03-23 08:43:20
    收起

  • SpringMVC demo 完整源码实例下载.zip

     2022-02-21 22:02:04
    比较完整的SpringMVC的demo，里面包含了对数据增删改查，上传下载文件的实现，异常处理，拦截器，国际化等等功能的实现
    收起
    mvc

  • springmvc 实例项目简单登录功能

     2020-02-29 18:40:22
    springmvc 实例项目简单登录功能 springmvc 实例项目简单登录功能 springmvc 实例项目简单登录功能 springmvc 实例项目简单登录功能
    收起

  • SSM(Spring+springmvc+mybatis)项目实例.zip

     2021-02-13 10:40:38
    对应博客https://blog.csdn.net/h15835161250/article/details/113798180的资源
    收起
    ssm

  • springMVC实例项目

     热门讨论 2013-09-03 16:46:54
    该资源包含了springMVC的实现原理，以及几个基本的springmvc项目，囊括了几乎所有springmvc知识点
    收起

  • springmvc 项目完整示例01 需求与数据库表设计 简单的springmvc应用实例 web项目

     2016-02-24 16:30:00
    springmvc 项目完整示例01 需求与数据库表设计 简单的springmvc应用实例 web项目 springmvc 项目完整示例02 项目创建-eclipse创建动态web项目 配置文件 junit单元测试 springmvc 项目完整示例03 小结 ...
    收起

  • Spring MVC简单项目实例---Hello SpringMvc

     千次阅读 2018-02-27 17:16:19
    工作一段时间，总想着自己搭一个框架，方便自己在上面应用各种自己学习的新技术,这边博客是先搭建一个小的spring mvc例子，后面在一边学习...配置监听，以及配置文件的加载，springmvc默认会去web-info目录下寻找spr...
    收起
    spring mvc

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,823
精华内容 16,329
热门标签
关键字：

springmvc项目实例

spring 订阅