一、修饰符

1、final

final关键字是最终的意思，可以修饰成员方法，成员变量，类

final修饰的特点：

修饰方法：表面该方法是最终的方法，不能被重写
修饰变量：表明该变量是常量，不能再次被赋值
修饰类：表明该类是最终类，不能被继承

final修饰局部变量

变量是基本数据类型：final修饰指的是基本数据类型的数据值不能发生改变
变量是引用数据类型：final修饰指的是音乐数据类型的地址值不能发生改变，但是地址值里面的内容是可以发生改变的

2、static

static关键字是静态的意思，可以修饰成员方法，成员变量

static修饰的特点：

该类的所有对象共享

这也是判断是否使用静态关键字的条件

可以通过类名调用

也可以通过对象名调用

static访问特点：

非静态的成员方法：（没有被static修饰符修饰过的成员方法）

能访问静态的成员变量
能访问非静态的成员变量
能访问静态的成员方法
能访问非静态的成员方法

静态的成员方法（被static修饰符修饰过的成员方法）

能访问静态的成员变量
能访问静态的成员方法

总结：静态成员方法只能访问静态成员

二、多态

1.1 多态概述

同一个对象，在不同时刻表现出来的不同形态

例：猫

可以说猫是猫：猫 cat = new 猫（）；

也可以说猫是动物：动物 animal = new 猫（）；

这里猫在不同时刻表现出来了不同的形态，这就是多态

多态的前提和体现

有继承/实现关系
有方法重写

有父类引用指向子类

1	Animal animal = new Cat(); //这就是父类引用指向子类

1.2 多态中成员访问特点

成员变量：编译看左边，运行看左边
成员方法：编译看左边，运行看右边

为什么成员变量和成员方法的访问不一样？

因为成员方法有重写，而成员变量没有

1.3 多态的好处和弊端

多态的好处：提高程序的拓展性

具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作

多态的弊端：不能使用子类的特有功能（不能使用子类的成员方法）

1.4 多态中的转型

向上转型

从子到父

父类引用指向子类对象

向下转型

从父到子

父类引用转为子类对象

public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        Animal a = new Cat(); // 向上转型
        a.eat();

        // 向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}

三、抽象类

1.1 抽象类概述

在Java中，一个没用方法体的方法应该定义为抽象方法，而类中如果有抽象方法，则该类必须定义为抽象类

1.2 抽象类的特点

抽象类和抽象方法必须用abstract关键字修饰

public abstractclass 类名{}

public abstractvoid eat();
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类不能实例化

可以参照抽象的方式，通过子类对象实例化，这叫抽象类多态

抽象类的子类

要么重写抽象类中的所有抽象方法

要么是抽象类（把子类也定义成抽象类）

1.3 抽象类的成员特点

成员变量

可以是变量

也可以是常量

构造方法

有构造方法，但是不能实例化

构造方法的作用？用于子类访问父类数据的初始化

成员方法

可以有抽象方法：限定子类必须完成某些动作

也可以有非抽象方法：提高代码复用性

四、接口

1.1 接口概述

接口就是一种公共的规范标准，只要符合规范标准，都可以通用Java中的接口，更多的体现在对行为的抽象

1.2 接口的特点

接口用关键字interface修饰

public interface 接口名{}

类实现接口用implements表示

public class 类名 implements 接口名 {}

接口不能实例化

接口实例化按照多态的方式，通过实现类对象实例化，这叫接口多态

多态的形式：具体类多态，抽象类多态，接口多态

多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象

接口的实现类

要么重写接口中的所有抽象方法

要么是抽象类

1.3 接口的成员特点

成员变量

只能是常量

默认修饰符：public static final

构造方法

接口没用构造方法，因为接口主要是对行为进行抽象的，没用具体存在

一个类如果没用父类，默认继承Object类

成员方法

只能是抽象方法

默认修饰符：public abstract

1.4 类和接口的关系

类和类的关系

继承关系，只能单继承，但是可以多层继承

类和接口的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

接口和接口的关系

继承关系，可以单继承，也可以多继承

1.5 抽象类和接口的区别

成员区别

抽象类变量，常量；有构造方法；由抽象方法；也有非抽象方法

接口常量，抽象方法

关系区别

类与类继承，单继承

类与接口实现，可以单实现，也可以多实现

接口与接口继承，单实现，多继承

设计理念区别

抽象类对类抽象，包括属性、行为

接口对行为抽象，主要是行为

五、内部类

1.1 内部类概述

内部类：就是在一个类中定义一个类。例：在一个类A的内部定义一个类B，类B就是内部类

内部类定义格式

格式

public class 类名 {
    修饰符 class 类名 {

    }
}

范例

public class Outer {
    public class Inner {

    }
}

内部类访问特点

内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象

public class Outer {
    // 创建内部类
    private class Inner {
        void show() {
            System.out.println(age);
        }
    }

    // method()这个方法存在的意义就是调用Inner这个内部类的show()方法
    void method() {
        // 在method()方法里创建内部类对象，并调用
        Inner in  = new Inner();
        in.show();
    }
}


// 内部类测试类
public class Demo {
    public static void main(String[] args) {
        // 创建Outer类对象
        Outer o = new Outer();
        // 调用 method() 方法就相当于调用了内部类里面的 show() 方法
        o.method();
    }
}
}

1.2 局部内部类

局部内部类特点：

局部内部类是在方法中定义类，所以外界是无法直接使用的，需要在方法内部创建对象并使用。

该类可以直接访问外部的成员，也可以访问方法内的局部变量。

public class Outer {
    private int num = 10;

    void method() {
        int num2 = 20;
        class Inner {
            void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }

        Inner i = new Inner();
        i.show();
    }
}


public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

1.3 匿名内部类

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

格式

1
2
3

new 类名或者接口名() {
    重写方法;
}

范例

new Inter() {
    public void show() {

    }
}

匿名内部类本质：是一个继承了该类或者实现了该接口的子类匿名对象

public interface Inter { // 这是一个接口，里面有一个show()方法
    void show();
}

public class Outer {
    void method() {

        new Inter() {  // n

            @Override
            public void show() {
                System.out.println("匿名内部类");
            }

        }.show();

    }
}



public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

六、IO

字符缓冲流复制文件

BufferedReder 字符缓冲输入流
BufferedWrite 字符缓冲输出流

package com.itheima.myIo.myCharStream.demo04;

import java.io.*;

/*
    需求：
        使用字符缓冲流特有功能复制Java文件
        数据源：D:\IdeaProject\study\src\com\itheima\myIo\myOutputStream\FileOutputStreamDemo02.java
        目的地：D:\IdeaProject\study\src\com\itheima\myIo\myCharStream\demo04\Copy.java
 */
public class BufferStreamDemo04 {
    public static void main(String[] args) throws IOException {
        // 字符缓冲输入流
        BufferedReader br = new BufferedReader(new FileReader("D:\\IdeaProject\\study\\src\\com\\itheima\\myIo\\myOutputStream\\FileOutputStreamDemo02.java"));
        // 字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\IdeaProject\\study\\src\\com\\itheima\\myIo\\myCharStream\\demo04\\Copy.java"));

        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        bw.close();
        br.close();
    }
}

十一、网络编程基础

1.1 网络编程概述

计算机网络

是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作
系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统

网络编程

在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换

1.2 网络编程三要素

IP地址

要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数
据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识

端口

网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时，如何区
分这些应用程序呢？如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的应用程序
了。也就是应用程序的标识

通信协议

通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定
的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则
被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守
才能完成数据交换。常见的协议有UDP协议和TCP协议

1.3 IP地址

IP地址：是网络中设备的唯一标识

IP地址分为两大类

IPv4：是给每个连接在网络上的主机分配一个32bit地址。按照TCP/IP规定，IP地址用二进制来表示，每个IP地址长
32bit，也就是4个字节。例如一个采用二进制形式的IP地址是“110000001010100000000001 01000010”，这么长
的地址，处理起来也太费劲了。为了方便使用，IP地址经常被写成十进制的形式，中间使用符号“.”分隔不同的字节。
于是，上面的IP地址可以表示为“192.168.1.66”。IP地址的这种表示法叫做“点分十进制表示法”，这显然比1和0容
易记忆得多
由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。为了扩大
地址空间，通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，这样就解决了网络地址资源数量不够的问题

常用命令

ipconfig：查看本机IP地址
ping IP地址：检查网络是否连通

特使IP地址：

127.0.0.1：回送地址，可以代表本机，一般用来测试

1.4 InerAddress的使用

为了方便我们对IP地址的获取和操作, Java提供了一个类InetAddress供我们使用

InetAddress:此类表示Internet协议（IP）地址

1.5 端口

端口：设备上应用程序的唯一标识

端口号：用两个字节表示的整数，它的取值范围是0~65535。其中，0～1023之间的端口号用于一些知名的网
络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导
致当前程序启动失败

1.6 协议

协议：计算机网络中，连接和通信的规则被称为网络通信协议

UDP协议

用户数据报协议(User Datagram Protocol)
UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。
由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输
例如视频会议通常采用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议

TCP协议

传输控制协议（Transmission Control Protocol）
TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，
它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端
向服务端发出连接请求，每次连接的创建都需要经过“三次握手。
三次握手：TCP协议中，在发送数据的准备阶段客户端与服务端之间的三次交互，以保证连接的可靠
- 第一次握手，客户端向服务器端发出连接请求，等待服务器确认
- 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求
- 第三次握手，客户端再次向服务器端发送确认信息，确认连接
  - 完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。这种面向连接的特性,TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等

2. UDP通信程序

2.1 UDP通信原理

UDP协议是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发送，接收数据的对象

因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念

Java提供了DatagramSocket类作为基于UDP协议的Socket

2.2 UDP发送数据

发送数据的步骤

创建发送端的Socket对象(DatagramSocket)
创建数据，并把数据打包
调用DatagramSocket对象的方法发送数据
关闭发送端

发送数据的步骤
① 创建发送端的Socket对象(DatagramSocket)
DatagramSocket()
② 创建数据，并把数据打包
DatagramPacket(byte[] buf, int length, InetAddress address, int port)
③ 调用DatagramSocket对象的方法发送数据
void send(DatagramPacket p)
④ 关闭发送端
void close()

package com.itheima.MyNet.itheima02;

import java.io.IOException;
import java.net.*;
import java.nio.charset.StandardCharsets;

/*
    1. 创建发送端的Socket对象(DatagramSocket)
    2. 创建数据，并把数据打包
    3. 调用DatagramSocket对象的方法发送数据
    4. 关闭发送端
 */
public class SendDemo {
    public static void main(String[] args) throws IOException {
        // 创建发送端的Socket对象(DatagramSocket)
        // 构造方法：DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口。
        DatagramSocket ds = new DatagramSocket(3306);

        // 创建数据，并把数据打包
        // DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        // 构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。
        byte[] bytes = "大头大头".getBytes();
//        int len = bytes.length;
//        InetAddress address = InetAddress.getByName("10.102.57.46");
//        int port = 12345;
        DatagramPacket dp = new DatagramPacket(bytes, bytes.length,InetAddress.getByName("2409:8a30:8a43:2240:5ef:bf78:eccc:4d5"),1219);


        // 调用DatagramSocket对象的方法发送数据
        ds.send(dp);

        // 关闭发送端
        ds.close();

    }
}

2.3 UDP接受数据

接收数据的步骤
① 创建接收端的Socket对象(DatagramSocket)
② 创建一个数据包，用于接收数据
③ 调用DatagramSocket对象的方法接收数据
④ 解析数据包，并把数据在控制台显示关闭接收端

package com.itheima.MyNet.itheima02;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.Arrays;

/*
    接收数据的步骤
     1. 创建接收端的Socket对象(DatagramSocket)
     2. 创建一个数据包，用于接收数据
     3. 调用DatagramSocket对象的方法接收数据
     4. 解析数据包，并把数据在控制台显示关闭接收端
     5. 关闭接收端
 */
public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        while(true) {
            // 创建接收端的Socket对象(DatagramSocket)
            DatagramSocket ds = new DatagramSocket(1219);

            // 创建一个数据包，用于接收数据
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);

            // 调用DatagramSocket对象的方法接收数据
            ds.receive(dp);

            // 解析数据包，并把数据在控制台显示关闭接收端
            byte[] data = dp.getData();
            int len = dp.getLength();
            String dataString = new String(data,0,len);
            System.out.println("数据是：" + dataString);

            // 关闭接收端
            ds.close();
        }
    }
}

3. TCP通信程序

3.1 TCP通信原理

TCP通信协议是一种可靠的网络协议，它在通信的两端各建立一个Socket对象，从而在通信的两端形成网络虚拟链路，一旦建立了虚拟的网络链路，两端的程序就可过虚拟链路进行通信

Java对基于TCP协议的网络提供了良好的封装，使用Socket对象来表示两端的通信端口，并通过Socket产生IO流来进行网络通信，Java为客户端提供了Socket类，为服务器端提供了ServerSocket类

uTools_1638448732396

3.2 TCP发送数据

发送数据的步骤
① 创建客户端的Socket对象(Socket)

Socket(String host, int ]port)

② 获取输出流，写数据

OutPutStream getOutPutStream()

③ 释放资源

void close()

package com.itheima.MyNet.itheima04;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

/*
    TCP发送数据的步骤
    ① 创建客户端的Socket对象(Socket)
    ② 获取输出流，写数据
    ③ 释放资源
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(Socket)
        //Socket(InetAddress address, int port) 创建流套接字并将其连接到指定IP地址的指定端口号。
//        Socket s = new Socket(InetAddress.getByName("10.102.57.46"),3306);
        //Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号。
        Socket s = new Socket("10.102.57.46", 3306);

        //获取输出流，写数据
        //OutputStream getOutputStream() 返回此套接字的输出流。
        OutputStream os = s.getOutputStream();
        os.write("这是tcp协议发送的数据".getBytes());

        //释放资源
        s.close();
    }
}

3.3 TCP接收数据

接收数据的步骤
① 创建服务器端的Socket对象(ServerSocket)
ServerSocket(int port)
②监听客户端连接，返回一个Socket对象
Socket accept()
③获取输入流，读数据，并把数据显示在控制台
InputStream getInputStream()
④释放资源
void close()

package com.itheima.MyNet.itheima04;


import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/*
    接收数据的步骤
    ① 创建服务器端的Socket对象(ServerSocket)
    ② 获取输入流，读数据，并把数据显示在控制台
    ③ 释放资源
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象(ServerSocket)
        ServerSocket serverSocket = new ServerSocket(7000);

        //Socket accept() 侦听要连接到此套接字并接受它。
        Socket accept = serverSocket.accept();

        //获取输入流，读数据，并把数据显示在控制台
        InputStream inputStream = accept.getInputStream();
        byte[] bys = new byte[1024];
        int len = inputStream.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("数据是：" + data);


        //释放资源
        serverSocket.close();
    }
}

十二、Lambda表达式

1.1 函数式编程思想概述

uTools_1639396954033

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”
面向对象思想强调“必须通过对象的形式来做事情”
函数式思想则尽量忽略面向对象的复杂语法“强调做什么，而不是以什么形式去做”
而我们要学习的Lambda表达式就是函数式思想的体现

1.2 体验Lambda表达式

需求：启动一个线程，在控制台输出—句话：多线程程序启动了

方式1:

定义一个类MyRunnable实现Runnable接口，重写run()方法
创建MyRunnable类的对象
创建Thread类的对象，把MyRunnable的对象作为构造参数传递
启动线程

javaWeb介绍

什么时javaWeb？

Web：全球广域网，也称为万维网(www)，能够通过浏览器访问的网站
JavaWeb：是用Java技术来解决相关web互联网领域的技术栈

十三、正则表达式

正则表达式定义了字符串组成的规则

定义：

1	var reg = /^\w{6,12}$/; //不要加引号

方法：

test(str)：判断指定字符串是否符合规则，返回true或false

语法

^：开始
$：结束
[ ]：代表某个范围内的单个字符,如：[0-9] 单个数字字符
.：代表任意单个字符，除了换行和行结束符
\w：代表单词字符：字母、数字、下划线（_），相当于[A-Z a-z 0-9_]
\d：代表数字字符：相当于[0-9]
量词：
+：至少一个
*：零个或多个
？：零个或一个
{x}：x个
{m,}：至少m个
{m,n}：至少m个，最多n个
二十、Web核心

一、javaWeb技术栈

B/S架构：Browser/Server，浏览器/服务器架构模式，它的特点是，客户端只需要浏览器，应用程序的逻辑和数
据都存储在服务器端。浏览器只需要请求服务器，获取Web资源，服务器把Web资源发送给浏览器即可
二、HTTP

1.1 概念

HyperText Transfer Protocol，超文本传输协议，规定了浏览器和服务器之间数据传输的规则

1.2 HTTP协议特点

基于TCP协议：面向连接，安全
基于请求-响应模型的：一次请求对应一次响应
HTTP协议是无状态的协议：对于事务处理没有记忆能力。每次请求-响应都是独立的。

缺点：多次请求间不能共享数据。Java中使用会话技术(Cookie、Session）来解决这个问题
优点：速度快

1.3 HTTP-请求数据格式‘

请求数据分为3部分：
1.请求行：请求数据的第一行。其中GET表示请求方式，/表示请求资源路径，HTTP/1.1表示协议版本
2.请求头：第二行开始，格式为key：value形式。
3.请求体：POST请求的最后一部分，存放请求参数

uTools_1639998349113

常见的HTTP 请求头：

Host: 表示请求的主机名
User-Agent: 浏览器版本，例如Chrome浏览器的标识类似Mozilla/5.0

Chrome/79，IE浏览器的标识类似Mozilla/5.0 (Windows NT …) like Gecko；
Accept：表示浏览器能接收的资源类型，如text/，image/或者/表示所有；
Accept-Language：表示浏览器偏好的语言，服务器可以据此返回不同语言的网页；
Accept-Encoding：表示浏览器可以支持的压缩类型，例如gzip, deflate等。

uTools_1639998597810

GET请求和 POST请求区别：

GET请求请求参数在请求行中，没有请求体。
```
POST请求请求参数在请求体中
```
2.GET请求请求参数大小有限制，
```
POST没有
```

1. HTTP-响应数据格式

响应数据分为3部分：
1.响应行：响应数据的第一行。其中HTTP/1.1表示协议版本， 200表示响应状态码，OK表示状态码描述
2.响应头：第二行开始，格式为key：value形式
3.响应体：最后一部分。存放响应数据

uTools_1639998972904

uTools_1639999011417

常见的HTTP 响应头：
Content-Type:表示该响应内容的类型，例如text/html，image/jpeg;
Content-Length：表示该响应内容的长度（字节数) ;
Content-Encoding:表示该响应压缩算法，例如gzip;
Cache-Control：指示客户端应如何缓存，例如max-age=300,表示可以最多缓存300秒

Web服务器是一个应该程序（软件），对HTTP协议的操作进行封装，使得程序员不必直接对协议进行操作，让Web开
发更加便捷。主要功能是“提供网上信息浏览服务“

uTools_1639999691337

1.5 Tomcat

概念：

Tomcat是Apache软件基金会一个核心项目，是一个开源免费的轻量级Web服务器，支持Servlet/JSP，少量JavaEE规范。
JavaEE:Java Enterprise Edition，Java企业版。指Java企业级开发的技术规范总和。包含13项JDBC、JNDI、EJB、RMI、JSP、Servlet、XML、JMS、Java IDL、JTS、JTA、JavaMail、JAF
Tomcat也被称为Web容器、Servlet容器。Servlet需要依赖于Tomcat才能运行

总结

Web 服务器作用？
- 封装HTTP协议操作，简化开发
- 可以将web项目部署到服务器中，对外提供网上浏览服务
Tomcat是一个轻量级的Web服务器，支持Servlet/JSP少量
JavaEE规范，也称为Web容器，Servlet容器
3.
二十一、IDEA中创建Maven Web项目

Web项目构建

uTools_1640004314147

uTools_1640004353879

使用骨架创建

uTools_1640087139632

不使用骨架创建

二十二、IDEA中使用Tomcat

将本地Tomcat集成到IDEA中，然后进行项目部署

uTools_1640086097462

Tomcat Maven 插件