DDD-如何集成限界上下文和应用服务的使用

@RestController
@RequestMapping("/tenants/{tenantId}/users")
public class UserSource {
	@Resource
	private AccessService accessService;
	
	@GetMapping("{username}/inRole/{role}")
	public Response getUserInRole(@RequestParam String aTenantId,
	                              @RequestParam String aUsername,
	                              @RequestParam String aRoleName) {
		Response response = null;
		User user = null;
		try{
			this.accessService.userInRole(aTenantId, aUsername, aRoleName);
		}catch (Exception e) {
			// 跳过异常
		}
		if (user != null) {
			response = this.userInRoleResponse(user, aRoleName);
		}
		return response;
	}
}

public class AccessService {
	@Transactional(readOnly= true)
	public User userInRole(String aTenantId, String aUse rname, String aRoleName) {

		User userInRole = null;
		TenantId tenantId = new TenantId(new TenantId(aTenantId));
		User user = DomainRegistry
						.userRepository()
						.userWithUsername(tenantId, aUsername);
		if (user != null) {
			Role role = DomainRegistry
							.roleRepository()
							.roleNamed(tenantId, aRoleName);

			if (role != null) {
				GroupMemberService groupMemberService = DomainRegistry.groupMemberService();
				if (role.isInRole(user, groupMemberService)) {
					userInRole = user;
				}
			}
		}
		return userInRole;
	}
}

{
  "role": "Author", "username": "zoe",
  "tenantId": "A94A8298-43B8-4DA0-9917-13FFF9E11 6ED",
  "firstName": "Zoe", 
  "lastName": "Doe",
  "emailAddress" : "zoe@saasovation. com"
}

public interface CollaboratorService {
	public Author authorFrom(Tenant aTenant, String anIdentity); 
  public Creator creatorFrom(Tenant aTenant, String anIdentity); 
  public Moderator moderatorFrom(Tenant aTenant, String anIdentity); 
  public Owner ownerFrom(Tenant aTenant, String anIdentity);
	public Participant participantFrom(Tenant aTenant, String anIdentity);
}

package com.saasovation.collaboration.infrastructure.services;

import com.saasovation.collaboration.domain.model.collaborator.Author;

public class TranslatingCollaboratorService implements CollaboratorService{ 
  
	@Override
	public Author authorFrom(Tenant aTenant, String anIdentity){ 
    Author author = this.userInRoleAdapter
      							.toCollaborator(aTenant, anIdentity, "Author",Author.class); 
    return author;
  }
}

package com.saasovation.collaboration.infrastructure.services; 
import org.jboss.resteasy.client.ClientRequest;
import org.jboss.resteasy.client.ClientResponse; 

public class UserInRoleAdapter(

		public <T extends Collaborator> T toCollaborator(
				Tenant aTenant,
				String anIdentity, String aRoleName,
				Class<T> aCollaboratorClass){ 
      T collaborator = nul1;
			try{
				ClientRequest request=this.buildRequest(aTenant, anIdentity, aRoleName);
        ClientResponse<String>response=request.get(String.class); 
        if (response.getStatus()==200){ 
          collaborator=new CollaboratorTranslator().toCollaboratorFromRepresentation(
            								response.getEntity(),
														aCollaboratorClass); 
        } else if (response.getStatus()!=204){ 
          throw new IllegalStateException("There was a problem requesting the user:" +anIdentity+"in role:" +aRoleName+ " with resulting status:"+response.getStatus()); 
        } catch(Throwable t){
					throw new IllegalStateException("Failed because:"+t.getMessage(),t);
        }
				return collaborator; 
		}
}

package com.saasovation.collaboration.infrastructure.services; 
import java.lang.reflect.Constructor;
import com.saasovation.common.media.RepresentationReader; 
public class CollaboratorTranslator{
	public CollaboratorTranslator(){ 
    super();
  }
	public <T extends Collaborator> T toCollaboratorFromRepresentation(String aUserInRoleRepresentation,Class<T> aCollaboratorClass) throws Exception{
		RepresentationReader reader=new RepresentationReader(aUserInRoleRepresentation); 
    String username = reader.stringValue("username");
		String firstName = reader.stringValue("firstName"); 
    String lastName = reader.stringValue("lastName");
		String emailAddress = reader.stringValue("emailAddress"); 
    T collaborator=this.newCollaborator(username, firstName, lastName, emailAddress,aCollaboratorClass); 
    return collaborator;
}
	private <T extends Collaborator> T newCollaborator(
    String aUsername,
    String aFirstName, 
    String aLastName, 
    String aEmailAddress,
    Class<T> aCollaboratorClass) throws Exception{
		Constructor<T> ctor=aCollaboratorClass.getConstructor(String.class, String.class, String.class); 
		T collaborator=ctor.newInstance(aUsername,(aFirstName + " " + aLastName).trim(), aEmailAddress);
    return collaborator; 
  }
}

package com.saasovation.collaboration.domain.model.collaborator; 
public final class Author extends Collaborator{
  public Author(String anIdentity, String aName,String anEmailAddress){
		super(anIdentity, aName, anEmailAddress); 
  }
}

package com.saasovation.collaboration.application; 
public class ForumService{
	@Transactional
	public Discussion startDiscussion(
		String aTenantId,
		String aForumId, 
    String anAuthorId, 
    String aSubject){
		Tenant tenant= new Tenant(aTenantId);
    ForumId forumId = new ForumId(aForumId); 
    Forum forum = this.forum(tenant, forumId); 
    if (forum ==nu11){
			throw new IllegalStateException("Forum does not exist."); 
    }
		Author author=this.collaboratorService.authorFrom(tenant, anAuthorId);
		Discussion newDiscussion=forum.startDiscussion(this.forumNavigationService(), author, aSubject);
		this.discussionRepository.add(newDiscussion); 
    return newDiscussion;
  }
}

package com.saasovation.identityaccess.application;
public class AccessService{
	@Transactional
	public void assignUserToRole(AssignUserToRoleCommand aCommand){
    TenantId tenantId=new TenantId(aCommand.getTenantId());
    User user=this.userRepository.userWithUsername(tenantId, aCommand.getUsername()); 
    if (user!=null){
			Role role=
			this.roleRepository.roleNamed(tenantId,aCommand.getRoleName());
    	if (role != null){
				role.assignUser(user); 
      }
    }
  }
}

package com.saasovation.identityaccess.domain.model.access;
public class Role extends Entity{
	public void assignUser(User aUser){ 
    if (aUser == null){
			throw new NullPointerException("User must not be nu11."); 
    }
		if (!this.tenantId().equals (aUser.tenantId())){ 
      throw new IllegalArgumentException("Wrong tenant for this user."); 
    }
		this.group().addUser (aUser);
    DomainEventPublisher.instance()
												·publish(new UserAssignedToRole(this.tenantId(),
                                                        this.name(), 
                                                        aUser.username(),
                                                        aUser.person().name().firstName(), 
                                                        aUser.person().name().lastName(), 
                                                        aUser.person().emailAddress())); 
  }
}

package com.saasovation.common.port.adapter.messaging.rabbitmg; 
public abstract class ExchangeListener {
	private MessageConsumer messageConsumer; 
	private Queue queue;
	public ExchangeListener () {
    super ();
  }
	this.attachToQueue ();
	this.registerConsumer ():
	protected abstract String exchangeName ();
  protected abstract void filteredDispatch(String aType, String aTextMessage);
	protected abstract String [] listensToEvents();
	protected String queueName () {
		return this.getClass ().getSimpleName ();
  }
	private void attachToQueue () {
    Exchange exchange = Exchange.fanOutInstance (ConnectionSettings.instance (), this.exchangeName (), true);
		this.queue = Queue.individualExchangeSubscriberInstance (exchange, this.exchangeName () + "." + this.queueName ());
  }
	private Queue queue () {
    return this.queue;
  }
	private void registerConsumer () {
    this.messageConsumer = MessageConsumer.instance (this.queue (), false);
		this.messageConsumer.receiveOnly(this.listensToEvents (), new MessageListener (MessageListener.Type. TEXT) {
			@Override
			public void handleMessage(String aType, String aMessageId, Date aTimestamp, String aTextMessage, long aDeliveryTag,boolean isRedelivery) throws Exception {
				filteredDispatch (aType, aTextMessage);
      }
    }  
  }
}

package com.saasovation.agilepm.infrastructure.messaging;

public class TeamMemberEnablerListener extends ExchangeListener{ 
  @Autowired
  private TeamService teamService; 
  public TeamMemberEnablerListener(){ 
    super();
  }
	@Override
  protected String exchangeName(){
		return Exchanges.IDENTITY_ACCESS_EXCHANGE_NAME; 
  }
  @Override
	protected void filteredDispatch(String aType, String aTextMessage){ 
    NotificationReader reader=new NotificationReader(aTextMessage);
		String roleName = reader.eventStringValue ("roleName"); 
    if (!roleName.equals ("ScrumProductOwner")&&!roleName.equals ("ScrumTeamMember")){ 
      return;
    }
		String emailAddress = reader.eventStringValue ("emailAddress"); 
    String firstName = reader.eventStringValue("firstName"); 
    String lastName = reader.eventStringValue("lastName"); 
    String tenantId=reader.eventStringValue("tenantId.id"); 
    String username=reader.eventStringValue("username"); 
    Date occurredon=reader.occurredon();
		if (roleName.equals("ScrumProductOwner")){
      this.teamService.enableProductOwner(
								new EnableProductOwnerCommand(tenantId,username, firstName, lastName, emailAddress,occurredon)); 
    }else{
			this.teamService.enableTeamMember(
        				new EnableTeamMemberCommand( tenantId,username, firstName, lastName, emailAddress,occurredon)); 
    }
	}
	@Override
  protected String[] listensToEvents(){ 
  	return new String[]{"com.saasovation.identityaccess.domain.model. access.UserAssignedToRole"}; 
  }
}

package com.saasovation.agilepm.application; 
public class TeamService {
	@Autowired
	private ProductOwnerRepository productOwnerRepository; 
  @Autowired
  private TeamMemberRepository teamMemberRepository;
  @Transactional
  public void enableProductOwner(EnableProductOwnerCommand aCommand){
		TenantId tenantId=new TenantId(aCommand.getTenantId()); 
    ProductOwner productOwner=this.productOwnerRepository·productOwnerOfIdentity(tenantId,aCommand.getUsername()); 
    if (productOwner!=nu1l){
			productOwner.enable(aCommand.getOccurredon()); 
    }else{
			productOwner=new ProductOwner(tenantId,aCommand.getUsername(), aCommand.getFirstName(), aCommand.getLastName(), aCommand.getEmailAddress () ,aCommand.getOccurredon());
      this.productOwnerRepository.add(productOwner); 
    }
  }
}

package com.saasovation.agilepm.application; 
public class TeamService{

	@Transactional
	public void disableTeamMember(DisableTeamMemberCommand aCommand){ 
    TenantId tenantId=new TenantId(aCommand.getTenantId()); 						
    TeamMember teamMember=this.teamMemberRepository.teamMemberofIdentity(tenantId,aCommand.getUsername());
		if (teamMember != nul1){
			teamMember.disable(aCommand.getOccurredon()); 
    }
  }
}

package com.saasovation.agilepm.domain.model.team; 
public abstract class Member extends Entity{ 
  private MemberChangeTracker changeTracker; 
  public void disable(Date asOfDate){
		if (this.changeTracker().canToggleEnabling(asOfDate)){ 
      this.setEnabled(false);
			this.setChangeTracker(this.changeTracker().enablingOn (asOfDate));
    }
  }
	public void enable(Date asOfDate){
		if (this.changeTracker().canToggleEnabling(asofDate)){ 
      this.setEnabled(true);
			this.setChangeTracker(
					this.changeTracker().enablingOn(asOfDate)); 
    }
  }

package com.saasovation.agilepm.domain.model.team;
public final class MemberChangeTracker implements Serializable { 
  private Date emailAddressChangedOn;
	private Date enablingOn;
  private Date nameChangedon; 
	public boolean canToggleEnabling(Date asOfDate){ 
    return this.enablingOn().before (asOfDate); 
  }
	public MemberChangeTracker enablingOn(Date asofDate){ 
    return new MemberChangeTracker(asOfDate, this.nameChangedOn(), this.emailAddressChangedOn()); 
  }
}

package com.saasovation.agilepm.application; 
public class ProductService{
	@Autowired
	private ProductRepository productRepository; 
  @Autowired
	private ProductOwnerRepository productOwnerRepository; 
  @Transactional
  public String newProductWithDiscussion(NewProductCommand aCommand){ 
    return this.newProductWith(aCommand.getTenantId(),
                               aCommand.getProductOwnerId(), 
                               aCommand.getName (),
                               aCommand.getDescription(),
                               this.requestDiscussionIfAvailable()); 
  }
}

package com.saasovation.agilepm.domain.model.product; 
public class Product extends ConcurrencySafeEntity{
  public Product(
    TenantId aTenantId, 
    ProductId aProductId,
    ProductOwnerId aProductOwnerId, 
    String aName,
    String aDescription,
    DiscussionAvailability aDiscussionAvailability){
    this();
    this.setTenantId(aTenantId); 
    this.setProductId(aProductId);
    this.setProductOwnerId(aProductOwnerId); 
    this.setName(aName);
    this.setDescription(aDescription); 
    this.setDiscussion(ProductDiscussion.fromAvailability(aDiscussionAvailability)); 
    DomainEventPublisher.instance()
      ·publish(new ProductCreated(this.tenantId(),
																	this.productId(),
                                  this.productOwnerId(),
                                  this.name(),
                                  this.description(),
                                  this.discussion().availability().isRequested())); 
  } 
}

package com.saasovation.agilepm.domain.model.product;
public final class ProductDiscussion implements Serializable{ 
  public static ProductDiscussion fromAvailability(DiscussionAvailability anAvailability){ 
    if (anAvailability.isReady()){
      throw new IllegalArgumentException("Cannot be created ready."); 
    }
    DiscussionDescriptor descriptor=new DiscussionDescriptor(DiscussionDescriptor.UNDEFINED_ID);
    return new ProductDiscussion(descriptor, anAvailability); 
  }
}

public class ProductDiscussionRequestedListener extends ExchangeListener{
  private static final String COMMAND="com.saasovation.collaboration.discussion.CreateExclusiveDiscussion";
  @Override
  protected void filteredDispatch(String aType,String aTextMessage){ 
    NotificationReader reader=new NotificationReader(aTextMessage);
    if (!reader.eventBooleanValue ("requestingDiscussion")){ 
      return;
    }
    Properties parameters=this.parametersFrom(reader); 
    PropertiesSerializer serializer=PropertiesSerializer.instance();
    String serialization = serializer.serialize(parameters); 
    String commandId=this.commandIdFrom(parameters); 
    this.messageProducer()
      .send(serialization, MessageParameters.durableText Parameters(COMMAND,commandId,new Date()))
      .close();
  }
}

package com.saasovation.collaboration.infrastructure.messaging;
public class ExclusiveDiscussionCreationListener extends ExchangeListener{ 
  @Autowired
  private ForumService forumService; 
  @Override
  protected void filteredDispatch(String aType,String aTextMessage){
    NotificationReader reader=new NotificationReader(aTextMessage);
    String tenantId = reader.eventStringValue("tenantId"); 
    String exclusiveOwnerId=reader.eventStringValue("exclusiveOwnerId");
    String forumSubject = reader.eventStringValue ("forumTitle"); 
    String forumDescription=reader.eventStringValue ("forumDescription"); 
    String discussionSubject=reader.eventStringValue ("discussionSubject") ; 
    String creatorId =reader.eventStringValue("creatorId"); 
    String moderatorId = reader.eventStringValue("moderatorId"); 
    // forum这里会发布一个时间ForumStarted
    forumService.startExclusiveForumWithDiscussion(
      tenantId, 
      creatorId, 
      moderatorId, 
      forumSubject, 
      forumDescription,
      discussionSubject, 
      exclusiveOwnerId); 
  }
}

package com.saasovation.agilepm.infrastructure.messaging;
public class DiscussionStartedListener extends ExchangeListener{ 
  @Autowired
  private ProductService productService; 
  @Override
  protected void filteredDispatch(String aType,String aTextMessage){ 
    NotificationReader reader=new NotificationReader(aTextMessage);
    String tenantId = reader.eventStringValue("tenant.id"); 
    String productId = reader.eventStringValue ("exclusiveOwner"); 
    String discussionId=reader.eventStringValue("discussionId.id"); 
    productService.initiateDiscussion(new InitiateDiscussionCommand( tenantId,productId, discussionId)); 
  }
}

package com.saasovation.agilepm.application; 
public class ProductService{
	@Autowired
	private ProductRepository productRepository; 
  @Transactional
  public void initiateDiscussion (InitiateDiscussionCommand aCommand) {
    Product product =productRepository.productofId(
      new TenantId (aCommand.getTenantId ()), 
      new ProductId (aCommand. getProductId ()));
    if (product == null) {
      throw new IllegalStateException ("Unknown product of tenant id: " + aCommand.getTenantId ()+ " and product id: "+ aCommand. getProductId ());
    }
		product.initiateDiscussion (new DiscussionDescriptor(aCommand.getDiscussionId ()));
}

package com.saasovation.agilepm.domain.model.product; 
public class Product extends ConcurrencySafeEntity{
	public void initiateDiscussion(DiscussionDescriptor aDescriptor){ 
    if (aDescriptor==null){
      throw new IllegalArgumentException("The descriptor must not be nu11."); 
    }
    if (this.discussion().availability().isRequested()){ 
      this.setDiscussion(this.discussion()
                         .nowReady(aDescriptor)); 
      DomainEventPublisher.instance()
        ·publish(new ProductDiscussionInitiated(this.tenantId(),this.productId(), this.discussion())); 
    }
  }
}

public class ProcessTimedOut{
  public boolean hasFullyTimedOut(); // 是否属于完全超时还是重试
  public boolean allowsRetries(); // 是否允许重试
  public int retryCount(); // 当前重试次数
  public int totalRetriesPermitted(); // 允许的重试总数
  public boolean totalRetriesReached(); // 检验是否达到总重试测试
}

package com.saasovation.agilepm.domain.model.product;
import com.saasovation.common.domain.model.process.ProcessId; 
import com.saasovation.common.domain.model.process.ProcessTimedout; 
public class ProductDiscussionRequestTimedout extends ProcessTimedOut{
  public ProductDiscussionRequestTimedout(String aTenantId, ProcessId aProcessId, int aTotalRetriesPermitted, int aRetryCount){
    super(aTenantId, aProcessId,aTotalRetriesPermitted,aRetryCount); 
  }
}

package com.saasovation.agilepm.infrastructure.messaging; 
public class ProductDiscussionRequestedListener extends ExchangeListener{ 
  @Override
  protected void filteredDispatch(String aType,String aTextMessage){ 
    NotificationReader reader=new NotificationReader(aTextMessage);
    if (!reader.eventBooleanValue ("requestingDiscussion")){ 
      return;
    }
    String tenantId = reader.eventStringValue("tenantId.id"); 
    String productId = reader.eventStringValue ("product.id") ;
    productService.startDiscussionInitiation(new StartDiscussionInitiationCommand(tenantId,productId)); ／／将命令发送给协作上下文
  }
}

package com.saasovation.agilepm.application; 
public class ProductService {
  @Transactional
  public void startDiscussionInitiation(StartDiscussionInitiationCommand aCommand){ 
    Product product=productRepository·productofId(
      new TenantId(aCommand.getTenantId()),
      new ProductId(aCommand.getProductId())); 
    if (product == null){
      throw new IllegalStateException("Unknown product of tenant id:" +aCommand.getTenantId()+ " and product id:"+aCommand.getProductId()); 
    }
    String timedOutEventName=ProductDiscussionRequestTimedout.class.getName();
    TimeConstrainedProcessTracker tracker=new TimeConstrainedProcessTracker (
      product.tenantId().id(), 
      ProcessId.newProcessId(),
      "Create discussion for product:" +product.name(),
      new Date(),
      5L * 60L * 1000L, // 每五分钟重试一次，
      3, // 总共重试3次
      timedOutEventName); 
    processTrackerRepository.add(tracker); 
    product.setDiscussionInitiationId(tracker.processId().id()); 
  }
}

package com.saasovation.agilepm.application; 
public class ProcessService{
  @Transactional
  public void checkForTimedOutProcesses(){
    Collection<TimeConstrainedProcessTracker> trackers= processTrackerRepository.allTimedOut () ;
    for (TimeConstrainedProcessTracker tracker:trackers){ 
      tracker.informProcessTimedout();
    }
  }
}

package com.saasovation.agilepm.infrastructure.messaging;
public class ProductDiscussionRetryListener extends ExchangeListener{ 
  @Autowired
  private ProcessService processService; 
  @Override
  protected String exchangeName(){
    return Exchanges.AGILEPM_EXCHANGE_NAME; 
  }
  @Override
  protected void filteredDispatch(String aType,String aTextMessage){
    Notification notification= NotificationSerializer
      .instance()
      .deserialize(aTextMessage,Notification.class); 
    ProductDiscussionRequestTimedout event=notification.event(); 
    if (event.hasFullyTimedOut()){
      productService.timeOutProductDiscussionRequest(new TimeOutProductDiscussionRequestCommand(
        event.tenantId(),
        event.processId().id(),
        event.occurredon())); 
    }else{
        productService.retryProductDiscussionRequest(new RetryProductDiscussionRequestCommand(
          event.tenantId(),
          event.processId().id())); 
    }
	}
	@Override
  protected String[] listensToEvents(){ 
    return new String[]{"com.saasovation.agilepm.process. ProductDiscussionRequestTimedOut"}; 
  }
}

package com.saasovation.agilepm.application; 
public class ProductService{
  @Transactional
  public void timeOutProductDiscussionRequest(TimeOutProductDiscussionRequestCommand aCommand){ 
    ProcessId processId=ProcessId.existingProcessId(aCommand.getProcessId());
    TenantId tenantId = new TenantId(aCommand.getTenantId()); 
    Product product=productRepository·productOfDiscussionInitiationId(tenantId,processId.id());
    this.sendEmailForTimedOutProcess(product); 
    product.failDiscussionInitiation();
  }
}

package com.saasovation.agilepm.domain.model.product; 
public class Product extends ConcurrencySafeEntity{ 
  public void failDiscussionInitiation(){
    if (!this.discussion().availability().isReady()){ 
      this.setDiscussionInitiationId(null);
      this.setDiscussion(ProductDiscussion 
                         .fromAvailability(DiscussionAvailability.FAILED)); 
    }
  }
}

package com.saasovation.agilepm.application; 
public class ProductService{
  @Transactional
  public void retryProductDiscussionRequest(RetryProductDiscussionRequestCommand aCommand){
    ProcessId processId=ProcessId.existingProcessId(aCommand.getProcessId());
    TenantId tenantId = new TenantId(aCommand.getTenantId());
    Product product=productRepository·productofDiscussionInitiationId(tenantId,processId.id()); 
    if (product == null){
      throw new IllegalStateException("Unknown product of tenant id:" +aCommand.getTenantId()+" and discussion initiation id:"+processId.id());
    }
    this.requestProductDiscussion(new RequestProductDiscussionCommand(aCommand.getTenantId(), product.productId().id()));
  }
}

package com.saasovation.agilepm.application; 
public class ProductService{
	@Autowired
	private ProductRepository productRepository; 
  @Transactional
  public void initiateDiscussion (InitiateDiscussionCommand aCommand) {
    Product product =productRepository.productofId(
      new TenantId (aCommand.getTenantId ()), 
      new ProductId (aCommand. getProductId ()));
    if (product == null) {
      throw new IllegalStateException ("Unknown product of tenant id: " + aCommand.getTenantId ()+ " and product id: "+ aCommand. getProductId ());
    }
		product.initiateDiscussion (new DiscussionDescriptor(aCommand.getDiscussionId ()));
    
    // 新添加的行为 （找到监听器中的创建，修改为完成，防止触发重试和超时机制）
    TimeConstrainedProcessTracker tracker=this.processTrackerRepository.trackerOfProcessId(
      ProcessId.existingProcessId(product.discussionInitiationId())); 
    tracker.completed();
}

package com.saasovation.identityaccess.application;
public interface TenantIdentityService{
  public void activateTenant(TenantId aTenantId);  // 激活已有Tenant
  public void deactivateTenant(TenantId aTenantId);  // 禁用已有Tenant
  public String offerLimitedRegistrationInvitation(TenantId aTenantId,Date aStartsonDate,Date anUntilDate); // 有限制的邀请其他Tenant
  public String offerOpenEndedRegistrationInvitation(TenantId aTenantId);  // 无限制的邀请其他Tenant
  public Tenant provisionTenant(String aTenantName,
                                String aTenantDescription, 
                                boolean isActive,
                                FullName anAdministratorName, 
                                EmailAddress anEmailAddress, 
                                PostalAddress aPostalAddress, 
                                Telephone aPrimaryTelephone, 
                                Telephone aSecondaryTelephone, 
              	                String aTimeZone); // 创建Tenant
  public Tenant tenant(TenantId aTenantId);  // 查询Tenant
}

package com.saasovation.identityaccess.application;
public class TenantIdentityService{
  @Transactional
  @PreAuthorize ("hasRole ('SubscriberRepresentative')") 
  public void activateTenant(TenantId aTenantId){
		this.nonNullTeant(aTenantId).active();
  }
  @Transactional
  @PreAuthorize ("hasRole ('SubscriberRepresentative')") 
  public void deactivateTenant(TenantId aTenantId){ 
    this.nonNu11Tenant(aTenantId).deactivate(); 
  }
  @Transactional(readonly=true)
  public Tenant tenant(TenantId aTenantId){ 
    Tenant tenant=this.tenantRepository().tenantOfId(aTenantId); 
    return tenant;
  }
  @Transactional(readonly=true)
  @PreAuthorize ("hasRole ('SubscriberRepresentative')") 
  public Tenant provisionTenant(String aTenantName,
                                String aTenantDescription, 
                                boolean isActive,
                                FullName anAdministratorName, 
                                EmailAddress anEmailAddress, 
                                PostalAddress aPostalAddress, 
                                Telephone aPrimaryTelephone, 
                                Telephone aSecondaryTelephone, 
              	                String aTimeZone){
    return this.tenantProvisioningService·provisionTenant(aTenantName,
                                                          aTenantDescription, 
                                                          isActive,
                                                          anAdministratorName, 
                                                          anEmailAddress, 
                                                          aPostalAddress, 
                                                          aPrimaryTelephone,
                                                          aSecondaryTelephone, 
                                                          aTimeZone);   
   }
  private Tenant nonNullTenant(TenantId aTenantId){
    Tenant tenant=this.tenant(aTenantId);
    if(tenant==null){
      throw new IllegalArgumentException("Tenant does not exist."); 
    }
    return tenant; 
  }
}

public class ProvisionTenantCommand{ 
  private String tenantName;
  private String tenantDescription;
  private boolean isActive;
  private String administratorFirstName; 
  private String administratorLastName;
  private String emailAddress;
  private String primaryTelephone; 
  private String secondaryTelephone; 
  private String addressStreetAddress; 
  private String addressCity;
  private String addressStateProvince;
  private String addressPostalCode;
  private String addressCountryCode; 
  private String timeZone;
  public ProvisionTenantCommand(...){ }
  public ProvisionTenantCommand(){ 
    super();
  }
  public String getTenantName(){ 
    return tenantName;
  }
  public void setTenantName(String tenantName){ 
    this.tenantName=tenantName;
  }
}

public class TenantIdentityService{
  ...
  @Transactional
  public String provisionTenant (ProvisionTenantCommand aCommand){ 
    return tenant.tenantId().id();
  }
  ...
}

TenantData tenantData=tenantIdentityService.provisionTenant(···, myTenantDataTransformer); 
TenantPresentationModel tenantPresentationModel= new TenantPresentationModel(tenantData.value());

@Transactional
@PreAuthorize ("hasRole (' SubscriberRepresentative')") 
public void provisionTenant(String aTenantName,
                            String aTenantDescription,
                            boolean isActive,
                            FullName anAdministratorName, 
                            EmailAddress anEmailAddress, 
                            PostalAddress aPostalAddress,
                            Telephone aPrimaryTelephone, 
                            Telephone aSecondaryTelephone, 
                            String aTimeZone){
  Tenant tenant= this.tenantProvisioningService·provisionTenant(aTenantName,
                                                                aTenantDescription, 
                                                                isActive,
                                                                anAdministratorName, 
                                                                anEmailAddress, 
                                                                aPostalAddress, 
                                                                aPrimaryTelephone, 
                                                                aSecondaryTelephone, 
                                                                aTimeZone);
  this.tenantIdentityoutputPort().write(tenant); 
}