[BIGNAMI] JAVA 6 EE Pocket Guide – O’REILLY

Interessante libro su Java 6 EE, ottimo per avere una visione generale (Amazon).

Free pdf download della versione *bignami* in italiano da qui ;)
Java6EEPocketGuide_BIGNAMI
Annunci

SCJP Sun Certified Programmer for Java 6 Study Guide – Object Orientation

Object Orientation

Encapsulation (Exam Objective 5.1)

Il beneficio chiave dell’encapsulation è la possibilità di cambiare il codice di determinate classi, senza danneggiare altre classi che vi fanno riferimento.

Per ottenere questo beneficio è necessario nascondere i dettagli dell’implementazione dietro a una interfaccia pubblica. In questo caso, per interfaccia si intende un insieme di metodi accessibili dall’esterno, in pratica l’API del codice. Nascondendo i dettagli implementativi, si possono apportare modifiche sul codice senza forzare cambiamenti nel codice che lo chiama.
Un design che tiene conto dell’encapsulation permette di ottenere mantenibilità, flessibilità ed estensibilità.
Come implementare l’encapsulation:

  • mantenere le variabili di istanza private,
  • esporre metodi di accesso pubblici e forzare il codice chiamante a usare questi metodi invece delle di usare direttamente le variabili di istanza,
  • per i metodi, utilizzare la naming convention dei JavaBean (set<someProperty>, get<someProperty>).

Inheritance, Is-A, Has-A (Exam Objective 5.5)

Ogni classe Java è una sottoclasse della classe Object, quindi ogni classe, presente e futura, erediterà da Object.
Per l’esame è necessario sapere che si possono creare relazioni di ereditarietà estendendo una classe. E’ anche importante capire quali sono le due ragioni principali per usare l’ereditarietà:
1) promuovere il riuso del codice
2) usare il polimorfismo.

Riuso: un comune approccio di design è quello di creare classi base che espongano funzionalità comuni a un insieme di oggetti, per poi creare sottoclassi più specializzate che ereditino da essa. Il riuso del codice attraverso l’ereditarietà significa che metodi con funzionalità generiche non necessitano di essere re-implementati in più classi.

Polimorfismo: usando l’ereditarietà si può accedere alla classi in modo polimorfico, vale a dire che ogni sottoclasse può essere trattata come la classe padre.

IS-A and HAS-A Relationships
Per l’esame è necessario saper riconoscere se il codice implementa una relazione IS-A o una relazione HAS-A.

  • IS-A
    • Una relazione IS-A è un modo per dire “questa cosa è del tipo di questa altra cosa”, si può esprimere
      implementando l’ereditarietà fra classi (attraverso la parola chiave “extends”) o con l’implementazione di interfaccie (attraverso la parola chiave “implements”)
  • HAS-A
    • La relazione HAS-A è basata sull’uso, invece che sulla ereditarietà. In altre parole, la classe A HAS-A B se il codice nella classe A fa riferimento ad una istanza della classe B.

Polymorphism (Exam Objective 5.2)

Escludendo gli oggetti di tipo Object, tutti gli oggetti java sono polimorfici se passano il test della relazione IS-A per il loro stesso tipo e per la classe Object.

Da ricordare che l’unico modo per accedere ad un oggetto è attraverso reference variable, e ci sono dei concetti chiave da tenere a mente:

  • Una reference variable può essere solo di un tipo e, una volta dichiarato, questo tipo non può mai essere cambiato.
  • Una reference è una variabile, quindi può essere re-assegnata ad altri oggetti (a meno che non sia dichiarata final).
  • Il tipo della reference variable determina i metodi che possono essere invocati sull’oggetto a cui la variabile fa riferimento.
  • Una reference variable può rappresentare un oggetto dello stesso tipo del tipo dichiarato per la reference o ogni sottotipo del tipo dichiarato.
  • Il tipo dichiarato di una reference variable può essere una classe o una interfaccia. Se il tipo è un’interfaccia può indicare ogni oggetti di ogni classe che implementa tale interfaccia.

The Java 6 EE Tutorial – Validazioni in JSF

Le validazioni JSF si ottengono in diversi modi:

  1. Usando JSF validator tag da annidare nella dichiarazione dei componenti nella view: viene fatto il binding tramite value expression ad una proprietà del backing bean.
  2. Creando un metodo nel backing beane facendovi riferimento nel componente tramite l’attributo validator.
    1. Il metodo del backing bean che esegue la validazione deve accettare un FacesContext, il componente i cui dati devono essere validati e il dato da validare ( stessa signature del metodo validate dell’interfaccia Validator). Possono essere validati solo valori di componenti UIInput o di suoi discendenti).
  3. Usando Bean Validator (NEW IN Java 6). I constraints per la validazione sono definiti tramite annotation su campi, metodi o classi di JavaBean component (quindi anche backing bean). Sono disponibili constraints built-in e in più se ne possono definire altre custom. Si può mettere più di un constraint sullo stesso elemento.

Esempi

JSF validator tag

<h:inputText id="Username" value="#{UserBean.userName}">
   <f:validateLength minimum="6" maximum="15"/>
</h:inputText>

Metodo nel backing bean

public void validateEmail(FacesContext context,UIComponent toValidate, Object value) {
  String message = "";
  String email = (String) value;
  if (email.contains(’@’)) {
    ((UIInput)toValidate).setValid(false);
    message = CoffeeBreakBean.loadErrorMessage(context,CoffeeBreakBean.CB_RESOURCE_BUNDLE_NAME,    "EMailError");
    context.addMessage(toValidate.getClientId(context),new FacesMessage(message));
  }
}

Nella view

<h:inputText value="#{userBean.email}" validator="#{userBean.validateEmail}">
</h:inputText>

Bean Validator 

Built-in

public class Name {
  @NotNull
  @Size(min=1, max=16)
  private String firstname;
  @NotNull
  @Size(min=1, max=16)
  private String lastname;
}

Validatori built-in disponibili

Custom

@NotNull
@Size(min = 3)
@FirstUpper
public String getName() {
  return name;
}
Definizione della annotation
package me.m1key.jsf.constraints;

import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;

@Documented
@Constraint(validatedBy = FirstUpperValidator.class)
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RetentionPolicy.RUNTIME)

public @interface FirstUpper {
  String message() default "{me.m1key.jsf.constraints.FirstUpper.message}";
  Class<?>[] groups() default {};
  Class<? extends Payload>[] payload() default {};
}
Implementazione del validatore
package me.m1key.jsf.constraints;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class FirstUpperValidator implements ConstraintValidator<FirstUpper, String> {
@Override
public void initialize(FirstUpper firstUpper) {
 // See JSR 303 Section 2.4.1 for sample implementation.
}

@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
  if (value == null || value.length() == 0) {
    return true;
  }
  return value.substring(0, 1).equals(value.substring(0, 1).toUpperCase());
}
}
See more at:
http://viralpatel.net/blogs/javaserver-faces-jsf-validation-tutorial-error-handling-jsf-validator/
http://www.mkyong.com/jsf2/custom-validator-in-jsf-2-0/
http://blog.m1key.me/2010/07/custom-validation-with-bean-validation.html

The Java 6 EE Tutorial – Expression Language

Reference ad oggetti

  • JavaBean components
  • Collections
  • Java SE enumerated types
  • Implicit object

Si scrive una espressione usando una variabile, che è il nome dell’oggetto. Il web container valuta la variabile cercando il suo valore sulla base del comportamento del metodo PageContext.findAttribute(String) dove String = nome variabile. La ricerca viene fatta dentro a:

    • la pagina
    • la request
    • la session
    • l’application scope.

Se non trovato torna null.

Recupero numero connessioni aperte PostgreSQL tramite JPA

La tabella da interrogare per recuperare il numero di connessioni aperte su PostgreSQL è la pg_stat_activity.

Nel mio caso, l’obiettivo è visualizzare in una pagina JSF il numero di connessioni aperte. Il recupero dati è gestito tramite JPA.

Nel componente EJB si può creare una query JPA nativa per eseguire la select count:

Query query = entityManager
 .createNativeQuery("SELECT count(*) as open_connection FROM pg_stat_activity where datname = :parNomeDb and usename = :parUsername");
query.setParameter("parNomeDb", nomeDb);
query.setParameter("parUsername", username);
BigInteger connessioniAperte = (BigInteger) query.getSingleResult();
return connessioniAperte;