• J’utilise depuis un bon moment les Gson mais depuis hier, plus rien ne marche pour une raison inconnue :

    :::
    exception ExceptInInitializerError at Gson.fromJson(JsonReader, Type) (com.google.gson.Gson:820)
    :::

    Voilà ma classe principale (désolé pour le désordre) :

    package fr.scarex.updater;
    
    import java.io.InputStream;
    import java.lang.reflect.Method;
    import java.lang.reflect.Type;
    import java.net.HttpURLConnection;
    import java.net.MalformedURLException;
    import java.net.Proxy;
    import java.net.URL;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Comparator;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map.Entry;
    import java.util.TreeMap;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    import net.minecraft.client.Minecraft;
    import net.minecraftforge.common.MinecraftForge;
    import net.minecraftforge.fml.common.Loader;
    import net.minecraftforge.fml.common.Mod;
    import net.minecraftforge.fml.common.ModContainer;
    import net.minecraftforge.fml.common.event.FMLInitializationEvent;
    
    import org.apache.commons.io.Charsets;
    import org.apache.commons.io.IOUtils;
    import org.apache.commons.lang3.ArrayUtils;
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    
    import com.google.gson.Gson;
    import com.google.gson.GsonBuilder;
    import com.google.gson.JsonArray;
    import com.google.gson.JsonDeserializationContext;
    import com.google.gson.JsonDeserializer;
    import com.google.gson.JsonElement;
    import com.google.gson.JsonObject;
    import com.google.gson.JsonParseException;
    
    import fr.scarex.updater.exception.VersionFormatException;
    import fr.scarex.updater.handler.UpdaterHandler;
    
    @Mod(modid = Updater.MODID, name = Updater.NAME, version = Updater.VERSION, clientSideOnly = true)
    public class Updater
    {
    public static final String MODID = "supdater";
    public static final String NAME = "Updater";
    public static final String VERSION = "0.1.0-SNAPSHOT";
    
    public static final Logger logger = LogManager.getLogger("Updater");
    
    public static Gson gson;
    
    public static Version mcversion;
    
    @Mod.EventHandler
    public void init(FMLInitializationEvent event) {
    MinecraftForge.EVENT_BUS.register(new UpdaterHandler());
    doUpdate();
    }
    
    public static ArrayList <modversions>modsList = new ArrayList<updater.modversions>();
    
    public String getVersionFileURL() {
    return "http://scarex.on.vg/Updater/versions.json";
    }
    
    public String getUpdaterVersion() {
    return Updater.VERSION;
    }
    
    public static void doUpdate() {
    Thread t = new Thread("Updater Thread") {
    @Override
    public void run() {
    try {
    mcversion = Version.parseMcVersion();
    } catch (VersionFormatException e1) {
    e1.printStackTrace();
    }
    GsonBuilder builder = new GsonBuilder();
    builder.registerTypeAdapter(Version.class, new VersionDeserializer());
    builder.registerTypeAdapter(ModVersions.class, new ModVersionsDeserializer());
    gson = builder.create();
    
    modsList.clear();
    for (ModContainer mod : Loader.instance().getModList()) {
    if (mod.getMod() != null) {
    Class clazz = mod.getMod().getClass();
    if (!clazz.getCanonicalName().startsWith("net.minecraft")) {
    try {
    String rawVersion;
    Version currentVersion;
    try {
    Method versionMethod = clazz.getDeclaredMethod("getUpdaterVersion");
    rawVersion = (String) versionMethod.invoke(mod.getMod());
    currentVersion = Version.parseVersion(rawVersion);
    } catch (Exception e) {
    rawVersion = mod.getVersion();
    currentVersion = Version.parseVersion(rawVersion);
    }
    String stringUrl = (String) clazz.getDeclaredMethod("getVersionFileURL").invoke(mod.getMod());
    URL versionFile = new URL(stringUrl);
    
    InputStream is = null;
    try {
    HttpURLConnection con = (HttpURLConnection) versionFile.openConnection(Proxy.NO_PROXY);
    con.setConnectTimeout(15000);
    con.setReadTimeout(15000);
    
    is = con.getInputStream();
    ModVersions modV = gson.fromJson(IOUtils.toString(is, Charsets.UTF_8), ModVersions.class);
    modV.setModContainer(mod);
    modV.setVersionFileLink(stringUrl);
    modV.setCurrentVersion(currentVersion);
    modsList.add(modV);
    } catch (Exception e) {
    logger.warn("Couldn't get version file with given url : " + versionFile, e);
    }
    IOUtils.closeQuietly(is);
    } catch (Exception e) {
    logger.warn("Couldn't retrieve mod's informations from mod " + mod.getName() + "(" + clazz.getCanonicalName() + ")", e);
    }
    }
    }
    }
    }
    };
    t.start();
    }
    
    public static class ModVersions
    {
    public static final Comparator <string>comparator = new Comparator<string>() {
    @Override
    public int compare(String s, String s1) {
    try {
    return Version.parseVersion(s).isNewerOrEqualWithSameIndex(mcversion, 1) ? (Version.parseVersion(s1).isNewerOrEqualWithSameIndex(mcversion, 1) ? s.compareTo(s1) : 1) : -1;
    } catch (VersionFormatException e) {
    e.printStackTrace();
    }
    return 0;
    }
    };
    public static final Pattern PARAMETERS_FINDER = Pattern.compile("{{(.+)}}");
    private ModContainer modContainer;
    private String versionFileLink;
    private String downloadLink;
    private TreeMap <string, version[]="">versions;
    private Version currentVersion;
    
    public ModVersions(ModContainer modC, String modid, String versionFile, String dlink, TreeMap <string, version[]="">versions, Version currentV) {
    this.modContainer = modC;
    this.versionFileLink = versionFile;
    this.downloadLink = dlink;
    this.versions = versions;
    this.currentVersion = currentV;
    }
    
    public ModVersions(String dlink, TreeMap <string, version[]="">versions) {
    this.downloadLink = dlink;
    this.versions = versions;
    }
    
    public Version getLatestVersionForUser(byte usertype, boolean acceptSnapshots) {
    Entry <string, version[]="">entry = this.versions.lastEntry();
    if ((entry.getKey().substring(0, 3)).equalsIgnoreCase(Minecraft.getMinecraft().getVersion().substring(0, 3))) {
    Version[] versions = entry.getValue();
    Version version = versions[0];
    for (int i = 0; i < versions.length; i++) {
    if (versions*.isNewerThanOrEqual(version) && versions*.getUserType() == usertype && (versions*.isSnapshot() && acceptSnapshots)) version = versions*;
    }
    return version;
    }
    return null;
    }
    
    public URL getDownloadLinkForVersion(Version v, String mcversion) {
    String beginning = this.versionFileLink.replaceFirst("/(*)$", "");
    String middle = this.downloadLink != null ? this.downloadLink : "";
    String end = v.getDownloadLink() != null ? v.getDownloadLink() : "";
    logger.info(beginning + " | " + middle + " | " + end);
    String fullURL = "";
    if (v.getDownloadLink().startsWith("http://") || v.getDownloadLink().startsWith("https://")) {
    fullURL = v.getDownloadLink();
    } else {
    if (middle.startsWith("http://") || middle.startsWith("https://"))
    fullURL = middle + end;
    else
    fullURL = beginning + middle + end;
    }
    StringBuffer sb = new StringBuffer(fullURL);
    Matcher m = PARAMETERS_FINDER.matcher(fullURL);
    while (m.find()) {
    if ("name".equalsIgnoreCase(m.group(1)))
    m.appendReplacement(sb, v.getName());
    else if ("version".equalsIgnoreCase(m.group(1)))
    m.appendReplacement(sb, v.getVersionString());
    else if ("user-type".equalsIgnoreCase(m.group(1)))
    m.appendReplacement(sb, "" + v.getUserType());
    else if ("importance".equalsIgnoreCase(m.group(1)))
    m.appendReplacement(sb, "" + v.getImportance());
    else if ("mc-version".equalsIgnoreCase(m.group(1))) m.appendReplacement(sb, mcversion);
    }
    m.appendTail(sb);
    logger.info(sb.toString());
    URL url = null;
    try {
    url = new URL(sb.toString());
    } catch (MalformedURLException e) {
    logger.warn(e);
    }
    return url;
    }
    
    public ModContainer getModContainer() {
    return this.modContainer;
    }
    
    public void setModContainer(ModContainer modC) {
    this.modContainer = modC;
    }
    
    public String getVersionFileLink() {
    return versionFileLink;
    }
    
    public void setVersionFileLink(String versionFileLink) {
    this.versionFileLink = versionFileLink;
    }
    
    public Version getCurrentVersion() {
    return currentVersion;
    }
    
    public void setCurrentVersion(Version currentVersion) {
    this.currentVersion = currentVersion;
    }
    
    public TreeMap <string, version[]="">getVersions() {
    return versions;
    }
    
    public void setVersions(TreeMap <string, version[]="">versions) {
    this.versions = versions;
    }
    
    @Override
    public String toString() {
    return "ModVersions [modContainer=" + modContainer + ", versionFileLink=" + versionFileLink + ", downloadLink=" + downloadLink + "]";
    }
    
    public String getMapAsString() {
    Iterator ite = versions.entrySet().iterator();
    String output = "";
    while (ite.hasNext()) {
    Entry <string, version[]="">entry = (Entry<string, updater.version[]="">) ite.next();
    output += "[Mc-version=" + entry.getKey() + ", versions=" + Arrays.toString(entry.getValue()) + "]\n";
    }
    return output;
    }
    }
    
    public static class Version implements Comparable <version>{
    private static final Pattern pattern = Pattern.compile("(?i)(\\d+)((?:\\.\\d+)*)([a-zA-Z])?(-snapshot)?");
    private static final Pattern patternMC = Pattern.compile("(?i)(\\d+)((?:\\.\\d+)*)([a-z- ]*)");
    private String name;
    private String changes;
    private String downloadLink;
    private String versionString;
    private int[] releases;
    private char releaseChar;
    private boolean snapshot;
    private byte userType;
    private byte importance;
    
    public Version(String versionS, char releaseChar, boolean snapshot, int … releases) {
    this.versionString = versionS;
    this.releaseChar = releaseChar;
    this.snapshot = snapshot;
    this.releases = releases;
    }
    
    public boolean isNewerThanOrEqual(Version v) {
    if (v.getLength() > this.getLength())
    return false;
    else if (v.getLength() < this.getLength()) return true;
    for (int i = 0; i < this.getLength(); i++) {
    if (v.getIndex(i) > this.getIndex(i))
    return false;
    else if (v.getIndex(i) < this.getIndex(i)) return true;
    }
    if (v.getReleaseChar() < this.getReleaseChar()) return true;
    return true;
    }
    
    public boolean isNewerOrEqualWithSameIndex(Version v, int index) {
    for (int i = 0; i <= index; i++) {
    if (v.getIndex(i) != this.getIndex(i)) return false;
    }
    for (int i = index + 1; i < Math.min(this.getLength(), v.getLength()); i++) {
    if (this.getIndex(i) < v.getIndex(i)) return false;
    }
    return true;
    }
    
    @Override
    public int compareTo(Version v) {
    return this.isNewerThanOrEqual(v) ? -1 : 1;
    }
    
    public static Version parseVersion(String version) throws VersionFormatException {
    Matcher m = pattern.matcher(version);
    if (m.matches()) {
    List <integer>list = new ArrayList<integer>();
    list.add(new Integer(m.group(1)));
    String[] array = m.group(2).split("\\.");
    for (int i = 1; i < array.length; i++) {
    list.add(Integer.parseInt(array*));
    }
    char c = m.group(3) != null && m.group(3).length() == 1 && Character.isAlphabetic(m.group(3).charAt(0)) ? m.group(3).charAt(0) : 'a';
    boolean snapshot = "-snapshot".equalsIgnoreCase(m.group(4)) ? true : false;
    return new Version(version, c, snapshot, ArrayUtils.toPrimitive(list.toArray(new Integer[0])));
    } else {
    throw new VersionFormatException(version);
    }
    }
    
    public static Version parseMcVersion() throws VersionFormatException {
    Matcher m = patternMC.matcher(Minecraft.getMinecraft().getVersion());
    if (m.matches()) {
    List <integer>list = new ArrayList<integer>();
    list.add(new Integer(m.group(1)));
    String[] array = m.group(2).split("\\.");
    for (int i = 1; i < array.length; i++) {
    list.add(Integer.parseInt(array*));
    }
    return new Version(Minecraft.getMinecraft().getVersion(), 'a', false, ArrayUtils.toPrimitive(list.toArray(new Integer[0])));
    } else {
    throw new VersionFormatException(Minecraft.getMinecraft().getVersion());
    }
    }
    
    public int getIndex(int i) {
    return this.releases*;
    }
    
    public int getLength() {
    return this.releases.length;
    }
    
    public String getName() {
    return name;
    }
    
    public void setName(String name) {
    this.name = name;
    }
    
    public char getReleaseChar() {
    return releaseChar;
    }
    
    public void setReleaseChar(char releaseChar) {
    this.releaseChar = releaseChar;
    }
    
    public boolean isSnapshot() {
    return snapshot;
    }
    
    public void setSnapshot(boolean snapshot) {
    this.snapshot = snapshot;
    }
    
    public byte getUserType() {
    return userType;
    }
    
    public void setUserType(byte userType) {
    this.userType = userType;
    }
    
    public String getChanges() {
    return changes;
    }
    
    public void setChanges(String changes) {
    this.changes = changes;
    }
    
    public String getDownloadLink() {
    return downloadLink;
    }
    
    public void setDownloadLink(String downloadLink) {
    this.downloadLink = downloadLink;
    }
    
    public byte getImportance() {
    return importance;
    }
    
    public void setImportance(byte importance) {
    this.importance = importance;
    }
    
    public String getVersionString() {
    return versionString;
    }
    
    public void setVersionString(String versionString) {
    this.versionString = versionString;
    }
    
    @Override
    public String toString() {
    return "Version [name=" + name + ", releases=" + Arrays.toString(releases) + ", releaseChar=" + releaseChar + ", snapshot=" + snapshot + ", userType=" + userType + "]";
    }
    
    public String toName() {
    String output = "";
    for (int i = 0; i < releases.length - 1; i++) {
    output += releases* + ".";
    }
    return output + releases[releases.length - 1] + (releaseChar == 'a' ? "" : releaseChar) + (snapshot ? "-snapshot" : "");
    }
    }
    
    public static class VersionDeserializer implements JsonDeserializer <version>{
    @Override
    public Version deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext ctx) throws JsonParseException {
    JsonObject obj = json.getAsJsonObject();
    Version version = null;
    try {
    version = Version.parseVersion(obj.get("version").getAsString());
    } catch (VersionFormatException e) {
    throw new JsonParseException("version couldn't be deserialized");
    }
    String name = obj.has("name") ? obj.get("name").getAsString() : "";
    version.setName(name);
    
    byte usertype = obj.has("user-type") ? obj.get("user-type").getAsByte() : 0;
    version.setUserType(usertype);
    
    String changes = obj.has("changes") ? obj.get("changes").getAsString() : "";
    version.setChanges(changes);
    
    byte imp = obj.has("importance") ? obj.get("importance").getAsByte() : 0;
    version.setImportance(imp);
    
    String dl = obj.has("download-link") ? obj.get("download-link").getAsString() : "";
    version.setDownloadLink(dl);
    return version;
    }
    }
    
    public static class ModVersionsDeserializer implements JsonDeserializer <modversions>{
    @Override
    public ModVersions deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext ctx) throws JsonParseException {
    JsonObject obj = json.getAsJsonObject();
    
    TreeMap <string, version[]="">map = new TreeMap<string, version[]="">(ModVersions.comparator);
    String dlink = obj.has("download-link") ? obj.get("download-link").getAsString() : "";
    
    JsonObject mcvobj = obj.get("mc-versions").getAsJsonObject();
    Iterator ite = mcvobj.entrySet().iterator();
    while (ite.hasNext()) {
    Entry <string, jsonelement="">entry = (Entry<string, jsonelement="">) ite.next();
    JsonArray jarray = entry.getValue().getAsJsonArray();
    
    Version[] versions = new Version[jarray.size()];
    Iterator ite1 = jarray.iterator();
    int i = 0;
    while (ite1.hasNext()) {
    JsonObject vobj = (JsonObject) ite1.next();
    versions* = ctx. <version>deserialize(vobj, Version.class);
    i++;
    }
    Arrays.sort(versions);
    map.put(entry.getKey(), versions);
    }
    return new ModVersions(dlink, map);
    }
    }
    }
    ```</version></string,></string,></string,></string,></modversions></version></integer></integer></integer></integer></version></string,></string,></string,></string,></string,></string,></string,></string,></string></string></updater.modversions></modversions>
  • Administrateurs Rédacteurs Moddeurs confirmés

    Erreur complète ?
    Avec juste une ligne ça va être compliqué, le stacktrace entier serait la bienvenue.


  • @‘robin4002’:

    Erreur complète ?
    Avec juste une ligne ça va être compliqué, le stacktrace entier serait la bienvenue.

    J’aimerais bien mais il n’y a pas de stacktrace car l’erreur ne peux pas être retenue par un bloque try/catch, le seul stacktrace que j’ai c’est celui du mod debug d’Eclipse.

    Voilà le plus complet que je peux faire :

    :::

    Thread [Updater Thread] (Suspended (exception ExceptionInInitializerError))
    Gson.fromJson(JsonReader, Type) line: 820
    Gson.fromJson(Reader, Type) line: 768
    Gson.fromJson(String, Type) line: 717
    Gson.fromJson(String, Class<t>) line: 689
    Updater$1.run() line: 114
    :::

    Ce stacktrace montre une ExceptionInInitializerError lorsque je le lance au début, mais lorsque j’appelle la fonction doUpdate() d’une autre classe, le stacktrace montre NoClassDefFoundError au même endroit.</t>

  • Administrateurs Rédacteurs Moddeurs confirmés

    L’erreur est ici :                                     ModVersions modV = gson.fromJson(IOUtils.toString(is, Charsets.UTF_8), ModVersions.class);
    Peut-être ta classe ModVersions n’est pas bonne ?


  • @‘robin4002’:

    L’erreur est ici :                                     ModVersions modV = gson.fromJson(IOUtils.toString(is, Charsets.UTF_8), ModVersions.class);
    Peut-être ta classe ModVersions n’est pas bonne ?

    C’est à dire pas bonne ? j’ai essaye en mettant gson. <modversions>fromJson(IOUtils.toString(is, Charsets.UTF_8), ModVersions.class) mais ça ne marche toujours pas.</modversions>

  • Administrateurs Rédacteurs Moddeurs confirmés

    J’ai jamais utilisé Gson, faudrait que tu vérifies la doc.


  • @‘robin4002’:

    J’ai jamais utilisé Gson, faudrait que tu vérifies la doc.

    J’ai cherché sur google sur une vingtaine de sites avec plusieurs recherches mais les personnes qui avaient ce problème venait de leur buildpath, or je n’ai jamais changé le buildpath depuis et je vois pas vraiment comment je pourrais le corriger.