Um fragmento de conteúdo estende um ativo padrão; consulte:
Criação e gerenciamento de fragmentos de conteúdo e criação de página com fragmentos de conteúdo para obter mais informações sobre fragmentos de conteúdo.
Gerenciamento de ativos e personalização e extensão de ativos para obter mais informações sobre os ativos padrão.
As partes constituintes básicas de um fragmento de conteúdo são:
Dependendo do tipo de fragmento, modelos ou modelos também são usados:
Agora, os modelos de fragmento de conteúdo são recomendados para criar todos os fragmentos.
Os modelos de fragmento de conteúdo são usados para todos os exemplos em We.Retail.
Modelos de fragmentos do conteúdo:
Quaisquer alterações em um modelo de fragmento de conteúdo existente podem afetar fragmentos dependentes; isso pode levar a propriedades órfãs nesses fragmentos.
Modelos de fragmento de conteúdo:
O Gerenciamento de fragmentos de conteúdo (CFM) faz parte do AEM Assets como:
Fragmentos de conteúdo com conteúdo estruturado (isto é, com base em um modelo de fragmento de conteúdo) são mapeados para um único ativo:
Todo o conteúdo é armazenado no nó jcr:content/data
do ativo:
Os dados do elemento são armazenados sob o subnó principal:
jcr:content/data/master
As variações são armazenadas em um subnó que contém o nome da variação:
por exemplo, jcr:content/data/myvariation
Os dados de cada elemento são armazenados no respectivo subnó como uma propriedade com o nome do elemento:
Por exemplo, o conteúdo do elemento text
é armazenado como propriedade text
em jcr:content/data/master
Os metadados e o conteúdo associado são armazenados abaixo de jcr:content/metadata
Exceto o título e a descrição, que não são considerados metadados tradicionais e armazenados em
jcr:content
Fragmentos de conteúdo simples (com base em um modelo) são mapeados para um composto que consiste em um ativo principal e subativos (opcionais):
Todas as informações de não conteúdo de um fragmento (como título, descrição, metadados, estrutura) são gerenciadas exclusivamente no ativo principal.
O conteúdo do primeiro elemento de um fragmento é mapeado para a representação original do ativo principal.
Elementos adicionais (se existentes) são mapeados para subativos do ativo principal.
Como ocorre com os ativos padrão, um fragmento de conteúdo é mantido em:
/content/dam
Para obter mais detalhes, consulte Fragmento do conteúdo - Excluir considerações.
O Componente principal do fragmento de conteúdo agora é recomendado. Consulte Desenvolvimento de componentes principais para obter mais detalhes.
Os fragmentos de conteúdo podem ser referenciados AEM páginas, assim como qualquer outro tipo de ativo. AEM fornece o Fragmento de conteúdo componente principal - um componente que permite incluir fragmentos de conteúdo em suas páginas. Você também pode estender, este Fragmento do conteúdo componente principal.
O componente usa a propriedade fragmentPath
para fazer referência ao fragmento de conteúdo real. A propriedade fragmentPath
é manipulada da mesma maneira que as propriedades semelhantes de outros tipos de ativos; por exemplo, quando o fragmento de conteúdo é movido para outro local.
O componente permite selecionar a variação a ser exibida.
Além disso, um intervalo de parágrafos pode ser selecionado para restringir a saída; por exemplo, isso pode ser usado para saída de várias colunas.
O componente permite conteúdo intermediário:
Aqui, o componente permite que você coloque outros ativos (imagens, etc.) entre os parágrafos do fragmento referenciado.
Para conteúdo intermediário, é necessário:
Modelo de fragmentos de conteúdo:
Ao usar um fragmento de conteúdo que tenha sido baseado em um modelo de fragmento de conteúdo em uma página, o modelo é referenciado. Isso significa que, se o modelo não tiver sido publicado no momento em que você publicar a página, ele será sinalizado e o modelo adicionado aos recursos a serem publicados com a página.
Modelo de fragmento de conteúdo:
Ao usar um fragmento de conteúdo que tenha sido baseado em um modelo de fragmento de conteúdo em uma página, não há referência quando o modelo foi copiado ao criar o fragmento.
A implementação de backend de fragmentos de conteúdo é, por exemplo, responsável por tornar as instâncias de um fragmento usadas em uma página pesquisável ou pelo gerenciamento de conteúdo de mídia mista. Essa implementação precisa saber quais componentes são usados para renderizar fragmentos e como a renderização é parametrizada.
Os parâmetros para isso podem ser configurados no Web Console, para o pacote OSGi Configuração do componente de fragmento de conteúdo.
Tipos
de recursosUma lista de
sling:resourceTypes
pode ser fornecido para definir componentes usados para renderizar fragmentos de conteúdo e para os quais o processamento em segundo plano deve ser aplicado.
Propriedades
de referênciaUma lista de propriedades pode ser configurada para especificar onde a referência ao fragmento é armazenada para o respectivo componente.
Não há mapeamento direto entre a propriedade e o tipo de componente.
AEM simplesmente a primeira propriedade que pode ser encontrada em um parágrafo. Então você deve escolher as propriedades cuidadosamente.
Ainda há algumas diretrizes que você deve seguir para garantir que seu componente seja compatível com o processamento em segundo plano do fragmento de conteúdo:
O nome da propriedade em que os elementos a serem renderizados são definidos deve ser element
ou elementNames
.
O nome da propriedade em que a variação a ser renderizada é definida deve ser variation
ou variationName
.
Se a saída de vários elementos for suportada (usando elementNames
para especificar vários elementos), o modo de exibição real será definido pela propriedade displayMode
:
singleText
(e houver apenas um elemento configurado), o elemento será renderizado como um texto com conteúdo intermediário, suporte a layout etc. Esse é o padrão para fragmentos nos quais apenas um único elemento é renderizado.Se o fragmento for renderizado para displayMode
== singleText
(implicitamente ou explicitamente), as seguintes propriedades adicionais serão reproduzidas:
paragraphScope
define se todos os parágrafos, ou apenas um intervalo de parágrafos, devem ser renderizados (valores: all
vs. range
)
se paragraphScope
== range
então a propriedade paragraphRange
define o intervalo de parágrafos a serem renderizados
Os fragmentos de conteúdo podem ser integrados com:
Traduções
Os Fragmentos de conteúdo são totalmente integrados ao AEM fluxo de trabalho de tradução. Em nível arquitetônico, isso significa:
As traduções individuais de um fragmento de conteúdo são, na verdade, fragmentos separados; por exemplo:
estão localizados sob raízes de idiomas diferentes:
/content/dam/<path>/en/<to>/<fragment>
vs.
/content/dam/<path>/de/<to>/<fragment>
mas eles compartilham exatamente o mesmo caminho relativo abaixo da raiz do idioma:
/content/dam/<path>/en/<to>/<fragment>
vs.
/content/dam/<path>/de/<to>/<fragment>
Além dos caminhos baseados em regras, não há mais conexão entre as diferentes versões linguísticas de um fragmento de conteúdo; são manipulados como dois fragmentos separados, embora a interface do usuário forneça os meios de navegação entre as variantes de idioma.
O fluxo de trabalho de tradução AEM funciona com /content
:
Como os modelos de fragmento de conteúdo residem em /conf
, eles não são incluídos nessas traduções. Você pode internacionalizar as strings de interface do usuário.
Os modelos são copiados para criar o fragmento, de modo que isso esteja implícito.
Esquemas de metadados
Os fragmentos de conteúdo (re)usam os schemas de metadados, que podem ser definidos com ativos padrão.
O CFM fornece seu próprio schema específico:
/libs/dam/content/schemaeditors/forms/contentfragment
isso pode ser estendido se necessário.
O respectivo formulário de schema é integrado ao editor de fragmentos.
Você pode usar a API do lado do servidor para acessar seus fragmentos de conteúdo; consulte:
É altamente recomendável usar a API do lado do servidor em vez de acessar diretamente a estrutura de conteúdo.
As três interfaces a seguir podem servir como pontos de entrada:
Modelo de fragmento (FragmentTemplate)
Use FragmentTemplate.createFragment()
para criar um novo fragmento.
Resource templateOrModelRsc = resourceResolver.getResource("...");
FragmentTemplate tpl = templateOrModelRsc.adaptTo(FragmentTemplate.class);
ContentFragment newFragment = tpl.createFragment(parentRsc, "A fragment name", "A fragment description.");
Esta interface representa:
Essas informações podem incluir:
Acessar dados básicos (título, descrição)
Acesse modelos/modelos para os elementos do fragmento:
ElementTemplate
)Acessar modelos para as variações do fragmento:
VariationTemplate
)Obter conteúdo associado inicial
Interfaces que representam informações importantes:
ElementTemplate
VariationTemplate
Fragmento do conteúdo (ContentFragment)
Essa interface permite que você trabalhe com um fragmento de conteúdo de forma abstrata.
É altamente recomendável acessar um fragmento por meio dessa interface. A alteração direta da estrutura de conteúdo deve ser evitada.
A interface fornece os meios para:
Gerenciar dados básicos (por exemplo, obter nome; get/set título/descrição)
Acessar metadados
Elementos de acesso:
Elementos de lista
Obter elementos por nome
Criar novos elementos (consulte Caveats)
Dados do elemento de acesso (consulte ContentElement
)
variações de lista definidas para o fragmento
Criar novas variações globalmente
Gerenciar conteúdo associado:
Acessar o modelo ou modelo do fragmento
As interfaces que representam os principais elementos de um fragmento são:
Elemento de conteúdo (ContentElement)
Obter dados básicos (nome, título, descrição)
Obter/definir conteúdo
Variações de acesso de um elemento:
Atalho para resolver variações (aplicando alguma lógica de fallback adicional e específica da implementação se a variação especificada não estiver disponível para um elemento)
Variação de conteúdo (ContentVariation)
Todas as três interfaces ( ContentFragment
, ContentElement
, ContentVariation
) estendem a interface Versionable
, que adiciona recursos de controle de versão, necessários para fragmentos de conteúdo:
Podem ser adaptados:
ContentFragment
pode ser adaptado para:
Resource
- o recurso Sling subjacente; observe que atualizar o subjacente Resource
diretamente requer a reconstrução do ContentFragment
objeto.
Asset
- a Asset
abstração DAM que representa o fragmento do conteúdo; observe que atualizar o objeto Asset
diretamente requer a reconstrução do ContentFragment
objeto.
ContentElement
pode ser adaptado para:
ElementTemplate
- para aceder às informações estruturais do elemento.FragmentTemplate
pode ser adaptado para:
Resource
- a Resource
determinação do modelo referenciado ou do modelo original que foi copiado;
Resource
não são refletidas automaticamente em FragmentTemplate
.Resource
pode ser adaptado para:
ContentFragment
FragmentTemplate
Note-se que:
A API é implementada para fornecer a funcionalidade suportada pela interface do usuário.
A API inteira foi projetada para e não persistir as alterações automaticamente (a menos que observado de outra forma no JavaDoc da API). Portanto, você sempre terá que confirmar o resolvedor de recursos da respectiva solicitação (ou o resolvedor que você está usando).
Tarefas que podem exigir esforço adicional:
A criação/remoção de novos elementos não atualizará a estrutura de dados de fragmentos simples (com base em um modelo de fragmento).
Criar novas variações de ContentElement
não atualizará a estrutura de dados (mas criá-las globalmente de ContentFragment
).
A remoção de variações existentes não atualizará a estrutura de dados.
Para AEM 6.5, a API do cliente é interna.
Consulte o link a seguir:
filter.xml
O filter.xml
para gerenciamento de fragmentos de conteúdo é configurado de modo que não se sobreponha ao pacote de conteúdo principal dos Ativos.
Uma sessão de edição é iniciada quando o usuário abre um fragmento de conteúdo em uma das páginas do editor. A sessão de edição é concluída quando o usuário sai do editor selecionando Salvar ou Cancelar.
Os requisitos para controle de uma sessão de edição são:
Os processos envolvidos são:
Iniciar uma sessão
Conclusão de uma sessão
O salvamento automático é interrompido.
Ao confirmar:
Após a reversão:
Edição
As ações possíveis são:
Inserir uma página
Verificar se uma sessão de edição já está presente; verificando o respectivo cookie.
Se houver, verifique se a sessão de edição foi iniciada para o fragmento de conteúdo que está sendo editado no momento
Se não houver uma sessão de edição, aguarde pela primeira alteração feita pelo usuário (veja abaixo).
Verifique se o fragmento de conteúdo já está referenciado em uma página e, se estiver, exiba as informações apropriadas.
Alteração de conteúdo
Sair de uma página
Para conseguir isso, você pode adaptar o recurso que representa a API para:
com.adobe.cq.dam.cfm.ContentFragment
Por exemplo:
// first, get the resource
Resource fragmentResource = resourceResolver.getResource("/content/dam/fragments/my-fragment");
// then adapt it
if (fragmentResource != null) {
ContentFragment fragment = fragmentResource.adaptTo(ContentFragment.class);
// the resource is now accessible through the API
}
Para criar um novo fragmento de conteúdo programaticamente, é necessário usar:
com.adobe.cq.dam.cfm.ContentFragmentManager#create
Por exemplo:
Resource templateOrModelRsc = resourceResolver.getResource("...");
FragmentTemplate tpl = templateOrModelRsc.adaptTo(FragmentTemplate.class);
ContentFragment newFragment = tpl.createFragment(parentRsc, "A fragment name", "A fragment description.");
O intervalo de salvamento automático (medido em segundos) pode ser definido usando o gerenciador de configuração (ConfMgr):
Nó: <*conf-root*>/settings/dam/cfm/jcr:content
Nome da Propriedade: autoSaveInterval
Tipo: Long
Padrão: 600
(10 minutos); está definido em /libs/settings/dam/cfm/jcr:content
Se você quiser definir um intervalo de salvamento automático de 5 minutos, é necessário definir a propriedade no nó; por exemplo:
Nó: /conf/global/settings/dam/cfm/jcr:content
Nome da Propriedade: autoSaveInterval
Tipo: Long
Valor: 300
(5 minutos equivale a 300 segundos)
Consulte Modelos de fragmento de conteúdo para obter informações completas.
Para obter mais informações, consulte