web crawler - online - Cómo escribir un rastreador?

web crawler online

Question

He pensado en intentar escribir un rastreador simple que pueda rastrear y generar una lista de sus hallazgos para los sitios web y el contenido de nuestra OSFL.

¿Alguien tiene alguna idea sobre cómo hacer esto? ¿Dónde apuntas el rastreador para comenzar? ¿Cómo devuelve sus hallazgos y sigue rastreando? Cómo sabe lo que encuentra, etc., etc.

Answer 1

Hice un rastreador web simple usando la extensión reactiva en .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);
    }
}

y puedes usarlo de la siguiente manera:

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

Answer 2

Los rastreadores son simples en concepto.

Obtiene una página raíz a través de HTTP GET, la analiza en busca de direcciones URL y las coloca en una cola a menos que ya las haya analizado (por lo que necesita un registro global de las páginas que ya ha analizado).

Puede usar el encabezado Content-type para descubrir cuál es el tipo de contenido y limitar su rastreador a solo analizar los tipos de HTML.

Puede quitar las etiquetas HTML para obtener el texto sin formato, en el que puede hacer análisis de texto (para obtener etiquetas, etc., el contenido de la página). Incluso podrías hacer eso en las etiquetas alt / title para las imágenes si tienes eso avanzado.

Y en segundo plano, puede tener un grupo de hilos que consumen URL de la cola y hacen lo mismo. Desea limitar el número de subprocesos, por supuesto.

Answer 3

Puede hacer una lista de palabras y hacer un hilo por cada palabra buscada en google.
Entonces cada hilo creará un nuevo hilo para cada enlace que encuentre en la página.
Cada hilo debe escribir lo que encuentra en una base de datos. Cuando cada hilo termina de leer la página, termina.
Y ahí tienes una gran base de datos de enlaces en tu base de datos.

Answer 4

Si los sitios de su NPO son relativamente grandes o complejos (con páginas dinámicas que efectivamente crearán un "agujero negro" como un calendario con un enlace de "día siguiente"), sería mejor usar un rastreador web real, como Heritrix.

Si los sitios suman un número reducido de páginas, puede salirse con la suya simplemente usando curl o wget. Solo recuerda si empiezan a crecer o si comienzas a hacer que tu script sea más complejo para usar solo un rastreador real o al menos ver su origen para ver qué están haciendo y por qué.

Algunos problemas (hay más):

• Agujeros negros (como se describe)
• Reintentos (¿y si obtiene 500?)
• Redirige
• Control de flujo (de lo contrario puede ser una carga para los sitios)
• Implementación de robots.txt

Answer 5

Use wget, haga una succión web recursiva, que arrojará todos los archivos en su disco duro, luego escriba otro script para revisar todos los archivos descargados y analizarlos.

Editar: o tal vez curl en lugar de wget, pero no estoy familiarizado con curl, no sé si lo hace descargas recursivas como wget.

Answer 6

Wikipedia tiene un buen artículo sobre rastreadores web , que abarca muchos de los algoritmos y consideraciones.

Sin embargo, no me molestaría en escribir mi propio rastreador. Es mucho trabajo, y como solo necesitas un "rastreador simple", estoy pensando que todo lo que realmente necesitas es un rastreador comercial . Hay muchos rastreadores de código abierto y gratuito que probablemente harán todo lo que necesites, con muy poco trabajo de tu parte.

Answer 7

Estarás reinventando la rueda, para estar seguro. Pero aquí está lo básico:

• Una lista de URL no visitadas: siembre esto con una o más páginas de inicio
• Una lista de URL visitadas, por lo que no das vueltas en círculos
• Un conjunto de reglas para las URL que no le interesan, por lo que no indexa todo Internet

Póngalos en almacenamiento persistente, para que pueda detener e iniciar el rastreador sin perder el estado.

Algoritmo es:

while(list of unvisited URLs is not empty) {
    take URL from 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
        }
    }
}

Answer 8

La parte complicada de un rastreador es si desea escalarlo a una gran cantidad de sitios web / solicitudes. En esta situación, tendrás que lidiar con algunos problemas como:

• Imposibilidad de mantener información todo en una base de datos.

• No hay suficiente memoria RAM para manejar grandes índices

• Rendimiento multiproceso y concurrencia

• Trampas de rastreo (ciclo infinito creado mediante el cambio de URL, calendarios, ID de sesión ...) y contenido duplicado.

• Rastrear desde más de una computadora

• Códigos HTML mal formados

• Errores http constantes de servidores

• Bases de datos sin compresión, que hacen que su necesidad de espacio sea aproximadamente 8 veces mayor.

• Volver a rastrear rutinas y prioridades.

• Utilice solicitudes con compresión (Deflate / gzip) (bueno para cualquier tipo de rastreador).

Y algunas cosas importantes

• Respete el robots.txt

• Y un rastreador demora en cada solicitud para no sofocar los servidores web.

Answer 9

Estoy usando el servidor de búsqueda abierto para la búsqueda interna de mi compañía. Prueba esto: http://open-search-server.com también está abierto.

Answer 10

Crawler web multiproceso

Si desea rastrear un sitio web de gran tamaño, debe escribir un rastreador multiproceso. Conectar, buscar y escribir información rastreada en archivos / bases de datos: estos son los tres pasos para rastrear, pero si usa un único subproceso de su CPU y la utilización de la red será vertido.

Un rastreador web de múltiples hilos necesita dos estructuras de datos: enlaces visitados (esto debe implementarse como hashmap o trai) y linksToBeVisited (esto es una cola).

El rastreador web utiliza BFS para recorrer la World Wide Web.

Algoritmo de un rastreador web básico: -

1. Agregue una o más URL de inicio a linksToBeVisited. El método para agregar una url a linksToBeVisited debe estar sincronizado.
2. Inserta un elemento de linksToBeVisited y agrégalo a los linksVisited. Este método pop para pop url de linksToBeVisited debe estar sincronizado.
3. Obtener la página de internet.
4. Analice el archivo y agregue cualquier enlace hasta ahora no visitado encontrado en la página a linksToBeVisited. Las URL se pueden filtrar si es necesario. El usuario puede proporcionar un conjunto de reglas para filtrar las URL que se analizarán.
5. La información necesaria que se encuentra en la página se guarda en la base de datos o archivo.

6. repita los pasos 2 a 5 hasta que la cola esté enlazada a linksToBeVisited.

   Aquí hay un fragmento de código sobre cómo sincronizar los hilos ....

    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;
        }
     }