najprostszy sposób na odczyt Json z adresu URL w Javie

To może być głupie pytanie, ale jaki jest najprostszy sposób na odczyt i analizę JSON z adresu URL w Javie ?

W Groovy jest to kwestia kilku linii kodu. Przykłady Java, które znalazłem, są absurdalnie długie (i mają ogromny blok obsługi wyjątków).

Chcę tylko przeczytać treść tego linku .

Używając artefaktu Maven org.json:jsonotrzymałem następujący kod, który moim zdaniem jest dość krótki. Nie tak krótki, jak to możliwe, ale nadal użyteczny.

package so4308554;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.nio.charset.Charset;

import org.json.JSONException;
import org.json.JSONObject;

public class JsonReader {

  private static String readAll(Reader rd) throws IOException {
    StringBuilder sb = new StringBuilder();
    int cp;
    while ((cp = rd.read()) != -1) {
      sb.append((char) cp);
    }
    return sb.toString();
  }

  public static JSONObject readJsonFromUrl(String url) throws IOException, JSONException {
    InputStream is = new URL(url).openStream();
    try {
      BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
      String jsonText = readAll(rd);
      JSONObject json = new JSONObject(jsonText);
      return json;
    } finally {
      is.close();
    }
  }

  public static void main(String[] args) throws IOException, JSONException {
    JSONObject json = readJsonFromUrl("https://graph.facebook.com/19292868552");
    System.out.println(json.toString());
    System.out.println(json.get("id"));
  }
}

Oto kilka alternatywnych wersji z Jacksonem (ponieważ istnieje więcej niż jeden sposób, w jaki możesz chcieć danych jako):

  ObjectMapper mapper = new ObjectMapper(); // just need one
  // Got a Java class that data maps to nicely? If so:
  FacebookGraph graph = mapper.readValue(url, FaceBookGraph.class);
  // Or: if no class (and don't need one), just map to Map.class:
  Map<String,Object> map = mapper.readValue(url, Map.class);

A konkretnie zwykły przypadek (IMO), w którym chcesz zajmować się obiektami Java, może być utworzony z jednej linijki:

FacebookGraph graph = new ObjectMapper().readValue(url, FaceBookGraph.class);

Inne biblioteki, takie jak Gson, obsługują również metody jednowierszowe; dlaczego wiele przykładów pokazuje, że dłuższe sekcje są dziwne. Co gorsza, wiele przykładów korzysta z przestarzałej biblioteki org.json; być może była to pierwsza rzecz, ale istnieje pół tuzina lepszych alternatyw, więc nie ma powodu, aby z niego korzystać.

Najprostszy sposób: skorzystaj z gson, własnej biblioteki goto json firmy Google. https://code.google.com/p/google-gson/

Oto próbka. Idę na tę darmową stronę geolocatora, analizuję plik Json i wyświetlam mój kod pocztowy. (po prostu umieść to w głównej metodzie, aby to przetestować)

    String sURL = "http://freegeoip.net/json/"; //just a string

    // Connect to the URL using java's native library
    URL url = new URL(sURL);
    URLConnection request = url.openConnection();
    request.connect();

    // Convert to a JSON object to print data
    JsonParser jp = new JsonParser(); //from gson
    JsonElement root = jp.parse(new InputStreamReader((InputStream) request.getContent())); //Convert the input stream to a json element
    JsonObject rootobj = root.getAsJsonObject(); //May be an array, may be an object. 
    String zipcode = rootobj.get("zip_code").getAsString(); //just grab the zipcode

Jeśli nie masz nic przeciwko użyciu kilku bibliotek, możesz to zrobić w jednym wierszu.

Uwzględnij biblioteki Apache Commons IOUtils i json.org .

JSONObject json = new JSONObject(IOUtils.toString(new URL("https://graph.facebook.com/me"), Charset.forName("UTF-8")));

Użyj HttpClient, aby pobrać zawartość adresu URL. A następnie skorzystaj z biblioteki z json.org do parsowania JSON. Korzystałem z tych dwóch bibliotek w wielu projektach, które były niezawodne i łatwe w użyciu.

Poza tym możesz spróbować użyć biblioteki Java API Facebooka. Nie mam doświadczenia w tej dziedzinie, ale pojawia się pytanie o przepełnienie stosu związane z używaniem interfejsu API Facebooka w java . Możesz spojrzeć na RestFB jako dobry wybór dla biblioteki.

Zrobiłem parser json w najprostszy sposób, oto jest

package com.inzane.shoapp.activity;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.json.JSONException;
import org.json.JSONObject;

import android.util.Log;

public class JSONParser {

static InputStream is = null;
static JSONObject jObj = null;
static String json = "";

// constructor
public JSONParser() {

}

public JSONObject getJSONFromUrl(String url) {

    // Making HTTP request
    try {
        // defaultHttpClient
        DefaultHttpClient httpClient = new DefaultHttpClient();
        HttpPost httpPost = new HttpPost(url);

        HttpResponse httpResponse = httpClient.execute(httpPost);
        HttpEntity httpEntity = httpResponse.getEntity();
        is = httpEntity.getContent();

    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

    try {
        BufferedReader reader = new BufferedReader(new InputStreamReader(
                is, "iso-8859-1"), 8);
        StringBuilder sb = new StringBuilder();
        String line = null;
        while ((line = reader.readLine()) != null) {
            sb.append(line + "\n");
            System.out.println(line);
        }
        is.close();
        json = sb.toString();

    } catch (Exception e) {
        Log.e("Buffer Error", "Error converting result " + e.toString());
    }

    // try parse the string to a JSON object
    try {
        jObj = new JSONObject(json);
    } catch (JSONException e) {
        Log.e("JSON Parser", "Error parsing data " + e.toString());
        System.out.println("error on parse data in jsonparser.java");
    }

    // return JSON String
    return jObj;

}
}

ta klasa zwraca obiekt json z adresu URL

a kiedy chcesz obiekt json, po prostu wywołujesz tę klasę i metodę w klasie Activity

mój kod jest tutaj

String url = "your url";
JSONParser jsonParser = new JSONParser();
JSONObject object = jsonParser.getJSONFromUrl(url);
String content=object.getString("json key");

tutaj „klucz json” oznacza ten klucz w pliku json

jest to prosty przykład pliku json

{
    "json":"hi"
}

Tutaj „json” jest kluczem, a „cześć” jest wartością

Spowoduje to, że twoja wartość json zostanie dodana do ciągu.

To bardzo proste, używając klienta Jersey, po prostu uwzględnij tę zależność od maven:

<dependency>
  <groupId>org.glassfish.jersey.core</groupId>
  <artifactId>jersey-client</artifactId>
  <version>2.25.1</version>
</dependency>

Następnie wywołaj go za pomocą tego przykładu:

String json = ClientBuilder.newClient().target("http://api.coindesk.com/v1/bpi/currentprice.json").request().accept(MediaType.APPLICATION_JSON).get(String.class);

Następnie użyj Google Gson, aby przeanalizować JSON:

Gson gson = new Gson();
Type gm = new TypeToken<CoinDeskMessage>() {}.getType();
CoinDeskMessage cdm = gson.fromJson(json, gm);

Jak dotąd uważam, że jest to najłatwiejszy sposób.

Użyj tej metody:

public static String getJSON(String url) {
        HttpsURLConnection con = null;
        try {
            URL u = new URL(url);
            con = (HttpsURLConnection) u.openConnection();

            con.connect();


            BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = br.readLine()) != null) {
                sb.append(line + "\n");
            }
            br.close();
            return sb.toString();


        } catch (MalformedURLException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (con != null) {
                try {
                    con.disconnect();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
        return null;
    }

I użyj tego w ten sposób:

String json = getJSON(url);
JSONObject obj;
   try {
         obj = new JSONObject(json);
         JSONArray results_arr = obj.getJSONArray("results");
         final int n = results_arr.length();
            for (int i = 0; i < n; ++i) {
                // get the place id of each object in JSON (Google Search API)
                String place_id = results_arr.getJSONObject(i).getString("place_id");
            }


   }

Nie jestem pewien, czy jest to skuteczne, ale jest to jeden z możliwych sposobów:

Odczytaj json z adresu URL url.openStream()i wczytaj zawartość do łańcucha.

zbuduj obiekt JSON z tym ciągiem (więcej na json.org )

JSONObject(java.lang.String source)
      Construct a JSONObject from a source JSON text string.

Chciałem tutaj dodać zaktualizowaną odpowiedź, ponieważ (nieco) ostatnie aktualizacje JDK ułatwiły nieco czytanie zawartości adresu URL HTTP. Jak powiedzieli inni, nadal będziesz musiał użyć biblioteki JSON do parsowania, ponieważ JDK obecnie jej nie zawiera. Oto kilka najczęściej używanych bibliotek JSON dla Java:

• org.JSON
• FasterXML Jackson
• GSON

Aby pobrać JSON z adresu URL, wydaje się to najprostszym sposobem przy użyciu ściśle klas JDK (ale prawdopodobnie nie jest to coś, co chciałbyś zrobić dla dużych ładunków), Java 9 wprowadziła: https://docs.oracle.com/en/ java / javase / 11 / docs / api / java.base / java / io / InputStream.html # readAllBytes ()

try(java.io.InputStream is = new java.net.URL("https://graph.facebook.com/me").openStream()) {
    String contents = new String(is.readAllBytes());
}

Aby na przykład przeanalizować JSON przy użyciu biblioteki GSON

com.google.gson.JsonElement element = com.google.gson.JsonParser.parseString(contents); //from 'com.google.code.gson:gson:2.8.6'

Oto pełna próbka sposobu analizowania zawartości Json. Przykład pobiera statystyki wersji Androida (znalezione tutaj w kodzie źródłowym Android Studio , który prowadzi tutaj) ).

Skopiuj pobrany plik stamtąd.json do res / raw, jako kopię zapasową.

build.gradle

    implementation 'com.google.code.gson:gson:2.8.6'

oczywisty

  <uses-permission android:name="android.permission.INTERNET" />

MainActivity.kt

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        if (savedInstanceState != null)
            return
        thread {
            // https://cs.android.com/android/platform/superproject/+/studio-master-dev:tools/adt/idea/android/src/com/android/tools/idea/stats/DistributionService.java
            var root: JsonArray
            Log.d("AppLog", "loading...")
            try {
                HttpURLConnection.setFollowRedirects(true)
                val statsUrl = "https://dl.google.com/android/studio/metadata/distributions.json" //just a string
                val url = URL(statsUrl)
                val request: HttpURLConnection = url.openConnection() as HttpURLConnection
                request.connectTimeout = 3000
                request.connect()
                InputStreamReader(request.content as InputStream).use {
                    root = JsonParser.parseReader(it).asJsonArray
                }
            } catch (e: Exception) {
                Log.d("AppLog", "error while loading from Internet, so using fallback")
                e.printStackTrace()
                InputStreamReader(resources.openRawResource(R.raw.distributions)).use {
                    root = JsonParser.parseReader(it).asJsonArray
                }
            }
            val decimalFormat = DecimalFormat("0.00")
            Log.d("AppLog", "result:")

            root.forEach {
                val androidVersionInfo = it.asJsonObject
                val versionNickName = androidVersionInfo.get("name").asString
                val versionName = androidVersionInfo.get("version").asString
                val versionApiLevel = androidVersionInfo.get("apiLevel").asInt
                val marketSharePercentage = androidVersionInfo.get("distributionPercentage").asFloat * 100f
                Log.d("AppLog", "\"$versionNickName\" - $versionName - API$versionApiLevel - ${decimalFormat.format(marketSharePercentage)}%")
            }
        }
    }
}

Zamiast zależności można także użyć tego:

InputStreamReader(request.content as InputStream).use {
    val jsonArray = JSONArray(it.readText())
}

i awaryjne:

InputStreamReader(resources.openRawResource(R.raw.distributions)).use {
    val jsonArray = JSONArray(it.readText())
}

Wynik uruchomienia tego:

loading...
result:
"Ice Cream Sandwich" - 4.0 - API15 - 0.20%
"Jelly Bean" - 4.1 - API16 - 0.60%
"Jelly Bean" - 4.2 - API17 - 0.80%
"Jelly Bean" - 4.3 - API18 - 0.30%
"KitKat" - 4.4 - API19 - 4.00%
"Lollipop" - 5.0 - API21 - 1.80%
"Lollipop" - 5.1 - API22 - 7.40%
"Marshmallow" - 6.0 - API23 - 11.20%
"Nougat" - 7.0 - API24 - 7.50%
"Nougat" - 7.1 - API25 - 5.40%
"Oreo" - 8.0 - API26 - 7.30%
"Oreo" - 8.1 - API27 - 14.00%
"Pie" - 9.0 - API28 - 31.30%
"Android 10" - 10.0 - API29 - 8.20%