Ik wil de methode van het .class-bestand wijzigen. Ik heb JD Eclipse Decompiler geïnstalleerd en het .class-bestand geopend. Ik heb een aantal codes toegevoegd en het .class-bestand opgeslagen. Maar het .class-bestand verandert niet.
Ik weet niet hoe ik decompiler moet gebruiken. En als het mogelijk is, hoe het .class-bestand te wijzigen zonder decompiler te gebruiken.
Ik gebruik Ubuntu.
Met vriendelijke groet
BEWERKEN:
Hier is mijn gedecompileerde code:
/* */ 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);
}
}
Antwoord 1, autoriteit 100%
U kunt deze stappen volgen om uw Java-klasse aan te passen:
- Decompileer het .class-bestand zoals u hebt gedaan en sla het op als .java
- Maak een project in Eclipse met dat java-bestand, de originele JAR
als bibliotheek, en al zijn afhankelijkheden - Verander de .java en compileer
- Haal het gewijzigde .class-bestand op en plaats het opnieuw in het origineel
JAR.
Antwoord 2, autoriteit 34%
Gebruik een bytecode-editor, zoals:
Wees voorzichtig, want je hebt een zeer goede kennis van de Java-bytecode nodig.
Je kunt de klasse ook tijdens runtime wijzigen met bytecode weven (zoals AspectJ).
Antwoord 3, autoriteit 7%
Ik heb wat codes toegevoegd en het .class-bestand opgeslagen.
Wat u ziet in JD EClipse Decompiler is een gedecompileerde weergave van bytecode in het .class-bestand. Ook al verander je de tekst, dit heeft geen invloed op de bytecode.
Antwoord 4, autoriteit 5%
wanneer je de code decompileert en wijzigt, moet je naar de hoofdmap van je eclipse-project gaan en je klasse controleren in de bin-map die zich op hetzelfde niveau als src bevindt. open vervolgens je originele pot met zip-tool ( 7zip is daar goed voor) en plaats de gewijzigde klasse in tha hetzelfde pakket in de pot.
Antwoord 5, autoriteit 2%
Gebruik java assist Java-bibliotheek voor het manipuleren van de Java-bytecode (.class-bestand) van een toepassing.
-> Spring , Hibernate , EJB gebruiken dit voor proxy-implementatie
-> we kunnen bytecode-manipulatie doen om wat programma-analyse uit te voeren
-> we kunnen Javassist gebruiken om een transparante cache voor methoderetourwaarden te implementeren, door alle methodeaanroepen te onderscheppen en alleen te delegeren aan de superimplementatie bij de eerste aanroep.
Antwoord 6, autoriteit 2%
U kunt elke decompiler gebruiken om het bestand eerst te decompileren.
Ik had ooit een soortgelijk probleem gehad waarbij ik de broncode van de applicatie niet had en een heel kleine wijziging in een bestand moest aanbrengen.
Hieronder is wat ik deed:
-
Het klassenbestand uit de pot gehaald
-
Geopend in een decompiler (ik gebruik JD GUI, je kunt het gemakkelijk uit veel bronnen op internet halen)
Je kunt het hier -
Je kunt alle bestanden in een pot bekijken met JD GUI.
- Wijzigingen aangebracht in het bestand dat ik wilde en alle code uit dat bestand gekopieerd
- Een nieuw project in eclipse gemaakt met alleen deze klasse (met dezelfde pakketstructuur als in de jar), met de originele jar als bibliotheek en alle andere afhankelijkheden.
- De klasse gecompileerd, het .class-bestand terug in de jar geïnjecteerd vanuit de bin-map van mijn werkruimte
- Mijn wisselgeld getest, gevierd met een kopje koffie 🙂
Antwoord 7
U kunt de code wijzigen wanneer u deze hebt gedecompileerd, maar deze moet opnieuw worden gecompileerd naar een class-bestand, de decompiler voert java-code uit, dit moet opnieuw worden gecompileerd met hetzelfde klassenpad als het originele bestand jar/class
Antwoord 8
Soms moeten we één enkel bestand van duizend bestanden compileren om het probleem op te lossen. In zo’n geval kan men dezelfde mapstructuur maken, zoals het klassenpad, het bestand decompileren naar java of het java-bestand kopiëren van de broncode. Breng de vereiste wijzigingen aan, compileer een bepaald bestand in klasse met alle afhankelijkheid/klassen op hun plaats en vervang tenslotte het klassenbestand. Herstart ten slotte de container. Zodra de oorlog is geëxplodeerd, wordt het bestand niet vervangen.
Antwoord 9
Voor zover ik heb kunnen achterhalen, is er geen eenvoudige manier om dit te doen. De eenvoudigste manier is om het klassenbestand niet daadwerkelijk om te zetten in een uitvoerbaar bestand, maar om een uitvoerbaar opstartprogramma rond het klassenbestand te plaatsen. Dat wil zeggen, maak een uitvoerbaar bestand (misschien een op het besturingssysteem gebaseerd, uitvoerbaar scriptbestand) dat eenvoudig de Java-klasse aanroept via de opdrachtregel.
Als je echt een programma wilt hebben dat dit doet, moet je kijken naar enkele van de geautomatiseerde installatieprogramma’s die er zijn.
Dit is een manier die ik heb gevonden:
[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]`