h:dataTable JSF2

h:dataTable è un tag  per visualizzare  una lista di oggetti in una tabella HTML.
Creare una classe User che contiene le informazioni da visualizzare:

User.java

package com;
public class User {
private String name;
private String surname;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSurname() {
return surname;
}
public void setSurname(String surname) {
this.surname = surname;
}
}

Creare un backing bean

TableExampleBean

package com;

import java.util.ArrayList;
import java.util.List;

import javax.annotation.PostConstruct;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;

@ManagedBean
@SessionScoped
public class TableExampleBean {

private List<User> users;

@PostConstruct
public void init() {
users = new ArrayList<User>();

User user = new User();
user.setName(“Paperino”);
user.setSurname(“Rossi”);
users.add(user);

user = new User();
user.setName(“Pippo”);
user.setSurname(“Rossi”);
users.add(user);

user = new User();
user.setName(“Pluto”);
user.setSurname(“Rossi”);
users.add(user);

}

public List<User> getUsers() {
return users;
}

public void setUsers(List<User> users) {
this.users = users;
}

}

Creare la pagina xhtml contenente il tag

showUsers.xhtml

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>
<html xmlns=”http://www.w3.org/1999/xhtml”
xmlns:f=”http://java.sun.com/jsf/core”
xmlns:h=”http://java.sun.com/jsf/html”
xmlns:ui=”http://java.sun.com/jsf/facelets”
xmlns:p=”http://primefaces.org/ui”
xmlns:c=”http://java.sun.com/jsp/jstl/core”>
<h:head>
</h:head>
<h:body>
<h:form>
<h:dataTable var=”user” value=”#{tableExampleBean.users}”>
<h:column>
<h:outputText value=”#{user.name}” />
</h:column>
<h:column>
<h:outputText value=”#{user.surname}” />
</h:column>
</h:dataTable>
</h:form>
</h:body>
</html>

Output visualizzato:

Raspberry XBMC Setup

Inserire la scheda SD nel lettore.
Scaricare da qui   l’installer per windows.
Scompattare il file e cliccare sul file “setup.exe”.
Apparirà questa schermata:

Selezionare “I accept the license….” e cliccare su install.
La scheda SD ora è completa.
Inserire la scheda SD nel raspberry e collegare mouse tastiera rete e televisione.
Ci vorrà qualche minuto per completare l’installazione.
L’XBMC si presenterà così:

Per settare la lingua andare su Appearance–>Settings e selezionare il tab International, selezionare la lingua desiderata.
Si possono aggiungere molti add-ons, anche per poter vedere direttamente i video di youtube.

Per trasferire i file dal PC al raspberry io ho usato un client FTP FileZilla 

cliccare  su “gestione siti”:

selezionare “nuovo sito”, inserire l’IP del raspberry (System–>System info–>Network), come protocollo mettere “SFTP”.

User: pi
Password: raspberry

ora si possono trasferire tutti i file che si vuole direttamente dal PC.
Andare in Video–>File–>Aggiungi Video–>Esplora–>Root System e selezionare la cartella in cui si trovano i film copiati dal PC.

Per accedere via web dal PC l’xbmc, inserire nel browser l’IP del raspberry.

Selezionare Remote e si aprirà una console di controllo

Volendo si può evitare di mettere tastiera e mouse e controllare tutto dal PC.

PrimeFaces Upload File

In PrimceFaces the tag for upload file is p:fileUpload.

This is the xhtml page

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>
<html xmlns=”http://www.w3.org/1999/xhtml”
xmlns:f=”http://java.sun.com/jsf/core”
xmlns:h=”http://java.sun.com/jsf/html”
xmlns:ui=”http://java.sun.com/jsf/facelets”
xmlns:p=”http://primefaces.org/ui”
xmlns:c=”http://java.sun.com/jsp/jstl/core”>
<h:head>
</h:head>
<h:body>
<h:form>
<p:fileUpload
fileUploadListener=”#{fileUploadController.handleFileUpload}”
mode=”advanced” dragDropSupport=”false” update=”messages”
sizeLimit=”100000″ fileLimit=”3″
allowTypes=”/(.|/)(gif|jpe?g|png)$/” />
<p:growl id=”messages” showDetail=”true” />
</h:form>
</h:body>
</html>

The managed bean is:

import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;  
import org.primefaces.event.FileUploadEvent;
import org.primefaces.model.UploadedFile;  
@Component
@ManagedBean
@SessionScoped
public class FileUploadController {
      public void handleFileUpload(FileUploadEvent event) {
        FacesMessage msg = new FacesMessage(“Succesful”, event.getFile().getFileName() + ” is uploaded.”);
        FacesContext.getCurrentInstance().addMessage(null, msg);
        //get uploaded file from the event
        UploadedFile uploadedFile = (UploadedFile)event.getFile();

        //create an InputStream from the uploaded file
        InputStream inputStr = null;
        try {
            inputStr = uploadedFile.getInputstream();
        } catch (IOException e) {
            //log error
        e.printStackTrace();
        }

        //create destination File
        String destPath = “D:\fbm\user\”+event.getFile().getFileName();
        File destFile = new File(destPath);

        //use org.apache.commons.io.FileUtils to copy the File
        try {                  
            FileUtils.copyInputStreamToFile(inputStr, destFile);
        } catch (IOException e) {
            //log error
        e.printStackTrace();
        }
    }
}

 In the web.xml add:

<filter>
    <filter-name>PrimeFaces FileUpload Filter</filter-name>
    <filter-class>
        org.primefaces.webapp.filter.FileUploadFilter
    </filter-class>
</filter>
<filter-mapping>
    <filter-name>PrimeFaces FileUpload Filter</filter-name>
    <servlet-name>Faces Servlet</servlet-name>
</filter-mapping>

download this jar:

commons-fileupload
commons-io

this is the output:

Hibernate: Mappatura many to many (xml)

Many-to-many  si ha quando un record di una tabella può essere collegato con tanti record su un altra tabella,e viceversa. 

ogni PERSONA può avere più CONTICORRENTI  e ogni CONTOCORRENTE può appartanere a più PERSONE.


File : Persona.java
package com.prova;
 import java.util.HashSet;
import java.util.Set;
 public class Persona implements java.io.Serializable {
  private Integer personaId;
private Set<ContoCorrente> contiCorrenti= new HashSet<ContoCorrente>(0);
  //getter, setter and constructor
}

File : ContoCorrente.java
package com.prova; 
import java.util.HashSet;
import java.util.Set;
 public class ContoCorrente implements java.io.Serializable {
  private Integer contoCorrenteId;
private Set<Persona> persone= new HashSet<Persone>(0);
  //getter, setter and constructor
}


File : Persona.hbm.xml
    <class name=”com.prova.Persona” table=”persona” catalog=”provadb”>
        <id name=”personaId” type=”java.lang.Integer”>
            <column name=”PERSONA_ID” />
            <generator class=”identity” />
        </id>
        <set name=”conticorrenti” table=”unione” 
         inverse=”false” lazy=”true” fetch=”select” cascade=”all” >
            <key>
                <column name=”PERSONA_ID” not-null=”true” />
            </key>
            <many-to-many entity-name=”com.prova.ContoCorrente”>
                <column name=”CONTO_CORRENTE_ID” not-null=”true” />
            </many-to-many>
        </set>
    </class>
</hibernate-mapping>




File : ContoCorrente.hbm.xml
<hibernate-mapping>
    <class name=”com.prova.ContoCorrente” table=”contocorrente” catalog=”mkyongdb”>
        <id name=”contoCorrenteId” type=”java.lang.Integer”>
            <column name=”CONTO_CORRENTE_ID” />
            <generator class=”identity” />
        </id>
       <set name=”persone” table=”unione” inverse=”true” lazy=”true” fetch=”select”>
            <key>
                <column name=”CONTO_CORRENTE_ID” not-null=”true” />
            </key>
            <many-to-many entity-name=”com.prova.Persona”>
                <column name=”PERSONA_ID” not-null=”true” />
            </many-to-many>
        </set>
    </class>
</hibernate-mapping>


Testiamo il tutto

File : App.java
public class App {
public static void main(String[] args) {
        System.out.println(“Hibernate many to many (XML Mapping)”);
Session session = HibernateUtil.getSessionFactory().openSession();
  session.beginTransaction();
  Persona persona = new Persona();
        ContoCorrente contoCorrente1 = new ContoCorrente ();
        ContoCorrente  contoCorrente2= new ContoCorrente ();
        Set<ContoCorrente > contoCorrenti= new HashSet<ContoCorrente >();
        contoCorrenti.add(contoCorrente1 );
        contoCorrenti.add(contoCorrente1 );
        persona.setContiCorrenti(contoCorrenti);
        session.save(persona);
  session.getTransaction().commit();
System.out.println(“Done”);
}
}

HashCode

Quando si ha che fare con gli oggetti, è buona norma riderifinire il metodo equals e anche il metodo hashcode().
In particolare, se abbiamo a che fare per esempio con mappe (hashset, set, etc), gli oggetti verranno inseriti in locazioni di 
memoria identificati con un valore detto bucket. All’interno dello bucket ci possono essere più oggetti.
Questo bucket è dato appunto dal metodo hashCode.
Il metodo hashcode deve essere ridefinito in base alle seguenti regole:
– se due oggetti risultano uguali in base a equals() allora anche i loro hash code devono essere uguali.
– se due oggetti hanno hash code differenti, allora equals() deve indicare che sono diversi.
Esistono anche gli altri 2 casi:
– se due oggetti sono diversi, secondo equals, possono avere hash code uguali o differenti.
– se due oggetti hanno hash code uguali, possono essere uguali o no.
Quando si fa una ricerca di un oggetto nella mappa, prima si controlla se si ha il suo hashcode(bucket),
se, e solo se, il bucket è presente si chiamare il metodo equals per fare l’ultima verifica. Questo 
perche come abbiamo detto nello stesso bucket possono essere inseriti più bucket.

Swing – Introduzione

Per fare grafica in java esistono principalmente due framework:
AWT, un package pesante ormai obsoleto
Swing, un package che a riutilizzato molte componenti di AWT ma migliorate e allegerite. Si riconoscono le componenti che discendono da AWT  perche hanno mantenuto lo stesso nome ma è stata aggiunta una J.

listener-adapter sono degli elementi che, associati a qualche componente, rimangono in ascolto di qualche evento (qualche click, focus, etc) che coinvolge il component suddetto. La differenza tra listener e adapter è, fondamentalmente, che usando i listener, essendo interfaccie, si deve implementare tutti i metodi, mentre con gli adapter, che a loro volta estendono i listener, si deve implementare solo alcuni metodi.

Un Component è un oggetto che può essere visualizzato a schermo e interagisce con l’utente tramite eventi, ad esempio con un click del mouse su tale oggetto. Esempi di Component sono i pulsanti, le checkbox, etc.
Un Container è un component che può contenere altri component, tramite i metodi  add(Component c) e remove(Component c).
Un container che non è contenuto in nessun altro oggetto viene detto Window.
Una Window non ha bordi, barre o controlli’ e ha la possibilità di contenere diversi Component sulla sua superficie.
Un Frame, invece, è una window provvista di bordi che  può essere ridimensionata o ridotto a icona tramite mouse. I JFrame sono i frame di JSwing, che sono uguali ai frame  di AWT ma ne risolvono  alcune problematiche.

Un JFrame può essere considerato come un contenitore di “alto livello”.Al suo interno contiene una successione di sotto-contenitori, detti Pannelli, ognuno con le sue particolarità:

  • Root Pane, poggiato direttamente sulla superficie del JFrame, che contiene il glass pane;
  • Glass Pane, un pannello  che cattura le azioni effettuate tramite il puntatore del mouse sulla finestra;
  • Layered Pane, serve a contenere un eventuale menù e il content pane;
  • Content Pane, che serve a contenere tutti gli elementi della GUI (componenti, contenitori, elementi di alto e basso livello) da aggiungere al JFrame. 
Si puo usare direttamente il Content Pane per aggiungere gli oggetti della GUI, ma per avere un maggior controllo, si preferisce usare ulteriori pannelli generici (JPanel).

Un Toolkit è un oggetto AWT  che da informazioni sulle caratteristiche dell’oggetto sul quale viene chiamato.

Codice Di Esempio

package allin.frontend.gui;

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;

public class GUIMain extends JFrame {
private JMenuBar barraDeiMenu;
private JMenu menu1, menu2, menu3;
private JMenuItem menuItem1, menuItem2, menuItem3, menuItem4;

public GUIMain() throws IOException {
this.setTitle(“Esempio di JFrame con menù”);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Toolkit mioToolkit = Toolkit.getDefaultToolkit();
Dimension dimensioniSchermo = mioToolkit.getScreenSize();

this.setSize((int) dimensioniSchermo.getWidth()-200,
(int) dimensioniSchermo.getHeight()-100);

// NOTA IMPORTANTE: l’origine del sistema di riferimento dello schermo
// (punto (0,0)) è situata IN ALTO A SINISTRA; (x,y)valori y positivi
// ‘scendendo’, x positivi proseguendo ‘verso destra’.
// con questo metodo si dice dove deve essere messo l angolo a sinistra
// del frame
this.setLocation(0, 0);

// Credo ed aggiungo la barra del menù, alcuni menù e voci del menù di
// esempio
barraDeiMenu = new JMenuBar();

menu1 = new JMenu(“File”);
menu2 = new JMenu(“Finestra”);
menu3 = new JMenu(“Aiuto”);

menu1.setMnemonic(‘f’);

menuItem1 = new JMenuItem(“Apri”);
menuItem2 = new JMenuItem(“Esci”);
menuItem3 = new JMenuItem(“Schermo intero”);
menuItem4 = new JMenuItem(“?”);

menuItem1.setMnemonic(‘a’);

menu1.add(menuItem1);
menu1.add(menuItem2);
menu2.add(menuItem3);
menu3.add(menuItem4);

barraDeiMenu.add(menu1);
barraDeiMenu.add(menu2);
barraDeiMenu.add(menu3);

this.setJMenuBar(barraDeiMenu);

Container content = getContentPane();

JPanel provaPanel = new JPanel();
JButton button = new JButton(“Click”);
provaPanel.add(button);
content.add(provaPanel,BorderLayout.EAST);


JPanel provaPanel1 = new JPanel();
JButton button1 = new JButton(“Clack”);
provaPanel1.add(button1);
content.add(provaPanel1,BorderLayout.WEST);

}

public static void main(String[] args) {
GUIMain pm;
try {
pm = new GUIMain();
pm.setVisible(true);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}

Raspberry

Il raspberry è un piccolo computer sviluppato nel Regno Unito della grandezza di circa una carta di credito venduto a basso costo.
Ha una CPU da 700MHz e una RAM 256/512 Mbyte. Non ha harddisk ma per il boot e per la memorizzazione dei dati si affida ad una scheda SD. Si basa su un sistema operativo con kernel Linux. E’ dotato di un connettore GPIO che permette di interfacciarsi con dispositivi esterni, quali ad esempio LED, rele, etc. La connessione ad internet è garantita dalla porta lan mentre mouse e tastiera vengono collegati attraverso le due porte USB. E’ presente una uscita audio con jack da 3,5mm mentre il collegamento al monitor avviene tramite cavetto hdmi o RCA. La potenza assorbita è di appena 700 mhA e 3,5 volt
Installare il sistema operativo su scheda SD
-Scaricare l’immagine del sistema operativo da qui . Ci sono più versioni, io personalmente ho scelto “Soft-float Debian” essendo l’unico, per ora, su cui può girare java.
– Scaricare il file win32diskimager e installarlo. 
– Lanciare win32diskimager, selezionare l’immagine del sistema operativo e la scheda SD.
– Cliccare su write e abbiamo la scheda SD pronta per l’uso
Se si ha un sistema operativo diverso da windows seguire queste istruzioni

Arduino: Controllare temperatura e umidità

DESCRIZIONE
Misurare temperatura e umidità tramite il sensore DHT11 e arduino.

Osservando il datasheet del DHT11 si nota che va collegata anche una resistenza (detta di pull-up) sul pin 2, e anche che vengono usati solo 3 piedini su 4 disponibili.
qui troverete la libreria che permette di usarlo

MATERIALE USATO
Sensore umidità e temperatura DHT11
Resistenza da 5k
Arduino

SCHEMA

SKETCH
#include

dht11 DHT11;

#define DHT11PIN 2

void setup()
{
  Serial.begin(9600);

}

void loop()
{

  int chk = DHT11.read(DHT11PIN);

  Serial.print("stato sensore: ");
  switch (chk)
  {
    case 0: Serial.println("OK"); break;
    case -1: Serial.println("Checksum error"); break;
    case -2: Serial.println("Time out error"); break;
    default: Serial.println("Unknown error"); break;
  }

  Serial.print("Umidita (%): ");
  Serial.println((float)DHT11.humidity, 2);

  Serial.print("Temperatura (Celsius): ");
  Serial.println((float)DHT11.temperature, 2);

  delay(5000);
}

Arduino: controllare una lampada da 220V

Lo scopo è  interrompere la fase di una 220v, che alimenta una lampadina, per 5 secondi e poi mantenerla per altri 5 e cosi via.
Materiale occorrente:
1 resistenza da 330 ohm
1 rele con input 28VDC10A – ouput 220/250VAC10A
1 transistor BC547
1 diodo 1N4001
Il rele è un interruttore controllato da una bobina. In base a quanta corrente entra nella bobina l’interruttore 1 sarà chiuso su 3  o su 2. Da notare che si controlla un circuito con la corrente di un’altro circuito, nel nostro caso si controlla la 220V con un circuito di 6V.
Lo schema seguito è quello sotto
Lo sketch caricato su arduino:
int tempPinBase = 13; 
void setup()
{
  
 Serial.begin(9600); //apertura porta seriale, set della velocità a 9600 bps
}
void loop()
{
digitalWrite(tempPinBase, HIGH);
delay(5000);  
digitalWrite(tempPinBase, LOW);
delay(5000);
//aspetta 5 secondo prima di ripetere
}
come si vede è abbastanza semplice. Manda tensione alta, conta fino a 5,  spegne, conta fino a 5.
Prima di provarlo direttamente con la 220V (con la 220V SI MUORE) ho messo al posto della lampada  e del generatore, una resistenza e un LED alimentati da 5V.

Transistor BJT

Un transistor è un dispositivo  elettronico a tre terminali: base, collettore e emettitore,
a volte  anche chiamato BJT.

E’ formato unendo 3 strati NPN o PNP. La versione NPN è quella più usata.
Ponendo l’emettitore a massa si dice che la il transistor è viene usato con la configurazione “emettitore comune”.

La sua caratteristica principale  è quella di essere pilotato in corrente, a differenza del JFET che è, invece, pilotato dalla  tensione.

Il transistor ha due possibili utilizzi: interruttore controllato o amplificatore lineare .

Interruttore controllato
Se la corrente nella base è nulla allora anche le correnti nel collettore e nell’emettitore
sono nulle. Lo si può vedere come un interruttore aperto tra collettore ed emettitore. In questo caso si dice che il transistor è in “interdizione“.
Se la corrente nella base è sufficiente, si ha una corrente che entra nel collettore ed esce dall’emettitore, quindi è come se si avesse un interruttore chiuso tra collettore ed emettitore.
A differenza di un normale interruttore, la corrente può scorrere tra Collettore ed Emettitore ma non viceversa  (si noti il verso della freccia sull’emettitore). La corrente di base può essere solo entrante. Si ha che  la corrente del collettore è uguale alla corrente della base sommata alla corrente dell’emettitore.
In questo caso si dice che il transistor è in “saturazione“.

 Amplificatore lineare
Il seguente  grafico mostra la corrente di collettore Ic in funzione della tensione Vce, mantenendo costante la Ib

All’aumentare della Vce, inizialmente la Ic è zero; poi aumenta linearmente e rapidamente fino al ginocchio; superato il ginocchio, la Ic resta praticamente costante, anche se aumenta la Vce,come se fosse un interruttore chiuso.
Si nota che, in base alla corrente di base, mantenendo costante la Vce, possiamo controllare la Ic, e variarla in modo lineare.
Quindi alimentando il collettore con una certa tensione e la base con un altra, possiamo con una piccola Ib controllare, e quindi anche aumentarla (amplificarla), una grande Ic.

Per una spiegazione più approfondita, qua troverete un ottimo tutorial.