# java

**Repository Path**: linux-lxf/java

## Basic Information

- **Project Name**: java
- **Description**: Java 代码部署测试仓库
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2024-06-26
- **Last Updated**: 2025-02-23

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

## Java代码与编译

使用 Maven 来打包一个简单的 Java 程序也是非常方便的。首先，我们需要确保你的项目结构符合 Maven 的标准目录结构，并且包含了正确的依赖配置。假设你的 Java 项目结构如下：

```
MySimpleHttpServer/
├── src/
│   └── main/
│       └── java/
│           └── SimpleHttpServer.java
└── pom.xml
```

其中，`SimpleHttpServer.java` 是你的 Java 源代码文件，而 `pom.xml` 是 Maven 的项目配置文件。

### 源码文件

```java
import com.sun.net.httpserver.HttpServer;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpExchange;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

public class SimpleHttpServer {

    public static void main(String[] args) throws IOException {
        int port = 8000;
        HttpServer server = HttpServer.create(new InetSocketAddress(port), 0);
        server.createContext("/", new MyHandler());
        server.setExecutor(null); // creates a default executor
        server.start();
        System.out.println("Server is running on port " + port);
    }

    static class MyHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange t) throws IOException {
            String response = "Hello, World!";
            t.sendResponseHeaders(200, response.length());
            OutputStream os = t.getResponseBody();
            os.write(response.getBytes());
            os.close();
        }
    }
}

```

这段代码是一个简单的Java程序，用于创建一个基本的HTTP服务器。让我来解释一下主要的部分：

1. **导入必要的类**：

   ```java
   import com.sun.net.httpserver.HttpServer;
   import com.sun.net.httpserver.HttpHandler;
   import com.sun.net.httpserver.HttpExchange;
   ```

   这些是Java SE中提供的用于创建HTTP服务器的类和接口。

2. **主类 SimpleHttpServer**：

   ```java
   public class SimpleHttpServer {
   ```

   这是主类的定义。

3. **main 方法**：

   ```java
   public static void main(String[] args) throws IOException {
       int port = 8000;
       HttpServer server = HttpServer.create(new InetSocketAddress(port), 0);
       server.createContext("/", new MyHandler());
       server.setExecutor(null); // creates a default executor
       server.start();
       System.out.println("Server is running on port " + port);
   }
   ```

   - **端口设置**：通过 `int port = 8000;` 设置服务器监听的端口为 8000。
   - **创建 HTTP 服务器**：使用 `HttpServer.create(new InetSocketAddress(port), 0);` 创建一个HTTP服务器实例，并绑定到指定的端口。
   - **设置处理程序**：通过 `server.createContext("/", new MyHandler());` 设置处理所有 `/` 路径请求的处理程序为 `MyHandler` 类。
   - **启动服务器**：通过 `server.start();` 启动HTTP服务器。
   - **输出提示**：通过 `System.out.println("Server is running on port " + port);` 输出服务器已经启动并监听的端口。

4. **静态内部类 MyHandler**：

   ```java
   static class MyHandler implements HttpHandler {
       @Override
       public void handle(HttpExchange t) throws IOException {
           String response = "Hello, World!";
           t.sendResponseHeaders(200, response.length());
           OutputStream os = t.getResponseBody();
           os.write(response.getBytes());
           os.close();
       }
   }
   ```

   - **实现 HttpHandler 接口**：`MyHandler` 类实现了 `HttpHandler` 接口，用于处理 HTTP 请求。
   - **handle 方法**：`handle(HttpExchange t)` 方法是处理请求的核心方法。
     - **构造响应**：使用 `String response = "Hello, World!";` 构造响应内容。
     - **发送响应头**：`t.sendResponseHeaders(200, response.length());` 发送状态码为 200 的响应头，并设置响应体长度。
     - **获取输出流**：`OutputStream os = t.getResponseBody();` 获取响应体的输出流。
     - **写入响应内容**：`os.write(response.getBytes());` 将响应内容写入输出流。
     - **关闭输出流**：`os.close();` 关闭输出流，完成响应的发送。

这段代码的作用是创建一个简单的HTTP服务器，监听在本地的 8000 端口，对所有的请求返回 "Hello, World!" 的字符串作为响应。

### 编写 `pom.xml` 文件

在 `pom.xml` 中配置 Maven 打包插件，以便将项目打包成可执行 JAR 文件。以下是一个简单的 `pom.xml` 配置示例：

```xml
<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.example</groupId>
    <artifactId>MySimpleHttpServer</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- Maven 插件 -->
    <build>
        <plugins>
            <!-- 打包成可执行 JAR 文件的插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.2.2</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>SimpleHttpServer</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
```

### 编写和编译代码

在 `src/main/java/` 目录下创建 `SimpleHttpServer.java` 文件，并编写你的 Java 代码（可以使用之前提到的简单 HTTP 服务器的代码）。

### 执行打包命令

打开命令行或终端，进入项目根目录（包含 `pom.xml` 文件），执行 Maven 打包命令：

```bash
mvn clean package
```

这个命令会让 Maven 执行 `package` 阶段，根据 `pom.xml` 中的配置，将项目编译、打包，并生成 JAR 文件。如果一切顺利，Maven 会在 `target/` 目录下生成一个 JAR 文件，例如 `MySimpleHttpServer-1.0-SNAPSHOT.jar`。

*需要科学上网*

### 运行打包后的 JAR 文件

最后，使用以下命令来运行生成的 JAR 文件：

```bash
java -jar target/MySimpleHttpServer-1.0-SNAPSHOT.jar
```

替换 `MySimpleHttpServer-1.0-SNAPSHOT.jar` 为你实际生成的 JAR 文件名。如果一切正常，你会看到类似于 `Server is running on port 8000` 的输出，表示你的 Java 程序成功运行。

通过 Maven 打包，你不仅可以更方便地管理依赖和构建过程，还能确保项目的一致性和可重复性。