mac - java decompiler

¿Cómo cambiar el archivo.class ya compilado sin descompilar?

Question

Quiero cambiar el método de archivo .class. Instalé JD Eclipse Decompiler y abrí el archivo .class. Agregué algunos códigos y guardo el archivo .class. Pero, el archivo .class no está cambiando.

No sé cómo usar el descompilador. Y si es posible, cómo cambiar el archivo .class sin usar el descompilador.

Estoy usando Ubuntu.

Saludos

EDITAR:

Aquí está mi código descompilado:

/* */ 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

Agregué algunos códigos y guardo el archivo .class.

Lo que ve en JD EClipse Decompiler es una representación descompilada del código de byte en el archivo .class. Aunque cambie el texto, no afectará al código de byte.

Answer 2

En algún momento necesitamos compilar un solo archivo de mil archivos para solucionar el problema. En tal caso, Uno puede crear la misma estructura de carpetas como la ruta de clase, descompilar el archivo en java o copiar el archivo java del código fuente. Realice los cambios necesarios, compile un archivo particular en clase con todas las dependencias / clases en su lugar y finalmente reemplace el archivo de clase. Finalmente reinicie el contenedor. Una vez que explote la guerra, el archivo no será reemplazado.

Answer 3

Por lo que he podido descubrir, no hay una forma sencilla de hacerlo. La forma más fácil es no convertir realmente el archivo de clase en un ejecutable, sino envolver un lanzador ejecutable alrededor del archivo de clase. Es decir, cree un archivo ejecutable (tal vez un archivo de scripting ejecutable basado en el sistema operativo) que simplemente invoque la clase Java a través de la línea de comandos.

Si realmente quieres tener un programa que lo haga, deberías mirar algunos de los instaladores automáticos que hay.

Aquí hay una manera que he encontrado:

[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 4

Puede cambiar el código cuando lo descompiló, pero tiene que volver a compilarlo en un archivo de class , el descompilador genera código java , este debe ser recompilado con la misma ruta de class archivo jar / class original.

Answer 5

Puedes seguir estos pasos para modificar tu clase java:

1. Descompile el archivo .class como lo ha hecho y guárdelo como .java
2. Cree un proyecto en Eclipse con ese archivo java, el JAR original como biblioteca y todas sus dependencias
3. Cambia el .java y compila.
4. Obtenga el archivo .class modificado y vuelva a colocarlo dentro del JAR original.

Answer 6

Puedes usar cualquier descompilador para primero descompilar el archivo.

Una vez tuve un problema similar en el que no tenía el código fuente de la aplicación y tuve que hacer un pequeño cambio en un archivo.

A continuación se muestra lo que hice:

1. Extrae el archivo de clase del jar

2. Lo abrí en un descompilador (uso JD GUI, puede obtenerlo fácilmente desde muchos recursos en internet) Puede descargarlo desde here

3. Realmente puedes ver todos los archivos en un jar usando la GUI de JD.

4. Realicé cambios en el archivo que quería y copié todo el código de ese archivo
5. Creó un nuevo proyecto en eclipse con solo esta clase ( con la misma estructura de paquetes que en el jar ), siempre que el jar original fuera la biblioteca y todas las demás dependencias.
6. Compilé la clase, inyecté el archivo .class de nuevo en el contenedor desde la carpeta bin de mi área de trabajo
7. Probé mi cambio, lo celebré tomando una taza de café :)

Answer 7

Utilice la biblioteca Java de Java Assist para manipular el código de bytes de Java (archivo .class) de una aplicación.

-> Spring, Hibernate, EJB usando esto para la implementación de proxy

-> Podemos manipular códigos de bytes para hacer un análisis del programa.

-> podemos usar Javassist para implementar un caché transparente para los valores de retorno de método, interceptando todas las invocaciones de método y delegando solo a la super implementación en la primera invocación.

Answer 8

Utilice un editor de código de bytes, como:

http://set.ee/jbe/

Tenga cuidado porque necesita un buen conocimiento del código de bytes de Java.

También puede cambiar la clase en tiempo de ejecución con el tejido de bytecode (como AspectJ).

Answer 9

cuando descompiles y cambias el código, debes ir a la carpeta raíz de tu proyecto de eclipse y revisar tu clase en la carpeta bin que está en el mismo nivel que src. luego, abra el frasco original con la herramienta zip ( 7zip es bueno para eso) y coloque la clase modificada en el mismo paquete dentro del frasco.