SPA Introdução ao AEM - React

Aplicativos de página única (SPAs) podem oferecer experiências interessantes para usuários de sites. Os desenvolvedores desejam criar sites usando estruturas SPA, e os autores desejam editar o conteúdo no AEM para um site criado usando estruturas SPA.

O recurso de criação do SPA oferece uma solução abrangente para oferecer suporte ao SPA no AEM. Este artigo apresenta um aplicativo simplificado para SPA na estrutura do React, explica como ele é montado, permitindo que você comece a usar seu próprio SPA rapidamente.

Introdução

Este artigo resume o funcionamento básico de um SPA simples e o mínimo que você precisa saber para que o seu funcione.

Para obter mais detalhes sobre como o SPA funciona no AEM, consulte os seguintes documentos:

• Introdução e passo a passo do SPA
• Introdução à criação do SPA
• Blueprint do SPA

Este documento abordará a estrutura de um SPA simplificado criado usando a estrutura do React e ilustrará como ele funciona para que você possa aplicar essa compreensão ao seu próprio SPA.

Dependências, configuração e criação

Além da dependência esperada do React, a amostra de SPA pode aproveitar bibliotecas adicionais para tornar a criação do SPA mais eficiente.

Dependências

A variável package.json define os requisitos do pacote SPA geral. As dependências mínimas do AEM para um SPA em funcionamento estão listadas aqui.

  "dependencies": {
    "@adobe/aem-react-editable-components": "~1.0.4",
    "@adobe/aem-spa-component-mapping": "~1.0.5",
    "@adobe/aem-spa-page-model-manager": "~1.0.3"
  }

Como este exemplo se baseia na estrutura do React, há duas dependências específicas do React que são obrigatórias na variável package.json arquivo:

react
 react-dom

A variável aem-clientlib-generator O é aproveitado para tornar a criação de bibliotecas de clientes automática como parte do processo de criação.

"aem-clientlib-generator": "^1.4.1",

Mais detalhes podem ser encontrados no GitHub aqui.

A variável aem-clientlib-generator está configurado no clientlib.config.js arquivo como segue.

module.exports = {
    // default working directory (can be changed per 'cwd' in every asset option)
    context: __dirname,

    // path to the clientlib root folder (output)
    clientLibRoot: "./../content/jcr_root/apps/my-react-app/clientlibs",

    libs: {
        name: "my-react-app",
        allowProxy: true,
        categories: ["my-react-app"],
        embed: ["my-react-app.responsivegrid"],
        jsProcessor: ["min:gcc"],
        serializationFormat: "xml",
        assets: {
            js: [
                "dist/**/*.js"
            ],
            css: [
                "dist/**/*.css"
            ]
        }
    }
};

Criando

Criar o aplicativo realmente aproveita Webpack para tradução, além do aem-clientlib-generator para criação automática da biblioteca do cliente. Portanto, o comando build será semelhante a:

"build": "webpack && clientlib --verbose"

Depois de criado, o pacote pode ser carregado para uma instância AEM.

Arquétipo de projeto do AEM

Qualquer projeto do AEM deve utilizar o Arquétipo de projeto do AEM, que aceita projetos SPA que usam o React ou Angular e utiliza o SDK do SPA.

Estrutura do aplicativo

Incluir as dependências e criar seu aplicativo conforme descrito anteriormente deixará você com um pacote de SPA que funciona e que você pode carregar para sua instância do AEM.

A próxima seção deste documento abordará como um SPA no AEM é estruturado, os arquivos importantes que orientam o aplicativo e como eles funcionam juntos.

Um componente de imagem simplificado é usado como exemplo, mas todos os componentes do aplicativo se baseiam no mesmo conceito.

index.js

O ponto de entrada no SPA é, naturalmente, o index.js O arquivo mostrado aqui foi simplificado para se concentrar no conteúdo importante.

import ReactDOM from 'react-dom';
import App from './App';
import { ModelManager, Constants } from "@adobe/aem-spa-page-model-manager";

...

ModelManager.initialize().then((pageModel) => {
ReactDOM.render(
    <App cqChildren={pageModel[Constants.CHILDREN_PROP]} cqItems={pageModel[Constants.ITEMS_PROP]} cqItemsOrder={pageModel[Constants.ITEMS_ORDER_PROP]} cqPath={ModelManager.rootPath} locationPathname={ window.location.pathname }/>
, document.getElementById('page'));

});

A principal função do index.js é utilizar o ReactDOM.render para determinar onde inserir o aplicativo no DOM.

Este é um uso padrão dessa função, não exclusivo deste aplicativo de exemplo.

Instanciação estática

Quando o componente é instanciado estaticamente usando o template do componente (por exemplo, JSX), o valor deve ser passado do modelo para as propriedades do componente.

App.js

Ao renderizar o aplicativo, index.js chamadas App.js, que é mostrado aqui em uma versão simplificada para se concentrar no conteúdo importante.

import {Page, withModel } from '@adobe/aem-react-editable-components';

...

class App extends Page {
...
}

export default withModel(App);

App.js O serve principalmente para envolver os componentes raiz que compõem o aplicativo. O ponto de entrada de qualquer aplicativo é a página.

Page.js

Ao renderizar a página, App.js chamadas Page.js listado aqui em uma versão simplificada.

import {Page, MapTo, withComponentMappingContext } from "@adobe/aem-react-editable-components";

...

class AppPage extends Page {
...
}

MapTo('my-react-app/components/structure/page')(withComponentMappingContext(AppPage));

Neste exemplo, a variável AppPage class extends Page, que contém os métodos de conteúdo interno que podem ser usados.

A variável Page A assimila a representação JSON do modelo de página e processa o conteúdo para envolver/decorar cada elemento da página. Mais detalhes sobre o Page pode ser encontrado no documento Blueprint SPA.

Image.js

Com a página renderizada, os componentes como Image.js conforme mostrado aqui pode ser renderizado.

import React, {Component} from 'react';
import {MapTo} from '@adobe/aem-react-editable-components';

require('./Image.css');

const ImageEditConfig = {

    emptyLabel: 'Image',

    isEmpty: function() {
        return !this.props || !this.props.src || this.props.src.trim().length < 1;
    }
};

class Image extends Component {

    render() {
        return (<img src={this.props.src}>);
    }
}

MapTo('my-react-app/components/content/image')(Image, ImageEditConfig);

A ideia central do AEM é a ideia de mapear componentes do SPA AEM para componentes do SPA e atualizar o componente quando o conteúdo é modificado (e vice-versa). Consulte o documento Visão geral do editor de SPA para obter um resumo deste modelo de comunicação.

MapTo('my-react-app/components/content/image')(Image, ImageEditConfig);

A variável MapTo O método mapeia o componente SPA para o componente AEM. Ele suporta o uso de uma única string ou uma matriz de strings.

ImageEditConfig é um objeto de configuração que contribui para habilitar os recursos de criação de um componente, fornecendo os metadados necessários para o editor gerar espaços reservados

Se não houver conteúdo, os rótulos serão fornecidos como espaços reservados para representar o conteúdo vazio.

Propriedades passadas dinamicamente

Os dados provenientes do modelo são transmitidos dinamicamente como propriedades do componente.

Exportar conteúdo editável

É possível exportar um componente e mantê-lo editável.

import React, { Component } from 'react';
import { MapTo } from '@adobe/aem-react-editable-components';

...

const EditConfig = {...}

class PageClass extends Component {...};

...

export default MapTo('my-react-app/react/components/structure/page')(PageClass, EditConfig);

A variável MapTo função retorna um valor Component que é o resultado de uma composição que estende o PageClass com os nomes e atributos de classe que permitem a criação. Esse componente pode ser exportado para ser instanciado posteriormente na marcação do aplicativo.

Quando exportado usando o MapTo ou withModel funções, a variável Page componente, é envolvido com um ModelProvider componente que fornece aos componentes padrão acesso à versão mais recente do modelo de página ou a um local preciso nesse modelo de página.

Para obter mais informações, consulte a Documento do blueprint do SPA.

Compartilhamento de informações entre componentes do SPA

É regularmente necessário que os componentes de um aplicativo de página única compartilhem informações. Há várias maneiras recomendadas de fazer isso, listadas a seguir em uma ordem crescente de complexidade.

• Opção 1: Centralize a lógica e a transmissão para os componentes necessários, por exemplo, usando o Contexto do React.
• Opção 2: Compartilhe estados do componente usando uma biblioteca de estado, como Redux.
• Opção 3: Aproveite a hierarquia de objetos personalizando e estendendo o componente de contêiner.

Próximas etapas

Para obter um guia passo a passo sobre como criar seu próprio SPA, consulte o Introdução ao editor SPA AEM - Tutorial de eventos do WKND.

Para obter mais informações sobre como se organizar para desenvolver SPA para AEM, consulte o artigo Desenvolvimento de AEM para SPA.

SPA Para mais detalhes sobre o modelo dinâmico para mapeamento de componentes e como ele funciona dentro do AEM, consulte o artigo Modelo dinâmico para mapeamento de componentes para SPA.

Se você quiser implementar o SPA no AEM para uma estrutura diferente do React ou do Angular SPA AEM ou simplesmente quiser se aprofundar em como o SDK do para o funciona, consulte o Blueprint SPA artigo.

Recursos do Business.Adobe.com