Installare tomcat 6 e postgresql 8.4 su ubuntu server 10.04

L’ambiente più familiare (lato server) per realizzare applicazioni web su linux è senza ombra di dubbio un server LAMP (Linux Apache MySQL PHP).

Ormai lo si riesce ad installare senza grosse difficoltà anche in ambiente linux, grazie (ancora una volta) ad ubuntu che mette a disposizione e ci configura tutti i pacchetti necessari per avere un ambiente completamente funzionante.

A volte risulta però necessario uscire dal seminato, cambiando magari DBMS o linguaggio di programmazione. Vuoi perchè si vuole avere un db più simile ad Oracle o vuoi perchè si preferisce un linguaggio più strutturato o più familiare ai programmatori.

Mi è successo alcuni giorni fa di provare a configurare sul mio server di casa, un ubuntu server 10.04 LTS, un gestionale web scritto in java compatibile con sql server o postgresql. Visto che, come saprà chi mi conosce, non amo molto le tecnologie microsoft e che non credo si riesca ad installare sql server su linux, ho deciso di buttarmi su postgresql ;-)…

Dovremmo quindi installare tomcat per avere un server web java e postgresql per il lato database.

Per prima cosa, assicuriamoci di avere il java development kit di Sun installato:

sudo apt-get install sun-java6-jdk

Ora possiamo procedere con l’installazione del server web tomcat:

sudo apt-get install tomcat6
sudo apt-get install tomcat6-admin

Una volta installati questi pacchetti il nostro server web sarà pronto per essere utilizzato e amministrato, potete verificarne il funzionamento digitanto da browser http://ip_server:8080/, dove ipserver sarà l’indirizzo ip della macchina su cui avete installato tomcat.

Per poter entrare nella sezione di amministrazione delle applicazioni installate in tomcat e verificare lo stato del server, si dovrà creare un utente e fornirgli i privilegi di amministrazione. Per fare ciò editate il file /etc/tomcat6/tomcat-users.xml inserendo le seguenti linee:

<role rolename="admin"/>
<role rolename="manager"/>
<user username="admin" password="admin" roles="admin,manager"/>

Tomcat su linux usa di default le openjdk ovvero le jdk java open source e non quelle ufficiali sun, perciò potreste incorrere in problemi di incompatibilità se installate software non testato su questa piattaforma, per modificare le jdk usate editate il file /etc/default/tomcat6/ e alla voce JAVA_HOME sostituite la linea con questa:

JAVA_HOME=/usr/lib/jvm/java-6-sun

Bene, ora che il server è installato e configurato possiamo passare all’installazione di postgresql:

sudo apt-get install postgresql

Ora che postgresql è installato configuriamo gli indirizzi ip sui quali il db server sarà in ascolto. Potrebbe non essere necessario fare questa configurazione se non desiderate gestire postgresql dall’esterno, ma pgadmin è un tool di gestione per postgresql davvero comodo. Editate quindi il file /etc/postgresql/8.4/main/postgresql.conf così:

listen_addresses = 'localhost,<em>ip_server</em>'

Dove ip_server sarà sempre l’ip della macchina su cui avete installato postgre.

Ora inseriamo la password per l’utente default postgres:

sudo -u postgres psql template1

Si aprirà la shell di postgre e dovremo eseguire la query:

ALTER USER postgres with encrypted password 'password';

Fatto ciò possiamo editare il file dei permessi di postgre /etc/postgresql/8.4/main/pg_hba.conf:

local   all   all   md5
host   all   all   192.168.0.0/24   md5

A questo punto possiamo riavviare sia tomcat sia postgre:

sudo /etc/init.d/tomcat6 restart
sudo /etc/init.d/postgresql-8.4 restart

…e andare a posizionare le nostre applicazioni in /var/lib/tomcat6/webapps/ e gestire i database da shell o tramite pgadmin ;-)

Riempire dinamicamente una jTable in Java

Ultimamente sto utilizzando intensamente Java per lavoro. Sto realizzando un gestionale abbastanza corposo, dove ho potuto sperimentare diverse cose interessanti.

Nel disegnare le interfacce, uno degli oggetti che sto trovando sempre più utile, è la jTable, nient’altro che una semplice tabella (la vecchia DataGrid di visual basic). Inizialmente avevo trovato un po’ ostico capire come funzionasse, nonostante ci fossero parecchi esempi che danno molti consigli su come usarle. Una delle pagine di esempi più complete è questa sul sito oracle.

Voglio però spendere qualche riga per spiegare come poter facilmente caricare una jTable leggendo i dati da un resultset o da un elenco qualsiasi.

Penso che il concetto più semplice per utilizzare al meglio le jTable sia implementare una List<T> (dove T può essere un array di Object o di String o una vostra classe personale, fate voi) con una ArrayList o una LinkedList. Questa lista terrà aggiornata la jTable.

Personalmente creo sempre un metodo che chiamo “refreshTable” che legge i dati dalla lista e li inserisce nella tabella. Il metodo non farà altro che usare un iteratore per scorrere la lista e creare una matrice di Object da passare alla nostra jTable per riempirla.

        //Creo array di intestazioni
        String [] headers=this.getTableHeaders();
        //Creo matrice di dati
        Object[][] data=new Object[this.lista.size()][headers.length];
        int i=0;
        for(Iterator<String[]> it=lista.iterator();it.hasNext();){
            String[] tmp=it.next();
            for(int j=0;j<tmp.length;j++){
                data[i][j]=tmp[j];
            }
            i++;
        }
        //Setto dati e intestazioni della tabella
        this.myJTable.setModel(new javax.swing.table.DefaultTableModel(data, headers){@Override public boolean isCellEditable(int rowIndex, int mColIndex) { return false; }});
        //Setto larghezza colonne
        this.setTableCellsSize(this.myJTable);
        //Imposto allinamento delle celle al centro
        DefaultTableCellRenderer renderer=new DefaultTableCellRenderer();
        renderer.setHorizontalAlignment(DefaultTableCellRenderer.CENTER);
        this.myJTable.setDefaultRenderer(this.myJTable.getColumnClass(0), renderer);
        this.myJTable.updateUI();

Così facendo abbia riempito la nostra jTable. Il metodo che fa ciò è il setModel(), al quale io passo sempre una matrice di Object che contiene i dati veri e propri e un array di String che contiene le intestazioni della tabella (che leggo dal mio metodo this.getTableHeaders() ). Oltre a questo ho creato un metodo (this.setTableCellsSize() ) che imposta la larghezza delle varie colonne della tabella:

        int prefWidth=(this.getWidth()/2)/(this.getHeadersTable()).length;
        tbl.setAutoResizeMode(jTable.AUTO_RESIZE_OFF);

        tbl.getColumnModel().getColumn(0).setPreferredWidth(prefWidth+20);
        tbl.getColumnModel().getColumn(1).setPreferredWidth(prefWidth+100);
        tbl.getColumnModel().getColumn(2).setPreferredWidth(prefWidth+20);
        tbl.getColumnModel().getColumn(3).setPreferredWidth(prefWidth-30);
        tbl.getColumnModel().getColumn(4).setPreferredWidth(prefWidth+20);
        tbl.getColumnModel().getColumn(5).setPreferredWidth(prefWidth+20);
        tbl.getColumnModel().getColumn(6).setPreferredWidth(prefWidth-20);
        tbl.getColumnModel().getColumn(7).setPreferredWidth(prefWidth+20);

Nelle ultime righe ho invece dichiarato un Renderer per settare l’allineamento al centro delle celle della jTable.

Prestate attenzione alla linea dove viene eseguita la setModel(): qui ho riscritto il metodo isCellEditable, in modo che restituisca sempre false. Così facendo qualsiasi cella della nostra jTable non potrà essere editata.

Se vi servissero esempi più dettagliati (ad esempio per inserire delle checkbox in una delle colonne o per aprire menu al pressione del tasto destro del mouse sulla tabella) fate un fischio! ;-)