文章目录

SpringMVC

SpringMVC

1 Spring MVC的简介

1.1 MVC

是一种开发模式，分层思想，使用该模式将应用分为模型层、控制层、视图层以更好的实现各层分离达到高内聚低耦合的效果

M(Model):Model层，主要指service|Dao|Model,主要用于进行业务处理,形成数据模型

V(View):视图层，主要指HTML/JS/JSP,主要用于界面展示

C(Controller):控制层，主要指Servlet,主要用于协调Model和View，用于获取请求并向页面响应的

1.2 MVC框架

它将一个应用使用MVC开发模式进行强行分离,MVC框架的核心在"控制器"，通过控制器将一个应用进行分割,并大大简化控制器的开发

struts框架，比较古老的优秀的MVC框架,属于apache的一个项目
WebWork框架,基于MVC的企业框架技术,由于webwork使用较少，但其内核优秀，后期apache对webwork进行改造，出现后期流行一时另一个MVC框架技术struts2
Struts2框架，是一个流行一时框架技术，struts2和之前的struts其实没有任何关系，只是借助于struts名气而已,属于apache的一个项目
SpringMVC框架，该框架是基于Spring的一套MVC框架技术，目前比较流行，它是springBoot所使用MVC技术

1.3 什么是SpringMVC?

SpringMVC属于Spring体系中的一个模块
SpringMVC是基于MVC的一个框架技术
SpringMVC提供了一套强大的控制器体系,通过这套控制器可以大大简化Web应用的开发，SpringMVC它将一些比较繁琐的逻辑实现了自动化处理，不在需要开发人员手动编写，如：参数自动封装、JSON自动转换等

图1 Spring体系结构图

1.4 SpringMVC工作流程

自定义核心Servlet流程图

图2 自定义核心Servlet流程图

SpringMVC工作流程图

在这里插入图片描述

图3 SpringMVC工作流程图

流程描述

① 客户端发送请求到 核心控制器(DispatcherServlet) ，根据请求的url在处理器映射器(HandlerMapper) 中找到对应Handler对象

②处理器映射器(HandlerMapper) 找到的Handler对象返回给核心控制器

③核心控制器(DispatcherServlet) 委派处理器适配器(HandlerAdapter)执行Handler

④处理器适配器(HandlerAdapter)将请求转给Handler对象执行具体业务

⑤处理器对象Handler，调用Model层进行业务处理，将结果返回给处理器适配器(HandlerAdapter),返回的结果为ModelAndView对象(Model指数据，view指视图)

⑥处理器适配器(HandlerAdapter),将ModelAndView对象返回给核心控制器

⑦核心控制器(DispatcherServlet)调用视图解析器(ViewResolver)对View进行解析,视图解析器根据核心控制器发送来的逻辑视图解析为一个物理视图并将物理视图返回给核心控制器

⑧核心控制器(DispatcherServlet)调用视图渲染器将视图渲染（将model数据加载到特定的对象如request）

⑨核心控制器(DispatcherServlet)向客户端响应

2 Spring MVC的使用

2.1 构建SpringMVC开发环境

① 新建一个基于Maven的Web应用

② 引入springMVC依赖包

servlet-api

       <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>

SpringWebMVC:

SpringMVC的核心包

导入Spring Web MVC核心包后，其他依赖包

如:aop/core/breans/context/web/expression包会自动导入

<!-- spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.25</version>
</dependency>

Jackson-databind:

是一个JSON处理包，Jackson包与SpringMVC自动绑定

SpringMVC中所使用的默认JSON处理为Jackson,无需单独设置，如果你要使用其他的

JSON库，则需要单独设置
```

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

③ 创建SpringMVC的初始化器

springMVC初始化容器
当服务器启动(tomcat)时，该类会自动创建该类包含三个初始化方法：

getRootConfigClasses():获得根配置类(spring核心配置)

getServletConfigClasses():获得springMVC配置类(针对SpringMVC配置)

可以和spring核心配置放在一起(管理不方便)

getServletConfigClasses():用于配置进入springMVC的访问路径(DispatcherServlet访问路径) "/":拦截所有请求，但排除jsp

"/*":拦截所有请求

核心配置类

public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
      
      
    /**
     * 初始化根容器配置类
     * @return
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
      
      
        return new Class[]{
      
      RootConfig.class};
    }
    /**
     * 初始化springMVC配置类
     * @return
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
      
      
        return new Class[]{
      
      MvcConfig.class};
    }
    /**
     *用于配置进入springMVC的访问路径(DispatcherServlet访问路径)           
     * @return
     */
    @Override
    protected String[] getServletMappings() {
      
      
        return new String[]{
      
      "/"};
    }
}

④ 创建相关配置类

根容器配置类

@Configuration
@ComponentScan("com.jiazhong.springmvc.service")
public class RootConfig {
    
    
}

springMVC配置类

/**
 * SpringMVC配置类
 * 实现WebMvcConfigurer接口，对springMVC进行相关配置
 * @EnableWebMvc:启用相关注解
 */
@Configuration
@EnableWebMvc
public class MvcConfig implements WebMvcConfigurer {
    
    

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
    
    
        configurer.enable();//放行静态资源
    }
}

2.2 SpringMVC的转发方式及作用域对象的使用

接2.1

⑤ 创建Controller控制器对象

转发方式

使用Controller注解后，该类就成为了一个springMVC控制器类

控制器和Servlet功能一样

控制器的每个方法都是处理独立功能的控制器

@RequestMapping:设置当前控制器的访问路径(父级路径)

在方法上使用该注解,表示设置该方法的访问路径(子级路径)

一个控制器的访问路径:父级路径/子级路径

@Controller
@RequestMapping("/demo")
public class DemoController {
    
    
    @RequestMapping("/demo01")
    public String demo01(){
    
    
        System.out.println("执行DemoController-->demo01控制器...");
        return "/index.jsp";//默认使用请求转发
    }
    @RequestMapping("/demo02")
    public String demo02(){
    
    
        System.out.println("执行DemoController-->demo02控制器...");
        return "redirect:/index.jsp";
    }
}

作用域对象的使用
springMVC中使用request对象的方式有两种:
- 1.与HttpServletRequest解耦方式
  - 在控制器方法参数加入Model参数
  - Model是一个Map集合，SpringMVC会自动将该对象添加到request对象中
  - 使用Model方式只能向request中添加获取或移除属性，不能做其他操作
- 与HttpServletRequest耦合方式
  - 在控制器方法参数加入HttpServletRequest参数，或其他参数
@SessionAttributes(“eat”):将model中的属性存到session中

@Controller
@RequestMapping("/demo01")
@SessionAttributes("eat")
public class Demo01Controller {
    
    
    @RequestMapping("/test01")
    public String test01(Model model) {
    
    
        //将数据添加到model中，请求转发时会将model中的数据添加到请求对象中，并转到页面使用
        model.addAttribute("name","小强");
     return "/index.jsp";
    }
    @RequestMapping("/test02")
    public String  test02(HttpServletRequest request, HttpServletResponse response){
    
    
        request.setAttribute("age",18);
        HttpSession session = request.getSession();
        session.setAttribute("hello","你好");
        return "/index.jsp";
    }
    @RequestMapping("/test03")
    public String test03(Model model){
    
    
        model.addAttribute("eat","吃了吗?");
        return "/index.jsp";
    }
}

3 Ajax

传统的开发，无论是重定向还是请求转发，进行页面跳转时，整个页面都会全部刷新，页面中所需要的资源都需要重新获取

AJAX技术可以在不重新加载整个页面的情况下，与服务器交换数据并更新部分网页内容。

3.1 Ajax简介

Ajax: async javascript and ~~XML~~ json(异步JavaScript和XML)

异步刷新技术

3.2 Ajax的基本使用

定义⼀个XMLHttpRequest核⼼对象
通过xmlHttpRequest.open⽅法建立与服务端的连接(指定请求方式及服务器地址)
服务端传递数据

接收返回值并处理

属性	描述
onreadystatechange	事件:请求状态改变事件当请求状态每次发生改变时，该事件对应函数都会被调用
readyState	存有XMLHttpServlet的状态。从0到4的变化。 0:请求未初始化1:服务器已建立连接2:请求已接收3:请求处理中4:请求已完成，且响应已就绪
status	200:响应成功301:资源(网页等)被永久转移到其他URL404:未找到页面500:内部服务器出错

状态码

分类	描述
1**	信息，服务器收到请求，需要请求者继续执行操作
2**	成功，操作被成功接受处理
3**	重定向，需进一步的操作以完成请求
4**	客户端错误，请求包含语法错误或无法完成请求
5**	服务器错误，服务器在处理请求的过程中发生了错误

前端代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<br>
<h2>test.jsp</h2>
用户名:<span id="user-Info"></span></br>
<button onclick="loadUserInfo()">测试</button>
<script>
    function loadUserInfo() {
        
        
        //创建XMLHttpRequest对象
        let xmlHttpRequest = new XMLHttpRequest();
        //建立于服务端的连接(指定请求方式及服务器地址)
        xmlHttpRequest.open("get", "/test01", true)
        /**
         * 注册回调函数
         * onreadystatechnge事件:请求状态改变事件
         *    当请求状态每次发生改变时，该事件对应函数都会被调用
         */
        xmlHttpRequest.onreadystatechange = function () {
        
        
            if (xmlHttpRequest.readyState == 4 && xmlHttpRequest.status == 200){
        
        
               //接受服务端回传数据
                let txt=xmlHttpRequest.responseText;
                document.getElementById("user-Info").innerHTML=txt;
            }
                }
        //发送请求
        xmlHttpRequest.send(null);
    }
</script>
</body>
</html>

后端代码

@WebServlet("/test01")
public class TestServlet extends HttpServlet {
      
      
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      
      
//        req.setAttribute("name","小明");
//        req.getRequestDispatcher("/test.jsp").forward(req,resp);
        resp.setContentType("json/application;charset=utf-8");
        //获得响应对象的输出流
        PrintWriter writer = resp.getWriter();
        writer.println("小李");
    }
}

3.3 使用Ajax处理json数据

字符串转化为json

let userJson=eval("("+userInfo+")");

前端代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body >
<script>
    function getUserInfo() {
      
      
        let xmlHttpRequest = new XMLHttpRequest();
        xmlHttpRequest.open("get", "/test02", true);
        xmlHttpRequest.onreadystatechange = function () {
      
      
            if (xmlHttpRequest.readyState == 4 && xmlHttpRequest.status == 200) {
      
      
                let userInfo=xmlHttpRequest.responseText;
                //字符串转化为json
                let userJsonArr=eval("("+userInfo+")");
               for (const user of userJsonArr){
      
      
                    console.log(user.userId,user.username,user.password);
                }
            }
        }
        xmlHttpRequest.send(null)
    }
</script>
</body>
</html>

后端代码

@WebServlet("/test02")
public class Test02Servlet extends HttpServlet {
    
    
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
    
        resp.setContentType("json/application;charset=utf-8");
        PrintWriter writer = resp.getWriter();
        List<User> userList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
    
    
            User user = new User();
            user.setUserId(10 + i);
            user.setUsername("admin" + i);
            user.setPassword("123456" + i);
            userList.add(user);
        }
        StringBuffer stringBuffer=new StringBuffer("[");
        for (User user:userList) {
    
    
            stringBuffer.append("{");
            stringBuffer.append("'userId':").append(user.getUserId()).append(",");
            stringBuffer.append("'username':'").append(user.getUsername()).append("',");
            stringBuffer.append("'password':'").append(user.getPassword()).append("'");
            stringBuffer.append("},");
        }
        stringBuffer.deleteCharAt(stringBuffer.length()-1);
        stringBuffer.append("]");
        writer.println(stringBuffer);
    }
}

3.4 使用fastjson处理json

① 引入依赖

<!-- fastjson2 -->
<dependency>
    <groupId>com.alibaba.fastjson2</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.24</version>
</dependency>

② 后端代码

@WebServlet("/test02")
public class Test02Servlet extends HttpServlet {
    
    
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
    
        resp.setContentType("application/json;charset=utf-8");
        PrintWriter writer = resp.getWriter();
        List<User> userList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
    
    
            User user = new User();
            user.setUserId(10 + i);
            user.setUsername("admin" + i);
            user.setPassword("123456" + i);
            userList.add(user);
        }
        Object o = JSON.toJSON(userList);
        writer.println(o);
    }
}

3.5 结合springMVC处理json

@ResponseBody:将方法返回值作为响应体输出到客户端

字符串

    @RequestMapping("/test01")
    @ResponseBody
    public String test01(){
    
    
        return "jack";
    }

List数组

    @RequestMapping("test02")
    @ResponseBody
    public List<User> test02(){
    
    
        List<User> userList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
    
    
            User user = new User();
            user.setUserId(10 + i);
            user.setUsername("admin" + i);
            user.setPassword("123456" + i);
            userList.add(user);
        }
        return userList;
    }

Map集合

    @RequestMapping("/test03")
    @ResponseBody
    public Map<String,String> test03(){
    
    
        Map map=new HashMap();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value3");
        map.put("key4","value4");
        return map;
    }

3.6 SpringMVC常用注解

@Configuration:表示类为一个配置类
@ComponentScan:包扫描器注解
@EnableWebMvc:开启SpringMVC默认配置注解
@Bean:标识方法的返回值为spring管理的一个Bean对象
@Controller:控制器注解
@RequestMapping:控制器访问路径注解
@ResponseBody:设置方法返回值为响应体并自动进行JSON转换注解
@RestController:@Controller+@ResponseBody两个注解组合
@SessionAttributes:设置session作用域存储的属性注解
@RequestParam("userAge"):从请求参数中获取参数名为userAge的值并复制其后的变量
@MapperScan():mybaits映射器扫描器
@Transactional:开启Spring声明式事务
@PropertySource("classpath:/db.properties"):引入外部文件
@RequestBody:在参数中使用的注解，用于解析客户端传入的payload格式的数据
@PathVariable：表示参数来自于路径地址

4 SpringMVC封装请求参数

请求一个字符串

    /**
     * 一个字符串,springMVC会将请求的参数中并进行类型转换
     * @param msg
     * @return
     */
    @RequestMapping("/test01")
    public String test01(String msg){
      
      
        System.out.println(msg);
        return msg;
    }

请求一个整型

 /**
     * 获得一个int类型参数，springMVC会将请求的参数中并进行类型转换
     * @param num
     * @return
     */
    @RequestMapping("/test02")
    public Integer test02(int num){
      
      
        System.out.println(num+10);
        return num;
    }

请求多个参数

@RequestBody:在参数中使用的注解，用于解析客户端传入的payload格式的数据

    /**
     * @RequestBody:请求参数为请求体
     * @param user
     * @return
     */
    @RequestMapping("/test03")
    public Integer test03(@RequestBody User user){
      
              System.out.println("password:"+user.getPassword()+",username:"+user.getUsername());
        return 0;
    }

路径传参

@PathVariable：表示参数来自于路径地址

  @RequestMapping("/test04/{num}")
    public Integer test04(@PathVariable int num){
      
      
        System.out.println(num+10);
        return num;
    }

数组或集合传参

    @RequestMapping("/test05")
    public Integer test05(@RequestBody List<User> user){
      
      
        System.out.println(user);
        return 0;
    }

5 Spring拦截器(Interceptor)

5.1 Spring拦截器的使用

当一个类实现了HandlerInterceptor该类就是一个拦截器

HandlerInterceptor包含三个默认的方法

①preHandler:(预处理方法)该方法在控制器之前执行(等同于Aop的前置通知)

②postHandle:(后处理方法)该方法在控制器执行之后执行(等同于Aop的后置通知)

③afterCompletion:(最后处理方法)该方法在视图渲染器渲染后执行

自定义拦截器

public class MyInterceptors implements HandlerInterceptor {
      
      
    /**
     * 预处理方法
     * @param request
     * @param response
     * @param handler  :处理器方法对象(控制器对象)
     * @return  boolean:返回为true:表示放行，执行该拦截器后的控制器或其他拦截器
     *                  返回为false:表示不放行，不执行后续组件(此时需要在拦截器中进行跳转)
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      
      
        System.out.println("MyInterceptors---->preHandle被执行....");
        return true;
    }
}

向springMVC中注册拦截器

springMVC配置类

@Configuration
@EnableWebMvc
@ComponentScan("com.jiazhong.springmvc.controller")
public class MvcConfig implements WebMvcConfigurer {
      
      
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
      
      
        configurer.enable();//放行静态资源
    }
    /**
     * 添加拦截器
     * @param registry
     */
    @Override
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
      
      
        //向springMVC添加具体拦截器
        registry.addInterceptor(new MyInterceptors())
//                .addPathPatterns("/demo02/demo01");//设置拦截路径
                .addPathPatterns("/demo02/*")//拦截demo02下所有路径
                .excludePathPatterns("/demo02/demo02")//排除不拦截的路径
                .order(11);//设置拦截器执行顺序
    } 
}

在拦截器内部直接调用处理器方法并进行结果处理

public class MyInterceptors implements HandlerInterceptor {
      
      
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      
      
        String msg = request.getParameter("msg");
        msg=msg+"000";
        //获得控制器方法对象(HandlerMethod)
        HandlerMethod handlerMethod=(HandlerMethod)handler;
        Object o = handlerMethod.getBean();
        //获得控制器方法对象
        Method method = handlerMethod.getMethod();
        //调用该方法
        Object message = method.invoke(o, msg);
        response.getWriter().println(message);
        return false;
    }
}

5.2 使用SpringMVC拦截器修改请求参数数据

自定义一个请求处理类

该类会对原始request对象进行包装，并改写里面的处理方法
该类自定义一个Map集合，表示所请求的参数，并重写相关操作
定义一个带有参数的构造方法，方法参数为HttpServletRequest对象
- HttpServletRequestWrapper是对request请求对象的处理，所以必须将HttpServletRequest对象传入

public class RequestParamWrapper extends HttpServletRequestWrapper {
    
    
    //存储request对象中所有参数
    private Map<String, String[]> paramsMap = new HashMap<>();

    /**
     * 定义一个带有参数的构造方法，方法参数为HttpServletRequest对象
     * HttpServletRequestWrapper是对request请求对象的处理，所以必须将HttpServletRequest对象传入
     *
     * @param request
     */
    public RequestParamWrapper(HttpServletRequest request) {
    
    
        //调用父类的构造方法
        super(request);
        //将request原始的参数集合转存到paramsMap中
        paramsMap.putAll(request.getParameterMap());
    }

    public RequestParamWrapper(HttpServletRequest request, Map<String, Object> extraMap) {
    
    
        //调用父类的构造方法
        this(request);
        //将request原始的参数集合转存到paramsMap中
        addParams(extraMap);
    }

    /**
     * 循环向paramMap添加参数
     *
     * @param extraMap
     */
    private void addParams(Map<String, Object> extraMap) {
    
    
        for (Map.Entry<String, Object> entry : extraMap.entrySet()) {
    
    
            //向paramMap添加一个参数
            addParam(entry.getKey(), entry.getValue());
        }
    }

    private void addParam(String name, Object value) {
    
    
        if (value instanceof String[]) {
    
    
            paramsMap.put(name, (String[]) value);
        } else if (value instanceof String) {
    
    
            paramsMap.put(name, new String[]{
    
    (String) value});
        } else {
    
    
            paramsMap.put(name, new String[]{
    
    String.valueOf(value)});
        }
    }


    /**
     * 根据参数名获得参数值
     * @param name
     * @return
     */
    public String getParameter(String name) {
    
    
        if (name == null || "".equals(name)){
    
    
            return null;
        }
        return this.paramsMap.get(name)[0];
    }

    /**
     * 根据参数名获得参数值，值为数组
     * @param name
     * @return
     */
    public String[] getParameterValues(String name){
    
    
        if (name == null || "".equals(name)){
    
    
            return null;
        }
       return this.paramsMap.get(name);
    }

    /**
     * 获得所有参数返回Map集合
     * @return
     */
    public Map<String,String[]> getParameterMap(){
    
    
        if (this.paramsMap==null||this.paramsMap.size()==0){
    
    
            return super.getParameterMap();//获得原始请求的数据
        }
        return this.paramsMap;
    }

    /**
     * 获得所有参数名
      * @return
     */
    public Enumeration<String> getParameterNames(){
    
    
        if (this.paramsMap==null||this.paramsMap.size()==0){
    
    
            return super.getParameterNames();//获得原始请求的数据
        }
        Set<String> strings = this.paramsMap.keySet();
        return Collections.enumeration(strings);
    }
}

过滤器传递包装好的请求和响应

@WebFilter("/*")
public class RequestWrapperFilter implements Filter {
    
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    
    
    }
    @Override
    public void doFilter(ServletRequest servletRequest,
                         ServletResponse servletResponse,
                         FilterChain filterChain) throws IOException, ServletException {
    
    
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        //创建自定义请求封包对象
        RequestParamWrapper requestWrapperFilter=new RequestParamWrapper(request);
        //将包装好的请求和响应传递到下一个对象
        filterChain.doFilter(requestWrapperFilter,response);
    }

    @Override
    public void destroy() {
    
    
    }
}

拦截器调用包装好的请求和响应

   public class MyInterceptors implements HandlerInterceptor {
    
    
       @Override
       public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
           String msg = request.getParameter("msg");
           //检测request是否为包装后的请求
           if (request instanceof RequestParamWrapper requestParamWrapper){
    
    
               //将request对象还原为包装后的请求
               requestParamWrapper.addParam("msg",msg+"10010");
           }
           return true ;
       }
   }

6 SSM整合

Spring+SpringMVC+myBatis

6.1 引入依赖

SpringWebMVC

SpringMVC的核心包

导入Spring Web MVC核心包后，其他依赖包

如:aop/core/breans/context/web/expression包会自动导入

<!-- spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.25</version>
</dependency>

servlet-api

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
</dependency>

mysql

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.28</version>
</dependency>

mybatis

<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis</artifactId>
   <version>3.5.10</version>
</dependency>

mybatis-spring

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

druid

<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>druid</artifactId>
   <version>1.2.14</version>
</dependency>

spring-jdbc

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

spring-tx

spring事务管理包

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-tx</artifactId>
   <version>5.3.25</version>
</dependency>

jackson Databind

可以使用fastjson2替换

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

pagehelper

基于MyBatis的分页插件包

<dependency>
   <groupId>com.github.pagehelper</groupId>
   <artifactId>pagehelper</artifactId>
   <version>5.3.2</version>
</dependency>

log4j2

<dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId>
   <version>1.2.17</version>
</dependency>

6.2 创建SpringMVC的初始化器

核心配置类

public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
      
      
    @Override
    protected Class<?>[] getRootConfigClasses() {
      
      
        return new Class[]{
      
      RootConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
      
      
        return new Class[]{
      
      MVCConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
      
      
        return new String[]{
      
      "/"};
    }
}

根容器配置类

配置dateSource

@Configuration
@ComponentScan("com.jiazhong.ssm.service")
@MapperScan("com.jiazhong.ssm.mapper")
@PropertySource("classpath:db.properties")
public class RootConfig {
      
      
    @Value("${jdbc.driverClassName}")
    private  String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    @Value("${druid.initialSize}")
    private Integer initialSize;
    @Value("${druid.maxActive}")
    private Integer maxActive;
    @Value("${druid.minIdle}")
    private Integer minIdle;
    @Value("${druid.maxWait}")
    private Long maxWait;
    @Bean
    public DataSource dataSource() {
      
      
        DruidDataSource dataSource =new DruidDataSource();
        dataSource.setDriverClassName(driverClassName);//设置当前驱动类
        dataSource.setUrl(url);//
        dataSource.setUsername(username);//用户名
        dataSource.setPassword(password);//密码
        //设置数据库连接池属性
        dataSource.setInitialSize(initialSize);
        dataSource.setMaxActive(maxActive);
        dataSource.setMinIdle(minIdle);
        dataSource.setMaxWait(maxWait);
        return dataSource;
    }
}

配置事务管理器

    @Bean
    @Autowired
    public TransactionManager transactionManager(DataSource dataSource){
      
      
        DataSourceTransactionManager dataSourceTransactionManager=new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource);
        return dataSourceTransactionManager;
    }

配置SqlSessionFactory:创建sqlsessionFactory对象

    @Bean
    @Autowired
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
      
      
        //创建sqlSessionBean对象
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        //设置数据源
        sqlSessionFactoryBean.setDataSource(dataSource);
        //创建MyBatis的配置器对象
        org.apache.ibatis.session.Configuration configuration=new org.apache.ibatis.session.Configuration();
        //设置日志
        configuration.setLogImpl(StdOutImpl.class);
        sqlSessionFactoryBean.setConfiguration(configuration);
        return sqlSessionFactoryBean.getObject();
}

springMVC配置类

@Configuration
@EnableWebMvc
@ComponentScan("com.jiazhong.ssm.controller")
public class MVCConfig implements WebMvcConfigurer {
      
      

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
      
      
        configurer.enable();//放行静态资源
    }
}

贯穿学习的源码在这

学习来自于西安加中实训

Java小记-SpringMVC(超级无敌认真好用，万字收藏篇!!!!)