AEM 6.4 heeft het einde van de uitgebreide ondersteuning bereikt en deze documentatie wordt niet meer bijgewerkt. Raadpleeg voor meer informatie onze technische ondersteuningsperioden. Ondersteunde versies zoeken hier.
Voor bepaalde functies voor inhoudsfragmenten moet de toepassing van AEM 6.4 Service Pack 2 (6.4.2.0).
Een inhoudsfragment breidt een standaardelement uit; zie:
Inhoudsfragmenten maken en beheren en Pagina's ontwerpen met inhoudsfragmenten voor meer informatie over inhoudsfragmenten.
Elementen beheren en Elementen aanpassen en uitbreiden voor meer informatie over standaardactiva.
De basis samenstellende delen van een inhoudsfragment zijn:
Afhankelijk van het type fragment worden ook modellen of sjablonen gebruikt:
Inhoudsfragmentmodellen worden nu aanbevolen voor het maken van al uw fragmenten.
De fragmentmodellen van de inhoud worden gebruikt voor alle voorbeelden in Wij.Retail.
Modellen van contentfragmenten:
Wijzigingen in een bestaand inhoudsfragmentmodel kunnen van invloed zijn op afhankelijke fragmenten. dit kan leiden tot weeseigenschappen in die fragmenten .
Sjablonen voor inhoudsfragmenten:
CFM (Content Fragment Management) maakt deel uit van AEM Assets als:
Inhoudsfragmenten met gestructureerde inhoud (d.w.z. gebaseerd op een inhoudsfragmentmodel) worden toegewezen aan één element:
Alle inhoud wordt opgeslagen onder de jcr:content/data
knooppunt van het element:
De elementgegevens worden opgeslagen onder het master subknooppunt:
jcr:content/data/master
Variaties worden opgeslagen onder een subknooppunt met de naam van de variatie:
bijv. jcr:content/data/myvariation
De gegevens van elk element worden in het desbetreffende subknooppunt opgeslagen als een eigenschap met de elementnaam:
bv. de inhoud van het element text
is opgeslagen als eigenschap text
op jcr:content/data/master
Metagegevens en bijbehorende inhoud worden hieronder opgeslagen jcr:content/metadata
Met uitzondering van de titel en de beschrijving, die niet als traditionele metagegevens worden beschouwd en op jcr:content
Eenvoudige inhoudsfragmenten (gebaseerd op een sjabloon) worden toegewezen aan een samenstelling die bestaat uit een hoofdelement en (optionele) subelementen:
Alle niet-inhoudinformatie van een fragment (zoals titel, beschrijving, metagegevens, structuur) wordt uitsluitend beheerd op het hoofdelement.
De inhoud van het eerste element van een fragment wordt toegewezen aan de oorspronkelijke uitvoering van het hoofdelement.
Aanvullende elementen (indien aanwezig) worden toegewezen aan subactiva van het hoofdactief.
Net als bij standaardelementen wordt een inhoudsfragment opgeslagen onder:
/content/dam
Zie voor meer informatie Inhoudsfragment - Overwegingen verwijderen.
De Component Content Fragment Core wordt nu aanbevolen. Zie Basiscomponenten ontwikkelen voor meer informatie .
Vanuit AEM pagina's kan naar inhoudsfragmenten worden verwezen, net als met elk ander elementtype. AEM biedt de Inhoudsfragment kerncomponent - component waarmee u inhoudsfragmenten op uw pagina's kunt opnemen. U kunt ook het volgende uitbreiden: Inhoudsfragment kerncomponent.
De component gebruikt de fragmentPath
eigenschap om naar het daadwerkelijke inhoudsfragment te verwijzen. De fragmentPath
vastgoed wordt op dezelfde wijze afgehandeld als soortgelijke eigenschappen van andere soorten activa; bijvoorbeeld wanneer het inhoudsfragment naar een andere locatie wordt verplaatst.
Met de component kunt u de variatie selecteren die moet worden weergegeven.
Bovendien kan een reeks alinea's worden geselecteerd om de uitvoer te beperken; Dit kan bijvoorbeeld worden gebruikt voor uitvoer met meerdere kolommen.
De component staat tussenliggende inhoud:
Voor tussenliggende inhoud moet u:
Inhoudsfragmentmodel:
Wanneer u een inhoudsfragment gebruikt dat is gebaseerd op een inhoudsfragmentmodel op een pagina, wordt naar het model verwezen. Dit betekent dat als het model niet is gepubliceerd op het moment dat u de pagina publiceert, dit wordt gemarkeerd en het model wordt toegevoegd aan de bronnen die met de pagina moeten worden gepubliceerd.
Sjabloon inhoudsfragment:
Wanneer u een inhoudsfragment gebruikt dat is gebaseerd op een inhoudsfragmentsjabloon op een pagina, is er geen verwijzing omdat de sjabloon is gekopieerd bij het maken van het fragment.
De back-endimplementatie van inhoudsfragmenten is bijvoorbeeld verantwoordelijk voor het maken van instanties van een fragment dat wordt gebruikt op een pagina die kan worden doorzocht, of voor het beheren van gemengde media-inhoud. Deze implementatie moet weten welke componenten worden gebruikt voor het renderen van fragmenten en hoe de rendering wordt geparametriseerd.
De parameters voor dit kunnen in worden gevormd Webconsole, voor de OSGi-bundel Configuratie van DAM-inhoudsfragmenten.
Brontypen
Een lijst van sling:resourceTypes
kan worden opgegeven om componenten te definiëren die worden gebruikt voor het renderen van inhoudsfragmenten en waar de achtergrondverwerking moet worden toegepast.
Referentie-eigenschappen
Een lijst met eigenschappen kan worden geconfigureerd om op te geven waar de verwijzing naar het fragment wordt opgeslagen voor de desbetreffende component.
Er is geen directe toewijzing tussen eigenschap en componenttype.
AEM gebruikt gewoon de eerste eigenschap die op een alinea staat. U moet de eigenschappen dus zorgvuldig kiezen.
Er zijn nog enkele richtlijnen die u moet volgen om ervoor te zorgen dat de component compatibel is met de achtergrondverwerking van het inhoudsfragment:
De naam van de eigenschap waarin het element of de elementen worden weergegeven, moet ofwel element
of elementNames
.
De naam van de eigenschap waarin de uit te voeren wijziging is gedefinieerd, moet ofwel variation
of variationName
.
Als de uitvoer van meerdere elementen wordt ondersteund (door elementNames
om meerdere elementen op te geven), wordt de werkelijke weergavemodus gedefinieerd door de eigenschap displayMode
:
singleText
(en er is slechts één geconfigureerd) wordt het element weergegeven als een tekst met tussenliggende inhoud, ondersteuning voor de layout, enz. Dit is de standaardinstelling voor fragmenten waarbij slechts één element wordt gerenderd.Als het fragment wordt gerenderd voor displayMode
== singleText
(impliciet of expliciet) worden de volgende aanvullende eigenschappen toegepast:
paragraphScope
definieert of alle alinea's, of alleen een reeks alinea's, moeten worden gerenderd (waarden: all
vs range
)paragraphScope
== range
dan de eigenschap paragraphRange
definieert het bereik van alinea's dat moet worden gerenderdInhoudsfragmenten kunnen worden geïntegreerd met:
Vertalingen
Inhoudsfragmenten zijn volledig geïntegreerd met de AEM vertaalworkflow. Op architectonisch niveau betekent dit:
De afzonderlijke vertalingen van een inhoudsfragment zijn eigenlijk afzonderlijke fragmenten. bijvoorbeeld:
zij bevinden zich in verschillende taalgebieden :
/content/dam/<path>/en/<to>/<fragment>
vs
/content/dam/<path>/de/<to>/<fragment>
maar ze delen exact hetzelfde relatieve pad onder de hoofdmap van de taal :
/content/dam/<path>/en/<to>/<fragment>
vs
/content/dam/<path>/de/<to>/<fragment>
Naast de op regel gebaseerde paden bestaat er geen verdere verbinding tussen de verschillende taalversies van een inhoudsfragment. ze worden behandeld als twee afzonderlijke fragmenten, hoewel de interface de mogelijkheid biedt om tussen de taalvarianten te navigeren.
De AEM vertaalworkflow werkt met /content
:
/conf
, worden deze niet in dergelijke vertalingen opgenomen. U kunt UI-tekenreeksen internationaliseren.Metagegevensschema's
CFM biedt een eigen, specifiek schema:
/libs/dam/content/schemaeditors/forms/contentfragment
dit kan zo nodig worden verlengd .
Het respectievelijke schema-formulier is geïntegreerd met de fragmenteditor.
U kunt de server-kant API gebruiken om tot uw inhoudsfragmenten toegang te hebben; zie:
com.adobe.cq.dam.cfm
Het wordt ten zeerste aanbevolen de server-side API te gebruiken in plaats van rechtstreeks toegang te krijgen tot de inhoudsstructuur.
De volgende drie interfaces kunnen als ingangspunten dienen:
Fragmentsjabloon
FragmentTemplate
Gebruiken FragmentTemplate.createFragment()
voor het maken van een nieuw fragment.
Resource templateOrModelRsc = resourceResolver.getResource("...");
FragmentTemplate tpl = templateOrModelRsc.adaptTo(FragmentTemplate.class);
ContentFragment newFragment = tpl.createFragment(parentRsc, "A fragment name", "A fragment description.");
Deze interface vertegenwoordigt:
Deze informatie kan omvatten:
Toegang tot basisgegevens (titel, beschrijving)
Sjablonen/modellen openen voor de elementen van het fragment:
ElementTemplate
)Sjablonen openen voor de variaties van het fragment:
VariationTemplate
)Aanvankelijke gekoppelde inhoud ophalen
Interfaces die belangrijke informatie vertegenwoordigen:
ElementTemplate
VariationTemplate
Inhoudsfragment
ContentFragment
Met deze interface kunt u op abstracte wijze werken met een inhoudsfragment.
Het wordt sterk geadviseerd om tot een fragment door deze interface toegang te hebben. Het rechtstreeks wijzigen van de inhoudsstructuur moet worden vermeden.
De interface voorziet u van de middelen:
Basisgegevens beheren (bijvoorbeeld naam ophalen; get/set titel/beschrijving)
Toegang tot metagegevens
Toegangselementen:
ContentElement
)Variaties weergeven die zijn gedefinieerd voor het fragment
Nieuwe variaties wereldwijd maken
Gekoppelde inhoud beheren:
Open het model of de sjabloon van het fragment
De interfaces die de belangrijkste elementen van een fragment vertegenwoordigen zijn:
Inhoud-element
ContentElement
Basisgegevens ophalen (naam, titel, beschrijving)
Inhoud ophalen/instellen
Toegang tot variaties van een element:
Sneltoets voor het oplossen van variaties (door een aanvullende, implementatiespecifieke fallback-logica toe te passen als de opgegeven variatie niet beschikbaar is voor een element)
Inhoudsvariatie
ContentVariation
Alle drie de interfaces ( ContentFragment
, ContentElement
, ContentVariation
) de Versionable
interface, die versiemogelijkheden toevoegt, vereist voor inhoudsfragmenten:
Het volgende kan worden aangepast:
ContentFragment
kan worden aangepast aan:
Resource
- de onderliggende sloopbron; nemen er nota van dat het bijwerken van de onderliggende Resource
rechtstreeks, moet u de ContentFragment
object.Asset
- de DAM Asset
abstractie die het inhoudsfragment vertegenwoordigt; de Asset
rechtstreeks, moet u de ContentFragment
object.ContentElement
kan worden aangepast aan:
ElementTemplate
- voor toegang tot de structurele informatie van het element.FragmentTemplate
kan worden aangepast aan:
Resource
- de Resource
het bepalen van het model waarnaar wordt verwezen of de oorspronkelijke sjabloon die is gekopieerd;
Resource
worden niet automatisch weerspiegeld in de FragmentTemplate
.Resource
kan worden aangepast aan:
ContentFragment
FragmentTemplate
Er zij op gewezen dat:
De API is geïmplementeerd om functionaliteit te bieden die door de UI wordt ondersteund.
De gehele API is ontworpen voor niet Wijzigingen automatisch aanhouden (tenzij anders vermeld in de API JavaDoc). Zo zult u altijd de middeloplosser van het respectieve verzoek (of resolver moeten begaan u eigenlijk gebruikt).
Taken die extra inspanning zouden kunnen vereisen:
ContentElement
werkt de gegevensstructuur niet bij (maar maakt deze globaal op basis van ContentFragment
zal).Voor AEM 6.4 is de client-side API intern.
Zie het volgende:
filter.xml
De filter.xml
voor inhoudsfragmentbeheer is zo geconfigureerd dat dit niet overlapt met het elementeninhoudspakket.
Er wordt een bewerkingssessie gestart wanneer de gebruiker een inhoudsfragment opent in een van de editorpagina's. De bewerkingssessie is voltooid wanneer de gebruiker de editor verlaat door een van de volgende opties te selecteren Opslaan of Annuleren.
Vereisten voor het besturen van een bewerkingssessie zijn:
Het gaat om de volgende processen:
Een sessie starten
Een sessie voltooien
Automatisch opslaan wordt gestopt.
Bij toewijzen:
Bij terugdraaien:
Bewerken
De mogelijke acties zijn:
Pagina's invoeren
Controleren of er al een bewerksessie aanwezig is; door de betreffende cookie te controleren.
Als er een bestaat, controleert u of de bewerkingssessie is gestart voor het inhoudsfragment dat momenteel wordt bewerkt
Als er geen bewerkingssessie bestaat, wacht u op de eerste wijziging die de gebruiker heeft aangebracht (zie hieronder).
Controleer of er al naar het inhoudsfragment wordt verwezen op een pagina en geef zo ja de juiste informatie weer.
Inhoud wijzigen
Pagina's verlaten
Hiertoe kunt u de bron die de API vertegenwoordigt aanpassen aan:
com.adobe.cq.dam.cfm.ContentFragment
Bijvoorbeeld:
// 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
}
Als u programmatisch een nieuw inhoudsfragment wilt maken, moet u het volgende gebruiken:
com.adobe.cq.dam.cfm.ContentFragmentManager#create
Bijvoorbeeld:
Resource templateOrModelRsc = resourceResolver.getResource("...");
FragmentTemplate tpl = templateOrModelRsc.adaptTo(FragmentTemplate.class);
ContentFragment newFragment = tpl.createFragment(parentRsc, "A fragment name", "A fragment description.");
Het interval voor automatisch opslaan (gemeten in seconden) kan worden gedefinieerd met behulp van configuratiebeheer (ConfMgr):
Knooppunt: <conf-root>/settings/dam/cfm/jcr:content
Naam eigenschap: autoSaveInterval
Type: Long
Standaard: 600
(10 minuten); dit is gedefinieerd op /libs/settings/dam/cfm/jcr:content
Als u een auto sparen interval van 5 minuten wilt plaatsen moet u het bezit op uw knoop bepalen; bijvoorbeeld:
Knooppunt: /conf/global/settings/dam/cfm/jcr:content
Naam eigenschap: autoSaveInterval
Type: Long
Waarde: 300
(5 minuten komt overeen met 300 seconden)
Zie Sjablonen voor inhoudsfragmenten voor volledige informatie.
Zie voor meer informatie