Verwenden der JSON-Datei in Android App-Ressourcen

Angenommen, ich habe eine Datei mit JSON-Inhalten im Rohressourcenordner meiner App. Wie kann ich dies in die App einlesen, damit ich den JSON analysieren kann?

Siehe openRawResource . So etwas sollte funktionieren:

InputStream is = getResources().openRawResource(R.raw.json_file);
Writer writer = new StringWriter();
char[] buffer = new char[1024];
try {
    Reader reader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
    int n;
    while ((n = reader.read(buffer)) != -1) {
        writer.write(buffer, 0, n);
    }
} finally {
    is.close();
}

String jsonString = writer.toString();

Kotlin ist jetzt die offizielle Sprache für Android, daher denke ich, dass dies für jemanden nützlich wäre

val text = resources.openRawResource(R.raw.your_text_file)
                                 .bufferedReader().use { it.readText() }

Ich habe die Antwort von @ kabuko verwendet, um ein Objekt zu erstellen, das aus einer JSON-Datei mit Gson aus den Ressourcen geladen wird:

package com.jingit.mobile.testsupport;

import java.io.*;

import android.content.res.Resources;
import android.util.Log;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;


/**
 * An object for reading from a JSON resource file and constructing an object from that resource file using Gson.
 */
public class JSONResourceReader {

    // === [ Private Data Members ] ============================================

    // Our JSON, in string form.
    private String jsonString;
    private static final String LOGTAG = JSONResourceReader.class.getSimpleName();

    // === [ Public API ] ======================================================

    /**
     * Read from a resources file and create a {@link JSONResourceReader} object that will allow the creation of other
     * objects from this resource.
     *
     * @param resources An application {@link Resources} object.
     * @param id The id for the resource to load, typically held in the raw/ folder.
     */
    public JSONResourceReader(Resources resources, int id) {
        InputStream resourceReader = resources.openRawResource(id);
        Writer writer = new StringWriter();
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(resourceReader, "UTF-8"));
            String line = reader.readLine();
            while (line != null) {
                writer.write(line);
                line = reader.readLine();
            }
        } catch (Exception e) {
            Log.e(LOGTAG, "Unhandled exception while using JSONResourceReader", e);
        } finally {
            try {
                resourceReader.close();
            } catch (Exception e) {
                Log.e(LOGTAG, "Unhandled exception while using JSONResourceReader", e);
            }
        }

        jsonString = writer.toString();
    }

    /**
     * Build an object from the specified JSON resource using Gson.
     *
     * @param type The type of the object to build.
     *
     * @return An object of type T, with member fields populated using Gson.
     */
    public <T> T constructUsingGson(Class<T> type) {
        Gson gson = new GsonBuilder().create();
        return gson.fromJson(jsonString, type);
    }
}

Um es zu verwenden, würden Sie Folgendes tun (das Beispiel befindet sich in einem InstrumentationTestCase):

   @Override
    public void setUp() {
        // Load our JSON file.
        JSONResourceReader reader = new JSONResourceReader(getInstrumentation().getContext().getResources(), R.raw.jsonfile);
        MyJsonObject jsonObj = reader.constructUsingGson(MyJsonObject.class);
   }

Von http://developer.android.com/guide/topics/resources/providing-resources.html :

Raw /
Arbitrary-Dateien, die in ihrer Raw-Form gespeichert werden sollen. Um diese Ressourcen mit einem unformatierten InputStream zu öffnen, rufen Sie Resources.openRawResource () mit der Ressourcen-ID R.raw.filename auf.

Wenn Sie jedoch Zugriff auf die ursprünglichen Dateinamen und die Dateihierarchie benötigen, können Sie einige Ressourcen im Verzeichnis resources / (anstelle von res / raw /) speichern. Dateien in Assets / erhalten keine Ressourcen-ID, sodass Sie sie nur mit AssetManager lesen können.

Wie in @mah angegeben, heißt es in der Android-Dokumentation ( https://developer.android.com/guide/topics/resources/providing-resources.html ), dass JSON-Dateien möglicherweise im Verzeichnis / raw unter / res (resources) gespeichert werden. Verzeichnis in Ihrem Projekt, zum Beispiel:

MyProject/
  src/ 
    MyActivity.java
  res/
    drawable/ 
        graphic.png
    layout/ 
        main.xml
        info.xml
    mipmap/ 
        icon.png
    values/ 
        strings.xml
    raw/
        myjsonfile.json

Innerhalb von Activitykann auf die json-Datei über die RKlasse (Resources) zugegriffen und in einen String eingelesen werden:

Context context = this;
Inputstream inputStream = context.getResources().openRawResource(R.raw.myjsonfile);
String jsonString = new Scanner(inputStream).useDelimiter("\\A").next();

Dies verwendet die Java-Klasse Scanner, was zu weniger Codezeilen führt als einige andere Methoden zum Lesen einer einfachen Text- / JSON-Datei. Das Begrenzungsmuster \Abedeutet "der Beginn der Eingabe". .next()liest das nächste Token, in diesem Fall die gesamte Datei.

Es gibt mehrere Möglichkeiten, die resultierende JSON-Zeichenfolge zu analysieren:

• Verwenden Sie Java / Android, das in JSONObject- und JSONArray- Objekten integriert ist, wie hier: JSON-Array-Iteration in Android / Java . Es kann zweckmäßig sein Strings zu bekommen, ganze Zahlen usw. unter Verwendung des optString(String name), optInt(String name)usw. Methoden, nicht die getString(String name), getInt(String name)Methoden, weil die optMethoden null anstelle einer Ausnahme bei Versagen zurück.
• Verwenden Sie eine Java / Android-JSON-Serialisierungs- / Deserialisierungsbibliothek wie die hier angegebene: https://medium.com/@IlyaEremin/android-json-parsers-comparison-2017-8b5221721e31

InputStream is = mContext.getResources().openRawResource(R.raw.json_regions);
                            int size = is.available();
                            byte[] buffer = new byte[size];
                            is.read(buffer);
                            is.close();
                           String json = new String(buffer, "UTF-8");

Verwenden von:

String json_string = readRawResource(R.raw.json)

Funktionen:

public String readRawResource(@RawRes int res) {
    return readStream(context.getResources().openRawResource(res));
}

private String readStream(InputStream is) {
    Scanner s = new Scanner(is).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

Fand diese Kotlin Snippet Antwort sehr hilfreich ♥ ️

Während die ursprüngliche Frage gestellt wurde, um einen JSON-String zu erhalten, denke ich, dass einige dies nützlich finden könnten. Ein weiterer Schritt mit Gsonführt zu dieser kleinen Funktion mit reifiziertem Typ:

private inline fun <reified T> readRawJson(@RawRes rawResId: Int): T {
    resources.openRawResource(rawResId).bufferedReader().use {
        return gson.fromJson<T>(it, object: TypeToken<T>() {}.type)
    }
}

Beachten Sie, dass Sie TypeTokennicht nur verwenden möchten, um beim T::classLesen von a List<YourType>die Löschung von Typ zu Typ nicht zu verlieren.

Mit der Typinferenz können Sie dann wie folgt verwenden:

fun pricingData(): List<PricingData> = readRawJson(R.raw.mock_pricing_data)