服务器

index.ts复制

const server = Bun.serve({
  // `routes` 需要 Bun v1.2.3+
  routes: {
    // 静态路由
    "/api/status": new Response("OK"),

    // 动态路由
    "/users/:id": req => {
      return new Response(`你好，用户 ${req.params.id}!`);
    },

    // 按 HTTP 方法处理
    "/api/posts": {
      GET: () => new Response("帖子列表"),
      POST: async req => {
        const body = await req.json();
        return Response.json({ created: true, ...body });
      },
    },

    // 通配符路由，匹配所有以 "/api/" 开头且未被其他路由匹配的请求
    "/api/*": Response.json({ message: "未找到" }, { status: 404 }),

    // 从 /blog/hello 重定向到 /blog/hello/world
    "/blog/hello": Response.redirect("/blog/hello/world"),

    // 懒加载文件并提供服务
    "/favicon.ico": Bun.file("./favicon.ico"),
  },

  // （可选）未匹配路由的回退处理：
  // 如果 Bun 版本低于 1.2.3，则需要
  fetch(req) {
    return new Response("未找到", { status: 404 });
  },
});

console.log(`服务器正在运行于 ${server.url}`);

import myReactSinglePageApp from "./index.html";

Bun.serve({
  routes: {
    "/": myReactSinglePageApp,
  },
});

Bun.serve({
  port: 8080, // 默认使用 $BUN_PORT、$PORT、$NODE_PORT，否则为 3000 // [!code ++]
  hostname: "mydomain.com", // 默认使用 "0.0.0.0" // [!code ++]
  fetch(req) {
    return new Response("404!");
  },
});

const server = Bun.serve({
  port: 0, // 随机端口 // [!code ++]
  fetch(req) {
    return new Response("404!");
  },
});

// server.port 是随机选择的端口
console.log(server.port);

console.log(server.port); // 3000
console.log(server.url); // http://localhost:3000

bun --port=4002 server.ts

BUN_PORT=4002 bun server.ts

PORT=4002 bun server.ts

NODE_PORT=4002 bun server.ts

Bun.serve({
  unix: "/tmp/my-socket.sock", // 套接字路径
  fetch(req) {
    return new Response(`404!`);
  },
});

Bun.serve({
  unix: "\0my-abstract-socket", // 抽象命名空间套接字
  fetch(req) {
    return new Response(`404!`);
  },
});

Bun.serve({
  tls: {
    key: Bun.file("./key.pem"),
    cert: Bun.file("./cert.pem"),
  },
  http3: true, // [!code ++]
  fetch(req) {
    return new Response("通过 HTTP/3 你好！");
  },
});

Bun.serve({
  tls: {
    key: Bun.file("./key.pem"),
    cert: Bun.file("./cert.pem"),
  },
  http3: true,
  http1: false, // [!code ++]
  fetch(req) {
    return new Response("仅 HTTP/3");
  },
});

Bun.serve({
  tls: {
    key: Bun.file("./key.pem"),
    cert: Bun.file("./cert.pem"),
  },
  http2: true, // [!code ++]
  fetch(req) {
    return new Response("通过 HTTP/2 你好！");
  },
});

Bun.serve({
  // 30 秒（默认值为 10）
  idleTimeout: 30,

  fetch(req) {
    return new Response("Bun!");
  },
});

import type { Serve } from "bun";

export default {
  fetch(req) {
    return new Response("Bun!");
  },
} satisfies Serve.Options<undefined>;

const server = Bun.serve({
  routes: {
    "/api/version": () => Response.json({ version: "1.0.0" }),
  },
});

// 部署新路由无停机
server.reload({
  routes: {
    "/api/version": () => Response.json({ version: "2.0.0" }),
  },
});

const server = Bun.serve({
  fetch(req) {
    return new Response("Hello!");
  },
});

// 优雅停止服务器（等待正在进行的请求完成）
await server.stop();

// 强制停止并关闭所有活跃连接
await server.stop(true);

const closed = server.closeIdleConnections();
console.log(`closed ${closed} idle connections`);

// 如果服务器是唯一运行的东西，不阻止进程退出
server.unref();

// 恢复默认行为 - 保持进程存活
server.ref();

const server = Bun.serve({
  routes: {
    "/api/version": Response.json({ version: "v1" }),
  },
  fetch(req) {
    return new Response("v1");
  },
});

// 更新为新处理器
server.reload({
  routes: {
    "/api/version": Response.json({ version: "v2" }),
  },
  fetch(req) {
    return new Response("v2");
  },
});

const server = Bun.serve({
  async fetch(req, server) {
    // 给这个请求最多 60 秒的无活动时间，而不是默认的 10 秒
    server.timeout(req, 60);

    // 如果请求体发送超过 60 秒，则请求将被中止
    await req.text();

    return new Response("Done!");
  },
});

Bun.serve({
  routes: {
    "/events": (req, server) => {
      // 为此流式响应禁用空闲超时。
      // 否则如果 10 秒内（默认的 idleTimeout）
      // 没有发送字节，连接将被关闭。
      server.timeout(req, 0);

      return new Response(
        async function* () {
          yield "data: hello\n\n";
          // 事件可以零星到达，而不会导致连接被终止
        },
        { headers: { "Content-Type": "text/event-stream" } },
      );
    },
  },
});

const server = Bun.serve({
  fetch(req, server) {
    const address = server.requestIP(req);
    if (address) {
      return new Response(`Client IP: ${address.address}, Port: ${address.port}`);
    }
    return new Response("Unknown client");
  },
});

const server = Bun.serve({
  fetch(req, server) {
    return new Response(
      `活动请求数：${server.pendingRequests}\n` + `活动 WebSocket 数：${server.pendingWebSockets}`,
    );
  },
});

const server = Bun.serve({
  fetch(req, server) {
    const chatUsers = server.subscriberCount("chat");
    return new Response(`${chatUsers} 位用户正在聊天`);
  },
  websocket: {
    message(ws) {
      ws.subscribe("chat");
    },
  },
});

Bun.serve({
  fetch(req: Request) {
    return new Response("Bun!");
  },
  port: 3000,
});

require("http")
  .createServer((req, res) => res.end("Bun!"))
  .listen(8080);

interface Server extends Disposable {
  /**
   * 停止服务器接受新连接。
   * @param closeActiveConnections 如果为 true，则立即终止所有连接
   * @returns 服务器停止时解析的 Promise
   */
  stop(closeActiveConnections?: boolean): Promise<void>;

  /**
   * Close idle keep-alive connections without stopping the server.
   * @returns The number of connections closed
   */
  closeIdleConnections(): number;

  /**
   * Update handlers without restarting the server.
   * Only fetch, error, routes, and websocket can be updated.
   */
  reload(options: Serve.Options<undefined>): Server;

  /**
   * 向运行中的服务器发出请求。
   * 用于测试或内部路由。
   */
  fetch(request: Request | string): Response | Promise<Response>;

  /**
   * 将 HTTP 请求升级为 WebSocket 连接。
   * @returns 升级成功时为 true，否则为 false
   */
  upgrade<T = undefined>(
    request: Request,
    options?: {
      headers?: Bun.HeadersInit;
      data?: T;
    },
  ): boolean;

  /**
   * 向所有订阅了某个主题的 WebSocket 客户端发布消息。
   * @returns 发送的字节数；如果消息被丢弃则为 0；如果应用了背压则为 -1
   */
  publish(
    topic: string,
    data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
    compress?: boolean,
  ): ServerWebSocketSendStatus;

  /**
   * 获取订阅了某个主题的 WebSocket 客户端数量。
   */
  subscriberCount(topic: string): number;

  /**
   * 获取客户端 IP 地址和端口。
   * @returns 对于已关闭的请求或 Unix 套接字，返回 null
   */
  requestIP(request: Request): SocketAddress | null;

  /**
   * 为请求设置自定义空闲超时时间。
   * @param seconds 超时时间（以秒为单位），设为 0 可禁用
   */
  timeout(request: Request, seconds: number): void;

  /**
   * 服务器运行时保持进程处于活动状态。
   */
  ref(): void;

  /**
   * 允许服务器作为唯一运行中的运行时进程退出。
   */
  unref(): void;

  /** 当前正在处理的 HTTP 请求数量 */
  readonly pendingRequests: number;

  /** 当前活动的 WebSocket 连接数量 */
  readonly pendingWebSockets: number;

  /** 完整的服务器 URL，包括协议、主机名和端口 */
  readonly url: URL;

  /** 服务器正在监听的端口 */
  readonly port: number;

  /** 服务器绑定到的主机名 */
  readonly hostname: string;

  /** 服务器是否处于开发模式 */
  readonly development: boolean;

  /** 服务器实例 ID */
  readonly id: string;
}

interface WebSocketHandler<T = undefined> {
  /** WebSocket 消息的最大大小（以字节为单位） */
  maxPayloadLength?: number;

  /** 应用背压前排队消息的字节数 */
  backpressureLimit?: number;

  /** 达到背压限制时是否关闭连接 */
  closeOnBackpressureLimit?: boolean;

  /** 背压解除时调用 */
  drain?(ws: ServerWebSocket<T>): void | Promise<void>;

  /** 空闲超时时间（以秒为单位） */
  idleTimeout?: number;

  /** 启用按消息进行的 deflate 压缩 */
  perMessageDeflate?:
    | boolean
    | {
        compress?: WebSocketCompressor | boolean;
        decompress?: WebSocketCompressor | boolean;
      };

  /** 发送 Ping 帧以保持连接处于活动状态 */
  sendPings?: boolean;

  /** Whether ws.publish() also sends the message to the socket that published it, if subscribed */
  publishToSelf?: boolean;

  /** 连接打开时调用 */
  open?(ws: ServerWebSocket<T>): void | Promise<void>;

  /** 收到消息时调用 */
  message(ws: ServerWebSocket<T>, message: string | Buffer): void | Promise<void>;

  /** 连接关闭时调用 */
  close?(ws: ServerWebSocket<T>, code: number, reason: string): void | Promise<void>;

  /** 收到 Ping 帧时调用 */
  ping?(ws: ServerWebSocket<T>, data: Buffer): void | Promise<void>;

  /** 收到 Pong 帧时调用 */
  pong?(ws: ServerWebSocket<T>, data: Buffer): void | Promise<void>;
}

interface TLSOptions {
  /** 证书颁发机构链 */
  ca?: string | Buffer | BunFile | Array<string | Buffer | BunFile>;

  /** 服务器证书 */
  cert?: string | Buffer | BunFile | Array<string | Buffer | BunFile>;

  /** DH 参数文件的路径 */
  dhParamsFile?: string;

  /** 私钥 */
  key?: string | Buffer | BunFile | Array<string | Buffer | BunFile>;

  /** 降低 TLS 内存使用量 */
  lowMemoryMode?: boolean;

  /** 私钥密码短语 */
  passphrase?: string;

  /** OpenSSL 选项标志 */
  secureOptions?: number;

  /** SNI 服务器名称 */
  serverName?: string;
}