Spring Notyes

2.1.
@Transactional
When we want to configure the transactional behavior of a method, we can do it
with:
@Transactional
void pay() {}
@NoRepositoryBean
Sometimes we want to create repository interfaces with the only goal of providing
common methods for the child repositories.
Of course, we don't want Spring to create a bean of these repositories since we

won't inject them anywhere. @NoRepositoryBean does exactly this: when we mark a
child interface of org.springframework.data.repository.Repository, Spring won't
create a bean out of it.
For example, if we want an Optional<T> findById(ID id) method in all of our

repositories, we can create a base repository:
@NoRepositoryBean
interface MyUtilityRepository<T, ID extends Serializable> extends CrudRepository<T,
ID> {
Optional<T> findById(ID id);
}
Copy
This annotation doesn't affect the child interfaces; hence Spring will create a
bean for the following repository interface:
@Repository
interface PersonRepository extends MyUtilityRepository<Person, Long> {}
Copy
Note, that the example above isn't necessary since Spring Data version 2 which
includes this method replacing the older T findOne(ID id).
freestar
2.3. @Param
We can pass named parameters to our queries using @Param:
@Query("FROM Person p WHERE p.name = :name")

Person findByName(@Param("name") String name);
Copy
Note, that we refer to the parameter with the :name syntax.
For further examples, please visit this article.
2.4. @Id
@Id marks a field in a model class as the primary key:
class Person {
@Id
Long id;
// ...
}
Copy
Since it's implementation-independent, it makes a model class easy to use with
multiple data store engines.
freestar
2.5. @Transient
We can use this annotation to mark a field in a model class as transient. Hence the
data store engine won't read or write this field's value:
class Person {
// ...
@Transient
int age;
// ...
}
Copy
Like @Id, @Transient is also implementation-independent, which makes it convenient
to use with multiple data store implementations.
2.6. @CreatedBy, @LastModifiedBy, @CreatedDate, @LastModifiedDate

With these annotations, we can audit our model classes: Spring automatically
populates the annotated fields with the principal who created the object, last
modified it, and the date of creation, and last modification:
public class Person {
// ...
@CreatedBy
User creator;
@LastModifiedBy
User modifier;
@CreatedDate
Date createdAt;
@LastModifiedDate
Date modifiedAt;
// ...
}
Copy
Note, that if we want Spring to populate the principals, we need to use Spring
Security as well.
For a more thorough description, please visit this article.
3. Spring Data JPA Annotations

3.1. @Query
With @Query, we can provide a JPQL implementation for a repository method:
@Query("SELECT COUNT(*) FROM Person p")

long getPersonCount();
Copy
Also, we can use named parameters:
@Query("FROM Person p WHERE p.name = :name")

Person findByName(@Param("name") String name);
Copy
Besides, we can use native SQL queries, if we set the nativeQuery argument to true:
@Query(value = "SELECT AVG(p.age) FROM person p", nativeQuery = true)

int getAverageAge();
Copy
For more information, please visit this article.
3.2. @Procedure
With Spring Data JPA we can easily call stored procedures from repositories.
First, we need to declare the repository on the entity class using standard JPA
annotations:
@NamedStoredProcedureQueries({
@NamedStoredProcedureQuery(
name = "count_by_name",
procedureName = "person.count_by_name",
parameters = {
@StoredProcedureParameter(
mode = ParameterMode.IN,
name = "name",
type = String.class),
@StoredProcedureParameter(
mode = ParameterMode.OUT,
name = "count",
type = Long.class)
}
)
})
class Person {}
Copy
After this, we can refer to it in the repository with the name we declared in the
name argument:
@Procedure(name = "count_by_name")
long getCountByName(@Param("name") String name);
Copy
3.3. @Lock
We can configure the lock mode when we execute a repository query method:
@Lock(LockModeType.NONE)
@Query("SELECT COUNT(*) FROM Person p")
long getPersonCount();
Copy
The available lock modes:
READ
WRITE
OPTIMISTIC
OPTIMISTIC_FORCE_INCREMENT
PESSIMISTIC_READ
PESSIMISTIC_WRITE
PESSIMISTIC_FORCE_INCREMENT
NONE
3.4. @Modifying
We can modify data with a repository method if we annotate it with @Modifying:
@Modifying
@Query("UPDATE Person p SET p.name = :name WHERE p.id = :id")
void changeName(@Param("id") long id, @Param("name") String name);
3.5. @EnableJpaRepositories
@Configuration
@EnableJpaRepositories(basePackages = "com.baeldung.persistence.dao")
4.1. @Document
This annotation marks a class as being a domain object that we want to persist to
the database:
@Document(collection = "user")
@Field("email")
String emailAddress;
// ...
4.3. @Query-e can provide a finder query on a MongoDB repository method:
@Query("{ 'name' : ?0 }")
@Configuration
@EnableMongoRepositories(basePackages = "com.baeldung.repository")
class MongoConfig
{

Spring Notyes

Uploaded by

Copyright:

Available Formats

Spring Notyes

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Spring Notyes

Uploaded by

Copyright:

Available Formats

2.1.

Of course, we don't want Spring to create a bean of these repositories since we

For example, if we want an Optional<T> findById(ID id) method in all of our

interface PersonRepository extends MyUtilityRepository<Person, Long> {}

@Query("FROM Person p WHERE p.name = :name")

For further examples, please visit this article.

2.6. @CreatedBy, @LastModifiedBy, @CreatedDate, @LastModifiedDate

public class Person {

3. Spring Data JPA Annotations

@Query("SELECT COUNT(*) FROM Person p")

@Query("FROM Person p WHERE p.name = :name")

@Query(value = "SELECT AVG(p.age) FROM person p", nativeQuery = true)

4.3. @Query-e can provide a finder query on a MongoDB repository method:

@Query("{ 'name' : ?0 }")

You might also like