Comece a usar a extensão MongoDB para hibernação ORM

Instalar dependências

Antes de começar a desenvolver, verifique se você tem as seguintes dependências instaladas em sua máquina local:

• Java versão 17 ou posterior

• Ambiente de desenvolvimento integrado (IDE), como IntelliJ IDEA ou Eclipse

Instalar a extensão

No seu IDE, crie um novo projeto Maven ou Gradle denominado MongoHibernateQuickstart. Para projetos Maven, adicione a seguinte dependência ao seu arquivo pom.xml:

<dependencies>
   <dependency>
      <groupId>org.mongodb</groupId>
      <artifactId>mongodb-hibernate</artifactId>
      <version>1.0.0-alpha0</version>
   </dependency>
</dependencies>

Para projetos Gradle, adicione a seguinte dependência ao seu arquivo build.gradle:

dependencies {
   implementation("org.mongodb:mongodb-hibernate:1.0.0-alpha0")
}

Em seu IDE, certifique-se de recarregar ou realizar a sincronização do seu projeto para concluir a instalação da extensão Hibernate ORM.

Crie uma MongoDB deployment gratuita no Atlas

Complete o guia Iniciar MongoDB para configurar uma nova conta Atlas e carregar dados de amostra em uma nova implantação MongoDB de camada grátis. Siga as instruções nas abas Cloud Deployment para criar sua implantação do MongoDB Atlas na nuvem.

Salve suas credenciais

Depois de criar seu usuário de banco de dados, salve o nome de banco de dados e a senha do banco de dados desse usuário em um local seguro para uso em uma etapa futura.

Encontre sua string de conexão do MongoDB Atlas

Para recuperar a string de conexão da implantação criada na etapa anterior, faça login na sua conta do Atlas e navegue até a seção Clusters. Clique no botão Connect para sua nova implantação, como mostrado na seguinte captura de tela:

Em seguida, vá para a seção Connect your application. Selecione "Java" no menu de seleção Driver e a versão que melhor corresponde à versão instalada no menu de seleção Version.

Copie a string de conexão

Clique no botão à direita da string de conexão para copiá-la para a área de transferência, como mostrado na seguinte captura de tela:

Editar seus espaços reservados para string de conexão

Salve sua string de conexão em um local seguro para uso posterior. Substitua os espaços reservados da string de conexão <db_username> e <db_password> pelo nome de usuário e senha do usuário do banco de dados .

Adicionar um banco de dados à sua string de conexão

Para se conectar ao banco de dados de amostra sample_mflix, que seu aplicação usará nas próximas etapas, adicione o nome do banco de dados à sua string de conexão.

Sua string de conexão deve ser semelhante ao exemplo a seguir:

mongodb+srv://<db_username>:<db_password>@<cluster>/sample_mflix?<options>

Codifique sua string de conexão para XML

Antes de adicionar sua string de conexão a um arquivo de configuração XML em uma etapa futura, você deve codificar os seguintes caracteres especiais em sua string de conexão:

• &: Substitua por &

• ': Substitua por '

• ": Substitua por "

• <: Substitua por <

• >: Substitua por >

Por padrão, sua string de conexão do Atlas inclui opções de conexão separadas pelo caractere &. Certifique-se de codificar em XML esse caractere.

Conectar seu aplicativo ao MongoDB

Navegue até o diretório MongoHibernateQuickstart do seu projeto src/main/resources e crie um novo arquivo denominado hibernate.cfg.xml, que armazena as definições de configuração do seu aplicativo.

Copie o seguinte código para este arquivo:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">com.mongodb.hibernate.dialect.MongoDialect</property>
        <property name="hibernate.connection.provider_class">
            com.mongodb.hibernate.jdbc.MongoConnectionProvider
        </property>
        <property name="jakarta.persistence.jdbc.url">
            connection-string
        </property>
        <property name="hibernate.show_sql">true</property>
        <mapping class="org.example.Movie"/>
    </session-factory>
</hibernate-configuration>

Na jakarta.persistence.jdbc.url propriedade , substitua connection-string o espaço reservado pela string de conexão que você criou na etapa anterior.

Crie uma classe de utilitário para gerenciar sessões

No diretório src/main/java/org/example do seu projeto, crie um novo arquivo chamado HibernateUtil.java. Esta classe de utilitário cria um SessionFactory com base em seu arquivo de configuração do hibernate.cfg.xml.

Copie o seguinte código para este arquivo:

package org.example;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public final class HibernateUtil {
  private static final SessionFactory SESSION_FACTORY =
          new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
  private HibernateUtil() {}
  public static SessionFactory getSessionFactory() { return SESSION_FACTORY; }
}

Defina sua Movie entidade

No diretório org/example do seu projeto, crie um novo arquivo chamado Movie.java. Esse arquivo contém sua entidade Movie, que representa a coleção de amostras sample_mflix.movies dos conjuntos de dados de amostra do Atlas.

Copie o seguinte código para este arquivo:

package org.example;
import com.mongodb.hibernate.annotations.ObjectIdGenerator;
import org.bson.types.ObjectId;
import java.util.List;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
@Entity
@Table(name = "movies")
public class Movie {
	@Id
	@ObjectIdGenerator
	private ObjectId id;
	private String title;
	private String plot;
	private int year;
	private List<String> cast;
	public Movie(String title, String plot, int year, List<String> cast) {
 		this.title = title;
		this.plot = plot;
		this.year = year;
		this.cast = cast;
 	}
	public Movie() {
	}
	public ObjectId getId() {
		return id;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getPlot() {
		return plot;
	}
	public void setPlot(String plot) {
		this.plot = plot;
	}
	
	public int getYear() {
		return year;
	}
	public void setYear(int year) {
		this.year = year;
	}
	public List<String> getCast() {
		return cast;
	}
	
	public void setCast(List<String> cast) {
		this.cast = cast;
	}
}

Este arquivo define uma entidade Movie com os seguintes campos:

• id: o identificador exclusivo do filme, mapeado para o campo MongoDB _id .

• title: O título do filme.

• year: o ano em que o filme foi lançado.

• cast: uma lista de strings representando os membros do elenco do filme.

Defina sua principal classe de aplicação

No diretório org/example do seu projeto, crie um novo arquivo chamado Main.java. Esse arquivo contém sua classe de aplicação principal, que armazena a lógica do seu aplicativo.

Copie o seguinte código para este arquivo:

package org.example;
import org.hibernate.Transaction;
import org.hibernate.Session;
import java.util.ArrayList;
import java.util.List;
public class Main {
        public static void main(String[] args) {
            var sf = HibernateUtil.getSessionFactory();
            Session session = sf.openSession();
            Transaction tx = session.beginTransaction();
            // Add CRUD operations here
            tx.commit();
            session.close();
            sf.close();
        }
}

Execute uma consulta no campo title

Navegue até seu arquivo Main.java e cole o seguinte código abaixo do comentário // Add CRUD operations here:

var searchTitle = "Little Women";
var results = session.createQuery("from Movie m where m.title = :t", Movie.class)
      .setParameter("t", searchTitle)
      .getResultList();
for (var m : results) {
   System.out.println("Title: " + m.getTitle() + ", Year: " + m.getYear());
}

Este código usa a linguagem de query do Hibernate ORM (HQL) para recuperar sample_mflix.movies documentos que têm um valor title de "Little Women". Em seguida, imprime os valores title e year de cada resultado.

Execute seu aplicativo

Execute o arquivo Main.java em seu IDE. Sua saída contém detalhes sobre o comando de banco de dados e os documentos recuperados:

Hibernate: {"aggregate": "movies", "pipeline": [{"$match": {"title": {"$eq": {"$undefined": true}}}},
{"$project": {"_id": true, "cast": true, "plot": true, "title": true, "year": true}}]}
Title: Little Women, Year: 1949
Title: Little Women, Year: 1994

Inserir um documento na movies coleção

Em seu arquivo Main.java, adicione o seguinte código para criar uma instância de entidade Movie chamada myMovie e salvá-la no banco de dados:

var title = "A Real Pain";
var plot = "Mismatched cousins David and Benji tour Poland to honor their grandmother. " +
       "Their adventure becomes complicated as old tensions resurface while exploring their family history.";
var year = 2024;
var cast = List.of("Jesse Eisenberg", "Kieran Culkin", "Will Sharpe");
var myMovie = new Movie(title, plot, year, cast);
session.persist(myMovie);
System.out.println("Movie created with ID: " + myMovie.getId());

Este código cria uma nova instância de entidade Movie e utiliza o método session.persist() para salvá-la no banco de dados.

Atualizar um documento

Adicione o seguinte código ao seu arquivo Main.java para atualizar a instância do Movie que você criou na etapa anterior:

var currentCast = new ArrayList<>(myMovie.getCast());
currentCast.add("Jennifer Grey");
myMovie.setCast(currentCast);
System.out.println("Movie updated with new cast: " + myMovie.getCast());

Este código recupera o valor cast atual, adiciona um novo nó e atualiza o campo cast da instância de entidade myMovie. A extensão ORM do Hibernar aplica esta alteração ao documento correspondente no banco de dados.

Excluir um documento

Adicione o seguinte código ao seu arquivo Main.java para excluir a instância de entidade myMovie:

session.remove(myMovie);
System.out.println("Movie deleted with ID: " + myMovie.getId());

Este código exclui a instância da entidade myMovie e seu documento correspondente do banco de dados.

Execute seu aplicativo

Execute o arquivo Main.java em seu IDE. Sua saída contém detalhes sobre suas operações de gravação:

Hibernate: {"insert": "movies", "documents": [{"cast": {"$undefined": true}, "plot": {"$undefined": true}, "title": {"$undefined": true}, "year": {"$undefined": true}, "_id": {"$undefined": true}}]}
Hibernate: {"delete": "movies", "deletes": [{"q": {"_id": {"$eq": {"$undefined": true}}}, "limit": {"$numberInt": "0"}}]}
Movie created with ID: <ObjectId>
Movie updated with new cast: [Jesse Eisenberg, Kieran Culkin, Will Sharpe, Jennifer Grey]
Movie deleted with ID: <ObjectId>