You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

113 lines
3.2 KiB
Markdown

---
name: decompile-classes
description: Decompile Java .class files back to source code. Use when user wants to restore compiled Java projects, reverse engineer class files, or convert bytecode to readable Java source.
version: 1.0.0
---
# Java Class Decompilation Guide
This skill guides the decompilation of Java .class files back to readable source code.
## When to Use
- User has compiled .class files without source code
- User wants to restore a Java project from compiled artifacts
- User needs to understand legacy compiled code
- User wants to reverse engineer a Java application
## Decompilation Process
### Step 1: Assess the Project
Before decompiling, gather information:
```bash
# Count class files
find <classes_dir> -name "*.class" | wc -l
# List package structure
find <classes_dir> -name "*.class" | sed 's|/[^/]*\.class$||' | sort -u
# Check for inner classes
find <classes_dir> -name "*\$*.class" | wc -l
```
### Step 2: Download CFR Decompiler
CFR is the recommended decompiler for modern Java:
```bash
# Download to plugin scripts directory
curl -L -o scripts/cfr.jar https://github.com/leibnitz27/cfr/releases/download/0.152/cfr-0.152.jar
```
### Step 3: Run Batch Decompilation
Use the decompile script:
```bash
bash C:/Users/K/.claude/plugins/cache/claude-plugins-official/plugin-dev/9eae436aa296/scripts/decompile.sh <input_dir> <output_dir>
```
Or decompile individual files:
```bash
java -jar cfr.jar MyClass.class --outputdir ./src
```
### Step 4: Handle Decompilation Issues
Common issues and solutions:
| Issue | Solution |
|-------|----------|
| Enum classes | CFR handles these well by default |
| Lambda expressions | Use `--decodelambdas true` |
| Inner classes | CFR outputs them as separate files |
| Obfuscated code | Use `--renamedupmembers true` |
| Missing dependencies | Add classpath with `--extraclasspath` |
### Step 5: Verify Decompiled Code
After decompilation:
1. Check file count matches original
2. Look for decompilation errors in output
3. Verify package structure is preserved
4. Spot-check complex classes for correctness
## CFR Command Options
```
java -jar cfr.jar <input> [options]
Options:
--outputdir <dir> Output directory
--silent Suppress progress output
--decodelambdas Decode lambda expressions
--decodestringswitch Decode string switches
--decodeswitch Decode switch statements
--renamedupmembers Rename duplicate members
--removeboilerplate Remove boilerplate code
--removeinnerclasses Remove inner class references
--showinferredlambdaithrows Show inferred lambda throws
--extraclasspath <path> Additional classpath for dependencies
```
## Post-Decompilation
After successful decompilation:
1. Run `analyze-structure` to understand the project
2. Run `generate-project` to create Maven/Gradle structure
3. Run `analyze-dependencies` to map dependencies
4. Review and fix any decompilation artifacts
## Tips
- **Large projects**: Process in batches to manage memory
- **Error recovery**: CFR is resilient, but check output for errors
- **Naming conflicts**: Inner classes may cause naming issues
- **Encoding**: Ensure UTF-8 for Chinese/Unicode content
- **Dependencies**: Some classes may reference external JARs