1. Perl과 웹 스크래핑의 만남: 기본 개념 이해하기 🤝

Perl(Practical Extraction and Report Language)은 1987년에 래리 월(Larry Wall)이 개발한 고급 프로그래밍 언어야. 텍스트 처리에 특화된 언어로, 정규표현식 지원이 강력해서 웹 스크래핑에 딱 맞는 언어라고 할 수 있어. 웹 초창기부터 CGI 스크립트 작성에 많이 사용되었던 언어이기도 하지!

Perl이 웹 스크래핑에 적합한 이유

웹 스크래핑은 단순히 데이터를 긁어오는 것 이상의 의미가 있어. 데이터 기반 의사결정이 중요해진 요즘, 웹에 흩어져 있는 정보를 체계적으로 수집하고 분석하는 능력은 엄청난 경쟁력이 될 수 있지. 재능넷에서도 이런 기술을 가진 사람들의 재능이 높은 가치를 인정받고 있어. 😊

이제 Perl로 웹 스크래핑을 시작하기 위한 기본 개념은 이해했으니, 다음 섹션에서는 실제 환경 설정부터 시작해 볼게!

2. Perl 설치부터 첫 스크래핑 코드까지 🛠️

Perl 설치하기

먼저 Perl을 설치해야 웹 스크래핑을 시작할 수 있어. 운영체제별 설치 방법을 알아보자!

필수 모듈 설치하기

Perl로 웹 스크래핑을 하려면 몇 가지 핵심 모듈이 필요해. CPAN을 통해 쉽게 설치할 수 있어.

cpan LWP::UserAgent
cpan HTML::Parser
cpan HTML::TreeBuilder
cpan Mojo::DOM
cpan HTTP::Cookies
cpan JSON

이 모듈들은 웹 스크래핑의 기본 도구들이야. 웹 페이지를 가져오고, HTML을 파싱하고, 데이터를 추출하는 데 사용될 거야.

첫 번째 웹 스크래핑 코드 작성하기

이제 간단한 웹 스크래핑 코드를 작성해 볼게. 웹 페이지의 제목을 가져오는 아주 기본적인 예제야.

#!/usr/bin/perl
use strict;
use warnings;
use LWP::UserAgent;
use HTML::TreeBuilder;

# 웹 클라이언트 생성
my $ua = LWP::UserAgent->new;
$ua->agent('Mozilla/5.0'); # 브라우저처럼 보이게 설정

# 웹 페이지 요청
my $url = 'https://www.example.com';
my $response = $ua->get($url);

# 요청 성공 확인
if ($response->is_success) {
    # HTML 파싱
    my $tree = HTML::TreeBuilder->new;
    $tree->parse($response->decoded_content);
    
    # 페이지 제목 추출
    my $title = $tree->look_down('_tag', 'title');
    print "페이지 제목: ", $title->as_text, "\n";
    
    # 메모리 해제
    $tree->delete;
} else {
    print "오류 발생: ", $response->status_line, "\n";
}

이 코드를 실행하면 example.com 웹사이트의 제목이 출력될 거야. 간단하지? 이게 웹 스크래핑의 기본 원리야. 웹 페이지를 가져와서 → 파싱하고 → 원하는 데이터를 추출하는 과정이지.

이제 기본적인 웹 스크래핑 코드를 작성해 봤으니, 다음 섹션에서는 더 강력한 Perl 모듈들을 자세히 알아볼게. 이 모듈들을 마스터하면 더 복잡한 웹사이트에서도 원하는 데이터를 쉽게 추출할 수 있을 거야! 🚀

3. 필수 Perl 모듈 마스터하기: LWP, HTML::Parser, Mojo::DOM 🧰

웹 스크래핑을 위한 Perl 모듈들은 각각 특별한 역할을 해. 마치 도구 상자 안의 다양한 도구들처럼, 상황에 맞게 적절한 모듈을 선택해서 사용하는 게 중요해. 이번 섹션에서는 가장 많이 사용되는 핵심 모듈들을 자세히 살펴볼게.

LWP::UserAgent - 웹 브라우저 역할

LWP(Library for WWW in Perl)는 Perl에서 HTTP 요청을 처리하는 가장 기본적인 모듈이야. 특히 LWP::UserAgent는 웹 브라우저처럼 동작하면서 웹 페이지를 가져오는 역할을 해.

use LWP::UserAgent;

# 사용자 에이전트 객체 생성
my $ua = LWP::UserAgent->new;

# 타임아웃 설정 (초 단위)
$ua->timeout(10);

# 브라우저처럼 보이게 설정
$ua->agent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');

# 웹 페이지 요청
my $response = $ua->get('https://www.example.com');

# 응답 확인
if ($response->is_success) {
    my $content = $response->decoded_content;
    print "페이지 내용을 성공적으로 가져왔습니다!\n";
} else {
    print "오류 발생: ", $response->status_line, "\n";
}

use HTTP::Cookies;

# 쿠키 jar 생성
my $cookie_jar = HTTP::Cookies->new(
    file => "cookies.txt",
    autosave => 1
);

# 사용자 에이전트에 쿠키 jar 설정
$ua->cookie_jar($cookie_jar);

# POST 요청 보내기
my $response = $ua->post(
    'https://www.example.com/login',
    [
        username => 'myuser',
        password => 'mypass'
    ]
);

# 프록시 설정
$ua->proxy(['http', 'https'], 'http://proxy.example.com:8080');

LWP::UserAgent는 웹 스크래핑의 첫 단계인 웹 페이지 요청과 응답 처리를 담당해. 이 모듈을 잘 활용하면 로그인이 필요한 사이트나 복잡한 폼 제출도 처리할 수 있어!

HTML::Parser와 HTML::TreeBuilder - HTML 분석하기

웹 페이지를 가져왔다면, 이제 HTML을 분석해서 원하는 정보를 찾아야 해. HTML::Parser와 HTML::TreeBuilder는 HTML 문서를 파싱하고 탐색하는 데 사용되는 모듈이야.

use HTML::TreeBuilder;

# HTML 파서 객체 생성
my $tree = HTML::TreeBuilder->new;
$tree->parse($html_content);
$tree->eof; # 파싱 완료

# 모든 링크 찾기
my @links = $tree->look_down('_tag', 'a');
foreach my $link (@links) {
    print "링크: ", $link->attr('href'), "\n";
    print "텍스트: ", $link->as_text, "\n";
}

# 특정 클래스를 가진 요소 찾기
my @elements = $tree->look_down('class', 'product-item');
foreach my $element (@elements) {
    print "상품명: ", $element->look_down('_tag', 'h2')->as_text, "\n";
}

# 메모리 해제 (중요!)
$tree->delete;

Mojo::DOM - 현대적인 HTML/XML 파서

최근에는 Mojo::DOM이 HTML 파싱의 강력한 대안으로 떠오르고 있어. jQuery와 유사한 CSS 선택자를 사용해서 HTML 요소를 쉽게 찾을 수 있지.

use Mojo::DOM;

# HTML 문자열로부터 DOM 객체 생성
my $dom = Mojo::DOM->new($html_content);

# CSS 선택자로 요소 찾기
my $title = $dom->at('title')->text;
print "제목: $title\n";

# 여러 요소 찾기
my @links = $dom->find('a')->map('attr', 'href')->each;
print "링크: $_\n" for @links;

# 복잡한 선택자 사용
my @products = $dom->find('div.product-item');
for my $product (@products) {
    my $name = $product->at('h2')->text;
    my $price = $product->at('.price')->text;
    print "상품: $name, 가격: $price\n";
}

WWW::Mechanize - 브라우저 자동화

WWW::Mechanize는 LWP::UserAgent를 확장한 모듈로, 폼 작성, 링크 클릭 등 브라우저 동작을 자동화하는 데 특화되어 있어. 로그인이 필요한 사이트나 여러 페이지를 탐색해야 하는 경우에 유용해.

use WWW::Mechanize;

# Mechanize 객체 생성
my $mech = WWW::Mechanize->new();

# 웹 페이지 방문
$mech->get('https://www.example.com/login');

# 폼 작성 및 제출
$mech->form_id('login-form');
$mech->field('username', 'myuser');
$mech->field('password', 'mypass');
$mech->click_button(value => 'Login');

# 로그인 후 페이지 확인
if ($mech->success()) {
    print "로그인 성공!\n";
    
    # 링크 클릭
    $mech->follow_link(text => '내 계정');
    
    # 현재 페이지의 내용 저장
    my $content = $mech->content();
    
    # 이미지 다운로드
    $mech->get_image('profile-pic', 'profile.jpg');
}

WWW::Mechanize는 사람이 브라우저로 하는 작업을 자동화할 수 있어서, 복잡한 웹사이트 탐색이나 로그인 후 데이터 수집에 매우 유용해. 재능넷 같은 사이트에서 특정 카테고리의 서비스를 모니터링하거나 분석하는 데도 활용할 수 있지!

이제 Perl의 주요 웹 스크래핑 모듈들을 알아봤으니, 다음 섹션에서는 Perl의 강력한 무기인 정규표현식을 활용해 데이터를 추출하는 방법을 살펴볼게. 정규표현식은 Perl의 가장 큰 장점 중 하나니까 꼭 마스터해야 해! 🔍

4. 정규표현식으로 데이터 추출하기 🧩

Perl은 정규표현식(Regular Expression)의 왕국이라고 불릴 만큼 강력한 패턴 매칭 기능을 제공해. 웹 스크래핑에서 정규표현식은 HTML 구조에서 원하는 데이터를 정확하게 추출하는 데 엄청난 도움이 돼.

Perl 정규표현식 기초

정규표현식은 텍스트 패턴을 찾기 위한 특별한 문법이야. Perl에서는 =~ 연산자와 함께 사용해.

my $text = "Hello, World!";

# 패턴 매칭
if ($text =~ /World/) {
    print "패턴을 찾았습니다!\n";
}

# 대소문자 구분 없이 매칭
if ($text =~ /world/i) {
    print "대소문자 구분 없이 찾았습니다!\n";
}

# 패턴 추출
if ($text =~ /(Hello), (World)/) {
    print "첫 번째 그룹: $1, 두 번째 그룹: $2\n";
}

HTML에서 정규표현식으로 데이터 추출하기

HTML 파싱 모듈도 좋지만, 간단한 데이터 추출은 정규표현식으로 더 빠르게 할 수 있어. 특히 HTML 구조가 일관적일 때 유용해.

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $response = $ua->get('https://www.example.com');
my $html = $response->decoded_content;

# 제목 추출
if ($html =~ /<title>(.*?)<\/title>/is) {
    my $title = $1;
    print "페이지 제목: $title\n";
}

# 모든 링크 URL 추출
my @links;
while ($html =~ /<a\s+[^>]*href=["']([^"']+)["'][^>]*>/gi) {
    push @links, $1;
}
print "총 " . scalar(@links) . "개의 링크를 찾았습니다.\n";

# 이미지 URL 추출
my @images;
while ($html =~ /<img\s+[^>]*src=["']([^"']+)["'][^>]*>/gi) {
    push @images, $1;
}
print "총 " . scalar(@images) . "개의 이미지를 찾았습니다.\n";

실전 예제: 상품 정보 추출하기

이제 실제 쇼핑몰 페이지에서 상품 정보를 추출하는 예제를 살펴볼게. HTML 파싱과 정규표현식을 함께 사용하는 방법이야.

use strict;
use warnings;
use LWP::UserAgent;
use HTML::TreeBuilder;

my $ua = LWP::UserAgent->new;
$ua->agent('Mozilla/5.0');

my $url = 'https://example-shop.com/products';
my $response = $ua->get($url);

if ($response->is_success) {
    my $html = $response->decoded_content;
    my $tree = HTML::TreeBuilder->new;
    $tree->parse($html);
    
    # 상품 컨테이너 찾기
    my @product_divs = $tree->look_down('_tag', 'div', 'class', 'product-item');
    
    foreach my $product (@product_divs) {
        # 상품명 추출
        my $name_element = $product->look_down('_tag', 'h3', 'class', 'product-name');
        my $name = $name_element ? $name_element->as_text : "이름 없음";
        
        # 가격 추출 (정규표현식 사용)
        my $price_html = $product->look_down('_tag', 'span', 'class', 'price')->as_HTML;
        my $price = "가격 정보 없음";
        
        if ($price_html =~ /₩([\d,]+)/i) {
            $price = $1;
        }
        
        # 평점 추출 (정규표현식 사용)
        my $rating_element = $product->look_down('_tag', 'div', 'class', 'rating');
        my $rating = "평점 정보 없음";
        
        if ($rating_element) {
            my $rating_html = $rating_element->as_HTML;
            if ($rating_html =~ /(\d\.\d)\/5/i) {
                $rating = $1;
            }
        }
        
        print "상품명: $name\n";
        print "가격: $price\n";
        print "평점: $rating\n";
        print "------------------------\n";
    }
    
    $tree->delete;
} else {
    print "오류 발생: ", $response->status_line, "\n";
}

정규표현식 디버깅 및 최적화

정규표현식은 강력하지만 디버깅하기 어려울 수 있어. Perl에서는 정규표현식을 테스트하고 디버깅하는 몇 가지 방법을 제공해.

# 정규표현식 디버깅 모드 활성화
use re 'debug';

# 매칭 결과 출력
my $text = "The price is ₩50,000";
if ($text =~ /(₩[\d,]+)/) {
    print "매칭된 텍스트: $1\n";
} else {
    print "매칭 실패\n";
}

# 정규표현식 모듈로 더 자세한 정보 얻기
use Regexp::Debugger;

# 정규표현식 성능 최적화
# 자주 사용하는 패턴은 미리 컴파일
my $price_regex = qr/₩([\d,]+)/;
if ($text =~ $price_regex) {
    print "컴파일된 정규식으로 매칭: $1\n";
}

정규표현식은 Perl 웹 스크래핑의 강력한 무기야. HTML 파싱 모듈과 함께 사용하면 거의 모든 웹사이트에서 원하는 데이터를 추출할 수 있어. 다음 섹션에서는 더 복잡한 웹사이트에서 데이터를 스크래핑하는 전략을 알아볼게! 🕸️

5. 복잡한 웹사이트 스크래핑 전략 🧠

지금까지 기본적인 웹 스크래핑 방법을 배웠어. 하지만 현실 세계의 웹사이트는 훨씬 복잡해. 자바스크립트로 동적 콘텐츠를 생성하거나, 로그인이 필요하거나, 봇 차단 기술을 사용하는 사이트들이 많지. 이번 섹션에서는 이런 복잡한 상황을 다루는 전략을 알아볼게.

동적 콘텐츠 스크래핑하기

많은 현대 웹사이트들은 자바스크립트를 사용해 페이지가 로드된 후에 콘텐츠를 동적으로 생성해. 이런 사이트는 일반적인 HTTP 요청만으로는 모든 데이터를 가져올 수 없어.

use LWP::UserAgent;
use JSON;

my $ua = LWP::UserAgent->new;
$ua->default_header('Accept' => 'application/json');

# API 엔드포인트 직접 호출
my $api_url = 'https://example.com/api/products?category=electronics';
my $response = $ua->get($api_url);

if ($response->is_success) {
    my $json = decode_json($response->decoded_content);
    
    # JSON 데이터 처리
    foreach my $product (@{$json->{products}}) {
        print "상품명: $product->{name}\n";
        print "가격: $product->{price}\n";
        print "------------------------\n";
    }
}

use WWW::Mechanize::Chrome;

# 헤드리스 Chrome 브라우저 인스턴스 생성
my $mech = WWW::Mechanize::Chrome->new(
    headless => 1,
    incognito => 1
);

# 페이지 로드 및 자바스크립트 실행 대기
$mech->get('https://example.com/products');
$mech->wait_until(sub { $mech->eval_in_page('return document.readyState') eq 'complete' });

# 자바스크립트 실행 후 콘텐츠 가져오기
my $content = $mech->content;

# 자바스크립트로 특정 요소 선택하기
my @product_names = $mech->eval_in_page(q{
    return Array.from(document.querySelectorAll('.product-name')).map(el => el.textContent);
});

print "상품명: $_\n" for @product_names;

인증이 필요한 사이트 스크래핑하기

로그인이 필요한 사이트에서 데이터를 스크래핑하려면 인증 과정을 자동화해야 해.

use LWP::UserAgent;
use HTTP::Cookies;

# 쿠키 저장소 생성
my $cookie_jar = HTTP::Cookies->new(
    file => "cookies.txt",
    autosave => 1
);

my $ua = LWP::UserAgent->new;
$ua->cookie_jar($cookie_jar);

# 로그인 폼 제출
my $login_url = 'https://example.com/login';
my $response = $ua->post($login_url, [
    username => 'myusername',
    password => 'mypassword',
    remember_me => 1
]);

# 로그인 성공 확인
if ($response->is_redirect || $response->content =~ /welcome/i) {
    print "로그인 성공!\n";
    
    # 로그인 후 보호된 페이지 접근
    my $protected_url = 'https://example.com/account';
    my $account_page = $ua->get($protected_url);
    
    # 계정 정보 추출
    if ($account_page->is_success) {
        print "계정 페이지 접근 성공!\n";
        # 데이터 추출 코드...
    }
}

use WWW::Mechanize;

my $mech = WWW::Mechanize->new();

# 로그인 페이지 접근
$mech->get('https://example.com/login');

# 폼 작성 및 제출
$mech->submit_form(
    form_number => 1,
    fields => {
        username => 'myusername',
        password => 'mypassword'
    },
    button => 'login'
);

# 로그인 성공 확인
if ($mech->success() && $mech->content =~ /welcome/i) {
    print "로그인 성공!\n";
    
    # 마이페이지로 이동
    $mech->follow_link(text => 'My Account');
    
    # 데이터 추출
    if ($mech->success()) {
        print "마이페이지 접근 성공!\n";
        # 데이터 추출 코드...
    }
}

봇 차단 우회하기

많은 웹사이트는 스크래핑 봇을 차단하기 위한 다양한 기술을 사용해. 이를 우회하기 위한 전략을 알아보자.

my $ua = LWP::UserAgent->new;

# 실제 브라우저처럼 보이게 설정
$ua->agent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36');

use Time::HiRes qw(sleep);

foreach my $url (@urls) {
    my $response = $ua->get($url);
    # 데이터 처리...
    
    # 무작위 시간 딜레이 (1~3초)
    my $delay = 1 + rand(2);
    sleep($delay);
}

# 실제 브라우저처럼 헤더 설정
$ua->default_header('Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8');
$ua->default_header('Accept-Language' => 'en-US,en;q=0.5');
$ua->default_header('Referer' => 'https://www.google.com/');
$ua->default_header('DNT' => '1');
$ua->default_header('Connection' => 'keep-alive');
$ua->default_header('Upgrade-Insecure-Requests' => '1');

# 프록시 서버 설정
$ua->proxy(['http', 'https'], 'http://proxy.example.com:8080');

# 또는 여러 프록시를 번갈아 사용
my @proxies = (
    'http://proxy1.example.com:8080',
    'http://proxy2.example.com:8080',
    'http://proxy3.example.com:8080'
);

# 무작위 프록시 선택
my $random_proxy = $proxies[int(rand(@proxies))];
$ua->proxy(['http', 'https'], $random_proxy);

페이지네이션 처리하기

많은 웹사이트는 데이터를 여러 페이지로 나누어 제공해. 모든 데이터를 수집하려면 페이지네이션을 처리해야 해.

use LWP::UserAgent;
use HTML::TreeBuilder;
use Time::HiRes qw(sleep);

my $ua = LWP::UserAgent->new;
$ua->agent('Mozilla/5.0');

my $base_url = 'https://example.com/products?page=';
my $max_pages = 10; # 수집할 최대 페이지 수

for my $page (1..$max_pages) {
    my $url = $base_url . $page;
    print "페이지 $page 수집 중...\n";
    
    my $response = $ua->get($url);
    
    if ($response->is_success) {
        my $tree = HTML::TreeBuilder->new;
        $tree->parse($response->decoded_content);
        
        # 상품 정보 추출
        my @products = $tree->look_down('_tag', 'div', 'class', 'product');
        
        foreach my $product (@products) {
            # 상품 데이터 추출 코드...
            print "상품 정보 추출 완료\n";
        }
        
        $tree->delete;
        
        # 다음 페이지가 없으면 종료
        if ($response->decoded_content !~ /다음 페이지|Next Page|page=$page+1/i) {
            print "마지막 페이지에 도달했습니다.\n";
            last;
        }
        
        # 요청 간 딜레이
        sleep(1 + rand(2));
    } else {
        print "페이지 $page 요청 실패: ", $response->status_line, "\n";
    }
}

실전 예제: 소셜 미디어 데이터 수집

이제 실제 소셜 미디어 사이트에서 데이터를 수집하는 예제를 살펴볼게. 여러 전략을 조합해서 사용하는 방법이야.

use strict;
use warnings;
use WWW::Mechanize;
use HTML::TreeBuilder;
use JSON;
use Time::HiRes qw(sleep);

# 브라우저 에뮬레이션
my $mech = WWW::Mechanize->new(
    agent => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/91.0.4472.124',
    cookie_jar => {},
    autocheck => 0,
    timeout => 30
);

# 로그인
print "로그인 중...\n";
$mech->get('https://example-social.com/login');

$mech->submit_form(
    form_id => 'login-form',
    fields => {
        username => 'myusername',
        password => 'mypassword'
    }
);

# 로그인 성공 확인
if ($mech->content =~ /Welcome|Dashboard|Profile/i) {
    print "로그인 성공!\n";
} else {
    die "로그인 실패!\n";
}

# 특정 해시태그 검색
my $hashtag = 'perl';
print "해시태그 #$hashtag 검색 중...\n";
$mech->get("https://example-social.com/search?q=%23$hashtag");

# 포스트 수집
my @collected_posts;
my $max_posts = 100;
my $page = 1;

while (@collected_posts < $max_posts) {
    print "페이지 $page 수집 중...\n";
    
    # 동적 콘텐츠 로딩 대기
    sleep(2);
    
    # HTML 파싱
    my $tree = HTML::TreeBuilder->new;
    $tree->parse($mech->content);
    
    # 포스트 요소 찾기
    my @post_elements = $tree->look_down('_tag', 'div', 'class', 'post-container');
    
    if (@post_elements == 0) {
        print "더 이상 포스트가 없습니다.\n";
        last;
    }
    
    foreach my $post (@post_elements) {
        # 포스트 ID 추출
        my $post_id = $post->attr('data-post-id') || "unknown";
        
        # 작성자 정보 추출
        my $author = $post->look_down('_tag', 'a', 'class', 'author-name');
        my $author_name = $author ? $author->as_text : "unknown";
        my $author_link = $author ? $author->attr('href') : "";
        
        # 포스트 내용 추출
        my $content_element = $post->look_down('_tag', 'div', 'class', 'post-content');
        my $content = $content_element ? $content_element->as_text : "";
        
        # 좋아요 수 추출
        my $likes_element = $post->look_down('_tag', 'span', 'class', 'like-count');
        my $likes = $likes_element ? $likes_element->as_text : 0;
        
        # 해시태그 추출
        my @hashtags;
        my $hashtag_elements = $post->look_down('_tag', 'a', sub { $_[0]->attr('href') && $_[0]->attr('href') =~ /\/hashtag\// });
        foreach my $tag (@$hashtag_elements) {
            push @hashtags, $tag->as_text;
        }
        
        # 포스트 데이터 저장
        push @collected_posts, {
            id => $post_id,
            author => {
                name => $author_name,
                profile => $author_link
            },
            content => $content,
            likes => $likes,
            hashtags => \@hashtags,
            collected_at => scalar(localtime)
        };
        
        print "포스트 ID: $post_id 수집 완료\n";
        
        if (@collected_posts >= $max_posts) {
            last;
        }
    }
    
    $tree->delete;
    
    # 다음 페이지로 이동
    my $next_link = $mech->find_link(text_regex => qr/Next|다음/i);
    if ($next_link) {
        $mech->follow_link(link => $next_link);
        $page++;
        
        # 요청 간 딜레이
        sleep(2 + rand(3));
    } else {
        print "마지막 페이지에 도달했습니다.\n";
        last;
    }
}

# 결과 저장
my $json = encode_json(\@collected_posts);
open my $fh, '>', "hashtag_${hashtag}_posts.json" or die "파일을 열 수 없습니다: $!";
print $fh $json;
close $fh;

print "총 ", scalar(@collected_posts), "개의 포스트를 수집했습니다.\n";
print "데이터가 hashtag_${hashtag}_posts.json 파일에 저장되었습니다.\n";

복잡한 웹사이트에서 데이터를 스크래핑하는 것은 도전적인 작업이지만, 적절한 전략과 도구를 사용하면 거의 모든 웹사이트에서 원하는 데이터를 수집할 수 있어. 다음 섹션에서는 수집한 데이터를 저장하고 가공하는 방법을 알아볼게! 📊

6. 데이터 저장 및 가공하기 💾

웹에서 데이터를 성공적으로 스크래핑했다면, 이제 그 데이터를 유용하게 사용할 차례야. 데이터를 적절한 형식으로 저장하고 가공하는 것은 웹 스크래핑 프로세스의 중요한 부분이지. 이번 섹션에서는 Perl을 사용해 스크래핑한 데이터를 다양한 형식으로 저장하고 가공하는 방법을 알아볼게.

텍스트 파일로 데이터 저장하기

가장 간단한 방법은 데이터를 일반 텍스트 파일로 저장하는 거야. CSV(쉼표로 구분된 값) 형식은 스프레드시트 프로그램에서 쉽게 열 수 있어 인기가 많아.

use strict;
use warnings;
use Text::CSV;

# 스크래핑한 데이터 (예시)
my @products = (
    {
        name => "스마트폰 X2000",
        price => "599000",
        rating => "4.5",
        available => "Yes"
    },
    {
        name => "노트북 울트라",
        price => "1200000",
        rating => "4.8",
        available => "No"
    },
    # 더 많은 제품 데이터...
);

# CSV 파일 생성
my $csv = Text::CSV->new({ binary => 1, auto_diag => 1 });
open my $fh, ">:encoding(utf8)", "products.csv" or die "products.csv: $!";

# 헤더 작성
$csv->print($fh, ["제품명", "가격", "평점", "재고여부"]);
print $fh "\n";

# 데이터 작성
foreach my $product (@products) {
    $csv->print($fh, [
        $product->{name},
        $product->{price},
        $product->{rating},
        $product->{available}
    ]);
    print $fh "\n";
}

close $fh;
print "데이터가 products.csv 파일에 저장되었습니다.\n";

JSON 형식으로 데이터 저장하기

JSON은 웹 데이터 교환에 널리 사용되는 형식이야. 구조화된 데이터를 저장하기에 적합하고, 다른 프로그래밍 언어에서도 쉽게 사용할 수 있어.

use strict;
use warnings;
use JSON;

# 스크래핑한 데이터 (예시)
my $data = {
    source => "example.com",
    date => scalar(localtime),
    products => [
        {
            name => "스마트폰 X2000",
            price => 599000,
            specs => {
                display => "6.7인치 AMOLED",
                processor => "스냅드래곤 8 Gen 1",
                ram => "12GB"
            },
            reviews => [
                { user => "user1", rating => 5, comment => "최고의 제품!" },
                { user => "user2", rating => 4, comment => "배터리가 조금 아쉬워요" }
            ]
        },
        # 더 많은 제품 데이터...
    ]
};

# JSON으로 변환
my $json = encode_json($data);

# 파일에 저장
open my $fh, ">:encoding(utf8)", "products.json" or die "products.json: $!";
print $fh $json;
close $fh;

# 더 읽기 쉬운 형식으로 저장 (Pretty Print)
open my $fh_pretty, ">:encoding(utf8)", "products_pretty.json" or die "products_pretty.json: $!";
print $fh_pretty JSON->new->pretty->encode($data);
close $fh_pretty;

print "데이터가 JSON 파일로 저장되었습니다.\n";

데이터베이스에 데이터 저장하기

대량의 데이터를 저장하거나 복잡한 쿼리를 실행해야 한다면, 데이터베이스를 사용하는 것이 좋아. Perl의 DBI(Database Interface) 모듈을 사용하면 다양한 데이터베이스와 연동할 수 있어.

use strict;
use warnings;
use DBI;

# 스크래핑한 데이터 (예시)
my @products = (
    ["스마트폰 X2000", "전자제품", 599000, 4.5],
    ["노트북 울트라", "전자제품", 1200000, 4.8],
    ["블루투스 이어폰", "액세서리", 89000, 4.2],
    # 더 많은 제품 데이터...
);

# SQLite 데이터베이스 연결
my $dbh = DBI->connect("dbi:SQLite:dbname=products.db", "", "", {
    RaiseError => 1,
    AutoCommit => 0
});

# 테이블 생성
$dbh->do("CREATE TABLE IF NOT EXISTS products (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    category TEXT,
    price INTEGER,
    rating REAL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)");

# 데이터 삽입
my $sth = $dbh->prepare("INSERT INTO products (name, category, price, rating) VALUES (?, ?, ?, ?)");

foreach my $product (@products) {
    $sth->execute(@$product);
}

# 변경사항 커밋
$dbh->commit;

# 데이터 확인
my $count = $dbh->selectrow_array("SELECT COUNT(*) FROM products");
print "총 $count개의 제품이 데이터베이스에 저장되었습니다.\n";

# 연결 종료
$dbh->disconnect;

데이터 정제 및 변환

웹에서 수집한 데이터는 종종 정제가 필요해. 불필요한 공백 제거, 형식 변환, 중복 제거 등의 작업을 해야 할 수 있어.

use strict;
use warnings;

# 스크래핑한 원시 데이터 (예시)
my @raw_data = (
    { name => " 스마트폰 X2000 ", price => "₩599,000원", date => "2023-05-15" },
    { name => "노트북 울트라", price => "₩1,200,000", date => "05/20/2023" },
    { name => "블루투스 이어폰 ", price => "가격: 89,000원", date => "2023년 6월 1일" },
    # 더 많은 데이터...
);

# 데이터 정제 함수
sub clean_data {
    my ($item) = @_;
    
    # 이름 정제 (앞뒤 공백 제거)
    $item->{name} =~ s/^\s+|\s+$//g;
    
    # 가격 정제 (숫자만 추출)
    $item->{price} =~ s/[^\d]//g;
    
    # 날짜 형식 통일 (YYYY-MM-DD)
    if ($item->{date} =~ m{(\d{1,2})/(\d{1,2})/(\d{4})}) {
        # MM/DD/YYYY 형식
        $item->{date} = sprintf("%04d-%02d-%02d", $3, $1, $2);
    } elsif ($item->{date} =~ m{(\d{4})년\s*(\d{1,2})월\s*(\d{1,2})일}) {
        # YYYY년 MM월 DD일 형식
        $item->{date} = sprintf("%04d-%02d-%02d", $1, $2, $3);
    }
    # 이미 YYYY-MM-DD 형식이면 변경 없음
    
    return $item;
}

# 모든 데이터 정제
my @cleaned_data = map { clean_data($_) } @raw_data;

# 결과 출력
foreach my $item (@cleaned_data) {
    print "이름: $item->{name}\n";
    print "가격: $item->{price}\n";
    print "날짜: $item->{date}\n";
    print "------------------------\n";
}

데이터 분석 및 시각화

수집한 데이터를 분석하고 시각화하면 더 많은 인사이트를 얻을 수 있어. Perl에서도 기본적인 데이터 분석과 차트 생성이 가능해.

use strict;
use warnings;
use Statistics::Descriptive;
use GD::Graph::bars;

# 스크래핑한 데이터 (예시: 제품 카테고리별 평균 가격)
my %category_prices = (
    '스마트폰' => [599000, 499000, 899000, 799000, 399000],
    '노트북' => [1200000, 950000, 1500000, 2000000, 800000],
    '태블릿' => [450000, 350000, 700000, 600000],
    '이어폰' => [89000, 120000, 45000, 250000, 70000],
);

# 카테고리별 통계 계산
my %stats;
foreach my $category (keys %category_prices) {
    my $stat = Statistics::Descriptive::Full->new();
    $stat->add_data(@{$category_prices{$category}});
    
    $stats{$category} = {
        count => $stat->count(),
        mean => int($stat->mean()),
        min => $stat->min(),
        max => $stat->max(),
        standard_deviation => int($stat->standard_deviation())
    };
}

# 결과 출력
foreach my $category (sort keys %stats) {
    print "카테고리: $category\n";
    print "  제품 수: $stats{$category}{count}\n";
    print "  평균 가격: $stats{$category}{mean}원\n";
    print "  최저 가격: $stats{$category}{min}원\n";
    print "  최고 가격: $stats{$category}{max}원\n";
    print "  표준 편차: $stats{$category}{standard_deviation}원\n";
    print "------------------------\n";
}

# 차트 생성 (평균 가격 비교)
my @categories = sort keys %stats;
my @avg_prices = map { $stats{$_}{mean} / 10000 } @categories; # 만원 단위로 변환

my $graph = GD::Graph::bars->new(600, 400);
$graph->set(
    x_label => '제품 카테고리',
    y_label => '평균 가격 (만원)',
    title => '카테고리별 평균 가격 비교',
    bar_spacing => 8,
    shadow_depth => 4,
    transparent => 0,
) or die $graph->error;

my $gd = $graph->plot([\@categories, \@avg_prices]) or die $graph->error;

# 이미지 저장
open my $fh, '>', 'price_comparison.png' or die "Cannot open file: $!";
binmode $fh;
print $fh $gd->png;
close $fh;

print "차트가 price_comparison.png 파일로 저장되었습니다.\n";

데이터 내보내기 및 공유

수집하고 분석한 데이터를 다른 사람들과 공유하거나 다른 시스템에서 활용하려면 적절한 형식으로 내보내는 것이 중요해.

use strict;
use warnings;
use Excel::Writer::XLSX;

# 스크래핑한 데이터 (예시)
my @products = (
    ["스마트폰 X2000", "전자제품", 599000, 4.5, "2023-05-15"],
    ["노트북 울트라", "전자제품", 1200000, 4.8, "2023-05-20"],
    ["블루투스 이어폰", "액세서리", 89000, 4.2, "2023-06-01"],
    # 더 많은 제품 데이터...
);

# Excel 파일 생성
my $workbook = Excel::Writer::XLSX->new('products.xlsx');
my $worksheet = $workbook->add_worksheet('제품 목록');

# 헤더 스타일 설정
my $header_format = $workbook->add_format();
$header_format->set_bold();
$header_format->set_bg_color('#D9E1F2');
$header_format->set_align('center');

# 헤더 작성
my @headers = ("제품명", "카테고리", "가격(원)", "평점", "등록일");
for my $col (0..$#headers) {
    $worksheet->write(0, $col, $headers[$col], $header_format);
}

# 데이터 작성
for my $row (0..$#products) {
    for my $col (0..$#{$products[$row]}) {
        $worksheet->write($row + 1, $col, $products[$row][$col]);
    }
}

# 열 너비 자동 조정
$worksheet->autofilter(0, 0, $#products + 1, $#{$headers});
$worksheet->freeze_panes(1, 0); # 첫 번째 행 고정

$workbook->close();
print "데이터가 products.xlsx 파일로 저장되었습니다.\n";

데이터 저장과 가공은 웹 스크래핑의 가치를 완성하는 단계야. 잘 정리된 데이터는 의사결정, 트렌드 분석, 시장 조사 등 다양한 목적으로 활용될 수 있어. 다음 섹션에서는 웹 스크래핑을 자동화하고 주기적으로 실행하는 방법을 알아볼게! 🤖

7. 자동화와 스케줄링: 주기적 데이터 수집 ⏰

웹 스크래핑의 진정한 힘은 자동화에서 나와. 한 번 작성한 스크래핑 스크립트를 주기적으로 실행하면 시간에 따른 데이터 변화를 추적할 수 있어. 이번 섹션에서는 Perl 스크래핑 스크립트를 자동화하고 스케줄링하는 방법을 알아볼게.

스크래핑 스크립트 모듈화하기

자동화하기 전에 스크립트를 모듈화하고 재사용 가능하게 만드는 것이 중요해. 명령줄 인자를 처리하고 로깅 기능을 추가해 보자.

#!/usr/bin/perl
use strict;
use warnings;
use LWP::UserAgent;
use HTML::TreeBuilder;
use JSON;
use Getopt::Long;
use Log::Log4perl qw(:easy);
use File::Basename;
use File::Path qw(make_path);

# 로깅 설정
Log::Log4perl->easy_init({
    level => $INFO,
    file => ">>scraper.log",
    layout => "%d{yyyy-MM-dd HH:mm:ss} [%p] %m%n"
});

# 명령줄 옵션 처리
my $url = '';
my $output_dir = 'data';
my $output_format = 'json';
my $category = '';

GetOptions(
    "url=s" => \$url,
    "output-dir=s" => \$output_dir,
    "format=s" => \$output_format,
    "category=s" => \$category
) or die("옵션 오류\n");

# URL 필수 체크
if (!$url) {
    die "URL은 필수입니다. --url 옵션을 사용하세요.\n";
}

# 출력 디렉토리 생성
make_path($output_dir) unless -d $output_dir;

# 메인 함수
sub main {
    INFO("스크래핑 시작: $url");
    
    # 웹 페이지 요청
    my $ua = LWP::UserAgent->new;
    $ua->agent('Mozilla/5.0');
    $ua->timeout(30);
    
    my $response = $ua->get($url);
    
    if (!$response->is_success) {
        ERROR("페이지 요청 실패: " . $response->status_line);
        return;
    }
    
    INFO("페이지 요청 성공");
    
    # HTML 파싱
    my $tree = HTML::TreeBuilder->new;
    $tree->parse($response->decoded_content);
    
    # 데이터 추출 (예: 제품 정보)
    my @items;
    my @product_elements = $tree->look_down('_tag', 'div', 'class', 'product-item');
    
    foreach my $product (@product_elements) {
        my $name = $product->look_down('_tag', 'h2')->as_text;
        my $price_element = $product->look_down('_tag', 'span', 'class', 'price');
        my $price = $price_element ? $price_element->as_text : "N/A";
        
        # 가격에서 숫자만 추출
        $price =~ s/[^\d]//g if $price ne "N/A";
        
        push @items, {
            name => $name,
            price => $price,
            category => $category,
            url => $url,
            timestamp => scalar(localtime)
        };
    }
    
    $tree->delete;
    
    my $count = scalar(@items);
    INFO("총 $count개 항목 추출 완료");
    
    # 결과 저장
    my $timestamp = time();
    my $filename = $output_dir . "/" . ($category ? "${category}_" : "") . "products_${timestamp}";
    
    if ($output_format eq 'json') {
        $filename .= '.json';
        open my $fh, ">:encoding(utf8)", $filename or die "파일 열기 실패: $!";
        print $fh encode_json(\@items);
        close $fh;
    } elsif ($output_format eq 'csv') {
        $filename .= '.csv';
        open my $fh, ">:encoding(utf8)", $filename or die "파일 열기 실패: $!";
        print $fh "이름,가격,카테고리,URL,타임스탬프\n";
        foreach my $item (@items) {
            print $fh join(",", 
                $item->{name}, 
                $item->{price}, 
                $item->{category}, 
                $item->{url}, 
                $item->{timestamp}
            ) . "\n";
        }
        close $fh;
    } else {
        ERROR("지원하지 않는 출력 형식: $output_format");
        return;
    }
    
    INFO("데이터 저장 완료: $filename");
}

# 스크립트 실행
main();

이 스크립트는 명령줄에서 다음과 같이 실행할 수 있어:

perl scraper.pl --url="https://example.com/products" --category="electronics" --format="json" --output-dir="data"

cron을 사용한 스케줄링 (Linux/macOS)

Linux나 macOS에서는 cron을 사용해 스크립트를 주기적으로 실행할 수 있어.

# crontab -e 명령으로 cron 작업 편집기 열기

# 매일 오전 9시에 실행
0 9 * * * /usr/bin/perl /path/to/scraper.pl --url="https://example.com/products" --category="electronics" --format="json" --output-dir="/path/to/data"

# 매주 월요일 오후 3시에 실행
0 15 * * 1 /usr/bin/perl /path/to/scraper.pl --url="https://example.com/products" --category="electronics" --format="json" --output-dir="/path/to/data"

# 매시간 실행
0 * * * * /usr/bin/perl /path/to/scraper.pl --url="https://example.com/products" --category="electronics" --format="json" --output-dir="/path/to/data"

작업 스케줄러 사용하기 (Windows)

Windows에서는 작업 스케줄러를 사용해 스크립트를 주기적으로 실행할 수 있어.

@echo off
cd /d C:\path\to\script\directory
perl scraper.pl --url="https://example.com/products" --category="electronics" --format="json" --output-dir="C:\path\to\data"
echo 스크래핑 완료: %date% %time% >> scraper_log.txt

여러 사이트 스크래핑 자동화

여러 웹사이트에서 데이터를 수집해야 한다면, 설정 파일을 사용해 스크래핑 대상을 관리하는 것이 좋아.

{
  "sites": [
    {
      "name": "전자제품 스토어",
      "url": "https://electronics-store.example.com/products",
      "category": "electronics",
      "selector": {
        "item": "div.product-item",
        "name": "h2.product-name",
        "price": "span.price"
      },
      "schedule": "daily"
    },
    {
      "name": "도서 사이트",
      "url": "https://book-store.example.com/new-releases",
      "category": "books",
      "selector": {
        "item": "div.book-item",
        "name": "h3.book-title",
        "price": "div.book-price",
        "author": "span.author"
      },
      "schedule": "weekly"
    },
    {
      "name": "패션 쇼핑몰",
      "url": "https://fashion-store.example.com/sale",
      "category": "fashion",
      "selector": {
        "item": "div.product-box",
        "name": "h4.item-name",
        "price": "p.item-price",
        "discount": "span.discount-rate"
      },
      "schedule": "daily"
    }
  ]
}

#!/usr/bin/perl
use strict;
use warnings;
use LWP::UserAgent;
use HTML::TreeBuilder;
use JSON;
use Log::Log4perl qw(:easy);
use File::Path qw(make_path);
use Getopt::Long;

# 로깅 설정
Log::Log4perl->easy_init({
    level => $INFO,
    file => ">>multi_scraper.log",
    layout => "%d{yyyy-MM-dd HH:mm:ss} [%p] %m%n"
});

# 명령줄 옵션
my $config_file = 'sites.json';
my $output_dir = 'data';
my $site_filter = '';

GetOptions(
    "config=s" => \$config_file,
    "output-dir=s" => \$output_dir,
    "site=s" => \$site_filter
) or die("옵션 오류\n");

# 설정 파일 읽기
open my $fh, "<:encoding(utf8)", $config_file or die "설정 파일을 열 수 없습니다: $!";
my $config_json = do { local $/; <$fh> };
close $fh;

my $config = decode_json($config_json);

# 출력 디렉토리 생성
make_path($output_dir) unless -d $output_dir;

# 사이트별 스크래핑 함수
sub scrape_site {
    my ($site) = @_;
    
    INFO("사이트 스크래핑 시작: $site->{name}");
    
    # 웹 페이지 요청
    my $ua = LWP::UserAgent->new;
    $ua->agent('Mozilla/5.0');
    $ua->timeout(30);
    
    my $response = $ua->get($site->{url});
    
    if (!$response->is_success) {
        ERROR("페이지 요청 실패: " . $response->status_line);
        return;
    }
    
    # HTML 파싱
    my $tree = HTML::TreeBuilder->new;
    $tree->parse($response->decoded_content);
    
    # 데이터 추출
    my @items;
    my @item_elements = $tree->look_down('_tag', 'div', 'class', $site->{selector}{item});
    
    foreach my $item_element (@item_elements) {
        my $item = {
            site => $site->{name},
            category => $site->{category},
            url => $site->{url},
            timestamp => scalar(localtime)
        };
        
        # 이름 추출
        my ($tag, $class) = split(/\./, $site->{selector}{name});
        my $name_element = $item_element->look_down('_tag', $tag, 'class', $class);
        $item->{name} = $name_element ? $name_element->as_text : "N/A";
        
        # 가격 추출
        ($tag, $class) = split(/\./, $site->{selector}{price});
        my $price_element = $item_element->look_down('_tag', $tag, 'class', $class);
        $item->{price} = $price_element ? $price_element->as_text : "N/A";
        
        # 가격에서 숫자만 추출
        $item->{price} =~ s/[^\d]//g if $item->{price} ne "N/A";
        
        # 추가 필드 추출 (있는 경우)
        foreach my $field (keys %{$site->{selector}}) {
            next if $field eq 'item' || $field eq 'name' || $field eq 'price';
            
            ($tag, $class) = split(/\./, $site->{selector}{$field});
            my $element = $item_element->look_down('_tag', $tag, 'class', $class);
            $item->{$field} = $element ? $element->as_text : "N/A";
        }
        
        push @items, $item;
    }
    
    $tree->delete;
    
    my $count = scalar(@items);
    INFO("사이트 $site->{name}에서 총 $count개 항목 추출 완료");
    
    # 결과 저장
    my $timestamp = time();
    my $filename = $output_dir . "/" . $site->{category} . "_" . $timestamp . ".json";
    
    open my $out_fh, ">:encoding(utf8)", $filename or die "파일 열기 실패: $!";
    print $out_fh encode_json(\@items);
    close $out_fh;
    
    INFO("데이터 저장 완료: $filename");
    return $count;
}

# 메인 함수
sub main {
    my $total_sites = 0;
    my $total_items = 0;
    
    foreach my $site (@{$config->{sites}}) {
        # 사이트 필터 적용 (지정된 경우)
        if ($site_filter && $site->{name} !~ /$site_filter/i && $site->{category} !~ /$site_filter/i) {
            next;
        }
        
        $total_sites++;
        my $items = scrape_site($site);
        $total_items += $items if defined $items;
        
        # 사이트 간 딜레이
        sleep(3) if $total_sites < scalar(@{$config->{sites}});
    }
    
    INFO("스크래핑 완료: 총 $total_sites 사이트에서 $total_items 항목 수집");
}

# 스크립트 실행
main();

오류 처리 및 알림 설정

자동화된 스크래핑 시스템에서는 오류 처리와 알림 기능이 중요해. 문제가 발생했을 때 즉시 알 수 있도록 설정해 보자.

use Email::Simple;
use Email::Sender::Simple qw(sendmail);
use Email::Sender::Transport::SMTP;
use Try::Tiny;

# 이메일 알림 함수
sub send_alert {
    my ($subject, $message) = @_;
    
    my $email = Email::Simple->create(
        header => [
            To      => 'your-email@example.com',
            From    => 'scraper-alert@example.com',
            Subject => $subject,
        ],
        body => $message,
    );
    
    my $transport = Email::Sender::Transport::SMTP->new({
        host => 'smtp.example.com',
        port => 587,
        ssl => 1,
        sasl_username => 'your-username',
        sasl_password => 'your-password',
    });
    
    try {
        sendmail($email, { transport => $transport });
        INFO("알림 이메일 전송 성공");
    } catch {
        ERROR("알림 이메일 전송 실패: $_");
    };
}

# 스크래핑 함수에 오류 처리 추가
sub scrape_site {
    my ($site) = @_;
    
    INFO("사이트 스크래핑 시작: $site->{name}");
    
    # 웹 페이지 요청
    my $ua = LWP::UserAgent->new;
    $ua->agent('Mozilla/5.0');
    $ua->timeout(30);
    
    my $response = $ua->get($site->{url});
    
    if (!$response->is_success) {
        my $error_msg = "페이지 요청 실패: " . $response->status_line;
        ERROR($error_msg);
        
        # 심각한 오류일 경우 알림 전송
        if ($response->code >= 500) {
            send_alert(
                "스크래핑 오류: $site->{name}",
                "사이트 $site->{name} ($site->{url}) 스크래핑 중 서버 오류가 발생했습니다.\n\n" .
                "오류 코드: " . $response->code . "\n" .
                "오류 메시지: " . $response->status_line . "\n\n" .
                "시간: " . scalar(localtime)
            );
        }
        
        return;
    }
    
    # 나머지 스크래핑 코드...
}

자동화는 웹 스크래핑의 진정한 가치를 실현하는 단계야. 한 번 설정해 놓으면 지속적으로 데이터를 수집하고 분석할 수 있어. 다음 섹션에서는 스크래핑 중 발생할 수 있는 다양한 오류를 처리하고 디버깅하는 방법을 더 자세히 알아볼게! 🛠️

8. 에러 처리와 디버깅 기법 🔧

웹 스크래핑은 외부 시스템에 의존하기 때문에 다양한 오류가 발생할 수 있어. 네트워크 문제, 웹사이트 구조 변경, 차단 등 예상치 못한 상황에 대비하는 것이 중요해. 이번 섹션에서는 Perl 웹 스크래핑 스크립트의 오류 처리와 디버깅 기법을 알아볼게.

일반적인 웹 스크래핑 오류 유형

Try::Tiny를 사용한 예외 처리

Perl에서는 Try::Tiny 모듈을 사용해 예외를 깔끔하게 처리할 수 있어.

use strict;
use warnings;
use Try::Tiny;
use LWP::UserAgent;
use HTML::TreeBuilder;
use Log::Log4perl qw(:easy);

# 로깅 설정
Log::Log4perl->easy_init($INFO);

# 웹 페이지 요청 함수
sub fetch_page {
    my ($url) = @_;
    
    my $ua = LWP::UserAgent->new;
    $ua->timeout(30);
    $ua->agent('Mozilla/5.0');
    
    try {
        my $response = $ua->get($url);
        
        if ($response->is_success) {
            return $response->decoded_content;
        } elsif ($response->code == 404) {
            die "페이지를 찾을 수 없습니다 (404)";
        } elsif ($response->code == 403) {
            die "접근이 거부되었습니다 (403). 봇 차단 가능성이 있습니다.";
        } elsif ($response->code == 429) {
            die "너무 많은 요청을 보냈습니다 (429). 잠시 후 다시 시도하세요.";
        } else {
            die "HTTP 오류: " . $response->status_line;
        }
    } catch {
        ERROR("페이지 요청 실패: $_");
        return undef;
    };
}

# HTML 파싱 함수
sub parse_html {
    my ($html) = @_;
    
    return undef unless $html;
    
    try {
        my $tree = HTML::TreeBuilder->new;
        $tree->parse($html);
        $tree->eof;
        
        return $tree;
    } catch {
        ERROR("HTML 파싱 실패: $_");
        return undef;
    };
}

# 데이터 추출 함수
sub extract_data {
    my ($tree, $selector) = @_;
    
    return [] unless $tree;
    
    try {
        my @elements = $tree->look_down(%$selector);
        
        if (@elements == 0) {
            WARN("선택자와 일치하는 요소를 찾을 수 없습니다: " . join(", ", %$selector));
            return [];
        }
        
        my @data;
        foreach my $element (@elements) {
            push @data, $element->as_text;
        }
        
        $tree->delete; # 메모리 해제
        
        return \@data;
    } catch {
        ERROR("데이터 추출 실패: $_");
        $tree->delete if $tree; # 오류 발생해도 메모리 해제
        return [];
    };
}

# 메인 스크래핑 함수
sub scrape {
    my ($url, $selector) = @_;
    
    INFO("스크래핑 시작: $url");
    
    my $html = fetch_page($url);
    if (!$html) {
        ERROR("페이지를 가져올 수 없어 스크래핑을 중단합니다.");
        return [];
    }
    
    my $tree = parse_html($html);
    if (!$tree) {
        ERROR("HTML을 파싱할 수 없어 스크래핑을 중단합니다.");
        return [];
    }
    
    my $data = extract_data($tree, $selector);
    
    INFO("스크래핑 완료: " . scalar(@$data) . "개 항목 추출");
    
    return $data;
}

# 사용 예
my $url = "https://example.com/products";
my $selector = { '_tag' => 'div', 'class' => 'product-name' };

my $product_names = scrape($url, $selector);

print "추출된 제품명:\n";
print "- $_\n" for @$product_names;

재시도 로직 구현하기

네트워크 오류나 일시적인 서버 문제는 재시도를 통해 해결할 수 있어.

use Time::HiRes qw(sleep);

# 재시도 로직이 포함된 페이지 요청 함수
sub fetch_page_with_retry {
    my ($url, $max_retries, $initial_delay) = @_;
    $max_retries ||= 3;
    $initial_delay ||= 2;
    
    my $retry_count = 0;
    my $delay = $initial_delay;
    
    while ($retry_count < $max_retries) {
        try {
            my $ua = LWP::UserAgent->new;
            $ua->timeout(30);
            $ua->agent('Mozilla/5.0');
            
            my $response = $ua->get($url);
            
            if ($response->is_success) {
                return $response->decoded_content;
            } elsif ($response->code == 429) {
                # 요청 제한에 걸린 경우 더 오래 대기
                my $retry_after = $response->header('Retry-After') || $delay * 2;
                WARN("요청 제한에 걸렸습니다. ${retry_after}초 후 재시도합니다.");
                sleep($retry_after);
                $retry_count++;
                $delay *= 2; # 지수 백오프
            } elsif ($response->code >= 500) {
                # 서버 오류는 재시도
                WARN("서버 오류 발생: " . $response->status_line . ". ${delay}초 후 재시도합니다.");
                sleep($delay);
                $retry_count++;
                $delay *= 2; # 지수 백오프
            } else {
                # 4xx 등 다른 오류는 재시도하지 않음
                die "HTTP 오류: " . $response->status_line;
            }
        } catch {
            if ($_ =~ /timeout|connection refused|name resolution/i) {
                # 네트워크 오류는 재시도
                WARN("네트워크 오류 발생: $_. ${delay}초 후 재시도합니다.");
                sleep($delay);
                $retry_count++;
                $delay *= 2; # 지수 백오프
            } else {
                # 다른 예외는 그대로 전파
                ERROR("오류 발생: $_");
                die $_;
            }
        };
    }
    
    # 최대 재시도 횟수 초과
    ERROR("최대 재시도 횟수($max_retries)를 초과했습니다.");
    return undef;
}

디버깅 기법

웹 스크래핑 스크립트를 디버깅하는 몇 가지 효과적인 방법을 알아보자.

# 로깅 레벨 설정
Log::Log4perl->easy_init({
    level => $DEBUG,  # 더 상세한 로그
    file => ">>scraper_debug.log",
    layout => "%d{yyyy-MM-dd HH:mm:ss} [%p] %F{1}:%L %M - %m%n"
});

# 다양한 지점에 로그 추가
DEBUG("URL 요청 시작: $url");
DEBUG("응답 헤더: " . $response->headers->as_string);
DEBUG("HTML 길이: " . length($html) . " 바이트");
DEBUG("선택자: " . join(", ", %$selector));

# 디버깅을 위해 HTML 응답 저장
sub save_html_for_debug {
    my ($html, $url) = @_;
    
    # URL에서 파일명 생성
    my $filename = $url;
    $filename =~ s/https?:\/\///;  # 프로토콜 제거
    $filename =~ s/[\/\?\&=:]/_/g; # 특수문자를 언더스코어로 변경
    $filename = "debug_${filename}.html";
    
    open my $fh, ">:encoding(utf8)", $filename or do {
        WARN("디버그 HTML을 저장할 수 없습니다: $!");
        return;
    };
    
    print $fh $html;
    close $fh;
    
    INFO("디버그용 HTML 저장됨: $filename");
}

# HTML에서 선택자 테스트
sub test_selector {
    my ($html, $selector) = @_;
    
    my $tree = HTML::TreeBuilder->new;
    $tree->parse($html);
    $tree->eof;
    
    my @elements = $tree->look_down(%$selector);
    my $count = scalar(@elements);
    
    INFO("선택자 테스트 결과: $count개 요소 발견");
    
    if ($count > 0) {
        my $i = 0;
        foreach my $element (@elements) {
            $i++;
            DEBUG("요소 $i: " . $element->as_HTML);
            DEBUG("텍스트: " . $element->as_text);
        }
    }
    
    $tree->delete;
    
    return $count;
}

use Devel::REPL;

# 특정 지점에서 대화형 쉘 시작
sub start_debug_shell {
    my ($variables) = @_;
    
    print "대화형 디버깅 쉘 시작...\n";
    print "사용 가능한 변수들: " . join(", ", keys %$variables) . "\n";
    
    my $repl = Devel::REPL->new;
    $repl->load_plugin($_) for qw(History LexEnv);
    
    # 변수들을 REPL 환경에 주입
    $repl->eval('use strict; use warnings;');
    foreach my $name (keys %$variables) {
        my $value = $variables->{$name};
        $repl->eval("my \$$name = \$variables->{'$name'};");
    }
    
    $repl->run;
}

# 사용 예
my $html = fetch_page($url);
my $tree = parse_html($html);

if (!$tree || !$tree->look_down(%$selector)) {
    WARN("선택자 매칭 실패. 디버깅 쉘 시작...");
    start_debug_shell({
        html => $html,
        tree => $tree,
        selector => $selector,
        url => $url
    });
}

HTML 구조 변경 감지하기

웹사이트 구조가 변경되면 스크래핑 스크립트가 작동하지 않을 수 있어. 이를 감지하고 대응하는 방법을 알아보자.

# HTML 구조 변경 감지 함수
sub detect_structure_change {
    my ($html, $expected_patterns) = @_;
    
    foreach my $pattern (@$expected_patterns) {
        unless ($html =~ /$pattern/) {
            WARN("예상 패턴을 찾을 수 없음: $pattern");
            return 1; # 변경 감지됨
        }
    }
    
    return 0; # 변경 없음
}

# 사용 예
my $html = fetch_page($url);

# 예상되는 HTML 패턴들
my @expected_patterns = (
    '<div class="product-list"',
    '<span class="price"',
    '<h2 class="product-name"'
);

if (detect_structure_change($html, \@expected_patterns)) {
    ERROR("웹사이트 구조가 변경되었을 수 있습니다. 스크래핑 스크립트를 확인하세요.");
    save_html_for_debug($html, $url);
    # 알림 전송 등 추가 조치
} else {
    INFO("웹사이트 구조 확인 완료. 스크래핑 계속 진행합니다.");
    # 정상 스크래핑 진행
}

성능 최적화

대량의 데이터를 스크래핑할 때는 성능 최적화도 중요해.

use Parallel::ForkManager;

# 병렬 처리로 여러 URL 스크래핑
sub scrape_urls_parallel {
    my ($urls, $max_processes) = @_;
    $max_processes ||= 5;
    
    my $pm = Parallel::ForkManager->new($max_processes);
    my %results;
    
    # 결과 수집 설정
    $pm->run_on_finish(sub {
        my ($pid, $exit_code, $ident, $exit_signal, $core_dump, $data) = @_;
        $results{$data->{url}} = $data->{items} if $data && $data->{items};
    });
    
    foreach my $url (@$urls) {
        $pm->start and next;
        
        # 자식 프로세스에서 스크래핑 수행
        my $items = scrape_url($url);
        
        # 결과 반환
        $pm->finish(0, { url => $url, items => $items });
    }
    
    $pm->wait_all_children;
    
    return \%results;
}

# 대용량 HTML 처리 시 메모리 사용량 최적화
sub process_large_html {
    my ($html_file) = @_;
    
    # 파일을 한 번에 메모리에 로드하지 않고 스트리밍 방식으로 처리
    open my $fh, "<:encoding(utf8)", $html_file or die "파일을 열 수 없습니다: $!";
    
    my $parser = HTML::Parser->new(
        api_version => 3,
        start_h => [\&handle_start, "tagname, attr"],
        text_h => [\&handle_text, "text"],
        end_h => [\&handle_end, "tagname"]
    );
    
    # 청크 단위로 파일 읽기
    my $buffer;
    while (read($fh, $buffer, 4096)) {
        $parser->parse($buffer);
    }
    $parser->eof;
    
    close $fh;
}

# 태그 처리 핸들러 (예시)
my $in_product = 0;
my $current_product = {};
my @products;

sub handle_start {
    my ($tagname, $attr) = @_;
    
    if ($tagname eq 'div' && $attr->{class} && $attr->{class} =~ /product-item/) {
        $in_product = 1;
        $current_product = {};
    } elsif ($in_product && $tagname eq 'h2' && $attr->{class} && $attr->{class} =~ /product-name/) {
        $in_product_name = 1;
    }
    # 기타 태그 처리...
}

sub handle_text {
    my ($text) = @_;
    
    if ($in_product_name) {
        $current_product->{name} = $text;
    }
    # 기타 텍스트 처리...
}

sub handle_end {
    my ($tagname) = @_;
    
    if ($tagname eq 'div' && $in_product) {
        $in_product = 0;
        push @products, { %$current_product };
    } elsif ($tagname eq 'h2' && $in_product_name) {
        $in_product_name = 0;
    }
    # 기타 종료 태그 처리...
}

use Digest::MD5 qw(md5_hex);
use Storable qw(store retrieve);

# URL 응답 캐싱
sub fetch_with_cache {
    my ($url, $cache_dir, $cache_ttl) = @_;
    $cache_dir ||= 'cache';
    $cache_ttl ||= 3600; # 1시간
    
    # 캐시 디렉토리 생성
    mkdir $cache_dir unless -d $cache_dir;
    
    # URL에서 캐시 키 생성
    my $cache_key = md5_hex($url);
    my $cache_file = "$cache_dir/$cache_key.cache";
    
    # 캐시 파일이 존재하고 TTL 내에 있으면 사용
    if (-f $cache_file && (time - (stat($cache_file))[9]) < $cache_ttl) {
        DEBUG("캐시에서 $url 로드");
        my $cached_data = retrieve($cache_file);
        return $cached_data->{content};
    }
    
    # 캐시 없거나 만료되었으면 새로 요청
    DEBUG("$url 새로 요청");
    my $ua = LWP::UserAgent->new;
    my $response = $ua->get($url);
    
    if ($response->is_success) {
        my $content = $response->decoded_content;
        
        # 캐시 저장
        store({ 
            url => $url,
            content => $content,
            timestamp => time()
        }, $cache_file);
        
        return $content;
    } else {
        ERROR("요청 실패: " . $response->status_line);
        return undef;
    }
}

견고한 오류 처리와 디버깅 시스템은 장기적으로 안정적인 웹 스크래핑 솔루션을 구축하는 데 필수적이야. 다음 섹션에서는 웹 스크래핑의 법적, 윤리적 측면을 살펴볼게! 🧑‍⚖️

9. 웹 스크래핑의 법적, 윤리적 고려사항 ⚖️

웹 스크래핑은 강력한 도구지만, 법적, 윤리적 경계 내에서 사용하는 것이 중요해. 이번 섹션에서는 웹 스크래핑을 할 때 고려해야 할 법적, 윤리적 문제들을 알아볼게.

웹 스크래핑의 법적 측면

웹 스크래핑의 윤리적 측면

use WWW::RobotRules;

# robots.txt 확인 함수
sub check_robots_txt {
    my ($url) = @_;
    
    my $ua = LWP::UserAgent->new;
    my $robot_name = "MyPerlScraper/1.0";
    
    # URL에서 도메인 추출
    my ($domain) = $url =~ m{https?://([^/]+)};
    my $robots_url = "https://$domain/robots.txt";
    
    my $rules = WWW::RobotRules->new($robot_name);
    my $response = $ua->get($robots_url);
    
    if ($response->is_success) {
        $rules->parse($robots_url, $response->decoded_content);
        
        if ($rules->allowed($url)) {
            INFO("robots.txt: $url 접근 허용");
            return 1;
        } else {
            WARN("robots.txt: $url 접근 금지");
            return 0;
        }
    } else {
        # robots.txt가 없으면 접근 허용으로 간주
        INFO("robots.txt 파일을 찾을 수 없음. 접근 허용으로 간주");
        return 1;
    }
}

my $ua = LWP::UserAgent->new;
$ua->agent('MyCompanyScraper/1.0 (+https://example.com/bot; bot@example.com)');

안전한 웹 스크래핑을 위한 가이드라인