php -v

composer --version

mkdir payment-integration
cd payment-integration
composer init

composer require stripe/stripe-php
composer require paypal/rest-api-sdk-php

payment-integration/
│
├── config/
│   ├── stripe.php          # Stripe 설정
│   └── paypal.php          # PayPal 설정
│
├── src/
│   ├── Payment/
│   │   ├── StripePayment.php
│   │   ├── PayPalPayment.php
│   │   └── PaymentInterface.php
│   │
│   └── Database/
│       └── TransactionLogger.php
│
├── public/
│   ├── index.php           # 메인 페이지
│   ├── checkout.php        # 결제 페이지
│   ├── success.php         # 성공 페이지
│   └── cancel.php          # 취소 페이지
│
├── vendor/                 # Composer 패키지
├── .env                    # 환경 변수 (API 키 저장)
├── .gitignore
└── composer.json

composer require vlucas/phpdotenv

# Stripe 설정
STRIPE_PUBLISHABLE_KEY=pk_test_your_publishable_key_here
STRIPE_SECRET_KEY=sk_test_your_secret_key_here

# PayPal 설정
PAYPAL_CLIENT_ID=your_client_id_here
PAYPAL_CLIENT_SECRET=your_client_secret_here
PAYPAL_MODE=sandbox  # 실제 운영 시 'live'로 변경

# 데이터베이스 설정
DB_HOST=localhost
DB_NAME=payment_db
DB_USER=root
DB_PASS=your_password

# 애플리케이션 설정
APP_URL=http://localhost:8000
CURRENCY=USD

<?php

require_once __DIR__ . '/../vendor/autoload.php';

use Dotenv\Dotenv;

$dotenv = Dotenv::createImmutable(__DIR__ . '/..');
$dotenv->load();

return [
    'publishable_key' => $_ENV['STRIPE_PUBLISHABLE_KEY'],
    'secret_key' => $_ENV['STRIPE_SECRET_KEY'],
    'currency' => $_ENV['CURRENCY'] ?? 'USD',
    'api_version' => '2023-10-16'
];

<?php

require_once __DIR__ . '/../vendor/autoload.php';

use Dotenv\Dotenv;

$dotenv = Dotenv::createImmutable(__DIR__ . '/..');
$dotenv->load();

return [
    'client_id' => $_ENV['PAYPAL_CLIENT_ID'],
    'client_secret' => $_ENV['PAYPAL_CLIENT_SECRET'],
    'mode' => $_ENV['PAYPAL_MODE'] ?? 'sandbox',
    'currency' => $_ENV['CURRENCY'] ?? 'USD',
    'return_url' => $_ENV['APP_URL'] . '/success.php',
    'cancel_url' => $_ENV['APP_URL'] . '/cancel.php'
];

<?php

namespace Payment;

interface PaymentInterface
{
    /**
     * 결제 초기화
     * 
     * @param array $data 결제 정보 (금액, 상품명 등)
     * @return mixed 결제 세션 또는 리다이렉트 URL
     */
    public function createPayment(array $data);
    
    /**
     * 결제 실행
     * 
     * @param string $paymentId 결제 ID
     * @param array $data 추가 데이터
     * @return array 결제 결과
     */
    public function executePayment(string $paymentId, array $data = []);
    
    /**
     * 결제 취소
     * 
     * @param string $paymentId 결제 ID
     * @return bool 취소 성공 여부
     */
    public function cancelPayment(string $paymentId): bool;
    
    /**
     * 환불 처리
     * 
     * @param string $paymentId 결제 ID
     * @param float $amount 환불 금액
     * @return array 환불 결과
     */
    public function refundPayment(string $paymentId, float $amount);
    
    /**
     * 결제 상태 조회
     * 
     * @param string $paymentId 결제 ID
     * @return array 결제 상태 정보
     */
    public function getPaymentStatus(string $paymentId): array;
}

<?php

namespace Payment;

use Stripe\Stripe;
use Stripe\Checkout\Session;
use Stripe\PaymentIntent;
use Stripe\Refund;
use Exception;

class StripePayment implements PaymentInterface
{
    private $secretKey;
    private $publishableKey;
    private $currency;
    
    public function __construct(array $config)
    {
        $this->secretKey = $config['secret_key'];
        $this->publishableKey = $config['publishable_key'];
        $this->currency = $config['currency'];
        
        // Stripe API 초기화
        Stripe::setApiKey($this->secretKey);
    }
    
    /**
     * Checkout Session 생성 (호스팅된 결제 페이지)
     */
    public function createPayment(array $data)
    {
        try {
            $session = Session::create([
                'payment_method_types' => ['card'],
                'line_items' => [[
                    'price_data' => [
                        'currency' => $this->currency,
                        'product_data' => [
                            'name' => $data['product_name'],
                            'description' => $data['description'] ?? '',
                        ],
                        'unit_amount' => $data['amount'] * 100, // 센트 단위
                    ],
                    'quantity' => $data['quantity'] ?? 1,
                ]],
                'mode' => 'payment',
                'success_url' => $data['success_url'] . '?session_id={CHECKOUT_SESSION_ID}',
                'cancel_url' => $data['cancel_url'],
                'customer_email' => $data['customer_email'] ?? null,
                'metadata' => $data['metadata'] ?? [],
            ]);
            
            return [
                'success' => true,
                'session_id' => $session->id,
                'url' => $session->url,
                'publishable_key' => $this->publishableKey
            ];
            
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * Payment Intent 생성 (커스텀 결제 폼)
     */
    public function createPaymentIntent(array $data)
    {
        try {
            $paymentIntent = PaymentIntent::create([
                'amount' => $data['amount'] * 100,
                'currency' => $this->currency,
                'description' => $data['description'] ?? '',
                'metadata' => $data['metadata'] ?? [],
            ]);
            
            return [
                'success' => true,
                'client_secret' => $paymentIntent->client_secret,
                'payment_intent_id' => $paymentIntent->id
            ];
            
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * 결제 실행 (Checkout Session 확인)
     */
    public function executePayment(string $sessionId, array $data = [])
    {
        try {
            $session = Session::retrieve($sessionId);
            
            return [
                'success' => true,
                'payment_status' => $session->payment_status,
                'amount_total' => $session->amount_total / 100,
                'customer_email' => $session->customer_details->email ?? null,
                'payment_intent' => $session->payment_intent
            ];
            
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * 결제 취소
     */
    public function cancelPayment(string $paymentId): bool
    {
        try {
            $paymentIntent = PaymentIntent::retrieve($paymentId);
            $paymentIntent->cancel();
            return true;
            
        } catch (Exception $e) {
            return false;
        }
    }
    
    /**
     * 환불 처리
     */
    public function refundPayment(string $paymentId, float $amount)
    {
        try {
            $refund = Refund::create([
                'payment_intent' => $paymentId,
                'amount' => $amount * 100, // 부분 환불 가능
            ]);
            
            return [
                'success' => true,
                'refund_id' => $refund->id,
                'status' => $refund->status,
                'amount' => $refund->amount / 100
            ];
            
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * 결제 상태 조회
     */
    public function getPaymentStatus(string $paymentId): array
    {
        try {
            $paymentIntent = PaymentIntent::retrieve($paymentId);
            
            return [
                'success' => true,
                'status' => $paymentIntent->status,
                'amount' => $paymentIntent->amount / 100,
                'currency' => $paymentIntent->currency,
                'created' => date('Y-m-d H:i:s', $paymentIntent->created)
            ];
            
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * Webhook 서명 검증
     */
    public function verifyWebhook(string $payload, string $signature, string $secret): bool
    {
        try {
            \Stripe\Webhook::constructEvent($payload, $signature, $secret);
            return true;
        } catch (Exception $e) {
            return false;
        }
    }
}

<?php

require_once __DIR__ . '/../vendor/autoload.php';

use Payment\StripePayment;

$config = require __DIR__ . '/../config/stripe.php';
$stripe = new StripePayment($config);

// POST 요청 처리
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $paymentData = [
        'product_name' => $_POST['product_name'],
        'description' => $_POST['description'] ?? '',
        'amount' => floatval($_POST['amount']),
        'quantity' => intval($_POST['quantity'] ?? 1),
        'customer_email' => $_POST['email'] ?? '',
        'success_url' => $_ENV['APP_URL'] . '/success.php',
        'cancel_url' => $_ENV['APP_URL'] . '/cancel.php',
        'metadata' => [
            'order_id' => uniqid('order_'),
            'user_id' => $_SESSION['user_id'] ?? 'guest'
        ]
    ];
    
    $result = $stripe->createPayment($paymentData);
    
    if ($result['success']) {
        // Stripe Checkout 페이지로 리다이렉트
        header('Location: ' . $result['url']);
        exit;
    } else {
        $error = $result['error'];
    }
}

?>

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Stripe 결제</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { font-family: 'Segoe UI', sans-serif; background: #f5f5f5; padding: 20px; }
        .container { max-width: 500px; margin: 50px auto; background: white; padding: 30px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
        h2 { color: #6c5ce7; margin-bottom: 20px; }
        .form-group { margin-bottom: 20px; }
        label { display: block; margin-bottom: 5px; color: #2d3436; font-weight: 600; }
        input, textarea { width: 100%; padding: 12px; border: 2px solid #dfe6e9; border-radius: 5px; font-size: 14px; }
        input:focus, textarea:focus { outline: none; border-color: #6c5ce7; }
        button { width: 100%; padding: 15px; background: #6c5ce7; color: white; border: none; border-radius: 5px; font-size: 16px; font-weight: 600; cursor: pointer; transition: 0.3s; }
        button:hover { background: #5f4dd1; }
        .error { background: #ff7675; color: white; padding: 10px; border-radius: 5px; margin-bottom: 20px; }
    </style>
</head>
<body>
    <div class="container">
        <h2>💳 Stripe 결제</h2>
        
        <?php if (isset($error)): ?>
            <div class="error">❌ <!--?= htmlspecialchars($error) ?></div>
        <?php endif; ?>
        
        <form method="POST">
            <div class="form-group">
                <label>상품명</label>
                <input type="text" name="product_name" required placeholder="예: 프리미엄 멤버십">
            </div>
            
            <div class="form-group">
                <label>상품 설명</label>
                <textarea name="description" rows="3" placeholder="상품에 대한 간단한 설명"></textarea>
            </div>
            
            <div class="form-group">
                <label>금액 (USD)</label>
                <input type="number" name="amount" step="0.01" required placeholder="29.99">
            </div>
            
            <div class="form-group">
                <label>수량</label>
                <input type="number" name="quantity" value="1" min="1">
            </div>
            
            <div class="form-group">
                <label>이메일</label>
                <input type="email" name="email" placeholder="your@email.com">
            </div>
            
            <button type="submit">🚀 Stripe로 결제하기</button>
        </form>
    </div>
</body>
</html></code-->

💛 PayPal 결제 구현하기

이제 PayPal 차례야! PayPal은 전 세계적으로 가장 많이 사용되는 결제 시스템 중 하나라서 꼭 통합해야 해. 🌍

src/Payment/PayPalPayment.php 파일을 만들어:


<?php

namespace Payment;

use PayPal\Rest\ApiContext;
use PayPal\Auth\OAuthTokenCredential;
use PayPal\Api\Amount;
use PayPal\Api\Payer;
use PayPal\Api\Payment;
use PayPal\Api\PaymentExecution;
use PayPal\Api\RedirectUrls;
use PayPal\Api\Transaction;
use PayPal\Api\RefundRequest;
use PayPal\Api\Sale;
use Exception;

class PayPalPayment implements PaymentInterface
{
    private $apiContext;
    private $currency;
    private $returnUrl;
    private $cancelUrl;
    
    public function __construct(array $config)
    {
        $this->currency = $config['currency'];
        $this->returnUrl = $config['return_url'];
        $this->cancelUrl = $config['cancel_url'];
        
        // PayPal API Context 초기화
        $this->apiContext = new ApiContext(
            new OAuthTokenCredential(
                $config['client_id'],
                $config['client_secret']
            )
        );
        
        $this->apiContext->setConfig([
            'mode' => $config['mode'],
            'log.LogEnabled' => true,
            'log.FileName' => __DIR__ . '/../../logs/paypal.log',
            'log.LogLevel' => 'INFO',
            'cache.enabled' => true,
        ]);
    }
    
    /**
     * PayPal 결제 생성
     */
    public function createPayment(array $data)
    {
        try {
            // Payer 설정
            $payer = new Payer();
            $payer->setPaymentMethod('paypal');
            
            // 금액 설정
            $amount = new Amount();
            $amount->setCurrency($this->currency)
                   ->setTotal($data['amount']);
            
            // 거래 정보 설정
            $transaction = new Transaction();
            $transaction->setAmount($amount)
                       ->setDescription($data['description'] ?? '')
                       ->setInvoiceNumber($data['invoice_number'] ?? uniqid('INV-'));
            
            // 리다이렉트 URL 설정
            $redirectUrls = new RedirectUrls();
            $redirectUrls->setReturnUrl($this->returnUrl)
                        ->setCancelUrl($this->cancelUrl);
            
            // Payment 객체 생성
            $payment = new Payment();
            $payment->setIntent('sale')
                   ->setPayer($payer)
                   ->setRedirectUrls($redirectUrls)
                   ->setTransactions([$transaction]);
            
            // 결제 생성
            $payment->create($this->apiContext);
            
            // 승인 URL 찾기
            $approvalUrl = null;
            foreach ($payment->getLinks() as $link) {
                if ($link->getRel() === 'approval_url') {
                    $approvalUrl = $link->getHref();
                    break;
                }
            }
            
            return [
                'success' => true,
                'payment_id' => $payment->getId(),
                'approval_url' => $approvalUrl,
                'state' => $payment->getState()
            ];
            
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * 결제 실행
     */
    public function executePayment(string $paymentId, array $data = [])
    {
        try {
            $payment = Payment::get($paymentId, $this->apiContext);
            
            $execution = new PaymentExecution();
            $execution->setPayerId($data['payer_id']);
            
            $result = $payment->execute($execution, $this->apiContext);
            
            return [
                'success' => true,
                'payment_id' => $result->getId(),
                'state' => $result->getState(),
                'payer_email' => $result->getPayer()->getPayerInfo()->getEmail(),
                'amount' => $result->getTransactions()[0]->getAmount()->getTotal(),
                'currency' => $result->getTransactions()[0]->getAmount()->getCurrency()
            ];
            
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * 결제 취소
     */
    public function cancelPayment(string $paymentId): bool
    {
        // PayPal은 승인 전 결제는 자동으로 만료됨
        // 승인 후 결제는 환불로 처리해야 함
        return true;
    }
    
    /**
     * 환불 처리
     */
    public function refundPayment(string $saleId, float $amount)
    {
        try {
            $sale = Sale::get($saleId, $this->apiContext);
            
            $refundRequest = new RefundRequest();
            $refundAmount = new Amount();
            $refundAmount->setCurrency($this->currency)
                        ->setTotal($amount);
            $refundRequest->setAmount($refundAmount);
            
            $refund = $sale->refundSale($refundRequest, $this->apiContext);
            
            return [
                'success' => true,
                'refund_id' => $refund->getId(),
                'state' => $refund->getState(),
                'amount' => $refund->getAmount()->getTotal()
            ];
            
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * 결제 상태 조회
     */
    public function getPaymentStatus(string $paymentId): array
    {
        try {
            $payment = Payment::get($paymentId, $this->apiContext);
            
            return [
                'success' => true,
                'payment_id' => $payment->getId(),
                'state' => $payment->getState(),
                'create_time' => $payment->getCreateTime(),
                'update_time' => $payment->getUpdateTime()
            ];
            
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
    
    /**
     * Webhook 검증
     */
    public function verifyWebhook(array $headers, string $payload, string $webhookId): bool
    {
        try {
            // PayPal Webhook 검증 로직
            // 실제 구현 시 PayPal의 Webhook 검증 API 사용
            return true;
        } catch (Exception $e) {
            return false;
        }
    }
}


PayPal 결제 페이지 만들기

public/paypal-checkout.php:


<?php

require_once __DIR__ . '/../vendor/autoload.php';

use Payment\PayPalPayment;

$config = require __DIR__ . '/../config/paypal.php';
$paypal = new PayPalPayment($config);

// POST 요청 처리
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $paymentData = [
        'amount' => floatval($_POST['amount']),
        'description' => $_POST['description'] ?? '',
        'invoice_number' => 'INV-' . time()
    ];
    
    $result = $paypal->createPayment($paymentData);
    
    if ($result['success']) {
        // PayPal 승인 페이지로 리다이렉트
        header('Location: ' . $result['approval_url']);
        exit;
    } else {
        $error = $result['error'];
    }
}

?>

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>PayPal 결제</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { font-family: 'Segoe UI', sans-serif; background: #f5f5f5; padding: 20px; }
        .container { max-width: 500px; margin: 50px auto; background: white; padding: 30px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
        h2 { color: #0070ba; margin-bottom: 20px; }
        .form-group { margin-bottom: 20px; }
        label { display: block; margin-bottom: 5px; color: #2d3436; font-weight: 600; }
        input, textarea { width: 100%; padding: 12px; border: 2px solid #dfe6e9; border-radius: 5px; font-size: 14px; }
        input:focus, textarea:focus { outline: none; border-color: #0070ba; }
        button { width: 100%; padding: 15px; background: #0070ba; color: white; border: none; border-radius: 5px; font-size: 16px; font-weight: 600; cursor: pointer; transition: 0.3s; }
        button:hover { background: #005a94; }
        .error { background: #ff7675; color: white; padding: 10px; border-radius: 5px; margin-bottom: 20px; }
    </style>
</head>
<body>
    <div class="container">
        <h2>💛 PayPal 결제</h2>
        
        <?php if (isset($error)): ?>
            <div class="error">❌ <!--?= htmlspecialchars($error) ?></div>
        <?php endif; ?>
        
        <form method="POST">
            <div class="form-group">
                <label>결제 설명</label>
                <textarea name="description" rows="3" required placeholder="결제 내용을 입력하세요"></textarea>
            </div>
            
            <div class="form-group">
                <label>금액 (USD)</label>
                <input type="number" name="amount" step="0.01" required placeholder="29.99">
            </div>
            
            <button type="submit">🚀 PayPal로 결제하기</button>
        </form>
    </div>
</body>
</html></code-->



그리고 PayPal 결제 완료 후 돌아오는 페이지 public/success.php:


<?php

require_once __DIR__ . '/../vendor/autoload.php';

use Payment\PayPalPayment;
use Payment\StripePayment;

// Stripe 결제 완료 처리
if (isset($_GET['session_id'])) {
    $config = require __DIR__ . '/../config/stripe.php';
    $stripe = new StripePayment($config);
    
    $result = $stripe->executePayment($_GET['session_id']);
    
    if ($result['success']) {
        $paymentInfo = $result;
        $paymentMethod = 'Stripe';
    }
}

// PayPal 결제 완료 처리
if (isset($_GET['paymentId']) && isset($_GET['PayerID'])) {
    $config = require __DIR__ . '/../config/paypal.php';
    $paypal = new PayPalPayment($config);
    
    $result = $paypal->executePayment($_GET['paymentId'], [
        'payer_id' => $_GET['PayerID']
    ]);
    
    if ($result['success']) {
        $paymentInfo = $result;
        $paymentMethod = 'PayPal';
    }
}

?>

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>결제 완료</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { font-family: 'Segoe UI', sans-serif; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); min-height: 100vh; display: flex; align-items: center; justify-content: center; padding: 20px; }
        .success-box { background: white; padding: 40px; border-radius: 15px; box-shadow: 0 10px 40px rgba(0,0,0,0.2); max-width: 500px; text-align: center; }
        .success-icon { font-size: 80px; margin-bottom: 20px; }
        h1 { color: #00b894; margin-bottom: 10px; }
        .info-box { background: #f8f9fa; padding: 20px; border-radius: 10px; margin: 20px 0; text-align: left; }
        .info-row { display: flex; justify-content: space-between; margin: 10px 0; padding: 10px 0; border-bottom: 1px solid #dfe6e9; }
        .info-row:last-child { border-bottom: none; }
        .label { font-weight: 600; color: #636e72; }
        .value { color: #2d3436; }
        .btn { display: inline-block; padding: 12px 30px; background: #6c5ce7; color: white; text-decoration: none; border-radius: 5px; margin-top: 20px; transition: 0.3s; }
        .btn:hover { background: #5f4dd1; }
    </style>
</head>
<body>
    <div class="success-box">
        <div class="success-icon">✅</div>
        <h1>결제가 완료되었습니다!</h1>
        <p>감사합니다. 결제가 성공적으로 처리되었습니다.</p>
        
        <?php if (isset($paymentInfo)): ?>
        <div class="info-box">
            <div class="info-row">
                <span class="label">결제 방법</span>
                <span class="value"><!--?= $paymentMethod ?></span>
            </div>
            <div class="info-row">
                <span class="label">결제 ID</span>
                <span class="value"><?= htmlspecialchars($paymentInfo['payment_id'] ?? $paymentInfo['payment_intent']) ?></span>
            </div>
            <div class="info-row">
                <span class="label">금액</span>
                <span class="value">$<?= number_format($paymentInfo['amount'] ?? $paymentInfo['amount_total'], 2) ?></span>
            </div>
            <div class="info-row">
                <span class="label">상태</span>
                <span class="value"><?= $paymentInfo['payment_status'] ?? $paymentInfo['state'] ?></span>
            </div>
        </div>
        <?php endif; ?>
        
        <a href="/" class="btn">홈으로 돌아가기</a>
    </div>
</body>
</html></code-->






🎭 통합 결제 페이지 만들기

이제 Stripe와 PayPal을 한 페이지에서 선택할 수 있는 통합 결제 페이지를 만들어보자! 사용자 경험이 훨씬 좋아질 거야. 🎨

public/checkout.php:


<?php
session_start();
require_once __DIR__ . '/../vendor/autoload.php';

// 장바구니나 주문 정보 (실제로는 DB에서 가져와야 함)
$orderInfo = [
    'product_name' => '프리미엄 멤버십',
    'description' => '1년 구독',
    'amount' => 99.99,
    'quantity' => 1
];
?>

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>통합 결제</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { font-family: 'Segoe UI', sans-serif; background: #f5f5f5; padding: 20px; }
        .container { max-width: 800px; margin: 30px auto; }
        .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; border-radius: 15px 15px 0 0; text-align: center; }
        .content { background: white; padding: 30px; border-radius: 0 0 15px 15px; box-shadow: 0 5px 20px rgba(0,0,0,0.1); }
        .order-summary { background: #f8f9fa; padding: 20px; border-radius: 10px; margin-bottom: 30px; }
        .order-item { display: flex; justify-content: space-between; margin: 10px 0; padding: 10px 0; border-bottom: 1px solid #dfe6e9; }
        .total { font-size: 1.5em; font-weight: bold; color: #2d3436; margin-top: 15px; }
        .payment-methods { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; margin-top: 30px; }
        .payment-btn { padding: 30px; border: 2px solid #dfe6e9; border-radius: 10px; text-align: center; cursor: pointer; transition: 0.3s; text-decoration: none; display: block; }
        .payment-btn:hover { transform: translateY(-5px); box-shadow: 0 5px 15px rgba(0,0,0,0.1); }
        .stripe-btn { border-color: #6c5ce7; }
        .stripe-btn:hover { background: #f0eeff; border-color: #5f4dd1; }
        .paypal-btn { border-color: #0070ba; }
        .paypal-btn:hover { background: #e6f3ff; border-color: #005a94; }
        .payment-icon { font-size: 50px; margin-bottom: 10px; }
        .payment-name { font-size: 1.2em; font-weight: 600; color: #2d3436; }
        .payment-desc { color: #636e72; font-size: 0.9em; margin-top: 5px; }
        
        @media (max-width: 600px) {
            .payment-methods { grid-template-columns: 1fr; }
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>💳 결제하기</h1>
            <p>안전하고 빠른 결제 시스템</p>
        </div>
        
        <div class="content">
            <div class="order-summary">
                <h3 style="margin-bottom: 15px; color: #2d3436;">📦 주문 내역</h3>
                
                <div class="order-item">
                    <span>상품명</span>
                    <strong><!--?= htmlspecialchars($orderInfo['product_name']) ?></strong>
                </div>
                
                <div class="order-item">
                    <span>설명</span>
                    <span><?= htmlspecialchars($orderInfo['description']) ?></span>
                </div>
                
                <div class="order-item">
                    <span>수량</span>
                    <span><?= $orderInfo['quantity'] ?></span>
                </div>
                
                <div class="order-item">
                    <span>단가</span>
                    <span>$<?= number_format($orderInfo['amount'], 2) ?></span>
                </div>
                
                <div class="total">
                    <span>총 결제 금액</span>
                    <span style="color: #6c5ce7;">$<?= number_format($orderInfo['amount'] * $orderInfo['quantity'], 2) ?></span>
                </div>
            </div>
            
            <h3 style="margin-bottom: 20px; color: #2d3436;">💰 결제 수단 선택</h3>
            
            <div class="payment-methods">
                <form action="stripe-checkout.php" method="POST" style="margin: 0;">
                    <input type="hidden" name="product_name" value="<?= htmlspecialchars($orderInfo['product_name']) ?>">
                    <input type="hidden" name="description" value="<?= htmlspecialchars($orderInfo['description']) ?>">
                    <input type="hidden" name="amount" value="<?= $orderInfo['amount'] ?>">
                    <input type="hidden" name="quantity" value="<?= $orderInfo['quantity'] ?>">
                    
                    <button type="submit" class="payment-btn stripe-btn" style="border: 2px solid #6c5ce7; background: white;">
                        <div class="payment-icon">💜</div>
                        <div class="payment-name">Stripe</div>
                        <div class="payment-desc">신용카드 / 체크카드</div>
                    </button>
                </form>
                
                <form action="paypal-checkout.php" method="POST" style="margin: 0;">
                    <input type="hidden" name="description" value="<?= htmlspecialchars($orderInfo['product_name'] . ' - ' . $orderInfo['description']) ?>">
                    <input type="hidden" name="amount" value="<?= $orderInfo['amount'] * $orderInfo['quantity'] ?>">
                    
                    <button type="submit" class="payment-btn paypal-btn" style="border: 2px solid #0070ba; background: white;">
                        <div class="payment-icon">💛</div>
                        <div class="payment-name">PayPal</div>
                        <div class="payment-desc">PayPal 계정 결제</div>
                    </button>
                </form>
            </div>
            
            <div style="margin-top: 30px; padding: 15px; background: #e8f5e9; border-radius: 8px; text-align: center;">
                <p style="color: #27ae60; margin: 0;">🔒 모든 결제는 SSL로 암호화되어 안전하게 처리됩니다</p>
            </div>
        </div>
    </div>
</body>
</html></code-->




🎨 UX 디자인 팁:

결제 페이지는 사용자가 가장 신경 쓰는 부분이야. 깔끔하고 신뢰감 있는 디자인이 중요해! 보안 배지나 SSL 인증 표시를 넣으면 전환율이 올라가더라고. 😊





🔔 Webhook으로 실시간 결제 알림 받기

결제가 완료되면 서버에서 자동으로 처리해야 할 일들이 많아. 주문 상태 업데이트, 이메일 발송, 재고 관리 등등... 이럴 때 Webhook을 사용하면 완전 편해! 🎯

Stripe Webhook 구현

public/webhooks/stripe.php:


<?php

require_once __DIR__ . '/../../vendor/autoload.php';

use Stripe\Stripe;
use Stripe\Webhook;

$config = require __DIR__ . '/../../config/stripe.php';
Stripe::setApiKey($config['secret_key']);

// Webhook Secret (Stripe 대시보드에서 확인)
$webhookSecret = 'whsec_your_webhook_secret_here';

// 요청 본문 가져오기
$payload = @file_get_contents('php://input');
$sigHeader = $_SERVER['HTTP_STRIPE_SIGNATURE'] ?? '';

try {
    // Webhook 서명 검증
    $event = Webhook::constructEvent($payload, $sigHeader, $webhookSecret);
    
    // 로그 기록
    file_put_contents(
        __DIR__ . '/../../logs/stripe-webhook.log',
        date('Y-m-d H:i:s') . ' - ' . $event->type . PHP_EOL,
        FILE_APPEND
    );
    
    // 이벤트 타입별 처리
    switch ($event->type) {
        case 'checkout.session.completed':
            $session = $event->data->object;
            
            // 결제 완료 처리
            handlePaymentSuccess($session);
            break;
            
        case 'payment_intent.succeeded':
            $paymentIntent = $event->data->object;
            
            // Payment Intent 성공 처리
            handlePaymentIntentSuccess($paymentIntent);
            break;
            
        case 'payment_intent.payment_failed':
            $paymentIntent = $event->data->object;
            
            // 결제 실패 처리
            handlePaymentFailure($paymentIntent);
            break;
            
        case 'charge.refunded':
            $charge = $event->data->object;
            
            // 환불 처리
            handleRefund($charge);
            break;
            
        default:
            // 처리하지 않는 이벤트
            break;
    }
    
    // 200 응답 반환 (중요!)
    http_response_code(200);
    echo json_encode(['status' => 'success']);
    
} catch (\UnexpectedValueException $e) {
    // 잘못된 페이로드
    http_response_code(400);
    echo json_encode(['error' => 'Invalid payload']);
    exit;
    
} catch (\Stripe\Exception\SignatureVerificationException $e) {
    // 서명 검증 실패
    http_response_code(400);
    echo json_encode(['error' => 'Invalid signature']);
    exit;
}

/**
 * 결제 성공 처리
 */
function handlePaymentSuccess($session)
{
    // 데이터베이스에 주문 정보 저장
    $orderId = $session->metadata->order_id ?? null;
    $amount = $session->amount_total / 100;
    $customerEmail = $session->customer_details->email ?? '';
    
    // TODO: 데이터베이스 업데이트
    // - 주문 상태를 '결제 완료'로 변경
    // - 결제 정보 저장
    // - 고객에게 확인 이메일 발송
    
    // 로그 기록
    file_put_contents(
        __DIR__ . '/../../logs/orders.log',
        sprintf(
            "[%s] Order %s completed - Amount: $%.2f - Email: %s\n",
            date('Y-m-d H:i:s'),
            $orderId,
            $amount,
            $customerEmail
        ),
        FILE_APPEND
    );
}

/**
 * Payment Intent 성공 처리
 */
function handlePaymentIntentSuccess($paymentIntent)
{
    // Payment Intent 방식의 결제 완료 처리
    $amount = $paymentIntent->amount / 100;
    
    // TODO: 필요한 비즈니스 로직 처리
}

/**
 * 결제 실패 처리
 */
function handlePaymentFailure($paymentIntent)
{
    // 결제 실패 알림
    $errorMessage = $paymentIntent->last_payment_error->message ?? 'Unknown error';
    
    // TODO: 고객에게 실패 알림 이메일 발송
    
    file_put_contents(
        __DIR__ . '/../../logs/payment-failures.log',
        sprintf(
            "[%s] Payment failed - Error: %s\n",
            date('Y-m-d H:i:s'),
            $errorMessage
        ),
        FILE_APPEND
    );
}

/**
 * 환불 처리
 */
function handleRefund($charge)
{
    $refundAmount = $charge->amount_refunded / 100;
    
    // TODO: 
    // - 주문 상태 업데이트
    // - 재고 복구
    // - 환불 완료 이메일 발송
    
    file_put_contents(
        __DIR__ . '/../../logs/refunds.log',
        sprintf(
            "[%s] Refund processed - Amount: $%.2f\n",
            date('Y-m-d H:i:s'),
            $refundAmount
        ),
        FILE_APPEND
    );
}


PayPal Webhook 구현

public/webhooks/paypal.php:


<?php

require_once __DIR__ . '/../../vendor/autoload.php';

use PayPal\Rest\ApiContext;
use PayPal\Auth\OAuthTokenCredential;

$config = require __DIR__ . '/../../config/paypal.php';

// PayPal API Context
$apiContext = new ApiContext(
    new OAuthTokenCredential(
        $config['client_id'],
        $config['client_secret']
    )
);
$apiContext->setConfig(['mode' => $config['mode']]);

// Webhook 데이터 받기
$payload = @file_get_contents('php://input');
$data = json_decode($payload, true);

// 로그 기록
file_put_contents(
    __DIR__ . '/../../logs/paypal-webhook.log',
    date('Y-m-d H:i:s') . ' - ' . ($data['event_type'] ?? 'unknown') . PHP_EOL,
    FILE_APPEND
);

// 이벤트 타입별 처리
if (isset($data['event_type'])) {
    switch ($data['event_type']) {
        case 'PAYMENT.SALE.COMPLETED':
            // 결제 완료
            handlePayPalPaymentCompleted($data);
            break;
            
        case 'PAYMENT.SALE.REFUNDED':
            // 환불 완료
            handlePayPalRefund($data);
            break;
            
        case 'PAYMENT.SALE.REVERSED':
            // 결제 취소
            handlePayPalReversal($data);
            break;
            
        default:
            // 기타 이벤트
            break;
    }
}

// 200 응답 반환
http_response_code(200);
echo json_encode(['status' => 'success']);

/**
 * PayPal 결제 완료 처리
 */
function handlePayPalPaymentCompleted($data)
{
    $resource = $data['resource'] ?? [];
    $amount = $resource['amount']['total'] ?? 0;
    $currency = $resource['amount']['currency'] ?? 'USD';
    $saleId = $resource['id'] ?? '';
    
    // TODO: 주문 처리 로직
    
    file_put_contents(
        __DIR__ . '/../../logs/orders.log',
        sprintf(
            "[%s] PayPal payment completed - Sale ID: %s - Amount: %s %s\n",
            date('Y-m-d H:i:s'),
            $saleId,
            $amount,
            $currency
        ),
        FILE_APPEND
    );
}

/**
 * PayPal 환불 처리
 */
function handlePayPalRefund($data)
{
    $resource = $data['resource'] ?? [];
    $refundAmount = $resource['amount']['total'] ?? 0;
    
    // TODO: 환불 처리 로직
    
    file_put_contents(
        __DIR__ . '/../../logs/refunds.log',
        sprintf(
            "[%s] PayPal refund processed - Amount: %s\n",
            date('Y-m-d H:i:s'),
            $refundAmount
        ),
        FILE_APPEND
    );
}

/**
 * PayPal 결제 취소 처리
 */
function handlePayPalReversal($data)
{
    // 결제 취소 처리
    file_put_contents(
        __DIR__ . '/../../logs/reversals.log',
        sprintf(
            "[%s] PayPal payment reversed\n",
            date('Y-m-d H:i:s')
        ),
        FILE_APPEND
    );
}



⚠️ Webhook 보안 주의사항:

1. 반드시 서명 검증을 해야 해! 누구나 Webhook URL에 요청을 보낼 수 있거든.

2. Webhook URL은 HTTPS여야 해.

3. IP 화이트리스트를 설정하면 더 안전해.

4. 중복 처리 방지를 위해 이벤트 ID를 저장하고 확인하자!


Webhook 테스트하기

로컬 환경에서 Webhook을 테스트하려면 ngrok 같은 터널링 도구를 사용해야 해:

# ngrok 설치 후
ngrok http 8000

# 생성된 HTTPS URL을 Stripe/PayPal 대시보드에 등록
# 예: https://abc123.ngrok.io/webhooks/stripe.php




💾 데이터베이스 설계하기

결제 정보를 제대로 관리하려면 데이터베이스 설계가 중요해! 간단하지만 확장 가능한 구조를 만들어보자. 📊

테이블 구조


-- 주문 테이블
CREATE TABLE orders (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT NOT NULL,
    order_number VARCHAR(50) UNIQUE NOT NULL,
    total_amount DECIMAL(10, 2) NOT NULL,
    currency VARCHAR(3) DEFAULT 'USD',
    status ENUM('pending', 'processing', 'completed', 'cancelled', 'refunded') DEFAULT 'pending',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    INDEX idx_user_id (user_id),
    INDEX idx_order_number (order_number),
    INDEX idx_status (status)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 결제 테이블
CREATE TABLE payments (
    id INT AUTO_INCREMENT PRIMARY KEY,
    order_id INT NOT NULL,
    payment_method ENUM('stripe', 'paypal') NOT NULL,
    payment_id VARCHAR(255) NOT NULL,
    transaction_id VARCHAR(255),
    amount DECIMAL(10, 2) NOT NULL,
    currency VARCHAR(3) DEFAULT 'USD',
    status ENUM('pending', 'completed', 'failed', 'refunded') DEFAULT 'pending',
    payer_email VARCHAR(255),
    payment_data JSON,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (order_id) REFERENCES orders(id) ON DELETE CASCADE,
    INDEX idx_order_id (order_id),
    INDEX idx_payment_id (payment_id),
    INDEX idx_status (status)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 환불 테이블
CREATE TABLE refunds (
    id INT AUTO_INCREMENT PRIMARY KEY,
    payment_id INT NOT NULL,
    refund_id VARCHAR(255) NOT NULL,
    amount DECIMAL(10, 2) NOT NULL,
    reason TEXT,
    status ENUM('pending', 'completed', 'failed') DEFAULT 'pending',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (payment_id) REFERENCES payments(id) ON DELETE CASCADE,
    INDEX idx_payment_id (payment_id),
    INDEX idx_refund_id (refund_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- Webhook 로그 테이블
CREATE TABLE webhook_logs (
    id INT AUTO_INCREMENT PRIMARY KEY,
    provider ENUM('stripe', 'paypal') NOT NULL,
    event_id VARCHAR(255) UNIQUE NOT NULL,
    event_type VARCHAR(100) NOT NULL,
    payload JSON NOT NULL,
    processed BOOLEAN DEFAULT FALSE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_event_id (event_id),
    INDEX idx_processed (processed)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;


데이터베이스 연결 클래스

src/Database/Connection.php:


<?php

namespace Database;

use PDO;
use PDOException;

class Connection
{
    private static $instance = null;
    private $pdo;
    
    private function __construct()
    {
        $host = $_ENV['DB_HOST'];
        $dbname = $_ENV['DB_NAME'];
        $user = $_ENV['DB_USER'];
        $pass = $_ENV['DB_PASS'];
        
        try {
            $this->pdo = new PDO(
                "mysql:host=$host;dbname=$dbname;charset=utf8mb4",
                $user,
                $pass,
                [
                    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
                    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
                    PDO::ATTR_EMULATE_PREPARES => false,
                ]
            );
        } catch (PDOException $e) {
            die("Database connection failed: " . $e->getMessage());
        }
    }
    
    public static function getInstance()
    {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
    
    public function getConnection()
    {
        return $this->pdo;
    }
    
    // Singleton 패턴 보호
    private function __clone() {}
    public function __wakeup() {}
}


트랜잭션 로거 클래스

src/Database/TransactionLogger.php:


<?php

namespace Database;

use PDO;

class TransactionLogger
{
    private $pdo;
    
    public function __construct()
    {
        $this->pdo = Connection::getInstance()->getConnection();
    }
    
    /**
     * 주문 생성
     */
    public function createOrder(array $data)
    {
        $sql = "INSERT INTO orders (user_id, order_number, total_amount, currency, status) 
                VALUES (:user_id, :order_number, :total_amount, :currency, :status)";
        
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute([
            'user_id' => $data['user_id'],
            'order_number' => $data['order_number'],
            'total_amount' => $data['total_amount'],
            'currency' => $data['currency'] ?? 'USD',
            'status' => $data['status'] ?? 'pending'
        ]);
        
        return $this->pdo->lastInsertId();
    }
    
    /**
     * 결제 정보 저장
     */
    public function logPayment(array $data)
    {
        $sql = "INSERT INTO payments 
                (order_id, payment_method, payment_id, transaction_id, amount, currency, status, payer_email, payment_data) 
                VALUES (:order_id, :payment_method, :payment_id, :transaction_id, :amount, :currency, :status, :payer_email, :payment_data)";
        
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute([
            'order_id' => $data['order_id'],
            'payment_method' => $data['payment_method'],
            'payment_id' => $data['payment_id'],
            'transaction_id' => $data['transaction_id'] ?? null,
            'amount' => $data['amount'],
            'currency' => $data['currency'] ?? 'USD',
            'status' => $data['status'] ?? 'pending',
            'payer_email' => $data['payer_email'] ?? null,
            'payment_data' => json_encode($data['payment_data'] ?? [])
        ]);
        
        return $this->pdo->lastInsertId();
    }
    
    /**
     * 주문 상태 업데이트
     */
    public function updateOrderStatus(int $orderId, string $status)
    {
        $sql = "UPDATE orders SET status = :status WHERE id = :id";
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute(['status' => $status, 'id' => $orderId]);
    }
    
    /**
     * 결제 상태 업데이트
     */
    public function updatePaymentStatus(string $paymentId, string $status)
    {
        $sql = "UPDATE payments SET status = :status WHERE payment_id = :payment_id";
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute(['status' => $status, 'payment_id' => $paymentId]);
    }
    
    /**
     * 환불 기록
     */
    public function logRefund(array $data)
    {
        $sql = "INSERT INTO refunds (payment_id, refund_id, amount, reason, status) 
                VALUES (:payment_id, :refund_id, :amount, :reason, :status)";
        
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute([
            'payment_id' => $data['payment_id'],
            'refund_id' => $data['refund_id'],
            'amount' => $data['amount'],
            'reason' => $data['reason'] ?? null,
            'status' => $data['status'] ?? 'pending'
        ]);
        
        return $this->pdo->lastInsertId();
    }
    
    /**
     * Webhook 이벤트 로그
     */
    public function logWebhookEvent(string $provider, string $eventId, string $eventType, array $payload)
    {
        $sql = "INSERT INTO webhook_logs (provider, event_id, event_type, payload) 
                VALUES (:provider, :event_id, :event_type, :payload)
                ON DUPLICATE KEY UPDATE event_id = event_id"; // 중복 방지
        
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute([
            'provider' => $provider,
            'event_id' => $eventId,
            'event_type' => $eventType,
            'payload' => json_encode($payload)
        ]);
    }
    
    /**
     * Webhook 이벤트 처리 완료 표시
     */
    public function markWebhookProcessed(string $eventId)
    {
        $sql = "UPDATE webhook_logs SET processed = TRUE WHERE event_id = :event_id";
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute(['event_id' => $eventId]);
    }
    
    /**
     * 주문 조회
     */
    public function getOrder(int $orderId)
    {
        $sql = "SELECT * FROM orders WHERE id = :id";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute(['id' => $orderId]);
        return $stmt->fetch();
    }
    
    /**
     * 결제 정보 조회
     */
    public function getPaymentByPaymentId(string $paymentId)
    {
        $sql = "SELECT * FROM payments WHERE payment_id = :payment_id";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute(['payment_id' => $paymentId]);
        return $stmt->fetch();
    }
}



💡 데이터베이스 팁:

1. 인덱스: 자주 조회하는 컬럼에는 인덱스를 걸어주자. 성능이 확 달라져!

2. JSON 컬럼: 유연한 데이터 저장에 유용해. 하지만 너무 남용하지는 말자.

3. 트랜잭션: 여러 테이블을 동시에 업데이트할 때는 트랜잭션을 사용해서 데이터 일관성을 보장하자!





🔒 보안 강화하기

결제 시스템에서 보안은 정말정말 중요해! 한 번의 보안 사고로 회사가 망할 수도 있거든. 😱 기본적인 보안 조치들을 알아보자!

1. CSRF 토큰 사용

src/Security/CSRF.php:


<?php

namespace Security;

class CSRF
{
    /**
     * CSRF 토큰 생성
     */
    public static function generateToken()
    {
        if (!isset($_SESSION['csrf_token'])) {
            $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
        }
        return $_SESSION['csrf_token'];
    }
    
    /**
     * CSRF 토큰 검증
     */
    public static function validateToken($token)
    {
        if (!isset($_SESSION['csrf_token'])) {
            return false;
        }
        return hash_equals($_SESSION['csrf_token'], $token);
    }
    
    /**
     * HTML 폼에 삽입할 hidden input 생성
     */
    public static function getTokenField()
    {
        $token = self::generateToken();
        return '<input type="hidden" name="csrf_token" value="' . htmlspecialchars($token) . '">';
    }
}


결제 폼에 CSRF 토큰 추가:


<form method="POST" action="process-payment.php">
    <?php echo \Security\CSRF::getTokenField(); ?>
    
    <!-- 나머지 폼 필드들 -->
</form>


2. 입력 데이터 검증 및 살균

src/Security/Validator.php:


<?php

namespace Security;

class Validator
{
    /**
     * 이메일 검증
     */
    public static function validateEmail($email)
    {
        return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
    }
    
    /**
     * 금액 검증
     */
    public static function validateAmount($amount)
    {
        if (!is_numeric($amount)) {
            return false;
        }
        
        $amount = floatval($amount);
        return $amount > 0 && $amount <= 999999.99;
    }
    
    /**
     * 문자열 살균
     */
    public static function sanitizeString($string)
    {
        return htmlspecialchars(strip_tags(trim($string)), ENT_QUOTES, 'UTF-8');
    }
    
    /**
     * 숫자만 추출
     */
    public static function sanitizeNumber($value)
    {
        return preg_replace('/[^0-9.]/', '', $value);
    }
    
    /**
     * 결제 데이터 검증
     */
    public static function validatePaymentData(array $data)
    {
        $errors = [];
        
        // 필수 필드 확인
        $required = ['amount', 'currency'];
        foreach ($required as $field) {
            if (!isset($data[$field]) || empty($data[$field])) {
                $errors[] = "필드 '$field'는 필수입니다.";
            }
        }
        
        // 금액 검증
        if (isset($data['amount']) && !self::validateAmount($data['amount'])) {
            $errors[] = "유효하지 않은 금액입니다.";
        }
        
        // 이메일 검증 (선택적)
        if (isset($data['email']) && !empty($data['email']) && !self::validateEmail($data['email'])) {
            $errors[] = "유효하지 않은 이메일 주소입니다.";
        }
        
        return [
            'valid' => empty($errors),
            'errors' => $errors
        ];
    }
}


3. Rate Limiting (요청 제한)

src/Security/RateLimiter.php:


<?php

namespace Security;

class RateLimiter
{
    private $redis;
    private $maxAttempts;
    private $decayMinutes;
    
    public function __construct($maxAttempts = 5, $decayMinutes = 1)
    {
        // Redis 연결 (또는 파일 기반 저장소)
        $this->maxAttempts = $maxAttempts;
        $this->decayMinutes = $decayMinutes;
    }
    
    /**
     * 요청 제한 확인
     */
    public function tooManyAttempts($key)
    {
        $attempts = $this->getAttempts($key);
        return $attempts >= $this->maxAttempts;
    }
    
    /**
     * 시도 횟수 증가
     */
    public function hit($key)
    {
        $cacheKey = $this->getCacheKey($key);
        $attempts = $this->getAttempts($key);
        
        if ($attempts === 0) {
            // 첫 시도
            $_SESSION[$cacheKey] = [
                'attempts' => 1,
                'expires_at' => time() + ($this->decayMinutes * 60)
            ];
        } else {
            $_SESSION[$cacheKey]['attempts']++;
        }
    }
    
    /**
     * 시도 횟수 조회
     */
    private function getAttempts($key)
    {
        $cacheKey = $this->getCacheKey($key);
        
        if (!isset($_SESSION[$cacheKey])) {
            return 0;
        }
        
        $data = $_SESSION[$cacheKey];
        
        // 만료 확인
        if (time() > $data['expires_at']) {
            unset($_SESSION[$cacheKey]);
            return 0;
        }
        
        return $data['attempts'];
    }
    
    /**
     * 캐시 키 생성
     */
    private function getCacheKey($key)
    {
        return 'rate_limit_' . md5($key);
    }
    
    /**
     * 남은 시간 (초)
     */
    public function availableIn($key)
    {
        $cacheKey = $this->getCacheKey($key);
        
        if (!isset($_SESSION[$cacheKey])) {
            return 0;
        }
        
        $expiresAt = $_SESSION[$cacheKey]['expires_at'];
        return max(0, $expiresAt - time());
    }
}


사용 예시:


<?php

use Security\RateLimiter;

$rateLimiter = new RateLimiter(5, 1); // 1분에 5번까지
$key = $_SERVER['REMOTE_ADDR']; // IP 주소 기반

if ($rateLimiter->tooManyAttempts($key)) {
    $seconds = $rateLimiter->availableIn($key);
    die("너무 많은 요청입니다. {$seconds}초 후에 다시 시도해주세요.");
}

$rateLimiter->hit($key);

// 결제 처리 계속...


4. SSL/TLS 강제

.htaccess 파일에 추가:


# HTTPS 강제 리다이렉트
RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

# 보안 헤더
Header always set X-Frame-Options "SAMEORIGIN"
Header always set X-Content-Type-Options "nosniff"
Header always set X-XSS-Protection "1; mode=block"
Header always set Referrer-Policy "strict-origin-when-cross-origin"
Header always set Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline' https://js.stripe.com; frame-src https://js.stripe.com https://www.paypal.com;"



⚠️ 절대 하지 말아야 할 것들:

1. 신용카드 정보를 직접 저장하지 마! (PCI DSS 위반)

2. API 키를 코드에 하드코딩하지 마!

3. 에러 메시지에 민감한 정보를 포함하지 마!

4. SQL 쿼리에 사용자 입력을 직접 넣지 마! (항상 Prepared Statement 사용)

5. 결제 금액을 클라이언트에서 받지 마! (서버에서 계산)





🧪 테스트하기

결제 시스템은 철저한 테스트가 필수야! 실제 돈이 오가는 부분이니까 더더욱 조심해야 해. 🎯

테스트 카드 번호





카드사
카드 번호
용도




Visa
4242 4242 4242 4242
성공 테스트


Visa (거절)
4000 0000 0000 0002
카드 거절 테스트


Visa (잔액 부족)
4000 0000 0000 9995
잔액 부족 테스트


Mastercard
5555 5555 5555 4444
성공 테스트


American Express
3782 822463 10005
성공 테스트





테스트 시 사용할 정보:

만료일: 미래의 아무 날짜 (예: 12/25)
CVC: 아무 3자리 숫자 (예: 123)
우편번호: 아무 5자리 숫자 (예: 12345)


PayPal Sandbox 계정

PayPal Developer 대시보드에서 테스트 계정을 만들 수 있어:


1
Sandbox 계정 생성
developer.paypal.com → Sandbox → Accounts에서 "Create Account" 클릭



2
계정 타입 선택
Personal (구매자)와 Business (판매자) 계정을 각각 만들어



3
테스트 결제
생성된 테스트 계정으로 로그인해서 결제 테스트를 진행해


자동화 테스트 작성

PHPUnit을 사용한 단위 테스트 예시:


<?php

use PHPUnit\Framework\TestCase;
use Payment\StripePayment;
use Payment\PayPalPayment;

class PaymentTest extends TestCase
{
    private $stripeConfig;
    private $paypalConfig;
    
    protected function setUp(): void
    {
        $this->stripeConfig = require __DIR__ . '/../config/stripe.php';
        $this->paypalConfig = require __DIR__ . '/../config/paypal.php';
    }
    
    /**
     * Stripe 결제 생성 테스트
     */
    public function testStripePaymentCreation()
    {
        $stripe = new StripePayment($this->stripeConfig);
        
        $result = $stripe->createPayment([
            'product_name' => 'Test Product',
            'description' => 'Test Description',
            'amount' => 10.00,
            'quantity' => 1,
            'success_url' => 'http://localhost/success',
            'cancel_url' => 'http://localhost/cancel'
        ]);
        
        $this->assertTrue($result['success']);
        $this->assertArrayHasKey('session_id', $result);
        $this->assertArrayHasKey('url', $result);
    }
    
    /**
     * PayPal 결제 생성 테스트
     */
    public function testPayPalPaymentCreation()
    {
        $paypal = new PayPalPayment($this->paypalConfig);
        
        $result = $paypal->createPayment([
            'amount' => 10.00,
            'description' => 'Test Payment'
        ]);
        
        $this->assertTrue($result['success']);
        $this->assertArrayHasKey('payment_id', $result);
        $this->assertArrayHasKey('approval_url', $result);
    }
    
    /**
     * 금액 검증 테스트
     */
    public function testAmountValidation()
    {
        $this->assertTrue(\Security\Validator::validateAmount(10.00));
        $this->assertTrue(\Security\Validator::validateAmount(0.01));
        $this->assertFalse(\Security\Validator::validateAmount(-10.00));
        $this->assertFalse(\Security\Validator::validateAmount(0));
        $this->assertFalse(\Security\Validator::validateAmount('invalid'));
    }
    
    /**
     * CSRF 토큰 테스트
     */
    public function testCSRFToken()
    {
        session_start();
        
        $token = \Security\CSRF::generateToken();
        $this->assertNotEmpty($token);
        
        $this->assertTrue(\Security\CSRF::validateToken($token));
        $this->assertFalse(\Security\CSRF::validateToken('invalid_token'));
    }
}


테스트 실행:

composer require --dev phpunit/phpunit
./vendor/bin/phpunit tests/PaymentTest.php




🚀 프로덕션 배포 체크리스트

드디어 실제 서비스에 배포할 준비가 됐어! 하지만 잠깐, 이것들은 꼭 확인하고 가자! ✅


1
환경 변수 전환
.env 파일에서 테스트 키를 실제 프로덕션 키로 변경:
# Stripe
STRIPE_PUBLISHABLE_KEY=pk_live_your_real_key
STRIPE_SECRET_KEY=sk_live_your_real_key

# PayPal
PAYPAL_MODE=live  # sandbox에서 live로 변경



2
SSL 인증서 확인
HTTPS가 제대로 작동하는지 확인. Let's Encrypt로 무료 SSL 인증서를 받을 수 있어!



3
Webhook URL 등록
Stripe와 PayPal 대시보드에서 프로덕션 Webhook URL을 등록:

Stripe: https://yourdomain.com/webhooks/stripe.php
PayPal: https://yourdomain.com/webhooks/paypal.php




4
에러 로깅 설정
프로덕션에서는 에러를 사용자에게 보여주지 말고 로그 파일에 기록:
// php.ini 또는 .htaccess
display_errors = Off
log_errors = On
error_log = /path/to/logs/php-errors.log



5
데이터베이스 백업
정기적인 자동 백업 설정. 결제 데이터는 절대 잃어버리면 안 돼!



6
모니터링 설정
결제 실패율, 응답 시간 등을 모니터링할 수 있는 시스템 구축



7
보안 헤더 확인
앞서 설정한 보안 헤더들이 제대로 적용되었는지 확인



8
테스트 결제 진행
실제 소액으로 테스트 결제를 진행해보고 환불까지 테스트



9
법적 문서 준비
이용약관, 개인정보처리방침, 환불 정책 등을 명확히 작성



10
고객 지원 준비
결제 관련 문의에 대응할 수 있는 시스템 구축





💡 실전 팁과 베스트 프랙티스

실제로 결제 시스템을 운영하면서 배운 노하우들을 공유할게! 🎓

1. 사용자 경험 최적화


🎨 결제 페이지 디자인:

- 불필요한 필드는 최소화 (이메일, 금액 정도만)

- 진행 상황을 명확히 표시 (1단계/3단계 등)

- 로딩 인디케이터 표시 (사용자가 기다리는 동안)

- 모바일 최적화는 필수! (모바일 결제가 50% 이상)


2. 에러 처리


🚨 친절한 에러 메시지:

- "결제에 실패했습니다" ❌

- "카드가 거절되었습니다. 다른 카드를 시도하거나 은행에 문의해주세요" ✅


사용자가 다음에 무엇을 해야 할지 명확히 알려주자!


3. 성능 최적화


⚡ 빠른 결제 경험:

- API 호출은 비동기로 처리

- 데이터베이스 쿼리 최적화 (인덱스 활용)

- 캐싱 활용 (Redis, Memcached)

- CDN 사용 (정적 파일 로딩 속도 향상)


4. 재시도 로직

네트워크 오류나 일시적인 문제로 결제가 실패할 수 있어. 재시도 로직을 구현하자:


<?php

function retryPayment(callable $paymentFunction, $maxAttempts = 3)
{
    $attempt = 0;
    $lastError = null;
    
    while ($attempt < $maxAttempts) {
        try {
            $result = $paymentFunction();
            
            if ($result['success']) {
                return $result;
            }
            
            $lastError = $result['error'] ?? 'Unknown error';
            
        } catch (Exception $e) {
            $lastError = $e->getMessage();
        }
        
        $attempt++;
        
        if ($attempt < $maxAttempts) {
            // 지수 백오프 (1초, 2초, 4초...)
            sleep(pow(2, $attempt - 1));
        }
    }
    
    return [
        'success' => false,
        'error' => "결제 실패 (시도 {$maxAttempts}회): " . $lastError
    ];
}

// 사용 예시
$result = retryPayment(function() use ($stripe, $paymentData) {
    return $stripe->createPayment($paymentData);
});


5. 이메일 알림

결제 완료, 실패, 환불 등의 상황에서 고객에게 이메일을 보내자:


<?php

function sendPaymentConfirmationEmail($orderData)
{
    $to = $orderData['customer_email'];
    $subject = '결제가 완료되었습니다 - 주문번호: ' . $orderData['order_number'];
    
    $message = "
    
    
        <style>
            body { font-family: Arial, sans-serif; line-height: 1.6; }
            .container { max-width: 600px; margin: 0 auto; padding: 20px; }
            .header { background: #6c5ce7; color: white; padding: 20px; text-align: center; }
            .content { padding: 20px; background: #f8f9fa; }
            .footer { text-align: center; padding: 20px; color: #636e72; }
        </style>
    
    
        <div class="container">
            <div class="header">
                <h1>결제 완료</h1>
            </div>
            <div class="content">
                <p>안녕하세요,</p>
                <p>주문이 성공적으로 완료되었습니다.</p>
                <p><strong>주문번호:</strong> {$orderData['order_number']}</p>
                <p><strong>결제금액:</strong> \${$orderData['amount']}</p>
                <p><strong>결제방법:</strong> {$orderData['payment_method']}</p>
                <p>감사합니다!</p>
            </div>
            <div class="footer">
                <p>문의사항이 있으시면 support@yourdomain.com으로 연락주세요.</p>
            </div>
        </div>
    
    
    ";
    
    $headers = "MIME-Version: 1.0" . "\r\n";
    $headers .= "Content-type:text/html;charset=UTF-8" . "\r\n";
    $headers .= "From: noreply@yourdomain.com" . "\r\n";
    
    mail($to, $subject, $message, $headers);
}


6. 분석 및 리포팅

결제 데이터를 분석해서 비즈니스 인사이트를 얻자:


<?php

class PaymentAnalytics
{
    private $pdo;
    
    public function __construct()
    {
        $this->pdo = \Database\Connection::getInstance()->getConnection();
    }
    
    /**
     * 일별 매출 조회
     */
    public function getDailySales($startDate, $endDate)
    {
        $sql = "SELECT 
                    DATE(created_at) as date,
                    COUNT(*) as transaction_count,
                    SUM(amount) as total_amount,
                    payment_method
                FROM payments
                WHERE status = 'completed'
                AND created_at BETWEEN :start_date AND :end_date
                GROUP BY DATE(created_at), payment_method
                ORDER BY date DESC";
        
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute([
            'start_date' => $startDate,
            'end_date' => $endDate
        ]);
        
        return $stmt->fetchAll();
    }
    
    /**
     * 결제 성공률 계산
     */
    public function getSuccessRate($period = '30 days')
    {
        $sql = "SELECT 
                    COUNT(*) as total,
                    SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as successful
                FROM payments
                WHERE created_at >= DATE_SUB(NOW(), INTERVAL $period)";
        
        $stmt = $this->pdo->query($sql);
        $result = $stmt->fetch();
        
        if ($result['total'] > 0) {
            return ($result['successful'] / $result['total']) * 100;
        }
        
        return 0;
    }
    
    /**
     * 인기 결제 수단
     */
    public function getPopularPaymentMethods()
    {
        $sql = "SELECT 
                    payment_method,
                    COUNT(*) as count,
                    SUM(amount) as total_amount
                FROM payments
                WHERE status = 'completed'
                AND created_at >= DATE_SUB(NOW(), INTERVAL 30 DAY)
                GROUP BY payment_method
                ORDER BY count DESC";
        
        return $this->pdo->query($sql)->fetchAll();
    }
}





🌟 추가 기능 구현하기

기본적인 결제 시스템을 넘어서 더 고급 기능들을 추가해보자! 🚀

1. 정기 결제 (구독)

Stripe Subscription을 사용한 정기 결제:


<?php

namespace Payment;

use Stripe\Stripe;
use Stripe\Customer;
use Stripe\Subscription;
use Stripe\Price;

class StripeSubscription
{
    private $secretKey;
    
    public function __construct($secretKey)
    {
        $this->secretKey = $secretKey;
        Stripe::setApiKey($secretKey);
    }
    
    /**
     * 구독 상품 생성
     */
    public function createSubscriptionPrice($productName, $amount, $interval = 'month')
    {
        $price = Price::create([
            'product_data' => [
                'name' => $productName,
            ],
            'unit_amount' => $amount * 100,
            'currency' => 'usd',
            'recurring' => [
                'interval' => $interval, // day, week, month, year
            ],
        ]);
        
        return $price->id;
    }
    
    /**
     * 고객 생성
     */
    public function createCustomer($email, $paymentMethodId)
    {
        $customer = Customer::create([
            'email' => $email,
            'payment_method' => $paymentMethodId,
            'invoice_settings' => [
                'default_payment_method' => $paymentMethodId,
            ],
        ]);
        
        return $customer->id;
    }
    
    /**
     * 구독 생성
     */
    public function createSubscription($customerId, $priceId)
    {
        $subscription = Subscription::create([
            'customer' => $customerId,
            'items' => [
                ['price' => $priceId],
            ],
            'expand' => ['latest_invoice.payment_intent'],
        ]);
        
        return [
            'subscription_id' => $subscription->id,
            'status' => $subscription->status,
            'current_period_end' => $subscription->current_period_end,
        ];
    }
    
    /**
     * 구독 취소
     */
    public function cancelSubscription($subscriptionId)
    {
        $subscription = Subscription::retrieve($subscriptionId);
        $subscription->cancel();
        
        return true;
    }
}


2. 쿠폰 및 할인 코드


<?php

class CouponManager
{
    private $pdo;
    
    public function __construct()
    {
        $this->pdo = \Database\Connection::getInstance()->getConnection();
    }
    
    /**
     * 쿠폰 검증
     */
    public function validateCoupon($code)
    {
        $sql = "SELECT * FROM coupons 
                WHERE code = :code 
                AND active = 1 
                AND (expires_at IS NULL OR expires_at > NOW())
                AND (usage_limit IS NULL OR usage_count < usage_limit)";
        
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute(['code' => $code]);
        $coupon = $stmt->fetch();
        
        if (!$coupon) {
            return [
                'valid' => false,
                'message' => '유효하지 않은 쿠폰 코드입니다.'
            ];
        }
        
        return [
            'valid' => true,
            'coupon' => $coupon
        ];
    }
    
    /**
     * 할인 금액 계산
     */
    public function calculateDiscount($amount, $coupon)
    {
        if ($coupon['type'] === 'percentage') {
            $discount = $amount * ($coupon['value'] / 100);
        } else {
            $discount = $coupon['value'];
        }
        
        // 최대 할인 금액 제한
        if (isset($coupon['max_discount']) && $discount > $coupon['max_discount']) {
            $discount = $coupon['max_discount'];
        }
        
        return [
            'original_amount' => $amount,
            'discount' => $discount,
            'final_amount' => max(0, $amount - $discount)
        ];
    }
    
    /**
     * 쿠폰 사용 기록
     */
    public function useCoupon($couponId, $userId)
    {
        // 사용 횟수 증가
        $sql = "UPDATE coupons SET usage_count = usage_count + 1 WHERE id = :id";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute(['id' => $couponId]);
        
        // 사용 기록 저장
        $sql = "INSERT INTO coupon_usage (coupon_id, user_id, used_at) VALUES (:coupon_id, :user_id, NOW())";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute([
            'coupon_id' => $couponId,
            'user_id' => $userId
        ]);
    }
}


3. 다중 통화 지원


<?php

class CurrencyConverter
{
    private $apiKey;
    private $baseCurrency = 'USD';
    
    public function __construct($apiKey)
    {
        $this->apiKey = $apiKey;
    }
    
    /**
     * 환율 조회 (캐싱 포함)
     */
    public function getExchangeRate($fromCurrency, $toCurrency)
    {
        $cacheKey = "exchange_rate_{$fromCurrency}_{$toCurrency}";
        
        // 캐시 확인 (1시간 유효)
        if (isset($_SESSION[$cacheKey]) && 
            $_SESSION[$cacheKey]['expires'] > time()) {
            return $_SESSION[$cacheKey]['rate'];
        }
        
        // API 호출 (예: exchangerate-api.com)
        $url = "https://api.exchangerate-api.com/v4/latest/{$fromCurrency}";
        $response = file_get_contents($url);
        $data = json_decode($response, true);
        
        $rate = $data['rates'][$toCurrency] ?? 1;
        
        // 캐시 저장
        $_SESSION[$cacheKey] = [
            'rate' => $rate,
            'expires' => time() + 3600 // 1시간
        ];
        
        return $rate;
    }
    
    /**
     * 금액 변환
     */
    public function convert($amount, $fromCurrency, $toCurrency)
    {
        if ($fromCurrency === $toCurrency) {
            return $amount;
        }
        
        $rate = $this->getExchangeRate($fromCurrency, $toCurrency);
        return round($amount * $rate, 2);
    }
    
    /**
     * 통화 기호 가져오기
     */
    public function getCurrencySymbol($currency)
    {
        $symbols = [
            'USD' => '$',
            'EUR' => '€',
            'GBP' => '£',
            'JPY' => '¥',
            'KRW' => '₩',
            'CNY' => '¥',
        ];
        
        return $symbols[$currency] ?? $currency;
    }
}





🎓 마무리하며

와! 여기까지 왔다니 정말 대단해! 🎉 우리가 함께 배운 내용을 정리해보자:


✨ 핵심 요약
✅ Stripe와 PayPal API 통합 방법
✅ 안전한 결제 시스템 구축
✅ Webhook을 통한 실시간 알림 처리
✅ 데이터베이스 설계 및 트랜잭션 관리
✅ 보안 강화 및 에러 처리
✅ 정기 결제, 쿠폰, 다중 통화 등 고급 기능


결제 시스템은 한 번 만들어놓으면 계속 발전시켜 나갈 수 있어. 사용자 피드백을 받아서 개선하고, 새로운 결제 수단을 추가하고, 더 나은 사용자 경험을 제공하는 거지! 💪

재능넷 같은 플랫폼에서도 이런 결제 시스템이 핵심이야. 재능을 사고파는 사람들이 안전하고 편리하게 거래할 수 있도록 말이야. 너도 이제 멋진 결제 시스템을 만들 수 있어!


🚀 다음 단계:

1. 실제 프로젝트에 적용해보기

2. 사용자 테스트 진행하기

3. 성능 모니터링 및 최적화

4. 새로운 결제 수단 추가 (Toss, 카카오페이 등)

5. 국제 결제 지원 확대


궁금한 점이 있거나 도움이 필요하면 언제든 Stripe와 PayPal의 공식 문서를 참고하자. 두 서비스 모두 정말 훌륭한 문서와 커뮤니티를 가지고 있어! 📚

자, 이제 나가서 멋진 결제 시스템을 만들어보자! 화이팅! 🎯✨