Maven
约 4486 字大约 15 分钟
2026-05-26
Nginx
// 打开官网 下载文件
// 打包前端的代码
// 将前端打包后的文件 放在 nginx 文件的html目录下
// 修改默认的80的款口号 在conf文件下面Maven
Maven 是 Apache 软件基金会提供的 Java 项目管理与自动构建工具，核心靠 POM 文件集中管理依赖和构建流程。
本地仓库
E:\Maven\apache-maven-3.9.9
什么是maven
Maven是apache旗下的一个开源项目，是一款用于管理和构建java项目的工具。
Maven的作用
- 依赖管理
- 统一项目结构
- 项目的构建
下载 环境配置
cmd --> mvn -v 查看是否安装成功
介绍
安装 即本地安装
IDEA集成Maven
配置Maven环境
当个项目配置
// 步骤一: 进入项目中 点击文件 再点击设置 // 和下面的步骤三道步骤五一样全局配置
// 步骤一: 点击文件 选择关闭项目 // 步骤二: 点击自定义 在选择左下角的所有设置 // 步骤三: 点击构建,执行,部署 ---> 构建工具 ---> Maven // 步骤四: 点开Maven --> 运行程序(配置jdk) // 步骤五: 点击编辑器 --> Java编辑器 --> 选择项目版本
创建Maven项目
// 步骤一: 创建一个空项目
// 步骤二: 创建一个模块(构建系统选Maven)
// 步骤三: 找到java文件 创建软件包
// 步骤四: 再在创建的软件包下创建类Maven坐标
pom.xml 文件
什么是坐标?
- Maven中的坐标是资源的唯一标识，通过该坐标可以唯一定位资源位置。
- 使用坐标来定义项目或引入项目中需要的依赖。
Maven坐标主要组成
groupld：定义当前Maven项目隶属组织名称（通常是域名反写，例如：com.itheima）
artifactld：定义当前Maven项目名称（通常是模块名称，例如order-service、goods-service）
version：定义当前项目版本号
<groupId>com.zkwy</groupId> <artifactId>maven-project01</artifactId> <version>1.0-SNAPSHOT</version>
导入Maven项目
多种方式都可以导入Maven项目
依赖配置
- 依赖：指当前项目运行所需要的jar包，一个项目中可以引入多个依赖。
<!--
- 配置：
- pom.xml中编写<dependencies>标签
- 在<dependencies>标签中使用<dependency>引入坐标
- 义坐标的groupld，artifactld，version
- 击刷新按钮，引入最新加入的坐标
-->
<dependencies>
<dependency>ch.qos.logback</dependency>
<artifactld>logback-classic</artifactld>
<version>1.2.3</version>
</dependencies>依赖传递
依赖具有传递性
直接传递
间接传递
右击选择图标 可视化的查看依赖
排除依赖
依赖范围
依赖的jar包，默认情况下，可以在任何地方使用。可以通过<Scope>...</scope>设置其作用范围作用范围:
- 主程序范围有效。（main文件夹范围内）
- 测试程序范围有效。（test文件夹范围内）
- 是否参与打包运行。（package指令范围内）
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.5.6</version>
<scope>test</scope>
</dependency>scope 值
- compile(默认)
- test
- provide
- runtime
生命周期
Maven的生命周期就是为了对所有的maven项目构建过程进行抽象和统一。
- clean:移除上一次构建生成的文件
- compile：编译项目源代码
- test:1使用合适的单元测试框架运行测试（junit）
- package：将编译后的文件打包，如：jar、war等
- install：安装项目到本地仓库
SpringBootWeb 入门
SpringBoot可以帮助我们非常快速的构建应用程序、简化开发、提高效率
// 需求：使用SpringBoot开发一个web应用，浏览器发起请求/hello后，给浏览器返回字符串“HelloWorld~"- 创建springboot工程，并勾选web开发相关依赖。
- 定义HelloController类，添加方法hello，并添加注解。
- 运行测试
创建SpringBoot
// 步骤一: 创建一个空项目
// 步骤二: 创建模块的时候选择Sprng Boot 根据提示创建
// 会自动创建出 软件包
// 步骤三: 直接创建对应的类IDEA创建SpringBoot没有java8
解决IDEA创建SpringBoot项目没有Java版本8
// 解决方案
// 方式一: 修改服务器 URL
// 原始地址
// https://start.spring.io
// 修改后的地址
// https://start.aliyun.comHTTP-概述
- 概念：Hyper Text Transfer Protocol，超文本传输协议，规定了浏览器和服务器之间数据传输的规则。
- 特点:
- 基于TCP协议：面向连接，安全
- 基于请求-响应模型的：一次请求对应一次响应
- HTTP协议是无状态的协议：对于事务处理没有记忆能力。每次请求-响应都是独立的。
- 缺点：多次请求间不能共享数据。
- 优点：速度快
HTTP-请求协议
- 请求行
- 请求头
- 请求体
GET /getData HTTP/1.1
User-Agent: PostmanRuntime/7.42.0
Accept: */*
Cache-Control: no-cache
Postman-Token: 5b5ebcdd-1818-4ad5-b15b-da9a3a27d7b4
Host: localhost:8080
Accept-Encoding: gzip, deflate, br
Connection: keep-aliveHTTP-响应协议
- 响应行
- 响应头
- 响应体
HTTP/1.1 200 OK
Content-Type: text/plain;charset=UTF-8
Content-Length: 10
Date: Fri, 08 Nov 2024 05:28:20 GMT
Keep-Alive: timeout=60
Connection: keep-alive
hello word状态码
- 1xxx
- 2xxx 200
- 3xxx
- 4xxx 404
- 5xxx 500
HTTP-协议解析
Web 服务器
Web服务器是一个软件程序，对HTTP协议的操作进行封装，使得程序员不必直接对协议进行操作，让Web开发更加便捷。主要功能是“提供网上信息浏览服务”。
- 对HTTP协议操作进行封装，简化web程序开发。
- 部署web项目，对外提供网上信息浏览服务。
// Apache Tomcat
// jetty://
// WebLogic
// WebSphereApache Tomcat
简介
- 一个轻量级的web服务器，支持servlet、jsp等少量javaEE规范。
- 也被称为web容器、servlet容器。
基本使用
下载：官网下载，地址https://tomcat.apache.org/download-90.cgi
安装：绿色版，直接解压即可
卸载：直接删除目录即可
启动：双击：bin\startup.bat
控制台中文乱码：修改conf/logging.properties
// java.util.logging.ConsoleHandler.encoding = UTF-8 // 修改如下: // java.util.logging.ConsoleHandler.encoding = GBK
关闭：
- 直接x掉运行窗口：强制关闭
- bin\shutdown.bat: 正常关闭
- Ctrl+C：正常关闭
入门程序解析
1．起步依赖
- spring-boot-starter-web
- spring-boot-starter-test
2.内嵌Tomcat服务器
- 基于Springboot开发的web应用程序，内置了tomcat服务器，当启动类运行时，会自动启动内嵌的tomcat服务器。
请求响应
Postman
Postman是一款功能强大的网页调试与发送网页HTTP请求的Chrome插件。
作用：常用于进行接口测试
简单参数
1.原始方式获取请求参数
- Controller方法形参中声明HttpServletRequest对象
- 调用对象的getParameter（参数名）
2.SpringBoot中接收简单参数
- 请求参数名与方法形参变量名相同
- 会自动进行类型转换
3.@RequestParam注解
- 方法形参名称与请求参数名称不匹配，通过该注解完成映射
- 该注解的required属性默认是true，代表请求参数必须传递
package com.zkwy.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
// 请求处理类
@RestController
public class UserController {
// 获取分类
@RequestMapping("/getData")
public String getData(){
System.out.println("hello word");
return "hello word";
}
// 测试请求参数的接受
@RequestMapping("/simpleParamOld")
public String simpleParamOld(HttpServletRequest request){
String name = request.getParameter("name");
String ageStr = request.getParameter("age");
// 需要手动的将age转化为int类型
int age = Integer.parseInt(ageStr);
// 返回数据
String result = "用户名: " + name + " 年龄: " + age;
System.out.println(result);
return result;
}
// 测试请求参数的接受 改造后的请求方式
@RequestMapping("/simpleParamNew")
public String simpleParamNew(@RequestParam(name = "name" ) String name , @RequestParam(name = "age" , required = false) Integer age){
// 返回数据
String result = "用户名: " + name + " 年龄: " + age;
System.out.println(result);
return result;
}
}实体参数
- 简单实体对象：请求参数名与形参对象属性名相同，定义POJO接收即可
- 复杂实体对象: eg: Address 又是一个Javabean类
// User.java Javabean类
package com.zkwy.pojo;
public class User {
private String name;
private int age;
// Address 是一个单独的 Javabean类
private Address address;
public User() {
}
public User(String name, int age, Address address) {
this.name = name;
this.age = age;
this.address = address;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
/**
* 获取
* @return address
*/
public Address getAddress() {
return address;
}
/**
* 设置
* @param address
*/
public void setAddress(Address address) {
this.address = address;
}
public String toString() {
return "User{name = " + name + ", age = " + age + ", address = " + address + "}";
}
}// Address.java Javabean类
package com.zkwy.pojo;
public class Address {
private String province; // 省份
private String city;
public Address() {
}
public Address(String province, String city) {
this.province = province;
this.city = city;
}
/**
* 获取
* @return province
*/
public String getProvince() {
return province;
}
/**
* 设置
* @param province
*/
public void setProvince(String province) {
this.province = province;
}
/**
* 获取
* @return city
*/
public String getCity() {
return city;
}
/**
* 设置
* @param city
*/
public void setCity(String city) {
this.city = city;
}
public String toString() {
return "Address{province = " + province + ", city = " + city + "}";
}
}// UserPojo.java 测试类
package com.zkwy.controller;
import com.zkwy.pojo.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserPojo {
// 实体参数
// 简单的实体参数
@RequestMapping("/simplePojo")
public String getSimple(User user){
System.out.println(user);
return "用户名: " + user.getName() + " 年龄: "+ user.getAge();
}
// 复杂的实体参数
@RequestMapping("/complexPojo")
public String getComplex(User user){
System.out.println(user);
return "用户名: " + user.getName() + " 年龄: "+ user.getAge() + " 省份: " + user.getAddress().getProvince() + " 城市: "+ user.getAddress().getCity() ;
}
}数组集合参数
- 数组：请求参数名与形参中数组变量名相同，可以直接使用数组封装
- 集合：请求参数名与形参中集合变量名相同，通过@RequestParam绑定参数关系
// 数组参数
@RequestMapping("/arrayParam")
public String getArrayParam(String[] array){
System.out.println(Arrays.toString(array));
return "ok";
}
// 集合参数 参数前面需要加 @RequestParam
@RequestMapping("/listParam")
public String getListParam(@RequestParam ArrayList<String> list){
System.out.println(list);
return "ok";
}
// 使用的场景:
// 1. 多选 自己喜欢的食物
// 2. 多选 路段名称日期参数
日期参数：使用@DateTimeFormat注解完成日期参数格式转换
// 日期时间格式
@RequestMapping("/dateParam")
public String getDateParam(@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime updateTime){
System.out.println(updateTime);
return "ok";
}Json参数
JSON参数：JSON数据键名与形参对象属性名相同，定义POJO类型形参即可接收参数，需要使用@RequestBody标识 POST请求
{
"name":"小冯",
"age":26,
"address":{
"province":"贵州",
"city":"贵阳"
}
}// JSON参数格式 需要是POST请求
@RequestMapping("/jsonParam")
public String getJsonParam(@RequestBody User user){
System.out.println(user);
return "ok";
}路径参数
路径参数：通过请求URL直接传递参数，使用{...}来标识该路径参数，需要使用@PathVariable获取路径参数
单个路径参数
// 单个路径参数
@RequestMapping("/path/{id}")
public String getPath(@PathVariable Integer id){
System.out.println(id);
return "ok";
}多个路径参数
// 多个路径参数
@RequestMapping("path/{name}/{id}")
public String getPaths(@PathVariable String name, @PathVariable Integer id){
System.out.println("姓名: " + name + " id: "+ id);
return "ok";
}响应
- 类型：方法注解、类注解
- 位置：Controller方法上/类上
- 作用：将方法返回值直接响应，如果返回值类型是实体对象/集合，将会转换为JSON格式响应
- 说明：@RestController=@Controller+@ResponseBody;
package com.zkwy.controller;
import com.zkwy.pojo.Address;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.List;
@RestController
@RequestMapping("/request")
public class RequestController {
// 响应 - 字符串
@RequestMapping("/getHello")
public String getHello(){
System.out.println("Hello Word");
return "Hello Word";
}
// 响应 - 对象json
@RequestMapping("/getArray")
public Address getArray(){
// 创建对象 并添加数据
Address add = new Address("贵州" ,"遵义");
System.out.println(add);
return add;
}
// 响应 - 集合json
@RequestMapping("/getList")
public List<Address> getList(){
// 创建集合
ArrayList<Address> list = new ArrayList<>();
// 创建对象
Address add1 = new Address("广东" , "江门");
Address add2 = new Address("湖南" , "岳阳");
// 向集合中添加数据
list.add(add1);
list.add(add2);
// 返回集合
return list;
}
}统一响应结果
将上面的返回信息 统一管理
// Resullt.java Javabean类
package com.zkwy.pojo;
public class Result {
private Integer code; // 202 代表失败 200 代表成功
private String message;
private Object data;
public Result() {}
public Result(Integer code, String message, Object data) {
this.code = code;
this.message = message;
this.data = data;
}
public Integer getCode() {return code;}
public void setCode(Integer code) {this.code = code;}
public String getMessage() {return message;}
public void setMessage(String message) {this.message = message;}
public Object getData() {return data;}
public void setData(Object data) {this.data = data;}
// 成功 返回数据
public static Result success(Object data){
return new Result(200 , "请求成功" , data);
}
// 成功 不返回数据 方法重载
public static Result success(){
return new Result(200 , "请求成功" ,null);
}
// 失败
public static Result error(String message){
return new Result(202 , message , null);
}
public String toString() {
return "Result{code = " + code + ", message = " + message + ", data = " + data + "}";
}
}// 改造后的数据
package com.zkwy.controller;
import com.zkwy.pojo.Address;
import com.zkwy.pojo.Result;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.List;
@RestController
@RequestMapping("/request/result")
public class RequestControllerResult {
// 响应 - 字符串
@RequestMapping("/getHello")
public Result getHello(){
return Result.success("Hello word");
}
// 响应 - 对象json
@RequestMapping("/getArray")
public Result getArray(){
// 创建对象 并添加数据
Address add = new Address("贵州" ,"遵义");
System.out.println(add);
return Result.success(add);
}
// 响应 - 集合json
@RequestMapping("/getList")
public Result getList(){
// 创建集合
ArrayList<Address> list = new ArrayList<>();
// 创建对象
Address add1 = new Address("广东" , "江门");
Address add2 = new Address("湖南" , "岳阳");
// 向集合中添加数据
list.add(add1);
list.add(add2);
// 返回集合
return Result.success(list);
}
}响应案例
// 案例: 获取员工数据，返回统一响应结果，在页面渲染展示
// 需求: 加载并解析emp.xml文件中的数据，完成数据处理，并在页面展示。// 获取员工数据，返回统一响应结果，在页面渲染展示
// 在pom.xml文件中引l入dom4j的依赖，用于解析xML文件
// 引入资料中提供的解析XML的工具类XMLParserUtils、对应的实体类Emp、XML文件emp.xml
// 引入资料中提供的静态页面文件，放在resources下的static目录下
// 编写Controller程序，处理请求，响应数据<?xml version="1.0" encoding="utf-8" ?>
<emps>
<emp>
<name>金毛狮王</name>
<age>55</age>
<image>http://qny.zkwygroup.com/device/20241108/A91DV1731040179588.jpg</image>
<!--1：男，2：女-->
<gender>1</gender>
<!--1：讲师，2：班主任，3：就业指导-->
<job>1</job>
</emp>
<emp>
<name>白眉鹰王</name>
<age>65</age>
<image>http://qny.zkwygroup.com/device/20241108/A91DV1731040179588.jpg</image>
<gender>1</gender>
<job>2</job>
</emp>
<emp>
<name>青蛙王子</name>
<age>45</age>
<image>http://qny.zkwygroup.com/device/20241108/A91DV1731040179588.jpg</image>
<gender>1</gender>
<job>2</job>
</emp>
<emp>
<name>紫荆龙王</name>
<age>38</age>
<image>http://qny.zkwygroup.com/device/20241108/A91DV1731040179588.jpg</image>
<gender>2</gender>
<job>3</job>
</emp>
</emps>// XmlParserUtils.java
package com.zkwy.utils;
import com.zkwy.pojo.Emp;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.util.ArrayList;
import java.util.Iterator;
public class XmlParserUtils {
// 参考文献: https://blog.51cto.com/liujinhui/10329495
// 私有化构造方法
// 目的: 不让外界创建他的对象
private XmlParserUtils() {}
// 解析xml文件 静态的成员成员方法
public static Object parser(String file){
try{
//创建解析器对象
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(file);
// 获取根元素对象
Element root = document.getRootElement();
// 获取emp元素集合(即根元素下一级)
Iterator<Element> elementIterator = root.elementIterator();
// 创建集合
ArrayList<Emp> list = new ArrayList<>();
// 遍历 emp元素集合
while(elementIterator.hasNext()){
// 获取单个元素
Element element = elementIterator.next();
// 创建对象
Emp emp = new Emp();
// 获取emp下一级元素集合
Iterator<Element> nextElementIterator = element.elementIterator();
// 遍历
while(nextElementIterator.hasNext()){
// 获取元素信息
Element ele = nextElementIterator.next();
if(ele.getName() == "name"){
emp.setName(ele.getText());
} else if (ele.getName() == "age") {
emp.setAge(ele.getText());
}else if (ele.getName() == "image") {
emp.setImage(ele.getText());
}else if (ele.getName() == "gender") {
// 1：男，2：女
emp.setGender(ele.getText());
}else if (ele.getName() == "job") {
// 1：讲师，2：班主任，3：就业指导
emp.setJob(ele.getText());
}
}
// 向集合中添加数据
list.add(emp);
}
return list;
}catch (Exception e ){
e.printStackTrace();
}
return null;
}
}// Emp.java
package com.zkwy.pojo;
public class Emp {
private String name;
private String age;
private String image;
private String gender;
private String job;
public Emp() {
}
public Emp(String name, String age, String image, String gender, String job) {
this.name = name;
this.age = age;
this.image = image;
this.gender = gender;
this.job = job;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public String getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(String age) {
this.age = age;
}
/**
* 获取
* @return image
*/
public String getImage() {
return image;
}
/**
* 设置
* @param image
*/
public void setImage(String image) {
this.image = image;
}
/**
* 获取
* @return gender
*/
public String getGender() {
return gender;
}
/**
* 设置
* @param gender
*/
public void setGender(String gender) {
this.gender = gender;
}
/**
* 获取
* @return job
*/
public String getJob() {
return job;
}
/**
* 设置
* @param job
*/
public void setJob(String job) {
this.job = job;
}
public String toString() {
return "Emp{name = " + name + ", age = " + age + ", image = " + image + ", gender = " + gender + ", job = " + job + "}";
}
}package com.zkwy.controller;
import com.zkwy.pojo.Emp;
import com.zkwy.pojo.Result;
import com.zkwy.utils.XmlParserUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Objects;
@RestController
@RequestMapping("/emp")
public class EmpController {
@RequestMapping("/getList")
public Result getList(){
// 步骤一: 加载并解析xml文件
// 获取emp.xml的文件路径
// String file = Objects.requireNonNull(this.getClass().getClassLoader().getResource("emp.xml")).getFile();
String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();
// 步骤二: 调用方法 解析xml
Object parser = XmlParserUtils.parser(file);
// 步骤三: 响应数据
return Result.success(parser);
}
}分层解耦
三层架构
- controller：控制层，接收前端发送的请求，对请求进行处理，并响应数据。
- service：业务逻辑层，处理具体的业务逻辑。
- dao：数据访问层(Data Access Object）（持久层），负责数据访问操作，包括数据的增、删、改、查。
分层解耦
- 内聚：软件中各个功能模块内部的功能联系
- 耦合：衡量软件中各个层/模块之间的依赖、关联的程度。
- 软件设计原则：高内聚低耦合
分层解耦
- 控制反转，简称IOC。对象的创建控制权由程序自身转移到外部（容器），这种思想称为控制反转。
- 依赖注入：Dependency Injection，简称Dl。容器为应用程序提供运行时，所依赖的资源，称之为依赖注入。
- Bean对象：IOC容器中创建、管理的对象，称之为bean
IOC & DI入门
IOC详解
Bean的声明 注解
- @Component 一般用户工具类
- @Controller 管理器 管理接口
- @Service 业务逻辑
- @Repository 很少使用
DI详解
依赖注入的注解
- @Autowired:默认按照类型自动装配。
- 如果同类型的bean存在多个：
- @Primary
- @Autowired+@Qualifier（“bean的名称"）
- @Resource（name="bean的名称")
@Resource与@Autowired区别
- @Autowired是spring框架提供的注解而@Resource是JDk提供的注解。
- @Autowired默认是按照类型注入，而@Resource默认是按照名称注入。
Maven高级
分模块设计与开发
1．什么是分模块设计？
- 将项目按照功能拆分成若干个子模块
2．为什么要分模块设计？
- 方便项目的管理维护、扩展，也方便模块间的相互调用，资源共享
3.注意事项
- 分模块设计需要先针对模块功能进行设计，再进行编码。不会先将工程开发完毕，然后进行拆分