jmolecules
1.10
Um conjunto de bibliotecas para ajudar os desenvolvedores a implementar modelos de domínio em Java simples e sem distrações.
Expresse explicitamente conceitos arquitetônicos para facilitar a leitura e gravação de código.
Mantenha o código específico do domínio livre de dependências técnicas. Reduza o código padrão.
Gere documentação automaticamente e valide estruturas de implementação e sua arquitetura.
Facilite a vida dos desenvolvedores.
Expresse que um trecho de código (um pacote, classe ou método) implementa um conceito arquitetônico.
Torne mais fácil para o leitor humano determinar que tipo de conceitos arquitetônicos é um determinado trecho de código.
Permitir integração de ferramentas:
Aumento do código. (Exemplos de ferramentas: ByteBuddy com integrações Spring e JPA).
Verifique as regras arquitetônicas. (Exemplos de ferramentas: jQAssistant, ArchUnit).
Exemplo: um domínio bancário.
import org . jmolecules . ddd . annotation .*;
@ Entity
class BankAccount {
@ Identity
final IBAN iban ;
/* ... */
}
@ ValueObject
class IBAN { /* ... */ }
@ ValueObject
record Currency { /* ... */ }
@ Repository
class Accounts { /* ... */ } Quando levamos a sério a Linguagem Ubíqua, queremos nomes (para classes, métodos, etc.) que contenham apenas palavras da linguagem de domínio. Isso significa que os títulos dos blocos de construção não devem fazer parte dos nomes. Portanto, em um domínio bancário, não queremos BankAccountEntity , CurrencyVO ou mesmo AccountRepository como tipos. Em vez disso, queremos BankAccount , Currency e Accounts – como no exemplo acima.
Ainda assim, queremos expressar que uma determinada classe (ou outro elemento arquitetônico) é um bloco de construção especial; ou seja, usa um padrão de design. jMolecules fornece um conjunto de anotações padrão para os blocos de construção conhecidos do DDD.
Como alternativa às anotações acima mencionadas, o jMolecules também fornece um conjunto de interfaces, em grande parte baseadas nas ideias apresentadas na série "Advancing Enterprise DDD" de John Sullivan. Eles permitem expressar relacionamentos entre os blocos de construção diretamente no sistema de tipos, para que o compilador possa ajudar a verificar a correção do modelo e as informações também possam ser processadas pela reflexão Java com mais facilidade.
Identifier — Um tipo para representar tipos que deveriam atuar como identificadores.
Identifiable<ID> — Qualquer coisa que exponha um identificador.
Entity<T extends AggregateRoot<T, ?>, ID> extends Identifiable<ID> — Uma entidade que declara a qual AggregateRoot ela pertence e qual identificador ela expõe.
AggregateRoot<T extends AggregateRoot<T, ID>, ID extends Identifier> extends Entity<T, ID> — uma raiz agregada sendo uma Entity pertencente a si mesma expondo um Identifier dedicado
Association<T extends AggregateRoot<T, ID>, ID extends Identifier> extends Identifiable<ID> — uma associação explícita a um alvo AggregateRoot .
Este arranjo orienta a modelagem e permite verificar facilmente as seguintes regras, potencialmente por reflexão:
Tipos de identificadores dedicados e aplicados por agregado para evitar que identificadores de diferentes agregados se misturem.
AggregateRoot deve referir-se apenas a instâncias Entity que foram declaradas como pertencentes a ela.
AggregateRoot se Entity s devem referir-se apenas a outros AggregateRoots por meio de instâncias Association .
Para verificação automatizada e integração de tecnologia de tempo de execução, consulte Integrações jMolecules.
jmolecules-ddd — anotações e interfaces para expressar blocos de construção DDD (objetos de valor, entidades, raízes agregadas, etc.) em código.
jmolecules-events — anotações e interfaces para expressar o conceito de eventos em código.
kmolecules-ddd — Versão de jmolecules-ddd baseada em Kotlin para mitigar problemas de interoperabilidade Kotlin/Java para o modelo baseado em tipo.
jMolecules fornece anotações para descrever conceitos arquitetônicos de nível superior seguindo os estilos de arquiteturas em camadas, cebola e hexagonal. Eles permitem marcar um pacote inteiro como uma camada, anel ou contendo portas e adaptadores. Eles apareceriam no arquivo package-info.java para cada pacote que você deseja anotar, por exemplo:
package-info.java para camada de domínio: @ DomainLayer
package org . acmebank . domain ;
import org . jmolecules . architecture . layered .*;package-info.java para camada de aplicativo: @ ApplicationLayer
package org . acmebank . application ;
import org . jmolecules . architecture . layered .*;Dessa forma, todas as classes do respectivo pacote são consideradas parte da camada anotada, anel ou considerada porta/adaptador.
Alternativamente, as classes podem ser anotadas diretamente:
import org . jmolecules . architecture . layered .*;
@ DomainLayer
@ Entity
public class BankAccount { /* ... */ }
@ ApplicationLayer
@ Service
public class TransferMoney { /* ... */ }Atualmente, existem anotações para arquitetura em camadas, cebola e hexagonal.
jmolecules-architecture — anotações para expressar estilos arquitetônicos em código.
jmolecules-cqrs-architecture — Arquitetura CQRS
@Command
@CommandDispatcher
@CommandHandler
@QueryModel
jmolecules-layered-architecture — Arquitetura em camadas
@DomainLayer
@ApplicationLayer
@InfrastructureLayer
@InterfaceLayer
jmolecules-onion-architecture — Arquitetura cebola
Clássico
@DomainModelRing
@DomainServiceRing
@ApplicationServiceRing
@InfrastructureRing
Simplificado (não separa modelo de domínio e serviços)
@DomainRing
@ApplicationRing
@InfrastructureRing
jmolecules-hexagonal-architecture — Arquitetura hexagonal
@Application
@(Primary|Secondary)Adapter
@(Primary|Secondary)Port
As anotações e interfaces do jMolecules podem ser usadas para gerar o código técnico necessário para expressar o conceito em uma determinada tecnologia alvo.
Integração Spring, Data JPA, Data MongoDB, Data JDBC e Jackson - para fazer o código usando anotações jMolecules funcionar imediatamente nessas tecnologias.
Os conceitos do jMolecules expressos em código podem ser usados para verificar regras que decorrem das definições dos conceitos e gerar documentação.
Plugin jQAssistant — para verificar regras aplicáveis aos diferentes estilos de arquitetura, blocos de construção DDD, CQRS e eventos. Também cria diagramas PlantUML a partir das informações disponíveis na base de código.
Regras do ArchUnit — permitem verificar relacionamentos entre blocos de construção DDD.
Spring Modulith — suporta detecção de componentes jMolecules, blocos de construção DDD e eventos para modelo de módulo e fins de documentação (consulte a documentação do Spring Modulith para obter mais informações).
Para usar jMolecules em seu projeto basta declarar uma dependência dele. Os binários de lançamento estão disponíveis no repositório central do Maven. Para evitar ter que declarar explicitamente todas as versões, recomendamos usar o jmolecules-bom na sua seção de gerenciamento de dependências.
< dependency >
< groupId >org.jmolecules</ groupId >
< artifactId >jmolecules-ddd</ artifactId >
< version >1.9.0</ version >
</ dependency >repositories {
mavenCentral()
}
dependencies {
implementation( " org.jmolecules:jmolecules-ddd:1.9.0 " )
} mvn release:prepare -DscmReleaseCommitComment="$ticketId - Release version $version." -DscmDevelopmentCommitComment="$ticketId - Prepare next development iteration."
mvn release:perform -Dgpg.keyname=$keyname
