Comment changer déjà compilé.fichier de classe sans décompiler?


Je veux changer .méthode du fichier de classe. J'ai installé JD Eclipse Decompiler et ouvert le .fichier de classe. J'ai ajouté quelques codes et enregistrer .fichier de classe. Mais, .le fichier de classe ne change pas.

Je ne sais pas comment utiliser decompiler. Et si c'est possible, comment faire pour changer .fichier de classe sans utiliser decompiler.

J'utilise Ubuntu.

Cordialement

MODIFIER:

Voici mon code décompilé:

/*     */ package org.hibernate.id;
/*     */ 
/*     */ import java.io.Serializable;
/*     */ import java.sql.ResultSet;
/*     */ import java.sql.SQLException;
/*     */ import java.util.HashMap;
/*     */ import java.util.Properties;
/*     */ import org.apache.commons.logging.Log;
/*     */ import org.apache.commons.logging.LogFactory;
/*     */ import org.hibernate.HibernateException;
/*     */ import org.hibernate.MappingException;
/*     */ import org.hibernate.dialect.Dialect;
/*     */ import org.hibernate.type.Type;
/*     */ import org.hibernate.util.ReflectHelper;
/*     */ 
/*     */ public final class IdentifierGeneratorFactory
/*     */ {
/*  25 */   private static final Log log = LogFactory.getLog(IdentifierGeneratorFactory.class);
/*     */ 
/*  64 */   private static final HashMap GENERATORS = new HashMap();
/*     */ 
/*  66 */   public static final Serializable SHORT_CIRCUIT_INDICATOR = new Serializable() {
/*     */     public String toString() { return "SHORT_CIRCUIT_INDICATOR";
/*     */     }
/*  66 */   };
/*     */ 
/*  70 */   public static final Serializable POST_INSERT_INDICATOR = new Serializable() {
/*     */     public String toString() { return "POST_INSERT_INDICATOR";
/*     */     }
/*  70 */   };
/*     */ 
/*     */   public static Serializable getGeneratedIdentity(ResultSet rs, Type type)
/*     */     throws SQLException, HibernateException, IdentifierGenerationException
/*     */   {
/*  32 */     if (!(rs.next())) {
/*  33 */       throw new HibernateException("The database returned no natively generated identity value");
/*     */     }
/*  35 */     Serializable id = get(rs, type);
/*     */ 
/*  37 */     if (log.isDebugEnabled()) log.debug("Natively generated identity: " + id);
/*  38 */     return id;
/*     */   }
/*     */ 
/*     */   public static Serializable get(ResultSet rs, Type type)
/*     */     throws SQLException, IdentifierGenerationException
/*     */   {
/*  45 */     Class clazz = type.getReturnedClass();
/*  46 */     if (clazz == Long.class) {
/*  47 */       return new Long(rs.getLong(1));
/*     */     }
/*  49 */     if (clazz == Integer.class) {
/*  50 */       return new Integer(rs.getInt(1));
/*     */     }
/*  52 */     if (clazz == Short.class) {
/*  53 */       return new Short(rs.getShort(1));
/*     */     }
/*  55 */     if (clazz == String.class) {
/*  56 */       return rs.getString(1);
/*     */     }
                if(clazz == java.math.BigDecimal.class){
                    return rs.getBigDecimal(1);
                }
/*     */ 
/*  59 */     throw new IdentifierGenerationException("this id generator generates long, integer, short or string78");
/*     */   }
/*     */ 
/*     */   public static IdentifierGenerator create(String strategy, Type type, Properties params, Dialect dialect)
/*     */     throws MappingException
/*     */   {
/*     */     try
/*     */     {
/*  92 */       Class clazz = getIdentifierGeneratorClass(strategy, dialect);
/*  93 */       IdentifierGenerator idgen = (IdentifierGenerator)clazz.newInstance();
/*  94 */       if (idgen instanceof Configurable) ((Configurable)idgen).configure(type, params, dialect);
/*  95 */       return idgen;
/*     */     }
/*     */     catch (Exception e) {
/*  98 */       throw new MappingException("could not instantiate id generator", e);
/*     */     }
/*     */   }
/*     */ 
/*     */   public static Class getIdentifierGeneratorClass(String strategy, Dialect dialect) {
/* 103 */     Class clazz = (Class)GENERATORS.get(strategy);
/* 104 */     if ("native".equals(strategy)) clazz = dialect.getNativeIdentifierGeneratorClass();
/*     */     try {
/* 106 */       if (clazz == null) clazz = ReflectHelper.classForName(strategy);
/*     */     }
/*     */     catch (ClassNotFoundException e) {
/* 109 */       throw new MappingException("could not interpret id generator strategy: " + strategy);
/*     */     }
/* 111 */     return clazz;
/*     */   }
/*     */ 
/*     */   public static Number createNumber(long value, Class clazz) throws IdentifierGenerationException {
/* 115 */     if (clazz == Long.class) {
/* 116 */       return new Long(value);
/*     */     }
/* 118 */     if (clazz == Integer.class) {
/* 119 */       return new Integer((int)value);
/*     */     }
/* 121 */     if (clazz == Short.class) {
/* 122 */       return new Short((short)(int)value);
/*     */     }

/*     */ 
/* 125 */     throw new IdentifierGenerationException("this id generator generates long, integer, short");
/*     */   }
/*     */ 
/*     */   static
/*     */   {
/*  75 */     GENERATORS.put("uuid", UUIDHexGenerator.class);
    GENERATORS.put("hilo", TableHiLoGenerator.class);
     GENERATORS.put("assigned", Assigned.class);
     GENERATORS.put("identity", IdentityGenerator.class);
    GENERATORS.put("select", SelectGenerator.class);
    GENERATORS.put("sequence", SequenceGenerator.class);
     GENERATORS.put("seqhilo", SequenceHiLoGenerator.class);
    GENERATORS.put("increment", IncrementGenerator.class);
   GENERATORS.put("foreign", ForeignGenerator.class);
     GENERATORS.put("guid", GUIDGenerator.class);
     GENERATORS.put("uuid.hex", UUIDHexGenerator.class);
     GENERATORS.put("sequence-identity", SequenceIdentityGenerator.class);
   }
 }
Author: Breed Hansen, 2012-12-28

9 answers

, Vous pouvez suivre ces étapes pour modifier votre classe java:

  1. Décompiler le .classez le fichier comme vous l'avez fait et enregistrez-le sous .java
  2. Créer un projet dans Eclipse avec ce fichier java, le JAR d'origine comme bibliothèque, et toutes ses dépendances
  3. Changer le .java et compiler
  4. Obtenir le modifié .class file et le remettre à l'intérieur de l'original POT.
 41
Author: izaera, 2012-12-29 18:49:20

Utilisez un éditeur de bytecode, comme:

Http://set.ee/jbe/

Soyez prudent car vous avez besoin d'une très bonne connaissance du bytecode Java.

Vous pouvez également modifier la classe à l'exécution avec le tissage de bytecode (comme AspectJ).

 14
Author: Lakatos Gyula, 2018-03-08 07:59:18

J'ai ajouté quelques codes et enregistrer .fichier de classe.

Ce que vous voyez dans le décompilateur JD EClipse est une représentation décompilée du code octet dans le .fichier de classe. Même si vous modifiez le texte, cela n'affectera pas le code octet.

 3
Author: Nikolay Kuznetsov, 2012-12-28 11:52:07

Lorsque vous décompilez et modifiez le code, vous devez aller dans le dossier racine de votre projet eclipse et vérifier votre classe dans le dossier bin qui est au même niveau que src. ensuite, ouvrez votre pot d'origine avec l'outil zip ( 7zip est bon pour cela ) et mettez la classe modifiée dans le même paquet à l'intérieur du pot.

 2
Author: abk, 2013-06-07 13:14:28

Utiliser java aider bibliothèque Java pour manipuler le bytecode Java (.la classe file) d'une application.

-> Spring, Hibernate, EJB utilisant ceci pour l'implémentation de proxy

- > nous pouvons manipuler le bytecode pour faire une analyse de programme

-> nous pouvons utiliser Javassist pour implémenter un cache transparent pour les valeurs de retour de méthode, en interceptant toutes les invocations de méthode et en ne déléguant à la super implémentation que lors de la première invocation.

 1
Author: Opster Elasticsearch Pro-Vijay, 2017-03-17 06:38:52

Vous pouvez utiliser n'importe quel décompilateur pour décompiler d'abord le fichier.

J'avais déjà fait face à un problème similaire où je n'avais pas de code source de l'application et je devais apporter une très petite modification dans un fichier.

Ci-Dessous est ce que j'ai fait:

  1. Extrait le fichier de classe à partir du pot

  2. Ouvert dans un décompilateur (j'utilise JD GUI, vous pouvez l'obtenir facilement de nombreuses ressources sur internet) Vous pouvez le télécharger à partir de ici

  3. Vous pouvez réellement afficher tous les fichiers dans un fichier jar à l'aide de l'interface graphique JD.

  4. Apporté des modifications au fichier que je voulais et copié tout le code de ce fichier
  5. A créé un nouveau projet dans eclipse avec uniquement cette classe (avec la même structure de paquet que dans le jar ), fourni le jar d'origine comme bibliothèque et toutes les autres dépendances.
  6. Compilé la classe, injecté le .classe fichier vers le bocal de dossier bin de mon espace de travail
  7. Testé mon changement, célébré en sirotant une tasse de café :)
 1
Author: user2280507, 2017-06-08 08:56:00

, Vous pouvez modifier le code décompilé, mais il doit être recompilé pour un class, le fichier decompiler sorties java le code, ce doit être recompilé avec la même classpath que l'original jar/class fichier

 0
Author: epoch, 2012-12-28 11:51:52

Parfois, nous devons compiler un seul fichier sur mille fichiers pour résoudre le problème. Dans un tel cas, On peut créer la même structure de dossier comme chemin de classe, décompiler le fichier en java ou copier le fichier java à partir du code source. Apportez les modifications requises, compilez un fichier particulier en classe avec toutes les dépendances/classes en place et enfin remplacez le fichier de classe. Enfin, redémarrez le conteneur. Une fois que la guerre est éclatée fichier ne sera pas remplacé.

 0
Author: Harish Arora, 2017-08-23 05:28:57

Pour autant que j'ai pu le découvrir, il n'y a pas de moyen simple de le faire. Le moyen le plus simple est de ne pas réellement convertir le fichier de classe en un exécutable, mais d'envelopper un lanceur exécutable autour du fichier de classe. Autrement dit, créez un fichier exécutable (peut-être un fichier de script exécutable basé sur le système d'exploitation) qui appelle simplement la classe Java via la ligne de commande.

Si vous voulez réellement avoir un programme qui le fait, vous devriez examiner certains des installateurs automatisés y.

Voici un moyen que j'ai trouvé:

[code]
import java.io.*;
import java.util.jar.*;

class OnlyExt implements FilenameFilter{
String ext;
public OnlyExt(String ext){
this.ext="." + ext;
}

@Override
public boolean accept(File dir,String name){
return name.endsWith(ext);
}
}

public class ExeCreator {
public static int buffer = 10240;
protected void create(File exefile, File[] listFiles) {
try {
byte b[] = new byte[buffer];
FileOutputStream fout = new FileOutputStream(exefile);
JarOutputStream out = new JarOutputStream(fout, new Manifest());
for (int i = 0; i < listFiles.length; i++) {
if (listFiles[i] == null || !listFiles[i].exists()|| listFiles[i].isDirectory())
System.out.println("Adding " + listFiles[i].getName());
JarEntry addFiles = new JarEntry(listFiles[i].getName());
addFiles.setTime(listFiles[i].lastModified());
out.putNextEntry(addFiles);

FileInputStream fin = new FileInputStream(listFiles[i]);
while (true) {
int len = fin.read(b, 0, b.length);
if (len <= 0)
break;
out.write(b, 0, len);
}
fin.close();
}
out.close();
fout.close();
System.out.println("Jar File is created successfully.");
} catch (Exception ex) {}
}

public static void main(String[]args){
ExeCreator exe=new ExeCreator();
FilenameFilter ff = new OnlyExt("class");
File folder = new File("./examples");
File[] files = folder.listFiles(ff);
File file=new File("examples.exe");
exe.create(file, files);
}

}


[/code]`
 -1
Author: kytuni, 2014-06-29 22:52:27