应急指挥与调度子模块示例

下面给出一个 “应急指挥与调度模块” 的示例实现，展示如何通过消息队列与数据库相结合，来完成应急事件的创建、任务分派、资源调度、进度汇报等功能。该模块与之前的“数据采集与管理”、“实时监测与预警”、“智能分析与辅助决策”等模块一样，可被视为微服务之一，接入到整个自然灾害应急管理系统当中。

重要说明

  1. 这是一个演示或原型级示例，适合初步了解“应急指挥与调度”在消息驱动场景下的整体思路。
  2. 实际生产环境需要补充：安全鉴权、RBAC/多角色访问控制、日志审计、分布式部署、高可用、CI/CD 集成、监控告警等工程化环节。
  3. 以下示例将代码集中在一个 main.py 文件里，便于一次性查看；实际开发中应进行更好的模块化拆分和工程化管理。
  4. 演示使用 RabbitMQ 作为消息队列（“消息的 Python 代码”），也可替换成 Kafka、Redis Stream、或其他消息中间件。

一、目录结构示例

假设我们建立一个名为 command-dispatch-service 的文件夹，用于存放本微服务代码。示例目录如下：

command-dispatch-service
├── Dockerfile
├── docker-compose.yml
├── requirements.txt
├── .env
├── app
│   ├── main.py       # FastAPI入口 + RabbitMQ 消费/生产示例
│   ├── config.py     # 可选: 存放数据库、MQ等配置
│   └── models.py     # 可选: ORM等
└── README.md

下面的示例会将所有核心内容合并到一个文件 main.py 中，方便展示。

二、依赖文件

1. requirements.txt

示例依赖（版本仅供参考）：

fastapi==0.95.2
uvicorn==0.22.0
pydantic==1.10.7
SQLAlchemy==1.4.46
psycopg2-binary==2.9.6
python-dotenv==1.0.0

# RabbitMQ/AMQP 客户端
pika==1.3.1

若你打算使用 Kafka，可安装 kafka-python 或 confluent-kafka 并在代码中做相应改动。

2. .env（示例）

存放环境变量，如数据库配置、RabbitMQ配置等：

DB_HOST=localhost
DB_PORT=5432
DB_NAME=dispatch_db
DB_USER=myuser
DB_PASS=mypass

RABBITMQ_HOST=localhost
RABBITMQ_PORT=5672
RABBITMQ_USER=guest
RABBITMQ_PASS=guest

# RabbitMQ中的Exchange、Queue名称等
RABBITMQ_EXCHANGE=emergency_exchange
RABBITMQ_QUEUE=task_queue

3. docker-compose.yml（示例）

可快速启动 PostgreSQL、RabbitMQ、以及本服务；示例如下：

version: '3.8'

services:
  db:
    image: postgres:14
    container_name: dispatch_db
    environment:
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypass
      POSTGRES_DB=dispatch_db
    ports:
      - "5432:5432"
    volumes:
      - db_data:/var/lib/postgresql/data

  rabbitmq:
    image: rabbitmq:3.9-management
    container_name: dispatch_rabbitmq
    environment:
      RABBITMQ_DEFAULT_USER: guest
      RABBITMQ_DEFAULT_PASS: guest
    ports:
      - "5672:5672"
      - "15672:15672"  # RabbitMQ管理UI端口
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq

  dispatch_api:
    build: .
    container_name: dispatch_api
    depends_on:
      - db
      - rabbitmq
    environment:
      - DB_HOST=db
      - DB_PORT=5432
      - DB_NAME=dispatch_db
      - DB_USER=myuser
      - DB_PASS=mypass
      - RABBITMQ_HOST=rabbitmq
      - RABBITMQ_PORT=5672
      - RABBITMQ_USER=guest
      - RABBITMQ_PASS=guest
      - RABBITMQ_EXCHANGE=emergency_exchange
      - RABBITMQ_QUEUE=task_queue
    ports:
      - "8300:8300"
    command: ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8300"]

volumes:
  db_data:
  rabbitmq_data:

三、app/main.py：应急指挥与调度模块完整示例

"""
示例：应急指挥与调度模块 (Command & Dispatch Module with RabbitMQ)

主要功能：
1. 事件(Incident)管理：创建应急事件、记录基本信息(类型、等级、地点等)。
2. 任务(Task)管理：指挥员在某个事件下创建/分配任务，指定执行部门/小组。
3. 资源(Resource)与调度：登记救援队、车辆、物资等，对接RabbitMQ进行分发或状态变更。
4. 消息队列交互：当有新任务或任务状态更新时，通过RabbitMQ发送消息，其他系统或内部消费线程可接收并处理。
5. 任务进度/报告回传：任务执行方可以发布进度到队列或通过API回传，指挥员在系统内查看执行情况。

注意：仅为原型示例，实际项目需补充安全、日志、权限、容灾、高可用等。
"""

import os
import time
import threading
from datetime import datetime
from typing import Optional, List

from fastapi import FastAPI, Body, Depends, HTTPException
from pydantic import BaseModel, Field
from sqlalchemy import create_engine, Column, Integer, String, DateTime, Boolean, ForeignKey
from sqlalchemy.orm import sessionmaker, declarative_base, Session, relationship
from sqlalchemy.exc import SQLAlchemyError

# 环境变量加载
from dotenv import load_dotenv
load_dotenv()

# ============== 数据库配置 ==============
DB_HOST = os.getenv("DB_HOST", "localhost")
DB_PORT = os.getenv("DB_PORT", "5432")
DB_NAME = os.getenv("DB_NAME", "dispatch_db")
DB_USER = os.getenv("DB_USER", "myuser")
DB_PASS = os.getenv("DB_PASS", "mypass")

DATABASE_URL = f"postgresql://{DB_USER}:{DB_PASS}@{DB_HOST}:{DB_PORT}/{DB_NAME}"

engine = create_engine(DATABASE_URL, echo=False)
SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False)
Base = declarative_base()

# ============== RabbitMQ配置 ==============
RABBITMQ_HOST = os.getenv("RABBITMQ_HOST", "localhost")
RABBITMQ_PORT = int(os.getenv("RABBITMQ_PORT", "5672"))
RABBITMQ_USER = os.getenv("RABBITMQ_USER", "guest")
RABBITMQ_PASS = os.getenv("RABBITMQ_PASS", "guest")
RABBITMQ_EXCHANGE = os.getenv("RABBITMQ_EXCHANGE", "emergency_exchange")
RABBITMQ_QUEUE = os.getenv("RABBITMQ_QUEUE", "task_queue")

import pika
import json

# ============== 数据库ORM模型 ==============
class Incident(Base):
    """
    应急事件表，如地震、洪水、火灾等事件的基本信息
    """
    __tablename__ = "incidents"

    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
    incident_type = Column(String(50))     # 事件类型，如 'earthquake', 'flood', 'fire'
    severity_level = Column(String(20))    # 事件严重程度，例: 'red', 'orange', 'yellow', 'blue' 或数字分级
    location = Column(String(100))         # 事件地点
    description = Column(String(255))      # 事件简要描述
    created_at = Column(DateTime, default=datetime.utcnow)

    tasks = relationship("Task", back_populates="incident")

class Task(Base):
    """
    任务表，记录在某个事件下创建的具体任务
    """
    __tablename__ = "tasks"

    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
    incident_id = Column(Integer, ForeignKey("incidents.id"))
    task_name = Column(String(100))
    assigned_department = Column(String(50))  # 指派给哪个部门或小组
    status = Column(String(20), default="pending")  # 任务状态: pending, in_progress, completed, canceled
    created_at = Column(DateTime, default=datetime.utcnow)

    incident = relationship("Incident", back_populates="tasks")

class Resource(Base):
    """
    资源表：记录可用的救援队、车辆、物资等
    """
    __tablename__ = "resources"

    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
    resource_name = Column(String(100))
    resource_type = Column(String(50))   # 'vehicle', 'team', 'equipment' 等
    is_available = Column(Boolean, default=True) 
    location = Column(String(100), nullable=True)
    created_at = Column(DateTime, default=datetime.utcnow)

# ============== 初始化数据库 ==============
def init_db():
    Base.metadata.create_all(bind=engine)

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

# ============== Pydantic Schemas ==============
class IncidentCreate(BaseModel):
    incident_type: str
    severity_level: str
    location: str
    description: Optional[str]

class IncidentResponse(BaseModel):
    id: int
    incident_type: str
    severity_level: str
    location: str
    description: Optional[str]
    created_at: datetime

    class Config:
        orm_mode = True

class TaskCreate(BaseModel):
    incident_id: int
    task_name: str
    assigned_department: str

class TaskUpdateStatus(BaseModel):
    status: str  # pending, in_progress, completed, canceled

class TaskResponse(BaseModel):
    id: int
    incident_id: int
    task_name: str
    assigned_department: str
    status: str
    created_at: datetime

    class Config:
        orm_mode = True

class ResourceCreate(BaseModel):
    resource_name: str
    resource_type: str
    location: Optional[str]

class ResourceUpdate(BaseModel):
    is_available: Optional[bool]
    location: Optional[str]

class ResourceResponse(BaseModel):
    id: int
    resource_name: str
    resource_type: str
    is_available: bool
    location: Optional[str]
    created_at: datetime

    class Config:
        orm_mode = True


# ============== FastAPI应用初始化 ==============
app = FastAPI(
    title="Command & Dispatch Service",
    description="应急指挥与调度模块示例 (使用RabbitMQ进行任务消息分发)",
    version="0.1.0",
)

# ============== RabbitMQ工具函数 ==============
def get_rabbitmq_connection():
    """
    创建并返回一个RabbitMQ连接
    """
    credentials = pika.PlainCredentials(RABBITMQ_USER, RABBITMQ_PASS)
    connection = pika.BlockingConnection(
        pika.ConnectionParameters(
            host=RABBITMQ_HOST, port=RABBITMQ_PORT, credentials=credentials
        )
    )
    return connection

def publish_task_message(task_data: dict):
    """
    将新创建的任务或任务状态更新发布到RabbitMQ中
    其他下游服务或工作者可订阅 queue 获取任务信息。
    """
    try:
        connection = get_rabbitmq_connection()
        channel = connection.channel()
        # 声明Exchange和Queue并进行绑定
        channel.exchange_declare(exchange=RABBITMQ_EXCHANGE, exchange_type='fanout', durable=True)
        channel.queue_declare(queue=RABBITMQ_QUEUE, durable=True)
        channel.queue_bind(queue=RABBITMQ_QUEUE, exchange=RABBITMQ_EXCHANGE)

        message_body = json.dumps(task_data)
        channel.basic_publish(
            exchange=RABBITMQ_EXCHANGE,
            routing_key="",
            body=message_body,
            properties=pika.BasicProperties(
                delivery_mode=2  # 使消息可持久化
            )
        )
        channel.close()
        connection.close()
        print(f"[MQ] 已发布任务消息: {task_data}")
    except Exception as e:
        print("[ERROR] 发布到RabbitMQ失败:", e)


# ============== RabbitMQ 消费线程(可选) ==============
def consume_task_updates():
    """
    作为后台线程示例，用于接收下游(如救援队APP)对任务的反馈/进度更新消息。
    模拟：若真实需求需要双向通信，可建立另一个队列或Exchange接收消息后更新数据库。
    """
    try:
        connection = get_rabbitmq_connection()
        channel = connection.channel()
        channel.queue_declare(queue="task_updates", durable=True)  # 示例: 另一个队列

        def callback(ch, method, properties, body):
            msg = json.loads(body.decode("utf-8"))
            print(f"[MQ-Consume] 收到下游反馈: {msg}")
            # 此处可更新数据库中对应任务的状态或进度
            # TODO: 根据具体需求自行实现
            ch.basic_ack(delivery_tag=method.delivery_tag)

        channel.basic_consume(queue="task_updates", on_message_callback=callback, auto_ack=False)
        print("[MQ] consume_task_updates 线程已启动，等待下游进度反馈...")
        channel.start_consuming()
    except Exception as e:
        print("[ERROR] 消费下游进度队列失败:", e)
        time.sleep(5)


# ============== 启动事件 ==============
@app.on_event("startup")
def on_startup():
    init_db()
    print("[INFO] 数据表初始化完成(若无则自动创建)")

    # 启动一个后台线程以监听下游反馈 (可选)
    consumer_thread = threading.Thread(target=consume_task_updates, daemon=True)
    consumer_thread.start()


# ============== Incident 相关接口 ==============
@app.post("/incidents", response_model=IncidentResponse, summary="创建应急事件")
def create_incident(incident_data: IncidentCreate, db: Session = Depends(get_db)):
    new_incident = Incident(
        incident_type=incident_data.incident_type,
        severity_level=incident_data.severity_level,
        location=incident_data.location,
        description=incident_data.description
    )
    try:
        db.add(new_incident)
        db.commit()
        db.refresh(new_incident)
        return new_incident
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/incidents", response_model=List[IncidentResponse], summary="查看所有应急事件")
def list_incidents(db: Session = Depends(get_db)):
    incidents = db.query(Incident).order_by(Incident.created_at.desc()).all()
    return incidents

@app.get("/incidents/{incident_id}", response_model=IncidentResponse, summary="根据ID查看事件详情")
def get_incident(incident_id: int, db: Session = Depends(get_db)):
    incident = db.query(Incident).filter(Incident.id == incident_id).first()
    if not incident:
        raise HTTPException(status_code=404, detail="Incident not found")
    return incident


# ============== Task 相关接口 ==============
@app.post("/tasks", response_model=TaskResponse, summary="在事件下创建任务")
def create_task(task_data: TaskCreate, db: Session = Depends(get_db)):
    # 检查incident是否存在
    incident = db.query(Incident).filter(Incident.id == task_data.incident_id).first()
    if not incident:
        raise HTTPException(status_code=404, detail="Incident not found")

    new_task = Task(
        incident_id=task_data.incident_id,
        task_name=task_data.task_name,
        assigned_department=task_data.assigned_department,
        status="pending"
    )
    try:
        db.add(new_task)
        db.commit()
        db.refresh(new_task)
        # 发布消息到RabbitMQ，通知下游(比如部门调度系统或人员App)
        publish_task_message({
            "event": "task_created",
            "task_id": new_task.id,
            "incident_id": new_task.incident_id,
            "task_name": new_task.task_name,
            "assigned_department": new_task.assigned_department,
            "status": new_task.status
        })
        return new_task
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/tasks", response_model=List[TaskResponse], summary="查看所有任务")
def list_tasks(db: Session = Depends(get_db)):
    tasks = db.query(Task).order_by(Task.created_at.desc()).all()
    return tasks

@app.get("/tasks/{task_id}", response_model=TaskResponse, summary="查看任务详情")
def get_task(task_id: int, db: Session = Depends(get_db)):
    task = db.query(Task).filter(Task.id == task_id).first()
    if not task:
        raise HTTPException(status_code=404, detail="Task not found")
    return task

@app.put("/tasks/{task_id}/status", response_model=TaskResponse, summary="更新任务状态")
def update_task_status(task_id: int, update_data: TaskUpdateStatus, db: Session = Depends(get_db)):
    task = db.query(Task).filter(Task.id == task_id).first()
    if not task:
        raise HTTPException(status_code=404, detail="Task not found")

    if update_data.status not in ["pending", "in_progress", "completed", "canceled"]:
        raise HTTPException(status_code=400, detail="Invalid status value")

    task.status = update_data.status
    try:
        db.commit()
        db.refresh(task)
        # 发布消息到RabbitMQ，通知下游(比如监控大屏或其它服务)
        publish_task_message({
            "event": "task_status_updated",
            "task_id": task.id,
            "incident_id": task.incident_id,
            "task_name": task.task_name,
            "assigned_department": task.assigned_department,
            "status": task.status
        })
        return task
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(status_code=500, detail=str(e))


# ============== Resource 相关接口 ==============
@app.post("/resources", response_model=ResourceResponse, summary="登记可用资源")
def create_resource(res_data: ResourceCreate, db: Session = Depends(get_db)):
    new_res = Resource(
        resource_name=res_data.resource_name,
        resource_type=res_data.resource_type,
        location=res_data.location
    )
    try:
        db.add(new_res)
        db.commit()
        db.refresh(new_res)
        return new_res
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/resources", response_model=List[ResourceResponse], summary="查看资源清单")
def list_resources(db: Session = Depends(get_db)):
    rs = db.query(Resource).order_by(Resource.created_at.desc()).all()
    return rs

@app.get("/resources/{resource_id}", response_model=ResourceResponse, summary="查看资源详情")
def get_resource(resource_id: int, db: Session = Depends(get_db)):
    r = db.query(Resource).filter(Resource.id == resource_id).first()
    if not r:
        raise HTTPException(status_code=404, detail="Resource not found")
    return r

@app.put("/resources/{resource_id}", response_model=ResourceResponse, summary="更新资源信息")
def update_resource(resource_id: int, update_data: ResourceUpdate, db: Session = Depends(get_db)):
    r = db.query(Resource).filter(Resource.id == resource_id).first()
    if not r:
        raise HTTPException(status_code=404, detail="Resource not found")

    if update_data.is_available is not None:
        r.is_available = update_data.is_available
    if update_data.location is not None:
        r.location = update_data.location
    try:
        db.commit()
        db.refresh(r)
        return r
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(status_code=500, detail=str(e))

说明：

  • 在 consume_task_updates() 函数中，我们声明了一个名为 task_updates 的队列来模拟下游反馈。当救援队、物资运输等执行方通过某种方式（APP、设备端）向此队列发送进度消息时，我们可在此后台线程中消费，并更新数据库中的任务状态。
  • 如果你只需要单向下行分发（仅指挥中心→执行方），也可以不写此消费者线程，或者将它替换成更轻量的做法。
  • publish_task_message() 用于将关键任务信息推送到 RabbitMQ，其他微服务或工作节点只需订阅相同 exchange / queue 即可实时获取任务变更信息，用于更新前端大屏、手机APP、或其他子系统。

四、如何运行

  1. 手动安装/运行

    • 安装 Python 3.9+，并安装依赖：

      pip install -r requirements.txt

    • 保证你有一套本地/远程 PostgreSQL、RabbitMQ 环境，并在 .env 中正确配置连接信息。

    • 运行服务：

      uvicorn app.main:app --host 0.0.0.0 --port 8300

    • 访问 http://localhost:8300/docs 打开自动生成的Swagger API文档进行调试。

  2. Docker Compose 方式

    • 运行：

      docker-compose up -d --build

    • 这会启动：

      • db (PostgreSQL) - 端口 5432
      • rabbitmq (RabbitMQ) - 端口 5672 (以及 15672 供Web管理)
      • dispatch_api (本FastAPI服务) - 端口 8300

    • 访问 http://localhost:8300/docs 测试接口。

五、测试调用示例

  1. 创建一个应急事件

    curl -X POST http://localhost:8300/incidents \
-H "Content-Type: application/json" \
-d '{
  "incident_type": "flood",
  "severity_level": "orange",
  "location": "River-A2",
  "description": "River water level is rising fast"
}'

  2. 在此事件下创建任务

    curl -X POST http://localhost:8300/tasks \
-H "Content-Type: application/json" \
-d '{
  "incident_id": 1,
  "task_name": "Evacuate nearby residents",
  "assigned_department": "CivilAffairs"
}'
    • 成功后，会自动向 RabbitMQ 发布 task_created 消息；其他订阅者会收到此任务信息。

  3. 更新任务状态

    curl -X PUT http://localhost:8300/tasks/1/status \
-H "Content-Type: application/json" \
-d '{
  "status": "in_progress"
}'
    • 成功后，会发布 task_status_updated 消息给MQ，显示该任务从 pending -> in_progress。

  4. 登记可用资源（如某救援队或车辆）

    curl -X POST http://localhost:8300/resources \
-H "Content-Type: application/json" \
-d '{
  "resource_name": "Rescue Team A",
  "resource_type": "team",
  "location": "Station-B1"
}'

  5. 查看 RabbitMQ

    • 打开浏览器访问 http://localhost:15672（用户名密码默认为 guest/guest），可查看 emergency_exchange、task_queue 中的消息发布情况；
    • 如有下游系统订阅了 task_queue，就能获取到 task_created / task_status_updated 的消息进行相应处理。

六、关键逻辑

  1. 事件 (Incident)

    • 表示一次实际发生的紧急情况，如洪水或地震；包含事件类型、严重度、地点、描述等信息。
    • 通过 /incidents 系列接口进行增删改查。

  2. 任务 (Task)

    • 每个事件下会有若干任务，如“搜救某区域” “紧急撤离” “修复堤坝” 等；
    • status 用于记录当前任务所处的阶段 (pending, in_progress, completed, canceled)。
    • 创建或更新时，会通过 RabbitMQ 广播消息，方便其他系统或团队监听并执行。

  3. 资源 (Resource)

    • 登记救援队、车辆、船只、直升机、医疗物资等；也可设置 is_available 和 location 等属性随时更新。
    • 在更复杂的场景下，可实现资源自动/半自动分配给任务，并在更新资源状态时也可通知其他模块（如地图可视化、调度优化算法等）。

  4. 消息驱动

    • 本示例使用 publish_task_message() 将关键事件 (task_created, task_status_updated) 推送到 RabbitMQ；
    • 其他微服务或设备可以订阅 task_queue 实时获取调度指令，实现松耦合与实时性；
    • 同理，还演示了一个可选的消费者 consume_task_updates()，若需要执行方回传进度，就可以在另一个队列 task_updates 中收消息，更新数据库对应的 status。

七、补充扩展

  1. 权限管理

    • 不同角色（指挥中心、政府部门、社会组织、志愿者）在调用 API 时可能有不同操作权限；
    • 建议采用 OAuth2/JWT 或自定义 RBAC 体系进行安全管控。

  2. 多灾种耦合/多服务协同

    • 本服务可与“实时监测与预警”服务联动：当监测到触发条件后，自动创建 Incident 并分派初始任务；
    • 可与“智能分析与辅助决策”服务联动：在创建任务或调度资源时，调用优化/预测模型，给出调度建议或路线规划。

  3. 更完善的资源管理

    • 资源的数量、容量、属性及分配算法；
    • 多个任务对同一资源的竞争与优先级调度；
    • 实时位置追踪（GPS）并结合GIS地图。

  4. 日志与审计

    • 关键操作（事件创建、任务分配、状态变更）需记录审计日志；
    • 满足政府或行业对于应急管理流程合规性的要求。

  5. 多副本与分布式

    • 在灾害高峰时请求量激增，可进行微服务多副本部署、RabbitMQ集群化、数据库读写分离等。

使用消息队列进行任务分发与进度同步的“应急指挥与调度模块”，实现其核心功能：事件管理、任务管理、资源管理，并通过 RabbitMQ 或者其他消息中间件将指令/状态改变实时广播给相关服务或客户端。

在真实环境中，结合安全鉴权、分布式部署、高可用、日志审计、可观测性等工程实践，才能形成一套可靠的多灾种应急管理指挥系统，助力更高效地统筹资源、指挥调度、应对自然灾害或突发事件。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/950181.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

注册中心如何选型？Eureka、Zookeeper、Nacos怎么选

注册中心如何选型？Eureka、Zookeeper、Nacos怎么选

这是小卷对分布式系统架构学习的第9篇文章，第8篇时只回答了注册中心的工作原理的内容，面试官的第二个问题还没回答，今天再来讲讲各个注册中心的原理，以及区别，最后如何进行选型 上一篇文章：如何设计一个注册…
阅读更多...
C++ 复习总结记录三

C++ 复习总结记录三

C 复习总结记录三 主要内容 1、类的六个默认成员函数 2、构造函数 3、析构函数 4、拷贝构造函数 5、赋值运算符重载 6、const 成员函数 7、取地址及 const 取地址操作符重载 一 类的六个默认成员函数 如果一个类中什么成员都没有，简称为空类。空类中并不是…
阅读更多...
【简博士统计学习方法】第1章：4. 模型的评估与选择

【简博士统计学习方法】第1章：4. 模型的评估与选择

4. 模型的评估与选择 4.1 训练误差与测试误差 假如存在样本容量为 N N N的训练集，将训练集送入学习系统可以训练学习得到一个模型，我们将这么模型用决策函数的形式表达，也就是 y f ^ ( x ) y\hat{f}(x) yf^​(x)，关于模型的拟合…
阅读更多...
计算机网络 （30）多协议标签交换MPLS

计算机网络 （30）多协议标签交换MPLS

前言 多协议标签交换（Multi-Protocol Label Switching，MPLS）是一种在开放的通信网上利用标签引导数据高速、高效传输的新技术。 一、基本概念 MPLS是一种第三代网络架构技术，旨在提供高速、可靠的IP骨干网络交换。它通过将IP地址映…
阅读更多...
【Java】JVM内存相关笔记

【Java】JVM内存相关笔记

Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。这些区域有各自的用途，以及创建和销毁的时间，有的区域随着虚拟机进程的启动而一直存在，有些区域则是依赖用户线程的启动和结束而建立和销毁。 程序计数器&am…
阅读更多...
鸿蒙 ArkUI实现地图找房效果

鸿蒙 ArkUI实现地图找房效果

常用的地图找房功能，是在地图上添加区域、商圈、房源等一些自定义 marker，然后配上自己应用的一些筛选逻辑构成，在这里使用鸿蒙 ArkUI 简单实现下怎么添加区域/商圈、房源等 Marker. 1、开启地图服务 在华为开发者官网，注册应用&…
阅读更多...
STM32-WWDG/IWDG看门狗

STM32-WWDG/IWDG看门狗

WWDG/IWDG一旦开启不能关闭，可通过选项字节在上电时启动硬件看门狗，看门狗计数只能写入不能读取。看门狗启用时，T6bit必须置1，防止立即重置。 一、原理 独立看门狗-超时复位 窗口看门狗-喂狗（重置计数器，…
阅读更多...
基于JAVA+SSM的车辆运输管理

基于JAVA+SSM的车辆运输管理

基于JAVASSM的车辆运输管理 前言 ✌全网粉丝20W,csdn特邀作者、博客专家、CSDN[新星计划]导师、java领域优质创作者,博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ 🍅文末附源码下载链接🍅 哈喽兄弟们&#…
阅读更多...
【Linux系列】Vim 编辑器中的高效文本编辑技巧：删除操作

【Linux系列】Vim 编辑器中的高效文本编辑技巧：删除操作

💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学…
阅读更多...
win10 VS2019上libtorch库配置过程

win10 VS2019上libtorch库配置过程

win10 VS2019上libtorch库配置过程 0 引言1 获取libtorch2 在VS上配置使用libtorch库3 结语 0 引言 💻💻AI一下💻💻   libtorch库是一个用于深度学习的C库，是PyTorch的官方C前端。它提供了用于构建和训练深度学习模…
阅读更多...
通过gradle发布aar或jar携带sources-jar到maven nexus

通过gradle发布aar或jar携带sources-jar到maven nexus

找了很久，没有找到满意的。终于找到一个好的办法。 gradle7.x适用。比以前的写法简洁。 发布传统的jar工程 比如okhttp，fastjson等项目，纯java工程。 直接创建新文件publish.gradle: apply plugin: maven-publishProperties properties …
阅读更多...
STM32-笔记38-I2C-oled实验

STM32-笔记38-I2C-oled实验

一、什么是I2C？ I2C总线，全称Inter-Integrated Circuit（互连集成电路），是一种由Philips（现NXP半导体）公司在1980年代初开发的同步 串行 半双工通信总线。 二、有了串口通信为什么要使用I2C&…
阅读更多...
【Linux系列】并发与顺序执行：在 Linux 脚本中的应用与选择

【Linux系列】并发与顺序执行：在 Linux 脚本中的应用与选择

💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学…
阅读更多...
“AI 视频图像识别系统，开启智能新视界

“AI 视频图像识别系统，开启智能新视界

咱老百姓现在的生活啊，那是越来越离不开高科技了，就说这 AI 视频图像识别系统，听起来挺高大上，实际上已经悄无声息地融入到咱们日常的方方面面，给咱带来了超多便利。 先讲讲安防领域吧，这可是 AI 图像识别的…
阅读更多...
Burpsuite20241102macM1版安装

Burpsuite20241102macM1版安装

1、安装jdk11 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" brew update brew install openjdk11 echo export PATH"/opt/homebrew/opt/openjdk11/bin:$PATH" >> ~/.zshrc source ~/.zshrc j…
阅读更多...
NVIDIA在CES 2025上的三大亮点：AI芯片、机器人与自动驾驶、全新游戏显卡

NVIDIA在CES 2025上的三大亮点：AI芯片、机器人与自动驾驶、全新游戏显卡

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗？订阅我们的简报，深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同，从行业内部的深度分析和实用指南中受益。不要错过这个机会，成为AI领…
阅读更多...
PDFMathTranslate： Star13.8k，一款基于AI的PDF文档全文双语翻译PDF文档全文双语翻译，保留格式神器，你应该需要它

PDFMathTranslate： Star13.8k，一款基于AI的PDF文档全文双语翻译PDF文档全文双语翻译，保留格式神器，你应该需要它

嗨，大家好，我是小华同学，关注我们获得“最新、最全、最优质”开源项目和高效工作学习方法 PDFMathTranslate是一个开源项目，旨在为用户提供便捷的PDF科学论文翻译解决方案。它不仅能够翻译文本，还能保留公式、图表、目…
阅读更多...
h264之多视点mvc编码及解码过程(JMVC平台举例）

h264之多视点mvc编码及解码过程(JMVC平台举例）

h264标准参考平台JMVC是针对MVC标准的，JMVC支持多视点编码、合流、多视点解码操作。可以利用JMVC生成h264 mvc码流和解码。 JMVC的下载地址是：jvet / JMVC GitLabH.264/AVC multi-view coding (MVC) extension JMVC reference softwarehttps://vcgit.hh…
阅读更多...
LabVIEW软件侵权分析与应对

LabVIEW软件侵权分析与应对

问：如果涉及到LabVIEW软件的仿制或模仿，特别是在功能、界面等方面，如何判断是否构成侵权？该如何应对？ 答：LabVIEW软件的侵权问题，尤其是在涉及到仿制或模仿其功能、界面、设计等方面&#xff0…
阅读更多...
条款07：为多态基类声明virtual析构函数

条款07：为多态基类声明virtual析构函数

1.工厂方法举例&#xff1a;多态基类析构函数不声明为virtual会发生什么 #include <iostream> using namespace std;class Base { public:~Base(){} };class Box :public Base { public:const static int s_i 0; };class Box1 :public Base { public:const static int …
阅读更多...
最新文章

Copyright @ 2022~2023