• 공용 IP 주소 확인하기
• 공유기 설정에서 포드포워딩 설정하기
• 방화벽 설정하기
• /etc/nginx/sites-available/default 설정

포드포워딩

• 포드포워딩이란?
  • 외부 IP에서 내부의 특정 IP에 연결해주는 역할

1. 공용IP를 이용해 공유기 설정 접속
2. 포트포워드 설정(외부:8000포트, 내부:80포트)

방화벽 설정

sudo ufw allow 8000/tcp
// sudo ufw allow 80/tcp
// sudo ufw allow 433/tcp

8000포트로 들어오는 트레픽 허용

• 안될 시 밑에 주석도 추가해보기

/etc/nginx/sites-available/default

server {
    listen 80;
    server_name public_ip;  # 공용 IP 주소
>
    location ~ \.html {
        root /var/www/html;  # stock.html 파일이 있는 디렉토리
        index stock.html
        try_files $uri $uri/ =404;
    }
>
    location /stock {
        proxy_pass http://localhost:8000;  # FastAPI 서버의 주소와 포트
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
* stock.html fetch IP주소 공용 IP로 변경

다양한 환경에서 접속해보기

같은 IP의 다른 기기에서 접속	외부 IP에서 기기에서 접속
* 같은 IP에서 다른 기기로 연결할 시 서버 로컬 기기의 IP주소로 연결
* 외부 IP의 기기에서 연결할 시 공용 IP:8000포트로 연결

주의사항

• 외부 IP에서 접속할 시 포드포워딩 확인하기
• stock.html의 fetch주소 공용 IP로 설정하기
• /etc/nginx/sites-available/default의 location 설정하기
• 307에러 발생 시 CORS 설정 확인하기

기능

• 테이블
  • Id(int): 고유 번호 사용
  • name(varchar): 상품명
  • quantity(int): 수량
  • description(varchar): 아이템 설명
• 기능
  • 전체 아이템 출력
  • 아이템 검색(상품명에 따른 검색)
  • 이아템 추가(상품명, 수량 필수 기입)
  • 아이템 수정(수량, 설명만 수정 가능)
  • 아이템 삭제

stockapp.py

stockapp.py 중

>
class Stock(BaseModel):   // Stock 모델 정의
    id: int
    name: str
    quantity: int
    description: str
>
class UpdateModel(BaseModel):   // Update 시 사용할 모델 정의
    quantity: int
    description: str
>
        ... stockapp.py 중 ...
 @app.put("/stock/{stock_id}")   
async def put_stock(stock_id: int, update: UpdateModel):     // 데이터 업데이트
    with app.db_connection.cursor() as cursor:
        sql = "update stock set quantity = %s, description = %s where id = %s"
        cursor.execute(sql, (update.quantity, update.description, stock_id))
        app.db_connection.commit()
    return {"message": "stock updated successfully"}

함수 제작 시 다양한 변수 사용 시 pydantic 모델로 정의 필요 - 변수로 대입 시 오류 발생(때문에 Stock, Update 모델 각각 정의 필요)

stock.html

stock.html 중

const response = await fetch('http://공용 IP:8000/stock');  // 네이버에서 공용 IP 검색 
const items = await response.json();

fetch 시 공용 IP 주소 사용(외부 IP에서 접속 시 필요) - 내부 IP에서만 사용 시에는 localhost 사용 가능

 const response = await fetch(`http://공용 IP:8000/stock/${itemId}`, {
        method: 'PUT',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({id: id, quantity: quantity, description: description})
  });

fetch 시 stringify로 stockapp.py의 함수에 필요한 변수 값 전송 - put_stock(id, quantity, description) 사용

실행하기

uvicorn stockapp:app --host 0.0.0.0 --port 8000 // 서버 가동

• --host 0.0.0.0: 0.0.0.0은 모든 네트워크 인터페이스에서의 요청을 수신하겠다는 의미
• --post 8000: 서버가 수신할 포트를 지정 즉 8000포트로 수신

http://localhost/stock.html 접속 stock테이블과 메인 페이지 정상 연결 확인

메인 페이지	stock 테이블
1. GET, localhost:8000/stock을 통해 전체 아이템 값 item에 저장
2. for문을 통해 각각의 아이템 출력

상품명으로 검색하기

1. GET, localhost:8000/stock을 통해 전체 아이템 값 item에 저장
2. for문을 통해 item 값을 돌며, 검색 값과 일치할 시 출력

상품 등록

상품명 "나사" 추가	추가 후 메인 페이지
1. POST, localhost:8000/stock로 stock테이블에 값 저장
- Id(고유번호) 값은 가장 테이블의 가장 큰 Id의 다음 수로 설정
- 상품명, 수량은 필수

상품 수정

수량 150, 11일로 수정	stock 테이블
수량을 150, 일정 11로 수정
1. PUT, localhost:8000/stock/{itemId}로 업데이트(id, 상품명, 수량)

상품 삭제

"케이블" 삭제	삭제 후 메인 페이지
1. "케이블" 삭제 시 DELETE, localhost:8000/stock/{itemId} 전송
2. 고유 번호에 맞는 아이템 삭제

확인하기

• 출력 에러 시 fastAPI에서 CORS 설정 확인하기

콘솔 창 입력

sudo apt-get update
sudo apt-get install libmysqlclient-dev    //  MySQL 클라이언트 라이브러리의 개발 파일을 제공
>
sudo install pymysql    

> pymysql 추가 설치하기

dbapp.py

dbapp.py 생성

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import pymysql
>
# FastAPI 애플리케이션 초기화
app = FastAPI()
>
# 데이터베이스 연결 설정
db_config = {
    'host': 'localhost',
    'user': '사용자_이름',
    'password': '비밀번호',
    'database': '데이터베이스_이름',
    'charset': 'utf8mb4',
    'cursorclass': pymysql.cursors.DictCursor
}
>
# FastAPI 시작 시 데이터베이스 연결 풀 생성
@app.on_event("startup")
async def startup():
    app.db_connection = pymysql.connect(**db_config)
>
# FastAPI 종료 시 데이터베이스 연결 풀 닫기
@app.on_event("shutdown")
async def shutdown():
    app.db_connection.close()
>
# Pydantic 모델 정의
class User(BaseModel):
    id: int
    name: str
    phone: str
    birth: str
>
# MySQL에서 데이터를 가져오는 route 정의
@app.get("/")
async def read_root():
    with app.db_connection.cursor() as cursor:
        cursor.execute("SELECT * FROM your_table")
        result = cursor.fetchall()
    return result
>
# MySQL에서 특정ID 데이터 가져오는 route 정의
@app.get("/users/{user_id}")
async def get_user(user_id: int):
    with app.db_connection.cursor() as cursor:
            sql = "select * from your_table where id = %s"
            cursor.execute(sql,(user_id,))
            result = cursor.fetchall()
    return result
>
# MySQL에 데이터 삽입하는 route 정의
@app.post("/users")
async def post_user(user: User):
    with app.db_connection.cursor() as cursor:
        sql = "INSERT INTO your_table (id, name, phone, birth) VALUES (%s, %s, %s, %s)"
        cursor.execute(sql, (user.id, user.name, user.phone, user.birth))
        app.db_connection.commit()
    return {"message": "User created successfully"}
>
# MySQL에서 데이터 수정하는 route 정의
@app.put("/users/{user_id}")
async def put_user(user_id: int, user: User):
    with app.db_connection.cursor() as cursor:
        sql = "UPDATE your_table SET name = %s, phone = %s, birth = %s WHERE id = %s"
        cursor.execute(sql, (user.name, user.phone, user.birth, user_id))
        app.db_connection.commit()
    return {"message": "User updated successfully"}
>
# MySQL에서 데이터 삭제하는 route 정의
@app.delete("/users/{user_id}")
async def delete_user(user_id: int):
    with app.db_connection.cursor() as cursor:
        sql = "DELETE FROM your_table WHERE id = %s"
        cursor.execute(sql, (user_id,))
        app.db_connection.commit()
    return {"message": "User deleted successfully"}
>

DB연결 및 CRUD

GET

콘솔 창 입력

uvicorn dbapp:app --host 0.0.0.0 --port 8000 --reload

> http://your_server_ip:8000 접속 - PHP 연결 시 사용했던 user DB연결(https://velog.velcdn.com/images/neymar_10/post/c0a08b47-e7a7-4074-923b-1e6fa48ea1a3/image.png)

POST

postman -> body탭 입력

{
    "id": 4,
    "name": "Min Jae",
    "phone": "010-4444-4444",
    "birth": "961115"
{

• 메소드 POST로 설정
  | 전체 조회
• --| ---|

PUT

postman -> body탭 입력

{
    "id": 1,
    "name": "Beom Su",
    "phone": "010-1111-1111",
    "birth": "111111"
{

• 메소드 PUT으로 설정
  birth를 "111111"로 수정|
• --| ---|

DELETE

• 메소드 DELETE로 설정
• http://your_server_ip:8000/users/id (DELETE를 원하는 Id 지정)
• Send
  id가 3인 user 삭제|
• --| ---|

RestAPI란?

• RestAPI는 클라이언트와 서버 간의 상호작용을 간단하고 유연하게 만들어주는 웹 서비스 아키텍처 스타일 중 하나

주요 개념

1. 자원
   • REST API에서 모든 것은 자원으로 간주
   • 각 자원은 고유한 URI를 통해 식별된다. 즉, 특정 사용자의 자원 URI는 http://api.example.com/users/123와 같을 수 있음
2. HTTP 메서드
   • REST API는 HTTP 메서드를 사용하여 자원에 대한 CRUD(생성, 읽기, 갱신, 삭제) 작업을 수행

    GET: 자원 조회
    POST: 새로운 자원 생성
    PUT: 기존 자원 갱신
    DELETE: 자원 삭제
    PATCH: 자원의 일부를 수정 

3. 표현
   • 클라이언트와 서버 간의 데이터 교환은 자원의 표현을 통해 발생
   • 표현은 일반적으로 JSON 또는 XML 형식으로 전송
4. 상태 없는 통신(Stateless Communication)
   • 각 요청은 클라이언트의 상태나 이전 요청의 문맥을 서버가 기억하지 않고 독립적으로 처리 - 모든 필요한 정보는 요청 내에 포함되어야 함
5. 계층화된 시스템
   • 클라이언트는 중간 서버를 통하거나 직접 서버와 통신할 수 있음 - 중간 서버는 로드 밸런싱, 캐싱, 보안 정책 등 다양한 기능을 제공가능
6. 캐싱
   • 서버는 응답에 캐시 가능한 정보를 포함시킬 수 있으며, 클라이언트는 이를 이용해 불필요한 서버 요청을 줄일 수 있음

REST API 설계 방법

1. 명확하고 일관된 자원 URI 설계
   • 자원의 URI는 직관적이고 일관성 있게 설계되어야 함
2. 적절한 HTTP 상태 코드 사용
   • 각 요청에 대해 적절한 HTTP 상태 코드를 반환하여 클라이언트가 요청의 성공 여부를 쉽게 이해할 수 있어야 함

    200 OK: 요청 성공
    201 Created: 새로운 자원 생성
    400 Bad Request: 잘못된 요청
    404 Not Found: 자원 찾을 수 없음
    500 Internal Server Error: 서버 오류

3. HATEOAS(Hypermedia As The Engine Of Application State)
   • 클라이언트가 서버의 응답을 통해 다음 가능한 행동에 대한 정보를 얻을 수 있어야 함
   • 응답에 관련 링크를 포함하여 클라이언트가 쉽게 탐색할 수 있어야 함
4. 보안
   • 인증(Authentication)과 권한 부여(Authorization)를 통해 자원에 대한 접근을 제어
   • HTTPS를 사용하여 데이터 전송 중 보안을 강화

>> 준비하기 <<

• Python 중 Flask, Django, FastAPI 등 다양한 프레임워크 중에서 FastAPI를 사용해 제작보았습니다.

패키지 설치

콘솔 창 입력

----------------FastAPI, Uvicorn 설치[1]------------------
ssh your_username@your_server_ip    // Ubuntu 서버에 SSH로 접속
>
sudo apt update
sudo apt install python3 python3-pip    // 파이썬 설치
>
pip3 install fastapi uvicorn    // FastAPI, Uvicorn 설치
>
----------------FastAPI, Uvicorn 등 설치 실패 시[2](가상 환경)-----------------
sudo apt install python3-venv    // 가상 환경 설치
>
mkdir my_fastapi_app    // 디렉터리 생성 및 이동
cd my_fastapi_app        
>
python3 -m venv venv        // 프로젝트 디렉토리에서 가상 환경을 생성
source venv/bin/activate    // 가상 환경 활성화
>
pip3 install fastapi uvicorn    // FastAPI, Uvicorn 설치

> 1, 2중에서 상황에 맞는 패키지 설치하기

FastAPI

my_fastapi_app/app.py

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
>
app = FastAPI()
>
# 데이터 모델
class Note(BaseModel):
    id: int
    title: str
    content: str
>
# 임시 데이터베이스
notes = []
>
# notes값 전체 조회
@app.get("/notes", response_model=list[Note])
def get_notes():
    return notes
>
# id별 notes 조회
@app.get("/notes/{note_id}", response_model=Note)
def get_note(note_id: int):
    note = next((note for note in notes if note.id == note_id), None)
    if note is None:
        raise HTTPException(status_code=404, detail="Note not found")
    return note
>
# notes 생성(id 자동으로 생성)
@app.post("/notes", response_model=Note, status_code=201)
def create_note(note: Note):
    notes.append(note)
    return note
>
# id별 notes 수정
@app.put("/notes/{note_id}", response_model=Note)
def update_note(note_id: int, updated_note: Note):
    note = next((note for note in notes if note.id == note_id), None)
    if note is None:
        raise HTTPException(status_code=404, detail="Note not found")
    note.title = updated_note.title
    note.content = updated_note.content
    return note
>
#id별 notes 삭제
@app.delete("/notes/{note_id}", status_code=204)
def delete_note(note_id: int):
    global notes
    notes = [note for note in notes if note.id != note_id]
    return None
>
# 현재 스크립트가 직접 실행될 때만 코드 블록 안의 내용 실행
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

> 메모리에 저장되는 CRUD 기능이 포함된 app.py 제작 - 임시로 데이터베이스 역할을 표현하기 위해 배열로 저장 - host="0.0.0.0": 서버가 모든 네트워크 인터페이스에서 접속을 허용

app.py 실행하기

• Postman 설치 후 실행(API를 디자인, 빌드, 테스트하기 위한 API 플랫폼)

GET

콘솔 창 입력

uvicorn app:app --host 0.0.0.0 --port 8000

>http://your_server_ip:8000 접속

전체 notes값 조회

POST

Postman -> body탭 입력

{
  "id": 1,
  "title": "Sample Note",
  "content": "This is a sample note."
}

• 메서드를 POST로 설정
• URL을 http://your_server_ip:8000/notes 로 설정
• Body 탭에서 raw와 JSON을 선택하고, 위의 JSON 데이터를 입력
• Send 버튼을 클릭

  POST

  전체 notes값 조회

PUT

Postman -> body 탭 입력

{
  "id": 1,
  "title": "Updated Sample Note",
  "content": "This is a Updated sample"
}

• 메서드를 PUT으로 설정
• URL을 http://your_server_ip:8000/notes/1 로 설정
• Body 탭에서 raw와 JSON을 선택하고, 위의 JSON 데이터를 입력
• Send 버튼을 클릭

  PUT

  전체 notes값 조회

DELETE

• 메서드를 DELETE으로 설정
• URL을 http://your_server_ip:8000/notes/1 로 설정
• Send 버튼을 클릭

  DELETE

  전체 notes값 조회

콘솔 창 입력

sudo apt update
sudo apt install mysql-server    // Ubuntu MySQL 설치
>
sudo mysql_secure_installation    // MySQL 설치 후 보안 설정

> 우분투에서 MySQL 설치 후 보안 설정하기

MySQL 접속하기

콘솔 창 입력

sudo mysql -u root -p    // MySQl 접속
CREATE DATABASE user_db; // DB생성
>
USE user_db;    // DB접속

> MySQL 접속 후 user_db에 접속하기

테이블 생성 및 데이터 삽입

콘솔 창 입력

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(20) NOT NULL,
    phone VARCHAR(15),
    birth VARCHAR(6)
);    // users 테이블 생성
>
INSERT INTO users (name, phone, birth) VALUES ('Beom Su', '010-1111-1111', '000000');
INSERT INTO users (name, phone, birth) VALUES ('Heung Min', '010-2222-2222', '920708');
INSERT INTO users (name, phone, birth) VALUES ('Kang In', '010-3333-3333', '010219');
// 테이블 데이터 삽입

PHP와 MySQL 연결

콘솔 창 입력 // conn.php파일 생성 후 아래 코드 삽입

<?php
$servername = "localhost";
$username = "root";
$password = "your_password";
$dbname = "your_db";
>
// MySQL 연결 생성    mysqli 중요!(철자 틀리면 안됨*함수임*)
$conn = new mysqli($servername, $username, $password, $dbname);
>
// 연결 확인
if ($conn->connect_error) {
    die("연결 실패: " . $conn->connect_error);
}
echo "연결 성공!";
?>

** 주의! **
연결 안될 시 페스워드 재설정 필요! >MySQL8.0 이상에서는 비밀번호 정책이 설정되어 충족하는 번호로 변경해야 함

1. 비밀번호 길이 최소 몇 글자 이상이여야 함
2. 대문자, 소문자, 숫자, 특수문자 등을 포함해야 함

   MySQL에서 변경 시
   ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'Strong_Password123!';

   conn.php 파일 | 정상 연결화면

---|---|

MySQL 비밀번호 정책 설정 변경

MySQL 설정 파일 (my.cnf 또는 my.ini)에서 비밀번호 정책을 변경

-----------------my.ini---------------------
[mysqld]
validate_password.policy=LOW
// MySQL 설정 파일을 열어서 [mysqld] 섹션에 다음과 같이 비밀번호 정책 관련 옵션을 추가

• 'LOW': 비밀번호 길이만 체크
• 'MEDIUM': 길이와 숫자/특수 문자 포함 여부 체크
• 'STRONG': 길이, 숫자, 특수 문자, 대문자/소문자 포함 여부 체크

MySQL 테이블과 PHP 연결

MySQL user 테이블 확인

users 테이블

User Info

user.php user테이블 연결확인

마무리

• MySQL와 PHP 연결이 안될 경우
  • MySQL 버전이 8.0이상일 경우 정책에 맞게 비밀번호 변경해보기
• WIFI연결 시 다른 로컬 기기에서도 user.php 접속해보기

콘솔 창 입력

php -v    //버전 확인 후 7.4이상 버전일 경우
---------------------7.4버전 이상일 경우 실행---------------------- 
sudo apt remove php* --purge    
sudo apt autoremove    // 기존 php 제거
>
sudo apt update    
sudo apt install software-properties-common
sudo add-apt-repository ppa:ondrej/php
sudo apt update    // PPA 저장소 추가
>
sudo apt install php7.4-cli php7.4-fpm php7.4-mysql php7.4-xml php7.4-mbstring php7.4-curl
// php7.4 버전으로 설치
-----------------------이상 없다면 생략 가능------------------------
>
sudo apt install libapache2-mod-php7.4    // Apache2 모듈 설치
>
sudo a2dismod php8.x  # 기존 PHP 8.x 모듈 비활성화 (설치된 경우)
sudo a2enmod php7.4
sudo systemctl restart apache2

> Apache2와 PHP 연결에 이상이 있다면 버전 문제일 수 있으므로 7.4로 재설치(권장) > php설치 후 libapache2-mod-php* 자신 PHP 버전에 맞는 Apache2설치 요망

PHP와 Nginx 연동

콘솔 창 입력

sudo nano /etc/nginx/sites-available/default

> Nginx 설정 파일 열고 PHP-FPM 소켓을 사용하도록 설정

    **    /etc/nginx/sites-available/default 파일 내용    **
    >
location ~ \.php$ {
    include snippets/fastcgi-php.conf;
    fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;  # PHP 7.4 FPM 소켓 경로
}

> /etc/nginx/sites-available/default에 위 코드 추가(PHP, Nginx연결)      -> 자신의 PHP 버전에 맞는 소켓으로 추가!

sudo systemctl restart php7.4-fpm
sudo systemctl restart nginx

> 설정 후 Nginx와 PHP-FPM 재시작

연결 확인

sudo nano /var/www/html/info.php 파일 생성

<?php phpinfo(); ?>

> /var/www/html/info.php 파일에 입력 후 접속

연결 확인

>> PHP 파일 생성 <<

index.php 파일 생성

<!DOCTYPE html>
<html>
<head>
    <title>PHP Example</title>
</head>
<body>
    <h1><?php echo "Hello, this is a PHP file."; ?></h1>
</body>
</html>

> /var/www/html/index.php파일 생성 후 코드 입력

index.php 파일	index.php 동작화면
> 만약 정상작동이 하지 않는다면 꼭 버전을 확인해보기

더 해보기

list.php 파일 제작해보기

<!DOCTYPE html>
<html>
<head>
    <title>User Information Table</title>
</head>
<body>
    <h2>User Information</h2>
<?php
// 사용자 정보를 담은 배열
$users = [
    ["name" => "Beom Su", "phone" => "010-1111-1111", "address" => "Seoul"],
    ["name" => "Gil Dong", "phone" => "010-2222-2222", "address" => "Busan"],
    ["name" => "Su Jin", "phone" => "010-3333-3333", "address" => "Gangwon"]
];
?>
<table>
    <tr>
        <th>Name</th>
        <th>Phone</th>
        <th>Address</th>
    </tr>
    <?php foreach ($users as $user) { ?>
    <tr>
        <td><?php echo htmlspecialchars($user["name"]); ?></td>
        <td><?php echo htmlspecialchars($user["phone"]); ?></td>
        <td><?php echo htmlspecialchars($user["address"]); ?></td>
    </tr>
    <?php }; ?>
</table>
</body>
</html>

list.php 화면

마무리

• 정상적으로 작동을 안한다면 PHP, Apache2버전, /etc/nginx/sites-available/default파일 안에 PHP-FPM버전이 자기 PHP버전과 일치한 지 확인해보기
• Apache2, Nginx의 포트가 중첩된 오류가 있을 수 있으니 포트도 확인해보기
• 다음엔 MySQL을 이용해 테이블 제작해보기

1. 기본 패키지 업데이트

콘솔 창 입력

sudo apt update

> 새로운 버전이 생겼을 수도 있으므로 업데이트 필요

2. 기본 설정 및 보안 설정

콘솔 창 입력

sudo apt install ufw
sudo ufw allow OpenSSH
sudo ufw enable

> SSH 및 방화벽 설정: 기본적으로 SSH를 통해 서버에 접근할 수 있도록 설정 > UFW(방화벽)를 설치하고 실행 시 항상 실행되도록 설정 > sudo ufw status로 상태확인 가능

콘솔 창 입력

sudo nano /etc/ssh/sshd_config
sudo systemctl restart ssh

> 'PermitRootLogin no': 루트 사용자로 SSH 접속을 차단 > 'PasswordAuthentication yes': 비밀번호 인증 허용(키 인증으로 변경 권장)

3. 웹 서버 서비스 설치 및 구성

콘솔 창 입력

sudo apt install nginx -y
sudo systemctl start nginx
sudo systemctl enable nginx

> nginx(웹 서버 서비스)시작 및 자동 실행 설정

콘솔 창 입력

sudo nano /etc/nginx/sites-available/default

> nginx 기본 설정 파일 편집

sudo nano /etc/nginx/sites-available/default 파일 내용

server {
    listen 81 default_server; // nginx와 apache2의 포트가 80번 충돌이 있을 수 있으므로 포트 조정
    listen [::]:81 default_server;
>
    root /var/www/html;
    index index.html index.htm index.nginx-debian.html index.php;
>
    server_name _;
>
    location / {
        try_files $uri $uri/ =404;
    }
>
    location ~ \.php$ { // 추후 php 연결을 위해 설정
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php7.4-fpm.sock;
    }
}

>> php7.4이상은 연결이 다르므로 php7.4버전으로 설치 <<      -> 혹시 다른 7.4이상 버전으로 방법이 있다면 알려주세요ㅠㅠ 'server' 블록 안 기본 루트 디렉토리 설정 'sudo systemctl reload nginx'    -> 'http://your_server_ip' 주소로 접속을 통해 welcome 페이지 확인

>>웹 페이지 설정<<

1. 기본 웹 페이지 디렉터리

콘솔 창 입력

cd /var/www/html

> nginx의 기본 웹 페이지 파일은 '/var/www/html' 디렉터리에 존재

2. 기본 인덱스 파일 수정

콘솔 창 입력

sudo nano index.html

> 접속 후 편집

/var/www/html/index.html파일

<!DOCTYPE html>
<html>
<head>
<title>Welcome to Nginx!</title>
</head>
<body>
    <h1>Success! Your Nginx server is working!</h1>
</body>
</html>

> 'uccess! Your Nginx server is working!'문구가 뜨면 정상 작동!

< 정상 작동 화면(index.html) >

3. 로컬에서 도메인명 사용

콘솔 창 입력

sudo nano /etc/hosts

> 접속 후 도메인과 IP주소 매핑 추가(your_server_ip www.beomsu.com)

ip주소 도메인으로 변경	www.beomsu.com으로 접속 확인

마무리

• nginx와 apache2의 포트 충돌 주의
  
• php7.4이상은 연결 방법이 다르므로 php7.4로 설치하는 것 추천
  

목차

1. 프로젝트 생성하기
2. View 환경설정
3. 스프링 웹 개발 기초
4. 회원 관리 예제
5. 스프링 빈과 의존 관계
6. 웹 MVC 제작
7. DB 제작(1)
8. DB 제작(2)
9. AOP

1. AOP

회원 조회 시간 측정 추가

 public Long join(Member member) {
     long start = System.currentTimeMillis();    //시작 시간 측정
     try {
         validateDuplicateMember(member); //중복 회원 검증
        memberRepository.save(member);
         return member.getId();
    }finally {
         long finish = System.currentTimeMillis();    // 종료 시간 측정
         long timeMs = finish - start;
         System.out.println("join " + timeMs + "ms"); // 총 시간 = 종료 시간 - 시작 시간
    }
}
// 회원가입 함수

<<문제점>>

1. 시간 측정은 핵심 로직이 아님(But 시간 측정 로직은 공통 사항)
2. 시간을 측정하는 로직과 핵심 비즈니스의 로직이 섞여서 유지보수 어려움(별도의 공통 로직으로 만드는 것도 힘듬)
3. 시간 측정 로직을 변경할 때 모든 로직을 찾아서 변경해야 함

AOP 적용

@Component    // @Bean으로도 등록 가능(선호)
@Aspect
public class TimeTraceAop {
   @Around("execution(* hello.hellospring..*(..))") // hello.hellospring 하위 모두 실행
    public Object execute(ProceedingJoinPoint joinPoint) throws Throwable {
             long start = System.currentTimeMillis();
             System.out.println("START: " + joinPoint.toString());
         try {
             return joinPoint.proceed();
        }finally {
             long finish = System.currentTimeMillis();
             long timeMs = finish - start;
             System.out.println("END: " + joinPoint.toString()+ " " + timeMs + "ms");
        }
     }
}
//hello.hellospring.aop.TimeTraceAop.java

<<해결>>

• 시간을 측정하는 로직을 별도의 공통 로직으로 제작
• 변경 시에도 공통 로직만 변경하면 됨(타겟팅도 가능)

AOP 동작 방식

<<기존 스프링 컨테이너>> [컨트롤러 -> 서비스]

<<AOP 적용 후 의존 관계>> [컨트롤러 -> 서비스(프록시) ->joinPoint.proceed()-> 서비스(실제)]

• AOP의 Around범위를 지정하면 서비스가 지정되면서 프록시 생성
• 컨트롤러가 프록시를 호출한 후 실제 서비스와 proceed가 함께 호출

목차

1. 프로젝트 생성하기
2. View 환경설정
3. 스프링 웹 개발 기초
4. 회원 관리 예제
5. 스프링 빈과 의존 관계
6. 웹 MVC 제작
7. DB 제작(1)
8. DB 제작(2)
9. AOP

4. 더 간단한 DB

JdbcTemplate

 public class JdbcTemplateMemberRepository implements MemberRepository {

     private final JdbcTemplate jdbcTemplate;

     public JdbcTemplateMemberRepository(DataSource dataSource) {
        jdbcTemplate = new JdbcTemplate(dataSource);
    }
    ...
 }

 //JdbcTemplateMemberRepository.java

• JdbcTemplate 사용을 위해 DataSource 주입

 @Override
 public Member save(Member member) {
     SimpleJdbcInsert jdbcInsert = new SimpleJdbcInsert(jdbcTemplate); 
    jdbcInsert.withTableName("member").usingGeneratedKeyColumns("id");

     Map<String, Object> parameters = new HashMap<>();
    parameters.put("name", member.getName()); //(필드이름, 값)

     Number key = jdbcInsert.executeAndReturnKey(new MapSqlParameterSource(parameters));
    member.setId(key.longValue());
     return member;
}

 // JdbcTemplateMemberRepository.java > 저장 부분

• jdbcInsert.withTableName("member").usingGeneratedKeyColumns("id");
  • member테이블의 id를 자동 증가 값 추가(앞서 사용했던 id Generated Key와 같음)
• jdbcInsert.executeAndReturnKey(new MapSqlParameterSource(parameters));
  • executeAndReturnKey 메서드는 데이터베이스에 쿼리를 실행
  • MapSqlParameterSource는 이름-값 쌍으로 매핑된 파라미터를 제공
    • parameters를 Map형태로 설정한 이유!

@Override
public Optional<Member> findByName(String name) {
    List<Member> result = jdbcTemplate.query("select * from member where name = ?", memberRowMapper(), name);
     return result.stream().findAny();
} //이름으로 조회 기능

private RowMapper<Member> memberRowMapper() {
    return (rs, rowNum) -> {
         Member member = new Member();
        member.setId(rs.getLong("id"));
        member.setName(rs.getString("name"));
         return member;
     };
} // memberRowMapper구현 코드

• RowMapper는 데이터베이스의 반환 결과인 ResultSet을 객체로 변환해 주는 클래스
  • 기존 Jdbc에서는 각 값을 일일이 get해주어야하는 수고로움을 자동화 해줌
• jdbcTemplate.query("select * from member where name = ?", memberRowMapper(), name);
  • sql에 맞는 name이 매칭되면 RowMapper후 매핑된 값을 반환

 @Bean
 public MemberRepository memberRepository() {
     //return new MemoryMemberRepository();
     //return new JdbcMemberRepository(dataSource);
     return new JdbcTemplateMemberRepository(dataSource);
}
// SpringConfig.java

• 스프링 컨테이너의 빈 모듈을 교체해줘야 함으로 JdbcTemplateMemberRepository(dataSource);로 교체

  테스트 정상 작동

JPA

& 반복 코드는 물론이고, 기본적인 SQL도 JPA가 직접 만들어서 실행

 implementation 'org.springframework.boot:spring-boot-starter-jdbc'
 implementation 'org.springframework.boot:spring-boot-starter-data-jpa

 // build.gradle > dependencies

• build.Gradle의 Dependencies jdbc에서 jpa로 수정

 spring.jpa.show-sql=true
 spring.jpa.hibernate.ddl-auto=none

 // application.properties

• application.properties에 show-sql, hibernate.ddl 추가
  • show-sql=true는 JPA가 생성하는 SQL을 출력
  • hibernate.ddl-auto=none는 자동으로 테이블 생성x
    • auto=create는 엔티티 정보를 바탕으로 테이블 자동 생성

 @Entity
 public class Member {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
     private String name;
    ...
}

// Member.java

• @Entity는 DB 테이블과 Jpa를 매핑
  • DB에 생성했던 Member 테이블의 이름과 class의 이름으로 매핑
• @ID는 엔티티의 기본 키 필드를 나타냄
  • DB 테이블의 기본 키 열과 매핑
• @GeneratedValue(strategy = GenerationType.IDENTITY)는 기본 키 값을 자동으로 생성하는 옵션
• 나머지 칼럼은 자동으로 매핑

 public class JpaMemberRepository implements MemberRepository{

     private final EntityManager em; // ENtityManager 생성

     public JpaMemberRepository(EntityManager em) {
         this.em = em;
    }

     public Member save(Member member) {    // 저장
        em.persist(member);    // DB 저장
         return member;
    }

     public Optional<Member> findById(Long id) {    // id로 찾기
         Member member = em.find(Member.class, id); //@id 기반으로 검색
         return Optional.ofNullable(member);
    }

     public List<Member> findAll() {    // 모두 찾기
         return em.createQuery("select m from Member m", Member.class)
                  .getResultList(); // alias로 전체 조회
    }

    public Optional<Member> findByName(String name) {  // 이름으로 찾기
         List<Member> result = em.createQuery("select m from Member m where m.name = :name", Member.class)
                .setParameter("name", name)
                .getResultList();
         return result.stream().findAny();
    }
 }

 // JpaMemberRepository.java

• EntityManager: 엔티티의 영구 저장과 관리를 담당
• persist(): 메서드는 전달된 엔티티 객체를 영구 저장소에 저장하고, 관리 상태로 전환
• find(table.class, id): 주어진 엔티티 클래스와 @id id를 기반으로 데이터베이스에서 엔티티를 찾음
  • 회원ID 기반이 아닌 @ID로 설정한 ID로 조회
• createQuery(sql, T.class): 테이블 클래스에 Sql 쿼리 전송
  • *대신 alias를 사용해 전체 조회

테스트 및 Hibernate=true 확인

스프링 데이터 JPA

• 리포지토리에 구현 클래스 없이 인터페이스 만으로 개발 가능
• CRUD 기능 제공
• 스프링 데이터 JPA는 JPA를 편리하게 사용하도록 도와주는 기술
  • JPA 완전 이해 필요!

 public interface SpringDataJpaMemberRepository extends JpaRepository<Member, Long>, MemberRepository {
     @Override
     Optional<Member> findByName(String name);
 }

 // SpringDataJpaMemberRepository.java(인터페이스)

• 스프링 데이터 JPA가 SpringDataJpaMemberRepository를 스프링 빈으로 자동 등록
  • 인터페이스를 보고 자동으로 등록해줌
• JpaRepository는 기본적으로 사용되는 조회, 저장, 삭제 등을 포함하고 있음
  • findBy(컬럼명) 등으로 간단하게 기본적인 조회 가능

    ...
 private final MemberRepository memberRepository;

 public SpringConfig(MemberRepository memberRepository) {
     this.memberRepository = memberRepository;
 }

    @Bean
 public MemberService memberService() {
     return new MemberService(memberRepository);
 }
     ...

 // SpringConfig.java

• memberRepository만 등록해주면 자동으로 JPA로 연결가능

목차

1. 프로젝트 생성하기
2. View 환경설정
3. 스프링 웹 개발 기초
4. 회원 관리 예제
5. 스프링 빈과 의존 관계
6. 웹 MVC 제작
7. DB 제작(1)
8. DB 제작(2)
9. AOP

1. H2 데이터베이스

H2 데이터베이스 설치

• https://www.h2database.com 방문 후 다운로드!

H2 데이터베이스 초기 설정

h2.jar File로 접속	h2접속(localhost:8082)

test.mv.DB 생성 확인	test.db 화면

1. Install 후 prgramFile > H2 > bin > h2.Jar File로 접속
2. 페이지 로드 후 연결(img2)
   • 페이지 주소명 앞 부분 localhost:8082로 변경
3. Users에 test.mv.DB파일이 생성된 것을 확인할 수 있다.
   • test파일 생성한 후에는 img2의 URL을 jdbc:h2:tcp://localhost/~/test 변경 후 접속
4. 정상적으로 testDB를 생성한 것을 확인 가능

H2 데이터베이스 사용해보기

* Member 테이블을 생성된 것을 확인할 수 있다.
* bigint는 Java에서 Long 자료형을 의미
* 칼럼 값을 자동으로 증가를 위한 generated by default as identify 설정

* Member 테이블에 홍길동 추가
* generated by default as identify를 설정했기 때문에 pk없이 추가 가능
* (1, 홍길동)이라는 값이 제대로 들어있는 것을 조회해볼 수 있다.

2. 순수JDBC

IntelliJ 환경 설정

implementation 'org.springframework.boot:spring-boot-starter-jdbc'
runtimeOnly 'com.h2database:h2'

//build.gradle에 라이브러리 추가

• build.gradle에 spring-boot-starter-jdbc 추가
  • Spring에 Jdbc를 연결하기 위해 추가
• com.h2database:h2 라이브러리 추가

spring.datasource.url=jdbc:h2:tcp://localhost/~/test
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa

//resources > application.properties에 추가

• 스프링에 H2를 연결했기 때문에 접속을 위한 설정 추가
  • H2 DB생성 및 연결 시 사용하는 값과 동일
  • 스프링부트 2.4부터는 spring.datasource.username=sa를 꼭 추가

JDBC 리포지토리 구현

public class JdbcMemberRepository implements MemberRepository{

    //javax.sql.DataSource 사용
    private final DataSource dataSource;

    public JdbcMemberRepository(DataSource dataSource) {
        this.dataSource = dataSource;
    }

• JdbcMemberRepository 생성
• spring.datasource는 DB 연결에 관한 예약된 key
  • driver-class-name, url, username, password 속성 필요
• this.dataSource = dataSource를 통해 스프링 부트의 DBSource 주입
  • application.properties에서 세팅한 값을 통해 스프링 부트 DBSource 제작

@Override
    public Member save(Member member) {
        String sql = "insert into member(name) values(?)";
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;

        try {
            conn = getConnection(); // DB 연결
            // sql 전송
            pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            pstmt.setString(1, member.getName()); // sql의 첫번째 '?'에 대입
            pstmt.executeUpdate(); // DB에 데이터 전송
            rs = pstmt.getGeneratedKeys();
            if (rs.next()) {
                member.setId(rs.getLong(1));
            } else {
                throw new SQLException("id 조회 실패");
            }
            return member;
        } catch (Exception e) {
            throw new IllegalStateException(e);
        } finally {
            close(conn, pstmt, rs);
        }
    }
 // JdbcMemberRepositiory > Save 기능

• pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);의 Statement.RETURN_GENERATED_KEYS는 기존 DB내에서 ID값을 자동으로 생성되도록 설정했으므로 Spring에서 값을 받기 위해 사용한 옵션
  • 즉 rs = pstmt.getGeneratedKeys();의 값을 받기 위해 사용
  • pstmt.executeUpdate();는 값을 받아올 수 없음
• 연결한 기능을 모두 사용한 후 항상 close로 마무리
  • 계속 연결되어 있으면 오류 및 장애 발생

@Override
    public List<Member> findAll() {
        String sql = "select * from member";

        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;

        try {
            conn = getConnection(); // DB 연결
            pstmt = conn.prepareStatement(sql); // sql 전송

            rs = pstmt.executeQuery(); // 데이터 받음

            List<Member> members = new ArrayList<>();
            while (rs.next()) { // 값이 있을 때까지 반복
                Member member = new Member();
                member.setId(rs.getLong("id"));
                member.setName(rs.getString("name"));
                members.add(member);
            }

            return members;
        } catch (Exception e) {
            throw new IllegalStateException(e);
        } finally {
            close(conn, pstmt, rs); // 연결 종료
        }
    }
 // JdbcMemberRepository > 조회(findAll) 기능

• executeQuery();는 excuteUpdate()와 달리 쿼리 값을 받음

SpringConfig 설정

@Bean
public MemberRepository memberRepository(){
    //return new MemoryMemberRepository();
    return new JdbcMemberRepository(dataSource);
}
//SpringConfig.java

• 컨테이너 안의 MemoryMemberRepository를 JdbcMemberRepository로 변경해 쉽게 전환 가능
  • 서비스-메모리(리)의 연결을 서비스-Jdbc(리)로 변경

돌려보기

* H2 DB에서 넣어놨던 Member 테이블 값이 조회되는 것을 확인 가능
* Spring과 DB가 잘 연결되어 있음을 확인 가능

* 데이터 삽입 또한 잘되는 것을 확인할 수 있다.

3. 스프링 통합 테스트

코드 작성

 @SpringBootTest
 @Transactional
 class MemberServiceIntegrationTest {
    @Autowired MemberService memberService;
    @Autowired MemberRepository memberRepository;
    @Test
     public void 회원가입() throws Exception {
         //Given
         Member member = new Member();
        member.setName("hello");
         //When
         Long saveId = memberService.join(member);
        //Then
         Member findMember = memberRepository.findById(saveId).get();
         assertEquals(member.getName(), findMember.getName());
    }
    @Test
     public void 중복_회원_예외() throws Exception {
         //Given
         Member member1 = new Member();
        member1.setName("spring");
         Member member2 = new Member();
        member2.setName("spring");
         //When
        memberService.join(member1);
         IllegalStateException e = assertThrows(IllegalStateException.class,
                () -> memberService.join(member2));//예외가 발생해야 한다.
         assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
    }
 }

 // MemberServiceIntegrationTest.java

회원가입	테스트 확인	DB에 커밋 X

@Commit 후 실행	DB에 커밋 O

• @SpringBootTest는 스프링 컨테이너와 테스트 실행
  • JDBC를 이용하기 위해선 스프링 컨테이너 필요!
• @Transactional는 독립적인 DB테스트 실행 가능
  • 테스트 시작 전에 트렌젝션을 시작하고 테스트 완료 후 항상 롤백
  • @Commit을 통해 커밋도 가능

목차

1. 프로젝트 생성하기
2. View 환경설정
3. 스프링 웹 개발 기초
4. 회원 관리 예제
5. 스프링 빈과 의존 관계
6. 웹 MVC 제작
7. DB 제작(1)
8. DB 제작(2)
9. AOP

1. 회원 웹 기능

홈 화면 추가

@Controller
public class HomeController {
    @GetMapping("/")    // localhost:8080
    public String home(){
        return "home";
    }
}
// HomeController.java

• ("/")는 index.html대신 localhost:8080에서 기본 동작
  • spring 순서: 스프링 컨테이너(컨트롤러) -> static 순 즉 index.html보다 "/"이 먼저 동작하게 됨

등록 폼 추가

    ...
@GetMapping("/members/new")    // /members/new를 받음
public String createForm() {
    return "members/createForm";    //members/createFrom.html 이동
}

@PostMapping(value = "/members/new")    // members/new를 받음
public String create(MemberForm form) {
    Member member = new Member();
    member.setName(form.getName());
    memberService.join(member);    //회원 가입
    return "redirect:/";    // 홈화면으로 이동
}
    ...

//MemberController.java 추가

• 이름을 summit하게 되면 리포지토리로 값 전달 후 홈 화면 이동
• memberService와 연결된 컨트롤러인 memberController안에서 동작할 수 밖에 없음

<div class="container">
    <form action="/members/new" method="post">
        <div
                class="form-group">
            <label
                    for="name">이름</label>
            <input
                    type="text" id="name" name="name" placeholder="이름을 입력하세요">
        </div>
        <button type="submit">등록</button>
    </form>
</div>
//createForm.html

• summit하게되면 리포지토리에 저장(save()함수 실행)
  • join() 제작 시 추가한 중복 값 예외 코드때문에 동일한 값 저장X
• action="/members/new"로 전송하기 때문에 @postMapping을 "/members/new"로 받게 됨
  • action="hi"이면 @postMapping("/members/hi")로 전달 가능
  • createForm.html이 members안의 파일임으로 action="hi"는 /members/hi로 전송하게 됨

조회 기능 추가

@GetMapping("/members")    //     /members시 동작
public String list(Model model){
    List<Member> members = memberService.findMembers();
    model.addAttribute("members",members);
    return "members/memberList";
}

• member의 전체 리스트를 조회 후 List에 저장
• "members"이름으로 model에 members 리스트를 담은 후 memberList.html로 전송

<div class="container">
    <div>
        <table>
            <thead>
            <tr>
                <th>#</th>
                <th>이름</th>
            </tr>
            </thead>
            <tbody>
            <tr th:each="member : ${members}">
                <td th:text="${member.id}"></td>
                <td th:text="${member.name}"></td>
            </tr>
            </tbody>
        </table>
    </div>
</div>

• each를 통해 ${members}로 받은 members리스트를 반복
  • 반복되는 각 member의 id와 name을 출력

목차

1. 프로젝트 생성하기
2. View 환경설정
3. 스프링 웹 개발 기초
4. 회원 관리 예제
5. 스프링 빈과 의존 관계
6. 웹 MVC 제작
7. DB 제작(1)
8. DB 제작(2)
9. AOP

1. 컴포넌트 스캔과 자동 의존 관계

member 컨트롤러 생성

@Controller    //@Component 대체 가능
public class MemberController {
    private final MemberService memberService;

    @Autowired //컨트롤러 서비스 연결     //에러 발생 - 서비스, 리포지토리 등록x
    public MemberController(MemberService memberService) {
        this.memberService = memberService;
    }
}

• 생성자에 @Autowired가 있으면 스프링이 연관된 객체를 스프링 컨테이너에서 찾아서 넣어준다.
  • 객체 의존관계를 외부에서 넣어주는 것을 DI (Dependency Injection), 의존성 주입이라 한다.
• 실행 시 에러 발생
  • 서비스, 리포지토리 등록X
• helloController는 스프링이 제공하는 컨트롤러여서 스프링 빈으로 자동 등록
• @Component 스프링에서 사용되는 가장 기본적인 annotation
  • scan-auto-detection과 DI을 사용하기 위해서 스프링 컨테이너에 등록하는 기본 annotation
  • Spring에서는 컨트롤러, 서비스, 리포지토리 annotation 추천

서비스, 리포지토리 객체 생성

@Service    //서비스 객체 등록
public class MemberService {
    ...
} //MemberService.java

@Repository    //리포지토리 객체 등록
public class MemoryMemberRepository implements MemberRepository{
    ...
}//MemoryMemberRepository.java

• 서비스, 리포지토리 객체 등록
  • 객체들 간의 연결을 안해주어 여전히 에러 발생
• 스프링은 스프링 컨테이너에 스프링 빈을 등록할 때, 기본으로 싱글톤으로 등록

객체 간 연결(@Autowired)

    ...
@Autowired //서비스 객체 연결
public MemberController(MemberService memberService) {
   this.memberService = memberService;
}    
    ...    // MemberConcroller.java

    ...
@Autowired // 리포지토리 객체 연결
public MemberService(MemberRepository memberRepository) {
    this.memberRepository = memberRepository;
}    
    ...    //MemberService.java

• 동작 시 스프링 애플리케이션이 정상 작동하게 된다.
  • 스프링 컨테이너에 등록 되있을 시 정상 작동(주의)
• 필드 주입, setter 주입, 생성자 주입 이렇게 3가지 방법이 있다. 의존관계가 실행중에 동적으로 변하는 경우는 거의 없으므로 생성자 주입을 권장
  • 보안, 편의성 좋음

2. 자바 코드로 직접 스프링 빈 등록

SpringConfig 생성

@Configuration
public class SpringConfig {

    @Bean    // 컨테이너에 등록
    public MemberService memberService(){
        return new MemberService(memberRepository());
    }

    @Bean
    public MemberRepository memberRepository(){
        return new MemoryMemberRepository();
    }
}    //SpringConfig.java

• @Bean 서비스, 리포지토리를 통해 빈에 등록
  • MemberService(memberRepository());을 통해 서비스와 리포지토리 연결

장단점

• 실무에서는 주로 정형화된 컨트롤러, 서비스, 리포지토리 같은 코드는 컴포넌트 스캔을 사용
• 정형화 되지 않거나, 상황에 따라 구현 클래스를 변경해야 하면 설정을 통해 스프링 빈으로 등록
  • 코드를 수정할 필요 없이 쉽게 변경 가능

목차

1. 프로젝트 생성하기
2. View 환경설정
3. 스프링 웹 개발 기초
4. 회원 관리 예제
5. 스프링 빈과 의존 관계
6. 웹 MVC 제작
7. DB 제작(1)
8. DB 제작(2)
9. AOP

1. 비즈니스 요구사항 정리

요구사항

• 데이터: 회원ID, 이름
• 기능: 회원 등록, 조회
• 아직 데이터 저장소가 선정되지 않음(가상의 시나리오)

2. 회원 도메인과 리포지토리 만들기

회원 객체

public class Member {
     private Long id;
     private String name;
     public Long getId() {
         return id;
     }
     public void setId(Long id) {
         this.id = id;
    }
    public String getName() {
         return name;
    }
     public void setName(String name) {
         this.name = name
    }
 }

• getter and setter를 이용해 id, name에 관한 Member클래스 생성
  • 단축키 Alt + Insert 사용

회원 리포지토리

 public interface MemberRepository {
    Member save(Member member);
    //null값을 optional로 가공 후 반환
    Optional<Member> findById(Long id); 
    Optional<Member> findByName(String name);
    List<Member> findAll();
}
// 회원 리포지토리 인터페이스

• 리포지토리에 가공하기 위한 기본적인 인터페이스들을 생성

public class MemoryMemberRepository implements MemberRepository{

    private  static Map<Long, Member> store = new HashMap<>();
    private static long sequence = 0L;

    @Override
    public Member save(Member member) {
        member.setId(++sequence);
        store.put(member.getId(),member);
        return member;
    }

    @Override
    public Optional<Member> findById(Long id) {
        return Optional.ofNullable(store.get(id));  //NULL값 반환 시 Optional로 감싸서 NULL값을 반환
    }

    @Override
    public Optional<Member> findByName(String name) {
        return store.values().stream()     // 루프
                .filter(member -> member.getName().equals(name))  // name과 값이 같을 시 필터링
                .findAny();     // 찾으면 반환
    }

    @Override
    public List<Member> findAll() {
        return new ArrayList<>(store.values());
    }

    public void clearStore(){
        store.clear();
    }
}
//회원 리포지토리 메모리 구현체

• 생성한 인터페이스의 기능을 구현
  • Map<>을 통해 회원 정보 저장
  • 편리성을 위해 List findAll()에서 List 사용
  • store.clear(); 함수는 리포지토리 초기화해주는 함수

테스트 케이스 작성

• 기존에는 main메소드, 컨트롤러에서 테스트를 진행
  • 준비과정, 반복진행 등 어려움 발생
• JUnit이라는 프레임워크로 테스트를 실행해서 이러한 문제를 해결

class MemoryMemberRepositoryTest {
    MemoryMemberRepository repository = new MemoryMemberRepository();


      @AfterEach    // 각 테스트 진행 후 동작
    public void afterEach(){
        repository.clearStore();
      }    

    @Test
    public void save(){
          //given
        Member member = new Member();
        member.setName("spring");
        //when
        repository.save(member);
        //then
        Member result = repository.findById(member.getId()).get();
        Assertions.assertEquals(result,member);   // (값, 비교값) 동일 시 무응답, 다를 시 값 반환
        assertThat(member).isEqualTo(result);
    }

    @Test
    public void findByName(){
        Member member1 = new Member();
        member1.setName("spring1");
        repository.save(member1);

        Member member2 = new Member();
        member2.setName("spring2");
        repository.save(member2);

        Member result = repository.findByName("spring1").get();

        assertThat(result).isEqualTo(member1);
    }

    @Test
    public void findAll(){
        Member member1 = new Member();
        member1.setName("spring1");
        repository.save(member1);

        Member member2 = new Member();
        member2.setName("spring1");
        repository.save(member2);

        List<Member> result = repository.findAll();
        assertThat(result.size()).isEqualTo(2);
    }
}
//회원 리포지토리 테스트 케이스

• 단축키 Ctrl + Shift + T 사용
• 각 테스트 케이스를 작성하여 main, 컨트롤러에서 하는 것 보다 안전하고 쉽게 테스트 가능
• 전체 테스트 케이스 동작 시 findByName과 findAll의 member값이 중복되어 에러 발생
  • @AfterEach를 통해 각 테스트마다 store.clear(); 진행(스토리지 초기화)
• assertThat(비교값).isEqualTo(비교 대상); 값이 같을 시 true, false를 반환(비교 함수)

3. 회원 서비스 개발

서비스 구현

public class MemberService {
    private final MemberRepository memberRepository;

    public MemberService(MemberRepository memberRepository) {  
        this.memberRepository = memberRepository;
    }

    public Long join(Member member){    // 회원 가입
        validateDuplicateMember(member);    // 중복 회원 검증
        memberRepository.save(member);
        return member.getId();
    }

    private void validateDuplicateMember(Member member) {   // 중복회원검증
        memberRepository.findByName(member.getName())
                .ifPresent(m -> {                       // findByName값이 도출될 시 동작
                    throw new IllegalStateException("이미 존재하는 회원입니다.");
                });
    }

    public List<Member> findMembers(){
        return memberRepository.findAll();
    }   // 전체 맴버 출력
    //Java에서는 대부분 List 사용(편의성)
    public Optional<Member> findOne(Long memberId){
        return memberRepository.findById(memberId);
    }   // 회원 검색(Id)
}
// 회원 서비스 

• 서비스는 비즈니스적인 요소(회원가입, 조회 등)를 구현

  before> private final MemberRepository memberRepository = 
  new MemoryMemberRepository();
  

after> public MemberService(MemberRepository memberRepository) { this.memberRepository = memberRepository; }

* 회원 서비스가 메모리 회원 리포지토리를 직접 생성(사실 상 기존 리포지토리와 다른 메모리 리포지토리 생성)
  * 회원 리포지토리의 코드가 회원 서비스 코드를 DI 가능하게 변경

> 서비스 테스트 케이스

class MemberServiceTest {

MemberService memberService;
MemoryMemberRepository memberRepository;

@BeforeEach    // 항상 새로운 객체 생성
public void beforeEach(){
    memberRepository = new MemoryMemberRepository();
    memberService = new MemberService(memberRepository);
}

@AfterEach    // 리포지토리 초기화
public void afterEach(){
    memberRepository.clearStore();
}

@Test
void 회원가입() {
    //given
    Member member = new Member();
    member.setName("park");
    //when
    Long saveId = memberService.join(member);
    //then
    Member findMember = memberService.findOne(saveId).get();
    assertThat(member.getName()).isEqualTo(findMember.getName());

}

@Test
void 중복회원() {
    //given
    Member member1 = new Member();
    member1.setName("park");

    Member member2 = new Member();
    member2.setName("park");

    //when
    memberService.join(member1);
    IllegalStateException e = assertThrows(IllegalStateException.class,
            () -> memberService.join(member2));//예외가 발생해야 한다.
    assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");

    //then
}

}

*  @BeforeEach 각 테스트 실행 전에 호출되어 테스트가 서로 영향이 없도록 항상 새로운 객체를 생성하고, 의존관계도 새로 맺어준다
* 테스트 케이스는 main 코드가 아니므로 가독성을 위한 클래스 명으로 생성 가능(회원가입, 중복회원 등)

목차

1. 프로젝트 생성하기
2. View 환경설정
3. 스프링 웹 개발 기초
4. 회원 관리 예제
5. 스프링 빈과 의존 관계
6. 웹 MVC 제작
7. DB 제작(1)
8. DB 제작(2)
9. AOP

1. 정적 컨텐츠

정적 페이지 제작

static > static.html 제작	8080:static.html

정적 페이지의 구동 과정

• localhost:8080/static.html -> 톰캣 서버 -> 스프링 컨테이너
  • static 관련 컨트롤러 확인
• 없을 시 resources: static/static.html 확인
  • 확인 시 출력

2. MVC와 템플릿 엔진

• MVC: Model, View, Controller

  Controller

@GetMapping("hello-mvc")
public String helloMvc(@RequestParam("name") String name, Model model){
    model.addAttribute("name", name);
    return "hello-template";
}
//controller

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>hello</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
<p th:text="'hello ' + ${name}"> hello empty!</p>
</body>
</html>
//resources/templates/hello-template.html

hello-mvc	hello-mvc?name=spring!!

hello-mvc가 호출될 시 name 파라미터를 받아 hello-template에 model("name", name)로 전송하게 된다.

• Required request parameter 'name' for method parameter type String is not present 즉 name 파라미터의 값이 없다는 애러가 발생하게 된다.
• hello-mvc?name=spring!!을 통해 파라미터 값을 지정해 hello spring!! 출력
  • public String helloMvc(@RequestParam("name") String name, Model model) 생성 시 파라미터"name"의 값을 받기로 한 것을 확인할 수 있다.

MVC, 템플릿 엔진 구동 과정

• localhost:8080/hello-mvc -> 톰캣 서버 -> 스프링 컨테이너
  • hello-mvc 관련 컨트롤러 확인
  • 확인 후 return hello-template, model("name", name) 전송
• 컨트롤러 -> viewResolver -> hello-template.html
  • model 값을 통해 html 변환 후 처리

3. API

String 전송

@GetMapping("hello-string")
@ResponseBody // http body에 직접 삽입
public String helloString(@RequestParam("name") String name,Model model){
        return "hello" + name;
    }
 //string 컨트롤러

• return 값인 hello + name 문자 그대로 출력되는 것을 확인할 수 있다.

JSON 전송

@GetMapping("hello-api")
@ResponseBody
public Hello helloApi(@RequestParam("name") String name){
    Hello hello = new Hello();
    hello.setName(name);
    return hello;
}
//api 컨트롤러

static class Hello{
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
//자바 빈 표준 방식(프로퍼티 접근 방식)

• JSON 형식(키-값 쌍)으로 출력되는 것을 확인할 수 있다.

@ResponseBody 구동 과정

• HTTP의 BODY에 문자 내용을 직접 반환
  • 'viewResolver 대신에 'HttpMessageConverter'가 동작
  • 기본 문자처리: 'StringHttpMessageConverter'
  • 기본 객체처리: 'MappingJackson2HttpMessageConveter'
  • byte 처리 등등 기타 여러 HttpMessageConveter가 기본으로 등록
  • hello-api -> 톰캣 서버 -> 스프링 컨테이너
  • @ResponseBody(return:hello(name:spring)) -> HttpMessageConveter
  • JsonConveter, StringConverter 중 키-값 쌍인 Json형식으로 출력

목차

1. 프로젝트 생성하기
2. View 환경설정
3. 스프링 웹 개발 기초
4. 회원 관리 예제
5. 스프링 빈과 의존 관계
6. 웹 MVC 제작
7. DB 제작(1)
8. DB 제작(2)
9. AOP

1. Welcome Page 만들기

인덱스 페이지 만들기

<!DOCTYPE HTML>
<html>
<head>
    <title>static content</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
<a>hello</a>
</body>
</html>

Resources > static > index.html 추가

• 8080포트에 접속 시 "hello"라는 문구 확인 가능
• static 파일에 정적 페이지(index.html) 제작 가능

thymeleaf 템플릿 엔진 동작

 @Controller
 public class HelloController {
    @GetMapping("hello")
 public String hello(Model model) {
        model.addAttribute("data", "hello!!");
 return "hello";
    }
 }
 // Java > controller > HelloController.java

 <!DOCTYPE HTML>
 <html xmlns:th="http://www.thymeleaf.org">
 <head>
    <title>Hello</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
 </head>
 <body>
 <p th:text="'안녕하세요. ' + ${data}" >안녕하세요. 손님</p>
 </body>
 </html>
 // resources > templates > hello.html

model의 <data, hello!!>가 hello.html에서 반환되는 것을 확인할 수 있다.

• 컨트롤러의 리턴 값에 대응하는 html에 동작하는 것을 알 수 있다.
• 컨트롤러 >> return hello, model(data: hello!) >> viewResolver >> hello.html

CMD창으로 실행해보기

gradlew.bat 실행	build>libs 이동

java -jar 실행	8080/hello 화면

• cmd창에서 프로젝트 파일로 이동한 뒤 gradlew.bat(window시) -> build -> libs 순으로 이동하다 보면 hellow-spring-0.0.1-SNAPSHOT.jar를 찾을 수 있다.
• java -jar hellow-spring-0.0.1-SNAPSHOT.jar를 실행하게 되면 IntelliJ에서 보았던 화면이 보이게 된다.

목차

1. 프로젝트 생성하기
2. View 환경설정
3. 스프링 웹 개발 기초
4. 회원 관리 예제
5. 스프링 빈과 의존 관계
6. 웹 MVC 제작
7. DB 제작(1)
8. DB 제작(2)
9. AOP

1.프로젝트 환경 설정

사전 준비물

• Java 17이상 설치
• IDE:IntelliJ 설치

스프링 부트 스타터 사이트 이용 https://start.spring.io

• 프로젝트 선택
  • Project: Gradle-Groovy Project
  • Language: Java
  • Spring Boot: 3.2.2
• Dependencies
  • Spring Web
  • Thymeleaf

2. 프로젝트 생성

프로젝트 IntelliJ에 연동하기

• 생성한 파일의 경로로 Intellij 연동 (프로젝트 생성 시 지정한 Project MataData: Name으로 프로젝트 생성)

Gradle 둘러보기

• 플러그
  • Java, version 3.2.2
• JAVA
  • Java 17버전
• Dependencies

  - thymeleaf
  - web

프로젝트 생성 시 체크했던 속성들과 동일하게 생성된 것을 확인할 수 있다.

조금 더 자세히 살펴보면 api, log, json, tomcat 등 웹 제작 필요한 다양한 라이브러리들을 자동을 추가해주는 고마운 일을 확인할 수 있다.

스프링 부트 라이브러리

• spring-boot-starter-web
  • spring-boot-starter-tocat: 톰캣(웹서버)
  • spring-boot-webmvc: 스프링 웹 MVC
• spring-boot-starter-thymeleaf: 타임리프 템플릿 엔진(view)
• spring-boot-starter(공통): 스프링 부트 + 스프링 코어 + 로깅
  • spring-boot
    • spring-core
  • spring-boot-starter-logging
    • logback, slf4j

테스트 라이브러리

• spring-boot-starter-test
  • junit: 테스트 프레임워크
  • mockito: 목 라이브러리
  • assertj: 테스트 코드를 좀 더 편하게 작성하게 도와주는 라이브러리
  • spring-test: 스프링 통합 테스트 지원

프로젝트 실행해보기

기본 코드를 실행해보면 Spring이라는 문구와 함께 구동되는 것을 볼 수 있다.

• 왜 Main, Test 파일로 나뉘어 있을까
  • 관리, 유지보수, 테스트를 용이하게 만들고 개발 프로세스를 자동화하는데 필요

    

    Tomcat의 기본 포트인 8080포트에 접속해보면 애러 페이지가 연결된 것을 확인할 수 있다.