springMVC之环境搭建和CRUD

于 2021-12-18 20:49:45 发布
阅读量593 收藏
点赞数 1
分类专栏： mybatis 文章标签： java spring cloud spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_58525944/article/details/122008338
版权
本文介绍了SpringMVC的基本概念、配置方法以及如何实现简单的增删改查操作，并演示了静态资源处理方式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

今日目标：

  1. Springmvc简介及配置
  2. Springmvc之helloword实现
  3. Springmvc常用注解及返回值处理
  4. Springmvc静态资源处理

本篇博客是在上一篇博客的基础上进行编写的

mybatis之关联关系映射（一对多和多对多关系）_m0_58525944的博客-优快云博客

一，Springmvc简介及配置

1  什么是springMVC?

        Spring Web MVC是一种基于Java的实现了MVC设计模式的、请求驱动类型的、轻量级Web框架。用于实现前端页面的展现与后端业务数据处理的分离。

mvc设计模式的好处

1.分层设计，实现了业务系统各个组件之间的解耦，有利于业务系统的可扩展性，可维护性。

2.有利于系统的并行开发，提升开发效率。

2  Spring MVC的优点

（1）可以支持各种视图技术,而不仅仅局限于JSP；

（2）与Spring框架集成（如IoC容器、AOP等）；

（3）清晰的角色分配：前端控制器(dispatcherServlet) , 请求到处理器映射（handlerMapping), 处理器适配器（HandlerAdapter), 视图解析器（ViewResolver）。

（4） 支持各种请求资源的映射策略。

3  Spring MVC的主要组件

（1）前端控制器 DispatcherServlet（不需要程序员开发）

作用：接收请求、响应结果，相当于转发器，有了DispatcherServlet 就减少了其它组件之间的耦合度。

（2）处理器映射器HandlerMapping（不需要程序员开发）

作用：根据请求的URL来查找Handler

（3）处理器适配器HandlerAdapter

注意：在编写Handler的时候要按照HandlerAdapter要求的规则去编写，这样适配器HandlerAdapter才可以正确的去执行Handler。

（4）处理器Handler（需要程序员开发）

（5）处理器或页面控制器(Controller)

（5）视图解析器 ViewResolver（不需要程序员开发）

（6）验证器(Validator)

作用：进行视图的解析，根据视图逻辑名解析成真正的视图（view）

（7）视图View（需要程序员开发jsp）

View是一个接口， 它的实现类支持不同的视图类型（jsp，freemarker，pdf等等）

1.5 SpringMVC处理请求的流程（工作原理）
4  SpringMVC处理请求的流程

  2.1 首先用户发送请求-->DispatherServlet

  2.2 DispatcherServlet-->HandlerMapping

  2.3 DispatcherServlet-->HandlerAdapter

  2.4 HandlerAdapter-->处理器功能处理方法的调用

  2.5 ModelAndView的逻辑视图名-->ViewRecolver

  2.6 View-->渲染

  2.7 返回控制权给DispatcherServlet，由DispatcherServlet返回呼应给用户，流程结束
5  SpringMVC核心开发步骤

  3.1 DispatcherServlet在web.xml中的部署描述，从而拦截请求到springMVC

  3.2 HandlerMapping的配置，从而将请求映射到处理器

  3.3 HandlerAdapter的配置，从而支持多种类型的处理器

  3.4 处理器(页面控制器)的配置，从而刊行功能处理

  3.5 ViewResolver的配置，从而将逻辑视图名解析为具体的视图技术

二，Springmvc之helloword实现

1  首先，spring的环境搭建，先导入相关依赖  我们在前几篇博客中导入了spring-context的依赖，我们只需要把下面的依赖对已存在的spring-context进行替换即可，因为下面的依赖中包含spring-context依赖的，所有，我们导依赖时尽量不要导入相同的依赖

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

添加JSTL依赖（为做页面版的增删改查使用）：当我们不使用前后端分离时，就用导如下依赖，不然会报错

  <!-- 缺少下面的这两个jar包会报java.lang.NoClassDefFoundError: javax/servlet/jsp/jstl/core/Config-->
  <!-- 原因：org.springframework.web.servlet.view.JstlView在视图解析时需要这二个jar包-->
<dependency>
          <groupId>jstl</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</version>
      </dependency>
      <dependency>
          <groupId>taglibs</groupId>
          <artifactId>standard</artifactId>
          <version>1.1.2</version>
      </dependency>

2  在WEB-INF下添加springmvc-servlet.xml(spring-mvc.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" 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-4.3.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 通过context:component-scan元素扫描指定包下的控制器-->
    <!--1) 扫描com.lgs及子子孙孙包下的控制器(扫描范围过大，耗时),然后去找对应的方法进行处理-->
    <aop:aspectj-autoproxy/>
    <context:component-scan base-package="com.lgs"/>

    <!--2) 此标签默认注册DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter -->
    <!--两个bean，这两个bean是spring MVC为@Controllers分发请求所必须的。并提供了数据绑定支持，-->
    <!--@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，读写XML的支持（JAXB），读写JSON的支持（Jackson）-->
    <mvc:annotation-driven></mvc:annotation-driven>

    <!--3) ViewResolver 如果使用前后端分离就不用写-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- viewClass需要在pom中引入两个包：standard.jar and jstl.jar -->
        <property name="viewClass"
                  value="org.springframework.web.servlet.view.JstlView"></property>
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--4) 单独处理图片、样式、js等资源 -->
    <!--<mvc:resources location="/css/" mapping="/css/**"/>-->
    <!--<mvc:resources location="/images/" mapping="/images/**"/>-->
    <!--<mvc:resources location="/js/" mapping="/js/**"/>-->
    <mvc:resources location="/static/" mapping="/static/**"/>

</beans>

3  修改web.xml（配置中央控制器DispatcherServlet）

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    <display-name>Archetype Created Web Application</display-name>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <!-- 读取Spring上下文的监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- Spring MVC servlet -->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--此参数可以不配置，默认值为：/WEB-INF/springmvc-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <!--web.xml 3.0的新特性，是否支持异步-->
        <async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <async-supported>true</async-supported>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

二，Springmvc之helloword实现

1  测试springMVC环境搭建是否成功  建立HelloController.java类

package com.lgs.controller;

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

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }

}

2  建立hello.jsp

<html>
<body>
<h2>Hello World!</h2>
</body>
</html>

3  配置此项目的Tomcat发布项目

配置成功后看运行结果：

总结：

1、浏览器发送请求：http://localhost:8080/hello（dispatcherservlet）
request对象去处理这个url，可以获取到除去ip+port+项目这一个固定的串，拿到/hello
2、在dispatcherservlet去寻找HandlerMapping
HandlerMapping：在整个spring上下文中寻找了所有的被@requestMapping注解所标记的方法，如果@requestMapping这个注解里面的值有/hello，那么进行下一步
3、从前面已经能够获取到需要被调用的方法，那么dispatcherservlet就会寻找到handlerAdapt适配器来动态调用方法，然后会出一个结果
4、dispatcherservlet将结果封装成一个modelAndView对象，然后将其返回给viewReslover进行解析
5、viewReslover解析完毕之后，会将对应的视图展现给用户

 三，Springmvc常用注解及返回值处理  案例：书籍的增删改查

1  准备工作（提前准备好工具类）

EncodingFiter（中文乱码处理）

package com.lgs.util;

import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 中文乱码处理
 * 
 */
@WebFilter("*.action")
public class EncodingFiter implements Filter {

	private String encoding = "UTF-8";// 默认字符集

	public EncodingFiter() {
		super();
	}

	public void destroy() {
	}

	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {
		HttpServletRequest req = (HttpServletRequest) request;
		HttpServletResponse res = (HttpServletResponse) response;

		// 中文处理必须放到 chain.doFilter(request, response)方法前面
		res.setContentType("text/html;charset=" + this.encoding);
		if (req.getMethod().equalsIgnoreCase("post")) {
			req.setCharacterEncoding(this.encoding);
		} else {
			Map map = req.getParameterMap();// 保存所有参数名=参数值(数组)的Map集合
			Set set = map.keySet();// 取出所有参数名
			Iterator it = set.iterator();
			while (it.hasNext()) {
				String name = (String) it.next();
				String[] values = (String[]) map.get(name);// 取出参数值[注：参数值为一个数组]
				for (int i = 0; i < values.length; i++) {
					values[i] = new String(values[i].getBytes("ISO-8859-1"),
							this.encoding);
				}
			}
		}

		chain.doFilter(request, response);
	}

	public void init(FilterConfig filterConfig) throws ServletException {
		String s = filterConfig.getInitParameter("encoding");// 读取web.xml文件中配置的字符集
		if (null != s && !s.trim().equals("")) {
			this.encoding = s.trim();
		}
	}

}

web.xml（添加过滤器包）：

   <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <async-supported>true</async-supported>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

增删改查的业务逻辑代码（根据以前的代码）

BookController.java：

package com.lgs.controller;

import com.lgs.model.Book;
import com.lgs.service.BookService;
import com.lgs.util.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * lgs
 */
@Controller
@RequestMapping("/book")
public class BookController {

    @Autowired
    private BookService bookService;

    @RequestMapping("/preSave")
    public String preSave(Book book,HttpServletRequest request){
        if(book.getBid() != null){
            Book b = this.bookService.selectByPrimaryKey(book.getBid());
            request.setAttribute("book2",b);
        }
        return "bookEdit";
    }

    @RequestMapping("/add")
    public String add(Book book){
        this.bookService.insert(book);
        return "redirect:/book/list";
    }

    @RequestMapping("/del/{bid}")
    public String del(@PathVariable(value = "bid") Integer bid){
        this.bookService.deleteByPrimaryKey(bid);
        return "redirect:/book/list";
    }

    @RequestMapping("/list")
    public String list(HttpServletRequest request,Book book){
        PageBean pageBean = new PageBean();
        pageBean.setRequest(request);
        Map map = new HashMap();
        map.put("bname","圣墟");
        List<Map> list = this.bookService.listPager(map, pageBean);
        request.setAttribute("bookList",list);
        request.setAttribute("pageBean",pageBean);
        return "bookList";
    }

//    @ResponseBody
//    @RequestMapping("/list2")
//    public Map list2(HttpServletRequest request,Book book){
//        PageBean pageBean = new PageBean();
//        pageBean.setRequest(request);
//        Map map = new HashMap();
//        map.put("bname","圣墟");
//        List<Map> list = this.bookService.listPager(map, pageBean);
//        map.put("bookList",list);
//        map.put("pageBean",pageBean);
//        return map;
//    }

    @RequestMapping("/edit")
    public String edit(Book book){
        this.bookService.updateByPrimaryKeySelective(book);
        return "redirect:/book/list";
    }

}

bookList.jsp（页面展示）：

<%@ page language="java" contentType="text/html; charset=UTF-8"
		 pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%--<%@ taglib uri="/zking" prefix="z" %>--%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
	<title>Insert title here</title>
	<script type="text/javascript">
		function add(){
			// window.location.href = "bookEdit.jsp";
			window.location.href="${pageContext.request.contextPath}/book/preSave";
		}

		function update(bid){
			window.location.href = "${pageContext.request.contextPath}/book/preSave?bid="+bid;
		}

		function del(bid){
			window.location.href = "${pageContext.request.contextPath}/book/del/"+bid;
		}
	</script>
</head>
<body>
<form action="${pageContext.request.contextPath}/book/list"
	  method="post">
	书名：<input type="text" name="bname"> <input type="submit"
											   value="确定">
</form>
<button onclick="add();">新增</button>
<table border="1" width="100%">
	<tr>
		<td>编号</td>
		<td>名称</td>
		<td>价格</td>
		<td>操作</td>
	</tr>
	<c:forEach items="${bookList }" var="b">
		<tr>
			<td>${b.bid }</td>
			<td>${b.bname }</td>
			<td>${b.price }</td>
			<td>
				<button onclick="update(${b.bid });">修改</button>&nbsp;&nbsp;&nbsp;
				<button onclick="del(${b.bid });">删除</button>
			</td>
		</tr>
	</c:forEach>
</table>
<%--<z:page pageBean="${pageBean }"></z:page>--%>
</body>
</html>

bookEdit.jsp（页面修改及增加）:

<%@ page language="java" contentType="text/html; charset=UTF-8"
		 pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
	<title>Insert title here</title>
	<script type="text/javascript">
		function doSubmit(bid){
			var bookForm = document.getElementById("bookForm");
			if(bid){
				//修改时候执行
				bookForm.action = '${pageContext.request.contextPath}/book/edit';
			}else{
				//新增时候执行
				bookForm.action = '${pageContext.request.contextPath}/book/add';
			}
			bookForm.submit();
		}
	</script>
</head>
<body>
<form id="bookForm" action="" method="post">
	bid:<input type="text" name="bid" value="${book2.bid }"><br>
	bname:<input type="text" name="bname" value="${book2.bname }"><br>
	price:<input type="text" name="price" value="${book2.price }"><br>
	<input type="submit" value="提交" onclick="doSubmit('${book2.bid }');"><br>
</form>
</body>
</html>

运行结果：

另外  json数据的返回测试

    @ResponseBody
    @RequestMapping("/list2")
    public Map list2(HttpServletRequest request,Book book){
        PageBean pageBean = new PageBean();
        pageBean.setRequest(request);
        Map map = new HashMap();
        map.put("bname","圣墟");
        List<Map> list = this.bookService.listPager(map, pageBean);
        map.put("bookList",list);
        map.put("pageBean",pageBean);
        return map;
    }

测试： 

总结：

四，Springmvc静态资源处理

SpringMvc是把静态资源当成了请求处理，需要在HelloController里面填写地址访问后台

在spring-mvc.xml中做资源处理映射

<mvc:resources location="/static/" mapping="/static/**"/>

运行结果：

OK！到这就结束了，希望能帮到你！！！

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

亣柒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值