Créer un composant Apache Camel de connexion à l’APNS – 2 sur 3

Nous avons vu dans un premier article comment initier le développement d’un composant Apache Camel. Cependant, nous n’avons pas encore abordé son développement à proprement parler et notre composant ne permet pas encore de communiquer avec les serveurs Apple. Nous allons donc voir dans cet article comment implémenter les différentes classes nécessaires au bon fonctionnement de notre composant.
Pour rappel l’objectif est de développer un composant capable de communiquer avec l’Apple Push Notification Service, qui permet d’envoyer des notifications aux appareils mobiles d’Apple (iPad, iPhone, iPod Touch).

Implémentation du composant

Les quatre interfaces suivantes doivent être implémentées pour développer un composant Camel permettant à la fois de consommer et produire des messages :

Interfaces à implémenter	Description
Component	Elle permet de créer les endpoints relatifs au composant.
Endpoint	Elle permet la création des Consumers et Producers relatifs à un endpoint défini par son URI.
Consumer	Elle correspond à l'implémentation des Consumers relatifs au endpoint d'un composant.
Producer	Elle correspond à l'implémentation des Producers relatifs au endpoint d'un composant.

La classe ApnsService

Pour communiquer avec les serveurs Apple, nous devons instancier un objet ApnsService. Le framework java-apns fournit pour cela la classe ApnsServiceBuilder. Celle-ci permet de construire facilement un objet ApnsService en spécifiant au builder la configuration souhaitée.

Le builder est obtenu grâce à la classe utilitaire Apns :

ApnsServiceBuilder builder = APNS.newService();

Ensuite, il suffit d’appeler les différentes méthodes de configuration du builder. Dans le cadre d’une configuration simple, le code source suivant est suffisant :

// Instanciation du builder
ApnsServiceBuilder builder = APNS.newService();

InputStream certificateInputStream = null;
try {
    // Ouverture de l'inputStream correspondant au certificat
    certificateInputStream = ResourceUtils.getInputStream("certificate_classpath");
    // Configuration du certificat utilisé pour communiquer avec l'APNS
    builder.withCert(certificateInputStream, "certificate_password")

} finally {
    // Fermeture de l'inputStream correspondant au certificat
    ResourceUtils.close(certificateInputStream);
}

// Configuration des URLs par défaut de production vers les serveurs APNS
builder.withProductionDestination();

// Configuration d'un pool de 5 connexions vers les serveurs APNS
builder.asPool(5);
// Configuration d'une politique de reconnexion uniquement lorsqu'une connexion vers les serveurs APNS est fermée
builder.withReconnectPolicy(ReconnectPolicy.Provided.NEVER);

// Obtention de l'instance configurée
ApnsService apnsService = builder.build();

Note : Un exemple de configuration plus complet de l’objet ApnsService peut être trouvé dans le code source du composant camel-apns.

Afin d’intégrer de façon efficace notre composant avec Spring, la classe ApnsServiceBuilder se révèle être un bon point de départ pour écrire une factory permettant de construire un objet ApnsService via Spring.

La classe ApnsComponent

L’interface Component correspond à l’unité de base définissant un composant Camel. Ce dernier est associé au scheme d’une URI lorsqu’il est ajouté à un contexte d’exécution.

Une implémentation par défaut de cette interface est fournie (en l’occurrence la classe DefaultComponent), ce qui permet de se focaliser sur les fonctionnalités de notre composant. Un composant Camel a pour rôle de créer les endpoints relatifs aux URI définies dans le contexte Camel. Cette tâche est réalisée par la méthode createEndpoint.

Chaque endpoint créé à partir d’un même ApnsComponent utilisera une unique configuration pour échanger avec l’APNS. C’est pourquoi le service d’accès à l’APNS sera injecté au niveau de l’objet ApnsComponent.

Le bean apnsService peut être setté par le constructeur ou bien par un setter pour faciliter l’intégration avec Spring.

public class ApnsComponent extends DefaultComponent {

    private ApnsService apnsService;

    public ApnsComponent() {
        super();
    }

    public ApnsComponent(ApnsService apnsService) {
        super();
        AssertUtils.notNull(apnsService, "apnsService is mandatory");
        this.apnsService = apnsService;
    }

    public ApnsComponent(CamelContext context) {
        super(context);
    }

    public ApnsService getApnsService() {
        return apnsService;
    }

    @SuppressWarnings("unchecked")
    protected Endpoint createEndpoint(String uri, String remaining, Map parameters) throws Exception {
        ApnsEndpoint endpoint = new ApnsEndpoint(uri, this);
        setProperties(endpoint, parameters);

        return endpoint;
    }

    /**
     * L'objet ApnsService peut être setté s'il le constructeur vide a été appelé pour instancier un objet ApnsComponent
     */
    public void setApnsService(ApnsService apnsService) {
        if (this.apnsService != null) {
            throw new IllegalArgumentException("apnsService already setted");
        }
        this.apnsService = apnsService;
    }

}

La classe ApnsEndpoint

La classe ApnsEndpoint permet de gérer la création des objets Consumer et Producer définis dans les routes Camel. Dans notre cas, nous étendrons la classe ScheduledPollEndpoint. Elle permet d’implémenter un endpoint qui saura créer des objets Consumer dont le déclenchement s’effectuera à intervalle régulier.

C’est la classe ApnsEndpoint qui a la charge de gérer les paramètres passés dans l’URI. Ainsi, les tokens passés en paramètres de l’URI d’un objet ApnsEndpoint seront injectés automatiquement via les setters correspondant aux paramètres renseignés. Si un paramètre ne correspond pas à un setter déclaré, une exception sera alors lancée.

Afin de faciliter le travail de configuration des paramètres spécifiques au travail de polling, c’est la classe ScheduledPollEndpoint qui lira automatiquement les paramètres de déclenchement renseignés sur l’URI. L’ApnsEndpoint aura donc toutes les informations nécessaires pour configurer les paramètres de déclenchement de l’objet ApnsConsumer.

Dans le cas de l’exécution de tests, les paramètres de déclenchement de la consommation de messages en provenance de l’APNS peuvent être configurés de la façon suivante :

from("apns:consumer?initialDelay=500&timeUnit=MILLISECONDS")
    .to("log:com.apache.camel.component.apns?showAll=true&multiline=true")
    .to("mock:result");

L’implémentation de la classe ApnsEndpoint donnera le code source suivant :

public class ApnsEndpoint extends ScheduledPollEndpoint {

    @SuppressWarnings("unused")
    private static final Log LOG = LogFactory.getLog(ApnsEndpoint.class);

    private CopyOnWriteArraySet consumers = new CopyOnWriteArraySet();

    private String tokens;

    public ApnsEndpoint(String uri, ApnsComponent component) {
        super(uri, component);
    }

    public String getTokens() {
        return tokens;
    }

    public void setTokens(String tokens) {
        this.tokens = tokens;
    }

    private ApnsComponent getApnsComponent() {
        return (ApnsComponent) getComponent();
    }

    /**
     * On obtient une instance de la clase ApnsService depuis l'object ApnsComponant
     */
    public ApnsService getApnsService() {
        return getApnsComponent().getApnsService();
    }

    /**
     * Indique que le endpoint n'est instancié qu'une seule fois par le contexte Camel
     */
    public boolean isSingleton() {
        return true;
    }

    /**
     * Permet d'obtenir la liste des consumers
     */
    protected Set getConsumers() {
        return consumers;
    }

    /**
     * Permet de créer un consumer
     */
    public Consumer createConsumer(Processor processor) throws Exception {

        ApnsConsumer apnsConsumer = new ApnsConsumer(this, processor);
        configureConsumer(apnsConsumer);

        return apnsConsumer;
    }

    /**
     * Permet de créer un producer
     */
    public Producer createProducer() throws Exception {
        return new ApnsProducer(this);
    }

}

La classe ApnsProducer

La classe ApnsProducer correspond à la classe qui permet d’envoyer des notifications aux terminaux mobiles Apple via les serveurs APNS. La classe abstraite DefaultProducer sera étendue pour fournir un support de base à notre implémentation.

Seule la méthode process reste ainsi à renseigner. Il suffira d’y implémenter l’envoi de la notification à l’APNS comme suit :

public class ApnsProducer extends DefaultProducer {

    private static final transient Log LOG = LogFactory.getLog(ApnsProducer.class);

    private ApnsEndpoint endpoint;

    private List tokenList;

    public ApnsProducer(ApnsEndpoint endpoint) {
        super(endpoint);
        this.endpoint = endpoint;
        configureTokens(apnsEndpoint);
    }

    /**
     * La méthode configureTokens permet d'extraire la liste de tokens destinataires
     * des notifications envoyées au endpoint.
     */
    private void configureTokens(ApnsEndpoint apnsEndpoint) {
        if (StringUtils.isNotEmpty(apnsEndpoint.getTokens())) {
            try {
                this.tokenList = extractTokensFromString(apnsEndpoint.getTokens());
            } catch (CamelException e) {
                throw new IllegalArgumentException(e);
            }
        }
    }

    /**
     * Méthode appelée par le producer pour traiter les échanges Camel
     */
    public void process(Exchange exchange) throws Exception {
        notify(exchange);
    }

    /**
     * La méthode notify est appelée pour envoyer une notification aux serveurs APNS.
     */
    private void notify(Exchange exchange) throws ApnsException, CamelException {

        String payload = exchange.getIn().getBody(String.class);

        // Une copie de la liste des tokens à notifier est passée en paramètre,
        // ainsi que le payload du message
        endpoint.getApnsService().push(new ArrayList(tokenList), payload);
    }

    /**
     * On extrait une liste de tokens à partir d'une chaîne de caractères contenant
     * des tokens séparés par un point virgule.
     */
    private List extractTokensFromString(String tokensStr) throws CamelException {

        tokensStr = StringUtils.trim(tokensStr);

        if (tokensStr.isEmpty()) {
            throw new CamelException("No token specified");
        }

        String[] tokenArray = tokensStr.split(";");

        int tokenArrayLength = tokenArray.length;
        for (String token: tokenArray) {
            token = token.trim();
            int tokenLength = token.length();
            // La taille d'un token est limitée à 64 caractères
            if (tokenLength != 64) {
                throw new CamelException("Token has wrong size['" + tokenLength + "']: " + token);
            }
        }

        List tokens = Arrays.asList(tokenArray);

        return tokens;
    }

}

Une fois la notification envoyée aux serveurs APNS, le terminal Apple recevra la notification et l’affichera comme suit dans le cas d’une notification texte:

La classe ApnsConsumer

La classe ApnsConsumer a pour objectif de nous permettre de consommer le flux feedback renvoyé par les serveurs APNS, permettant de connaître les terminaux mobiles Apple pour lesquels il n’est plus nécessaire d’envoyer de notifications (Par exemple, lorsque l’application a été désintallée).

Comme vu précédemment, la stratégie de consommation peut suivre un pattern de type Event Driven Consumer ou bien de Polling Consumer. Ici, nous choisirons le pattern Event Driven Consumer, et nous étendrons la classe ScheduledPollConsumer qui prend en charge toute la complexité de la gestion de consommation des messages et nous laisse nous concentrer sur le principal, c’est à dire, fournir les messages à consommer par nos routes de traitement.

Pour cela, il suffit d’implémenter la méthode poll qui permet d’interroger le service feedback d’Apple selon le timing d’interrogation configuré par l’URI.

C’est la classe ApnsEndpoint, qui au moment de la création de l’objet ApnsConsumer, configurera les paramétrages de polling à partir des paramètres récupérés via l’URI.

La méthode doStart aura pour rôle de vérifier qu’un seul objet ApnsConsumer est créé afin de ne pas consommer en double les messages d’une même configuration de l’ApnsService.

La méthode poll est implémentée ici de façon à récupérer les informations sur les appareils pour lesquels il ne faut plus envoyer de notifications. Pour cela, nous récupérons dans un premier temps une liste d’objets InactiveDevice renvoyés par le flux feedback de l’APNS, puis nous itérons sur cette liste pour les faire traiter par le processor Camel, qui n’est autre que la route de traitement Camel.

public class ApnsConsumer extends ScheduledPollConsumer {

    private static final int DEFAULT_CONSUME_INITIAL_DELAY = 10;
    private static final int DEFAULT_CONSUME_DELAY = 3600;
    private static final TimeUnit DEFAULT_CONSUME_TIME_UNIT = TimeUnit.SECONDS;
    private static final boolean DEFAULT_APNS_FIXED_DELAY = true;

    /**
     * La configuration par défaut des paramètres de polling est fait lors de la
     * construction de l'objet. Ces valeurs pourront être écrasées par des valeurs
     * configurées via l'URI.
     */
    public ApnsConsumer(ApnsEndpoint apnsEndpoint, Processor processor) {
        super(apnsEndpoint, processor);

        setInitialDelay(DEFAULT_CONSUME_INITIAL_DELAY);
        setDelay(DEFAULT_CONSUME_DELAY);
        setTimeUnit(DEFAULT_CONSUME_TIME_UNIT);
        setUseFixedDelay(DEFAULT_APNS_FIXED_DELAY);
    }

    /**
     * Chaque élément de cette liste obtenue par l'appel de la méthode getInactiveDevices()
     * sera passé à la route Camel via l'appel de la méthode getProcessor().process(e)
     */
    protected void poll() throws Exception {
        List inactiveDeviceList = getInactiveDevices();

        Iterator it = inactiveDeviceList.iterator();

        while (it.hasNext()) {
            InactiveDevice inactiveDevice = it.next();

            Exchange e = getEndpoint().createExchange();

            e.getIn().setBody(inactiveDevice);

            // On donne chaque élément de la liste de terminaux inactifs
            // reçu sur le flux feedback pour qu'il soit traité par la route associée
            getProcessor().process(e);
        }
    }

    /**
     * La méthode getInactiveDevices() permet d'obtenir depuis le flux feedback une
     * liste d'objects InactiveDevice.
     */
    private List getInactiveDevices() {
        ApnsEndpoint ae = (ApnsEndpoint) getEndpoint();

        Map inactiveDeviceMap = ae.getApnsService().getInactiveDevices();

        List inactiveDeviceList = new ArrayList();

        for (Entry inactiveDeviceEntry: inactiveDeviceMap.entrySet()) {
            String deviceToken = inactiveDeviceEntry.getKey();
            Date date = inactiveDeviceEntry.getValue();

            InactiveDevice inactiveDevice = new InactiveDevice(deviceToken, date);

            inactiveDeviceList.add(inactiveDevice);
        }

        return inactiveDeviceList;
    }

    @Override
    public ApnsEndpoint getEndpoint() {
        return (ApnsEndpoint) super.getEndpoint();
    }

    /**
     * La consommation du flux feedback doit être faite par un unique consumer.
     * La méthode doStart permet de s'enassurer lors du démarrage.
     * Si un autre consumer est déjà déclaré, alors une exception sera lancée.
     */
    @Override
    protected void doStart() throws Exception {
        // only add as consumer if not already registered
        if (!getEndpoint().getConsumers().contains(this)) {
            if (!getEndpoint().getConsumers().isEmpty()) {
                throw new IllegalStateException("Endpoint " + getEndpoint().getEndpointUri() + " only allows 1 active consumer but you attempted to start a 2nd consumer.");
            }
            getEndpoint().getConsumers().add(this);
        }
        super.doStart();
    }

    @Override
    protected void doStop() throws Exception {
        super.doStop();
        getEndpoint().getConsumers().remove(this);
    }

}

Conclusion

Nous avons vu dans cette seconde partie comment implémenter les classes nécessaires au développement d’un composant Apache Camel. Nous verrons dans une dernière partie comment mettre en place différentes stratégies de test pour valider notre composant.

Liens utiles

• Ecrire des composants Apache Camel
• Création d’un composant Camel pour communiquer avec Amazon SQS
• Apple Push Notification Service par Apple
• Provider Communication with Apple Push Notification Service par Apple

Le site google code du composant ‘camel-apns’ présenté dans l’article :

• http://code.google.com/p/camel-apns

Parties suivantes et précédentes de l’article :

• Créer un composant Apache Camel de connexion à l’APNS – 1 sur 3
• Créer un composant Apache Camel de connexion à l’APNS – 3 sur 3