[바미] Go - SQL query(CRUD)

model/model.go

  package model

  import "time"

  type Todo struct {
    ID        int       `json:"id"`
    Name      string    `json:"name"`
    Completed bool      `json:"completed"`
    CreatedAt time.Time `json:"created_at"`
  }

  type DbHandler interface {
    GetTodos() []*Todo
    AddTodo(name string) *Todo
    RemoveTodo(id int) bool
    CompleteTodo(id int, complete bool) bool // 1
    close() 
  }

 // var handler DbHandler

  func NewDBHandler() DBHandler { // 2
    //handler = newMemoryHandler()
    handler = newSqliteHandler()
  }
/*
  func GetTodos() []*Todo {
    return handler.getTodos()
  }

  func AddTodo(name string) *Todo {
    return handler.addTodo(name)
  }

  func RemoveTodo(id int) bool {
    return handler.removeTodo(id)
  }

  func CompleteTodo(id int, complete bool) bool {
    return handler.completeTodo(id, complete)
  }
*/

이제 GetTodos(), AddTodo(), RemoveTodo(), CompleteTodo() 들만 채워주면 되는데 문제가 하나 생긴게, DB를 열어주면 close를 해주어야 해서 close를 추가했는데,

이 인스턴스에 대한 생명주기에 대해 관리해주어야 합니다.

그런데 이 패키지안에서 알 수 없기 때문에 이 close를 호출해주는 책임을 이 패키지를 사용하는 쪽에 넘겨주어야 합니다.

 

1 : 그래서 dbHandler 라는 interface에 close함수를 추가시켜주고, interface와 메소드 모두 public하게 바꾸어 줍니다.

2 : 그리고 init()를 NewDBHandler()로 만들어서 DBHandler라는 인터페이스 자체를 바깥쪽으로 내보냅니다.

그래서 이 함수를 호출한 쪽에서 DBHandler의 인스턴스들을 가지고 사용하다가 필요가 없어질 때 close()를 할 수 있게 웹으로 책임을 넘겨줍니다.

 

그 후 인터페이스가 바뀌었기 때문에 model/sqliteHandler.go도 수정해 줍니다.

package model

import (
    "database/sql"
    "os"

    _ "github.com/mattn/go-sqlite3"
)

type sqliteHandler struct {
    db *sql.DB
}

func (s *sqliteHandler) GetTodos() []*Todo {
    return nil
}

func (s *sqliteHandler) AddTodo(name string) *Todo {
    return nil
}

func (s *sqliteHandler) RemoveTodo(id int) bool {
    return false
}

func (s *sqliteHandler) CompleteTodo(id int, complete bool) bool {
    return false
}

func (s *sqliteHandler) close() {
    s.db.Close()
}

func newSqliteHandler() DBHandler {
    os.Remove("./test.db")
    database, err := sql.Open("sqlite3", "./test.db")
    if err != nil {
        panic(err)
    }
    statement, _ := database.Prepare(
        `CREATE TABLE IF NOT EXISTS todos (
            id        INTEGER  PRIMARY KEY AUTOINCREMENT,
            name      TEXT,
            completed BOOLEAN,
            createdAt DATETIME
        )`)
    statement.Exec()
    return &sqliteHandler{db: database}
}

그 후 model/memoryHandler.go 쪽도 바꾸어 줍니다.

package model

import "time"

type memoryHandler struct {
    todoMap map[int]*Todo
}

func (m *memoryHandler) GetTodos() []*Todo {
    list := []*Todo{}
    for _, v := range m.todoMap {
        list = append(list, v)
    }
    return list
}

func (m *memoryHandler) AddTodo(name string) *Todo {
    id := len(m.todoMap) + 1
    todo := &Todo{id, name, false, time.Now()}
    m.todoMap[id] = todo
    return todo
}

func (m *memoryHandler) RemoveTodo(id int) bool {
    if _, ok := m.todoMap[id]; ok {
        delete(m.todoMap, id)
        return true
    }
    return false
}

func (m *memoryHandler) CompleteTodo(id int, complete bool) bool {
    if todo, ok := m.todoMap[id]; ok {
        todo.Completed = complete
        return true
    }
    return false
}

func(m *memoryHandler) close() { // 1

}

func newMemoryHandler() DBHandler {
    m := &memoryHandler{}
    m.todoMap = make(map[int]*Todo)
    return m
}

1 : 인터페이스에 맞춰주기 위해 close()함수를 새로 만들어 줍니다.

 

그리고 app/app.go도 수정을 해줍니다.

package app

import (
    "net/http"
    "strconv"

    "github.com/gorilla/mux"
    "github.com/unrolled/render"
)

var rd *render.Render

type AppHandler struct { // 1
    http.Handler // 1
    db model.DBHandler // 2
}

func indexHandler(w http.ResponseWriter, r *http.Request) {
    http.Redirect(w, r, "/todo.html", http.StatusTemporaryRedirect)
}

func getTodoListHandler(w http.ResponseWriter, r *http.Request) {
    list := model.GetTodos()
    rd.JSON(w, http.StatusOK, list)
}

func addTodoHandler(w http.ResponseWriter, r *http.Request) {
    name := r.FormValue("name")
    todo := model.AddTodo(name)
    rd.JSON(w, http.StatusCreated, todo)
}

type Success struct {
    Success bool `json:"success"`
}

func removeTodoHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id, _ := strconv.Atoi(vars["id"])
    ok := model.RemoveTodo(id)
    if ok {
        rd.JSON(w, http.StatusOK, Success{true})
    } else {
        rd.JSON(w, http.StatusOK, Success{false})
    }
}

func completeTodoHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id, _ := strconv.Atoi(vars["id"])
    complete := r.FormValue("complete") == "true"
    ok := model.CompleteTodo(id, complete)
    if ok {
        rd.JSON(w, http.StatusOK, Success{true})
    } else {
        rd.JSON(w, http.StatusOK, Success{false})
    }
}

func MakeHandler() http.Handler {
    //todoMap = make(map[int]*Todo)

    rd = render.New()
    r := mux.NewRouter()

    r.HandleFunc("/todos", getTodoListHandler).Methods("GET")
    r.HandleFunc("/todos", addTodoHandler).Methods("POST")
    r.HandleFunc("/todos/{id:[0-9]+}", removeTodoHandler).Methods("DELETE")
    r.HandleFunc("/complete-todo/{id:[0-9]+}", completeTodoHandler).Methods("GET")
    r.HandleFunc("/", indexHandler)

    return r
}

1 : 이 쪽도 마찬가지로 main.go에서 사용하기 때문에 이것도 하나의 패키지인데, 이제는 Model.go의 DBHandler를 만들어서 사용할 것이기 때문에, 이 것의 대한 close책임을 이 패키지를 사용한 쪽에 넘겨야 합니다.

그런데 app.go도 하나의 패키지이고, 이것을 main.go에서 사용하기 때문에 app.go에는 close책임이 없기 때문에 수정해 주어야 합니다.

 

1-1 : http.Handler를 포함 타입 이라고 하는데

  handler http.Handler

맴버 변수를 암시적으로 생략해서 이 인터페이스를 포함하고 있다. 라는 의미입니다.

상속하고 비슷한 개념으로 볼 수 있지만 상속관계가 아닙니다.
has-a관계이지 is-a관계가 아닙니다.

is-a관계 has-a관계에 대해

1-2 : model의 DB핸들러를 추가해 줍니다.

그 후 아래의 함수들을 AppHandler의 메소드로 바꾸어 줍니다.

func (a *AppHandler) indexHandler(w http.ResponseWriter, r *http.Request) {
    http.Redirect(w, r, "/todo.html", http.StatusTemporaryRedirect)
}

func (a *AppHandler) getTodoListHandler(w http.ResponseWriter, r *http.Request) {
    list := a.db.GetTodos() // 1
    rd.JSON(w, http.StatusOK, list)
}

func (a *AppHandler) addTodoHandler(w http.ResponseWriter, r *http.Request) {
    name := r.FormValue("name")
    todo := a.db.AddTodo(name)
    rd.JSON(w, http.StatusCreated, todo)
}

type Success struct {
    Success bool `json:"success"`
}

func (a *AppHandler) removeTodoHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id, _ := strconv.Atoi(vars["id"])
    ok := a.db.RemoveTodo(id)
    if ok {
        rd.JSON(w, http.StatusOK, Success{true})
    } else {
        rd.JSON(w, http.StatusOK, Success{false})
    }
}

func (a *AppHandler) completeTodoHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id, _ := strconv.Atoi(vars["id"])
    complete := r.FormValue("complete") == "true"
    ok := a.db.CompleteTodo(id, complete)
    if ok {
        rd.JSON(w, http.StatusOK, Success{true})
    } else {
        rd.JSON(w, http.StatusOK, Success{false})
    }
}

1 : AppHandler의 db 변수를 사용 할 수 있도록 바꾸어 줍니다.

 

그 후 AppHandler를 initialize해주어야 하는데, MakeHandler()할 때 반환값을 AppHandler의 포인터가 반환되도록 바꾸어 줍니다.

var rd *render.Render = render.New() // 1

func MakeHandler(filepath string) *AppHandler {
    r := mux.NewRouter()
    a := &AppHandler{
        Handler: r, // 1
        db:      model.NewDBHandler(filepath),
    }

    r.HandleFunc("/todos", a.getTodoListHandler).Methods("GET")
    r.HandleFunc("/todos", a.addTodoHandler).Methods("POST")
    r.HandleFunc("/todos/{id:[0-9]+}", a.removeTodoHandler).Methods("DELETE")
    r.HandleFunc("/complete-todo/{id:[0-9]+}", a.completeTodoHandler).Methods("GET")
    r.HandleFunc("/", a.indexHandler)

    return a
}

그 후 muxRouter를 지워주고, AppHandler를 만들어 줍니다.

1 : render.New() 부분은 전역이기 때문에 저 위치에 initialize시켜 줍니다.

2 : http 핸들러 부분은 muxRouter가 되고, dbHandler는 model의 NewDBHandler를 호출해서 그 결과를 db변수에 집어 넣습니다. 이렇게 하면 AppHandler라는 인스턴스가 만들어지게 되는데 muxRouter에 등록을 할 때 일반 함수가 아닌 메소드로 변경되었기 때문에 메소드 형태로 바꾸어 줍니다.

그리고 반환을 AppHandler를 반환하기 때문에 a값을 넣어 줍니다.

이렇게 한 이유는 DB핸들러가 프로그램이 종료되기 전에 Close()를 불러주어야 하는데 이걸 model패키지 입장에서는 자기가 만든 인스턴스에 대해서 얼만큼 사용될 지를 알 수 없기 때문입니다.

그러니까 자기 패키지안에선 Close()를 불러줄 수 가 없습니다.

결국에는 이 패키지를 사용한 쪽에서 불러주어야 하는데 그 패키지를 app/app.go에서 사용하는데

이 app 또한 전적으로 DBHandler를 사용권한을 가지고 있지 않습니다. 이것 또한 바깥에서 사용되는 패키지이기 때문 입니다.

 

그래서 새로운 인스턴스를 만들어서 바깥에서 AppHandler의 function을 호출할 수 있게 코드를 추가해 줍니다.

 

app/app.go

....

 func (a *AppHandler) Close() { // 1
    a.db.Close()
}

...

1 : 이렇게해서 app패키지를 사용하는 쪽에서 Close()를 호출 할 수 있도록 해줍니다.

 

그리고 main.go에서 appHandler를 만들었기 때문에 프로그램이 종료되기 전에 defer로 m의 Close를 호출 할 수 있게 됩니다.

main.go

func main() {
   m := app.MakeHandler("./test.db")
   defer m.Close()
   n := negroni.Classic()
   n.UseHandler(m)

   log.Println("Started App")
   err := http.ListenAndServe(":3000", n)
   if err != nil {
      panic(err)
   }
}

그 후 app에서 build가 잘 되는지 test를 해보면 만들어 놓은것이 없으므로 Fail이 났음을 확인할 수 있습니다.

그리고 test.db가 생성 된 것을 확인 할 수 있습니다.

저 test.db가 생성된 이유는 model/sqliteHandler.go에서

func newSqliteHandler() dbHandler {
  database, err := sql.Open("sqlite3", "./test.db")
    ...
}

"./test.db"를 여는데 저 파일이 없기 때문에 생성된 것입니다.

 

이제 본격적으로 기능들을 추가해봅시다!

먼저 getTodos()와 addTodo()를 수정해보죠.

model/sqliteHandler.go

package model

func (s *sqliteHandler) getTodos() []*Todo { // 1
  todos := []*Todo{} // 1
  rows, err := s.db.Query("SELECT id, name, completed, createdAt FROM todos") // 2
  if err != nil { // 3
    panic(err)
  }
  defer rows.Close() // 5
  for rows.Next() { // 4
     var todo Todo
     rows.Scan(&todo.ID, &todo.Name, &todo.Completed, &todo.CreatedAt)
     todos = append(todos, &todo)
  }
  return todos
}

1-1 : data를 저장할 쿼리문을 만들어야 하는데, data를 읽어서 그 data를 반환시켜주어야 하기 때문에 data를 반환시켜주는 list를 만들어 줍니다.
1-2 : 쿼리문 작성.
Query()를 보면 query문을 먼저 작성하고, 전달인자(argument)를 넣으면 성공시에 sql.Rows, 실패시에 error가 나오게 됩니다.
1-3 : 에러가 있을 시 에러 처리.
1-4 : 데이터가 잘 뽑아져 나왔을 시 각 행(row)을 돌면서 데이터를 가져와야 하기 때문에 for문으로 반복문을 돌려주는데, for.Next()는 다음행으로 가겠다는 의미이며, 다음 행이 없을 때 return false가 되어 return true가 될 때 까지 돌면서 레코드들을 읽어 줍니다.

rows.Scan()을 쓰게 되면 쿼리안에 있던 값들이 각각에 맞춰서 가져오게 되는데, 이 data를 담을 todo객체를 만들어서 Scan()안에 받아올 각 항목들을 넣어주면 됩니다.

그 후 todo에 들어간 값들을 todos에 저장해준 뒤, todos를 return 해줍니다.

1-5 : 그 다음 row를 close시켜 줍니다.

func (s *sqliteHandler) addTodo(name string) *Todo { // 2
   stmt, err := s.db.Prepare("INSERT INTO todos (name, completed, createdAt) VALUES (?, ?, datetime('now'))") // 1

  if err != nil { // 2
      panic(err)
  }

  rst, err := stmt.Exec(name, false) // 3

  if err != nil { // 4
    panic(err)
  }

  id, _ := rst.LastInsertId() // 5
  var todo Todo // 6
  todo.ID = int(id) // 7
  todo.Name = name // 8
  todo.Completed = false // 9
  todo.CreatedAt = time.Now() // 10

  return &todo // 1
}

2-1 : 여기서도 쿼리문을 작성해주어야 하는데 s.db.Prepare()로 Statement를 만들어 줍니다.
Prepare의 반환값으로 Statement값과 error값이 나옵니다.
2-2 : error 처리.
2-3 : Statement값이 나왔기 때문에 execute해주어야 하는데 Exec()의 대응되는 전달인자(argument)는

아까 Insert 쿼리에 '?'로 썼던 부분입니다. 그래서 name에 name값, complete값에 false값을 넣어줍니다.

Exec()가 반환되는 값은 result와 error가 나옵니다.

2-4 : 이 과정에서 error가 있을 수 있기 때문에 에러 처리를 해줍니다.
2-5 : 그 후 result값이 나왔고, AddTodo를 한 다음에 추가한 Todo의 정보를 알려주어야 합니다.

name, completed, createdAt값은 알 수 있는데 insert 시 id값을 넣지 않았으므로 id값은 알 수가 없습니다.

(table을 만들었을 때 AUTO로 설정했기 때문입니다.)

그래서 자동으로 발급된 그 id값을 알아야하기 때문에 result의 메소드로 LastInsertId()가 있는데 마지막으로 추가된 레코드의 id값을 알려 줍니다.

이 것을 id변수에 넣어주고,

2-6 : return값이 todo이기 때문에 todo를 만들어 줍니다.
2-7 : 그래서 todo의 id는 새로만든 id가 될 것이고, 이 타입이 int64여서 int로 바꾸어 줍니다.
2-8 : name값은 요청한 name값이 되고,
2-9 : completed값은 false로 넣어주고,
2-10 : CreateAt은 현재시간으로 넣어 줍니다.
2-11 : 그 후 포인터 값을 반환시켜 줍니다.

 

이렇게 하면 add와 get이 끝이 납니다!

 

그 후 저장후에 테스트를 진행해 봅시다!

에러 문을 보면 65번째 줄과 79번째 줄이 통과가 안되었는데, 이 부분은 Completetodo와 delete한 부분입니다.

그러므로 방금 수정했던 Add와 Get은 통과가 되었다는 의미인데, 여기서 한 번 더 테스트를 해보면

아까는 통과되었던 부분도 통과가 되지 않은 것을 확인 할 수 있습니다.

그 이유는 레코드가 2개가 와야하는데 4개가 왔기 때문입니다. 아까 생성된 test.db파일이 한번 만들어지면 지워지지 않는데

 

첫 번째 테스트 시 이미 테이블이 만들어진 상태에서 테스트 코드에서 add를 2번하여 레코드 2개가 추가되었고, GetTodos를 진행하여 2개의 레코드를 조회했고, 두 번째 테스트 시 추가 했었던 레코드 2개가 이미 추가 된 상태에서 2개를 또 추가하는 것이기 때문에

4개가 된 것입니다.

 

그래서 이것을 테스트를 돌리기 전에 db파일을 삭제하도록 수정해야 합니다.

app/app_test.go

 func TestTodos(t *testing.T) {
   os.Remove("./test.db")

   ah := MakeHandler()
   defer ah.Close()
   ts := httptest.NewServer(ah)
    ...
 }

os.Remove()를 추가 해주고, ts부분에서 AppHandler가 나와서 Close()를 시켜주어야 하기 때문에 다음과 같이 수정해 줍니다.
AppHandler는 http.Handler를 임베디드하고 있기 때문에 NewServer()의 인자로 바로 써 줄 수 있습니다.

ah 또한 function이 끝나기 전에 DB를 닫아주어야 하기 때문에 Close()시켜 줍니다.

 

이제 테스팅을 해보면

Get, Add를 제외한 부분만 에러가 나는 것을 확인할 수 있습니다.

 

이제 CompleteTodo를 수정해봅시다!

CompleteTodo는 완료상태를 변경하는 것인데, 기존 레코드는 그대로 두고, 기존 레코드의 complete값만 변경해주는 부분입니다.

func (s *sqliteHandler) CompleteTodo(id int, complete bool) bool {
   stmt, err := s.db.Prepare("UPDATE todos SET completed=? WHERE id=?") // 1

   if err != nil { // 2
     panic(err)
   }

   rst, err := stmt.Exec(complete, id) // 3

   if err != nil { // 4
     panic(err)
   }

  cnt, _ := rst.RowsAffected() // 5
  return cnt > 0 // 6
}

1 : Prepare()로 UPDATE문을 넣어줍니다. 마찬가지로 statement가 나오고, error가 나옵니다.
2 : 에러 처리.
3 : 첫번째 전달인자(argument)값이 Compelte, 두 번째 전달인자(argument)값이 id값으로 넣어 줍니다.
4 : 에러 처리.
5 : 위의 쿼리문을 영향받은 레코드 갯수가 몇개인지 알려줍니다. UPDATE 시 1이 될 것이고, UPDATE가 되지 않으면 0이 될 것입니다.
6 : 그래서 UPDATE된 항목이 있을 시 True가 될 것이고, 그렇지 않으면 False값이 될 것 입니다.

 

그 다음 RemoveTodo()를 수정해봅시다!

func (s *sqliteHandler) RemoveTodo(id int) bool {
  stmt, err := s.db.Prepare("DELETE FROM todos WHERE id=?") // 1

  if err != nil { // 2
    panic(err)
  }

  rst, err := stmt.Exec(id) // 3

  if err != nil { // 4
    panic(err)
  }

  cnt, _ := rst.RowsAffected() // 5
  return cnt > 0 // 6
}

1 : remove도 마찬가지로 Statement를 만들어 줍니다.
2 : 에러 처리.
3 : 첫번째 전달인자(argument)값을 id값으로 넣어 줍니다.
4 : 에러 처리.
5 : 위의 쿼리문을 영향받은 레코드 갯수가 몇개인지 알려 줍니다.
6 : 그래서 DELETE된 항목이 있을 시 True가 될 것이고, 그렇지 않으면 False값이 될 것 입니다.

 

그 후 테스트를 진행해보자!

4개 모두 통과가 되었습니다!

코딩이 완료 되었고, 서버로 실행하여 동작을 하는지 확인해 봅시다!

memoryDB가 아닌 FileDB로 변경해주었기 때문에 위와 같이 임의적으로 data를 추가 시킨 뒤 서버를 재시작 해주면 마지막 상태가 저장 되어 있음을 확인 할 수 있습니다.

프로그램이 종료되어도, test.db에 저장되어 있습니다.

 

그 후에 한가지 수정할 사항이 있는데, model/sqliteHandler.go에서

func newSqliteHandler() dbHandler {
  database, err := sql.Open("sqlite3", "./test.db")
    ...
  }

이렇게 configuration에 관련된 항목들을 코드안에 있는 박아 놓는 형태가 좋지 않아 최대한 바깥 쪽으로 빼주는게 좋습니다.

func newSqliteHandler(filepath string) DBHandler {
   database, err := sql.Open("sqlite3", filepath)
     if err != nil {
        panic(err)
     }

   statement, _ := database.Prepare(
    `CREATE TABLE IF NOT EXISTS todos (
       id        INTEGER  PRIMARY KEY AUTOINCREMENT,
       name      TEXT,
       completed BOOLEAN,
       createdAt DATETIME
    )`)

   statement.Exec()
   return &sqliteHandler{db: database}
}

이런식으로 filepath를 인자로 받아서 sql.Open()에 넣어 줍니다.

그래서 기존에 있던 "./test.db"는 model/model.go의 NewDBHandler()안에 넣어 줍니다.

func NewDBHandler() DBHandler {
  //handler = newMemoryHandler()
  return newSqliteHandler("./test.db")
}

그래서 이렇게 바뀌어야 하는데 여기에 넣어 놓으나, sqliteHandler.go에 넣어 놓으나 사실상 똑같기 때문에 filepath의 인자를 받아서 여기에도 filepath를 넘겨 줍니다.

func NewDBHandler(filepath string) DBHandler {
  //handler = newMemoryHandler()
  return newSqliteHandler(filepath)
}

또 filepath부분이 불리는 부분인 app/app.go의 MakeHandler()부분도 마찬가지로 수정해 줍니다.

func MakeHandler(filepath string) *AppHandler {
  r := mux.NewRouter()
  a := &AppHandler{
        Handler: r,
    db:      mo
    del.NewDBHandler(filepath),
  }

  r.HandleFunc("/todos", a.getTodoListHandler).Methods("GET")
  r.HandleFunc("/todos", a.addTodoHandler).Methods("POST")
  r.HandleFunc("/todos/{id:[0-9]+}", a.removeTodoHandler).Methods("DELETE")
  r.HandleFunc("/complete-todo/{id:[0-9]+}", a.completeTodoHandler).Methods("GET")
  r.HandleFunc("/", a.indexHandler)

  return a
}

그렇게 사용하는 부분들을 거슬러 올라가다보면 main.go까지 사용하는데 main에서 "./test.db"를 추가 시켜 줍니다.

func main() {
  m := app.MakeHandler("./test.db")
  defer m.Close()
  n := negroni.Classic()
  n.UseHandler(m)

  log.Println("Started App")
  err := http.ListenAndServe(":3000", n)

  if err != nil {
    panic(err)
  }
}

여기서 파일을 바꾸어 줄 수 있습니다. 그렇다면 여기에서도 마찬가지로

 

코드에 박힌 것이 아니야?

라고 생각할 수 있습니다.

그래서 여기서는 flag같은 실행인자를 가져오는 패키지가 있어서 사용할 수 있는데 지금은 그것을 사용하지 않고 그냥 넣어 줍니다.

main에 넣는 것은 금방 바꿀 수 있어서 좋고, 패키지 안쪽에 있는 것 보다 최대한 바깥쪽에 넣어주는 것이 좋습니다.

 

이렇게 해서 기존 todos를 바꾸어 주는 부분들이 끝이 났습니다.

 

풀소스 : github.com/ckdqja135/Typescript-restful-starter/tree/master/mdfile/Go/Go%20-%20Web%20Source/SQL%20query(CRUD)%20%ED%92%80%EC%86%8C%EC%8A%A4