Introduzione

BEEing utilizza la codifica UTF-8 senza BOM (Unicode Transformation Format, 8 bit), molto utile per il trasferimento di informazioni tramite sistemi di posta elettronica o per la memorizzazione di dati all’interno di un datastore. In particolare risulta essere molto adatta a questo tipo di piattaforma, essendo BEEing un framework multilingue.

Come impostare una codifica in BEEing

Per definire una determinata codifica sulla piattaforma (es. UTF-8) è necessario seguire i seguenti passi;

Impostare la codifica UTF-8 in Glassfish

Glassfish è l’application server utilizzato da BEEing, all’interno del quale è necessario configurare un pool contenente le connessioni con i database.

Per ogni connessione è necessario definire alcune proprietà aggiuntive (vedi l’apposita sezione in Installare la versione 3.x di BEEing) tramite cui specificare il nome del database, l’indirizzo IP … Tra queste può essere inserita anche la proprietà Encoding con valore il tipo di codifica che si intende utilizzare.

Impostare la codifica UTF-8 nel Database.

Il database destinato a contenere i nostri dati dev’essere configurato con la codifica prescelta onde evitare spiacevoli conversioni errate; questa impostazione può essere specificata attraverso il software prescelto per la gestione dei datastore. Di seguito un esempio tramite Navicat.

Codifica per Progetto (per chi ama lavorare sul codice sorgente)

Tramite un apposito IDE di programmazione (o sull’apposito file.xml) è possibile impostare la codifica di un progetto.

Ad esempio Netbeans consente questa operazione entrando nelle proprietà del progetto di interesse.

Codifica per Eclipse-Link (per chi ama lavorare sul codice sorgente)

Se siete degli sviluppatori e state realizzando un nuovo plug-in con un apposito database, allora dovreste assicurarvi che anche le dichiarazioni delle persistence unit contengano le corrette specifiche di encoding.

Eclipse-Link consente l’interazione tra BEEing ed il datastore. Perchè possa essere utilizzato all’interno dal framework è necessario configurare, per ogni progetto, il file persistence.xml. All’interno di questo file è possibile definire il tipo di codifica da utilizzare per la comunicazione con il database:

AUTORE: Roberto Fratti

In questo articolo “Cos’è BEEing” avevo già introdotto a grandi linee le potenzialità del Framework e l’idea del percorso evolutivo della piattaforma verso un sistema applicativo, per così dire, “pronto all’uso”.

Cosa posso farci con BEEing? Posso realizzare un CRM? Posso utilizzarlo come wiki aziendale? Posso utilizzare il datastore come sistema di archiviazione o condivisione documentale? Posso utilizzarlo per l’implementazione di un sistema di configurazione commerciale? Posso pubblicare report aziendali? Posso gestire i profili professionali dei miei dipendenti?

La risposta a queste domande è sì. BEEing racchiude una serie di funzionalità base ed alcune predisposizioni a funzionalità che possono essere sviluppate ad-hoc o che verranno sviluppate in futuro. Come già detto in piu’ occasioni, BEEing si sta evolvendo di giorno in giorno e quotidianamente presenta nuovi plug-in e nuove funzionalità

Ad oggi viene utilizzato con grande successo come piattaforma sociale di livello enterprise, integrando funzionalità tipiche di una extranet aziendale, di un wiki intra/extra aziendale, di un sistema di archiviazione/condivisione documentale, di una piattaforma a supporto di soluzioni commerciali di configurazione.

Perchè utilizzare BEEing per lo sviluppo di soluzioni Enterprise?

Potrei rispondere perchè è Open Source, il codice rispetta tutti i principali standard tecnologici e fa largo uso di molti altri progetti Open Source (es: ZK, JSON, Velocity, Rome, EclipseLink, Jakarta Commons, ecc..). Inoltre si appoggia ad uno dei migliori Application Server Open Source, Glassfish (oggi supportato da Oracle).

Ma il motivo principale deve essere che BEEing è stato progettato appositamente per l’implementazione di soluzioni sociali a livello Enterprise. Che si tratti di mettere in piedi un semplice wiki aziendale o un piu’ complesso sistema intra/extra aziendale, BEEing è sempre la scelta migliore.

Potete personalizzare ogni template grafico, configurare il profilo utente ai massimi dettagli (ruoli, attributi e gruppi), sfruttare la tecnologia wiki nativa, il datastore interno per l’archiviazione di files, oppure sviluppare internamente i vostri plug-in per fornire ai vostri utenti report sempre aggiornati, sistemi dispositivi integrati al vostro ERP, sistemi di configurazione commerciale o a supporto della progettazione tecnica.

In una sola parola, perchè BEEing è flessibile e quell’idea che avete in mente può facilmente diventare realtà.

Chi può trarre vantaggio nell’utilizzo di BEEing?

Aziende:

Tutte le aziende che trovino sufficienti le funzionalità applicative incluse (wiki, gestione profili, blog, archiviazione, sistema multilingue) o quelle che dispongono di una struttura tecnica interna in grado di personalizzare ed estendere la piattaforma.

Software House:

BEEing è facilmente integrabile con quasi tutti i piu’ moderni sistemi gestionali oggi presenti sul mercato (l’integrazione con SAP/R3, per esempio, avviene mediante BAPI e JCo) ed offre una semplice ma potente piattaforma di sviluppo che consente anche ai programmatori meno esperti di cimentarsi con lo svliluppo di applicazioni web solide e graficamente accattivanti. L’architettura a componenti, che coinvolge anche l’aspetto grafico del framework, consente la realizzazione di oggetti e widget riutilizzabili in ogni contesto.

Sviluppatori Liberi Professionisti:

Per chi già sviluppa in java e vuole una piattaforma economica, flessibile, robusta e semplice da implementare presso i propri clienti. Sviluppare su BEEing, Glassfish e MySQL non costa nulla ed offre potenzialità illimitate.
Potrete tranquillamente affrontare tutte le richieste dei vostri clienti.
Inoltre potreste diventare partner ed implementatori   certificati.

E l’assistenza?

Molti ci hanno già contattati, perciò non esitate se avete dubbi o quesiti di ogni tipo.
BEEing è giovane, e ci stiamo organizzando per istruire una rete di partner intenzionati ad investire in progetti Open Source e che siano in grado di diffonderne le conoscenze.
Molto presto pubblicheremo i nominativi delle prime Software House in grado di fornire assistenza tecnica a pagamento.
Per ora potete benissimo sfruttare l’assistenza gratuita che forniamo con piacere a tutti coloro che ne facciano richiesta.

AUTORE: Gian Angelo Geminiani

La cache utilizza in parte la memoria ram della macchina host.
Per questo motivo è buona norma configurare Glassfish in modo che renda disponibile la memoria a BEEing nel minor tempo possibile.

Glassfish viene installato con un’impostazione base adatta ad un ambiente di sviluppo e debug.
Per ambienti di produzione occorre modificare alcune opzioni della macchina virtuale.
Per farlo dovete aprire la sezione “JVM Options” ed impostare le seguenti opzioni come di seguito:

1. Cambiate l’opzione -client in -server.
2. Impostate l’opzione Xms in questo modo: -Xms832m
3. Impostate l’opzione Xmx in questo modo: -Xmx832m
4. Assicuratevi che esista questa opzione: -XX:MaxPermSize=192m

AUTORE: Gian Angelo Geminiani

Questo post spiega come configurare Glassfish su piattaforma Linux Ubuntu affinchè parta come daemon (servizio) al boot della macchina.
L’installer non esegue queste attività automaticamente, ma in un contesto di produzione è impensabile dover avviare manualmente l’Application Server.

Questo breve tutorial è dedicato agli utenti meno esperti.

Installazione di Glassfish

Prima di avventurarci nelle attività successive, dovete aver effettuato l’installazione di Glassfish e la configurazione di BEEing come da tutorial.

Dalla procedura di installazione dovete segnarvi il percorso in cui Glassfish è stato installato.
es: /home/administrator/glassfishv3

Creazione del file di avvio

La creazione del file di avvio è molto semplice.
Il file dovrà essere creato nella cartella /etc/init.d.
Chiameremo il file semplicemente GlassFish.

1. Avviare l’editor di testo in modalità amministrativa:

Eseguire il seguente comando da terminale:

sudo gedit /etc/init.d/GlassFish

Appena inserita la password di amministrazione (quella che avrete impostato in fase di installazione del sistema operativo) l’editor verrà aperto pronto alla modifica del file GlassFish (che naturalmente in questa fase sarà vuoto).
Copiate nel file il seguente contenuto:

GLASSFISHHOME=/home/administrator/glassfishv3/glassfish
case "$1" in
start)
 ${GLASSFISHHOME}/bin/asadmin start-domain domain1
 ;;
stop)
 ${GLASSFISHHOME}/bin/asadmin stop-domain domain1
 ;;
restart)
 ${GLASSFISHHOME}/bin/asadmin stop-domain domain1
 ${GLASSFISHHOME}/bin/asadmin start-domain domain1
 ;;
*)
 echo $"usage: $0 {start|stop|restart}"
 exit 1
esac

Salvate e Chiudete il file.

2. Rendere Avviabile il file GlassFish

Digitate a terminale il seguente comando:

sudo chmod a+x /etc/init.d/GlassFish

E’ possibile che vi venga richiesta nuovamente la password di amministratore.

3. Creare i links al file Glassfish per i diversi livelli di avvio.

Nelle fasi precedenti abbiamo creato un file, GlassFish, che consente l’avvio e l’arresto (ed il riavvio) dell’Application Server.
Poi lo abbiamo reso eseguibile, in modo che possa essere  lanciato come un qualsiasi altro programma.

Ora dobbiamo creare i link all’interno di apposite cartelle che invocheranno il nostro file GlassFish.
Per evitare di eseguire la procedura manualmente, possiamo utilizzare uno script che ho reperito sul blog di Sun e ho riadattato.
Dobbiamo innanzi tutto creare un file eseguibile contenente lo script che lanceremo successivamente.

Per creare il file eseguibile con lo script compiremo la stessa procedura descritta nei punti 1 e 2.

Avvio dell’editor di testo:

sudo gedit /home/administrator/Desktop/CreateLinks

Verrà creato un file CreateLinks sul desktop.

Copiate il seguente contenuto nel file e salvate. Potete poi chiudere l’editor.

#!/bin/bash

# Author: Ken Kranz - Sun Microsystems, Inc

TARGET=$1

NUMBER=$2

USAGE="$(basename $0) TARGET NUMBER"

if [[ $# != 2 ]]; then

    echo $USAGE

    exit 0

fi

if [[ x$TARGET = x ]]; then

    echo missing TARGET

    echo $USAGE

    exit 1

fi

if [[ x$NUMBER = x ]]; then

    echo missing NUMBER

    echo $USAGE

    exit 1

fi

if [[ ! -e /etc/init.d/$TARGET ]]; then

    echo cannot find $TARGET

    exit 1

fi

sudo chmod a+x /etc/init.d/$TARGET

sudo ln -v -s /etc/init.d/$TARGET /etc/rc0.d/K${NUMBER}$TARGET

sudo ln -v -s /etc/init.d/$TARGET /etc/rc1.d/K${NUMBER}$TARGET

sudo ln -v -s /etc/init.d/$TARGET /etc/rc2.d/S${NUMBER}$TARGET

sudo ln -v -s /etc/init.d/$TARGET /etc/rc3.d/S${NUMBER}$TARGET

sudo ln -v -s /etc/init.d/$TARGET /etc/rc4.d/S${NUMBER}$TARGET

sudo ln -v -s /etc/init.d/$TARGET /etc/rc5.d/S${NUMBER}$TARGET

sudo ln -v -s /etc/init.d/$TARGET /etc/rc6.d/K${NUMBER}$TARGET

Rendere il file CreteLinks eseguibile.

sudo chmod a+x /home/administrator/Desktop/CreateLinks

Eseguire CreateLinks.

Siamo finalmente pronti ad eseguire CreteLinks, il file che si occuperà per noi di effettuare tutte le modifiche necessarie all’avvio, arresto e riavvio di Glassfish come daemon.

Da terminale dovrete digitare, uno alla volta, i seguenti comandi:

sudo /home/administrator/Desktop/CreateLinks GlassFish 2

sudo /home/administrator/Desktop/CreateLinks GlassFish 5

sudo /home/administrator/Desktop/CreateLinks GlassFish 0

sudo /home/administrator/Desktop/CreateLinks GlassFish 1

sudo /home/administrator/Desktop/CreateLinks GlassFish 6

Riavviate la macchina e verificate che Glassfish sia partito.

AUTORE: Gian Angelo Geminiani

Introduzione.

Questo post è indirizzato esclusivamente ai programmatori che abbiano interesse ad orientarsi nel codice sorgente di BEEing.
Per migliorare la lettura del codice ed il lavoro in team, abbiamo definito alcune semplici specifiche che vanno dalla definizione dei nomi delle variabili, dei metodi, ecc.. alla struttura dei package.

Specifiche:

NOMI COMPOSTI:

Java impone che i nomi di metodi,di variabili … vengano scritti con l’iniziale minuscola.
Se sono nomi composti, ogni nuova parola deve iniziare con la lettera maiuscola.

***************************************************************
setPostName(final String postName){
…..
…..
}
***************************************************************

DIVISIONE ALL’INTERNO DEI PROGETTI:

Il codice sorgente di BEEing è organizzato in packages ed in cartelle.
La divisione in cartelle rispetta le specifiche del pattern MVC (Model View Control), e separa nettamente GUI (View),  Model e Controller:

• GUI: Parte di grafica. Spesso viene fatta un ulteriore divisione in GUI_WIDGETS, GUI_COMPONENTS, GUI_WINDOWS…
• MODEL: Sezione relativa al Database.
• CONTROLLER: Cartella destinata a contenere classi di utiliti, classi astratte …

***************************************************************

NOMI DEI PACKAGE:

In BEEing si è scelto di definire in nomi dei package in questo modo:

Prima parte: org.sf.bee.

Seconda parte: nome del progetto o identificativo della sezione: (esempio search, admin, wiki …);

Terza parte: nome della cartella in cui si trova il package: gui (se si trova in una cartella GUI), gui.components (se si trova nella cartella GUI_COMPONENTS);

Quarta parte: components, widgets, windows a seconda del tipo di componente. Non viene inserita se è già stata specificata al terzo punto;

Quinta parte: pagectrls, nel caso si tratti di un componente che funga da controller della pagina. In questo modo è molto facile distinguere tra classi principali e classi secondarie.

Sesta parte: nome esplicito ed identificativo della funzionalità della classe. Tutto in minuscolo e senza separatori.
ESEMPIO:

***************************************************************

UTILIZZATE NOMI INTELLIGENTI:

Scrivendo i nomi chiaramente non avrete bisogno di scrivere commenti troppo descrittivi.
Esempi di nomi per i metodi:
doSave, doRemove … –> il prefisso do rende l’idea di un’azione, quindi può essere utilizzato per i metodi chiamati al click su un bottone, su un link …;

getText, getName … –> il prefisso get, in italiano “dammi”, dedicatelo a quei metodi che devono restituire qualcosa;

setText, setName … –> viceversa adoperate la parola set, in italiano “imposta”, per quei metodi che devono inizializzare o aggiornare dei dati (normalmente vengono passati, come argomenti, i dati da aggiornare);

init, initComponents… –> il prefisso init dev’essere utilizzato per indicare una inizializzazione. Normalmente tutti i metodi che iniziano con init vengono posti vicini nel codice.

E’ buona norma che i metodi abbiano una lunghezza massima intorno alle 15 righe. Quando iniziano ad essere 20 – 30 sarebbe buona norma pensare di dividere i metodi in due o più; in questo modo sarà più facile manutenere e debuggare il codice.

Un’altra tecnica spesso utilizzata per aver maggiore chiarezza consiste nell’inserire delle righe bianche per dividere le varie parti di un metodo.

***************************************************************

CURARE LA FORMA:

Cercate di dichiarare le variabili sempre prima del codice così da poterle ritrovare facilmente. –>
Utilizzate sempre le costanti (nome della variabile tutto maiuscolo). –>
Quando potete, anteponete al tipo di variabile la keyword final. –>


Andiamo nel dettaglio…

Cercate di dichiarare le variabili sempre prima del codice così da poterle ritrovare facilmente.

Utilizzate sempre le costanti (nome della variabile tutto maiuscolo).

All’interno di una classe (Prova.java):
public static final String BTN_ADD = “btnAdd”;
All’interno di un’altra classe che debba utilizzare lo stesso bottone della classe Prova (Test.java):
public static final String BTN_ADD =  Prova.BTN_ADD;
In questo modo non dovrete ricercare per tutta la classe (o addirittura su più classi) una stringa da modificare (es. da “btnAdd” a “btnNew”), basterà farlo per una sola costante.

Formattate bene il codice; molti strumenti di sviluppo offrono delle funzioni che consentono una strutturazione automatica.

Quando potete, anteponete al tipo di variabile la costante final.

L’applicazione della keyword final alle variabili è un’ottimizzazione in quanto constente di allocarle direttamente in memoria così che possano essere reperite più velocemente.
Naturalmente comporta alcune limitazioni, in quanto dopo la dichiarazione, potrete inizializzare la variabile UNA sola volta.

Applicando final ad una classe, impedisce la creazione di sottoclassi (N.B. non confondere il concetto di sottoclasse, subclass, con istanza della classe).

Se applicata ai metodi ne impedisce l’override.

Alcune variabili, quelle relative ai componenti grafici, è buona norma inizializzare SOLO una volta per ogni istanza di classe.

L’utilizzo di questo metodo comporta i seguenti vantaggi:
- performance migliori
- drastica riduzione di null pointer exception e di pagine bianche.
Mal che vada, non vedendo il componente, potrete farvi immediatamente un’idea su chi ha originato l’errore.

AUTORE: Roberto Fratti

Glassfish dispone di un metodo molto semplice per testare la connessione ad un database, il ping.

Per verificare se tutti i parametri inseriti nella procedura di configurazione sono corretti, è sufficiente cliccare sul bottone Ping.

E’ molto semplice, selezionate la connessione desiderata tra quelle presenti nel “Connection Pools” e fate click su “Ping”.

Se tutto ha funzionato a dovere otterrete un bel “Ping Succeded“, oppure un errore di qualche tipo.

Se avete appena installato Glassfish e non avete distribuito i driver del database, allora otterrete un errore JDBC che vi informa dell’impossibilità da parte del sistema di reperire il driver richiesto.
Niente di cui preoccuparsi, ecco come ottenere e distribuire i driver su Glassfish.

Distribuire i driver del vostro database su Glassfish.

Questa procedura ha lo scopo di rendere disponibili i driver di database a livello di application server.
Procedete in questo modo:

1. Scaricate il driver desiderato. Poniamo ad esempio che abbiate necessità di testare la connessione con MySQL, allora dovrete scaricare l’ultima versione dei driver da questo sito: http://dev.mysql.com/downloads/connector/j/ (.tar o .zip a seconda del sistema operativo su cui state facendo girare Glassfish)
2. Aprite l’archivio appena scaricato ed estraetene il contenuto in una cartella temporanea o sul Desktop. Dovreste ottenere una cartella con un nome simile a questo: “mysql-connector-java-5.1.10″
3. Aprite la cartella e verificate la presenza di un file .jar dal nome simile a “mysql-connector-java-5.1.10-bin.jar” (il nome può cambiare in funzione della versione del driver).
4. Copiate il file “mysql-connector-java-5.1.10-bin.jar” nella cartella LIB di Glassfish che trovate nel percorso “glassfish/lib/”. Se siete in ambiente Windows e state utilizzando Glassfishv3 il percorso dovrebbe essere grosso modo questo: “c:\glassfishv3\glassfish\lib”.
   Se invece state utilizzando Linux e avete installato Glassfish con i parametri di default, il percorso dovrebbe essere “/home/USER/glassfishv3/glassfish”.
5. Riavviate Glassfish.

A questo punto riprovate il Ping. Se otterrete nuovamente un errore, questa volta dovrebbe trattarsi di un errore diverso da quello precedente e riportante l’indicazione che la connessione non è possibile perchè il database non è raggiungibile o l’utente non è stato riconosciuto.

AUTORE: Gian Angelo Geminiani

Innanzi tutto, per le versioni 3.x, abbiamo accorpato i vari database (bee_sys, bee_membership, bee_wiki, bee_audit, bee_community, ecc..) in uno unico (bee_sys).
Le motivazioni che ci hanno spinto a ridefinire l’architettura dei dati sono innumerevoli, ma la principale è stata l’integrazione con Glassfish 3.x ed il fatto che ora i datasource vengono gestiti direttamente da Glassfish e quindi devono essere configurati al suo interno.

I plug-in, invece, manterranno la classica architettura a database separati e dovranno essere configurati manualmente all’interno di Glassfish (nelle versioni precedenti erano auto-installanti).

Il risultato è che ora l’avvio dell’applicazione (avvio dell’ambiente, controllo integrità database, upgrade database, ecc..) richiede molta meno memoria, un minor utilizzo di CPU e tempi ridotti ad un quinto (circa 18 secondi su una macchina a singolo processore a  con 4 gb di ram).

Installazione e configurazione MySQL.

Non cambia quasi nulla dalla precedente versione di Glassfish.
L’unica cosa è la creazione manuale del database principale: bee_sys.

Creare il database bee_sys.

La creazione manuale del database principale è molto semplice e può essere fatta da riga di comando “CREATE DATABASE …” oppure con un qualunque tool di amministrazione (MYSQL ADMINISTRATOR va benissimo).
E’ importante tener presente che non occorre creare l’intera struttura di metadati (Tabelle, Campi, ecc..) perchè a questo penserà poi la procedura di “sincronizzazione degli schema” di BEEing.

Anche in questo caso mi permetto di consigliarvi uno strumento gratuito nella versione Lite e molto potente per la gestione del database, cioè Navicat.
Purtroppo non è un progetto Open Source, ma vi garantisco che sul mercato difficilmente troverete tools all’altezza di Navicat.
Inoltre la versione Lite fa tutto ciò di cui avrete bisogno per amministrare agevolmente un database.

Installazione e configurazione di Glassfish v 3.x

Glassfish v3 è realmente un application server eccezionale (EJB 3.1, JAVA EE6, Corba 3, ecc..) e potete scaricarlo dal sito ufficiale a questo link: DOWNLOAD GLASSFISH
Sul sito trovate inoltre tutte le indicazioni per installare Glassfish sia in ambiente Windows che Linux o Mac.

Personalmente preferisco lavorare su una macchina virtuale Linux Ubuntu (VMWARE Server è gratis da qualche anno) ed installare BEEing in questo ambiente. In questo modo posso portarmi dietro la macchina virtuale su un disco esterno ed utilizzarla su tutte le macchine di sviluppo senza dover ogni volta riconfigurare l’ambiente o aggiornare il server.
Presto forniremo una macchina virtuale preconfigurata e pronta all’uso (chi ne avesse urgenza può contattarci commentando questo post).

Configurazione di BEEing v3 in Glassfish v3.

La prima cosa da fare è quella di copiare e sovrascrivere il file login.conf (vedi post precedente).
La procedura è molto semplice: Aprite la cartella contenente i files di configurazione e copiatevi all’interno il file login.config, sovrascrivendo la versione esistente.

Ora siamo pronti alla definizione delle risorse database: Connection Pool e JDBC Resources.

I passi da fare sono due.
Per prima cosa dovrete definire una connessione al database all’interno del Connection Pool e attribuirle un nome. Non importa quale nome attribuirete alla connessione perchè lo ritroverete successivamente elencato all’interno di un elenco a discesa (Attribuzione del Nome JNDI).
Successivamente dovrete creare un abbinamento tra nome JNDI (che deve essere tassativamente bee_sys) e risorsa all’interno del Connection Pool selezionando la connessione appena creata dall’elenco a discesa.

1. Creazione della connessione nel Connection Pools:

Selezionate “Connection Pools” dall’albero alla vostra sinistra. Glassfish vi elecherà tutte le connessioni esistenti (in genere quelle di esempio, se non avete creato manualmente altre connessioni).
Per aggiungere una nuova connessione cliccate sul bottone “New..”. Si aprirà la maschera col wizard di configurazione della connessione.

STEP 1

• Name: Un nome a vostra scelta. Non importa quale nome sceglierete in questa fase, perchè successivamente lo ritroverete elencato in una combo box.
• Resource Type: Avrete diverse opzioni. Selezionate “javax.sql.DataSource”.
• Database Vendor: “MySQL”.

STEP 2

La seconda maschera è piuttosto ampia e riporta una serie di campi già precompilati.
Lasciate i valori di default, andranno benissimo.
La sezione a cui dedicare attenzione è quella delle “Additional Properties”.

Questa sezione deve essere compilata con i dati relativi al vostro database.
Eliminate le proprietà di troppo ed assicuratevi di inserire quelle necessarie:

• databaseName: Nome del Database (bee_sys)
• portNumber: Porta del Database (3306)
• driverClass: La classe del driver fornito con il database (com.mysql.jdbc.Driver)
• serverName: Il Nome o L’indirizzo IP del server (localhost)
• user: Nome Utente del database (beeing)
• password: La Password (beeing)

2. Creazione della risorsa JDBC

Creazione dell’utente amministratore del database.

Non dimenticate di creare l’utente amministratore del database.
Nei passi precedenti (Additional Properties) abbiamo utilizzato “beeing” come utente amministratore con password “beeing”.
Potete utilizzare qualunque altro utente in fase di configurazione della connessione, l’importante è che poi non vi dimentichiate di crearlo anche all’interno del database.

La creazione di un utente in MySQL è piuttosto semplice, ma diventa addirittura banale se utilizzate uno strumento come Navicat.
Ricordatevi di assegnare all’utente creato i massimi privilegi, in modo che possa amministrare il database per conto vostro (BEEing si occupa dell’update degli schema).

Note su MySQL.

Se utilizzate MySQL su una macchina differente da quella su cui installate Glassfish, non dimenticate di autorizzare le connessioni da remoto da parte dell’utente utilizzato da BEEing.
In caso contrario MySQL non consentirà l’accesso al database e BEEing non sarà in grado di inizializzarsi correttamente.

A questo punto potete “deployare” il file BEEing.war che avrete scaricato dai repository (potete farlo sia da sourceforge che da kenai).

Login.conf

Non dimenticate di modificare il file login.conf.
Questa modifica è necessaria alla gestione della procedura di autenticazione di BEEing.
Potete scaricare il file Login.conf da questo link.

La procedura è descritta anche nel post precedente: “Come installare BEEing“.

Deploy di BEEing.

Scaricate il file BEEing_3_0_0.war.
Per distinguere le diverse versioni, abbiamo rinominato il file BEEing.war in BEEing_3_0_0.war.
Tuttavia il nome dell’applicazione deve essere BEEing e non BEEing_3_0_0 come invece accadrebbe se effettuaste il deploy con il file BEEing_3_0_0.war.

Rinominate BEEing_3_0_0.war in BEEing.war e procedete al deploy.
E’ fondamentale che “Application Name” e “Context Root” siano BEEing.

Se avete dubbi su come effettuare il deploy di un’applicazione su Glassfish, fate riferimento al post precedente “Come installare BEEing“.

Link Utili:

Sito Glassfish: https://glassfish.dev.java.net/

Sito MySQL: http://dev.mysql.com/downloads/mysql/5.1.html

Sito Navicat: http://www.navicat.com/download/download.html

Sito VMWare: http://www.vmware.com/products/server/

BEEing Download v3 da SourceForge

BEEing Download v3 da Kenai

Come verificare la connessione al database.

Buon Anno a tutti

AUTORE: Gian Angelo Geminiani

E’ stato creato un nuovo componente per la visualizzazione delle informazioni di un determinato utente.

Il componente si chiama

org.sf.bee.wiki.gui.components.membership.user.info.CMPauthorinfo

Alla classe si possono passare alcuni parametri per modificarne le informazioni ed eventualmente il layout.

Le proprietà sono le seguenti

setUser(User user) = vuole l’istanza di un utente da cui prelevare le informazioni

setShowName(boolean showName) = visualizza o meno il nome dell’utente (il default è false)

setShowImage(boolean showImage) = visualizza o meno l’immagine dell’utente (il default è true)

setHorizontalLayout(boolean horizontalLayout) = visualizza il layout in orizzontale  se true o verticale se false (il default è true). Questa proprietà si applica solamente al nome utente

setShowExtraInfo(boolean showExtraInfo) = visualizza o meno l’etichetta con le informazioni extra

setExtraInfo(final String extraInfo) = setta il contenuto delle informazioni extra

setStyleClass(final String styleClass) = assegna uno stile alle etichette ed all’immagine, passando il nome di una classe di stili

Il componente prevede altri due parametri di configurazione per il settaggio dell’utente

setUserById(final long userId) = assegna l’utente passando l’id

setUserByUid(final String userUid) = assegna l’utente passando l’uid

tuttavia, qualora si disponesse già di un utente, è meglio usare il metodo setUser al fine di risparmiare un accesso al database.