Flyweight Pattern – Optymalizacja Pamięci w Javie

## Dlaczego Flyweight jest ważny?

W aplikacjach biznesowych często mamy do czynienia z tysiącami podobnych obiektów – produkty w sklepie internetowym, użytkownicy w systemie CRM, czy elementy interfejsu. Bez optymalizacji każdy obiekt konsumuje pamięć na dane, które mogą być współdzielone. Flyweight rozwiązuje ten problem, co przekłada się bezpośrednio na niższe koszty serwerów i lepszą wydajność aplikacji.

## Czym jest wzorzec Flyweight?

Flyweight to strukturalny wzorzec projektowy, który minimalizuje zużycie pamięci poprzez współdzielenie efektywnie danych wspólnych dla wielu obiektów. Zamiast przechowywać wszystkie dane w każdym obiekcie, wydzielamy:

## Implementacja w Javie – Przykład Praktyczny

Załóżmy, że tworzymy system zarządzania dokumentami w firmie. Mamy tysiące dokumentów, ale tylko kilka typów (PDF, DOC, XLS) z różnymi nazwami i rozmiarami.

### Krok 1: Interfejs Flyweight

// Intrinsic state - współdzielony między wszystkimi dokumentami tego typu
public interface DocumentType {
    void process(String fileName, int fileSize); // extrinsic state jako parametry
}

### Krok 2: Konkretne implementacje Flyweight

public class PdfDocumentType implements DocumentType {
    private final String typeIcon; // intrinsic state
    private final String defaultViewer; // intrinsic state
    
    public PdfDocumentType() {
        this.typeIcon = "pdf-icon.png";
        this.defaultViewer = "Adobe Reader";
        System.out.println("Utworzono PdfDocumentType flyweight");
    }
    
    @Override
    public void process(String fileName, int fileSize) {
        System.out.println(String.format(
            "Przetwarzanie PDF: %s (%d KB) z ikoną %s w %s",
            fileName, fileSize, typeIcon, defaultViewer
        ));
    }
}

public class WordDocumentType implements DocumentType {
    private final String typeIcon;
    private final String defaultViewer;
    
    public WordDocumentType() {
        this.typeIcon = "word-icon.png";
        this.defaultViewer = "Microsoft Word";
        System.out.println("Utworzono WordDocumentType flyweight");
    }
    
    @Override
    public void process(String fileName, int fileSize) {
        System.out.println(String.format(
            "Przetwarzanie Word: %s (%d KB) z ikoną %s w %s",
            fileName, fileSize, typeIcon, defaultViewer
        ));
    }
}

### Krok 3: Factory dla zarządzania Flyweight’ami

import java.util.HashMap;
import java.util.Map;

public class DocumentTypeFactory {
    private static final Map flyweights = new HashMap<>();
    
    public static DocumentType getDocumentType(String type) {
        DocumentType flyweight = flyweights.get(type);
        
        if (flyweight == null) {
            switch (type.toLowerCase()) {
                case "pdf":
                    flyweight = new PdfDocumentType();
                    break;
                case "doc":
                case "docx":
                    flyweight = new WordDocumentType();
                    break;
                default:
                    throw new IllegalArgumentException("Nieobsługiwany typ: " + type);
            }
            flyweights.put(type, flyweight);
        }
        
        return flyweight;
    }
    
    public static int getCreatedFlyweightsCount() {
        return flyweights.size();
    }
}

### Krok 4: Kontekst wykorzystujący Flyweight

public class Document {
    private final String fileName; // extrinsic state
    private final int fileSize; // extrinsic state
    private final DocumentType type; // reference do flyweight
    
    public Document(String fileName, int fileSize, String fileType) {
        this.fileName = fileName;
        this.fileSize = fileSize;
        this.type = DocumentTypeFactory.getDocumentType(fileType);
    }
    
    public void process() {
        type.process(fileName, fileSize);
    }
}

## Praktyczne zastosowanie

public class DocumentManagementSystem {
    public static void main(String[] args) {
        List documents = Arrays.asList(
            new Document("raport-q4.pdf", 2048, "pdf"),
            new Document("prezentacja.pdf", 5120, "pdf"),
            new Document("umowa.docx", 512, "docx"),
            new Document("notatki.doc", 256, "doc"),
            new Document("analiza.pdf", 3072, "pdf")
        );
        
        System.out.println("=== Przetwarzanie dokumentów ===" );
        documents.forEach(Document::process);
        
        System.out.println(String.format(
            "\\nUtworzono %d flyweight'ów dla %d dokumentów",
            DocumentTypeFactory.getCreatedFlyweightsCount(),
            documents.size()
        ));
    }
}

## Korzyści i wady wzorca

### Korzyści:
– **Dramatyczna redukcja pamięci** – szczególnie przy tysiącach obiektów
– **Lepsza wydajność cache** – mniej obiektów = lepsze wykorzystanie CPU cache
– **Centralne zarządzanie** – wspólne właściwości w jednym miejscu

### Wady:
– **Zwiększona złożoność kodu** – podział na stan intrinsic/extrinsic
– **Możliwe problemy z wielowątkowością** – współdzielone obiekty wymagają synchronizacji
– **Overhead na wywołania metod** – przekazywanie extrinsic state jako parametry

## Kiedy stosować Flyweight?

## Zastosowania w prawdziwych projektach

### 1. Systemy GUI
Swing w Javie używa Flyweight dla renderowania znaków – każda litera „A” ma współdzieloną reprezentację graficzną, ale różne pozycje na ekranie.

### 2. Gry komputerowe
Cząsteczki, drzewa, budynki – wszystko co występuje w dużych ilościach z podobnymi właściwościami.

### 3. Systemy e-commerce
Produkty w tej samej kategorii dzielą metadane (ikony, opisy kategorii), różnią się tylko ceną i nazwą.