Spring Data is pretty convenient and speeds up development avoiding boilerplate code. However there are cases where annotation queries are not enough for the custom functionality you might want to achieve.
Therefore spring data allows us to add custom methods to a Spring Data Repository. I will use the same project structure from a previous blog post.
We have an entity called Employee
package com.gkatzioura.springdata.jpa.persistence.entity;
import javax.persistence.*;
/**
* Created by gkatzioura on 6/2/16.
*/
@Entity
@Table(name = "employee", schema="spring_data_jpa_example")
public class Employee {
@Id
@Column(name = "id")
@GeneratedValue(strategy = GenerationType.SEQUENCE)
private Long id;
@Column(name = "firstname")
private String firstName;
@Column(name = "lastname")
private String lastname;
@Column(name = "email")
private String email;
@Column(name = "age")
private Integer age;
@Column(name = "salary")
private Integer salary;
public Long getId() {
return id;
}
public void setId(Long 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 String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Integer getSalary() {
return salary;
}
public void setSalary(Integer salary) {
this.salary = salary;
}
}And the Spring Data repository
package com.gkatzioura.springdata.jpa.persistence.repository;
import com.gkatzioura.springdata.jpa.persistence.entity.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
/**
* Created by gkatzioura on 6/2/16.
*/
@Repository
public interface EmployeeRepository extends JpaRepository<Employee,Long>{
}Suppose that we want to add some custom sql functionality for example querying with a LIKE statement and joining with a table that is not mapped as an entity.
This is for demonstration purposes only. For your project you might have a better schema. Plus spring data comes with out of the box functionality for like statements, look at EndingWith, Containing, StartingWith.
We shall create the table bonus and add a reference to the employee table.
set schema 'spring_data_jpa_example'; create table bonus( id serial primary key, employee_id integer, amount real, foreign key (employee_id) references employee (id), unique (employee_id) ); insert into bonus ( employee_id, amount) VALUES(1, 100);
The sql query that we want to implement will query for employees whose name starts with a specified text and a bonus bigger than a certain amount. In jdbc we have to pass our variable concatenated with the character ‘%’.
So what we need is a native jpa query like this one
Query query = entityManager.createNativeQuery("select e.* from spring_data_jpa_example.bonus b, spring_data_jpa_example.employee e\n" +
"where e.id = b.employee_id " +
"and e.firstname LIKE ? " +
"and b.amount> ? ", Employee.class);
query.setParameter(1, firstName + "%");
query.setParameter(2, bonusAmount);In order to add this functionality to our spring data Repository we have to add an interface. It is mandatory for our interface to follow the naming convention of ${Original Repository name}Custom. Therefore the interface describing our custom functionality should be
package com.gkatzioura.springdata.jpa.persistence.repository;
import com.gkatzioura.springdata.jpa.persistence.entity.Employee;
import java.util.List;
/**
* Created by gkatzioura on 6/3/16.
*/
public interface EmployeeRepositoryCustom {
List<Employee> getFirstNamesLikeAndBonusBigger(String firstName, Double bonusAmount);
}And the implementation should be
package com.gkatzioura.springdata.jpa.persistence.repository;
import com.gkatzioura.springdata.jpa.persistence.entity.Employee;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import java.util.List;
/**
* Created by gkatzioura on 6/3/16.
*/
@Repository
@Transactional(readOnly = true)
public class EmployeeRepositoryImpl implements EmployeeRepositoryCustom {
@PersistenceContext
EntityManager entityManager;
@Override
public List<Employee> getFirstNamesLikeAndBonusBigger(String firstName, Double bonusAmount) {
Query query = entityManager.createNativeQuery("select e.* from spring_data_jpa_example.bonus b, spring_data_jpa_example.employee e\n" +
"where e.id = b.employee_id " +
"and e.firstname LIKE ? " +
"and b.amount> ? ", Employee.class);
query.setParameter(1, firstName + "%");
query.setParameter(2, bonusAmount);
return query.getResultList();
}
}And we should change our original spring data repository in order to inherit the custom functionality.
package com.gkatzioura.springdata.jpa.persistence.repository;
import com.gkatzioura.springdata.jpa.persistence.entity.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
/**
* Created by gkatzioura on 6/2/16.
*/
@Repository
public interface EmployeeRepository extends JpaRepository<Employee,Long>, EmployeeRepositoryCustom {
}Seems like a nice way of composition. Now let’s add a method to a controller that will call this custom method
package com.gkatzioura.springdata.jpa.controller;
import com.gkatzioura.springdata.jpa.persistence.entity.Employee;
import com.gkatzioura.springdata.jpa.persistence.repository.EmployeeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* Created by gkatzioura on 6/2/16.
*/
@RestController
public class TestController {
@Autowired
private EmployeeRepository employeeRepository;
@RequestMapping("/employee")
public List<Employee> getTest() {
return employeeRepository.findAll();
}
@RequestMapping("/employee/filter")
public List<Employee> getFiltered(String firstName,@RequestParam(defaultValue = "0") Double bonusAmount) {
return employeeRepository.getFirstNamesLikeAndBonusBigger(firstName,bonusAmount);
}
}The source code can be found on github.
| Reference: | Add Custom functionality to a Spring Data Repository from our JCG partner Emmanouil Gkatziouras at the gkatzioura blog. |
