Un type pour une valeur ou une erreur

import java.util.Optional;

public abstract class Validation<E, T> {

    private Validation() {}

    abstract Validation<T, E> swap();

    abstract Optional<T> toOptional();

    public static class Success<E, T> extends Validation<E, T> {
        private final T value;

        public Success(T value) {
            this.value = value;
        }

        @Override
        Failure<T, E> swap() {
            return new Failure<>(value);
        }

        @Override
        public Optional<T> toOptional() {
            return Optional.ofNullable(value);
        }

    }

    public static class Failure<E, T> extends Validation<E, T> {

        private final E error;

        public Failure(E error) {
            this.error = error;
        }

        @Override
        Optional<T> toOptional() {
            return Optional.empty();
        }

        @Override
        Success<T, E> swap() {
            return new Success<>(error);
        }

    }
}

Limiter le nombre de sous-classes

abstract class Base {

    private Base() {}

    public static class Class1 extends Base { ... }
    public static class Class2 extends Base { ... }

}

 

JPA – Trucs et astuces

  • mettre les annotations sur les méthodes et non sur les attributs
  • chaque entité doit implémenter java.io.Serializable
  • utiliser les annotations Embeddable / Embedded pour mieux définir le domaine métier
  • utiliser des données du domaine pour implémenter equals/hashcode et non l’identifiant technique
  • visibilité du constructeur sans argument : protected
  • visibilité du setter de l’indentifiant technique : protected
  • ne pas utiliser de type primitif sur une entité
  • utiliser l’annotation Basic pour ajouter l’information optional=false par défaut
  • utiliser l’annotation Column pour maîtriser le mapping
  • utiliser l’annotation Temporal pour les types temporel
  • ne pas utiliser les types java.sql.Date et java.sql.Timestamp

JPA JoinColumn vs MappedBy

Extrait la page : http://stackoverflow.com/questions/11938253/jpa-joincolumn-vs-mappedby

@JoinColumn could be used on both sides of the relationship. The question was about using @JoinColumn on the @OneToMany side (rare case). And the point here is in physical information location.

According to documentation:

Since many to one are (almost) always the owner side of a bidirectional relationship in the JPA spec, the one to many association is annotated by @OneToMany(mappedBy=…)

@Entity
public class Troop {
@OneToMany(mappedBy="troop")
public Set getSoldiers() {
...
}

@Entity
public class Soldier {
@ManyToOne
@JoinColumn(name="troop_fk")
public Troop getTroop() {
...
}

Troop has a bidirectional one to many relationship with Soldier through the troop property. You don’t have to (must not) define any physical mapping in the mappedBy side.

To map a bidirectional one to many, with the one-to-many side as the owning side, you have to remove the mappedBy element and set the many to one @JoinColumn as insertable and updatable to false. This solution is not optimized and will produce some additional UPDATE statements.

@Entity
public class Troop {
@OneToMany
@JoinColumn(name="troop_fk") //we need to duplicate the physical information
public Set getSoldiers() {
...
}

@Entity
public class Soldier {
@ManyToOne
@JoinColumn(name="troop_fk", insertable=false, updatable=false)
public Troop getTroop() {
...
}

Rafraîchissement d’une vue matérialisée

Afin d’activer le rafraichissement d’une vue en mode FAST REFRESH, il faut avant de créer la vue matérialisée, créer l’objet qui va contenir le journal des modifications (logs)
CREATE MATERIALIZED VIEW LOG ON "MA_TABLE";
CREATE MATERIALIZED VIEW "MA_TABLE_REPORT" AS SELECT * FROM "MA_TABLE";

L’objet journal créé, MLOG$_MA_TABLE, va contenir les modifications à apporter entre chaque rafraîchissement.

 

Problème de timezone

ORA-01882: timezone region not found

La timezone peut être renseignée au lancement de la machine virtuelle :
export JAVA_OPTS="-Duser.timezone=='+01:00'"

Bibliothèques JAVA

Joda Time

Cette bibliothèque permet de gérer le temps plus finement que dans Java en standard

http://joda-time.sourceforge.net/index.html