Как написать краулер?

Вы, конечно, будете изобретать велосипед. Но вот основы:

• Список непосещенных URL-адресов - заполните его одной или несколькими стартовыми страницами.
• Список посещенных URL-адресов - так что вы не ходите по кругу
• Набор правил для URL-адресов, которые вам не интересны - поэтому вы не индексируете весь Интернет

Поместите их в постоянное хранилище, чтобы вы могли остановить и запустить поисковый робот без потери состояния.

Алгоритм такой:

while(list of unvisited URLs is not empty) {
    take URL from list
    remove it from the unvisited list and add it to the visited list
    fetch content
    record whatever it is you want to about the content
    if content is HTML {
        parse out URLs from links
        foreach URL {
           if it matches your rules
              and it's not already in either the visited or unvisited list
              add it to the unvisited list
        }
    }
}

Сложная часть краулера - это если вы хотите масштабировать его для огромного количества веб-сайтов / запросов. В этой ситуации вам придется столкнуться с некоторыми проблемами, такими как:

• Невозможность хранить всю информацию в одной базе данных.

• Недостаточно ОЗУ для работы с огромными индексами

• Многопоточность и параллелизм

• Ловушки краулера (бесконечный цикл, созданный изменением URL-адресов, календарей, идентификаторов сессий ...) и дублированного контента.

• Сканирование с более чем одного компьютера

• Некорректные HTML-коды

• Постоянные HTTP-ошибки с серверов

• Базы данных без сжатия, что увеличивает потребность в пространстве примерно в 8 раз.

• Пересмотрите процедуры и приоритеты.

• Используйте запросы со сжатием (Deflate / gzip) (подходит для любого краулера).

И несколько важных вещей

• Уважайте robots.txt

• И задержка краулера на каждый запрос, чтобы не задушить веб-серверы.

Многопоточный веб-сканер

Если вы хотите сканировать веб-сайт большого размера, вам следует написать многопоточный сканер. подключение, выборка и запись просканированной информации в файлы / базу данных - это три этапа сканирования, но если вы используете однопоточный, то загрузка вашего процессора и сети будет израсходована.

Многопоточный поисковый робот нуждается в двух структурах данных: linksVisited (это должно быть реализовано как хэш-карта или trai) и linksToBeVisited (это очередь).

Поисковый робот использует BFS для обхода всемирной паутины.

Алгоритм базового поискового робота: -

1. Добавьте один или несколько исходных URL-адресов в linksToBeVisited. Метод добавления URL-адреса в linksToBeVisited должен быть синхронизирован.
2. Извлечь элемент из linksToBeVisited и добавить его в linksVisited. Этот метод pop для извлечения url-адреса из linksToBeVisited должен быть синхронизирован.
3. Загрузите страницу из Интернета.
4. Разберите файл и добавьте любую до сих пор не посещенную ссылку, найденную на странице, в linksToBeVisited. При необходимости URL-адреса могут быть отфильтрованы. Пользователь может указать набор правил для фильтрации URL-адресов для сканирования.
5. Необходимая информация, найденная на странице, сохраняется в базе данных или файле.

6. повторяйте шаги со 2 по 5, пока очередь не станет пустой.

   Вот фрагмент кода о том, как синхронизировать потоки ....

    public void add(String site) {
      synchronized (this) {
      if (!linksVisited.contains(site)) {
        linksToBeVisited.add(site);
        }
      }
    }
   
    public String next() {
       if (linksToBeVisited.size() == 0) {
       return null;
       }
          synchronized (this) {
           // Need to check again if size has changed
          if (linksToBeVisited.size() > 0) {
             String s = linksToBeVisited.get(0);
             linksToBeVisited.remove(0);
             linksVisited.add(s);
             return s;
          }
        return null;
        }
     }
   

По сути, краулеры просты.

Вы получаете корневую страницу через HTTP GET, анализируете ее, чтобы найти URL-адреса, и помещаете их в очередь, если они еще не были проанализированы (поэтому вам нужна глобальная запись страниц, которые вы уже проанализировали).

Вы можете использовать заголовок Content-type, чтобы узнать, какой тип содержимого, и ограничить поисковый робот только синтаксическим анализом типов HTML.

Вы можете вырезать HTML-теги, чтобы получить простой текст, который вы можете анализировать (чтобы получить теги и т. Д., Основную часть страницы). Вы даже можете сделать это с тегами alt / title для изображений, если у вас есть опыт.

А в фоновом режиме у вас может быть пул потоков, которые потребляют URL-адреса из очереди и делают то же самое. Конечно, вы хотите ограничить количество потоков.

Если сайты вашей НКО относительно большие или сложные (с динамическими страницами, которые фактически создают «черную дыру», например, календарь со ссылкой «на следующий день»), вам лучше использовать настоящий веб-сканер, например Heritrix.

Если на сайтах всего несколько страниц, вы можете обойтись простым использованием curl, wget или вашего собственного. Просто помните, если они начнут расти или вы начнете усложнять свой сценарий, чтобы просто использовать настоящего краулера или, по крайней мере, посмотреть на его источник, чтобы узнать, что они делают и почему.

Некоторые проблемы (их больше):

• Черные дыры (как описано)
• Повторные попытки (что, если вы получите 500?)
• Перенаправления
• Контроль потока (иначе вы можете быть обузой на сайтах)
• реализация robots.txt

В Википедии есть хорошая статья о поисковых роботах, охватывающая многие алгоритмы и рекомендации.

Однако я бы не стал писать собственный поисковый робот. Это большая работа, и поскольку вам нужен только «простой сканер», я думаю, все, что вам действительно нужно, это стандартный поисковый робот. Существует множество бесплатных поисковых роботов с открытым исходным кодом, которые, вероятно, сделают все, что вам нужно, с очень небольшой работой с вашей стороны.

Вы можете составить список слов и создать цепочку для каждого слова, найденного в Google.
Затем каждый поток будет создавать новую цепочку для каждой ссылки, которую он найдет на странице.
Каждый поток должен записывать то, что он находит в база данных. Когда каждый поток заканчивает чтение страницы, он завершается.
И у вас есть очень большая база данных ссылок в вашей базе данных.

Используйте wget, выполните рекурсивное веб-отсасывание, которое выгружает все файлы на ваш жесткий диск, а затем напишите другой сценарий, чтобы просмотреть все загруженные файлы и проанализировать их.

Изменить: или, может быть, curl вместо wget, но я не знаком с curl, я не знаю, выполняет ли он рекурсивные загрузки, такие как wget.

Я использую сервер открытого поиска для внутреннего поиска моей компании, попробуйте следующее: http://open-search-server.com это также открытая среда.

Я сделал простой веб-сканер, используя реактивное расширение в .net.

https://github.com/Misterhex/WebCrawler

public class Crawler
    {
    class ReceivingCrawledUri : ObservableBase<Uri>
    {
        public int _numberOfLinksLeft = 0;

        private ReplaySubject<Uri> _subject = new ReplaySubject<Uri>();
        private Uri _rootUri;
        private IEnumerable<IUriFilter> _filters;

        public ReceivingCrawledUri(Uri uri)
            : this(uri, Enumerable.Empty<IUriFilter>().ToArray())
        { }

        public ReceivingCrawledUri(Uri uri, params IUriFilter[] filters)
        {
            _filters = filters;

            CrawlAsync(uri).Start();
        }

        protected override IDisposable SubscribeCore(IObserver<Uri> observer)
        {
            return _subject.Subscribe(observer);
        }

        private async Task CrawlAsync(Uri uri)
        {
            using (HttpClient client = new HttpClient() { Timeout = TimeSpan.FromMinutes(1) })
            {
                IEnumerable<Uri> result = new List<Uri>();

                try
                {
                    string html = await client.GetStringAsync(uri);
                    result = CQ.Create(html)["a"].Select(i => i.Attributes["href"]).SafeSelect(i => new Uri(i));
                    result = Filter(result, _filters.ToArray());

                    result.ToList().ForEach(async i =>
                    {
                        Interlocked.Increment(ref _numberOfLinksLeft);
                        _subject.OnNext(i);
                        await CrawlAsync(i);
                    });
                }
                catch
                { }

                if (Interlocked.Decrement(ref _numberOfLinksLeft) == 0)
                    _subject.OnCompleted();
            }
        }

        private static List<Uri> Filter(IEnumerable<Uri> uris, params IUriFilter[] filters)
        {
            var filtered = uris.ToList();
            foreach (var filter in filters.ToList())
            {
                filtered = filter.Filter(filtered);
            }
            return filtered;
        }
    }

    public IObservable<Uri> Crawl(Uri uri)
    {
        return new ReceivingCrawledUri(uri, new ExcludeRootUriFilter(uri), new ExternalUriFilter(uri), new AlreadyVisitedUriFilter());
    }

    public IObservable<Uri> Crawl(Uri uri, params IUriFilter[] filters)
    {
        return new ReceivingCrawledUri(uri, filters);
    }
}

и вы можете использовать его следующим образом:

Crawler crawler = new Crawler();
IObservable observable = crawler.Crawl(new Uri("http://www.codinghorror.com/"));
observable.Subscribe(onNext: Console.WriteLine, 
onCompleted: () => Console.WriteLine("Crawling completed"));