JAR Files

// ── JAR contents (viewed with jar tf myapp.jar or unzip -l): ─────────
//
//  META-INF/
//  META-INF/MANIFEST.MF
//  META-INF/services/
//  META-INF/services/javax.annotation.processing.Processor
//  com/
//  com/example/
//  com/example/service/
//  com/example/service/OrderService.class
//  com/example/service/UserService.class
//  com/example/model/
//  com/example/model/Order.class
//  com/example/model/User.class
//  application.properties
//  db/migration/V1__create_tables.sql
//  templates/email/welcome.html
//  static/images/logo.png

// ── Loading resources from a JAR at runtime: ─────────────────────────
// Resources are loaded via ClassLoader — searches classpath including JARs:
InputStream config = getClass()
    .getResourceAsStream("/application.properties");

// With leading slash — searches from root of classpath:
InputStream template = getClass()
    .getResourceAsStream("/templates/email/welcome.html");

// Without leading slash — relative to current class's package:
InputStream query = OrderService.class
    .getResourceAsStream("queries.sql");
// searches: com/example/service/queries.sql in any JAR on classpath

// ── Listing JAR contents from command line: ───────────────────────────
// jar tf myapp.jar                 — list all files in jar
// jar xf myapp.jar                 — extract all files
// jar xf myapp.jar META-INF/MANIFEST.MF  — extract specific file
// unzip -l myapp.jar               — list with sizes (Unix)
// unzip -p myapp.jar META-INF/MANIFEST.MF  — print file content

// ── Create a JAR from compiled class files: ──────────────────────────
// Assume .class files are in the 'out/' directory:

// Basic JAR — no manifest:
// jar cf myapp.jar -C out .
//   c = create
//   f = output file name follows
//   -C out = change to 'out' directory
//   . = include everything from there

// JAR with custom manifest:
// jar cfm myapp.jar META-INF/MANIFEST.MF -C out .
//   m = manifest file follows (after the JAR filename)

// Executable JAR with main class specified via -e flag:
// jar cfe myapp.jar com.example.Main -C out .
//   e = entry point (main class) follows

// Verbose output:
// jar cvf myapp.jar -C out .
//   v = verbose: prints each added file

// ── Viewing JAR contents: ────────────────────────────────────────────
// jar tf myapp.jar               — table of contents (list files)
// jar tvf myapp.jar              — verbose listing with sizes
// jar tf myapp.jar | grep ".class" — show only class files

// ── Extracting from a JAR: ────────────────────────────────────────────
// jar xf myapp.jar                            — extract all
// jar xf myapp.jar META-INF/MANIFEST.MF       — extract one file

// ── Adding a JAR to the classpath: ───────────────────────────────────
// java -cp myapp.jar:lib/gson.jar com.example.Main         (Unix)
// java -cp myapp.jar;libgson.jar com.example.Main         (Windows)
// java -cp "lib/*" com.example.Main                        — all JARs in lib/

// ── Running an executable JAR: ───────────────────────────────────────
// java -jar myapp.jar
// java -jar myapp.jar arg1 arg2    — with command line arguments
// java -Xmx512m -jar myapp.jar    — with JVM flags

// ── Maven creates a JAR with: mvn package ─────────────────────────────
// Output: target/myapp-1.0.0.jar (thin JAR, no dependencies)
//
// For fat JAR with Spring Boot:
// mvn spring-boot:repackage  or  mvn package (if spring-boot plugin configured)
// Output: target/myapp-1.0.0.jar  (fat JAR — includes all dependencies)

// ── Fat JAR — everything bundled: ────────────────────────────────────
//
//  myapp-1.0.0-fat.jar contents:
//  META-INF/MANIFEST.MF
//  com/example/service/OrderService.class       ← your code
//  com/example/model/Order.class                ← your code
//  com/google/gson/Gson.class                   ← Gson dependency
//  org/springframework/web/...                  ← Spring dependency
//  ch/qos/logback/...                           ← Logback dependency
//  application.properties                       ← your resources

// ── Classpath declaration: ───────────────────────────────────────────
// Single JAR:
// java -cp myapp.jar com.example.Main

// Multiple JARs and directories:
// java -cp "classes:lib/gson.jar:lib/logback.jar" com.example.Main

// All JARs in a directory (Java 6+):
// java -cp "classes:lib/*" com.example.Main

// ── Classpath shadowing — order matters: ──────────────────────────────
// If both these JARs contain com.google.gson.Gson:
// java -cp "lib/gson-2.8.jar:lib/gson-2.10.jar" com.example.Main
// → gson-2.8.jar Gson is loaded (first in classpath)

// ── Loading resources — classpath search: ────────────────────────────
// getResourceAsStream searches classpath entries in order,
// just like class loading:

public class Config {
    public static Properties load() throws IOException {
        Properties props = new Properties();

        // Searches each classpath entry for "config.properties"
        // at the root level:
        try (InputStream is = Config.class
                .getClassLoader()
                .getResourceAsStream("config.properties")) {
            if (is == null) {
                throw new IOException("config.properties not found on classpath");
            }
            props.load(is);
        }
        return props;
    }
}

// ── ClassLoader hierarchy: ────────────────────────────────────────────
ClassLoader app      = Main.class.getClassLoader();
ClassLoader platform = app.getParent();
ClassLoader boot     = platform.getParent();   // null — bootstrap CL
System.out.println(app.getClass().getName());     // jdk.internal.loader.ClassLoaders$AppClassLoader

// ── Maven dependency resolution (no classpath shadowing issues): ──────
// Maven selects the nearest version in the dependency tree.
// pom.xml:
// <dependencies>
//   <dependency>
//     <groupId>com.google.code.gson</groupId>
//     <artifactId>gson</artifactId>
//     <version>2.10.1</version>    ← explicit version — no ambiguity
//   </dependency>
// </dependencies>