-

 

 

 

 

 

 

 

package ch15;

class MyOuterClass {
	int outerNum = 10;
	
	public MyOuterClass() {
		MyInnerClass mc = new MyInnerClass();
		System.out.println(mc.innerNum);
	}

	class MyInnerClass {
		int innerNum = 20;
	}
}

public class InnerEx01 {
	public static void main(String[] args) {
		MyOuterClass moc = new MyOuterClass();
		MyOuterClass.MyInnerClass d = moc.new MyInnerClass();
	}
}

 

 

 

package Chat;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Vector;

public class MySocketServer {

	ServerSocket serverSocket;
	Vector<NewSocketThread> vt; // 어레이리스트와 비슷하지만 여러곳에서 동시접근 시 queue를 이용하여 순서대로 처리한다

	public MySocketServer() throws Exception {
		vt = new Vector<>(); // 새 벡터 객체 생성

		serverSocket = new ServerSocket(3000);

		while (true) {

			// socket 을 보관해놔야한다 - 메시지 보내야할 소켓을 기억해야 하기 때문
			// 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다
			Socket socket = serverSocket.accept();
			System.out.println("요청이 들어옴");

			// 스레드를 돌리기 위한 객체 생성(socket을 받는다)
			// 각각 스레드는 자기가 연결해야할 socket을 객체 안에 들고 있게 된다
			NewSocketThread nt = new NewSocketThread(socket);

			// 새 스레드에 nt객체(타겟)을 넣는다
			Thread newWorker = new Thread(nt);

			// 스레드를 실행한다
			newWorker.start();

			// 벡터배열에 nt객체를 추가한다
			vt.add(nt);

		}
	}

	// 딴곳에 쓸일이없이 클래스 내부에서만 쓸거라면 내부클래스 생성
	// 새로운 스레드에게 버퍼를 연결할 수 있게 socket을 전달
	class NewSocketThread implements Runnable {

		Socket socket; // MySocketServer()에서 서버소켓이 받은 소켓을 저장
		BufferedReader br;
		BufferedWriter bw;

		public NewSocketThread(Socket socket) {
			this.socket = socket; // 받은 소켓을 저장
		}

		@Override
		public void run() {
			try {

				// 소켓에서 데이터를 받기 위한 버퍼
				br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

				// 소켓에 데이터를 쓰기 위한 버퍼
				bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

				String msg = "";

				// 버퍼에서 받은 데이터를 msg로 넣고 msg가 null이 아니면 내용을 실행한다
				while ((msg = br.readLine()) != null) {
					System.out.println("클라이언트 : " + msg);

					// 클라이언트들에게 누군가가 보낸 메시지를 다시 보낸다
					for (NewSocketThread newSocketThread : vt) {

						// 메시지를 보낸 당사자를 제외하고 나머지 클라이언트들에게 보낸다
						if (newSocketThread != this) {
							newSocketThread.bw.write(msg + "\n");
							newSocketThread.bw.flush(); // 버퍼를 비우는 것
						}
					}
				}

			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {

		try {
			new MySocketServer(); // 소켓 서버 가동
		} catch (Exception e) {
			e.printStackTrace();
		}

	}
}

 

 

package Chat;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class MySocketClient {
	
	// 소켓 통신을 위한 변수 생성
	Socket socket;

	public MySocketClient() throws Exception {
		
		// 소켓 객체 생성 - ip주소와 포트를 입력한다
		socket = new Socket("192.168.0.85", 3000);
		
		// 서버에서 보낸 데이터를 읽어들이는 쓰레드의 타겟을 생성한다
		ReadThread rt = new ReadThread();
		
		// 타겟을 쓰레드에 넣는다
		Thread newWorker = new Thread(rt);
		
		// 쓰레드 실행
		newWorker.start();
		
		// 소켓에 데이터를 보낼 bw 객체 생성
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

		// 키보드로 받은 데이터를 읽어들일 버퍼 keyboardIn 생성
		BufferedReader keyboardIn = new BufferedReader(new InputStreamReader(System.in));

		String outPutMsg = "";

		// 메인쓰레드는 여기서 무한루프
		while ((outPutMsg = keyboardIn.readLine()) != null) {
			bw.write(outPutMsg + "\n");
			bw.flush();
		}

	}
	
	// 쓰레드 실행을 위한 런 메서드를 포함한 러너블 클래스
	class ReadThread implements Runnable {
		
		@Override
		public void run() {
			try {
				
				BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
				
				String inputMsg = "";
				
				// 상대방이 보낸 데이터를 서버가 이 클라이언트로 보내면 br로 읽어서 실행
				while ((inputMsg = br.readLine()) != null) {
					System.out.println("상대방 : " + inputMsg);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}

		}
	}

	public static void main(String[] args) {
		try {
			new MySocketClient(); // 클라이언트 메서드 실행
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

 

-

 

finally

package Chat;

interface StarUnit {
	int getHp();
}

abstract class Protoss implements StarUnit{
	abstract int getSh();
}

abstract class Zerg implements StarUnit {}

class Zealot extends Protoss {
	int sh = 100;
	int hp = 100;
	
	@Override
	public int getSh() {
		return sh;
	}
	
	@Override
	public int getHp() {
		return hp;
	}
}

class Ultra extends Zerg {
	int hp = 100;
	
	@Override
	public int getHp() {
		return hp;
	}
	
}

public class FinallyEx01 {
	
	// 상태체크 (hp, sh)
	static void check(StarUnit unit) {
		try {
			Zealot z = (Zealot)unit;
			System.out.println("쉴드" + z.getSh());			
			System.out.println("체력" + z.getHp());			
		} catch (Exception e) {
			// 저그
			Ultra u = (Ultra)unit;
			System.out.println("저그는 쉴드가 없습니다.");
			System.out.println("남은 체력은 : " + u.getHp());
		} finally { // try 들어가면 무조건 실행된다
			System.out.println("나는 무조건 실행돼");
		}
	}
	
	public static void main(String[] args) {
		check(new Ultra());
	}
}

 

-

 

서버소켓 클래스

- 이름만 서버소켓이지 단순한 소켓이다
- 가장 중요한 기능 
0. accept요청을 대기하다가 연결을 받게 된다
1. 새로운 소켓 생성
2. 서버 소켓과 연결된 선을 끊는다 (기존 소켓을 없애는게 아니다?)
3. 새로운 클라이언트 소켓에 연결
4. 다시 accept 요청을 대기

소켓이 만들어 질 때 마다 새로운 스레드가 필요하다

 

package ch15;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class MySocketServer {
	
	ServerSocket serverSocket;
	Socket socket;
	
	public MySocketServer() {
		try {
			
			serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
			socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다

			BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			
			String msg = "";
			while ((msg = br.readLine()) != null) {
				System.out.println("sender : " + msg);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		
	}
}

 

 

package ch15;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class MySocketServer {
	
	ServerSocket serverSocket;
	Socket socket;
	BufferedReader br;
	
	public MySocketServer() {
		try {
			
			serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
			socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다

			br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			
			String msg = "";
			while ((msg = br.readLine()) != null) {
				System.out.println("sender : " + msg);
			}
			
		} catch (Exception e) { // 소켓연결이 끊기면 catch로 와지면서 while을 벗어나게 된다 
			e.printStackTrace();
		}

		try {
			br.close();
			socket.close();
			serverSocket.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		
	}
}

 

 

package ch15;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class MySocketServer {

	ServerSocket serverSocket;
	Socket socket;
	BufferedReader br;

	// throws는 함수의 모든 내용이 try catch가 필요한 경우 사용하면 된다
	public MySocketServer() throws Exception { // throws 는 함수를 호출한 자에게 던지는 것이다

		serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
		socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다

		br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

		String msg = "";
		while ((msg = br.readLine()) != null) {
			System.out.println("sender : " + msg);
		}

		br.close();
		socket.close();
		serverSocket.close();
	}

	public static void main(String[] args) {
		
		try { // main이 함수를 호출 했기 때문에 여기서 트라이캐치를 사용
			new MySocketServer();
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
}

 

 

 

 

package ch15;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class MySocketServer {

	ServerSocket serverSocket;
	Socket socket;
	BufferedReader br;

	// throws는 함수의 모든 내용이 try catch가 필요한 경우 사용하면 된다
	public MySocketServer() throws Exception { // throws 는 함수를 호출한 자에게 던지는 것이다

		serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
		socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다
		System.out.println("요청이 들어옴");
		br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

		String msg = "";
		while ((msg = br.readLine()) != null) {
			System.out.println("sender : " + msg);
		}

		br.close();
		socket.close();
		serverSocket.close();
	}

	public static void main(String[] args) {
		
		try { // main이 함수를 호출 했기 때문에 여기서 트라이캐치를 사용
			new MySocketServer();
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
}

 

 

 

 

package ch15;

import java.io.PrintWriter;
import java.net.Socket;

public class MySocketClient {
	
	Socket socket;
	
	public MySocketClient() throws Exception {
		socket = new Socket("localhost", 15000); // 서버소켓의 accept() 함수를 호출
		//"localhost" 또는 127.0.0.1 는 약속된 내용
		
		PrintWriter pw = new PrintWriter(socket.getOutputStream(), true); // autoFlush기능이 있다
		
	}
	
	public static void main(String[] args) {
		try {
			new MySocketClient();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

 

 

 

 

package ch15;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class MySocketServer {

	ServerSocket serverSocket; // 서버소켓은 연결요청을 대기하다가 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다
	Socket socket; // 서버소켓이 리턴한 소켓을 받는 역할
	BufferedReader br; // 스트림이 연결되면 BufferedReader로 데이터를 받는다

	// throws는 함수의 모든 내용이 try catch가 필요한 경우 사용하면 된다
	public MySocketServer() throws Exception { // throws 는 함수를 호출한 자(여기서는 main)에게 던지는 것이다

		serverSocket = new ServerSocket(15000); // 서버 소켓 생성 (연결을 받는)
		socket = serverSocket.accept(); // 요청을 대기 - 연결이 되면 소켓을 리턴하고 서버소켓에 연결된 선을 끊는다
		System.out.println("요청이 들어옴");
		br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

		String msg = "";
		while ((msg = br.readLine()) != null) { // br로 데이터를 받고 msg에 넣은 후 null값인지 확인한다
			System.out.println("상대방 : " + msg); // 받은 메시지를 출력한다
		}

		// 사용이 끝난 인스턴스를 닫는다
		br.close();
		socket.close();
		serverSocket.close();
	}

	public static void main(String[] args) {
		
		try { // main이 함수를 호출 했기 때문에 여기서 트라이캐치를 사용
			new MySocketServer(); // 소켓서버 가동 메서드 실행;
		} catch (Exception e) {}
	}
}

 

 

package ch15;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class MySocketClient {
	
	Socket socket; // 소켓 생성
	BufferedReader br; // 키보드로 내가 입력한 메시지를 받기위한 br
	BufferedWriter bw; // 내가 입력한 메시지를 소켓으로 보내기 위한 bw 
	
	public MySocketClient() throws Exception {
		
		//스트림
		//"localhost" 또는 127.0.0.1 는 약속된 내용 - 내 컴퓨터의 내부 주소
		socket = new Socket("192.168.0.115", 15000); // 서버소켓의 accept() 함수를 호출
		
		// 소켓 - 버퍼드라이터 연결
		bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
		
		// 키보드 - 버퍼드리더 연결
		br = new BufferedReader(new InputStreamReader(System.in));
		
		String msg = "";
		
		// 키보드로 입력한 메시지를 확인하여 null이 아니면 bw에 적고 flush
		while ((msg = br.readLine()) != null) {
			bw.write(msg + "\n"); // "\n"은 상대방 소켓에서 읽어들이기 위해서 필요한 것이라 넣은 것
			System.out.println("내 메시지 : " + msg);
			bw.flush(); // 버퍼는 꽉차지 않으면 플러시 되지 않기 때문에 수동으로 플러시 시켜준다
		}
		
		// 인스턴스 닫기
		bw.close();
		br.close();
		socket.close();
		
	}
	
	public static void main(String[] args) {
		try {
			new MySocketClient(); // 클라이언트 메서드 실행
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

 

 

ArrayList - 동시접근해서 데이터가 꼬일 수 있다

Vector - 동시접속자를 큐에 저장하고 임계구역으로 만들어 여러사람이 동시에 들어오면 순서대로 처리한다 

-----------------------------

모스키토 통신

mqtt

유튜브 퍼블리셔를 구독자가 구독하면

퍼블리셔와 구독자가 통신을 하는데

퍼블리셔는 업로드만 하면 구독자에게 메시지가 가게 된다

구독+업로드 만으로 통신이 연결되는 방식

 

유튜브에서 유래된 방식

 

우리나라 표준 통신으로 바뀔 예정 (국제적으로도 유행)

-----------------------------

브로드 캐스트 통신

와이파이와 같이 모든 곳에 뿌리고 받는사람이 선택해서 받는 방식

------------------------------

블루투스 통신

기본적으로 1:1방식 

메시 네트워크라는 방식으로 브로드 캐스트 통신처럼 사용가능
- 페어링을 위한 브로드캐스트인데 그것에 메시지를 담는 것 (페어링 없이 다대다 통신)

-----------------------------

소켓통신

프로토콜이 없다.(약속이 없다)

*만약 소켓통신에 약속을 달면 (지그비, HTTP) 등의 통신을 할 수 있다

 

Socket -> OS가 들고 있다

OS가 들고 있는 것을 빌려 쓰는 것을 시스템콜이라고 한다

클라이언트와 서버는 포트를 가지고 있다 - 이 포트를 소켓이라고 한다 - 0~65536

(클라이언트, 서버) 서로 포트번호가 같을 필요는 없다

스트림을 연결하고 버퍼드리더, 버퍼드라이터만 이용하면 통신가능하다

 

멀티프로세싱 - 프로세스 여러개가 동시에 작동해서 작업을 빨리 수행 하는 것
(1개의 프로세스가 3가지 작업을 15초에 할 수 있는데 3개의 프로세스로 나누어 작업하여 5초만에 할 수 있다)

멀티프로세싱 할 경우 cpu가 여러개 있으면 좋다 (병렬처리 가능)

프로그램이 멀티코어를 지원 할 경우에만 멀티프로세싱을 사용 할 수 있다

--------------------------------------

쓰레드

일을 실행하는 단위

일종의 스택

멀티스레드 - 라운드로빈 - 타임슬라이싱 -  일을 시간을 쪼개서 돌아가면서 함

스레드(thread)는 어떠한 프로그램 내에서, 특히 프로세스 내에서 실행되는 흐름의 단위를 말한다. 일반적으로 한 프로그램은 하나의 스레드를 가지고 있지만, 프로그램 환경에 따라 둘 이상의 스레드를 동시에 실행할 수 있다. 이러한 실행 방식을 멀티스레드(multithread)라고 한다.

https://ko.wikipedia.org/wiki/%EC%8A%A4%EB%A0%88%EB%93%9C_(%EC%BB%B4%ED%93%A8%ED%8C%85)

 

스레드 (컴퓨팅) - 위키백과, 우리 모두의 백과사전

위키백과, 우리 모두의 백과사전. 두 개의 스레드를 실행하고 있는 하나의 프로세스. 스레드(thread)는 어떠한 프로그램 내에서, 특히 프로세스 내에서 실행되는 흐름의 단위를 말한다. 일반적으로 한 프로그램은 하나의 스레드를 가지고 있지만, 프로그램 환경에 따라 둘 이상의 스레드를 동시에 실행할 수 있다. 이러한 실행 방식을 멀티스레드(multithread)라고 한다. 프로세스와 스레드의 비교[편집] 멀티프로세스와 멀티스레드는 양쪽 모두 여러 흐름이 동

ko.wikipedia.org

 

문맥교환(컨텍스트 스위칭 context swiching)

여러가지 일을 시간을 쪼개서 돌아가면서 계속 하는 것

 

장점

1. 사람의 눈에 동시에 일을 하는 것 처럼 보임
2. 서버에서 그림 등의 데이터를 받는 등의 대기시간에 cpu가 다른 일을 할 수 있다

 

단점

1. 순서와 위치를 기억해야하기 때문에 느려짐 (컨텍스트 스위칭)

 

자바에는 기본적으로 main스택이라는 스레드를 가지고 있다

main스레드 이외의 스레드를 Target

Runnable 타입의 클래스 안에 run()메서드가 있고 그 스레드는 Target이 될 수 있다

 

스레드는 OS가 들고 있다 (윈도우 등)

OS에 스레드를 더 실행해달라고 요청해야 한다. (Runnable타입으로)

OS는 램에서 Runnable 타입의 힙을 찾고 run() 메서드를 실행한다 - 콜백

--------------------------------------

OS가 들고 있는 기능을 사용하는 것을 시스템 콜이라고 한다

--------------------------------------

IPC

데이터 통신을 할려면 시리얼라이즈를 해야한다 - 데이터 직렬화 - 직렬화는 마샬링의 일부

마샬링 - 프로세스간 데이터 통신할 때 데이터를 다른 프로세스가 읽을 수 있게 직렬화 하는 것
(클래스를 다른 곳으로 전송하면 String타입으로 전송되는데 그것을 다시 클래스로 만드는 등)

------------------------------------

콜백

스레드가 메인 스레드에 이벤트를 전송

다른스레드가 종료 된것을 메인 스레드에 보냄

-----------------------------------

데이터베이스에서 동기화

데이터가 일치

------------------------------------

프로세스에서 동기화

동기적 - 일의 순서가 일치해서 순서대로 실행됨

비동기적 - 일의 순서가 나뉘어서 여러개 실행됨

비동기 처리 - promise

비동기에서는 나중시간에 약속된 기능이 있다면

그 시간과 겹치는 앞쪽에 기능이 새로 추가 된다면 앞쪽기능이 실행되다가

약속된 기능이 실행된 뒤 나머지 앞쪽 기능이 실행된다

-------------------------------------

자바에서는 매개변수에 함수를 못넘기기 때문에
클래스를 만들어서 오브젝트를 매개변수로 넘겨서 그 안에 생성했던 함수를 이용한다
-> 익명클래스의 사용 이유

----------------------------------

익명클래스

 

 

 

 

 

 

익명클래스로 스레드 추가도 가능

 

 

 

 

 

 

 

야매

 

해결

 

 

 

클래스는 여러 자료를 담을 수 있는 자료형이다.

 

명함이라는 클래스 자료형

 

명함이라는 클래스로 만든 인스턴스

 

기본자료형과 클래스자료형의 차이

기본자료형(예를들어 int 등)은 int a = 1; 이라고 만들면 a 에 1이라는 숫자가 들어간다.

하지만 클래스자료형은 명함 m1 = new 명함(); 이라고 만들면
m1에 데이터가 아닌 그 데이터를 가리키는 주소가 들어간다.

위에서 생성한 m1명함 m2 = m1; 이런식으로 m2에 넣는다고 하더라도
데이터가 들어가는 것이 아닌 주소가 들어가게 된다.

즉 아래와 같이
기본자료형반환() 이라는 함수를 호출하여 반환된 값을 출력해보면 값이 나오지만,
클래스자료형반환() 이라는 함수를 호출하여 반환된 값을 출력해보면 해당 데이터의 주소가 나온다.
(컴퓨터에 따라 주소가 아니라 인스턴스의 내용이 대괄호 안에 나올 수 있다.)

 

 

package ch13;

class A {
	int a = 10;
}

public class Test {
	
	static void sample(A a) {
		System.out.println(a.a);
	}
	
	
	public static void main(String[] args) {
		
	// 기본자료형은 데이터 자체를 저장한다
	int a1 = 10;
	int a2 = a1;
	
	a1 = a1 + 10;
	System.out.println(a1);
	System.out.println(a2);
	
	
	// 클래스자료형은 인스턴스의 주소값을 저장한다
	A test = new A();
	A test1 = test;
	
	test.a = test.a + 10;
	System.out.println(test.a);
	System.out.println(test1.a);
	
	
	// 서로 다른 인스턴스 이기 때문에 데이터가 따로 계산된다
	A test2 = new A();
	A test3 = new A();
	
	test2.a = test2.a + 10;
	System.out.println(test2.a);
	System.out.println(test3.a);
	}
}

 

순서

공공데이터 링크확인
http://json.parser.online.fr/ 으로 JSON구조확인하기
http://www.jsonschema2pojo.org/ 으로 Class파일 쉽게 만들기
Gson으로 Json -> 자바객체 전환하기
이용하기

 

먼저 공공데이터 링크를 확인한다

 

http://json.parser.online.fr/ 으로 JSON구조확인하기

위 사이트는 json을 보기쉽게 해준다 (자바에서 이용할때 참조)

 

http://www.jsonschema2pojo.org/ 으로 Class파일 쉽게 만들기

위 사이트에 json을 붙여넣고 아래와 같이 설정을한뒤
preview를 한다

 

package mask;

import java.util.List;

public class MaskInfo {

	private long count;
	private String page;
	private List<StoreInfo> storeInfos = null;
	private long totalCount;
	private long totalPages;

	public long getCount() {
		return count;
	}

	public void setCount(long count) {
		this.count = count;
	}

	public String getPage() {
		return page;
	}

	public void setPage(String page) {
		this.page = page;
	}

	public List<StoreInfo> getStoreInfos() {
		return storeInfos;
	}

	public void setStoreInfos(List<StoreInfo> storeInfos) {
		this.storeInfos = storeInfos;
	}

	public long getTotalCount() {
		return totalCount;
	}

	public void setTotalCount(long totalCount) {
		this.totalCount = totalCount;
	}

	public long getTotalPages() {
		return totalPages;
	}

	public void setTotalPages(long totalPages) {
		this.totalPages = totalPages;
	}

}
package mask;

public class StoreInfo {

	private String addr;
	private long code;
	private double lat;
	private double lng;
	private String name;
	private String type;

	public String getAddr() {
		return addr;
	}

	public void setAddr(String addr) {
		this.addr = addr;
	}

	public long getCode() {
		return code;
	}

	public void setCode(long code) {
		this.code = code;
	}

	public double getLat() {
		return lat;
	}

	public void setLat(double lat) {
		this.lat = lat;
	}

	public double getLng() {
		return lng;
	}

	public void setLng(double lng) {
		this.lng = lng;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

}

 

Gson으로 Json -> 자바객체 전환하기

 

이용하기

package mask;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

import com.google.gson.Gson;

public class MaskApp {

	public static long maskPage() {
		try {
			// 1번 주소 객체 만들기
			URL url = new URL("https://8oi9s0nnth.apigw.ntruss.com/corona19-masks/v1/stores/json?page=1");

			// 2번 스트림 연결
			HttpURLConnection con = (HttpURLConnection) url.openConnection();

			// 3번 버퍼 연결 (문자열)
			BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream(), "UTF-8"));

			// 4. 문자 더하기
			StringBuilder sb = new StringBuilder();

			String input = "";
			while ((input = br.readLine()) != null) {
				sb.append(input);
			}

			System.out.println(sb.toString());
			System.out.println();

			br.close(); // 버퍼 닫기
			con.disconnect(); // 스트림 닫기

			// 5. 자바 오브젝트로 변환
			Gson gson = new Gson();
			MaskInfo mask = gson.fromJson(sb.toString(), MaskInfo.class);
			long count = mask.getTotalPages();

			return count;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return 0;
	}

	public static MaskInfo maskInfo(int page) {
		try {
			// 1번 주소 객체 만들기
			URL url = new URL("https://8oi9s0nnth.apigw.ntruss.com/corona19-masks/v1/stores/json?page=" + page);

			// 2번 스트림 연결
			HttpURLConnection con = (HttpURLConnection) url.openConnection();

			// 3번 버퍼 연결 (문자열)
			BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream(), "UTF-8"));

			// 4. 문자 더하기
			StringBuilder sb = new StringBuilder();

			String input = "";
			while ((input = br.readLine()) != null) {
				sb.append(input);
			}

			System.out.println(sb.toString());
			System.out.println();

			br.close(); // 버퍼 닫기
			con.disconnect(); // 스트림 닫기

			// 5. 자바 오브젝트로 변환
			Gson gson = new Gson();
			MaskInfo mask = gson.fromJson(sb.toString(), MaskInfo.class);

			return mask;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public static void main(String[] args) {
		System.out.println("지역을 입력하세요");
		Scanner sc = new Scanner(System.in);
		String loc = sc.nextLine();

		List<StoreInfo> test = maskInfo(1).getStoreInfos();

		maskInfo(1).getStoreInfos().get(0).getAddr();

		ArrayList<MaskInfo> maskInfoList = new ArrayList<>();

		for (int i = 1; i < 1 + 1; i++) { // maskPage() 넣어야함
			MaskInfo mask = maskInfo(i);
			maskInfoList.add(mask);
		}

		for (MaskInfo maskInfo : maskInfoList) {
			for (int i = 0; i < maskInfo.getStoreInfos().size(); i++) {
				if (maskInfo.getStoreInfos().get(i).getAddr().contains(loc)) {
					System.out.println(maskInfo.getStoreInfos().get(i).getAddr());
					System.out.println(maskInfo.getStoreInfos().get(i).getName());
					System.out.println();
				}
			}
		}
	}
}

 

패키지명 : 패키지 이름을 적는다

클래스이름 : 클래스이름을 마음대로 적는다

나머지 사항도 원하는 것만 체크한다

+ Recent posts