{"id":4678,"date":"2023-05-24T10:36:48","date_gmt":"2023-05-24T13:36:48","guid":{"rendered":"https:\/\/elemarjr.com\/clube-de-estudos\/?p=4678"},"modified":"2023-10-21T21:37:27","modified_gmt":"2023-10-22T00:37:27","slug":"padrao-de-design-singleton-implementacao-e-exemplos-de-uso","status":"publish","type":"artigos","link":"https:\/\/elemarjr.com\/clube-de-estudos\/artigos\/padrao-de-design-singleton-implementacao-e-exemplos-de-uso\/","title":{"rendered":"Padr\u00e3o de design Singleton: Implementa\u00e7\u00e3o e Exemplos de Uso"},"content":{"rendered":"\n

Entendendo o Padr\u00e3o Singleton<\/em><\/h2>\n\n\n\n

O que \u00e9 o Padr\u00e3o Singleton<\/em>?<\/h3>\n\n\n\n

O padr\u00e3o Singleton<\/em> \u00e9 um padr\u00e3o de projeto que garante a exist\u00eancia de apenas uma inst\u00e2ncia de uma determinada classe durante a execu\u00e7\u00e3o do programa. Ele fornece um ponto de acesso global a essa inst\u00e2ncia, facilitando o seu uso.<\/p>\n\n\n\n

Quando usar o Padr\u00e3o Singleton<\/em>?<\/h3>\n\n\n\n

O Singleton<\/em> \u00e9 \u00fatil quando precisamos de uma \u00fanica inst\u00e2ncia de uma classe para controlar a\u00e7\u00f5es. \u00c9 comum em casos onde se precisa coordenar a\u00e7\u00f5es em um sistema ou quando objetos mais pesados, como conex\u00f5es de banco de dados, precisam ser gerenciados.<\/p>\n\n\n\n

Implementa\u00e7\u00e3o do Padr\u00e3o Singleton<\/em><\/h2>\n\n\n\n

Implementa\u00e7\u00e3o B\u00e1sica<\/h3>\n\n\n\n

A implementa\u00e7\u00e3o b\u00e1sica do padr\u00e3o Singleton<\/em> envolve a cria\u00e7\u00e3o de uma classe com um m\u00e9todo que cria uma nova inst\u00e2ncia da classe se uma ainda n\u00e3o existir. Se uma inst\u00e2ncia j\u00e1 existir, ele simplesmente a retorna.<\/p>\n\n\n\n

C#<\/span><\/path><\/path><\/svg><\/span>
using<\/span> System<\/span>;<\/span><\/span>\n<\/span>\npublic<\/span> <\/span>class<\/span> <\/span>Singleton<\/span><\/span>\n{<\/span><\/span>\n    <\/span>private<\/span> <\/span>static<\/span> Singleton instance<\/span>;<\/span><\/span>\n    <\/span><\/span>\n    <\/span>\/\/ Construtor privado para evitar instancia\u00e7\u00e3o direta<\/span><\/span>\n    <\/span>private<\/span> <\/span>Singleton<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>"<\/span>Inst\u00e2ncia criada.<\/span>"<\/span>)<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n    <\/span><\/span>\n    <\/span>\/\/ M\u00e9todo est\u00e1tico para obter a inst\u00e2ncia \u00fanica<\/span><\/span>\n    <\/span>public<\/span> <\/span>static<\/span> Singleton <\/span>GetInstance<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>if<\/span> <\/span>(<\/span>instance<\/span> <\/span>==<\/span> <\/span>null<\/span>)<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>instance<\/span> <\/span>=<\/span> <\/span>new<\/span> Singleton<\/span>()<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span><\/span>\n        <\/span>return<\/span> <\/span>instance<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n    <\/span><\/span>\n    <\/span>public<\/span> <\/span>void<\/span> <\/span>SomeMethod<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>"<\/span>Executando m\u00e9todo da inst\u00e2ncia Singleton.<\/span>"<\/span>)<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\npublic<\/span> <\/span>class<\/span> <\/span>Program<\/span><\/span>\n{<\/span><\/span>\n    <\/span>public<\/span> <\/span>static<\/span> <\/span>void<\/span> <\/span>Main<\/span>(<\/span>string<\/span>[]<\/span> args<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>\/\/ Obter a inst\u00e2ncia do Singleton<\/span><\/span>\n        Singleton singleton1 <\/span>=<\/span> <\/span>Singleton<\/span>.<\/span>GetInstance<\/span>()<\/span>;<\/span><\/span>\n        <\/span>singleton1<\/span>.<\/span>SomeMethod<\/span>()<\/span>;<\/span> <\/span>\/\/ Executar m\u00e9todo na inst\u00e2ncia<\/span><\/span>\n        <\/span><\/span>\n        <\/span>\/\/ Obter a mesma inst\u00e2ncia novamente<\/span><\/span>\n        Singleton singleton2 <\/span>=<\/span> <\/span>Singleton<\/span>.<\/span>GetInstance<\/span>()<\/span>;<\/span><\/span>\n        <\/span>singleton2<\/span>.<\/span>SomeMethod<\/span>()<\/span>;<\/span> <\/span>\/\/ Executar m\u00e9todo na inst\u00e2ncia novamente<\/span><\/span>\n        <\/span><\/span>\n        <\/span>\/\/ Verificar se as inst\u00e2ncias s\u00e3o iguais<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>singleton1<\/span> <\/span>==<\/span> <\/span>singleton2<\/span>)<\/span>;<\/span> <\/span>\/\/ Retorna true, pois \u00e9 a mesma inst\u00e2ncia<\/span><\/span>\n        <\/span><\/span>\n        <\/span>\/\/ Tentar criar uma nova inst\u00e2ncia diretamente<\/span><\/span>\n        <\/span>\/\/ Singleton singleton3 = new Singleton(); \/\/ Isso n\u00e3o \u00e9 permitido, pois o construtor \u00e9 privado<\/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, a classe Singleton<\/code> implementa o padr\u00e3o Singleton<\/em>. Ela possui um construtor privado para evitar a cria\u00e7\u00e3o direta de inst\u00e2ncias e um m\u00e9todo est\u00e1tico GetInstance()<\/code> que retorna a inst\u00e2ncia \u00fanica. Quando o m\u00e9todo GetInstance()<\/code> \u00e9 chamado pela primeira vez, uma nova inst\u00e2ncia \u00e9 criada. Nas chamadas subsequentes, a mesma inst\u00e2ncia \u00e9 retornada.<\/p>\n\n\n\n
No m\u00e9todo Main<\/code>, demonstramos o uso do padr\u00e3o Singleton<\/em> ao obter a inst\u00e2ncia do Singleton<\/em> e executar um m\u00e9todo na mesma. Em seguida, obtemos a inst\u00e2ncia novamente e verificamos se \u00e9 a mesma inst\u00e2ncia, o que retorna true<\/code>. Al\u00e9m disso, mostramos que a tentativa de criar uma nova inst\u00e2ncia diretamente \u00e9 impedida pelo construtor privado.<\/p>\n\n\n\n
Implementa\u00e7\u00e3o com thread-safe<\/em><\/h3>\n\n\n\n
Em ambientes multithread<\/em>, a implementa\u00e7\u00e3o b\u00e1sica pode levar a problemas. Nesses casos, podemos adicionar um bloqueio de thread<\/em> (sincroniza\u00e7\u00e3o) para garantir que apenas um thread<\/em> possa criar uma inst\u00e2ncia.<\/p>\n\n\n\n
C#<\/span><\/path><\/path><\/svg><\/span>
using<\/span> System<\/span>;<\/span><\/span>\n<\/span>\npublic<\/span> <\/span>class<\/span> <\/span>Singleton<\/span><\/span>\n{<\/span><\/span>\n    <\/span>private<\/span> <\/span>static<\/span> Singleton instance<\/span>;<\/span><\/span>\n    <\/span>private<\/span> <\/span>static<\/span> <\/span>readonly<\/span> <\/span>object<\/span> lockObject <\/span>=<\/span> <\/span>new<\/span> <\/span>object<\/span>()<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>\/\/ Construtor privado para evitar instancia\u00e7\u00e3o direta<\/span><\/span>\n    <\/span>private<\/span> <\/span>Singleton<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>\/\/ M\u00e9todo p\u00fablico est\u00e1tico que retorna a \u00fanica inst\u00e2ncia da classe<\/span><\/span>\n    <\/span>public<\/span> <\/span>static<\/span> Singleton <\/span>GetInstance<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>\/\/ Verifica se a inst\u00e2ncia j\u00e1 foi criada<\/span><\/span>\n        <\/span>if<\/span> <\/span>(<\/span>instance<\/span> <\/span>==<\/span> <\/span>null<\/span>)<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>\/\/ Bloqueia o acesso simult\u00e2neo de m\u00faltiplas threads<\/span><\/span>\n            <\/span>lock<\/span> <\/span>(<\/span>lockObject<\/span>)<\/span><\/span>\n            <\/span>{<\/span><\/span>\n                <\/span>\/\/ Verifica novamente se a inst\u00e2ncia ainda \u00e9 nula (pode ter sido criada por outra thread)<\/span><\/span>\n                <\/span>if<\/span> <\/span>(<\/span>instance<\/span> <\/span>==<\/span> <\/span>null<\/span>)<\/span><\/span>\n                <\/span>{<\/span><\/span>\n                    <\/span>\/\/ Cria uma nova inst\u00e2ncia da classe<\/span><\/span>\n                    <\/span>instance<\/span> <\/span>=<\/span> <\/span>new<\/span> Singleton<\/span>()<\/span>;<\/span><\/span>\n                <\/span>}<\/span><\/span>\n            <\/span>}<\/span><\/span>\n        <\/span>}<\/span><\/span>\n<\/span>\n        <\/span>\/\/ Retorna a inst\u00e2ncia existente ou a rec\u00e9m-criada<\/span><\/span>\n        <\/span>return<\/span> <\/span>instance<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>void<\/span> <\/span>PrintMessage<\/span>(<\/span>string<\/span> message<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>message<\/span>)<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\npublic<\/span> <\/span>class<\/span> <\/span>Program<\/span><\/span>\n{<\/span><\/span>\n    <\/span>public<\/span> <\/span>static<\/span> <\/span>void<\/span> <\/span>Main<\/span>(<\/span>string<\/span>[]<\/span> args<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>\/\/ Obtem a inst\u00e2ncia do Singleton<\/span><\/span>\n        Singleton singleton1 <\/span>=<\/span> <\/span>Singleton<\/span>.<\/span>GetInstance<\/span>()<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>\/\/ Chama o m\u00e9todo da inst\u00e2ncia<\/span><\/span>\n        <\/span>singleton1<\/span>.<\/span>PrintMessage<\/span>(<\/span>"<\/span>Ol\u00e1, eu sou a inst\u00e2ncia 1!<\/span>"<\/span>)<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>\/\/ Obtem outra inst\u00e2ncia do Singleton<\/span><\/span>\n        Singleton singleton2 <\/span>=<\/span> <\/span>Singleton<\/span>.<\/span>GetInstance<\/span>()<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>\/\/ Chama o m\u00e9todo da inst\u00e2ncia<\/span><\/span>\n        <\/span>singleton2<\/span>.<\/span>PrintMessage<\/span>(<\/span>"<\/span>Ol\u00e1, eu sou a inst\u00e2ncia 2!<\/span>"<\/span>)<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>\/\/ Verifica se as duas inst\u00e2ncias s\u00e3o iguais<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>"<\/span>As duas inst\u00e2ncias s\u00e3o iguais? <\/span>"<\/span> <\/span>+<\/span> <\/span>(<\/span>singleton1<\/span> <\/span>==<\/span> <\/span>singleton2<\/span>))<\/span>;<\/span><\/span>\n<\/span>\n        <\/span>\/\/ Aguarda a press\u00e3o de uma tecla para encerrar o programa<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>ReadKey<\/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, a classe Singleton<\/code> implementa o padr\u00e3o Singleton<\/em>. O m\u00e9todo GetInstance()<\/code> retorna a \u00fanica inst\u00e2ncia da classe, garantindo que apenas uma inst\u00e2ncia seja criada mesmo em ambientes multithread<\/em>. A classe Program<\/code> demonstra o uso do Singleton<\/em>, onde s\u00e3o obtidas duas inst\u00e2ncias do Singleton<\/em> e verificado se s\u00e3o iguais.<\/p>\n\n\n\n
Implementa\u00e7\u00e3o com Lazy Initialization<\/em><\/h3>\n\n\n\n
Em algumas situa\u00e7\u00f5es, queremos adiar a cria\u00e7\u00e3o da inst\u00e2ncia Singleton<\/em> at\u00e9 o momento em que realmente precisamos dela. Isso \u00e9 chamado de “lazy initialization”<\/em>.<\/p>\n\n\n\n
C#<\/span><\/path><\/path><\/svg><\/span>
public<\/span> <\/span>class<\/span> <\/span>Singleton<\/span><\/span>\n{<\/span><\/span>\n    <\/span>\/\/ Vari\u00e1vel est\u00e1tica que armazena a \u00fanica inst\u00e2ncia do Singleton<\/span><\/span>\n    <\/span>private<\/span> <\/span>static<\/span> Singleton instance<\/span>;<\/span><\/span>\n    <\/span><\/span>\n    <\/span>\/\/ Objeto de controle de acesso \u00e0 inst\u00e2ncia do Singleton<\/span><\/span>\n    <\/span>private<\/span> <\/span>static<\/span> <\/span>readonly<\/span> <\/span>object<\/span> lockObject <\/span>=<\/span> <\/span>new<\/span> <\/span>object<\/span>()<\/span>;<\/span><\/span>\n    <\/span><\/span>\n    <\/span>\/\/ Propriedade para acessar a inst\u00e2ncia do Singleton<\/span><\/span>\n    <\/span>public<\/span> <\/span>static<\/span> Singleton Instance<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>get<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>\/\/ Verifica se a inst\u00e2ncia ainda n\u00e3o foi criada<\/span><\/span>\n            <\/span>if<\/span> <\/span>(<\/span>instance<\/span> <\/span>==<\/span> <\/span>null<\/span>)<\/span><\/span>\n            <\/span>{<\/span><\/span>\n                <\/span>\/\/ Utiliza o objeto de controle de acesso para garantir que apenas uma thread possa criar a inst\u00e2ncia<\/span><\/span>\n                <\/span>lock<\/span> <\/span>(<\/span>lockObject<\/span>)<\/span><\/span>\n                <\/span>{<\/span><\/span>\n                    <\/span>\/\/ Verifica novamente se a inst\u00e2ncia ainda n\u00e3o foi criada, pois outra thread pode ter criado enquanto aguardava o lock<\/span><\/span>\n                    <\/span>if<\/span> <\/span>(<\/span>instance<\/span> <\/span>==<\/span> <\/span>null<\/span>)<\/span><\/span>\n                    <\/span>{<\/span><\/span>\n                        <\/span>\/\/ Cria a inst\u00e2ncia do Singleton<\/span><\/span>\n                        <\/span>instance<\/span> <\/span>=<\/span> <\/span>new<\/span> Singleton<\/span>()<\/span>;<\/span><\/span>\n                    <\/span>}<\/span><\/span>\n                <\/span>}<\/span><\/span>\n            <\/span>}<\/span><\/span>\n            <\/span><\/span>\n            <\/span>\/\/ Retorna a inst\u00e2ncia do Singleton<\/span><\/span>\n            <\/span>return<\/span> <\/span>instance<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n    <\/span>}<\/span><\/span>\n    <\/span><\/span>\n    <\/span>\/\/ Construtor privado para evitar a cria\u00e7\u00e3o direta do Singleton<\/span><\/span>\n    <\/span>private<\/span> <\/span>Singleton<\/span>()<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>\/\/ Inicializa\u00e7\u00e3o do Singleton<\/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, utilizamos a t\u00e9cnica de “lazy initialization<\/em>” para criar a inst\u00e2ncia do Singleton<\/em> somente quando ela for necess\u00e1ria. A propriedade Instance<\/code> \u00e9 respons\u00e1vel por retornar a inst\u00e2ncia existente ou criar uma nova inst\u00e2ncia se ela ainda n\u00e3o tiver sido criada. O objeto lockObject<\/code> \u00e9 utilizado para controlar o acesso concorrente \u00e0 cria\u00e7\u00e3o da inst\u00e2ncia, garantindo que apenas uma thread <\/em>possa criar o Singleton<\/em>.<\/p>\n\n\n\n
\u00c9 importante ressaltar que essa implementa\u00e7\u00e3o com lazy initialization <\/em>\u00e9 thread-safe<\/em>, ou seja, garante que apenas uma inst\u00e2ncia do Singleton<\/em> ser\u00e1 criada mesmo em ambientes com m\u00faltiplas threads<\/em>.<\/p>\n\n\n\n
Exemplos de Uso do Padr\u00e3o Singleton<\/em><\/h2>\n\n\n\n
Uso em Gerenciadores de Conex\u00e3o<\/h3>\n\n\n\n
Gerenciadores de conex\u00e3o s\u00e3o um exemplo cl\u00e1ssico de uso do padr\u00e3o Singleton<\/em>. Eles gerenciam um recurso que \u00e9 caro para criar e manter, e onde normalmente s\u00f3 precisamos de uma inst\u00e2ncia.<\/p>\n\n\n\n
Uso em Loggers<\/em><\/h3>\n\n\n\n
Loggers<\/em> que escrevem em um arquivo ou enviam mensagens para um servidor tamb\u00e9m s\u00e3o comumente implementados como Singletons<\/em>. Eles agregam todos os logs em um \u00fanico local, facilitando a an\u00e1lise e depura\u00e7\u00e3o.<\/p>\n\n\n\n
Uso em Configura\u00e7\u00f5es do Sistema<\/h3>\n\n\n\n
As classes de configura\u00e7\u00e3o do sistema que mant\u00e9m um conjunto de par\u00e2metros que podem ser acessados globalmente tamb\u00e9m s\u00e3o um bom exemplo de uso do Singleton<\/em>.<\/p>\n\n\n\n
Vantagens e Desvantagens do Padr\u00e3o Singleton<\/em><\/h2>\n\n\n\n
Como todo padr\u00e3o de design<\/em>, o Singleton<\/em> tem suas vantagens e desvantagens. Ele \u00e9 \u00fatil quando precisamos garantir que apenas uma inst\u00e2ncia de uma classe exista, mas pode ser problem\u00e1tico quando usado indevidamente, especialmente em ambientes multithread<\/em>.<\/p>\n\n\n\n
Considera\u00e7\u00f5es Finais<\/h2>\n\n\n\n
O padr\u00e3o Singleton<\/em> \u00e9 uma ferramenta poderosa em nosso arsenal de design <\/em>de software<\/em>. Como com qualquer ferramenta, devemos us\u00e1-la sabiamente e entender bem seus pr\u00f3s e contras antes de aplic\u00e1-la.<\/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
O padr\u00e3o Singleton<\/em> \u00e9 considerado uma m\u00e1 pr\u00e1tica?<\/strong>
N\u00e3o, o padr\u00e3o Singleton<\/em> n\u00e3o \u00e9 uma m\u00e1 pr\u00e1tica, mas deve ser usado com cuidado, pois pode levar a problemas se usado incorretamente.<\/p>\n\n\n\n
O padr\u00e3o Singleton<\/em> pode ser usado em aplicativos multi-thread<\/em>?<\/strong>
Sim, mas precisa ser implementado corretamente para evitar condi\u00e7\u00f5es de corrida.<\/p>\n\n\n\n
Singleton<\/em> e Global s\u00e3o a mesma coisa?<\/strong>
N\u00e3o, embora ambos forne\u00e7am acesso global, Singleton<\/em> garante uma \u00fanica inst\u00e2ncia, enquanto uma vari\u00e1vel global n\u00e3o.<\/p>\n\n\n\n
Posso ter mais de um Singleton<\/em> em minha aplica\u00e7\u00e3o?<\/strong>
Sim, voc\u00ea pode ter v\u00e1rios tipos diferentes de Singletons<\/em> em sua aplica\u00e7\u00e3o.<\/p>\n\n\n\n
O que \u00e9 “lazy initialization<\/em>” em Singleton<\/em>?<\/strong>
“Lazy initialization<\/em>” \u00e9 a t\u00e9cnica de adiar a cria\u00e7\u00e3o da inst\u00e2ncia Singleton<\/em> at\u00e9 o momento em que ela \u00e9 realmente necess\u00e1ria.<\/p>\n","protected":false},"featured_media":4760,"parent":0,"template":"","cursos":[7],"class_list":["post-4678","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\/4678","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\/4760"}],"wp:attachment":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/media?parent=4678"}],"wp:term":[{"taxonomy":"cursos","embeddable":true,"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/cursos?post=4678"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}