项目是前后端分离的项目~部署在docker上~结合chatgpt~deepseek~cursor~csdn
写的有点乱~多多包涵~图书馆快关门啦~

1. 根据chatgpt创建一个dockerfile~对应的结构~

docker_file/
├── docker-compose.yml     # Docker Compose 配置文件，定义所有服务
├── init.sql               # MySQL 数据库初始化脚本
│
├── frontend/              # 前端服务的目录
│   ├── Dockerfile         # 前端应用的 Dockerfile
│   ├── package.json
│   ├── nginx.conf
│   └── dist/              # 前端构建后的静态文件 (如果需要COPY)
│
└── backend/               # 后端服务的目录
    ├── Dockerfile         # 后端应用的 Dockerfile
    ├── your-backend-app.jar  # 后端构建后的 JAR 包目录

2.打包前端项目~直接在前端文件下输入打包的命令行

npm run build

打包的文件会生成存放在【dist】文件夹中


3.用cursor写的前端：dockerfile~

# 构建阶段
FROM node:18-alpine as build-stage

# 设置工作目录
WORKDIR /app

# 复制package.json和package-lock.json
COPY package*.json ./

# 安装依赖
RUN npm install

# 复制项目文件
COPY . .

# 构建项目
RUN npm run build

# 生产阶段
FROM nginx:stable-alpine as production-stage

# 复制构建产物到nginx目录
COPY --from=build-stage /app/dist /usr/share/nginx/html

# 复制nginx配置文件
COPY nginx.conf /etc/nginx/conf.d/nginx.conf

# 暴露80端口
EXPOSE 80

# 启动nginx
CMD ["nginx", "-g", "daemon off;"] 

4.nginx.conf文件~

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    # 开启 gzip 压缩
    gzip on;
    gzip_min_length 1k;
    gzip_comp_level 6;
    gzip_types text/plain text/css text/javascript application/json application/javascript application/x-javascript application/xml;
    gzip_vary on;
    gzip_disable "MSIE [1-6]\.";

    server {
        listen       80;
        server_name  localhost;

        root /usr/share/nginx/html;
        index index.html;

        # 支持前端路由
        location / {
            try_files $uri $uri/ /index.html;
            add_header Cache-Control "no-cache, no-store, must-revalidate";
            add_header Pragma "no-cache";
            add_header Expires "0";
        }

        # 静态资源缓存配置
        location /assets {
            expires 1y;
            add_header Cache-Control "public, no-transform";
        }

        # API 代理配置
        location /api {
            proxy_pass http://backend:8080;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            
            # 添加安全相关的 headers
            add_header X-Frame-Options "SAMEORIGIN";
            add_header X-XSS-Protection "1; mode=block";
            add_header X-Content-Type-Options "nosniff";
        }

        # 错误页面配置
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
} 

5.docker_compose.yml前端部分：

frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile
    container_name: doctors-frontend
    ports:
      - "5173:80"
    depends_on:
      - backend
    networks:
      - app-network

6.打包后端文件 maven-clean-package：出现jar包就是打包好的文件。

6.后端:dockerfile

# 使用JDK 17作为基础镜像
FROM eclipse-temurin:17-jdk-alpine

# 设置工作目录
WORKDIR /app

# 复制Maven构建的jar包到容器中
COPY doctor_recommend-0.0.1-SNAPSHOT.jar app.jar

# 暴露应用端口（根据你的应用配置修改端口号）
EXPOSE 8080

# 设置时区为中国时区
ENV TZ=Asia/Shanghai

# 启动命令
ENTRYPOINT ["java","-jar","app.jar"] 

7.docker_compose.yml后端部分：

  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile
    container_name: doctors-backend
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/doctor?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
      - SPRING_DATASOURCE_USERNAME=root
      - SPRING_DATASOURCE_PASSWORD=123456
    depends_on:
      - mysql
    networks:
      - app-network

8.数据库

步骤如下：

1. 在本地导出已有数据库数据（含结构+数据）（例如我数据库的名称为：doctor）：
   出现了好几次的乱码情况【建议直接使用图形化工具进行导出】~
   导出和docker识别都出现了乱码情况~
   导出的命令：

   mysqldump -u 用户名 -p --default-character-set=utf8mb4 --set-charset --skip-set-charset --hex-blob --databases doctor > init.sql
   

2. 修改 init.sql 文件 (解决乱码关键)：
   用文本编辑器打开 init.sql 文件。
   在文件的最开头（所有现有内容之前），添加以下两行：

   SET NAMES utf8mb4;
   SET CHARACTER SET utf8mb4;

3. 在项目根目录放置这个 SQL 文件：

   doctor_docker/ init.sql

4. 在 docker-compose.yml 中配置挂载：
   【因为我本地的mysql服务的端口就是3306，把本地的服务关闭~或者也可以改~】

   services:
     mysql:
       image: mysql:8.0
       container_name: doctors-mysql
       ports:
         - "3306:3306"
       environment:
         - MYSQL_ROOT_PASSWORD=123456
         - MYSQL_DATABASE=doctor
       volumes:
         - mysql-data:/var/lib/mysql
         - ./init.sql:/docker-entrypoint-initdb.d/init.sql
       networks:
         - app-network
       command: --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci

   ✅ 这样容器第一次启动时会自动导入这个备份文件，包含你本地已有的数据。

5. 注意：这个 SQL 文件只在第一次启动时执行。

8.【如果有修改sql文件】
       停止并移除所有旧的容器和数据卷 (关键！)：这一步非常重要，它会删除所有与你的 Docker Compose 配置相关的旧容器和数据卷，确保 MySQL 容器从一个干净的状态开始，并重新加载 init.sql。

 docker-compose down -v

9.重新构建并启动服务：

这个命令会根据 docker-compose.yml 重新构建（如果需要）并启动所有定义的容器。

 docker-compose up -d --build

10.最后的：docker-compose.yml 【添加注释】

# Docker Compose 文件版本，定义了 Compose 文件的语法和特性版本
version: '3.8' # 推荐使用较新的版本，例如 '3.8'

# 定义服务（即你要运行的各个应用容器）
services:
  # 前端服务配置
  frontend:
    # 构建镜像的配置
    build:
      # 指定构建上下文（Dockerfile 和所需源文件所在的目录），相对于 docker-compose.yml 文件的路径
      context: ./frontend
      # 指定用于构建此服务的 Dockerfile 的名称（如果不是默认的 'Dockerfile'）
      dockerfile: Dockerfile
    # 为容器指定一个易于识别的名称
    container_name: doctors-frontend
    # 端口映射：将主机（你的电脑）的 5173 端口映射到容器的 80 端口
    # 这样你可以通过 localhost:5173 访问前端应用
    ports:
      - "5173:80"
    # 声明此服务依赖于 backend 服务，确保 backend 先启动
    depends_on:
      - backend
    # 将此服务连接到 'app-network' 网络，以便与其他服务通信
    networks:
      - app-network

  # 后端服务配置
  backend:
    # 构建镜像的配置
    build:
      # 指定构建上下文目录
      context: ./backend
      # 指定 Dockerfile 的名称
      dockerfile: Dockerfile
    # 为容器指定一个名称
    container_name: doctors-backend
    # 端口映射：将主机的 8080 端口映射到容器的 8080 端口
    # 这样你可以通过 localhost:8080 访问后端 API
    ports:
      - "8080:8080"
    # 环境变量配置，通常用于 Spring Boot 应用的配置
    environment:
      - SPRING_PROFILES_ACTIVE=prod # 激活 Spring Boot 的 prod (生产) 配置
      # 数据库连接 URL：'mysql' 是 MySQL 容器在 Docker 网络中的服务名，3306 是其端口
      - SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/doctor?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
      - SPRING_DATASOURCE_USERNAME=root # 数据库用户名
      - SPRING_DATASOURCE_PASSWORD=123456 # 数据库密码
    # 声明此服务依赖于 mysql 服务，确保 mysql 先启动
    depends_on:
      - mysql
    # 将此服务连接到 'app-network' 网络
    networks:
      - app-network

  # MySQL 数据库服务配置
  mysql:
    # 使用官方的 MySQL 8.0 镜像
    image: mysql:8.0
    # 为容器指定一个名称
    container_name: doctors-mysql
    # 端口映射：将主机的 3306 端口映射到容器的 3306 端口
    # 这样你可以在主机上通过 3306 端口连接到容器内的 MySQL
    ports:
      - "3306:3306"
    # 环境变量配置，用于初始化 MySQL 容器
    environment:
      - MYSQL_ROOT_PASSWORD=123456 # 设置 root 用户的密码
      - MYSQL_DATABASE=doctor # 容器启动时自动创建的数据库名称
    # 数据卷挂载：实现数据持久化和文件初始化
    volumes:
      - mysql-data:/var/lib/mysql # 挂载一个命名卷 'mysql-data' 到容器的 MySQL 数据目录，实现数据持久化
      # 挂载本地的 init.sql 文件到容器的初始化目录，用于数据库初始化（结构和数据）
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    # 将此服务连接到 'app-network' 网络
    networks:
      - app-network
    # 容器启动时执行的命令，这里用于强制 MySQL 服务器使用 UTF-8 字符集和 unicode 校对规则
    command: --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci

# 定义 Docker 网络，使得各个服务可以在同一个网络中相互通信
networks:
  app-network:
    driver: bridge # 使用默认的桥接网络类型

# 定义命名卷，用于数据持久化
volumes:
  mysql-data: # 定义一个名为 'mysql-data' 的卷，用于存储 MySQL 数据
              # Docker 会在宿主机上管理这个卷的实际存储位置