신입사원 무지는 게시판 불량 이용자를 신고하고 처리 결과를 메일로 발송하는 시스템을 개발하려 합니다. 무지가 개발하려는 시스템은 다음과 같습니다.
각 유저는 한 번에 한 명의 유저를 신고할 수 있습니다.
신고 횟수에 제한은 없습니다. 서로 다른 유저를 계속해서 신고할 수 있습니다.
한 유저를 여러 번 신고할 수도 있지만, 동일한 유저에 대한 신고 횟수는 1회로 처리됩니다.
k번 이상 신고된 유저는 게시판 이용이 정지되며, 해당 유저를 신고한 모든 유저에게 정지 사실을 메일로 발송합니다.
유저가 신고한 모든 내용을 취합하여 마지막에 한꺼번에 게시판 이용 정지를 시키면서 정지 메일을 발송합니다.
다음은 전체 유저 목록이 ["muzi", "frodo", "apeach", "neo"]이고, k = 2(즉, 2번 이상 신고당하면 이용 정지)인 경우의 예시입니다.
유저 ID유저가 신고한 ID설명
"muzi"
"frodo"
"muzi"가 "frodo"를 신고했습니다.
"apeach"
"frodo"
"apeach"가 "frodo"를 신고했습니다.
"frodo"
"neo"
"frodo"가 "neo"를 신고했습니다.
"muzi"
"neo"
"muzi"가 "neo"를 신고했습니다.
"apeach"
"muzi"
"apeach"가 "muzi"를 신고했습니다.
각 유저별로 신고당한 횟수는 다음과 같습니다.
유저 ID신고당한 횟수
"muzi"
1
"frodo"
2
"apeach"
0
"neo"
2
위 예시에서는 2번 이상 신고당한 "frodo"와 "neo"의 게시판 이용이 정지됩니다. 이때, 각 유저별로 신고한 아이디와 정지된 아이디를 정리하면 다음과 같습니다.
유저 ID유저가 신고한 ID정지된 ID
"muzi"
["frodo", "neo"]
["frodo", "neo"]
"frodo"
["neo"]
["neo"]
"apeach"
["muzi", "frodo"]
["frodo"]
"neo"
없음
없음
따라서 "muzi"는 처리 결과 메일을 2회, "frodo"와 "apeach"는 각각 처리 결과 메일을 1회 받게 됩니다.
이용자의 ID가 담긴 문자열 배열id_list, 각 이용자가 신고한 이용자의 ID 정보가 담긴 문자열 배열report, 정지 기준이 되는 신고 횟수k가 매개변수로 주어질 때, 각 유저별로 처리 결과 메일을 받은 횟수를 배열에 담아 return 하도록 solution 함수를 완성해주세요.
제한사항
2 ≤id_list의 길이 ≤ 1,000
1 ≤id_list의 원소 길이 ≤ 10
id_list의 원소는 이용자의 id를 나타내는 문자열이며 알파벳 소문자로만 이루어져 있습니다.
id_list에는 같은 아이디가 중복해서 들어있지 않습니다.
1 ≤report의 길이 ≤ 200,000
3 ≤report의 원소 길이 ≤ 21
report의 원소는 "이용자id 신고한id"형태의 문자열입니다.
예를 들어 "muzi frodo"의 경우 "muzi"가 "frodo"를 신고했다는 의미입니다.
id는 알파벳 소문자로만 이루어져 있습니다.
이용자id와 신고한id는 공백(스페이스)하나로 구분되어 있습니다.
자기 자신을 신고하는 경우는 없습니다.
1 ≤k≤ 200,k는 자연수입니다.
return 하는 배열은id_list에 담긴 id 순서대로 각 유저가 받은 결과 메일 수를 담으면 됩니다.
[ 오답 풀이 ]
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class 신고결과받기 {
/*
- 문제 : 불량 이용자 신고 후 처리 결과를 메일로 발송하는 시스템 개발
- 시스템 :
1) 각 유저는 한 번에 한명의 유저 신고 가능
+ 신고 횟수 제한 없음
+ 서로 다른 유저 계속 신고 가능
+ 한 유저를 여러본 신고할 수 있지만, 동일한 유저에 대한 신고 횟수는 1회로 처리됨
2) k번 이상 신고된 유저는 게시판 이용 금지되며,
그 유저에 대해 모든 유저에게 정지 사실 메일로 발송됨
+ 유저가 신고한 모든 내용을 취합해서 마지막에 한꺼번에 게시판 이용 정지를 시키면서 정지 메일을 발송
- 입력 값 :
id_list : 유저 목록
report : 신고 한 사람과 신고 당한 사람
k : 정지되는 횟수
- 신고 메일 양식 :
"muzi"가 "frodo"를 신고했습니다.
- 유저 목록 :
"muzi", "frodo", "apeach", "neo"
- 결과 :
각 유저별 메일을 받은 횟수를 배열에 담은 것을 리턴
// report 에 (띄어쓰기) 를 기준으로 split 해서 배열에 담음
// 0번부터 짝수는 신고인, 홀수는 신고 당한사람
// 신고인과 신고 당한사람 비교 문법 필요
// k번 이상된 사람 있으면 cnt 의 해당하는 인덱스에 카운터가 증가됨
*/
public static void main(String[] args) {
String[] id_list = {"muzi", "frodo", "apeach", "neo"};
String[] report = {"muzi frodo","apeach frodo","frodo neo","muzi neo","apeach muzi"};
String[] report2 = {"ryan con", "ryan con", "ryan con", "ryan con"};
int k = 2;
int[] solution = solution(id_list, report2, k);
for (int i = 0; i < solution.length; i++) {
System.out.println(solution[i] + " ");
}
}
public static int[] solution(String[] id_list, String[] report, int k) {
int[] answer = new int[id_list.length];
HashMap<String, String> map = new HashMap<>();
String[][] SplitString = new String[report.length][2];
int[] cnt = new int[id_list.length];
for (int i = 0; i < cnt.length; i++) {
cnt[i] = 0;
}
for (int i = 0; i < report.length; i++) {
SplitString[i] = report[i].split(" ");
}
for (int i = 0; i < SplitString.length; i++) {
for (int w = 0; w < id_list.length; w++) {
// > 신고한사람, 당한사람이 한번이라도 있으면 map 에 담기기 때문에 map 을 다시 조회해서 해당하는 인원이 나오면 신고 카운트가 증가되지 않음
Iterator<Map.Entry<String, String>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<String, String> entry = entries.next();
if (entry.getKey().equals(SplitString[i][0]) && entry.getValue().equals(SplitString[i][1])) {
System.out.println(entry.getKey() + " " + entry.getValue());
continue;
}
if(entry.getKey().equals(SplitString[i][0])){
answer[w] = answer[w] + 1;
}
}
// <
if(SplitString[i][1].equals(id_list[w])){
map.put(SplitString[i][0],SplitString[i][1]);
cnt[w] = cnt[w]+1;
}
}
}
return cnt;
}
}
해결 방식의 문제점
문제를 잘못 이해한게 가장 큰 실수였습니다.
id_list 별 신고 당한 횟수로 이해를 하고 다음과 같이 코드를 작성하였습니다.
저렇게 작성하게 될 경우, 신고한 사람의 기준에서 카운트를 세는 과정을 구할 수가 없습니다.
그래서 저 방식을 그대로 유지한 채 코드를 수정해보려 했지만 해결 방법을 찾지 못했습니다.
다른 사람들의 코드를 보니 HashSet 을 이용하는 것으로 보입니다.
그래서 다시 풀이를 작성해보겠습니다.
public static int[] solution(String[] id_list, String[] report, int k){
int[] answer = new int[id_list.length];
/*
HashMap<String,HashSet<String>> DeclaratedMap
-> 중복 체크
HashMap<String,Integer> DeclarateMap
-> 키값 : 신고당한사람, value값 : 카운트 횟수
HashSet<String> repSet
-> report 를 리스트로 변환한 후 hashSet 의 요소로 넣어줌
*/
HashMap<String, HashSet<String>> DeclaratedMap = new HashMap<>();
HashMap<String, Integer> DeclarateCountMap = new HashMap<>();
HashSet<String> DeclarateSet = new HashSet<>(Arrays.asList(report));
for (String DeclareInfo : DeclarateSet) {
String Declarater = DeclareInfo.split(" ")[0];
String Declarated = DeclareInfo.split(" ")[1];
// HashSet 에 신고 당한 대상을 담아준다.
HashSet<String> temp = new HashSet<>();
temp.add(Declarated);
// 만약 신고 당한 대상의 map에 신고 한 사람 이름의 키 값이 존재 하지 않으면 추가해준다.
DeclaratedMap.putIfAbsent(Declarater, temp);
// 신고 당한 대상의 map 에 신고한 사람의 키에 대한 HashSet에 신고당한 대상의 이름을 넣어준다.
DeclaratedMap.get(Declarater).add(Declarated);
DeclarateCountMap.put(Declarated, DeclarateCountMap.getOrDefault(Declarated, 0) + 1);
}
//
for (String Declared : DeclarateCountMap.keySet()) {
int DeclaredCount = DeclarateCountMap.get(Declared);
if (DeclaredCount >= k) {
for (int i = 0; i < id_list.length; i++) {
if (DeclaratedMap.containsKey(id_list[i]) && DeclaratedMap.get(id_list[i]).contains(Declared)) {
answer[i]++;
}
}
}
}
return answer;
}
collect(Collectors.변환될 타입) : 스트림으로 반환하는 요소를 해당 컬렉션으로 바꿔서 리턴해줍니다.
sorted(Comparator.reverseOrder()) : 스트림 내에 요소를 내림차순으로 정렬
sorted(Comparator.comparingInt(String::length)) : 스트림 내에 요소를 문자열 길이 기준으로 정렬
결과 만들기
가공한 스트림을 가지고 내가 사용할 결과 값을 만들어내는 단계입니다. 따라서 최종 작업입니다.
long count = IntStream.of(1,2,3,4,5).count();
long count = IntStream.of(1,2,3,4,5).sum();
long count = IntStream.of(1,2,3,4,5).min();
long count = IntStream.of(1,2,3,4,5).max();
최소, 최대, 합, 평균 등 기본형 타입으로 결과를 만들어 낼 수 있습니다.
* 이때, [ 평균/최소/최대 ] 의 경우에는 스트림이 비어있는 경우를 표현할 수 없기때문에 Optional 을 이용해 리턴합니다.
이 외에,
Reduction, Collecting, Matching, foreach
에 대한 개념이 있지만 현재 쓸 일이 없어서 기억을 못할 것 같으므로 다음에 사용할 일 있을 때
다시 따로 블로깅 하도록 하겠습니다.
조건검사
findAny, findFirst()
filter() 연산과 함께 사용됩니다. 조건식에 맞는 요소가 있는지 확인할 때 사용됩니다.
반환 타입이 Optional<T> 이며, 스트림의 요소가 없을 때는 비어 있는 Optional 객체를 반환합니다.
allMatch() : 조건식에 모든 요소가 일치하면 true
anyMath() : 어떤 요소 하나라도 조건에 일치하면 true
noneMatch() : 조건식에 모든 요소들이 일치하지많으면 true
[ 소스코드 예제 ]
현재 제가 진행중인 프로젝트에서 사용된 스트림에 대해서 알아보겠습니다.
private static Map<Long, Member> store = new HashMap<>();
public Optional<Member> findByname(String name) {
return store.values().stream()
.filter(member -> member.getName().equals(name))
.findAny();
}
1. store.values () 의 반환 타입
: Collection<Member>
즉, values 는 값을 컬렉션 타입으로 반환 해줍니다.
2. .stream()
: 컬렉션으로 반환된 values 를 stream 으로 만들어줍니다.
3. .filter( member -> member.getName().equals(name))
: store 내부의 member 인자에서 getName() 을 통해서 name 값을 받아옵니다.
받아온 name 과 findByname 의 인자로 주어진 name 을 비교해줍니다.
4. .findAny()
: filter 한 조건식에 맞는 요소가 있으면 해당 요소를 모두 반환해줍니다. ( 첫번째 하나만 하려면 findFirst )
만약 findAny() 를 붙치지 않는다면 Stream() 을 그대로 반환하는 모습을 볼 수 있습니다.
네오와 프로도가 숫자놀이를 하고 있습니다. 네오가 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면 프로도는 원래 숫자를 찾는 게임입니다.
다음은 숫자의 일부 자릿수를 영단어로 바꾸는 예시입니다.
1478 → "one4seveneight"
234567 → "23four5six7"
10203 → "1zerotwozero3"
이렇게 숫자의 일부 자릿수가 영단어로 바뀌어졌거나, 혹은 바뀌지 않고 그대로인 문자열s가 매개변수로 주어집니다.s가 의미하는 원래 숫자를 return 하도록 solution 함수를 완성해주세요.
참고로 각 숫자에 대응되는 영단어는 다음 표와 같습니다.
숫자영단어
0
zero
1
one
2
two
3
three
4
four
5
five
6
six
7
seven
8
eight
9
nine
제한사항
1 ≤s의 길이 ≤ 50
s가 "zero" 또는 "0"으로 시작하는 경우는 주어지지 않습니다.
return 값이 1 이상 2,000,000,000 이하의 정수가 되는 올바른 입력만s로 주어집니다.
[ 나의 풀이 ]
import java.util.HashMap;
import java.util.Map;
public class NumberAndWord {
public static void main(String[] args) {
/*
- 숫자놀이
: 네오 -> 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면
프로도는 원래 숫자를 찾는 게임
//when
네오가 프로도에게 일부 자릿수를 영단어로 바꾼 카드를 건네줌
//then
프로도는 원래 숫자를 찾음
// how
1. hashMap 에 0 ~ 9 까지 저장
2. 입력받은 문자열을 char 형으로 변환
3. 변환된 char 형이 문자일 경우 하나씩 합치면서 hash value 값과 동일한지 비교
( 숫자일 경우 결과 값에 바로 합쳐줌 )
4. 비교 후 같으면 해당 값을 hashMap 가 비교해서 같은 값을 가지는 key 값을
결과 값에 합쳐줌
*/
int res = solution("one4seveneight");
System.out.println(res);
}
public static int solution(String s){
int answer = 0;
String temp = "";
HashMap<Integer, String> hashMap = new HashMap<>();
hashMap.put(0, "zero");
hashMap.put(1, "one");
hashMap.put(2, "two");
hashMap.put(3, "three");
hashMap.put(4, "four");
hashMap.put(5, "five");
hashMap.put(6, "six");
hashMap.put(7, "seven");
hashMap.put(8, "eight");
hashMap.put(9, "nine");
//when
char[] ch = s.toCharArray();
for (int i = 0; i < ch.length; i++) {
int k = Character.getNumericValue(ch[i]);
if(0 <= k && k <= 9){
if(answer == 0){
answer += k;
}
else{
answer = (answer * 10) + k;
}
}
else {
temp += ch[i];
for (Map.Entry<Integer, String> entry : hashMap.entrySet()) {
if (entry.getValue().equals(temp)) {
if (answer == 0) {
answer += entry.getKey();
} else {
answer = (answer * 10) + entry.getKey();
}
temp = "";
}
}
}
}
return answer;
}
}
다른 사람의 코드를 보니 너무 깔끔하고 짧게 구현해놔서 제 코드를 다시 보니 부끄럽네요..
import java.util.*;
class Solution {
public int solution(String s) {
int answer = 0;
StringBuilder sb = new StringBuilder("");
int len = s.length();
String[] digits = {"0","1","2","3","4","5","6","7","8","9"};
String[] alphabets = {"zero","one","two","three","four","five","six","seven","eight","nine"};
for(int i=0; i<10; i++){
s = s.replaceAll(alphabets[i],digits[i]);
}
return Integer.parseInt(s);
}
}
모르겠는 메소드와 타입이 있어서 분석 먼저 해보겠습니다.
StringBuilder
변경 가능한 문자열을 만들어줍니다.
아래와 같이 String 형을 그냥 더하게 된다면 메모리 할당과 해제를 시키는 면에서 비효율적인 코드가 완성됩니다.
String a = "aa";
String b = "bb";
String c = a+b;
자바에서 String 형은 변경이 불가능합니다.
[ 문자열이 더해지는 과정 ]
1) 하나의 문자열을 다른 문자열과 연결하면 새 문자열이 생성
2) 이전 문자열은 가비지 컬렉터로 들어갑니다.
만약, 이러한 행위를 100만번을 하게 된다면 많은 메모리를 잡아 먹게 됩니다.
이 경우 사용하는게 StringBuilder 입니다.
[ 사용 방법 ]
1) StringBuilder 객체 생성
2) append 로 더해줌
3) toString() 으로 할당
StringBuilder sb = new StringBuilder();
sb.append("aa").append("bb");
String c = sb.toString();
em.persist(), tx.commit(), em.close() 와 같은 트랜잭션 작업
이렇게 AOP 없이 구현하게 되면 애플리케이션 전반적으로 트랜잭션과 관련된 중복된 코드가 수도 없이 나오게 됩니다.
스프링에서는 @Transactional 이라는 어노테이션을 통해서 AOP 기능을 적용할 수 있습니다.
@Component
@Transactional // (1)
public class Example2_12 {
private Connection connection;
public void registerMember(Member member, Point point) throws SQLException {
saveMember(member);
savePoint(point);
}
private void saveMember(Member member) throws SQLException {
// Spring JDBC를 이용한 회원 정보 저장
}
private void savePoint(Point point) throws SQLException {
// Spring JDBC를 이용한 포인트 정보 저장
}
}
@Transactional
해당 클래스에 트랜잭션 기능이 적용된 프록시 객체가 생성됩니다.
프록시 객체는 @Transactional 이 포함된 메소드가 호출될 경우, 트랜잭션을 시작하고 정상 여부에 따라 커밋 또는 롤백됩니다.
* 단, 테스트 코드에서의 @Transactional 은 다른 기능을 하므로 주의해야합니다.
Java Console Application 의 경우 main() 과 같은 엔트리 포인트가 종료되면 애플리케이션의 실행이 종료됩니다.
하지만 웹에서 동작하는 웹 애플리케이션의 경우 클라이언트가 외부에서 접속해서 사용하는 서비스이기 때문에
main() 메서드가 종료되면 안됩니다.
그런데 서블릿 컨테이너에는 서블릿 클래스만 존재하지 main() 메서드가 존재하지 않습니다.
서블릿 컨테이너의 동작원리
1. 서블릿 컨테이너는 클라이언트의 요청이 들어옴
2. 그때마다 서블릿 컨테이너 내의 컨테이너 로직 ( service() 메서드 ) 이 서블릿을 직접 실행
이러한 과정을 거치므로 main () 메서드가 필요 없습니다.
이 경우 서블릿 컨테이너가 서블릿을 제어하고 있기 때문에 애플리케이션 주도권은 서블릿 컨테이너에 있습니다.
그래서 이를 서블릿와 웹 애플리케이션 간에 IoC (제어의 역전) 가 적용되어 있다고 할 수 있습니다.
그렇다면 Spring 에는 IoC 개념이 어떻게 적용되어 있을까요??
DI 의존성 주입
IoC 는 서버 컨테이너 기술, 디자인 패턴, 객체 지향 설계 등에 적용하게 되는 일반적인 개념에 반해
DI ( Dependency Injection ) 는 IoC 개념을 조금 구체화 시킨것이라고 볼 수 있습니다.
의존성
객체 지향 프로그래밍에서 의존성이라고 하면 대부분 객체간의 의존성을 의미합니다.
예를 들어서,
A,B 두 개의 클래스 파일이 존재합니다. A 클래스에서 B 클래스의 메서드 기능을 사용할 것입니다. 이렇게 A 클래스가 B 클래스의 기능을 사용 할 때, "A 클래스는 B 클래스에 의존한다" 라고 합니다.
[ 의존 관계 ]
public class MemberController{
public void static main(String[] args){
MenuService ms = new MenuSerivce();
List<Menu> menuList = ms.getMenuList(); // 의존 관계 성립
}
}
public class MenuService{
public List<Menu> getMenuList(){
return null
}
}
위와 같이 의존 관계가 성립됩니다.
위의 과정에서는 아직 의존성 주입이 일어나지 않았습니다.
[ 의존성 주입 ]
public class Client{
public static void main(String[] args){
MemberService ms = new MemberService();
MemberConroller mc = new MemberConroller(ms);
List<Menu> menuList = mc.getMenu();
}
}
public class MemberConroller{
private MemberService memberService;
public MemberConroller(MemberService memberService){
this.memberService = memberService;
}
public List<Menu> getMenu(){
return memberService.getMenuList();
}
}
public class MenuService{
public List<Menu> getMenuList(){
return null;
}
}
MemberService 기능을 사용하기 위해 MemberController 생성자의 객체를 전달받고 있습니다.
이처럼 생성자를 통해서 어떤 클래스의 객체를 전달 받는 것을 의존성 주입이라고 합니다.
생성자의 피라미터로 객체를 전달하는 것을 "외부에서 객체를 주입한다" 라고 표현을 합니다.
그렇다면 여기서 의미하는 외부는 무엇일까요??
[ Client 객체 ] 에서 [ MemberController 의 생성자 피라미터 ] 로 menuService 를 전달하고 있습니다.
이렇게 객체를 MemberController 외부에서 전달하고 있기 때문에 Client 가 외부가 됩니다.
의존성 주입의 실무예제
위는 실무에서의 대화 장면입니다.
- Stub : 메서드가 호출되면 미리 준비된 데이터를 응답하는 과정으로, 고정된 데이터이므로 동일한 데이터를 리턴합니다.
해야할 것
- 메뉴 데이터 조회 API 를 위해 MenuServiceStub 클래스를 추가로 작성해서 코드를 구성
- MenuService -> MenuServiceStub 으로 클래스명 변경
- Client , MenuController 는 MenuService 에 의존하기 때문에 클래스명을 변경해야됨
이렇게 업무의 변경사항이 생겼다고 수정된 클래스를 사용하는 수많은 클래스들을 바꿔야 한다면 상당히 비효율적입니다.
그래서 강한 결합이 아닌 느슨한 결합이 필요합니다.
느슨한 결합으로 만들기 위한 대표적인 방법이 [ 인터페이스 사용 ] 입니다.
즉, 클래스를 직접적으로 의존하는게 아니라 인터페이스에 의존하도록 해주는 것입니다.
MenuConroller 가 MenuService 를 의존하지만,
MenuService 의 구현체가 MenuServiceImp, MenuServiceStub 둘 중에 뭔지는 알 필요가 없는 것입니다.
그저 메뉴 목록 데이터를 조회만 할 수 있으면 되는 것입니다.
[ 느슨한 결합 ]
public interface MenuService {
List<Menu> getList();
}
public class MenuServiceImp implements MenuService {
@Override
List<Menu> getList(){
return List.Of (
new Menu(1,"Americano",2400),
new Menu(2,"Latte",3000)
);
}
}
public class MenuController(){
private MenuService ms;
public MenuController(MenuService ms){
this.ms = ms;
}
public List<Menu> getMenu(){
return ms.getList();
}
}
public class client{
public static void main(String[] args){
MenuService ms = new MenuServiceImp(); // 업캐스팅
MenuController mc = new MenuController(ms);
List<Menu> menu = mc.getMenu();
}
}
- 업캐스팅 : [ client 객체 ] 의 ( 인터페이스 타입 변수 = new 인터페이스 구현체 ) 와 같은 할당 방법
하지만 위와 같은 방법에도 문제가 있습니다.
Service 구현체에서 new 키워드로 직접 객체를 생성해주고 있습니다.
이는 스프링을 통해서 해결이 가능합니다.
public inteface MemberService{
void save();
List<Menu> getList();
}
public class MemberServiceImp implements MemberService{
ArrayList<Menu> list = new ArrayList<>();
@Override
void save(Menu menu){
list.add(menu);
}
@Override
List<Menu> getList(){
return list;
}
}
public class client{
ApplicationContext ac = new AnnotationApplicationContext(SpringConfig.class);
MenuController mc = ac.getBean(MenuController.class);
List<Menu> list = mc.getMenu();
}
public class MemberController(){
public MemberService ms;
@Autowired
public MemberController(MemberService ms){
this.ms = ms;
}
List<Menu> getMenu(){
return ms.getList();
}
}
@Configuration
@ComponentScan(basePackageClasses = Client.class)
public class SpringConfig(){
@Bean
public MemberService getMemberService(){
return new MemberServiceImp();
}
@Bean
public MemberController getMemberController(){
return MemberController(getMemberService());
}
}
[ 동작과정 ]
테스트 코드에서 위의 코드를 호출한다고 가정하겠습니다.
Menu 객체를 생성해 MemberService 메서드로 리스트를 저장
MemberController 를 호출하면 SpringConfig 라는 IoC 컨테이너로 가서 빈 조회
빈이 존재한다면 해당 되는 빈을 mc 에 할당
mc 의 getMenu 로 Menu를 조회
위와 같은 동작과정을 거친다면 Spring Framework 영역에서 빈등록, 의존성 주입으로 의존 객체들을 관리 해줍니다.
그래서 MenuService 의 구현체만 변경해줌으로써 한번만 코드를 수정하면 수정 부분에 대해 의존하고 있는 부분까지도
@Test
@Commit
void insertData() {
Member member = new Member();
member.setName("test");
member.setPhonenumber("01011");
member.setAddress(new Address("city","street","10000"));
member.setWorkPeriod(new WorkPeriod());
Member save = repository.save(member);
}
- member 객체를 테스트 코드에서 만듬
- save 함수 내부에서 begin ~ persist ~ commit 과정을 거침으로써 테스트코드에서는 이에 대한 코드를 작성할 일이 없음
임베디드 타입으로 선언한 값들이 정상적으로 들어오는 것을 알 수 있음
값 타입 공유 참조
임베디드 타입 같은 값 타입을 여러 엔티티에서 공유하면 위험함
[ 예시 ]
@Test
@Commit
void insertData() {
Address address = new Address("city","str","10000");
//공유 객체
Member member = new Member();
member.setName("test");
member.setPhonenumber("01011");
// member.setAddress(new Address("city","street","10000"));
member.setAddress(address);
member.setWorkPeriod(new WorkPeriod());
Member member2 = new Member();
member2.setName("test");
member2.setPhonenumber("01011");
member2.setAddress(address);
member2.getAddress().setCity("geoje"); // 수정
Member save = repository.save(member);
Member save2 = repository.save(member2);
}
주어진 인접행렬에서 한 정점으로부터 다른 정점으로 이어지는 길이 존재하는지 반환해야 합니다.
입력
인자 1: matrix
Array 타입을 요소로 갖는 인접 행렬이 담긴 2차원 배열
인자 2: from
int 타입의 시작 정점
인자 3: to
int 타입의 도착 정점
출력
boolean 타입을 리턴해야 합니다.
import java.util.LinkedList;
import java.util.Queue;
public class AdjacentFindRoot {
public static void main(String[] args) {
/*
- 인접 행렬에서 한 정점으로 부터 다른 정점으로 이어지는 길이 존재하는지 반환
- 입력 : 2차원 배열, 시작정점, 도착정점
- 출력 : 시작정점에서 도착 정점으로 가는 길이 있으면 true 를 반환
*/
int[][] test = new int[][]{
{0, 1, 0, 0, 0},
{0, 0, 0, 1, 0},
{0, 1, 0, 0, 0},
{0, 1, 1, 0, 0},
};
boolean directions = getDirections(test, 1, 4);
System.out.println(directions);
}
public static boolean getDirections(int[][] matrix, int from, int to) {
Queue<Integer> queue = new LinkedList<>();
queue.add(from);
boolean[] visited = new boolean[matrix.length];
visited[from] = true;
while(queue.size() > 0){
int now = queue.poll();
if(now == to) return true;
for (int i = 0; i < matrix[now].length; i++) {
if (matrix[now][i] == 1 && !visited[i]) {
queue.add(i);
visited[i] = true;
}
}
}
return false;
}
}
이처럼 클라이언트와 서버가 HTTP 통신을 할 때는 어떤 요청을 보내고 받느냐에 따라 메서드 사용이 달라집니다.
REST ( Representational State Transfer ) API 는 웹에서 사용되는 데이터나 자원을 HTTP URI 로 표현하고,
HTTP Protocol 을 통해 요청과 응답을 정의하는 방식을 의미합니다.
간단한 비유를 들어보겠습니다.
어떤 식당의 손님이 있고, 식사 혹은 음료를 주문한다고 가정해보겠습니다. 메뉴판의 상태가 내가 알아볼 수 없는 언어이고, 가독성이 떨어지는 메뉴판이라고 한다면 주문하기 어렵습니다. 이럴 때 만약, 메뉴판이 잘 알아볼 수 있게 누군가 규정을 해놓는다면 누구나 쉽게 메뉴판을 읽고 주문할 수 있습니다. 이러한 역할을 해주는 것이 REST API 입니다.
클라이언트 - 서버 사이에도 데이터와 리소스를 요청하고, 요청에 따른 응답을 전달해주기 위한 메뉴판이 필요합니다. 이 메뉴판을 보고 클라이언트는 식당에서 식사를 주문하듯 서버에 요청하고, 이에 대한 응답을 다시 서버에서 클라이언트로 전송하게 됩니다.
따라서 HTTP 프로토콜 기반으로 요청과 응답에 따라 리소스를 주고받기 위해선 알아보기 쉽게 작성된 메뉴판이 필요합니다. 이 역할을 API 가 수행해야 하므로 서로 잘 알아볼 수 있도록 작성하는 것이 중요합니다.
좋은 REST API 디자인 방법
REST 성숙도 모델을 구조화하면 다음과 같습니다.
실제로는 2단계까지만 적용해도 좋은 API 디자인이라고 볼 수 있으며, 이런 경우 HTTP API 라고 부릅니다.
REST 성숙도 모델 0단계
HTTP 프로토콜을 사용하기만 하면 됩니다.
물론 이 경우, REST API 라고 할 수는 없습니다.
REST 성숙도 모델 1단계
개별 리소스와의 통신을 준수해야 합니다.
모든 자원은 개별 리소스에 맞는 엔드포인트를 사용해야 하며, 요청하고 받은 자원에 대한 정보를 응답으로 전달해야 한다는 것입니다.
앞선 0 단계에서는 모든 요청에서 엔드 포인트로 /appointment 를 사용했습니다.
하지만 1 단계에서는 요청하는 리소스가 무엇인지에 따라 각기 다른 엔드포인트로 구분하여 사용해야 합니다.
위의 예시에서 예약 가능한 시간 확인이라는 요청의 응답으로 받게 되는 자원(리소스)은 허준이라는 의사의 예약 가능한 시간대입니다.
그렇기 때문에 요청 시 /doctors/허준이라는 엔드포인트를 사용한 것을 볼 수 있습니다.
그뿐만 아니라, 특정 시간에 예약하게 되면, 실제 slot이라는 리소스의 123이라는 id를 가진 리소스가 변경되기 때문에, 하단의 특정 시간에 예약이라는 요청에서는 /slots/123으로 실제 변경되는 리소스를 엔드포인트로 사용하였습니다.
예시와 같이, 어떤 리소스를 변화시키는지 혹은 어떤 응답이 제공되는지에 따라 각기 다른 엔드포인트를 사용하기 때문에, 적절한 엔드포인트를 작성하는 것이 중요합니다.
엔드포인트 작성 시에는 동사, HTTP 메서드, 혹은 어떤 행위에 대한 단어 사용은 지양하고, 리소스에 집중해 명사 형태의 단어로 작성하는 것이 바람직 방법입니다.
더불어 요청에 따른 응답으로 리소스를 전달할 때에도 사용한 리소스에 대한 정보와 함께 리소스 사용에 대한 성공/실패 여부를 반환해야 합니다. 예를 들어 만약 김코딩 환자가 허준 의사에게 9시에 예약을 진행하였으나, 해당 시간이 마감되어 예약이 불가능하다고 가정할 때, 아래와 같이 리소스 사용에 대한 실패 여부를 포함한 응답을 받아야 합니다.
REST 성숙도 모델 2단계
REST 성숙도 모델 2단계에서는 CRUD에 맞게 적절한 HTTP 메서드를 사용하는 것에 중점을 둡니다. 앞서 0단계와 1단계 예시에서 보았듯, 모든 요청을 CRUD에 상관없이 POST로 하고 있습니다. 그러나 REST 성숙도 모델 2단계에 따르면 이는 CRUD에 따른 적합한 메서드를 사용한 것은 아닙니다.
먼저 예약 가능한 시간을 확인한다는 것은 예약 가능한 시간을 조회(READ)하는 행위를 의미하고, 특정 시간에 예약한다는 것은 해당 특정 시간에 예약을 생성(CREATE)한다는 것과 같습니다. 그렇기 때문에 조회(READ)하기 위해서는 GET 메서드를 사용하여 요청을 보내고, 이때 GET 메서드는 body를 가지지 않기 때문에 query parameter를 사용하여 필요한 리소스를 전달합니다.
또한 예약을 생성(CREATE)하기 위해서는 POST 메서드를 사용하여 요청을 보내는 것이 바람직합니다. 그리고 2단계에서는 POST 요청에 대한 응답이 어떻게 반환되는지도 중요합니다.
이 경우 응답은 새롭게 생성된 리소스를 보내주기 때문에, 응답 코드도 201 Created 로 명확하게 작성해야 하며, 관련 리소스를 클라이언트가 Location 헤더에 작성된 URI를 통해 확인할 수 있도록 해야, 완벽하게 REST 성숙도 모델의 2단계를 충족한 것이라고 볼 수 있습니다.
물론 메서드를 사용할 때도 규칙이 있습니다.
GET 메서드 같은 경우는 서버의 데이터를 변화시키지 않는 요청에 사용해야 합니다.
POST 는 요청마다 새로운 리소스를 생성하고 PUT 은 요청마다 같은 리소스를 반환합니다. 이렇게 매 요청마다 같은 리소스를 반환하는 특징을 멱등(idempotent)하다고 합니다. 그렇기 때문에 멱등성을 가지는 메서드 PUT과 그렇지 않은 POST는 구분하여 사용해야 합니다.
PUT 과 PATCH 도 구분하여 사용해야 합니다. PUT은 교체, PATCH는 수정의 용도로 사용합니다.
API를 작성할 때, REST 성숙도 모델의 2단계까지 적용을 하면 대체적으로 잘 작성된 API라고 여깁니다.
물론 로이 필딩은 앞서 이야기한 바와 같이 3단계까지 만족하지 못한다면 REST API가 아니기 때문에 HTTP API라고 불러야 한다고 주장하지만, 뒤에 만나게 되는 레퍼런스의 모범적인 API 디자인조차도 REST 성숙도 모델의 3단계까지 적용한 경우는 극히 드뭅니다. 따라서 3단계까지 무조건적으로 모두 적용해야 한다는 것은 아닙니다.
REST 성숙도 모델 3단계
마지막 단계는 HATEOAS(Hypertext As The Engine Of Application State)라는 약어로 표현되는 하이퍼미디어 컨트롤을 적용합니다. 3단계의 요청은 2단계와 동일하지만, 응답에는 리소스의 URI를 포함한 링크 요소를 삽입하여 작성한다는 것이 다릅니다.
이때 응답에 들어가게 되는 링크 요소는 응답을 받은 다음에 할 수 있는 다양한 액션들을 위해 많은 하이퍼미디어 컨트롤을 포함하고 있습니다.
예를 들어 위와 같이 허준이라는 의사의 예약 가능 시간을 확인한 후에는 그 시간대에 예약을 할 수 있는 링크를 삽입하거나, 특정 시간에 예약을 완료하고 나서는 그 예약을 다시 확인할 수 있도록 링크를 작성해 넣을 수도 있습니다.
이렇게 응답 내에 새로운 링크를 넣어 새로운 기능에 접근할 수 있도록 하는 것이 3단계의 중요 포인트입니다.
만약 클라이언트 개발자들이 응답에 담겨 있는 링크들을 눈여겨본다면, 이러한 링크들은 조금 더 쉽고, 효율적으로 리소스와 기능에 접근할 수 있게 하는 트리거가 될 수 있습니다.
1. start line : 요청이나 응답의 상태를 나타냄. 항상 첫 번째 줄에 위치합니다.
2. HTTP headers : 요청을 지정하거나, 메시지에 포함된 본문을 설명하는 헤더의 집합
3. empty line : 헤더와 본문을 구분하는 빈 줄이 있습니다.
4. body : 요청과 관련된 데이터나 응답과 관련된 데이터 또는 문서를 포함 ( 요청,응답 유형에 따라 선택적 사용됨 )
Request
Start Line
HTTP 요청은 클라이언트가 서버에 보내는 메시지입니다.
Start Line 에는 세가지 요소가 있습니다.
1. 수행할 작업 ( GET, PUT, POST 등 ) 이나 방식 ( HEAD, OPTIONS ) 을 설명하는 HTTP method 를 나타냅니다.
2. 요청 대상 또는 프로토콜, 포트, 도메인의 절대 경로는 요청 컨텍스트에 작성됩니다. 이 요청 형식은 HTTP method 마다 다릅니다.
- origin 형식 : ? 와 쿼리 문자열이 붙는 절대 경로입니다. POST, GET, HEAD, OPTIONS 등의 메서드와 함께 사용됩니다.
- absolute 형식 : 완전한 URL 형식으로, 프록시에 연결하는 경우 대부분 GET method 와 함께 사용됩니다.
- authority 형식 : 도메인 이름과 포트 번호로 이뤄진 URL 의 authority component 입니다. HTTP 터널을 구축하는 경우,
CONNECT 와 함께 사용할 수 있습니다.
- asterisk 형식 : OPTIONS 와 함께 별표( ) 하나로 서버 전체를 표현합니다.
Headers
헤더 이름 ( 대소문자 구분이 없는 문자열 ), 콜론 ( : ), 값을 입력합니다.
값은 헤더에 따라 다릅니다. 여러 종류의 헤더가 있고, 다음과 같이 그룹을 나눌 수 있습니다.
- General headers : 메시지 전체에 적용되는 헤더로, body를 통해 전송되는 데이터와는 관련이 없는 헤더입니다.
- Request headers : fetch를 통해 가져올 리소스나 클라이언트 자체에 대한 자세한 정보를 포함하는 헤더를 의미합니다.
User-Agent, Accept-Type, Accept-Language 와 같은 헤더는 요청을 보다 구체화합니다.
Referer 처럼 컨텍스트를 제공하거나 If-None 가 같은 조건에 따라 제약을 추가할 수 있습니다.
- Representation headers : 이전에는 Entity Headers 로 불렀으며, body에 담긴 리소스의 정보를 포함하는 헤더입니다.
Body
요청의 본문은 HTTP messages 구조의 마지막에 위치합니다. 모든 요청에 body가 필요하지는 않습니다. GET, HEAD, DELETE, OPTIONS처럼 서버에 리소스를 요청하는 경우에는 본문이 필요하지 않습니다. POST나 PUT과 같은 일부 요청은 데이터를 업데이트하기 위해 사용합니다. body는 다음과 같이 두 종류로 나눌 수 있습니다.
Single-resource bodies(단일-리소스 본문) : 헤더 두 개(Content-Type과 Content-Length)로 정의된 단일 파일로 구성됩니다.
Multiple-resource bodies(다중-리소스 본문) : 여러 파트로 구성된 본문에서는 각 파트마다 다른 정보를 지닙니다. 보통 HTML form과 관련이 있습니다.
응답(Responses)
Status line
응답의 첫 줄은 Status line이라고 부르며, 다음의 정보를 포함합니다.
현재 프로토콜의 버전(HTTP/1.1)
상태 코드 - 요청의 결과를 나타냅니다. (200, 302, 404 등)
상태 텍스트 - 상태 코드에 대한 설명
Status line은 HTTP/1.1 404 Not Found. 처럼 생겼습니다.
Headers
응답에 들어가는 HTTP headers는 요청 헤더와 동일한 구조를 가지고 있습니다. 대소문자 구분 없는 문자열과 콜론(:), 값을 입력합니다. 값은 헤더에 따라 다릅니다. 요청의 헤더와 마찬가지로 몇 그룹으로 나눌 수 있습니다.
General headers : 메시지 전체에 적용되는 헤더로, body를 통해 전송되는 데이터와는 관련이 없는 헤더입니다.
Response headers : 위치 또는 서버 자체에 대한 정보(이름, 버전 등)와 같이 응답에 대한 부가적인 정보를 갖는 헤더로, Vary, Accept-Ranges와 같이 상태 줄에 넣기에는 공간이 부족했던 추가 정보를 제공합니다.
Representation headers : 이전에는 Entity headers로 불렀으며, body에 담긴 리소스의 정보(콘텐츠 길이, MIME 타입 등)를 포함하는 헤더입니다.
Body
응답의 본문은 HTTP messages 구조의 마지막에 위치합니다. 모든 응답에 body가 필요하지는 않습니다. 201, 204와 같은 상태 코드를 가지는 응답에는 본문이 필요하지 않습니다. 응답의 body는 다음과 같이 두 종류로 나눌 수 있습니다.
Single-resource bodies(단일-리소스 본문) :
길이가 알려진 단일-리소스 본문은 두 개의 헤더(Content-Type, Content-Length)로 정의합니다.
길이를 모르는 단일 파일로 구성된 단일-리소스 본문은 Transfer-Encoding이 chunked 로 설정되어 있으며, 파일은 chunk로 나뉘어 인코딩되어 있습니다.
Multiple-resource bodies(다중-리소스 본문) : 서로 다른 정보를 담고 있는 body입니다.
Stateless
Stateless는 말 그대로 상태를 가지지 않는다는 뜻입니다. HTTP로 클라이언트와 서버가 통신을 주고받는 과정에서, HTTP가 클라이언트나 서버의 상태를 확인하지 않습니다.
사용자는 쇼핑몰에 로그인하거나 상품을 클릭해서 상세 화면으로 이동하고, 상품을 카트에 담거나 로그아웃을 할 수도 있습니다. 클라이언트에서 발생한 이런 모든 상태를 HTTP 통신이 추적하지 않습니다.
만약 쇼핑몰에서 카트에 담기 버튼을 눌렀을 때, 카트에 담긴 상품 정보(상태)를 저장해둬야 합니다. 그러나 HTTP는 통신 규약일 뿐이므로, 상태를 저장하지 않습니다.
따라서, 필요에 따라 다른 방법(쿠키-세션, API 등)을 통해 상태를 확인할 수 있습니다.
- 유저의 입력와 요청에 의한 콘텐츠나 정보의 최신화가 페이지를 새로 불러오지 않고 현재 페이지에서 이뤄집니다.
- 필수적인 요소만 요청합니다.
- AJAX, Asynchronous JavaScript, XML 이 주로 사용합니다.
- 유저는 페이지 새로 고침 되지 않고, 요청한 응답을 기다리면서 페이지와 상호작용이 가능합니다.
Microservice Architecture
작고 가벼운 특정한 한 가지 기능에 집중한 웹 애플리케이션을 의미합니다.
각 애플리케이션의 기능 요소들은 상호간에 의존적으로 설계되지 않습니다.
따라서 개발 단계에서도 그리고 개발 완성 이후에도 같은 개발 언어를 사용할 필요가 없습니다.
개발자는 원하는 언어를 사용해 기능 개발에 유연성을 갖게 되고, 개발 과정의 전반적인 속도와 생산성이 향상됩니다.
Serverless Architecture
개발자가 웹 애플리케이션의 서버와 기타 기반 기능들에 대해 외부의 제 3자인 클라우드 서비스 제공자에게 의탁하는 방식입니다.
이 방식은 개발자가 서버,기반 기능들에 걱정할 필요 없이 특정 기능의 개발에 집중할 수 있게 합니다.
HTTP
웹 브라우저상에서 클라이언트와 서버간의 통신을 담당하는 프로토콜입니다.
클라이언트에서의 데이터 요청과 서버에서의 요청에 대한 응답을 반복하면서 웹 애플리케이션을 작동시킵니다.
HTTP 요청을 할 때에는 하고 싶은 처리의 종류를 나타내는 메서드 이름, 처리 대상의 이름이 포함됩니다.
HTTP 응답에는 요청에 대한 처리 결과를 상태 코드, 헤더, 실제 처리 결과인 메시지가 포함됩니다.
쿠키와 세션
HTTP 는 데이터를 요청하고 요청에 대한 응답을 전송하는 무상태성의 프로토콜 입니다.
우리가 특정 쇼핑몰에 접속한다고 가정해보겠습니다.
구매를 원하는 상품에 대해 장바구니에 넣음 -> 그 중 일부 물품만 결제 진행 ( 남은 물품은 나중에 구매 )
위와 같은 기능을 실현할 때에는 무상태성의 특징을 가진 HTTP 프로토콜만 가지고는 불가능합니다.
이를 위해 필요한 기능이 쿠키와 세션입니다.
쿠키 : 웹 애플리케이션을 사용하는 유저의 정보를 클라이언트에 보관 후 다음 접속 부터는 유저의 정보를 클라이언트가 서버로 보내서 유저를 서버가 식별하게 합니다. 쿠키에 담긴 내용으로 웹 애플리케이션에 유저가 설정했던 항목들에 대해 저장을 해서 다음에 이어서 같은 방식으로 작동하게 도와줍니다.
세션 : 서버에 Session-Id 라는 고유 아이디를 할당해서 유저를 식별합니다. 단순하고 유출되면 안되는 정보는 서버에서 관리를 하면서 세션 ID와 매칭해서 저장해 관리합니다. 주로 사용되는 방법은, 세션 정보는 쿠키에서 관리하고 실제 매칭되는 값들은 서버측에서 관리하는게 일반적입니다.
사용자 인증
컴퓨터나 특정 시스템을 사용할 때 유저를 식별할 수 있는 ID 값과 암호를 입력합니다.
웹에서의 인증은 개인정보를 바탕으로 합니다.
단지 사용자 식별용 고유 아이디와 암호 뿐이 아니라, 개인의 신원 또한 파악하는 다요소 인증(MFA) 가 웹에서의 보안의 필수 요소로 되었습니다.
가장 일상적으로 접근하는 방식은 OAuth 방식의 로그인입니다.
이 방식은 서비스 자격증명 메커니즘을 다른 믿을만한 제3자의 서비스에 위임해 인증하는 방식입니다.
iOS, AOS, Window 아 같은 특정 실행환경에 종속됩니다. 이는 아래의 특징을 지닙니다.
- 장점
1) 웹 애플리케이션보다 빠름
2) 설치된 기기의 시스템 리소스에 접근이 용이 ( GPS, Camera )
3) 인터넷 없어도 됨
- 단점
1) 웹 애플리케이션에 비해 개발비가 더 들어감 ( 각 OS간의 멀티플랫폼 개발 등 )
2) 빠른 업데이트가 어려움
3) 앱스토어 승인이 어려우며, 비용 발생
웹 애플리케이션
정적인 웹사이트에서 벗어나 동적인 웹 브라우저라는 소프트웨어를 결합한 것
- 장점
1) 브라우저를 통해 실행되기에 설치,다운로드가 필요 없음
2) 업데이트 유지관리가 쉬움
3) 네이티브 애플리케이션에 비해 만들기 편리
- 단점
1) 인터넷 필요
2) 네이티브 애플리케이션에 비해 느림
3) 사용자 접근성이 떨어짐
4) 보안상 위험 노출이 쉬움
LAN, WAN
웹 애플리케이션의 연결된 네트워크를 LAN 또는 WAN 이라고 합니다.
LAN
회사 내부와 같이 좁은 범위에 연결된 네트워크
WAN
LAN 들이 모여 세계의 네트워크를 구성하는 넓은 범위의 네트워크
* 우리는 왜 인터넷 비용을 지불할까요?
LAN 이 WAN 으로 확장하기 위해서는 통신 회선 서비스를 이용해야 합니다. KT, LG, SK 는 이런 회선 서비스를 구성하고 고객에게 서비스를 제공합니다. 그러면 우리가 사용하는 인터넷은 이런 회선 서비스를 이용해 WAN 에 접속해야하기 때문에 비용을 지불해야 합니다.
프로토콜
컴퓨터들끼리 서로 소통을 할 때 필요한 약속입니다.
우리가 가전제품을 사용할때마다 전원에 연결해 사용하는 전원코드가 있다고 생각해봅니다.
그러면 가전 제품마다 콘센트를 다르게 하면 매번 다른 콘센트를 바꿔 달아야 할겁니다.
이런 경우를 대비해서 어느정도의 공통 규격을 만들어서 그 규격을 바탕으로 제조사가 제조를 하게 됩니다.
이렇게 인터넷도 마찬가지로 어느 컴퓨터든 네트워크를 사용할 수 있게 하는 공통 언어를 프로토콜이라고 합니다.
TCP / IP
인터넷 통신 스위트는 인터넷에서 컴퓨터들이 서로 정보를 주고 받는데 쓰이는 통신 규약의 모음입니다.
이 모음을 통해 다른 컴퓨터, 다른 운영체제, 다른 회선간 통신이 가능합니다.
현재까지 표준으로 사용되고 있는 것이 TCP/IP 입니다.
IP 주소
IP는 Internet Protocol 이 줄임말입니다.
인터넷 Url 에 192.30.125:8080 이렇게 네 덩이의 주소를 IP라고 부릅니다.
IPv4는 IP주소 체계의 네 번째 버전을 의미합니다.
IPv6는 누구나 컴퓨터를 사용함에 따라 많은 IP를 가지게 되자 IPv4로 감당할 수 있는 한계를 넘어서게 되자 나온 IP주소입니다.
TCP/IP 구조에서 컴퓨터를 식별하기 위해 사용되는 주소입니다.
LAN 네트워크 내부에서는 Private IP 주소가 사용되고, 인터넷에서는 Public IP 주소가 사용됩니다.
MAC 주소
각 네트워크 기기가 처음부터 제조사에서 할당한 고유 시리얼 주소를 MAC 주소라고 부릅니다.
네트워크 송 수신을 위해서는 IP주소와 MAC 주소를 조합해야 통신이 가능합니다.
이더넷 에서 MAC - 네트워크 상의 송수신 상대를 특정할 때 사용
TCP/IP 에서 IP - IP 주소를 사용하게 됨
같은 LAN 에 속한 기기끼리 통신할 때는 우선 상대방의 MAC주소를 파악하기위해 ARP를 사용합니다.
MAC주소를 파악하기 위해 네트워크 전체에 브로드캐스트를 통해 패킷을 보내고,
해당 IP를 가지고 있는 컴퓨터가 자신의 MAC주소를 Response하게 됨으로써 통신할 수 있게 해주는 프로토콜입니다.
패킷
기기기리의 통신에는 회선 교환 방식 ( Circuit ) 과 패킷 교환 방식 두가지가 있습니다.
