Enhancing events with data that is not part of the Aggregate?

How do I enhance events with data that is not part of the Aggregate to answer the question? I can provide several possibilities. I will list them here in this blog post:

Include non-stateful attributes in the Aggregate

    public class City extends AbstractAnnotatedAggregateRoot {
        // Name would normally not be included as it's not
        // necessary for the state of the object
        private String name;
        public City(AggregateIdentifier identifier) {
            super(identifier);
        }
        public City(AggregateIdentifier identifier, String name) {
            super(identifier);
            // Easy as the name is already an argument
            apply(new CityCreatedEvent(name));
        }
        public void remove() {
             // Here we can use the stored name to enhance the event
             apply(new CityRemovedEvent(name));
         }
        @EventHandler
        public void handle(CityCreatedEvent event) {
             // Store the name
             this.name = event.getName();
         }
     }

Include immutable (!) data from other aggregates as an attribute

    public class City extends AbstractAnnotatedAggregateRoot {
        // Reference to a country aggregate
        private UUID countryUUID;
         // Immutable (!) name of the country
        private String countryName;
         // Name would normally not be included as it's not
        // necessary for the state of the object
        private String cityName;
         public City(AggregateIdentifier identifier) {
            super(identifier);
        }
         public City(AggregateIdentifier identifier, UUID countryUUID, String countryName, String cityName) {
            super(identifier);
            // This event is easy as the names are already an arguments
            apply(new CityCreatedEvent(countryUUID, countryName, cityName));
        }
         public void remove() {
            // Here we can use the country and city name
            apply(new CityRemovedEvent(countryName, cityName));
        }
         @EventHandler
        public void handle(CityCreatedEvent event) {
            this.countryUUID = event.getCountryUUID();
            this.countryName = event.getCountryName();
            this.cityName = event.getCountryName();
        }
    }    

Query data in the command handler and pass it as an argument

    @Named
    public class CityCommandHandler {
         @Inject
        @Named("cityRepository")
        private Repository repository;
         @Inject
        private QueryService queryService;
    
        @CommandHandler
        public void handle(CreateCityCommand command) {
    
            // Checks the country reference exists and returns the name
            Country country = queryService.loadCountry(command.getCountryUUID());
    
            // Create the aggregate using the loaded country name
            City city = new City(new UUIDAggregateIdentifier(command.getCityUUID()), country.getUUID(), country.getName(), command.getCityName());
            repository.add(city);
    
        }
    
        @CommandHandler
        public final void handle(RemoveCityCommand command) {
    
            // Checks the country reference exists and returns the name
            Country country = queryService.loadCountry(command.getCountryUUID());
    
            // Load the city
            City city = repository.load(new UUIDAggregateIdentifier(command.getCityUUID()));
    
            // Use the name from the previous query
            city.remove(country.getName());
    
        }
     }

    public class City extends AbstractAnnotatedAggregateRoot {

        // Reference to a country aggregate.
        private UUID countryUUID;
    
        // Note, that the country name is NOT stored
        // as it is considered mutable
    
        // Name of the city for the event
        private String cityName;
    
        public City(AggregateIdentifier identifier) {
            super(identifier);
        }
    
        public City(AggregateIdentifier identifier, UUID countryUUID, String countryName, String cityName) {
            super(identifier);
            // Easy as the name is already an argument
            apply(new CityCreatedEvent(countryUUID, countryName, cityName));
        }
    
        // NOTE: Method signature looks strange! Doesn't it?
        public void remove(String countryName) {
            // Here we can use the name from the argument
            // and the stored city name
            apply(new CityRemovedEvent(countryName, cityName));
        }
    
        @EventHandler
        public void handle(CityCreatedEvent event) {
            this.countryUUID = event.getCountryUUID();
            this.cityName = event.getCityName();
        }
     }

Include data in the command and pass it as an argument

    @Named
    public class CityCommandHandler {
    
        @Inject
        @Named("cityRepository")
        private Repository repository;
    
        @Inject
        private QueryService queryService;
    
        @CommandHandler
        public void handle(CreateCityCommand command) {
    
            // Checks the country reference exists and returns the name
            Country country = queryService.loadCountry(command.getCountryUUID());
    
            // Create the aggregate using the loaded country name
            City city = new City(new UUIDAggregateIdentifier(command.getCityUUID()), country.getUUID(), country.getName(), command.getCityName());
            repository.add(city);
    
        }
    
        @CommandHandler
        public final void handle(RemoveCityCommand command) {
    
            // Load the city
            City city = repository.load(new UUIDAggregateIdentifier(command.getCityUUID()));
    
            // Command includes the country name for the argument
            city.remove(command.getCountryName());
    
        }
     }

Query data in the aggregate's method using an injected service

    @Named
    public class CityCommandHandler {
    
        @Inject
        @Named("cityRepository")
        private Repository repository;
    
        @Inject
        private QueryService queryService;
    
        @CommandHandler
        public void handle(CreateCityCommand command) {
    
            // Checks implicitly the country reference and loads the name
            String countryName = queryService.loadCountryName(command.getCountryUUID());
    
            // Create the aggregate using the loaded country name
            City city = new City(new UUIDAggregateIdentifier(command.getCityUUID()), command.getCountryUUID(), countryName, command.getCityName());
            repository.add(city);
    
        }
    
        @CommandHandler
        public final void handle(RemoveCityCommand command) {
    
            // Load the city
            City city = repository.load(new UUIDAggregateIdentifier(command.getCityUUID()));
    
            // Inject the query service into the aggregate
            city.setQueryService(queryService);
    
            // Inside this method the name will be queried
            city.remove();
        }
    }

    public class City extends AbstractAnnotatedAggregateRoot {

        // Reference to a country aggregate.
        private UUID countryUUID;
    
        // Note, that the country name is NOT stored
        // as it is considered mutable
    
        // Name of the city for the event
        private String cityName;
    
        // Query service used to load missing data
        private transient QueryService queryService;
    
        public City(AggregateIdentifier identifier) {
            super(identifier);
        }
    
        public City(AggregateIdentifier identifier, UUID countryUUID, String countryName, String cityName) {
            super(identifier);
            // Easy as the name is already an argument
            apply(new CityCreatedEvent(countryUUID, countryName, cityName));
        }
    
        public void remove() {
            // Load the name and include it in the event
            String countryName = queryService.loadCountryName(countryUUID);
            apply(new CityRemovedEvent(countryName, cityName));
        }
    
        public void setQueryService(QueryService queryService) {
            this.queryService = queryService;
        }
    
        @EventHandler
        public void handle(CityCreatedEvent event) {
            this.countryUUID = event.getCountryUUID();
            this.cityName = event.getCityName();
        }
    
    }    

Query data in the aggregate's method using a method specific query service

This was suggested by Greg Young (Course in Hamburg, September 2011) to make more explicit that an aggregate method uses a query.

    @Named
	public class CityCommandHandler {

		@Inject
		@Named("cityRepository")
		private Repository repository;

		@Inject
		private QueryService queryService;

		@CommandHandler
		public void handle(CreateCityCommand command) {

			// Checks implicitly the country reference and loads the name
			String countryName = queryService.loadCountryName(command.getCountryUUID());

			// Create the aggregate using the loaded country name
			City city = new City(new UUIDAggregateIdentifier(command.getCityUUID()), command.getCountryUUID(), countryName, command.getCityName());
			repository.add(city);
		}

		@CommandHandler
		public final void handle(RemoveCityCommand command) {

			// Load the city
			City city = repository.load(new UUIDAggregateIdentifier(command.getCityUUID()));

			// Provide a method specific query service
			city.remove(new CityRemoveQueryService() {
				public String loadCountryName(UUID countryUUID) {
					// In this case we simply map the call to the common query service
				return queryService.loadCountryName(countryUUID);
				}
			});
		}
	}

Caution

Never do any queries in an Event Handler method in an Aggregate! Replaying the events at a later time may else lead to different event content.