Post

Django: URL, 뷰(Views), 템플릿(Template)

Django에서 URL, 뷰(View), 템플릿(Template) 관리

Django: URL, 뷰(Views), 템플릿(Template)

4. URL 관리

Django의 URL 관리는 URLconf를 사용하여 클라이언트 요청(URL)을 특정 뷰(View)로 연결합니다.

4.1 URLconf의 역할

  • Django는 클라이언트 요청이 들어오면 urls.py 파일에서 URL 패턴을 확인하고 해당 뷰(View)로 요청을 전달합니다.
  • URLconf는 path 또는 re_path를 사용해 URL 패턴을 정의합니다.

4.2 URL 매핑 및 뷰 연결

1. 프로젝트의 urls.py 설정

  • urls.py는 프로젝트 전체의 URL을 관리하며, 각 앱의 URL을 포함합니다.
  • 기본 구조:

    1
    2
    3
    4
    5
    6
    7
    8
    
      from django.contrib import admin
      from django.urls import path, include
        
      urlpatterns = [
          path('admin/', admin.site.urls),  # 관리자 페이지
          path('blog/', include('blog.urls')),  # blog 앱의 URL 연결
      ]
        
    

2. 앱의 urls.py 설정

  • 앱 내부에 urls.py 파일을 생성합니다:

    1
    2
    3
    4
    5
    6
    7
    
      from django.urls import path
      from . import views
        
      urlpatterns = [
          path('hello/', views.hello, name='hello'),
      ]
        
    

3. 뷰(View) 작성

  • views.py에 함수를 추가하여 간단한 응답을 반환합니다:

    1
    2
    3
    4
    5
    
      from django.http import HttpResponse
        
      def hello(request):
          return HttpResponse("Hello, World!")
        
    

4. URL 매핑 확인

  • 서버를 실행하고 /blog/hello/에 접속하면 “Hello, World!”가 출력됩니다:

    1
    2
    
      python manage.py runserver
        
    

4.3 URL Reverse 기능

  • URL Reverse는 URL 이름을 통해 URL을 생성하는 기능으로, URL 구조 변경 시 유용합니다.
  • 예시:

    1
    2
    3
    
      from django.urls import reverse
      url = reverse('hello')  # 'hello'는 name='hello'로 지정된 URL 이름
        
    

4.4 네임스페이스 활용

  • 대규모 프로젝트에서는 앱별로 URL 이름 충돌을 방지하기 위해 네임스페이스를 사용합니다.
  • 프로젝트의 urls.py에서 네임스페이스를 지정:

    1
    2
    
      path('blog/', include(('blog.urls', 'blog'), namespace='blog')),
        
    
  • URL 정의 시 네임스페이스 사용:

    1
    2
    
      reverse('blog:hello')  # 'blog'는 네임스페이스, 'hello'는 URL 이름
        
    

5. 뷰(Views) 이해

Django에서 뷰(View)는 클라이언트 요청을 처리하고 응답을 반환하는 역할을 합니다. 뷰는 웹 애플리케이션의 컨트롤러 역할을 담당합니다.

5.1 Django의 뷰 개념

  • 뷰는 요청을 받고 처리한 후:
    1. HTML 페이지를 반환하거나,
    2. 데이터(JSON, XML 등)를 반환합니다.
  • 주요 유형:
    • 함수형 뷰(Function-Based View, FBV): 함수로 작성.
    • 클래스형 뷰(Class-Based View, CBV): 클래스로 작성.

5.2 함수형 뷰(Function-Based View)

기본 구조

  • 요청을 받아 적절한 응답을 반환하는 Python 함수입니다.
  • 기본 템플릿:

    1
    2
    3
    4
    5
    
      from django.http import HttpResponse
        
      def my_view(request):
          return HttpResponse("Hello, World!")
        
    

요청 처리

  • request 객체를 통해 클라이언트 요청 데이터를 읽을 수 있습니다:

    1
    2
    3
    4
    5
    6
    
      def my_view(request):
          if request.method == 'GET':
              return HttpResponse("GET 요청 처리")
          else:
              return HttpResponse("다른 요청 처리")
        
    

URL과 연결

  • urls.py에 함수형 뷰를 등록:

    1
    2
    3
    4
    5
    6
    7
    
      from django.urls import path
      from . import views
        
      urlpatterns = [
          path('hello/', views.my_view, name='my_view'),
      ]
        
    

5.3 클래스형 뷰(Class-Based View)

기본 구조

  • Django에서 제공하는 CBV는 코드 재사용과 확장이 용이합니다.
  • 기본 템플릿:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    
      from django.http import HttpResponse
      from django.views import View
        
      class MyView(View):
          def get(self, request):
              return HttpResponse("GET 요청 처리")
          def post(self, request):
              return HttpResponse("POST 요청 처리")
        
    

URL과 연결

  • urls.py에서 클래스형 뷰를 연결:

    1
    2
    3
    4
    5
    6
    7
    
      from django.urls import path
      from .views import MyView
        
      urlpatterns = [
          path('hello/', MyView.as_view(), name='my_view'),
      ]
        
    

5.4 FBV와 CBV의 비교

  • FBV는 간단한 로직에 적합.
  • CBV는 재사용성 및 복잡한 로직 처리에 적합.
특징함수형 뷰(FBV)클래스형 뷰(CBV)
작성 용이성간단한 로직에 적합초기 작성이 복잡할 수 있음
유연성한정된 기능 재사용 가능확장성과 재사용성 우수
읽기 편의성짧고 명확클래스 구조로 길어질 수 있음

5.5 뷰와 템플릿 연결

  • HTML 응답을 반환하려면 템플릿 파일을 사용할 수 있습니다.

예제: 템플릿 응답

  1. 뷰 작성

    1
    2
    3
    4
    5
    
     from django.shortcuts import render
        
     def hello_template(request):
         return render(request, 'hello.html', {'name': 'Django'})
        
    
  2. 템플릿 파일 생성
    • templates/hello.html:

      1
      2
      3
      4
      5
      6
      
        <html>
        <body>
            <h1>Hello, !</h1>
        </body>
        </html>
              
      
  3. URL 연결

    1
    2
    3
    4
    
     urlpatterns = [
         path('hello/', views.hello_template, name='hello_template'),
     ]
        
    
  4. 브라우저에서 /hello/ URL에 접속하면 “Hello, Django!”가 표시됩니다.

6. 템플릿 시스템

Django의 템플릿 시스템은 HTML 파일을 동적으로 생성하는 데 사용됩니다. 템플릿 언어(Django Template Language, DTL)를 사용해 동적인 데이터를 표시하거나 로직을 포함할 수 있습니다.

6.1 템플릿 언어(Django Template Language, DTL)

기본 문법

  1. 변수 출력
    • 템플릿에서 Python 변수를 출력:

      1
      2
      
        <p></p>
              
      
    • 예: {'name': 'Django'} 데이터를 전달하면:

      1
      2
      
        <p>Django</p>
              
      
  2. 필터 사용
    • 데이터를 수정하거나 형식을 바꿈:

      1
      2
      3
      
        <p></p>  <!-- 소문자로 변환 -->
        <p></p>  <!-- 날짜 포맷 -->
              
      
  3. 태그 사용
    • 템플릿 로직에 사용되는 제어 구조:

      1
      2
      3
      4
      
              
            <p>Please log in.</p>
              
              
      
  4. 반복문
    • 리스트나 딕셔너리 데이터를 순회:

      1
      2
      3
      4
      
        <ul>
                  
        </ul>
              
      

6.2 템플릿 파일 생성 및 관리

1. 템플릿 디렉토리 설정

  • settings.py에서 템플릿 디렉토리를 설정:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    
      TEMPLATES = [
          {
              'BACKEND': 'django.template.backends.django.DjangoTemplates',
              'DIRS': [BASE_DIR / 'templates'],  # 템플릿 경로
              'APP_DIRS': True,
              'OPTIONS': {
                  'context_processors': [
                      'django.template.context_processors.debug',
                      'django.template.context_processors.request',
                      'django.contrib.auth.context_processors.auth',
                      'django.contrib.messages.context_processors.messages',
                  ],
              },
          },
      ]
        
    

2. 템플릿 파일 생성

  • 프로젝트 루트에 templates 폴더를 생성하고, 예를 들어 hello.html 파일 추가:

    1
    2
    3
    4
    5
    6
    
      <html>
          <body>
              <h1>Hello, !</h1>
          </body>
      </html>
        
    

3. 템플릿 사용

  • 뷰에서 render를 사용해 템플릿 파일과 데이터를 연결:

    1
    2
    3
    4
    5
    6
    
      from django.shortcuts import render
        
      def hello_view(request):
          context = {'name': 'Django'}
          return render(request, 'hello.html', context)
        
    

6.3 템플릿 상속과 블록 구조

기본 템플릿 생성

  • base.html:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    
        
      <html>
          <head>
              <title>{% block title %}My Site{% endblock %}</title>
          </head>
          <body>
              <header>
                  <h1>Welcome to My Site</h1>
              </header>
              {% block content %}{% endblock %}
              <footer>
                  <p>Footer content here.</p>
              </footer>
          </body>
      </html>
        
    

상속된 템플릿

  • home.html:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    
        
      {% extends 'base.html' %}
        
      {% block title %}Home Page{% endblock %}
        
      {% block content %}
          <p>This is the home page content.</p>
      {% endblock %}
        
    

6.4 정적 파일 관리

정적 파일 설정

  • 정적 파일(CSS, JS, 이미지 등)을 관리하려면 STATIC_URL 설정:

    1
    2
    
      STATIC_URL = '/static/'
        
    

정적 파일 디렉토리 생성

  1. 프로젝트 루트에 static 폴더 생성.
  2. CSS 파일 예:
    • static/css/styles.css:

      1
      2
      3
      4
      
        body {
            font-family: Arial, sans-serif;
        }
              
      

템플릿에서 정적 파일 로드

  1. {% load static %} 태그를 사용:

    1
    2
    3
    4
    
        
     {% load static %}
     <link rel="stylesheet" href="{% static 'css/styles.css' %}">
        
    
This post is licensed under CC BY 4.0 by the author.