Java CacheWriterException类代码示例

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void sessionEnd(boolean commit) throws CacheWriterException {
    Transaction transaction = session.transaction();
    if (transaction == null) {
        return;
    }
    Map<Object, Object> properties = session.properties();
    if (!commit) {
        Map bigBuffer = (Map) properties.get(BUFFER_PROPERTY_NAME);
        if (bigBuffer != null) {
            bigBuffer.remove(cacheName);
        }
    }
    Set<String> caches = (Set<String>) properties.get(CACHES_PROPERTY_NAME);
    if (caches != null && caches.remove(cacheName) && caches.isEmpty()) {
        Map<String, Collection<Cache.Entry<?, ?>>> buffer =
                (Map<String, Collection<Cache.Entry<?, ?>>>) properties.get(BUFFER_PROPERTY_NAME);
        notifyListeners(nextTransactionId(), buffer);
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
@Override
public void handle(long transactionId, Map<String, Collection<Cache.Entry<?, ?>>> updates)
        throws CacheWriterException {
    List<Future<RecordMetadata>> futures = producers
            .get()
            .stream()
            .map(producer -> producer.send(transactionId, updates))
            .collect(Collectors.toList());
    try {
        for (Future<RecordMetadata> future : futures) {
            future.get();
        }
    } catch (InterruptedException | ExecutionException e) {
        throw new CacheWriterException(e);
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public Future<RecordMetadata> send(long transactionId,
    Map<String, Collection<Cache.Entry<?, ?>>> updates) throws CacheWriterException {
    try {
        int partition = partition(transactionId, partitions);
        TransactionScope key = keyTransformer.apply(transactionId, updates);
        List<List> value = valueTransformer.apply(updates);
        ProducerRecord record = new ProducerRecord(dataTopic, partition, transactionId, serializer.serialize(key),
            serializer.serialize(value));
        return producer.send(record);
    }
    catch (Exception e) {
        throw new CacheWriterException(e);
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void sessionEnd(boolean commit) throws CacheWriterException {
    Transaction transaction = session.transaction();
    if (transaction == null) {
        return;
    }
    Map<Object, Object> properties = session.properties();
    if (!commit) {
        Map bigBuffer = (Map)properties.get(BUFFER_PROPERTY_NAME);
        if (bigBuffer != null) {
            bigBuffer.remove(cacheName);
        }
    }
    Set<String> caches = (Set<String>)properties.get(CACHES_PROPERTY_NAME);
    if (caches != null && caches.remove(cacheName) && caches.isEmpty()) {
        Map<String, Collection<Cache.Entry<?, ?>>> buffer =
            (Map<String, Collection<Cache.Entry<?, ?>>>)properties.get(BUFFER_PROPERTY_NAME);
        notifyListeners(nextTransactionId(), buffer);
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void sessionEnd(boolean commit) throws CacheWriterException {
    Transaction transaction = session.transaction();
    if (transaction == null) {
        return;
    }
    Map<Object, Object> properties = session.properties();
    if (!commit) {
        Map bigBuffer = (Map)properties.get(BUFFER_PROPERTY_NAME);
        if (bigBuffer != null) {
            bigBuffer.remove(cacheName);
        }
    }
    Set<String> caches = (Set<String>)properties.get(CACHES_PROPERTY_NAME);
    if (caches != null && caches.remove(cacheName) && caches.isEmpty() && !isOnDRCluster()) {
        Map<String, Collection<Cache.Entry<?, ?>>> buffer =
            (Map<String, Collection<Cache.Entry<?, ?>>>)properties.get(BUFFER_PROPERTY_NAME);
        notifyListeners(nextTransactionId(), buffer);
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
@Override public void writeTransaction(long transactionId, Map<String, Collection<Cache.Entry<?, ?>>> updates)
    throws CacheWriterException {
    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("[M] Writing synchronous replica for transaction {} with size of batch {}",
                transactionId, updates.size());
    }
    Collection<RemoteKafkaProducer> producers = replicaProducersManager.getProducers();

    if (!producers.isEmpty()) {
        List<Future<RecordMetadata>> futures = new ArrayList<>(producers.size());
        for (RemoteKafkaProducer producer : producers) {
            futures.add(producer.writeTransaction(transactionId, updates));
        }
        wait(futures);
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
/** {@inheritDoc} */
@SuppressWarnings({"JpaQueryApiInspection"})
@Override public void delete(Object key) {
    System.out.println(">>> Store delete [key=" + key + ']');

    Session hibSes = ses.attachment();

    try {
        hibSes.createQuery("delete " + Person.class.getSimpleName() + " where key = :key").
            setParameter("key", key).
            executeUpdate();
    }
    catch (HibernateException e) {
        throw new CacheWriterException("Failed to remove value from cache store [key=" + key + ']', e);
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void onSessionEnd(CacheStoreSession ses, boolean commit) {
    Session hibSes = ses.attach(null);

    if (hibSes != null) {
        try {
            Transaction tx = hibSes.getTransaction();

            if (commit) {
                if (hibSes.isDirty())
                    hibSes.flush();

                if (tx.getStatus() == TransactionStatus.ACTIVE)
                    tx.commit();
            }
            else if (tx.getStatus().canRollback())
                tx.rollback();
        }
        catch (HibernateException e) {
            throw new CacheWriterException("Failed to end store session [tx=" + ses.transaction() + ']', e);
        }
        finally {
            hibSes.close();
        }
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void write(javax.cache.Cache.Entry<? extends Long, ? extends Person> entry) {
    Long key = entry.getKey();
    Person val = entry.getValue();

    System.out.println(">>> Store write [key=" + key + ", val=" + val + ']');

    Session hibSes = ses.attachment();

    try {
        hibSes.saveOrUpdate(val);
    }
    catch (HibernateException e) {
        throw new CacheWriterException("Failed to put value to cache store [key=" + key + ", val" + val + "]", e);
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void onSessionStart(CacheStoreSession ses) {
    if (ses.attachment() == null) {
        try {
            Session hibSes = sesFactory.openSession();

            ses.attach(hibSes);

            if (ses.isWithinTransaction())
                hibSes.beginTransaction();
        }
        catch (HibernateException e) {
            throw new CacheWriterException("Failed to start store session [tx=" + ses.transaction() + ']', e);
        }
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void onSessionEnd(CacheStoreSession ses, boolean commit) {
    Session hibSes = ses.attach(null);

    if (hibSes != null) {
        try {
            Transaction tx = hibSes.getTransaction();

            if (commit) {
                hibSes.flush();

                if (tx.isActive())
                    tx.commit();
            }
            else if (tx.isActive())
                tx.rollback();
        }
        catch (HibernateException e) {
            throw new CacheWriterException("Failed to end store session [tx=" + ses.transaction() + ']', e);
        }
        finally {
            hibSes.close();
        }
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void sessionEnd(boolean commit) throws CacheWriterException {
    if (!storeSes.isWithinTransaction())
        return;

    List<Mutation> mutations = mutations();
    if (mutations == null || mutations.isEmpty())
        return;

    CassandraSession ses = getCassandraSession();

    try {
        ses.execute(mutations);
    }
    finally {
        mutations.clear();
        U.closeQuiet(ses);
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void delete(final Object key) {
    try {
        doInvoke(new IgniteInClosureX<BinaryRawWriterEx>() {
            @Override public void applyx(BinaryRawWriterEx writer) throws IgniteCheckedException {
                writer.writeByte(OP_RMV);
                writer.writeLong(session());
                writer.writeString(ses.cacheName());
                writer.writeObject(key);
            }
        }, null);
    }
    catch (IgniteCheckedException e) {
        throw new CacheWriterException(U.convertExceptionNoWrap(e));
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void deleteAll(final Collection<?> keys) {
    try {
        doInvoke(new IgniteInClosureX<BinaryRawWriterEx>() {
            @Override public void applyx(BinaryRawWriterEx writer) throws IgniteCheckedException {
                writer.writeByte(OP_RMV_ALL);
                writer.writeLong(session());
                writer.writeString(ses.cacheName());

                writer.writeInt(keys.size());

                for (Object o : keys)
                    writer.writeObject(o);
            }
        }, null);
    }
    catch (IgniteCheckedException e) {
        throw new CacheWriterException(U.convertExceptionNoWrap(e));
    }
}
 

import javax.cache.integration.CacheWriterException; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void onSessionEnd(CacheStoreSession ses, boolean commit) {
    Connection conn = ses.attach(null);

    if (conn != null) {
        try {
            if (commit)
                conn.commit();
            else
                conn.rollback();
        }
        catch (SQLException e) {
            throw new CacheWriterException("Failed to end store session [tx=" + ses.transaction() + ']', e);
        }
        finally {
            U.closeQuiet(conn);
        }
    }
}