PrimeFaces + Spring Data + MongoDB-Integration

Dieses Tutorial führt Sie durch die Integration verschiedener Frameworks wie PrimeFaces, Spring Data und MongoDB. In unseren vorherigen Tutorials haben wir mehr über die einzelnen Themen PrimeFaces, Spring Data und MongoDB erklärt. Hier ein einfaches Beispiel für die Verwendung des Registrierungsformulars, bei dem die Details schließlich in der MongoDB-Datenbank gespeichert werden.

1. Java Bean

Die in diesem Beispiel verwendeten Entitäten sind Adresse und Mitarbeiter.

Adresse.java

package net.javabeat.springdata.jpa.data;

import java.math.BigInteger;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document
public class Address {
	@Id
	private BigInteger id;
	private String addressCountry;
	private String addressCity;

	public BigInteger getId() {
		return id;
	}
	public void setId(BigInteger 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.jpa.data;

import java.math.BigInteger;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection="employee")
public class Employee {
	@Id
	private BigInteger id;
	private String employeeName;
	private Address address = new Address();

	public BigInteger getId() {
		return id;
	}
	public void setId(BigInteger 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;
	}
}

2. Spring-Konfigurationen (MongoDB konfigurieren)

In diesem Schritt müssen Sie die Federkonfiguration für die Konfiguration schreiben MongoDB-Datenbank und definieren Sie auch die Bohnen im Federbehälter. Außerdem müssen wir die Spring-Datenrepositorys hinzufügen.

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">

    <!-- Spring Beans -->
    <context:component-scan base-package="net.javabeat.springdata.beans.*"></context:component-scan>

	<!-- 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>

3. Spring Data Repository

Spring Data definiert abstrakt Repositories die um Ihre Implementierungsgeschäftsdomäne erweitert werden muss. Beachten Sie, dass Sie keine der Methoden implementieren müssen, Spring Data selbst erstellt zur Laufzeit eine Implementierung. Das ist der große Vorteil der Verwendung der Federdaten für die Datenbankanwendungen. Wenn Sie mehr über dieses Thema erfahren möchten, finden Sie hier eine Liste mit Artikeln zu diesem Thema Frühlingsdaten.

EmployeeRepository.java

package net.javabeat.springdata.repo;

import java.math.BigInteger;

import net.javabeat.springdata.jpa.data.Employee;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface EmployeeRepository extends CrudRepository&lt;Employee, BigInteger&gt;{}

4. Spring Bean Service

RegistrationService.java

package net.javabeat.springdata.beans;

import net.javabeat.springdata.repo.EmployeeRepository;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RegistrationService {
	@Autowired
	private EmployeeRepository repository;

	public RegistrationService(){

	}

	public EmployeeRepository getRepository() {
		return repository;
	}

	public void setRepository(EmployeeRepository repository) {
		this.repository = repository;
	}
}

5. PrimeFaces / JSF-Konfigurationen

Eine weitere Konfiguration, die wir zum Ausführen dieses Beispiels benötigen, ist die Definition der Java Server Faces (JSF)-Konfigurationsdatei. Wir verwenden die PrimeFaces als Ansichtsebene.

faces-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<faces-config xmlns="http://xmlns.jcp.org/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-facesconfig_2_2.xsd"
	version="2.2">
<application>
	<resource-bundle>
		<base-name>net.javabeat.jsf.application</base-name>
		<var>msg</var>
	</resource-bundle>
	<el-resolver>org.springframework.web.jsf.el.SpringBeanFacesELResolver</el-resolver>
</application>
</faces-config>

6. Von PrimeFaces verwaltete Bean

RegistrationManagedBean.java

package net.javabeat.primefaces.managedbeans;

import java.util.ArrayList;
import java.util.List;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.SessionScoped;

import net.javabeat.springdata.beans.RegistrationService;
import net.javabeat.springdata.jpa.data.Employee;

import com.google.common.collect.Lists;

@ManagedBean
@SessionScoped
public class RegistrationManagedBean {

	private Employee employee = new Employee();

	private List&lt;Employee&gt; employees = new ArrayList&lt;Employee&gt;();

	@ManagedProperty(value=&quot;#{registrationService}&quot;)
	private RegistrationService service;

	public Employee getEmployee() {
		return employee;
	}

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

	public List&lt;Employee&gt; getEmployees() {
		this.employees = Lists.newArrayList(this.service.getRepository().findAll());
		return employees;
	}

	public void setEmployees(List&lt;Employee&gt; employees) {
		this.employees = employees;
	}

	public RegistrationService getService() {
		return service;
	}

	public void setService(RegistrationService service) {
		this.service = service;
	}

	public String register(){
		this.service.getRepository().save(employee);
		this.employee = new Employee();
		return &quot;&quot;;
	}
}

7. Web-Bereitstellungsdeskriptor

Es ist der Web-Bereitstellungsdeskriptor (web.xml), der zum Ausführen dieser Beispiel-Webanwendung verwendet wird. Es hat das
web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" metadata-complete="true" version="2.5">

  <context-param>
    <description>State saving method: 'client' or 'server'
						(=default). See JSF Specification 2.5.2
		</description>
    <param-name>javax.faces.STATE_SAVING_METHOD</param-name>
    <param-value>server</param-value>
  </context-param>

  <context-param>
    <param-name>javax.faces.application.CONFIG_FILES</param-name>
    <param-value>/WEB-INF/faces-config.xml</param-value>
  </context-param>

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/spring-config/*.xml</param-value>
  </context-param>

  <servlet>
    <servlet-name>Faces Servlet</servlet-name>
    <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>Faces Servlet</servlet-name>
    <url-pattern>/faces/*</url-pattern>
  </servlet-mapping>

  <servlet-mapping>
    <servlet-name>Faces Servlet</servlet-name>
    <url-pattern>*.xhtml</url-pattern>
  </servlet-mapping>

  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <listener>
    <listener-class>com.sun.faces.config.ConfigureListener</listener-class>
  </listener>
</web-app>

8. Die Aussicht

Hier ist die PrimeFaces-Ansicht, die in diesem Beispiel verwendet wird.

index.xhtml

<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:ui="http://java.sun.com/jsf/facelets"
	xmlns:h="http://java.sun.com/jsf/html"
	xmlns:f="http://java.sun.com/jsf/core"
	xmlns:p="http://primefaces.org/ui">
	<h:head>
		<script name="jquery/jquery.js" library="primefaces"></script>
	</h:head>
	<f:view>
		<h:form prependId="false">
			<h:panelGrid columns="2">
				<h:outputText value="Enter Employee Name:"/>
				<p:inputText value="#{registrationManagedBean.employee.employeeName}"></p:inputText>
				<h:outputText value="Enter Employee Address Country:"/>
				<p:inputText value="#{registrationManagedBean.employee.address.addressCountry}"></p:inputText>
				<h:outputText value="Enter Employee Address City:"/>
				<p:inputText value="#{registrationManagedBean.employee.address.addressCity}"></p:inputText>
			</h:panelGrid>
			<p:commandButton value="Register" action="#{registrationManagedBean.register}" ajax="false"/>
			<p:separator/>
			<h:panelGrid columns="1">
				<p:dataTable value="#{registrationManagedBean.employees}" var="employee">
					<p:column headerText="Employee's Name">
						<h:outputText value="#{employee.employeeName}"/>
					</p:column>
					<p:column headerText="Employee's Country">
						<h:outputText value="#{employee.address.addressCountry}"/>
					</p:column>
					<p:column headerText="Employee's City">
						<h:outputText value="#{employee.address.addressCity}"/>
					</p:column>
				</p:dataTable>
			</h:panelGrid>
		</h:form>
	</f:view>
</html>

9. Primefaces + Spring Data + MongoDB-Demo

Primefaces + Spring Data + MongoDB Beispiel 1

MongoDB + PrimeFaces RegisterEmployees

9. Datenbankeinträge

Es handelt sich um die Momentaufnahme der Datenbankeinträge nach der Ausführung des oben genannten Programms.

Persistierte MongoDB-Datensätze

(wpdm_file id=92)

Kommentar verfassen

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

Nach oben scrollen