import org.axonframework.repository.Repository; //导入依赖的package包/类
@Autowired
public UserCommandHandler(Repository<UserAggregate> userAggregateRepository,
                          UserRepository userRepository,
                          PasswordEncryptor passwordEncryptor) {
    this.userAggregateRepository = userAggregateRepository;
    this.userRepository = userRepository;
    this.passwordEncryptor = passwordEncryptor;
}
 

import org.axonframework.repository.Repository; //导入依赖的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.repository.Repository; //导入依赖的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.repository.Repository; //导入依赖的package包/类
@Override
public <I, T extends EventSourcedAggregateRoot<I>> Repository<T> createRepository(Class<T> type) {
    EventSourcingRepository<T> repo = new EventSourcingRepository<>(type,m_evtStore);
    repo.setEventBus(m_evtBus);

    return repo;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
@Override
public <I, T extends EventSourcedAggregateRoot<I>> Repository<T> createRepository(Class<T> type) {
    final CachingEventSourcingRepository<T> repo =
        new CachingEventSourcingRepository<>(
            new GenericAggregateFactory<>(type),
            m_evtStore);

    repo.setEventBus(m_evtBus);
    repo.setCache(m_cache);

    return repo;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
@Produces @Default Repository<Account> produceAccountRepository() {
	
	SimpleEntityManagerProvider simpleEntityManagerProvider = new SimpleEntityManagerProvider(em);
	
	GenericJpaRepository<Account> jpaRepository = new GenericJpaRepository<Account>(simpleEntityManagerProvider, Account.class);
			
	CdiEventListener cdiEventListener = new CdiEventListener();
	
	cdiEventListener.registerEventHandler(AccountDebitedEvent.class, accountDebitedEventHandler);
	
	eventBus.subscribe(cdiEventListener);
	
	jpaRepository.setEventBus(eventBus);
	
	return jpaRepository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
@Autowired
public OrderCommandHandler(Repository<Order> repository) {
    this.repository = repository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
@Autowired
public StoreAssistantCommandHandler(Repository<StoreAssistant> repository) {
    this.repository = repository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
@Autowired
public DeliveryDayCommandHandler(Repository<DeliveryDay> repository) {
    this.repository = repository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
@Autowired
public RoleCommandHandler(Repository<RoleAggregate> roleAggregateRepository) {
    this.roleAggregateRepository = roleAggregateRepository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
@Autowired
public ToDoCommandHandler(Repository<ToDoItemAggregate> repository) {
    this.repository = repository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
public void setOrganizationRepository(Repository<Organization> organizationRepository) {
    this.repository = organizationRepository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
public void setServiceSpecificationRepository(Repository<ServiceSpecification> serviceSpecificationRepository) {
    this.serviceSpecificationRepository = serviceSpecificationRepository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
public void setServiceInstanceRepository(Repository<ServiceInstance> serviceInstanceRepository) {
    this.serviceInstanceRepository = serviceInstanceRepository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
public void setMembershipRepository(Repository<Membership> membershipRepository) {
    this.membershipRepository = membershipRepository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
@Bean
public Repository<User> userAggregateRepository() {
    EventSourcingRepository repository = new EventSourcingRepository<>(User.class, eventStore());
    repository.setEventBus(eventBus());
    return repository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
@Bean
public Repository<Organization> organizationRepository() {
    EventSourcingRepository repository = new EventSourcingRepository<>(Organization.class, eventStore());
    repository.setEventBus(eventBus());
    return repository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
@Bean
public Repository<ServiceSpecification> serviceSpecificationRepository() {
    EventSourcingRepository repository = new EventSourcingRepository<>(ServiceSpecification.class, eventStore());
    repository.setEventBus(eventBus());
    return repository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
@Bean
public Repository<ServiceInstance> serviceInstanceRepository() {
    EventSourcingRepository repository = new EventSourcingRepository<>(ServiceInstance.class, eventStore());
    repository.setEventBus(eventBus());
    return repository;
}
 

import org.axonframework.repository.Repository; //导入依赖的package包/类
@Bean
public Repository<Membership> organizationMembershipRepository() {
    EventSourcingRepository repository = new EventSourcingRepository<>(Membership.class, eventStore());
    repository.setEventBus(eventBus());
    return repository;
}