Examples with SessionName com.oracle.coherence.spring.annotation.SessionName used on opensource projects

Example 1 with SessionName

use of com.oracle.coherence.spring.annotation.SessionName in project coherence-spring by coherence-community.

the class NamedCacheConfiguration method getCacheInternal.

/**
 * Create a {@link NamedCache} instance.
 * <p>
 * If the injection point has a type of {@link ContinuousQueryCache} or is qualified with the {@link View}
 * annotation then a {@link ContinuousQueryCache} instance will be returned otherwise a {@link NamedCache} will be
 * returned.
 * @param injectionPoint the {@link InjectionPoint} that the {@link NamedCache} will be retrieved from
 * @param isCQC a flag specifying whether to return a {@link ContinuousQueryCache}
 * @param <K> the type of the cache keys
 * @param <V> the type of the cache values
 * @return a {@link NamedCache} instance to inject into the injection point
 */
private <K, V> NamedCache<K, V> getCacheInternal(InjectionPoint injectionPoint, boolean isCQC) {
    final MergedAnnotations mergedAnnotations;
    if (injectionPoint.getMethodParameter() != null) {
        mergedAnnotations = MergedAnnotations.from(injectionPoint.getMethodParameter().getParameterAnnotations());
    } else {
        mergedAnnotations = MergedAnnotations.from(injectionPoint.getAnnotatedElement());
    }
    final MergedAnnotation<Name> mergedNameAnnotation = mergedAnnotations.get(Name.class);
    final MergedAnnotation<SessionName> mergedSessionNameAnnotation = mergedAnnotations.get(SessionName.class);
    final MergedAnnotation<View> mergedViewAnnotation = mergedAnnotations.get(View.class);
    final String sessionName;
    final String cacheName = this.determineCacheName(injectionPoint, mergedNameAnnotation);
    if (!mergedSessionNameAnnotation.isPresent() || mergedSessionNameAnnotation.synthesize().value().trim().isEmpty()) {
        sessionName = Coherence.DEFAULT_NAME;
    } else {
        sessionName = mergedSessionNameAnnotation.synthesize().value();
    }
    if (logger.isDebugEnabled()) {
        logger.debug(String.format("Going to retrieve NamedCache '%s' for session '%s'.", cacheName, sessionName));
    }
    if (cacheName == null || cacheName.trim().isEmpty()) {
        throw new IllegalArgumentException("Cannot determine cache/map name. No @Name qualifier and injection point is not named");
    }
    final Session session = Coherence.findSession(sessionName).orElseThrow(() -> new IllegalStateException(String.format("No Session is configured with name '%s'.", sessionName)));
    final NamedCache<K, V> cache = session.getCache(cacheName);
    if (isCQC || mergedViewAnnotation.isPresent()) {
        boolean hasValues = (!mergedViewAnnotation.isPresent()) || mergedViewAnnotation.synthesize().cacheValues();
        final Filter filter = this.filterService.getFilter(injectionPoint);
        final ValueExtractor extractor = this.extractorService.getExtractor(injectionPoint, true);
        return new ContinuousQueryCache<>(cache, filter, hasValues, null, extractor);
    }
    return cache;
}

Example 2 with SessionName

use of com.oracle.coherence.spring.annotation.SessionName in project coherence-spring by coherence-community.

the class NamedTopicConfiguration method getTopicInternal.

private <V> NamedTopic<V> getTopicInternal(InjectionPoint injectionPoint) {
    final MergedAnnotations mergedAnnotations = MergedAnnotations.from(injectionPoint.getAnnotatedElement());
    final MergedAnnotation<SessionName> mergedSessionNameAnnotation = mergedAnnotations.get(SessionName.class);
    final MergedAnnotation<Name> mergedNameAnnotation = mergedAnnotations.get(Name.class);
    final String sessionName;
    final String topicName = this.determineTopicName(injectionPoint, mergedNameAnnotation);
    if (!mergedSessionNameAnnotation.isPresent() || mergedSessionNameAnnotation.synthesize().value().trim().isEmpty()) {
        sessionName = Coherence.DEFAULT_NAME;
    } else {
        sessionName = mergedSessionNameAnnotation.synthesize().value();
    }
    if (logger.isDebugEnabled()) {
        logger.debug(String.format("Going to retrieve NamedTopic '%s' for session '%s'.", topicName, sessionName));
    }
    if (topicName == null || topicName.trim().isEmpty()) {
        throw new IllegalArgumentException("Cannot determine topic name. No @Name qualifier and injection point is not named");
    }
    final Session session = Coherence.findSession(sessionName).orElseThrow(() -> new IllegalStateException(String.format("No Session is configured with name '%s'.", sessionName)));
    return session.getTopic(topicName);
}

Example 3 with SessionName

use of com.oracle.coherence.spring.annotation.SessionName in project coherence-spring by coherence-community.

the class CoherenceTopicListenerSubscribers method createSubscribers.

@SuppressWarnings({ "rawtypes", "unchecked" })
public void createSubscribers(Coherence coherence) {
    final Map<String, List<Method>> candidates = this.candidates.getCoherenceTopicListenerCandidateMethods();
    for (Map.Entry<String, List<Method>> entry : candidates.entrySet()) {
        final String beanName = entry.getKey();
        final List<Method> methods = entry.getValue();
        for (Method method : methods) {
            final Class<?> argumentClassType = method.getParameters()[0].getType();
            if (logger.isDebugEnabled()) {
                logger.debug(String.format("Handling Coherence %s - Bean: %s, method: %s", argumentClassType.getName(), beanName, method.getName()));
            }
            String topicName = Utils.getFirstTopicName(method).orElse(method.getName());
            SessionName sessionNameAnn = AnnotatedElementUtils.findMergedAnnotation(method, SessionName.class);
            String sessionName = (sessionNameAnn != null) ? sessionNameAnn.value() : Coherence.DEFAULT_NAME;
            if (!coherence.hasSession(sessionName)) {
                if (logger.isInfoEnabled()) {
                    logger.info(String.format("Skipping @CoherenceTopicListener annotated method subscription %s Session %s does not exist on Coherence instance %s", method, sessionName, coherence.getName()));
                }
                continue;
            }
            Session session = coherence.getSession(sessionName);
            Publisher[] sendToPublishers;
            String[] sendToTopics = getSendToTopicNames(method);
            if (sendToTopics.length > 0) {
                if (method.getReturnType().equals(Void.class)) {
                    if (logger.isInfoEnabled()) {
                        logger.info(String.format("Skipping @SendTo annotations for @CoherenceTopicListener annotated method %s - method return type is void", method));
                    }
                    sendToPublishers = new Publisher[0];
                } else {
                    sendToPublishers = new Publisher[sendToTopics.length];
                    for (int i = 0; i < sendToTopics.length; i++) {
                        NamedTopic<?> topic = session.getTopic(sendToTopics[i]);
                        sendToPublishers[i] = topic.createPublisher();
                    }
                }
            } else {
                sendToPublishers = new Publisher[0];
            }
            List<Subscriber.Option> options = new ArrayList<>();
            MergedAnnotation<SubscriberGroup> subscriberGroupAnn = MergedAnnotations.from(method).get(SubscriberGroup.class);
            subscriberGroupAnn.getValue("value", String.class).ifPresent((name) -> options.add(Subscriber.Name.of(name)));
            Set<Annotation> filterAnnotations = MergedAnnotations.from(method).stream().filter((mergedAnnotation) -> mergedAnnotation.getType().isAnnotationPresent(FilterBinding.class)).map(MergedAnnotation::synthesize).collect(Collectors.toSet());
            if (!filterAnnotations.isEmpty()) {
                Filter filter = this.filterService.resolve(filterAnnotations);
                if (filter != null) {
                    options.add(Subscriber.Filtered.by(filter));
                }
            }
            Set<Annotation> extractorAnnotations = MergedAnnotations.from(method).stream().filter((mergedAnnotation) -> mergedAnnotation.getType().isAnnotationPresent(ExtractorBinding.class)).map(MergedAnnotation::synthesize).collect(Collectors.toSet());
            if (!extractorAnnotations.isEmpty()) {
                ValueExtractor extractor = this.extractorService.resolve(extractorAnnotations);
                if (extractor != null) {
                    options.add(Subscriber.Convert.using(extractor));
                }
            }
            NamedTopic<?> topic = session.getTopic(topicName);
            Subscriber<?> subscriber = topic.createSubscriber(options.toArray(new Subscriber.Option[0]));
            Object bean = this.applicationContext.getBean(beanName);
            TopicSubscriber<?, ?, ?> topicSubscriber = new TopicSubscriber<>(topicName, subscriber, sendToPublishers, bean, method, this.scheduler);
            this.subscribers.add(topicSubscriber);
            topicSubscriber.nextMessage();
        }
    }
    this.subscribed = true;
}