🎯 네임스페이스 고급 활용법

기본은 이제 알았으니, 좀 더 깊이 들어가볼까?
실전에서 유용한 고급 기법들을 알려줄게! 🚀

네임스페이스는 여러 단계로 중첩할 수 있어.
프로젝트 구조를 더 세밀하게 나눌 수 있지!

<?php
// App/Models/Database/MySQL/Connection.php
namespace App\Models\Database\MySQL;

class Connection
{
    public function connect()
    {
        return "MySQL 연결 성공!";
    }
}

// 사용할 때
use App\Models\Database\MySQL\Connection;
$conn = new Connection();

이렇게 하면 데이터베이스 관련 코드를 더 체계적으로 관리할 수 있어.
MySQL, PostgreSQL, MongoDB 등을 각각 다른 서브 네임스페이스로 분리하는 거지! 📊

네임스페이스를 사용하다 보면 PHP 내장 클래스를 쓸 때 주의해야 해.
왜냐하면 네임스페이스 안에서는 기본적으로 현재 네임스페이스에서 클래스를 찾기 때문이야!

<?php
namespace App\Models;

class User
{
    public function createDate()
    {
        // 잘못된 방법 - App\Models\DateTime을 찾으려고 함
        // $date = new DateTime();
        
        // 올바른 방법 1 - 전역 네임스페이스 명시
        $date = new \DateTime();
        
        // 올바른 방법 2 - use로 임포트
        // use DateTime;
        // $date = new DateTime();
        
        return $date;
    }
}

네임스페이스는 클래스뿐만 아니라 함수와 상수에도 적용할 수 있어!
많이 사용하진 않지만, 알아두면 유용한 기능이야.

<?php
namespace App\Helpers;

// 네임스페이스 함수
function formatDate($date)
{
    return date('Y-m-d', strtotime($date));
}

// 네임스페이스 상수
const APP_VERSION = '1.0.0';

// 사용할 때
use function App\Helpers\formatDate;
use const App\Helpers\APP_VERSION;

echo formatDate('2024-01-15');
echo APP_VERSION;

함수는 use function, 상수는 use const로 임포트해!
헬퍼 함수나 설정 상수를 관리할 때 깔끔하게 정리할 수 있어. 🧹

🤖 오토로딩의 마법

자, 이제 네임스페이스는 완벽하게 이해했지?
그런데 아직 한 가지 문제가 남아있어. 😅

네임스페이스를 아무리 잘 만들어도, 결국 각 파일을 require나 include로 불러와야 하잖아?
파일이 100개면 require 문도 100개... 상상만 해도 끔찍하지? 😱

오토로딩도 진화 과정을 거쳤어. 간단히 살펴보자!

<?php
function __autoload($className)
{
    include $className . '.php';
}

// User 클래스를 사용하면 자동으로 User.php를 로드
$user = new User();

<?php
spl_autoload_register(function ($className) {
    $file = str_replace('\\', '/', $className) . '.php';
    if (file_exists($file)) {
        require $file;
    }
});

// 여러 개의 오토로더를 등록할 수 있음!
spl_autoload_register(function ($className) {
    // 다른 로딩 로직
});

직접 오토로더를 만들어보면서 원리를 이해해보자!
생각보다 간단해. 😊

<?php
// autoload.php
spl_autoload_register(function ($className) {
    // 네임스페이스 구분자를 디렉토리 구분자로 변경
    // App\Models\User -> App/Models/User
    $file = str_replace('\\', DIRECTORY_SEPARATOR, $className);
    
    // .php 확장자 추가
    $file = __DIR__ . '/' . $file . '.php';
    
    // 파일이 존재하면 로드
    if (file_exists($file)) {
        require $file;
    }
});

// 이제 이 파일만 include하면 끝!
// index.php
require 'autoload.php';

use App\Models\User;
use App\Controllers\UserController;

$user = new User(); // 자동으로 App/Models/User.php 로드!
$controller = new UserController(); // 자동으로 App/Controllers/UserController.php 로드!

어때? 신기하지? 🪄
클래스 이름만 보고 파일 경로를 추측해서 자동으로 로드하는 거야!

하지만 이 방식에도 문제가 있어.
프로젝트마다 디렉토리 구조가 다르면? 오토로더도 매번 다르게 만들어야 해.
그래서 등장한 게 바로 PSR-4 표준이야! 🌟

📋 PSR-4: 오토로딩의 표준

PSR은 PHP Standards Recommendations의 약자야.
PHP-FIG(PHP Framework Interop Group)라는 단체에서 만든 PHP 코딩 표준이지.

그중에서 PSR-4는 오토로딩에 관한 표준이야! 📜

실제로 어떻게 구조를 잡는지 보자!
이게 PSR-4의 핵심이야. 🏗️

project/
├── src/
│   ├── Models/
│   │   ├── User.php
│   │   └── Post.php
│   ├── Controllers/
│   │   ├── UserController.php
│   │   └── PostController.php
│   └── Services/
│       └── EmailService.php
├── vendor/
├── composer.json
└── index.php

이 구조에서 각 파일의 네임스페이스는 이렇게 돼:

<?php
// src/Models/User.php
namespace App\Models;

class User
{
    // ...
}

// src/Controllers/UserController.php
namespace App\Controllers;

class UserController
{
    // ...
}

// src/Services/EmailService.php
namespace App\Services;

class EmailService
{
    // ...
}

보이지? 네임스페이스 구조 = 디렉토리 구조야!
App\Models\User 클래스는 src/Models/User.php에 있고,
App\Controllers\UserController 클래스는 src/Controllers/UserController.php에 있어.

이 규칙만 지키면 오토로더가 자동으로 파일을 찾을 수 있어! 🎯

PSR-4 표준을 따르는 오토로더를 직접 만들어보자!
Composer를 쓰지 않고도 이해할 수 있도록 순수 PHP로 작성할게.

<?php
// PSR4Autoloader.php
class PSR4Autoloader
{
    // 네임스페이스 프리픽스와 베이스 디렉토리 매핑
    protected $prefixes = [];
    
    // 네임스페이스 프리픽스 등록
    public function addNamespace($prefix, $baseDir)
    {
        // 네임스페이스 프리픽스 정규화
        $prefix = trim($prefix, '\\') . '\\';
        
        // 베이스 디렉토리 정규화
        $baseDir = rtrim($baseDir, DIRECTORY_SEPARATOR) . '/';
        
        // 배열에 추가
        if (!isset($this->prefixes[$prefix])) {
            $this->prefixes[$prefix] = [];
        }
        $this->prefixes[$prefix][] = $baseDir;
    }
    
    // 오토로더 등록
    public function register()
    {
        spl_autoload_register([$this, 'loadClass']);
    }
    
    // 클래스 로드
    public function loadClass($className)
    {
        // 현재 네임스페이스 프리픽스
        $prefix = $className;
        
        // 네임스페이스 프리픽스를 찾을 때까지 거슬러 올라감
        while (false !== $pos = strrpos($prefix, '\\')) {
            $prefix = substr($className, 0, $pos + 1);
            $relativeClass = substr($className, $pos + 1);
            
            // 매핑된 파일 로드 시도
            $mappedFile = $this->loadMappedFile($prefix, $relativeClass);
            if ($mappedFile) {
                return $mappedFile;
            }
            
            // 다음 프리픽스 시도
            $prefix = rtrim($prefix, '\\');
        }
        
        return false;
    }
    
    // 매핑된 파일 로드
    protected function loadMappedFile($prefix, $relativeClass)
    {
        // 프리픽스가 등록되어 있는지 확인
        if (!isset($this->prefixes[$prefix])) {
            return false;
        }
        
        // 각 베이스 디렉토리를 순회
        foreach ($this->prefixes[$prefix] as $baseDir) {
            // 상대 클래스 이름을 파일 경로로 변환
            $file = $baseDir
                  . str_replace('\\', '/', $relativeClass)
                  . '.php';
            
            // 파일이 존재하면 로드
            if ($this->requireFile($file)) {
                return $file;
            }
        }
        
        return false;
    }
    
    // 파일 require
    protected function requireFile($file)
    {
        if (file_exists($file)) {
            require $file;
            return true;
        }
        return false;
    }
}

// 사용 예시
$loader = new PSR4Autoloader();

// App 네임스페이스를 src 디렉토리에 매핑
$loader->addNamespace('App', __DIR__ . '/src');

// 오토로더 등록
$loader->register();

// 이제 자동으로 로드됨!
use App\Models\User;
use App\Controllers\UserController;

$user = new User();
$controller = new UserController();

와, 코드가 좀 길지? 😅
하지만 이게 PSR-4 오토로더의 핵심 로직이야!

동작 원리를 간단히 설명하면:
1. 클래스 이름에서 네임스페이스 프리픽스를 찾아
2. 등록된 베이스 디렉토리를 가져와서
3. 나머지 클래스 경로를 파일 경로로 변환하고
4. 해당 파일을 require 하는 거야!

실제로는 이렇게 복잡하게 만들 필요 없어.
왜냐하면 Composer가 이 모든 걸 자동으로 해주거든! 🎁

🎼 Composer와 PSR-4의 완벽한 조합

자, 이제 진짜 실전으로 들어가보자!
현대 PHP 개발에서는 거의 모든 프로젝트가 Composer를 사용해.
Composer는 PHP의 의존성 관리 도구인데, PSR-4 오토로딩을 완벽하게 지원해! 🎵

먼저 Composer를 설치해야 해.
공식 사이트(getcomposer.org)에서 다운로드할 수 있어!

curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer

설치가 끝나면 터미널에서 composer --version을 입력해봐.
버전 정보가 나오면 성공! 🎉

프로젝트 루트에 composer.json 파일을 만들어야 해.
이 파일이 프로젝트의 설정과 의존성을 관리하는 핵심 파일이야!

{
    "name": "mycompany/myproject",
    "description": "내 멋진 PHP 프로젝트",
    "type": "project",
    "require": {
        "php": ">=7.4"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

여기서 중요한 부분은 autoload 섹션이야!
"App\\" 네임스페이스를 "src/" 디렉토리에 매핑한다는 뜻이지.

즉, App\Models\User 클래스는 src/Models/User.php에 있어야 한다는 거야! 📍

composer.json 파일을 만들었으면, 이제 오토로더를 생성해야 해.
터미널에서 프로젝트 루트로 이동한 다음 이 명령어를 실행해:

composer install

또는 이미 composer를 사용 중이라면:

composer dump-autoload

그러면 vendor 디렉토리가 생기고, 그 안에 autoload.php 파일이 만들어져!
이 파일 하나만 include하면 모든 오토로딩이 자동으로 작동해. 🪄

이제 실전에서 어떻게 사용하는지 보자!
완전한 프로젝트 구조를 만들어볼게.

myproject/
├── src/
│   ├── Models/
│   │   ├── User.php
│   │   └── Post.php
│   ├── Controllers/
│   │   ├── UserController.php
│   │   └── PostController.php
│   ├── Services/
│   │   └── EmailService.php
│   └── Helpers/
│       └── StringHelper.php
├── vendor/
│   └── autoload.php (Composer가 자동 생성)
├── public/
│   └── index.php
└── composer.json

각 파일의 내용을 보자:

<?php
// src/Models/User.php
namespace App\Models;

class User
{
    private $name;
    private $email;
    
    public function __construct($name, $email)
    {
        $this->name = $name;
        $this->email = $email;
    }
    
    public function getName()
    {
        return $this->name;
    }
    
    public function getEmail()
    {
        return $this->email;
    }
}

<?php
// src/Services/EmailService.php
namespace App\Services;

class EmailService
{
    public function send($to, $subject, $message)
    {
        // 실제로는 메일 전송 로직이 들어가겠지만
        // 여기서는 간단히 출력만 할게
        echo "📧 메일 전송!\n";
        echo "받는 사람: {$to}\n";
        echo "제목: {$subject}\n";
        echo "내용: {$message}\n";
        return true;
    }
}

<?php
// src/Controllers/UserController.php
namespace App\Controllers;

use App\Models\User;
use App\Services\EmailService;

class UserController
{
    private $emailService;
    
    public function __construct()
    {
        $this->emailService = new EmailService();
    }
    
    public function register($name, $email)
    {
        // 사용자 생성
        $user = new User($name, $email);
        
        // 환영 메일 전송
        $this->emailService->send(
            $user->getEmail(),
            "회원가입을 환영합니다!",
            "{$user->getName()}님, 가입해주셔서 감사합니다!"
        );
        
        return $user;
    }
}

<?php
// public/index.php
require __DIR__ . '/../vendor/autoload.php';

use App\Controllers\UserController;

// 컨트롤러 생성
$controller = new UserController();

// 사용자 등록
$user = $controller->register('홍길동', 'hong@example.com');

echo "\n✅ 사용자 등록 완료!\n";
echo "이름: " . $user->getName() . "\n";
echo "이메일: " . $user->getEmail() . "\n";

보이지? 딱 한 줄만 추가하면 돼!
require __DIR__ . '/../vendor/autoload.php';

이 한 줄이 모든 마법을 일으켜! ✨
더 이상 require나 include를 쓸 필요가 없어.
use로 클래스를 선언하기만 하면 자동으로 로드돼!

🏗️ 실전 프로젝트 구조 설계

이론은 충분히 배웠으니, 이제 실전 프로젝트 구조를 설계해보자!
재능넷 같은 플랫폼에서 PHP 개발 재능을 공유할 때도 이런 구조를 사용하면 좋아. 😊

가장 많이 사용하는 MVC(Model-View-Controller) 패턴을 PSR-4로 구현해보자!

project/
├── src/
│   ├── Models/           # 데이터 모델
│   │   ├── User.php
│   │   ├── Post.php
│   │   └── Comment.php
│   ├── Controllers/      # 비즈니스 로직
│   │   ├── UserController.php
│   │   ├── PostController.php
│   │   └── CommentController.php
│   ├── Views/           # 화면 템플릿
│   │   ├── users/
│   │   ├── posts/
│   │   └── layouts/
│   ├── Services/        # 서비스 레이어
│   │   ├── AuthService.php
│   │   ├── EmailService.php
│   │   └── PaymentService.php
│   ├── Repositories/    # 데이터 접근 레이어
│   │   ├── UserRepository.php
│   │   └── PostRepository.php
│   ├── Middleware/      # 미들웨어
│   │   ├── AuthMiddleware.php
│   │   └── CorsMiddleware.php
│   ├── Helpers/         # 헬퍼 함수
│   │   ├── StringHelper.php
│   │   └── DateHelper.php
│   └── Config/          # 설정 파일
│       ├── Database.php
│       └── App.php
├── public/              # 공개 디렉토리
│   ├── index.php
│   ├── css/
│   └── js/
├── tests/               # 테스트 코드
│   ├── Unit/
│   └── Integration/
├── vendor/              # Composer 패키지
├── .env                 # 환경 변수
├── composer.json
└── README.md

이 구조의 composer.json은 이렇게 설정해:

{
    "name": "mycompany/awesome-project",
    "description": "PSR-4 기반의 멋진 PHP 프로젝트",
    "type": "project",
    "require": {
        "php": ">=7.4"
    },
    "require-dev": {
        "phpunit/phpunit": "^9.0"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "Tests\\": "tests/"
        }
    }
}

autoload-dev는 개발 환경에서만 사용하는 오토로딩 설정이야.
테스트 코드 같은 건 프로덕션에서 필요 없으니까 분리하는 거지! 🎯

각 레이어가 어떤 역할을 하는지 실제 코드로 보자!

<?php
namespace App\Models;

class User
{
    private $id;
    private $username;
    private $email;
    private $createdAt;
    
    public function __construct(array $data)
    {
        $this->id = $data['id'] ?? null;
        $this->username = $data['username'];
        $this->email = $data['email'];
        $this->createdAt = $data['created_at'] ?? date('Y-m-d H:i:s');
    }
    
    public function getId(): ?int
    {
        return $this->id;
    }
    
    public function getUsername(): string
    {
        return $this->username;
    }
    
    public function getEmail(): string
    {
        return $this->email;
    }
    
    public function toArray(): array
    {
        return [
            'id' => $this->id,
            'username' => $this->username,
            'email' => $this->email,
            'created_at' => $this->createdAt
        ];
    }
}

<?php
namespace App\Repositories;

use App\Models\User;
use PDO;

class UserRepository
{
    private $db;
    
    public function __construct(PDO $db)
    {
        $this->db = $db;
    }
    
    public function find(int $id): ?User
    {
        $stmt = $this->db->prepare('SELECT * FROM users WHERE id = ?');
        $stmt->execute([$id]);
        $data = $stmt->fetch(PDO::FETCH_ASSOC);
        
        return $data ? new User($data) : null;
    }
    
    public function findByEmail(string $email): ?User
    {
        $stmt = $this->db->prepare('SELECT * FROM users WHERE email = ?');
        $stmt->execute([$email]);
        $data = $stmt->fetch(PDO::FETCH_ASSOC);
        
        return $data ? new User($data) : null;
    }
    
    public function save(User $user): bool
    {
        $data = $user->toArray();
        
        if ($user->getId()) {
            // 업데이트
            $stmt = $this->db->prepare(
                'UPDATE users SET username = ?, email = ? WHERE id = ?'
            );
            return $stmt->execute([
                $data['username'],
                $data['email'],
                $data['id']
            ]);
        } else {
            // 생성
            $stmt = $this->db->prepare(
                'INSERT INTO users (username, email, created_at) VALUES (?, ?, ?)'
            );
            return $stmt->execute([
                $data['username'],
                $data['email'],
                $data['created_at']
            ]);
        }
    }
    
    public function delete(int $id): bool
    {
        $stmt = $this->db->prepare('DELETE FROM users WHERE id = ?');
        return $stmt->execute([$id]);
    }
}

<?php
namespace App\Services;

use App\Models\User;
use App\Repositories\UserRepository;

class UserService
{
    private $userRepository;
    private $emailService;
    
    public function __construct(
        UserRepository $userRepository,
        EmailService $emailService
    ) {
        $this->userRepository = $userRepository;
        $this->emailService = $emailService;
    }
    
    public function register(string $username, string $email, string $password): User
    {
        // 이메일 중복 체크
        if ($this->userRepository->findByEmail($email)) {
            throw new \Exception('이미 사용 중인 이메일입니다.');
        }
        
        // 사용자 생성
        $user = new User([
            'username' => $username,
            'email' => $email
        ]);
        
        // 저장
        $this->userRepository->save($user);
        
        // 환영 메일 발송
        $this->emailService->sendWelcomeEmail($user);
        
        return $user;
    }
    
    public function updateProfile(int $userId, array $data): User
    {
        $user = $this->userRepository->find($userId);
        
        if (!$user) {
            throw new \Exception('사용자를 찾을 수 없습니다.');
        }
        
        // 데이터 업데이트 로직
        // ...
        
        $this->userRepository->save($user);
        
        return $user;
    }
}

<?php
namespace App\Controllers;

use App\Services\UserService;

class UserController
{
    private $userService;
    
    public function __construct(UserService $userService)
    {
        $this->userService = $userService;
    }
    
    public function register()
    {
        try {
            // POST 데이터 받기
            $username = $_POST['username'] ?? '';
            $email = $_POST['email'] ?? '';
            $password = $_POST['password'] ?? '';
            
            // 유효성 검사
            if (empty($username) || empty($email) || empty($password)) {
                throw new \Exception('모든 필드를 입력해주세요.');
            }
            
            // 서비스 호출
            $user = $this->userService->register($username, $email, $password);
            
            // 성공 응답
            $this->jsonResponse([
                'success' => true,
                'message' => '회원가입이 완료되었습니다.',
                'data' => $user->toArray()
            ]);
            
        } catch (\Exception $e) {
            // 에러 응답
            $this->jsonResponse([
                'success' => false,
                'message' => $e->getMessage()
            ], 400);
        }
    }
    
    private function jsonResponse(array $data, int $statusCode = 200)
    {
        http_response_code($statusCode);
        header('Content-Type: application/json');
        echo json_encode($data, JSON_UNESCAPED_UNICODE);
        exit;
    }
}

보이지? 각 레이어가 명확한 역할을 가지고 있어! 🎯

• Models: 데이터 구조만 정의
• Repositories: 데이터베이스 접근만 담당
• Services: 비즈니스 로직 처리
• Controllers: HTTP 요청/응답 처리

이렇게 분리하면 코드가 깔끔해지고, 테스트하기도 쉬워져! 🧪

위 코드에서 눈치챘을 수도 있는데, 각 클래스가 필요한 의존성을 생성자로 받고 있지?
이게 바로 의존성 주입(DI) 패턴이야!

간단한 DI 컨테이너를 만들어보자:

<?php
namespace App\Core;

class Container
{
    private $bindings = [];
    private $instances = [];
    
    // 바인딩 등록
    public function bind(string $abstract, callable $concrete)
    {
        $this->bindings[$abstract] = $concrete;
    }
    
    // 싱글톤 등록
    public function singleton(string $abstract, callable $concrete)
    {
        $this->bind($abstract, function($container) use ($abstract, $concrete) {
            if (!isset($this->instances[$abstract])) {
                $this->instances[$abstract] = $concrete($container);
            }
            return $this->instances[$abstract];
        });
    }
    
    // 인스턴스 가져오기
    public function make(string $abstract)
    {
        if (isset($this->bindings[$abstract])) {
            return $this->bindings[$abstract]($this);
        }
        
        throw new \Exception("바인딩을 찾을 수 없습니다: {$abstract}");
    }
}

// 사용 예시
$container = new Container();

// PDO 바인딩
$container->singleton(PDO::class, function() {
    return new PDO('mysql:host=localhost;dbname=mydb', 'user', 'pass');
});

// Repository 바인딩
$container->bind(UserRepository::class, function($c) {
    return new UserRepository($c->make(PDO::class));
});

// Service 바인딩
$container->bind(UserService::class, function($c) {
    return new UserService(
        $c->make(UserRepository::class),
        $c->make(EmailService::class)
    );
});

// Controller 바인딩
$container->bind(UserController::class, function($c) {
    return new UserController($c->make(UserService::class));
});

// 사용
$controller = $container->make(UserController::class);

이렇게 하면 의존성 관리가 훨씬 쉬워져!
Laravel 같은 프레임워크도 이런 방식으로 동작해. 🚀

🔧 고급 PSR-4 활용 기법

기본은 이제 완벽하게 이해했지?
이제 좀 더 고급 기법들을 알아보자! 🎓

하나의 프로젝트에서 여러 네임스페이스를 사용할 수 있어.
예를 들어, 플러그인 시스템이나 모듈 시스템을 만들 때 유용해!

{
    "autoload": {
        "psr-4": {
            "App\\": "src/",
            "Plugins\\": "plugins/",
            "Themes\\": "themes/",
            "Admin\\": "admin/src/"
        }
    }
}

이렇게 하면:

project/
├── src/              → App\
├── plugins/          → Plugins\
├── themes/           → Themes\
└── admin/
    └── src/          → Admin\

각 디렉토리가 독립적인 네임스페이스를 가지게 돼!
플러그인 개발자는 Plugins\ 네임스페이스만 사용하면 되는 거지. 🔌

PSR-4를 따르지 않는 레거시 코드나 특수한 경우에는 클래스맵을 사용할 수 있어.

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        },
        "classmap": [
            "legacy/",
            "lib/OldClass.php"
        ]
    }
}

클래스맵은 지정된 디렉토리나 파일을 스캔해서 모든 클래스를 찾아내!
PSR-4보다 느리지만, 구조가 복잡한 레거시 코드를 통합할 때 유용해. 🗺️

클래스가 아닌 일반 PHP 파일(헬퍼 함수 등)을 자동으로 로드하고 싶다면?

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        },
        "files": [
            "src/helpers.php",
            "src/constants.php"
        ]
    }
}

<?php
// src/helpers.php
if (!function_exists('dd')) {
    function dd(...$vars)
    {
        foreach ($vars as $var) {
            var_dump($var);
        }
        die();
    }
}

if (!function_exists('env')) {
    function env($key, $default = null)
    {
        return $_ENV[$key] ?? $default;
    }
}

이렇게 하면 autoload.php를 로드할 때 이 파일들도 자동으로 로드돼!
Laravel의 헬퍼 함수들도 이런 방식으로 제공돼. 🛠️

프로덕션 환경에서는 오토로딩 성능을 최적화해야 해!

composer dump-autoload --optimize

composer dump-autoload --classmap-authoritative

composer dump-autoload --apcu

🐛 문제 해결과 디버깅

PSR-4를 사용하다 보면 가끔 문제가 생길 수 있어.
자주 발생하는 문제들과 해결 방법을 알아보자! 🔍

Fatal error: Uncaught Error: Class 'App\Models\User' not found

// ❌ 잘못된 예
// 파일: src/Model/User.php (Models가 아니라 Model!)
namespace App\Models;

// ✅ 올바른 예
// 파일: src/Models/User.php
namespace App\Models;

// ❌ 잘못된 예
// 파일: src/Models/user.php (소문자!)
class User { }

// ✅ 올바른 예
// 파일: src/Models/User.php (대문자!)
class User { }

// ❌ 잘못된 예
"autoload": {
    "psr-4": {
        "App": "src/"  // 백슬래시 없음!
    }
}

// ✅ 올바른 예
"autoload": {
    "psr-4": {
        "App\\": "src/"  // 백슬래시 두 개!
    }
}

composer dump-autoload

Windows는 파일 시스템이 대소문자를 구분하지 않지만,
Linux/Mac은 구분해! 이게 큰 문제가 될 수 있어. 😰

오토로딩 문제를 디버깅하는 유용한 방법들! 🔧

// vendor/composer/autoload_psr4.php 파일 확인
// 네임스페이스 매핑이 올바른지 체크

$vendorDir = dirname(dirname(__FILE__));
$baseDir = dirname($vendorDir);

return array(
    'App\\' => array($baseDir . '/src'),
);

<?php
// 특정 클래스의 파일 경로 확인
$reflection = new ReflectionClass('App\Models\User');
echo $reflection->getFileName();
// 출력: /path/to/project/src/Models/User.php

<?php
spl_autoload_register(function($class) {
    echo "오토로딩 시도: {$class}\n";
}, true, true); // prepend = true (먼저 실행)

// 어떤 클래스를 로드하려고 하는지 확인 가능

composer validate
composer diagnose

🎬 마무리하며

와! 정말 긴 여정이었지? 😅
여기까지 읽은 너는 이제 PHP 네임스페이스와 PSR-4 오토로딩의 전문가야! 🎓

이제 너는 현대적인 PHP 개발의 기초를 완벽하게 이해했어!
Laravel, Symfony 같은 프레임워크의 코드도 이해할 수 있을 거야.

재능넷에서 PHP 개발 재능을 공유하거나 배울 때도
이런 표준화된 구조를 사용하면 훨씬 전문적으로 보일 거야! 💼

기억해, 좋은 코드는 단순히 작동하는 코드가 아니라
읽기 쉽고, 유지보수하기 쉽고, 확장하기 쉬운 코드야! ✨

이 글이 도움이 됐다면, 직접 프로젝트를 만들어보면서 연습해봐.
처음엔 어색하겠지만, 금방 익숙해질 거야!

화이팅! 🚀 너는 할 수 있어!