InputStream à partir d'une URL

, Essayez:

final InputStream is = new URL("http://wwww.somewebsite.com/a.txt").openStream();

(a) wwww.somewebsite.com/a.txt n'est pas un 'URL de fichier'. Ce n'est pas une URL à tous. Si vous mettez http:// sur le devant de celui-ci il serait une URL HTTP, qui est clairement ce que vous avez l'intention ici.

(b) FileInputStream est pour les fichiers, pas les Url.

(c) la façon d'obtenir un flux d'entrée à partir de N'importe quelle URL est via URL.openStream(), ou URL.getConnection().getInputStream(), qui est équivalent mais vous pourriez avoir d'autres raisons pour obtenir le URLConnection et jouer avec lui en premier.

votre code original utilise FileInputStream, qui est pour accéder aux fichiers hébergés par le système de fichiers.

le constructeur que vous avez utilisé tentera de localiser un fichier nommé a.txt dans www.somewebsite.com sous-dossier du répertoire de travail courant (la valeur de la propriété du système utilisateur.dir). Le nom que vous fournissez est résolu à un fichier en utilisant la classe File.

sont le moyen générique de résoudre ce problème. Vous pouvez utiliser des URLs pour accéder aux fichiers locaux mais aussi réseau hébergé ressources. La classe URL supporte le protocole file:// en plus de http:// ou https:// donc vous êtes bon pour y aller.

Voici un exemple complet qui lit le contenu de la page web donnée. La page web est lue à partir d'un formulaire HTML. Nous utilisons les classes standard InputStream , mais cela pourrait être fait plus facilement avec la bibliothèque JSoup.

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>

</dependency>

<dependency>
    <groupId>commons-validator</groupId>
    <artifactId>commons-validator</artifactId>
    <version>1.6</version>
</dependency>  

ce sont les dépendances Maven. Nous utilisons la bibliothèque Apache Commons pour valider les chaînes D'URL.

package com.zetcode.web;

import com.zetcode.service.WebPageReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(name = "ReadWebPage", urlPatterns = {"/ReadWebPage"})
public class ReadWebpage extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        response.setContentType("text/plain;charset=UTF-8");

        String page = request.getParameter("webpage");

        String content = new WebPageReader().setWebPageName(page).getWebPageContent();

        ServletOutputStream os = response.getOutputStream();
        os.write(content.getBytes(StandardCharsets.UTF_8));
    }
}

le servlet ReadWebPage lit le contenu de la page Web et le renvoie au client en clair format texte. La tâche de lire la page est déléguée à WebPageReader .

package com.zetcode.service;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import org.apache.commons.validator.routines.UrlValidator;

public class WebPageReader {

    private String webpage;
    private String content;

    public WebPageReader setWebPageName(String name) {

        webpage = name;
        return this;
    }

    public String getWebPageContent() {

        try {

            boolean valid = validateUrl(webpage);

            if (!valid) {

                content = "Invalid URL; use http(s)://www.example.com format";
                return content;
            }

            URL url = new URL(webpage);

            try (InputStream is = url.openStream();
                    BufferedReader br = new BufferedReader(
                            new InputStreamReader(is, StandardCharsets.UTF_8))) {

                content = br.lines().collect(
                      Collectors.joining(System.lineSeparator()));
            }

        } catch (IOException ex) {

            content = String.format("Cannot read webpage %s", ex);
            Logger.getLogger(WebPageReader.class.getName()).log(Level.SEVERE, null, ex);
        }

        return content;
    }

    private boolean validateUrl(String webpage) {

        UrlValidator urlValidator = new UrlValidator();

        return urlValidator.isValid(webpage);
    }
}

WebPageReader valide L'URL et lit le contenu de la page web. Il retourne une chaîne contenant le code HTML de la page.

<!DOCTYPE html>
<html>
    <head>
        <title>Home page</title>
        <meta charset="UTF-8">
    </head>
    <body>
        <form action="ReadWebPage">

            <label for="page">Enter a web page name:</label>
            <input  type="text" id="page" name="webpage">

            <button type="submit">Submit</button>

        </form>
    </body>
</html>

enfin, ceci est la page d'accueil contenant le formulaire HTML. Ceci est tiré de mon tutoriel à propos de ce thème.

avec un certain succès, j'utilise cette méthode. Il gère redirections et on peut passer un nombre variable de en-têtes HTTP comme Map<String,String> . Il permet aussi de rediriger Du HTTP vers HTTPS .

private InputStream urlToInputStream(URL url, Map<String, String> args) {
    HttpURLConnection con = null;
    InputStream inputStream = null;
    try {
        con = (HttpURLConnection) url.openConnection();
        con.setConnectTimeout(15000);
        con.setReadTimeout(15000);
        if (args != null) {
            for (Entry<String, String> e : args.entrySet()) {
                con.setRequestProperty(e.getKey(), e.getValue());
            }
        }
        con.connect();
        int responseCode = con.getResponseCode();
        /* By default the connection will follow redirects. The following
         * block is only entered if the implementation of HttpURLConnection
         * does not perform the redirect. The exact behavior depends to 
         * the actual implementation (e.g. sun.net).
         * !!! Attention: This block allows the connection to 
         * switch protocols (e.g. HTTP to HTTPS), which is <b>not</b> 
         * default behavior. See: /q/urlconnection-doesn-t-follow-redirect-24104/"Location");
            try {
                URL newUrl = new URL(redirectUrl);
                return urlToInputStream(newUrl, args);
            } catch (MalformedURLException e) {
                URL newUrl = new URL(url.getProtocol() + "://" + url.getHost() + redirectUrl);
                return urlToInputStream(newUrl, args);
            }
        }
        /*!!!!!*/

        inputStream = con.getInputStream();
        return inputStream;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

exemple d'appel

private InputStream getInputStreamFromUrl(URL url, String user, String passwd) throws IOException {
        String encoded = Base64.getEncoder().encodeToString((user + ":" + passwd).getBytes(StandardCharsets.UTF_8));
        Map<String,String> httpHeaders=new Map<>();
        httpHeaders.put("Accept", "application/json");
        httpHeaders.put("User-Agent", "myApplication");
        httpHeaders.put("Authorization", "Basic " + encoded);
        return urlToInputStream(url,httpHeaders);
    }