Java ContentUrlKeyEntity类代码示例

import org.alfresco.repo.domain.contentdata.ContentUrlKeyEntity; //导入依赖的package包/类
@Override
protected ContentUrlEntity createContentUrlEntity(String contentUrl, long size, ContentUrlKeyEntity contentUrlKeyEntity)
{
    ContentUrlEntity contentUrlEntity = new ContentUrlEntity();
    contentUrlEntity.setContentUrl(contentUrl);
    contentUrlEntity.setSize(size);
    contentUrlEntity.setOrphanTime(null);
    /* Long id = (Long) */ template.insert(INSERT_CONTENT_URL, contentUrlEntity);
    /*contentUrlEntity.setId(id);*/

    if(contentUrlKeyEntity != null)
    {
        template.insert(INSERT_SYMMETRIC_KEY, contentUrlKeyEntity);
    }

    // Done
    return contentUrlEntity;
}
 

import org.alfresco.repo.domain.contentdata.ContentUrlKeyEntity; //导入依赖的package包/类
@Override
protected int updateContentUrlEntity(ContentUrlEntity existing, ContentUrlEntity entity)
{
    int ret = 0;

    ContentUrlKeyEntity existingContentUrlKey = existing.getContentUrlKey();
    ContentUrlKeyEntity contentUrlKey = entity.getContentUrlKey();
    contentUrlKey.setContentUrlId(existing.getId());
    if(existingContentUrlKey == null)
    {
        ret = template.insert(INSERT_SYMMETRIC_KEY, contentUrlKey);
    }
    else if (!EqualsHelper.nullSafeEquals(existingContentUrlKey, contentUrlKey))
    {
        ret = template.update(UPDATE_SYMMETRIC_KEY, contentUrlKey);
    }

    return ret;
}
 

import org.alfresco.repo.domain.contentdata.ContentUrlKeyEntity; //导入依赖的package包/类
@Override
public List<ContentUrlKeyEntity> getSymmetricKeysByMasterKeyAlias(String masterKeyAlias, long fromId, int maxResults)
{
    ContentUrlKeyEntity entity = new ContentUrlKeyEntity();
    entity.setMasterKeyAlias(masterKeyAlias);
    entity.setId(fromId);
    List<ContentUrlKeyEntity> results = template.selectList(SELECT_SYMMETRIC_KEYS_BY_MASTER_KEY, 
            entity, new RowBounds(0, maxResults));
    return results;
}
 

import org.alfresco.repo.domain.contentdata.ContentUrlKeyEntity; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public ContentReader getReader(final String contentUrl)
{
    ContentReader reader;
    final ContentReader backingReader = super.getReader(contentUrl);
    if (backingReader != null && backingReader.exists())
    {
        final String effectiveContentUrl = backingReader.getContentUrl();
        final ContentUrlEntity urlEntity = this.contentDataDAO.getContentUrl(effectiveContentUrl);
        if (urlEntity == null)
        {
            throw new ContentIOException("Missing content URL entity for " + effectiveContentUrl);
        }
        final ContentUrlKeyEntity urlKeyEntity = urlEntity.getContentUrlKey();
        if (urlKeyEntity != null)
        {
            try
            {
                final Key key;
                final EncryptedKey encryptedKey = urlKeyEntity.getEncryptedKey();

                if (!EqualsHelper.nullSafeEquals(this.masterKeyStoreId, encryptedKey.getMasterKeystoreId())
                        || !EqualsHelper.nullSafeEquals(this.masterKeyAlias, encryptedKey.getMasterKeyAlias()))
                {
                    throw new ContentIOException(
                            "Content encryption key was encrypted with a master key from a different master key store / with a different key alias");
                }

                final ByteBuffer ekBuffer = encryptedKey.getByteBuffer();
                try (final ByteBufferByteChannel ekChannel = new ByteBufferByteChannel(ekBuffer))
                {
                    try (final DecryptingReadableByteChannel dkChannel = new DecryptingReadableByteChannel(ekChannel,
                            this.masterPrivateKey))
                    {
                        // due to overhead the key should always have fewer bytes than the encrypted key
                        final ByteBuffer dkBuffer = ByteBuffer.allocate(ekBuffer.capacity());
                        dkChannel.read(dkBuffer);

                        dkBuffer.flip();
                        final byte[] keyBytes = new byte[dkBuffer.remaining()];
                        dkBuffer.get(keyBytes);

                        key = new SecretKeySpec(keyBytes, encryptedKey.getAlgorithm());
                    }
                }

                reader = new DecryptingContentReaderFacade(backingReader, key, urlKeyEntity.getUnencryptedFileSize());
            }
            catch (final DecoderException | IOException e)
            {
                LOGGER.error("Error loading symmetric content encryption key", e);
                throw new ContentIOException("Error loading symmetric content encryption key", e);
            }
        }
        else
        {
            reader = backingReader;
        }
    }
    else
    {
        reader = backingReader;
    }
    return reader;
}