☜SeYUN☞

■ Server

package com.lgcns.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;

import com.google.gson.Gson;

public class RunManager {

    public static void main(String[] args) throws Exception {
        Server server = new Server(8080);

        ServletContextHandler context = new ServletContextHandler();
        context.setContextPath("/");
        context.addServlet(JsonServlet.class, "/api/json");

        server.setHandler(context);
        server.start();

        System.out.println("Jetty server started: http://localhost:8080/api/json");

        server.join();
    }

    public static class JsonServlet extends HttpServlet {
        private final Gson gson = new Gson();

        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws IOException {

            String name = request.getParameter("name");

            Map<String, Object> result = new HashMap<>();
            result.put("method", "GET");
            result.put("status", "success");
            result.put("message", "GET request processed");
            result.put("name", name);

            writeJsonResponse(response, result);
        }

        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response)
                throws IOException {

            StringBuilder jsonBody = new StringBuilder();

            try (BufferedReader reader = request.getReader()) {
                String line;
                while ((line = reader.readLine()) != null) {
                    jsonBody.append(line);
                }
            }

            RequestData requestData = gson.fromJson(jsonBody.toString(), RequestData.class);

            Map<String, Object> result = new HashMap<>();
            result.put("method", "POST");
            result.put("status", "success");
            result.put("message", "POST request processed");
            result.put("receivedData", requestData);

            writeJsonResponse(response, result);
        }

        private void writeJsonResponse(HttpServletResponse response, Object data)
                throws IOException {

            response.setStatus(HttpServletResponse.SC_OK);
            response.setContentType("application/json");
            response.setCharacterEncoding("UTF-8");

            String json = gson.toJson(data);
            response.getWriter().write(json);
        }
    }

    public static class RequestData {
        private String userId;
        private String userName;
        private String message;

        public String getUserId() {
            return userId;
        }

        public String getUserName() {
            return userName;
        }

        public String getMessage() {
            return message;
        }
    }
}

jetty version client

HttpClient httpClient = new HttpClient();

        	httpClient.start();

        	Request request = httpClient.newRequest(url).method(HttpMethod.POST);
        	request.content(new StringContentProvider(sendData));

        	request.header(HttpHeader.CONTENT_TYPE, "application/json");


        	ContentResponse contentRes = request.send();

        	System.out.println(contentRes.getContentAsString());

        	httpClient.stop();

        	return contentRes.getContentAsString();

■ Client

이거는 java.net 버전임

package com.lgcns.test;

import com.google.gson.Gson;

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.HashMap;
import java.util.Map;

public class JsonClient {

    private static final Gson gson = new Gson();

    public static void main(String[] args) throws Exception {
        sendGet();
        sendPost();
    }

    private static void sendGet() throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://localhost:8080/api/json?name=testUser"))
                .header("Accept", "application/json")
                .GET()
                .build();

        HttpResponse<String> response =
                client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println("GET Response:");
        System.out.println(response.body());
    }

    private static void sendPost() throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();

        Map<String, Object> requestData = new HashMap<>();
        requestData.put("userId", "dev001");
        requestData.put("userName", "홍길동");
        requestData.put("message", "Hello Jetty JSON Server");

        String jsonBody = gson.toJson(requestData);

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://localhost:8080/api/json"))
                .header("Content-Type", "application/json; charset=UTF-8")
                .header("Accept", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        HttpResponse<String> response =
                client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println("POST Response:");
        System.out.println(response.body());
    }
}

package com.lgcns.test;

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.servlet.ServletHandler;

public class RunManager {
	
	
	public static void main(String[] args) throws Exception {
		new RunManager().start();
	}

	public void start() throws Exception {
		Server server = new Server();
		ServerConnector http = new ServerConnector(server);
		http.setHost("127.0.0.1");
		http.setPort(8080);
		server.addConnector(http);

		ServletHandler servletHandler = new ServletHandler();
		servletHandler.addServletWithMapping(MyServlet.class, "/*");
				
		server.setHandler(servletHandler);

		server.start();
		server.join();
	}
}

package com.lgcns.test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;

import javax.servlet.ServletException;
import javax.servlet.http.*;

import com.google.gson.Gson;

public class MyServlet extends HttpServlet {

	private static final long serialVersionUID = 1L;
	static class Data {
		String agentId;
		String reqId;
		String time;
		String type;
		int data;
		int latancy;
		
		public String toString() {
			//System.out.println(id + " " + time + " " + type + " " + data);
			return agentId + " " + reqId + " " + time + " " + type + " " + data;
		}
	}
	
	ArrayList<Data> PList = new ArrayList<Data>();
	ArrayList<Data> AList = new ArrayList<Data>();
	
	protected void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
		
		System.out.println("Path " + req.getPathInfo()); 
		
		
		InputStreamReader isr = new InputStreamReader(req.getInputStream());
		BufferedReader br = new BufferedReader(isr);
		String line = null;
		StringBuffer sb = new StringBuffer();
		
		while((line = br.readLine()) != null) {
			sb.append(line);
		}
				
		if(req.getPathInfo().equals("/monitoring")) {
			Gson gson = new Gson();
			
			HashMap map = gson.fromJson(sb.toString(), HashMap.class);
			
			Data data = new Data();
			
			data.agentId = (String) map.get("agentId");			
			data.reqId = (String) map.get("requestId");
			data.time = (String) map.get("timestamp");
			data.type = (String) map.get("dataType");
			double temp = (double) map.get("dataValue");
			data.data = (int)temp;
			
			if(data.type.equals("P")) {
				temp = (double) map.get("latency");
				data.latancy = (int)temp;
			}
						
			System.out.println(data);
			
			if(data.type.equals("P")) {
				PList.add(data);
			}else {
				AList.add(data);
			}
			
			res.setStatus(200);
			res.getWriter().write("done");
		}else if(req.getPathInfo().equals("/performance")) {
			Gson gson = new Gson();			
			
			File file = new File("./MODELS.JSON");
			
			FileReader fr = new FileReader(file);
			BufferedReader br2 = new BufferedReader(fr);
			StringBuffer strBuf = new StringBuffer();
			String line2 = null;
			while((line2 = br2.readLine()) != null) {
				strBuf.append(line2);				
			}
			
			HashMap modelList = gson.fromJson(strBuf.toString(), HashMap.class);
			
			HashMap map = gson.fromJson(sb.toString(), HashMap.class);
			String modelName = (String)map.get("modelName");
			String timeWindow = (String)map.get("timeWindow");
			
			ArrayList<String> agentList = (ArrayList) modelList.get(modelName);
			
			System.out.println(agentList);
			
			
			int searchCnt = 0;		
			int matCnt = 0;
			int latency = 0;
			int totalLatency = 0;
			
			for(Data pdata : PList) {
				//2025041010
				if(pdata.time.startsWith(timeWindow) != true) { 
					continue;
				}
				boolean flag = false;
				for(String agent :  agentList) {
					if(agent.equals(pdata.agentId)) {
						flag = true;
						break;
					}
				}
				
				if(flag == false) continue;
				
				searchCnt++;
				totalLatency += pdata.latancy;
				for(Data adata : AList ) {
					if(pdata.reqId.equals(adata.reqId)) {
						if(pdata.data == adata.data) {
							matCnt++;
						}
					}
				}
			}
			
			
			HashMap respon = new HashMap();
					
			latency = totalLatency / searchCnt;
			
			//{"correct":5, "total":6}
			respon.put("correct", matCnt);
			respon.put("total", searchCnt);
			respon.put("latency", latency);
			
			String answer = gson.toJson(respon);
					
			res.setStatus(200);
			res.getWriter().write(answer);
		}
		
		
	}
	
}