Visualizzazione post con etichetta programming. Mostra tutti i post
Visualizzazione post con etichetta programming. Mostra tutti i post

lunedì 24 agosto 2026

Domain-Driven Design e Clean Code nell'Ecosistema Spring Boot con Java 25

Nello sviluppo enterprise contemporaneo, costruire applicazioni resilienti ed evolvibili richiede l'abbandono di modelli anemici e architetture centrate sul database. L'adozione congiunta di Domain-Driven Design (DDD) e Clean Code (applicati tramite l'Architettura Esagonale o Ports & Adapters) permette di isolare il core di business dai dettagli infrastrutturali.

Con il rilascio di Java 25 (LTS), il linguaggio offre strumenti formidabili per esprimere i costrutti del DDD in modo nativo: Records, Sealed Interfaces, Pattern Matching avanzato e costruttori flessibili permettono di modellare Value Objects, Entità ed Eventi di Dominio con un livello di rigore e pulizia mai visto prima.


1. Fondamenti: Cosa Significa DDD e Clean Code?

Cos'è il Clean Code?

Formalizzato da Robert C. Martin ("Uncle Bob"), il Clean Code è codice progettato per essere compreso immediatamente da altri sviluppatori, prima ancora che dalle macchine:

  • Single Responsibility Principle (SRP): Una classe o un metodo deve avere una sola ragione per cambiare.
  • Indipendenza dai Framework: Il business core non deve dipendere da Spring, Hibernate, Jackson o protocolli di rete.
  • Espressività e Nomi Intenzionali: Il codice deve essere auto-documentante e privo di effetti collaterali oscuri.
  • Testabilità Isolata: Il core di business deve essere verificabile istantaneamente con Unit Test puri su POJO.

Cos'è il Domain-Driven Design (DDD)?

Introdotto da Eric Evans, il DDD pone la complessità del business ("il Dominio") al centro della progettazione software:

  • Ubiquitous Language (Linguaggio Ubiquo): Vocabolario condiviso tra esperti di business e sviluppatori, riflesso in modo trasparente nelle classi e nei metodi.
  • Bounded Context (Contesti Delimitati): Confini espliciti che delimitano la consistenza semantica del modello.
  • Pattern Tattici:
    • Value Objects: Oggetti immutabili definiti solo dal proprio stato/valore, senza ID (perfetti come record in Java 25).
    • Entities: Oggetti definiti dalla loro identità persistente (es. OrderId).
    • Aggregate Root: Unità atomica di consistenza che incapsula entità interne e garantisce le regole e gli invarianti di business.
    • Domain Events: Fatti immutabili accaduti nel dominio, ideali da modellare con sealed interface e record.
    • Repository Port: Astrazione pura Java che simula una collezione in memoria per salvare/caricare l'aggregato.

2. Il Problema: Anemic Domain Model vs Rich Domain Model

Nelle applicazioni Spring tradizionali, è comune incontrare l'anti-pattern dell'Anemic Domain Model, dove le entità sono meri contenitori di dati (getter/setter) e la logica è sparpagliata in classi @Service gigantesche. Ecco come cambia il paradigma con il Rich Domain Model:

Caratteristica Anemic Model (Anti-Pattern) Rich Domain Model (DDD + Java 25)
Invarianti di Business Violati facilmente da setter indiscriminati. Protetti dentro l'Aggregate Root e Value Objects.
Posizione della Logica Dispersa in grossi @Service procedurali. Incapsulata in Entità, Value Objects e Metodi di Business.
Accoppiamento Framework @Entity, @Table, annotazioni Jackson nel core. POJO e Record puri, zero annotazioni esterne.
Velocità dei Test Test lenti con contesti Spring o mock complessi. Test unitari ultra-rapidi eseguiti in pochi millisecondi.

3. Struttura del Bounded Context (Architettura Esagonale)

L'Architettura Esagonale (Ports & Adapters) permette di mantenere il Dominio al centro, completamente isolato.

com.example.ecommerce.order
 ├── domain                     <-- CORE POJO/RECORD (Zero Spring/JPA)
 │    ├── model                 <-- Order (Aggregate), OrderId, Money, OrderLine
 │    ├── event                 <-- OrderDomainEvent (Sealed Interface)
 │    ├── exception             <-- OrderDomainException
 │    └── repository            <-- OrderRepository (Output Port)
 ├── application                <-- CASI D'USO
 │    ├── dto                   <-- CreateOrderCommand, OrderResponseDto
 │    └── service               <-- CreateOrderUseCaseService
 └── infrastructure             <-- DETTAGLI TECNICI E ADAPTERS
      ├── persistence           <-- OrderJpaEntity, SpringDataOrderRepository
      │    ├── adapter          <-- OrderRepositoryJpaAdapter 
      │    └── mapper           <-- OrderPersistenceMapper (MapStruct)
      └── rest                  <-- OrderRestController (Web Adapter)

4. Configurazione Maven: pom.xml per Java 25

Per supportare le ultime feature, configuriamo Spring Boot 3.5+, MapStruct e Testcontainers per Java 25:

<!-- dependencies essenziali nel pom.xml -->
<properties>
    <java.version>25</java.version>
    <org.mapstruct.version>1.6.3</org.mapstruct.version>
</properties>

<dependencies>
    <!-- Spring Boot Web, Data JPA, Validation -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- MapStruct per il mapping pulito -->
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct</artifactId>
        <version>${org.mapstruct.version}</version>
    </dependency>
</dependencies>

5. Implementazione del Dominio (Java 25)

5.1 Value Objects Immutabili (Records)

I record di Java sono la traduzione naturale dei Value Objects del DDD: garantiscono immutabilità, comparazione per valore e permettono validazioni compatte.

package com.example.ecommerce.order.domain.model;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Currency;

public record Money(BigDecimal amount, Currency currency) {

    public static final Currency EUR = Currency.getInstance("EUR");

    // Compact constructor per le invarianti
    public Money {
        if (amount == null || amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("L'importo non può essere negativo");
        }
        if (currency == null) {
            throw new IllegalArgumentException("La valuta è obbligatoria");
        }
        amount = amount.setScale(2, RoundingMode.HALF_UP);
    }

    public static Money ofEuros(double value) {
        return new Money(BigDecimal.valueOf(value), EUR);
    }

    public static Money zero(Currency currency) {
        return new Money(BigDecimal.ZERO, currency);
    }

    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Valute incompatibili");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }

    public Money multiply(int quantity) {
        return new Money(this.amount.multiply(BigDecimal.valueOf(quantity)), this.currency);
    }
}

Gli identificatori fortemente tipizzati prevengono errori comuni (es. scambiare un OrderId con un CustomerId):

public record OrderId(java.util.UUID value) {
    public OrderId {
        if (value == null) throw new IllegalArgumentException("OrderId non può essere nullo");
    }
    public static OrderId generate() { return new OrderId(java.util.UUID.randomUUID()); }
}

5.2 Domain Events con Sealed Interfaces

Le Sealed Interfaces permettono di creare gerarchie chiuse, perfette per garantire un pattern matching esaustivo in fase di compilazione.

package com.example.ecommerce.order.domain.event;

import com.example.ecommerce.order.domain.model.OrderId;
import com.example.ecommerce.order.domain.model.Money;
import java.time.Instant;
import java.util.UUID;

public sealed interface OrderDomainEvent {
    OrderId orderId();
    Instant occurredOn();

    record OrderCreatedEvent(OrderId orderId, UUID customerId, Instant occurredOn) implements OrderDomainEvent {}
    record OrderPaidEvent(OrderId orderId, Money totalPaid, Instant occurredOn) implements OrderDomainEvent {}
    record OrderCancelledEvent(OrderId orderId, String reason, Instant occurredOn) implements OrderDomainEvent {}
}

5.3 L'Aggregate Root: Il Cuore del Dominio

L'Order non ha annotazioni JPA. Espone solo metodi di business espliciti (ubiquitous language) e non espone setter per alterare illegalmente il suo stato interno.

package com.example.ecommerce.order.domain.model;

import com.example.ecommerce.order.domain.event.OrderDomainEvent;
import com.example.ecommerce.order.domain.event.OrderDomainEvent.*;
import java.time.Instant;
import java.util.*;

public class Order {
    private final OrderId id;
    private final UUID customerId;
    private final List<OrderLine> lines;
    private OrderStatus status;
    private final List<OrderDomainEvent> domainEvents = new ArrayList<>();

    public Order(OrderId id, UUID customerId) {
        if (customerId == null) throw new IllegalArgumentException("CustomerId obbligatorio");
        this.id = Objects.requireNonNull(id, "OrderId obbligatorio");
        this.customerId = customerId;
        this.lines = new ArrayList<>();
        this.status = OrderStatus.CREATED;

        recordEvent(new OrderCreatedEvent(this.id, this.customerId, Instant.now()));
    }

    public void addProduct(UUID productId, Money unitPrice, int quantity) {
        if (this.status != OrderStatus.CREATED) {
            throw new IllegalStateException("Impossibile modificare un ordine nello stato " + this.status);
        }
        this.lines.add(new OrderLine(productId, unitPrice, quantity));
    }

    public Money calculateTotal() {
        if (lines.isEmpty()) return Money.zero(Money.EUR);
        return lines.stream()
                .map(OrderLine::calculateSubtotal)
                .reduce(Money.zero(Money.EUR), Money::add);
    }

    public void markAsPaid() {
        if (this.status != OrderStatus.CREATED) {
            throw new IllegalStateException("Solo gli ordini CREATED possono essere pagati");
        }
        if (this.lines.isEmpty()) {
            throw new IllegalStateException("Impossibile saldare un ordine privo di articoli");
        }
        this.status = OrderStatus.PAID;
        recordEvent(new OrderPaidEvent(this.id, calculateTotal(), Instant.now()));
    }

    private void recordEvent(OrderDomainEvent event) {
        this.domainEvents.add(event);
    }

    public List<OrderDomainEvent> pullDomainEvents() {
        var events = List.copyOf(domainEvents);
        domainEvents.clear();
        return events;
    }

    // Solo Getter (stato in sola lettura, collezioni non modificabili)
    public OrderId getId() { return id; }
    public OrderStatus getStatus() { return status; }
    public List<OrderLine> getLines() { return Collections.unmodifiableList(lines); }
}

6. L'Application Layer: Use Cases e Pattern Matching

Il servizio applicativo orchestra il recupero, la mutazione e il salvataggio. Usiamo l'operatore switch potenziato di Java 25 per dispacciare gli eventi in modo type-safe ed esaustivo.

package com.example.ecommerce.order.application.service;

import com.example.ecommerce.order.domain.event.OrderDomainEvent;
import com.example.ecommerce.order.domain.event.OrderDomainEvent.*;
import com.example.ecommerce.order.domain.model.*;
import com.example.ecommerce.order.domain.repository.OrderRepository;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class CreateOrderUseCaseService {

    private final OrderRepository orderRepository;
    private final ApplicationEventPublisher eventPublisher;

    public CreateOrderUseCaseService(OrderRepository orderRepository, ApplicationEventPublisher eventPublisher) {
        this.orderRepository = orderRepository;
        this.eventPublisher = eventPublisher;
    }

    public OrderResponseDto handle(CreateOrderCommand command) {
        Order order = new Order(OrderId.generate(), command.customerId());

        command.items().forEach(item -> 
            order.addProduct(item.productId(), Money.ofEuros(item.price()), item.quantity())
        );

        Order savedOrder = orderRepository.save(order);

        // Dispatching eventi con Pattern Matching
        savedOrder.pullDomainEvents().forEach(this::dispatchDomainEvent);

        return new OrderResponseDto(savedOrder.getId().value(), savedOrder.getStatus().name());
    }

    private void dispatchDomainEvent(OrderDomainEvent event) {
        // Switch esaustivo su sealed interface (Java 25)
        switch (event) {
            case OrderCreatedEvent created -> eventPublisher.publishEvent(created);
            case OrderPaidEvent paid       -> eventPublisher.publishEvent(paid);
            case OrderCancelledEvent canc  -> eventPublisher.publishEvent(canc);
        }
    }
}

7. L'Infrastructure Layer: L'Adapter JPA

L'infrastruttura implementa il repository (Port) del Dominio, mappando il POJO Order in un'entità JPA (OrderJpaEntity) tramite MapStruct.

@Component
public class OrderRepositoryJpaAdapter implements OrderRepository {

    private final SpringDataOrderRepository springDataRepository;
    private final OrderPersistenceMapper mapper; // Interfaccia MapStruct

    public OrderRepositoryJpaAdapter(SpringDataOrderRepository springRepo, OrderPersistenceMapper mapper) {
        this.springDataRepository = springRepo;
        this.mapper = mapper;
    }

    @Override
    public Order save(Order order) {
        // Dominio -> JPA
        var entity = mapper.toJpaEntity(order);
        var saved = springDataRepository.save(entity);
        // JPA -> Dominio
        return mapper.toDomainEntity(saved);
    }
}

8. Il Superpotere: Testabilità Estrema

Grazie all'isolamento architetturale, i test di business vengono eseguiti senza mock complessi e senza avviare il contesto Spring. Sono test rapidissimi, eseguiti in millisecondi.

class OrderTest {
    @Test
    void shouldCalculateTotalAndMarkAsPaid() {
        // Arrange
        Order order = new Order(OrderId.generate(), UUID.randomUUID());
        order.addProduct(UUID.randomUUID(), Money.ofEuros(49.90), 2);
        
        // Act
        order.markAsPaid();
        
        // Assert
        assertEquals(Money.ofEuros(99.80), order.calculateTotal());
        assertEquals(OrderStatus.PAID, order.getStatus());
        
        var events = order.pullDomainEvents();
        assertTrue(events.stream().anyMatch(e -> e instanceof OrderDomainEvent.OrderPaidEvent));
    }
}

Conclusione

L'integrazione di Java 25, Domain-Driven Design e Clean Code in un'Architettura Esagonale risolve i limiti storici dello sviluppo enterprise monolitico:

  1. Isolamento Totale: Il dominio non conosce i database o il web. Potresti passare da REST a gRPC, o da PostgreSQL a MongoDB, e le classi core non cambierebbero di una virgola.
  2. Sintassi Moderna: Records e Sealed Interfaces rimuovono tonnellate di boilerplate, rendendo il codice elegante e strettamente tipizzato.
  3. Qualità Assicurata: Le regole di business sono centralizzate nell'Aggregate Root e facilmente testabili, azzerando le probabilità di corruzione dello stato interno.

Iniziare un progetto con questo grado di disaccoppiamento richiede un piccolo investimento iniziale in mapping (tramite MapStruct), ma il ritorno in termini di leggibilità, flessibilità e stabilità è incalcolabile.

domenica 25 agosto 2013

domenica 11 novembre 2012

NetBeans 7.2 + Google App Engine

1) Donwload appengine sdk.

2) unzip file


3) Open NetBeans -- tools - plugins

4) add new Url http://kenai.com/downloads/nbappengine/NetBeans7.2/updates.xml


5) install plug-in

6) add new server


7) Start new project (Web Application) with Server Google App Engine.

venerdì 14 settembre 2012

MBFastTrack - Online la Beta

Online la Beta di MBFastTrack. 

Applicativo realizzato in Java con Spring, MongoDB e Bootstrap.

E' una beta e prendetela come tale ancora pieni di bachi... ;)





martedì 4 settembre 2012

PHP - Problemi con EOL

Per qualche strano motivo il testo contenuto in una variabile continua ad andare a capo, questa cosa non è gradita alla funzione javascript a cui passo il valore, dopo varie ricerche e prove riesco a trovare una soluzione.



 $html = '' . $var1 . '' . $var2;
 $html = str_replace("\\r\\n", "", addslashes(trim($html)));
 $html = str_replace(PHP_EOL,"",$html);
 $html = str_replace(array("\r", "\n"), '', $html);


il PHP alle volte è veramente ostico.

mercoledì 11 gennaio 2012

Spring MVC + MongoDB


Primo approccio con il framework Spring 3.1, integrazione tra MVC e MongoDB.

Per installare MongoDB basta scaricarlo, ed eseguire mongod dopo avere precedentemente creato la cartella \data\db.

In questo progetto di netbeans  ho voluto utilizzare il più possibile le annotation  per ridurre al minimo il codice java da scrivere.

Da quello che ho capito esiste ancora qualche problema con il GridFs nell'integrazione con Spring, ma sarà il prossimo passo.


link utili:



giovedì 1 dicembre 2011

MongoDB : Doctrine ODM vs. Mandango

MongoDB Doctine ODM:

pro:
  • semplice e intuitivo
  • i field di tipo array si dichiarano in modo semplice
  • possibilità di _id autogenerati negli embed 
  • Nessun problema con Embed dentro embed e Reference dentro ad embed etc.
  • Id generati anche negli embed in modo semplice

contro:
  • definisco gli indici negli object ma questi non vengono effettivamente creati
  • è lento rispetto a Mandango altri ODM
  • E' in Beta
  • E' difficile trovare documentazione.
da capire:

  • Devo capire se la velocità aumenta configurando gli object in xml.
Mandango

pro:

  • Molta velocità rispetto a Doctine
  • con Mandator crea automaticamente i modelli partendo da un array().
  • i modelli base vengono rigenerati quelli che devono essere estesi da noi no. (ottima cosa)
  • una volta presa la mano con le conf degli object diventa molto veloce.
  • molto utile la funzionalità references/relations
contro:
  • ReferenceOne non molto chiara in db.
  • E' difficile trovare documentazione.
  • Per definire un tipo di dato array bisogna definirlo di tipo 'raw'.
  • Per la definizione dei campi sulle reference bisogna definire un polymorphic per comodità (vedi sotto l'esempio)
  • Non sono riuscito a trovare il metodo per configurare un campo Data a default now().
  • Comportamento strano con gli embed, es : creo un embed di tipo indirizzo e lo salvo in una collection nel field via1, riuso sempre nello codice qualche riga sotto  l'embed salvandolo sempre nella collection indirizzo ma nel campo via2. l'Embed non viene salvato, come se fosse flushato quando è stato agganciato al primo campo.
  • Problemi segnalati con il GridFS
  • Poco supporto sul gruppo 
  • Ho riscontrato un problema nelle reference contenuti negli embed.



ReferenceOne:

Doctrine : definizione molto completa nella collection.



 Mandango: definizione meno accurata.



a mio avviso è meglio usare il field di tipo polymorphic in modo da avere la definizione esatta della classe collegata per facilitare l'eventuale consultazione del db:


è ridondante ma più comprensibile.



altri..

Morph : mancano diversi parti (embed, etc.)
Shanty-Mongo: da verificare sembra valido ad una prima occhiata.

Questo post sarà in aggiornamento continuo.


venerdì 14 ottobre 2011

MongoDB and Java - Checking cluster status

Java Example for monitoring MongoDB Cluster.

package freedbtoMongoDb;

import com.mongodb.DB;
import com.mongodb.Mongo;
import java.util.ArrayList;
import java.util.List;

public class CheckCluster {

    static String host = "192.168.0.72";
    static int[] ports = {
        //replica1
        20001, 20002, 20003, 20005,
        //replica11
        20011, 20012, 20013,
        //configsvr1
        20050,
        //configsvr2
        20060,
        //configdb1
        20100,
        //configdb2
        20101
    };

    public static void main(String[] args) {

        try {

            while (true) {
                Thread.sleep(10000);

                for (int port : ports) {

                    try {
                        Mongo m = new Mongo(host, port);
                        List add_l = m.getAllAddress();
                        System.out.println("address:" + add_l);
                        System.out.println("Version: " + m.getVersion());

                        if (m.getReplicaSetStatus() != null) {
                            System.out.println("Replica Name: " + m.getReplicaSetStatus().getName());
                        }

                        ArrayList db_ll = (ArrayList) m.getDatabaseNames();
                        System.out.println("db_list:" + db_ll);
                        for (String db_name : db_ll) {
                            DB d = m.getDB(db_name);
                            System.out.println(db_name + ": " + d.getStats().get("ok") + " - fileSize: " + Double.parseDouble(d.getStats().get("fileSize").toString()) / 1024 + "MB");
                        }

                        m.close();

                        System.out.println();
                    } catch (Exception e) {
                        System.out.println("Problemi sul db: " + port + "\n" + e.getMessage());
                        //send Mail
                    }
                }

            }
        } catch (Throwable t) {
                   //send Mail
        }
    }
}

[download source]

giovedì 29 settembre 2011

FreeDB to MongoDB


Ultimamente mi trovo a lavorare con MongoDB, ed ecco subito un test di import di massa scritto in java per testare le tempistiche di import e Query del db.

Come al solito utilizzo il freedb, trasformo tutti il db in un succoso file json da 800MB con la classe FreeDbToJson (progetto completo linkato al fondo del post).

questa è una riga del json:

{
   "id":"soundtrack_fe13d011",
   "filename":"soundtrack/fe13d011",
   "revision":"0",
   "title":"100 Love Songs Stage 4 Cd4",
   "genre":"Soundtrack",
   "artist":"IndianDigitalAudio.com",
   "length":"5074",
   "year":"2011",
   "extd":"",
    "tracks":{
              "15":{"title":"Mausam Achanak"},
              "16":{"title":"I Dont Know What To Do"},
              "13":{"title":"Aaja Maahi"},
              "14":{"title":"Janeman"},
              "11":{"title":"Roshan Dil Ka Jahan"},
              "12":{"title":"Yaad Teri Aaye"},
             "3":{"title":"Jo Ghumshuda"},
              "2":{"title":"Dhadke Jiya"},
              "1":{"title":"Nazrein Karam"},
              "10":{"title":"Tum Bhi Ho Wahi"},
             "0":{"title":"Aao Milo Chalo"},
              "7":{"title":"Mausam"},
              "6":{"title":"Mera Pehla Pehla Pyaar"},
              "5":{"title":"Raat Ke Dhai Baje"},
              "4":{"title":"Jaane Tu Meri Kya Hai"},
              "9":{"title":"Pyaar Ki Yeh Kahani"},
              "8":{"title":"Miss You Everyday"}
  }

}
Dopo aver ottenuto questo file eseguo un'altro piccolo programmino in java per importare di massa tutti i record utilizzando la funzionalità requestStart().


package freedbtoMongoDb;

import com.mongodb.DB;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.util.JSON;
import java.io.IOException;

public class JsonToMongoDB {

    static String host = "hostname";
    static int port = 27017;
    static String db_name = "freedb";
    static String target_folder = "/marco/mongodb/file/";

    public static void main(String[] args) throws IOException {

        Mongo m = new Mongo(host, port);
        DB db = m.getDB(db_name);
        db.requestStart();

        System.out.println("File: " + target_folder + "disk.json");
       BigFile file = null;
        try {
            file = new BigFile(target_folder + "disk.json");
        } catch (Exception ex) {
            System.out.println("exception: " + ex.getMessage());
        }

        long ts = System.currentTimeMillis();
        int i = 0;
        for (String line : file) {
            db.getCollection("disk").insert((DBObject) JSON.parse(line));
            System.out.println("line: " + i);
            i++;
        }

        System.out.println("tot time: " + (System.currentTimeMillis() - ts));
        db.requestDone();

    }
}

il db mongo server è installato su una vm dedicata invece il programma sopra gira in locale in netbeans, le tempistiche sono state:  - tot time: 959532 ( circa 16 minuti) per 3057298 righe inserite.

[sorgenti]

giovedì 22 settembre 2011

Doctrine MongoDB - @ReferenceOne to different target class






<?

/**
 * @Document
 * @InheritanceType("SINGLE_COLLECTION")
 * @DiscriminatorField(fieldName="type")
 * @DiscriminatorMap({"student"="Student","customer"="Customer"})
 */

class People {


/** @Id */
protected $id;



/** @String */
protected $name;


/** @String */
protected $surname;


        ..etc.. etc...



}





/**
 * @Document
 */
class Student extend People {


/** @String */
protected $course;

/** @String */
protected $year;


        ..etc.. etc...



}




/**

 * @Document

 */

class Customer extend People {


/** @String */
protected $code;

/** @String */
protected $name;


        ..etc.. etc...


}


/**

 * @Document

 */

class MixedPeople {


/** @Id */
protected $id;

        /** @ReferenceOne(targetDocument="People") */
protected $mixedpeople;

        ..etc.. etc...


}

martedì 24 maggio 2011

MBFastUrl - nuova beta - vari fix - nuove stats

- cron con statistiche per ip
- fix sulla grafica
- varie ottimizzazione sulle conf
- stats log sui qrcode
- cron e stats con sommatoria degli ip nelle varie fasi view,save,qrcode

il server di test attualmente è arrivato ad avere 460 Link salvati e più di 12500 click sui link, non male visto che lo utilizzo solo io per propagare i link sui vari social.

per ora il db dei link in SqLite è 26 MB invece quello di elaborazione delle statistiche 19 MB.

Per ora SqLite tiene, magari prossimamente ci sarà un porting a OrientDB.

lunedì 23 maggio 2011

From Freedb.org to OrientDB - #4

#1 - #2 - #3

Download a big file about 170 Mb.
Uncompress  ... about 614 Mb and 2630481 file...

to speed up the importation are processed only 1000 files per folder.

sample porting schema from FreeDB to OrientDB:



import code




import com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx;
import com.orientechnologies.orient.core.metadata.schema.OProperty.INDEX_TYPE;
import com.orientechnologies.orient.core.metadata.schema.OType;
import com.orientechnologies.orient.core.record.impl.ODocument;
import com.orientechnologies.orient.core.sql.query.OSQLSynchQuery;
import com.orientechnologies.orient.server.OServer;
import com.orientechnologies.orient.server.OServerMain;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import org.apache.commons.io.FileUtils;

private String base = "/Users/marco/orientdb/";
private String root_dir = base + "/file_freedb/freedb-complete-20090101/";
private HashMap cache_year = new HashMap();
private HashMap cache_genre = new HashMap();

  private void import_data() {

        try {

            OServer server = OServerMain.create();
            server.startup(new File(base + "/file/conf.xml"));

            ODatabaseDocumentTx db = new ODatabaseDocumentTx("local:" + base + "/freedb");
            if (!db.exists()) {
                db.create();
                System.out.println("create new DB");
            } else {
                db.delete();
                db.create();
                System.out.println("delete and create new DB");
            }


            FileFilter directoryFilter = new FileFilter() {

                public boolean accept(File file) {
                    return file.isDirectory();
                }
            };

            //default index on odocument
            db.begin();


            ODocument oArtist = new ODocument(db, "artist");
            oArtist.field("name", "Various", OType.STRING);
            oArtist.save();

            db.getMetadata().getSchema().getClass("artist").createProperty("name", OType.STRING).createIndex(INDEX_TYPE.FULLTEXT);
            db.getMetadata().getSchema().save();


            ODocument oTrack = new ODocument(db, "track");
            oTrack.field("title", "Various", OType.STRING);
            oTrack.save();

            db.getMetadata().getSchema().getClass("track").createProperty("title", OType.STRING).createIndex(INDEX_TYPE.FULLTEXT);
            db.getMetadata().getSchema().save();


            ODocument oGendr = new ODocument(db, "genre");
            oGendr.field("name", "Various", OType.STRING);
            oGendr.save();

            db.getMetadata().getSchema().getClass("genre").createProperty("name", OType.STRING).createIndex(INDEX_TYPE.UNIQUE);
            db.getMetadata().getSchema().save();


            ODocument oYear = new ODocument(db, "year");
            oYear.field("data", "19000101", OType.DATE);
            oYear.save();

            db.getMetadata().getSchema().getClass("year").createProperty("data", OType.DATE).createIndex(INDEX_TYPE.UNIQUE);
            db.getMetadata().getSchema().save();


            db.commit();


            File[] dirs = new File(root_dir).listFiles(directoryFilter);
            int i = 0;
            for (File dir : dirs) {

                if (!dir.isDirectory()) {
                    continue;
                }

                System.out.println("" + dir);

                int max_file_for_debug = 0;
                Collection files = FileUtils.listFiles(dir, null, true);
                for (File file : files) {
                    if (file.getName().startsWith(".")) {
                        continue;
                    }


                    try {
                        List lines = FileUtils.readLines(file);

                        db.begin();
                        ODocument oDisk = new ODocument(db, "disk");

                        ArrayList tracks = new ArrayList();

                        String titles = "";
                        String extd = "";
                        for (String line : lines) {

                            if (line.startsWith("# Disc length:")) {
                                String length = line.replaceAll("# Disc length:", "").replaceAll("seconds", "").replaceAll("secs", "").trim();

                                oDisk.field("Disc Length", length, OType.INTEGER);
                            }

                            if (line.startsWith("# Revision:")) {
                                String revision = line.replaceAll("# Revision:", "").trim();


                                oDisk.field("revision", revision, OType.INTEGER);
                            }


                            if (line.startsWith("#")) {
                                continue;
                            }

                            String ele[] = line.split("=");

                            if (ele == null || ele.length == 1) {
                                continue;
                            }

                            String key = ele[0];
                            String value = ele[1];


                            if (key.equals("DISKID")) {
                                oDisk.field(key.toLowerCase(), value, OType.STRING);
                            }

                            if (key.equals("DYEAR")) {
                                oDisk.field("year", check_and_create_year(value + "0101", db), OType.LINK);
                            }

                            if (key.equals("DGENRE")) {

                                oDisk.field("genre", check_and_create_genre(value, db), OType.LINK);
                            }

                            //concatenate multiple title lines
                            if (key.equals("DTITLE")) {
                                titles += value;
                            }

                            if (key.equals("EXTD")) {
                                extd += value;
                            }



                            //tracks list
                            if (key.startsWith("TTITLE")) {
                                oTrack = new ODocument(db, "track");
                                oTrack.field("n", key.replaceAll("TTITLE", ""), OType.INTEGER);

                                String tartist = "";


                                oTrack.field("title", getTitle(value));

                                tartist = getAuthor(value);

                                if (!tartist.equals("")) {

                                    oTrack.field("artist", check_and_create_artist(tartist, db), OType.LINK);
                                } else {
                                    oTrack.field("artist");
                                }


                                oTrack.save();
                                tracks.add(oTrack);

                            }

                        }

                        //add track_list
                        if (!tracks.isEmpty()) {
                            oDisk.field("tracks", tracks, OType.EMBEDDEDLIST);
                        }

                        //title and artist disk
                        if (!titles.equals("")) {

                            oDisk.field("title", getTitle(titles));
                            oDisk.field("artist", check_and_create_artist(getAuthor(titles), db), OType.LINK);

                        }

                        //title and artist disk
                        if (!extd.equals("")) {
                            oDisk.field("extd", extd);
                        }

                        oDisk.save();
                        db.commit();

                    } catch (IOException ex) {
                        System.out.println("ex (1):" + ex.getMessage() + ex.getStackTrace().toString());

                        for (StackTraceElement s : ex.getStackTrace()) {
                            System.out.println("" + s);
                        }

                        db.rollback();
                        continue;

                    }


                    i++;
                    if ((i >= 1000) && (i % 1000) == 1) {
                        System.out.println("\t" + file);
                        for (String s : db.getClusterNames()) {
                            System.out.println("cluster: " + s + " - " + db.countClusterElements(s));

                        }

                        //for debug max 1000 file for folder
                        break;
                    }

                }

            }


            db.close();

            //server
            server.shutdown();
        } catch (Exception ex) {
            System.out.println("ex (2):" + ex.getMessage() + ex.getStackTrace().toString());


            for (StackTraceElement s : ex.getStackTrace()) {
                System.out.println("" + s);
            }

        }

    }

    private ODocument check_and_create_artist(String name, ODatabaseDocumentTx db) {


        if (name.equals("")) {
            return null;
        }


        OSQLSynchQuery query = new OSQLSynchQuery("select from artist where name = ?");
        List result = db.command(query).execute(name);


        if (!result.isEmpty()) {
            return (ODocument) result.get(0);

        } else {

            ODocument oArtist = new ODocument(db, "artist");
            oArtist.field("name", /*a*/ name, OType.STRING);
            oArtist.save();

            return oArtist;
        }


    }

    private ODocument check_and_create_year(String year, ODatabaseDocumentTx db) {

        if (cache_year.containsKey(year)) {
            return cache_year.get(year);
        }


        OSQLSynchQuery query = new OSQLSynchQuery("select from year where data = ?");
        List result = db.command(query).execute(year);


        if (!result.isEmpty()) {
            cache_year.put(year, (ODocument) result.get(0));
            return (ODocument) result.get(0);

        } else {

            ODocument oYear = new ODocument(db, "year");
            oYear.field("data", year, OType.DATE);
            oYear.save();
            cache_year.put(year, oYear);

            return oYear;
        }


    }

    private ODocument check_and_create_genre(String genre, ODatabaseDocumentTx db) {

        if (cache_genre.containsKey(genre)) {
            return cache_genre.get(genre);
        }

        OSQLSynchQuery query = new OSQLSynchQuery("select from genre where name = ?");
        List result = db.command(query).execute(genre);

        if (!result.isEmpty()) {
            cache_genre.put(genre, (ODocument) result.get(0));
            return (ODocument) result.get(0);

        } else {

            ODocument oGenre = new ODocument(db, "genre");
            oGenre.field("name", genre, OType.STRING);
            oGenre.save();
            cache_genre.put(genre, oGenre);
            return oGenre;
        }


    }

    private String getTitle(String value) {


        if (value.indexOf("/") == -1) {
            return escape(value);
        }

        try {
            return escape(value.split("/")[0]);
        } catch (Exception e) {
            return "";
        }

    }

    private String getAuthor(String value) {

        if (value.indexOf("/") == -1) {
            return "";
        }

        if (value.split("/").length == 0) {
            return "";
        }

        try {
            return escape(value.split("/")[1]);
        } catch (Exception e) {
            return "";
        }


    }

    private String escape(String s) {
        if (s == null) {
            return s;
        }
        return s.trim().replaceAll("\\[", "").replaceAll("\\]", "").replaceAll("'", "\\\\'");
    }



Lib:

  • commons-io-2.0.1.jar
  • orient-commons-1.0rc2-SNAPSHOT.jar
  • orientdb-client-1.0rc2-SNAPSHOT.jar
  • orientdb-core-1.0rc2-SNAPSHOT.jar
  • orientdb-enterprise-1.0rc2-SNAPSHOT.jar
  • orientdb-server-1.0rc2-SNAPSHOT.jar
  • orientdb-tools-1.0rc2-SNAPSHOT.jar
  • persistence-api-1.0.jar

after several hours...


cluster: internal - 3
cluster: index - 882
cluster: default - 0
cluster: orole - 3
cluster: ouser - 3
cluster: artist - 43767
cluster: track - 155602
cluster: genre - 995
cluster: year - 114
cluster: disk - 11001



about 4GB of db...

Test Query:


first time:
query:select from artist name like 'Pink%' tot time:25692 ms
next:
query:select from artist name like 'Pink%' tot time:1646 ms

first time:
query:select from disk where artist.name like 'Pink%' tot time: 13388 ms
next:
query:select from disk where artist.name like 'Pink%' tot time: 4714 ms

first time:
query:select from disk where tracks contains ( artist.name like 'Pink%' ) tot time: 1628 ms
next:
query:select from disk where tracks contains ( artist.name like 'Pink%' ) tot time: 1481 ms

first/next time:
query:select from disk where year.data = '19780101' tot time: 906


mercoledì 11 maggio 2011

Java - Generare e scaricare il Qrcode di Google

comoda funzionalità per scaricare da url un file generato da google per di Qrcode utilizzando le commons.io:




package com.utils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

public class HttpUtil {

    public static synchronized void downloadData(String url, String target) {

        try {
            org.apache.commons.io.FileUtils.copyURLToFile(new URL(url), new File(target));
        } catch (IOException ex) {
            System.err.println("errore " + ex.getMessage());
        }


    }
}




poi semplicemente:


HttpUtil.downloadData("https://chart.googleapis.com/chart?cht=qr&chs=100x100&chl=http://www.google.it", "/home/marco/qrcode.png");




la documentazione di Google

martedì 3 maggio 2011

MBFastUrl - nuova beta - fix e prima parte di admin

Aggiornamento del progetto MBFastUrl:

- Home page made in aurora.
- Pagina di login con relativo login (demo/demo)
- Prima parte di admin
- vari fix

venerdì 29 aprile 2011

OrientDB - primi passi di Embedding in java - #1

Sono sempre alla ricerca di DB in java da Embeddare in modo da provarli più rapidamente su NetBeans.

Dopo avere scaricato le lib della RC1 dal sito, prendo confidenza con lo strumento con qualche articolo su  RecordID e i Cluster

includo le lib nel mio progetto ed inizio a capire dalla documentazione come creare e gestire un db.




import com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx;
import com.orientechnologies.orient.core.metadata.security.OUser;
import com.orientechnologies.orient.core.record.impl.ODocument;
import com.orientechnologies.orient.core.sql.query.OSQLSynchQuery;
import com.orientechnologies.orient.server.OServer;
import com.orientechnologies.orient.server.OServerMain;
import java.io.File;

public class Main {

  public static void main(String[] args) {

    try {

          OServer server = OServerMain.create();
          server.startup(new File("/home/marco/file/conf.xml"));
          ODatabaseDocumentTx db = new ODatabaseDocumentTx("local:/home/marco/db").create();
          server.shutdown();
    } catch (Exception ex) {
            System.out.println("ex:" + ex.getMessage());
    }

  }
}




il file conf.xml è questo:


<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<orient-server>
<network>
<protocols>
    <protocol name="binary" implementation="com.orientechnologies.orient.server.network.protocol.binary.ONetworkProtocolBinary"/>
    <protocol name="http" implementation="com.orientechnologies.orient.server.network.protocol.http.ONetworkProtocolHttpDb"/>
    </protocols>
    <listeners>
    <listener ip-address="0.0.0.0" port-range="2424-2430" protocol="binary"/>
    <listener ip-address="0.0.0.0" port-range="2480-2490" protocol="http"/>
    </listeners>
  </network>
    <users>
    <user name="root" password="test" resources="*"/>
    </users>
    <properties>
    <entry name="orientdb.www.path" value="/home/marco/Scrivania/orientdb/www/"/>
    <entry name="orientdb.config.file" value="/home/marco/Scrivania/orientdb/file/orientdb-server-config.xml"/>
    <entry name="server.cache.staticResources" value="false"/>
    <entry name="log.console.level" value="info"/>
<entry name="log.file.level" value="fine"/>
    </properties>
</orient-server>



a questo punto il db è creato per accederci bisogna utilizzare questa connessione:

ODatabaseDocumentTx db = new ODatabaseDocumentTx("local:/home/marco/db").open("admin", "admin");


di default viene creato l'utente admin admin per l'accesso del db in locale.


con questa funzionalità è possibile vedere quali cluster sono presenti, gli elementi contenuti e info sull'utente in uso sul nostro nuovo db:

System.out.println("closed:" + db.isClosed());
OUser user = db.getUser();
System.out.println("user:" + user.getName());
System.out.println("password:" + user.getPassword());

for (String s : db.getClusterNames()) {
           System.out.println("cluster: " + s + " - " + db.countClusterElements(s));

}




Salviamo qualcosa


          try {
db.begin();

ODocument persona = new ODocument(db, "Persona");
persona.field("nome", "marco");
persona.field("cognome", "bianchi");
persona.save();

persona = new ODocument(db, "Persona");
persona.field("nome", "carlo");
persona.field("cognome", "rossi");
persona.save();

db.commit();
} catch (Exception e) {
System.out.println("ex:" + e.getMessage());
db.rollback();
} finally {
db.close();
}



Eseguiamo la query ed estraiamo i valori appena scritti


List persone = db.query(new OSQLSynchQuery("select from Persona"));

for (ODocument persona : persone) {
System.out.println( persona.field("nome") + " " +  persona.field("cognome"));
}

non male vero?

se rieseguite il codice per elencare i cluster vedrete:

Persona : 2


E' possibili correlare anche gli object in questo modo inserendo documenti in documenti:




try {
db.begin();

ODocument persona = new ODocument(db, "Persona");
persona.field("nome", "marco");
persona.field("cognome", "bianchi");

ODocument auto = new ODocument(db, "Auto");
auto.field("marco", "seat ibiza");
auto.field("cilindrata", "1444");
persona.field("auto",auto);


persona.save();

persona = new ODocument(db, "Persona");
persona.field("nome", "carlo");
persona.field("cognome", "rossi");

auto = new ODocument(db, "Auto");
auto.field("marco", "fiat punto");
auto.field("cilindrata", "1245");
persona.field("auto",auto);

persona.save();

db.commit();
} catch (Exception e) {
System.out.println("ex:" + e.getMessage());
db.rollback();
} finally {
db.close();
}





e ancora più complesso inserendo una lista di valori in un field sotto forma di List:




try {
db.begin();

ODocument persona = new ODocument(db, "Persona");
persona.field("nome", "marco");
persona.field("cognome", "bianchi");

ArrayList mezzi_list = new ArrayList();

ODocument auto = new ODocument(db, "Auto");
auto.field("marco", "seat ibiza");
auto.field("cilindrata", "1444");

mezzi_list.add(auto);

auto = new ODocument(db, "Auto");
auto.field("marco", "fiat punto");
auto.field("cilindrata", "1245");

mezzi_list.add(auto);

persona.field("mezzi",mezzi_list);

persona.save();

db.commit();
} catch (Exception e) {
System.out.println("ex:" + e.getMessage());
db.rollback();
} finally {
db.close();
}




lunedì 11 aprile 2011

Prestashop 1.4 - problemi paginazione/ordinamento sui best-sales

Nella estrazione dei Best Sales ho notato il problema del non funzionamento della paginazione e dell’ordinamento, penso che chi guarda questa sezione vorrebbe vedere l’elenco dei prodotti più venduti ordinati appunto da quelli più venduti!!

questo file è da inserire nella cartella /overide/controllers/BestSalesController.php


tra le altre cose ho scoperto che è possibile usare la cartella /overide/ per iserire tutte le classi e i controller che vanno sovrascritti!


articolo postato anche qui


venerdì 8 aprile 2011

Prestashop 1.4 - problemi sul calcolo dei voucher

Usando Prestashop mi sono accorto che esiste un problema sul calcolo dei voucher, infatti gli sconti vengono sempre calcolati sul totale ordine con iva e spese di spedizione quando il cliente logicamente vuole il calcolo sulla sommatoria di soli tutti i prodotti iva esclusa. Per sistemare questa problematica ho dovuto eseguire una patch brutale del codice dei File Cart.php, Discount.php e naturalmente la generazione del PDF.php

per il file Discount.php bisogna modificare il seguente e calcolo

foreach ($products AS $product)
if (count($categories) AND Product::idIsOnCategoryId($product['id_product'], $categories))
$totalAmount += $useTax ? $product['total_wt'] : $product['total'];


con

foreach ($products AS $product)
if (count($categories) AND Product::idIsOnCategoryId($product['id_product'], $categories))
$totalAmount += $product['total'];
//$totalAmount += $useTax ? $product['total_wt'] : $product['total'];


qui trovate la funzione da sostituire nel file Cart.php

per il pdf lascio ad ognuno la modifiche che servono.

questo post è stato anche inserito qui

se avete bisogno di aiuto scrivetemi.

venerdì 11 marzo 2011

Java - getRemoteAddr Ip su Proxy

Nel caso di una web-app su proxy (tipo apache2 che ridirige sulla 8080 dove risponde jetty in localhost) l'ip referer viene salvato da apache (con attiva la direttiva "ProxtPreserveHost on" )  nell'header X-Forwarded-For.

giovedì 10 marzo 2011

Prestashop 1.4 - Cache

Quando la cache non ti fa modificare i moduli bisogna eliminare i file contenuti in

tools/smarty/cache e tools/smarty/compile