Redis란 무엇인가

Key, Value 구조의 비정형 데이터를 저장하고 관리하기 위한 오픈 소스 기반의 비관계형 데이터베이스 관리 시스템 입니다.

비정형 데이터는 일정한 구조나 형식 없이 저장된 데이터를 의미하며 이러한 데이터들을 저장하고 관리하기 위한 관리 시스템이 Redis입니다.

Redis는 비관계형 데이터베이스?

비관계형 데이터베이스는 특정 데이터 모델에 대해 특정 목적에 맞추어 구축되는 데이터베이스로서 유연한 스키마를 갖추고 있습니다.

이러한 데이터베이스 유형은 큰 데이터 볼륨, 짧은 지연 시간과 유연한 데이터 모델이 필요한 애플리케이션에 최적화 되어 있습니다.

관계형 데이터베이스와 차이점은?

데이터 저장 방법에 차이점이 있습니다. 관계형 데이터베이는 데이터를 행과 열이 있는 테이블 형식으로 저장합니다.

비관계형 데이터베이스는 데이터에 엑세스하고 관리하기 위해 다양한 데이터 모델을 사용합니다. 스키마가 없기 때문에 관계형 데이터베이스에서 요구되는 제약 조건 없이 저장됩니다.

대표적으로 Key, Value 형태로 저장하며 이때 Key값은 고유 식별자 역할을 합니다. 단순한 객체부터 복잡한 집합체에 이르기까지 무엇이든 키와 값이 될 수 있습니다.

이 외에도 도큐먼트 데이터베이스와 그래프 데이터베이스가 있습니다.

Redis는 왜 사용할까?

데이터 베이스는 데이터를 물리 디스크에 직접 쓰기 때문에 서버에 문제가 발생하여 다운되더라도 데이터가 손실되지 않습니다.

하지만 매번 디스크에 접근해야 하기 때문에 사용자가 많아질 수록 부하가 많아져서 느려질 수 있습니다.

일반적으로 서비스 운영 초반이거나 규모가 작은, 사용자가 많지 않은 서비스의 경우에는 WEB-WAS-DB의 구조로도 데이터베이스에 무리가 가지 않습니다.

그러나 사용자가 늘어난다면 데이터베이스가 과부하 될 수 있기 때문에 캐시 서버를 도입하여 사용하게 됩니다. 그리고 이 캐시 서버로 이용할 수 있는 것이 바로 Redis입니다.

캐시 서버는 뭔가요?

캐시 서버는 클라이언트가 자주 요청하는 데이터를 메모리나 빠른 스토리지에 저장하여, 반복적인 데이터 요청 시 서버에 부담을 줄이고 응답 시간을 단축하는 역할을 합니다.

이 시스템은 네트워크 대역폭을 절약하고, 데이터베이스나 원본 서버의 부하를 감소시켜 성능을 최적화하는 데 중요한 역할을 합니다.

간단한 예를 들어보겠습니다.

1. 클라이언트가 서버에 데이터를 요청합니다.
2. 서버는 외부 API를 통해 데이터를 가져오고 그것을 응답으로 넘겨줍니다.
3. 이 때 외부 API 접근의 응답속도가 1000ms 정도 나옵니다.
4. 클라이언트는 데이터를 응답받기까지 1000ms는 적다고 생각합니다.
5. 그래서 중간에 캐시에 저장하기로 합니다.
6. 이제부터 서버는 5 ~ 10분 간격으로 외부 API에 데이터를 요청하여 캐시에 저장합니다.
7. 클라이언트가 서버에 데이터를 요청합니다.
8. 서버는 캐시에서 데이터를 꺼내 클라이언트로 응답해줍니다.
9. 1000ms 씩 걸리던 외부 API 접속 과정이 생략되어 클라이언트는 빠르게 데이터를 받아 볼 수 있습니다.

이렇듯 주 요청하는 데이터를 임시로 저장해두었다가 클라이언트가 요청할 때 빠르게 전달해주는 시스템입니다.

Redis의 장점은 뭔가요?

1. 성능 모든 Redis 데이터는 메모리에 저장되어 대기 시간을 낮추고 처리량을 높이며, 평균적으로 읽기 및 쓰기의 작업 속도가 1ms로 디스크 기반 데이터베이스보다 빠릅니다.

2. 유연한 데이터 구조 Redis의 데이터는 String, List, Set, Hash, Sorted Set, Bitmap, JSON 등 다양한 데이터 타입을 지원합니다. 따라서, 애플리케이션의 요구 사항에 알맞은 다양한 데이터 타입을 활용할 수 있습니다.

3. 개발 용이성 Redis는 쿼리문이 필요로 하지 않으며, 단순한 명령 구조로 데이터의 저장, 조회 등이 가능합니다. 또한, Java, Python, C, C++, C#, JavaScript, PHP, Node.js, Ruby 등을 비롯한 다수의 언어를 지원합니다.

4. 영속성 Redis는 영속성을 보장하기 위해 데이터를 디스크에 저장할 수 있습니다. 따라서 서버에 치명적인 문제가 발생하더라도 디스크에 저장된 데이터를 통해 복구가 가능합니다.

5. 싱글 스레드 방식 Redis는 싱글 스레드 방식을 사용하여 한 번에 하나의 명령어만을 처리하기 때문에 연산을 원자적으로 처리하여 Race Condition(경쟁 상태)가 거의 발생하지 않습니다. 하지만, 멀티 스레드를 지원하지 않기 때문에 시간 복잡도가 O(n)인 명령어의 사용은 주의해서 사용해야 합니다.

1. 간단 비교

2. 언어와 실행 구조의 차이

Spring

• 언어: Java
• 실행 방식: JVM 위에서 동작
• 요청 처리 모델: 기본적으로 멀티 스레드
• 요청 하나당 스레드 할당

➡️ 안정성, 예측 가능한 성능이 강점

Fast API

• 언어: Python
• 실행 방식: ASGI 서버(Uvicorn) 위에서 실행
• 요청 처리 모델: 비동기(async/await)

➡️ 비동기 + 타입 힌트 기반

Node.js

• 언어: JavaScript
• 실행 방식: V8 엔진
• 요청 처리 모델: 싱글 스레드 + 이벤트 루프

➡️ I/O가 많은 서비스에 강함 ➡️ 블로킹 코드에 취약

3. 내부 구조 차이

Spring

구조 특징

• MVC 구조
• DI(의존성 주입), AOP 기반
• 필터 -> 인터셉터 -> 컨트롤러 -> 서비스 -> 레포지토리

Client
-> Filter
-> Intercepter
-> Controller
-> Service
-> Repository
-> DB

특징

• 코드 구조가 강제됨
• 설계가 잘 되면 유지보수가 매우 편함
• 보일러플레이트 많음

Fast API

구조 특징

• 함수 중심 구조
• 타입 힌트 기반 자동 검증
• Open API(Swagger) 자동 생성

@app.get("/users/{id}")
async def get_user(id: int):
    return {"id" : id}

특징

• 구조가 자유로움
• 빠른 개발
• 팀이 커질수록 설계가 중요해짐

Node.js(Express 기준)

구조 특징

• 미들웨어 체인
• 요청 -> 미들웨어 -> 컨트롤러

app.get("/users/:id", async (req, res) => {
  res.json({id: req.params.id});
});

특징

• 매우 자유로움
• 잘못 설계하면 스파게티 코드
• NestJS를 쓰면 Spring과 유사해짐

4. 성능 관점 비교

5. 개발 생산성 비교

6. 생태계

Spring

• 대기업, 금융, 공공기관
• 인증/보안(Spring Security)
• 트랜잭션 관리
• 대규모 조직 협업

➡️ 안정성 + 표준

Fast API

• 스타트업
• AI/ML 서버
• 크롤링, 데이터 처리 API

➡️ 빠른 실험과 검증

Node.js

• 채팅
• 알림 서버
• 실시간 서비스
• BFF(Backend for Frontend)

➡️ 실시간 + 프론트 연계

7. 조합 예시

Spring Boot (메인 서버)
 ├─ 인증 / 비즈니스 로직
 ├─ DB 트랜잭션
 └─ 사용자 API

Node.js (보조 서버)
 └─ 채팅 / WebSocket

FastAPI (서브 서버)
 └─ 크롤링 / AI / 데이터 처리

8. 각 기술별 CRUD 예제 비교

0. 공통 CRUD 요구사항

• 사용자 생성(Create)
• 사용자 조회(Read)
• 사용자 수정(Update)
• 사용자 삭제(Delete)

Spring CRUD

Entity

@Entity
@Getter @Setter
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
}

Repository

public interface UserRepository extends JpaRepository<User, Long> {
}

Service

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;

    public User create(User user) {
        return userRepository.save(user);
    }

    public User get(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User not found"));
    }

    public User update(Long id, User user) {
        User existing = get(id);
        existing.setName(user.getName());
        return userRepository.save(existing);
    }

    public void delete(Long id) {
        userRepository.deleteById(id);
    }
}

Controller

@RestController
@RequestMapping("/users")
@RequiredArgsConstructor
public class UserController {

    private final UserService userService;

    @PostMapping
    public User create(@RequestBody User user) {
        return userService.create(user);
    }

    @GetMapping("/{id}")
    public User get(@PathVariable Long id) {
        return userService.get(id);
    }

    @PutMapping("/{id}")
    public User update(@PathVariable Long id, @RequestBody User user) {
        return userService.update(id, user);
    }

    @DeleteMapping("/{id}")
    public void delete(@PathVariable Long id) {
        userService.delete(id);
    }
}

Fast API CRUD

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    id: int
    name: str

users = {}

Create

@app.post("/users")
async def create_user(user: User):
    users[user.id] = user
    return user

Read

@app.get("/users/{id}")
async def get_user(id: int):
    return users.get(id)

Update

@app.put("/users/{id}")
async def update_user(id: int, user: User):
    users[id] = user
    return user

Delete

@app.delete("/users/{id}")
async def delete_user(id: int):
    users.pop(id, None)
    return {"message": "deleted"}

Node.js

const express = require("express");
const app = express();

app.use(express.json());

const users = {};

Create

app.post("/users", (req, res) => {
  const { id, name } = req.body;
  users[id] = { id, name };
  res.json(users[id]);
});

Read

app.get("/users/:id", (req, res) => {
  res.json(users[req.params.id]);
});

Update

app.put("/users/:id", (req, res) => {
  const { name } = req.body;
  users[req.params.id].name = name;
  res.json(users[req.params.id]);
});

Delete

app.delete("/users/:id", (req, res) => {
  delete users[req.params.id];
  res.json({ message: "deleted" });
});

9. 추가 Spring vs NestJS

전체 구조 비교

Entity / Model

Spring(JPA Entity)

@Entity
@Getter @Setter
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
}

NestJS(TypeORM Entity)

import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;
}

차이점

• Spring: JPA 표준
• NestJS: TypeORM / Prisma 등 선택
• 문법만 다르고 개념은 동일

Repository

Spring

public interface UserRepository extends JpaRepository<User, Long> {
}

NestJS

@Injectable()
export class UserRepository {
  constructor(
    @InjectRepository(User)
    private repo: Repository<User>,
  ) {}

  save(user: User) {
    return this.repo.save(user);
  }

  findById(id: number) {
    return this.repo.findOneBy({ id });
  }
}

차이점

• Spring: 인터페이스만 정의 -> 구현 자동
• NestJS: 직접 래핑(조금 더 명시적)

Service(비즈니스 로직)

Spring Service

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;

    public User create(User user) {
        return userRepository.save(user);
    }

    public User get(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User not found"));
    }
}

NestJS Service

@Injectable()
export class UserService {
  constructor(private readonly userRepository: UserRepository) {}

  async create(user: User): Promise<User> {
    return this.userRepository.save(user);
  }

  async get(id: number): Promise<User> {
    return this.userRepository.findById(id);
  }
}

차이점

• Spring: 동기 코드처럼 보임
• NestJS: async/await 명시
• DI 방식은 거의 동일

Controller

Spring Controller

@RestController
@RequestMapping("/users")
@RequiredArgsConstructor
public class UserController {

    private final UserService userService;

    @PostMapping
    public User create(@RequestBody User user) {
        return userService.create(user);
    }

    @GetMapping("/{id}")
    public User get(@PathVariable Long id) {
        return userService.get(id);
    }
}

NestJS Controller

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Post()
  create(@Body() user: User) {
    return this.userService.create(user);
  }

  @Get(':id')
  get(@Param('id') id: number) {
    return this.userService.get(id);
  }
}

차이점

• 어노테이션 <-> 데코레이터 문법 차이
• 의미는 동일

DTO & Validation

Spring DTO

public class UserDto {
    @NotBlank
    private String name;
}

NestJS DTO

import { IsNotEmpty } from 'class-validator';

export class UserDto {
  @IsNotEmpty()
  name: string;
}

차이점

• Spring: Hibernate Validator
• NestJS: Class-Validator
• 검증 위치 개념 동일

차이 요약

10. 기술 선택 가이드

• 메인 비즈니스 서버 -> Spring
• Node 기반이지만 큰 규모 -> NestJS
• 채팅 / 실시간 -> Node.js or NestJS
• 빠른 MVP -> Node.js / Fast API

JWT(JSON Web Token)는 사용자 인증 저오와 추가 데이터를 JSON 형태로 담아서 암호화한 문자열이다.

즉, 이 사용자가 누구인지를 증명할 수 있게 해주는 디지털 서명된 토큰인 것이다.

ex)

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
eyJ1c2VySWQiOjEsInJvbGUiOiJ1c2VyIn0.
s7Kfj3VfknBvS9vU8HnV9zUpAbWQqf7sn9UiEqlP3ko

이 문자열은 아래와 같이 총 3부분으로 나뉘어 있다.

1. 왜 JWT를 사용하나?

📊세션 방식과 JWT를 비교해보자

JWT는 서버에 상태를 저장하지 않고도 인증을 유지할 수 있기 때문에 마이크로서비스, 모바일 앱, 서버간 통신 등에서 효율적이다.

3. 프론트엔드에서 JWT의 활용

1. 로그인시 토큰 받기

// 예: 로그인 API 호출 결과
const response = await axios.post("/login", { id, password });
const token = response.data.token;

2. 서버에서 받은 토큰을 저장 브라우저 저장소에 저장(권장: HttpOnly 쿠키 또는 LocalStorage)

// 예시 (간단하게 localStorage에 저장)
localStorage.setItem("token", token);

보안상 안전한 방식은 HttpOnly 쿠키 사용이다.

3. API 호출 시 토큰을 함께 전송 서버가 인증된 요청인지 확인하려면, JWT를 헤더에 넣어서 보내야 한다.

// 예: 게시글 목록 요청 시
const token = localStorage.getItem("token");

axios.get("/api/posts", {
  headers: {
    Authorization: `Bearer ${token}`
  }
});

4. 서버는 토큰을 검사

• 서버는 요청이 올 때마다 JWT를 검사하여 유효한 사용자면 응답을 해준다.
• 보통 Spring Boot에서는 필터나 인터셉터에서 검사를 처리한다.

4. JWT 사용 시나리오

회원가입 & 로그인

1. 로그인 성공 -> JWT 발급
2. 프론트는 JWT를 저장
3. 이후 모든 요청에 JWT를 헤더에 넣음
4. 서버는 JWT를 검사해 요청한 사람이 누구인지 파악

5. 주의할 점

1. JWT 탈취 시 큰 위험 -> Https + HttpOnly 쿠키 권장
2. 만료 시간 설정 필수
3. JWT는 섭버에서 무효화 불가 -> 때문에문에 짧은 유효시간 + RefreshToken을 같이 사용하기도 한다.

0. 리다이렉트(Redirect)란?

리다이렉트는 사용자가 어떤 URL로 접속했을 때 자동으로 다른 URL로 이동시키는 것을 말한다.

예를 들어, example.com에 접속했을 때 자동으로 example.com/home으로 이동하거나, 오래된 페이지 URL을 새 페이지 URL로 연결하는 경우에 사용한다.

사용자는 example.com에 접속했지만 실제로는 리다이렉트 되어 example.com/home으로 이동되어 화면에 보여지는 것이다.

1. Vue Router에서 리다이렉트를 사용하는 경우

{
  path: "",
  redirect: "/home"
}

이런 식으로 사용할 수 있다. path 부분의 ""은 부모 경로의 자식 라우트 중 빈 문자열을 경로에 사용하여 부모 경로로 접속하면 자동으로 부모경로/home 페이지가 보이도록 한 것이다.

2. 왜 리다이렉트가 필요할까?

만약 리다이렉트가 없으면 /부모경로에 들어가도 아무 자식 컴포넌트가 렌더링이 되지 않을 수 있다. 그렇게 되면 사용자가 접속했을 때 아무런 화면도 보이지 않게 되는 것이다.

따라서 유저에게 원하는 화면을 보여주기 위해 리다이렉트를 사용하는 것이다.

0. 디자인 참고하기

디자인을 시작하기에 앞서, 나는 디자인에 대해 문외한이기 때문에 타 사이트를 참고하여 해보려 한다.

네이버 메인

네이버 구조

다음 메인

다음 구조

구글 메인

구글 구조

벨로그 메인

벨로그 구조

사람인 메인

사람인 구조

포털 사이트 3곳, 채용 사이트 1곳, 소셜네트워크 사이트 1곳 총 5곳의 메인 화면을 분석해보았다.

5곳의 사이트 구조를 전부 합쳐 보면,

이런 모양이 나온다.

여기서 하나씩 지워보면서 사이트 구조를 만들어보자.

구조를 하나씩 지웠으니 크기와 배치를 조정해보자.

완성된 구조 모습

결과

구조를 완성했으니 각 요소들을 가져오고 색상도 바꿔보자!

요소들은 당장 넣을 내용이 없으니 각 사이트에서 캡처해서 가져와봤다. 생각보다 괜찮게 나온 듯하다.

네트워크

컴퓨터 A와 컴퓨터 B는 직접적으로 연결되어 있다.

컴퓨터 B와 컴퓨터 C는 직접적으로 연결되어 있다.

→ 컴퓨터 A와 C는 간접적으로 연결되어 있다.

A-B

B-C

A-C

A-B-C

이를 하나의 네트워크라고 한다.

매개변수로 컴퓨터의 개수 n 컴퓨터의 연결 정보가 담긴 2차원 배열 computers가 주어질 때, 네트워크의 개수를 return하라.

제한 사항

1. 컴퓨터의 개수 n은 1 이상 200 이하인 자연수이다.
2. 각 컴퓨터는 0부터 n-1 인 정수로 표현한다.
3. i번 컴퓨터와 j번 컴퓨터가 연결되어 있으면 computers[i][j]를 1로 표현한다.
4. computers[i][i]는 항상 1이다.

입출력 예시

접근 방법

예시를 가지고 그래프를 그려보자.

A-B

B-A

C

위처럼 A와 B는 서로 연결되어 있지만, C는 다른 컴퓨터와 연결되어 있지 않다.

따라서 네트워크의 개수는 2이다.

A-B

B-A

B-C

C-B

A-B-C

위처럼 3대의 컴퓨터는 서로 연결되어 있다.

따라서 네트워크의 개수는 1이다.

네트워크는 그래프로 표현할 수 있다.

모든 네트워크를 탐색하고 한 개의 네트워크가 탐색이 끝나면 count하면 된다.

그래프 탐색에는 BFS와 DFS가 있다.

단순히 탐색만 하는 문제라 둘 중에 어느 것을 사용해도 되므로, BFS와 DFS 둘 다 익숙해지기 위해 두 방법으로 코드를 작성해보겠다.

BFS사용

먼저 BFS로 그래프를 탐색하는 것부터 구현해보자.

2차원 배열 computers[i][j]의 [0][0]부터 차례대로 Queue에 넣어보자.

이 때, i == j 인 경우는 건너 뛴다. → i와 j가 같은 경우는 자기 자신을 가리키기 때문이다.

Queue에 [0][1]을 넣고 방문 표시를 한다.

[1][0]부터 값이 1인 인덱스를 탐색한다. → 1이면 이어지고, 0이면 이어지지 않는다.

탐색한 인덱스가 1이면 해당 인덱스의 방문 여부를 확인한다.

방문했으면 다음으로 넘어가고 그렇지 않으면 Queue에 삽입한다.

더 방문할 인덱스가 없으면 탐색을 종료한다.

위 과정을 코드로 작성해보자.

import java.util.Queue;
import java.util.HashMap;

Queue<Integer> queue = new Queue<>();
HashMap<Integer, Boolean> visited = new HashMap<>();

int answer = 0;

for(int i = 0; i < computers.length; i++) {
    bfs(0, true);
}

public void bfs(int node, boolean visit) {
    queue.push(node);
    visited.put(0, true);

    while(!queue.isEmpty()) {
        node = queue.poll();

        for(int i = 0; i < computers[node].length; i++) {
            if(node == i) {
                continue;
            } else if(computers[node][i] == 1 && visited.get(i) != true) {
                    queue.push(i);
                    visited.put(i, true);
            }
        }
    }
    answer++;
}

이제 프로그래머스에 옮겨 적어보자.

import java.util.Queue;
import java.util.LinkedList;

class Solution {
    public void bfs(int node, int[][] computers, boolean[] visited) {
        Queue<Integer> queue = new LinkedList<>();

        queue.offer(node);
        visited[node] = true;

        while(!queue.isEmpty()) {
            node = queue.poll();

            for(int i = 0; i < computers[node].length; i++) {
                if(node == i) {
                    continue;
                } else if(computers[node][i] == 1 && visited[i] != true) {
                    queue.offer(i);
                    visited[i] = true;
                }
            }
        }
    }

    public int solution(int n, int[][] computers) {
        boolean[] visited = new boolean[n];

        int answer = 0;

        for(int i = 0; i < computers.length; i++) {
          if(visited[i] == false) {
              answer++;
              bfs(i, computers, visited);
            }
        }

        return answer;
    }
}

정답!

DFS 사용

BFS를 사용해서 해결했으니, 이번엔 DFS로 풀어보자.

DFS는 재귀 호출을 사용해야 한다.

시작 노드를 DFS 함수의 매개변수로 넣어준다.

시작 노드를 받은 DFS 함수는 방문 여부를 표시하고, 시작 노드가 어디와 연결되어 있는지 배열을 탐색한다.

BFS와 마찬가지로 i == j 인 경우는 건너 뛴다. → i와 j가 같은 경우는 자기 자신을 가리키기 때문이다.

computer[node][i]가 1이면, 다시 DFS 함수에 매개변수로 i값을 넣어준다.

그러면 재귀 호출로 인해 DFS를 반복하여 그래프를 탐색할 수 있다.

위 과정을 코드로 작성해 보자.

public void dfs(int currentNode, int[][] computers, boolean[] visited) {
    visited[currentNode] = true;

    for(int i = 0; i < computers[currentNode].length; i++) {
        if(computers[currentNode][i] == 1 && !visited[i]) {
            dfs(i, computers, visited);
        }
    }
}

아래는 프로그래머스에 위 코드를 옮겨 적은 것이다.

import java.util.Queue;
import java.util.LinkedList;

class Solution {
    public void dfs(int currentNode, int[][] computers, boolean[] visited) {
        visited[currentNode] = true;

        for(int i = 0; i < computers[currentNode].length; i++) {
            if(computers[currentNode][i] == 1 && !visited[i]) {
                dfs(i, computers, visited);
            }
        }
    }

    public int solution(int n, int[][] computers) {
        boolean[] visited = new boolean[n];

        int answer = 0;

        for(int i = 0; i < n; i++) {
            if(!visited[i]) {
                answer++;
                dfs(i, computers, visited);
            }
        }

        return answer;
    }
}

정답!

코드 구현

import java.util.Queue;
import java.util.LinkedList;

class Solution {
    public void bfs(int node, int[][] computers, boolean[] visited) {
        Queue<Integer> queue = new LinkedList<>();

        queue.offer(node);
        visited[node] = true;

        while(!queue.isEmpty()) {
            node = queue.poll();

            for(int i = 0; i < computers[node].length; i++) {
                if(node == i) {
                    continue;
                } else if(computers[node][i] == 1 && visited[i] != true) {
                    queue.offer(i);
                    visited[i] = true;
                }
            }
        }
    }

    public int solution(int n, int[][] computers) {
        boolean[] visited = new boolean[n];

        int answer = 0;

        for(int i = 0; i < computers.length; i++) {
            if(visited[i] == false) {
                answer++;
            }

            bfs(i, computers, visited);
        }

        return answer;
    }
}

배우게 된 점

처음으로 BFS를 직접 구현해 보았다.

답안을 보지 않고 했더니, BFS만 구현하는데 2시간이나 걸렸다.

익숙해지도록 연습을 많이 해야겠다.

DFS는 생각보다 훨씬 빠르게 구현했다. 10분 정도 걸린 것 같다.

DFS가 BFS보다 구현하기 쉬운 걸까?

20. Valid Parentheses

1. 올바른 괄호를 구해야 한다.
2. 괄호는 소, 중, 대 괄호 다 가능하다.
3. 괄호는 같은 종류의 괄호로 열리고 닫혀야 한다.
4. 괄호 안의 괄호가 열린 후 닫히지 않은 채로 존재하면 안 된다.
5. 괄호가 올바른지 올바르지 않은 지를 true와 false로 판단하여 return한다.

예시 ( )⇒ 올바른 괄호 ( [ ] ) ⇒ 올바른 괄호 ( [ ) ] ⇒ 올바르지 않은 괄호

접근 방법

1. 앞에 열린 괄호가 없는 상태에서 닫힌 괄호가 들어오는 경우에 false를 return 해야 한다.
2. 올바른 괄호 내부에 있는 괄호가 올바르지 않은 경우 false 를 return 한다.
3. 괄호 한 쌍이 서로 다른 종류로 이루어져 있는 경우 false를 return 한다.
4. 이 외의 경우 전부 true 를 return 한다.

실패한 풀이

각 괄호의 종류 별로 open 과 close 를 판단할 boolean 타입 변수를 선언한다. → 기본 값은 true로 한다.

괄호가 열리면 false 를 삽입한다. 괄호가 닫히면 true 를 삽입한다. → 괄호가 닫힌 경우 다른 종류의 괄호 변수 값을 확인한다. → 다른 종류의 괄호 변수가 전부 true 가 아니라면, 즉시 false 를 return 한다. → 다른 종류의 괄호 변수가 전부 true 이면 계속 탐색을 진행한다.

탐색이 끝난 후에 모든 괄호 변수가 true 이면 true 를 return 한다. 더 생각을 해봤지만 위의 방법으로는 괄호 내부의 괄호를 판단할 수 없을 것 같다. 다른 방법이 떠오르지 않아 답안을 보기로 했다.

아래는 실패한 코드이다. 괄호 내부의 괄호에서 판단이 되지 않아 실패했다.

class Solution {
    public boolean isValid(String s) {
        boolean bigBracket = false, midBracket = false, smallBracket = false;
        int bigCount = 0, midCount = 0, smallCount = 0;

        for(int i = 0; i < s.length(); i++) {
            if(s.charAt(i) == '[' || s.charAt(i) == ']') {
                bigCount += s.charAt(i) == '[' ? 1 : -1;
            } else if(s.charAt(i) == '{' || s.charAt(i) == '}') {
                midCount += s.charAt(i) == '{' ? 1 : -1;
            } else {
                smallCount += s.charAt(i) == '(' ? 1 : -1;
            }
        }

        bigBracket = bigCount == 0 ? true : false;
        midBracket = midCount == 0 ? true : false;
        smallBracket = smallCount == 0 ? true : false;

        return bigBracket == true && midBracket == true && smallBracket == true ? true : false;
    }
}

답안 확인한 후 적용한 풀이

답안은 Stack을 사용했다.

열린 괄호를 만나면, 스택에 해당 괄호와 같은 종류의 닫힌 괄호를 저장한다.

닫힌 괄호를 만나면, 가장 최근에 스택에 저장한 값을 반환하여 비교한다. → 같으면 삭제하고, 다르면 false 를 return 한다.

마지막에는 isEmpty() 를 사용하여 비어 있으면 성공적으로 탐색을 마친 것이므로 true 를 반환하도록 한다.

코드 구현

class Solution {
    public boolean isValid(String s) {
        Deque<Character> stack = new ArrayDeque<>();

        for(int i = 0; i < s.length(); i++) {
            if(s.charAt(i) == '(') {
                stack.push(')');
            } else if(s.charAt(i) == '{') {
                stack.push('}');
            } else if(s.charAt(i) == '[') {
                stack.push(']');
            } else if(!stack.isEmpty() && stack.peek() == s.charAt(i)) {
                stack.pop();
            } else {
                return false;
            }
        }

        return stack.isEmpty();
    }
}

배우게 된 점

Stack을 응용하는 법을 알게 되었다.

문제 파악

완주하지 못한 선수

마라톤 선수들이 마라톤에 참여했다.

단 한 명을 제외하고는 모두 완주했다.

마라톤에 참여한 선수들의 이름이 담긴 배열 participant과, 완주한 선수들의 이름이 담긴 배열 completion이 주어진다.

완주하지 못한 선수의 이름을 return하라.

입력

출력

접근 방법

배열의 정렬을 이용한 풀이(현재 풀이)

문자열도 정렬을 할 수 있을까? → 문자열도 Arrays.sort를 이용해서 정렬이 가능하다.

문자열 정렬을 확인했으니 이 문제는 간단하게 풀 수 있을 것 같다.

주어진 입력은 규칙이 있다.

참가자와 완주자에는 단 한 명의 이름이 없다는 것 외에는 동일하다.

그럼 두 배열을 오름차순으로 정렬시킨 후 서로 비교해서 없는 사람을 찾으면 된다.

하지만 여기엔 반례가 있다.

두 배열에는 길이가 1만큼 차이가 있으며, 완주하지 못한 사람이 가장 마지막에 있을 경우가 그 예이다.

그에 대해선 if로 조건을 처리해주면 될 것이다.

문제 알고리즘 구현 순서

1. 두 배열을 정렬한다.
   • 정렬이 되면 두 배열은 같은 순서와 같은 값을 가질 것이다.
   • 참가자와 완주자 명단은 한 명의 유무를 제외하고는 동일하기 때문이다.
2. for 반복문을 하나 생성하고 두 배열을 비교한다.
   • 완주한 선수 배열이 길이가 더 짧으니 완주한 선수 배열의 길이로 반복 횟수를 설정한다.
   • 순서를 정렬했으니, 순차적으로 비교해도 값은 일치할 것이다.
   • 중간에 일치하지 않는 경우가 바로 완주하지 못한 선수의 이름이다.
   • 만약 일치하지 않는 경우를 찾지 못 하고 반복문이 끝난다면, 참여 선수 배열의 마지막 값이 완주하지 못한 선수의 이름이 된다.

시간 복잡도: O(n log n) → 정렬의 시간 복잡도이다.

HashMap을 이용한 풀이(찾아본 다른 풀이) → 시간 복잡도 측면에서 좀 더 효율적이다.

두 배열을 순차적으로 꺼내면서 나온 선수들의 이름을 카운트 하는 방식은 어떨까?

HashMap에 Key값으로 선수의 이름을 넣고, Value값으로 선수의 이름이 나온 횟수를 카운트 하자.

그 후 다시 반복문을 돌리면서 나온 선수의 이름을 차감하면 혼자만 값이 다른 선수가 완주하지 못한 선수가 된다.

import java.util.HashMap;

class Solution {
    public String solution(String[] participant, String[] completion) {
        HashMap<String, Integer> hashmap = new HashMap<>();

        for(String name : participant) {
            hashmap.put(name, hashmap.getOrDefault(name, 0) + 1);
        }

        for(String name : completion) {
            hashmap.put(name, hashmap.get(name) - 1);
        }

        for(String name : hashmap.keySet()) {
            if(hashmap.get(name) != 0) {
                return name;
            }
        }

        return "";
    }
}

HashMap<String, Integer> hashmap = new HashMap<>(); → HashMap 선언부이다. key를 String 타입으로, value를 Integer 타입으로 선언했다.

for(String name : participant) → particiant의 값을 하나씩 꺼내어 name에 넣는다.

hashmap.put(name, hashmap.getOrDefault(name, 0) + 1);
→ hashmap.getOrDefault(name, 0) + 1 → name key가 HashMap에 있으면 그 key의 value값을 반환한다. 없으면 0을 반환한다. 이후 1을 증가시킨다. → hashmap.put() → 위에서 나온 값을 HashMap의 key 값이 일치하는 곳에 저장한다.

for(String name : completion) → completion의 값을 하나씩 꺼내어 name에 넣는다.

hashmap.get(name) - 1 → HashMap에서 name key에 해당하는 value 값을 가져온다. 가져온 값에는 1을 차감한다.

hashmap.put(name, hashmap.get(name) - 1); → 위에서 나온 값을 다시 name key에 일치하는 value 값에 넣는다.

for(String name : hashmap.keySet()) → HashMap의 key값들을 추려서 Set<String>형태로 변환한다. → 그 후 name에 하나씩 저장한다.

if(hashmap.get(name) != 0) return name → name의 값과 일치하는 HashMap의 key가 가지고 있는 value 값이 0이 아니면, 해당 name을 return한다.

return ""; → 컴파일 에러 방지용 return

시간 복잡도: O(n)

코드 구현

import java.util.Arrays;

class Solution {
    public String solution(String[] participant, String[] completion) {
        String answer = "";

        Arrays.sort(participant);
        Arrays.sort(completion);

        for(int i = 0; i < completion.length; i++) {
            if(participant[i].equals(completion[i]) == false) {
                return participant[i];
            }
        }

        return participant[participant.length - 1];
    }
}

배우게 된 점

문자열 배열도 정렬이 가능하다는 사실을 알았다.

HashMap의 기본적인 사용법에 대해 익힐 수 있었다.

class Parent {
    String field1;
    void method1() {
        System.out.println("부모의 메소드1");
    }
    void method2() {
        System.out.println("부모의 메소드2");
    }
}

class Child extends Parent {
    String field2;
    void method3() {
        System.out.println("자식의 메소드3");
    }
}

public class ChildExample {
    public static void main(String[] args) {
        Parent parent = new Child();

        parent.field2 = "yyy";
        parent.method3();
    }
}

해당 코드를 실행하려 하면 field2와 method3에 대해서 Symbol을 찾을 수 없다는 에러가 나온다.

이는 즉, field2와 method3를 찾을 수 없다는 뜻이다.

이유가 뭘까?

정답은 Parent parent = new Child(); 이 한 줄에 있다.

해당 코드를 살펴보면, Parent 로 부모 타입의 참조 변수를 생성했기 때문에 Child 클래스에만 있는 멤버(필드 혹은 메서드)에 접근할 수 없기 때문이다.

부모 타입으로 참조 변수를 생성했으면 자식 클래스의 객체 인스턴스를 생성하더라도 부모 타입에 있는 필드와 메서드만 사용할 수 있다.

하지만 현재 코드에서는 field2와 method3가 자식 클래스에만 있기 때문에 찾을 수 없다는 에러가 발생하게 되는 것이다.

해당 코드처럼 자식 클래스에만 있는 필드와 메서드를 사용하려면, 강제 타입 변환을 해줘야 한다.

class Parent {
    String field1;

    void method1() {
        System.out.println("부모의 메소드1");
    }
    void method2() {
        System.out.println("부모의 메소드2");
    }
}

class Child extends Parent {
    String field2;

    void method3() {
        System.out.println("자식의 메소드3");
    }
}

public class ChildExample {
    public static void main(String[] args) {
        Parent parent = new Child();
        Child child = (Child) parent; // 강제 타입 변환

        parent.field2 = "yyy";
        parent.method3();
    }
}

위 코드와 같이 Child child = (Child) parent; 코드를 한 줄 추가해주면, parent 참조 변수가 Child 타입 참조 변수로 강제 변환 되어 Child에만 있는 필드와 메서드를 사용할 수 있게 된다.

혹은 다음과 같이 코드를 수정해도 된다.

class Parent {
    String field1;
    String field2;

    void method1() {
        System.out.println("부모의 메소드1");
    }
    void method2() {
        System.out.println("부모의 메소드2");
    }
    void method3() {
        System.out.println("부모의 메소드3");
    }
}

class Child extends Parent {
    String field2;

    void method3() {
        System.out.println("자식의 메소드3");
    }
}

public class ChildExample {
    public static void main(String[] args) {
        Parent parent = new Child();

        parent.field2 = "yyy";
        parent.method3();
    }
}

위와 같이 코드를 수정하면 Child 클래스는 부모 클래스인 Parent 클래스에서 필드와 메소드를 상속 받아 다시 정의한 것이기 때문에 타입 변환 없이 그대로 사용할 수 있게 된다.

이 때 부모 클래스에 있는 필드나 메서드를 그대로 자식 클래스에서 가져와 다시 정의하는 것을 재정의라고 하며 오버라이딩(Overriding)이라고 부른다.

이때 재정의된 필드나 메서드에 @Override 어노테이션을 붙이기도 한다.

그러면 생성자의 호출 순서는 어떻게 될까?

생성자의 호출 순서를 알기 전에 생성자가 무엇인지 알아야 한다.

생성자란?

생성자는 클래스의 인스턴스가 생성될 때 호출되는 특별한 메서드이다.

생성자의 이름은 클래스 이름과 같아야 하며, 반환 타입은 없다.

• 생성자는 new 키워드를 통해 객체를 생성할 때 자동으로 호출된다.

Parent parent = new Child(); // new Child()에서 Child()가 생성자이다.

• 클래스에 생성자를 정의하지 않으면, 자바는 컴파일할 때 자동으로 기본 생성자를 제공하게 된다.

→ 생성자의 매개변수가 없으며, 내부 코드가 없는 몸체만 제공한다.

클래스간의 상속이 이루어질 때, 생성자에도 호출 순서가 있다.

생성자는 항상 부모 생성자가 먼저 실행되며, 그 후에 자식 생성자가 실행된다.

우리는 자바 코드에서 종종 이런 코드를 볼 수 있다.

Parent parent = new Child();

이 코드를 뜯어 보면, Parent 타입으로 참조 변수를 선언하고, 참조 변수의 명을 parent로 정의했다. 그리고 new 연산자를 통해 Child()라는 생성자를 호출하고 있다. Child는 Child 클래스의 생성자이다.

정리하자면 Parent 타입 참조 변수 parent에 Child() 생성자를 호출하여 초기화 하고 있는 것이다.

우리는 Child() 생성자를 호출했기에 Child() 생성자가 먼저 실행될 것이라고 생각하기 쉽다.

하지만 Java는 컴파일 될 때 항상 부모 클래스의 생성자를 먼저 실행시킨다.

예시

class Parent {
    Parent() {
        System.out.println("부모 생성자");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("자식 생성자");
    }
}

public class ParentTest {
    public static void main(String[] args) {
        Parent p = new Child();
    }
}

위 코드를 실행시키게 되면,

부모 생성자
자식 생성자

위와 같은 결과가 나온다.

이 코드의 결과로 부모 생성자가 먼저 실행된다는 것을 알 수 있다.

원리는 이렇다.

자식 클래스 생성자에는 위 코드와 같이 super()를 적지 않을 수도 있다.

여기서 super()란 부모 클래스의 메소드를 호출하는 키워드이다.

하지만 자바는 컴파일 될 시 자식 클래스에 super() 가 없으면 자동으로 생성해서 실행하기 때문에 항상 부모 클래스의 생성자가 먼저 실행되게 되는 것이다.

하지만 이런 생각이 들 수도 있다.

코드에서 new Child()로 자식 클래스의 생성자를 호출했으니 자식 클래스 생성자가 먼저 실행된 것 아닌가요?

좀 헷갈릴 수 있는 부분이지만 답은 아니다 이다.

이유는 호출과 실행의 차이점에 있다.

호출과 실행은 비슷한 개념이지만 서로 다른 의미를 가지고 있다.

1, 호출

호출은 메서드나 생성자, 함수 등을 실행하라고 요청하는 것을 말한다. 다시 말해 “해당 코드를 실행해!”라고 컴퓨터에게 알려주는 동작인 것이다. 즉, 실행하는 것이 아닌 실행하라고 명령하는 신호인 것이다.

2. 실행

실행은 호출된 메서드나 생성자 내부의 코드가 실제로 실행되는 과정을 말한다. 호출이 일어난 뒤, 그 메서드나 생성자 안에 있는 코드가 한 줄씩 순차적으로 실행되는 것이다.

따라서 코드로 살펴보면,

class Parent {
    Parent() {
        System.out.println("부모 생성자");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("자식 생성자");
    }
}

public class ParentTest {
    public static void main(String[] args) {
        Parent p = new Child();
    }
}

위 코드에서 new Child() 부분은 Child 생성자를 실행하라고 호출한 것이다.

그래서 컴퓨터가 실행하려고 Child 생성자를 봤더니, 이는 Parent 클래스에서 상속받은 클래스의 생성자인 것이다.

컴퓨터는 Child 생성자의 첫 줄에 super()를 자동으로 생성하고, super()는 부모 클래스 생성자를 호출하는 키워드이기에 Child 생성자가 실행되지 않고 Parent 생성자를 먼저 실행한 것이다.

이후 Parent 생성자의 실행이 끝난 뒤에 다시 Child 생성자로 돌아가 Child 생성자를 실행하게 되는 것이다.

요약하자면,

1. Child() 생성자 호출
2. Child() 생성자 첫 줄에 super() 생성
3. super()에 의해 Parent() 실행
4. Parent() 실행
5. Child() 실행

그래서 아래와 같은 실행 결과가 나오는 것이다.

부모 생성자
자식 생성자

추가로 자식 클래스 생성자에 super 키워드를 작성할 때는 항상 자식 생성자의 첫 줄에 작성해야한다.

그렇지 않으면 super 키워드가 자식 클래스 생성자의 첫 줄에 없다는 에러를 마주하게 될 것이다.

주어진 예산 안에서 최대로 지원할 수 있는 부서의 수를 구하라.

접근 방법

정해진 예산 안에서 최대한 많은 부서에 지원을 해야한다.

그렇다면 부서별 요청 금액이 들어 있는 배열을 오름차순으로 정렬해준다.

그 후 예산 범위 보다 작거나 같을 때까지 앞에서 부터 차례대로 더한 후 더한 횟수를 반환하면 된다.

코드 구현

import java.util.Arrays;

class Solution {
    public int solution(int[] d, int budget) {
        int answer = 0;
        int sum = 0;

        Arrays.sort(d); // 주어진 배열을 오름차순 정렬

        // 배열을 하나씩 꺼내서 더한다.
        // 더한 값이 budget보다 커지면 반복문을 종료한다.
        // 문제에서는 budget보다 작거나 같은 경우를 원하기 때문에 더한 횟수에서 1을 뺀다.
        // budget보다 커진 경우는 한 번을 더 더했기 때문이다.
        for(int i = 0; i < d.length; i++) {
            sum += d[i];
            answer++;

            if(sum > budget) {
                answer--;
                break;
            }
        }

        return answer;
    }
}

배우게 된 점

Arrays.sort() 메소드를 배웠습니다.

해당 메소드를 배우기 전에는 코드록 정렬을 직접 구현해서 사용했었는데, Arrays.sort()를 알게 된 뒤 코드가 훨씬 간결해져서 좋았습니다.

예산

주어진 예산 안에서 최대로 지원할 수 있는 부서의 수를 구하라.

접근 방법

정해진 예산 안에서 최대한 많은 부서에 지원을 해야한다.

그렇다면 부서별 요청 금액이 들어 있는 배열을 오름차순으로 정렬해준다.

그 후 예산 범위 보다 작거나 같을 때까지 앞에서 부터 차례대로 더한 후 더한 횟수를 반환하면 된다.

코드 구현

import java.util.Arrays;

class Solution {
    public int solution(int[] d, int budget) {
        int answer = 0;
        int sum = 0;

        Arrays.sort(d); // 주어진 배열을 오름차순 정렬

        // 배열을 하나씩 꺼내서 더한다.
        // 더한 값이 budget보다 커지면 반복문을 종료한다.
        // 문제에서는 budget보다 작거나 같은 경우를 원하기 때문에 더한 횟수에서 1을 뺀다.
        // budget보다 커진 경우는 한 번을 더 더했기 때문이다.
        for(int i = 0; i < d.length; i++) {
            sum += d[i];
            answer++;

            if(sum > budget) {
                answer--;
                break;
            }
        }

        return answer;
    }
}

배우게 된 점

Arrays.sort() 메소드를 배웠습니다.

해당 메소드를 배우기 전에는 코드록 정렬을 직접 구현해서 사용했었는데, Arrays.sort()를 알게 된 뒤 코드가 훨씬 간결해져서 좋았습니다.

주어진 숫자 중 서로 다른 3개를 골라 더했을 때, 나올 수 있는 소수의 개수를 구하라.

접근 방법

• 현재 코드에 적용된 방법

소수란 무엇인가?

• 1과 자기 자신 만을 약수로 갖는 수이다.

  
  

소수를 판단하는 방법

1. 단순히 2부터 n-1까지 나머지 연산자로 연산한다.

    - 이 과정에서 나머지가 0이 되는 수가 없다면 이 수는 소수인 것이다.

   → 하지만 이 방법은 2부터 n-1까지 반복 연산을 수행하므로 비효율적이다. 시간복잡도는 O(n-2)

• 소수의 특성

어떤 수 N은 작은 수 * 큰 수 형태로 이루어져 있다.

N의 제곱근 보다 큰 수로 N을 나눈다면 그 몫은 이미 이전에 걸러져 있다.

24 = 2 × 12  
24 = 3 × 8  
24 = 4 × 6  
24 = 6 × 4 ← 이 부분부터는 순서만 바뀐다.
24 = 8 × 3
24 = 12 × 2

24의 제곱근 = 약 4.89

4.89보다 큰 24의 약수는 6

하지만 6은 이미 4 * 6에서 걸러진다.

즉, 24의 제곱근 미만인 수만 확인하면 된다.

11이 소수인지 판별하려면?

11의 제곱근 = 약 3.31

3.31 미만인 수 1, 2

소수는 1과 자기 자신 만을 약수로 갖는 수이므로 1은 제외

2는 11의 약수인가? → ❌

그러므로 11은 소수이다.

Java에서 제곱근을 구하려면 Math.sqrt()를 사용하면 된다.

어떤 수 N이 소수인지 판별하려면?

for(int i = 2; i < Math.sqrt(N); i++) {
    if(N % i == 0) {
        break;
    }
}

이런 식으로 작성하면 된다.

• 서로 다른 숫자 3개를 뽑아야 한다.
  1. 배열의 시작 인덱스부터 3개의 숫자를 순차적으로 뽑는다.
     • arr[0], arr[1], arr[2]
       
  2. 그 후 arr[2]만 순차적으로 증가 시켜 더한다.
  3. arr[2]가 배열의 끝(arr[n])에 도달했다면, arr[1]과 arr[2]의 인덱스를 1 증가시킨다.
     • arr[0], arr[2], arr[3]
       
  4. 2 - 3의 과정을 반복한다.
  5. 최종적으로 아래와 같은 형태가 되면 arr[0]의 인덱스를 1 증가시킨다.
     • arr[0], arr[n-1], arr[n] → arr[1], arr[2], arr[3]
       
  6. 그 후 2 - 5의 과정을 반복하면 주어진 배열에서 3가지의 수를 더하는 모든 경우의 수를 얻을 수 있다.

위의 방법을 사용하여 코드를 작성해 본다.

→ 3중 for문을 사용하자.

for문의 시간 복잡도: O(n)

2중 for문의 시간 복잡도: O(n^2)

3중 for문의 시간 복잡도: O(n^3)

문제의 제한사항

배열의 길이 n은 3 ≤ n ≤ 50이다.

최악의 경우 50^3까지 반복할 수 있다.

50^3 < 10^8 이므로, 3중 for문을 사용해도 된다.

• 재귀 함수를 이용한 풀이

    class Solution {
        int answer = 0;
  
        public int solution(int[] nums) {
            comb(nums, 0, 0, 0); // 조합 뽑기 시작
                                                     // 최초에는 아직 아무것도 뽑지 않았으므로 0, 0, 0
            return answer;
        }
  
            // count = 뽑은 횟수
            // sum = 뽑은 수의 합
            // start = 다음에 뽑을 인덱스
        void comb(int[] nums, int count, int sum, int start) {
                // 3회 뽑았으면 소수 판별 시작
            if(count == 3) {
                    // 합이 소수이면 개수 카운트
                if(isPrime(sum)) {
                    answer++;
                }
  
                return;
            }
  
                    // 반복문을 통한 재귀호출로 다음 숫자 뽑기
            for(int i = start; i < nums.length; i++) {
                comb(nums, count + 1, sum + nums[i], i + 1);
            }
        }
  
        boolean isPrime(int n) {
            if(n < 2) {
                return false;
               }
  
            for(int i = 2; i <= Math.sqrt(n); i++) {
                if(n % i == 0) return false;
            }
  
            return true;
        }
    }

• 에라토스테네스의 체를 사용한 풀이

  • 에라토스테네스의 체

    주어진 자연수 N이 소수이기 위한 필요 충분 조건은 N이 N의 제곱근보다 크지 않은 어떤 소수로도 나눠지지 않는다.

    어떠한 수1과 어떠한 수2를 나누면 몫이 발생하게 되는데 몫과 나누는 수, 둘 중 하나는 반드시 해당 수의 제곱근 이하이기 때문이다.

    → 즉, 2부터 시작해서, 그 수의 배수를 모두 지워나간다. 그러면 남아 있는 수는 모두 소수가 된다.

    예시: 1부터 30까지의 모든 소수 구하기

    2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

    1. 2는 소수니까 제외한 후 2의 배수를 모두 제거한다.

       2 3 X 5 X 7 X 9 X 11 X 13 X 15 X 17 X 19 X 21 X 23 X 25 X 27 X 29 X

    2. 3은 소수이므로 제외한 후 3의 모든 배수를 제거한다.

       2 3 X 5 X 7 X X X 11 X 13 X X X 17 X 19 X X X 23 X 25 X X X 29 X

    3. 5도 소수이므로 제외한 후 5의 모든 배수를 제거한다.

       2 3 X 5 X 7 X X X 11 X 13 X X X 17 X 19 X X X 23 X 25 X X X 29 X

       최종적으로 소수만 남게 되었다.

    코드로 구현해보자

      import java.util.Arrays;
    
      public class SieveExample {
          public static void main(String[] args) {
              int n = 30; // 1부터 30까지 소수 찾기
              boolean[] isPrime = new boolean[n + 1];
              Arrays.fill(isPrime, true); // 일단 전부 소수라고 가정
              isPrime[0] = isPrime[1] = false; // 0과 1은 소수가 아님
    
              for (int i = 2; i * i <= n; i++) {
                  if (isPrime[i]) {
                      for (int j = i * i; j <= n; j += i) {
                          isPrime[j] = false; // i의 배수 제거
                      }
                  }
              }
    
              System.out.println("소수 목록:");
              for (int i = 2; i <= n; i++) {
                  if (isPrime[i]) {
                      System.out.print(i + " ");
                  }
              }
          }
      }

    Arrays.fill(배열명, 값)

    → 배열 내부의 모든 값을 하나로 초기화 하는 메소드.

    Arrays.fill(isPrime, true); → isPrime의 모든 인덱스의 값을 true로 초기화 함.

    소수는 true, 소수가 아닌 수는 false → 초기에는 모든 수를 소수로 가정!

    for문을 i * i부터 시작하는 이유

    i * i 이전의 값은 이미 지워졌기 때문이다.

    예시

    i = 2일 때:

    • 2의 배수는 4, 6, 8, 10, 12, ...

      i = 3일 때:

    • 3의 배수는 6, 9, 12, 15, ...

      3 * 3 이전의 수는 3 * 2이다.

      하지만 이전에 2의 배수를 지우는 과정에서 2 * 3으로 인해 지워졌다.

      4일 경우를 확인해 보면, 4 * 2, 4 * 3은 2와 3의 배수를 지우는 과정인 2 * 4, 3 * 4에서 지워졌다.

      5일 경우를 확인해 보면, 5 * 4, 5 * 3, 5 * 2 는 모두 2와 3과 4의 배수를 지우는 과정인 2 * 5, 3 * 5, 4 * 5 에서 지워졌다.

    • 결론*

      i * i 미만의 값은 모두 이전 과정에서 지워졌기 때문에 반복문의 시작 값을 i * i로 설정한다.

    • 시간복잡도: O(Nlog(log N))*

**✅위의 에라토스테네스의 체를 가지고 코드를 구현해보자**

```java
import java.util.Arrays;

class Solution {
    public int solution(int[] nums) {
        int answer = 0;

        // 0. 오름차순 정렬
        Arrays.sort(nums);

        // 1. 합의 최댓값 구하기
        int n = nums.length;
        int maxSum = nums[n - 1] + nums[n - 2] + nums[n - 3];

        // 2. 에라토스테네스의 체로 소수 판별 배열 만들기
        boolean[] isPrime = new boolean[maxSum + 1];
        Arrays.fill(isPrime, true); // 일단 전부 소수라고 가정
        isPrime[0] = isPrime[1] = false; // 0과 1은 소수가 아님

        for (int i = 2; i * i <= maxSum; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j <= maxSum; j += i) {
                    isPrime[j] = false;
                }
            }
        }

        // 3. 3개 조합 만들기 + 소수 판별
        for (int i = 0; i < n - 2; i++) {
            for (int j = i + 1; j < n - 1; j++) {
                for (int k = j + 1; k < n; k++) {
                    int sum = nums[i] + nums[j] + nums[k];
                    if (isPrime[sum]) {
                        answer++;
                    }
                }
            }
        }

        return answer;
    }
}

```

**기존 코드와 시간 복잡도 비교**

1. 기존 코드
    - 3중첩 for문: **O(N^3)**
    - 소수 판별: **O(√N)**

1. 에라토스테네스의 체를 사용한 코드
    - 3중첩 for문: **O(N^3)**
    - 에라토스테네스의 체 만들기: **O(Nlog(log N))**
    - 소수 판별: **O(1)**

**N이 커지게 되면 에라토스테네스의 체 방식이 시간 복잡도가 효율적이다.**

코드 구현

class Solution {
    public int solution(int[] nums) {
        int answer = 0;
        int sum = 0;

        for(int i = 0; i < nums.length - 2; i++) {
            for(int j = i + 1; j < nums.length - 1; j++) {
                for(int k = j + 1; k < nums.length; k++) {
                    sum = nums[i] + nums[j] + nums[k];

                    boolean isBreak = false;

                    // 소수 판단
                    for(int l = 2; l <= Math.sqrt(sum); l++) {
                        if(sum % l == 0) {
                            isBreak = true;
                            break;
                        }
                    }

                    if(!isBreak) {
                        answer++;
                    }
                }
            }
        }

        return answer;
    }
}

배우게 된 점

1. Math.sqrt() 사용법에 대해 알 수 있었다.
2. 소수를 판별하는 에라토스테네스의 체를 익힐 수 있었다.
3. 문제에 접근하고 떠올린 방법을 코드로 구현하는 능력을 기를 수 있었다.

객체의 메모리 주소를 참조하는 타입이다. 배열, 열거, 클래스, 인터페이스 타입이 있다.

기본 타입과 참조 타입의 차이

기본 타입 기본타입으로 선언된 변수는 값 자체를 저장한다. 스택에 값 자체를 저장한다.

참조 타입 참조 타입으로 선언된 변수는 객체가 생성된 메모리 주소를 저장한다. 스택에 객체가 생성된 메모리 주소를 저장한다. 해당 메모리 주소를 참조하여 힙에 저장된 객체에 접근한다.

메모리 사용 영역

메소드, 힙, 스택 영역

• JVM은 운영체제에서 할당받은 메모리 영역을 메소드 영역, 힙 영역, 스택 영역으로 구분해서 사용

• 메소드 영역

  • 바이트코드 파일을 읽은 내용이 저장되는 영역

• 힙 영역

  • 객체가 생성되는 영역, 객체의 번지는 메소드 영역과 스택 영역의 상수와 변수에서 참조

• 스택 영역

  • 메소드를 호출할 때마다 생성되는 프레임이 저장되는 영역

참조 타입 변수의 ==, != 연산

• ==, != 연산자는 객체의 번지를 비교해 변수의 값이 같은지, 다른지를 조사한다.
• 번지가 같다면 동일한 객체를 참조하는 것이고, 다르다면 다른 객체를 참조하는 것이다.

public static void main(String[] args) {
    int[] arr1; //배열 변수 arr1 선언
    int[] arr2; //배열 변수 arr2 선언
    int[] arr3; //배열 변수 arr3 선언

    arr1 = new int[] { 1, 2, 3 }; //배열 { 1, 2, 3 }을 생성하고 arr1 변수에 대입
    arr2 = new int[] { 1, 2, 3 }; //배열 { 1, 2, 3 }을 생성하고 arr2 변수에 대입
    arr3 = arr2; //배열 변수 arr2의 값을 배열 변수 arr3에 대입

    System.out.println(arr1 == arr2); // arr1과 arr2 변수가 같은 배열을 참조하는지 검사
    System.out.println(arr2 == arr3); // arr2와 arr3 변수가 같은 배열을 참조하는지 검사
}

결과

false
true

arr1과 arr2는 각각 선언 되었기에 서로 다른 객체의 메모리 주소를 참조한다. arr3에 arr2를 대입했기 때문에 arr3는 arr2의 메모리 주소를 참조하고 있다. 따라서 arr2와 arr3는 true가 나온다.

문자열 타입

문자열은 Stirng 객체로 생성 String은 메모리 주소값을 참조하는 참조형 변수이다.

String 값을 비교하려면 equals로 비교해야한다.

String name1 = "홍길동"
String name2 = "홍길동"
String name3 = new String("홍길동");

name1 == name2
name1 == name3

결과

true
false

String은 서로 같은 값을 가지고 있으면 같은 참조로 본다.

하지만 String name3는 new String("홍길동"); 으로 값은 같지만 새로 선언했기에 다른 참조를 가지고 있다.

그럼 참조가 아닌 값을 비교하려면 어떻게 해야할까?

name1.equals(name3);로 값 자체가 같은지 비교하면 된다.

public static void main(String[] args) {
    String strVar1 = "홍길동";
    String strVar2 = "홍길동";

    if(strVar1 == strVar2) {
        System.out.println("strVar1과 strVar2는 참조가 같음");
    } else {
        System.out.println("strVar1과 strVar2는 참조가 다름");
    }

    if(strVar1.equals(strVar2)) {
        System.out.println("strVar1과 strVar2는 문자열이 같음");
    }

    String strVar3 = new String("홍길동");
    String strVar4 = new String("홍길동");

    if(strVar3 == strVar4) {
        System.out.println("strVar3과 strVar4는 참조가 같음");
    } else {
        System.out.println("strVar3과 strVar4는 참조가 다름");
    }

    if(strVar3.equals(strVar4)) {
        System.out.println("strVar3과 strVar4는 문자열이 같음");
    }
}

결과

strVar1과 strVar2는 참조가 같음
strVar1과 strVar2는 문자열이 같음
strVar3과 strVar4는 참조가 다름
strVar3과 strVar4는 문자열이 같음

문자열 추출

• charAt() 메소드로 문자열에서 매개값으로 주어진 인덱스의 문자를 추출한다.

String subject = "자바 프로그래밍";

char charValue = subject.charAt(3);

System.out.print(charValue);

결과

프

charAt은 문자열의 앞에서부터 위치를 매겨 특정 위치의 문자를 추출할 수 있다. 0부터 시작한다.

문자열 길이 문자열에서 문자의 개수를 얻고 싶다면 length() 메소드를 사용한다. 공백도 포함해서 계산된다.

문자열 대체 replace() 메소드는 기존 무자열은 그대로 두고, 대체한 새로운 문자열을 리턴한다.

String oldStr = "자바 프로그래밍";
String newStr = oldStr.replace("자바", "JAVA");

System.out.print(newStr);

결과

JAVA 프로그래밍

문자열 잘라내기 문자열에서 특정 위치의 문자열을 잘라내어 가져오고 싶다면 substring(시작 위치, 종료 위치) 메소드를 사용한다.

종료 위치의 -1까지 잘라낸다. 종료 위치를 작성하지 않으면 시작 위치부터 문자열의 끝까지 잘라낸다.

String ssn = "880815-1234567";
String firstNum = ssn.substring(0, 6);
String secondNum = ssn.substring(7);

System.out.println(firstNum);
System.out.print(secondNum);

결과

880815
1234567

문자열 찾기 문자열에서 특정 문자열의 위치를 찾고자 할 때는 indexOf() 사용한다.

String subject = "자바 프로그래밍";

int index = subject.indexOf("프로그래밍");
// 포함되어 있지 않으면 -1을 리턴한다.

포함 여부 결과만 알고 싶은 경우 constains() 메소드를 사용한다.

boolean result = subject.contains("프로그래밍");

문자열 분리 구분자가 있는 여러 개의 문자열을 분리할 때 split() 메소드를 사용한다.

String board = "번호,제목,내용,글쓴이";

String[] arr = board.split(",");

배열 타입

배열의 선언 방법

자료형 배열명 = new 자료형[배열의 크기]; // 동적 초기화
자료형[] 배열명 = {값1, 값2, 값3, ...}; // 정적 초기화

배열의 길이 배열의 길이는 문자열과 비슷하게 length로 확인한다.

문자열과는 ()의 유무의 차이가 있다 문자열: length(); 배열: length;

릴리즈 노트는 소프트웨어 개발 과정에서 정리된 릴리즈 정보를 최종 사용자인 고객과 공유하기 위한 문서이다.

Header(머릿말) 릴리즈 노트 이름, 소프트웨어 이름, 릴리즈 버전, 릴리즈 날짜, 릴리즈 노트 날짜, 릴리즈 노트 버전 등

개요 소프트웨어 및 변경사항 전체에 대한 간략한 내용

목적 해당 릴리즈 버전에서의 새로운 기능이나 수정된 기능의 목록과 릴리즈 노트의 목적에 대한 간략한 개요

문제 요약 수정된 버그에 대한 간략한 설명 또는 릴리즈 추가 항목에 대한 요약

재현 항목 버그 발견에 대한 과정 설명

수정/개선 내용 버그를 수정/개선한 내용을 간단히 설명

사용자 영향도 사용자가 다른 기능들을 사용하는데 있어 해당 릴리즈 버전에서의 기능 변화가 미칠 수 있는 영향에 대한 설명

SW 지원 영향도 해당 릴리즈 버전에서의 기능 변화가 다른 응용 프로그램들을 지원하는 프로세스에 미칠 수 있는 영향에 대한 설명

노트 SW/HW 설치 항목, 업그레이드, 소프트웨어 문서화에 대한 참고 항목

면책 조항 회사 및 소프트웨어와 관련하여 참조할 사항

연락처 사용자 지원 및 문의 응대를 위한 연락처 정보

디지털 저작권 관리의 구성 요소

클리어링 하우스(Clearing House) 저작권에 대한 사용 권한, 라이선스 발급, 암호화된 키 관리, 사용량에 따른 결제 관리 등을 수행하는 곳

콘텐츠 제공자(Contents Provider) 콘텐츠를 제공하는 저작권자

패키저(Packager) 콘텐츠를 메타 데이터와 함께 배포 가능한 형태로 묶어 암호화하는 프로그램

콘텐츠 분배자(Contents Distributor) 암호화된 콘텐츠를 유통하는 곳이나 사람

콘텐츠 소비자(Customer) 콘텐츠를 구매해서 사용하는 주체

DRM 컨트롤러(DRM Controller) 배포된 콘텐츠의 이용 권한을 통제하는 프로그램

보안 컨테이너(Security Container) 콘텐츠 원본을 안전하게 유통하기 위한 전자적 보안 장치

디지털 저작권 관리의 기술 요소

암호화(Encryption) 콘텐츠 및 라이선스를 암호화하고 전자 서명을 할 수 있는 기술

키 관리(Key Management) 콘텐츠를 암호화한 키에 대한 저장 및 분배 기술

암호화 파일 생성 콘텐츠를 암호화된 콘텐츠로 생성하기 위한 기술

식별 기술(Identification) 콘텐츠에 대한 식별 체계 표현 기술

저작권 표현(Right Expression) 라이선스의 내용 표현 기술

정책 관리(Policy Management) 라이선스 발급 및 사용에 대한 정책 표현 및 관리 기술

크랙 방지(Tamper Resistance) 크랙에 의한 콘텐츠 사용 방지 기술

인증(Authentication) 라이선스 발급 및 사용의 기준이 되는 사용자 인증 기술

소프트웨어 설치 메뉴얼

• 소프트웨어 설치 메뉴얼은 개발 초기에서부터 적용된 기준이나 사용자가 소프트웨어를 설치하는 과정에 필요한 내용을 기록한 설명서와 안내서이다.
• 설치 메뉴얼은 사용자 기준으로 작성한다.
• 설치 시작부터 완료할 때까지의 전 과정을 빠짐없이 순서대로 설명한다.
• 설치 과정에서 표시될 수 있는 오류 메시지 및 예외 상황에 관한 내용을 별도로 분류하여 설명한다.

소프트웨어 패키징의 형상 관리

• 형상 관리(SCM; Software Configuration Management)는 개발 과정에서 소프트웨어의 변경 사항을 관리하기 위해 개발된 일련의 활동이다.
• 형상 관리는 소프트웨어 개발의 전 단계에 적용되는 활동이며, 유지보수 단계에서도 수행된다.
• 형상 관리는 소프트웨어 개발의 전체 비용을 줄이고, 개발 과정의 여러 방해 요인이 최소화되도록 보증하는 것을 목적으로 한다.
• 대표적인 형상 관리 도구에는 Git, SVN, CVS 등이 있다.

형상 관리 기능

형상 식별 형상 관리 대상에 이름과 관리 번호를 부여하고, 계층(Tree) 구조로 구분하여 수정 및 추적이 용이하도록 하는 작업

버전 제어 소프트웨어 업그레이드나 유지 보수 과정에서 생성된 다른 버전의 형상 항목을 관리하고, 이를 위해 특정 절차와 도구(Tool)를 결합시키는 작업

형상 통제 식별된 형상 항목에 대한 변경 요구를 검토하여 현재의 기준선(Base Line)이 잘 반영될 수 있도록 조정하는 작업

형상 검사 기준선의 무결성을 평가하기 위해 확인, 검증, 검열 과정을 통해 공식적으로 승인하는 작업

형상 기록 형상의 식별, 통제, 감사 작업의 결과를 기록/관리하고 보고서를 작성하는 작업

소프트웨어의 버전 등록 관련 주요 기능

저장소(Repository) 최신 버전의 파일들과 변경 내역에 대한 정보들이 저장되어 있는 곳

가져오기(Import) 버전 관리가 되고 있지 않은 아무것도 없는 저장소에 처음으로 파일을 복사함

체크아웃(Check-Out) 프로그램을 수정하기 위해 저장소에서 파일을 받아옴

체크인(Check-In) 체크아웃 한 파일의 수정을 완료한 후 저장소의 파일을 새로운 버전으로 갱신함

커밋(Commit) 체크인을 수행할 때 이전에 갱신된 내용이 있는 경우에는 충돌(Conflict)을 알리고 diff 도구를 이용해 수정한 후 갱신을 완료함

동기화(Update) 저장소에 있는 최신 버전으로 자신의 작업 공간을 동기화함

소프트웨어 버전 관리 도구 - 분산 저장소 방식

• 분산 저장소 방식은 버전 관리 자료가 하나의 원격 저장소와 분산된 개발자 PC의 지역 저장소에 함께 저장되어 관리되는 방식이다.
• 지역 저장소에서 버전 관리가 가능하므로 원격 저장소에 문제가 생겨도 지역 저장소의 자료를 이용하여 작업할 수 있다.
• 종류: Git, GNU arch, DCVS, Bazarr, Mercurial, TeamWare, Bitkeeper, Plastic SCM 등

빌드 자동화 도구

• 빌드 자동화 도구는 빌드를 포함하여 테스트 및 배포를 자동화하는 도구이다.
• 애자일과 같은 지속적인 통합 개발 환경에서 유용하게 활용된다.
• 빌드 자동화 도구 종류: Jenkins, Gradle, Ant, Maven, Make 등

Gradle

• Gradle은 Groovy를 기반으로 한 오픈 소스 형태의 자동화 도구이다.
• 안드로이드 앱 개발 환경에서 사용된다.
• 안드로이드뿐만 아니라 플러그인을 설정하면, JAVA, C/C++, Python 등의 언어도 빌드할 수 있다.
• Groovy를 사용해서 만든 DSL(Domain Specific Language)을 스크립트 언어로 사용한다.

메시 네트워크(Mesh Network)

• 차세대 이동통신, 홈네트워킹, 공공 안정 등 특수 목적을 위한 새로운 방식의 네트워크 기술이다.
• 대규모 디바이스의 네트워크 생성에 최적화되어 있다.

피코넷(PICONET) 여러 개의 독립된 통신장치가 블루투스 기술이나 UWB 통신 기술을 사용하여 통신망을 형성하는 무선 네트워크 기술이다.

애드 혹 네트워크(Ad-hoc Network)

• 재난 현장과 같이 별도의 고정된 유선망을 구축할 수 없는 장소에서 모바일 호스트(Mobile Host)만을 이용하여 구성한 네트워크이다.
• 망을 구성한 후 단기간 사용되는 경우나 유선망을 구성하기 어려운 경우에 적합하다.

파장 분할 다중화(WDM; Wavelength Division Multiplexing) 광섬유를 이용한 통신기술의 하나로, 파장이 서로 다른 복수의 신호를 보냄으로써 여러 대의 단말기가 동시에 통신 회선을 사용할 수 있도록 하는 기술이다.

소프트웨어 정의 데이터센터(SDDC; Software Defined Data Center)

• 데이터 센터의 모든 자원을 가상화하여 인력의 개입 없이 소프트웨어 조작만으로 관리 및 제어되는 데이터 센터를 의미한다.
• 컴퓨팅, 네트워킹, 스토리지, 관리 등을 모두 소프트웨어로 정의한다.

개방형 링크드 데이터(LOD, Linked Open Data)

• Linked Data와 Open Data의 합성어로, 누구나 사용할 수 있도록 웹상에 공개된 연계 데이터를 의미한다.
• 웹상에 존재하는 데이터를 개별 URI(인터넷 식별자)로 식별하고, 각 URI에 링크 정보를 부여함으로써 상호 연결된 웹을 지향하는 모형이다.

IoT(Internet of Things, 사물 인터넷) 정보 통신 기술을 기반으로 실세계와 가상 세계의 다양한 사물들을 인터넷으로 서로 연결하여 진보된 서비스를 제공하기 위한 서비스 기반 기술이다.

클라우드 컴퓨팅(Cloud Computing) 각종 컴퓨팅 자원을 중앙 컴퓨터에 두고 인터넷 기능을 갖는 단말기로 언제 어디서나 인터넷을 통해 컴퓨터 작업을 수행할 수 있는 가상화된 환경을 의미한다.

USN(Ubiquitous Sensor Network)

• 각종 센서로 수집한 정보를 무선으로 수집할 수 있도록 구성한 네트워크이다.
• 필요한 모든 것에 RFID 태그를 부착하고, 이를 통하여 사물의 인식정보는 물론 주변의 환경정보까지 탐지하여 이를 네트워크에 연결하여 정보를 관리한다.

SSO(Single Sign On)

• 한 번의 로그인으로 개인이 가입한 모든 사이트를 이용할 수 있게 해주는 시스템이다.
• 개인정보를 각 사이트마다 일일이 기록해야 하던 불편함을 해소할 수 있다.
• 기업에서는 회원에 대한 통합관리가 가능해 마케팅을 극대화시킬 수 있다.

SW 관련 신기술

블록체인(Blockchain) P2P(Peer-to-Peer) 네트워크를 이용하여 온라인 금융 거래 정보를 온라인 네트워크 참여자(Peer)의 디지털 장비에 분산 저장하는 기술이다.

메시업(Mashup) 웹에서 제공하는 정보 및 서비스를 이용하여 새로운 소프트웨어나 서비스, 데이터베이스 등을 만드는 기술로, 다수의 정보원이 제공하는 콘텐츠를 조합하여 하나의 서비스로 제공하는 웹 사이트 또는 애플리케이션을 말한다.

서비스 지향 아키텍처(SOA; Service Oriented Architecture)

• 기업의 소프트웨어 인프라인 정보시스템을 공유와 재사용이 가능한 서비스 단위나 컴포넌트 중심으로 구축하는 정보기술 아키텍처이다.
• SOA 기반 애플리케이션 구성 계층: 표현, 업무 프로세스, 서비스 중간, 애플리케이션, 데이터 저장 계층

디지털 트윈(Digital Twin)

• 현실속의 사물을 소프트웨어로 가상화한 모델이다.
• 실제 물리적인 자산을 소프트웨어로 가상화함으로써 실제 자산의 특성에 대한 정확한 정보를 얻을 수 있다.

그레이웨어(Grayware) 소프트웨어를 제공하는 입장에서는 악의적이지 않은 유용한 소프트웨어라고 주장할 수 있지만 사용자 입장에서는 유용할 수도 있고 악의적일 수도 있는 애드웨어, 트랙웨어, 기타 악성 코드나 악성 공유웨어를 말한다.

양자 암호키 분배(QKD; Quantum Key Distribution)

• 양자 통신을 위해 비밀키를 분배하여 관리하는 기술이다.
• 두 시스템이 암호 알고리즘 동작을 위한 비밀키를 안전하게 공유하기 위해 양자 암호키 분배 시스템을 설치하여 운용하는 방식으로 활용된다.

서비스형 소프트웨어(SaaS; Software as a Service) 소프트웨어의 여러 기능 중에서 사용자가 필요로 하는 서비스만 이용할 수 있도록 한 소프트웨어이다.

시멘틱 웹(Semantic Web) 컴퓨터가 사람을 대신하여 정보를 읽고 이해하고 가공하여 새로운 정보를 만들어 낼 수 있도록 이해하기 쉬운 의미를 가진 차세데 지능형 웹을 의미한다.

리치 인터넷 애플리케이션(RIA; Rich Internet Application) 플래시 애니메이션 기술과 웹 서버 애플리케이션 기술을 통합하여 기존 HTML 보다 역동적이고 인터랙티브한 웹 페이지를 제공하는 신개념의 플래시 웹 페이지 제작 기술이다.

HW 관련 신기술

앤 스크린(N-Screen) N개의 서로 다른 단말기에서 동일한 콘텐츠를 자유롭게 이용할 수 있는 서비스이다.

신 클라이언트 PC

• 하드디스크나 주변장치 없이 기본적인 메모리만 갖추고 서버와 네트워크로 운용되는 개인용 컴퓨터이다.
• 서버 기반 컴퓨팅과 관계가 깊다.

엠디스크(M-DISC; Millennial DISC)

• 한 번의 기록만으로 자료를 영구 보관할 수 있는 광저장장치이다.
• 디스크 표면의 무기물층에 레이저를 이용해 자료를 조각해서 기록한다.

멤스(MEMS; Micro-Electro Mechanical Systems) 초정밀 반도체 제조 기술을 바탕으로 센서, 액추에이터 등 기계 구조를 다양한 기술로 미세 가공하여 전기기계적 동작을 할 수 있도록 한 초미세 장치이다.

멤리스터(Memristor) 메모리와 레지스터의 합성어로 전류의 방향과 양 등 기존의 경험을 모두 기억하는 특별한 소자이다.

트러스트존 기술(TrustZone Technology) 하나의 프로세서 내에 일반 애플리케이션을 처리하는 일반 구역과 보안이 필요한 애필리케이션을 처리하는 보안 구역으로 분할하여 관리하는 하드웨어 기반의 보안 기술이다.

DB 관련 신기술

하둡(Hadoop)

• 오픈 소스를 기반으로 한 분산 컴퓨팅 플랫폼이다.
• 더그 커팅과 마이크 캐퍼렐라가 개발했으며, 구글의 맵리듀스 엔진을 사용하고 있다.
• 일반 PC급 컴퓨터들로 가상화된 대형 스토리지를 형성하고 그 안에 보관된 거대한 데이터 세트를 병렬로 처리할 수 있도록 개발된 자바 소프트웨어 프레임워크이다.

맵리듀스(MapReduce)

• 대용량 데이터를 분산 처리하기 위한 목적으로 개발된 프로그래밍 모델이다.
• 흩어져 있는 데이터를 연관성 있는 데이터 분류로 묶는 Map 작업을 수행한 후 중복 데이터를 제거하고 원하는 데이터를 추출하는 Reduce 직업을 수행한다.

데이터 마이닝(Data Mining) 대량의 데이터를 분석하여 데이터에 내재된 변수 사이의 상호관계를 규명하여 일정한 패턴을 찾아내는 기법이다.

타조(Tajo) 오픈 소스 기반 분산 컴퓨팅 플랫폼인 아파치 하둡 기반의 분산 데이터 웨어하우스 프로젝트이다.

OLAP(Online Analytical Processing)

• 다차원으로 이루어진 데이터로부터 통계적인 요약 정보를 분석하여 의사결정에 활용하는 방식이다.
• OLAP 연산: Roll-up, Drill-down, Drill though, Drillacross, Pivoting, Slicing, Dicing

브로드 데이터(Broad Data) 다양한 채널에서 소비자와 상호 작용을 통해 생성된 것으로, 기업 마케팅에 있어 효율적이고 다양한 데이터이며, 이전에 사용하지 않거나 알지 못했던 새로운 데이터나 기존 데이터에 새로운 가치가 더해진 데이터이다.

• 운영체제(OS; Operating System)는 컴퓨터 시스템의 자원들을 효율적으로 관리하며, 사용자가 컴퓨터를 편리하고 효과적으로 사용할 수 있도록 환경을 제공하는 여러 프로그램 모임이다.
• 컴퓨터 사용자와 컴퓨터 하드웨어 간의 인터페이스로 동작하는 시스템 소프트웨어의 일종이다.
• 프로세서, 기억장치, 입/출력장치, 파일 및 정보 등의 자원을 관리한다.

UNIX

• UNIX는 1960년대 AT&T 벨 연구소, MIT, General Electric이 공동 개발한 운영체제이다.
• 시분할 시스템을 위해 설계된 대화식 운영체제이다.
• 대부분 C 언어로 작성되어 있어 이식성이 높으며 장치, 프로세스 간의 호환성이 높다.
• 트리 구조의 파일 시스템을 갖는다.

UNIX 시스템의 구성

커널

• UNIX의 가장 핵심적인 부분으로 하드웨어를 보호하고, 프로그램과 하드웨어 간의 인터페이스 역할을 담당한다
• 프로세스 관리, 기억장치 관리, 파일 관리, 입/출력 관리, 프로세스간 통신, 데이터 전송 및 변환 등 여러가지 기능을 수행한다.

쉘

• 사용자의 명령어를 인식하여 프로그램을 호출하고 명령을 수행하는 명령어 해석기이다.
• 시스템과 사용자 간의 인터페이스를 담당한다.

Android

• Android는 구글 사에서 개발한 리눅스 커널 기반의 개방형 모바일 운영체제이다.
• 모든 코드가 공개된 개방형 소프트웨어이다.
• 자바와 코틀린으로 애플리케이션을 작성한다.

기억장치 - 배치 전략

• 배치 전력은 새로 반입되는 프로그램이나 데이터를 주기억장치의 어디에 위치시킬 것인지를 결정하는 전략이다.
• 최초 적합(First Fit): 프로그램이나 데이터가 들어갈 수 있는 크기의 빈 영역 중에서 첫 번쨰 분할 영역에 배치시키는 방법
• 최적 적합(Best Fit): 프로그램이나 데이터가 들어갈 수 있는 크기의 빈 영역 주에서 단편화를 가장 작게 남기는 분할 영역에 배치시키는 방법
• 최악 적합(Worst Fit): 프로그램이나 데이터가 들어갈 수 있는 크기의 빈 영역 중에서 단편화를 가장 많이 남기는 분할 영역에 배치시키는 방법

가상기억장치 구현 기법

페이징(Paging) 기법

• 가상기억장치에 보관되어 있는 프로그램과 주기억장치의 영역을 동일한 크기로 나눈 후 나눠진 프로그램을 동일하게 나눠진 주기억장치의 영역에 적재시켜 실행하는 기법이다.
• 프로그램을 일정한 크기로 나눈 단위를 페이지라고 하고, 페이지 크기로 일정하게 나누어진 주기억장치의 단위를 페이지 프레임이라고 한다.

세그먼테이션(Segmentation)기법

• 가상기억장치에 보관되어 있는 프로그램을 다양한 크기의 논리적인 단위로 나눈 후 주기억장치에 적재시켜 실행시키는 기법이다.
• 프로그램을 배열이나 함수 등과 같은 논리적인 크기로 나눈 단위를 세그먼트라고 하며, 각 세그먼트는 고유한 이름과 크기를 갖는다.

페이지 교체 알고리즘

• 페이지 부재(Page Fault)가 발생하면 가상기억장치에서 필요한 페이즈를 찾아 주기억장치에 적재해야 하는데, 이때 주기억장치의 모든 페이지 프레임이 사용중이면 어떤 페이지 프레임을 선택하여 교체할 것인지를 결정하는 기법이 페이지 교체 알고리즘이다.
• 종류: OPT, FIFO, LRU, LFU, NUR, SCR 등

FIFO

FIFO(First In First Out)는 각 페이지가 주기억장치에 적재될 때마다 그떄의 시간을 기억시켜 가장 먼저 들어와서 가장 오래 있었던 페이지를 교체하는 기법이다.

LRU

LRU(Least Recently Used)는 최근에 가장 오랫동안 사용하지 않은 페이지를 교체하는 기법이다.

LFU

• LFU(Least Frequently Used)는 사용 빈도가 가장 적은 페이지를 교제하는 기법이다.
• 활발하게 사용되는 페이지는 사용 횟수가 많아 교체되지 않고 사용된다.

Locality

• Locality(국부성, 지역성, 구역성, 국소성)는 프로세스가 실행되는 동안 주기억장치를 참조할 때 일부 페이지만 집중적으로 참조하는 성질이 있다는 이론이다.
• 스래싱을 방지하기 위한 워킹 셋 이론의 기반이 되었다.
• 시간 구역성(Temporal Locality): 프로세스가 실행되면서 하나의 페이지를 일정 시간 동안 집중적으로 액세스하는 현상
• 공간 구역성(Spatial Locality): 프로세스 실행 시 일정 위치의 페이지를 집중적으로 액세스하는 현상

워킹 셋

• 워킹 셋(Working Set)은 프로세스가 일정 시간 동안 자주 참조하는 페이지들의 집합이다.
• 자주 참조되는 워킹 셋을 주기억장치에 상주시킴으로써 페이지 부재 및 페이지 교체 현상이 줄어들어 프로세스의 기억장치 사용이 안정된다.

스래싱

• 스래싱(Thrashing)은 프로세스의 처리 시간보다 페이지 교체에 소요되는 시간이 더 많아지는 현상이다.
• 다중 프로그래밍 시스템이나 가상기억장치를 사용하는 시스템에서 하나의 프로세스 수행 과정 중에 자주 페이지 부재가 발생함으로써 나타나며, 전테 시스템의 성능이 저하된다.

프로세스 상태 전이

프로세스 상태 전이는 프로세스가 시스템 내에 존재하는 동안 프로세스의 상태가 변하는 것을 의미한다.

프로세스 상태 전이 관련 용어

Dispatch(디스패치) 준비 상태에서 대기하고 있는 프로세스 중 하나가 프로세서를 할당받아 실행 상태로 전이되는 과정이다.

Wake Up 입/출력 작업이 완료되어 프로세스가 대기 상태에서 준비 상태로 전이 되는 과정이다.

Spooling(스풀링) 입/출력장치의 공유 및 상대적으로 느린 입/출력장치의 처리 속도를 보완하고 다중 프로그래밍 시스템의 성능을 향상시키기 위해 입/출력할 데이터를 직접 입/출력장치에 보내지 않고 나중에 한꺼번에 입/출력하기 위해 디스크에 저장하는 과정이다.

스레드

• 스레드(Thread)는 시스템의 여러 자원을 할당받아 실행하는 프로그램의 단위 또는 프로세스 내에서의 작업 단위로 사용된다.
• 프로세스의 일부 특성을 갖고 있기 때문에 경량(Light Weight) 프로세스라고도 한다.

SJF

• SJF(Shortest Job First, 단기 작업 우선)는 준비상태 큐에서 기다리고 있는 프로세스들 중에서 실행 시간이 가장 짧은 프로세스에게 먼저 CPU를 할당하는 기법이다.
• 가장 적은 평균 대기 시간을 제공하는 최적 알고리즘이다.

HRN

• HRN(Highest Response-ratio Next)은 대기 시간과 서비스(실행) 시간을 이용하는 기법이다.
• 우선순위를 계산하여 그 숫자가 가장 높은 것부터 낮은 순으로 우선순위가 부여된다.
• 우선순위 계산식
• 우선순위 계산식 = (대기 시간 + 서비스 시간)/서비스 시간*

RR

• RR(Round Robin)은 각 프로세스를 시간 할당량(Time Slice, Quantum) 동안만 실행한 후 실행이 완료되지 않으면 다음 프로세스에게 CPU를 넘겨주는 기법이다.
• 시분할 시스템을 위해 고안된 방식으로, 할당되는 시간의 크기가 작으면 작은 프로세스들에게 유리하다.
• 할당되는 시간이 클 경우 FCFS 기법과 같아지고, 할당되는 시간이 작을 경우 문맥 교환 및 오버헤드가 자주 발생되어 요청된 작업을 신속히 처리할 수 없다.

SRT

• SRT(Shortest Remaining Time)는 현재 실행주인 프로세스의 남은 시간과 준비상태 큐에 새로 도착한 프로세스의 실행 시간을 비교하여 가장 짧은 실행 시간을 요구하는 프로세스에게 CPU를 할당하는 기법이다.
• 시분할 시스템에 유용하며, 준비상태 큐에 있는 각 프로세스의 실행 시간을 추적하여 보유하고 있어야하므로 오버헤드가 증가한다.

환경변수

• 환경변수란 시스템 소프트웨어의 동작에 영향을 미치는 동적인 값들의 모임을 의미한다.
• 환경 변수는 변수명과 값으로 구성된다.
• Windows에서 set을 입력하면 모든 환경 변수와 값을 출력한다.
• UNIX나 LINUX에서는 setm envm printenv, setenv 중 하나를 입력하면 모든 환경 변수와 값을 표시한다.

UNIX/LINUX 기본 명령어

chmod

• chmod는 파일의 보호 모드를 설정하여 파일의 사용 허가를 지정하는 UNIX 명렁어이다.
• 8진법 숫자를 이용한 방법으로도 파일의 보호 모드를 설정할 수 있다.

IP 주소

IP 주소(Internet Protocol Address)는 인터넷에 연결된 모든 컴퓨터 자원을 구분하기 위한 고유한 주소이다.

IPv4(Internet Protocol version 4)

• 8비트씩 4부분, 총 32비트로 구성되어 있다.
• 네트워크 부분의 길이에 따라 A 클래스에서 E 클래스까지 총 5단계로 구성되어 있다.

IPv6(Internet Protocol version 6)

• IPv6은 현재 사용하고 있는 IP 주소 체계인 IPv4의 주소 부족 문제를 해결하기 위해 개발되었다.
• 16비트씩 8부분, 총 128비트로 구성되어 있다.
• 각 부분을 16진수로 표현하고, 콜론(:)으로 구분한다.
• 인증성, 기밀성, 데이터 무결성의 지원으로 보안 문제를 해결할 수 있다.

IPv6의 주소 체계

• 유니캐스트(Unicast): 단일 송신자와 단일 수신자 간의 통신(1 대 1)
• 멀티캐스트(Multicast): 단일 송신자와 다중 수신자 간의 통신(1 대 다)
• 애니캐스트(Anycast): 단일 송신자와 가장 가까이 있는 단일 수신자 간의 통신(1 대 1)

서브네팅(Subnetting)의 예

192.168.1.0/24 네트워크를 FLSM 방식을 이용하여 3개의 Subnet으로 나누시오. (단 IP Subnet-Zero를 적용했다.)

192.168.1.0/24 네트워크의 서브넷 마스크는 1의 개수가 24개 즉 C 클래스에 속하는 네트워크이다.

서브넷 마스크를 Subnet으로 나눌 때는 서브넷 마스크가 0인 부분, 즉 마지막 8비트를 이용하면 된다.

Subnet으로 나눌 때 "3개의 Subnet으로 나눈다"는 것처럼 네트워크가 기준일 떄는 왼쪽을 기준으로 나눌 네트워크 수에 필요한 비트를 할당하고 나머지 비트로 호스트를 구성하면 된다.

3개의 Subnet으로 구성하라 했으니 8비트 중 3을 표현하는데 필요한 2비트를 제외하고 나머지 6비트를 호스트로 구성하면 된다.

호스트 ID가 6Bit로 설정되었고, 문제에서 FLSM(Fixed Length Subnet Mask), 즉 고정된 크기로 주소를 할당하라고 했으므로 3개의 네트워크에 64개(2의 6승 = 64)씩 고정된 크기로 할당하면 다음과 같다.

OSI 참조 모델

OSI 참조 모델은 다른 시스템 간의 원활한 통신을 위해 ISO(국제표준화기구)에서 제안한 통신 규약(Protocol)이다.

물리 계층(Physical Layer) 전공에 필요한 두 장치 간의 실제 접속과 절단 등 기계적, 전기정, 기능적, 절차적 특성에 대한 규칙을 정의한다.

데이터 링크 계층(Data Link Layer) 두 개의 인접한 개방 시스템들 간에 신뢰성 있고 효율적인 정보 전송을 할 수 있도록 시스템 간 연결 설정과 유지 및 종료를 담당한다.

네트워크 계층(Network Layer, 망계층) 개방 시스템들 간의 네트워크 연결을 관리하는 기능과 데이터의 교환 및 중계 기능을 한다.

전송 계층(Transport Layer) 논리적 안정과 균일한 데이터 전송 서비스를 제공함으로써 종단 시스템(End-to-End) 간에 투명한 데이터 전송을 가능하게 한다.

세션 계층(Session Layer) 송/수신 측 간의 관련성을 유지하고 대화 제어를 담당한다.

표현 계층(Presentation Layer) 서로 다른 데이터 표현 형태를 갖는 시스템 간의 상호 접속을 위해 필요한 계층으로, 코드 변환, 데이터 암호화, 데이터 압축, 구문 검색 등의 기능을 수행한다.

응용 계층(Application Layer) 사용자(응용 프로그램)가 OSI 환경에 접근할 수 있도록 서비스를 제공한다.

네트워크 관련 장비

라우터(Router)

• 브리지와 같이 LAN과 LAV의 연결 기능에 데이터 전송의 최적 경로를 선택하는 기능이 추가된 장치이다.
• 서로 다른 LAN 또는 LAN과 WAN을 연결하는 기능도 한다.

리피티(Repeater) 거리가 증가할수록 감쇠하는 디지털 신호의 장거리 전송을 위해 수신한 신호를 재생시키거나 출력 전압을 높여 전송하는 장치이다.

허브(Hub)

• 한 사무실이나 가까운 거리의 컴퓨터들을 연결하는 장치로, 각각의 회선을 통합하여 관리한다.
• 신호 증폭 기능을 하는 리피터의 역할을 포함한다.

브리지(Bridge)

• LAN과 LAN을 연결하거나 LAN 안에서의 컴퓨터 그룹을 연결하는 장치이다.
• 브리지를 이용한 서브넷(Subnet) 구성 시 전송 가능한 회선 수는 브리지가 n개일 때, n(n-1)/2개이ek.

게이트웨이(Gateway)

• OSI 전 계층의 프로토콜 구조가 다른 네트워크를 연결하는 장치이다.
• LAN에서 다른 네트워크에 데이터를 보내거나 다른 네트워크로부터 데이터를 받아들이는 출입구 역할을 한다.

프로토콜

• 프로토콜은 서로 다른 기기들 간의 데이터 교환을 원활하게 수행할 수 있도록 표준화시켜 놓은 통신 규약이다.
• 1965년 톰 마릴이 컴퓨터가 메시지를 전달하고, 메시지가 제대로 도착했는지 확인하며, 도착하지 않았을 경우 메시지를 재전송하는 일련의 방법을 '기술적 은어'란 뜻의 프로토콜로 정의한 바 있다.

프로토콜의 기본 요소

• 구문(Syntax): 전송하고자 하는 데이터의 형식, 부호화, 신호 레벨 등을 규정함
• 의미(Semantics): 두 기기 간의 효율적이고 정확한 정보 전송을 위한 협조 사항과 오류 관리를 위한 제어 정보를 규정함
• 시간(Timing): 두 기기 간의 통신 속도, 메시지의 순서 제어 등을 규정함

패킷 교환 방식

패킷 교환 방식은 메시지를 일정한 길이의 패킷으로 잘라서 전송하는 방식으로, 가상 회선 방식과 데이터그램 방식이 있다.

가상 회선 방식

• 단말기 상호 간에 논리적인 가상 통신 회선을 미리 설정하여 송신지와 수신지 사이의 연결을 확립한 후에 설정된 경로를 따라 패킷들을 순서적으로 운반하는 방식이다.
• 정보 전송 전에 제어 패킷에 의해 경로가 설정된다.
• 모든 패킷은 같은 경로로 발생 순서대로 전송된다. 즉, 패킷의 송/수신 순서가 같다.

데이터그램 방식

• 연결 경로를 설정하지 않고 인접한 노드들의 트래픽(전송량) 상황을 감안하여 각각의 패킷들을 순서에 상관없이 독립적으로 운반하는 방식이다.
• 패킷마다 전송 경로가 다르므로, 패킷은 목적지의 완전한 주소를 가져야 한다.
• 순서에 상관없이 여러 경로를 통해 도착한 패킷들은 수신 측에서 순서를 재정리한다.

TCP/IP

TCP/IP(Transmission Control Protocol/Internet Protocol)는 인터넷에 연결된 서로 다른 기종의 컴퓨터들이 데이터를 주고받을 수 있도록 하는 표준 프로토콜이다.

TCP(Transmission Control Protocol)

• OSI 7계층의 전송 계층에 해당한다.
• 가상 회선 방식을 기반으로 하는 양방향 연결 서비스를 제공한다.
• 패킷의 다중화, 순서 제어, 오류 제어, 흐름 제어 기능을 제공한다.

IP(Internet Protocol)

• OSI 7계층의 네트워크 계층에 해당한다.
• 데이터그램 방식을 기반으로 하는 비연결형 서비스를 제공한다.
• 패킷의 분해/조립, 주소 지정, 경로 선택 기능을 제공한다.

UDP

• UDP(User Datagram Protocol)는 데이터 전송 전에 연결을 설정하지 않는 비연결형 서비스를 제공하는 프로토콜이다.
• TCP에 비해 상대적으로 단순한 헤더 구조를 가지므로, 오버헤드가 적고, 흐름 제어나 순서 제어가 없어 전송 속도가 빠르다.
• 실시간 전송에 유리하며, 신뢰성보다는 속도가 중요시되는 네트워크에서 사용된다.

L2TP

• L2TP(Layer 2 Tunneling Protocol)는 PPTP와 L2F의 기술적 장점들을 결합하여 만들어진 터널링 프로토콜이다.
• 데이터 링크 계층에서 구현되는 터널링 프로토콜이다.
• 자체적으로 암호화 및 인증 기능을 제공하지 않아 다른 보안 프로토콜과 함께 사용되는 경우가 많다.
• PPTP(Point to Point Tunneling Protocol): PPP패킷을 IP 패킷에 캡슐화하여 통과시키기 위한 터널링 프로토콜
• L2F(Layer 2 Forwarding): 인터넷을 통한 VPN(가상 사설망) 연결을 위해 개발된 터널링 프로토콜

ICMP

• ICMP(Internet Control Message Protocol, 인터넷 제어 메시지 프로토콜)는 IP와 조합하여 통신중에 발생하는 오류의 처리와 전송 경로 변경 등을 위한 제어 메시지를 관리하는 역할을 한다.
• 헤더는 8Byte로 구성된다.

ARP / RARP

ARP(Address Resolution Protocol, 주소 분석 프로토콜) 호스트의 IP 주소를 호스트와 연결된 네트워크 접속 장치의 물리적 주소(MAC Address)로 변환하는 기능을 수행하는 프로토콜이다.

RARP(Reverse Address Resolution Protocol) ARP와 반대로 물리적 주소를 IP 주소로 변환하는 기능을 수행하는 프로토콜로, 역순 주소 결정 프로토콜이라 불린다.

네트워크 구축

네트워크는 두 대 이상의 컴퓨터를 전화선이나 케이블 등으로 연결하여 자원을 공유하는 것을 말한다.

성형(Star, 중앙 집중형) 중앙에 중앙 컴퓨터가 있고, 이를 중심으로 단말장치들이 연결되는 중앙 짖ㅂ중식의 네트워크 구성 형태이다.

링형(Ring, 루프형) 컴퓨터와 단말장치들을 서로 이웃하는 것끼리 연결시킨 포인트 투 포인트9Point-to-Point) 방식의 구성 형태이다.

버스형(Bus) 한 개의 통신 회선에 여러 대의 단말장치가 연결되어 있는 형태이다.

계층형(Tree, 분산형) 중앙 컴퓨터와 일정 지역의 단말장치까지는 하나의 통신 회선으로 연결시키고, 이웃하는 단말장치는 일정 지역 내에 설치된 중간 단말장치로부터 다시 연결시키는 형태이다.

망형(Mesh)

• 모든 지점의 컴퓨터와 단말장치를 서로 연결한 형태로, 노드의 연결성이 높다.
• 모든 노드를 망형으로 연결하려면 노드의 수가 n개일 때, n(n-1)/2개의 회선이 필요하고 노드당 n-1개의 포트가 필요하다.

IEEE 802의 주요 표준 규격

IEEE 802는 KAN의 표준안이다.

IEEE 802의 주요 표준 규격

NAT

• NAT(Network Address Translation, 네트워크 주소 변환)은 한 개의 정식 IP 주소에 대량의 가상 사설 IP 주소를 할당 및 연결하는 기능이다.
• 한 개의 IP 주소를 사용해서 외부에 접속할 수 있는 노드는 어느 시점에서 한 개로 제한되는 문제가 있지만 IP 마스커레이드를 이용하여 해결할 수 있다.

IGP

IGP(Interior Gateway Protocol, 내부 게이트웨이 프로토콜)는 하나의 자율 시스템(AS) 내의 라우팅에 사용되는 프로토콜이다.

RIP(Routing Information Protocol)

• 현재 가장 널리 사용되는 라우팅 프로토콜로 거리 벡터 라우팅 프로토콜이라고도 불린다.
• 최단 경로 탐색에 Bellman-Ford 알고리즘을 사용한다.
• 소규모 동종의 네트워크(자율 시스템, AS) 내에서 효율적인 방법이다.

OSFP(Open Shortest Path First protocol)

• RIP의 단점을 해결하여 새로운 기능을 지원하는 인터넷 프로토콜로, 대규모 네트워크에서 많이 사용된다.
• 최단 경로 탐색에 다익스트라 알고리즘을 사용한다.

EGP / BGP

EGP(Exterior Gateway Protocol) 자율 시스템(AS) 간의 라우팅, 즉 게이트웨이 간의 라우팅에 사용되는 프로토콜이다.

BGP(Border Gateway Protocol)

• 자율 시스템(AS) 간의 라우팅 프로토콜로, EGP의 단점을 보완하기 위해 맘ㄴ들어진 프로토콜이다.
• 초기에 BGP 라우터들이 연결될 때에는 전체 경로 제어표(라우팅 테이블)를 교환하고, 이후에는 변화된 정보만을 교환한다.

흐름 제어

흐름 제어(Flow Control)란 네트워크 내의 원활한 흐름을 의해 송/수신 측 사이에 전송되는 패킷의 양이나 속도를 규제하는 기능이다.

정지-대기

• 수신 측의 확인 신호(ACK)를 받은 후에 다음 패킷을 전송하는 방식이다.
• 한 번에 하나의 패킷만을 전송할 수 있다.

슬라이딩 윈도우(Sliding Window)

• 확인 신호, 즉 수신 통지를 이용하여 송신 데이터의 양을 조절하는 방식이다.
• 수신 측의 확인 신호를 받지 않더라도 미리 정해진 패킷의 수만큼 연속적으로 전송하는 방식으로, 한 번에 여러개의 패킷을 전송할 수 있어 전송 효율이 좋다.
• 송신 측은 수신 측으로부터 확인 신호(ACK) 없이도 보낼 수 있는 패킷의 최대치를 미리 약속받는데, 이 패킷의 최대치가 윈도우 크기(Window Size)를 의미한다.

RAID

RADI(Redudeant Array of Independent Disk)는 2개 이상의 하드디스크로 디스크 배열을 구성하고, 파일을 구성하는 데이터 블록들을 서로 다른 디스크에 분산 저장하거나 다중화하는 저장 기술로, 구현된 기술에 따라 다음과 같이 레벨로 구분한다.

RAID 0

• 스트라이핑이라고 불린다.
• 디스크를 병렬로 연결하여 디스크의 개수만큼 용량과 속도가 배로 증가한다.
• 하나의 디스크만 손상되어도 전체 데이터가 파손 된다.

RAID 1

• 미러링이라고 불린다.
• 같은 데이터를 다른 디스크에 동일하게 복사하는 방식이다.

RAID 2 ~ 4

• 하나의 디스크에 오류 정정 부호를 비트, 바이트, 워드 단위로 저장하고, 나머지 디스크는 RAID 0과 같이 활용하여 안정성을 높인 모드이다.
• 하나의 디스크가 손상되어도 정상 가동이 가능하며 최소 3개의 디스크가 필요하다.

RAID 5

• 오류 정정 부호를 블록 단위로 여러 디스크에 분산 저장한 방식이다.
• 하나의 디스크가 손상되어도 정상 가동이 가능하며 최소 3개의 디스크가 필요하다.

RAID 6

• RAID 5와 원리는 같으나 오류 정정 부호 2개를 저장하는 방식이다.
• 두 개의 디스크가 손상되어도 정상 가동이 가능하며 최소 4개의 디스크가 필요하다.

Secure OS

• Secure OS는 기존의 운영체제에 내제된 보안 취약점을 해소하기 위해 보안 기능을 갖춘 커널을 이식하여 외부의 침입으로부터 시스템 자원을 보호하는 운영체제를 의미한다.
• 보안 커널은 보안 기능을 갖춘 커널을 의미하며, TCB를 기반으로 참조 모니터의 개념을 구현하고 집행한다.
• Secure OS의 보안 기능: 식별 및 인증, 임의적/강제적 접근통제, 객체 재사용 보호, 완전한 조정, 신뢰 경로, 감사 및 감사기록 축소 등

회복

• 회복(Recovery)은 트랜잭션들을 수행하는 도중 장애가 발생하여 데이터베이스가 손상되었을 때 손상되기 이전의 정상 상태로 복구하는 작업이다.
• 회복 기법의 종류: 연기 갱신 기법, 즉각 갱신 기법, 그림자 페이지 대체 기법, 검사점 기법

REDO / UNDO

REDO 데이터베이스가 비정상적으로 종료되었을 떄, 디스크에 저장된 로그를 분석하여 트랜잭션의 시작과 완료에 대한 기록이 있는 트랜잭션들의 작업을 재작업한다. 즉, 로그를 이용하여 해당 데이터 항목에 대해 이전 값을 이후 값으로 변경하는 연산이다.

UNDO 데이터베이스가 비정상적으로 종료되었을 떄, 디스크에 저장된 로그를 분석하여 트랜잭션의 시작에 대한 기록은 있지만 완료 기록은 없는 트랜잭션들이 작업한 변경 내용들을 모두 취소한다. 즉 로그를 이용하여 해당 데이터 항목에 대해 이후 값을 이전 값으로 변경하는 연산이다.

즉각 갱신 기법

• 즉각 갱신 기법은 트랜잭션이 데이터를 갱신하면 트랜잭션이 부분 완료되기 전이라도 즉시 실제 데이터베이스에 반영하는 방법이다.
• 장애가 발생하여 회복 작업할 경우를 대비하여 갱신된 내용들을 Log에 보관시킨다.
• Redo(재시도) Undo(취소) 모두 사용 가능하다.

로킹

• 로킹은 트랜잭션들이 어떤 로킹 단위를 액세스하기 전에 Lock을 요청해서 Lock이 허락되어야만 그 로킹 단위를 액세스할 수 있도록 하는 기법이다.
• 주요 데이터의 액세스를 상호 배타적으로 한다.

타임 스탬프 순서

• 타임 스탬프 순서는 트랜잭션과 트랜잭션이 읽거나 갱신한 데이터에 대해 트랜잭션이 실행을 시작하기 전에 시간표를 부여하여 부여된 시간에 따라 트랜잭션 작업을 수행하는 기법이다.
• 직렬성 순서를 결정하기 위해 트랜잭션 간의 처리 순서를 미리 선택하는 기법들 중에서 가장 보편적인 방법이다.

로킹 단위

• 로킹 단위는 병행제어에서 한꺼번에 로킹할 수 있는 객체의 크기를 의미한다.
• 데이터베이스, 파일, 레코드, 필드 등이 로킹 단위가 될 수 있다.
• 로킹 단위가 크면 로크 수가 작아 관리하기 쉽지만 병행성 수준이 낮아진다.
• 로킹 단위가 작으면 로크 수가 많아 관리하기 복잡해 오버헤드가 증가하지만 병행성 수준이 높아진다.

교착상태

• 교착상태(DeadLock)는 상호 배제에 의해 나타나는 문제점으로, 둘 이상의 프로세스들이 자원을 점유한 상태에서 서로 다른 프로세스가 점유하고 있는 자원을 요구하며 무한정 기다리는 현상을 의미한다.
• 교착상태 발생의 필요 충분 조건

교착상태의 해결 방법

예방 기법(Prevention)

• 교착상태가 발생하지 않도록 사전에 시스템을 제어하는 방법
• 교착상테 발생의 네 가지 조건 중엣 어느 하나르 제거함으로써 수행됨

회피 기법(Avoidance)

• 교착상태가 발생할 가능성을 배제하지 않고 교착상태가 발생하면 적절히 피해 나가는 방법
• 주로 은행원 알고리즘이 사용됨

발견 기법(Detection) 시스템에 교착상태가 발생했는지 점검하여 교착상태에 있는 프로세스와 자원을 발견하는 것

회복 기법(Recovery) 교착상태를 일으킨 프로세스를 종료하거나 교착상태의 프로세스에 할당된 자원을 선점하여 프로세스나 자원을 회복하는 것

타입 변수명; -> 변수가 생성됨. 변수를 선언한다. 자바는 변수에 들어갈 타입이 선언할 떄 결정된다.(정적타입핑)

타입 변수명 = 값; 변수는 선언 즉시 초기화하는 습관을 들이는 것이 좋다.

초기화되지 않은 변수는 쓰레기 값이 들어가 있다.

자바는 전역변수가 없다. 무조건 {} 안에 들어가야 한다.

int a = 10; // 이렇게 밖에 나와 있으면 안 된다.
public class VariableTest {

}

public class VariableTest {
    int a = 10; // 이렇게 내부에 들어와 있어야 한다.
}

클래스가 독립적으로 실행되기 위해선 main 함수가 필요하다. 만약 함수가 여러개인 경우 무조건 main()을 호출한다.

public class VariableTest {
    // java에서의 메인함수.
    // 함수가 여러개인 경우 메인함수부터 호출한다.
    public static void main(String[] args) {
        ...
    }

    public static void function1 {
        ...
    }

    public static void function2 {
        ...
    }

    public static void function3 {
        ...
    }
}

자바의 자료형 기본 4가지: 정수, 실수, 문자(단일), 논리

정수 : byte(1byte), short(2byte), int(4byte), long(8byte) () 안의 숫자는 해당 자료형의 byte 크기이다.

public class VariableTest {
    byte age = 127; // 변수는 소문자로 시작해야 한다.
    short year = 2025;
    int hit = 21000000;
    long money = 2200000000L; // 마지막에 L을 붙이지 않으면 Int형으로 인식한다.    
}

실수 : float(소수점 7자리, 4byte), double(소수점 15자리, 8byte)

public class VariableTest {
    float w = 70.5F; // float은 뒤에 F를 붙여야 한다.
    double h = 170.000000555;
}

문자(단일) : char

public class VariableTest {
    char gender = '여' // 문자는 '' 홀따옴표로 감싼다.
}

논리형 : boolean

public class VariableTest {
    boolean food = true;
    boolean eat = false;
}

문자열: String -> 대문자로 시작하는 이유는 클래스이기 때문이다.

public class VariableTest {
    String name = "김국민" // ""이중 따옴표로 감싸줘야 한다.

    // 여러줄을 입력할 때 사용한다.
    String plan = """
            나는
            훌륭한
            자바 개발자가 되고 싶다.
            """;
}

System: 부품 -> 컴퓨터 out: output 출력 장치, 기본은 모니터이다. in: input 입력장치, 기본은 키보드이다. print: 출력하라.

System.out.print -> 컴퓨터 모니터에 출력하라.

public class VariableTest {
    byte age = 127; // 변수는 소문자로 시작해야 한다.

    // +연산자가 하나라도 문자열이면 결과는 String(결합연산자)가 된다.
    System.out.print("내 나이는 " + age + "세야.");  
}

출력의 종류: print, println, printf

print -> 출력후 개행이 실행되지 않는다. println -> 출력후 개행을 실행한다. printf -> 출력 포맷을 정한다.

public class VariableTest {
    byte age = 127; // 변수는 소문자로 시작해야 한다.

    // 이 때 변수의 값을 받아주는 서식문자를 변수의 타입에 맞게 지정해야 한다.
    System.out.printf("내 나이는 %d세야!", age);
}

타입 변환

1. 기본형과 기본형이 아닌 것은 =(대입연산자로) 형변환이 불가능하다.
2. 문자열 변수에 들어있는 것을 기본형 변수에 바로 넣을 수 없다.
3. 기본형 변수에 들어있는 것을 문자열 변수에 바로 넣을 수 없다.

이 때는 아래의 함수를 써야한다.

• 문자를 숫자로 바꾸고 싶은 경우 String.valueOf(변환할 변수);

• 숫자를 문자로 바꾸고 싶은 경우 Integer.parsInt(변환 할 변수);

public class VariableTest {
    // byte를 숫자로 바꾸고 싶은 경우
    byte age = 127;
    int age2 = age; // <- 자동형변환

    byte age3 = (byte)age2; // 1byte <- 강제형변환 4byte

    // 문자를 숫자로 바꾸고 싶은 경우
    String data = "100";
    int num = data; // 기본형 <- 기본형X
    // 부품을 수정해줘야한다.
    int num = Integer.parseInt(data);

    String data2 = "11.11";
    double num2 = Double.parseDouble(data2);

    // 숫자를 문자열로 바꾸고 싶은 경우
    String data3 = String.valueOf(num2);
}

• 시스템에 침입한 후 침입 사실을 숨긴 채 백도어, 트로이목마를 설치하고ㅡ 원격 접근, 내부 사용 흔적 삭제, 관리자 권한 획득 등 주로 불법적인 해킹에 사용되는 기능들을 제공하는 프로그램들의 모음이다.
• 컴퓨터의 운영체제에서 실행 파일과 실행 중인 프로세스를 숨김으로써 운영체제 검사 및 백신 프로그램의 탐지를 피할 수 있다.

APT(Advanced Persistent Threats, 지능형 지속 위협)

다양한 IT 기술과 방식들을 이용해 조직적으로 특정 기업이나 조직 네트워크에 침투해 활동 거점을 마련한 뒤 때를 기다리면서 보안을 무력화시키고 정보를 수집한 다음 외부로 빼돌리는 형태의 공격이다.

무작위 대입 공격(Brute Force Attack)

암호화된 문서의 암호키를 찾아내기 위해 적용 가능한 모든 값을 대입하여 공격하는 방식이다.

큐싱(Qshing)

QR코드를 통해 악성 앱의 다운로드를 유도하거나 악성 프로그램을 설치하도록 하는 금융사기 기법의 하나로, QR코드와 개인정보 및 금융정보를 낚는다는 의미의 합성 신조어이다.

스미싱(Smishing)

문자 메시지를 이용해 사용자의 개인 신용 정보를 뺴내는 수법이다.

스피어 피싱(Spear Phishing)

사회 공학의 한 기법으로, 특정 대상을 선정한 후 그 대상에게 일반적인 이메일로 위장한 메일을 지속적으로 발송하여, 발송 메일의 본문 링크나 첨부된 파일을 클릭하도록 유도해 사용자의 개인 정보를 탈취하는 공격이다.

좀비PC

악성코드에 감염되어 다른 프로그램이나 컴퓨터를 조종하도록 만들어진 컴퓨터로, C&C(Command & Control) 서버의 제어를 받아 주로 DDoS 공격 등에 이용된다.

C&C 서버

해커가 원격지에서 감염된 좀비 PC에 명령을 내리고 악성코드를 제어하기 위한 용도로 사용하는 서버를 말한다.

봇넷(Botnet)

악성 프로그램에 감염되어 악의적인 의도로 사용될 수 있는 다수의 컴퓨터들이 네트워크로 연결된 형태를 말한다.

제로 데이 공격

보안 취약점이 발견되었을 떄 발견된 취약점의 존재 자체가 널리 공표되기도 전에 해당 취약점을 통하여 이루어지는 보안 공격으로, 공격의 신속성을 의미한다.

트로이 목마

정상적인 기능을 하는 프로그램으로 위장하여 프로그램 내에 숨어 있다가 해당 프로그램이 동작할 때 활성화되어 부작용을 일으키지만 자기 복제 능력은 없다.

CC(Common Criteria)인증

국가마다 서로 다른 정보보호시스템 평가기준을 연동하고 평가결과를 상호 인증하기 위해 제정된 정보보안 평가기준으로, ISO/IEC 15408애 등록된 국제 표준이다.

멀버타이징(Malvertising)

악성 소프트웨어를 뜻하는 멀웨어와 광고의 합성어로, 온라인 광고를 통해 악성코드를 유포시키는 행위를 말한다.

정보공유분석센터(ISAC; Information Sharing & Analysis Center)

취약점 및 침해요인과 그 대응방안에 관한 정보를 제공하며, 침해사고가 발생하는 경우 실시간 경보/분석체계를 운영하고, 금융/통신 등 분야별 정보통신기반시설을 보호하기 위한 업무를 수행하는 곳이다.

업무연속성계획(BCP; Business Continuity Planning)

각종 재해, 장애, 재난으로부터 위기관리를 기반으로 재해복구, 업무복구 및 재개, 비상계획 등의 비즈니스 연속성을 보장하기 위한 계획으로, RTP, RPO, 우선순위를 결정하기 위해 업무 영향 분석을 수행한다.

데이터 디들링(Data Diddling)

처리할 자료를 다른 자료와 바꿔서 처리하는 것으로, 입력값이나 출력값을 부정한 의도로 수정하여 잘못된 결과가 나오도록 유도하는 방식이다.

비트로커(BitLocker)

Windows 7부터 지원되기 시작한 Windows 전용의 볼륨 암호화 기능으로, TPM(Trusted Platform Module)과 AES-128 알고리즘을 사용한다.

공급망 공격(Supply Chain Attack)

소프트웨어 공급망에 침투하여 악성코드를 배포하는 공격으로, SW 빌드 및 배포 과정에 악성코드를 삽입하여 이용자들을 공격한다.

바이러스(Virus)

컴퓨터의 정상적인 작동을 방해하기 위해 운영체제나 저장된 데이터에 손상을 입히는 프로그램으로, 자신을 복제할 수 있고, 다른 프로그램을 감염시킬 수 있다.

웜(Worm)

네트워크를 통해 연속적으로 자신을 복제하여 시스템의 부하를 높임으로써 결국 시스템을 다운시키는 바이러스의 일종으로, 분산 서비스 거부 공격, 버퍼 오버플로 공격, 슬래머 등이 웜 공격의 한 형태이다.

소프트웨어 개발 보안 요소는 소프트웨어 개발에 있어 충족시켜야 할 요소 및 요건을 의미하며, 기밀성, 무결성, 가용성을 보안의 3대 요소라 한다.

기밀성(Confidentiality)

• 시스템 내의 정보와 자원은 인가된 사용자에게만 접근이 허용된다.
• 정보가 전송 중에 노출되더라도 데이터를 읽을 수 없다.

무결성(Intergrity) 시스템 내의 정보는 오직 인가된 사용자만 수정할 수 있다.

가용성(Availability) 인가받은 사용자는 시스템 내의 정보와 자원을 언제라도 사용할 수 있다.

인증(Authentication)

• 시스템 내의 정보와 자원을 사용하려는 사용자가 합벚거인 사용자인지를 확인하는 모든 행위이다.
• 대표적 방법: 패스워드, 인증용 카드, 지문 검사 등

부인 방지(NonRequdiation) 데이터를 송/수신한 자가 송/수신 사실을 부인할 수 없도록 송/수신 증거를 제공한다.

SQL 삽입

• SQL 삽입(Injection)은 웹 응용 프로그램에 SQL을 삽입하여 내부 데이터베이스 서버의 데이터를 유출 및 변조하고, 관리자 인증을 우회하는 보안 약점이다.
• 동적 쿼리에 사용되는 입력 데이터에 예약어 및 특수문자가 입력되지 않게 필터링 되도록 설정하여 방지할 수 있다.

스택 가드

• 스택 가드(Stack Guard)는 널포인터 역참조와 같이 주소가 저장되는 스택에서 발생하는 보안 약점을 막는 기술 중 하나이다.
• 메모리상에서 프로그램의 복귀 주소와 변수 사이에 특정 값을 저장한 후 그 값이 변경되었을 경우 오버플로우 상태로 판단하여 프로그램 실행을 중단함으로써 잘못된 복귀 주소의 호출을 막는다.

접근 제어자

• 접근 제어자는 프로그래밍 언어에서 특정 개체를 선언할 때 외부로부터의 접근을 제한하기 위해 사옹되는 예약어이다.
• **접근 제어자의 종류(접근 가능: ○, 접근 불가능: Ⅹ)

개인키 암호화 기법

• 개인키 암호화(Private Key Encryption) 기법은 동일한 키로 데이터를 암호화하고 복호화하는 암호화 기법이다.
• 대칭 암호 기법 또는 단일키 암호화 기법이라고도 한다.
• 암호화와 복호화 속도가 빠르다.
• 관리해야 할 키의 수가 많다.
• 개인키 암호화 기법의 종류에는 스트림 암호화 방식과 블록 암호화 방식이 있다.

스트림 암호화 방식

• 평문과 동일한 길이의 스트림을 생성하여 비트 단위로 암호화 하는 방식.
• 종류: LFSR, RC4, TKIP

블록 암호화 방식

• 한 번에 하나의 데이터 블록을 암호화 하는 방식
• 종류: DES, SEED, AES, ARIA, IDEA, Skipjack

IDEA

• IDEA(International Data Encryption Algorithm)는 스위스의 라이(Lai)와 메시(Messey)가 1990년에 개발한 PES를 개선한 알고리즘이다.
• 블록 크기는 64비트이고, 키 길이는 128비트이다.

Skipjack

• Skipjack은 국가 안전 보장국(NSA)에서 개발한 암호화 알고리즘이다.
• 클리퍼 칩(Clipper Chip)이라는 IC칩에 내장되어 있다.
• 블록 크기는 64비트이고, 키 길이는 80비트이다.
• 주로 음성 통신 장비에 삽입되어 음성 데이터를 암호화한다.

DES

• DES(Data Encryption Standard)는 1975년 미국 NBS에서 발표한 개인키 암호화 알고리즘이다.
• 블록 크기는 64비트, 키 길이는 56비트이며 16회의 라운드를 수행한다.
• DES를 3번 적용하여 보안을 더욱 강화한 3DES(Triple DES)가 있다.

AES

• AES(Advanced Encryption Standard)는 2001년 미국 표준 기술 연구소(NIST)에서 바라표한 개인키 암호화 알고리즘이다.
• DES의 한계를 느낀 NIST에서 공모한 후 발표하였다.
• 블록 크기는 128비트이며, 키 길이에 따라 AES-128, AES-192, AES-256으로 분류된다.

RSA

• RSA(Rivest Shamir Adleman)는 1978년 MIT의 라이베스트(Rivest), 샤미르(Shamir), 애들먼(Adelman)에 의해 제안된 공개키 암호화 알고리즘이다.
• 큰 숫자를 소인수분해 하기 어렵다는 것에 기반하여 만들어졌다.

TKIP

• TKIP(Temporal Key Intergrity Protocol)는 기존의 무선 랜 보안 프로토콜이 WEP의 취약성을 보완한 데이터 보안 프로토콜이다.
• 암호 알고리즘의 입력 키 길이를 128비트로 늘리고 패킷당 키 할당, 키값 재설정 등의 키 관리 방식을 개선하였다.

해시

• 해시(Hash)는 임의의 길이의 입력 데이터나 메시지를 고정된 길이의 값이나 키로 변환하는 것을 의미한다.
• 해시 알고리즘을 해시 함수라고 부르며, 해시 함수로 변환된 값이나 키를 해시값 또는 해시키라고 부른다.
• 종류: SHA 시리즈, HAVAL, MD4, MD5, N-NASH, SNEFRU 등

MD5

• MD5(Mseesage Digest algorithm 5)는 1991년 R.Rivest가 MD4를 대체하기 위해 고안한 암호화 해시 함수이다.
• 블록 크기가 512비트이며, 키 길이는 128비트이다.

인증

• 인증(Authentication)은 다중 사용자 컴퓨터 시스템이나 네티워크 시스템에서 로그인을 요청한 사용자의 정보를 확인하고 접근 권하을 검증하는 보안 절차이다.
• 인증의 종류

침임 탐지 시스템

• 침임 탐지 시스템(IDS; Intrusion Detection System)은 컴퓨터 시스템의 비정상적인 사용, 오용, 남용 등을 실시간으로 탐지하는 시스템이다.
• 오용 탐지(Misuse Detection): 미리 입력해 둔 공격 패턴이 감지되면 이를 알려줌
• 이상 탐지(Anomaly Detection): 평균적인 시스템의 상태를 기준으로 비정상적인 행위나 자원의 사용이 감지되면 이를 알려줌.

VPN

• VPN(Virtual Private Network, 가상 사설 통신망)은 인터넷 등 통신 사업자의 공중 네트워크와 암호화 기술을 이용하여 사용자가 마치 자신의 전용 회선을 사용하는 것처럼 해주는 보안 솔루션이다.
• SSL VPN: PC에 VPN Client 프로그램을 설치하여 VPN 서버에 접속하는 방식으로, 암호화를 위해 SSL 프로토콜을 사용함.
• IPSec VPN: VPN 서버가 설치된 각각의 네트워크를 서로 연결하는 방식으로, 암호화를 위해 IPSec 프로토콜을 사용함.

SIEM

• SIEM(Security Information and Event Management)은 다양한 장비에서 발생하는 로그 및 보안 이벤트를 통합하여 관리하는 빅 데이터 기반의 보안 솔루션이다.
• 방화벽, IDS, IPS, 웹 방화벽, VPN 등에서 발생한 로그 및 보안 이벤트를 통합하여 관리함으로써 비용 및 자원을 절약할 수 있다.
• 장기간의 로그 및 보안 이벤트를 수집 및 검색할 수 있는 빅데이터 기반의 통합 로그 수집 시스템이다.

SSH

• SSH(Secure SHell, 시큐어 셸)는 다른 컴퓨터에 원격으로 접속하여 작업을 수행할 수 있도록 다양한 기능을 지원하는 프로토콜 또는 이를 이용한 응용 프로그램이다.
• 데이터 암호화와 강력한 인증 방법으로 보안성이 낮은 네트워크에서도 안전하게 통신할 수 있다.
• 키를 통한 인증 방법을 사용하려면 사전에 클라이언트의 공개키를 서버에 등록해야 한다.
• 기본적으로는 22번 포트를 사용한다.

AAA(=3A)

• AAA는 다음 3가지 기능을 기반으로 사용자의 컴퓨터 자원 접근에 대한 처리와 서비스를 제동하는 기반 구조 또는 규격을 의미한다.
• 인증(Authentication): 접근하는 사용자의 시원을 검증하는 기능
• 인간(Authorization): 신원이 검증된 사용자에게 특정된 권한과 서비스를 허용하는 기능
• 과금(Accounting): 사용자가 어떤 종류의 서비스를 이용했고, 얼마만큼의 지원을 사용했는지 기록 및 보관하는 기능

정보보호 관리 체계

• 정보보호 관리 체계(ISMS; Information Security Management System)는 정보 자산을 안전하게 보호하기 위한 보호 절차와 대책을 의미한다.
• 조직에 맞는 정보보호 정책을 수립하고, 위험에 상시 대응하는 여러 보안 대책을 통합 관리/ 운용한다.
• 우리나라에서는 정보보호 관리 체계를 평가하고 인증하는 사업을 한국인터넷진흥원(KISA)에서 운영하고 있다.

Ping of Death

• Ping if Death(죽음의 핑)는 Ping 명령을 전송할 때 패킷의 크기를 인터넷 프로토콜 허용 범위 이상으로 전송하여 공격 대상의 네트워크를 마비시키는 서비스 거보 공격 방법이다.
• 공격에 사용되는 큰 패킷은 수백 개의 패킷으로 분할되어 전송되는데, 공격 대상은 분할된 대량의 패킷을 수신함으로써 분할되어 전송된 패킷을 재조립해야 하는 부담과 분할되어 전송된 각각의 패킷들의 ICMP Ping 메시지에 대한 응답을 처리하는라 시스템이 다운되게 된다.

SMURFING

• SMURFING(스머핑)은 IP나 ICMP의 특성을 악용하여 엄청난 양의 데이터를 한 사이트에 집중적으로 보냄으로써 네트워크를 불능 상태로 만드는 공격 방법이다.
• SMURFING 공격을 무력화하는 방법 중 하나는 각 네트워크 라우터에서 브로드캐스트 주소를 사용할 수 없게 미리 설정해 놓는 것이다.

LAND Attack

LAND Attack(Local Area Network Denial Attack)은 패킷을 전송할 때 송신 IP 주소와 수신 IP 주소를 모두 공격 대상의 IP 주소로 하여 공격 대상에게 전송하는 것으로, 이 패킷을 받은 공격 대상은 송신 IP 주소가 자신이므로 자신에게 응답을 수행하게 되는데, 이러한 패킷이 계속해서 전송될 경우 자신에 대해 무한히 응답하게 하는 공격 방법이다.

분산 서비스 공격용 툴

에이전트의 역할을 수행하도록 설계된 프로그램으로 데몬이라고 부르며, 다음과 같은 종류가 있다.

• Trin00 가장 초기 형태의 데몬으로, 주로 UDP Flooding 공격을 수행함
• TFN(Tribe Flood Network) UDP Flooding 뿐만 아니라 TCP SYN Flood 공격, ICMP 응답 요청, 스머핑 공격 등을 수행함.
• TFN2K TFN의 확장판임
• Stacheldraht
  • 이전 툴들의 기능을 유지하면서, 공격자, 마스터, 에이전트가 쉽게 노출되지 않도록 암호화된 통신을 수행함
  • 툴이 자동으로 업데이트됨

세션 하이재킹

• 세션 하이재킹은 상호 인증 과정을 거친 후 접속해 있는 서버와 서로 접속되어 클라이언트 사이의 세션 정보를 가로채는 공격 기법으로, 접속을 위한 인증 정보 없이도 가로챈 세션을 이용해 공격자가 원래의 클라이언트인 것처럼 위장하여 서버의 자원이나 데이터를 무단으로 사용한다.

• TCP 3-Way-Handshake 과정에 끼어듦으로써 클라이언트와 서버 간의 동기화된 시퀀스 번호를 가로채 서버에 무단으로 접근하는 TCP 세션 하이재킹이 대표적인 예이다.

ARP 스푸핑

ARP 스푸핑은 ARP의 취약점을 이용한 공격 기법으로, 자신의 물리적 주소(MAC)를 공격 대상의 것으로 변조하여 공격 대상에게 도달해야 하는 데이터 패킷을 가로패거나 방해하는 기법이다.

• **ARP(Address Resolution Protocol): 호ㅛㅡ트의 IP주소를 호스트와 연결된 네트워크 접속 장치의 물리적 주소(MAC Address)로 변환해주는 프로토콜

사회 공학

사회 공학은 컴퓨터 보안에 있어서, 인산 상호 작용의 깊은 신뢰를 바탕으로 사람들을 속여 정상 보안 절차를 깨트리기 위한 비기술적 시스템 침입 수단이다.

다크 데이터

다크 데이터는 특정 목적을 가지고 데이터를 수집하였으나, 이후 활용되지 않고 저장만 되어 있는 대량의 데이터를 의미한다.

타이포스쿼팅

• 타이포스쿼팅은 네티즌들이 사이트에 접속할 때 주소를 잘못 입력하거나 철자를 빠뜨리는 실수를 이용하기 위해 이와 유서한 유명 도메인을 미리 등록하는 것이다.
• URL 하이재킹이라고도 한다.

스니핑

스니핑은 네트워크의 중간에서 남의 패킷 정보를 도청하는 해킹 유형의 하나로, 수동적 공격에 해당한다.

워터링 홀

• 워터링 홀은 목표 대상이 자주 방문하는 웹 사이트를 사전에 감염시켜 대상이 해당 사이트에 방문했을 떄 악성 코드에 감염되게 하는 웹 기반 공격이다.
• 감염된 PC를 기반으로 대상이 속한 조직의 중요 시스템에 접근하거나 불능으로 만드는 등의 영향력을 행사할 수 있다.

키로거 공격

키로거 공격은 컴퓨터 사용자의 키보드 움직임을 탐지해 ID, 패스워드, 꼐좌번호, 카드번호 등과 같은 개인의 중요한 정보를 몰래 빼가는 해킹 공격이다.

랜섬웨어

랜섬웨어는 인터넷 사용자의 컴퓨터에 잠입해 내부 문서나 파일 등을 암호화해 사용자가 열지 못하게 하는 프로그램으로, 암호 해독용 프로그램의 전달을 조건으로 사용자에게 돈을 요구하기도 한다.

백도어

• 백도어는 시스템 설계자가 서비스 기술자나 유지 보수 프로그램 작성자의 액세스 편의를 위해 시스템 보안을 제거하여 만들어 놓은 비밀 통로로, 컴퓨터 범죄에 악용되기도 한다.
• 백도어 탐지 방법: 무결서 ㅇ검사, 열린 포트 확인, 로그 분석, SetUID 파일 검사 등

• DDL(Data Define Language, 데이터 정의어)은 DB 구조, 데이터 형식, 접근 방식 등 DB를 구축하거나 수정할 목적으로 사용하는 언어이다.
• DDL의 3가지 유형 CREATE, ALTER, DROP

CREATE INDEX

CREATE INDEX는 인덱스를 정의하는 명령문이다. CREATE [UNIQUE] INDEX 인덱스명 ON 테이블명(속성명[ASC|DESC][, 속성명[ASC|DESC]]) [CLUSTER];

• UNIQUE 사용된 경우: 중복 값이 없는 속성으로 인덱스를 생성함 생략된 경우: 중복 값을 허용하는 속성으로 인덱스를 생성함
• 정렬 여부 지정 ASC: 오름차순 정렬 DESC: 내림차순 정렬 생략된 경우: 오름차순으로 정렬됨
• CLUSTER: 사용하면 인덱스가 클러스터드 인덱스로 설정됨

ALTER TABLE

ALTER TABLE은 테이블에 대한 정의를 변경하는 명령문이다.

표기 형식 ALTER TABLE 테이블명 ADD 속성명 데이터_타입[DEFAULT '기본값']; ALTER TABLE 테이블명 ALTER 속성명[SET DEFAULT '기본값']; ALTER TABLE 테이블명 DROP COLUMN 속성명[CASCADE];

• ADD: 세로운 속성(열)을 추가할 때 사용함.
• ALTER: 특정 속성의 Default 값을 변경할 때 사용함.
• DROP COLUMN: 특정 속성을 삭제할 때 사용함.

DROP

DROP은 스키마, 도메인, 기본 테이블, 뷰 테이블, 인덱스, 제약 조건 등을 제거하는 명령문이다.

표기 형식 DROP SCHEMA 스키마명[CASCADE|RESTRICT]; DROP DOMAIN 도메인명[CASCADE|RESTRICT]; DROP TABLE 테이블명[CASCADE|RESTRICT]; DROP VIEW 뷰명[CASCADE|RESTRICT]; DROP INDEX 인덱스명[CASCADE|RESTRICT]; DROP CONSTRAINT 제약조건명;

• CASCADE: 제거할 요소를 참조하는 다른 모든 개체를 함께 제거함.
• RESTRICT: 다른 개체가 제거할 요소를 참조중일 때는 제거를 취소함.

DCL

• DCL(Data Control Language, 데이터 제어어)은 데이터의 보안, 무결성, 회복, 병행 제어 등을 정의하는 데 사용하는 언어이다.
• DCL은 데이터베이스 관리자가 데이터 관리를 목적으로 사용한다. COMMIT, ROLLBACK, GRANT, REVOKE

GEANT / REVOKE

• 데이터베이스 관리자가 데이터베이스 사용자에게 권한을 부여하거나 취소하기 위한 명령어이다.
• 표기 형식*
• GRANT* 권한_리스트 ON 개체 TO 사용자[WITH GRANT OPTION];
• REVOKE* [GRANT OPTION FOR] 권한_리스트 ON 개체 FROM 사용자[CASCADE];
• 권한 종류: ALL, SELECT, INSERT, DELETE, UPDATE 등
• WITH GRANT OPTION: 부여받은 권한을 다른 사용자에게 다시 부여할 수 있는 권한을 부여함
• GRANT OPTION FOR: 다른 사용자에게 권한을 부여할 수 있는 권한을 취소함
• CASCADE: 권한 취소 시 권한을 부여받았던 사용자가 다른 사용자에게 부여한 권한도 연쇄적으로 취소함

DML

• DML(Data Maniplation Language, 데이터 조작어)은 데이터베이스 사용자가 저장된 데이터를 실질적으로 관리하는데 사용되는 언어이다.
• DML은 데이터베이스 사용자와 데이터베이스 관리 시스템 간의 인터페이스를 제공한다. SELECT, INSERT, DELETE, UPDATE

삽입문(INSERT INTO ~)

INSERT INTO 테이블명(속성명1, 속성명2, ...]) VALUES(데이터1, 데이터2, ...);

삭제문(DELETE FROM ~)

DELETE FROM 테이블명[WHERE 조건];

갱신문(UPDATE ~ SET ~)

UPDATE 테이블명 SET 속성명1 = 데이터1, [속성명2 = 데이터2, ...] [WHERE 조건];

SELECT

SELECT [PREDICATE][테이블명.]속성명[AS 별칭][, [테이블명.]속성명, ...] FROM 테이블명[, 테이블명, ...] [WHERE 조건] [GROUP BY 속성명, 속성명, ...] [HAVING 조건] [ORDER BY 속성명 [ASC | DESC]];

• SELECT절
  • PREDICATE: 검색할 튜플 수를 제한하는 명령어를 기술함
  • DISTINCT: 중복된 튜플이 있으면 그 중 첫 번째 한 개만 표시함

하위 질의

하위 질의는 조건절에 주어진 질의를 먼저 수행하여 그 검색 결과를 조건절의 피연산자로 사용한다.

그룹 함수

그룹 함수는 GROUP BY절에 지정된 그룹별로 속성의 값을 집계할 때 사용된다.

집합 연산자를 이용한 통합 질의

집합 연산자를 사용하여 2개 이상의 테이블의 데이터를 하나로 통합한다.

표기 형식 SELECT 속성명1, 속성명2, ... FROM 테이블명 UNION | UNION ALL | INTERSECT | EXCEPT SELECT 속성명1, 속성명2, ... FROM 테이블명 [ORDER BY 속성명 [ASC | DESC]];

• 두 개의 SELECT문에 기술한 속성들은 개수와 데이터 유형이 서로 동일해야 한다.
• 집합 연산자의 종류

JOIN

• JOIN은 2개의 릴레이션에서 연관된 튜플들을 결합하여, 하나의 새로운 릴레이션을 반환한다.
• JOIN은 일반적으로 FROM절에 기술하지만, 릴레이션이 사용되는 곳 어디에나 사용할 수 있다.
• JOIN은 크게 INNER JOIN과 OUTER JOIN으로 구분된다.
  • INNER JOIN: THETA JOIN, EQUI JOIN, NATURAL JOIN, NON-EQUI JOIN
  • OUTER JOIN: LEFT OUTER JOIN, RIGHT OUTER JOIN, FULL OUTER JOIN

EQUI JOIN(동등 조인)

• JOIN에 참여하는 두 릴레이션의 속성 값을 비교하여 조건을 만족하는 튜플만 반환하는 조인을 THEA JOIN(세타 조인)이라고 하며, 조인에 사용되는 조건에는 =, ≠, <, ≤, >, ≥가 있다.

• EQUI JOIN(동등조인)은 조인에 사용되는 조건 중 =(equal) 비교에 의해 같은 값을 가지는 행을 연결하여 결과를 생성하는 방법이다.

• EQUI JOIN에서 JOIN 조건이 '='일 때 동일한 속성이 두 번 나타나게 되는데, 이 중 중복된 속성을 제거하여 같은 속성을 한 번만 표기하는 방법을 NATURAL JOIN(자연 조인)이라고 한다.

• EQUI JOIN에서 연결 고리가 되는 공통 속성을 JOIN 속성이라고 한다.

• WHERE절을 이용한 EQUI JOIN의 표기 형식

• SELECT* [테이블명1.]속성명, [테이블명.]속성명2, ...

• FROM* 테이블명1, 테이블명2, ...

• WHERE* 테이블명1.속성명 = 테이블명2.속성명;

• NATURAL JOIN절을 이용한 EQUI JOIN의 표기 형식

• SELECT* [테이블명1.]속성명, [테이블명.]속성명2, ...

• FROM* 테이블명1 NATURAL JOIN 테이블명2

• JOIN ~ USING절을 이용한 EQUI JOIN의 표기 형식

• SELECT* [테이블명1.]속성명, [테이블명.]속성명2, ...

• FROM* 테이블명1 JOIN 테이블명2 USING(속성명);

OUTER JOIN

• LEFT OUTER JOIN: INNER JOIN의 결과를 구한 후, 우측 항 릴레이션의 어떤 튜플과도 맞지 않는 좌측 항의 릴레이션에 있는 튜플들에 NULL 값을 붙여서 INNER JOIN의 결과에 추가함

• 표기 형식

• SELECT* [테이블명1.]속성명, [테이블명.]속성명2, ...

• FROM* 테이블명1 LEFT OUTER JOIN 테이블명2

• ON* 테이블명1.속성명 = 테이블명2.속성명;

• RIGHT OUTER JOIN: INNER JOIN의 결과를 구한 후, 좌측 항 릴레이션의 어떤 튜플과도 맞지 않는 우측 항의 릴레이션에 있는 튜플들에 NULL 값을 붙여서 INNER JOIN의 결과에 추가함

• 표기 형식

• SELECT* [테이블명1.]속성명, [테이블명.]속성명2, ...

• FROM* 테이블명1 RIGHT OUTER JOIN 테이블명2

• ON* 테이블명1.속성명 = 테이블명2.속성명;

트리거

• 트리거(Trigger)는 데이터베이스 시스템에서 데이터의 삽입, 갱신, 삭제 등의 이벤트가 발생할 때 관련 작업이 자동으로 수행되게 하는 절차형 SQL이다.
• 트리거는 데이터베이스에 저장되며, 데이터 변경 및 무결성 유지, 로그 메시지 출력 등의 목적으로 사용된다.