Spring/spring-data-couchbase
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

DATACOUCH-463 - Revise readme for a consistent structure.

Browse Source
This commit is contained in:
Mark Paluch
2019-07-09 12:20:58 +02:00
parent aa0ae6e7d5
commit c38faa35c5
2 changed files with 143 additions and 246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
CI.adoc Normal file
View File

@@ -0,0 +1,34 @@
= Continuous Integration
image:https://jenkins.spring.io/buildStatus/icon?job=spring-data-couchbase%2Fmaster&subject=Moore%20(master)["Spring Data Couchbase", link="https://jenkins.spring
.io/view/SpringData/job/spring-data-couchbase/"]
image:https://jenkins.spring.io/buildStatus/icon?job=spring-data-couchbase%2F3.1.x&subject=Lovelace%20(3.1.x)["Spring Data Couchbase", link="https://jenkins.spring
.io/view/SpringData/job/spring-data-couchbase/"]
image:https://jenkins.spring.io/buildStatus/icon?job=spring-data-couchbase%2F2.2.x&subject=Ingalls%20(2.2.x)["Spring Data Couchbase", link="https://jenkins.spring
.io/view/SpringData/job/spring-data-couchbase/"]
== Running CI tasks locally
Since this pipeline is purely Docker-based, it's easy to:
* Debug what went wrong on your local machine.
* Test out a a tweak to your `test.sh` script before sending it out.
* Experiment against a new image before submitting your pull request.
All of these use cases are great reasons to essentially run what the CI server does on your local machine.
IMPORTANT: To do this you must have Docker installed on your machine.
1. `docker run -it --mount type=bind,source="$(pwd)",target=/spring-data-couchbase-github -v /usr/bin/docker:/usr/bin/docker -v /var/run/docker.sock:/var/run/docker.sock adoptopenjdk/openjdk8:latest /bin/bash`
+
This will launch the Docker image and mount your source code at `spring-data-couchbase-github`.
+
2. `cd spring-data-couchbase-github`
+
Next, test everything from inside the container:
+
3. `./mvnw -Pci clean dependency:list test -Dsort -B` (or whatever test configuration you must use)
Since the container is binding to your source, you can make edits from your IDE and continue to run build jobs.
NOTE: Docker containers can eat up disk space fast! From time to time, run `docker system prune` to clean out old images.

355
README.adoc
View File

@@ -1,23 +1,6 @@
image:https://spring.io/badges/spring-data-couchbase/ga.svg[Spring Data Couchbase,link=https://projects.spring.io/spring-data-couchbase#quick-start]
image:https://spring.io/badges/spring-data-couchbase/snapshot.svg[Spring Data Couchbase,link=https://projects.spring.io/spring-data-couchbase#quick-start]
image:https://spring.io/badges/spring-data-couchbase/ga.svg[Spring Data Couchbase,link=https://projects.spring.io/spring-data-couchbase#quick-start] image:https://spring.io/badges/spring-data-couchbase/snapshot.svg[Spring Data Couchbase,link=https://projects.spring.io/spring-data-couchbase#quick-start]
image:https://jenkins.spring.io/buildStatus/icon?job=spring-data-couchbase%2Fmaster&subject=Moore%20(master)["Spring Data Couchbase", link="https://jenkins.spring
.io/view/SpringData/job/spring-data-couchbase/"]
image:https://jenkins.spring.io/buildStatus/icon?job=spring-data-couchbase%2F3.1.x&subject=Lovelace%20(3.1.x)["Spring Data Couchbase", link="https://jenkins.spring
.io/view/SpringData/job/spring-data-couchbase/"]
image:https://jenkins.spring.io/buildStatus/icon?job=spring-data-couchbase%2F2.2.x&subject=Ingalls%20(2.2.x)["Spring Data Couchbase", link="https://jenkins.spring
.io/view/SpringData/job/spring-data-couchbase/"]
= Spring Data Couchbase 2.2.x
`Spring-Data Couchbase 2.2.x` is the Spring Data connector for the `Couchbase Java SDK 2.x` generation.
Both the SDK and this Spring Data community project are major version changes with lots of differences from their
respective previous versions.
Notably, this version is compatible with `Couchbase Server 4.0`, bringing support for the `N1QL` query language.
= Spring Data Couchbase
= Spring Data Couchbase image:https://jenkins.spring.io/buildStatus/icon?job=spring-data-couchbase%2Fmaster&subject=Build[link=https://jenkins.spring.io/view/SpringData/job/spring-data-couchbase/] https://gitter.im/spring-projects/spring-data[image:https://badges.gitter.im/spring-projects/spring-data.svg[Gitter]]
The primary goal of the https://www.springsource.org/spring-data[Spring Data] project is to make it easier to build
Spring-powered applications that use new data access technologies such as non-relational databases, map-reduce
@@ -32,190 +15,70 @@ Integration tests require a couchbase server with a bucket name "protected" with
If the server allows users, then an user with username "protected" with "password" as the password should also be set.
The recommended way to run tests is to install docker and use container in server.properties.
== Getting Help
This project is lead and maintained by Couchbase, Inc.
For a comprehensive treatment of all the Spring Data Couchbase features, please refer to:
== Features
* the https://docs.spring.io/spring-data/couchbase/docs/current/reference/html/[User Guide] for the current GA version.
* the https://docs.spring.io/spring-data/couchbase/docs/current/api/[JavaDocs] have extensive comments
in them as well.
* for more detailed questions, use the https://stackoverflow.com/questions/tagged/spring-data-couchbase[StackOverflow `spring-data-couchbase` tag]
or Couchbase's own https://forums.couchbase.com/c/java-sdk[forums].
* Spring configuration support using Java based `@Configuration` classes or an XML namespace for the Couchbase driver (Java SDK version 2.x).
* `CouchbaseTemplate` helper class that increases productivity performing common Couchbase operations. Includes integrated object mapping between documents and POJOs.
* Exception translation into Spring’s portable Data Access Exception hierarchy.
* Feature Rich Object Mapping integrated with Spring’s Conversion Service.
* Annotation based mapping metadata but extensible to support other metadata formats.
* Automatic implementation of `Repository` interfaces including support for custom finder methods (backed by Couchbase’s query language, `N1QL`) and `PagingAndSortingRepository`.
* For Couchbase server versions < 4.0, repositories can still be backed by Couchbase Views.
* Support for geospatial and multidimensional querying (backed by Couchbase Spatial Views)
* JMX administration and monitoring
* Can serve as the backend for `@Cacheable` support, to cache any objects you need for high performance access (see sibling Spring Cache project in Couchbase’s github, https://github.com/couchbaselabs/couchbase-spring-cache[couchbaselabs/couchbase-spring-cache]).
If you are new to Spring as well as to Spring Data, look for information about
https://www.springsource.org/projects[Spring projects].
== Version compatibility
== Quick Start
`Spring-Data Couchbase 3.0.x` is the Spring Data connector for the `Couchbase Java SDK 2.x` generation.
=== Maven configuration
Both the SDK and this Spring Data community project are major version changes with lots of differences from their
respective previous versions.
Add the Maven dependency:
Notably, this version is compatible with `Couchbase Server 4.0`, bringing support for the `N1QL` query language.
[source,xml]
----
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-couchbase</artifactId>
<version>2.0.0.RELEASE</version>
</dependency>
----
== Code of Conduct
If you'd rather like the latest snapshots of the upcoming major version, use our Maven snapshot repository and declare
the appropriate dependency version.
This project is governed by the link:CODE_OF_CONDUCT.adoc[Spring Code of Conduct]. By participating, you are expected to uphold this code of conduct. Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.
[source,xml]
----
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-couchbase</artifactId>
<version>2.1.0.BUILD-SNAPSHOT</version>
</dependency>
== Getting Started
<repository>
<id>spring-libs-snapshot</id>
<name>Spring Snapshot Repository</name>
<url>http://repo.spring.io/libs-snapshot</url>
</repository>
----
=== CouchbaseTemplate
CouchbaseTemplate is the central support class for Couchbase database operations. It provides:
* Basic POJO mapping support to and from JSON (by default through Jackson)
* Convenience methods to interact with the store (insert object, update objects) and Couchbase specific ones
* Exception translation into Spring's https://docs.spring.io/spring/docs/current/spring-framework-reference/html/dao.html#dao-exceptions[technology agnostic DAO exception hierarchy].
=== Spring Data Repositories
To simplify the creation of data repositories Spring Data Couchbase provides a generic repository programming model. It
will automatically create a repository proxy for you that adds implementations of finder methods you specify on an
interface.
To create a repository on top of a `UserInfo` entity, all you need to write is:
Here is a quick teaser of an application using Spring Data Repositories in Java:
[source,java]
----
public interface UserRepository extends CrudRepository<UserInfo, String> {
public interface PersonRepository extends CrudRepository<Person, Long> {
/**
* Return all users emitted by the view userInfo/adults
*/
@View
List<UserInfo> findAdults();
/**
* Find all users matching the last name.
*/
@View(viewName="lastNames")
List<UserInfo> findByLastname(String lastName);
/**
* Find all the users whose first name contains the word.
*/
List<UserInfo> findByFirstnameContains(String word);
List<Person> findByLastname(String lastname);
List<Person> findByFirstnameLike(String firstname);
}
----
Once you get a reference to that repository bean, you'll find a lot of methods that make it very easy to work with this
entity. In addition to the ones provided through the `CrudRepository`, you can add your own methods as well.
@Service
public class MyService {
In general, every CRUD method that does not depend on a single key (like `findById`) needs a backing View, `all` on the
server side (the design document is by default expected to be the uncapitalized name of the entity, like `userInfo`).
private final PersonRepository repository;
== Custom Repository Methods and Views
Finder methods you define, if annotated with `@View`, also are backed by views. Either you want to return all items from
these views and you can let the method name reflect the view name (like in `findAdults()`, where it'll expect an
`adults` view), or provide simple criteria (you explicitly specify the `viewName` and let the method name determine your
criteria, like in `findByLastname`).
In the example above, it assumes you have a view named `findByLastname` in the `userInfo` design document. You
can customize the view and design document name through the `@View` annotation. Also make sure you publish them into
production before accessing it.
This is an example view for the `findByLastname` method:
[source,javascript]
----
function (doc, meta) {
if(doc._class == "com.example.entity.UserInfo" && doc.lastname) {
emit(doc.lastname, null);
public MyService(PersonRepository repository) {
this.repository = repository;
}
public void doWork() {
repository.deleteAll();
Person person = new Person();
person.setFirstname("Couch");
person.setLastname("Base");
repository.save(person);
List<Person> lastNameResults = repository.findByLastname("Base");
List<Person> firstNameResults = repository.findByFirstnameLike("Cou*");
}
}
----
If you want to use more query parameters than what is supported through query derivation (see `ViewQueryCreator`), you
need to provide the implementation of the finder methods yourself and use the underlying `CouchbaseTemplate`.
The `all` view that backs CRUD `findAll()` and `count()` needs to look like this (and do not forget the `_count` reduce
function):
[source,javascript]
----
function (doc, meta) {
if(doc._class == "com.example.entity.UserInfo") {
emit(null, null);
}
}
----
Alternatively, if view creation isn't too costly, you can ask the framework to create it automatically by annotating the
repository with `@ViewIndexed(designDoc = &quot;userInfo&quot;, viewName = &quot;all&quot;)`.
== N1QL and Query Derivation
With the introduction of `N1QL`, Couchbase can now better support query derivation (the mechanism that allows you to
add custom methods that will automatically be implemented as a N1QL query derived from the method's name).
This is the default repository query mechanism, so the associated `@Query` annotation is optional. Here is what it looks
like:
[source,java]
----
public interface UserRepository extends CrudRepository<UserInfo, String> {
/**
* Advanced querying with N1QL derivation
*/
@Query
List<UserInfo> findByLastnameEqualsIgnoreCaseAndFirstnameStartsWithAndIsAdultTrue(String lastName, String fnamePrefix);
}
----
For instance, calling `find...(&quot;Locke&quot;, &quot;J&quot;)` will get resolved to this N1QL WHERE clause (similar to SQL):
[source,sql]
----
...WHERE LOWER(lastname) = LOWER("Locke") AND firstname LIKE "J%" AND isAdult = TRUE;
----
You can alternatively write the statement yourself inside the `@Query` annotation, using the `$SELECT_ENTITY$`
placeholder to make sure all necessary fields and metadata are selected by N1QL:
[source,java]
----
@Query("$SELECT_ENTITY$ WHERE firstname LIKE "%ck%")
List<UserInfo> findPatrickAndJackAmongOthers();
@Query("$SELECT_ENTITY$ WHERE firstname LIKE $1")
List<UserInfo> findUsersWithTheirFirstnameLike(String likePattern);
----
N1QL needs at least a generic purpose `N1QL primary index` to work with, and can make use of a more entity
type-specific `N1QL secondary index`. You can create both automatically (provided you are confident this
is not to much of a cost) by annotating a repository with `@N1qlPrimaryIndexed` and/or `@N1qlSecondaryIndexed`.
== Using The Repository
Extending `CrudRepository` causes CRUD methods being pulled into the interface so that you can easily save and find
single entities and collections of them.
You can have Spring automatically create a proxy for the interface by using the following JavaConfig:
[source,java]
----
@Configuration
@EnableCouchbaseRepositories
public class Config extends AbstractCouchbaseConfiguration {
@@ -237,89 +100,89 @@ public class Config extends AbstractCouchbaseConfiguration {
}
----
This sets up a connection to a Couchbase cluster and enables the detection of Spring Data repositories (through
`@EnableCouchbaseRepositories`). The same configuration would look like this in XML:
=== Maven configuration
Add the Maven dependency:
[source,xml]
----
<couchbase:cluster id="cb-first">
<couchbase:node>localhost</couchbase:node>
</couchbase:cluster>
<couchbase:bucket id="cb-bucket-first" cluster-ref="cb-first" bucket="default" password="" />
<couchbase:template id="cb-template-first" bucket-ref="cb-bucket-first" />
<couchbase:repositories couchbase-template-ref="cb-template-first" />
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-couchbase</artifactId>
<version>${version}.RELEASE</version>
</dependency>
----
This will find the repository interface and register a proxy object in the container. You can use it as shown below:
If you'd rather like the latest snapshots of the upcoming major version, use our Maven snapshot repository and declare the appropriate dependency version.
[source,java]
[source,xml]
----
@Service
public class MyService {
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-couchbase</artifactId>
<version>${version}.BUILD-SNAPSHOT</version>
</dependency>
private final UserRepository userRepository;
@Autowired
public MyService(UserRepository userRepository) {
this.userRepository = userRepository;
}
public void doWork() {
userRepository.deleteAll();
UserInfo userInfo = new UserInfo();
UserInfo.setLastname("Jackson");
UserInfo = userRepository.save(userInfo);
List<UserInfo> allJacksons = userRepository.findByLastname("Jackson");
}
}
<repository>
<id>spring-libs-snapshot</id>
<name>Spring Snapshot Repository</name>
<url>https://repo.spring.io/libs-snapshot</url>
</repository>
----
== Running CI tasks locally
== Getting Help
Since this pipeline is purely Docker-based, it's easy to:
Having trouble with Spring Data? We’d love to help!
* Debug what went wrong on your local machine.
* Test out a a tweak to your `test.sh` script before sending it out.
* Experiment against a new image before submitting your pull request.
* Check the
https://docs.spring.io/spring-data/couchbase/docs/current/reference/html/[reference documentation], and https://docs.spring.io/spring-data/couchbase/docs/current/api/[Javadocs].
* Learn the Spring basics – Spring Data builds on Spring Framework, check the https://spring.io[spring.io] web-site for a wealth of reference documentation.
If you are just starting out with Spring, try one of the https://spring.io/guides[guides].
* If you are upgrading, check out the https://docs.spring.io/spring-data/couchbase/docs/current/changelog.txt[changelog] for "`new and noteworthy`" features.
* Ask a question - we monitor https://stackoverflow.com[stackoverflow.com] for questions tagged with https://stackoverflow.com/tags/spring-data[`spring-data-couchbase`].
You can also chat with the community on https://gitter.im/spring-projects/spring-data[Gitter].
* Report bugs with Spring Data Couchbase at https://jira.spring.io/browse/DATACOUCH[jira.spring.io/browse/DATACOUCH].
All of these use cases are great reasons to essentially run what the CI server does on your local machine.
== Reporting Issues
IMPORTANT: To do this you must have Docker installed on your machine.
Spring Data uses JIRA as issue tracking system to record bugs and feature requests. If you want to raise an issue, please follow the recommendations below:
1. `docker run -it --mount type=bind,source="$(pwd)",target=/spring-data-couchbase-github -v /usr/bin/docker:/usr/bin/docker -v /var/run/docker.sock:/var/run/docker.sock adoptopenjdk/openjdk8:latest /bin/bash`
+
This will launch the Docker image and mount your source code at `spring-data-couchbase-github`.
+
2. `cd spring-data-couchbase-github`
+
Next, test everything from inside the container:
+
3. `./mvnw -Pci clean dependency:list test -Dsort -B` (or whatever test configuration you must use)
* Before you log a bug, please search the
https://jira.spring.io/browse/DATACOUCH[issue tracker] to see if someone has already reported the problem.
* If the issue doesn’t already exist, https://jira.spring.io/browse/DATACOUCH[create a new issue].
* Please provide as much information as possible with the issue report, we like to know the version of Spring Data that you are using and JVM version.
* If you need to paste code, or include a stack trace use JIRA `{code}…{code}` escapes before and after your text.
* If possible try to create a test-case or project that replicates the issue. Attach a link to your code or a compressed file containing your code.
Since the container is binding to your source, you can make edits from your IDE and continue to run build jobs.
== Building from Source
NOTE: Docker containers can eat up disk space fast! From time to time, run `docker system prune` to clean out old images.
You don’t need to build from source to use Spring Data (binaries in https://repo.spring.io[repo.spring.io]), but if you want to try out the latest and greatest, Spring Data can be easily built with the https://github.com/takari/maven-wrapper[maven wrapper].
You also need JDK 1.8.
== Contributing to Spring Data
[source,bash]
----
$ ./mvnw clean install
----
Here are some ways for you to get involved in the community:
If you want to build with the regular `mvn` command, you will need https://maven.apache.org/run-maven/index.html[Maven v3.5.0 or above].
* Get involved with the Spring community on Stack Overflow. Please help out on the
https://stackoverflow.com/questions/tagged/spring-data[`spring-data`] and
https://stackoverflow.com/questions/tagged/spring-data-couchbase[`spring-data-couchbase`] tags by responding to
questions.
* Create https://jira.spring.io/browse/DATACOUCH[JIRA] `DATACOUCH` tickets for bugs and new features and comment and
vote on the ones that you are interested in.
* Github is for social coding: if you want to write code, we encourage contributions through pull requests from
https://help.github.com/forking/[forks of this repository]. If you want to contribute code this way, please reference
a JIRA ticket as well covering the specific issue you are addressing.
* Watch for upcoming articles on Spring by https://assets.spring.io/drupal/node/feed.xml[subscribing] to spring.io RSS feed.
_Also see link:CONTRIBUTING.adoc[CONTRIBUTING.adoc] if you wish to submit pull requests, and in particular please sign the https://cla.pivotal.io/sign/spring[Contributor’s Agreement] before your first change, is trivial._
Before we accept a non-trivial patch or pull request we will need you to https://cla.pivotal.io/sign/spring[sign the Contributor License Agreement]. Signing the contributor’s agreement does not grant anyone commit rights to the main repository, but it does mean that we can accept your contributions, and you will get an author credit if we do. If you forget to do so, you'll be reminded when you submit a pull request. Active contributors might be asked to join the core team, and given the ability
to merge pull requests.
=== Building reference documentation
Building the documentation builds also the project without running tests.
[source,bash]
----
$ ./mvnw clean install -Pdistribute
----
The generated documentation is available from `target/site/reference/html/index.html`.
== Examples
* https://github.com/spring-projects/spring-data-examples/[Spring Data Examples] contains example projects that explain specific features in more detail.
== License
Spring Data Couchbase is Open Source software released under the https://www.apache.org/licenses/LICENSE-2.0.html[Apache 2.0 license].