【SSM框架（中）-SpringMVC、Maven】

最新推荐文章于 2024-06-13 10:18:30 发布

～勇～

最新推荐文章于 2024-06-13 10:18:30 发布

阅读量284

点赞数

文章标签： maven servlet java

本文链接：https://blog.csdn.net/CHENGKENYONG/article/details/130650034

版权

SSM框架【中】-SpringMVC、Maven

SpringMVC
Maven

SpringMVC

简介

引论（Servlet与SpringMVC开发）

SpringMVC技术与Servlet技术功能等同，均属于web层开发技术，但是SpringMVC能简化Servlet开发
【Servlet开发】：
在这里插入图片描述

【SpringMVC开发】：
在这里插入图片描述
【学习内容以及重点】：

SpringMVC简介：
请求与响应：掌握基于SpringMVC获取请求参数和响应json数据操作
REST风格：熟练应用基于REST风格的请求路径设置与参数传递
SSM整合(注解版)：基于SSM整合技术开发任意业务模块功能
拦截器

概述

【内容】：

SpringMVC技术与Servlet技术功能等同，均属于web层开发技术
SpringMVC能简化Servlet开发；使用简洁、开发便捷（相比于Servlet）；灵活性强
SpringMVC是一种表现层框架技术
SpringMVC用于进行表现层功能开发

【框架图】：
MVC：MVC（Model View Controller）是软件工程中的一种软件架构模式，它把软件系统分为模型（Model）、视图（View）和控制器（Controller）三个基本部分。用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。
SpringMVC：Spring MVC对这套MVC流程进行封装，帮助开发者屏蔽底层细节，并且开放出相关接口供开发者调用，让MVC开发更简单方便
在这里插入图片描述

SpringMVC基础

SpringMVC入门案例

项目目录：
在这里插入图片描述

【步骤1】：使用SpringMVC技术需要在pom.xml文件钟先导入SpringMVC坐标与Servlet坐标，以及Tomcat坐标（将pom.xml中多余的内容删除掉，再添加SpringMVC需要的依赖）

<?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.itheima</groupId>
  <artifactId>springmvc_01_quickstart</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
//Servlet依赖
  <dependencies>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
//SpringMVC依赖
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
  </dependencies>
//Tomcat依赖
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

注意：
在这里插入图片描述
【步骤2】：创建Controller类（SpringMVC平替Servlet）,其中RequestBody用来设置当前控制器方法响应内容为当前返回值，无需解析

@Controller
public class UserController {
    @RequestMapping("/save")
    @RequestBody//设置当前控制器方法响应内容为当前返回值，无需解析
    public void save(){
        System.out.println("user save ...");
        return("hello");
   }
}

【步骤3】：创建配置类

@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}

【步骤4】：使用配置类替换web.xml ，将web.xml删除，换成ServletContainersInitConfig，目的是将SpringMVC加载到tomcat环境中

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    //加载springmvc配置类
    protected WebApplicationContext createServletApplicationContext() {
        //初始化WebApplicationContext对象
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        //加载指定配置类
        ctx.register(SpringMvcConfig.class);
        return ctx;
   }
    //设置由springmvc控制器处理的请求映射路径，即处理哪些请求
    protected String[] getServletMappings() {
        return new String[]{"/"};
   }
    //加载spring配置类
    protected WebApplicationContext createRootApplicationContext() {
        return null;
   }
}

【小结】：
在这里插入图片描述

SpringMVC入门案例工作流程

【两个过程】：为了更好的使用SpringMVC,我们将SpringMVC的使用过程总共分两个阶段来分析，分别是启动服务器初始化过程和单次请求过程
在这里插入图片描述

启动服务器初始化过程
（1）、服务器启动，执行ServletContainersInitConfig类，初始化web容器
——功能类似于以前的web.xml
（2）、执行createServletApplicationContext方法，创建了WebApplicationContext对象
——该方法加载SpringMVC的配置类SpringMvcConfig来初始化SpringMVC的容器
（3）、加载SpringMvcConfig配置类

（4）、执行@ComponentScan加载对应的bean
——扫描指定包及其子包下所有类上的注解，如Controller类上的@Controller注解
（5）、加载UserController，每个@RequestMapping的名称对应一个具体的方法

——此时就建立了 /save 和 save方法的对应关系
（6）、执行getServletMappings方法，设定SpringMVC拦截请求的路径规则

——/代表所拦截请求的路径规则，只有被拦截后才能交给SpringMVC来处理请求
单次请求过程
（1）、发送请求http://localhost/save
（2）、 web容器发现该请求满足SpringMVC拦截规则，将请求交给SpringMVC处理
（3）、解析请求路径/save
（4）、由/save匹配执行对应的方法save(）
——上面的第五步已经将请求路径和方法建立了对应关系，通过/save就能找到对应的save方法
（5）、执行save()
（6）、检测到有@ResponseBody直接将save()方法的返回值作为响应体返回给请求方

bean加载控制（Spring与SpringMVC区分加载bean）

项目目录：
在这里插入图片描述
【问题】：当Spring与SpringMVC在一个项目环境下配置时，Spring与SpringMVC需要区分加载各自的bean，这时候我们就要做到用注解的方式用来实现
【方法】：

方式一：修改Spring配置类，设定扫描范围为精准范围。（只让Spring扫描到service层与dao层）

@Configuration
@ComponentScan({"com.itheima.service","comitheima.dao"})
public class SpringConfig {
}

方式二：修改Spring配置类，设定扫描范围为com.itheima,排除掉controller包中的bean

@Configuration
@ComponentScan(value="com.itheima",
    excludeFilters=@ComponentScan.Filter(
   type = FilterType.ANNOTATION,
        classes = Controller.class )
)
public class SpringConfig {
}

说明：
在这里插入图片描述
小问题：

【加载Spring配置类】：最后一个问题，有了Spring的配置类，要想在tomcat服务器启动将其加载，我们需要修改ServletContainersInitConfig

方式一：

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMvcConfig.class);
        return ctx;
   }
    protected String[] getServletMappings() {
        return new String[]{"/"};
   }
   //加载Spring配置类
    protected WebApplicationContext createRootApplicationContext() {
      AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringConfig.class);
        return ctx;
   }
}

方式二：

public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
         }
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
   }
    protected String[] getServletMappings() {
        return new String[]{"/"};
   }
}

【小结】：
在这里插入图片描述

PostMan工具介绍

【PostMan简介】：代码编写完后，我们要想测试，只需要打开浏览器直接输入地址发送请求即可。发送的是GET请求可以直接使用浏览器，但是如果要发送的是POST请求呢?
如果要求发送的是post请求，我们就得准备页面在页面上准备form表单，测试起来比较麻烦。所以我们就需要借助一些第三方工具，如PostMan.

PostMan是一款功能强大的网页调试与发送网页HTTP请求的Chrome插件。
作用：常用于进行接口测试
特征：简单、实用、美观、大方

【PostMan安装】：直接官网安装即可
【PostMan使用】：

创建WorkSpace工作空间
发送请求
保存当前请求

请求与响应

设置请求映射路径

【问题】：如以下代码中有两个类方法的请求路径相同（下面的 /save为例），当我们通过浏览器的url访问时，他会不知道访问哪个方法导致报错，为此我们需要通过 @RequestMapping来设置映射路径前缀来区分
Controller目录下的BookController类和UserController类：

@Controller
public class UserController {
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'module':'user save'}";
   }
    @RequestMapping("/delete")
    @ResponseBody
    public String save(){
        System.out.println("user delete ...");
        return "{'module':'user delete'}";
   }
}
@Controller
public class BookController {
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("book save ...");
        return "{'module':'book save'}";
   }
}

利用@RequestMapping添加前缀进行区分：

@Controller
@RequestMapping("/user")添加位置
public class UserController {
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'module':'user save'}";
   }
    @RequestMapping("/delete")
    @ResponseBody
     public String save(){
        System.out.println("user delete ...");
        return "{'module':'user delete'}";
   }
}
@Controller
@RequestMapping("/book")//添加位置
public class BookController {
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("book save ...");
        return "{'module':'book save'}";
   }
}

get请求与post请求发送普通参数

【Get请求】：

Get请求发送多个参数的形式：？参数名1=参数值&参数名2=参数值【比如http://localhost/commonParam?name=itcast&age=15】
PostMan操作：
接收参数：直接写在方法的形参里就可以接收参数了

@Controller
public class UserController {
    @RequestMapping("/commonParam")
    @ResponseBody
    public String commonParam(String name,int age){
        System.out.println("普通参数传递 name ==> "+name);
        System.out.println("普通参数传递 age ==> "+age);
        return "{'module':'commonParam'}";
   }
}

Get请求中文乱码：（参数传递中文值）出现乱码的原因相信大家都清楚，Tomcat8.5以后的版本已经处理了中文乱码的问题，但是IDEA中的Tomcat插件目前只到Tomcat7，所以需要修改pom.xml来解决GET请求中文乱码问题

<build>
    <plugins>
      <plugin>
      <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port><!--tomcat端口号-->
          <path>/</path> <!--虚拟目录-->
          <uriEncoding>UTF-8</uriEncoding><!--访问路径编解码字符集-->
        </configuration>
      </plugin>
    </plugins>
  </build>

【Post请求】：

PostMan发送请求参数：
接收请求参数：与Get一样不做修改
POST请求中文乱码：配置过滤器

public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
   }
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
   }
    protected String[] getServletMappings() {
        return new String[]{"/"};
   }
    //乱码处理
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
   }
}

五种类型参数传递

前面我们已经能够使用GET或POST来发送请求和数据，所携带的数据都是比较简单的数据，接下来在这个基础上，我们来研究一些比较复杂的参数传递，常见的参数种类有:

普通参数
POJO类型参数
嵌套POJO类型参数
数组类型参数
集合类型参数

【小结】：

json数据传递参数

前面我们说过，现在比较流行的开发方式为异步调用。前后台以异步方式进行交换，传输的数据使用的是JSON,所以前端如果发送的是JSON数据，后端该如何接收?

对于JSON数据类型，我们常见的有三种:

json普通数组（[“value1”,“value2”,“value3”,…]）
【步骤一】：pom.xml添加依赖，SpringMVC默认使用的是jackson来处理json的转换，所以需要在pom.xml添加jackson依赖

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

【步骤二】：PostMan发送JSON数据
在这里插入图片描述
【步骤三】：开启SpringMVC注解支持，在SpringMVC的配置类中开启SpringMVC的注解 @EnableWebMvc支持，这里面就包含了将JSON转换成对象的功能。

@Configuration
@ComponentScan("com.itheima.controller")
//开启json数据类型自动转换
@EnableWebMvc
public class SpringMvcConfig {
}

【步骤四】：参数前添加@RequestBody

//使用@RequestBody注解将外部传递的json数组数据映射到形参的集合对象中作为数据
@RequestMapping("/listParamForJson")
@ResponseBody
public String listParamForJson(@RequestBody List<String> likes){
    System.out.println("list common(json)参数传递 list ==> "+likes);
    return "{'module':'list common for json param'}";
}

json对象（{key1:value1,key2:value2,…}）
json对象数组（[{key1:value1,…},{key2:value2,…}]）

小结：

日期型参数传递

前面我们处理过简单数据类型、POJO数据类型、数组和集合数据类型以及JSON数据类型，接下来我们还得处理一种开发中比较常见的一种数据类型，日期类型

日期类型比较特殊，因为对于日期的格式有N多中输入方式，比如:

2088-08-18
2088/08/18
08/18/2088
…

针对这么多日期格式，SpringMVC该如何接收，它能很好的处理日期类型数据么?

日期格式：YYYY/MM/DD
发送请求：使用PostMan发送GET请求，并设置date参数：http://localhost/dataParam?date=2088/08/08

接收请求：在UserController类中添加方法，把参数设置为日期类型

@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date)
    System.out.println("参数传递 date ==> "+date);
    return "{'module':'data param'}";
}

日期格式：YYYY-MM-DD
发送请求：使用PostMan发送请求，携带两个不同的日期格式：http://localhost/dataParam?date=2088/08/08&date1=2088-08-08

接收请求：需要使用@DateTimeFormat

@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,
                        @DateTimeFormat(pattern="yyyy-MM-dd") Date date1)
    System.out.println("参数传递 date ==> "+date);
    System.out.println("参数传递 date1(yyyy-MM-dd) ==> "+date1);
    return "{'module':'data param'}";
}

日期格式：yyyy/MM/dd HH:mm:ss
发送请求：使用PostMan发送请求，携带两个不同的日期格式：http://localhost/dataParam?date=2088/08/08&date1=2088-08-08&date2=2088/08/08 8:08:08

接收请求：先修改UserController类，添加第三个参数

@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,
                        @DateTimeFormat(pattern="yyyy-MM-dd")Date date1,
                        @DateTimeFormat(pattern="yyyy/MM/dd HH:mm:ss") Date date2)
    System.out.println("参数传递 date ==> "+date);
    System.out.println("参数传递 date1(yyyy-MM-dd) ==> "+date1);
    System.out.println("参数传递 date2(yyyy/MM/dd HH:mm:ss) ==> "+date2);
    return "{'module':'data param'}";
}

【小结】：
在这里插入图片描述

响应

SpringMVC接收到请求和数据后，进行一些了的处理，当然这个处理可以是转发给Service，Service层再调用Dao层完成的，不管怎样，处理完以后，都需要将结果告知给用户。比如:根据用户ID查询用户信息、查询用户列表、新增用户等。

对于响应，主要就包含两部分内容：

响应页面
响应数据
——文本数据
—— json数据

因为异步调用是目前常用的主流方式，所以我们需要更关注的就是如何返回JSON数据，对于其他只需要认识了解即可。

设置返回页面

@Controller
public class UserController {
    @RequestMapping("/toJumpPage")
    //注意
    //1.此处不能添加@ResponseBody,如果加了该注入，会直接将page.jsp当字符串返回前端
    //2.方法需要返回String
    public String toJumpPage(){
        System.out.println("跳转页面");
        return "page.jsp";
   }    
}

返回文本数据[了解]

@Controller
public class UserController {
   @RequestMapping("/toText")
 //注意此处该注解就不能省略，如果省略了,会把response text当前页面名称去查找，如果没有回报404错误
    @ResponseBody
    public String toText(){
        System.out.println("返回纯文本数据");
        return "response text";
   }  
}

响应JSON（POJO）数据

@Controller
public class UserController {
    @RequestMapping("/toJsonPOJO")
    @ResponseBody
    public User toJsonPOJO(){
        System.out.println("返回json对象数据");
        User user = new User();
        user.setName("itcast");
        user.setAge(15);
        return user;
   }  
}

注意：返回值为实体类对象，设置返回值为实体类类型，即可实现返回对应对象的json数据，需要依赖@ResponseBody注解和@EnableWebMvc注解

响应JSON（POJO）集合对象

@Controller
public class UserController {
    @RequestMapping("/toJsonList")
    @ResponseBody
    public List<User> toJsonList(){
        System.out.println("返回json集合数据");
        User user1 = new User();
        user1.setName("传智播客");
        user1.setAge(15);
 
        User user2 = new User();
        user2.setName("黑马程序员");
        user2.setAge(12);
 
        List<User> userList = new ArrayList<User>();
        userList.add(user1);
        userList.add(user2);
 
        return userList;
   }
}

【小结】：
在这里插入图片描述

REST风格

REST简介

REST（Representational State Transfer），表现形式状态转换,它是一种软件架构风格，当我们想表示一个网络资源的时候，可以使用两种方式:

传统风格资源描述形式
——http://localhost/user/getById?id=1 查询id为1的用户信息
——http://localhost/user/saveUser 保存用户信息
REST风格描述形式
——http://localhost/user/1
——http://localhost/user

传统方式一般是一个请求url对应一种操作，这样做不仅麻烦，也不安全，因为会程序的人读取了你的请求url地址，就大概知道该url实现的是一个什么样的操作。
查看REST风格的描述，你会发现请求地址变的简单了，并且光看请求URL并不是很能猜出来该URL的具体功能。
所以REST的优点有:

隐藏资源的访问行为，无法通过地址得知对资源是何种操作
书写简化

但是我们的问题也随之而来了，一个相同的url地址即可以是新增也可以是修改或者查询，那么到底我们该如何区分该请求到底是什么操作呢? 按照REST风格访问资源时使用行为动作区分对资源进行了何种操作【即通过url+请求动作（GET、POST、PUT、DELETE共同确定一个操作】

URL	请求类型（行为动作）	表示的操作
http://localhost/users	GET（查询）	查询全部用户信息
http://localhost/users	POST（新增/保存）	添加用户信息
http://localhost/users	PUT（修改/更新）	修改用户信息
http://localhost/users/1	GET（查询）	查询指定用户信息
http://localhost/users/1	DELETE（删除）	删除用户信息

请求的方式比较多，但是比较常用的就4种，分别是GET , POST , PUT , DELETE。按照不同的请求方式代表不同的操作类型：

发送GET请求是用来做查询
发送POST请求是用来做新增
发送PUT请求是用来做修改
发送DELETE请求是用来做删除

RESTful入门案例

【说明】：为了用REST风格描述的URL形式综合上请求类型找到Controller层中的方法资源，我们需要将传统的Controller层中的方法编写风格进行修改，具体操作如下：

新增：在@RequesMapping中将URL后缀值（“/save”）改为（value=“/users”）和添加请求类型值（method=RequestMethod.POST）

//传统风格
@Controller
public class UserController {
 //设置当前请求方法为POST，表示REST风格中的添加操作
    @RequestMapping("/save")
    @ResponseBody
    public String save() {
        System.out.println("user save...");
        return "{'module':'user save'}";
   }
}
//REST风格
@Controller
public class UserController {
 //设置当前请求方法为POST，表示REST风格中的添加操作
    @RequestMapping(value = "/users",method = RequestMethod.POST)
    @ResponseBody
    public String save() {
        System.out.println("user save...");
        return "{'module':'user save'}";
   }
}

删除（路径传参id）：在 @RequesMapping中将URL后缀值（“/delete”）改为（value=“/users/{id}”）【id表示的就是从路径上传过来的参数】和添加请求类型值（method=RequestMethod.DELETE），此外需要在方法的形参前加上注解@PathVariable表示该id是从路径上传过来的

//传统风格
@Controller
public class UserController {
    //设置当前请求方法为DELETE，表示REST风格中的删除操作
 @RequestMapping("/delete")
    @ResponseBody
    public String delete(Integer id) {
        System.out.println("user delete..." + id);
        return "{'module':'user delete'}";
   }
//REST风格
@Controller
public class UserController {
    //设置当前请求方法为DELETE，表示REST风格中的删除操作
 @RequestMapping(value = "/users/{id}",method = RequestMethod.DELETE)
    @ResponseBody
    public String delete(@PathVariable Integer id) {
        System.out.println("user delete..." + id);
        return "{'module':'user delete'}";
   }

注意：
在这里插入图片描述

修改，根据ID查询、查询所有类推即可（只需要改变上面两种情况的请求类型值@RequestMapping中属性method=……即可）

【小结】：
在这里插入图片描述

REST快速开发

在这里插入图片描述

【小结】：

基于RESTful页面数据交互

具体案例见RESTful案例

SSM整合

【SSM整合流程框架】：

创建工程
SSM整合
>>>Spring
———SpringConfig
>>>Mybatis
———MybatisConfihg
———JdbcConfig
———jdbc.properties
>>>SpringMVC
———ServletConfig
———SpringMvcConfig
功能模块
>>>表与实体类
>>>dao（接口+自动代理）
>>>service（接口与实现类）
———业务层接口测试（整合JUnit）
>>>controller
———表现层接口测试（PostMan）

整合配置

创建工程：
【步骤一】：创建一个Maven的web项目，可以使用Maven的骨架创建
在这里插入图片描述
【步骤二】：pom.xml添加SSM所需要的依赖jar包

【步骤三】：创建项目包结构

config目录存放的是相关的配置类
controller编写的是Controller类
dao存放的是Dao接口，因为使用的是Mapper接口代理方式，所以没有实现类包
service存的是Service接口，impl存放的是Service实现类
resources:存入的是配置文件，如Jdbc.properties
webapp:目录可以存放静态资源
test/java:存放的是测试类

【步骤四】：创建SpringConfig配置类

@Configuration
@ComponentScan({"com.itheima.service"})//Spring只需要管理service层等，controller层交给SpringMVC管
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MyBatisConfig.class})
@EnableTransactionManagement//开启事务管理
public class SpringConfig {
}

【步骤五】：创建jdbc.properties，在resources下提供jdbc.properties,设置数据库连接四要素

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_db
jdbc.username=root
jdbc.password=root

【步骤六】：创建JdbcConfig配置类

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
 
    @Bean//数据源对象Druid配置
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
            dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
   }
   
   @Bean//事务管理器配置
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager ds = new DataSourceTransactionManager();
        ds.setDataSource(dataSource);
        return ds;
   }
}

【步骤七】：创建MybatisConfig配置类【SqlSessionFactoryBean、MapperScannerConfigurer】

public class MyBatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setTypeAliasesPackage("com.itheima.domain");
        return factoryBean;
   }
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
   }
}

【步骤八】：创建Web项目入口配置类ServletConfig

public class ServletConfig extends 
AbstractAnnotationConfigDispatcherServletInitializer {
    //加载Spring配置类
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
   }
    //加载SpringMVC配置类
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
   }
    //设置SpringMVC请求地址拦截规则
    protected String[] getServletMappings() {
        return new String[]{"/"};
   }
    //设置post请求中文乱码过滤器
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("utf-8");
        return new Filter[]{filter};
   }
}

【步骤九】：创建SpringMVC配置类

@Configuration
@ComponentScan("com.itheima.controller")
@EnableWebMvc
public class SpringMvcConfig {
}

功能模块开发

功能开发：
【步骤一】：创建数据库及表
在这里插入图片描述

【步骤二】：创建项目目录结构

【步骤三】：在domain目录下编写模型类

public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;
    //getter...setter...toString省略
}

【步骤四】：编写Dao接口

public interface BookDao {
 // @Insert("insert into tbl_book values(null,#{type},#{name},#{description})")这行也可以
    @Insert("insert into tbl_book (type,name,description) values(#{type},#{name},#{description})")
    public void save(Book book);
    
    @Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")
    public void update(Book book);

    @Delete("delete from tbl_book where id = #{id}")
    public void delete(Integer id);
 
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);
 
    @Select("select * from tbl_book")
    public List<Book> getAll();
}

【步骤五】：编写Service接口和实现类

//Service接口
@Transactional//事务管理
public interface BookService {
    /**
     * 保存
     * @param book
     * @return
     */
    public boolean save(Book book);
    /**
     * 修改
     * @param book
     * @return
     */
    public boolean update(Book book);
    /**
     * 按id删除
     * @param id
     * @return
     */
    public boolean delete(Integer id);
    /**
     * 按id查询
     * @param id
     * @return
     */
    public Book getById(Integer id);
    /**
     * 查询全部
     * @return
     *     
     */
    public List<Book> getAll();
}
//实现类
@Service

public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;
 
    public boolean save(Book book) {
        bookDao.save(book);
        return true;
   }
    public boolean update(Book book) {
        bookDao.update(book);
        return true;
   }
    public boolean delete(Integer id) {
        bookDao.delete(id);
        return true;
   }
    public Book getById(Integer id) {
        return bookDao.getById(id);
   }
    public List<Book> getAll() {
        return bookDao.getAll();
   }
}

在这里插入图片描述

【步骤六】：编写Contorller类

@RestController
@RequestMapping("/books")

public class BookController {
    @Autowired
    private BookService bookService;
 
    @PostMapping
    public boolean save(@RequestBody Book book) {
        return bookService.save(book);
   }
    @PutMapping
    public boolean update(@RequestBody Book book) {
        return bookService.update(book);
   }
    @DeleteMapping("/{id}")
    public boolean delete(@PathVariable Integer id) {
        return bookService.delete(id);
   }
    @GetMapping("/{id}")
    public Book getById(@PathVariable Integer id) {
        return bookService.getById(id);
   }
    @GetMapping
    public List<Book> getAll() {
        return bookService.getAll();
   }
}

接口测试

【表现层测试】：在test/java目录下添加该测试目录（我们先来对查询进行单元测试。）

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class BookServiceTest {
    @Autowired
    private BookService bookService;
 
    @Test
    public void testGetById(){
        Book book = bookService.getById(1);
        System.out.println(book);
   }
    @Test
    public void testGetAll(){
        List<Book> all = bookService.getAll();
        System.out.println(all);
   }
}

【PostMan测试】：具体见上面PostMan工具测试

表现层与前端数据传输协议定义

SSM整合以及功能模块开发完成后，接下来，我们在上述案例的基础上分析下有哪些问题需要我们去解决下。首先第一个问题是:

在Controller层增删改返回给前端的是boolean类型数据
在Controller层查询单个返回给前端的是对象
在Controller层查询所有返回给前端的是集合对象

目前我们就已经有三种数据类型返回给前端，如果随着业务的增长，我们需要返回的数据类型会越来越多【可能是布尔型，可能是对象，可能是集合对象】。对于前端开发人员在解析数据的时候就比较凌乱了，所以对于前端来说，如果后台能够返回一个统一的数据结果【用data封装起来】，前端在解析的时候就可以按照一种方式进行解析。开发就会变得更加简单。所以我们就想能不能将返回结果的数据进行统一，具体如何来做，大体的思路为:
为了封装返回的结果数据:创建结果模型类，数据封装到data属性中
为了封装返回的数据是何种操作及是否操作成功:操作结果封装到code属性中
操作失败后为了封装返回的错误信息:特殊消息封装到message(msg)属性中

根据分析，我们可以设置统一数据返回结果类：

public class Result{
 private Object data;
 private Integer code;
 private String msg;
}

注意:Result类名及类中的字段并不是固定的，可以根据需要自行增减提供若干个构造方法，方便操作。

表现层与前端数据传输协议实现

前面我们已经分析了如何封装返回结果数据，具体在项目中该如何实现见下面操作
【步骤一】：创建目录结构，案例与SSM整合案例一摸一样
在这里插入图片描述
【步骤二】：创建Result类

public class Result {
    //描述统一格式中的数据
    private Object data;
    //描述统一格式中的编码，用于区分操作，可以简化配置0或1表示成功失败
    private Integer code;
    //描述统一格式中的消息，可选属性
    private String msg;
    public Result() {
   }
    //构造方法是方便对象的创建
    public Result(Integer code,Object data) {
        this.data = data;
        this.code = code;
   }
    //构造方法是方便对象的创建
    public Result(Integer code, Object data, String msg) {
        this.data = data;
        this.code = code;
        this.msg = msg;
   }
    //setter...getter...省略
}

【步骤三】：定义返回码Code类

//状态码
public class Code {
	//保存、删除、更新、查询成功状态码
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;
    //保存、删除、更新、查询失败状态码
    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
}

【步骤四】：返回的任何Boolean、List、Book类型均用Result封装替换

@RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private BookService bookService;
 
    @PostMapping
    public boolean save(@RequestBody Book book) {
        //return bookService.save(book);替换为
        boolean flag = bookService.save(book);
        return new Result(flag ? Code.SAVE_OK:Code.SAVE_ERR,flag);//Result的构造方法有code和data的参数
   }
   
    @PutMapping
    public boolean update(@RequestBody Book book) {
        //return bookService.update(book);替换为
        boolean flag = bookService.update(book);
        return new Result(flag ? Code.UPDATE_OK:Code.UPDATE_ERR,flag);//Result的构造方法有code和data的参数
   }
    @DeleteMapping("/{id}")
    public boolean delete(@PathVariable Integer id) {
        //return bookService.delete(id);替换为
         boolean flag = bookService.delete(id);
         return new Result(flag ? Code.DELETE_OK:Code.DELETE_ERR,flag);
   }
    @GetMapping("/{id}")
    public Book getById(@PathVariable Integer id) {
        //return bookService.getById(id);替换为
        Book book = bookService.getById(id);
        Integer code = book != null ? Code.GET_OK : Code.GET_ERR;
        String msg = book != null ? "" : "数据查询失败，请重试！";
        return new Result(code,book,msg);//Result的构造方法有code和data、message的参数
   }
    @GetMapping
    public List<Book> getAll() {
        //return bookService.getAll();替换为
        List<Book> bookList = bookService.getAll();
        Integer code = bookList != null ? Code.GET_OK : Code.GET_ERR;
        String msg = bookList != null ? "" : "数据查询失败，请重试！";
        return new Result(code,bookList,msg);//Result的构造方法有code和data、message的参数
   }
}

异常处理器

【问题描述】：更改controller目录下的BookController中getById方法，使其产生异常

@GetMapping("/{id}")
public Result getById(@PathVariable Integer id) {
    //手动添加一个错误信息
    if(id==1){
        int i = 1/0;
   }
    Book book = bookService.getById(id);
    Integer code = book != null ? Code.GET_OK : Code.GET_ERR;
    String msg = book != null ? "" : "数据查询失败，请重试！";
    return new Result(code,book,msg);
}

毫无疑问，程序运行肯定会报错，在解决问题之前，我们先来看下异常的种类及出现异常的原因:

框架内部抛出的异常：因使用不合规导致
数据层抛出的异常：因外部服务器故障导致（例如：服务器访问超时）
业务层抛出的异常：因业务逻辑书写错误导致（例如：遍历业务书写操作，导致索引异常等）
表现层抛出的异常：因数据收集、校验等规则导致（例如：不匹配的数据类型间导致异常）
工具类抛出的异常：因工具类书写不严谨不够健壮导致（例如：必要释放的连接长期未释放等）

【解决思路】：

各个层级均出现异常，异常处理代码书写在哪一层?
所有的异常均抛出到表现层（最高层）进行处理
异常的种类很多，表现层如何将所有的异常都处理到呢?
异常分类，根据异常的类型分别处理
表现层处理异常，每个方法中单独书写，代码书写量巨大且意义不强，如何解决?
AOP,SpringMVC已经为我们提供了一套解决方案:异常处理器（集中的、统一的处理项目中出现的异常。）

【解决流程】：
步骤一：创建目录
在这里插入图片描述
步骤二：:创建异常处理器类并且返回结果给前端（返回Result对象数据，是开发达到统一）

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {
    //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
    @ExceptionHandler(Exception.class)//处理哪种异常类型
    public Result doException(Exception ex){
     System.out.println("嘿嘿,异常你哪里跑！")
     return new Result(666,null,"嘿嘿,异常你哪里跑！");//返回Result对象数据，是开发达到统一
   }
}

【小结】：
在这里插入图片描述

异常处理

【问题描述】：异常处理器我们已经能够使用了，那么在咱们的项目中该如何来处理异常呢? 因为异常的种类有很多，如果每一个异常都对应一个@ExceptionHandler，那得写多少个方法来处理各自的异常，所以我们在处理异常之前，需要对异常进行一个分类:

业务异常（BusinessException）:比如用户未按照指定格式进行数据填写或者故意传递错误数据
解决：发送对应消息传递给用户，提醒规范操作（大家常见的就是提示用户名已存在或密码格式不正确等）
系统异常（SystemException）：比如数据库或服务器宕机
解决一：发送固定消息传递（如下）给用户，安抚用户
系统繁忙，请稍后再试
系统正在维护升级，请稍后再试
系统出问题，请联系系统管理员等
解决二：发送特定消息给运维人员，提醒维护
可以发送短信、邮箱或者是公司内部通信软件
解决三：记录日志
发消息和记录日志对用户来说是不可见的，属于后台程序
其他异常（Exception）：编程人员未预期到的异常，如:用到的文件不存在
解决一：发送固定消息传递给用户，安抚用户
解决二：发送特定消息给编程人员，提醒维护（纳入预期范围内）
一般是程序没有考虑全，比如未做非空校验等
解决三：记录日志

【具体解决流程】：
步骤一：创建目录结构
在这里插入图片描述
步骤二：自定义异常类SystemException、BusinessException异常类

//SystemException异常类，自定义异常处理器，用于封装异常信息，对异常进行分类
public class SystemException extends RuntimeException{
	//自定义Code错误代码，并实现getter和setter方法
    private Integer code;
    public Integer getCode() {
        return code;
   }
    public void setCode(Integer code) {
        this.code = code;
   }
   //自定义构造方法，并使用来自父类的message（通过父类的构造方法得到【super(message)】）
    public SystemException(Integer code, String message) {
        super(message);
        this.code = code;
   }
    public SystemException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
   }
}

//BusinessException异常类，自定义异常处理器，用于封装异常信息，对异常进行分类
public class BusinessException extends RuntimeException{
    private Integer code;
    public Integer getCode() {
        return code;
   }
    public void setCode(Integer code) {
        this.code = code;
   }
    public BusinessException(Integer code, String message) {
        super(message);
                this.code = code;
   }
    public BusinessException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
   }
}

说明：让自定义异常类继承RuntimeException的好处是，后期在抛出这两个异常的时候，就不用在try…catch…或throws了；自定义异常类中添加code属性的原因是为了更好的区分异常是来自哪个业务的

步骤二：将其他异常包成自定义异常（具体的包装方式有：方式一: try{}catch(){}在catch中重新throw我们自定义异常即可。和方式二:直接throw自定义异常即可）见下即可

public Book getById(Integer id) {
    //模拟业务异常，包装成自定义异常
    if(id == 1){
        throw new BusinessException(Code.BUSINESS_ERR,"请不要使用你的技术挑战我的
耐性!");
   }
    //模拟系统异常，将可能出现的异常进行包装，转换成自定义异常
    try{
        int i = 1/0;
   }catch (Exception e){
        throw new SystemException(Code.SYSTEM_TIMEOUT_ERR,"服务器访问超时，请重
试!",e);
   }
    return bookDao.getById(id);
}

步骤三：处理器类中处理自定义异常

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {
    //@ExceptionHandler用于设置当前处理器类对应的异常类型
    @ExceptionHandler(SystemException.class)
    public Result doSystemException(SystemException ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex对象发送给开发人员
        return new Result(ex.getCode(),null,ex.getMessage());
   }
    @ExceptionHandler(BusinessException.class)
    public Result doBusinessException(BusinessException ex){
        return new Result(ex.getCode(),null,ex.getMessage());
   }
    //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
    @ExceptionHandler(Exception.class)
    public Result doOtherException(Exception ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex对象发送给开发人员
        return new Result(Code.SYSTEM_UNKNOW_ERR,null,"系统繁忙，请稍后再试！");
   }
}

【小结】： 在这里插入图片描述

前后台协议联调（列表【查询所有】功能）

【准备工作】：

步骤一：添加静态资源到web项目中，具体目录如下
在这里插入图片描述
步骤二：因为添加了静态资源，SpringMVC会拦截，所有需要在SpringConfig的配置类中将静态资源进行放行。新建SpringMvcSupport

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {     
 registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
 registry.addResourceHandler("/css/**").addResourceLocations("/css/");   
 registry.addResourceHandler("/js/**").addResourceLocations("/js/");  
 registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins
/");
   }
}

步骤三：在SpringMvcConfig中扫描SpringMvcSupport

@Configuration
@ComponentScan({"com.itheima.controller","com.itheima.config"})
@EnableWebMvc
public class SpringMvcConfig {
}

【列表功能实现】：

需求:页面加载完后发送异步请求到后台获取列表数据进行展示。
1.找到页面的钩子函数，created()
2. created()方法中调用了this.getAll()方法
3.在getAll()方法中使用axios发送异步请求从后台获取数据
4.访问的路径为http://localhost/books
5.返回数据
具体的前端代码可以见RESTful案例

返回数据res.data【即上面封装好的Result对象数据，只是后台以JSON格式传给前端的，并被res.data接收到】的内容如下:

{
    "data": [
        {
            "id": 1,
            "type": "计算机理论",
            "name": "Spring实战 第五版",
            "description": "Spring入门经典教程，深入理解Spring原理技术内幕"

       },
       {
            "id": 2,
            "type": "计算机理论",
            "name": "Spring 5核心原理与30个类手写实践",
            "description": "十年沉淀之作，手写Spring精华思想"

       },...//省略

   ],
    "code": 20041,
    "msg": ""
}

发送方式：【axios.get("/books").then((res)=>{……}表示”查询请求“是通过前端发送GET请求/books方法资源（里面有实现查询数据库并返回数据库内容【用Result封装好的】的代码）实现的，返回的数据由res接收；后台返回的Rusult对象数据(JSON形式)由res.data获得，并由res.data.data获得JSON里面的data数据，再传递给dataList再由前端展示出来】

getAll() {
    //发送ajax请求
    axios.get("/books").then((res)=>{//表示GET请求books目录下的资源，然后返回结果res，而后台返回的Rusult对象数据(JSON形式)由res.data获得，再由res.data.data获得JSON里面的data数据
        this.dataList = res.data.data;
   });
}

显示效果：
在这里插入图片描述

前后台协议联调（添加功能）

【添加功能显示】：
在这里插入图片描述

需求:完成图片的新增功能模块
1.找到页面上的”新建“按钮，按钮上绑定了@click="handleCreate()"方法,所以点击这个按钮会执行handleCreate()里的请求
2. 在method中找到handleCreate方法，方法中打开新增面板(设置属性dialogFormVisible=true使得添加功能的弹窗可视化即自动弹出来)
3.新增面板中找到”确定“按钮,按钮上绑定了@click="handleAdd()"方法，所以点击这个按钮会执行handleAdd()里的请求
4.在method中找到handleAdd方法
5.在方法中发送请求和数据，响应成功后将新增面板关闭（dialogFormVisible=false）并重新查询数据（再次调用getAll方法显示全部）

handleCreate打开新增面板

handleCreate() {
    this.dialogFormVisible = true;//使得添加功能的弹窗可视化（即弹出添加功能的弹窗）
},

handleAdd方法发送异步请求并携带数据【axios.post("/books",this.formData).then((res)表示”添加请求“是通过前端发送POST请求/books方法资源（里面有实现添加到数据库功能的代码）实现的；其中this.formData代表携带的添加数据this.dialogFormVisible = false;表示添加操作完成后自动关闭添加弹窗this.getAll();表示添加完成后自动查询显示全部】

handleAdd () {
    //发送ajax请求
    //this.formData是表单中的数据，最后是一个json数据
    axios.post("/books",this.formData).then((res)=>{//表示绑定了handleAdd的按钮点击后发送的是这个请求
        this.dialogFormVisible = false;
        this.getAll();
   });
}

前后台协议联调（添加功能状态功能）

基础的新增功能已经完成，但是还有一些问题需要解决下:

需求:新增成功是关闭面板，重新查询数据，那么新增失败以后该如何处理?
1.在handlerAdd方法中根据后台返回的数据来进行不同的处理
2.如果后台返回的是成功，则提示成功信息，并关闭面板
3.如果后台返回的是失败，则提示错误信息

【步骤一】：由于我们后台表现层（controller）需要判断添加是否成功（即获取下面第一张图bookService.save(book)的返回值）以便返回不同code值给前端完成步骤二，但是当时为了方便把bookService.save(book)的返回值都确定为true了（第二张图），为此我们需要修改
在这里插入图片描述

而由于bookDao.save(book)对数据库操作我们没设返回值【第一张图】（但是一般有返回值为int型表示是否添加成功），因此我们也需要改回来【第二张图】

因此service层中的BookService也改为下图，这样表现层（controller）才能正确获得返回值（flag）并且前端也能获取到正确的code并执行
在这里插入图片描述

【步骤二】：修改前端页面

handleAdd () {
    //发送ajax请求
    axios.post("/books",this.formData).then((res)=>{
        //如果操作成功，关闭弹层，显示数据
        //无论新增成功或失败后台都会返回Result封装好的数据，其中里面的code携带了是否添加成功的代码，msg携带了是否添加成功的信息
        if(res.data.code == 20011){
            this.dialogFormVisible = false;//添加成功后弹窗关闭
            this.$message.success("添加成功");
       }else if(res.data.code == 20010){
            this.$message.error("添加失败");
       }else{
            this.$message.error(res.data.msg);
       }
   }).finally(()=>{//无论添加成功与否都要显示所有数据
        this.getAll();
   });
}

【步骤三】：新增成功后，再次点击新增按钮会发现之前的数据还存在，这个时候就需要在新增的时候将表单内容清空。

resetForm(){
 this.formData = {};//formData表示新增操作中在文本框添入的数据，设置为空，即表示在新增的时候将表单内容清空。
}
handleCreate() {
    this.dialogFormVisible = true;
    this.resetForm();//弹出新增图书对话框后，调用重置表单方法将文本框内容清空
}

前后台协议联调（修改功能）

在这里插入图片描述

需求:完成图书信息的修改功能
1.找到页面中的”编辑“按钮，该按钮绑定了@click="handleUpdate(scope.row)"所以点击这个按钮会执行handleUpdate(row)里的请求
2.在method的handleUpdate方法中发送异步请求根据ID查询图书信息（弹出编辑窗口并显示当前行的数据）
3.根据后台返回的结果，判断是否查询成功
如果查询成功打开修改面板回显数据，如果失败提示错误信息
4.修改完成后找到修改面板的”确定“按钮，该按钮绑定了@click="handleEdit()"所以点击这个按钮会执行handleEdite()里的请求
5.在method的handleEdit方法中发送异步请求提交修改数据
6.根据后台返回的结果，判断是否修改成功
如果成功提示错误信息，关闭修改面板，重新查询数据，如果失败提示错误信息

scope.row代表的是当前行的行数据，也就是说,scope.row就是选中行对应的json数据，如下:

{
    "id": 1,
    "type": "计算机理论",
    "name": "Spring实战 第五版",
    "description": "Spring入门经典教程，深入理解Spring原理技术内幕"
}

【步骤一】：修改handleUpdate方法:弹出编辑窗口并显示当前行的数据

//弹出编辑窗口
handleUpdate(row) {
    // console.log(row);   //row.id 查询条件
    //查询数据，根据当前行数据的id查询并展示在编辑窗口的文本框（formData中）
    axios.get("/books/"+row.id).then((res)=>{//表示绑定了handleUpdate的按钮点击后发送的是这个请求
        if(res.data.code == 20041){//查询成功
            //展示弹层，加载数据
            this.formData = res.data.data;//将查询数据展示在编辑窗口的文本框中
            this.dialogFormVisible4Edit = true;//编辑窗口可视化
       }else{
            this.$message.error(res.data.msg);//查询失败返回错误信息
       }
   });
}

【步骤二】：修改handleEdit方法，与添加操作基本无异

handleEdit() {
    //发送ajax请求
    axios.put("/books",this.formData).then((res)=>{
        //如果操作成功，关闭弹层，显示数据
        if(res.data.code == 20031){
            this.dialogFormVisible4Edit = false;
            this.$message.success("修改成功");
       }else if(res.data.code == 20030){
            this.$message.error("修改失败");
       }else{
            this.$message.error(res.data.msg);
       }
   }).finally(()=>{
        this.getAll();
   });
}

前后台协议联调（删除功能）

在这里插入图片描述

需求:完成页面的删除功能。
1.找到页面的"删除"按钮，按钮上绑定了@click="handleDelete(scope.row)"所以点击这个按钮会执行handleDelete()里的请求
2.method的handleDelete方法弹出提示框
3.用户点击取消,提示操作已经被取消。
4.用户点击确定，发送异步请求并携带需要删除数据的主键ID
5.根据后台返回结果做不同的操作
如果返回成功，提示成功信息，并重新查询数据
如果返回成功，提示成功信息，并重新查询数据

修改handleDelete方法：this.$confirm(弹出提示框).then(()=>{删除业务实现}).catch(()=>{取消删除，弹出提示信息})

handleDelete(row) {
    //1.弹出提示框
    this.$confirm("此操作永久删除当前数据，是否继续？","提示",{
        type:'info'
   }).then(()=>{
        //2.做删除业务
        axios.delete("/books/"+row.id).then((res)=>{
            if(res.data.code == 20021){
                this.$message.success("删除成功");
           }else{
                this.$message.error("删除失败");
           }
       }).finally(()=>{
            this.getAll();//删除后立即查询所有，起到刷新的作用
       });
   }).catch(()=>{
        //3.取消删除
        this.$message.info("取消删除操作");
   });
}

SSM整合整个前端页面展示

在这里插入图片描述

拦截器

拦截器简介

在这里插入图片描述

(1)浏览器发送一个请求会先到Tomcat的web服务器
(2)Tomcat服务器接收到请求以后，会去判断请求的是静态资源还是动态资源
(3)如果是静态资源，会直接到Tomcat的项目部署目录下去直接访问
(4)如果是动态资源，就需要交给项目的后台代码进行处理
(5)在找到具体的方法之前，我们可以去配置过滤器(可以配置多个)，按照顺序进行执行
(6)然后进入到到中央处理器(SpringMVC中的内容)，SpringMVC会根据配置的规则进行拦截
(7)如果满足规则，则进行处理，找到其对应的controller类中的方法进行执行,完成后返回结果
(8)如果不满足规则，则不进行处理
(9)这个时候，如果我们需要在每个Controller方法执行的前后添加业务，具体该如何来实现?
这个就是拦截器要做的事。

【概念】：拦截器（Interceptor）是一种动态拦截方法调用的机制，在SpringMVC中动态拦截控制器方法的执行
【作用】：

在指定的方法调用前后执行预先设定的代码
阻止原始方法的执行
总结：拦截器就是用来做增强

【拦截器和过滤器的区别】：

归属不同：Filter属于Servlet技术，Interceptor属于SpringMVC技术
拦截内容不同：Filter对所有访问进行增强，Interceptor仅针对SpringMVC的访问进行增强

在这里插入图片描述

拦截器入门案例

【在上面环境的基础上创建工作目录】：
在这里插入图片描述
【开发流程】：
步骤一：在controller.interceptor目录下创建拦截器类ProjectInterceptor并且继承接口HandlerInterceptor实现里面的方法（方法具体的作用在下面注释中）

@Component
//定义拦截器类，实现HandlerInterceptor接口
//注意当前类必须受Spring容器控制
public class ProjectInterceptor implements HandlerInterceptor {
    @Override
    //原始方法调用前执行的内容
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...");
        return true;//是否使得原始方法和后面的postHandle、afterCompletion方法终止
   }
    @Override
    //原始方法调用后执行的内容
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");
   }
    @Override
    //原始方法调用完成后执行（在postHandle后执行）的内容
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...");
   }
}

注意:拦截器类要被SpringMVC容器扫描到。
步骤二：配置拦截器类（registry.addInterceptor(projectInterceptor).addPathPatterns("/books"，"/books/*" );指我们配置的拦截器拦截访问 /books结尾的资源请求和以 /books/……结尾的资源请求，）

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Autowired
    private ProjectInterceptor projectInterceptor;
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
       registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
   }
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        //配置拦截器
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books"，"/books/*" );//指我们配置的拦截器拦截访问/books结尾资源和以/books/……结尾的请求，
   }
}

步骤三：SpringMVC添加SpringMvcSupport包扫描

@Configuration
@ComponentScan({"com.itheima.controller","com.itheima.config"})
@EnableWebMvc
public class SpringMvcConfig{
}

步骤四：:简化SpringMvcSupport的编写

@Configuration
@ComponentScan({"com.itheima.controller"})
@EnableWebMvc
//实现WebMvcConfigurer接口可以简化开发，但具有一定的侵入性
public class SpringMvcConfig implements WebMvcConfigurer {
    @Autowired
    private ProjectInterceptor projectInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //配置多拦截器
		registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
   }
}

此后咱们就不用再写SpringMvcSupport类了。最后我们来看下拦截器的执行流程:
在这里插入图片描述

拦截器参数

【前置处理方法的参数说明】：
在这里插入图片描述
使用request对象可以获取请求数据中的内容，如获取请求头的Content-Type

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    String contentType = request.getHeader("Content-Type");
    System.out.println("preHandle..."+contentType);
    return true;
}

使用handler参数，可以获取原始方法的相关信息

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    HandlerMethod hm = (HandlerMethod)handler;
    String methodName = hm.getMethod().getName();//可以获取方法的名称
    System.out.println("preHandle..."+methodName);
    return true;
}

【后置处理方法的参数说明】：
在这里插入图片描述
【完成处理方法的参数说明】：

拦截器链配置

【问题】：目前，我们在项目中只添加了一个拦截器，如果有多个，该如何配置?配置多个后，执行顺序是什么?
【配置多个拦截器】：
步骤一：创建拦截器类，实现接口，并重写接口中的方法

@Component

public class ProjectInterceptor2 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...222");
        return false;
   }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...222");
   }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...222");
   }
}

步骤二:配置拦截器类

@Configuration
@ComponentScan({"com.itheima.controller"})
@EnableWebMvc
//实现WebMvcConfigurer接口可以简化开发，但具有一定的侵入性
public class SpringMvcConfig implements WebMvcConfigurer {
    @Autowired
    private ProjectInterceptor projectInterceptor;
    @Autowired
    private ProjectInterceptor2 projectInterceptor2;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //配置多拦截器
		registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
        registry.addInterceptor(projectInterceptor2).addPathPatterns("/books","/books/*");

小结：
在这里插入图片描述

Maven

分模块开发的意义

在这里插入图片描述

分模块开发与设计

根据分模块开发的意义，我们可以将domain作为一个单独的模块（放在一个新目录【maven_03_pojo】下）开发，并且原来的模块【maven_02_ssm】可以通过导入依赖坐标的形式使用到domain里面的类，具体步骤如下：
【步骤一】：创建工作环境
在这里插入图片描述
【步骤二】：抽取domain层，创建新模块（创建一个名称为maven_03_pojo的jar项目,为什么项目名是从02到03这样创建，原因后面我们会提到，这块的名称可以任意。）

【步骤三】：项目中创建domain包（在maven_03_pojo项目中创建com.itheima.domain包，并将maven_02_ssm中Book类拷贝到该包中）
在这里插入图片描述
【步骤四】：删除原项目中的domain包，删除后，maven_02_ssm项目中用到Book的类中都会有红色提示，如下:

说明:出错的原因是maven_02_ssm中已经将Book类删除，所以该项目找不到Book类，所以报错，要想解决上述问题，我们需要在maven_02_ssm中添加maven_03_pojo的依赖。

【步骤五】：建立依赖关系，在maven_02_ssm项目的pom.xml添加maven_03_pojo的依赖

<dependency>
    <groupId>com.itheima</groupId>
    <artifactId>maven_03_pojo</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

因为添加了依赖，所以在maven_02_ssm中就已经能找到Book类，所以刚才的报红提示就会消失。

【步骤六】：编译maven_02_ssm项目，编译maven_02_ssm你会在控制台看到如下错误
在这里插入图片描述
错误信息为：不能解决maven_02_ssm项目的依赖问题，找不到maven_03_pojo这个jar包。
为什么找不到呢?
原因是Maven会从本地仓库找对应的jar包，但是本地仓库又不存在该jar包所以会报错。在IDEA中是有maven_03_pojo这个项目，所以我们只需要将maven_03_pojo项目安装到本地仓库即可。

【步骤七】：将项目安装本地仓库，将需要被依赖的项目maven_03_pojo，使用maven的install命令，把其安装到Maven的本地仓库中。
在这里插入图片描述
【小结】：实际开发中会有抽取很多模块，它们之间会相会依赖调用，都可以通过以上流程实现

依赖传递

【依赖传递】：
回到我们刚才的项目案例中，打开Maven的面板，你会发现:
在这里插入图片描述
在项目所依赖的这些jar包中，有一个比较大的区别就是有的依赖前面有箭头> ,有的依赖前面没有。那么这个箭头所代表的含义是什么?
打开前面的箭头，你会发现这个jar包下面还包含有其他的jar包

你会发现有两个maven_03_pojo的依赖被加载到Dependencies中，那么maven_04_dao中的maven_03_pojo能不能使用呢?
要想验证非常简单，只需要把maven_02_ssm项目中pom.xml关于maven_03_pojo的依赖注释或删除掉

在Dependencies中移除自己所添加maven_03_pojo依赖后，打开BookServiceImpl的类，你会发现Book类依然存在，可以被正常使用

这个特性其实就是我们要讲解的依赖传递。

【依赖冲突】：
在这里插入图片描述

可选依赖与排除依赖

在这里插入图片描述
【方案一:可选依赖】

【方案二:排除依赖】

聚合

在这里插入图片描述
【步骤1】:创建一个空的maven项目

【步骤2】:将项目的打包方式改为pom

【步骤3】：pom.xml添加所要管理的项目

【步骤4】:使用聚合统一管理项目

继承

【问题说明】：与下面的执行流程无关
在这里插入图片描述
【提取所有的公共依赖（所有子项目都继承父项目的依赖）】
步骤一：创建一个空的Maven项目（maven_01_parent）并将其打包方式设置为pom
因为这一步和前面maven创建聚合工程的方式是一摸一样，所以我们可以单独创建一个新的工程，也可以直接和聚合公用一个工程。实际开发中，聚合和继承一般也都放在同一个项目中，但是这两个的功能是不一样的。
步骤二：在子项目中设置其父工程（分别在maven_02_ssm , maven_03_pojo , maven_04_dao的pom.xml中添加其父项目为
maven_01_parent）
在这里插入图片描述
步骤三：优化子项目共有依赖导入问题（简化配置），将子项目共同使用的jar包都抽取出来，维护在父项目的pom.xml中

步骤四：删除三个子项目中已经被抽取到父项目的pom.xml中的jar包，这样子项目所有公共依赖都放入了父项目中简化了子项目的开发

【提供子项目可选依赖（子项目可以根据需求选择性继承父项目的依赖）】
问题说明（与下面的执行流程）无关：
在这里插入图片描述
步骤一：在父工程mavne_01_parent的pom.xml来定义依赖管理（管理junit依赖）

步骤二：将maven_02_ssm的pom.xml中的junit依赖删除掉，刷新Maven
刷新完会发现，在maven_02_ssm项目中的junit依赖并没有出现，所以我们得到一个结论:
<dependencyManagement>标签不真正引入jar包，而是配置可供子项目选择的jar包依赖；子项目要想使用它所提供的这些jar包，需要自己添加依赖，并且不需要指定<version>

步骤三：在maven_02_ssm的pom.xml添加junit的依赖
在这里插入图片描述
这样就可以使得maven_02_ssm单独继承父项目的junit依赖，其他的子项目也可以通过这种方式获取依赖

属性

【问题】：
前面我们已经在父工程中的dependencyManagement标签中对项目中所使用的jar包版本进行了统一的管理，但是如果在标签中有如下的内容:
在这里插入图片描述
你会发现，如果我们现在想更新Spring的版本，你会发现我们依然需要更新多个jar包的版本，这样的话还是有可能出现漏改导致程序出问题，而且改起来也是比较麻烦。
问题清楚后，我们需要解决的话，就可以参考咱们java基础所学习的变量，声明一个变量，在其他地方使用该变量，当变量的值发生变化后，所有使用变量的地方，就会跟着修改，即:
在这里插入图片描述
【解决步骤】：
步骤1:父工程中定义属性

步骤2:修改依赖的version

配置文件加载属性

在这里插入图片描述

版本管理

在这里插入图片描述

多环境开发

【问题】：
在这里插入图片描述
我们平常都是在自己的开发环境进行开发，当开发完成后，需要把开发的功能部署到测试环境供测试人员进行测试使用，等测试人员测试通过后，我们会将项目部署到生成环境上线使用。
这个时候就有一个问题是，不同环境的配置是不相同的，如不可能让三个环境都用一个数据库，所以就会有三个数据库的url配置，我们在项目中如何配置?要想实现不同环境之间的配置切换又该如何来实现呢?

【实现流程】：
步骤一：父工程配置多个环境,并指定默认激活环境（记得删除配置属性中重复的jdbc.url）
在这里插入图片描述

在这里插入图片描述
步骤二:切换默认环境为生产环境

步骤三:命令行实现环境切换

跳过测试

【问题】：
在这里插入图片描述
【方式一】:IDEA工具实现跳过测试

【方式二】:配置插件实现跳过测试

【方式三】:命令行跳过测试

私服简介与安装

【简介】：
团队开发现状分析
在这里插入图片描述

(1)张三负责ssm_crm的开发，自己写了一个ssm_pojo模块，要想使用直接将ssm_pojo安装到本地
仓库即可
(2)李四负责ssm_order的开发，需要用到张三所写的ssm_pojo模块，这个时候如何将张三写的ssm_pojo模块交给李四呢?
(3)如果直接拷贝，那么团队之间的jar包管理会非常混乱而且容器出错，这个时候我们就想能不能将写好的项目上传到中央仓库，谁想用就直接联网下载即可
(4)Maven的中央仓库不允许私人上传自己的jar包,那么我们就得换种思路，自己搭建一个类似于中央仓库的东西，把自己的内容上传上去，其他人就可以从上面下载jar包使用
(5)这个类似于中央仓库的东西就是我们接下来要学习的私服

所以到这就有两个概念，一个是私服，一个是中央仓库
私服:公司内部搭建的用于存储Maven资源的服务器
远程仓库:Maven开发团队维护的用于存储Maven资源的服务器

所以说:
私服是一台独立的服务器，用于解决团队内部的资源共享与资源同步问题
搭建Maven私服的方式有很多，我们来介绍其中一种使用量比较大的实现方式:Nexus(Sonatype公司的一款maven私服产品)
下载地址： https://help.sonatype.com/repomanager3/download

私服仓库分类

【私服资源操作流程分析】：
在这里插入图片描述

(1)在没有私服的情况下，我们自己创建的服务都是安装在Maven的本地仓库中
(2)私服中也有仓库，我们要把自己的资源上传到私服，最终也是放在私服的仓库中
(3)其他人要想使用你所上传的资源，就需要从私服的仓库中获取
(4)当我们要使用的资源不是自己写的，是远程中央仓库有的第三方jar包，这个时候就需要从远程中央仓库下载，每个开发者都去远程中央仓库下速度比较慢(中央仓库服务器在国外)
(5)私服就再准备一个仓库，用来专门存储从远程中央仓库下载的第三方jar包，第一次访问没有就会去远程中央仓库下载，下次再访问就直接走私服下载
(6)前面在介绍版本管理的时候提到过有SNAPSHOT和RELEASE，如果把这两类的都放到同一个仓库，比较混乱，所以私服就把这两个种jar包放入不同的仓库
(7)上面我们已经介绍了有三种仓库，一种是存放SNAPSHOT的，一种是存放RELEASE还有一种是存放从远程仓库下载的第三方jar包，那么我们在获取资源的时候要从哪个仓库种获取呢?
(8)为了方便获取，我们将所有的仓库编成一个组，我们只需要访问仓库组去获取资源。

所有私服仓库总共分为三大类:
宿主仓库hosted:保存无法从中央仓库获取的资源
-自主研发
-第三方非开源项目,比如Oracle,因为是付费产品，所以中央仓库没有

代理仓库proxy:
代理远程仓库，通过nexus访问其他公共仓库，例如中央仓库

仓库组group:
-将若干个仓库组成一个群组，简化配置
-仓库组不能保存资源，属于设计型仓库
在这里插入图片描述

本地仓库访问私服配置

我们通过IDEA将开发的模块上传到私服，中间是要经过本地Maven的
本地Maven需要知道私服的访问地址以及私服访问的用户名和密码
私服中的仓库很多，Maven最终要把资源上传到哪个仓库?
Maven下载的时候，又需要携带用户名和密码到私服上找对应的仓库组进行下载，然后再给IDEA

在这里插入图片描述

上面所说的这些内容，我们需要在本地Maven的配置文件settings.xml中进行配置。

【配置流程】
步骤一：私服上配置仓库
在这里插入图片描述
说明:
第5，6步骤是创建itheima-snapshot仓库
第7，8步骤是创建itheima-release仓库

步骤二:配置本地Maven对私服的访问权限

<servers>
    <server>
        <id>itheima-snapshot</id>
        <username>admin</username>
        <password>admin</password>
    </server>
    <server>
        <id>itheima-release</id>
        <username>admin</username>
        <password>admin</password>
    </server>
</servers>

步骤三:配置私服的访问路径

<mirrors>
    <mirror>
        <!--配置仓库组的ID-->
        <id>maven-public</id>
        <!--*代表所有内容都从私服获取-->
        <mirrorOf>*</mirrorOf>
        <!--私服仓库组maven-public的访问路径-->
        <url>http://localhost:8081/repository/maven-public/</url>
    </mirror>
</mirrors>

为了避免阿里云Maven私服地址的影响，建议先将之前配置的阿里云Maven私服镜像地址注释掉，等练习完后，再将其恢复。

在这里插入图片描述
至此本地仓库就能与私服进行交互了。

私服资源上传与下载

本地仓库与私服已经建立了连接，接下来我们就需要往私服上上传资源和下载资源，具体的实现步骤为:

【步骤一】：配置工程上传私服的具体位置

<!--配置当前工程保存在私服中的具体位置-->
<distributionManagement>
    <repository>
        <!--和maven/settings.xml中server中的id一致，表示使用该id对应的用户名和密码-->
        <id>itheima-release</id>
         <!--release版本上传仓库的具体地址-->
        <url>http://localhost:8081/repository/itheima-release/</url>
    </repository>
    <snapshotRepository>
        <!--和maven/settings.xml中server中的id一致，表示使用该id对应的用户名和密码-->
        <id>itheima-snapshot</id>
        <!--snapshot版本上传仓库的具体地址-->
        <url>http://localhost:8081/repository/itheima-snapshot/</url>
    </snapshotRepository>
</distributionManagement>

【步骤二】：发布资源到私服
在这里插入图片描述
或者执行Maven命令

mvn deploy

注意：要发布的项目都需要配置distributionManagement标签，要么在自己的pom.xml中配置，要么在其父项目中配置，然后子项目中继承父项目即可。

【步骤三】：查看结果
发布成功，在私服中就能看到:
在这里插入图片描述
现在发布是在itheima-snapshot仓库中，如果想发布到itheima-release仓库中就需要将项目pom.xml中的version修改成RELEASE即可。

如果想删除已经上传的资源，可以在界面上进行删除操作:
在这里插入图片描述
如果私服中没有对应的jar，会去中央仓库下载，速度很慢。可以配置让私服去阿里云中下载依赖。

至此私服的搭建就已经完成，相对来说有点麻烦，但是步骤都比较固定，后期大家如果需要的话，就可以参考上面的步骤一步步完成搭建即可。

～勇～

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【SSM框架（中）-SpringMVC、Maven】

SpringMVC技术与Servlet技术功能等同，均属于web层开发技术，但是SpringMVC能简化Servlet开发【Servlet开发】：【SpringMVC开发】：【学习内容以及重点】：【内容】：【框架图】：MVC：MVC（Model View Controller）是软件工程中的一种软件架构模式，它把软件系统分为模型（Model）、视图（View）和控制器（Controller）三个基本部分。用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性
复制链接

扫一扫