一、第一个 Java 程序

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

运行结果：

Hello, Java!

代码解析：

• public class：定义公共类，类名必须与文件名一致
• main 方法：程序入口，JVM 从这里开始执行
• System.out.println()：控制台输出语句

二、变量与数据类型

1. 基本数据类型

public class DataType {
    public static void main(String[] args) {
        // 整数类型
        int age = 25;
        long population = 7_000_000_000L;
        
        // 浮点类型
        double price = 99.99;
        float pi = 3.14f;
        
        // 字符类型
        char grade = 'A';
        
        // 布尔类型
        boolean isJavaFun = true;
        
        System.out.println("年龄：" + age);
        System.out.println("价格：" + price);
        System.out.println("等级：" + grade);
        System.out.println("有趣吗：" + isJavaFun);
    }
}

2. 引用数据类型

String name = "张三";
String city = "北京";

System.out.println(name + "住在" + city);

三、运算符

1. 算术运算符

int a = 10, b = 3;

System.out.println("a + b = " + (a + b));  // 13
System.out.println("a - b = " + (a - b));  // 7
System.out.println("a * b = " + (a * b));  // 30
System.out.println("a / b = " + (a / b));  // 3 (整数除法)
System.out.println("a % b = " + (a % b));  // 1 (取余)

2. 关系运算符

int x = 5, y = 10;

System.out.println("x == y: " + (x == y));  // false
System.out.println("x != y: " + (x != y));  // true
System.out.println("x > y: " + (x > y));    // false
System.out.println("x < y: " + (x = 5: " + (x >= 5));  // true

3. 逻辑运算符

boolean a = true, b = false;

System.out.println("a && b: " + (a && b));  // false (与)
System.out.println("a || b: " + (a || b));  // true (或)
System.out.println("!a: " + (!a));          // false (非)

四、控制流程

1. if-else 条件语句

import java.util.Scanner;

public class IfExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入你的年龄：");
        int age = scanner.nextInt();
        
        if (age < 18) {
            System.out.println("未成年");
        } else if (age < 60) {
            System.out.println("成年人");
        } else {
            System.out.println("老年人");
        }
        
        scanner.close();
    }
}

2. switch 语句

public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;
        String dayName;
        
        switch (day) {
            case 1:
                dayName = "星期一";
                break;
            case 2:
                dayName = "星期二";
                break;
            case 3:
                dayName = "星期三";
                break;
            case 4:
                dayName = "星期四";
                break;
            case 5:
                dayName = "星期五";
                break;
            case 6:
            case 7:
                dayName = "周末";
                break;
            default:
                dayName = "无效的日期";
        }
        
        System.out.println("今天是：" + dayName);
    }
}

3. for 循环

public class ForLoop {
    public static void main(String[] args) {
        // 计算 1 到 100 的和
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println("1 到 100 的和：" + sum);
        
        // 打印 99 乘法表
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "×" + i + "=" + (i*j) + "  ");
            }
            System.out.println();
        }
    }
}

4. while 循环

public class WhileLoop {
    public static void main(String[] args) {
        int count = 1;
        
        while (count <= 5) {
            System.out.println("第 " + count + " 次循环");
            count++;
        }
        
        // do-while 循环
        int num = 1;
        do {
            System.out.println("至少执行一次：" + num);
            num++;
        } while (num <= 3);
    }
}

五、数组

public class ArrayExample {
    public static void main(String[] args) {
        // 声明并初始化数组
        int[] numbers = {1, 2, 3, 4, 5};
        
        // 访问数组元素
        System.out.println("第一个元素：" + numbers[0]);
        System.out.println("数组长度：" + numbers.length);
        
        // 遍历数组
        System.out.print("所有元素：");
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + " ");
        }
        System.out.println();
        
        // 增强型 for 循环
        System.out.print("增强 for：");
        for (int num : numbers) {
            System.out.print(num + " ");
        }
        
        // 二维数组
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        System.out.println("\n二维数组：");
        for (int[] row : matrix) {
            for (int val : row) {
                System.out.print(val + " ");
            }
            System.out.println();
        }
    }
}

六、方法（函数）

public class MethodExample {
    
    // 无返回值方法
    public static void sayHello(String name) {
        System.out.println("你好，" + name + "！");
    }
    
    // 有返回值方法
    public static int add(int a, int b) {
        return a + b;
    }
    
    // 可变参数
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
    
    // 递归方法：计算阶乘
    public static long factorial(int n) {
        if (n == 0 || n == 1) {
            return 1;
        }
        return n * factorial(n - 1);
    }
    
    public static void main(String[] args) {
        sayHello("张三");
        
        int result = add(10, 20);
        System.out.println("10 + 20 = " + result);
        
        System.out.println("1+2+3+4+5 = " + sum(1, 2, 3, 4, 5));
        
        System.out.println("5 的阶乘 = " + factorial(5));
    }
}

七、面向对象基础

1. 类的定义

// 定义一个学生类
class Student {
    // 成员变量
    String name;
    int age;
    String major;
    
    // 构造方法
    public Student(String name, int age, String major) {
        this.name = name;
        this.age = age;
        this.major = major;
    }
    
    // 成员方法
    public void study() {
        System.out.println(name + "正在学习" + major + "专业");
    }
    
    public void introduce() {
        System.out.println("我叫" + name + "，今年" + age + "岁");
    }
}

// 使用类
public class Main {
    public static void main(String[] args) {
        Student s1 = new Student("李四", 20, "计算机科学与技术");
        Student s2 = new Student("王五", 21, "软件工程");
        
        s1.introduce();
        s1.study();
        
        s2.introduce();
        s2.study();
    }
}

八、实战练习

练习 1：猜数字游戏

import java.util.Random;
import java.util.Scanner;

public class GuessNumber {
    public static void main(String[] args) {
        Random random = new Random();
        int target = random.nextInt(100) + 1;
        Scanner scanner = new Scanner(System.in);
        int attempts = 0;
        
        System.out.println("=== 猜数字游戏 ===");
        System.out.println("我已经想好了一个 1-100 之间的数字");
        
        while (true) {
            System.out.print("请猜：");
            int guess = scanner.nextInt();
            attempts++;
            
            if (guess  target) {
                System.out.println("太大了！");
            } else {
                System.out.println("恭喜你猜对了！");
                System.out.println("总共猜了 " + attempts + " 次");
                break;
            }
        }
        
        scanner.close();
    }
}

总结

本文涵盖了 Java 基础语法的核心内容：

1. ✅ 变量与数据类型
2. ✅ 运算符（算术、关系、逻辑）
3. ✅ 控制流程（if、switch、for、while）
4. ✅ 数组（一维、二维）
5. ✅ 方法定义与调用
6. ✅ 面向对象基础（类与对象）

学习建议：

• 多敲代码：把示例代码都亲手敲一遍
• 多练习：完成文中的实战练习
• 理解原理：不要死记硬背，理解为什么这样写
• 循序渐进：基础打牢后再学习高级特性

下节预告：《Java 面向对象进阶：继承、封装、多态》

如果觉得本文有帮助，欢迎收藏、转发，让更多人看到！有任何问题欢迎在评论区留言讨论。

Java 基础语法入门：零基础也能看懂的详细教程最先出现在帝讯博客。

什么是指针？

简单来说，指针就是一个变量，它存储的是另一个变量的内存地址。想象一下，你家的地址就是一个”指针”，通过这个地址可以找到你家。

#include <stdio.h>

int main() {
    int age = 25;        // 定义一个整型变量
    int *p = &age;       // p 是指针，存储 age 的地址
    
    printf("age 的值：%d\n", age);
    printf("age 的地址：%p\n", &age);
    printf("指针 p 的值：%p\n", p);
    printf("指针 p 指向的值：%d\n", *p);
    
    return 0;
}

输出结果：

age 的值：25
age 的地址：0x7fff5fbff6ac
指针 p 的值：0x7fff5fbff6ac
指针 p 指向的值：25

指针的核心运算符

1. 取地址运算符 &

int a = 10;
int *ptr = &a;  // &a 获取变量 a 的地址

2. 解引用运算符 *

int a = 10;
int *ptr = &a;
printf("%d", *ptr);  // *ptr 获取 ptr 指向的值，输出 10

指针与数组

指针和数组有着密切的关系，数组名本质上就是一个常量指针。

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = arr;  // ptr 指向数组第一个元素
    
    // 两种访问方式等价
    printf("arr[0] = %d\n", arr[0]);
    printf("*ptr = %d\n", *ptr);
    
    // 指针算术运算
    for(int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, *(ptr + i));
    }
    
    return 0;
}

指针与函数

1. 指针作为函数参数

通过指针可以实现”传地址调用”，在函数内部修改外部变量的值。

#include <stdio.h>

// 交换两个数的值
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 10, y = 20;
    swap(&x, &y);
    printf("x = %d, y = %d\n", x, y);  // 输出：x = 20, y = 10
    return 0;
}

2. 返回指针的函数

// 返回数组中最大值的指针
int* findMax(int arr[], int size) {
    int *maxPtr = &arr[0];
    for(int i = 1; i  *maxPtr) {
            maxPtr = &arr[i];
        }
    }
    return maxPtr;
}

二级指针

指针本身也是变量，也有地址，指向指针的指针就是二级指针。

#include <stdio.h>

int main() {
    int a = 100;
    int *p1 = &a;      // 一级指针
    int **p2 = &p1;    // 二级指针
    
    printf("a = %d\n", a);
    printf("*p1 = %d\n", *p1);
    printf("**p2 = %d\n", **p2);
    
    return 0;
}

动态内存分配

指针最重要的应用之一就是动态内存管理。

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 动态分配数组
    int n = 5;
    int *arr = (int*)malloc(n * sizeof(int));
    
    // 使用动态数组
    for(int i = 0; i < n; i++) {
        arr[i] = (i + 1) * 10;
    }
    
    // 打印结果
    for(int i = 0; i < n; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }
    
    // 释放内存
    free(arr);
    arr = NULL;  // 避免野指针
    
    return 0;
}

常见指针错误

1. 野指针

// 错误示例
int *ptr;  // 未初始化的指针
*ptr = 10; // 危险！ptr 指向未知地址

// 正确做法
int *ptr = NULL;  // 初始化为 NULL
int a = 10;
ptr = &a;         // 再赋值有效地址

2. 内存泄漏

// 错误示例
int *ptr = (int*)malloc(sizeof(int));
*ptr = 10;
// 忘记 free(ptr)，导致内存泄漏

// 正确做法
int *ptr = (int*)malloc(sizeof(int));
*ptr = 10;
// 使用完毕后
free(ptr);
ptr = NULL;

3. 悬空指针

// 错误示例
int *getPointer() {
    int local = 100;
    return &local;  // 错误！返回局部变量地址
}

// 正确做法
int *getPointer() {
    int *ptr = (int*)malloc(sizeof(int));
    *ptr = 100;
    return ptr;  // 返回动态分配的内存
}

实战练习

题目 1：字符串反转

#include <stdio.h>
#include <string.h>

void reverseString(char *str) {
    char *start = str;
    char *end = str + strlen(str) - 1;
    char temp;
    
    while(start < end) {
        temp = *start;
        *start = *end;
        *end = temp;
        start++;
        end--;
    }
}

int main() {
    char str[] = "Hello, World!";
    printf("原字符串：%s\n", str);
    reverseString(str);
    printf("反转后：%s\n", str);
    return 0;
}

题目 2：冒泡排序（指针实现）

#include <stdio.h>

void bubbleSort(int *arr, int n) {
    for(int i = 0; i < n - 1; i++) {
        for(int j = 0; j  *(arr + j + 1)) {
                int temp = *(arr + j);
                *(arr + j) = *(arr + j + 1);
                *(arr + j + 1) = temp;
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    bubbleSort(arr, n);
    
    printf("排序后：");
    for(int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    
    return 0;
}

总结

指针是 C 语言的核心，掌握指针需要大量实践。以下是学习建议：

1. 理解概念：指针就是地址，*和&是核心运算符
2. 多画图：画出内存图帮助理解指针指向
3. 多练习：通过实际编程加深理解
4. 注意内存管理：malloc 和 free 配对使用
5. 避免常见错误：野指针、内存泄漏、悬空指针

指针虽然难，但一旦掌握，你的 C 语言水平会有质的飞跃。加油！💪

下节预告：《数据结构基础：链表与指针的完美结合》

如果你觉得本文有帮助，欢迎收藏、转发，让更多人看到！

C 语言指针详解：从入门到精通的完整指南最先出现在帝讯博客。

容器化技术已经成为现代应用部署的标准。随着微服务架构的普及和云原生技术的发展，Docker作为容器化的事实标准，已经深入到每个开发者的日常工作中。本文将带你从Docker基础概念开始，逐步构建企业级容器化部署方案，无论你是初学者还是有一定经验的开发者，都能从中获得实用的知识和技巧。

第一章：Docker基础概念与安装

1.1 什么是Docker？

Docker是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的Linux机器或Windows机器上，也可以实现虚拟化。

核心概念：

• 镜像（Image）：只读模板，包含运行应用程序所需的所有内容
• 容器（Container）：镜像的运行实例，可以启动、停止、删除
• 仓库（Registry）：存储和分发镜像的地方，如Docker Hub

1.2 Docker安装与配置

Ubuntu/Debian系统

         
    # 更新包索引    
    sudo apt update    
         
    # 安装必要依赖    
    sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release    
         
    # 添加Docker官方GPG密钥    
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg    
         
    # 设置稳定版仓库    
    echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null    
         
    # 安装Docker Engine    
    sudo apt update    
    sudo apt install docker-ce docker-ce-cli containerd.io    
         
    # 验证安装    
    sudo docker run hello-world    

CentOS/RHEL系统

         
    # 卸载旧版本    
    sudo yum remove docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine    
         
    # 安装必要工具    
    sudo yum install -y yum-utils    
         
    # 添加Docker仓库    
    sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo    
         
    # 安装Docker Engine    
    sudo yum install docker-ce docker-ce-cli containerd.io    
         
    # 启动并设置开机自启    
    sudo systemctl start docker    
    sudo systemctl enable docker    

Windows WSL2

         
    # 在PowerShell中以管理员身份运行    
    wsl --install    
    # 重启计算机后，安装Docker Desktop for Windows    
    # 确保WSL2后端已启用    

1.3 用户权限配置

为了避免每次使用Docker命令都需要sudo，将当前用户添加到docker组：

         
    sudo usermod -aG docker $USER    
    # 重新登录或执行以下命令    
    newgrp docker    

第二章：镜像构建最佳实践

2.1 Dockerfile编写规范

基础Dockerfile示例：

         
    # 使用官方Node.js运行时作为基础镜像    
    FROM node:18-alpine    
         
    # 设置工作目录    
    WORKDIR /app    
         
    # 复制package.json和package-lock.json（如果存在）    
    COPY package*.json ./    
         
    # 安装依赖    
    RUN npm ci --only=production && npm cache clean --force    
         
    # 复制应用源代码    
    COPY . .    
         
    # 暴露端口    
    EXPOSE 3000    
         
    # 定义环境变量    
    ENV NODE_ENV=production    
         
    # 运行应用    
    CMD ["node", "server.js"]    

2.2 多阶段构建（Multi-stage Builds）

多阶段构建可以显著减小最终镜像的大小：

         
    # 构建阶段    
    FROM node:18-alpine AS builder    
    WORKDIR /app    
    COPY package*.json ./    
    RUN npm ci --only=production && npm cache clean --force    
    COPY . .    
    RUN npm run build    
         
    # 运行阶段    
    FROM node:18-alpine AS runner    
    WORKDIR /app    
    COPY --from=builder /app/dist ./dist    
    COPY --from=builder /app/node_modules ./node_modules    
    COPY package*.json ./    
    EXPOSE 3000    
    CMD ["node", "dist/server.js"]    

2.3 镜像优化技巧

减少镜像层数：

         
    # 不好的做法 - 多个RUN指令    
    RUN apt-get update    
    RUN apt-get install -y curl    
    RUN apt-get install -y vim    
         
    # 好的做法 - 合并RUN指令    
    RUN apt-get update &&     
        apt-get install -y curl vim &&     
        rm -rf /var/lib/apt/lists/*    

使用.dockerignore文件：

node_modules
npm-debug.log
.git
.gitignore
README.md
.env
.nyc_output
coverage
.nyc_output
.coverage
.vscode
 

第三章：Docker Compose编排多容器应用

3.1 Docker Compose基础

Docker Compose是一个用于定义和运行多容器Docker应用程序的工具。

docker-compose.yml示例：

         
    version: '3.8'    
         
    services:    
      web:    
        build: .    
        ports:    
          - "3000:3000"    
        environment:    
          - NODE_ENV=production    
          - DATABASE_URL=postgresql://user:password@db:5432/myapp    
        depends_on:    
          - db    
          - redis    
        volumes:    
          - ./logs:/app/logs    
         
      db:    
        image: postgres:13    
        environment:    
          POSTGRES_DB: myapp    
          POSTGRES_USER: user    
          POSTGRES_PASSWORD: password    
        volumes:    
          - postgres_data:/var/lib/postgresql/data    
        restart: unless-stopped    
         
      redis:    
        image: redis:6-alpine    
        command: redis-server --appendonly yes    
        volumes:    
          - redis_data:/data    
        restart: unless-stopped    
         
    volumes:    
      postgres_data:    
      redis_data:    

3.2 环境配置管理

多环境配置：

         
    # docker-compose.prod.yml    
    version: '3.8'    
    services:    
      web:    
        build:    
          context: .    
          dockerfile: Dockerfile.prod    
        ports:    
          - "80:3000"    
        environment:    
          - NODE_ENV=production    
        restart: unless-stopped    
         
    # docker-compose.dev.yml      
    version: '3.8'    
    services:    
      web:    
        build:    
          context: .    
          dockerfile: Dockerfile.dev    
        ports:    
          - "3000:3000"    
        environment:    
          - NODE_ENV=development    
        volumes:    
          - .:/app    
          - /app/node_modules    

使用命令：

         
    # 开发环境    
    docker-compose -f docker-compose.yml -f docker-compose.dev.yml up    
         
    # 生产环境    
    docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d    

第四章：网络配置与数据持久化

4.1 Docker网络模式

四种网络模式：

1. bridge（默认）：容器间通过虚拟网桥通信
2. host：容器直接使用主机网络
3. none：容器无网络
4. overlay：跨主机容器通信

自定义网络：

         
    # 创建自定义网络    
    docker network create --driver bridge my-network    
         
    # 运行容器时指定网络    
    docker run --network my-network --name web-app nginx    

4.2 数据持久化策略

三种数据持久化方式：

1. Volumes（推荐）

         
    # 创建命名卷    
    docker volume create my-vol    
         
    # 挂载卷到容器    
    docker run -d --name web-app -v my-vol:/app/data nginx    

2. Bind Mounts

         
    # 挂载主机目录    
    docker run -d --name web-app -v /host/path:/container/path nginx    

3. tmpfs Mounts

         
    # 临时文件系统挂载（仅Linux）    
    docker run -d --name web-app --tmpfs /app/cache nginx    

第五章：安全加固与资源限制

5.1 安全最佳实践

使用非root用户：

         
    FROM node:18-alpine    
    RUN addgroup -g 1001 -S nodejs    
    RUN adduser -S nextjs -u 1001    
    USER nextjs    

扫描镜像漏洞：

         
    # 使用Docker Scout    
    docker scout quickview your-image:tag    
         
    # 使用Trivy    
    trivy image your-image:tag    

最小化基础镜像：

• 优先使用alpine版本
• 使用distroless镜像
• 定期更新基础镜像

5.2 资源限制

CPU和内存限制：

         
    # docker-compose.yml    
    services:    
      web:    
        image: nginx    
        deploy:    
          resources:    
            limits:    
              cpus: '0.5'    
              memory: 512M    
            reservations:    
              cpus: '0.25'    
              memory: 256M    

单独容器的资源限制：

         
    docker run -d     
      --name web-app     
      --memory=512m     
      --cpus=0.5     
      nginx    

第六章：CI/CD集成方案

6.1 GitHub Actions集成

.github/workflows/docker-build.yml：

         
    name: Build and Push Docker Image    
         
    on:    
      push:    
        branches: [ main ]    
         
    jobs:    
      build:    
        runs-on: ubuntu-latest    
            
        steps:    
        - uses: actions/checkout@v3    
            
        - name: Set up Docker Buildx    
          uses: docker/setup-buildx-action@v2    
              
        - name: Login to Docker Hub    
          uses: docker/login-action@v2    
          with:    
            username: ${{ secrets.DOCKERHUB_USERNAME }}    
            password: ${{ secrets.DOCKERHUB_TOKEN }}    
                
        - name: Build and push    
          uses: docker/build-push-action@v4    
          with:    
            context: .    
            push: true    
            tags: your-username/your-app:latest    

6.2 GitLab CI/CD集成

.gitlab-ci.yml：

         
    stages:    
      - build    
      - test    
      - deploy    
         
    build-image:    
      stage: build    
      script:    
        - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .    
        - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA    
         
    deploy-production:    
      stage: deploy    
      script:    
        - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY    
        - docker pull $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA    
        - docker stop my-app || true    
        - docker rm my-app || true    
        - docker run -d --name my-app -p 80:3000 $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA    
      only:    
        - main    

第七章：实战案例 – 完整Web应用部署

7.1 应用架构

我们将部署一个完整的Web应用，包含以下组件：

• Nginx：反向代理和静态文件服务
• PHP-FPM：PHP应用服务器
• MySQL：数据库
• Redis：缓存和会话存储

7.2 目录结构

my-web-app/
├── docker-compose.yml
├── nginx/
│   └── default.conf
├── php/
│   └── Dockerfile
├── src/
│   └── index.php
└── .env
 

7.3 配置文件

docker-compose.yml：

         
    version: '3.8'    
         
    services:    
      nginx:    
        image: nginx:alpine    
        ports:    
          - "80:80"    
        volumes:    
          - ./src:/var/www/html    
          - ./nginx/default.conf:/etc/nginx/conf.d/default.conf    
        depends_on:    
          - php    
        restart: unless-stopped    
         
      php:    
        build: ./php    
        volumes:    
          - ./src:/var/www/html    
        environment:    
          - DB_HOST=mysql    
          - DB_NAME=myapp    
          - DB_USER=user    
          - DB_PASS=password    
        depends_on:    
          - mysql    
          - redis    
        restart: unless-stopped    
         
      mysql:    
        image: mysql:8.0    
        environment:    
          MYSQL_DATABASE: myapp    
          MYSQL_USER: user    
          MYSQL_PASSWORD: password    
          MYSQL_ROOT_PASSWORD: rootpassword    
        volumes:    
          - mysql_data:/var/lib/mysql    
        restart: unless-stopped    
         
      redis:    
        image: redis:6-alpine    
        volumes:    
          - redis_data:/data    
        restart: unless-stopped    
         
    volumes:    
      mysql_data:    
      redis_data:    

nginx/default.conf：

         
    server {    
        listen 80;    
        server_name localhost;    
        root /var/www/html;    
        index index.php;    
         
        location / {    
            try_files $uri $uri/ /index.php?$query_string;    
        }    
         
        location ~ .php$ {    
            fastcgi_pass php:9000;    
            fastcgi_index index.php;    
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;    
            include fastcgi_params;    
        }    
    }    

php/Dockerfile：

         
    FROM php:8.1-fpm-alpine    
         
    # 安装扩展    
    RUN docker-php-ext-install mysqli pdo pdo_mysql    
         
    # 安装Redis扩展    
    RUN pecl install redis && docker-php-ext-enable redis    
         
    # 清理    
    RUN rm -rf /tmp/* /var/tmp/*    
         
    WORKDIR /var/www/html    

src/index.php：

         
    <?php    
    echo "<h1>欢迎使用Docker容器化部署！</h1>";    
         
    // 测试数据库连接    
    try {    
        $pdo = new PDO(    
            "mysql:host=mysql;dbname=myapp",    
            "user",    
            "password"    
        );    
        echo "<p>✅ 数据库连接成功！</p>";    
    } catch (PDOException $e) {    
        echo "<p>❌ 数据库连接失败: " . $e->getMessage() . "</p>";    
    }    
         
    // 测试Redis连接    
    try {    
        $redis = new Redis();    
        $redis->connect('redis', 6379);    
        $redis->set('test', 'Hello Redis!');    
        echo "<p>✅ Redis连接成功！</p>";    
        echo "<p>Redis测试值: " . $redis->get('test') . "</p>";    
    } catch (Exception $e) {    
        echo "<p>❌ Redis连接失败: " . $e->getMessage() . "</p>";    
    }    
    ?>    

7.4 部署步骤

         
    # 1. 克隆项目    
    git clone your-repo-url    
    cd my-web-app    
         
    # 2. 构建并启动服务    
    docker-compose up -d    
         
    # 3. 验证服务状态    
    docker-compose ps    
         
    # 4. 查看日志    
    docker-compose logs -f    
         
    # 5. 访问应用    
    # 打开浏览器访问 http://localhost    

第八章：监控与维护

8.1 日志管理

查看容器日志：

         
    # 查看特定服务日志    
    docker-compose logs web    
         
    # 实时跟踪日志    
    docker-compose logs -f web    
         
    # 查看最近100行日志    
    docker-compose logs --tail=100 web    

8.2 性能监控

使用cAdvisor监控容器性能：

         
    # docker-compose.monitoring.yml    
    version: '3.8'    
    services:    
      cadvisor:    
        image: gcr.io/cadvisor/cadvisor:v0.47.0    
        volumes:    
          - /:/rootfs:ro    
          - /var/run:/var/run:rw    
          - /sys:/sys:ro    
          - /var/lib/docker/:/var/lib/docker:ro    
        ports:    
          - "8080:8080"    
        privileged: true    
        devices:    
          - /dev/kmsg    

8.3 定期维护任务

清理未使用的资源：

         
    # 清理停止的容器    
    docker container prune    
         
    # 清理未使用的镜像    
    docker image prune -a    
         
    # 清理未使用的卷    
    docker volume prune    
         
    # 清理未使用的网络    
    docker network prune    
         
    # 一键清理所有未使用资源    
    docker system prune -a    

结语

Docker容器化部署不仅简化了应用的部署流程，还提高了环境的一致性和可移植性。通过本文的学习，你应该已经掌握了从基础概念到企业级应用部署的完整知识体系。

记住，容器化不是终点，而是现代化应用开发和运维的新起点。随着Kubernetes、Service Mesh等技术的发展，容器化生态还在不断演进。保持学习，持续优化你的容器化实践！

附录：常用Docker命令速查

Docker容器化部署全攻略：从零到企业级应用最先出现在帝讯博客。

JVM线程私有的区域有：虚拟机栈，本地方法栈，程序计数器。

虚拟机栈：主要存储方法，局部变量，运行的数据。 本地方法栈：主要存储本地方法（含有Native关键字的方法）。 程序计数器：存储程序运行位置的字节码行号指示器。

JVM线程共享的区域有：Java堆，元空间

Java堆：存储所有创建的对象，数组等。 元空间：存储虚拟机加载的字节码数据，常量，静态变量，运行时常量池等。

线程上下文切换

线程上下文切换，也就是CPU不再执行当前的线程，而去执行其他的线程。那有哪些原因会导致线程的上下文切换呢？

1. 线程的时间片用完
2. 垃圾回收（会暂停当前工作的线程，先进行垃圾回收）
3. 更高优先级的线程运行
4. 线程主动调用了某些方法，如sleep，yeild，wait，join，synchronized，lock等

当发生上下文切换时，操作系统会保存当前线程的状态，恢复另一个线程的状态，此时程序计数器会记住下一条jvm指令的执行地址，同时上文记录，程序计数器是线程私有的。

如何判断对象是否存活

判断对象是否存活有两种方法：引用计数算法和可达性分析算法。

引用计数法

在对象被创建的时候，会在对象头中分配一个空间，即计时器，来保存这个对象被引用的次数。如果这个对象被其他的对象引用，它的引用计数器会+1，如果删除其他对象对这个对象的引用，则它的引用计数会-1，当对象的引用计数为0时，这个对象就会被当成垃圾回收。

优点： 引用计数法实现起来比较简单，判断对象是否存活的效率比较高。 缺点： 无法解决对象之间循环引用的问题，不能检测到环的出现。例如，A和B之间相互引用，此时计数器都会显示为1，此时A和B都无法进行垃圾回收。

可达性分析法

Java虚拟机中的垃圾回收机制都是采用的可达性分析算法来探索存活的对象的。此种方法工作原理是会扫描java堆中的对象，沿着GC Roots对象往下寻找，看看是否能在此引用链中找到该对象，如果找不到的话，证明该对象没用了，表示该对象可以回收。

可达性分析算法最大的优点之一就是解决了对象之间的相互循环依赖的问题，目前和引用计数法比起来没有缺点。

JVM中的垃圾回收算法

对于新生代和老年代的对象，在JVM中会采取不同的垃圾回收算法。年轻代的对象一般都是朝生暮死的，创建之后很快就会被回收，而老年代的对象是需要长期存活的，因此用到的算法大不相同。新生代对应的收集方法为“Minor GC”，老年代对应的收集方法称为“Major GC”，而对于整个堆空间和方法区的回收被称为“Full GC”

标记清除算法

标记清除算法为最基础的垃圾收集算法，即为每个对象都分配一个标记为，这个标记位会记录对象的状态。标记着所要回收的对象，在标记完成后，统一回收掉所有被标记的对象，也可以标记存活的对象，清理掉未标记的对象。标记清除算法用于老年代的垃圾回收中。

优点： 基于可达性分析算法，实现起来比较简单，后续的算法都是基于这种思想来实现的。 缺点： 影响最大的一点在于，标记清除算法会使内存空间碎片化，即标记并清除垃圾后，会产生很多不连续的内存空间，这将导致较大的对象因为无法找到连续的内存而提前触发一次垃圾回收。 如果大部分对象需要回收，就会进行大量的标记和清除操作，存活对象数量多时效率会降低。

复制算法

复制算法被用于新生代的垃圾回收机制中，新生代有三部分，Eden（80%），和两个survivor区（From Survivor 和 To Survivor）。两个Survivor区为容量大小相等的两块内存，每次只使用其中的一块内存，当使用的那块内存用完后，就会将内存中还存活着的对象复制到另一块内存上，然后把使用过的那块内存空间清空。

优点： 实现起来比较简单，效率也比较高，可以保证内存有连续的区域，能够解决标记清除算法导致的内存碎片问题。 缺点： 可分配的内存空间缩小了一半儿，代价比较高，内存空间浪费比较多； 存活的对象比较多的时候使用复制算法将会导致效率降低。 进行标记清除算法时，会导致应用程序挂起（停顿），即stop the world（STW）。

扩展： 90%以上的对象都是朝生暮死的，所以在新生代中，每次为对象分配内存时会使用Eden区和其中的一块Survivor区，当发生垃圾回收时，JVM会将Eden和Survivor中存活的对象都复制到另一块Survivor区域内，之后清理掉Eden区和Survivor区域中的空间。综上所述，建立新对象时，新生代可用内存空间为整个儿新生代容量的90%（80%的Eden区和10%的Survivor区），如果发生了极少部分情况，即多于10%的对象存活下来了，没有被垃圾回收器回收掉，此时JVM会触发空间担保机制，即当Survivor空间不足以容纳一次Minor GC后的存活对象时，就需要依赖老年代进行分配担保。

标记整理算法

标记整理法是对标记清除算法的一个改进。第一个阶段和标记清除算法一样，都是将对象标记为存活和死亡状态，然而在第二阶段，标记清除算法只是将被标记的对象进行清除，标记整理算法会将存活的对象进行整理并且放到另一个端，然后再把所有的对象清除掉。 标记整理算法用于老年代的回收机制中。

优点： 不会像垃圾清除算法那样产生不连续的内存碎片空间 不会像复制算法那样划分两个区域，提高了空间的利用率 缺点： 效率上肯定更慢一些，因为多了一步整理的操作过程。

如何判断变量是否线程安全

对于成员变量和静态变量

• 如果它们没有被共享，则它们是线程安全的；
• 如果它们被共享了，根据它们的状态是否能够改变，又会分两种情况：如果只有读操作，则它们是线程安全的；如果有读写操作，则这段代码是临界区，是需要考虑线程安全的。

对于局部变量是否线程安全

• 局部变量是线程安全的
• 但局部变量引用的对象则未必线程安全。如果该对象没有逃离方法的作用访问，它是线程安全的；如果该对象逃离方法的作用范围，则是需要考虑线程安全的。

最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18] 输出：4 解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2： 输入：nums = [0,1,0,3,2,3] 输出：4

示例 3： 输入：nums = [7,7,7,7,7,7,7] 输出：1

思路：该题让求出最长的递增子序列，因此至少需要一次遍历，考虑到代码进行到每一步的状态才可以，所以动态规划法解决此题比较容易。

代码+详解：

class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums.length==0){
            return 0; //长度为0直接返回0
        }
        int [] dp=new int[nums.length];
        dp[0]=1; //初始化数组，也可以调用库函数Arrays.fill(dp,1)，但是效率会慢些
        int result=1;//初始化结果
        for(int i=1;i<nums.length;i++){
            dp[i]=1;//初始化数组
            for(int j=0;j<i;j++){
                if(nums[j]<nums[i]){
                dp[i]=Math.max(dp[i],dp[j]+1);//循环更新dp[i]的最大值
                }
            }
            result=Math.max(result,dp[i]);
        }
        return result;
    }
}

这些Java基础知识，诸佬们都还记得嘛(学习，复习，面试都可)最先出现在帝讯博客。

（1）pages（目录）：用来存放所有小程序的页面。

（2）utils（目录）：用来存放工具性质的模板

（3）app.js:小程序项目的入口文件

（4）app.json:小程序项目的全局配置文件。

（5）app.wxss:小程序项目的全局样式文件

（6） project.config.json项目的配置文件

这是一个练习项目宿舍管理小程序，我们可以清晰地看到在文件夹miniprogram下存在的几个文件夹。 第一个文件夹images主要是存放一些小程序中所需的图片；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YqBTqrBc-1664789463320)(https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7b41ad29e527442586288e704e3f7bba~tplv-k3u1fbpfcp-watermark.image?)]

pages就是存放小程序的每个页面，因为每个小程序肯定不会只有一个页面，所以pages下也存在多个页面。例如home是主页面，night是学生晚归管理界面等等。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ilBVlWH2-1664789463321)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b486a9199dff409dba11ede7c65b5d6f~tplv-k3u1fbpfcp-watermark.image?)]

JSON配置

JSON是一种数据格式，在实际开发工作中，JSON总是以配置文件的形式存在。在小程序中它也是以配置文件的形式存在，通过对不同的.json配置文件进行设置，可以对小程序进行不同级别的设置。

(1)小程序配置app.json

app.json是当前小程序的全局配置，包括了小程序的所有页面路径，窗口外观，界面表现等等。 新建一个空白的小程序，app.json默认的配置代码：

{
    "pages": [
        "pages/index/index"
    ],
    "window": {
        "backgroundTextStyle": "light",
        "navigationBarBackgroundColor": "#fff",
        "navigationBarTitleText": "Weixin",
        "navigationBarTextStyle": "black"
    },
    "style": "v2",
    "sitemapLocation": "sitemap.json"
}

其中pages是用来记录所有页面的路径，window记录全局页面的背景和文字颜色；style定义了组件的样式版本；sitemapLocation用来指明sitemap.json的位置

（2） 工具配置project.config.json

小程序的每个项目根目录下都会生成一个工具配置文件，主要目的就是方便开发者根据自己的兴趣爱好进行一些个性化配置，比如界面颜色、编译配置等方面。你在开发者工具中进行的任何配置都是会写入到这个文件的。

（3）页面配置page.json

小程序中的每一个页面，可以使用.json文件来对本页面的窗口外观进行配置，页面中的配置项会覆盖app.json的window中相同的配置项。

WXML 模板

其实小程序的开发和网页开发很类似，学过前端的小伙伴都知道网页是通过html+css+js进行开发的。而在小程序中wxml充当的就是网页中html的角色。

<view class="container">
  <view class="userinfo">
    <button wx:if="{{!hasUserInfo && canIUse}}"> 获取头像昵称 </button>
    <block wx:else>
      <image src="{{userInfo.avatarUrl}}" background-size="cover"></image>
      <text class="userinfo-nickname">{{userInfo.nickName}}</text>
    </block>
  </view>
  <view class="usermotto">
    <text class="user-motto">{{motto}}</text>
  </view>
</view>

和html非常相似但也存在很多不一样的地方，

• 标签名字不一样，小程序的标签是view、button、text
• 多了一些 wx:if 这样的属性以及 {{ }} 这样的表达式
• 提供了类似于vue中的模板语法

WXSS样式

WXSS是一套样式语言，用于描述WXML的组件样式，相当于网页开发中的css，WXSS具有CSS的大部分特性，但也做了一些扩充和修改。

• 新增了尺寸单位
• 提供了全局的样式和局部样式。其中app.wxss就是进行全局的样式设置。而page.wxss是进行单个页面的样式设置。
• WXSS 仅支持部分 CSS 选择器

JS逻辑交互

一个小程序或者是界面只有静态的样式完全是不能满足人们的需求的，必须有人机交互，这一功能就是通过JS来实现的。小程序的JS文件主要分为三类：app.js是整个小程序的入口；页面的.js文件，是单独页面的入口；普通的.js文件，就是普通的功能模块文件。例如：点击一个按钮的时候，希望界面上显示“Hello”

Page({
  clickMe: function() {
    this.setData({ msg: "Hello" })
  }
})

除此之外还可以通过JS调用小程序中的各种API，利用这些API可以使用微信提供的丰富功能。比如：微信登录、获取用户信息、微信支付等等。

小程序的组成结构最先出现在帝讯博客。

v1.5.2

v1.5.1

图片：

下载地址：https://suyan8.lanzoub.com/ijy7S1wizzxa

CoreNext主题1.5.2免授权 | WordPress源码最先出现在帝讯博客。