rx.subjects.SerializedSubject Java Examples

public Observable<LogRow> getLogs() {

        SerializedSubject<LogRow, LogRow> subject
                = new SerializedSubject<>(PublishSubject.create());

        ThreadFactory threadFactory = new ThreadFactoryBuilder().setDaemon(true).setNameFormat(Example_8_Model.class.getSimpleName() + "-thread-%d").build();
        final ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors(), threadFactory);

        IntStream.range(1, Runtime.getRuntime().availableProcessors() + 1).forEach(value -> {
            executorService.submit(() -> {
                SysOutUtils.sysout(Thread.currentThread().getName() + " will briefly start creating lots of log rows...");
                VariousUtils.sleep(1000);
                long incrementingNumber = 1;
                while (true) {
                    subject.onNext(new LogRow(
                            DateTimeFormatter.ISO_DATE_TIME.format(LocalDateTime.now()),
                            "Status " + Integer.toString(ThreadLocalRandom.current().nextInt(1, 5)),
                            "Action " + incrementingNumber + " from " + Thread.currentThread().getName()));
                }
            });
        });

        return subject;
    }
 

/**
 * Sends an event to the bus
 * <p>
 * @param  event  the event that should be broadcasted to the bus
 * @param  key  the key this event should be broadcasted to
 * @param  sendToDefaultBusAsWell  if true, all observers of the event class will receive this event as well
 */
public synchronized <T> void sendEvent(T event, String key, boolean sendToDefaultBusAsWell)
{
    RXBusEventIsNullException.checkEvent(event);
    RXBusKeyIsNullException.checkKey(key);

    // 1) send to key bound bus
    SerializedSubject subject = getSubject(new RXQueueKey(event.getClass(), key), false);
    // only send event, if subject exists => this means someone has at least once subscribed to it
    if (subject != null)
        subject.onNext(event);

    // 2) send to unbound bus
    if (sendToDefaultBusAsWell)
        sendEvent(event);
}
 

/**
 * Sends an event to the bus
 * <p>
 * @param  event  the event that should be broadcasted to the bus
 * @param  key  the key this event should be broadcasted to
 * @param  sendToDefaultBusAsWell  if true, all observers of the event class will receive this event as well
 */
public synchronized <T> void sendEvent(T event, Integer key, boolean sendToDefaultBusAsWell)
{
    RXBusEventIsNullException.checkEvent(event);
    RXBusKeyIsNullException.checkKey(key);

    // 1) send to key bound bus
    SerializedSubject subject = getSubject(new RXQueueKey(event.getClass(), key), false);
    // only send event, if subject exists => this means someone has at least once subscribed to it
    if (subject != null)
        subject.onNext(event);

    // 2) send to unbound bus
    if (sendToDefaultBusAsWell)
        sendEvent(event);
}
 

protected void failedToWriteBatch(AsyncConnection<T> connection,
                                  int batchSize, Counter legacyDroppedWrites, SerializedSubject<String, String> metaMsgSubject) {
    if (legacyDroppedWrites != null) {
        legacyDroppedWrites.increment(batchSize);
    }
    if (metaMsgSubject != null) {
        MantisMetaDroppedMessage msg = new MantisMetaDroppedMessage(batchSize, System.currentTimeMillis());
        metaMsgSubject.onNext(msg.toString());
    }
    failedWrites.increment(batchSize);
    connectionManager.failedWrites(connection, batchSize);
}
 

public <T> Observable<T> register(@NonNull Object tag, @NonNull Class<T> clazz) {
    List<Subject> subjectList = mSubjectsMapper.get(tag);
    if (subjectList == null) {
        subjectList = new ArrayList<>();
        mSubjectsMapper.put(tag, subjectList);
    }

    Subject<T, T> subject = new SerializedSubject<>(PublishSubject.<T>create());
    subjectList.add(subject);
    if (DEBUG) {
        Timber.d("[register] mSubjectsMapper: " + mSubjectsMapper);
    }
    return subject;
}
 

private synchronized SerializedSubject getSubject(RXQueueKey key, boolean createIfMissing)
{
    // 1) look if key already has a publisher subject, if so, return it
    if (mSubjectsKeys.containsKey(key))
        return mSubjectsKeys.get(key);
    // 2) else, create a new one and put it into the map
    else if (createIfMissing)
    {
        SerializedSubject subject = new SerializedSubject(PublishSubject.create());
        mSubjectsKeys.put(key, subject);
        return subject;
    }
    else
        return null;
}
 

private synchronized SerializedSubject getSubject(Class<?> key, boolean createIfMissing)
{
    // 1) look if key already has a publisher subject, if so, return it
    if (mSubjectsClasses.containsKey(key))
        return mSubjectsClasses.get(key);
    // 2) else, create a new one and put it into the map
    else if (createIfMissing)
    {
        SerializedSubject subject = new SerializedSubject(PublishSubject.create());
        mSubjectsClasses.put(key, subject);
        return subject;
    }
    else
        return null;
}
 

/**
 * Get an observable that observes all events that are send with the key and are of the type of the event class
 * <p>
 * @param  key  the event key you want to observe
 * @return      an Observable, that will observe all events of the @param key class
 */
public synchronized <T> Observable<T> observeEvent(RXQueueKey key)
{
    if (key == null)
        throw new RuntimeException("You can't use a null key");

    SerializedSubject subject = getSubject(key, true);
    return subject;
}
 

/**
 * Get an observable that observes all events of the the class the
 * <p>
 * @param  eventClass  the class of event you want to observe
 * @return      an Observable, that will observe all events of the @param key class
 */
public synchronized <T> Observable<T> observeEvent(Class<T> eventClass)
{
    RXBusEventIsNullException.checkEvent(eventClass);

    SerializedSubject subject = getSubject(eventClass, true);
    return subject;
}
 

/**
 * Sends an event to the bus
 * ATTENTION: all observers that are observing the class of the event will retrieve it
 * <p>
 * @param  event  the event that should be broadcasted to the bus
 */
public synchronized <T> void sendEvent(T event)
{
    RXBusEventIsNullException.checkEvent(event);

    SerializedSubject subject = getSubject(event.getClass(), false);
    // only send event, if subject exists => this means someone has at least once subscribed to it
    if (subject != null)
        subject.onNext(event);
}
 

@Inject
public DefaultAuditLogService() {
    this.observer = new SerializedSubject<>(PublishSubject.create());
    this.observable = observer
            .onBackpressureBuffer(
                    BACK_PRESSURE_BUFFER_SIZE,
                    () -> logger.warn("Exceeded back pressure buffer of " + BACK_PRESSURE_BUFFER_SIZE),
                    BackpressureOverflow.ON_OVERFLOW_DROP_OLDEST
            )
            .observeOn(Schedulers.io());
}
 

protected Observable<Void> manageConnection(final DefaultChannelWriter<R> writer, String host, int port,
                                            String groupId, String slotId, String id, final AtomicLong lastWriteTime, final boolean applicationHeartbeats,
                                            final Subscription heartbeatSubscription, boolean applySampling, long samplingRateMSec,
                                            final SerializedSubject<String, String> metaMsgSubject, final Subscription metaMsgSubscription,
                                            Func1<T, Boolean> predicate, final Action0 connectionClosedCallback,
                                            final Counter legacyMsgProcessedCounter, final Counter legacyDroppedWrites,
                                            final Action0 connectionSubscribeCallback) {
    return manageConnectionWithCompression(writer, host, port, groupId, slotId, id, lastWriteTime, applicationHeartbeats, heartbeatSubscription,
            applySampling, samplingRateMSec, null, null, predicate, connectionClosedCallback, legacyMsgProcessedCounter, legacyDroppedWrites, connectionSubscribeCallback, false, false);

}
 

@SuppressWarnings({ "unchecked", "rawtypes", "null" })
GatewayHandler(WebSocketClientHandshaker handshaker) {
   this.authorizedMessages = new SerializedSubject(PublishSubject.create());
   this.registeredMessages = new SerializedSubject(PublishSubject.create());
   this.platformMessages = new SerializedSubject(PublishSubject.create());
   this.protocolMessages = new SerializedSubject(PublishSubject.create());

   this.handshaker = handshaker;
   this.websocketFrameBuf = Unpooled.unreleasableBuffer(Unpooled.buffer(GatewayConnection.WEBSOCKETS_MAX_FRAME_LENGTH));

   this.lastHubMsg = System.nanoTime();
   this.lastPlatformMsg = System.nanoTime();
}
 

private RxAttachPicker() {
    this.subject = new SerializedSubject<>(PublishSubject.<ArrayList<String>>create());
}
 

public WritableEndpoint(String host, int port, String slotId,
                        ObservableConnection<?, ?> connection) {
    super(host, port, slotId);
    subject = new SerializedSubject<T, T>(PublishSubject.<T>create());
    this.connection = connection;
}
 

private RxBus(){
    rxBus = new SerializedSubject(PublishSubject.<T>create());
}
 

public RxBus() {
    mBus = new SerializedSubject<>(PublishSubject.create());
}
 

public RxBus() {
    bus = new SerializedSubject<>(PublishSubject.create());
}
 

private RxBus() {
    //非线程安全的PublishSubject包装成线程安全的SerializedSubject
    bus = new SerializedSubject<>(PublishSubject.create());
}
 

public WritableEndpoint(String host, int port) {
    super(host, port);
    subject = new SerializedSubject<T, T>(PublishSubject.<T>create());
}
 

public RxBus() {
        mSubject = new SerializedSubject<>(PublishSubject.create());
        mSubscriptionMap = new HashMap<>();
}
 

private RxImagePicker() {
    this.subject = new SerializedSubject<>(PublishSubject.<List<Image>>create());
}
 

private RxTokenPicker() {
    this.subject = new SerializedSubject<>(PublishSubject.<ArrayList<FormTokenObject>>create());
}
 

private RxSignaturePicker() {
    this.subject = new SerializedSubject<>(PublishSubject.<Bitmap>create());
}
 

private RxBus()
{

    bus = new SerializedSubject<>(PublishSubject.create());
}
 

public RxBus() {
    bus = new SerializedSubject<>(PublishSubject.create());
}
 

private RxBus() {
    subject = new SerializedSubject<>(PublishSubject.create());
}
 

private RxBus() {
    bus = new SerializedSubject<>(PublishSubject.create());
}
 

private RxBus()
{

    bus = new SerializedSubject<>(PublishSubject.create());
}
 

private RxBusManager(){
        mSubject = new SerializedSubject<>(PublishSubject.create());
        mSubscriptionMap = new HashMap<>();
}