3. Create OCD configuration file as MultisiteExternalizeOCDConfiguration.java

package com.javadoubts.core.services;

import org.osgi.service.metatype.annotations.AttributeDefinition;
import org.osgi.service.metatype.annotations.AttributeType;
import org.osgi.service.metatype.annotations.ObjectClassDefinition;

@ObjectClassDefinition(
    name = "MultisiteExternalizer OCD Configuration",
    description = "MultisiteExternalizer OCD Configuration description"
)
public @interface MultisiteExternalizeOCDConfiguration {

    @AttributeDefinition(
            name = "String[] of Site and Domain Mapping",
            description = "String[] of Site and Domain Mapping",
            type = AttributeType.STRING)
    String[] mapping();

}

3. Create below interface named as MultisiteExternalizerOCDService.java having and a public method getMapping() method.

package com.javadoubts.core.services;

public interface MultisiteExternalizerOCDService {
    public String[] getMapping();
}

4. Create below class MultisiteExternalizerOCDServiceImpl.java which implements MultisiteExternalizerOCDService.java interface and implement getMapping() method.

package com.javadoubts.core.services.impl;

import com.javadoubts.core.services.MultisiteExternalizeOCDConfiguration;
import com.javadoubts.core.services.MultisiteExternalizerOCDService;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.metatype.annotations.Designate;

@Component(service = MultisiteExternalizerOCDService.class, immediate = true)
@Designate(ocd = MultisiteExternalizeOCDConfiguration.class)
public class MultisiteExternalizerOCDServiceImpl implements MultisiteExternalizerOCDService {

    private String[] mapping;

    @Activate
    protected void activate(MultisiteExternalizeOCDConfiguration config) {
       this.mapping = config.mapping();
    }

    @Override
    public String[] getMapping() {
        return mapping;
    }
}

5. Create or use earlier created Sling Model Java Class to generate end User externalized URL depending on domain and site hierarchy:

package com.javadoubts.core.models;

import com.day.cq.commons.Externalizer;
import com.javadoubts.core.services.MultisiteExternalizerOCDService;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.Optional;
import org.apache.sling.models.annotations.injectorspecific.OSGiService;
import org.apache.sling.models.annotations.injectorspecific.SlingObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.annotation.PostConstruct;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;

@Model(adaptables = Resource.class)
public class ButtonModel {

    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Inject
    @Optional
    protected String link;

    @SlingObject
    ResourceResolver resourceResolver;

    @OSGiService
    Externalizer externalizer;

    @OSGiService
    MultisiteExternalizerOCDService multisiteExternalizerOCDService;


    private String externalizeLink;
    @PostConstruct
    protected void init() {

        List<String> paths = new ArrayList<>();
        List<String> domains = new ArrayList<>();

        /*
          This will create a list of paths and domains separated by 
          colon(:) which is define as part of 
          com.javadoubts.core.services.impl.MultisiteExternalizerOCDServiceImpl.xml
          OSGI Configuration.          

          /content/practice:practice,
          /content/test:test,
          /content/javadoubts:javadoubt
        */        
        String[] mappings = multisiteExternalizerOCDService.getMapping();
        if (ArrayUtils.isNotEmpty(mappings)) {
            for (String mapping: mappings) {
                String[] parts = StringUtils.split(mapping, ":");
                if (parts.length == 2 ) {
                    paths.add(parts[0]);
                    domains.add(parts[1]);
                }
            }
        }

        String domain = getMappedDomain(paths, domains, link);

        // It will create externalize path depending on domain key.
        externalizeLink = externalizer.externalLink(
            resourceResolver, domain, link);
    }

    /* 
      Function will return key for domain mapping. 
      e.g. practice for /content/practice site hierarchy.
    */
    private String getMappedDomain(List<String> paths, List<String> domains, String url) {
        String domain = null;
        for (int i = 0; i < paths.size(); i++) {
            String candidatePath = paths.get(i);
            if (StringUtils.isNotEmpty(link) && link.startsWith(candidatePath)) {
                domain = domains.get(i);
                break;
            }
        }

        if (StringUtils.isBlank(domain)) domain = "publish";

        return domain;
    }


    public String getLink() {
        return link;
    }

    public void setLink(String link) {
        this.link = link;
    }

    public String getExternalizeLink() {
        return externalizeLink;
    }

    public void setExternalizeLink(String externalizeLink) {
        this.externalizeLink = externalizeLink;
    }
}

6. Create a component to author link having below sightly code within it as shown below:

7. Below is the component output where it is using http://practice.com as domain depending on site hierarchy /content/practice/us/en/home starting with /content/practice.