protected InMemoryRepository(Class<T> aggregateType, EventBus eventBus, RepositoryProvider repositoryProvider) { this.aggregateModel = AnnotatedAggregateMetaModelFactory.inspectAggregate(aggregateType); this.eventBus = eventBus; this.repositoryProvider = repositoryProvider; }
/** * Shorthand to create a factory instance and inspect the model for the given {@code aggregateType}, using given * {@code parameterResolverFactory} to resolve parameter values for annotated handlers. * * @param aggregateType The class of the aggregate to create the model for * @param parameterResolverFactory to resolve parameter values of annotated handlers with * @param <T> The type of aggregate described in the model * @return The model describing the structure of the aggregate */ public static <T> AggregateModel<T> inspectAggregate(Class<T> aggregateType, ParameterResolverFactory parameterResolverFactory) { return new AnnotatedAggregateMetaModelFactory(parameterResolverFactory).createModel(aggregateType); }
c -> c.getComponent( AggregateMetaModelFactory.class, () -> new AnnotatedAggregateMetaModelFactory(c.parameterResolverFactory(), c.handlerDefinition(aggregate)) ).createModel(aggregate));
@Override public <C> AnnotatedAggregateModel<C> modelOf(Class<? extends C> entityType) { return AnnotatedAggregateMetaModelFactory.this.createModel(entityType); }
c -> c.getComponent( AggregateMetaModelFactory.class, () -> new AnnotatedAggregateMetaModelFactory(c.parameterResolverFactory(), c.handlerDefinition(aggregate)) ).createModel(aggregate));
@Override public <C> AnnotatedAggregateModel<C> modelOf(Class<? extends C> entityType) { return AnnotatedAggregateMetaModelFactory.this.createModel(entityType); }
private AggregateModel<T> inspectAggregateModel() { if (parameterResolverFactory == null && handlerDefinition == null) { return AnnotatedAggregateMetaModelFactory.inspectAggregate(aggregateType); } else if (parameterResolverFactory != null && handlerDefinition == null) { handlerDefinition = ClasspathHandlerDefinition.forClass(aggregateType); } return AnnotatedAggregateMetaModelFactory.inspectAggregate( aggregateType, parameterResolverFactory, handlerDefinition ); }
/** * Shorthand to create a factory instance and inspect the model for the given {@code aggregateType}. * * @param aggregateType The class of the aggregate to create the model for * @param <T> The type of aggregate described in the model * @return The model describing the structure of the aggregate */ public static <T> AggregateModel<T> inspectAggregate(Class<T> aggregateType) { return new AnnotatedAggregateMetaModelFactory().createModel(aggregateType); }
private AggregateModel<T> inspectAggregateModel() { if (parameterResolverFactory == null) { parameterResolverFactory = ClasspathParameterResolverFactory.forClass(aggregateType); } return handlerDefinition == null ? AnnotatedAggregateMetaModelFactory.inspectAggregate(aggregateType, parameterResolverFactory) : AnnotatedAggregateMetaModelFactory.inspectAggregate(aggregateType, parameterResolverFactory, handlerDefinition); }
/** * Shorthand to create a factory instance and inspect the model for the given {@code aggregateType}, using given * {@code parameterResolverFactory} to resolve parameter values for annotated handlers and {@code handlerDefinition} * to create concrete handlers. * * @param aggregateType The class of the aggregate to create the model for * @param parameterResolverFactory to resolve parameter values of annotated handlers with * @param handlerDefinition The handler definition used to create concrete handlers * @param <T> The type of aggregate described in the model * @return The model describing the structure of the aggregate */ public static <T> AggregateModel<T> inspectAggregate(Class<T> aggregateType, ParameterResolverFactory parameterResolverFactory, HandlerDefinition handlerDefinition) { return new AnnotatedAggregateMetaModelFactory(parameterResolverFactory, handlerDefinition) .createModel(aggregateType); }
private DisruptorRepository(AggregateFactory<T> aggregateFactory, Cache cache, EventStore eventStore, ParameterResolverFactory parameterResolverFactory, SnapshotTriggerDefinition snapshotTriggerDefinition, RepositoryProvider repositoryProvider) { this.aggregateFactory = aggregateFactory; this.cache = cache; this.eventStore = eventStore; this.snapshotTriggerDefinition = snapshotTriggerDefinition; this.model = AnnotatedAggregateMetaModelFactory.inspectAggregate(aggregateFactory.getAggregateType(), parameterResolverFactory); this.repositoryProvider = repositoryProvider; }
/** * Shorthand to create a factory instance and inspect the model for the given {@code aggregateType}. * * @param aggregateType The class of the aggregate to create the model for * @param <T> The type of aggregate described in the model * @return The model describing the structure of the aggregate */ public static <T> AggregateModel<T> inspectAggregate(Class<T> aggregateType) { return new AnnotatedAggregateMetaModelFactory().createModel(aggregateType); }
private DisruptorRepository(AggregateFactory<T> aggregateFactory, Cache cache, EventStore eventStore, ParameterResolverFactory parameterResolverFactory, HandlerDefinition handlerDefinition, SnapshotTriggerDefinition snapshotTriggerDefinition, RepositoryProvider repositoryProvider) { this.aggregateFactory = aggregateFactory; this.cache = cache; this.eventStore = eventStore; this.snapshotTriggerDefinition = snapshotTriggerDefinition; this.model = AnnotatedAggregateMetaModelFactory.inspectAggregate(aggregateFactory.getAggregateType(), parameterResolverFactory, handlerDefinition); this.repositoryProvider = repositoryProvider; }
/** * Shorthand to create a factory instance and inspect the model for the given {@code aggregateType}, using given * {@code parameterResolverFactory} to resolve parameter values for annotated handlers. * * @param aggregateType The class of the aggregate to create the model for * @param parameterResolverFactory to resolve parameter values of annotated handlers with * @param <T> The type of aggregate described in the model * @return The model describing the structure of the aggregate */ public static <T> AggregateModel<T> inspectAggregate(Class<T> aggregateType, ParameterResolverFactory parameterResolverFactory) { return new AnnotatedAggregateMetaModelFactory(parameterResolverFactory).createModel(aggregateType); }
@SuppressWarnings("unchecked") @Override protected DomainEventMessage createSnapshot(Class<?> aggregateType, String aggregateIdentifier, DomainEventStream eventStream) { DomainEventMessage firstEvent = eventStream.peek(); AggregateFactory<?> aggregateFactory = getAggregateFactory(aggregateType); if (aggregateFactory == null) { throw new IllegalArgumentException( "Aggregate Type is unknown in this snapshotter: " + aggregateType.getName() ); } aggregateModels.computeIfAbsent(aggregateType, k -> AnnotatedAggregateMetaModelFactory .inspectAggregate(k, parameterResolverFactory, handlerDefinition)); Object aggregateRoot = aggregateFactory.createAggregateRoot(aggregateIdentifier, firstEvent); SnapshotAggregate<Object> aggregate = new SnapshotAggregate(aggregateRoot, aggregateModels.get(aggregateType), repositoryProvider); aggregate.initializeState(eventStream); if (aggregate.isDeleted()) { return null; } return new GenericDomainEventMessage<>(aggregate.type(), aggregate.identifierAsString(), aggregate.version(), aggregate.getAggregateRoot()); }
/** * Shorthand to create a factory instance and inspect the model for the given {@code aggregateType}, using given * {@code parameterResolverFactory} to resolve parameter values for annotated handlers and {@code handlerDefinition} * to create concrete handlers. * * @param aggregateType The class of the aggregate to create the model for * @param parameterResolverFactory to resolve parameter values of annotated handlers with * @param handlerDefinition The handler definition used to create concrete handlers * @param <T> The type of aggregate described in the model * @return The model describing the structure of the aggregate */ public static <T> AggregateModel<T> inspectAggregate(Class<T> aggregateType, ParameterResolverFactory parameterResolverFactory, HandlerDefinition handlerDefinition) { return new AnnotatedAggregateMetaModelFactory(parameterResolverFactory, handlerDefinition) .createModel(aggregateType); }
@Test public void testCommandsAreRoutedToCorrectEntity() throws Exception { AggregateModel<Book> bookAggregateModel = AnnotatedAggregateMetaModelFactory.inspectAggregate(Book.class); EventBus mockEventBus = SimpleEventBus.builder().build(); mockEventBus.subscribe(m -> m.forEach(i -> System.out.println(i.getPayloadType().getName()))); AnnotatedAggregate<Book> bookAggregate = AnnotatedAggregate.initialize((Book) null, bookAggregateModel, mockEventBus); bookAggregate.handle(command(new CreateBookCommand("book1"))); bookAggregate.handle(command(new CreatePageCommand("book1"))); bookAggregate.handle(command(new CreateParagraphCommand("book1", 0))); bookAggregate.handle(command(new CreateParagraphCommand("book1", 0))); bookAggregate.handle(command(new UpdateParagraphCommand("book1", 0, 0, "Hello world"))); bookAggregate.handle(command(new UpdateParagraphCommand("book1", 0, 1, "Hello world2"))); assertEquals("Hello world", bookAggregate.getAggregateRoot().getPages().get(0).getParagraphs().get(0).getText()); assertEquals("Hello world2", bookAggregate.getAggregateRoot().getPages().get(0).getParagraphs().get(1).getText()); }
private AggregateModel<T> inspectAggregateModel() { if (parameterResolverFactory == null && handlerDefinition == null) { return AnnotatedAggregateMetaModelFactory.inspectAggregate(aggregateType); } else if (parameterResolverFactory != null && handlerDefinition == null) { handlerDefinition = ClasspathHandlerDefinition.forClass(aggregateType); } return AnnotatedAggregateMetaModelFactory.inspectAggregate( aggregateType, parameterResolverFactory, handlerDefinition ); }
private AggregateModel<T> inspectAggregateModel() { if (parameterResolverFactory == null) { parameterResolverFactory = ClasspathParameterResolverFactory.forClass(aggregateType); } return handlerDefinition == null ? AnnotatedAggregateMetaModelFactory.inspectAggregate(aggregateType, parameterResolverFactory) : AnnotatedAggregateMetaModelFactory.inspectAggregate(aggregateType, parameterResolverFactory, handlerDefinition); }
private DisruptorRepository(AggregateFactory<T> aggregateFactory, Cache cache, EventStore eventStore, ParameterResolverFactory parameterResolverFactory, SnapshotTriggerDefinition snapshotTriggerDefinition, RepositoryProvider repositoryProvider) { this.aggregateFactory = aggregateFactory; this.cache = cache; this.eventStore = eventStore; this.snapshotTriggerDefinition = snapshotTriggerDefinition; this.model = AnnotatedAggregateMetaModelFactory.inspectAggregate(aggregateFactory.getAggregateType(), parameterResolverFactory); this.repositoryProvider = repositoryProvider; }