Spring Data + MongoDB + REST-Shell-Integration

Dieses Tutorial führt Sie durch ein Beispiel zum Verständnis der Integration zwischen Spring Data, Spring REST und MongoDB. Wie Sie das verwenden werden Ruheschale zum Erreichen verschiedener Operationen gegen die Datenbank. Entitäten werden in MongoDB in der Form gespeichert, in der eine äußere Entität einen Verweis auf die innere speichert. Im Gegensatz zu den meisten Beispielen, die hier in früheren Tutorials veröffentlicht wurden. Außerdem sehen Sie die Integration von Spring Boot zur Initialisierung eines eingebetteten Apache Tomcat.

Lesen Sie auch:

  • Spring Roo + Spring Data JPA-Repositories + Eclipse-Integration
  • Spring Data JPA + Querydsl
  • Spring Data + MongoDB

1. Erforderliche Werkzeuge

Die erforderlichen Plattformen und Umgebungen für dieses Tutorial:

  • JDK 1.7.
  • Maven 3.2.1.
  • Eclipse-IDE Kepler 4.3.
  • Frühlingsdaten
  • MongoDB

2. Java Beans (Entitäten)

Zur Definition der Geschäftsdomäne werden die Entitäten „Adresse“ und „Mitarbeiter“ verwendet.

Adresse.java

package net.javabeat.springdata.data;

import javax.persistence.Id;

import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

@Document(collection="Address")
public class Address {
	@Id
	@Field
	private String id;
	@Field
	private String addressCountry = "";
	@Field
	private String addressCity = "";

	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getAddressCountry() {
		return addressCountry;
	}
	public void setAddressCountry(String addressCountry) {
		this.addressCountry = addressCountry;
	}
	public String getAddressCity() {
		return addressCity;
	}
	public void setAddressCity(String addressCity) {
		this.addressCity = addressCity;
	}
}

Employee.java

package net.javabeat.springdata.data;

import javax.persistence.Id;

import org.springframework.data.mongodb.core.mapping.DBRef;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

@Document(collection="Employee")
public class Employee {
	@Id
	@Field
	private String id;
	@Field
	private String employeeName;
	@DBRef
	private Address address;

	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getEmployeeName() {
		return employeeName;
	}
	public void setEmployeeName(String employeeName) {
		this.employeeName = employeeName;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
}

3. Spring-Datenrepositorys

Es sind die Spring-Datenrepositorys, die für die Kommunikation mit der MongoDB für jede CRUD-Operation verwendet werden.

AddressRepository.java

package net.javabeat.springdata.repo;

import net.javabeat.springdata.data.Address;

import org.springframework.data.repository.CrudRepository;
import org.springframework.data.rest.core.annotation.RepositoryRestResource;

@RepositoryRestResource(collectionResourceRel="address",path="address")
public interface AddressRepository extends CrudRepository<Address,String>{
}

EmployeeRepository.java

package net.javabeat.springdata.repo;

import net.javabeat.springdata.data.Employee;

import org.springframework.data.repository.CrudRepository;
import org.springframework.data.rest.core.annotation.RepositoryRestResource;

@RepositoryRestResource(collectionResourceRel="employee",path="employee")
public interface EmployeeRepository extends CrudRepository<Employee, String>{
}

4. Spring-Kontextkonfiguration

Hier ist die erforderliche Spring-Kontextkonfiguration für die Kommunikation mit der MongoDB.

SpringContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mongo="http://www.springframework.org/schema/data/mongo"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

	<!-- Register Mongo Instance -->
	<mongo:mongo id="mongo" host="localhost" port="27017" />
	<!--  for defining mongo template -->
	<bean id="mongoTemplate"  >
		<constructor-arg ref="mongo" />
		<constructor-arg name="databaseName" value="JavaBeat" />
	</bean>

	<!-- For consider the using of annotations foe defining Spring Bean -->
	<context:annotation-config />

	<!-- For defining Spring Bean -->
	<context:component-scan base-package="net.javabeat.springdata.beans" />
	<!-- For defining mongo repository -->
	<mongo:repositories base-package="net.javabeat.springdata.repo" />

</beans>

5. Ausführbare Anwendung

Diese eigenständige Spring-Boot-Anwendung startet diese Beispielanwendung.

Ausführbare Datei.java

package net.javabeat.springdata.executable;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;
import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;
import org.springframework.data.rest.webmvc.config.RepositoryRestMvcConfiguration;

@Configuration
@EnableMongoRepositories
@Import(RepositoryRestMvcConfiguration.class)
@ImportResource("classpath:SpringContext.xml")
@EnableAutoConfiguration
public class Executable {

	public static void main(String() args) {
		SpringApplication.run(Executable.class, args);
	}
}

6. Maven-Abhängigkeiten

Es sind die Maven-Bibliotheken, die die erforderlichen Bibliotheken für die vorgeschlagene Kommunikation mit der MongoDB über Spring REST definieren.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>net.javabeat.springdata</groupId>
	<artifactId>SpringData-MongoDB-REST</artifactId>
	<version>1.0</version>
	<packaging>jar</packaging>

	<name>Spring Data</name>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.0.2.RELEASE</version>
	</parent>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

	<dependencies>

		<!-- Dependency for Spring Boot -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-rest-core</artifactId>
			<version>2.0.2.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-mongodb</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-rest-webmvc</artifactId>
		</dependency>
	</dependencies>

</project>

7. Installieren Sie die REST-Shell

Rest Shell ist die native Engine, die von Spring bereitgestellt wird und von heruntergeladen werden kann Hier. Nachdem Sie die Shell heruntergeladen haben, können Sie sie an jedem von Ihnen vorgeschlagenen Speicherort entpacken.

Öffnen Sie die Befehlszeile, navigieren Sie zum entpackten Speicherort, den Sie zuvor ausgewählt haben, und geben Sie in die Befehlszeile ein Ruheschale und drücken Sie die Eingabetaste. Stellen Sie sicher, dass Ihre Anwendung betriebsbereit ist, bevor Sie die Shell weiter verwenden.

Rest-Shell wird gestartet

8. MongoDB + Spring Data Repository + Spring REST Demo

In dieser Demonstration wurde eine Reihe von Snapshots zur Verdeutlichung der Vorgänge READ, PERSIST und DELETE verwendet.

Listen Sie alle Sammlungen in MongoDB auf

Adresse folgen – Adresse von ID 1 abrufen

Dem Mitarbeiter folgen – den Mitarbeiter mit der ID 1 erhalten

Erstellen Sie einen Mitarbeiter und verknüpfen Sie ihn mit der bereits erstellten Adressentität

Liste der Adressen

Listen Sie alle Mitarbeiter auf

9. MongoDB-Sammlungen

Datenbank-Adressdatensätze

Datenbank-Mitarbeiterdatensätze

10. Zugriff über HTTP

Liste der HTTP-Mitarbeiter

11. Zusammenfassung

Herzlichen Glückwunsch, Sie haben gerade eine Anwendung entwickelt, die Spring REST verwendet, um erfolgreiche Operationen gegen MongoDB durchzuführen.

Laden Sie den Quellcode herunter

(wpdm_file id=100)

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen