如何更改已编译的.class文件反编译没有？(How to change already compi

我想改变的.class文件的方法。 我安装了JD的Eclipse反编译，打开.class文件。 我加了一些代码，并保存.class文件。 但是，.class文件没有改变。

我不知道如何使用反编译。 而如果是有可能，如何改变.class文件，而无需使用反编译。

我使用Ubuntu。

问候

编辑：

这里是我的反编译的代码：

/*     */ 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);
   }
 }

Answer 1:

您可以按照下列步骤来修改你的java类：

1. 反编译.class文件，你所做的和将其保存为的.java
2. 在Eclipse中创建与Java文件的一个项目，原来的JAR图书馆，和所有依赖
3. 更改的.java和编译
4. 获取修改后的.class文件，并把它再次原来的JAR内。

Answer 2:

使用字节码编辑器，如：

http://set.ee/jbe/

要小心，因为你需要的Java字节码的一个很好的知识。

您还可以在字节码编织（如AspectJ的）运行时更改类。

Answer 3:

我加了一些代码，并保存.class文件。

您在JD日食闪客看到什么是反编译的.class文件的字节码表示。 即使您更改文本也不会影响字节码。

Answer 4:

当你反编译，改变你必须去对你的Eclipse项目的根文件夹，并检查您的bin文件夹至极类的代码是在同一水平上的SRC。 然后打开你原来的罐子zip工具（ 7zip的是适合这种模式），并把修改后的类在临同一个包罐内。

Answer 5:

使用Java帮助 Java库，用于操纵应用程序的Java字节码（.class文件）。

- > spring，hibernate的，EJB使用本作代理实现

- >我们可以字节码操作，做一些程序分析

- >我们可以用了Javassist来实施方法的返回值的透明缓存，拦截所有的方法调用，只委托给第一次调用超级实现。

Answer 6:

您可以更改代码，当你反编译它，但它已被重新编译的class文件，反编译器输出java代码，这必须与同一类路径的原始重新编译jar / class文件

Answer 7:

据我已经能够找出来，有没有简单的方法来做到这一点。 最简单的办法就是不要在类文件转换为实际的可执行文件，但环绕类文件的可执行发射。 也就是说，创建一个可执行文件（可能是基于操作系统的，可执行的脚本文件），它只是通过命令行调用Java类。

如果你想真正有一个程序，这样做，你应该考虑一些自动安装在那里。

这里是我已经找到一种方法：

[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]`

Answer 8:

你可以使用任何反编译器来编译第一文件。

我曾经遇到一个呈三角问题，我没有足够的应用程序的源代码，并不得不作出在文件中的变化非常小。

下面是我做的：

1. 提取从罐子的类文件

2. 打开了它在反编译器（我用JD GUI，可以从互联网上的许多资源很容易得到它）你可以从下载它这里

3. 实际上，你可以查看使用JD GUI一个罐子中的所有文件。

4. 做出改变，我想该文件，并从该文件复制所有的代码
5. 创建Eclipse的一个新项目，只有这个类（ 具有相同的封装结构的罐子 ），提供的原始罐子为图书馆和所有其他的依赖。
6. 编译类，从我的工作空间的bin文件夹中注入的.class文件回到罐子
7. 测试了我的变化，喝着一杯咖啡庆祝吧:)

Answer 9:

有时我们需要编译一个单一的文件出万个文件来解决这个问题。 在这种情况下，人们可以创建相同的文件夹结构等类路径，反编译该文件为Java或从源代码复制Java文件。 做必要的更改，编译一个特定的文件到类全部到位依赖性/类和最终替换类文件。 最后重新启动容器。 一旦战争爆炸文件不会被取代。

文章来源: How to change already compiled .class file without decompile?