精华内容
下载资源
问答
  • 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>
    
    

    更多相关内容
  • 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
    .............................................................
  • 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简介:也叫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返回给请求者(浏览器)
     

    展开全文
  • SpringMvc实例

    2014-10-29 14:27:39
    Java语言springMVC+jpa的开发环境
  • SpringMvc项目配置实例

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

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

    展开全文
  • 实现注册和登录的springmvc项目
  • @Repository public class SystemJobsDaoImpl implements SystemIJobsDao{ @Autowired public JdbcTemplate temple; @Override public List<Jobs> findAll() { return temple.query("select * from ...
  • 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填入项目名称如:...
  • 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=...
  • 七、在弹框中找到spring选项,这里又有一个坑可能你的弹框中没有spring选项,这是因为你的project中可能已经有了springmvc项目所以添加不了支持,可以在Project Structure中去掉该项目,也可把新创建的项目新建一...
  • 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,史上最详细的搭建教程,附赠jar和项目源码
  • springMVC搭建实例demo

    2017-03-23 08:43:20
  • 比较完整的SpringMVC的demo,里面包含了对数据增删改查,上传下载文件的实现,异常处理,拦截器,国际化等等功能的实现
  • springmvc 实例项目简单登录功能 springmvc 实例项目简单登录功能 springmvc 实例项目简单登录功能 springmvc 实例项目简单登录功能
  • 对应博客https://blog.csdn.net/h15835161250/article/details/113798180的资源
  • springMVC实例项目

    热门讨论 2013-09-03 16:46:54
    该资源包含了springMVC的实现原理,以及几个基本的springmvc项目,囊括了几乎所有springmvc知识点
  • 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...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,823
精华内容 16,329
关键字:

springmvc项目实例

spring 订阅