Blog - Pagina 46 di 47 - Programming Academy

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

</id>

<set name=”conticorrenti” table=”unione”

inverse=”false” lazy=”true” fetch=”select” cascade=”all” >

<key>

</key>

<many-to-many entity-name=”com.prova.ContoCorrente”>

</many-to-many>

</set>

</class>

</hibernate-mapping>

File : ContoCorrente.hbm.xml

<hibernate-mapping>

</id>

<key>

</key>

<many-to-many entity-name=”com.prova.Persona”>

</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 );

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.

I 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.

Elettronica di Base: Generatori Continua

Esistono due tipi di generatori in continua: di tensione e di corrente.

Generatore di tensione
Lo scopo principale di questo generatore è fornire una tensione costante, detta di targa, a prescindere da quale sia il carico collegato. Per poter fare questo, essendo V=R*I, variare la corrente in base al carico.
Nel caso in cui si abbia un R piccolissima, o un corto circuito, il generatore dovrà erogare una corrente altissima, nel far questo o si romperà o salterà qualche fusibile di protezione.
Quindi riassumendo avremo:

la tensione in uscita dipende ESCLUSIVAMENTE dal generatore, e non dal carico.
la corrente in uscita dipende ESCLUSIVAMENTE dal carico, e non dal generatore.

Nel 99% dei casi si ha a che fare con generatori di tensione.

Generatore di corrente
In questo caso è la corrente che deve rimanere sempre costante. Per fare ciò, il generatore varierà la tensione. Quindi nel caso di un circuito aperto la tensione salirà fino a quando o si rompe o scattano dei circuiti di sicurezza che fanno scaricare la tensione accumulata.
Riassumendo, nel caso di un generatore di corrente si ha:

la corrente in uscita dipende ESCLUSIVAMENTE dal generatore, e non dal carico.
la tensione in uscita dipende ESCLUSIVAMENTE dal carico, e non dal generatore.

Android: Grafica 2D, le basi

I compontenti di base per poter fare grafica 2D con android sono:
la View, che tramite le chiamate al suo metodo onDraw ci permette di ridisegnare lo schermo.
il Canvas, la classe che contiene le api fondamentali per disegnare (es. drawLine(), drawCircle(), etc.) su una immagine(bitmap) .
la Bitmap, che contiene i pixel, ossia l’immagine vera e propria.
un Paint, che descrive i colori e gli stili per disegnare.

con l’esempio sotto disegniamo un rettangolo rosso

Bitmap bitMapEsempio = BitmapFactory.decodeResource(res, R.drawable.qualche img);
Canvas canvasMaschera = new Canvas(bitMapEsempio);
Paint paint = new Paint();
paint.setColor(Color.RED);
canvasMaschera.drawRect(left, top, right, bottom, paint);// se paint è null si hanno immagini opache

non alllocare troppi oggetti nel metodo View.onDraw, questo metodo viene richiamato tante volte, e quindi potrebbe rallentare di molto l’app.