Supponiamo di avere un file con contenuti JSON nella cartella delle risorse non elaborate nella mia app. Come posso leggerlo nell'app, in modo da poter analizzare il JSON?
Risposte:
Vedi openRawResource . Qualcosa di simile dovrebbe funzionare:
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();
\res\json_file.json
cartella o dentro \res\raw\json_file.json
?
getResources()
chiamare? Dove dovrebbe andare il file di risorse raw? Quale convenzione dovresti seguire per assicurarti che gli strumenti di compilazione vengano creati R.raw.json_file
?
Kotlin è ora la lingua ufficiale per Android, quindi penso che sarebbe utile per qualcuno
val text = resources.openRawResource(R.raw.your_text_file)
.bufferedReader().use { it.readText() }
Ho usato la risposta di @ kabuko per creare un oggetto che viene caricato da un file JSON, utilizzando Gson , dalle risorse:
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);
}
}
Per usarlo, dovresti fare qualcosa come il seguente (l'esempio è in un 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);
}
implementation 'com.google.code.gson:gson:2.8.5'
Da http://developer.android.com/guide/topics/resources/providing-resources.html :
File raw / arbitrari da salvare nella loro forma grezza. Per aprire queste risorse con un InputStream grezzo, chiama Resources.openRawResource () con l'ID risorsa, che è R.raw.filename.Tuttavia, se hai bisogno di accedere ai nomi di file originali e alla gerarchia dei file, potresti considerare di salvare alcune risorse nella directory assets / (invece di res / raw /). Ai file negli asset / non viene assegnato un ID risorsa, quindi puoi leggerli solo utilizzando AssetManager.
Come afferma @mah, la documentazione di Android ( https://developer.android.com/guide/topics/resources/providing-resources.html ) dice che i file json possono essere salvati nella directory / raw sotto / res (risorse) directory nel tuo progetto, ad esempio:
MyProject/
src/
MyActivity.java
res/
drawable/
graphic.png
layout/
main.xml
info.xml
mipmap/
icon.png
values/
strings.xml
raw/
myjsonfile.json
All'interno di un Activity
, è possibile accedere al file json tramite la R
classe (Resources) e leggere in una stringa:
Context context = this;
Inputstream inputStream = context.getResources().openRawResource(R.raw.myjsonfile);
String jsonString = new Scanner(inputStream).useDelimiter("\\A").next();
Questo utilizza la classe Java Scanner
, portando a meno righe di codice rispetto ad altri metodi di lettura di un semplice file di testo / json. Il modello delimitatore \A
significa "l'inizio dell'input". .next()
legge il token successivo, che in questo caso è l'intero file.
Esistono diversi modi per analizzare la stringa json risultante:
optString(String name)
, optInt(String name)
ecc metodi, non i getString(String name)
, getInt(String name)
metodi, poiché i opt
metodi restituiscono null anziché un'eccezione in caso di fallimento.import java.util.Scanner; import java.io.InputStream; import android.content.Context;
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");
Utilizzando:
String json_string = readRawResource(R.raw.json)
Funzioni:
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() : "";
}
Ho trovato questa risposta dello snippet di Kotlin molto utile ♥ ️
Mentre la domanda originale chiedeva di ottenere una stringa JSON, immagino che alcuni potrebbero trovarlo utile. Un ulteriore passo avanti Gson
porta a questa piccola funzione di tipo reificato:
private inline fun <reified T> readRawJson(@RawRes rawResId: Int): T {
resources.openRawResource(rawResId).bufferedReader().use {
return gson.fromJson<T>(it, object: TypeToken<T>() {}.type)
}
}
Nota che vuoi usare TypeToken
non solo T::class
così se leggi un fileList<YourType>
non perderai il tipo per cancellazione del tipo.
Con l'inferenza del tipo puoi quindi usare in questo modo:
fun pricingData(): List<PricingData> = readRawJson(R.raw.mock_pricing_data)