import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
private Injector createInjector() {
    return Guice.createInjector(new AbstractModule() {
        @Override
        protected void configure() {
            // Event store
            CommandBus commandBus = new SimpleCommandBus();
            CommandGateway commandGateway = new DefaultCommandGateway(commandBus);

            EventStore eventStore = new FileSystemEventStore(new SimpleEventFileResolver(eventStoreFolder));

            EventBus eventBus = new SimpleEventBus();

            EventSourcingRepository repository = new EventSourcingRepository(Rating.class, eventStore);
            repository.setEventBus(eventBus);

            // Event store handlers
            AggregateAnnotationCommandHandler.subscribe(Rating.class, repository, commandBus);
            AnnotationEventListenerAdapter.subscribe(new RatingEventHandler(), eventBus);

            // Load twist config
            TwistProvider twistProvider = new TwistProvider(twistsDataFile);

            // Twist rating
            TwistRating twistRating = new TwistRatingEventStore(commandGateway, twistProvider);


            // Bootstrap aggregates
            twistProvider.getTwists().stream().forEach(twist -> {
                commandGateway.send(new CreateTwistCommand(twist.id));
            });

            // Set up bindings
            bind(TwistRating.class).toInstance(twistRating);
            bind(TwistProvider.class).toInstance(twistProvider);

            Logger.info("Injector configured");
        }
    });
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
@SuppressWarnings("deprecation")
@Bean
AggregateAnnotationCommandHandler<OrderAggregate> productAggregateCommandHandler() {
  AggregateAnnotationCommandHandler<OrderAggregate> handler = 
      new AggregateAnnotationCommandHandler<OrderAggregate>(
      OrderAggregate.class, orderEventSourcingRepository(), commandBus());
  return handler;
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
/**
 * This method registers your Aggregate Root as a @CommandHandler
 *
 * @return
 */
@Bean
AggregateAnnotationCommandHandler<ProductAggregate> productAggregateCommandHandler(EventSourcingRepository<ProductAggregate> eventSourcingRepository, CommandBus commandBus) {
    AggregateAnnotationCommandHandler<ProductAggregate> handler = new AggregateAnnotationCommandHandler<ProductAggregate>(
            ProductAggregate.class,
            eventSourcingRepository,
            commandBus);
    return handler;
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

    if (EventSourcedAggregateRoot.class.isAssignableFrom(bean.getClass())) {
        AggregateRoot aggregateRoot = (AggregateRoot) bean;
        EventSourcingRepository repository = new EventSourcingRepository(bean.getClass(), eventStore);
        repository.setEventBus(eventBus);
        beanFactory.registerSingleton(beanName + "Repository", repository);
        AggregateAnnotationCommandHandler.subscribe(aggregateRoot.getClass(), repository, commandBus);
    }

    return bean;
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
/**
 *  Subclasses should call this method in order to setup repositories and command handlers etc...
 * @param <T>
 * @param aggregateType The aggregate type to prepare for
 */
protected static <T extends EventSourcedAggregateRoot> EventSourcingRepository<T> subscribe(Class<T> aggregateType){
    // we need to configure the repository
    EventSourcingRepository<T> eventSourcingRepository = new EventSourcingRepository<>(aggregateType, eventStore);
    eventSourcingRepository.setEventBus(eventBus);

    // Axon needs to know that our aggregate can handle commands
    AggregateAnnotationCommandHandler.subscribe(aggregateType, eventSourcingRepository, commandBus);
    return eventSourcingRepository;
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <T extends EventSourcedAggregateRoot> void addAggregateType(Class<T> aggregateType) {
    removeAggregateType(aggregateType);

    Repository<T> repo = m_repoFactory.createRepository(aggregateType);

    m_aggregates.put(aggregateType,new AggregateSubscription(
        repo,
        AggregateAnnotationCommandHandler.subscribe(
            aggregateType,
            repo,
            m_commandBus)));
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
private <T extends EventSourcedAggregateRoot> AggregateSubscription<T> createAggregateSubscription(
    Repository<T> repo, Class<T> aggregateType) {
    return new AggregateSubscription(
        repo,
        AggregateAnnotationCommandHandler.subscribe(
            aggregateType,
            repo,
            m_cmdBus)
    );
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
@Bean
public AggregateAnnotationCommandHandler orderCommandHandler() {
    return AggregateAnnotationCommandHandler.subscribe(Order.class, orderRepository(), commandBus());
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
@Bean
public AggregateAnnotationCommandHandler dayOfChoiceCommandHandler() {
    return AggregateAnnotationCommandHandler.subscribe(DeliveryDay.class, dayOfChoiceRepository(), commandBus());
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
@Bean
public AggregateAnnotationCommandHandler storeAssistantCommandHandler() {
    return AggregateAnnotationCommandHandler.subscribe(StoreAssistant.class, storeAssistantRepository(), commandBus());
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
@Bean
public AggregateAnnotationCommandHandler<Library> libraryCommandHandler() {
	AggregateAnnotationCommandHandler<Library> commandHandler = AggregateAnnotationCommandHandler
			.subscribe(Library.class, libraryRepository(), axonconf.commandBus());
	return commandHandler;
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
@Bean
public AggregateAnnotationCommandHandler<User> userAggregateCommandHandler() {
    return AggregateAnnotationCommandHandler.subscribe(User.class, userAggregateRepository(), commandBus());
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
@Bean
public AggregateAnnotationCommandHandler<Organization> organizationAggregateCommandHandler() {
    return AggregateAnnotationCommandHandler.subscribe(Organization.class, organizationRepository(), commandBus());
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
@Bean
public AggregateAnnotationCommandHandler<Membership> organizationMembershipCommandHandler() {
    return AggregateAnnotationCommandHandler.subscribe(Membership.class, organizationMembershipRepository(), commandBus());
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
@Bean
public AggregateAnnotationCommandHandler<ServiceSpecification> serviceSpecificationAggregateCommandHandler() {
    return AggregateAnnotationCommandHandler.subscribe(ServiceSpecification.class, serviceSpecificationRepository(), commandBus());
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
@Bean
public AggregateAnnotationCommandHandler<ServiceInstance> serviceInstanceAggregateCommandHandler() {
    return AggregateAnnotationCommandHandler.subscribe(ServiceInstance.class, serviceInstanceRepository(), commandBus());
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
public AggregateSubscription(final Repository<?> repository,final AggregateAnnotationCommandHandler<?> handler) {
    this.repository = repository;
    this.handler    = handler;
}
 

import org.axonframework.commandhandling.annotation.AggregateAnnotationCommandHandler; //导入依赖的package包/类
public AggregateSubscription(final Repository<T> repository,final AggregateAnnotationCommandHandler<T> handler) {
    this.repository = repository;
    this.handler    = handler;
}