iSharkFly-Docs
/
java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #2 from eugenp/master 

Merge upstream to local
This commit is contained in:
Alex Theedom 2016-06-07 01:06:41 +03:00
parent 2f5f965ff2 49c9072564
commit 42ce4d4020
50 changed files with 1972 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
core-java-8/src/main/java/com/baeldung/datetime/UseDuration.java Normal file
View File

@ -0,0 +1,16 @@
package com.baeldung.datetime;
import java.time.Duration;
import java.time.LocalTime;
import java.time.Period;
public class UseDuration {
public LocalTime modifyDates(LocalTime localTime,Duration duration){
return localTime.plus(duration);
}
public Duration getDifferenceBetweenDates(LocalTime localTime1,LocalTime localTime2){
return Duration.between(localTime1, localTime2);
}
}

46
core-java-8/src/main/java/com/baeldung/datetime/UseLocalDate.java Normal file
View File

@ -0,0 +1,46 @@
package com.baeldung.datetime;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
public class UseLocalDate {
public LocalDate getLocalDateUsingFactoryOfMethod(int year, int month, int dayOfMonth){
return LocalDate.of(year, month, dayOfMonth);
}
public LocalDate getLocalDateUsingParseMethod(String representation){
return LocalDate.parse(representation);
}
public LocalDate getLocalDateFromClock(){
LocalDate localDate = LocalDate.now();
return localDate;
}
public LocalDate getNextDay(LocalDate localDate){
return localDate.plusDays(1);
}
public LocalDate getPreviousDay(LocalDate localDate){
return localDate.minus(1, ChronoUnit.DAYS);
}
public DayOfWeek getDayOfWeek(LocalDate localDate){
DayOfWeek day = localDate.getDayOfWeek();
return day;
}
public LocalDate getFirstDayOfMonth(){
LocalDate firstDayOfMonth = LocalDate.now().with(TemporalAdjusters.firstDayOfMonth());
return firstDayOfMonth;
}
public LocalDateTime getStartOfDay(LocalDate localDate){
LocalDateTime startofDay = localDate.atStartOfDay();
return startofDay;
}
}

11
core-java-8/src/main/java/com/baeldung/datetime/UseLocalDateTime.java Normal file
View File

@ -0,0 +1,11 @@
package com.baeldung.datetime;
import java.time.LocalDateTime;
public class UseLocalDateTime {
public LocalDateTime getLocalDateTimeUsingParseMethod(String representation){
return LocalDateTime.parse(representation);
}
}

35
core-java-8/src/main/java/com/baeldung/datetime/UseLocalTime.java Normal file
View File

@ -0,0 +1,35 @@
package com.baeldung.datetime;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;
public class UseLocalTime {
public LocalTime getLocalTimeUsingFactoryOfMethod(int hour, int min, int seconds){
LocalTime localTime = LocalTime.of(hour, min, seconds);
return localTime;
}
public LocalTime getLocalTimeUsingParseMethod(String timeRepresentation){
LocalTime localTime = LocalTime.parse(timeRepresentation);
return localTime;
}
public LocalTime getLocalTimeFromClock(){
LocalTime localTime = LocalTime.now();
return localTime;
}
public LocalTime addAnHour(LocalTime localTime){
LocalTime newTime = localTime.plus(1,ChronoUnit.HOURS);
return newTime;
}
public int getHourFromLocalTime(LocalTime localTime){
return localTime.getHour();
}
public LocalTime getLocalTimeWithMinuteSetToValue(LocalTime localTime, int minute){
return localTime.withMinute(minute);
}
}

15
core-java-8/src/main/java/com/baeldung/datetime/UsePeriod.java Normal file
View File

@ -0,0 +1,15 @@
package com.baeldung.datetime;
import java.time.LocalDate;
import java.time.Period;
public class UsePeriod {
public LocalDate modifyDates(LocalDate localDate,Period period){
return localDate.plus(period);
}
public Period getDifferenceBetweenDates(LocalDate localDate1,LocalDate localDate2){
return Period.between(localDate1, localDate2);
}
}

19
core-java-8/src/main/java/com/baeldung/datetime/UseToInstant.java Normal file
View File

@ -0,0 +1,19 @@
package com.baeldung.datetime;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Calendar;
import java.util.Date;
public class UseToInstant {
public LocalDateTime convertDateToLocalDate(Date date){
LocalDateTime localDateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
return localDateTime;
}
public LocalDateTime convertDateToLocalDate(Calendar calendar){
LocalDateTime localDateTime = LocalDateTime.ofInstant(calendar.toInstant(), ZoneId.systemDefault());
return localDateTime;
}
}

13
core-java-8/src/main/java/com/baeldung/datetime/UseZonedDateTime.java Normal file
View File

@ -0,0 +1,13 @@
package com.baeldung.datetime;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class UseZonedDateTime {
public ZonedDateTime getZonedDateTime(LocalDateTime localDateTime,ZoneId zoneId){
ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, zoneId);
return zonedDateTime;
}
}

55
core-java-8/src/test/java/com/baeldung/datetime/UseLocalDateTest.java Normal file
View File

@ -0,0 +1,55 @@
package com.baeldung.datetime;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;
import org.junit.Assert;
import org.junit.Test;
public class UseLocalDateTest {
UseLocalDate useLocalDate = new UseLocalDate();
@Test
public void givenValues_whenUsingFactoryOf_thenLocalDate(){
Assert.assertEquals("2016-05-10",useLocalDate.getLocalDateUsingFactoryOfMethod(2016,5,10).toString());
}
@Test
public void givenString_whenUsingParse_thenLocalDate(){
Assert.assertEquals("2016-05-10",useLocalDate.getLocalDateUsingParseMethod("2016-05-10").toString());
}
@Test
public void whenUsingClock_thenLocalDate(){
Assert.assertEquals(LocalDate.now(),useLocalDate.getLocalDateFromClock());
}
@Test
public void givenDate_whenUsingPlus_thenNextDay(){
Assert.assertEquals(LocalDate.now().plusDays(1),useLocalDate.getNextDay(LocalDate.now()));
}
@Test
public void givenDate_whenUsingMinus_thenPreviousDay(){
Assert.assertEquals(LocalDate.now().minusDays(1),useLocalDate.getPreviousDay(LocalDate.now()));
}
@Test
public void givenToday_whenUsingGetDayOfWeek_thenDayOfWeek(){
Assert.assertEquals(DayOfWeek.SUNDAY,useLocalDate.getDayOfWeek(LocalDate.parse("2016-05-22")));
}
@Test
public void givenToday_whenUsingWithTemporalAdjuster_thenFirstDayOfMonth(){
Assert.assertEquals(1,useLocalDate.getFirstDayOfMonth().getDayOfMonth());
}
@Test
public void givenLocalDate_whenUsingAtStartOfDay_thenReturnMidnight(){
Assert.assertEquals(LocalDateTime.parse("2016-05-22T00:00:00"),useLocalDate.getStartOfDay(LocalDate.parse("2016-05-22")));
}
}

19
core-java-8/src/test/java/com/baeldung/datetime/UseLocalDateTimeTest.java Normal file
View File

@ -0,0 +1,19 @@
package com.baeldung.datetime;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Month;
import org.junit.Assert;
import org.junit.Test;
public class UseLocalDateTimeTest {
UseLocalDateTime useLocalDateTime = new UseLocalDateTime();
@Test
public void givenString_whenUsingParse_thenLocalDateTime(){
Assert.assertEquals(LocalDate.of(2016, Month.MAY, 10),useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalDate());
Assert.assertEquals(LocalTime.of(6,30),useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalTime());
}
}

36
core-java-8/src/test/java/com/baeldung/datetime/UseLocalTimeTest.java Normal file
View File

@ -0,0 +1,36 @@
package com.baeldung.datetime;
import java.time.LocalTime;
import org.junit.Assert;
import org.junit.Test;
public class UseLocalTimeTest {
UseLocalTime useLocalTime = new UseLocalTime();
@Test
public void givenValues_whenUsingFactoryOf_thenLocalTime(){
Assert.assertEquals("07:07:07",useLocalTime.getLocalTimeUsingFactoryOfMethod(7,7,7).toString());
}
@Test
public void givenString_whenUsingParse_thenLocalTime(){
Assert.assertEquals("06:30",useLocalTime.getLocalTimeUsingParseMethod("06:30").toString());
}
@Test
public void givenTime_whenAddHour_thenLocalTime(){
Assert.assertEquals("07:30",useLocalTime.addAnHour(LocalTime.of(6,30)).toString());
}
@Test
public void getHourFromLocalTime(){
Assert.assertEquals(1, useLocalTime.getHourFromLocalTime(LocalTime.of(1,1)));
}
@Test
public void getLocalTimeWithMinuteSetToValue(){
Assert.assertEquals(LocalTime.of(10, 20), useLocalTime.getLocalTimeWithMinuteSetToValue(LocalTime.of(10,10), 20));
}
}

29
core-java-8/src/test/java/com/baeldung/datetime/UsePeriodTest.java Normal file
View File

@ -0,0 +1,29 @@
package com.baeldung.datetime;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import org.junit.Assert;
import org.junit.Test;
public class UsePeriodTest {
UsePeriod usingPeriod=new UsePeriod();
@Test
public void givenPeriodAndLocalDate_thenCalculateModifiedDate(){
Period period = Period.ofDays(1);
LocalDate localDate = LocalDate.parse("2007-05-10");
Assert.assertEquals(localDate.plusDays(1),usingPeriod.modifyDates(localDate, period));
}
@Test
public void givenDates_thenGetPeriod(){
LocalDate localDate1 = LocalDate.parse("2007-05-10");
LocalDate localDate2 = LocalDate.parse("2007-05-15");
Assert.assertEquals(Period.ofDays(5), usingPeriod.getDifferenceBetweenDates(localDate1, localDate2));
}
}

20
core-java-8/src/test/java/com/baeldung/datetime/UseZonedDateTimeTest.java Normal file
View File

@ -0,0 +1,20 @@
package com.baeldung.datetime;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import org.junit.Assert;
import org.junit.Test;
public class UseZonedDateTimeTest {
UseZonedDateTime zonedDateTime=new UseZonedDateTime();
@Test
public void givenZoneId_thenZonedDateTime(){
ZoneId zoneId=ZoneId.of("Europe/Paris");
ZonedDateTime zonedDatetime=zonedDateTime.getZonedDateTime(LocalDateTime.parse("2016-05-20T06:30"), zoneId);
Assert.assertEquals(zoneId,ZoneId.from(zonedDatetime));
}
}

16
jsf/pom.xml
View File

@ -90,12 +90,21 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<version>${maven-compiler-plugin.version}</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>${maven-war-plugin.version}</version>
<configuration>
<failOnMissingWebXml>false</failOnMissingWebXml>
</configuration>
</plugin>
</plugins>
</build>
@ -112,5 +121,10 @@
<!--Tomcat-->
<javax.servlet.version>3.1.0</javax.servlet.version>
<!-- maven plugins -->
<maven-compiler-plugin.version>3.5.1</maven-compiler-plugin.version>
<maven-war-plugin.version>2.6</maven-war-plugin.version>
</properties>
</project>

15
spring-all/src/main/java/org/baeldung/scopes/HelloMessageGenerator.java Normal file
View File

@ -0,0 +1,15 @@
package org.baeldung.scopes;
public class HelloMessageGenerator {
private String message;
public String getMessage() {
return message;
}
public void setMessage(final String message) {
this.message = message;
}
}

27
spring-all/src/main/java/org/baeldung/scopes/Person.java Normal file
View File

@ -0,0 +1,27 @@
package org.baeldung.scopes;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(final String name, final int age) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
@Override
public String toString() {
return "Person [name=" + name + "]";
}
}

31
spring-all/src/main/java/org/baeldung/scopes/ScopesController.java Normal file
View File

@ -0,0 +1,31 @@
package org.baeldung.scopes;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class ScopesController {
public static final Logger LOG = Logger.getLogger(ScopesController.class);
@Resource(name = "requestMessage")
HelloMessageGenerator requestMessage;
@Resource(name = "sessionMessage")
HelloMessageGenerator sessionMessage;
@RequestMapping("/scopes")
public String getScopes(final Model model) {
LOG.info("Request Message:" + requestMessage.getMessage());
LOG.info("Session Message" + sessionMessage.getMessage());
requestMessage.setMessage("Good morning!");
sessionMessage.setMessage("Good afternoon!");
model.addAttribute("requestMessage", requestMessage.getMessage());
model.addAttribute("sessionMessage", sessionMessage.getMessage());
return "scopesExample";
}
}

57
spring-all/src/main/java/org/baeldung/spring/config/ScopesConfig.java Normal file
View File

@ -0,0 +1,57 @@
package org.baeldung.spring.config;
import org.baeldung.scopes.HelloMessageGenerator;
import org.baeldung.scopes.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.view.JstlView;
import org.springframework.web.servlet.view.UrlBasedViewResolver;
@Configuration
@ComponentScan("org.baeldung.scopes")
@EnableWebMvc
public class ScopesConfig {
@Bean
public UrlBasedViewResolver setupViewResolver() {
final UrlBasedViewResolver resolver = new UrlBasedViewResolver();
resolver.setPrefix("/WEB-INF/view/");
resolver.setSuffix(".jsp");
resolver.setViewClass(JstlView.class);
return resolver;
}
@Bean
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public HelloMessageGenerator requestMessage() {
return new HelloMessageGenerator();
}
@Bean
@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public HelloMessageGenerator sessionMessage() {
return new HelloMessageGenerator();
}
@Bean
@Scope(value = WebApplicationContext.SCOPE_GLOBAL_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public HelloMessageGenerator globalSessionMessage() {
return new HelloMessageGenerator();
}
@Bean
@Scope("prototype")
public Person personPrototype() {
return new Person();
}
@Bean
@Scope("singleton")
public Person personSingleton() {
return new Person();
}
}

10
spring-all/src/main/resources/scopes.xml Normal file
View File

@ -0,0 +1,10 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="personSingleton" class="org.baeldung.scopes.Person" scope="singleton"/>
<bean id="personPrototype" class="org.baeldung.scopes.Person" scope="prototype"/>
</beans>

10
spring-all/src/main/webapp/WEB-INF/view/scopesExample.jsp Normal file
View File

@ -0,0 +1,10 @@
<html>
<head></head>
<body>
<h1>Bean Scopes Examples</h1>
<br>
Request Message: ${requestMessage }<br>
Session Message: ${sessionMessage }
</body>
</html>

43
spring-all/src/test/java/org/baeldung/scopes/ScopesTest.java Normal file
View File

@ -0,0 +1,43 @@
package org.baeldung.scopes;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class ScopesTest {
private static final String NAME = "John Smith";
private static final String NAME_OTHER = "Anna Jones";
@Test
public void testScopeSingleton() {
final ApplicationContext applicationContext = new ClassPathXmlApplicationContext("scopes.xml");
final Person personSingletonA = (Person) applicationContext.getBean("personSingleton");
final Person personSingletonB = (Person) applicationContext.getBean("personSingleton");
personSingletonA.setName(NAME);
Assert.assertEquals(NAME, personSingletonB.getName());
((AbstractApplicationContext) applicationContext).close();
}
@Test
public void testScopePrototype() {
final ApplicationContext applicationContext = new ClassPathXmlApplicationContext("scopes.xml");
final Person personPrototypeA = (Person) applicationContext.getBean("personPrototype");
final Person personPrototypeB = (Person) applicationContext.getBean("personPrototype");
personPrototypeA.setName(NAME);
personPrototypeB.setName(NAME_OTHER);
Assert.assertEquals(NAME, personPrototypeA.getName());
Assert.assertEquals(NAME_OTHER, personPrototypeB.getName());
((AbstractApplicationContext) applicationContext).close();
}
}

10
spring-data-couchbase-2/README.md
View File

@ -2,11 +2,12 @@
### Relevant Articles:
- [Spring Data Couchbase](http://www.baeldung.com/spring-data-couchbase)
- [Entity Validation, Query Consistency, and Optimistic Locking in Spring Data Couchbase](http://www.baeldung.com/entity-validation-locking-and-query-consistency-in-spring-data-couchbase)
### Overview
This Maven project contains the Java code for Spring Data Couchbase
entities, repositories, and template-based services
as described in the tutorial, as well as a unit test
as described in the tutorials, as well as a unit/integration test
for each service implementation.
### Working with the Code
@ -22,13 +23,16 @@ mvn clean install
```
### Running the tests
There are three test classes in src/test/java in the package
The following test classes are in src/test/java in the package
org.baeldung.spring.data.couchbase.service:
- PersonServiceTest (abstract)
- PersonRepositoryTest (concrete)
- PersonTemplateServiceTest (concrete)
- StudentServiceTest (abstract)
- StudentRepositoryTest (concrete)
- StudentTemplateServiceTest (concrete)
The latter two may be run as JUnit tests from your IDE
The concrete test classes may be run as JUnit tests from your IDE
or using the Maven command line:
```
mvn test

2
spring-data-couchbase-2/pom.xml
View File

@ -93,7 +93,7 @@
<java.version>1.7</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<spring-framework.version>4.2.4.RELEASE</spring-framework.version>
<spring-data-couchbase.version>2.0.0.RELEASE</spring-data-couchbase.version>
<spring-data-couchbase.version>2.1.1.RELEASE</spring-data-couchbase.version>
<hibernate-validator.version>5.2.4.Final</hibernate-validator.version>
<joda-time.version>2.9.2</joda-time.version>
<logback.version>1.1.3</logback.version>

53
spring-data-couchbase-2/src/test/java/org/baeldung/spring/data/couchbase/service/PersonServiceTest.java
View File

@ -27,28 +27,20 @@ public abstract class PersonServiceTest extends IntegrationTest {
static final String smith = "Smith";
static final String johnSmithId = "person:" + john + ":" + smith;
static final Person johnSmith = new Person(johnSmithId, john, smith);
static final JsonObject jsonJohnSmith = JsonObject.empty()
.put(typeField, Person.class.getName())
.put("firstName", john)
.put("lastName", smith)
.put("created", DateTime.now().getMillis());
static final JsonObject jsonJohnSmith = JsonObject.empty().put(typeField, Person.class.getName()).put("firstName", john).put("lastName", smith).put("created", DateTime.now().getMillis());
static final String foo = "Foo";
static final String bar = "Bar";
static final String foobarId = "person:" + foo + ":" + bar;
static final Person foobar = new Person(foobarId, foo, bar);
static final JsonObject jsonFooBar = JsonObject.empty()
.put(typeField, Person.class.getName())
.put("firstName", foo)
.put("lastName", bar)
.put("created", DateTime.now().getMillis());
static final JsonObject jsonFooBar = JsonObject.empty().put(typeField, Person.class.getName()).put("firstName", foo).put("lastName", bar).put("created", DateTime.now().getMillis());
PersonService personService;
@BeforeClass
public static void setupBeforeClass() {
Cluster cluster = CouchbaseCluster.create(MyCouchbaseConfig.NODE_LIST);
Bucket bucket = cluster.openBucket(MyCouchbaseConfig.BUCKET_NAME, MyCouchbaseConfig.BUCKET_PASSWORD);
final Cluster cluster = CouchbaseCluster.create(MyCouchbaseConfig.NODE_LIST);
final Bucket bucket = cluster.openBucket(MyCouchbaseConfig.BUCKET_NAME, MyCouchbaseConfig.BUCKET_PASSWORD);
bucket.upsert(JsonDocument.create(johnSmithId, jsonJohnSmith));
bucket.upsert(JsonDocument.create(foobarId, jsonFooBar));
bucket.close();
@ -57,7 +49,7 @@ public abstract class PersonServiceTest extends IntegrationTest {
@Test
public void whenFindingPersonByJohnSmithId_thenReturnsJohnSmith() {
Person actualPerson = personService.findOne(johnSmithId);
final Person actualPerson = personService.findOne(johnSmithId);
assertNotNull(actualPerson);
assertNotNull(actualPerson.getCreated());
assertEquals(johnSmith, actualPerson);
@ -65,7 +57,7 @@ public abstract class PersonServiceTest extends IntegrationTest {
@Test
public void whenFindingAllPersons_thenReturnsTwoOrMorePersonsIncludingJohnSmithAndFooBar() {
List<Person> resultList = personService.findAll();
final List<Person> resultList = personService.findAll();
assertNotNull(resultList);
assertFalse(resultList.isEmpty());
assertTrue(resultContains(resultList, johnSmith));
@ -75,8 +67,8 @@ public abstract class PersonServiceTest extends IntegrationTest {
@Test
public void whenFindingByFirstNameJohn_thenReturnsOnlyPersonsNamedJohn() {
String expectedFirstName = john;
List<Person> resultList = personService.findByFirstName(expectedFirstName);
final String expectedFirstName = john;
final List<Person> resultList = personService.findByFirstName(expectedFirstName);
assertNotNull(resultList);
assertFalse(resultList.isEmpty());
assertTrue(allResultsContainExpectedFirstName(resultList, expectedFirstName));
@ -84,17 +76,24 @@ public abstract class PersonServiceTest extends IntegrationTest {
@Test
public void whenFindingByLastNameSmith_thenReturnsOnlyPersonsNamedSmith() {
String expectedLastName = smith;
List<Person> resultList = personService.findByLastName(expectedLastName);
final String expectedLastName = smith;
final List<Person> resultList = personService.findByLastName(expectedLastName);
assertNotNull(resultList);
assertFalse(resultList.isEmpty());
assertTrue(allResultsContainExpectedLastName(resultList, expectedLastName));
}
@Test
public void whenFindingByFirstNameJohn_thenReturnsOnePersonNamedJohn() {
final String expectedFirstName = john;
final List<Person> resultList = personService.findByFirstName(expectedFirstName);
assertTrue(resultList.size() == 1);
}
private boolean resultContains(List<Person> resultList, Person person) {
boolean found = false;
for(Person p : resultList) {
if(p.equals(person)) {
for (final Person p : resultList) {
if (p.equals(person)) {
found = true;
break;
}
@ -104,8 +103,8 @@ public abstract class PersonServiceTest extends IntegrationTest {
private boolean allResultsContainExpectedFirstName(List<Person> resultList, String firstName) {
boolean found = false;
for(Person p : resultList) {
if(p.getFirstName().equals(firstName)) {
for (final Person p : resultList) {
if (p.getFirstName().equals(firstName)) {
found = true;
break;
}
@ -115,8 +114,8 @@ public abstract class PersonServiceTest extends IntegrationTest {
private boolean allResultsContainExpectedLastName(List<Person> resultList, String lastName) {
boolean found = false;
for(Person p : resultList) {
if(p.getLastName().equals(lastName)) {
for (final Person p : resultList) {
if (p.getLastName().equals(lastName)) {
found = true;
break;
}

36
spring-data-couchbase-2b/.classpath Normal file
View File

@ -0,0 +1,36 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="src" output="target/classes" path="src/main/java">
<attributes>
<attribute name="optional" value="true"/>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="src" output="target/test-classes" path="src/test/java">
<attributes>
<attribute name="optional" value="true"/>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="output" path="target/classes"/>
</classpath>

30
spring-data-couchbase-2b/.project Normal file
View File

@ -0,0 +1,30 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>spring-data-couchbase-2</name>
<comment>This project is a simple template for a jar utility using Spring.
</comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.springframework.ide.eclipse.core.springbuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.m2e.core.maven2Builder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.springframework.ide.eclipse.core.springnature</nature>
<nature>org.eclipse.jdt.core.javanature</nature>
<nature>org.eclipse.m2e.core.maven2Nature</nature>
</natures>
</projectDescription>

20
spring-data-couchbase-2b/.springBeans Normal file
View File

@ -0,0 +1,20 @@
<?xml version="1.0" encoding="UTF-8"?>
<beansProjectDescription>
<version>1</version>
<pluginVersion><![CDATA[2.2.7.200909012107-CI-R3397-B453]]></pluginVersion>
<configSuffixes>
<configSuffix><![CDATA[xml]]></configSuffix>
</configSuffixes>
<enableImports><![CDATA[true]]></enableImports>
<configs>
</configs>
<configSets>
<configSet>
<name><![CDATA[test]]></name>
<allowBeanDefinitionOverriding>true</allowBeanDefinitionOverriding>
<incomplete>false</incomplete>
<configs>
</configs>
</configSet>
</configSets>
</beansProjectDescription>

36
spring-data-couchbase-2b/README.md Normal file
View File

@ -0,0 +1,36 @@
## Spring Data Couchbase Tutorial Project
### Relevant Articles:
- [Spring Data Couchbase](http://www.baeldung.com/spring-data-couchbase)
- [Entity Validation, Query Consistency, and Optimistic Locking in Spring Data Couchbase](http://www.baeldung.com/entity-validation-locking-and-query-consistency-in-spring-data-couchbase)
### Overview
This Maven project contains the Java code for Spring Data Couchbase
entities, repositories, and repository-based services
as described in the tutorials, as well as a unit/integration test
for each service implementation.
### Working with the Code
The project was developed and tested using Java 7 and 8 in the Eclipse-based
Spring Source Toolkit (STS) and therefore should run fine in any
recent version of Eclipse or another IDE of your choice
that supports Java 7 or later.
### Building the Project
You can also build the project using Maven outside of any IDE:
```
mvn clean install
```
### Running the tests
The following test classes are in src/test/java in the package
org.baeldung.spring.data.couchbase.service:
- CampusRepositoryServiceTest
- PersonRepositoryServiceTest
- StudentRepositoryServiceTest
These may be run as JUnit tests from your IDE
or using the Maven command line:
```
mvn test
```

105
spring-data-couchbase-2b/pom.xml Normal file
View File

@ -0,0 +1,105 @@
<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>org.baeldung</groupId>
<artifactId>spring-data-couchbase-2b</artifactId>
<version>0.1-SNAPSHOT</version>
<name>spring-data-couchbase-2b</name>
<packaging>jar</packaging>
<dependencies>
<!-- Spring Context and Couchbase Peristence -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring-framework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring-framework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-couchbase</artifactId>
<version>${spring-data-couchbase.version}</version>
</dependency>
<!-- Hibernate JSR-303 Bean Validation -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>${hibernate-validator.version}</version>
</dependency>
<dependency>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
<version>${joda-time.version}</version>
</dependency>
<!-- Logging with SLF4J & LogBack -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${org.slf4j.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>${logback.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>log4j-over-slf4j</artifactId>
<version>${org.slf4j.version}</version>
</dependency>
<!-- Test-Scoped Dependencies -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring-framework.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
<properties>
<java.version>1.7</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<spring-framework.version>4.2.4.RELEASE</spring-framework.version>
<spring-data-couchbase.version>2.1.1.RELEASE</spring-data-couchbase.version>
<hibernate-validator.version>5.2.4.Final</hibernate-validator.version>
<joda-time.version>2.9.2</joda-time.version>
<logback.version>1.1.3</logback.version>
<org.slf4j.version>1.7.12</org.slf4j.version>
<junit.version>4.11</junit.version>
</properties>
</project>

79
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/MyCouchbaseConfig.java Normal file
View File

@ -0,0 +1,79 @@
package org.baeldung.spring.data.couchbase;
import java.util.Arrays;
import java.util.List;
import org.baeldung.spring.data.couchbase.model.Campus;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.couchbase.config.AbstractCouchbaseConfiguration;
import org.springframework.data.couchbase.core.CouchbaseTemplate;
import org.springframework.data.couchbase.core.mapping.event.ValidatingCouchbaseEventListener;
import org.springframework.data.couchbase.core.query.Consistency;
import org.springframework.data.couchbase.repository.config.EnableCouchbaseRepositories;
import org.springframework.data.couchbase.repository.config.RepositoryOperationsMapping;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
import com.couchbase.client.java.Bucket;
@Configuration
@EnableCouchbaseRepositories(basePackages={"org.baeldung.spring.data.couchbase"})
public class MyCouchbaseConfig extends AbstractCouchbaseConfiguration {
public static final List<String> NODE_LIST = Arrays.asList("localhost");
public static final String DEFAULT_BUCKET_NAME = "baeldung";
public static final String DEFAULT_BUCKET_PASSWORD = "";
@Override
protected List<String> getBootstrapHosts() {
return NODE_LIST;
}
@Override
protected String getBucketName() {
return DEFAULT_BUCKET_NAME;
}
@Override
protected String getBucketPassword() {
return DEFAULT_BUCKET_PASSWORD;
}
@Bean
public Bucket campusBucket() throws Exception {
return couchbaseCluster().openBucket("baeldung2", "");
}
@Bean
public CouchbaseTemplate campusTemplate() throws Exception {
CouchbaseTemplate template = new CouchbaseTemplate(
couchbaseClusterInfo(), campusBucket(),
mappingCouchbaseConverter(), translationService());
template.setDefaultConsistency(getDefaultConsistency());
return template;
}
@Override
public void configureRepositoryOperationsMapping(RepositoryOperationsMapping baseMapping) {
try {
baseMapping.mapEntity(Campus.class, campusTemplate());
} catch (Exception e) {
//custom Exception handling
}
}
@Override
protected Consistency getDefaultConsistency() {
return Consistency.READ_YOUR_OWN_WRITES;
}
@Bean
public LocalValidatorFactoryBean localValidatorFactoryBean() {
return new LocalValidatorFactoryBean();
}
@Bean
public ValidatingCouchbaseEventListener validatingCouchbaseEventListener() {
return new ValidatingCouchbaseEventListener(localValidatorFactoryBean());
}
}

102
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/model/Campus.java Normal file
View File

@ -0,0 +1,102 @@
package org.baeldung.spring.data.couchbase.model;
import javax.validation.constraints.NotNull;
import org.springframework.data.annotation.Id;
import org.springframework.data.couchbase.core.mapping.Document;
import org.springframework.data.geo.Point;
import com.couchbase.client.java.repository.annotation.Field;
@Document
public class Campus {
@Id
private String id;
@Field
@NotNull
private String name;
@Field
@NotNull
private Point location;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Point getLocation() {
return location;
}
public void setLocation(Point location) {
this.location = location;
}
@Override
public int hashCode() {
int hash = 1;
if(id != null) {
hash = hash * 31 + id.hashCode();
}
if(name != null) {
hash = hash * 31 + name.hashCode();
}
if(location != null) {
hash = hash * 31 + location.hashCode();
}
return hash;
}
@Override
public boolean equals(Object obj) {
if((obj == null) || (obj.getClass() != this.getClass())) return false;
if(obj == this) return true;
Campus other = (Campus) obj;
return this.hashCode() == other.hashCode();
}
@SuppressWarnings("unused")
private Campus() {}
public Campus(Builder b) {
this.id = b.id;
this.name = b.name;
this.location = b.location;
}
public static class Builder {
private String id;
private String name;
private Point location;
public static Builder newInstance() {
return new Builder();
}
public Campus build() {
return new Campus(this);
}
public Builder id(String id) {
this.id = id;
return this;
}
public Builder name(String name) {
this.name = name;
return this;
}
public Builder location(Point location) {
this.location = location;
return this;
}
}
}

87
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/model/Person.java Normal file
View File

@ -0,0 +1,87 @@
package org.baeldung.spring.data.couchbase.model;
import javax.validation.constraints.NotNull;
import org.joda.time.DateTime;
import org.springframework.data.annotation.Id;
import org.springframework.data.couchbase.core.mapping.Document;
import com.couchbase.client.java.repository.annotation.Field;
@Document
public class Person {
@Id
private String id;
@Field
@NotNull
private String firstName;
@Field
@NotNull
private String lastName;
@Field
@NotNull
private DateTime created;
@Field
private DateTime updated;
public Person(String id, String firstName, String lastName) {
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public DateTime getCreated() {
return created;
}
public void setCreated(DateTime created) {
this.created = created;
}
public DateTime getUpdated() {
return updated;
}
public void setUpdated(DateTime updated) {
this.updated = updated;
}
@Override
public int hashCode() {
int hash = 1;
if(id != null) {
hash = hash * 31 + id.hashCode();
}
if(firstName != null) {
hash = hash * 31 + firstName.hashCode();
}
if(lastName != null) {
hash = hash * 31 + lastName.hashCode();
}
return hash;
}
@Override
public boolean equals(Object obj) {
if((obj == null) || (obj.getClass() != this.getClass())) return false;
if(obj == this) return true;
Person other = (Person) obj;
return this.hashCode() == other.hashCode();
}
}

113
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/model/Student.java Normal file
View File

@ -0,0 +1,113 @@
package org.baeldung.spring.data.couchbase.model;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Past;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
import org.joda.time.DateTime;
import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.Version;
import org.springframework.data.couchbase.core.mapping.Document;
import com.couchbase.client.java.repository.annotation.Field;
@Document
public class Student {
private static final String NAME_REGEX = "^[a-zA-Z .'-]+$";
@Id
private String id;
@Field
@NotNull
@Size(min=1, max=20)
@Pattern(regexp=NAME_REGEX)
private String firstName;
@Field
@NotNull
@Size(min=1, max=20)
@Pattern(regexp=NAME_REGEX)
private String lastName;
@Field
@Past
private DateTime dateOfBirth;
@Field
@NotNull
private DateTime created;
@Field
private DateTime updated;
@Version
private long version;
public Student() {}
public Student(String id, String firstName, String lastName, DateTime dateOfBirth) {
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
this.dateOfBirth = dateOfBirth;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public DateTime getDateOfBirth() {
return dateOfBirth;
}
public void setDateOfBirth(DateTime dateOfBirth) {
this.dateOfBirth = dateOfBirth;
}
public DateTime getCreated() {
return created;
}
public void setCreated(DateTime created) {
this.created = created;
}
public DateTime getUpdated() {
return updated;
}
public void setUpdated(DateTime updated) {
this.updated = updated;
}
@Override
public int hashCode() {
int hash = 1;
if(id != null) {
hash = hash * 31 + id.hashCode();
}
if(firstName != null) {
hash = hash * 31 + firstName.hashCode();
}
if(lastName != null) {
hash = hash * 31 + lastName.hashCode();
}
if(dateOfBirth != null) {
hash = hash * 31 + dateOfBirth.hashCode();
}
return hash;
}
@Override
public boolean equals(Object obj) {
if((obj == null) || (obj.getClass() != this.getClass())) return false;
if(obj == this) return true;
Student other = (Student) obj;
return this.hashCode() == other.hashCode();
}
}

19
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/repos/CampusRepository.java Normal file
View File

@ -0,0 +1,19 @@
package org.baeldung.spring.data.couchbase.repos;
import java.util.Set;
import org.baeldung.spring.data.couchbase.model.Campus;
import org.springframework.data.couchbase.core.query.Dimensional;
import org.springframework.data.couchbase.core.query.View;
import org.springframework.data.geo.Distance;
import org.springframework.data.geo.Point;
import org.springframework.data.repository.CrudRepository;
public interface CampusRepository extends CrudRepository<Campus, String> {
@View(designDocument="campus", viewName="byName")
Set<Campus> findByName(String name);
@Dimensional(dimensions=2, designDocument="campus_spatial", spatialViewName="byLocation")
Set<Campus> findByLocationNear(Point point, Distance distance);
}

11
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/repos/PersonRepository.java Normal file
View File

@ -0,0 +1,11 @@
package org.baeldung.spring.data.couchbase.repos;
import java.util.List;
import org.baeldung.spring.data.couchbase.model.Person;
import org.springframework.data.repository.CrudRepository;
public interface PersonRepository extends CrudRepository<Person, String> {
List<Person> findByFirstName(String firstName);
List<Person> findByLastName(String lastName);
}

11
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/repos/StudentRepository.java Normal file
View File

@ -0,0 +1,11 @@
package org.baeldung.spring.data.couchbase.repos;
import java.util.List;
import org.baeldung.spring.data.couchbase.model.Student;
import org.springframework.data.repository.CrudRepository;
public interface StudentRepository extends CrudRepository<Student, String> {
List<Student> findByFirstName(String firstName);
List<Student> findByLastName(String lastName);
}

54
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/service/CampusRepositoryService.java Normal file
View File

@ -0,0 +1,54 @@
package org.baeldung.spring.data.couchbase.service;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.baeldung.spring.data.couchbase.model.Campus;
import org.baeldung.spring.data.couchbase.repos.CampusRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.geo.Distance;
import org.springframework.data.geo.Point;
import org.springframework.stereotype.Service;
@Service
@Qualifier("CampusRepositoryService")
public class CampusRepositoryService implements CampusService {
private CampusRepository repo;
@Autowired
public void setCampusRepository(CampusRepository repo) {
this.repo = repo;
}
@Override
public Campus find(String id) {
return repo.findOne(id);
}
@Override
public Set<Campus> findByName(String name) {
return repo.findByName(name);
}
@Override
public Set<Campus> findByLocationNear(Point point, Distance distance) {
return repo.findByLocationNear(point, distance);
}
@Override
public Set<Campus> findAll() {
Set<Campus> campuses = new HashSet<>();
Iterator<Campus> it = repo.findAll().iterator();
while(it.hasNext()) {
campuses.add(it.next());
}
return campuses;
}
@Override
public void save(Campus campus) {
repo.save(campus);
}
}

20
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/service/CampusService.java Normal file
View File

@ -0,0 +1,20 @@
package org.baeldung.spring.data.couchbase.service;
import java.util.Set;
import org.baeldung.spring.data.couchbase.model.Campus;
import org.springframework.data.geo.Distance;
import org.springframework.data.geo.Point;
public interface CampusService {
Campus find(String id);
Set<Campus> findByName(String name);
Set<Campus> findByLocationNear(Point point, Distance distance);
Set<Campus> findAll();
void save(Campus campus);
}

58
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/service/PersonRepositoryService.java Normal file
View File

@ -0,0 +1,58 @@
package org.baeldung.spring.data.couchbase.service;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.baeldung.spring.data.couchbase.model.Person;
import org.baeldung.spring.data.couchbase.repos.PersonRepository;
import org.joda.time.DateTime;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
@Qualifier("PersonRepositoryService")
public class PersonRepositoryService implements PersonService {
private PersonRepository repo;
@Autowired
public void setPersonRepository(PersonRepository repo) {
this.repo = repo;
}
public Person findOne(String id) {
return repo.findOne(id);
}
public List<Person> findAll() {
List<Person> people = new ArrayList<Person>();
Iterator<Person> it = repo.findAll().iterator();
while(it.hasNext()) {
people.add(it.next());
}
return people;
}
public List<Person> findByFirstName(String firstName) {
return repo.findByFirstName(firstName);
}
public List<Person> findByLastName(String lastName) {
return repo.findByLastName(lastName);
}
public void create(Person person) {
person.setCreated(DateTime.now());
repo.save(person);
}
public void update(Person person) {
person.setUpdated(DateTime.now());
repo.save(person);
}
public void delete(Person person) {
repo.delete(person);
}
}

22
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/service/PersonService.java Normal file
View File

@ -0,0 +1,22 @@
package org.baeldung.spring.data.couchbase.service;
import java.util.List;
import org.baeldung.spring.data.couchbase.model.Person;
public interface PersonService {
Person findOne(String id);
List<Person> findAll();
List<Person> findByFirstName(String firstName);
List<Person> findByLastName(String lastName);
void create(Person person);
void update(Person person);
void delete(Person person);
}

58
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/service/StudentRepositoryService.java Normal file
View File

@ -0,0 +1,58 @@
package org.baeldung.spring.data.couchbase.service;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.baeldung.spring.data.couchbase.model.Student;
import org.baeldung.spring.data.couchbase.repos.StudentRepository;
import org.joda.time.DateTime;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
@Qualifier("StudentRepositoryService")
public class StudentRepositoryService implements StudentService {
private StudentRepository repo;
@Autowired
public void setStudentRepository(StudentRepository repo) {
this.repo = repo;
}
public Student findOne(String id) {
return repo.findOne(id);
}
public List<Student> findAll() {
List<Student> people = new ArrayList<Student>();
Iterator<Student> it = repo.findAll().iterator();
while(it.hasNext()) {
people.add(it.next());
}
return people;
}
public List<Student> findByFirstName(String firstName) {
return repo.findByFirstName(firstName);
}
public List<Student> findByLastName(String lastName) {
return repo.findByLastName(lastName);
}
public void create(Student student) {
student.setCreated(DateTime.now());
repo.save(student);
}
public void update(Student student) {
student.setUpdated(DateTime.now());
repo.save(student);
}
public void delete(Student student) {
repo.delete(student);
}
}

22
spring-data-couchbase-2b/src/main/java/org/baeldung/spring/data/couchbase/service/StudentService.java Normal file
View File

@ -0,0 +1,22 @@
package org.baeldung.spring.data.couchbase.service;
import java.util.List;
import org.baeldung.spring.data.couchbase.model.Student;
public interface StudentService {
Student findOne(String id);
List<Student> findAll();
List<Student> findByFirstName(String firstName);
List<Student> findByLastName(String lastName);
void create(Student student);
void update(Student student);
void delete(Student student);
}

17
spring-data-couchbase-2b/src/main/resources/logback.xml Normal file
View File

@ -0,0 +1,17 @@
<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>web - %date [%thread] %-5level %logger{36} - %message%n
</pattern>
</encoder>
</appender>
<logger name="org.springframework" level="WARN" />
<logger name="org.baeldung" level="DEBUG" />
<root level="INFO">
<appender-ref ref="STDOUT" />
</root>
</configuration>

25
spring-data-couchbase-2b/src/site/site.xml Normal file
View File

@ -0,0 +1,25 @@
<?xml version="1.0" encoding="ISO-8859-1"?>
<project name="Spring Batch: ${project.name}">
<bannerLeft>
<name>Spring Sample: ${project.name}</name>
<href>index.html</href>
</bannerLeft>
<skin>
<groupId>org.springframework.maven.skins</groupId>
<artifactId>maven-spring-skin</artifactId>
<version>1.0.5</version>
</skin>
<body>
<links>
<item name="${project.name}" href="index.html"/>
</links>
<menu ref="reports"/>
</body>
</project>

13
spring-data-couchbase-2b/src/test/java/org/baeldung/spring/data/couchbase/IntegrationTest.java Normal file
View File

@ -0,0 +1,13 @@
package org.baeldung.spring.data.couchbase;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { MyCouchbaseConfig.class, IntegrationTestConfig.class })
@TestExecutionListeners(listeners = { DependencyInjectionTestExecutionListener.class })
public abstract class IntegrationTest {
}

9
spring-data-couchbase-2b/src/test/java/org/baeldung/spring/data/couchbase/IntegrationTestConfig.java Normal file
View File

@ -0,0 +1,9 @@
package org.baeldung.spring.data.couchbase;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan(basePackages = "org.baeldung.spring.data.couchbase")
public class IntegrationTestConfig {
}

17
spring-data-couchbase-2b/src/test/java/org/baeldung/spring/data/couchbase/TestCouchbaseConfig.java Normal file
View File

@ -0,0 +1,17 @@
package org.baeldung.spring.data.couchbase;
import org.springframework.data.couchbase.core.convert.MappingCouchbaseConverter;
import org.springframework.data.couchbase.core.query.Consistency;
public class TestCouchbaseConfig extends MyCouchbaseConfig {
@Override
public String typeKey() {
return MappingCouchbaseConverter.TYPEKEY_SYNCGATEWAY_COMPATIBLE;
}
@Override
public Consistency getDefaultConsistency() {
return Consistency.READ_YOUR_OWN_WRITES;
}
}

135
spring-data-couchbase-2b/src/test/java/org/baeldung/spring/data/couchbase/service/CampusRepositoryServiceTest.java Normal file
View File

@ -0,0 +1,135 @@
package org.baeldung.spring.data.couchbase.service;
import static org.junit.Assert.*;
import java.util.Set;
import javax.annotation.PostConstruct;
import org.baeldung.spring.data.couchbase.IntegrationTest;
import org.baeldung.spring.data.couchbase.model.Campus;
import org.baeldung.spring.data.couchbase.repos.CampusRepository;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.geo.Distance;
import org.springframework.data.geo.Metrics;
import org.springframework.data.geo.Point;
public class CampusRepositoryServiceTest extends IntegrationTest {
@Autowired
@Qualifier("CampusRepositoryService")
private CampusRepositoryService campusService;
@Autowired
private CampusRepository campusRepo;
private final Campus Brown = Campus.Builder.newInstance()
.id("campus:Brown")
.name("Brown")
.location(new Point(71.4025, 51.8268))
.build();
private final Campus Cornell = Campus.Builder.newInstance()
.id("campus:Cornell")
.name("Cornell")
.location(new Point(76.4833, 42.4459))
.build();
private final Campus Columbia = Campus.Builder.newInstance()
.id("campus:Columbia")
.name("Columbia")
.location(new Point(73.9626, 40.8075))
.build();
private final Campus Dartmouth = Campus.Builder.newInstance()
.id("campus:Dartmouth")
.name("Dartmouth")
.location(new Point(72.2887, 43.7044))
.build();
private final Campus Harvard = Campus.Builder.newInstance()
.id("campus:Harvard")
.name("Harvard")
.location(new Point(71.1167, 42.3770))
.build();
private final Campus Penn = Campus.Builder.newInstance()
.id("campus:Penn")
.name("Penn")
.location(new Point(75.1932, 39.9522))
.build();
private final Campus Princeton = Campus.Builder.newInstance()
.id("campus:Princeton")
.name("Princeton")
.location(new Point(74.6514, 40.3340))
.build();
private final Campus Yale = Campus.Builder.newInstance()
.id("campus:Yale")
.name("Yale")
.location(new Point(72.9223, 41.3163))
.build();
private final Point Boston = new Point(71.0589, 42.3601);
private final Point NewYorkCity = new Point(74.0059, 40.7128);
@PostConstruct
private void loadCampuses() throws Exception {
campusRepo.save(Brown);
campusRepo.save(Columbia);
campusRepo.save(Cornell);
campusRepo.save(Dartmouth);
campusRepo.save(Harvard);
campusRepo.save(Penn);
campusRepo.save(Princeton);
campusRepo.save(Yale);
}
@Test
public final void givenNameHarvard_whenFindByName_thenReturnsHarvard() throws Exception {
Set<Campus> campuses = campusService.findByName(Harvard.getName());
assertNotNull(campuses);
assertFalse(campuses.isEmpty());
assertTrue(campuses.size() == 1);
assertTrue(campuses.contains(Harvard));
}
@Test
public final void givenHarvardId_whenFind_thenReturnsHarvard() throws Exception {
Campus actual = campusService.find(Harvard.getId());
assertNotNull(actual);
assertEquals(Harvard, actual);
}
@Test
public final void whenFindAll_thenReturnsAll() throws Exception {
Set<Campus> campuses = campusService.findAll();
assertTrue(campuses.contains(Brown));
assertTrue(campuses.contains(Columbia));
assertTrue(campuses.contains(Cornell));
assertTrue(campuses.contains(Dartmouth));
assertTrue(campuses.contains(Harvard));
assertTrue(campuses.contains(Penn));
assertTrue(campuses.contains(Princeton));
assertTrue(campuses.contains(Yale));
}
@Test
public final void whenFindByLocationNearBoston_thenResultContainsHarvard() throws Exception {
Set<Campus> campuses = campusService.findByLocationNear(Boston, new Distance(1, Metrics.NEUTRAL));
assertFalse(campuses.isEmpty());
assertTrue(campuses.contains(Harvard));
assertFalse(campuses.contains(Columbia));
}
@Test
public final void whenFindByLocationNearNewYorkCity_thenResultContainsColumbia() throws Exception {
Set<Campus> campuses = campusService.findByLocationNear(NewYorkCity, new Distance(1, Metrics.NEUTRAL));
assertFalse(campuses.isEmpty());
assertTrue(campuses.contains(Columbia));
assertFalse(campuses.contains(Harvard));
}
}

130
spring-data-couchbase-2b/src/test/java/org/baeldung/spring/data/couchbase/service/PersonRepositoryServiceTest.java Normal file
View File

@ -0,0 +1,130 @@
package org.baeldung.spring.data.couchbase.service;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.util.List;
import org.baeldung.spring.data.couchbase.IntegrationTest;
import org.baeldung.spring.data.couchbase.MyCouchbaseConfig;
import org.baeldung.spring.data.couchbase.model.Person;
import org.joda.time.DateTime;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import com.couchbase.client.java.Bucket;
import com.couchbase.client.java.Cluster;
import com.couchbase.client.java.CouchbaseCluster;
import com.couchbase.client.java.document.JsonDocument;
import com.couchbase.client.java.document.json.JsonObject;
public class PersonRepositoryServiceTest extends IntegrationTest {
private static final String typeField = "_class";
private static final String john = "John";
private static final String smith = "Smith";
private static final String johnSmithId = "person:" + john + ":" + smith;
private static final Person johnSmith = new Person(johnSmithId, john, smith);
private static final JsonObject jsonJohnSmith = JsonObject.empty()
.put(typeField, Person.class.getName())
.put("firstName", john)
.put("lastName", smith)
.put("created", DateTime.now().getMillis());
private static final String foo = "Foo";
private static final String bar = "Bar";
private static final String foobarId = "person:" + foo + ":" + bar;
private static final Person foobar = new Person(foobarId, foo, bar);
private static final JsonObject jsonFooBar = JsonObject.empty()
.put(typeField, Person.class.getName())
.put("firstName", foo)
.put("lastName", bar)
.put("created", DateTime.now().getMillis());
@Autowired
@Qualifier("PersonRepositoryService")
private PersonService personService;
@BeforeClass
public static void setupBeforeClass() {
Cluster cluster = CouchbaseCluster.create(MyCouchbaseConfig.NODE_LIST);
Bucket bucket = cluster.openBucket(MyCouchbaseConfig.DEFAULT_BUCKET_NAME, MyCouchbaseConfig.DEFAULT_BUCKET_PASSWORD);
bucket.upsert(JsonDocument.create(johnSmithId, jsonJohnSmith));
bucket.upsert(JsonDocument.create(foobarId, jsonFooBar));
bucket.close();
cluster.disconnect();
}
@Test
public void whenFindingPersonByJohnSmithId_thenReturnsJohnSmith() {
Person actualPerson = personService.findOne(johnSmithId);
assertNotNull(actualPerson);
assertNotNull(actualPerson.getCreated());
assertEquals(johnSmith, actualPerson);
}
@Test
public void whenFindingAllPersons_thenReturnsTwoOrMorePersonsIncludingJohnSmithAndFooBar() {
List<Person> resultList = personService.findAll();
assertNotNull(resultList);
assertFalse(resultList.isEmpty());
assertTrue(resultContains(resultList, johnSmith));
assertTrue(resultContains(resultList, foobar));
assertTrue(resultList.size() >= 2);
}
@Test
public void whenFindingByFirstNameJohn_thenReturnsOnlyPersonsNamedJohn() {
String expectedFirstName = john;
List<Person> resultList = personService.findByFirstName(expectedFirstName);
assertNotNull(resultList);
assertFalse(resultList.isEmpty());
assertTrue(allResultsContainExpectedFirstName(resultList, expectedFirstName));
}
@Test
public void whenFindingByLastNameSmith_thenReturnsOnlyPersonsNamedSmith() {
String expectedLastName = smith;
List<Person> resultList = personService.findByLastName(expectedLastName);
assertNotNull(resultList);
assertFalse(resultList.isEmpty());
assertTrue(allResultsContainExpectedLastName(resultList, expectedLastName));
}
private boolean resultContains(List<Person> resultList, Person person) {
boolean found = false;
for(Person p : resultList) {
if(p.equals(person)) {
found = true;
break;
}
}
return found;
}
private boolean allResultsContainExpectedFirstName(List<Person> resultList, String firstName) {
boolean found = false;
for(Person p : resultList) {
if(p.getFirstName().equals(firstName)) {
found = true;
break;
}
}
return found;
}
private boolean allResultsContainExpectedLastName(List<Person> resultList, String lastName) {
boolean found = false;
for(Person p : resultList) {
if(p.getLastName().equals(lastName)) {
found = true;
break;
}
}
return found;
}
}

170
spring-data-couchbase-2b/src/test/java/org/baeldung/spring/data/couchbase/service/StudentRepositoryServiceTest.java Normal file
View File

@ -0,0 +1,170 @@
package org.baeldung.spring.data.couchbase.service;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.util.List;
import javax.validation.ConstraintViolationException;
import org.baeldung.spring.data.couchbase.IntegrationTest;
import org.baeldung.spring.data.couchbase.MyCouchbaseConfig;
import org.baeldung.spring.data.couchbase.model.Student;
import org.joda.time.DateTime;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import com.couchbase.client.java.Bucket;
import com.couchbase.client.java.Cluster;
import com.couchbase.client.java.CouchbaseCluster;
import com.couchbase.client.java.document.JsonDocument;
import com.couchbase.client.java.document.json.JsonObject;
public class StudentRepositoryServiceTest extends IntegrationTest {
private static final String typeField = "_class";
private static final String joe = "Joe";
private static final String college = "College";
private static final String joeCollegeId = "student:" + joe + ":" + college;
private static final DateTime joeCollegeDob = DateTime.now().minusYears(21);
private static final Student joeCollege = new Student(joeCollegeId, joe, college, joeCollegeDob);
private static final JsonObject jsonJoeCollege = JsonObject.empty()
.put(typeField, Student.class.getName())
.put("firstName", joe)
.put("lastName", college)
.put("created", DateTime.now().getMillis())
.put("version", 1);
private static final String judy = "Judy";
private static final String jetson = "Jetson";
private static final String judyJetsonId = "student:" + judy + ":" + jetson;
private static final DateTime judyJetsonDob = DateTime.now().minusYears(19).minusMonths(5).minusDays(3);
private static final Student judyJetson = new Student(judyJetsonId, judy, jetson, judyJetsonDob);
private static final JsonObject jsonJudyJetson = JsonObject.empty()
.put(typeField, Student.class.getName())
.put("firstName", judy)
.put("lastName", jetson)
.put("created", DateTime.now().getMillis())
.put("version", 1);
@Autowired
@Qualifier("StudentRepositoryService")
private StudentService studentService;
@BeforeClass
public static void setupBeforeClass() {
Cluster cluster = CouchbaseCluster.create(MyCouchbaseConfig.NODE_LIST);
Bucket bucket = cluster.openBucket(MyCouchbaseConfig.DEFAULT_BUCKET_NAME, MyCouchbaseConfig.DEFAULT_BUCKET_PASSWORD);
bucket.upsert(JsonDocument.create(joeCollegeId, jsonJoeCollege));
bucket.upsert(JsonDocument.create(judyJetsonId, jsonJudyJetson));
bucket.close();
cluster.disconnect();
}
@Test
public void whenCreatingStudent_thenDocumentIsPersisted() {
String firstName = "Eric";
String lastName = "Stratton";
DateTime dateOfBirth = DateTime.now().minusYears(25);
String id = "student:" + firstName + ":" + lastName;
Student expectedStudent = new Student(id, firstName, lastName, dateOfBirth);
studentService.create(expectedStudent);
Student actualStudent = studentService.findOne(id);
assertNotNull(actualStudent.getCreated());
assertNotNull(actualStudent);
assertEquals(expectedStudent.getId(), actualStudent.getId());
}
@Test(expected=ConstraintViolationException.class)
public void whenCreatingStudentWithInvalidFirstName_thenConstraintViolationException() {
String firstName = "Er+ic";
String lastName = "Stratton";
DateTime dateOfBirth = DateTime.now().minusYears(25);
String id = "student:" + firstName + ":" + lastName;
Student student = new Student(id, firstName, lastName, dateOfBirth);
studentService.create(student);
}
@Test(expected=ConstraintViolationException.class)
public void whenCreatingStudentWithFutureDob_thenConstraintViolationException() {
String firstName = "Jane";
String lastName = "Doe";
DateTime dateOfBirth = DateTime.now().plusDays(1);
String id = "student:" + firstName + ":" + lastName;
Student student = new Student(id, firstName, lastName, dateOfBirth);
studentService.create(student);
}
@Test
public void whenFindingStudentByJohnSmithId_thenReturnsJohnSmith() {
Student actualStudent = studentService.findOne(joeCollegeId);
assertNotNull(actualStudent);
assertNotNull(actualStudent.getCreated());
assertEquals(joeCollegeId, actualStudent.getId());
}
@Test
public void whenFindingAllStudents_thenReturnsTwoOrMoreStudentsIncludingJoeCollegeAndJudyJetson() {
List<Student> resultList = studentService.findAll();
assertNotNull(resultList);
assertFalse(resultList.isEmpty());
assertTrue(resultContains(resultList, joeCollege));
assertTrue(resultContains(resultList, judyJetson));
assertTrue(resultList.size() >= 2);
}
@Test
public void whenFindingByFirstNameJohn_thenReturnsOnlyStudentsNamedJohn() {
String expectedFirstName = joe;
List<Student> resultList = studentService.findByFirstName(expectedFirstName);
assertNotNull(resultList);
assertFalse(resultList.isEmpty());
assertTrue(allResultsContainExpectedFirstName(resultList, expectedFirstName));
}
@Test
public void whenFindingByLastNameSmith_thenReturnsOnlyStudentsNamedSmith() {
String expectedLastName = college;
List<Student> resultList = studentService.findByLastName(expectedLastName);
assertNotNull(resultList);
assertFalse(resultList.isEmpty());
assertTrue(allResultsContainExpectedLastName(resultList, expectedLastName));
}
private boolean resultContains(List<Student> resultList, Student student) {
boolean found = false;
for(Student p : resultList) {
if(p.getId().equals(student.getId())) {
found = true;
break;
}
}
return found;
}
private boolean allResultsContainExpectedFirstName(List<Student> resultList, String firstName) {
boolean found = false;
for(Student p : resultList) {
if(p.getFirstName().equals(firstName)) {
found = true;
break;
}
}
return found;
}
private boolean allResultsContainExpectedLastName(List<Student> resultList, String lastName) {
boolean found = false;
for(Student p : resultList) {
if(p.getLastName().equals(lastName)) {
found = true;
break;
}
}
return found;
}
}

17
spring-data-couchbase-2b/src/test/resources/logback.xml Normal file
View File

@ -0,0 +1,17 @@
<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>web - %date [%thread] %-5level %logger{36} - %message%n
</pattern>
</encoder>
</appender>
<logger name="org.springframework" level="WARN" />
<logger name="org.baeldung" level="DEBUG" />
<root level="INFO">
<appender-ref ref="STDOUT" />
</root>
</configuration>