go get -u github.com/gocolly/colly/v2

package main

import (
    "fmt"
    "github.com/gocolly/colly/v2"
)

type Article struct {
    Title string
    Link  string
    Date  string
}

func main() {
    var articles []Article

    c := colly.NewCollector(
        // 허용할 도메인 지정
        colly.AllowedDomains("example-news.com"),
        // 동시 요청 수 제한
        colly.Async(true),
    )

    // 요청 속도 제한 (초당 2개)
    c.Limit(&colly.LimitRule{
        DomainGlob:  "*",
        Parallelism: 2,
        RandomDelay: 1 * time.Second,
    })

    // 기사 정보 수집
    c.OnHTML("article.news-item", func(e *colly.HTMLElement) {
        article := Article{
            Title: e.ChildText("h2.title"),
            Link:  e.ChildAttr("a", "href"),
            Date:  e.ChildText("time.published"),
        }
        articles = append(articles, article)
    })

    // 다음 페이지 링크 찾기
    c.OnHTML("a.next-page", func(e *colly.HTMLElement) {
        nextPage := e.Attr("href")
        c.Visit(e.Request.AbsoluteURL(nextPage))
    })

    // 에러 처리
    c.OnError(func(r *colly.Response, err error) {
        fmt.Println("에러 발생:", r.StatusCode, err)
    })

    // 크롤링 완료 후
    c.OnScraped(func(r *colly.Response) {
        fmt.Printf("총 %d개의 기사를 수집했습니다!\n", len(articles))
    })

    // 시작!
    c.Visit("https://example-news.com/latest")
    c.Wait()

    // 결과 출력
    for _, article := range articles {
        fmt.Printf("제목: %s\n링크: %s\n날짜: %s\n\n", 
            article.Title, article.Link, article.Date)
    }
}

package main

import (
    "github.com/gocolly/colly/v2"
    "math/rand"
    "time"
)

func main() {
    c := colly.NewCollector()

    // User-Agent 목록
    userAgents := []string{
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36",
    }

    // 랜덤 User-Agent 설정
    rand.Seed(time.Now().UnixNano())
    
    c.OnRequest(func(r *colly.Request) {
        r.Headers.Set("User-Agent", userAgents[rand.Intn(len(userAgents))])
        r.Headers.Set("Accept", "text/html,application/xhtml+xml")
        r.Headers.Set("Accept-Language", "ko-KR,ko;q=0.9,en-US;q=0.8")
        r.Headers.Set("Referer", "https://www.google.com")
    })

    c.Visit("https://example.com")
}

package main

import (
    "github.com/gocolly/colly/v2"
    "github.com/gocolly/colly/v2/extensions"
    "time"
)

func main() {
    c := colly.NewCollector()

    // robots.txt 자동 확인
    c.IgnoreRobotsTxt = false

    // 요청 속도 제한
    c.Limit(&colly.LimitRule{
        DomainGlob:  "*",
        Parallelism: 2,
        Delay:       2 * time.Second,
        RandomDelay: 1 * time.Second,
    })

    // 랜덤 User-Agent 사용 (확장 기능)
    extensions.RandomUserAgent(c)
    extensions.Referer(c)

    // 캐싱 설정
    c.CacheDir = "./cache"

    c.OnRequest(func(r *colly.Request) {
        fmt.Println("방문:", r.URL)
    })

    c.Visit("https://example.com")
}

package main

import (
    "github.com/gocolly/colly/v2"
    "github.com/gocolly/colly/v2/debug"
    "log"
    "os"
)

func main() {
    // 로그 파일 생성
    logFile, err := os.Create("crawler.log")
    if err != nil {
        panic(err)
    }
    defer logFile.Close()

    // 로거 설정
    logger := log.New(logFile, "", log.LstdFlags)

    c := colly.NewCollector(
        colly.Debugger(&debug.LogDebugger{}),
    )

    // 요청 로깅
    c.OnRequest(func(r *colly.Request) {
        logger.Printf("방문: %s\n", r.URL)
    })

    // 응답 로깅
    c.OnResponse(func(r *colly.Response) {
        logger.Printf("응답 받음: %s (상태: %d)\n", 
            r.Request.URL, r.StatusCode)
    })

    // 에러 로깅
    c.OnError(func(r *colly.Response, err error) {
        logger.Printf("에러 발생: %s - %v\n", r.Request.URL, err)
    })

    c.Visit("https://example.com")
}

package main

import (
    "github.com/gocolly/colly/v2"
    "time"
)

func main() {
    c := colly.NewCollector()

    // 재시도 설정
    maxRetries := 3
    retryCount := make(map[string]int)

    c.OnError(func(r *colly.Response, err error) {
        url := r.Request.URL.String()
        
        if retryCount[url] < maxRetries {
            retryCount[url]++
            fmt.Printf("재시도 %d/%d: %s\n", 
                retryCount[url], maxRetries, url)
            
            // 잠시 대기 후 재시도
            time.Sleep(2 * time.Second)
            r.Request.Retry()
        } else {
            fmt.Printf("최대 재시도 횟수 초과: %s\n", url)
        }
    })

    c.Visit("https://example.com")
}

package main

import (
    "context"
    "github.com/gocolly/colly/v2"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "time"
)

type Article struct {
    Title     string    `bson:"title"`
    Content   string    `bson:"content"`
    URL       string    `bson:"url"`
    CreatedAt time.Time `bson:"created_at"`
}

func main() {
    // MongoDB 연결
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    client, err := mongo.Connect(ctx, 
        options.Client().ApplyURI("mongodb://localhost:27017"))
    if err != nil {
        panic(err)
    }
    defer client.Disconnect(ctx)

    collection := client.Database("crawler").Collection("articles")

    c := colly.NewCollector()

    c.OnHTML("article", func(e *colly.HTMLElement) {
        article := Article{
            Title:     e.ChildText("h2"),
            Content:   e.ChildText("p"),
            URL:       e.Request.URL.String(),
            CreatedAt: time.Now(),
        }

        // MongoDB에 저장
        _, err := collection.InsertOne(ctx, article)
        if err != nil {
            fmt.Println("저장 실패:", err)
        } else {
            fmt.Println("저장 완료:", article.Title)
        }
    })

    c.Visit("https://example.com/articles")
}

package main

import (
    "context"
    "github.com/chromedp/chromedp"
    "github.com/gocolly/colly/v2"
    "time"
)

func main() {
    // Chrome 컨텍스트 생성
    ctx, cancel := chromedp.NewContext(context.Background())
    defer cancel()

    // 타임아웃 설정
    ctx, cancel = context.WithTimeout(ctx, 30*time.Second)
    defer cancel()

    var htmlContent string

    // JavaScript 실행 후 HTML 가져오기
    err := chromedp.Run(ctx,
        chromedp.Navigate("https://example-spa.com"),
        chromedp.WaitVisible("div.content", chromedp.ByQuery),
        chromedp.Sleep(2*time.Second),
        chromedp.OuterHTML("html", &htmlContent),
    )
    if err != nil {
        panic(err)
    }

    // Colly로 파싱
    c := colly.NewCollector()
    
    c.OnHTML("div.dynamic-content", func(e *colly.HTMLElement) {
        fmt.Println("제목:", e.ChildText("h2"))
    })

    c.OnHTML(htmlContent, func(e *colly.HTMLElement) {
        // HTML 파싱
    })
}

package main

import (
    "encoding/csv"
    "fmt"
    "github.com/gocolly/colly/v2"
    "os"
    "strconv"
    "strings"
    "time"
)

type Product struct {
    Name     string
    Price    float64
    Shop     string
    URL      string
    ImageURL string
}

func main() {
    products := []Product{}

    // 쇼핑몰별 크롤러 설정
    shops := map[string]string{
        "ShopA": "https://shop-a.com/search?q=",
        "ShopB": "https://shop-b.com/products?keyword=",
    }

    keyword := "무선이어폰"

    for shopName, baseURL := range shops {
        c := colly.NewCollector(
            colly.AllowedDomains(getDomain(baseURL)),
        )

        c.Limit(&colly.LimitRule{
            DomainGlob:  "*",
            Parallelism: 1,
            Delay:       2 * time.Second,
        })

        // ShopA 크롤링
        if shopName == "ShopA" {
            c.OnHTML("div.product-item", func(e *colly.HTMLElement) {
                product := Product{
                    Name:     e.ChildText("h3.product-name"),
                    Price:    parsePrice(e.ChildText("span.price")),
                    Shop:     shopName,
                    URL:      e.ChildAttr("a", "href"),
                    ImageURL: e.ChildAttr("img", "src"),
                }
                products = append(products, product)
            })
        }

        // ShopB 크롤링
        if shopName == "ShopB" {
            c.OnHTML("article.item", func(e *colly.HTMLElement) {
                product := Product{
                    Name:     e.ChildText("div.title"),
                    Price:    parsePrice(e.ChildText("div.price")),
                    Shop:     shopName,
                    URL:      e.ChildAttr("a.link", "href"),
                    ImageURL: e.ChildAttr("img.thumb", "src"),
                }
                products = append(products, product)
            })
        }

        c.Visit(baseURL + keyword)
    }

    // 가격순 정렬
    sortByPrice(products)

    // CSV로 저장
    saveToCSV(products, "price_comparison.csv")

    // 결과 출력
    fmt.Printf("\n총 %d개의 상품을 찾았습니다!\n\n", len(products))
    for i, p := range products {
        if i >= 10 {
            break
        }
        fmt.Printf("%d. %s - ₩%.0f (%s)\n", 
            i+1, p.Name, p.Price, p.Shop)
    }
}

func parsePrice(priceStr string) float64 {
    // 가격 문자열에서 숫자만 추출
    priceStr = strings.ReplaceAll(priceStr, ",", "")
    priceStr = strings.ReplaceAll(priceStr, "원", "")
    priceStr = strings.TrimSpace(priceStr)
    
    price, err := strconv.ParseFloat(priceStr, 64)
    if err != nil {
        return 0
    }
    return price
}

func getDomain(url string) string {
    // URL에서 도메인 추출
    parts := strings.Split(url, "/")
    if len(parts) >= 3 {
        return parts[2]
    }
    return ""
}

func sortByPrice(products []Product) {
    // 간단한 버블 정렬
    for i := 0; i < len(products); i++ {
        for j := i + 1; j < len(products); j++ {
            if products[i].Price > products[j].Price {
                products[i], products[j] = products[j], products[i]
            }
        }
    }
}

func saveToCSV(products []Product, filename string) {
    file, err := os.Create(filename)
    if err != nil {
        fmt.Println("CSV 파일 생성 실패:", err)
        return
    }
    defer file.Close()

    writer := csv.NewWriter(file)
    defer writer.Flush()

    // 헤더 작성
    writer.Write([]string{"상품명", "가격", "쇼핑몰", "URL", "이미지URL"})

    // 데이터 작성
    for _, p := range products {
        writer.Write([]string{
            p.Name,
            fmt.Sprintf("%.0f", p.Price),
            p.Shop,
            p.URL,
            p.ImageURL,
        })
    }

    fmt.Println("CSV 파일 저장 완료:", filename)
}

package main

import (
    "github.com/gocolly/colly/v2"
    "runtime"
    "time"
)

func main() {
    c := colly.NewCollector(
        colly.Async(true),
        colly.CacheDir("./cache"),
    )

    // 동시 요청 수 최적화
    c.Limit(&colly.LimitRule{
        DomainGlob:  "*",
        Parallelism: 10, // CPU 코어 수에 맞게 조정
        Delay:       100 * time.Millisecond,
    })

    // 불필요한 리소스 차단
    c.OnRequest(func(r *colly.Request) {
        // 이미지, CSS, JS 파일 차단
        if strings.HasSuffix(r.URL.Path, ".jpg") ||
           strings.HasSuffix(r.URL.Path, ".css") ||
           strings.HasSuffix(r.URL.Path, ".js") {
            r.Abort()
        }
    })

    // 메모리 관리
    processedCount := 0
    c.OnScraped(func(r *colly.Response) {
        processedCount++
        
        // 1000개마다 가비지 컬렉션
        if processedCount%1000 == 0 {
            runtime.GC()
            fmt.Printf("처리 완료: %d개\n", processedCount)
        }
    })

    // 크롤링 시작
    for i := 1; i <= 100; i++ {
        c.Visit(fmt.Sprintf("https://example.com/page/%d", i))
    }

    c.Wait()
}