万字大章学习SpringMVC

最新推荐文章于 2022-03-30 17:27:26 发布

月下赶路人

最新推荐文章于 2022-03-30 17:27:26 发布

阅读量673

点赞数

分类专栏： javaEE 文章标签： mvc java spring mybatis

本文链接：https://blog.csdn.net/Lotus_dong/article/details/123058543

版权

javaEE 专栏收录该内容

21 篇文章 1 订阅

订阅专栏

SpringMVC

首先我们了解一下经典的MVC模式，MVC全称Model View Controller，M指业务模型和数据模型，V指用户界面，C指控制器。使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。Spring MVC属于SpringFrameWork的后续产品。

SpringMVC是Spring框架的一个模块，SpringMVC和Spring无需通过中间整合层进行统一整合，已经融合在Spring Web Flow里面。SpringMVC是一个基于MVC的web框架，方便前后端进行数据的传输。SpringMVC拥有控制器，接收外部请求，解析参数传给服务层。

MyBatis解决了java代码和sql语句之间的耦合，代替了数据持久层；Spring解决了业务层和其它各层之间的耦合，优化了service层；SpringMVC解决了java代码和servlet之间的耦合，代替了servlet，SpringMVC本质还是Servlet，实现了对Servlet解耦。

SpringMVC运行流程

	我们在使用Servlet来完成web项目时，我们通过Servlet来处理用户页面和数据库之间的数据交互，那时候我们所有的Servlet层代码都需要我们自己去写入，并且会有大量的“重复”代码，严重降低了我们开发的效率，使我们不能专注于业务，SpringMVC就可以很好的为我们解决这一问题。

在这里插入图片描述

用户向服务器发送请求，请求被Spring前端控制器DispatcherServlet捕获；
前端控制器DispatcherServlet接收到请求后，调用映射处理器HandlerMapping。处理器HandlerMapping根据请求的url找到处理该请求的处理器Handler（即Controller），将处理器Handler返回给前端控制器DispatcherServlet。
DispatcherServlet根据获得的Handler，选择一个合适的HandlerAdapter（处理器适配器）。在填充Handler的入参过程中，根据配置，Spring会做出一些额外的工作：

（1）HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应消息。

（2）数据转换：对请求消息进行数据转换。如String转换为Integer、Double等。

（3）数据格式化：对请求消息进行数据格式化。如将字符串转换为格式化数字或格式化日期等等。

（4）数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中。
Handler控制器执行完毕后，会向DispatcherServlet返回一个ModelAndView对象。
根据返回的ModelAndView，选择一个适合的ViewResolver视图解析器（必须是已经注册到Spring中的视图解析器）返回给DispacherServlet；
ViewResolver结合Model和View来渲染视图；
将渲染后的结果响应给客户端。

SpringMVC环境搭建

进行web开发需要提前配置好Tomcat

倒入SpringMVC的相关jar

<!--SpringMVC依赖的jar包-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

<!--加servlet-->
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.0</version>
    <scope>provided</scope>
</dependency>

如果使用jsp的el表达式，还需要导入jstl的jar包

<!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

配置DispatcherServlet

DispatcherServlet是从HttpServlet中继承而来。所以它是一个标准的Servlet，因此我们需要在web.xml文件中进行配置，使它在启动时加载Spring配置文件。

在web.xml文件中配置：

	<!--配置spring核心请求分发的的DisPatcherServlet-->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <!--把Spring的配置文件交给contextConfogLocation-->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring.xml</param-value>
        </init-param>
        <!--服务器启动时就初始化DispatcherServlet和启动 spring-->
        <load-on-startup>0</load-on-startup>
    </servlet>
    <!--
        请求映射
        所有的请求都会进入DispatcherServlet(分发器)
    -->
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

开启SpringMVC注解

<!--开启spring注解扫描-->
<context:component-scan base-package="com.cwd.ssm"></context:component-scan>

<!--开启SpringMVC注解功能-->
<mvc:annotation-driven></mvc:annotation-driven>

配置视图解析器

在Spring.xml文件中配置视图解析器

<!--配置视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
    <!--控制器返回的所有视图界面的prefix（前缀）都要为value-->
    <property name="prefix" value="/WEB-INF/pages/"></property>
    <!--控制器返回的所有视图界面的suffix（后缀）都要为value-->
    <property name="suffix" value=".jsp"></property>
</bean>

控制器类的搭建

我们使用@Controller注解标签标记SpringMVC的Controller对象，即控制器类。同时，我们也要使用RequestMapping注解来标记请求地址映射，可用在类或方法上。

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;


@Controller//扫描到这个类后交给IOC管理,用于创建对象,默认是单例的,多线程情况下线程不安全
@RequestMapping(path = "/user")//指定一个映射的地址,属性为value或path都一样,可以指定多个,
public class UserController {

    @RequestMapping(path = "/toLogin")//指定请求方式
    public ModelAndView toLogin() {
        System.out.println("toLogin");
        ModelAndView mv = new ModelAndView("login");;
        return mv;
    }

}

这时当我们要访问toLogin（）方法是的路径就是/user/toLogin

SpringMVC的使用

请求转发

SpringMVC默认响应时使用请求转发方式，返回值可以是ModelAndView，控制器处理方法的返回值如果为ModelAndView，则其即包含视图信息，也包含模型数据信息。如果返回String，可以将数据封装到一个Model对象中，直接返回字符串格式的视图名即可。

返回值为ModelAndView时，相应数据设置：

（1）添加模型数据：addObject（String attributeName，Object attributeValue）

（2）设置视图：void setViewName（String viewName）

//返回ModelAndView 
@GetMapping(path = "/toAddUser")
 public ModelAndView toAddUser(HttpSession session) {
     TUser user = (TUser) session.getAttribute("user");
     Integer communityId = user.getId();
     ModelAndView mv = new ModelAndView("userManage/addUser");
     List<TDept> depts = deptService.toDeptList(communityId);
     mv.addObject("depts", depts);
     return mv;
 }

//返回String
@GetMapping(path = "/toUpdate")
public String toUpdateUser(HttpServletRequest request, String id) {
    User user = userService.toUpdateUser(id);
    request.setAttribute("user", user);
    List<Role> roles = userService.findRoles();
    request.setAttribute("roles", roles);
    return "updateUser";
}

视图解析

我们在controller里面经常这样return一个ModelAndView，DisPatcherServlet靠视图解析器把viewName解析为/jsp/viewname.jsp 常用的视图解析器：InternalResourceViewResolver，其实InternalResourceViewResolver的工作很简单：在视图逻辑名前加上prefix（前缀），后面加上suffix（后缀）；前端控制器最终转发到/jsp/viewname.jsp。
配置视图解析器

<!--视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
    <property name="prefix" value="/jsp/"></property>
    <property name="suffix" value=".jsp"></property>
</bean>

接收请求

@Controller

Spring配置中指定了自动扫描的basepackage后，Spring会扫描这些包以及子包中的使用了@Controller标识的类，然后将类加入到Spring IOC容器中，注入依赖。需要注意的是这个bean在Spring IOC容器中是单例的，每次请求到来的时候，使用的都是同一个bean对象。

@RequestMapping

这个标签的作用就是与请求匹配，如果匹配上了，所修饰的方法才会被执行。这里需要注意两个属性，一是value/path，一是method。value是path的别名，都指请求的路径，类型是一个String[]，也就是说它可以匹配多个请求路径。method指的是请求的方法，如GET、POST。

只有当前请求与@RequestMapping上指定的属性都匹配的时候，才会执行它标注的方法。假定应用的上下文路径为"http://localhost:9090/"，那么@RequestMapping（path = “/user”）请求的路径就是"http://localhost:9090/user"，请求方式没有限制，既可以是GET，也可以是POST。

@RequestMapping（path = “/user”，method = RequestMethod.GET）请求的路径就是"http://localhost:9090/user"，请求方式只能是GET。它等价于GETMapping（path = “/user”）。同理@RequestMapping（path = “/user”，method = RequestMethod.POST）也等价于POSTMapping（path = “/user”）。

获取请求数据
我们编写处理器方法的目的，就是为了处理客户端提交的数据，而客户端的提交时按照HTTP协议报文格式来提交的，下面我们看一下常见的HTTP POST提交的报文来理解报文的各个部分与处理器方法参数的对应关系：

（1）请求方法：对应到@ReuqestMapping中的method。

（2）请求URI：前部分是项目根路径，后面部分对应@RequestMapping中的value/path。

（3）请求头：比如获取User-Agent中的值则使用@RequestHeader（“User-Agent”）。

（4）请求参数：比如获取name参数的值，使用@RequestParam（“name”）来获取。

@Controller 
@RequestMapping("/students")
public class StudentController { 					
	@RequestMapping(value="/create",method=RequestMethod.POST) 
	public String create( @RequestParam("name") String name, 
						  @RequestParam("age") Integer age, 
						  @RequestHeader("User-Agent") String userAgent){ 
		return null; 
    }
}

按照上面代码的方式就可以获取到参数值，但是如果请求参数的名称与处理器中参数名相同时，那我们可以选择省略@RequestParam绑定，如：

@Controller 
@RequestMapping("/students")
public class StudentController { 					
	@RequestMapping(value="/create",method=RequestMethod.POST) 
	public String create( String name, Integer age, 
						  @RequestHeader("User-Agent") String userAgent){ 
		return null; 
    }

参数列表中还可以直接内置HttpServletRequest，HttpSession，HttpServletResponse等对象。

重定向

控制器方法返回字符串类型的值会被当成逻辑视图名处理，如果返回的字符串中带redirect：前缀时，SpringMVC会对它们进行特殊处理：将redirect：当成指示符，其余字符串作为URL处理。如return “redirect:/page/student/update.jsp”；

过滤静态资源文件

<!--放行过滤静态资源文件请求-->
<mvc:default-servlet-handler/>

当DispatcherServlet的url配置为/时，我们需要在Spring.xml文件中加入此配置，可以访问静态资源。例如.jpg、.js、.css带有后缀名的文件。如果不加此配置，我们的网页就不能引入静态文件资源，会导致网页元素缺失。配置了之后就会在SpringMVC上下文中定义一个org.springframework.web.servlet.resource.DefaultServletHttpRequestHander，它能够对进入DispacherServlet中的URL进行筛查。如果是静态资源请求，就将请求转由Web应用服务器默认的Servlet处理，如果不是静态资源请求，才会由DispacherServlet继续处理。

中文乱码处理

我们在提交请求的时候，如果输入的是中文就会产生乱码。解决的方法是添加一个过滤器，为request对象设置编码集。SpringMVC中为我们提供了这个过滤器，只需要在web.xml中配置好即可：

<!--springMVC编码过滤器-->
<filter>
    <filter-name>encodingFilter</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>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

Ajax返回json

@responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式后，写入到response对象的body去，通常用来向异步请求返回JSON数据。需要注意的是，在使用此注解之后不会再走视图处理器，而是直接向数据写入到输入流中，它的效果等同于通过response对象输出指定格式的数据。

添加jackson的jar包

<!--添加json相关jar包 jackson 将java对象转为json格式-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.1</version>
</dependency>

 @ResponseBody
 @RequestMapping(path = "/checkAccount")
 public Integer checkAccount(String account) {
     User user = userService.checkAccount(account);
     if (user != null) {
     	return 1;
     } else {
     	return 0;
     }
 }
 //也可以直接返回对象或对象集合,jackson会自动转换为JSON格式

文件上传

首先我们要导入文件上传下载所需的jar文件

<!--上传/下载文件时必须依赖apache提供的jar包-->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>

配置文件解析器, 在springMVC.xml文件中

<!--
    文件解析器
    maxUploadSize:编码最大的上传的数量
-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="defaultEncoding" value="utf-8"></property>
    <property name="maxUploadSize" value="10485760"></property>
</bean>

设置文件上传的表单属性

（1）method=“post”

（2）enctype=“multipart/form-data” 以二进制形式提交文件数据时，在控制器中不能正常接收，spring框架可以结合apache的文件上传组件，对二进制的数据进行封装，我们就可以在控制器中接收到想要的数据。

（3）accept=".jpg,.png" 限制选择文件时的后缀。

<form action="upLoad" method="post" enctype="multipart/form-data" target="_top">
    <table>
    	<tr>
            <td>描述&nbsp;&nbsp;&nbsp;&nbsp;</td>
            <td>
                <input type="text" name="desc" value="">
            </td>
        </tr>
        <tr>
            <td>头像&nbsp;&nbsp;&nbsp;&nbsp;</td>
            <td>
                <input type="file" name="fileName" accept=".jpg,.png" value="">
            </td>
        </tr>
        <tr align="center">
            <td colspan="2">
                <input type="submit" value="上传">
            </td>
        </tr>
    </table>
</form>

设置控制器类标签

/*
    上传文件(图像)
    CommonsMultipartFile接收客户端传输的二进制文件,由SpringMVC和apache的文件上传组件解析后的流
*/
@PostMapping(path = "/upLoad")
public String upLoad(@RequestParam("fileName") CommonsMultipartFile file,
String desc,
HttpSession session) {
    try {
        User user = (User) session.getAttribute("user");
        file.getName();//前端设置的文件name 如fileName
        //获取文件原始名 如libai.jpg
        String OriginalFilename = file.getOriginalFilename();
        //获取文件类型
        String FileType = file.getContentType();
        //获取输入流对象
        InputStream FileStream = file.getInputStream();
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

拦截器

SpringMVC定义了拦截器接口HandlerInterceptor，该接口定义了三个方法，这三个方法的调用时在SpringMVC框架内部完成的，调用这三个方法的时候，其参数值也是从框架内部传递进来的。拦截器主要是针对要进入Controller的请求。

boolean preHandle

预处理方法，实现处理器方法的预处理，就是在处理器方法执行之前这个方法会被执行，相当于拦截了处理器方法，框架会传递请求和响应对象给该方法，第三个参数被拦截的处理器方法。如果preHandle方法返回true表示继续流程，返回flase表示流程中断，不会继续调用其它的拦截器或处理器方法，此时需要通过response来响应。

void postHandle

后处理方法，实现处理器方法的后处理，就是在处理器方法调用完成，但在渲染视图之前，该方法被调用，此时我们可以通过modelAndView（模型和视图对象）对模型数据进行处理或对视图进行处理。

afterCompletion

整个请求处理完毕，在视图渲染完毕时该方法被执行。

public class TestInterceptor implements HandlerInterceptor {
    /*
        当请求到达控制器前被执行 
    */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("之前执行");
        return false;
    }

    /*
        控制器方法执行之后执行 
    */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("控制器方法执行之后执行");
    }

    /*
        整个请求结束后执行 
    */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("请求结束后执行");
    }
}

在Spring.xml中注册拦截器

<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--进入拦截器的方法-->
        <mvc:mapping path="/**"/>
        <!--不包含  放行的地址-->
        <mvc:exclude-mapping path="/user/toLogin"/>
        <mvc:exclude-mapping path="/user/login"/>
        <mvc:exclude-mapping path="/static/**"/>
        <bean id="islogin" class="com.cwd.ssm.util.TestInterceptor"></bean>
    </mvc:interceptor>
</mvc:interceptors>

监听器

Servlet监听器是Servlet规范中定义的一种特殊类，用于监听ServletContext、HttpSession和ServletRequest等域对象的创建与销毁事件，以及监听这些域对象中属性发生修改的事件。

监听器分类

按监听对象分类

（1）用于监听应用程序对象（ServletContext）

（2）用于监听用户会话对象（HttpSession）

（3）用于监听请求消息对象（ServletRequest）

按监听事件分类

（1）监听对象的创建和销毁的事件监听器。

（2）监听对象属性变更（添加、修改、删除）的监听器。

监听器接口

Servlet API中定义了监听器接口，用来监听不同的事件类型。

ServletContextListener:上下文监听器;
ServletContextAttribute:上下文属性监听器;
ServletRequestListener:请求监听器;
ServletRequestAttributeListener:请求属性监听器;
HttpSessionListener:会话监听器;
HttpSessionAttribute:会话属性监听器.

配置监听器类

创建监听器类，实现监听器接口，在web.xml文件中配置监听器类。

<listener>
	<listener-class>监听器类全类名</listener-class>
</listener>

实例

监听器类

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class ObjectListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ServletContext context = sce.getServletContext();
        context.setAttribute("path", context.getContextPath());
    }
}

配置监听器类

<!--配置监听器-->
<listener>
	<listener-class>com.cwd.ssm.util.ObjectListener</listener-class>
</listener>

SpringMVC整合MyBatis–ssm全部配置文件

我把三个框架的配置文件分开，最后统一倒入到spring.xml文件进行整合

导入Spring、SpringMVC、MyBatis配置文件

<dependencies>
    <!--springMVC-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>

    <!-- mysql-connector-java -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency>

    <!-- spring-jdbc -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>

    <!-- 阿里数据源  德鲁伊-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.10</version>
    </dependency>

    <!--spring-aspects-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>


    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>provided</scope>
    </dependency>

    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>

    <!--mybatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.2</version>
    </dependency>

    <!--spring-mybatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.1</version>
    </dependency>

    <!--添加json相关jar包 jackson 将java对象转为json格式-->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.1</version>
    </dependency>

    <!--上传/下载文件时必须依赖apache提供的jar包-->
    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.3.1</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>RELEASE</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>RELEASE</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

SpringMVC.xml和web.xml文件

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

    <!--配置spring核心请求分发的的DisPatcherServlet-->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <!--把Spring的配置文件交给contextConfogLocation-->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring.xml</param-value>
        </init-param>
        <!--服务器启动时就初始化DispatcherServlet和启动 spring-->
        <load-on-startup>0</load-on-startup>
    </servlet>
    <!--
        请求映射
        所有的请求都会进入DispatcherServlet(分发器)
    -->
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--springMVC编码过滤器-->
    <filter>
        <filter-name>encodingFilter</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>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
    <welcome-file-list>
        <welcome-file>/user/toLogin</welcome-file>
    </welcome-file-list>

    <!--配置监听器-->
    <listener>
        <listener-class>com.cwd.ssm.util.ObjectListener</listener-class>
    </listener>
</web-app>

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



     <!--开启springMVC注解功能-->
     <mvc:annotation-driven></mvc:annotation-driven>

     <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
         <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
         <property name="prefix" value="/WEB-INF/pages/"></property>
         <property name="suffix" value=".jsp"></property>
    </bean>

    <!--放行过滤静态资源文件请求-->
    <mvc:default-servlet-handler/>

    <!--
    文件解析器
    maxUploadSize:编码最大的上传的数量
    -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="defaultEncoding" value="utf-8"></property>
        <property name="maxUploadSize" value="10485760"></property>
    </bean>

    <!--配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--进入拦截器的方法-->
            <mvc:mapping path="/**"/>
            <!--不包含  放行的地址-->
            <mvc:exclude-mapping path="/user/toLogin"/>
            <mvc:exclude-mapping path="/user/login"/>
            <mvc:exclude-mapping path="/static/**"/>
            <bean id="islogin" class="com.cwd.ssm.util.IsLoginInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

MyBatisConfig.xml文件（全局配置文件）、db.xml文件（数据库源配置文件）、MyBatis.xml文件

MyBatisConfig.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>

  <!--全局设置-->
  <settings>
    <setting name="logImpl" value="LOG4J"/>
    <!--驼峰命名映射-->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
    <!--开启全局的懒加载-->
    <setting name="lazyLoadingEnabled" value="true"/>
  </settings>

  <!--为java类型 设置别名-->
  <typeAliases>
    <package name="com.cwd.ssm.bean"/>
  </typeAliases>
  
</configuration>

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

    <!--
    1.管理数据库的链接
    配置DruidDataSource交给spring容器管理,spring管理数据库链接(数据源)
    -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${url}"></property>
        <property name="driverClassName" value="${driver}"></property>
        <property name="username" value="${uname}"></property>
        <property name="password" value="${passwd}start"></property>
    </bean>

    <!--
    2.配置事务管理类
    -->
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--
    3.开始注解事务管理
    -->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager"></tx:annotation-driven>

</beans>

MyBatis.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--数据库连接管理-->
    <import resource="db.xml"></import>

    <!--spring管理SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <!--导入mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatisConfig.xml"></property>
        <!--扫描所有的映射文件-->
        <property name="mapperLocations" value="classpath:mapper/*Mapper.xml"> </property>
    </bean>

    <!--扫描dao包中的所有接口  并生成接口的代理对象-->
    <bean id="mapperFactory" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.cwd.ssm.dao"></property>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"> </property>
    </bean>

</beans>

spring.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/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

     <!--开启spring注解扫描-->
     <context:component-scan base-package="com.cwd.ssm"></context:component-scan>

     <!--导入SpringMVC-->
     <import resource="springMVC.xml"></import>

     <!--导入MyBatis-->
     <import resource="mybatis.xml"></import>

</beans>

月下赶路人

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
万字大章学习SpringMVC

文章目录SpringMVCSpringMVC运行流程SpringMVC环境搭建配置视图解析器SpringMVC的使用请求转发视图解析接收请求重定向过滤静态资源文件中文乱码处理Ajax返回json文件上传拦截器监听器监听器分类监听器接口配置监听器类实例SpringMVC整合MyBatis--ssm全部配置文件SpringMVC 首先我们了解一下经典的MVC模式，MVC全称Model View Controller，M指业务模型和数据模型，V指用户界面，C指控制器。使用MVC的目的是将M和V的实现代码分
复制链接

扫一扫