{"id":4832,"date":"2023-06-01T18:50:43","date_gmt":"2023-06-01T21:50:43","guid":{"rendered":"https:\/\/elemarjr.com\/clube-de-estudos\/?p=4832"},"modified":"2023-10-21T21:36:28","modified_gmt":"2023-10-22T00:36:28","slug":"bridge-adapter-e-proxy-tres-padroes-essenciais-para-o-design-de-sistemas-flexiveis","status":"publish","type":"artigos","link":"https:\/\/elemarjr.com\/clube-de-estudos\/artigos\/bridge-adapter-e-proxy-tres-padroes-essenciais-para-o-design-de-sistemas-flexiveis\/","title":{"rendered":"Bridge, Adapter e Proxy: Tr\u00eas padr\u00f5es essenciais para o design de sistemas flex\u00edveis"},"content":{"rendered":"\n

Padr\u00e3o Bridge<\/em><\/h2>\n\n\n\n

O que \u00e9 o padr\u00e3o Bridge<\/em>?<\/h3>\n\n\n\n

O padr\u00e3o Bridge<\/em> \u00e9 um padr\u00e3o de design estrutural que tem a inten\u00e7\u00e3o de “desacoplar uma abstra\u00e7\u00e3o de sua implementa\u00e7\u00e3o, de modo que as duas possam variar independentemente”. Parece complexo? Vamos simplificar: imagine que voc\u00ea tem um controle remoto de TV. A forma como o controle funciona \u00e9 a abstra\u00e7\u00e3o, e a marca ou modelo do controle \u00e9 a implementa\u00e7\u00e3o. Com o padr\u00e3o Bridge<\/em>, voc\u00ea pode alterar a forma como o controle funciona ou mudar a marca ou modelo sem que um interfira no outro.<\/p>\n\n\n\n

Quando usar o padr\u00e3o Bridge<\/em>?<\/h3>\n\n\n\n

Recomendo a utiliza\u00e7\u00e3o do padr\u00e3o Bridge <\/em>quando voc\u00ea quer evitar um v\u00ednculo permanente entre a abstra\u00e7\u00e3o e a implementa\u00e7\u00e3o. Isso pode ser \u00fatil quando a implementa\u00e7\u00e3o deve ser selecionada ou alterada em tempo de execu\u00e7\u00e3o.<\/p>\n\n\n\n

C#<\/span><\/path><\/path><\/svg><\/span>
using<\/span> System<\/span>;<\/span><\/span>\n<\/span>\n\/\/ Abstra\u00e7\u00e3o<\/span><\/span>\nabstract<\/span> <\/span>class<\/span> <\/span>Abstraction<\/span><\/span>\n{<\/span><\/span>\n    <\/span>protected<\/span> Implementor implementor<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>Abstraction<\/span>(<\/span>Implementor implementor<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>this<\/span>.<\/span>implementor<\/span> <\/span>=<\/span> <\/span>implementor<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>abstract<\/span> <\/span>void<\/span> <\/span>Operation<\/span>()<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Implementa\u00e7\u00e3o<\/span><\/span>\ninterface<\/span> Implementor<\/span><\/span>\n{<\/span><\/span>\n    <\/span>void<\/span> <\/span>OperationImp<\/span>()<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Implementa\u00e7\u00e3o Concreta A<\/span><\/span>\nclass<\/span> <\/span>ConcreteImplementorA<\/span> <\/span>:<\/span> Implementor<\/span><\/span>\n{<\/span><\/span>\n    <\/span>public<\/span> <\/span>void<\/span> <\/span>OperationImp<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>"<\/span>Implementa\u00e7\u00e3o A sendo executada.<\/span>"<\/span>)<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Implementa\u00e7\u00e3o Concreta B<\/span><\/span>\nclass<\/span> <\/span>ConcreteImplementorB<\/span> <\/span>:<\/span> Implementor<\/span><\/span>\n{<\/span><\/span>\n    <\/span>public<\/span> <\/span>void<\/span> <\/span>OperationImp<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>"<\/span>Implementa\u00e7\u00e3o B sendo executada.<\/span>"<\/span>)<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Abstra\u00e7\u00e3o Refinada<\/span><\/span>\nclass<\/span> <\/span>RefinedAbstraction<\/span> <\/span>:<\/span> Abstraction<\/span><\/span>\n{<\/span><\/span>\n    <\/span>public<\/span> <\/span>RefinedAbstraction<\/span>(<\/span>Implementor implementor<\/span>)<\/span> <\/span>:<\/span> <\/span>base<\/span>(<\/span>implementor<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>override<\/span> <\/span>void<\/span> <\/span>Operation<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>"<\/span>Abstra\u00e7\u00e3o sendo executada.<\/span>"<\/span>)<\/span>;<\/span><\/span>\n        <\/span>implementor<\/span>.<\/span>OperationImp<\/span>()<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Program<\/span><\/span>\n{<\/span><\/span>\n    <\/span>static<\/span> <\/span>void<\/span> <\/span>Main<\/span>(<\/span>string<\/span>[]<\/span> args<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>\/\/ Cria as implementa\u00e7\u00f5es concretas<\/span><\/span>\n        Implementor implementorA <\/span>=<\/span> <\/span>new<\/span> ConcreteImplementorA<\/span>()<\/span>;<\/span><\/span>\n        Implementor implementorB <\/span>=<\/span> <\/span>new<\/span> ConcreteImplementorB<\/span>()<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>\/\/ Cria a abstra\u00e7\u00e3o refinada associada com a implementa\u00e7\u00e3o A<\/span><\/span>\n        Abstraction abstraction <\/span>=<\/span> <\/span>new<\/span> RefinedAbstraction<\/span>(<\/span>implementorA<\/span>)<\/span>;<\/span><\/span>\n        <\/span>abstraction<\/span>.<\/span>Operation<\/span>()<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>()<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>\/\/ Altera a implementa\u00e7\u00e3o associada \u00e0 abstra\u00e7\u00e3o para a implementa\u00e7\u00e3o B<\/span><\/span>\n        <\/span>abstraction<\/span>.<\/span>implementor<\/span> <\/span>=<\/span> <\/span>implementorB<\/span>;<\/span><\/span>\n        <\/span>abstraction<\/span>.<\/span>Operation<\/span>()<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>Console<\/span>.<\/span>ReadLine<\/span>()<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: ChatGPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Neste exemplo, temos a abstra\u00e7\u00e3o Abstraction<\/code> que possui uma refer\u00eancia para a interface Implementor<\/code>. As classes ConcreteImplementorA<\/code> e ConcreteImplementorB<\/code> s\u00e3o as implementa\u00e7\u00f5es concretas da interface Implementor<\/code>. A classe RefinedAbstraction<\/code> \u00e9 uma abstra\u00e7\u00e3o refinada que estende a classe Abstraction<\/code>. O programa principal cria as implementa\u00e7\u00f5es concretas, associa a abstra\u00e7\u00e3o refinada com a implementa\u00e7\u00e3o A, executa a opera\u00e7\u00e3o e, em seguida, altera a implementa\u00e7\u00e3o para B e executa novamente a opera\u00e7\u00e3o.<\/p>\n\n\n\n
Padr\u00e3o Adapter<\/em><\/h2>\n\n\n\n
O que \u00e9 o padr\u00e3o Adapter<\/em>?<\/h3>\n\n\n\n
Agora vamos falar sobre o padr\u00e3o Adapter<\/em>. Ele \u00e9 um padr\u00e3o de design estrutural que permite que duas interfaces incompat\u00edveis trabalhem juntas. \u00c9 como um tradutor entre dois idiomas incompat\u00edveis. Em outras palavras, o padr\u00e3o Adapter<\/em> cria uma ponte entre duas interfaces que de outra forma n\u00e3o poderiam trabalhar juntas devido a suas interfaces incompat\u00edveis.<\/p>\n\n\n\n
Quando usar o padr\u00e3o Adapter<\/em>?<\/h3>\n\n\n\n
Voc\u00ea deve considerar o uso do padr\u00e3o Adapter <\/em>quando quiser usar uma classe existente que seja incompat\u00edvel com o restante do seu c\u00f3digo. Ou quando quiser criar uma classe reutiliz\u00e1vel que coopere com classes n\u00e3o relacionadas ou n\u00e3o previstas.<\/p>\n\n\n\n
C#<\/span><\/path><\/path><\/svg><\/span>
using<\/span> System<\/span>;<\/span><\/span>\n<\/span>\n\/\/ Interface existente<\/span><\/span>\ninterface<\/span> ITarget<\/span><\/span>\n{<\/span><\/span>\n    <\/span>void<\/span> <\/span>Request<\/span>()<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Classe existente<\/span><\/span>\nclass<\/span> <\/span>Adaptee<\/span><\/span>\n{<\/span><\/span>\n    <\/span>public<\/span> <\/span>void<\/span> <\/span>SpecificRequest<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>"<\/span>M\u00e9todo SpecificRequest da classe Adaptee sendo chamado.<\/span>"<\/span>)<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Adapter<\/span><\/span>\nclass<\/span> <\/span>Adapter<\/span> <\/span>:<\/span> ITarget<\/span><\/span>\n{<\/span><\/span>\n    <\/span>private<\/span> Adaptee adaptee<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>Adapter<\/span>(<\/span>Adaptee adaptee<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>this<\/span>.<\/span>adaptee<\/span> <\/span>=<\/span> <\/span>adaptee<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>void<\/span> <\/span>Request<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>"<\/span>Adapter chamando o m\u00e9todo SpecificRequest da classe Adaptee.<\/span>"<\/span>)<\/span>;<\/span><\/span>\n        <\/span>adaptee<\/span>.<\/span>SpecificRequest<\/span>()<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Program<\/span><\/span>\n{<\/span><\/span>\n    <\/span>static<\/span> <\/span>void<\/span> <\/span>Main<\/span>(<\/span>string<\/span>[]<\/span> args<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>\/\/ Cria a inst\u00e2ncia da classe Adaptee<\/span><\/span>\n        Adaptee adaptee <\/span>=<\/span> <\/span>new<\/span> Adaptee<\/span>()<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>\/\/ Cria o Adapter e passa a inst\u00e2ncia do Adaptee<\/span><\/span>\n        ITarget target <\/span>=<\/span> <\/span>new<\/span> Adapter<\/span>(<\/span>adaptee<\/span>)<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>\/\/ Chama o m\u00e9todo Request do Adapter<\/span><\/span>\n        <\/span>target<\/span>.<\/span>Request<\/span>()<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>Console<\/span>.<\/span>ReadLine<\/span>()<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: ChatGPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Neste exemplo, temos a interface ITarget<\/code> que define a interface esperada pelo cliente. A classe Adaptee<\/code> \u00e9 a classe existente que possui uma interface incompat\u00edvel com ITarget<\/code>. A classe Adapter<\/code> implementa a interface ITarget<\/code> e atua como um adaptador entre o cliente e a classe Adaptee<\/code>. No programa principal, criamos uma inst\u00e2ncia de Adaptee<\/code>, criamos um Adapter<\/code> passando a inst\u00e2ncia do Adaptee<\/code> e chamamos o m\u00e9todo Request<\/code> do Adapter<\/code>, que internamente chama o m\u00e9todo SpecificRequest<\/code> da classe Adaptee<\/code>.<\/p>\n\n\n\n
Padr\u00e3o Proxy<\/em><\/h2>\n\n\n\n
O que \u00e9 o padr\u00e3o Proxy<\/em>?<\/h3>\n\n\n\n
Chegamos agora ao padr\u00e3o Proxy<\/em>. Esse padr\u00e3o de design estrutural fornece um substituto ou espa\u00e7o reservado para outro objeto para controlar o acesso a ele. \u00c9 como um intermedi\u00e1rio que pode adicionar funcionalidades extras ao objeto sem mudar sua interface.<\/p>\n\n\n\n
Quando usar o padr\u00e3o Proxy<\/em>?<\/h3>\n\n\n\n
O padr\u00e3o Proxy <\/em>\u00e9 \u00fatil quando voc\u00ea precisa controlar o acesso a um objeto, seja para adicionar uma camada de seguran\u00e7a, otimizar o desempenho, entre outros.<\/p>\n\n\n\n
C#<\/span><\/path><\/path><\/svg><\/span>
using<\/span> System<\/span>;<\/span><\/span>\n<\/span>\n\/\/ Interface do objeto real e do proxy<\/span><\/span>\ninterface<\/span> ISubject<\/span><\/span>\n{<\/span><\/span>\n    <\/span>void<\/span> <\/span>Request<\/span>()<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Objeto real<\/span><\/span>\nclass<\/span> <\/span>RealSubject<\/span> <\/span>:<\/span> ISubject<\/span><\/span>\n{<\/span><\/span>\n    <\/span>public<\/span> <\/span>void<\/span> <\/span>Request<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>"<\/span>RealSubject: Processando a requisi\u00e7\u00e3o.<\/span>"<\/span>)<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Proxy<\/span><\/span>\nclass<\/span> <\/span>Proxy<\/span> <\/span>:<\/span> ISubject<\/span><\/span>\n{<\/span><\/span>\n    <\/span>private<\/span> RealSubject realSubject<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>void<\/span> <\/span>Request<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>\/\/ Cria o objeto real sob demanda<\/span><\/span>\n        <\/span>if<\/span> <\/span>(<\/span>realSubject<\/span> <\/span>==<\/span> <\/span>null<\/span>)<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>"<\/span>Proxy: Criando uma inst\u00e2ncia do RealSubject.<\/span>"<\/span>)<\/span>;<\/span><\/span>\n            <\/span>realSubject<\/span> <\/span>=<\/span> <\/span>new<\/span> RealSubject<\/span>()<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n<\/span>\n        <\/span>\/\/ Executa a requisi\u00e7\u00e3o atrav\u00e9s do objeto real<\/span><\/span>\n        <\/span>realSubject<\/span>.<\/span>Request<\/span>()<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Program<\/span><\/span>\n{<\/span><\/span>\n    <\/span>static<\/span> <\/span>void<\/span> <\/span>Main<\/span>(<\/span>string<\/span>[]<\/span> args<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>\/\/ Cria o proxy<\/span><\/span>\n        ISubject proxy <\/span>=<\/span> <\/span>new<\/span> Proxy<\/span>()<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>\/\/ Chama o m\u00e9todo Request do proxy<\/span><\/span>\n        <\/span>proxy<\/span>.<\/span>Request<\/span>()<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>Console<\/span>.<\/span>ReadLine<\/span>()<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: ChatGPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Neste exemplo, temos a interface ISubject<\/code> que define a interface tanto para o objeto real (RealSubject<\/code>) quanto para o proxy (Proxy<\/code>). A classe RealSubject<\/code> representa o objeto real com a funcionalidade que desejamos controlar o acesso. O Proxy<\/code> atua como um substituto do objeto real e controla o acesso a ele. No programa principal, criamos uma inst\u00e2ncia do Proxy<\/code> e chamamos o m\u00e9todo Request<\/code>, que internamente verifica se o objeto real j\u00e1 foi criado ou n\u00e3o. Se n\u00e3o foi criado, o Proxy<\/code> cria uma inst\u00e2ncia do RealSubject<\/code> e em seguida realiza a requisi\u00e7\u00e3o atrav\u00e9s do objeto real.<\/p>\n\n\n\n
Como esses padr\u00f5es ajudam no design de sistemas flex\u00edveis<\/h2>\n\n\n\n
Os padr\u00f5es de design Bridge, Adapter <\/em>e Proxy <\/em>contribuem para o desenvolvimento de sistemas flex\u00edveis e adapt\u00e1veis. Cada um desses padr\u00f5es oferece uma maneira diferente de garantir que as partes do seu sistema possam variar independentemente umas das outras.<\/p>\n\n\n\n
Como esses padr\u00f5es podem beneficiar o neg\u00f3cio<\/h2>\n\n\n\n
Em um contexto de neg\u00f3cios, a utiliza\u00e7\u00e3o desses padr\u00f5es de design pode trazer v\u00e1rios benef\u00edcios, como maior flexibilidade, redu\u00e7\u00e3o de custos com manuten\u00e7\u00e3o e evolu\u00e7\u00e3o do sistema, al\u00e9m de permitir a integra\u00e7\u00e3o com outros sistemas de forma mais f\u00e1cil.<\/p>\n\n\n\n
Conclus\u00e3o<\/h2>\n\n\n\n
Para finalizar, os padr\u00f5es de design s\u00e3o ferramentas poderosas que podem ajudar a criar sistemas mais flex\u00edveis, de f\u00e1cil manuten\u00e7\u00e3o e interoper\u00e1veis. Espero que este artigo tenha ajudado a esclarecer a import\u00e2ncia dos padr\u00f5es Bridge, Adapter <\/em>e Proxy <\/em>no design de sistemas. Lembre-se: a melhor pr\u00e1tica \u00e9 sempre aquela que melhor se adequa ao seu caso!<\/p>\n\n\n\n
Esse conte\u00fado \u00e9 parte do material disponibilizado para os participantes do meu grupo de estudos de\u00a0Padr\u00f5es de Projeto<\/strong>. Voc\u00ea quer participar desse grupo?\u00a0Clique aqui e veja como funciona<\/a><\/strong>.<\/p>\n\n\n\n
D\u00favidas Frequentes<\/h2>\n\n\n\n
Qual a diferen\u00e7a entre os padr\u00f5es Bridge, Adapter e Proxy<\/em>?<\/strong>
A principal diferen\u00e7a \u00e9 a finalidade de cada um deles. O padr\u00e3o Bridge<\/em> \u00e9 usado para separar a abstra\u00e7\u00e3o da implementa\u00e7\u00e3o, o Adapter<\/em> \u00e9 utilizado para compatibilizar interfaces incompat\u00edveis, e o Proxy<\/em> controla o acesso a objetos.<\/p>\n\n\n\n
Os padr\u00f5es de design podem ajudar no desenvolvimento de software?<\/strong>
Sim, os padr\u00f5es de design <\/em>podem ajudar no desenvolvimento de software, tornando-o mais organizado, eficiente e f\u00e1cil de manter.<\/p>\n\n\n\n
Todos os sistemas precisam usar esses padr\u00f5es?<\/strong>
N\u00e3o necessariamente. O uso de padr\u00f5es depende dos requisitos e complexidade do sistema.<\/p>\n\n\n\n
O uso de padr\u00f5es de design<\/em> pode ter um impacto negativo?<\/strong>
Se usados incorretamente, os padr\u00f5es de design podem tornar o sistema excessivamente complexo e dif\u00edcil de entender. \u00c9 importante usar os padr\u00f5es de design<\/em> de forma adequada.<\/p>\n\n\n\n
Qual padr\u00e3o de design<\/em> devo usar?<\/strong>
Depende das necessidades do seu sistema. Cada padr\u00e3o tem suas pr\u00f3prias vantagens e desvantagens, e a decis\u00e3o de usar um padr\u00e3o espec\u00edfico deve ser baseada nas necessidades espec\u00edficas do seu sistema.<\/p>\n","protected":false},"featured_media":4957,"parent":0,"template":"","cursos":[7],"class_list":["post-4832","artigos","type-artigos","status-publish","has-post-thumbnail","hentry","cursos-gof"],"acf":[],"_links":{"self":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/artigos\/4832","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/artigos"}],"about":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/types\/artigos"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/media\/4957"}],"wp:attachment":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/media?parent=4832"}],"wp:term":[{"taxonomy":"cursos","embeddable":true,"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/cursos?post=4832"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}