各種言語での具体的なサーバーの実装例

from flask import Flask, request

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello, world!'

@app.route('/api', methods=['POST'])
def api():
    data = request.get_json()  # POSTされたJSONデータを取得

    # ここにAPIの処理を実装

    response = {'result': 'success'}  # レスポンスデータを作成
    return response

if __name__ == '__main__':
    app.run(debug=True)  # デバッグモードでFlaskアプリを実行

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

@SpringBootApplication
@RestController
public class ServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServerApplication.class, args);
    }

    @GetMapping("/")
    public String hello() {
        return "Hello, world!";
    }

    @PostMapping("/api")
    public String api(@RequestBody String requestBody) {
        // ここにAPIの処理を実装

        String response = "{\"result\":\"success\"}"; // レスポンスデータを作成
        return response;
    }
}

const express = require('express');
const app = express();
const bodyParser = require('body-parser');

// JSONリクエストボディをパースするためのミドルウェアを設定
app.use(bodyParser.json());

app.get('/', (req, res) => {
    res.send('Hello, world!');
});

app.post('/api', (req, res) => {
    const requestData = req.body; // POSTされたJSONデータを取得

    // ここにAPIの処理を実装

    const responseData = { result: 'success' }; // レスポンスデータを作成
    res.json(responseData); // JSONレスポンスを送信
});

app.listen(3000, () => {
    console.log('Server is running on http://localhost:3000');
});

(ns my-app.server
  (:require [ring.adapter.jetty :refer [run-jetty]]
            [ring.middleware.json :refer [wrap-json-body]]
            [ring.util.response :refer [response]]
            [ring.util.request :refer [params]]))

(defn handle-post [request]
  (let [data (params request)] ; POSTされたデータを取得
    ; ここにAPIの処理を実装
    (response {:result "success"}))) ; レスポンスデータを作成

(defn handle-get [request]
  (response "Hello, world!")) ; レスポンスデータを作成

(defn app [request]
  (let [method (:request-method request)]
    (case method
      :post (handle-post request)
      :get (handle-get request)
      ; その他のHTTPメソッドに対する処理を追加
      )))

; JettyサーバーでRingアプリケーションを起動
(run-jetty app {:port 3000})

// routes/api.php

Route::post('/api/data', 'ApiController@handlePost'); // POSTリクエストのハンドラ
Route::get('/api/data', 'ApiController@handleGet'); // GETリクエストのハンドラ

// app/Http/Controllers/ApiController.php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\Response;

class ApiController extends Controller
{
    public function handlePost(Request $request)
    {
        $data = $request->all(); // POSTされたデータを取得
        // ここにAPIの処理を実装
        return response()->json(['result' => 'success']); // JSONレスポンスを返す
    }

    public function handleGet(Request $request)
    {
        return response('Hello, world!'); // レスポンスデータを返す
    }
}

package main

import (
	"fmt"
	"net/http"
)

func main() {
	http.HandleFunc("/", handleRoot) // ルートハンドラの設定
	http.HandleFunc("/api/data", handleAPI) // /api/data ハンドラの設定
	http.ListenAndServe(":8080", nil) // ポート8080でサーバーを起動し、リクエストをハンドラに渡す
}

func handleRoot(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "Hello, World!") // レスポンスデータを書き込む
}

func handleAPI(w http.ResponseWriter, r *http.Request) {
	// /api/data へのリクエストのハンドラを実装
	if r.Method == "POST" {
		// POSTリクエストの処理
		// r.Body からリクエストボディを取得し、必要に応じて処理を実装
		fmt.Fprint(w, "Received POST request")
	} else if r.Method == "GET" {
		// GETリクエストの処理
		// 必要に応じてデータを取得し、レスポンスデータを生成して w に書き込む
		fmt.Fprint(w, "Received GET request")
	} else {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
	}
} 

#include 
#include 
#include 
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SOCKET_PATH "/tmp/my_socket" // ソケットのパス

int main() {
    int server_fd, client_fd;
    struct sockaddr_un server_addr, client_addr;
    socklen_t client_addr_len;
    char buffer[256];

    // ソケットの作成
    server_fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // ソケットの設定
    server_addr.sun_family = AF_UNIX;
    strncpy(server_addr.sun_path, SOCKET_PATH, sizeof(server_addr.sun_path) - 1);

    // ソケットのバインド
    if (bind(server_fd, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1) {
        perror("bind");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // ソケットのリスニング開始
    if (listen(server_fd, 5) == -1) {
        perror("listen");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    printf("Server is running...\n");

    while (1) {
        // クライアントからの接続を待ち受ける
        client_addr_len = sizeof(client_addr);
        client_fd = accept(server_fd, (struct sockaddr *) &client_addr, &client_addr_len);
        if (client_fd == -1) {
            perror("accept");
            close(server_fd);
            exit(EXIT_FAILURE);
        }

        printf("Client connected\n");

        // クライアントからのデータを受信
        ssize_t num_bytes = recv(client_fd, buffer, sizeof(buffer), 0);
        if (num_bytes == -1) {
            perror("recv");
            close(client_fd);
            close(server_fd);
            exit(EXIT_FAILURE);
        }

        printf("Received data: %.*s\n", (int) num_bytes, buffer);

        // クライアントにデータを送信
        if (send(client_fd, "Hello, World!", 14, 0) == -1) {
            perror("send");
            close(client_fd);
            close(server_fd);
            exit(EXIT_FAILURE);
        }

        // クライアントとの接続を閉じる
        close(client_fd);
    }

    // ソケットを閉じる
    close(server_fd);

    return 0;
}