The wiki page is under active construction, expect bugs.

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
statnice:bakalar:b6b36omo [2025/06/12 11:45] – [Behavioral design patterns] prokopstatnice:bakalar:b6b36omo [2025/06/13 07:31] (current) – [Structural design patterns: adapter, proxy, bridge, composite, facade, decorator, flyweight] prokop
Line 395: Line 395:
 </code> </code>
  
-{{statnice:bakalar:omofprototype.png?700}}+{{statnice:bakalar:omoprototype.png?700}}
  
 === Builder === === Builder ===
Line 582: Line 582:
  
 {{statnice:bakalar:sinfacade.png?500}} {{statnice:bakalar:sinfacade.png?500}}
 +
 +=== Composite Design Pattern ===
 +
 + * Účel:
 +  * Umožňuje jednotné zacházení s **jednotlivými objekty** i s **jejich složením (stromová struktura)**.
 +  * Používá se pro reprezentaci **hierarchických struktur** (např. souborový systém, GUI komponenty, organizace).
 +
 + * Struktura:
 +  * **Component** – společné rozhraní pro listy i složené objekty.
 +  * **Leaf** – jednoduchý objekt (např. soubor).
 +  * **Composite** – složený objekt (např. složka obsahující další objekty).
 +
 + * Výhody:
 +  * Rekurzivní zpracování hierarchických struktur.
 +  * Klientský kód se nemusí starat, zda pracuje s listem nebo composite – volá jednotné metody.
 +  * Umožňuje dynamicky přidávat/odebírat prvky.
 +
 +=== Příklad použití: souborový systém ===
 +
 +<code java>
 +  interface FileSystemItem {
 +    void display(String indent);
 +  }
 +
 +  class File implements FileSystemItem {
 +    private String name;
 +
 +    public File(String name) {
 +        this.name = name;
 +    }
 +
 +    public void display(String indent) {
 +        System.out.println(indent + "- File: " + name);
 +    }
 +  }
 +
 +  class Folder implements FileSystemItem {
 +    private String name;
 +    private List<FileSystemItem> children = new ArrayList<>();
 +
 +    public Folder(String name) {
 +        this.name = name;
 +    }
 +
 +    public void add(FileSystemItem item) {
 +        children.add(item);
 +    }
 +
 +    public void display(String indent) {
 +        System.out.println(indent + "+ Folder: " + name);
 +        for (FileSystemItem item : children) {
 +            item.display(indent + "  ");
 +        }
 +    }
 +  }
 +
 +  public class CompositeDemo {
 +    public static void main(String[] args) {
 +        Folder root = new Folder("root");
 +        root.add(new File("readme.txt"));
 +
 +        Folder src = new Folder("src");
 +        src.add(new File("Main.java"));
 +        src.add(new File("Utils.java"));
 +
 +        root.add(src);
 +        root.display("");
 +    }
 +  }
 +</code>
  
 === Decorator === === Decorator ===
Line 1179: Line 1249:
  
 === Interpreter === === Interpreter ===
-  * Vyhodnocuje výrazy v definovaném jazyce (např. matematický jazyk). +  * Definuje jazyk (syntaxi + sémantiku) pomocí tříd. 
-  * Každý prvek jazyka má vlastní třídu.+  * Každý prvek výrazu má svou třídu. 
 +  * Používá se k implementaci jednoduchých jazyků, výrazů, konfigurací, pravidel. 
 +  * Struktura: 
 +    * `Expression` – rozhraní nebo abstraktní třída pro všechny výrazy. 
 +    * `TerminalExpression` – konkrétní výrazy (proměnné, konstanty). 
 +    * `NonTerminalExpression` – operace (např. sčítání, odečítání). 
 +    * `Context` – mapa proměnných (např. {"x" → 10})
 <code java> <code java>
-   Expression exp = new Plus( +   // Rozhraní pro výraz 
-       new Variable("w"), +   public interface Expression { 
-       new Minus( +       int interpret(Map<String, Integer> context); 
-           new Variable("x"), +   } 
-           new Variable("z") + 
-       ) +   // Terminální výraz – proměnná 
-   ); +   public class Variable implements Expression { 
-   Map<String, Integer> context = Map.of("w", 6, "x", 30, "z", 8); +       private String name; 
-   int result = exp.evaluate(context);  // výsledek: 6 + (30 - 8)+ 
 +       public Variable(String name) { 
 +           this.name = name; 
 +       } 
 + 
 +       public int interpret(Map<String, Integer> context) { 
 +           return context.get(name); 
 +       } 
 +   } 
 + 
 +   // Non-terminal – součet 
 +   public class Plus implements Expression { 
 +       private Expression left, right; 
 + 
 +       public Plus(Expression left, Expression right) { 
 +           this.left = left; 
 +           this.right = right; 
 +       } 
 + 
 +       public int interpret(Map<String, Integer> context) { 
 +           return left.interpret(context) + right.interpret(context); 
 +       } 
 +   } 
 + 
 +   // Non-terminal – rozdíl 
 +   public class Minus implements Expression { 
 +       private Expression left, right; 
 + 
 +       public Minus(Expression left, Expression right) { 
 +           this.left = left; 
 +           this.right = right; 
 +       } 
 + 
 +       public int interpret(Map<String, Integer> context) { 
 +           return left.interpret(context) - right.interpret(context); 
 +       } 
 +   } 
 + 
 +   // Ukázka použití 
 +   public class InterpreterDemo { 
 +       public static void main(String[] args) { 
 +           Expression expr = new Plus( 
 +               new Variable("x"), 
 +               new Minus( 
 +                   new Variable("y"), 
 +                   new Variable("z") 
 +               ) 
 +           ); 
 + 
 +           Map<String, Integer> context = Map.of("x", 5, "y", 10, "z", 3); 
 +           int result = expr.interpret(context); // 5 + (10 - 3) = 12 
 + 
 +           System.out.println("Výsledek: " + result); 
 +       } 
 +   }
 </code> </code>
-{{:statnice:bakalar:omointerpreter.png?700}}+{{:statnice:bakalar:omointerpreter.png?500}}
  
 ===== Datové struktury a patterny: lazy loading, object pool, cache map, filter, reduce pattern ===== ===== Datové struktury a patterny: lazy loading, object pool, cache map, filter, reduce pattern =====
 +
 +=== Lazy Loading ===
 +  * Odložené načtení dat z paměti, databáze nebo vzdáleného zdroje.
 +  * Zvyšuje efektivitu, pokud některá data nejsou vždy potřeba.
 +  * Čtyři hlavní implementace:
 +    * **Virtual Proxy** – místo objektu se vrací proxy, která objekt načte při prvním použití.
 +    * **Lazy Initialization** – načítání na základě podmínky `if (obj == null)`.
 +    * **Ghost** – objekt se načítá po částech podle potřeby (např. jen ID, pak detaily).
 +    * **Value Holder** – objekt zabalený v obalu, který řídí načtení hodnoty.
 +
 +<code java>
 +   public class Company {
 +       private ContactList contacts;
 +
 +       public ContactList getContacts() {
 +           if (contacts == null) {
 +               contacts = new ContactListProxy(); // virtual proxy
 +           }
 +           return contacts;
 +       }
 +   }
 +
 +   public class ContactListProxy implements ContactList {
 +       private ContactList realList;
 +
 +       public List<Customer> getCustomers() {
 +           if (realList == null) {
 +               realList = new RealContactList(); // expensive operation
 +           }
 +           return realList.getCustomers();
 +       }
 +   }
 +</code>
 +
 +{{statnice:bakalar:omolazy.png?300}}
 +
 +=== Object Pool ===
 +  * Vzor, který opakovaně používá drahé objekty místo jejich opakovaného vytváření a likvidace.
 +  * Typické použití:
 +    * JDBC připojení (`ConnectionPool`)
 +    * File handle
 +    * HTTP klienti
 +  * Pool může mít parametry: minimální/ maximální počet instancí, TTL, idle cleanup.
 +<code java>
 +   public class ObjectPool<T> {
 +       private BlockingQueue<T> pool;
 +
 +       public ObjectPool(Supplier<T> creator, int maxSize) {
 +           pool = new ArrayBlockingQueue<>(maxSize);
 +           for (int i = 0; i < maxSize; i++) {
 +               pool.offer(creator.get());
 +           }
 +       }
 +
 +       public T borrow() throws InterruptedException {
 +           return pool.take();
 +       }
 +
 +       public void release(T obj) {
 +           pool.offer(obj);
 +       }
 +   }
 +
 +   // Použití:
 +   ObjectPool<Connection> connectionPool = new ObjectPool<>(MyConnection::new, 5);
 +   Connection conn = connectionPool.borrow();
 +   // ...
 +   connectionPool.release(conn);
 + </code>
 +
 + {{statnice:bakalar:omoobjpool.png?300}}{{statnice:bakalar:omoobjpool2.png?300}}
 +
 +=== Cache ===
 +* Vzor, který ukládá data, která se často opakovaně používají.
 +  * Používá se např. pro:
 +    * Konfigurace, katalogy, uživatelská data
 +  * Základní princip:
 +    * `get(key)` → pokud data nejsou nalezena, stáhnout z pomalého zdroje a uložit.
 +  * Eviction policy (např. LRU) zabraňuje přetečení paměti.
 +
 +<code java>
 +   public class SimpleCache<K, V> {
 +       private final int capacity;
 +       private final Map<K, V> cache = new LinkedHashMap<>();
 +
 +       public SimpleCache(int capacity) {
 +           this.capacity = capacity;
 +       }
 +
 +       public synchronized V get(K key, Supplier<V> dataLoader) {
 +           if (!cache.containsKey(key)) {
 +               if (cache.size() >= capacity) {
 +                   Iterator<K> it = cache.keySet().iterator();
 +                   it.next(); it.remove(); // remove oldest
 +               }
 +               cache.put(key, dataLoader.get());
 +           }
 +           return cache.get(key);
 +       }
 +   }
 +
 +   // Použití:
 +   SimpleCache<String, Person> personCache = new SimpleCache<>(100);
 +   Person p = personCache.get("123", () -> loadPersonFromDB("123"));
 +</code>
 + {{statnice:bakalar:omocache.png?400}}
 +
 +=== Map, Filter, Reduce (stream API) ===
 +  * Funkcionální operace na sekvencích dat (např. kolekce) umožňující čistý a efektivní styl programování.
 +  * Vzniká **pipeline** z řetězených operací, které jsou **lazy** vyhodnocovány.
 +
 +  * **Map**: transformace každého prvku.
 +  <code java>
 +     List<String> names = people.stream()
 +         .map(Person::getName)
 +         .collect(Collectors.toList());
 +  </code>
 +
 +  * **Reduce**: agregace prvků do jedné hodnoty.
 +   <code java>
 +     // Příklad z prezentace – nalezení největšího čísla
 +     List<Integer> numbers = Arrays.asList(5, 12, 3, 21, 7);
 +
 +     int max = numbers.stream()
 +         .reduce(Integer.MIN_VALUE, (a, b) -> a > b ? a : b); \\tady passujeme lambda funkci
 +
 +     System.out.println("Maximum: " + max);
 +   </code>
 +
 +  * **Filter**: výběr pouze těch prvků, které splňují predikát.
 +   <code java>
 +     List<Person> fromPraha = people.stream()
 +         .filter(p -> p.getCity().equals("Praha"))
 +         .collect(Collectors.toList());
 +   </code>
 +
 +  * **Kombinování:**
 +  <code java>
 +     List<String> sortedNames = people.stream()
 +         .filter(p -> p.getCity().equals("Praha"))
 +         .map(Person::getName)
 +         .sorted()
 +         .collect(Collectors.toList());
 +  </code>
 +
  
 ===== Specifikace, návrhy specifikací, web API, Apiary, Swagger, GraphQL ===== ===== Specifikace, návrhy specifikací, web API, Apiary, Swagger, GraphQL =====
 +
 +<markdown>
 +### Specifikace
 +
 += Formální popis toho, jak se má komponenta v systému chovat
 +
 + - zahrnuje popis jejích rozhraní, funkcí a očekávaného chování
 + - představuje společný kontrakt pro implementátora komponenty a klienta komponenty
 + - význam specifikace: předchází chybám, srozumitelnost, připravenost na změny
 +
 +
 +**Behaviorální ekvivalence**
 +
 +"Dva kódy jsou behaviorálně ekvivalentní, pokud při stejných vstupech ve stejném kontextu dávají stejné výstupy a vedou ke stejnému stavu systému."
 +
 + - odpovídá na otázku zda-li se dva zdrojové kódy chovají stejně (možnost výměny kódu beze změny chování systému)
 + - není obecně testovatelná
 + - faktory ovlivňující behav. ekvivalenci: Vstupní hodnoty, Kontext běhu, Vedlejší efekty, Chybové stavy
 + - hraje roli i kontrakt mezi klientem a implementací:
 +   - Preconditions = požadavky, které musí klient splnit, než zavolá funkci
 +   - Postconditions = záruky, které funkce poskytne
 +
 +**Změna specifikace** - silná vs. slabá
 +
 +S2 je silnější nebo stejná jako S1 pokud:
 + - Preconditions pro S2 jsou slabší než nebo stejné jako pro S1
 + - Postcondition pro S2 jsou silnější nebo stejné jako pro S1
 +
 +=> můžeme nahradit S1 za S2 bez ovlivnění stávajících klientů
 +
 +**Přesnost popisu specifikace**
 +- Deterministic: jednoznačně určený výstup
 +- Undetermined: není jednozačně určen výstup 
 +
 +Příklad: "vrátí __první__ index i, kde arr[i] = val" vs "vrátí index i, kde arr[i] = val"
 +
 +**Deklarativní vs Operativní specifikace**
 +
 +- Deklarativní: nepopisuje detaily interních kroků implementace, popisuje výstup na základě vstupů
 +- Operativní: popisuje kroky implementace, slouží jako návod pro vývojáře
 +
 +(deklarativní preferovanější)
 +
 +**Testování** - testy musí splňovat podmínky specifikace, testy nesmí být podřízeny implementaci, ale výhradně specifikaci rozhraní
 +
 +### REST (Representational State Transfer)
 +
 += architektonický styl pro návrh webových API (nemusí být nutně vázaný na HTTP protokol)
 +- REST API jsou navrženy na základě resources = objekty/data/služby ke kterým klient přistupuje
 +- každý resource má identifikátor - URI
 +- používá se jednotný interface, aby byl zajištěn decoupling klienta a serveru (v HTTP použito verb v hlavičce - get, put, post, delete, patch)
 +- ! je bezestavový, odpovědi mohou být cacheovány
 +
 +Existují různé úrovně implementace:
 +- Level 0: jedno URI pro všechny operace, operace jsou post volání na toto URI
 +- Level 1: separátní URI pro jednotlivé resources
 +- Level 2: využití HTTP metod pro definici operací na resource
 +- Level 3: využití hypermedia odkazů (odpovědi obsahují URI na další resources např. objednávka -> uri pro položky)
 +
 +**Web API**
 +
 += api na webovém serveru nebo klientu
 +- request response koncept, předávání zpráv ve formátu JSON nebo XML
 +- ve většine řešení postavený na HTTP (využívání response kódů)
 +
 +SOAP (Simple Object Access Protocol)
 +
 +- protokol pro komunikaci mezi 2 zařízeními
 +- pro popis služeb využívá WSDL (web services description language) - formální popis poskytované funkcionality (xml)
 +- zprávy jsou ve formátu XML
 +- zpřístupňuje klientovi funkce a operace (např. může mít funkci CreateEmployee pro vytvoření zaměstnance v systému) -> orientovaná procedurálně
 +- není cachovaný
 +- pomalejší
 +
 +REST API
 +
 +- zpřístupňuje klientovi data -> orientovaná datově
 +- využívá HTTP - metody pro přístup ke zdrojům: get, put, post, delete, patch
 +- podporuje různé formáty - především JSON ale mohou být různé
 +- popis endpointů je méně formální
 +- rychlejší
 +
 +GraphQL
 +
 +- efektivní nástupce REST API
 +- dává možnost specifikace požadovaných dat
 +- když operace vrací objektový graf, tak mohu specifikovat hloubku a podmnožiny atributů jednotlivých entit
 +- zvládá větší zátěž než REST
 +
 +Open API
 +- Open API Initiative - zaměřuje se na vytvoření,zkvalitňování a propagaci formátu pro popis rozhraní, které bude nezávislé na dodavateli
 +- Open API Specification 
 +  - definuje standard pro popis REST API, nezávislé na programovacím jazyku
 +  - může být použita pro generování klientského i serverového kódu pro různé programovací jazyky, generování dokumentace, validace obsahu zpráv, testování
 +
 +Swagger
 +
 +- framework pro definici rozhraní podle specifikace OpenAPI
 +- pokrývá celý životní cyklus REST API:
 +  - návrh - Swagger Editor - nástroj pro psaní OpenAPI specifikace v YAML/JSON
 +  - dokumentace - Swagger UI - vygeneruje interaktivní dokumentaci z OpenAPI popisu
 +  - build - Swagger Codegen - automaticky generuje kód klientů/serverů podle specifikace
 +  - testování - Swagger Inspector - umožňuje testovat API volání přímo z prohlížeče
 +  - deployment - zakomponování do Docker apod.
 +
 +na datové struktury se v rámci zpráv odkazuje pomocí REF - uri
 +
 +APIARY
 +
 +- obdobný nástroj swaggeru
 +
 +</markdown>

Trace: • b4b01num • b0b33opt

Navigation

Playground

QR Code
QR Code statnice:bakalar:b6b36omo (generated for current page)