si vous faites face à la page " ce fichier ne peut pas être vérifié pour les virus " intermezzo, le téléchargement n'est pas si facile.

vous avez essentiellement besoin de télécharger d'abord le lien de téléchargement normal, qui toutefois vous redirige vers la page" Télécharger quand même". Vous devez stocker les cookies de cette première demande, trouver le lien pointé par le bouton" Télécharger quand même", puis utiliser ce lien pour télécharger le fichier, mais en réutilisant les cookies que vous avez obtenu de la la première demande.

voici une variante de bash du processus de téléchargement en utilisant CURL:

curl -c /tmp/cookies "https://drive.google.com/uc?export=download&id=DOCUMENT_ID" > /tmp/intermezzo.html
curl -L -b /tmp/cookies "https://drive.google.com$(cat /tmp/intermezzo.html | grep -Po 'uc-download-link" [^>]* href="\K[^"]*' | sed 's/\&/\&/g')" > FINAL_DOWNLOADED_FILENAME

Notes:

• cette procédure va probablement cesser de fonctionner après quelques modifications de Google
• la commande grep utilise la syntaxe Perl ( -P ) et le \K " opérateur "qui signifie essentiellement "ne pas inclure quoi que ce soit précédant \K au résultat apparié. Je ne sais pas quelle version de grep a introduit ces options, mais les versions anciennes ou non-Ubuntu ne l'ont probablement pas
• une solution Java serait plus ou moins la même, il suffit de prendre une bibliothèque HTTPS qui peut gérer les cookies, et une bibliothèque de parsing de texte agréable

cela semble être mis à jour à partir du 19 mai 2015:

Comment je l'ai eu à travailler:

comme dans la réponse récemment mise à jour de jmbertucci, rendez votre dossier public à tout le monde. C'est un peu plus compliqué qu'avant, vous devez cliquez sur Avancé pour changer le dossier de "Sur - Public sur le web."

trouver votre UUID de dossier comme avant--juste aller dans le dossier et trouver votre UUID dans la barre d'adresse:

https://drive.google.com/drive/folders/<folder UUID>

puis

https://googledrive.com/host/<folder UUID>

il vous redirigera vers une page de type index avec un sous-domaine géant, mais vous devriez être en mesure de voir les fichiers dans votre dossier. Ensuite, vous pouvez faire un clic droit pour sauvegarder le lien vers le fichier que vous voulez (j'ai remarqué que ce lien direct a aussi ce grand sous-domaine pour googledrive.com ). Ça a bien marché pour moi avec wget .

cela semble aussi fonctionner avec les dossiers partagés des autres.

par exemple,

https://drive.google.com/folderview?id=0B7l10Bj_LprhQnpSRkpGMGV2eE0&usp=sharing

cartes

https://googledrive.com/host/0B7l10Bj_LprhQnpSRkpGMGV2eE0

et un clic droit peut enregistrer un lien direct vers l'un de ces fichiers.

je sais que c'est une vieille question mais je n'ai pas pu trouver une solution à ce problème après quelques recherches, donc je partage ce qui a fonctionné pour moi.

j'ai écrit ce code C pour un de mes projets. Il peut contourner l'avertissement de virus de balayage programmatically. Le code peut probablement être converti en Java.

using System;
using System.IO;
using System.Net;

public static class FileDownloader
{
    private const string GOOGLE_DRIVE_DOMAIN = "drive.google.com";
    private const string GOOGLE_DRIVE_DOMAIN2 = "https://drive.google.com";

    // Normal example: FileDownloader.DownloadFileFromURLToPath( "http://example.com/file/download/link", @"C:\file.txt" );
    // Drive example: FileDownloader.DownloadFileFromURLToPath( "http://drive.google.com/file/d/FILEID/view?usp=sharing", @"C:\file.txt" );
    public static FileInfo DownloadFileFromURLToPath( string url, string path )
    {
        if( url.StartsWith( GOOGLE_DRIVE_DOMAIN ) || url.StartsWith( GOOGLE_DRIVE_DOMAIN2 ) )
            return DownloadGoogleDriveFileFromURLToPath( url, path );
        else
            return DownloadFileFromURLToPath( url, path, null );
    }

    private static FileInfo DownloadFileFromURLToPath( string url, string path, WebClient webClient )
    {
        try
        {
            if( webClient == null )
            {
                using( webClient = new WebClient() )
                {
                    webClient.DownloadFile( url, path );
                    return new FileInfo( path );
                }
            }
            else
            {
                webClient.DownloadFile( url, path );
                return new FileInfo( path );
            }
        }
        catch( WebException )
        {
            return null;
        }
    }

    // Downloading large files from Google Drive prompts a warning screen and
    // requires manual confirmation. Consider that case and try to confirm the download automatically
    // if warning prompt occurs
    private static FileInfo DownloadGoogleDriveFileFromURLToPath( string url, string path )
    {
        // You can comment the statement below if the provided url is guaranteed to be in the following format:
        // https://drive.google.com/uc?id=FILEID&export=download
        url = GetGoogleDriveDownloadLinkFromUrl( url );

        using( CookieAwareWebClient webClient = new CookieAwareWebClient() )
        {
            FileInfo downloadedFile;

            // Sometimes Drive returns an NID cookie instead of a download_warning cookie at first attempt,
            // but works in the second attempt
            for( int i = 0; i < 2; i++ )
            {
                downloadedFile = DownloadFileFromURLToPath( url, path, webClient );
                if( downloadedFile == null )
                    return null;

                // Confirmation page is around 50KB, shouldn't be larger than 60KB
                if( downloadedFile.Length > 60000 )
                    return downloadedFile;

                // Downloaded file might be the confirmation page, check it
                string content;
                using( var reader = downloadedFile.OpenText() )
                {
                    // Confirmation page starts with <!DOCTYPE html>, which can be preceeded by a newline
                    char[] header = new char[20];
                    int readCount = reader.ReadBlock( header, 0, 20 );
                    if( readCount < 20 || !( new string( header ).Contains( "<!DOCTYPE html>" ) ) )
                        return downloadedFile;

                    content = reader.ReadToEnd();
                }

                int linkIndex = content.LastIndexOf( "href=\"/uc?" );
                if( linkIndex < 0 )
                    return downloadedFile;

                linkIndex += 6;
                int linkEnd = content.IndexOf( '"', linkIndex );
                if( linkEnd < 0 )
                    return downloadedFile;

                url = "https://drive.google.com" + content.Substring( linkIndex, linkEnd - linkIndex ).Replace( "&amp;", "&" );
            }

            downloadedFile = DownloadFileFromURLToPath( url, path, webClient );

            return downloadedFile;
        }
    }

    // Handles 3 kinds of links (they can be preceeded by https://):
    // - drive.google.com/open?id=FILEID
    // - drive.google.com/file/d/FILEID/view?usp=sharing
    // - drive.google.com/uc?id=FILEID&export=download
    public static string GetGoogleDriveDownloadLinkFromUrl( string url )
    {
        int index = url.IndexOf( "id=" );
        int closingIndex;
        if( index > 0 )
        {
            index += 3;
            closingIndex = url.IndexOf( '&', index );
            if( closingIndex < 0 )
                closingIndex = url.Length;
        }
        else
        {
            index = url.IndexOf( "file/d/" );
            if( index < 0 ) // url is not in any of the supported forms
                return string.Empty;

            index += 7;

            closingIndex = url.IndexOf( '/', index );
            if( closingIndex < 0 )
            {
                closingIndex = url.IndexOf( '?', index );
                if( closingIndex < 0 )
                    closingIndex = url.Length;
            }
        }

        return string.Format( "https://drive.google.com/uc?id={0}&export=download", url.Substring( index, closingIndex - index ) );
    }
}

// Web client used for Google Drive
public class CookieAwareWebClient : WebClient
{
    private class CookieContainer
    {
        Dictionary<string, string> _cookies;

        public string this[Uri url]
        {
            get
            {
                string cookie;
                if( _cookies.TryGetValue( url.Host, out cookie ) )
                    return cookie;

                return null;
            }
            set
            {
                _cookies[url.Host] = value;
            }
        }

        public CookieContainer()
        {
            _cookies = new Dictionary<string, string>();
        }
    }

    private CookieContainer cookies;

    public CookieAwareWebClient() : base()
    {
        cookies = new CookieContainer();
    }

    protected override WebRequest GetWebRequest( Uri address )
    {
        WebRequest request = base.GetWebRequest( address );

        if( request is HttpWebRequest )
        {
            string cookie = cookies[address];
            if( cookie != null )
                ( (HttpWebRequest) request ).Headers.Set( "cookie", cookie );
        }

        return request;
    }

    protected override WebResponse GetWebResponse( WebRequest request, IAsyncResult result )
    {
        WebResponse response = base.GetWebResponse( request, result );

        string[] cookies = response.Headers.GetValues( "Set-Cookie" );
        if( cookies != null && cookies.Length > 0 )
        {
            string cookie = "";
            foreach( string c in cookies )
                cookie += c;

            this.cookies[response.ResponseUri] = cookie;
        }

        return response;
    }

    protected override WebResponse GetWebResponse( WebRequest request )
    {
        WebResponse response = base.GetWebResponse( request );

        string[] cookies = response.Headers.GetValues( "Set-Cookie" );
        if( cookies != null && cookies.Length > 0 )
        {
            string cookie = "";
            foreach( string c in cookies )
                cookie += c;

            this.cookies[response.ResponseUri] = cookie;
        }

        return response;
    }
}

L'utilisation d'un compte de Service pourrait fonctionner pour vous.

#Case 1: Télécharger un fichier de petite taille.

• vous pouvez utiliser l'url avec le format https://drive.google.com/uc?export=download&id=FILE_ID et puis entrée de fichier peuvent être obtenus directement.

#Case 2: télécharger un fichier de grande taille.

• vous avez collé un mur d'une page d'alerte de balayage de virus retourné. Par l'analyse de élément HTML dom, j'ai essayé d'obtenir le lien avec confirmer le code sous le bouton "Télécharger quand même" mais cela n'a pas fonctionné. Sa peut-requis cookie de session ou de info. entrez la description de l'image ici

SOLUTION:

• finalement j'ai trouvé la solution pour deux cas ci-dessus. Il suffit de mettre httpConnection.setDoOutput(true) dans le pas de connexion pour obtenir un Json.

  )]}' { "disposition":"SCAN_CLEAN", "downloadUrl":"http:www...", "fileName":"exam_list_json.txt", "scanResult":"OK", "sizeBytes":2392}

ensuite, vous pouvez utiliser n'importe quel JSON parser pour lire downloadUrl, nom de fichier et sizeBytes.

• Vous pouvez consulter l'extrait de suivre, espérons que cela aide.

  private InputStream gConnect(String remoteFile) throws IOException{
      URL  url = new URL(remoteFile);
      URLConnection connection = url.openConnection();
      if(connection instanceof HttpURLConnection){
          HttpURLConnection httpConnection = (HttpURLConnection) connection;
          connection.setAllowUserInteraction(false);
          httpConnection.setInstanceFollowRedirects(true);
          httpConnection.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows 2000)");
          httpConnection.setDoOutput(true);          
          httpConnection.setRequestMethod("GET");
          httpConnection.connect();
  
          int reqCode = httpConnection.getResponseCode();
  
  
          if(reqCode == HttpURLConnection.HTTP_OK){
              InputStream is = httpConnection.getInputStream();
              Map<String, List<String>> map = httpConnection.getHeaderFields();
              List<String> values = map.get("content-type");
              if(values != null && !values.isEmpty()){
                  String type = values.get(0);
  
                  if(type.contains("text/html")){
                      String cookie = httpConnection.getHeaderField("Set-Cookie");
                      String temp = Constants.getPath(mContext, Constants.PATH_TEMP) + "/temp.html";
                      if(saveGHtmlFile(is, temp)){
                          String href = getRealUrl(temp);
                          if(href != null){
                              return parseUrl(href, cookie);
                          }
                      }
  
  
                  } else if(type.contains("application/json")){
                      String temp = Constants.getPath(mContext, Constants.PATH_TEMP) + "/temp.txt";
                      if(saveGJsonFile(is, temp)){
                          FileDataSet data = JsonReaderHelper.readFileDataset(new File(temp));
                          if(data.getPath() != null){
                              return parseUrl(data.getPath());
                          }
                      }
                  }
              }
              return is;
          }
      }
      return null;
  }
  

et

   public static FileDataSet readFileDataset(File file) throws IOException{
        FileInputStream is = new FileInputStream(file);
        JsonReader reader = new JsonReader(new InputStreamReader(is, "UTF-8"));

        reader.beginObject();
        FileDataSet rs = new FileDataSet();
        while(reader.hasNext()){
            String name = reader.nextName();
            if(name.equals("downloadUrl")){
                rs.setPath(reader.nextString());
            } else if(name.equals("fileName")){
                rs.setName(reader.nextString());
            } else if(name.equals("sizeBytes")){
                rs.setSize(reader.nextLong());
            } else {
                reader.skipValue();
            }
        }
        reader.endObject();
        return rs;

    }

j'envisagerais de télécharger à partir du lien, gratter la page que vous obtenez pour saisir le lien de confirmation, et ensuite télécharger cela.

si vous regardez L'URL" download anyway "il a un paramètre de requête supplémentaire confirm avec un jeton apparemment généré au hasard. Car c'est de l'aléatoire...et vous ne voulez probablement pas comprendre comment le générer vous-même, raclage pourrait être la manière la plus facile sans savoir quoi que ce soit sur la façon dont le site fonctionne.

Vous devrez peut-être envisager différents scénarios.

si vous voulez simplement télécharger un fichier par programme (au lieu de donner à l'utilisateur un lien pour l'ouvrir dans un navigateur) à travers L'API GoogleDrive, je suggère d'utiliser le downloadUrl du fichier au lieu du webContentLink , comme documenté ici: https://developers.google.com/drive/web/manage-downloads

https://github.com/google/skicka

j'ai utilisé cet outil en ligne de commande pour télécharger des fichiers à partir de Google Drive. Il suffit de suivre les instructions dans la section Getting Started et vous devriez télécharger des fichiers à partir de Google Drive en quelques minutes.

https://drive.google.com/uc?export=download&id=FILE_ID remplacer FILE_ID par file id.

si vous ne savez pas où sont id de fichier, puis vérifier cela l'article LIEN Article

je crée simplement un javascript de sorte qu'il capture automatiquement le lien et télécharger et fermer l'onglet avec l'aide de tampermonkey .

// ==UserScript==
// @name         Bypass Google drive virus scan
// @namespace    SmartManoj
// @version      0.1
// @description  Quickly get the download link
// @author       SmartManoj
// @match        https://drive.google.com/uc?id=*&export=download*
// @grant        none
// ==/UserScript==

    function sleep(ms) {
      return new Promise(resolve => setTimeout(resolve, ms));
    }

    async function demo() {
        await sleep(5000);
        window.close();
    }

    (function() {
        location.replace(document.getElementById("uc-download-link").href);
        demo();
    })();

de même, vous pouvez obtenir la source html de l'url et télécharger en java.