Programmiamo

Oggi volevo mostrarvi una mia implementazione del DAO pattern.

Nei post precedenti vi ho fornito alcuni link con la descrizione dei J2EE patterns.

Per aiutarvi a comprendere meglio il pattern DAO, ho pensato che sarebbe stato utile illustrarvi come io l'implemento. Ovviamente non voglio esaurire con questo post tutte le problematiche di persistenza utilizzando l'approccio DAO con classi POJO, ma è una buona base di partenza. In futuro discuteremo estensioni e, magari, anche approcci alternativi.

Come al solito trovate l'articolo nel nostro wiki.

Aggiornamento
Volevo segnalarvi questo tool a pagamento chiamato Firestorm. E' un DAO generator che può generare DAO partendo da un database esistente (o definito tramite file xml). Può generare codice per diversi back end: JDBC (molti database), Hibernate, Entity Bean, etc.

Vi consiglio di scaricare la Standard Edition (se vi interessa JDBC), e provare a fare il reverse engineering di tabelle (max 3 se si usa l'evaluation license) di un database e studiarvi il codice che, secondo me, va sempre adattato alle proprie esigenze.

Oggi voglio presentarvi una diversa categoria di Patterns pubblicati nel famoso libro Pattern-Oriented Software Architecture: Patterns for Concurrent and Network Objects di Douglas C. Shmidt.

In quel libro vengono discussi classici problemi in ambienti distribuiti e la loro soluzione attraverso specifici patterns.

Questi patterns vengono divise in 4 categorie: cuncurrency, event, initialization, e synchronization patterns.

Vediamo ora in dettaglio ciascun pattern. In futuro avremo modo di analizzare questi patterns in maggior dettaglio cercando di capire anche eventuali utilizzi in applicazioni pratiche.

Concurrency Patterns

Thread per Session
Thread Pool
Thread Specific Storage
Leader/Followers
Half Sync/Half Async
Active Object
Monitor Object

Event Patterns

Reactor
Proactor
AsynchronousCompletion Token

Initialization Patterns

Acceptor/Connector
Service Configurator
Object Lifetime Manager

Synchronization Patterns

Double Checked Locking
Thread Safe Interface
Scoped Locking
Strategized Locking

Miscellaneous

External Polymorphism
Wrapper Facade

In questo post vi ho parlato di un tutorial su un videogame 3D dedicato al calcio. Nei precedenti post, però, abbiamo parlato anche di design patterns GoF. In questo post volevo mostrarvi un esempio pratico di applicazioni dei patterns ad un ipotetico gioco di calcio. Potreste utilizzare questa guida per migliorare il codice pubblicato nel tutorial creando la vostra versione. Certo ci sarebbe da migliorare anche la grafica ma questo può avvenire gradualmente.

Qui di seguito trovate i links alla guida.

- Parte I-II;

- Parte III-IV. 

Oggi parliamo di un'altra categoria di patterns: Core J2EE Patterns. Molti dei patterns che presenterò in questo post sono un'estensione dei patterns fondamentali Gof. La figura in questa pagina, mostra la struttura interna di un'ipotetica appliazione J2EE. Essa è composta da un web container e un ejb container. Il secondo viene utilizzato per la gestione della persistenza (ejb entity bean) e business logic (ejb session bean).

Un'applicazione J2EE può essere composta anche solo dal web container, con la business logic implementata in semplici classi Java e la persistenza gestita attraverso il pattern DAO.

L'applicazione J2EE è, generalmente, composta da 3 layer: presentation, business e integration.

Per ciascuno dei 3 layers ci sono dei patterns che ci consentono di risolvere numerosi problemi comuni.

Qui riporto un elenco dei Core J2EE Patterns organizzati per layers.

Presentation Layer

Interception Filter

Front Controller

View Helper

Composite View

Service to Worker

Dispatcher View

Business Layer

Business Delegate

Value Object

Session Facade

Composite Entity

Value Object Assembler

Value List Handler

Service Locator

Integration Layer

Data Access Object

Service Activator

Qui trovate un esempio di applicazione J2EE (PetStore) che utilizza questi patterns.

 

Programmo da molti anni e uno dei problemi tipici dei programmatori, soprattutto quelli inesperti è l'attitudine a reinventare la ruota.

 

In molte applicazioni, i problemi da affrontare sono più o meno gli stessi: persistenza, transazioni, threading, e molto altro.

Quello che i programmatori inesperti spesso fanno è quello di reinventare soluzioni nuove a problemi noti.
Così come in architettura e ingegneria esistono soluzione a problemi noti, lo stesso vale per la programmazione.

Per questa ragione nascono i design patterns. Essi sono soluzioni noti a problemi noti. Il mio modo di programmare è enormemente cambiato dopo la lettura di questo libro, che presenta un set di patterns individuati dalla Gang of Four (Gof).

Questi patterns si possono raggruppare in 3 categorie: strutturali, comportamentali e creazionali.

Ecco a voi un'infarinatura dei patterns presentati in questo libro. Vi consiglio di studiarli attentamente se volete diventare veri professionisti del software.

Patterns Creazionali

Abstract Factory

Builder

Factory Method

Prototype

Singleton

Patterns Strutturali

Adapter

Bridge

Composite

Decorator

Facade

Flyweight

Proxy

Iterator

Patterns Comportamentali

Chain of Responsability

Command

Interpreter

Mediator

Memento

Observer

State

Strategy

Template Method

Visitor