Application Developer, Database designer, and Software Architect in a wide variety of business applications. Particularly interested in client/server application and relational database design using MySql. Deeply skilled in IMAP /SMTP protocol, Web service stack protocol. Strong experience in Hosting product like shared, virtual and mail hosting.
Avete mai provato quella fantastica sensazione di leggerezza nel correre senza obiettivi cronometrici?
Nell’ultimo anno tanti di noi, per svariati motivi, hanno dovuto affrontare e superare percorsi di vita intrisi di ostacoli con la fisiologica conseguenza di trascurare l’attività sportiva.
La pigrizia si autoalimenta giorno dopo giorno in una spirale che ci trascina verso l’oblio sportivo. E proviamo a chiederci perché abbiamo ‘sprecato’ le nostre giornate alla ricerca di una performance, spendendo ogni singola goccia di energia in un’impresa che stravolge la quotidianità.
Cerchiamo una giustificazione per odiare, almeno per un po’, quell’attività che in realtà ci fa stare bene. Ma non troviamo un solo motivo per cui correre è deleterio.
In quest’estate anomala, fatta di Remote Working e una libertà sportiva riacquistata a fatica, ho trovato il tempo di costruire un nuovo modo di concepire lo sport abbinato alla quotidianità: non più costrizione ma piacevole evasione.
Ho riniziato a correre dopo un infortunio non troppo grave dal punto di vista medico, ma gravoso dal punto di vista del recupero. Una tripla frattura al piede che mi ha lasciato ai box per quasi 60 giorni.
Ma prima di correre ho deciso che serviva recuperare una condizione decente attraverso degli sport complementari come il nuoto e la bici. Ma è quest’ultima che ha il merito di aver riacceso la fiaccola dello sportivo che ha sempre illuminato il mio approccio alla vita.
Salita dopo salita ho ritrovato sensazioni dimenticate da tempo. Ho acquisito confidenza con l’articolazione. Ho riacquistato tonalità muscolare e archiviato il dolore al piede.
Ma soprattutto ho capito che puntare tutte le fiches sul piatto della corsa equivale ad infilarsi in un tunnel, la cui porta d’ingresso si chiude alle nostre spalle non lasciandoci altra possibilità che avanzare o fermarci senza alternative.
Personalmente, Correre è il modo più veloce per svuotami dalla negatività, trovare soluzioni a problemi o concepire nuove idee.
Ma è anche il modo più veloce per vivere la natura.
Correre ad un passo dal mare e respirare l’aria salmastra è una sensazione che ci riempie di emozioni.
Corriamo per il piacere di farlo senza però chiudere la porta alle nostre spalle.
Continuerò a praticare sport che mi permettano di recuperare dagli acciacchi ma lo Sport che mi ha stregato e mi regala più emozioni e sensazioni dolci è la corsa.
Vorrei farvi vivere attraverso questo racconto quanto la corsa e l’atletica siano parte integrante di Sestu.
Uno dei pregi del Correre a Sestu è la possibilità di scegliere tra svariate alternative, sia in termini di ambiente in cui svolgere l’attività fisica, sia in termini di intensità e partecipazione alla vita sociale della famiglia della Nuova Atletica Sestu.
Potrete trovarvi a correre in campagna e perdervi tra i vitigni.
Potrete scegliere la collina, con il rimboschimento, dove vedrete luoghi vissuti millenni fa e respirerete un’aria pura godendo del silenzio assordante interrotto solo dai vostri passi sui ciottoli e sullo sterrato.
O semplicemente verrete in pista, la culla naturale dell’atletica, e vi innamorerete perdutamente del Track&Field dove capirete che l’atletica non è solo corsa ma tanto altro ancora.
Ma la cosa più importante è che troverete, sempre che lo vogliate, un compagno con cui condividere tali percorsi.
Un campione assoluto della corsa su strada, detentore del record del mondo in maratona in un post su Facebook ha scritto delle semplici parole:
“My message to the people in the world is to go for a run. I believe it’s the way to free our minds and to make ourselves healthy and happy.”
Il mio messaggio ai cittadini del mondo è di uscire all’aperto per una corsa. Io credo che sia il modo per liberare la nostra mente e rendere noi stessi felici e in salute.
Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.
✓ Live Streaming✓ Interactive Chat✓ Private Shows✓ HD Quality
Anya is LIVE right now
FREE
Free to watch • No registration required • HD streaming
Chi non usa JSF può andare direttamente alla sezione JPA per capire come effettuare il setup delle librerie necessarie, il datasource setup, come scrivere un resources/META-INF/persistence.xml file con riferimenti a hibernate.
Punto dritto al sodo e vi spiattelo il codice di seguito:
import java.util.Map;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import org.apache.log4j.Logger;
/**
* Class to manage Entity manager factory and Entity manager in persistence
* context without Context Listener. <br/>
* Class takes care of following basic things: <br/>
* <ul>
* <li>using one time on-demand initialization, it sets up the
* EntityManagerFactory</li>
* <li>it provides a way to create, obtain and properly close an EntityManager</li>
* <li>it provides a way to create, obtain and properly close an EntityManager
* overriding the default configuration read in persistence.xml</li>
* <li>the DBManager class provides an explicit "readOnly" mode which you should
* use when you are not going to persist any changes (effectively no JPA
* transaction is created in readonly mode)</li>
* <li>it provides a way for you to trigger a commit or rollback</li>
* </ul>
*
* @author Alessio Flaviani 19/set/2013 DBManager.java
*/
public class DBManager {
protected static String CLASS_NAME = DBManager.class.getName();
protected static Logger logger = Logger.getLogger(DBManager.class);
private static volatile boolean initialized = false;
private static Boolean lock = new Boolean(true);
private static EntityManagerFactory emf = null;
private EntityManager outer;
private static volatile boolean initializedOver = false;
private static Boolean lockOver = new Boolean(true);
private static EntityManagerFactory emfOver = null;
private EntityManager outerOver;
/**
* Default constructor
*/
public DBManager() {
}
/**
* Open Dba; if readonly no JPA transaction is actually started, meaning you
* will have no persistence store. You can still persist stuff, but the
* entities won't become managed.
*/
public DBManager(boolean readOnly) {
logger.debug("initializing entity manager factory ...");
initialize();
logger.debug("opening entity manager ...");
openEm(readOnly);
}
/**
* Open Dba; if readonly no JPA transaction is actually started, meaning you
* will have no persistence store. You can still persist stuff, but the
* entities won't become managed.
*
* @param entityFactoryConfig
* new properties to override previous configuration, if exist.
*/
public DBManager(Map<String, Object> entityFactoryConfig) {
logger
.debug("initializing entity manager factory overriding default configuration ...");
initialize(entityFactoryConfig);
logger
.debug("opening entity manager overriding default configuration ...");
openEmOver(false);
}
/**
* Thread safe way to initialize the entity manager factory.
*/
private void initialize() {
if (initialized) {
return;
}
synchronized (lock) {
if (initialized) {
return;
}
initialized = true;
try {
emf = Persistence.createEntityManagerFactory("VDH_DB");
logger.info("entity manager factory created at once ...");
} catch (Throwable t) {
logger.error("Failed to setup persistence unit!", t);
return;
}
}
}
/**
* Thread safe way to initialize the entity manager factory with new
* properties to override previous configuration
*
* @param entityFactoryConfig
* void
*/
private void initialize(Map<String, Object> entityFactoryConfig) {
if (initializedOver) {
return;
}
synchronized (lockOver) {
if (initializedOver) {
return;
}
initializedOver = true;
try {
emfOver = Persistence.createEntityManagerFactory(
"com.tiscali.hosting.dns", entityFactoryConfig);
logger.info("entity manager factory overrides ...");
} catch (Throwable t) {
logger
.error(
"Failed to setup persistence unit with configuration overrides!",
t);
return;
}
}
}
/**
* Create an entity manager. if readonly no JPA transaction is actually
* started.
*
* @param readOnly
* void
*/
public void openEm(boolean readOnly) {
if (outer != null) {
return;
}
outer = emf.createEntityManager();
if (!readOnly) {
logger.debug("opening transaction ...");
outer.getTransaction().begin();
}
}
/**
* Create an entity manager. if readonly no JPA transaction is actually
* started.
*
* @param readOnly
* void
*/
public void openEmOver(boolean readOnly) {
if (outerOver != null) {
return;
}
outerOver = emfOver.createEntityManager();
if (!readOnly) {
logger.debug("opening ovveride transaction ...");
outerOver.getTransaction().begin();
}
}
/**
* Get the outer transaction; an active transaction must already exist for
* this to succeed.
* @return EntityManager
*/
public EntityManager getActiveEm() {
if (outer == null) {
throw new IllegalStateException("No transaction was active!");
}
return outer;
}
/**
* Get the outer transaction; an active transaction must already exist for
* this to succeed.
*/
public EntityManager getActiveEmOver() {
if (outerOver == null) {
throw new IllegalStateException(
"No override transaction was active!");
}
return outerOver;
}
/**
* Commit the transaction only if there is an active one
*
* void
*/
public void commit() {
if (outer != null && outer.getTransaction().isActive()
&& !outer.getTransaction().getRollbackOnly()) {
logger.debug("commiting ...");
this.outer.getTransaction().commit();
this.outer.getTransaction().begin();
} else {
logger.error("commit failed, outer is null");
}
}
/**
* Commit the transaction only if there is an active one
*
* void
*/
public void commitOver() {
if (outerOver != null && outerOver.getTransaction().isActive()
&& !outerOver.getTransaction().getRollbackOnly()) {
logger.debug("override commiting ...");
this.outerOver.getTransaction().commit();
this.outerOver.getTransaction().begin();
} else {
logger.error("commit override failed, outer is null");
}
}
/**
* Mark the transaction as rollback only, if there is an active transaction
* to begin with.
*/
public void markRollback() {
if (outer != null) {
logger.debug("mark rollback ...");
outer.getTransaction().setRollbackOnly();
}
}
/**
* Mark the transaction as rollback only, if there is an active transaction
* to begin with.
*/
public void markRollbackOver() {
if (outerOver != null) {
logger.debug("mark rollback override...");
outerOver.getTransaction().setRollbackOnly();
}
}
/**
* True if the transaction has marked as rollback
*
* @return boolean
*/
public boolean isRollbackOnly() {
return outer != null && outer.getTransaction().getRollbackOnly();
}
/**
* True if the transaction has marked as rollback
*
* @return boolean
*/
public boolean isRollbackOnlyOver() {
return outerOver != null
&& outerOver.getTransaction().getRollbackOnly();
}
/**
* Close the entity manager, properly committing or rolling back a
* transaction if one is still active.
*/
public void closeEm() {
if (outer == null) {
return;
}
try {
if (outer.getTransaction().isActive()) {
if (outer.getTransaction().getRollbackOnly()) {
logger.debug("rollbacking ...");
outer.getTransaction().rollback();
} else {
logger.debug("commiting ...");
outer.getTransaction().commit();
}
}
} finally {
if (outer.isOpen())
outer.close();
outer = null;
}
}
/**
* Close the entity manager, properly committing or rolling back a
* transaction if one is still active.
*/
public void closeEmOver() {
if (outerOver == null) {
return;
}
try {
if (outerOver.getTransaction().isActive()) {
if (outerOver.getTransaction().getRollbackOnly()) {
logger.debug("rollbacking override ...");
outerOver.getTransaction().rollback();
} else {
logger.debug("commiting override ...");
outerOver.getTransaction().commit();
}
}
} finally {
if (outerOver.isOpen())
outerOver.close();
outerOver = null;
}
}
}
Ho apportato pochi cambi alla classe riportata nell'articolo precedentemente citato.
La classe permette di gestire l'entity factory manager e l'entity manager in un contesto di persistenza senza implementare un context listener per la creazione,
gestione e chiusura della factory stessa in fase di startup e shutdown del server container.
La classe permette di
sfruttare l'inizializzazione one-time della factory su richiesta
creare, utilizzare e chiudere un'entity manager
creare, utilizzare e chiudere un'entity manager sovrascrivendo la configurazione di default letta nel persistence.xml utilizzato da hibernate
un metodo di gestione delle istanze senza persistenza
una gestione dei commit e dei rollback delle transazioni ottimizzato
Ho introdotto la possibilità di creare entity manager con la configurazione passata a runtime. Nel mio specifico caso ho la necessità di creare l'entity manager leggendo la configurazione del db a cui connettermi in base a delle discriminanti passate come parametro. E' una situazione molto utile per chi deve lavorare su basi dati differenti nello stesso algoritmo.
Ho modificato la gestione dei commit riaprendo la transazione dopo la chiusura della precedente.
La spiegazione è semplice: ho un'architettura complessa costituita da più webservice. Alcuni di essi sono invocati da altri webservice da 1 a n volte.
I metodi dei webservice inglobati in altri webservice gestiscono l'intero ciclo di vita della transazione: apertura entity e transaction, commit o rollback, chiusura entity.
Di conseguenza il metodo inglobante (passatemi il termine :) ) si ritroverebbe la transazione chiusa al completamento del ciclo di vita del metodo inglobato perchè l'entity manager è gestita a livello globale!
Da qui la decisione di riaprire la transazione dopo un commit!
Come scritto da Gimby (l'autore dell'articolo postato in alto):
‘Java is really the only choice when it comes to the requirements for a company like ours — extreme performance requirements and extreme scalability requirements. There is no viable alternative’
