Flyweight Design Pattern

// Flyweight — shared tree type data
public class TreeType {
    private final String name;
    private final String color;
    private final byte[] texture; // Large data — shared!

    public TreeType(String name, String color, byte[] texture) {
        this.name = name;
        this.color = color;
        this.texture = texture;
        System.out.println("Created TreeType: " + name + " (texture: " + texture.length + " bytes)");
    }

    // Operation uses both intrinsic (this) and extrinsic (params) state
    public void draw(int x, int y, int age) {
        System.out.printf("Drawing %s tree at (%d,%d), age=%d, color=%s%n",
                          name, x, y, age, color);
    }

    public String getName() { return name; }
}

// Flyweight Factory — ensures sharing
public class TreeTypeFactory {
    private static final Map<String, TreeType> cache = new HashMap<>();

    public static TreeType getTreeType(String name, String color, byte[] texture) {
        String key = name + "_" + color;

        return cache.computeIfAbsent(key, k -> new TreeType(name, color, texture));
    }

    public static int getCacheSize() {
        return cache.size();
    }
}

// Context — stores extrinsic state + reference to flyweight
public class Tree {
    private final int x;        // extrinsic
    private final int y;        // extrinsic
    private final int age;      // extrinsic
    private final TreeType type; // flyweight reference (intrinsic state)

    public Tree(int x, int y, int age, TreeType type) {
        this.x = x;
        this.y = y;
        this.age = age;
        this.type = type;
    }

    public void draw() {
        type.draw(x, y, age); // Pass extrinsic state to flyweight
    }
}

// Client — the forest
public class Forest {
    private final List<Tree> trees = new ArrayList<>();

    public void plantTree(int x, int y, int age, String name, String color, byte[] texture) {
        TreeType type = TreeTypeFactory.getTreeType(name, color, texture);
        trees.add(new Tree(x, y, age, type));
    }

    public void drawForest() {
        trees.forEach(Tree::draw);
    }

    public static void main(String[] args) {
        Forest forest = new Forest();
        Random random = new Random();

        byte[] oakTexture = new byte[5_000_000];   // 5MB texture
        byte[] pineTexture = new byte[4_000_000];  // 4MB texture
        byte[] birchTexture = new byte[3_000_000]; // 3MB texture

        // Plant 1 million trees — only 3 TreeType objects created!
        for (int i = 0; i < 1_000_000; i++) {
            int x = random.nextInt(10000);
            int y = random.nextInt(10000);
            int age = random.nextInt(100);

            switch (random.nextInt(3)) {
                case 0 -> forest.plantTree(x, y, age, "Oak", "Green", oakTexture);
                case 1 -> forest.plantTree(x, y, age, "Pine", "DarkGreen", pineTexture);
                case 2 -> forest.plantTree(x, y, age, "Birch", "White", birchTexture);
            }
        }

        System.out.println("Trees planted: " + 1_000_000);
        System.out.println("Unique TreeType objects: " + TreeTypeFactory.getCacheSize());
        // Output: Trees planted: 1000000
        // Output: Unique TreeType objects: 3
    }
}

// Flyweight — character glyph
public class CharacterGlyph {
    private final char character;
    private final String font;
    private final int size;
    private final boolean bold;

    public CharacterGlyph(char character, String font, int size, boolean bold) {
        this.character = character;
        this.font = font;
        this.size = size;
        this.bold = bold;
    }

    // Extrinsic state (row, col) passed at render time
    public void render(int row, int col) {
        System.out.printf("'%c' [%s %dpx %s] at (%d,%d)%n",
            character, font, size, bold ? "bold" : "normal", row, col);
    }

    public String getKey() {
        return character + "_" + font + "_" + size + "_" + bold;
    }
}

// Flyweight Factory
public class GlyphFactory {
    private final Map<String, CharacterGlyph> glyphs = new HashMap<>();
    private int creationCount = 0;

    public CharacterGlyph getGlyph(char c, String font, int size, boolean bold) {
        String key = c + "_" + font + "_" + size + "_" + bold;

        if (!glyphs.containsKey(key)) {
            glyphs.put(key, new CharacterGlyph(c, font, size, bold));
            creationCount++;
        }

        return glyphs.get(key);
    }

    public void printStats(int totalCharacters) {
        System.out.println("Total characters in document: " + totalCharacters);
        System.out.println("Unique glyph objects created: " + creationCount);
        System.out.printf("Memory saved: %.1f%%%n",
            (1.0 - (double) creationCount / totalCharacters) * 100);
    }
}

// Usage
public class TextEditor {
    public static void main(String[] args) {
        GlyphFactory factory = new GlyphFactory();
        String document = "Hello World! This is a flyweight demo. Hello again!";
        int totalChars = 0;

        for (int i = 0; i < document.length(); i++) {
            char c = document.charAt(i);
            CharacterGlyph glyph = factory.getGlyph(c, "Arial", 12, false);
            glyph.render(0, i); // row=0, col=i (extrinsic state)
            totalChars++;
        }

        factory.printStats(totalChars);
        // Unique glyph objects: ~20 (unique chars)
        // vs 51 objects without flyweight
    }
}

// Flyweight — database connection wrapper
public class DatabaseConnection {
    private final String url;
    private final String driver;
    private boolean inUse;

    public DatabaseConnection(String url, String driver) {
        this.url = url;
        this.driver = driver;
        this.inUse = false;
        System.out.println("Creating expensive DB connection to: " + url);
        // Simulate expensive connection setup
    }

    public void executeQuery(String query) {
        System.out.println("[" + url + "] Executing: " + query);
    }

    public boolean isInUse() { return inUse; }
    public void acquire() { this.inUse = true; }
    public void release() { this.inUse = false; }
}

// Flyweight Factory — Connection Pool
public class ConnectionPool {
    private final List<DatabaseConnection> pool;
    private final int maxSize;

    public ConnectionPool(String url, String driver, int maxSize) {
        this.maxSize = maxSize;
        this.pool = new ArrayList<>();
        // Pre-create connections (flyweight objects)
        for (int i = 0; i < maxSize; i++) {
            pool.add(new DatabaseConnection(url, driver));
        }
    }

    public synchronized DatabaseConnection acquire() {
        for (DatabaseConnection conn : pool) {
            if (!conn.isInUse()) {
                conn.acquire();
                return conn;
            }
        }
        throw new RuntimeException("Connection pool exhausted! Max: " + maxSize);
    }

    public synchronized void release(DatabaseConnection conn) {
        conn.release();
    }

    public int getActiveCount() {
        return (int) pool.stream().filter(DatabaseConnection::isInUse).count();
    }
}

// Usage
public class App {
    public static void main(String[] args) {
        ConnectionPool pool = new ConnectionPool("jdbc:mysql://localhost/db", "mysql", 5);

        // 1000 queries, only 5 connection objects!
        DatabaseConnection conn = pool.acquire();
        conn.executeQuery("SELECT * FROM users");
        pool.release(conn);

        System.out.println("Active connections: " + pool.getActiveCount());
    }
}