SpringMVC入门笔记

最新推荐文章于 2023-03-20 16:22:45 发布

抓娃男孩

最新推荐文章于 2023-03-20 16:22:45 发布

阅读量274

点赞数

分类专栏： Spring 框架篇文章标签： mvc 前端 spring

本文链接：https://blog.csdn.net/weixin_46055944/article/details/125023480

版权

框架篇同时被 2 个专栏收录

3 篇文章 6 订阅

订阅专栏

Spring

1 篇文章 0 订阅

订阅专栏

SpringMVC

1.什么是SpringMVC

它是基于MVC开发模式的框架,用来优化控制器.它是Spring家族的一员.它也具备IOC和AOP.

2.什么是MVC?

它是一种开发模式,它是模型视图控制器的简称.所有的web应用都是基于MVC开发.
M:模型层,包含实体类,业务逻辑层,数据访问层
V:视图层,html,javaScript,vue等都是视图层,用来显现数据
C:控制器,它是用来接收客户端的请求,并返回响应到客户端的组件,Servlet就是组件

3.ssm框架优化的方向

在这里插入图片描述

4.SpringMVC框架的优点

1)轻量级,基于MVC的框架
2)易于上手,容易理解,功能强大
3)它具备IOC和AOP
4)完全基于注解开发

请求流程

SpringMVC的执行流程

在这里插入图片描述

5.基于注解的SpringMVC框架开发的步骤

1)新建项目,选择webapp模板.
2)修改目录,添加缺失的test,java,resources(两套),并修改目录属性
3)修改pom.xml文件,添加SpringMVC的依赖,添加Servlet的依赖

<!--springMVC依赖-->    
<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!--添加servlet的依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>

4)添加springmvc.xml配置文件,指定包扫描,添加视图解析器.

    <!--添加包扫描-->
    <context:component-scan base-package="com.bjpowernode.controller"></context:component-scan>
    <!--添加视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--配置前缀-->
        <property name="prefix" value="/admin/"></property>
        <!--配置后缀-->
        <property name="suffix" value=".jsp"></property>
    </bean>

5)删除web.xml文件,新建web.xml
6)在web.xml文件中注册springMVC框架(所有的web请求都是基于servlet的)

    <!--注册SpringMVC框架-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--
          指定拦截什么样的请求
          http://localhost:8080/one
          http://localhost:8080/index.jsp
          http://localhost:8080/demo.action
          <a href="${pageContext.request.contextPath}/demo.action">访问服务器</a>
        -->
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>

7)在webapp目录下新建admin目录,在admin目录下新建main.jsp页面,删除index.jsp页面,并新建,发送请求给服务器
在这里插入图片描述

8)开发控制器(Servlet),它是一个普通的类.

	  @Controller  //交给Spring去创建对象
	public class DemoAction {
	    /**
	     * 以前的Servlet的规范
	     * protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {}
	     * action中所有的功能实现都是由方法来完成的
	     * action方法的规范
	     * 1)访问权限是public
	     * 2)方法的返回值任意
	     * 3)方法名称任意
	     * 4)方法可以没有参数,如果有可是任意类型
	     * 5)要使用@RequestMapping注解来声明一个访问的路径(名称)
	     *
	     */
	    @RequestMapping("/demo")
	    public String demo(){
	        System.out.println("服务器被访问到了.......");
	        return "main";  //可以直接跳到/admin/main.jsp页面上
	    }
	}

9)添加tomcat进行测试功能

6.分析web请求

web请求执行的流程
核心处理器
index.jsp<--------------->DispatcherServlet<------------------->SpringMVC的处理器是一个普通的方法
one.jsp <--------------->DispatcherServlet<------------------->SpringMVC的处理器是一个普通的方法

DispatcherServlet要在web.xml文件中注册才可用.

注解式开发

1.@RequestMapping注解详解

此注解就是来映射服务器访问的路径.
1)此注解可加在方法上,是为此方法注册一个可以访问的名称(路径)

  @RequestMapping("/demo")
    public String demo(){
        System.out.println("服务器被访问到了.......");
        return "main";  //可以直接跳到/admin/main.jsp页面上
    }
  <a href="${pageContext.request.contextPath}/demo.action">访问服务器</a>

2)此注解可以加在类上,相当于是包名(虚拟路径),区分不同类中相同的action的名称

  @RequestMapping("/user")
  public class DemoAction1 {..}
  <a href="${pageContext.request.contextPath}/user/demo.action">访问服务器</a>

3)此注解可区分get请求和post请求

  @Controller
	public class ReqAction {
	    @RequestMapping(value = "/req",method = RequestMethod.GET)
	    public String req(){
	        System.out.println("我是处理get请求的........");
	        return "main";
	    }
	    @RequestMapping(value = "/req" ,method = RequestMethod.POST)
	    public String req1(){
	        System.out.println("我是处理post请求的........");
	        return "main";
	    }
	}

2.五种数据提交方式的优化

1)单个提交数据

页面:

  <form action="${pageContext.request.contextPath}/one.action">
      姓名:<input name="myname"><br>
      年龄:<input name="age"><br>s
      <input type="submit" value="提交">
 </form>

action:

  @RequestMapping("/one")
    public String one(String myname,int age){  ===>自动注入,并且类型转换
        System.out.println("myname="+myname+",age="+(age+100));
        return "main";
    }

2)对象封装提交数据

在提交请求中,保证请求参数的名称与实体类中成员变量的名称一致,则可以自动创建对象,则可以自动提交数据,自动类型转换,自动封装数据到对象中.
实体类:

    public class Users {
    private String name;
    private int age;
    }

页面:

	<form action="${pageContext.request.contextPath}/two.action" method="post">
	    姓名:<input name="name"><br>
	    年龄:<input name="age"><br>
	    <input type="submit" value="提交">
	</form>

action:

    @RequestMapping("/two")
    public String two(Users u){
        System.out.println(u);
        return "main";
    }

3)@PathVariable以及动态占位符提交

@PathVariable常常用在restful风格的请求中,是用来解析路径中参数名称不一致的问题
仅限于超链接或地址拦提交数据.它是一杠一值,一杠一大括号,使用注解@PathVariable来解析.

  <a href="${pageContext.request.contextPath}/three/张三/22.action">动态提交</a>

   @RequestMapping("/three/{uname}/{uage}")
    public String three(
            @PathVariable("uname")  ===>用来解析路径中的请求参数
            String name,
            @PathVariable("uage")
            int age){
        System.out.println("name="+name+",age="+(age+100));
        return "main";
    }

4)映射名称不一致

@RequestParam是用来解决请求参数名称不一致的问题

页面

<h4>4.参数名称不致解决方案</h4>
<form action="${pageContext.request.contextPath}/four.action" method="post">
    姓名:<input name="name"><br>
    年龄:<input name="age"><br>
    <input type="submit" value="提交">
</form>

action

提交请求参数与action方法的形参的名称不一致,使用注解@RequestParam来解析

    /**
     *  姓名:<input name="name"><br>
     *  年龄:<input name="age"><br>
     */
    @RequestMapping("/four")
    public String four(
            @RequestParam("name")  ===>专门用来解决名称不一致的问题
            String uname,
            @RequestParam("age")
            int uage){
        System.out.println("uname="+uname+",uage="+(uage+100));
        return "main";
    }

5)手工提取数据

页面

<h4>5.手工提取数据</h4>
<form action="${pageContext.request.contextPath}/five.action" method="post">
    姓名:<input name="name"><br>
    年龄:<input name="age"><br>
    <input type="submit" value="提交">
</form>

action

  /**
     *  姓名:<input name="name"><br>
     *  年龄:<input name="age"><br>
     */
  @RequestMapping("/five")
    public String five(HttpServletRequest request){
        String name = request.getParameter("name");
        int age = Integer.parseInt(request.getParameter("age"));
        System.out.println("name="+name+",age="+(age+100));
        return "main";
    }

3.中文乱码解决方案

配置过滤器.

  <filter>
        <filter-name>encode</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <!--
          配置参数
            private String encoding;
            private boolean forceRequestEncoding;
            private boolean forceResponseEncoding;
        -->
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encode</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

4.action方法的返回值

1)String:客户端资源的地址,自动拼接前缀和后缀.还可以屏蔽自动拼接字符串,可以指定返回的路径.
2)Object:返回json格式的对象.自动将对象或集合转为json.使用的jackson工具进行转换,必须要添加jackson依赖.一般用于ajax请求.
3)void:无返回值,一般用于ajax请求.
4)基本数据类型,用于ajax请求.
5)ModelAndView:返回数据和视图对象,现在用的很少.

5.完成ajax请求访问服务器,返回学生集合.

1)添加jackson依赖

<dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.8</version>
</dependency>

2)在webapp目录下新建js目录,添加jQuery函数库
3)在index.jsp页面上导入函数库

function show() {
  $.ajax({
    url:"${pageContext.request.contextPath}/ajax.action",
    dataType:"json",
    type:"get",
    success:function (list) {
      //  alert(list);
      var s="";
      $.each(list,function (i,stu) {
        //  alert(stu);
        s+=stu.name+"----"+stu.age+"<br>";
      });
      $("#mydiv").html(s);
      
    }
  });
    }

4)在action上添加注解@ResponseBody,用来处理ajax请求

	@Controller
	public class AjaxAction {
	    //处理ajax请求,一定要加@ResponseBody
	    @ResponseBody
	    @RequestMapping("/ajax")
	    public List<Student> ajax(){
	        Student stu1 = new Student("张三",22);
	        Student stu2 = new Student("李四",24);
	        Student stu3 = new Student("王五",23);
	       List<Student> list = new ArrayList<>();
	       list.add(stu1);
	       list.add(stu2);
	       list.add(stu3);
	        //调用json转换工具ObjectMapper进行转换
	        return list;  //===>springmvc负责转换成json
	    }
	}

5)在springmvc.xml文件中添加注解驱动mvc:annotationdriven/,它用来解析@ResponseBody注解

  <mvc:annotation-driven></mvc:annotation-driven>

6.四种跳转方式

请求转发是基于服务器端的跳转；重定向是基于客户端的跳转。
在这里插入图片描述

本质还是两种跳转:请求转发和重定向,衍生出四种是请求转发页面,转发action,重定向页面,重定向action

  @RequestMapping("/one")
    public String one(){
        System.out.println("这是请求转发页面跳转.........");
        return "main";  //默认是请求转发,使用视图解析器拼接前缀后缀进行页面跳转
    }

    @RequestMapping("/two")
    public String two(){
        System.out.println("这是请求转发action跳转.........");
        //  /admin/  /other.action  .jsp
        //forward: 这组字符串可以屏蔽前缀和后缀的拼接.实现请求转发跳转
        return "forward:/other.action";  //默认是请求转发,使用视图解析器拼接前缀后缀进行页面跳转
    }

    @RequestMapping("/three")
    public String three(){
        System.out.println("这是重定向页面.......");
        //redirect:  这组字符串可以屏蔽前缀和后缀的拼接.实现重定向跳转。所以下面的路径要自己拼全
        return "redirect:/admin/main.jsp";
    }

    @RequestMapping("/four")
    public String four(){
        System.out.println("这是重定向action.......");
        //redirect:  这组字符串可以屏蔽前缀和后缀的拼接.实现重定向跳转
        return "redirect:/other.action";
    }

    @RequestMapping("/five")
    public String five(){
        System.out.println("这是随便跳.......");

        return "forward:/fore/login.jsp";
    }

请求转发和重定向的区别

具体参考 https://blog.csdn.net/qq_41717185/article/details/108169853

请求转发和重定向的应用场景

建议一：
对于竭力避免表单重复提交的场景下选择重定向方式
建议二：
对于效率要求更高的场景选择服务器内请求转发
建议三：
若携带较多参数则选择服务器内请求转发

请求转发偏向于：为同一业务功能服务
重定向偏向于：不同业务功能之间的跳转

7.SpringMVC默认的参数类型

不需要去创建,直接拿来使用即可.
1)HttpServletRequest
2)HttpServletResponse
3)HttpSession
4)Model
5)Map
6)ModelMap
注意:Map,Model,ModelMap和request一样,都使用请求作用域进行数据传递.所以服务器端的跳转必须是请求转发.
重定向想要携带数据，可以用HttpSession

   		//做一个数据,传到main.jsp页面上
        Users u = new Users("张三",22);

        //各种方式传递数据
        request.setAttribute("requestUsers",u);
        session.setAttribute("sessionUsers",u);
        model.addAttribute("modelUsers",u);
        map.put("mapUsers",u);
        modelMap.addAttribute("modelMapUsers",u);

携带数据的请求

jsp页面

requestUsers:${requestUsers}<br>
sessionUsers:${sessionUsers}<br>
modelUsers:${modelUsers}<br>
mapUsers:${mapUsers}<br>
modelMapUsers:${modelMapUsers}<br>
response:${cookie}<br>
从index.jsp页来来的数据${param.name}

action

@Controller
public class DataAction {

    @RequestMapping("/data")
    public String data(HttpServletRequest request,
                       HttpServletResponse response,
                       HttpSession session,
                       Model model,
                       Map map,
                       ModelMap modelMap){

        //做一个数据,传到main.jsp页面上
        Users u = new Users("张三",22);

        //传递数据
        request.setAttribute("requestUsers",u);
        session.setAttribute("sessionUsers",u);
        model.addAttribute("modelUsers",u);
        map.put("mapUsers",u);
        modelMap.addAttribute("modelMapUsers",u);

        Cookie cookie = new Cookie("cookie","123456");
        response.addCookie(cookie);

        return "main";  //请求转发方式跳转
       // return "redirect:/admin/main.jsp";  
      //如果是请求重定向的话，那么只剩下session的数据还能带过去，其他方式的数据的都会丢失
    }
}

作用域：本页面的、请求的、会话的、全局的

8.日期处理

action

package com.bjpowernode.controller;

import com.bjpowernode.pojo.Student;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 *
 */
@Controller
public class MyDateAction {

    SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
    /**
     * 日期:<input type="date" name="mydate"><br>
     *
     */
//    @RequestMapping("/mydate")
//    public String mydate(
//            @DateTimeFormat(pattern = "yyyy-MM-dd")
//            Date mydate){
//        System.out.println(mydate);
//        System.out.println(sf.format(mydate));
//        return "show";
//    }

    //注册一个全局的日期处理注解
    @InitBinder
    public void initBinder(WebDataBinder dataBinder){
        dataBinder.registerCustomEditor(Date.class,new CustomDateEditor(sf,true));
    }
    @RequestMapping("/mydate")
    public String mydate(Date mydate, HttpServletRequest request){
        System.out.println(mydate);
        System.out.println(sf.format(mydate));
        request.setAttribute("mydate",sf.format(mydate));
        return "show";
    }

    @RequestMapping("/list")
    public String list(HttpServletRequest request) throws ParseException {
        Student stu1 = new Student("张三",sf.parse("2000-01-01"));
        Student stu2 = new Student("李四",sf.parse("2001-08-11"));
        Student stu3 = new Student("王五",sf.parse("2002-09-21"));
        List<Student> list = new ArrayList<>();
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        request.setAttribute("list",list);
        return "show";
    }
}

1)日期的提交处理

A.单个日期处理

要使用注解@DateTimeFormat,此注解必须搭配springmvc.xml文件中的<mvc:annotationdriven标签>

    @RequestMapping("/mydate")
    public String mydate(
            @DateTimeFormat(pattern = "yyyy-MM-dd")   //前端传过来的日期，转为日期格式注入
            Date mydate){
        System.out.println(mydate);
        System.out.println(sf.format(mydate));   //格式日期输出
        return "show";
    }

B.类中全局日期处理

全局的则不需要mvc:annotationdriven标签
注册一个注解,用来解析本类中所有的日期类型,自动转换. /*

@InitBinder
public void initBinder(WebDataBinder dataBinder){
    /*  registerCustomEditor的参数
        参数1：转成什么类型
        参数2：需要什么工具去做转换
    */
    /*
     CustomDateEditor的参数
     参数1：格式刷工具
     参数2：是否允许为空
    */
    dataBinder.registerCustomEditor(Date.class,new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),true));
    }

2)日期的显示处理

在页面上显示好看的日期,必须使用JSTL.
步骤:

A)添加依赖jstl

<dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
</dependency>

B)在页面上导入标签库

如果是单个日期对象,直接转为好看的格式化的字符串进行显示.
如果是list中的实体类对象的成员变量是日期类型,则必须使用jstl进行显示.

    <%--导入jstl核心标签库--%>
	<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
	<%--导入jstl格式化标签库--%>
	<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

C)使用标签显示数据

  <table width="800px" border="1">
    <tr>
        <th>姓名</th>
        <th>生日</th>
    </tr>
    	<c:forEach items="${list}" var="stu">
    <tr>
            <td>${stu.name}</td>
            <td>${stu.birthday}------ <fmt:formatDate value="${stu.birthday}" pattern="yyyy-MM-dd"></fmt:formatDate></td>
    </tr>
    	</c:forEach>
	</table>

<mvc:annotation-driven />的作用参考

https://www.zhihu.com/question/362051844/answer/1286615054

9.资源在WEB-INF目录下

此目录下的动态资源,不可直接访问,只能通过请求转发的方式进行访问 .

  @Controller
	public class WebInfAction {
	    @RequestMapping("/showIndex")
	    public String showIndex(){
	        System.out.println("访问index.jsp");
	        return "index";
	    }
	    @RequestMapping("/showMain")
	    public String showMain(){
	        System.out.println("访问main.jsp");
	        return "main";
	    }
	    @RequestMapping("/showLogin")
	    public String showLogin(){
	        System.out.println("访问login.jsp");
	        return "login";
	    }
	    //登录的业务判断
	    @RequestMapping("/login")
	    public String login(String name, String pwd, HttpServletRequest request){
	        if("zar".equalsIgnoreCase(name) && "123".equalsIgnoreCase(pwd)){
	            return "main";
	        }else{
	            request.setAttribute("msg","用户名或密码不正确!");
	            return "login";
	        }
	    }
	}

拦截器

1.SpringMVC的拦截器

针对请求和响应进行的额外的处理.在请求和响应的过程中添加预处理,后处理和最终处理.

2.拦截器执行的时机

1)preHandle():在请求被处理之前进行操作,预处理
2)postHandle():在请求被处理之后,但结果还没有渲染前进行操作,可以改变响应结果,后处理
3)afterCompletion:所有的请求响应结束后执行善后工作,清理对象,关闭资源 ,最终处理.

3.拦截器实现的两种方式

1)继承HandlerInterceptorAdapter的父类
2)实现HandlerInterceptor接口,实现的接口,推荐使用实现接口的方式

4.拦截器应用场景

1、日志记录：记录请求信息的日志
2、权限检查，如登录检查
3、性能检测：检测方法的执行时间
4、处理cookie、本地化、国际化、主题等。
5、通用行为：读取cookie得到用户信息并将用户对象放入请求，从而方便后续流程使用，还有如提取Locale、Theme信息等，只要是多个处理器都需要的即可使用拦截器实现）
6、登录验证，判断用户是否登录。

5.拦截器实现的步骤

注意：拦截器可以配置多个，形成拦截器链，即可以多次拦截
1)改造登录方法,在session中存储用户信息,用于进行权限验证

  @RequestMapping("/login")
    public String login(String name, String pwd, HttpServletRequest request){
        if("zar".equalsIgnoreCase(name) && "123".equalsIgnoreCase(pwd)){
            //在session中存储用户信息,用于进行权限验证
            request.getSession().setAttribute("users",name);
            return "main";
        }else{
            request.setAttribute("msg","用户名或密码不正确!");
            return "login";
        }
    }

2)开发拦截器的功能.实现HandlerInterceptor接口,重写preHandle()方法

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //是否登录过的判断
        if(request.getSession().getAttribute("users") == null){
            //此时就是没有登录,打回到登录页面,并给出提示
            request.setAttribute("msg","您还没有登录,请先去登录!");
            //最原始的请求转发
            request.getRequestDispatcher("/WEB-INF/jsp/login.jsp")
                .forward(request,response);
            
            return false;
        }
        return true;//放行请求
    }
}

2)在springmvc.xml文件中注册拦截器

<mvc:interceptors>
  <mvc:interceptor>
    <!--映射要拦截的请求-->
    <mvc:mapping path="/**"/>
    <!--设置放行的请求-->
    <mvc:exclude-mapping path="/showLogin"></mvc:exclude-mapping>
    <mvc:exclude-mapping path="/login"></mvc:exclude-mapping>
    <!--配置具体的拦截器实现功能的类-->
    <bean class="com.bjpowernode.interceptor.LoginInterceptor"></bean>
  </mvc:interceptor>
</mvc:interceptors>

拦截器、监听器、过滤器的区别

在这里插入图片描述

过滤器（Filter）：可以拿到原始的http请求，但是拿不到你请求的控制器和请求控制器中的方法的信息。
拦截器（Interceptor）：可以拿到你请求的控制器和方法，却拿不到请求方法的参数。
切片（Aspect）: 可以拿到方法的参数，但是却拿不到http请求和响应的对象

过滤器应用场景

过滤器应用场景
1）过滤敏感词汇（防止sql注入）
2）设置字符编码
3）URL级别的权限访问控制
4）压缩响应信息

SSM整合

SSM整合的步骤

0)建库,建表
1)新建Maven项目,选择webapp模板
2)修改目录
3)修改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_006_ssm</artifactId>
  <version>1.0</version>
  <packaging>war</packaging>
  
  
  
  
  <!-- 集中定义依赖版本号 -->
  <properties>
    <!--单元测试的依赖-->
    <junit.version>4.12</junit.version>
    <!--spring的相关依赖-->
    <spring.version>5.2.5.RELEASE</spring.version>
    <!--mybatis的相关依赖-->
    <mybatis.version>3.5.1</mybatis.version>
    <!--mybaits与spring整合的依赖-->
    <mybatis.spring.version>1.3.1</mybatis.spring.version>
    <!--mybatis支持的分页插件的依赖-->
    <mybatis.paginator.version>1.2.15</mybatis.paginator.version>
    <!--mysql的依赖-->
    <mysql.version>5.1.32</mysql.version>
    <!--slf4j日志依赖-->
    <slf4j.version>1.6.4</slf4j.version>
    <!--阿里的数据库连接池-->
    <druid.version>1.1.12</druid.version>
    <!--分页插件的依赖-->
    <pagehelper.version>5.1.2</pagehelper.version>
    <!--JSTL的依赖(jsp的标准标签库)-->
    <jstl.version>1.2</jstl.version>
    <!--servlet的依赖-->
    <servlet-api.version>3.0.1</servlet-api.version>
    <!--jsp的依赖-->
    <jsp-api.version>2.0</jsp-api.version>
    <!--jackson的依赖,springmvc框架默认进行JSON转换的依赖工具-->
    <jackson.version>2.9.6</jackson.version>
  </properties>
  
  
  <dependencies>
    <!-- spring -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jms</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!-- Mybatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis.spring.version}</version>
    </dependency>
    <dependency>
      <groupId>com.github.miemiedev</groupId>
      <artifactId>mybatis-paginator</artifactId>
      <version>${mybatis.paginator.version}</version>
    </dependency>
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>${pagehelper.version}</version>
    </dependency>
    <!-- MySql -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
    <!-- 连接池 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>${druid.version}</version>
    </dependency>
    
    <!-- junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    
    
    <!-- JSP相关 -->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>${jstl.version}</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jsp-api</artifactId>
      <scope>provided</scope>
      <version>${jsp-api.version}</version>
    </dependency>
    <!-- Jackson Json处理工具包 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    
  </dependencies>
  
  <!-- 插件配置 -->
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
    </plugins>
    <!--识别所有的配置文件-->
    <resources>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
  </build>
</project>

4)添加jdbc.properties属性文件

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssmuser?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=123

5)添加SqlMapConfig.xml文件(使用模板)

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  
  
  <!--设置日志输出语句,显示相应操作的sql语名-->
  <settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
  </settings>
  
</configuration>

6)添加applicationContext_mapper.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:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
  
  <!--配置数据源-->
  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${jdbc.driverClassName}"></property>
    <property name="url" value="${jdbc.url}"></property>
    <property name="username" value="${jdbc.username}"></property>
    <property name="password" value="${jdbc.password}"></property>
  </bean>
  
  <!--配置SqlSessionFactoryBean-->
  <bean class="org.mybatis.spring.SqlSessionFactoryBean">
    <!--配置数据源-->
    <property name="dataSource" ref="dataSource"></property>
    <!--配置SqlMapConfig.xml核心配置-->
    <property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
    <!--注册实体类-->
    <property name="typeAliasesPackage" value="com.bjpowernode.pojo"></property>
  </bean>
  <!--注册mapper.xml文件-->
  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.bjpowernode.mapper"></property>
  </bean>
</beans>

7)添加applicationContext_service.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:tx="http://www.springframework.org/schema/tx"
       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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
  
  <!--这里可以不用导入applicationContext_mapper.xml，因为在web.xml注册spring框架的时候一次性用通配符注入-->
  
  <!--添加包扫描-->
  <context:component-scan base-package="com.bjpowernode.service.impl"></context:component-scan>
  <!--添加事务管理器-->
  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--切记切记:配置数据源-->
    <property name="dataSource" ref="dataSource"></property>
  </bean>
  <!--配置事务切面-->
  <tx:advice id="myadvice" transaction-manager="transactionManager">
    <tx:attributes>
      <tx:method name="*select*" read-only="true"/>
      <tx:method name="*find*" read-only="true"/>
      <tx:method name="*serach*" read-only="true"/>
      <tx:method name="*get*" read-only="true"/>
      <tx:method name="*insert*" propagation="REQUIRED"/>
      <tx:method name="*add*" propagation="REQUIRED"/>
      <tx:method name="*save*" propagation="REQUIRED"/>
      <tx:method name="*set*" propagation="REQUIRED"/>
      <tx:method name="*update*" propagation="REQUIRED"/>
      <tx:method name="*change*" propagation="REQUIRED"/>
      <tx:method name="*modify*" propagation="REQUIRED"/>
      <tx:method name="*delete*" propagation="REQUIRED"/>
      <tx:method name="*drop*" propagation="REQUIRED"/>
      <tx:method name="*remove*" propagation="REQUIRED"/>
      <tx:method name="*clear*" propagation="REQUIRED"/>
      <tx:method name="*" propagation="SUPPORTS"/>
    </tx:attributes>
  </tx:advice>
  <!--配置切入点+绑定-->
  <aop:config>
    <aop:pointcut id="mycut" expression="execution(* com.bjpowernode.service.impl.*.*(..))"></aop:pointcut>
    <aop:advisor advice-ref="myadvice" pointcut-ref="mycut"></aop:advisor>
  </aop:config>
</beans>

8)添加spirngmvc.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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
  
  <!--添加包扫描-->
  <context:component-scan base-package="com.bjpowernode.controller"></context:component-scan>
  <!--添加注解驱动-->
  <mvc:annotation-driven></mvc:annotation-driven>
  <!--因为本项目全部是ajax请求,不需要配置视图解析器-->
</beans>

9)删除web.xml文件,新建,改名,设置中文编码,并注册spirngmvc框架,并注册Spring框架

<?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">
  <!--添加中文编码过滤器
        private String encoding;
        private boolean forceRequestEncoding;
        private boolean forceResponseEncoding;
    -->
  <filter>
    <filter-name>encode</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceRequestEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
    <init-param>
      <param-name>forceResponseEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encode</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <!--注册SpringMVC框架-->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <!--注册Spring框架,目的就是启动spring容器，使用监听器的方式-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <!--        通配符 *号，可以把applicationContext_mapper.xml和applicationContext_service.xml都注册-->
    <param-value>classpath:applicationContext_*.xml</param-value>
  </context-param>
</web-app>

10)新建实体类user
11)新建UserMapper.java接口
12)新建UserMapper.xml实现增删查所有功能,没有更新
13)新建service接口和实现类
14)新建测试类,完成所有功能的测试
15)新建控制器,完成所有功能
16)浏览器测试功能

依赖中的标签

provided 表示该依赖打包的时候不要打包进去
test 表示只在测试中用这个依赖
scope的几个属性详解：

compile：默认值他表示被依赖项目需要参与当前项目的编译，还有后续的测试，运行周期也参与其中，是一个比较强的依赖。打包的时候通常需要包含进去。
test：依赖项目仅仅参与测试相关的工作，包括测试代码的编译和执行，不会被打包，例如：junit。
runtime：表示被依赖项目无需参与项目的编译，不过后期的测试和运行周期需要其参与。与compile相比，跳过了编译而已。例如JDBC驱动，适用运行和测试阶段。
provided：打包的时候可以不用包进去，别的设施会提供。事实上该依赖理论上可以参与编译，测试，运行等周期。相当于compile，但是打包阶段做了exclude操作。
system：从参与度来说，和provided相同，不过被依赖项不会从maven仓库下载，而是从本地文件系统拿。需要添加systemPath的属性来定义路径。

分页小技巧

如何显示某一页的数据 (当前页码-1)*每页的条数
总共有多少页：总数据数 %每页条数，如果是整除，则总页数就等于总数据数 /每页条数；
如果不整除，则总页数等于总数据数 /每页条数 +1

其次还需要注意的是：页码page的类型尽量用封装类型Integer，而不用int；因为int的默认值是0，而0有可能是我们传过来的页码；如果用Integer判空就可以用是否为null，而不用0来判空

@RequestMapping("/selectUserPage")
public List<User> selectUserPage(String userName,String userSex,Integer page){
    //根据页码计算起始行
    int startRow = 0;
    if(page != null){
        startRow = (page-1) * PAGE_SIZE;
    }
    
    return userService.selectUserPage(userName,userSex,startRow);
}

抓娃男孩

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC入门笔记

SpringMVC1.什么是SpringMVC它是基于MVC开发模式的框架,用来优化控制器.它是Spring家族的一员.它也具备IOC和AOP.2.什么是MVC?它是一种开发模式,它是模型视图控制器的简称.所有的web应用都是基于MVC开发.M:模型层,包含实体类,业务逻辑层,数据访问层V:视图层,html,javaScript,vue等都是视图层,用来显现数据C:控制器,它是用来接收客户端的请求,并返回响应到客户端的组件,Servlet就是组件3.ssm框架优化的方向4.SpringM
复制链接

扫一扫