Ver3.5 Django와 Python으로 만드는맞춤형 쇼핑몰 백엔드 완전 정복 🐍🛍️

Django와 Python으로 만드는
맞춤형 쇼핑몰 백엔드 완전 정복 🐍🛍️
처음부터 끝까지, 친구처럼 쉽게 알려주는 실전 가이드
야, 솔직히 말할게. 쇼핑몰 하나 만들려고 검색하다 보면 정보가 너무 많아서 오히려 머리가 터질 것 같지 않아? 😅 React니 Vue니 Node.js니... 근데 오늘은 그런 복잡한 거 다 제쳐두고, Python 생태계의 최강 웹 프레임워크 Django로 쇼핑몰 백엔드를 어떻게 설계하고 구현하는지 제대로 파헤쳐볼 거야.
Django는 "배터리 포함(Batteries Included)" 철학으로 유명한데, 이게 무슨 말이냐면 쇼핑몰 개발에 필요한 거의 모든 기능이 이미 내장되어 있다는 뜻이야. 인증 시스템, 관리자 패널, ORM, 보안 기능... 이걸 다 직접 만들어야 한다고 생각해봐. 진짜 끔찍하잖아 😱
이 글에서는 상품 관리부터 장바구니, 결제 연동, 주문 처리까지 실제 쇼핑몰 백엔드에 필요한 핵심 기능들을 단계별로 살펴볼 거야. 코드도 있고, 설계 개념도 있고, 실무 팁도 있어. 자, 시작해보자! 🚀
🐍 왜 Django인가? 쇼핑몰 백엔드에서의 강점
먼저 "왜 Django야?" 라는 질문에 제대로 답해볼게. 쇼핑몰 백엔드를 개발할 때 Django를 선택하는 이유는 단순히 Python이 인기 있어서가 아니야. 실제로 쇼핑몰 도메인에 딱 맞는 기능들이 있거든.
Django의 ORM, 관리자 패널, 인증 시스템 덕분에 쇼핑몰 MVP를 단 몇 주 만에 구축 가능. 반복 작업 최소화.
CSRF 보호, SQL 인젝션 방어, XSS 방지가 기본 내장. 결제 정보 다루는 쇼핑몰에서 보안은 필수!
상품 등록, 주문 관리, 회원 관리를 위한 관리자 패널이 자동 생성됨. 별도 어드민 개발 불필요.
Django REST Framework로 RESTful API를 빠르게 구축. 모바일 앱, SPA 프론트엔드와 완벽 연동.
django-oscar, django-shop 같은 전문 쇼핑몰 패키지부터 결제 연동 라이브러리까지 생태계가 탄탄.
앱(App) 단위 모듈화로 기능 추가/제거가 쉬움. 트래픽 증가에 따른 수평 확장도 용이.
🏗️ 프로젝트 구조 설계: 기초가 탄탄해야 집이 안 무너진다
쇼핑몰 백엔드를 개발할 때 가장 먼저 해야 할 일은 프로젝트 구조를 제대로 잡는 것이야. 처음에 대충 만들면 나중에 기능 추가할 때 진짜 고생해. 경험자로서 말하는데, 이 부분에서 시간 투자하는 게 나중에 몇 배로 돌아와 😤
Django 앱 분리 전략
Django는 프로젝트를 여러 개의 앱(App)으로 분리하는 구조야. 쇼핑몰의 경우 다음과 같이 앱을 나누는 게 일반적이야:
myshop/ # 프로젝트 루트
├── config/ # 프로젝트 설정
│ ├── settings/
│ │ ├── base.py # 공통 설정
│ │ ├── development.py # 개발 환경
│ │ └── production.py # 운영 환경
│ ├── urls.py
│ └── wsgi.py
├── apps/
│ ├── accounts/ # 회원 관리 앱
│ ├── products/ # 상품 관리 앱
│ ├── categories/ # 카테고리 앱
│ ├── cart/ # 장바구니 앱
│ ├── orders/ # 주문 관리 앱
│ ├── payments/ # 결제 처리 앱
│ ├── reviews/ # 리뷰/평점 앱
│ └── notifications/ # 알림 앱
├── static/ # 정적 파일
├── media/ # 업로드 파일
├── requirements/
│ ├── base.txt
│ ├── development.txt
│ └── production.txt
└── manage.py
기본 설정 파일 구성
settings/base.py에서 공통으로 사용할 설정들을 잡아줘야 해:
# config/settings/base.py
from pathlib import Path
import os
BASE_DIR = Path(__file__).resolve().parent.parent.parent
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
# 서드파티 앱
'rest_framework',
'rest_framework_simplejwt',
'corsheaders',
'django_filters',
'storages', # AWS S3 연동
# 쇼핑몰 앱
'apps.accounts',
'apps.products',
'apps.categories',
'apps.cart',
'apps.orders',
'apps.payments',
'apps.reviews',
'apps.notifications',
]
MIDDLEWARE = [
'corsheaders.middleware.CorsMiddleware', # CORS 맨 위에!
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
# DRF 기본 설정
REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': [
'rest_framework_simplejwt.authentication.JWTAuthentication',
],
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.permissions.IsAuthenticatedOrReadOnly',
],
'DEFAULT_PAGINATION_CLASS':
'rest_framework.pagination.PageNumberPagination',
'PAGE_SIZE': 20,
'DEFAULT_FILTER_BACKENDS': [
'django_filters.rest_framework.DjangoFilterBackend',
'rest_framework.filters.SearchFilter',
'rest_framework.filters.OrderingFilter',
],
}
👤 회원 시스템: 커스텀 User 모델부터 JWT까지
쇼핑몰에서 회원 시스템은 진짜 중요해. Django 기본 User 모델을 그냥 쓰면 나중에 필드 추가할 때 엄청 고생하거든. 처음부터 커스텀 User 모델을 만드는 게 정석이야. 이건 Django 공식 문서에서도 강력 권장하는 사항이야!
커스텀 User 모델 설계
# apps/accounts/models.py
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin
from django.db import models
from django.utils import timezone
from .managers import CustomUserManager
class User(AbstractBaseUser, PermissionsMixin):
"""쇼핑몰 커스텀 유저 모델"""
email = models.EmailField(unique=True, verbose_name='이메일')
username = models.CharField(max_length=50, verbose_name='사용자명')
phone = models.CharField(
max_length=20, blank=True, verbose_name='전화번호'
)
# 쇼핑몰 특화 필드
is_seller = models.BooleanField(
default=False, verbose_name='판매자 여부'
)
point = models.PositiveIntegerField(
default=0, verbose_name='포인트'
)
# 소셜 로그인 연동
social_provider = models.CharField(
max_length=20, blank=True,
choices=[
('kakao', '카카오'),
('naver', '네이버'),
('google', '구글'),
]
)
social_uid = models.CharField(max_length=100, blank=True)
is_active = models.BooleanField(default=True)
is_staff = models.BooleanField(default=False)
date_joined = models.DateTimeField(default=timezone.now)
# 이메일을 username으로 사용
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']
objects = CustomUserManager()
class Meta:
verbose_name = '사용자'
verbose_name_plural = '사용자 목록'
def __str__(self):
return self.email
class UserProfile(models.Model):
"""유저 프로필 (배송지 등 추가 정보)"""
user = models.OneToOneField(
User, on_delete=models.CASCADE, related_name='profile'
)
profile_image = models.ImageField(
upload_to='profiles/', blank=True, null=True
)
birth_date = models.DateField(blank=True, null=True)
gender = models.CharField(
max_length=10, blank=True,
choices=[('M', '남성'), ('F', '여성'), ('N', '미선택')]
)
class Meta:
verbose_name = '유저 프로필'
class ShippingAddress(models.Model):
"""배송지 관리"""
user = models.ForeignKey(
User, on_delete=models.CASCADE, related_name='addresses'
)
name = models.CharField(max_length=50, verbose_name='수령인')
phone = models.CharField(max_length=20, verbose_name='연락처')
zipcode = models.CharField(max_length=10, verbose_name='우편번호')
address1 = models.CharField(max_length=200, verbose_name='주소')
address2 = models.CharField(
max_length=200, blank=True, verbose_name='상세주소'
)
is_default = models.BooleanField(
default=False, verbose_name='기본 배송지'
)
class Meta:
verbose_name = '배송지'
AUTH_USER_MODEL = 'accounts.User' 꼭 추가해줘!
JWT 인증 구현
쇼핑몰 API에서는 JWT(JSON Web Token) 인증이 표준이야. djangorestframework-simplejwt 패키지를 쓰면 쉽게 구현할 수 있어:
# apps/accounts/views.py
from rest_framework import generics, status
from rest_framework.response import Response
from rest_framework.permissions import AllowAny
from rest_framework_simplejwt.tokens import RefreshToken
from django.contrib.auth import authenticate
from .serializers import UserRegistrationSerializer, UserLoginSerializer
class RegisterView(generics.CreateAPIView):
"""회원가입 API"""
permission_classes = [AllowAny]
serializer_class = UserRegistrationSerializer
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.save()
# JWT 토큰 발급
refresh = RefreshToken.for_user(user)
return Response({
'user': serializer.data,
'tokens': {
'refresh': str(refresh),
'access': str(refresh.access_token),
},
'message': '회원가입이 완료되었습니다! 🎉'
}, status=status.HTTP_201_CREATED)
class LoginView(generics.GenericAPIView):
"""로그인 API"""
permission_classes = [AllowAny]
serializer_class = UserLoginSerializer
def post(self, request):
email = request.data.get('email')
password = request.data.get('password')
user = authenticate(email=email, password=password)
if not user:
return Response(
{'error': '이메일 또는 비밀번호가 올바르지 않습니다.'},
status=status.HTTP_401_UNAUTHORIZED
)
if not user.is_active:
return Response(
{'error': '비활성화된 계정입니다.'},
status=status.HTTP_403_FORBIDDEN
)
refresh = RefreshToken.for_user(user)
return Response({
'tokens': {
'refresh': str(refresh),
'access': str(refresh.access_token),
},
'user': {
'id': user.id,
'email': user.email,
'username': user.username,
'point': user.point,
}
})
📦 상품 관리 시스템: 쇼핑몰의 심장
상품 모델은 쇼핑몰 백엔드에서 가장 복잡한 부분 중 하나야. 단순히 이름이랑 가격만 있는 게 아니라, 카테고리, 옵션, 재고, 이미지, 할인 등 다양한 요소를 고려해야 해. 실제 쇼핑몰 수준의 모델을 설계해볼게 💪
카테고리 모델 (계층 구조)
# apps/categories/models.py
from django.db import models
class Category(models.Model):
"""계층형 카테고리 (대분류 > 중분류 > 소분류)"""
name = models.CharField(max_length=100, verbose_name='카테고리명')
slug = models.SlugField(max_length=100, unique=True)
parent = models.ForeignKey(
'self',
on_delete=models.CASCADE,
null=True,
blank=True,
related_name='children',
verbose_name='상위 카테고리'
)
image = models.ImageField(
upload_to='categories/', blank=True, null=True
)
order = models.PositiveIntegerField(default=0, verbose_name='정렬순서')
is_active = models.BooleanField(default=True)
class Meta:
verbose_name = '카테고리'
ordering = ['order', 'name']
def __str__(self):
if self.parent:
return f'{self.parent.name} > {self.name}'
return self.name
def get_ancestors(self):
"""상위 카테고리 목록 반환"""
ancestors = []
current = self
while current.parent:
ancestors.insert(0, current.parent)
current = current.parent
return ancestors
상품 모델 (옵션 포함)
# apps/products/models.py
from django.db import models
from django.utils.text import slugify
from apps.accounts.models import User
from apps.categories.models import Category
class Product(models.Model):
"""상품 메인 모델"""
STATUS_CHOICES = [
('active', '판매중'),
('inactive', '판매중지'),
('soldout', '품절'),
('draft', '임시저장'),
]
seller = models.ForeignKey(
User, on_delete=models.CASCADE,
related_name='products', verbose_name='판매자'
)
category = models.ForeignKey(
Category, on_delete=models.SET_NULL,
null=True, related_name='products'
)
name = models.CharField(max_length=200, verbose_name='상품명')
slug = models.SlugField(max_length=200, unique=True, blank=True)
description = models.TextField(verbose_name='상품 설명')
detail_content = models.TextField(
blank=True, verbose_name='상세 설명 (HTML)'
)
# 가격 정보
original_price = models.PositiveIntegerField(verbose_name='정가')
sale_price = models.PositiveIntegerField(
null=True, blank=True, verbose_name='할인가'
)
discount_rate = models.PositiveSmallIntegerField(
default=0, verbose_name='할인율(%)'
)
# 재고 (옵션 없는 경우)
stock = models.PositiveIntegerField(default=0, verbose_name='재고')
# 배송 정보
shipping_fee = models.PositiveIntegerField(
default=0, verbose_name='배송비'
)
free_shipping_threshold = models.PositiveIntegerField(
default=50000, verbose_name='무료배송 기준금액'
)
# 상태 및 통계
status = models.CharField(
max_length=20, choices=STATUS_CHOICES, default='active'
)
view_count = models.PositiveIntegerField(default=0, verbose_name='조회수')
sales_count = models.PositiveIntegerField(default=0, verbose_name='판매수')
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
class Meta:
verbose_name = '상품'
ordering = ['-created_at']
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify(self.name, allow_unicode=True)
# 할인율 자동 계산
if self.sale_price and self.original_price:
self.discount_rate = int(
(1 - self.sale_price / self.original_price) * 100
)
super().save(*args, **kwargs)
@property
def current_price(self):
"""현재 판매가"""
return self.sale_price if self.sale_price else self.original_price
@property
def is_free_shipping(self):
"""무료배송 여부"""
return self.current_price >= self.free_shipping_threshold
class ProductImage(models.Model):
"""상품 이미지"""
product = models.ForeignKey(
Product, on_delete=models.CASCADE, related_name='images'
)
image = models.ImageField(upload_to='products/%Y/%m/')
alt_text = models.CharField(max_length=200, blank=True)
is_main = models.BooleanField(default=False, verbose_name='대표 이미지')
order = models.PositiveSmallIntegerField(default=0)
class Meta:
ordering = ['order']
class ProductOption(models.Model):
"""상품 옵션 (색상, 사이즈 등)"""
product = models.ForeignKey(
Product, on_delete=models.CASCADE, related_name='options'
)
name = models.CharField(max_length=50, verbose_name='옵션명') # 예: 색상
class Meta:
verbose_name = '상품 옵션'
class ProductOptionValue(models.Model):
"""상품 옵션 값 + 재고"""
option = models.ForeignKey(
ProductOption, on_delete=models.CASCADE, related_name='values'
)
value = models.CharField(max_length=100, verbose_name='옵션값') # 예: 빨강
additional_price = models.IntegerField(
default=0, verbose_name='추가금액'
)
stock = models.PositiveIntegerField(default=0, verbose_name='재고')
sku = models.CharField(
max_length=100, unique=True, blank=True, verbose_name='SKU'
)
class Meta:
verbose_name = '옵션 값'
ProductVariant 모델을 별도로 만들어서 조합별 재고와 SKU를 관리하는 게 더 좋아. 대형 쇼핑몰에서 주로 쓰는 방식이야.
상품 API (ViewSet 활용)
# apps/products/views.py
from rest_framework import viewsets, filters, status
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticatedOrReadOnly
from django_filters.rest_framework import DjangoFilterBackend
from django.db.models import Q, Avg
from .models import Product
from .serializers import (
ProductListSerializer,
ProductDetailSerializer,
ProductCreateSerializer
)
from .filters import ProductFilter
from .permissions import IsSellerOrReadOnly
class ProductViewSet(viewsets.ModelViewSet):
"""상품 CRUD API"""
queryset = Product.objects.filter(
status='active'
).select_related(
'seller', 'category'
).prefetch_related(
'images', 'options__values'
)
permission_classes = [IsSellerOrReadOnly]
filter_backends = [DjangoFilterBackend, filters.SearchFilter,
filters.OrderingFilter]
filterset_class = ProductFilter
search_fields = ['name', 'description', 'category__name']
ordering_fields = ['created_at', 'current_price',
'view_count', 'sales_count']
ordering = ['-created_at']
def get_serializer_class(self):
if self.action == 'list':
return ProductListSerializer
elif self.action in ['create', 'update', 'partial_update']:
return ProductCreateSerializer
return ProductDetailSerializer
def retrieve(self, request, *args, **kwargs):
"""상품 상세 조회 + 조회수 증가"""
instance = self.get_object()
# 조회수 증가 (F() 사용으로 race condition 방지)
from django.db.models import F
Product.objects.filter(pk=instance.pk).update(
view_count=F('view_count') + 1
)
serializer = self.get_serializer(instance)
return Response(serializer.data)
@action(detail=False, methods=['get'])
def best_sellers(self, request):
"""베스트셀러 상품 목록"""
queryset = self.get_queryset().order_by('-sales_count')[:10]
serializer = ProductListSerializer(queryset, many=True)
return Response(serializer.data)
@action(detail=False, methods=['get'])
def new_arrivals(self, request):
"""신상품 목록"""
queryset = self.get_queryset().order_by('-created_at')[:20]
serializer = ProductListSerializer(queryset, many=True)
return Response(serializer.data)
@action(detail=True, methods=['post'])
def toggle_wishlist(self, request, pk=None):
"""위시리스트 추가/제거"""
product = self.get_object()
user = request.user
wishlist, created = Wishlist.objects.get_or_create(
user=user, product=product
)
if not created:
wishlist.delete()
return Response({'status': 'removed', 'message': '위시리스트에서 제거되었습니다.'})
return Response({'status': 'added', 'message': '위시리스트에 추가되었습니다! ❤️'})
🛒 장바구니 시스템: 로그인/비로그인 모두 지원
장바구니는 쇼핑몰에서 UX적으로 정말 중요한 기능이야. 특히 비로그인 상태에서도 장바구니를 유지하고, 로그인하면 기존 장바구니와 합치는 기능이 필요해. 이걸 어떻게 구현하는지 보여줄게!
# apps/cart/models.py
from django.db import models
from apps.accounts.models import User
from apps.products.models import Product, ProductOptionValue
class Cart(models.Model):
"""장바구니"""
# 로그인 유저 또는 세션 기반
user = models.OneToOneField(
User, on_delete=models.CASCADE,
null=True, blank=True, related_name='cart'
)
session_key = models.CharField(
max_length=40, null=True, blank=True, unique=True
)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
class Meta:
verbose_name = '장바구니'
@property
def total_price(self):
"""장바구니 총 금액"""
return sum(item.subtotal for item in self.items.all())
@property
def total_count(self):
"""장바구니 총 수량"""
return sum(item.quantity for item in self.items.all())
class CartItem(models.Model):
"""장바구니 아이템"""
cart = models.ForeignKey(
Cart, on_delete=models.CASCADE, related_name='items'
)
product = models.ForeignKey(
Product, on_delete=models.CASCADE
)
option_value = models.ForeignKey(
ProductOptionValue, on_delete=models.SET_NULL,
null=True, blank=True
)
quantity = models.PositiveIntegerField(default=1)
added_at = models.DateTimeField(auto_now_add=True)
class Meta:
unique_together = ['cart', 'product', 'option_value']
@property
def unit_price(self):
"""단가 (옵션 추가금액 포함)"""
base_price = self.product.current_price
if self.option_value:
base_price += self.option_value.additional_price
return base_price
@property
def subtotal(self):
"""소계"""
return self.unit_price * self.quantity
장바구니 서비스 레이어
비즈니스 로직은 View에 직접 쓰지 말고 서비스 레이어로 분리하는 게 좋아. 테스트하기도 쉽고 재사용성도 높아져:
# apps/cart/services.py
from django.db import transaction
from .models import Cart, CartItem
from apps.products.models import Product, ProductOptionValue
class CartService:
"""장바구니 비즈니스 로직"""
@staticmethod
def get_or_create_cart(request):
"""요청에서 장바구니 가져오기 (로그인/비로그인 처리)"""
if request.user.is_authenticated:
cart, created = Cart.objects.get_or_create(user=request.user)
else:
# 세션 기반 장바구니
if not request.session.session_key:
request.session.create()
session_key = request.session.session_key
cart, created = Cart.objects.get_or_create(
session_key=session_key
)
return cart
@staticmethod
def add_item(cart, product_id, quantity=1, option_value_id=None):
"""장바구니에 상품 추가"""
try:
product = Product.objects.get(pk=product_id, status='active')
except Product.DoesNotExist:
raise ValueError('존재하지 않는 상품입니다.')
option_value = None
if option_value_id:
try:
option_value = ProductOptionValue.objects.get(
pk=option_value_id, option__product=product
)
except ProductOptionValue.DoesNotExist:
raise ValueError('올바르지 않은 옵션입니다.')
# 재고 확인
available_stock = (
option_value.stock if option_value else product.stock
)
if available_stock < quantity:
raise ValueError(f'재고가 부족합니다. (현재 재고: {available_stock}개)')
# 이미 있으면 수량 증가, 없으면 새로 생성
cart_item, created = CartItem.objects.get_or_create(
cart=cart,
product=product,
option_value=option_value,
defaults={'quantity': quantity}
)
if not created:
new_quantity = cart_item.quantity + quantity
if new_quantity > available_stock:
raise ValueError(f'최대 {available_stock}개까지 담을 수 있습니다.')
cart_item.quantity = new_quantity
cart_item.save()
return cart_item
@staticmethod
def merge_carts(session_cart, user_cart):
"""로그인 시 세션 장바구니를 유저 장바구니에 합치기"""
with transaction.atomic():
for session_item in session_cart.items.all():
user_item, created = CartItem.objects.get_or_create(
cart=user_cart,
product=session_item.product,
option_value=session_item.option_value,
defaults={'quantity': session_item.quantity}
)
if not created:
user_item.quantity += session_item.quantity
user_item.save()
# 세션 장바구니 삭제
session_cart.delete()
📋 주문 시스템: 트랜잭션이 핵심이야!
주문 처리는 쇼핑몰 백엔드에서 가장 민감하고 중요한 부분이야. 결제는 됐는데 재고 차감이 안 됐다거나, 재고는 차감됐는데 주문이 안 생성됐다거나... 이런 상황이 발생하면 진짜 큰일 나거든 😱 그래서 데이터베이스 트랜잭션을 철저하게 관리해야 해.
# apps/orders/models.py
from django.db import models
from apps.accounts.models import User, ShippingAddress
from apps.products.models import Product, ProductOptionValue
class Order(models.Model):
"""주문 모델"""
STATUS_CHOICES = [
('pending', '결제 대기'),
('paid', '결제 완료'),
('preparing', '상품 준비중'),
('shipped', '배송중'),
('delivered', '배송 완료'),
('cancelled', '주문 취소'),
('refund_requested', '환불 요청'),
('refunded', '환불 완료'),
]
user = models.ForeignKey(
User, on_delete=models.PROTECT, related_name='orders'
)
order_number = models.CharField(
max_length=30, unique=True, verbose_name='주문번호'
)
# 배송 정보 (스냅샷 - 배송지 변경되어도 주문 정보 유지)
recipient_name = models.CharField(max_length=50)
recipient_phone = models.CharField(max_length=20)
zipcode = models.CharField(max_length=10)
address1 = models.CharField(max_length=200)
address2 = models.CharField(max_length=200, blank=True)
delivery_memo = models.CharField(max_length=200, blank=True)
# 금액 정보
subtotal = models.PositiveIntegerField(verbose_name='상품 금액')
shipping_fee = models.PositiveIntegerField(
default=0, verbose_name='배송비'
)
discount_amount = models.PositiveIntegerField(
default=0, verbose_name='할인 금액'
)
point_used = models.PositiveIntegerField(
default=0, verbose_name='사용 포인트'
)
total_amount = models.PositiveIntegerField(verbose_name='최종 결제금액')
status = models.CharField(
max_length=20, choices=STATUS_CHOICES, default='pending'
)
# 배송 추적
tracking_number = models.CharField(
max_length=50, blank=True, verbose_name='운송장번호'
)
courier = models.CharField(
max_length=50, blank=True, verbose_name='택배사'
)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
class Meta:
verbose_name = '주문'
ordering = ['-created_at']
def generate_order_number(self):
"""주문번호 생성 (날짜 + 랜덤)"""
from django.utils import timezone
import random
import string
date_str = timezone.now().strftime('%Y%m%d')
random_str = ''.join(
random.choices(string.ascii_uppercase + string.digits, k=8)
)
return f'ORD-{date_str}-{random_str}'
class OrderItem(models.Model):
"""주문 아이템 (상품 정보 스냅샷)"""
order = models.ForeignKey(
Order, on_delete=models.CASCADE, related_name='items'
)
product = models.ForeignKey(
Product, on_delete=models.PROTECT
)
# 주문 시점의 상품 정보 스냅샷
product_name = models.CharField(max_length=200)
option_name = models.CharField(max_length=100, blank=True)
unit_price = models.PositiveIntegerField()
quantity = models.PositiveIntegerField()
subtotal = models.PositiveIntegerField()
class Meta:
verbose_name = '주문 아이템'
주문 생성 서비스 (트랜잭션 처리)
# apps/orders/services.py
from django.db import transaction
from django.db.models import F
from .models import Order, OrderItem
from apps.products.models import Product, ProductOptionValue
from apps.cart.models import Cart
class OrderService:
@staticmethod
@transaction.atomic
def create_order_from_cart(user, cart, shipping_data, coupon=None):
"""
장바구니에서 주문 생성
- 재고 확인 및 차감
- 주문 생성
- 포인트 처리
모두 하나의 트랜잭션으로 처리!
"""
cart_items = cart.items.select_related(
'product', 'option_value'
).all()
if not cart_items.exists():
raise ValueError('장바구니가 비어있습니다.')
# 1. 재고 확인 및 잠금 (select_for_update로 동시성 방지)
for item in cart_items:
if item.option_value:
option = ProductOptionValue.objects.select_for_update().get(
pk=item.option_value.pk
)
if option.stock < item.quantity:
raise ValueError(
f'[{item.product.name}] 재고가 부족합니다.'
)
else:
product = Product.objects.select_for_update().get(
pk=item.product.pk
)
if product.stock < item.quantity:
raise ValueError(
f'[{item.product.name}] 재고가 부족합니다.'
)
# 2. 금액 계산
subtotal = cart.total_price
shipping_fee = OrderService._calculate_shipping(cart_items)
discount_amount = 0
if coupon:
discount_amount = coupon.calculate_discount(subtotal)
point_used = shipping_data.get('point_used', 0)
if point_used > user.point:
raise ValueError('보유 포인트가 부족합니다.')
total_amount = subtotal + shipping_fee - discount_amount - point_used
# 3. 주문 생성
order = Order(user=user, **shipping_data)
order.order_number = order.generate_order_number()
order.subtotal = subtotal
order.shipping_fee = shipping_fee
order.discount_amount = discount_amount
order.point_used = point_used
order.total_amount = max(total_amount, 0)
order.save()
# 4. 주문 아이템 생성 + 재고 차감
order_items = []
for item in cart_items:
order_items.append(OrderItem(
order=order,
product=item.product,
product_name=item.product.name,
option_name=str(item.option_value) if item.option_value else '',
unit_price=item.unit_price,
quantity=item.quantity,
subtotal=item.subtotal,
))
# 재고 차감
if item.option_value:
ProductOptionValue.objects.filter(
pk=item.option_value.pk
).update(stock=F('stock') - item.quantity)
else:
Product.objects.filter(
pk=item.product.pk
).update(stock=F('stock') - item.quantity)
OrderItem.objects.bulk_create(order_items)
# 5. 포인트 차감
if point_used > 0:
User.objects.filter(pk=user.pk).update(
point=F('point') - point_used
)
# 6. 장바구니 비우기
cart.items.all().delete()
return order
@staticmethod
def _calculate_shipping(cart_items):
"""배송비 계산 로직"""
# 간단한 예시: 5만원 이상 무료배송
total = sum(item.subtotal for item in cart_items)
return 0 if total >= 50000 else 3000
select_for_update()는 해당 행에 대한 DB 락을 걸어서 동시에 여러 요청이 같은 재고를 차감하는 걸 방지해줘. 이게 없으면 동시 주문 시 재고가 마이너스가 될 수 있어!
💳 결제 연동: PG사와 친해지기
한국 쇼핑몰에서 결제 연동은 보통 PG(Payment Gateway)사를 통해 이루어져. 대표적으로 아임포트(PortOne), 토스페이먼츠, KG이니시스 등이 있어. 여기서는 가장 많이 쓰이는 PortOne(구 아임포트) 연동을 예시로 설명할게.
결제 모델
# apps/payments/models.py
from django.db import models
from apps.orders.models import Order
class Payment(models.Model):
"""결제 정보"""
METHOD_CHOICES = [
('card', '신용카드'),
('trans', '실시간 계좌이체'),
('vbank', '가상계좌'),
('phone', '휴대폰 소액결제'),
('kakaopay', '카카오페이'),
('naverpay', '네이버페이'),
('tosspay', '토스페이'),
]
STATUS_CHOICES = [
('ready', '결제 준비'),
('paid', '결제 완료'),
('cancelled', '결제 취소'),
('failed', '결제 실패'),
]
order = models.OneToOneField(
Order, on_delete=models.PROTECT, related_name='payment'
)
# PG사 정보
imp_uid = models.CharField(
max_length=100, unique=True, null=True, blank=True,
verbose_name='아임포트 거래 UID'
)
merchant_uid = models.CharField(
max_length=100, unique=True, verbose_name='주문 고유번호'
)
method = models.CharField(
max_length=20, choices=METHOD_CHOICES, verbose_name='결제 수단'
)
amount = models.PositiveIntegerField(verbose_name='결제 금액')
status = models.CharField(
max_length=20, choices=STATUS_CHOICES, default='ready'
)
# 가상계좌 정보
vbank_num = models.CharField(max_length=50, blank=True)
vbank_name = models.CharField(max_length=50, blank=True)
vbank_due = models.DateTimeField(null=True, blank=True)
# 취소/환불 정보
cancel_amount = models.PositiveIntegerField(default=0)
cancel_reason = models.TextField(blank=True)
cancelled_at = models.DateTimeField(null=True, blank=True)
paid_at = models.DateTimeField(null=True, blank=True)
created_at = models.DateTimeField(auto_now_add=True)
class Meta:
verbose_name = '결제'
결제 검증 API (웹훅 처리)
# apps/payments/views.py
import requests
from django.db import transaction
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django.conf import settings
from .models import Payment
from apps.orders.models import Order
class PaymentVerifyView(APIView):
"""결제 검증 API (프론트에서 결제 완료 후 호출)"""
def post(self, request):
imp_uid = request.data.get('imp_uid')
merchant_uid = request.data.get('merchant_uid')
if not imp_uid or not merchant_uid:
return Response(
{'error': '결제 정보가 올바르지 않습니다.'},
status=status.HTTP_400_BAD_REQUEST
)
# 1. 아임포트 액세스 토큰 발급
token_response = requests.post(
'https://api.iamport.kr/users/getToken',
data={
'imp_key': settings.IAMPORT_API_KEY,
'imp_secret': settings.IAMPORT_API_SECRET,
}
)
access_token = token_response.json()['response']['access_token']
# 2. 결제 정보 조회 (아임포트 서버에서)
payment_response = requests.get(
f'https://api.iamport.kr/payments/{imp_uid}',
headers={'Authorization': access_token}
)
payment_data = payment_response.json()['response']
# 3. 결제 검증
try:
payment = Payment.objects.get(merchant_uid=merchant_uid)
except Payment.DoesNotExist:
return Response(
{'error': '주문 정보를 찾을 수 없습니다.'},
status=status.HTTP_404_NOT_FOUND
)
# 금액 위변조 검증 (핵심!)
if payment_data['amount'] != payment.amount:
return Response(
{'error': '결제 금액이 일치하지 않습니다. 위변조 의심!'},
status=status.HTTP_400_BAD_REQUEST
)
# 4. 결제 상태 업데이트
with transaction.atomic():
if payment_data['status'] == 'paid':
payment.imp_uid = imp_uid
payment.status = 'paid'
from django.utils import timezone
payment.paid_at = timezone.now()
payment.save()
# 주문 상태 업데이트
payment.order.status = 'paid'
payment.order.save()
# 포인트 적립 (결제금액의 1%)
earned_point = int(payment.amount * 0.01)
from django.db.models import F
from apps.accounts.models import User
User.objects.filter(
pk=payment.order.user.pk
).update(point=F('point') + earned_point)
# 알림 발송 (Celery 비동기)
from apps.notifications.tasks import send_order_confirmation
send_order_confirmation.delay(payment.order.pk)
return Response({
'status': 'success',
'message': '결제가 완료되었습니다! 🎉',
'order_number': payment.order.order_number,
'earned_point': earned_point,
})
return Response(
{'error': '결제 처리 중 오류가 발생했습니다.'},
status=status.HTTP_500_INTERNAL_SERVER_ERROR
)
⭐ 리뷰 시스템: 신뢰도를 높이는 핵심 기능
쇼핑몰에서 리뷰는 구매 전환율에 엄청난 영향을 미쳐. 잘 만들어진 리뷰 시스템은 구매 완료 후에만 작성 가능하도록 제한하고, 평점 집계를 효율적으로 처리해야 해.
# apps/reviews/models.py
from django.db import models
from django.core.validators import MinValueValidator, MaxValueValidator
from apps.accounts.models import User
from apps.products.models import Product
from apps.orders.models import OrderItem
class Review(models.Model):
"""상품 리뷰"""
user = models.ForeignKey(
User, on_delete=models.CASCADE, related_name='reviews'
)
product = models.ForeignKey(
Product, on_delete=models.CASCADE, related_name='reviews'
)
order_item = models.OneToOneField(
OrderItem, on_delete=models.SET_NULL,
null=True, verbose_name='주문 아이템'
)
rating = models.PositiveSmallIntegerField(
validators=[MinValueValidator(1), MaxValueValidator(5)],
verbose_name='평점'
)
title = models.CharField(max_length=100, verbose_name='제목')
content = models.TextField(verbose_name='내용')
# 포토 리뷰
is_photo_review = models.BooleanField(default=False)
# 도움이 됐어요
helpful_count = models.PositiveIntegerField(default=0)
# 판매자 답변
seller_reply = models.TextField(blank=True, verbose_name='판매자 답변')
replied_at = models.DateTimeField(null=True, blank=True)
is_verified = models.BooleanField(
default=True, verbose_name='구매 인증 리뷰'
)
created_at = models.DateTimeField(auto_now_add=True)
class Meta:
verbose_name = '리뷰'
ordering = ['-created_at']
def save(self, *args, **kwargs):
super().save(*args, **kwargs)
# 상품 평점 업데이트
self._update_product_rating()
def _update_product_rating(self):
"""상품 평균 평점 업데이트"""
from django.db.models import Avg
avg = Review.objects.filter(
product=self.product
).aggregate(avg=Avg('rating'))['avg']
# Product 모델에 avg_rating 필드가 있다고 가정
Product.objects.filter(pk=self.product.pk).update(
avg_rating=round(avg, 1) if avg else 0
)
class ReviewImage(models.Model):
"""리뷰 이미지"""
review = models.ForeignKey(
Review, on_delete=models.CASCADE, related_name='images'
)
image = models.ImageField(upload_to='reviews/%Y/%m/')
order = models.PositiveSmallIntegerField(default=0)
class Meta:
ordering = ['order']
🔔 비동기 처리: Celery로 알림 보내기
주문 완료 이메일, SMS 발송, 재고 부족 알림 같은 작업들은 메인 요청 처리와 분리해서 비동기로 처리해야 해. 이걸 동기로 처리하면 사용자가 결제 완료 후 이메일 발송될 때까지 기다려야 하거든. 그래서 Celery + Redis 조합을 많이 써!
# config/celery.py
import os
from celery import Celery
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings.production')
app = Celery('myshop')
app.config_from_object('django.conf:settings', namespace='CELERY')
app.autodiscover_tasks()
# config/settings/base.py에 추가
CELERY_BROKER_URL = 'redis://localhost:6379/0'
CELERY_RESULT_BACKEND = 'redis://localhost:6379/0'
CELERY_ACCEPT_CONTENT = ['json']
CELERY_TASK_SERIALIZER = 'json'
CELERY_RESULT_SERIALIZER = 'json'
CELERY_TIMEZONE = 'Asia/Seoul'
# apps/notifications/tasks.py
from celery import shared_task
from django.core.mail import send_mail
from django.template.loader import render_to_string
from django.conf import settings
@shared_task(bind=True, max_retries=3)
def send_order_confirmation(self, order_id):
"""주문 완료 이메일 발송"""
try:
from apps.orders.models import Order
order = Order.objects.select_related(
'user'
).prefetch_related('items__product').get(pk=order_id)
# HTML 이메일 템플릿 렌더링
html_content = render_to_string(
'emails/order_confirmation.html',
{'order': order}
)
send_mail(
subject=f'[주문완료] {order.order_number} 주문이 완료되었습니다.',
message='',
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[order.user.email],
html_message=html_content,
)
return f'이메일 발송 완료: {order.user.email}'
except Exception as exc:
# 실패 시 재시도 (지수 백오프)
raise self.retry(exc=exc, countdown=60 * (2 ** self.request.retries))
@shared_task
def check_low_stock():
"""재고 부족 상품 체크 (주기적 실행)"""
from apps.products.models import Product
low_stock_products = Product.objects.filter(
stock__lte=10, status='active'
)
for product in low_stock_products:
# 판매자에게 알림 발송
send_low_stock_alert.delay(product.pk)
return f'{low_stock_products.count()}개 상품 재고 부족 알림 발송'
@shared_task
def send_low_stock_alert(product_id):
"""재고 부족 알림"""
from apps.products.models import Product
product = Product.objects.select_related('seller').get(pk=product_id)
send_mail(
subject=f'[재고 부족 알림] {product.name}',
message=f'상품 "{product.name}"의 재고가 {product.stock}개 남았습니다.',
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[product.seller.email],
)
django-celery-beat 패키지를 쓰면 DB에서 스케줄을 관리할 수 있어서 편리해!
🔍 검색 최적화: 빠른 상품 검색 구현
쇼핑몰에서 검색 기능은 UX의 핵심이야. Django ORM의 기본 검색도 괜찮지만, 상품 수가 많아지면 Elasticsearch나 PostgreSQL의 Full-Text Search를 활용하는 게 훨씬 빨라. 여기서는 PostgreSQL FTS를 먼저 보여줄게:
# apps/products/filters.py
import django_filters
from django.db.models import Q
from .models import Product
class ProductFilter(django_filters.FilterSet):
"""상품 필터링"""
# 가격 범위
min_price = django_filters.NumberFilter(
method='filter_min_price', label='최소 가격'
)
max_price = django_filters.NumberFilter(
method='filter_max_price', label='최대 가격'
)
# 카테고리 (하위 카테고리 포함)
category = django_filters.NumberFilter(
method='filter_category', label='카테고리'
)
# 할인 상품만
on_sale = django_filters.BooleanFilter(
method='filter_on_sale', label='할인 상품'
)
# 무료배송만
free_shipping = django_filters.BooleanFilter(
method='filter_free_shipping', label='무료배송'
)
class Meta:
model = Product
fields = ['category', 'min_price', 'max_price']
def filter_min_price(self, queryset, name, value):
return queryset.filter(
Q(sale_price__gte=value) |
Q(sale_price__isnull=True, original_price__gte=value)
)
def filter_max_price(self, queryset, name, value):
return queryset.filter(
Q(sale_price__lte=value) |
Q(sale_price__isnull=True, original_price__lte=value)
)
def filter_category(self, queryset, name, value):
"""하위 카테고리 포함 필터링"""
from apps.categories.models import Category
try:
category = Category.objects.get(pk=value)
# 해당 카테고리와 모든 하위 카테고리 ID 수집
category_ids = self._get_all_category_ids(category)
return queryset.filter(category_id__in=category_ids)
except Category.DoesNotExist:
return queryset.none()
def _get_all_category_ids(self, category):
ids = [category.pk]
for child in category.children.all():
ids.extend(self._get_all_category_ids(child))
return ids
def filter_on_sale(self, queryset, name, value):
if value:
return queryset.filter(sale_price__isnull=False)
return queryset
def filter_free_shipping(self, queryset, name, value):
if value:
from django.db.models import F, ExpressionWrapper, IntegerField
return queryset.filter(
Q(sale_price__gte=F('free_shipping_threshold')) |
Q(sale_price__isnull=True,
original_price__gte=F('free_shipping_threshold'))
)
return queryset
캐싱 전략 (Redis 활용)
# apps/products/views.py (캐싱 추가)
from django.core.cache import cache
from django.utils.decorators import method_decorator
from django.views.decorators.cache import cache_page
class ProductViewSet(viewsets.ModelViewSet):
@action(detail=False, methods=['get'])
def best_sellers(self, request):
"""베스트셀러 - Redis 캐싱 (1시간)"""
cache_key = 'products:best_sellers'
cached_data = cache.get(cache_key)
if cached_data:
return Response(cached_data)
queryset = self.get_queryset().order_by('-sales_count')[:10]
serializer = ProductListSerializer(queryset, many=True)
# 1시간 캐싱
cache.set(cache_key, serializer.data, 60 * 60)
return Response(serializer.data)
@action(detail=False, methods=['get'])
def categories_with_count(self, request):
"""카테고리별 상품 수 (캐싱)"""
cache_key = 'categories:product_count'
cached_data = cache.get(cache_key)
if not cached_data:
from apps.categories.models import Category
from django.db.models import Count
categories = Category.objects.annotate(
product_count=Count('products',
filter=Q(products__status='active'))
).filter(parent__isnull=True)
cached_data = [
{
'id': cat.id,
'name': cat.name,
'product_count': cat.product_count
}
for cat in categories
]
cache.set(cache_key, cached_data, 60 * 30) # 30분
return Response(cached_data)
🛡️ 보안 강화: 쇼핑몰에서 절대 놓치면 안 되는 것들
쇼핑몰은 개인정보와 결제 정보를 다루기 때문에 보안이 정말 중요해. Django가 기본적으로 많은 보안 기능을 제공하지만, 추가로 신경 써야 할 부분들이 있어 🔐
| 보안 항목 | Django 설정 | 설명 |
|---|---|---|
| HTTPS 강제 | SECURE_SSL_REDIRECT = True |
모든 HTTP 요청을 HTTPS로 리다이렉트 |
| HSTS | SECURE_HSTS_SECONDS = 31536000 |
브라우저가 HTTPS만 사용하도록 강제 |
| XSS 방지 | SECURE_BROWSER_XSS_FILTER = True |
크로스 사이트 스크립팅 공격 방어 |
| 클릭재킹 방지 | X_FRAME_OPTIONS = 'DENY' |
iframe 임베딩 차단 |
| CSRF 보호 | 기본 활성화 | 위조 요청 방지 (API는 JWT로 대체) |
| Rate Limiting | django-ratelimit | API 요청 횟수 제한 (브루트포스 방지) |
# config/settings/production.py
# 보안 설정
SECURE_SSL_REDIRECT = True
SECURE_HSTS_SECONDS = 31536000
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True
SECURE_BROWSER_XSS_FILTER = True
SECURE_CONTENT_TYPE_NOSNIFF = True
X_FRAME_OPTIONS = 'DENY'
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
# 비밀번호 검증 강화
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
'OPTIONS': {'min_length': 8}
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# JWT 설정
from datetime import timedelta
SIMPLE_JWT = {
'ACCESS_TOKEN_LIFETIME': timedelta(hours=1),
'REFRESH_TOKEN_LIFETIME': timedelta(days=7),
'ROTATE_REFRESH_TOKENS': True,
'BLACKLIST_AFTER_ROTATION': True,
'ALGORITHM': 'HS256',
'SIGNING_KEY': SECRET_KEY,
}
# CORS 설정 (허용 도메인만)
CORS_ALLOWED_ORIGINS = [
'https://www.myshop.com',
'https://admin.myshop.com',
]
CORS_ALLOW_CREDENTIALS = True
pip install django[argon2] 설치 후 PASSWORD_HASHERS 설정에서 argon2를 첫 번째로 올려줘!
📊 Django Admin 커스터마이징: 강력한 관리 도구
Django Admin은 그냥 쓰면 기본적인 CRUD만 되는데, 커스터마이징하면 진짜 강력한 쇼핑몰 관리 도구가 돼. 주문 현황 대시보드, 상품 일괄 처리, 매출 통계 등을 Admin에서 바로 볼 수 있어!
# apps/orders/admin.py
from django.contrib import admin
from django.utils.html import format_html
from django.db.models import Sum, Count
from .models import Order, OrderItem
class OrderItemInline(admin.TabularInline):
model = OrderItem
extra = 0
readonly_fields = ['product', 'product_name', 'unit_price',
'quantity', 'subtotal']
can_delete = False
@admin.register(Order)
class OrderAdmin(admin.ModelAdmin):
list_display = [
'order_number', 'user', 'status_badge',
'total_amount_display', 'created_at'
]
list_filter = ['status', 'created_at']
search_fields = ['order_number', 'user__email', 'recipient_name']
readonly_fields = ['order_number', 'created_at', 'updated_at']
inlines = [OrderItemInline]
# 주문 상태 일괄 변경 액션
actions = ['mark_as_preparing', 'mark_as_shipped', 'mark_as_delivered']
def status_badge(self, obj):
"""상태를 컬러 배지로 표시"""
colors = {
'pending': '#e8a87c',
'paid': '#5b9bd5',
'preparing': '#9b8bd5',
'shipped': '#6bbf8e',
'delivered': '#4aa870',
'cancelled': '#e87c7c',
}
color = colors.get(obj.status, '#999')
return format_html(
'<span style="background:{};color:#fff;padding:3px 8px;'
'border-radius:4px;font-size:12px;">{}</span>',
color,
obj.get_status_display()
)
status_badge.short_description = '주문 상태'
def total_amount_display(self, obj):
return f'{obj.total_amount:,}원'
total_amount_display.short_description = '결제금액'
def mark_as_preparing(self, request, queryset):
updated = queryset.filter(status='paid').update(status='preparing')
self.message_user(request, f'{updated}개 주문을 준비중으로 변경했습니다.')
mark_as_preparing.short_description = '선택 주문 → 상품 준비중'
def mark_as_shipped(self, request, queryset):
updated = queryset.filter(status='preparing').update(status='shipped')
self.message_user(request, f'{updated}개 주문을 배송중으로 변경했습니다.')
mark_as_shipped.short_description = '선택 주문 → 배송중'
def mark_as_delivered(self, request, queryset):
updated = queryset.filter(status='shipped').update(status='delivered')
self.message_user(request, f'{updated}개 주문을 배송완료로 변경했습니다.')
mark_as_delivered.short_description = '선택 주문 → 배송완료'
🧪 테스트 코드: 믿을 수 있는 쇼핑몰 만들기
쇼핑몰에서 버그는 곧 매출 손실이야. 특히 결제, 재고 관련 버그는 치명적이지. 테스트 코드를 작성하면 이런 문제를 미리 잡을 수 있어. 처음엔 귀찮아 보여도 나중에 진짜 고마워하게 될 거야 😊
# apps/orders/tests.py
from django.test import TestCase
from django.contrib.auth import get_user_model
from apps.products.models import Product, ProductOption, ProductOptionValue
from apps.categories.models import Category
from apps.cart.models import Cart, CartItem
from apps.orders.services import OrderService
User = get_user_model()
class OrderServiceTest(TestCase):
def setUp(self):
"""테스트 데이터 설정"""
self.user = User.objects.create_user(
email='test@test.com',
username='테스터',
password='testpass123!'
)
self.category = Category.objects.create(
name='테스트 카테고리', slug='test-category'
)
self.product = Product.objects.create(
seller=self.user,
category=self.category,
name='테스트 상품',
slug='test-product',
description='테스트 상품입니다.',
original_price=30000,
stock=10,
)
self.cart = Cart.objects.create(user=self.user)
CartItem.objects.create(
cart=self.cart,
product=self.product,
quantity=2
)
self.shipping_data = {
'recipient_name': '홍길동',
'recipient_phone': '010-1234-5678',
'zipcode': '12345',
'address1': '서울시 강남구',
'address2': '101호',
}
def test_create_order_success(self):
"""정상 주문 생성 테스트"""
order = OrderService.create_order_from_cart(
self.user, self.cart, self.shipping_data
)
self.assertEqual(order.user, self.user)
self.assertEqual(order.items.count(), 1)
self.assertEqual(order.subtotal, 60000) # 30000 * 2
self.assertEqual(order.status, 'pending')
# 재고 차감 확인
self.product.refresh_from_db()
self.assertEqual(self.product.stock, 8) # 10 - 2
# 장바구니 비워짐 확인
self.assertEqual(self.cart.items.count(), 0)
def test_create_order_insufficient_stock(self):
"""재고 부족 시 주문 실패 테스트"""
# 재고보다 많은 수량 담기
CartItem.objects.filter(cart=self.cart).update(quantity=20)
with self.assertRaises(ValueError) as context:
OrderService.create_order_from_cart(
self.user, self.cart, self.shipping_data
)
self.assertIn('재고가 부족합니다', str(context.exception))
# 재고 변경 없음 확인 (트랜잭션 롤백)
self.product.refresh_from_db()
self.assertEqual(self.product.stock, 10)
def test_create_order_empty_cart(self):
"""빈 장바구니 주문 실패 테스트"""
empty_cart = Cart.objects.create()
with self.assertRaises(ValueError) as context:
OrderService.create_order_from_cart(
self.user, empty_cart, self.shipping_data
)
self.assertIn('장바구니가 비어있습니다', str(context.exception))
coverage run manage.py test && coverage report 명령어로 커버리지를 확인할 수 있어!
🚀 배포 전략: 실제 서비스 운영하기
개발이 끝났으면 이제 배포해야지! Django 쇼핑몰의 일반적인 배포 스택을 알아보자. 요즘은 Docker + AWS 조합이 가장 많이 쓰여.
# Dockerfile
FROM python:3.11-slim
WORKDIR /app
# 시스템 패키지 설치
RUN apt-get update && apt-get install -y \
postgresql-client \
&& rm -rf /var/lib/apt/lists/*
# Python 패키지 설치
COPY requirements/production.txt .
RUN pip install --no-cache-dir -r production.txt
# 소스 코드 복사
COPY . .
# 정적 파일 수집
RUN python manage.py collectstatic --noinput
# Gunicorn으로 실행
CMD ["gunicorn", "--bind", "0.0.0.0:8000",
"--workers", "4",
"--worker-class", "gevent",
"config.wsgi:application"]
# docker-compose.yml (개발 환경)
version: '3.8'
services:
web:
build: .
command: python manage.py runserver 0.0.0.0:8000
volumes:
- .:/app
ports:
- "8000:8000"
environment:
- DJANGO_SETTINGS_MODULE=config.settings.development
depends_on:
- db
- redis
db:
image: postgres:15
environment:
POSTGRES_DB: myshop
POSTGRES_USER: myshop_user
POSTGRES_PASSWORD: myshop_password
volumes:
- postgres_data:/var/lib/postgresql/data
redis:
image: redis:7-alpine
ports:
- "6379:6379"
celery:
build: .
command: celery -A config worker -l info
volumes:
- .:/app
depends_on:
- redis
- db
celery-beat:
build: .
command: celery -A config beat -l info
volumes:
- .:/app
depends_on:
- redis
volumes:
postgres_data:
📈 성능 최적화: N+1 문제와 쿼리 최적화
쇼핑몰 백엔드에서 성능 문제의 주범은 대부분 N+1 쿼리 문제야. 상품 목록 100개를 가져오면서 각 상품의 이미지, 카테고리, 판매자 정보를 따로따로 쿼리하면... 100 * 3 = 300번의 DB 쿼리가 발생해. 이걸 해결하는 게 핵심이야!
# 나쁜 예 (N+1 문제 발생)
products = Product.objects.all()
for product in products:
print(product.category.name) # 매번 DB 쿼리!
print(product.seller.email) # 매번 DB 쿼리!
for image in product.images.all(): # 매번 DB 쿼리!
print(image.image.url)
# 좋은 예 (select_related + prefetch_related)
products = Product.objects.select_related(
'category', # ForeignKey - JOIN으로 한 번에
'seller', # ForeignKey - JOIN으로 한 번에
).prefetch_related(
'images', # ManyToMany/역참조 - 별도 쿼리 1번
'options__values', # 중첩 prefetch
).annotate(
review_count=Count('reviews'),
avg_rating=Avg('reviews__rating'),
).filter(status='active')
# 결과: 쿼리 수가 N+1에서 3~4개로 줄어듦!
쿼리 디버깅 도구
# 개발 환경에서 쿼리 수 확인
from django.db import connection
# 쿼리 수 확인
print(len(connection.queries))
# django-debug-toolbar 설치 (개발 환경)
# pip install django-debug-toolbar
# settings/development.py에 추가:
INSTALLED_APPS += ['debug_toolbar']
MIDDLEWARE += ['debug_toolbar.middleware.DebugToolbarMiddleware']
INTERNAL_IPS = ['127.0.0.1']
# 또는 django-silk로 API 성능 프로파일링
# pip install django-silk
category, status, created_at 같이 자주 필터링/정렬하는 필드에는 반드시 인덱스를 걸어줘!
🎯 마무리: 재능넷에서 Django 쇼핑몰 개발자 찾기
여기까지 Django와 Python으로 쇼핑몰 백엔드를 구축하는 방법을 쭉 살펴봤어. 정리해보면:
이 모든 걸 혼자 구현하기 어렵다면, 재능넷에서 Django 전문 개발자를 찾아보는 것도 좋은 방법이야! 재능넷에는 쇼핑몰 백엔드 개발 경험이 풍부한 Python/Django 개발자들이 많이 활동하고 있어서, 맞춤형 쇼핑몰 개발을 의뢰하거나 코드 리뷰를 받을 수 있거든 🙌
관련 키워드
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.