3. SpringMVC
3.1 了解SpringMVC
概述
SpringMVC技术与Servlet技术功能等同，均属于web层开发技术
学习路线
请求与响应
REST分割
SSM整合
拦截器
目标：
掌握基于SpringMVC获取请求参数与响应json数据操作
熟练应用基于REST风格的请求路径设置与参数传递
能够根据实际业务建立前后端开发通信协议并进行实现
基于SSM整合技术开发任意业务模块功能
3.2 SpringMVC简介
3.2.1 SpringMVC概述
SpringMVC是一种基于Java实现MVC模型的轻量级Web框架
优点
使用简单，开发便捷（相比于Servlet）
灵活性强
3.2.2 SpringMVC入门案例
使用SpringMVC需要先导入SpringMVC坐标与Servlet坐标
<dependencies>
<!--1.导入坐标-->
<!--Servlet-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<!--由于可能会和tomcat插件冲突，添加范围provided-->
<scope>provided</scope>
</dependency>
<!--SpringMVC-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
</dependencies>
创建SpringMVC控制器类（等同于Servlet功能）
//2.定义controller
//2.1 使用@Controller定义bean
@Controller
public class UserController {
//2.2 设置当前操作的访问路径
@RequestMapping("/save")
//2.3 设置当前操作的返回值类型
@ResponseBody
public String save(){
System.out.println("user save..");
return "{'module':'Spring MVC'}";
}
}
初始化SpringMVC环境（同Spring环境），设定SpringMVC加载对应Bean
//3.创建SpringMVC的配置文件，加载Controller对应的bean
@Configuration
@ComponentScan("com.mark.controller")
public class SpringMVC {
}
初始化Servlet容器，加载SpringMVC环境，并设置SpringMVC技术处理的请求
//4.定义一个Servlet容器启动的配置类，在里面加载Spring的配置，告知服务器使用SpringMVC
public class ServletContainerInitConfig extends AbstractDispatcherServletInitializer {
//加载SpringMVC容器配置
@Override
protected WebApplicationContext createServletApplicationContext() {
//原来Spring获取容器：ApplicationContext ctx= new AnnotationConfigApplicationContext()
//获取容器
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
//注册配置
ctx.register(SpringMVCConfig.class);
return ctx;
}
//设置哪些请求归属SpringMVC处理
@Override
protected String[] getServletMappings() {
//所有请求都归SpringMVC处理
return new String[]{"/"};
}
//加载Spring容器配置
@Override
protected WebApplicationContext createRootApplicationContext() {
return null;
}
}
注意：此时web.xml可以删除，之后配置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>
这时浏览器访问http://localhost/save 即可看到结果 {'module':'Spring MVC'}
3.2.3 注解介绍
@Controller
类型：类注解
位置：SpringMVC控制器类定义上方
作用：设定SpringMVC的核心控制器bean
范例：
@Controller
public class UserController {
}
@RequestMapping
类型：方法注解
位置：SpringMVC控制器方法定义上方
作用：设置当前控制器方法请求访问路径
范例：
@RequestMapping("/save")
public void save(){
System.out.println("user save ...");
}
相关属性
value（默认）：请求访问路径
@ResponseBody
类型：方法注解
位置：SpringMVC控制器方法定义上方
作用：设置当前控制器方法响应内容为当前返回值，无需解析
范例
@RequestMapping("/save")
@ResponseBody
public String save(){
System.out.println("user save ...");
return "{'info':'springmvc'}";
}
3.2.4 SpringMVC入门程序开发总结（1+N）
一次性工作
创建工程，设置服务器，加载工程
导入坐标
创建web容器启动类，加载SpringMVC配置，并设置SpringMVC请求拦截路径
SpringMVC核心配置类（设置配置类，扫描controller包，加载Controller控制器bean）
多次工作
定义处理请求的控制器类（@Controller）
定义处理请求的控制器方法，并配置映射路径（@RequestMapping）与返回json数据（@ResponseBody）
3.2.5 Servlet配置类详解
AbstractDispatcherServletInitializer类是SpringMVC提供的快速初始化Web3.0容器的抽象类
AbstractDispatcherServletInitializer提供三个接口方法供用户实现
createServletApplicationContext()方法：
创建Servlet容器时，加载SpringMVC对应的bean并放入WebApplicationContext对象范围中，而WebApplicationContext的作用范围为ServletContext范围，即整个web容器范围
@Override
protected WebApplicationContext createServletApplicationContext() {
//原来Spring获取容器：ApplicationContext ctx= new AnnotationConfigApplicationContext()
//获取容器
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
//注册配置
ctx.register(SpringMVCConfig.class);
return ctx;
}
getServletMappings()方法：
设定SpringMVC对应的请求映射路径，设置为/表示拦截所有请求，任意请求都将转入到SpringMVC进行处理
@Override
protected String[] getServletMappings() {
//所有请求都归SpringMVC处理
return new String[]{"/"};
}
createRootApplicationContext()方法：
如果创建Servlet容器时需要加载非SpringMVC对应的bean，使用当前方法进行，使用方式同createServletApplicationContext()。如果没有返回null即可
@Override
protected WebApplicationContext createRootApplicationContext() {
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
ctx.register(SpringConfig.class);
return ctx;
}
3.2.6 入门案例工作流程分析
启动服务器初始化过程
服务器启动，执行ServletContainersInitConfig类，初始化web容器
执行createServletApplicationContext方法，创建了WebApplicationContext对象
加载SpringMvcConfig
执行@ComponentScan加载对应的bean
加载UserController，每个@RequestMapping的名称对应一个具体的方法
执行getServletMappings方法，定义所有的请求都通过SpringMVC
单次请求过程
发送请求localhost/save
web容器发现所有请求都经过SpringMVC，将请求交给SpringMVC处理
解析请求路径/save
由/save匹配执行对应的方法save(）
执行save()
检测到有@ResponseBody直接将save()方法的返回值作为响应求体返回给请求方
3.2.7 Controller加载控制与业务bena加载控制
不同的bean由不同的容器管理
SpringMVC相关的bean：表现层bean
Spring控制的bean：
业务bean（Service）
功能bean（DataSource等）
因为功能不同，如何避免Spring错误的加载到SpringMVC的bean？
加载Spring控制的bean的时候排除掉SpringMVC控制的bean
不同bean的加载控制：
SpringMVC相关bean加载控制
SpringMVC加载的bean对应均在com.mark.controller包内
Spring相关bean加载控制
方式一：Spring加载的bean设定扫描范围为com.mark，排除掉controller包内的bean
@Configuration
//@ComponentScan({"com.mark.service","com.mark.dao"})
//扫描com.mark下的所有，但是按照注解排除掉使用了Controller注解的bean
@ComponentScan(value = "com.mark",
excludeFilters = @ComponentScan.Filter(
type = FilterType.ANNOTATION,
classes = Controller.class
)
)
public class SpringConfig {
}
方式二：Spring加载的bean设定扫描范围为精准范围，例如service包、dao包
@Configuration
@ComponentScan({"com.mark.service","com.mark.dao"})
public class SpringConfig {
}
方式三：不区分Spring与SpringMVC的环境，加载到同一个环境
相关注解介绍
@ComponentScan
类型：类注解
范例：
@Configuration
@ComponentScan(value = "com.mark",
excludeFilters = @ComponentScan.Filter(
type = FilterType.ANNOTATION,
classes = Controller.class
)
)
public class SpringConfig {
}
属性
excludeFilters：排除扫描路径中加载的bean，需要指定类别（type）与具体项（classes）
includeFilters：加载指定的bean，需要指定类别（type）与具体项（classes）
配置Web容器启动类改进、简化：继承AbstractAnnotationConfigDispatcherServletInitializer类
public class ServletContainerInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class[]{SpringConfig.class};
}
@Override
protected Class<?>[] getServletConfigClasses() {
return new Class[]{SpringMVCConfig.class};
}
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
}
3.2.8 PostMan
PostMan简介
PostMan是一款功能强大的网页调试与发送网页HTTP请求的Chrome插件
作用：常用于进行接口测试
特征：
简单
实用
美观
大方
PostMan基础操作
注册登录
创建/进入工作空间
发起请求测试结果
3.3 请求与响应
3.3.1 请求映射路径
思考：
团队多人开发，每个人设置不同的请求路径，冲突如何解决？
设置模块名作为请求路径前缀
@Controller
public class BookController {
@RequestMapping("/book/save")
@ResponseBody
public String save(){
System.out.println("book save ...");
return "{'module':'book save'}";
}
}
@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 delete() {
System.out.println("user delete ...");
return "{'module':'user delete'}";
}
}
注解介绍
名称：@RequestMapping
类型：方法注解 类注解
位置：SpringMVC控制器方法定义上方
作用：设置当前控制器方法请求访问路径，如果设置在类上统一设置当前控制器方法请求访问路径前缀
范例：
@Controller
@RequestMapping("/book")
public class BookController {
@RequestMapping("/save")
@ResponseBody
public String save() {
System.out.println("book save ...");
return "{'module':'book save'}";
}
}
属性
value（默认）：请求访问路径，或访问路径前缀
3.3.2 各种请求参数传递
请求方式
Get请求
Post请求
Get请求参数
普通参数：url地址传参，地址参数名与形参变量名相同，定义形参即可接收参数
@Controller
@RequestMapping("/user")
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':'common param'}";
}
}
请求参数名与形参变量名不同，使用@RequestParam绑定参数关系
@Controller
@RequestMapping("/user")
public class UserController {
//普通参数
@RequestMapping("/commonParam")
@ResponseBody
public String commonParam(@RequestParam("name") String username,int age){
System.out.println("普通参数传递 name ==>"+username);
System.out.println("普通参数传递 age ==>"+age);
return "{'module':'common param'}";
}
}
这时发送请求的名字为name，username可以接收到name的值
POJO参数：请求参数名与形参对象属性名相同，定义POJO类型形参即可接收参数
//POJO参数
@RequestMapping("/pojoParam")
@ResponseBody
public String pojoParam(User user){
System.out.println("POJO参数传递 user ==>"+user);
return "{'module':'pojo param'}";
}
嵌套POJO参数：POJO对象中包含POJO对象
请求参数名与形参对象属性名相同，按照对象层次结构关系即可接收嵌套POJO属性参数
public class User {
private String name;
private int age;
private Address address;
}
public class Address {
private String province;
private String city;
}
数组参数：请求参数名与形参数组名相同且请求参数为多个，定义数组类型形参即可接收参数
@RequestMapping("arrayParam")
@ResponseBody
public String arrayParam(String[] hobby){
System.out.println(("数组参数传递 hobby ==> "+ Arrays.toString(hobby)));
return "{'module':'array param'}";
}
集合保存普通参数：请求参数名与形参集合对象名相同且请求参数为多个，@RequestParam绑定参数关系
@RequestMapping("listParam")
@ResponseBody
public String listParam(@RequestParam List<String> hobby){
System.out.println("集合参数传递 hobby ==> "+ hobby);
return "{'module':'list param'}";
}
Post请求参数
普通参数：form表单post请求传参，表单参数名与形参变量名相同，定义形参即可接收参数，代码与Get相同。
Post请求中文乱码处理
在Servlet启动类配置中添加过滤器
//乱码处理
@Override
protected Filter[] getServletFilters() {
CharacterEncodingFilter filter = new CharacterEncodingFilter();
filter.setEncoding("UTF-8");
return new Filter[]{filter};
}
其他类型与Get方式规则一样
3.3.3 响应json数据
添加json数据转换相关坐标
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
设置发送json数据（请求body中添加json数据）
开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
@Configuration
@ComponentScan("com.mark.controller")
@EnableWebMvc
public class SpringMvcConfig {
}
使用@RequestBody注解将外部传递的json数组数据映射到形参的集合对象中作为数据
集合类数据：
@RequestMapping("/listParamForJson")
@ResponseBody
public String listParamForJson(@RequestBody List<String> hobby){
System.out.println("list common(json)参数传递 list ==> "+hobby);
return "{'module':'list common for json param'}";
}
POJO类数据：json数据与形参对象属性名相同，定义POJO类型形参即可接收参数
@RequestMapping("/pojoParamForJson")
@ResponseBody
public String pojoParamForJson(@RequestBody User user){
System.out.println("pojo(json)参数传递 user ==> "+user);
return "{'module':'pojo for json param'}";
}
POJO集合参数
@RequestMapping("/listPojoParamForJson")
@ResponseBody
public String listPojoParamForJson(@RequestBody List<User> list){
System.out.println("list pojo(json)参数传递 list ==> "+list);
return "{'module':'list pojo for json param'}";
}
3.3.4 日期类型参数传递
日期类型数据基于不同系统 格式也不尽相同
2000-04-18
2000/04/18
04/18/2000
接收形参时，根据不同的日期格式设置不同的接收方式，默认格式：yyyy/MM/dd。实用@DateTimeFormat设定日期时间型数据格式，属性：pattern = 日期时间格式字符串
@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'}";
}
/*
参数传递 date ==> Tue Apr 18 00:00:00 CST 2000
参数传递 date1(yyyy-MM-dd) ==> Tue Apr 18 00:00:00 CST 2000
参数传递 date2(yyyy/MM/dd HH:mm:ss) ==> Tue Apr 18 00:05:20 CST 2000
*/
3.3.5 响应
响应页面（了解）
返回值为String类型，设置返回值为页面名称，即可实现页面跳转
@RequestMapping("/toJumpPage")
public String toJumpPage(){
System.out.println("跳转页面");
return "page.jsp";
}
响应数据
文本数据（了解）
返回值为String类型，设置返回值为任意字符串信息，即可实现返回指定字符串信息，需要依赖@ResponseBody注解
@RequestMapping("/toText")
@ResponseBody
public String toText(){
System.out.println("返回纯文本数据");
return "response text";
}
json数据（重点）
响应POJO对象
返回值为实体类对象，设置返回值为实体类类型，即可实现返回对应对象的json数据，需要依赖@ResponseBody注解和@EnableWebMvc注解
@RequestMapping("/toJsonPOJO")
@ResponseBody
public User toJsonPOJO(){
System.out.println("返回json对象数据");
User user = new User();
user.setName("itcast");
user.setAge(15);
return user;
}
响应POJO集合对象
返回值为集合对象，设置返回值为集合类型，即可实现返回对应集合的json数组数据，需要依赖@ResponseBody注解和@EnableWebMvc注解
@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;
}
3.4 REST风格
3.4.1 REST风格简介
REST（Representational State Transfer），表现形式状态转换
传统风格资源描述形式
http://localhost/user/getById?id=1
http://localhost/user/saveUser
REST风格描述形式
http://localhost/user/1
http://localhost/user
优点：
书写简化
隐藏资源的访问行为，无法通过地址得知对资源是何种操作
按照REST风格访问资源时使用行为动作区分对资源进行了何种操作
http://localhost/users：查询全部用户信息 GET（查询）
http://localhost/users/1：查询指定用户信息 GET（查询）
http://localhost/users：添加用户信息 POST（新增/保存）
http://localhost/users：修改用户信息 PUT（修改/更新）
http://localhost/users/1：删除用户信息 DELETE（删除）
上述行为是约定方式，约定不是规范，可以打破，所以称REST风格，而不是REST规范。
描述模块的名称通常使用复数，也就是加s的格式描述，表示此类资源，而非单个资源，例如：users、books、accounts……
根据REST风格对资源进行访问称为RESTful
3.4.2 RESTful入门案例
步骤：
修改@RequestMapping路径为模块名称复数
@RequestMapping("/users")
设置请求行为（http请求动作）
@RequestMapping(value = "/users",method = RequestMethod.POST)
设定请求参数（路径变量）
@RequestMapping(value = "/users/{id}",method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id) {
System.out.println("user delete..." + id);
return "{'module':'user delete'}";
}
实现：
@Controller
public class UserController {
//设置当前请求方法为POST，表示REST风格中的添加操作
@RequestMapping(value = "/users",method = RequestMethod.POST)
@ResponseBody
public String save(@RequestBody User user) {
System.out.println("user save..."+user);
return "{'module':'user save'}";
}
//设置当前请求方法为DELETE，表示REST风格中的删除操作
//@PathVariable注解用于设置路径变量（路径参数），要求路径上设置对应的占位符，并且占位符名称与方法形参名称相同
@RequestMapping(value = "/users/{id}",method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id) {
System.out.println("user delete..." + id);
return "{'module':'user delete'}";
}
//设置当前请求方法为PUT，表示REST风格中的修改操作
@RequestMapping(value = "/users",method = RequestMethod.PUT)
@ResponseBody
public String update(@RequestBody User user) {
System.out.println("user update..." + user);
return "{'module':'user update'}";
}
//设置当前请求方法为GET，表示REST风格中的查询操作
//@PathVariable注解用于设置路径变量（路径参数），要求路径上设置对应的占位符，并且占位符名称与方法形参名称相同
@RequestMapping(value = "/users/{id}",method = RequestMethod.GET)
@ResponseBody
public String getById(@PathVariable Integer id) {
System.out.println("user getById..." + id);
return "{'module':'user getById'}";
}
//设置当前请求方法为GET，表示REST风格中的查询操作
@RequestMapping( value = "/users",method = RequestMethod.GET)
@ResponseBody
public String getAll() {
System.out.println("user getAll...");
return "{'module':'user getAll'}";
}
}
POST、DELETE、PUT、GET分别对应增删改查
@PathVariable注解用于设置路径变量（路径参数），要求路径上设置对应的占位符，并且占位符名称与方法形参名称相同
截至目前，见到过的接收参数注解有三种
@RequestParam：用于接收url地址传参或表单传参 绑定参数
@RequestBody：用于接收json数据映射到形参中作为数据
@PathVariable：用于接收路径参数，@RequestMapping中使用{参数名称}描述路径参数
应用
后期开发中，发送请求参数超过1个时，以json格式为主，@RequestBody应用较广
采用RESTful进行开发，当参数数量较少时，例如1个，可以采用@PathVariable接收请求路径变量，通常用于传递id值
如果发送非json格式数据，选用@RequestParam接收请求参数
3.4.3 REST快速开发
在上面的案例中，有很多重复编写的代码
将每个方法的value中的模块名提取到类前
将每个方法的@ResponseBody提取到类前
而类的@Controller和@ResponseBody可以合并成@RestController
每个方法@PostMapping中的请求行为设置可以用对应的@xxxMapping注解替换
//@Controller
//@ResponseBody配置在类上可以简化配置，表示设置当前每个方法的返回值都作为响应体
//@ResponseBody
@RestController//使用@RestController注解替换@Controller与@ResponseBody注解，简化书写
@RequestMapping("/books")
public class BookController {
//@RequestMapping( method = RequestMethod.POST)
@PostMapping//使用@PostMapping简化Post请求方法对应的映射配置
public String save(@RequestBody Book book) {
System.out.println("book save..." + book);
return "{'module':'book save'}";
}
//@RequestMapping(value = "/{id}" ,method = RequestMethod.DELETE)
@DeleteMapping("/{id}")//使用@DeleteMapping简化DELETE请求方法对应的映射配置
public String delete(@PathVariable Integer id) {
System.out.println("book delete..." + id);
return "{'module':'book delete'}";
}
//@RequestMapping(method = RequestMethod.PUT)
@PutMapping//使用@PutMapping简化Put请求方法对应的映射配置
public String update(@RequestBody Book book) {
System.out.println("book update..." + book);
return "{'module':'book update'}";
}
//@RequestMapping(value = "/{id}" ,method = RequestMethod.GET)
@GetMapping("/{id}")//使用@GetMapping简化GET请求方法对应的映射配置
public String getById(@PathVariable Integer id) {
System.out.println("book getById..." + id);
return "{'module':'book getById'}";
}
//@RequestMapping(method = RequestMethod.GET)
@GetMapping//使用@GetMapping简化GET请求方法对应的映射配置
public String getAll() {
System.out.println("book getAll...");
return "{'module':'book getAll'}";
}
}
3.4.4 案例：基于RESTful页面数据交互
POSTMan实现后台接口开发
@RestController
@RequestMapping("/books")
public class BookController {
/**
* 保存新增数据
* @param book
* @return
*/
@PostMapping
public String save(@RequestBody Book book) {
System.out.println("book save" + book);
return "{'module':'book save success'}";
}
/**
* 获取全部
* @return
*/
@GetMapping
public List<Book> getAll() {
Book book1 = new Book();
book1.setType("计算机");
book1.setName("SpringMVC入门");
book1.setDescription("我是小白");
Book book2 = new Book();
book2.setType("计算机");
book2.setName("SpringMVC实战");
book2.setDescription("我是大佬");
List<Book> list = new ArrayList<Book>();
list.add(book1);
list.add(book2);
return list;
}
}
实现页面数据交互：
由于在访问静态资源页面时，SpringMVC的Sevlet容器配置中设置了protected String[] getServletMappings() { return new String[]{"/"};}会拦截所有请求，导致无法打开页面
因此创建SpringMvcSupport配置类，设置对静态资源的访问放行
@Configuration
public class SpringMVCSupport extends WebMvcConfigurationSupport {
@Override
protected void addResourceHandlers(ResourceHandlerRegistry registry) {
//当访问/pages/???的时候，不要走MVC，走/pages目录下的内容
registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
registry.addResourceHandler("/css/**").addResourceLocations("/css/");
registry.addResourceHandler("/js/**").addResourceLocations("/js/");
registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
}
}
前端页面通过异步提交访问后台控制器
//添加
saveBook() {
axios.post("/books", this.formData).then((res) => {
});
},
//主页列表查询
getAll() {
axios.get("/books").then((res) => {
this.dataList = res.data;
});
},
3.5 SSM整合
3.5.1 整合配置
创建工程
SSM整合
Spring
SpringConfig
@Configuration
@ComponentScan({"com.mark.service"})
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {}
MyBatis
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
public DataSource dataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(driver);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
}
}
MyBatisConfig
public class MybatisConfig {
@Bean
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
factoryBean.setDataSource(dataSource);
factoryBean.setTypeAliasesPackage("com.mark.domain");
return factoryBean;
}
@Bean
public MapperScannerConfigurer mapperScannerConfigurer() {
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("com.mark.dao");
return msc;
}
}
jdbc.properties
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_db
jdbc.username=root
jdbc.password=123
SpringMVC
SpringMVCConfig
@Configuration
@ComponentScan({"com.mark.controller","com.mark.config"})
@EnableWebMvc
public class SpringMvcConfig {}
ServletConfig
public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class[]{SpringConfig.class};
}
@Override
protected Class<?>[] getServletConfigClasses() {
return new Class[]{SpringMvcConfig.class};
}
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
@Override
protected Filter[] getServletFilters() {
CharacterEncodingFilter characterEncodingFilter =new CharacterEncodingFilter();
characterEncodingFilter.setEncoding("UTF-8");
return new Filter[]{characterEncodingFilter};
}
}
SpringMVCSupport
@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
@Override
protected void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
registry.addResourceHandler("/js/**").addResourceLocations("/js/");
registry.addResourceHandler("/css/**").addResourceLocations("/css/");
registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
}
}
3.5.2 功能模块开发
表与实体类
创建表：
-- ----------------------------
-- Table structure for tbl_book
-- ----------------------------
DROP TABLE IF EXISTS `tbl_book`;
CREATE TABLE `tbl_book` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`type` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`description` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 13 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of tbl_book
-- ----------------------------
INSERT INTO `tbl_book` VALUES (1, '计算机理论', 'Spring实战 第5版', 'Spring入门经典教程，深入理解Spring原理技术内幕');
INSERT INTO `tbl_book` VALUES (2, '计算机理论', 'Spring 5核心原理与30个类手写实战', '十年沉淀之作，手写Spring精华思想');
INSERT INTO `tbl_book` VALUES (3, '计算机理论', 'Spring 5 设计模式', '深入Spring源码剖析Spring源码中蕴含的10大设计模式');
INSERT INTO `tbl_book` VALUES (4, '计算机理论', 'Spring MVC+MyBatis开发从入门到项目实战', '全方位解析面向Web应用的轻量级框架，带你成为Spring MVC开发高手');
INSERT INTO `tbl_book` VALUES (5, '计算机理论', '轻量级Java Web企业应用实战', '源码级剖析Spring框架，适合已掌握Java基础的读者');
INSERT INTO `tbl_book` VALUES (6, '计算机理论', 'Java核心技术 卷I 基础知识（原书第11版）', 'Core Java 第11版，Jolt大奖获奖作品，针对Java SE9、10、11全面更新');
INSERT INTO `tbl_book` VALUES (7, '计算机理论', '深入理解Java虚拟机', '5个维度全面剖析JVM，大厂面试知识点全覆盖');
INSERT INTO `tbl_book` VALUES (8, '计算机理论', 'Java编程思想（第4版）', 'Java学习必读经典,殿堂级著作！赢得了全球程序员的广泛赞誉');
INSERT INTO `tbl_book` VALUES (9, '计算机理论', '零基础学Java（全彩版）', '零基础自学编程的入门图书，由浅入深，详解Java语言的编程思想和核心技术');
INSERT INTO `tbl_book` VALUES (10, '市场营销', '直播就该这么做：主播高效沟通实战指南', '李子柒、李佳琦、薇娅成长为网红的秘密都在书中');
INSERT INTO `tbl_book` VALUES (11, '市场营销', '直播销讲实战一本通', '和秋叶一起学系列网络营销书籍');
INSERT INTO `tbl_book` VALUES (12, '市场营销', '直播带货：淘宝、天猫直播从新手到高手', '一本教你如何玩转直播的书，10堂课轻松实现带货月入3W+');
实体类：
@Getter
@Setter
@ToString
public class Book {
private Integer id;
private String type;
private String name;
private String description;
}
创建好所有的接口和实现类
dao（接口+自动代理实现）
public interface BookDao {
//@Insert("insert into tbl_book values (null,#{type},#{name},#{description})")
//上面语句中type指的是Book类的属性名，id需要为null
//下面语句中第一个type指的是表里的属性名 第二个type指的是Book类的属性名，不需要为id赋值
/**
* 保存
* @param book
*/
@Insert("insert into tbl_book (type, name, description) values (#{type}, #{name}, #{description})")
public void save(Book book);
/**
* 修改/更新
* @param book
*/
@Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")
public void update(Book book);
/**
* 删除
* @param id
*/
@Delete("delete from tbl_book where id = #{id}")
public void delete(Integer id);
/**
* 根据id获取book
* @param id
* @return
*/
@Select("select id, type, name, description from tbl_book where id = #{id}")
public Book getById(Integer id);
/**
* 获取所有book
* @return
*/
@Select("select id, type, name, description from tbl_book")
public List<Book> getAll();
}
service（接口+实体类）
public interface BookService {
/**
* 保存
* @param book
*/
public boolean save(Book book);
/**
* 修改/更新
* @param book
*/
public boolean update(Book book);
/**
* 根据id删除
* @param id
*/
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;
@Override
public boolean save(Book book) {
bookDao.save(book);
return true;
}
@Override
public boolean update(Book book) {
bookDao.update(book);
return true;
}
@Override
public boolean delete(Integer id) {
bookDao.delete(id);
return true;
}
@Override
public Book getById(Integer id) {
//Book book = bookDao.getById(id);
//return book;
return bookDao.getById(id);
}
@Override
public List<Book> getAll() {
return bookDao.getAll();
}
}
controller
@RestController
@RequestMapping("/books")
public class BookController {
@Autowired
private BookService bookService;
/**
* 保存
* @param book
*/
@PostMapping
public boolean save(@RequestBody Book book) {
return bookService.save(book);
}
/**
* 修改/更新
* @param book
*/
@PutMapping
public boolean update(@RequestBody Book book) {
return bookService.update(book);
}
/**
* 根据id删除
* @param id
*/
@DeleteMapping("/{id}")
public boolean delete(@PathVariable Integer id) {
return bookService.delete(id);
}
/**
* 根据id查询
* @param id
* @return
*/
@GetMapping("/{id}")
public Book getById(@PathVariable Integer id) {
return bookService.getById(id);
}
/**
* 获取所有
* @return
*/
@GetMapping
public List<Book> getAll() {
return bookService.getAll();
}
}
3.5.3 接口测试
业务层接口测试（整合Junit）
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class BookServiceTest {
@Autowired
private BookService bookService;
@Test
public void testGetById() {
Book book = bookService.getById(2);
System.out.println(book);
}
@Test
public void testGetAll() {
List<Book> list = bookService.getAll();
System.out.println(list);
}
}
表现层接口测试（PostMan）
3.5.4 添加事务
在Spring配置类中打开使用注解式事务驱动@EnableTransactionManagement
在JDBC配置类中添加事务管理器配置PlatformTransactionManager
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
DataSourceTransactionManager ptm = new DataSourceTransactionManager();
ptm.setDataSource(dataSource);
return ptm;
}
给要添加事务的实现类的接口添加注解@Transactional
3.5.5 表现层数据封装协议
前端接收数据格式
增删改：true
查单条：
{
"id": 1,
"type": "计算机理论",
"name": "Spring实战 第5版",
"description": "Spring入门经典教程，深入理解Spring原理技术内幕"
}
查全部：
[
{
"id": 1,
"type": "计算机理论",
"name": "Spring实战 第5版",
"description": "Spring入门经典教程，深入理解Spring原理技术内幕"
},
{
"id": 2,
"type": "计算机理论",
"name": "Spring 5核心原理与30个类手写实战",
"description": "十年沉淀之作，手写Spring精华思想"
}
]
统一格式，前端接收数据格式：封装数据到data属性中，封装操作到code属性中，封装特殊消息到message（msg）属性中
增删改：
{
"code":20031
"data":true
}
查单条：
{
"code":20041
"data":{
"id": 1,
"type": "计算机理论",
"name": "Spring实战 第5版",
"description": "Spring入门经典教程，深入理解Spring原理技术内幕"
}
}
查单条数据为空
{
"code":20040
"data":null
"msg":"数据查询失败，请重试！"
}
查全部：
{
"code":20041
"data":[
{
"id": 1,
"type": "计算机理论",
"name": "Spring实战 第5版",
"description": "Spring入门经典教程，深入理解Spring原理技术内幕"
},
{
"id": 2,
"type": "计算机理论",
"name": "Spring 5核心原理与30个类手写实战",
"description": "十年沉淀之作，手写Spring精华思想"
}
]
}
设置统一数据返回结果类
public class Result {
private Object data;
private Integer code;
private String msg;
}
Result类中的字段并不是固定的，可以根据需要自行删减
提供若干个构造方法，方便操作
3.5.5 表现层与前端数据传输数据协议实现
添加Result结果数据
@Getter
@Setter
public class Result {
private Object data;
private Integer code;
private String msg;
public Result(Integer code, Object data, String msg) {
this.data = data;
this.code = code;
this.msg = msg;
}
public Result(Integer code, Object data) {
this.data = data;
this.code = code;
}
public Result() {
}
}
修改Controller的return数据
@RestController
@RequestMapping("/books")
public class BookController {
@Autowired
private BookService bookService;
/**
* 保存
* @param book
*/
@PostMapping
public Result save(@RequestBody Book book) {
boolean flag = bookService.save(book);
return new Result(flag ? Code.SAVE_OK : Code.SAVE_ERR, flag);
}
/**
* 修改/更新
* @param book
*/
@PutMapping
public Result update(@RequestBody Book book) {
boolean flag = bookService.update(book);
return new Result(flag ? Code.UPDATE_OK : Code.UPDATE_ERR, flag);
}
/**
* 根据id删除
* @param id
*/
@DeleteMapping("/{id}")
public Result delete(@PathVariable Integer id) {
boolean flag = bookService.delete(id);
return new Result(flag ? Code.DELETE_OK : Code.DELETE_ERR, flag);
}
/**
* 根据id查询
* @param id
* @return
*/
@GetMapping("/{id}")
public Result getById(@PathVariable Integer 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);
}
/**
* 获取所有
* @return
*/
@GetMapping
public Result getAll() {
List<Book> books = bookService.getAll();
Integer code = books.isEmpty() ? Code.GET_OK : Code.GET_ERR;
String msg = books.isEmpty() ? "" : "数据查询失败，请重试";
return new Result(code, books, msg);
}
}
3.5.6 异常处理器
程序开发过程中不可避免的会遇到异常现象
出现异常现象的常见位置与常见诱因如下
框架内部抛出的异常：因使用不合规导致
数据层抛出的异常：因外部服务器故障导致（例如：服务器访问超时）
业务层抛出的异常：因业务逻辑书写错误导致（例如：遍历业务书写操作，导致索引异常等）
表现层抛出的异常：因数据收集、校验等规则导致（例如：不匹配的数据类型间导致异常）
工具类抛出的异常：因工具类书写不严谨不够健壮导致（例如：必要释放的连接长期未释放等）
各个层级都会出现异常，异常处理代码书写在哪一层？
所有的异常均抛出到表现层进行处理
表现层处理异常，每个方法中单独书写，代码书写量巨大且意义不强，如何解决？
AOP思想
异常处理器
集中的、统一的处理项目中出现的异常
@RestControllerAdvice
public class ProjectExceptionAdvice {
@ExceptionHandler(Exception.class)
public Result doException(Exception ex){
System.out.println("异常别跑");
return new Result(666,null,"异常别跑");
}
}
@RestControllerAdvice：声明一个类作为异常处理器
@ExceptionHandler：定义当前方法处理哪一种异常
项目异常分类
业务异常(BusinessException)
规范的用户行为产生的异常
不规范的用户行为操作产生的异常
系统异常(SystemException)
项目运行过程中可预计且无法避免的异常
其他异常(Exception)
编程人员未预期到的异常
项目异常处理方案
业务异常(BusinessException)
发送对应消息传递给用户，提醒规范操作
系统异常(SystemException)
发送固定消息传递给用户，安抚用户
发送特定消息给运维人员，提醒维护
记录日志
其他异常(Exception)
发送固定消息传递给用户，安抚用户
发送特定消息给编程人员，提醒维护（纳入预期范围内）
记录日志
实现：
新建exception包
创建Exception类，自定义系统、业务级异常
@Getter
@Setter
public class SystemException extends RuntimeException {
private Integer code;
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;
}
}
@Getter
@Setter
public class BusinessException extends RuntimeException{
private Integer 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;
}
}
自定义异常编码
public class Code {
public static final Integer SYS_ERR = 50001;
public static final Integer SYS_TIMEOUT_ERR = 50002;
public static final Integer SYS_UNKNOW_ERR = 59999;
public static final Integer Business_ERR = 60002;
}
将可能出现的异常进行包装，转换成自定义异常，触发自定义异常
@Override
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.SYS_TIMEOUT_ERR,"服务器访问超时，请重试",e);
}
return bookDao.getById(id);
}
在异常处理器中分别进行处理
@RestControllerAdvice
public class ProjectExceptionAdvice {
@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());
}
@ExceptionHandler(Exception.class)
public Result doException(Exception ex){
//记录日志
//发送消息给运维
//发送邮件给开发文件,ex对象发送给开发人员
return new Result(Code.SYS_UNKNOW_ERR,null,"系统繁忙，请稍后再试");
}
}
3.5.7 前后台协议联调
列表功能
getAll() {
//发送ajax请求
axios.get("/books").then((res)=>{
this.dataList = res.data.data;
})
},
添加功能
//弹出添加窗口
handleCreate() {
this.dialogFormVisible = true;
},
//添加
handleAdd() {
//发送ajax请求
axios.post("/books", this.formData).then((res) => {
//console.log(res.data)
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 = {}
},
//弹出添加窗口
handleCreate() {
this.dialogFormVisible = true;
this.resetForm();
},
修改功能
//弹出编辑窗口
handleUpdate(row) {
//查询数据，根据id查询
axios.get("/books/"+row.id).then((res)=>{
if (res.data.code== 20041){
//展示弹层，加载数据
this.formData = res.data.data;
this.dialogFormVisible4Edit = true;
}else{
this.$message.error(res.data.msg)
}
})
},
//编辑
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();
})
},
删除功能
// 删除
handleDelete(row) {
//弹出提示框
this.$confirm("此操作不可逆，永久删除数据，是否继续", "提示", {
type: 'info'
}).then(() => {
//删除业务
//查询数据，根据id查询
axios.delete("/books/" + row.id).then((res) => {
if (res.data.code == 20021) {
this.$message.success("删除成功")
} else {
this.$message.error("删除失败")
}
}).finally(() => {
this.getAll();
});
}).catch(() => {
//取消删除
this.$message.info("取消删除操作")
});
}
3.6 拦截器
3.6.1 拦截器概念
拦截器（Interceptor）是一种动态拦截方法调用的机制，在SpringMVC中动态拦截控制器方法的执行
作用
在指定的方法调用前后执行预先设定的代码
组织原始方法的执行
拦截器和过滤器的区别
归属不同：Filter属于Servlet技术，Interceptor属于SpringMVC技术
拦截内容不同：Filter对所有访问进行增强，Interceptor仅针对SpringMVC的访问进行增强
3.6.2 入门案例
制作拦截器功能类：声明拦截器的bean，并实现HanderInterceptor接口（注意：扫描加载bean）
@Component
public class ProjectInterceptor implements HandlerInterceptor {
//在原始被拦截之前运行的代码
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("preHandle");
//false时，只执行preHandle，终止原始操作的运行
return true;
}
//在原始被拦截之后运行的代码
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle");
}
//在原始被拦截之后运行的代码并且在post之后
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("afterCompletion");
}
}
配置拦截器的执行位置：定义配置类，继承WebMvcConfigurationSupport，实现addInterceptor方法设定拦截的访问路径（注意：扫描加载配置）
@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时输出：
preHandle
book save...Book{书名='haha', 价格=200.0}
postHandle
afterCompletion
简化开发：
不需要SpringMVCSupport类，直接在SpringMvcConfig中实现（侵入式较强）
@Configuration
@ComponentScan({"com.mark.controller"})
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer {
@Autowired
private ProjectInterceptor projectInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
}
}
3.6.3 拦截器参数
前置处理
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String contentType = request.getHeader("Content-Type");
HandlerMethod hm=(HandlerMethod) handler;
hm.getMethod();
System.out.println("preHandle..."+contentType);
return true;
}
参数
request：请求对象
response：响应对象
handler：被调用的处理器对象，本质上是一个方法对象，对反射技术中的Method对象进行了再包装
返回值
返回值为false，被拦截的处理器将不再执行
后置处理
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle...");
}
参数
modelAndView：如果处理器执行完成具有返回结果，可以读取到对应数据与页面信息，并进行调整
完成后处理
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("afterCompletion");
}
参数
ex：如果处理器执行过程中出现异常对象，可以针对异常情况精选单独处理
3.6.4 拦截器链配置
当配置多个拦截器时，形成拦截器链
配置两个拦截器后运行顺序：
preHandle...
preHandle...222
book getById...1
postHandle...222
postHandle...
afterCompletion...222
afterCompletion
先进后出
拦截器链的运行顺序参照拦截器添加顺序为准
拦截器运行中断，post都不会执行
4. Maven进阶
4.1 分模块开发与设计
分模块开发意义
将原始模块按照功能拆分成若干个子模块，方便模块间的相互调用，接口共享
分模块开发步骤
创建Maven模块
书写模块代码
分模块开发需要先针对模块功能进行设计，再进行编码。不会先将工程开发完毕，然后进行拆分
通过maven指令安装模块到本地仓库（install命令）
团队内部开发需要发布模块到团队内部可共享的仓库中（私服）
在主项目pom中引入各个模块坐标
4.2 依赖管理
依赖指当前项目运行所需的jar，一个项目可以设置多个依赖
格式：
<!--设置当前项目所依赖的所有jar-->
<dependencies>
<!--设置具体的依赖-->
<dependency>
<!--依赖所属群组的id-->
<groupId>com.mark</groupId>
<!--依赖所属项目的id-->
<artifactId>Maven_02_Pojo</artifactId>
<!--依赖版本号-->
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
</dependencies>
依赖传递
依赖具有传递性
直接依赖：在当前项目中通过依赖配置建立的依赖关系
间接依赖：被建立依赖关系的资源如果依赖其他资源，当前项目简介依赖其他资源
依赖传递冲突问题
路径优先：当依赖中出现相同的资源时，层级越深，优先级越低，层级越浅，优先级越高
声明优先：当资源在相同层级被依赖时，配置顺序靠前的覆盖配置顺序靠后的
特殊优先：当同级配置了相同资源的不同版本，后配置的覆盖先配置的
可选依赖：optional标签。对外隐藏当前资源。——不透明
可选依赖是隐藏当前工程所依赖的资源，隐藏后对应资源将不具有依赖传递性
<dependency>
<groupId>com.mark</groupId>
<artifactId>Maven_02_Pojo</artifactId>
<version>1.0-SNAPSHOT</version>
<!--可选依赖是隐藏当前工程所依赖的资源，隐藏后对应资源将不具有依赖传递性-->
<optional>true</optional>
</dependency>
排除依赖：主动端来依赖的资源。——不需要
在引入其他模块坐标时，该有不需要的依赖可使用排除依赖标签exclusions，被排除的资源无需指定版本
<dependency>
<groupId>com.mark</groupId>
<artifactId>Maven_03_Dao</artifactId>
<version>1.0-SNAPSHOT</version>
<!--隐藏当前资源对应的依赖关系-->
<exclusions>
<exclusion>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
</exclusion>
</exclusions>
</dependency>
可选依赖和排除依赖区别：
可选依赖：控制当前模块资源能不能被别人发现
排除依赖：用别人的资源发现不好的资源可以去掉
4.3 聚合与继承
聚合
聚合就是将多个模块组织成一个整体，同时进行项目构建的过程称为聚合
聚合工程：通常是一个不具有业务功能的“空”工程（有且仅有一个pom文件)
作用：使用聚合工程可以将多个工程编组，通过对聚合工程进行构建，实现对所包含的模块进行同步构建
当工程中某个模块发生更新（变更）时，必须保障工程中与已更新模块关联的模块同步更新，此时可以使用聚合工程来解决批量模块同步构建的问题
步骤：
创建新的模块
修改打包方式为pom
<groupId>com.mark</groupId>
<artifactId>Maven_00_parent</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
设置管理的模块名称
<!--设置管理的模块名称-->
<modules>
<module>../Maven_01_SSM</module>
<module>../Maven_02_Pojo</module>
<module>../Maven_03_Dao</module>
</modules>
继承
概念：继承描述的是两个工程间的关系，与java中的继承相似，子工程可以继承父工程中的配置信息，常见于依赖关系的继承。简单来说，父工程的依赖子工程可以使用。
作用：
简化配置
减少版本冲突
实现：
在父工程的pom中设置打包类型为pom
在父工程的pom文件中配置依赖关系（子工程将沿用父工程的依赖关系）
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
......
</dependencies>
在父工程中配置子工程可以选择的依赖
<!--定义依赖管理-->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</dependencyManagement>
在子工程中配置当前工程所继承的父工程
<parent>
<groupId>com.mark</groupId>
<artifactId>Maven_00_parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!--相对路径，可以快速地找到继承的工程。可以不写-->
<relativePath>../Maven_00_parent/pom.xml</relativePath>
</parent>
子工程这时就可以使用父工程的依赖，同时还可以配置父工程中可选的依赖坐标
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
子工程中使用父工程中的可选依赖时，仅需要提供群组id和项目id,无需提供版本，版本由父工程统一提供，避免版本冲突
子工程中还可以定义父工程中没有定义的依赖关系
聚合与继承的区别
作用
聚合用于快速构建项目
继承用于快速配置
相同点：
聚合与继承的pom.xml文件打包方式均为pom,可以将两种关系制作到同一个pom文件中
聚合与继承均属于设计型模块，并无实际的模块内容
不同点：
聚合是在当前模块中配置关系，聚合可以感知到参与聚合的模块有哪些
继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己
4.4 属性管理
属性的配置与使用
定义属性
<properties>
<spring.version>5.2.10.RELEASE</spring.version>
<junit.version>4.12</junit.version>
</properties>
引用属性
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>
<!--定义依赖管理-->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
</dependencyManagement>
配置文件加载属性
定义属性
<properties>
<spring.version>5.2.10.RELEASE</spring.version>
<junit.version>4.12</junit.version>
<jdbc.url>jdbc:mysql://127.0.0.1:3306/ssm_db</jdbc.url>
</properties>
配置文件中引用属性
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=${jdbc.url}
jdbc.username=root
jdbc.password=123
开启资源文件目录加载属性的过滤器
<build>
<!--扩大maven构建范围-->
<resources>
<resource>
<!--使指定的目录里的文件可以解析${}的格式-->
<directory>${project.basedir}/src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
</build>
配置maven打war包时，可以忽略web.xml的检查
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.3</version>
<configuration>
<failOnMissingWebXml>false</failOnMissingWebXml>
</configuration>
</plugin>
</plugins>
其他属性（了解）
属性列表
自定义属性（常用)
内置属性
Setting属性
Java系统属性
环境变量属性
版本管理
工程版本：
SNAPSHOT(快照版本)
项目开发过程中临时输出的版本，称为快照版本
快照版本会随着开发的进展不断更新
RELEASE(发布版本)
项目开发到进入阶段里程碑后，向团队外部发布较为稳定的版本，这种版本所对应的构件文件是稳定的，即便进行功能的后续开发，也不会改变当前发布版本内容，这种版本称为发布版本
发布版本
alpha版
beta版
纯数字版
4.5 多环境配置与应用
多环境开发
maven提供配置多种环境的设定，帮助开发者使用过程中快速切换环境
<!--配置多环境开发-->
<profiles>
<!--定义开发环境：生产环境-->
<profile>
<!--定义环境对应的唯一名称-->
<id>env_dep</id>
<!--定义环境中专属的属性值-->
<properties>
<jdbc.url>jdbc:mysql://127.1.1.1:3306/ssm_db</jdbc.url>
</properties>
<!--设定是否为默认启动环境-->
<activation>
<activeByDefault>true</activeByDefault>
</activation>
</profile>
<!--定义开发环境：开发环境-->
<profile>
<id>env_pro</id>
<properties>
<jdbc.url>jdbc:mysql://127.2.2.2:3306/ssm_db</jdbc.url>
</properties>
</profile>
<!--定义开发环境：测试环境-->
<profile>
<id>env_test</id>
<properties>
<jdbc.url>jdbc:mysql://127.3.3.3:3306/ssm_db</jdbc.url>
</properties>
</profile>
</profiles>
使用多环境（构建过程）
mvn 指令 -P 环境定义id
范例：
mvn install -P env_pro
跳过测试
应用场景
功能更新中并且没有开发完毕
快速打包
......
方式一：快速跳过
方式二：配置跳过
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.12.4</version>
<configuration>
<!--false：不跳过所有test-->
<skipTests>false</skipTests>
<!--排除掉不参与测试的内容-->
<excludes>**/BookServiceTest.java</excludes>
</configuration>
</plugin>
</plugins>
方式三：命令跳过
mvn package -D skipTests
4.6 私服
私服简介
私服就是一台独立的服务器，用于解决团队内部的资源共享与资源同步问题
Nexus
Sonatype公司的一款maven私服产品
下载地址：https://help.sonatype.com/repomanager3/product-information/download
使用：
启动服务器（命令行启动）
nexus.exe /run nexus
访问服务器（默认端口8081）
http://localhost:8081
修改基础配置信息
安装路径下etc目录中nexus-default.properties文件保存有nexus基础配置信息，例如默认访问端口
修改服务器运行配置信息
安装路径下bin目录中nexus.vmoptions文件保存有nexus服务器启动的配置信息，例如默认占用内存空间
私服仓库分类
仓库组是小组内共享资源用的，宿主仓库是小组内自己用的，代理仓库是所有项目组公用的
资源上传与下载
本地仓库访问私服配置
创建自己的两个仓库
配置本地仓库对私服的访问权限：打开maven的settings.xml文件，找到servers
<!-- 配置访问私服的权限 -->
<server>
<!-- 私服中的服务器id名称 -->
<id>mark-snapshot</id>
<!-- admin -->
<username>admin</username>
<!-- 123 -->
<password>123</password>
</server>
<server>
<!-- 私服中的服务器id名称 -->
<id>mark-release</id>
<!-- admin -->
<username>admin</username>
<!-- 123 -->
<password>123</password>
</server>
设置仓库组管理范围
配置映射关系
<!-- 私服的访问路径 -->
<mirror>
<!-- 仓库组的id -->
<id>maven-public</id>
<mirrorOf>*</mirrorOf>
<url>http://localhost:8081/repository/maven-public/h</url>
</mirror>
私服资源上传与下载
配置工程保存在私服中的位置
<!--配置当前工程保存在私服中的具体位置-->
<distributionManagement>
<repository>
<id>mark-release</id>
<url>http://localhost:8081/repository/mark-release/</url>
</repository>
<snapshotRepository>
<id>mark-snapshot</id>
<url>http://localhost:8081/repository/mark-snapshot/</url>
</snapshotRepository>
</distributionManagement>
上传指令：deploy（在上传前要为所有的模块配置继承关系）
然后接可以在仓库中看到上传的资源了
因为pom.xml中设置了版本为SNAPSHOT，因此只上传到了snapshot仓库，当修改为RELEASE时便可上传到mark-release仓库中
<groupId>com.mark</groupId>
<artifactId>Maven_00_parent</artifactId>
<version>1.0-RELEASE</version>
<packaging>pom</packaging>
可以更换中央仓库：
