SpringMVC学习笔记

2022/2/15 6:11:51

编程Tag： string 视图 return XML 笔记 springMvc 学习 Hello public

本文主要是介绍SpringMVC学习笔记，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1、MVC概念

模型 Model（JavaBean、DAO、Service）
视图 View（JSP）
控制器 Controller（Servlet）

2、Spring MVC 执行原理

DispatcherServlet 表示前置控制器，是整个 SpringMVC 的控制中心。用户发出请求，DispatcherServlet 接收请求并拦截请求。
- 我们假设请求的url为 : http://localhost:8080/SpringMVC/hello
- 如上url拆分成三部分:
  - http://localhost:8080 服务器域名
  - SpringMVC 部署在服务器上的web站点（项目名）
  - hello 表示控制器
- 通过分析，如上url表示为:请求位于服务器 localhost:8080 上的 SpringMVC 站点的 hello 控制器。
HandlerMapping 为处理器映射。DispatcherServlet 调用 HandlerMapping；HandlerMapping 根据请求 url 查找 Handler。
HandlerExecution 表示具体的 Handler ,其主要作用是根据url查找控制器，如上 url 被查找控制器为: hello。
HandlerExecution 将解析后的信息传递给 DispatcherServlet，如解析控制器映射等。
HandlerAdapter 表示处理器适配器，其按照特定的规则去执行 Handler。
Handler 让具体的 Controller 执行。
Controller 将具体的执行信息返回给 HandlerAdapter，如 ModelAndView。
HandlerAdapter 将视图逻辑名或模型传递给 DispatcherServlet 。
DispatcherServlet 调用视图解析器（ViewResolver）来解析 HandlerAdapter 传递的逻辑视图名。
视图解析器将解析的逻辑视图名传给 DispatcherServlet 。
DispatcherServlet 根据视图解析器解析的视图结果，调用具体的视图。
最终视图呈现给用户。

3、创建 Spring MVC 项目

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.14</version>
</dependency>

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

    <!-- 配置DispatcherServlet:这个是SpringMVC的核心，也称为：请求分发器，前端控制器 -->
    <servlet>
        <servlet-name>springmvc</ servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>\

        <!-- DispatcherServlet 要绑定 Spring 的配置文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        
        <!-- 启动级别: 1 。数字越小，启动越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--
        在SpringMVC 中，/ 和 /* 存在区别
        / : 只匹配所有的请求，不会去匹配jsp页面
        /*: 匹配所有的请求,包括jsp页面
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

3.1 xml配置版（用于理解原理，一般不使用）

<!-- Spring 配置文件 -->
<!-- springmvc-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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 处理器映射器 -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

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

    <!-- 视图解析器：模板引擎 ThymeLeaf Freemarker... -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" 
          id="InternalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- BeanNameUrlHandlerMapping: bean -->
    <bean id="/hello" class="com.kuang.controller.HelloController"/>

</beans>

3.2 注解版（一般用这个）

步骤如下：

新建一个 web 项目

导入相关 jar 包

编写 web.xml ，注册 DispatcherServlet

编写 SpringMVC 配置文件

接下来就是去创建对应的控制类，Controller

最后完善前端视图和 Controller 之间的对应

测试运行调试

使用 SpringMVC 必须配置的三大件:
处理器映射器、处理器适配器、视图解析器

通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的 xml 配置

<!-- Spring 配置文件 -->
<!-- springmvc-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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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
                           http://www.springframework.org/schema/mvc
                           https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自动扫描包，让指定包下的注解生效，由 IOC 容器统一管理 -->
    <context:component-scan base-package="controller"/>
    
    <!-- 让 Spring MVC 不处理静态资源.css .js .html .mp3 .mp4 -->
    <mvc:default-servlet-handler />
    
    <!--
      支持mvc注解驱动
      Spring中一般采用 @RequestMapping 注解来完成映射关系
      要想使 @RequestMapping 注解生效必须向上下文中注册 DefauLtAnnotationHandLerMapping
      和一个 AnnotationMethodHandLerAdapter 实例
      这两个实例分别在类级别和方法级别处理。
      而annotation-driven配置帮助我们自动完成上述两个实例的注入。
     -->
    <mvc:annotation-driven />
    
    <!-- 视图解析器：模板引擎 ThymeLeaf Freemarker... -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" 
          id="InternalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>
    
</beans>

@Controller
@RequestMapping("/hello")
public class Hellocontroller {
    
    //	localhost:8080/hello/h1
    @RequestMapping("/h1")
    public String hello(Model model) {
        //封装数据
        model.addAttribute( s: "msg", o: "Hello,SpringMVCAnnotation! ");
        return "hello"; //会被视图解析器处理，直接跳转到视图hello.jsp;
    }
}

<!-- hello.jsp -->
<%@page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
    </head>
    <body>
        ${msg}
    </body>
</html>

4、RESTful 风格

概念

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。
基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

功能

资源：互联网所有的事物都可以被抽象为资源.
资源操作：使用 POST、DELETE、PUT、GET，使用不同方法对资源进行操作。
分别对应添加、删除、修改、查询。

传统方式操作资源：通过不同的参数来实现不同的效果！方法单一，Post和 Get

http://127.0.0.1/item/queryltem.action?id=1 查询，GET
http://127.0.0.1/item/saveltem.action 新增，POST
http://127.0.0.1/item/updateltem.action 更新，POST
http://127.0.0.1/item/deleteltem.action?id=1 删除，GET或POST

使用RESTful操作资源：可以通过不同的请求方式来实现不同的效果！请求地址一样，但是功能可以不同！

http://127.0.0.1/item/1 查询，GET
http://127.0.0.1/item 新增，POST
http://127.0.0.1/item 更新，PUT
http://127.0.0.1/item/1 删除，DELETE

原来的风格：

@Controller
public class RestFulController {
    //原来的：http://localhost:8080/add?a=1&b=2
    @RequestMapping("/add")
    public String test1(int a,int b,Model model){
        int res = a + b;
        model.addAttribute( "msg" , "结果为" + res );
        return "test";
    }
}

RESTful风格：

@Controller
public class RestFulController {
    //RestFul：http://localhost:8080]add/a/b
    //示例请求：http://localhost:8080]add/1/2
    @RequestMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a, @PathVariable int b, Model model){
        int res = a + b;
        model.addAttribute( "msg" , "结果为" + res );
        return "test";
    }
}

5、@RequestMapping 方法级别的注解变体

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
使用以上组合注解，可对请求的方法做出限制（使用哪种方法才能执行此段代码）

示例：

@Controller
public class RestFulController {
    //@RequestMapping(path = "/add/{a}/{b}", method = RequestMethod.GET) 等价于
    @GetMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a, @PathVariable int b, Model model){
        int res = a + b;
        model.addAttribute( "msg" , "结果为" + res );
        return "test";
    }
}

6、转发与重定向

通过SpringMVC来实现转发和重定向 — 有视图解析器

重定向，不需要视图解析器，本质就是重新请求一个新地方嘛，所以注意路径问题。

可以重定向到另外一个请求实现。

在重定向路径名前添加 redirect:

@Controller
public class ResultspringMVC2 {
    
    @RequestMapping( "/rsm2/t1" )
    public String test1() {
        //转发
        return "test";	//转发时，存在视图解析器的话，直接写视图名，无需后缀
    }
    
    @RequestMapping( "/rsm2/t2" )
    public String test2() {
        //重定向
        return "redirect:/index.jsp" ;	//重定向时，写好路径名
        // return "redirect:hello.do" ; // hello.do为另一个请求
    }
}

7、接收请求参数

7.1 参数为基本数据

重点：在方法参数前添加注解 @RequestParam

提交数据：http://localhost:8080/hello?username=wjd

处理方法︰

//@RequestParam( "username" ) : username提交的域的名称
@RequestMapping( "/hello" )
public String hello(@RequestParam( "username" ) String name) {
    System.out.println( name ) ;
    return "hello" ;
}

后台输出：wjd

7.2 参数为对象

提交数据：http://localhost:8080/mvc04/user?name=kuangshen&id=1&age=15

处理方法︰

@RequestMapping( "/user" )
public String user ( User user ) {
    System.out.println(user);
    return "hello" ;
}

后台输出：User { id=1,name= 'kuangshen', age=15 }

说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

8、数据回显

8.1 Model

@RequestMapping( "/ct2/hello" )
public String hello(@RequestParam( "username" ) String name, Model model){
    //封装要显示到视图中的数据
    //相当于req.setAttribute( "name", name);
    model.addAttribute( "msg", name ) ;
    System.out.println(name);
    return "test";
}

8.2 ModelMap

@RequestMapping( "/ct2/hello" )
public String hello(ModelMap model){
    model.addAttribute( "msg", name ) ;
    return "test";
}

8.3 ModelAndView

public class ControllerTest1 implements Controller {
    public ModelAndView handleRequest(){
        //返回一个模型视图对象
        ModelAndview mv = new ModelAndView();
        mv.addObject ( "msg", "controllerTest1" );
        mv.setViewName ( "test" );
        return mv;
    }
}

使用区别：

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于 Model 对象的操作和理解。
ModelMap 继承了 LinkedHashMap ，除了实现了自身的一些方法，同样的继承 LinkedHashMap 的方法和特性。
ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

9、乱码问题

9.1 响应返回乱码

在 web.xml 中配置 Spring MVC 的乱码过滤器

<!-- web.xml -->
<!-- 配置SpringMVC的乱码过滤器 -->
<filter>
    <filter-name>encoding</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>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <!-- 这里一定要用 /* 才能过滤所有请求，如果用 / 会有个别的请求(jsp页面的请求)无法过滤 -->
    <url-pattern>/*</url-pattern>
</filter-mapping>

上面这种过滤器，能够解决POST请求的乱码问题，对于GET请求，还是会乱码

实在不行用这种：

@RequestMapping(path = "/test", produces = "application/json; charset=utf-8")

9.2 JSON输出乱码

在 springmvc-servlet.xml 中配置 mvc:annotation-driven

<!-- Spring 配置文件 springmvc-servlet.xml -->
<!-- JSON乱码问题配置 -->
<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8" />
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false" />
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

10、常用注解

@Controller、@RequestMapping

@Controller
public class TestController {
    @RequestMapping("/01")
    public String test() {
        return "已经进入了test方法";
    }
}

@PathVariable（URL路径段作为参数）

@Controller
public class RestFulController {
    @RequestMapping("/add/{a}/{b}")
    public String test1(@PathVariable String a, @PathVariable String b, Model model){
        model.addAttribute( "msg" , "结果为" + a + b );
        return "test";
    }
}

@RequestParam（设置GET/POST请求参数名）

@RequestMapping( "/ct2/hello" )
public String hello(@RequestParam( "username" ) String name, Model model){
    //封装要显示到视图中的数据
    //相当于req.setAttribute( "name", name);
    model.addAttribute( "msg", name ) ;
    System.out.println(name);
    return "test";
}

@ResponseBody

当某一方法String返回值不想经过视图解析器时，在方法名上方使用此注解

@RestController

当控制器中的所有方法均不想经过视图解析器时，使用此注解

@Controller
public class TestController {
    @ResponseBody
    @RequestMapping("/01")
    public String test() {
        return "已经进入了test方法";
    }
}

//等价于

@RestController
public class TestController {
    @RequestMapping("/01")
    public String test() {
        return "已经进入了test方法";
    }
}

11、拦截器

在applicationContext.xml中添加配置

<!-- applicationContext.xml -->
<!-- 拦截器配置 -->
<mvc:interceptors>
    <mvc:interceptor>
        <!-- ** 包括这个请求下面的所有的请求 -->
        <mvc:mapping path="/**"/>
        <bean class="com.kuang.config.MyInterceptor" />
    </mvc:interceptor>
</mvc:interceptors>

编写拦截器类

package config;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor implements HandlerInterceptor {

    /*
        return true;    执行下一个拦截器，放行
        return false;   不执行下一个拦截器
     */

    @Override
    public boolean preHandle( HttpServletRequest request, HttpServletResponse response, Object handler ) throws Exception {
        return HandlerInterceptor.super.preHandle( request, response, handler );
    }

    @Override
    public void postHandle( HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView ) throws Exception {
        HandlerInterceptor.super.postHandle( request, response, handler, modelAndView );
    }

    @Override
    public void afterCompletion( HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex ) throws Exception {
        HandlerInterceptor.super.afterCompletion( request, response, handler, ex );
    }
}

12、文件上传与下载

在applicationContext.xml中添加配置

<!-- applicationContext.xml -->
<!-- 文件上传配置 -->
<bean id="multipartResolver" class="org.springframework. web.multipart.commons.CommonsMultipartResolver">
    <!-- 请求的编码格式，必须和JSP的pageEncoding属性一致，以便正确读取表单的内容，默认为IS0-8859-1 -->
    <property name="defaultEncoding" value="utf-8"/>
    <!-- 上传文件大小上限，单位为字节(10485760=10M) -->
    <property name="maxUploadSize" value="10485760"/>
    <property name="maxInMemorySize" value="40960"/>
</bean>

编写文件控制器类

@RequestMapping( "/upload2" )
// @RequestParam("file")将 name=file 控件得到的文件封装成 CommonsMultipartFile 对象
// 批量上传 CommonsMultipartFile 则为数组即可
public String fileUpload(@RequestParam("file") CommonsMultipartFile file, HttpservletRequest request) throws IOException {
    //上传路径保存设置
    String path = request.getServletContext().getRealPath( "/upload" );
    File realPath = new File(path); 
    if (!realPath.exists()){
        realPath.mkdir();
    }
    //上传文件地址
    System.out.println("上传文件保存地址:"+realPath);
    //通过CommonsMultipartFile的方法 transferTo() 直接写文件
    file.transferTo(new File( realPath +"/"+ file.getOriginalFilename()));
    return "redirect:/index.jsp";
}

13、SSM整合

13.1 依赖导入

<!-- pom.xml -->
<dependencies>
    <!--Junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <!--数据库驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <!--数据库连接池:c3p0: dbcp-->
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.5</version>
    </dependency>
    <!-- Servlet-JSP -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <!--Mybatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.2</version>
    </dependency>
    <!--Spring-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
</dependencies>

13.2 静态资源导出问题

<!-- pom.xml -->
<build>
    <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>

13.3 各类配置文件

13.3.1 MyBatis配置文件

mybatis-config.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>

    <!-- 配置数据源交给 Spring 去做 -->

    <typeAliases>
        <package name="pojo"/>
    </typeAliases>

    <mappers>
        <mapper class="mapper.UserMapper"/>
    </mappers>

</configuration>

13.3.2 Spring配置文件

applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <import resource="spring-dao.xml"/>
    
</beans>

db.properties 必须加 jdbc. 这个前缀，不然报错

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=false
jdbc.username=root
jdbc.password=

spring-dao.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">

    <!-- 1.关联数据库配置文件 -->
    <context:property-placeholder location="classpath:db.properties"/>

    <!-- 2.连接池
        dbcp:半自动化操作，不能自动连接
        c3p0:自动化操作（自动化的加载配置文件，并且可以自动设置到对象中!)
        druid : hikari
    -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}" />
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

        <!-- c3p0连接池的私有属性 -->
        <property name="initialPoolSize" value="10"/>
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!-- 关闭连接后不自动commit -->
        <property name="autoCommitOnClose" value="false" />
        <!-- 获取连接超时时间 -->
        <property name="checkoutTimeout" value="10000" />
        <!-- 当获取连接失败重试次数 -->
        <property name="acquireRetryAttempts" value="2"/>

    </bean>

    <!-- 3.sqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 绑定Mybatis配置文件 -->
        <property name="configLocation" value="classpath:mybatis-config.xml" />
        <property name="mapperLocations" value="classpath:dao/*.xml"/>
    </bean>

    <!-- 4.配置dao接口扫描包,动态的实现了Dao接口可以注入到Spring容器中! -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <!-- 要扫描的dao包 -->
        <property name="basePackage" value="dao" />
    </bean>

</beans>

注意事项：

如果 Mapper.xml 与 Mapper.class 在同一个包下且同名，Spring 中 MapperScannerConfigurer 扫描 Mapper.class 的同时会自动扫描同名的 Mapper.xml 并装配到 Mapper.class 。
如果 Mapper.xml 与 Mapper.class 不在同一个包下或者不同名，就必须使用配置 mapperLocations 指定 mapper.xml 的位置。（如idea中 maven 默认不打包java文件夹下的xml文件,未在pom.xml中配置resource的情况下)
此时spring是通过识别mapper.xml中的
<mapper namespace=“com.hhtc.mapper.xxMapper”"> namespace的值来确定对应的Mapper.class的。

13.3.3 Spring MVC 配置文件

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:mvc="http://www.springframework.org/schema/mvc"
       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/mvc
                           http://www.springframework.org/schema/mvc/spring-mvc.xsd
                           http://www.springframework.org/schema/context
                           https://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 1.注解驱动 -->
    <mvc:annotation-driven/>
    <!-- 2.静态资源过滤 -->
    <mvc:default-servlet-handler/>
    <!-- 3.扫描包: controller -->
    <context:component-scan base-package="controller" />
    <!-- 4.视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

这篇关于SpringMVC学习笔记的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！