All Articles ↓
4 mesi fa

CUBA 7.2 - Che novità ci sono?

La settima versione della piattaforma CUBA è stata un grande passo avanti. I miglioramenti dell'architettura interna e il nuovo IDE hanno costituito una grande base per ulteriori miglioramenti. E continuiamo ad aggiungere nuove funzionalità per rendere la vita dello sviluppatore più facile e il suo lavoro più productive.

Nella versione 7.2 abbiamo introdotto una serie di modifiche che potrebbero sembrare delle “breaking changes”, ma grazie alla flessibilità della versione 7 sono solo una naturale evoluzione della piattaforma.

CUBA poliglotta

text

Kotlin è ora pienamente supportato come linguaggio per le applicazioni basate su CUBA. Ora è possibile creare entità, servizi, controller di schermate e tutti gli altri componenti utilizzando Kotlin.

Il codice in Kotlin consente di utilizzare istruzioni più brevi e concise, in modo da poter creare applicazioni ancora più velocemente di prima. Utilizzando il supporto del linguaggio di IntelliJ IDEA, siamo stati in grado di implementare le stesse funzionalità di Java: iniezioni guidate dal contesto, suggerimenti intelligenti, generazione di codice, ecc.

Ecco un esempio di una semplice entità. Come si può vedere, il codice è molto più breve di quello in Java, non ci sono getter e setter, e il codice è perfettamente leggibile e chiaro.

@NamePattern("%s|name")
@Table(name = "PETCLINIC_VET")
@Entity(name = "petclinic_Vet")
class Vet : StandardEntity() {
   @NotNull
   @Column(name = "NAME", nullable = false, unique = true)
   var name: String? = null

   companion object {
       private const val serialVersionUID = -8600988577624886948L
   }
}

I controller delle schermate avranno un aspetto piuttosto familiare per chiunque abbia già lavorato con CUBA:

@UiController("petclinic_Vet.edit")
@UiDescriptor("vet-edit.xml")
@EditedEntityContainer("vetDc")
@LoadDataBeforeShow
class VetEdit : StandardEditor<Vet>() {
   @Inject
   private lateinit var vetService: VetService

   @Subscribe("assignVisit")
   private fun onAssignVisitClick(event: Button.ClickEvent) {
       vetService.scheduleVisit(editedEntity, LocalDateTime.now());
   }
}

e i servizi:

interface VetService {
   companion object {
       const val NAME = "petclinic_VetService"
   }
   fun scheduleVisit(vet: Vet, visitDate: LocalDateTime): Visit
}


@Service(VetService.NAME)
class VetServiceBean : VetService {
   @Inject
   private lateinit var dataManager: DataManager

   override fun scheduleVisit(vet: Vet, visitDate: LocalDateTime): Visit {
       //Business logic for a visit scheduling
   }
}

Il codice è completamente compatibile con Java, si possono anche mischiare sorgenti Kotlin e Java nella stessa applicazione.

E infine, programmare in Kotlin è divertente !

Aggiornamenti del Sistema di Sicurezza

text

La sicurezza è sempre importante. Abbiamo fatto una revisione approfondita del nostro sottosistema di sicurezza e abbiamo deciso di utilizzare l'approccio "negare di default". Potrebbe sembrare insolito per chi ha già lavorato con CUBA, ma il motto "meglio sicuri che spiacenti" è incredibilmente rilevante nel periodo delle fughe di dati personali. Come sempre, forniamo un processo di migrazione per le applicazioni sviluppate con le precedenti versioni CUBA.

Un'altra novità importante: la definizione dei ruoli in fase di progettazione. Ora è possibile definire le regole di accesso in codice Java, quindi non sarà necessario esportare le definizioni dei ruoli dal proprio ambiente di test e importarle nella versione di produzione. Non abbandoniamo la tradizionale definizione dei ruoli di runtime, ma aggiungiamo solo un'altra caratteristica al nostro sottosistema di sicurezza. Sta a voi decidere se volete utilizzare i ruoli di runtime, quelli di design-time o entrambi.

Ecco un esempio che definisce le regole di accesso per le entità, gli attributi e le schermate:

@Role(name = "Customers Full Access")
public class CustomersFullAccessRole extends AnnotatedRoleDefinition {

    @EntityAccess(target = Customer.class,
            allow = {EntityOp.CREATE, EntityOp.READ, EntityOp.UPDATE, EntityOp.DELETE})
    @Override
    public EntityPermissionsContainer entityPermissions() {
        return super.entityPermissions();
    }

    @EntityAttributeAccess(target = Customer.class, modify = {"name", "email"})
    @Override
    public EntityAttributePermissionsContainer entityAttributePermissions() {
        return super.entityAttributePermissions();
    }

    @ScreenAccess(allow = {"application-demo", "demo_Customer.browse", "demo_Customer.edit"})
    @Override
    public ScreenPermissionsContainer screenPermissions() {
        return super.screenPermissions();
    }
}

Potrebbe sembrare più "verboso" rispetto alla definizione "tradizionale" a runtime, ma questo approccio ci permette di impostare un accesso più granulare ai vari componenti dell'applicazione. In combinazione con i nuovi "scopes", il sottosistema di sicurezza aggiornato renderà la vostra applicazione più sicura.

Miglioramenti alla Generic UI

Continuiamo a supportare e aggiornare il sottosistema Generic UI. In questa versione, abbiamo reso il menù laterale collassabile di default, così da risparmiare più spazio nella schermata dell'applicazione. Lo si può osservare non appena si avvia l'applicazione.

Un’altra modifica dietro le quinte: ora gli sviluppatori possono definire le viste nel descrittore XML delle schermate, quindi non è più obbligatorio creare tutte le viste nel file views.xml.

<data> 
    <instance id="orderDc" class="com.company.sales.entity.Order"> 
        <view extends="_local"> 
            <property name="lines" view="_minimal">
                <property name="product" view="_local"/>
                <property name="quantity"/>
            </property>
            <property name="customer" view="_minimal"/>
        </view>
        <loader/> 
    </instance>
</data>

Oltre a questo, abbiamo introdotto una serie di piccole modifiche per semplificare il lavoro degli sviluppatori:

  • Posizionamento flessibile per i componenti nei forms
  • Ordinamento iniziale per le griglie
  • Comando Seleziona/Deseleziona tutto per le griglie
  • Scorciatoie da tastiera per i pulsanti
  • Miglioramenti dei campi data e ora
  • E altro ancora

Deployment Semplificato

text

In questa versione è possibile configurare le connessioni al database direttamente nell'applicazione. In alternativa alle definizioni JNDI, è possibile definire le proprietà di connessione nel file app.properties.

cuba.dbmsType = hsql
cuba.dataSourceProvider = application
cuba.dataSource.username = sa
cuba.dataSource.password =
cuba.dataSource.dbName = petclinic
cuba.dataSource.host = localhost
cuba.dataSource.port = 9010

Questa caratteristica rende l'applicazione indipendente dall'ambiente dell'application server. E questo diventa più potente in combinazione con i profili di Spring - un'altra novità della versione 7.2.

I profili di Spring permettono di definire i beans che saranno specifici per un ambiente di distribuzione. Per esempio, si possono avere diverse implementazioni per i server di sviluppo e di produzione.

public interface HelloService {
    String NAME = "demo_helloService";

    String hello(String input);
}

@Service(HelloService.NAME)
@Profile("dev")
public class HelloDevServiceBean implements HelloService {
    @Override
    public String hello(String input) {
        return "Development stub: hello " + input;
    }
}

@Service(HelloService.NAME)
@Profile("prod")
public class HelloProdServiceBean implements HelloService {
    @Override
    public String hello(String input) {
        return "Production service: hello " + input;
    }
}

Un profilo può essere attivato sia nel file web.xml che impostando la proprietà di ambiente spring.profiles.active dalla riga di comando:

java -Dspring.profiles.active=prod -jar app.jar

I profili di Spring possono essere applicati non solo ai beans, ma anche ai file di configurazione. Ad esempio, è possibile definire le proprietà di connessione delle sorgenti dati, specifiche per il profilo, nel file <profilo>-app.properties. Oppure specificare diversi server SMTP per ambienti di prova e di produzione. Dite "no" alle e-mail di test nelle caselle di posta dei vostri clienti!

Aggiornamenti di CUBA Studio

Tutte le funzionalità elencate finora sono supportate in CUBA Studio. Anche il nostro principale strumento di sviluppo è in costante sviluppo. Stiamo aggiungendo nuove funzionalità, utilizzando nuove API IntelliJ e migliorando gli algoritmi di generazione del codice, cercando di automatizzare tutto ciò che può essere automatizzato, in modo da non dover scrivere codice noioso e ripetitivo.

text

L'elenco completo degli aggiornamenti si trova qui, esaminiamo solo i più importanti:

  • Nuovo template per la schermata di login. Ora è possibile utilizzare una finestra di login più "branding-friendly".
  • L'interfaccia utente dello screen designer è stata rivisitata, abbiamo diviso i suoi pannelli per risparmiare spazio nella finestra dell’IDE, e permettere agli sviluppatori di vedere le modifiche mentre modificano il layout XML.
  • Il Project Wizard è stato esteso per supportare nuovi linguaggi di programmazione e ci permette di inserire informazioni aggiuntive come localizzazione e proprietà principali del datastore.

Conclusioni

Con questo aggiornamento, sviluppare con il framework CUBA diventa più facile, più veloce e più piacevole. Con Kotlin avete la possibilità di utilizzare uno dei migliori linguaggi di programmazione emergenti.

La distribuzione in diversi ambienti è semplificata grazie ai profili di Spring e alle sorgenti dati configurate nell'applicazione.

I miglioramenti dell'interfaccia utente generica (Generic UI) vi aiuteranno a realizzare esperienze utente sempre più accurate ed efficaci.

E continuiamo a mantenere la retrocompatibilità del framework, quindi l'aggiornamento delle applicazioni alla versione 7.2 dovrebbe essere il più fluido possibile.

Potete trovare le note di rilascio con tutte le modifiche a questo link.

Paolo Furini