Spring Data REST Exporter

Dieses Tutorial enthält detaillierte Anweisungen zur Verwendung des Spring Data REST-Projekts in Ihren Spring MVC-Anwendungen zum Exportieren Ihrer JPA-Entitäten. Der größte Vorteil der Verwendung von Spring Data REST Das liegt daran, dass die Entitäten problemlos exportiert und über das HTTP-Protokoll verfügbar gemacht werden können.

Mit dem Spring Data REST-Repository-Exportprojekt können Sie diese verwalteten Entitäten jetzt über einen REST-Webdienst exportieren, um einfach mit den Daten zu interagieren. Der Exportmechanismus stellt eine Ressource transparent pro Repository bereit, ordnet CRUD-Vorgänge HTTP-Methoden für diese Ressource zu und bietet die Möglichkeit, die auf der Repository-Schnittstelle bereitgestellten Abfragemethoden auszuführen.

Aber bevor es losgeht Spring Data Exporter , ist es wichtig, das REST-Konzept zu verstehen. Außerdem ist es wichtig zu wissen, dass dieses Tutorial versuchen wird, das Konzept von REST zu vereinfachen, indem es Folgendes berücksichtigt Frühlingsstiefel zur Implementierung einer eigenständigen Spring-MVC-Anwendung.

1. RUHE

REST steht für Representational State Transfer (REST) ​​und ist ein Architekturstil. Es handelt sich um eine Verallgemeinerung der Prinzipien des HTTP-Protokolls, aus denen die folgenden Kernkonzepte abgeleitet werden:

  • Ressourcen: Systeme stellen Ressourcen für andere Systeme bereit: einen Mitarbeiter, eine Adresse usw.
  • Identifikatoren: Diese Ressourcen können über einen Identifikator adressiert werden. In der HTTP-Welt sind diese Bezeichner URIs
  • Verben: Auf jede Ressource kann über einen genau definierten Satz von Verben zugegriffen und sie manipuliert werden. Die im HTTP am häufigsten verwendeten Verben sind GET, POST, DELETE, HEAD und OPTIONS.
  • Vertretungen: Ein Client interagiert nie direkt mit der Ressource, sondern über deren Darstellung. Wie Sie in diesem Tutorial sehen werden, sollte JSON zur Darstellung der Ressourcen verwendet werden.

2. Persistenzeinheiten

Für diese Tutorials verwenden wir die Persistenzentität „Mitarbeiter“ und „Adresse“. Schauen wir uns die Implementierung dieser Entitäten und deren Modellierung im Datenbankschema an. Beachten Sie, dass dieses Beispiel verwendet Java Persistence API (JPA) für den Unternehmensexporteur. Wir können jeden anderen von Spring Data Rest unterstützten Persistenzanbieter zum Exportieren der Entitäten verwenden. Die einzige Veränderung wird sein Persistenz-Repository.

Employee.java

package net.javabeat.springdata.jpa.data;

import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;

@Entity
public class Employee {

	@Id
	private Integer employeeId;

	@Basic(optional = false)
	private String employeeName;

	@OneToOne(cascade = CascadeType.ALL)
	@JoinColumn(name = "Address")
	private Address address;

	public Address getAddress() {
		return address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}

	public Integer getEmployeeId() {
		return employeeId;
	}

	public void setEmployeeId(Integer employeeId) {
		this.employeeId = employeeId;
	}

	public String getEmployeeName() {
		return employeeName;
	}

	public void setEmployeeName(String employeeName) {
		this.employeeName = employeeName;
	}

	public boolean equals(Object obj){
		if(obj instanceof Employee){
			Employee emp = (Employee)obj;
			if(this.employeeId == emp.employeeId){
				return true;
			}
		}
		return false;
	}

	public int hashCode(){
		return this.employeeId;
	}

}

Adresse.java

package net.javabeat.springdata.jpa.data;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity(name = "address")
public class Address {
	@Id
	private Integer addressId;
	private String addressCountry;
	private String addressCity;

	@OneToOne(cascade = CascadeType.ALL, mappedBy = "address")
	private Employee employee;

	public Employee getEmployee() {
		return employee;
	}

	public void setEmployee(Employee employee) {
		this.employee = employee;
	}

	public int getAddressId() {
		return addressId;
	}

	public void setAddressId(int addressId) {
		this.addressId = addressId;
	}

	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;
	}
}

Zur Vereinfachung haben wir das Datenbankschema-Design bereitgestellt, das Ihnen beim Schreiben des Beispiels hilft. Sie können auch den Beispielquellcode am Ende dieses Tutorials herunterladen.

Mitarbeitertisch

Fremdschlüssel des Mitarbeiters

Adresstabelle

3. JPA-Kontextkonfigurationen

Hier ist der Persistenzkontext, der für dieses Tutorial verwendet wird. Diese Konfigurationsdatei enthält Konfigurationsdetails für den MYSQL-Datenbanktreiber und die oben genannten Persistenzeinheiten.

persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
	<persistence-unit name="SpringData" transaction-type="RESOURCE_LOCAL">
		<class>net.javabeat.springdata.jpa.data.Employee</class>
		<class>net.javabeat.springdata.jpa.data.Address</class>
		<properties>
			<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/JavaBeat" />
			<property name="javax.persistence.jdbc.user" value="root" />
			<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
			<property name="javax.persistence.jdbc.password" value="root" />
			<property name="eclipselink.logging.level" value="OFF" />
		</properties>
	</persistence-unit>
</persistence>

4. Kontextkonfigurationen für Spring-Anwendungen

Hier ist die Spring-Kontextkonfiguration für dieses Beispiel. Weitere Informationen zu den Konfigurationen finden Sie im Tutorial zu Spring Data – JPA.

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:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:util="http://www.springframework.org/schema/util" xmlns:jpa="http://www.springframework.org/schema/data/jpa" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">

	<!-- 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 bootstrapping the Spring Repository -->
	<jpa:repositories base-package="net.javabeat.springdata.repo" />

	<!-- Necessary to get the entity manager injected into the factory bean -->
	<bean   />

	<!-- Define EclipseLink JPA Vendor Adapter -->
	<bean id="jpaVendorAdapter"  >
		<property name="databasePlatform" value="org.eclipse.persistence.platform.database.MySQLPlatform" />
		<property name="generateDdl" value="false" />
		<property name="showSql" value="true" />
	</bean>

	<!-- Entity Manager Factory -->
	<bean id="entityManagerFactory"  >
		<property name="persistenceUnitName" value="SpringData"></property>
		<property name="jpaVendorAdapter" ref="jpaVendorAdapter" />
	</bean>

	<!-- Transaction Manager -->
	<bean id="transactionManager"  >
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>

	<!-- Enable Transactional Manner -->
	<tx:annotation-driven transaction-manager="transactionManager" />

</beans>

5. Spring REST-Repositorys

Um Ihre Repositorys als REST verfügbar zu machen, müssen Sie die Repositorys mithilfe von definieren @RepositoryRestResource Anmerkung.

EmployeeRepository.java

package net.javabeat.springdata.repo;

import net.javabeat.springdata.jpa.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, Integer>{}

AddressRepository.java

package net.javabeat.springdata.repo;

import net.javabeat.springdata.jpa.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,Integer>{}

6. Maven-Abhängigkeiten für Spring Data Rest

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-JPA</artifactId>
	<version>1.0</version>
	<packaging>jar</packaging>
	<name>Spring Data</name>
	<!-- Inherit defaults from Spring Boot -->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.0.2.RELEASE</version>
	</parent>
	<dependencies>
		<!-- Dependencies for Eclipse JPA Persistence API -->
		<dependency>
			<groupId>org.eclipse.persistence</groupId>
			<artifactId>eclipselink</artifactId>
			<version>2.5.0-RC1</version>
			<exclusions>
				<exclusion>
					<groupId>org.eclipse.persistence</groupId>
					<artifactId>commonj.sdo</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<!-- Dependency for MySql Java connector -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		<!-- Spring Data Dependency -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-jpa</artifactId>
		</dependency>
		<!-- Dependency for REST Exporter -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-rest-webmvc</artifactId>
		</dependency>
		<!-- Required Spring Boot Web Application Dependency -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- Required Spring Boot JPA Dependency -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
	</dependencies>
</project>

7. Beispielanwendung für den Spring Data REST Exporter

Diese Beispielanwendung wird mit der Spring Boot-Anwendung ausgeführt. Wenn Sie die Tomcat-Laufzeitumgebung auf Ihrem Computer haben, werden im folgenden Beispiel die Tomcat- und Spring-MVC-Anwendungen eingebettet.

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.jpa.repository.config.EnableJpaRepositories;
import org.springframework.data.rest.webmvc.config.RepositoryRestMvcConfiguration;

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

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

8. Ausführen der Anwendung

Sie können jetzt über den Browser auf den Spring Data Rest zugreifen, der als REST-Dienste angezeigt wird.

Adress-Repository

Greifen Sie auf Spring-Repositories zu

Mitarbeiter-Repository

9. Zusammenfassung

Spring Data bietet dem Spring Developer die Möglichkeit, REST-Webdienste für bereits benutzerdefinierte CRUD-Repositorys zu erstellen. Dieser Dienst ist auf die CRUD-Repositorys beschränkt, in den nächsten Versionen sollten jedoch auch andere Arten von Repositorys unterstützt werden.

Laden Sie den Quellcode herunter

  • Laden Sie den Quellcode herunter

Kommentar verfassen

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

Nach oben scrollen