Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Junte-se a nós no Amazon Web Services re:Invent 2024! Saiba como usar o MongoDB para casos de uso de AI .
Desenvolvedor do MongoDB
Central de desenvolvedor do MongoDBchevron-right
Produtoschevron-right
MongoDBchevron-right

Por que dados não estruturados são uma boa opção para Java

Aasawari Sahasrabuddhe7 min read • Published Aug 30, 2024 • Updated Sep 16, 2024
MongoDBJava
SNIPPET
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Artigo
star-empty
star-empty
star-empty
star-empty
star-empty
Como desenvolvedores Java do aplicativo legado em que você trabalhou, a maioria de você deve ter passado grande parte do desenvolvimento do aplicativo domínio dos bancos de dados relacionais, da construção de esquemas e do aprimoramento das queries SQL. Durante aqueles dias, os dados eram limitados e facilmente mapeados para as rígidas estruturas do esquema. Mas, com a mudança da era, em que os dados são valorizados como cobre, eles estão crescendo exponencialmente e se tornando mais desestruturados.
Dados não estruturados referem-se a informações que não seguem um padrão predefinido ou não estão organizadas em um padrão rigoroso. Como mencionado acima, os dados não estruturados contêm dados em formatos variados, como dados de mídia, CSVs e muitos mais. O armazenamento deles em bancos de dados relacionais tem sido difícil devido aos diversos formatos. Portanto, nós os armazenamos como JSONs, XMLs, etc. Saiba mais sobre dados não estruturados.
Por que você deve se importar como desenvolvedor Java? Os aplicativos empresariais criados atualmente têm mais dados não estruturados, como textos para avaliações de clientes, imagens de produtos e detalhes de envio, e tudo isso em uma única plataforma. Bancos de dados relacionais exigem projetos complexos para lidar com isso, enquanto o MongoDB cresce nesse cenário, facilitando para os desenvolvedores Java o trabalho com tipos de dados tão diversos.

Como o MongoDB se mostra útil com dados não estruturados?

No mundo acelerado de hoje, onde os requisitos de aplicativos estão em constante mudança, o desafio de gerenciar dados não estruturados em rápido crescimento se torna significativamente mais gerenciável. Isso ocorre em grande parte porque os dados não estruturados não precisam estar em conformidade com um modelo de esquema rígido, oferecendo flexibilidade que é particularmente benéfica ao trabalhar com bancos de dados não relacionais, como o MongoDB.
A arquitetura sem esquema do MongoDB permite que os desenvolvedores introduzam novos campos em documentos ou coleções em tempo real, sem a necessidade de revisar um esquema inteiro. Isso não apenas minimiza o tempo de inatividade, mas também acelera o processo de desenvolvimento, permitindo que as equipes se adaptem rapidamente aos requisitos em constante mudança.
Por outro lado, um modelo de esquema rigoroso pode exigir um esforço substancial quando são necessárias mudanças contínuas. Ao gerenciar dados em um formato não estruturado, o MongoDB reduz significativamente a sobrecarga associada a essas alterações. Seu esquema dinâmico é particularmente adequado para lidar com diversos tipos de dados, como imagens, tags e metadados, tornando-o a opção ideal para aplicativos modernos que lidam com uma grande variedade de conteúdo.
Além disso, a escalabilidade horizontal integrada do MongoDB permite que os desenvolvedores expandam seus aplicativos sem esforço à medida que os volumes de dados aumentam, garantindo que o desempenho permaneça consistente mesmo com o aumento da quantidade de dados não estruturados. Para desenvolvedores Java, isso significa que eles podem lidar com grandes conjuntos de dados de forma eficiente, mantendo a agilidade necessária para atender às necessidades de negócios em constante mudança.

Como você trabalha com dados não estruturados em Java?

Agora, vamos voltar ao objetivo principal do artigo: por que você, como desenvolvedor Java, deve usar o MongoDB como banco de dados para seus dados não estruturados em crescimento?
Quando mencionamos dados não estruturados, eles são armazenados principalmente no formato JSON, assim como os dados armazenados no MongoDB. Ele armazena os dados em um formato semelhante a JSON conhecido como BSON, ou Binary JSON, que é altamente compatível com o modelo POJO do Java.
Essa compatibilidade torna o mapeamento mais simples. Por exemplo, digamos que você tem uma classe de cliente em seu aplicativo Java que armazena detalhes de um cliente específico.
1public class Customer {
2 private String id;
3 private String name;
4 private String email;
5 // Constructors, getters, and setters
6}
Com o driver Java do MongoDB, você pode mapear a classeCliente para um documento do MongoDB. Abaixo está o exemplo, onde este mapeamento seria útil na inserção de um novo documento.
1public class CustomerRepository {
2 private MongoCollection<Document> collection;
3 public CustomerRepository() {
4 MongoClient mongoClient = MongoClients.create("mongodb://localhost:27017");
5 this.collection = mongoClient.getDatabase("mydatabase").getCollection("customers");
6 }
7 public void addCustomer(Customer customer) {
8 Document doc = new Document("id", customer.getId())
9 .append("name", customer.getName())
10 .append("email", customer.getEmail());
11 collection.insertOne(doc);
12 }
13}
E da mesma forma, consultar e atualizar os dados se tornará mais simples. Ao usar o driver Java do MongoDB, você pode trabalhar diretamente com documentos BSON de uma forma que se encaixa naturalmente no modelo POJO do Java.
O exemplo acima mostra que as operações do MongoDB podem ser intuitivas e simples mesmo sem o uso de frameworks. Portanto, esses dados não estruturados são uma boa opção para aplicativos Java.
Esse mapeamento também se mostra útil ao operar nos subdocumentos que estão sendo criados. Por exemplo, se o Cliente também tiver detalhes sobre seus Pedidos, eles serão armazenados como:
1public class Customer {
2 private String id;
3 private String name;
4 private String email;
5 private List<String> Orders;
6 // Constructors, getters, and setters
7}
Aqui, para buscar os pedidos, você não precisa realizar junções complicadas em várias tabelas. O MongoDB permite recuperar dados aninhados ou relacionados diretamente de um documento. Para fazer isso, você pode usar:
1Customer customer = customerCollection.find(Filters.eq("_id", "customerId")).first();
2if (customer != null) {
3 List&<Order> orders = orderCollection.find(Filters.in("_id", customer.getOrders())).into(new ArrayList<>());
4 orders.forEach(order -> System.out.println(order.getProductName()));
5} else {
6 System.out.println("Customer not found");
7}
A estrutura de agregação do MongoDB também permite que você execute queries complexas em grandes volumes de dados não estruturados. Essas operações são otimizadas e reduzem com eficiência os cálculos complexos de várias junções.
O driver Java do MongoDB fornece construtores para realizar manipulação de dados e executar queries nos dados. Esses construtores simplificam o processo de criação de queries complexas do MongoDB em Java, oferecendo uma API clara e encadeável que se assemelha à linguagem natural, facilitando a leitura e a escrita do código.

Consultando dados não estruturados no MongoDB com Java

Nesta seção, forneceremos exemplos práticos de como o driver Java do MongoDB ajuda você a trabalhar com dados não estruturados, além de discutir como utilizar POJOs e construtores. Existem determinados pré-requisitos que você precisa acompanhar, incluindo a configuração necessária e o conhecimento necessário para trabalhar com MongoDB e Java.

Pré-requisitos

  1. Se você ainda não tiver um cluster do Atlas, comece gratuitamente.
  2. Use o mecanismo deimportação para carregar os dados fornecidos como produtoDetalhes.json em seu cluster do Atlas.
  3. Atualize seu driver MongoDB Java para a versão 5.1 ou superior.
  4. Use o Java versão 17 ou superior.

Como os dados não estruturados no MongoDB ajudam no mapeamento de POJOs?

Após carregar os dados em seu cluster do Atlas, seus dados devem ver a seguinte estrutura, que é armazenada no formato BSON (Binary JSON):
1{
2 "_id": {"$oid": "66cc68309ff045b1b411b6ba"},
3 "productName": "Wireless Mouse",
4 "category": "Electronics",
5 "price": 29.99,
6 "stock": 150,
7 "description": "Ergonomic wireless mouse with adjustable DPI settings.",
8 "brand": "TechBrand",
9 "images": [
10 {
11 "url": "https://example.com/images/wireless_mouse_1.jpg",
12 "altText": "Wireless Mouse Top View"
13 },
14 {
15 "url": "https://example.com/images/wireless_mouse_2.jpg",
16 "altText": "Wireless Mouse Side View"
17 }
18 ],
19 "features": "2.4 GHz wireless connectivity, Adjustable DPI from 800 to 1600, Compatible with Windows and macOS",
20 "reviews": [
21 {
22 "customerId": {"$oid": "66cc67443921db64869bcf3d"},
23 "rating": 4.5,
24 "comment": "Great mouse, very comfortable to use!",
25 "date": "2023-03-01T08:45:00Z"
26 }
27 ]
28}
Como o MongoDB armazena dados em um formato semelhante a JSON, os POJOs são particularmente úteis. Eles se alinham intimamente com o modelo de dados orientado a documentos do MongoDB, permitindo um processo de desenvolvimento mais natural e eficiente.
Para nosso exemplo, temos uma classe POJOs criada para Produto, Imagem e Resenhas usando classes de modelo como classeProduto.java, Imagem.javae Resenhas.java respectivamente .
Ter os campos mapeados dentro dos POJOs torna as operações fáceis e eficientes.
Por exemplo, em Main.java, as operações CRUD básicas tornam-se mais simples.
No código abaixo, primeiro tentamos fazer a conexão com o URI do MongoDB Atlas colocando a connection string na variável de ambiente. Você pode seguir a documentação para obter sua connection string.
Na última parte do código, realizamos algumas operações simples, como CRUD (Create, Read, Update, Delete), para operar no banco de dados.
O código completo é fornecido como:
1public static void main(String[] args) {
2 ConnectionString connectionString = new ConnectionString(System.getenv("mongodb.uri"));
3 CodecRegistry pojoCodecRegistry = fromProviders(PojoCodecProvider.builder().automatic(true).build());
4 CodecRegistry codecRegistry = fromRegistries(MongoClientSettings.getDefaultCodecRegistry(), pojoCodecRegistry);
5 MongoClientSettings clientSettings = MongoClientSettings.builder()
6 .applyConnectionString(connectionString)
7 .codecRegistry(codecRegistry)
8 .build();
9 try (MongoClient mongoClient = MongoClients.create(clientSettings)) {
10 MongoDatabase database = mongoClient.getDatabase("ecommerce");
11 MongoCollection<Product> collection = database.getCollection("productDetails", Product.class);
12
13 Product newProduct = new Product();
14 newProduct.setId(new ObjectId());
15 newProduct.setProductName("Wireless Mouse");
16 newProduct.setCategory("Electronics");
17 newProduct.setPrice(29.99);
18 newProduct.setStock(150);
19 newProduct.setDescription("Ergonomic wireless mouse with adjustable DPI settings.");
20 newProduct.setBrand("TechBrand");
21 newProduct.setFeatures("2.4 GHz wireless connectivity, Adjustable DPI from 800 to 1600, Compatible with Windows and macOS");
22
23 List<Image> images = new ArrayList<>();
24 images.add(new Image("https://example.com/images/wireless_mouse_1.jpg", "Wireless Mouse Top View"));
25 images.add(new Image("https://example.com/images/wireless_mouse_2.jpg", "Wireless Mouse Side View"));
26 newProduct.setImages(images);
27
28 List<Reviews> reviews = new ArrayList<>();
29 reviews.add(new Reviews(new ObjectId("66cc67443921db64869bcf3d"), 4.5, "Great mouse, very comfortable to use!", "2024-08-18T19:00:00Z"));
30 newProduct.setReviews(reviews);
31
32 collection.insertOne(newProduct);
33 System.out.println("Inserted product: " + newProduct);
34
35 Product foundProduct = collection.find(Filters.eq("productName", "Wireless Mouse")).first();
36 System.out.println("Found product: " + foundProduct);
37
38 collection.updateOne(Filters.eq("_id", newProduct.getId()), Updates.set("stock", 140));
39 Product updatedProduct = collection.find(Filters.eq("_id", newProduct.getId())).first();
40 System.out.println("Updated product stock: " + updatedProduct.getStock());
41
42 collection.deleteOne(Filters.eq("_id", newProduct.getId()));
43 System.out.println("Deleted product: " + newProduct.getProductName());
44 }
45}

Usando construtores no MongoDB

Os construtores, fornecidos pelo driver Java do MongoDB, simplificam as operações para CRUD básico e também para escrever aggregations complexas. Essas são as classes de utilitários que permitem criar operações complexas de maneira legível e segura de tipo, tornando o código mais expressivo e fácil de manter.
Vamos entender o uso dos construtores por meio de um exemplo de código.
Os construtores de aggregation são construídos usando a classe agregada que fornece o método para criar estágios de pipeline no código Java.
O exemplo fornecido abaixo da classeAggregationBuilder.java mostra como você pode criar um pipeline de agregação simples usando métodos de construtor.
A aggregation abaixo é uma instância para mostrar detalhes do produto para os três principais produtos mais bem avaliados.
1private static void runAverageRatingPipeline(MongoCollection<Product> collection) {
2 AggregateIterable<Product> result = collection.aggregate(Arrays.asList(
3 unwind("$reviews"),
4 group("$_id",
5 avg("averageRating", "$reviews.rating"),
6 first("productName", "$productName"),
7 first("category", "$category"),
8 first("price", "$price"),
9 first("brand", "$brand"),
10 first("stock", "$stock")
11 ),
12 match(gte("averageRating", 4.5)),
13 sort(Sorts.descending("averageRating")),
14 project(fields(
15 excludeId(),
16 include("productName", "category", "price", "brand", "stock")
17 )),
18 limit(3)
19 )
20 );
21
22 System.out.println("High-Rated Products:");
23 for (Product doc : result) {
24 System.out.println(doc.toProductDetails());
25 }
26}
Da mesma forma, o trecho de código abaixo utiliza construtores de atualização para atualizar os registros de coleção.
1private static void updateLowStockProducts(MongoCollection<Product> collection) {
2 collection.updateMany(
3 lt("stock", 50),
4 Updates.inc("stock", 20)
5 );
6
7 System.out.println("Update: Increased stock for products with less than 50 units.");
8}
É assim que os construtores tornam sua vida mais simples e eficiente. Você pode acessar o código completo no repositório doGithub .

Conclusão

Para resumir tudo, a verdade é que os dados estão crescendo a uma taxa sem precedentes e se tornando cada vez mais diversos e desestruturados, e os bancos de dados relacionais tradicionais podem precisar ser revistos. Para desenvolvedores Java familiarizados com a rigidez dos esquemas SQL, o MongoDB oferece uma alternativa revigorante com sua arquitetura sem esquemas e integração natural com o modelo POJO do Java.
Além disso, o esquema dinâmico e a poderosa estrutura de agregação do MongoDB permitem o desenvolvimento rápido e a query complexa sem a sobrecarga de esquemas rígidos.
A incorporação do MongoDB aos seus aplicativos Java não apenas simplifica o gerenciamento de dados, mas também permite que você se adapte rapidamente aos requisitos em constante mudança e ao dimensionamento com facilidade. À medida que o cenário de dados avança, os recursos do MongoDB posicionam você para lidar com os desafios dos dados não estruturados e garantem que seus aplicativos permaneçam robustos e responsivos em um mundo orientado por dados.
Se você quiser saber mais sobre como criar aplicativos em Java e estruturas como Spring Boot e Quartokus, visite o MongoDB Developer Center para obter mais tutoriais interessantes.
Principais comentários nos fóruns
Ainda não há comentários sobre este artigo.
Iniciar a conversa

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Artigo
star-empty
star-empty
star-empty
star-empty
star-empty
Relacionado
Início rápido

Início rápido: tipos de dados BSON - Data


Sep 23, 2022 | 2 min read
Notícias e Anúncios

Laravel Herd adiciona suporte nativo ao MongoDB


Oct 07, 2024 | 0 min read
Início rápido

Java - Mapeamento de POJOs


Mar 01, 2024 | 5 min read
Tutorial

Arquiteturas de dados em tempo real com o MongoDB Cloud Manager e o Verizon 5G Edge


Aug 28, 2024 | 8 min read
Sumário