JNoSQL/Artemis/Repository

Repisotry

In addition to repositories class, Artemis has the Repository. This interface helps the Entity repository to save, update, delete and retrieve information.

To use Repository, just need to create a new interface that extends the Repository.

 interface PersonRepository extends Repository<Person> {

    }

The qualifier is mandatory to define the database type whose will use at the injection point moment.

@Inject
@Database(DatabaseType.DOCUMENT)
private PersonRepository documentRepository;
@Inject
@Database(DatabaseType.COLUMN)
private PersonRepository columnRepository;

And then, as the repository class, create either a ColumnFamilyManager or a DocumentCollectionManager with produces method:

@Produces
public DocumentCollectionManager getManager() {
DocumentCollectionManager manager = //instance
return manager;
}

@Produces
public ColumnFamilyManager getManager() {
ColumnFamilyManager manager = //instance
return manager;
}

So, Artemis will inject automatically.

PersonRepository repository = //instance

Person person = new Person();
person.setNickname("diana");
person.setName("Diana Goodness");

List<Person> people = Collections.singletonList(person);

repository.save(person);
repository.save(people);
repository.save(people, Duration.ofHours(2));

Search information from Repository

The Repository also has a method query. These are the keywords:

• findBy: The prefix to find some information
• deleteBy: The prefix to delete some information

Also the operators:

• And
• Or
• Between
• LessThan
• GreaterThan
• LessThanEqual
• GreaterThanEqual
• Like
• OrderBy
• OrderBy____Desc
• OrderBy_____ASC

interface PersonRepository extends Repository<Person> {

    List<Person> findByAddress(String address);

    Stream<Person> findByName(String name);

    Stream<Person> findByNameOrderByNameAsc(String name);

    Optional<Person> findByNickname(String nickname);

    void deleteByNickName(String nickname);
}

Using Repository as asynchronous way

The RepositoryAsync interface works similarly as Repository but with asynchronous work.

@Inject
@Database(DatabaseType.DOCUMENT)
private PersonRepositoryAsync documentRepositoryAsync;

@Inject
@Database(DatabaseType.COLUMN)
private PersonRepositoryAsync columnRepositoryAsync;

In other words, just inject and then create an Entity Manager async with producers method.

PersonRepositoryAsync repositoryAsync = //instance

Person person = new Person();
person.setNickname("diana");
person.setName("Diana Goodness");

List<Person> people = Collections.singletonList(person);


repositoryAsync.save(person);
repositoryAsync.save(people);
repositoryAsync.save(person, p -> {});
repositoryAsync.save(people, Duration.ofHours(2));

Also, delete and retrieve information with a callback.

    interface PersonRepositoryAsync extends RepositoryAsync<Person> {

        void findByNickname(String nickname, Consumer<List<Person>> callback);

        void deleteByNickName(String nickname);

        void deleteByNickName(String nickname, Consumer<Void> callback);
    }

Repository at KeyValue

Key-value database has support to Repository.

 
public interface UserRepository extends Repository<User, String> {
}

And inject the resource.

@Inject
private UserRepository userRepository;

Then use a producer to BucketManager

@Produces
public BucketManager getManager() {
BucketManager manager =//instance
return manager;
}

UserRepository userRepository = //instance
User user = new User("ada", "Ada Lovelace", 30);
List<User> users = Collections.singletonList(user);
userRepository.save(user);
userRepository.save(users);


Optional<User> userOptional = userRepository.findById("ada");
Iterable<User> usersFound = userRepository.findById(Collections.singletonList("ada"));

In the key-value resource, the Repository does not support method query resource.

Links

• Documentation https://www.gitbook.com/book/jnosql/jnosql-book/details
• Start with Artemis