java - spring data jpa ejemplo

Cómo agregar un método personalizado a Spring Data JPA

Question

Estoy investigando Spring Data JPA. Considere el siguiente ejemplo en el que obtendré toda la funcionalidad crud y finder funcionando por defecto y si quiero personalizar un buscador, eso también se puede hacer fácilmente en la interfaz misma.

@Transactional(readOnly = true)
public interface AccountRepository extends JpaRepository<Account, Long> {

  @Query("<JPQ statement here>")
  List<Account> findByCustomer(Customer customer);
}

Me gustaría saber cómo puedo agregar un método personalizado completo con su implementación para el Depósito de cuentas anterior. Como es una Interfaz, no puedo implementar el método allí.

Answer 1

Además de la answer de axtavt, no olvide que puede insertar Entity Manager en su implementación personalizada si lo necesita para generar sus consultas:

public class AccountRepositoryImpl implements AccountRepositoryCustom {

    @PersistenceContext
    private EntityManager em;

    public void customMethod() { 
        ...
        em.createQuery(yourCriteria);
        ...
    }
}

Answer 2

Debe crear una interfaz separada para sus métodos personalizados:

public interface AccountRepository 
    extends JpaRepository<Account, Long>, AccountRepositoryCustom { ... }

public interface AccountRepositoryCustom {
    public void customMethod();
}

y proporcione una clase de implementación para esa interfaz:

public class AccountRepositoryImpl implements AccountRepositoryCustom {

    @Autowired
    AccountRepository accountRepository;  /* Optional - if you need it */

    public void customMethod() { ... }
}

Ver también:

• 1.3.1. Agregar comportamiento a repositorios individuales

Answer 3

Estoy usando el siguiente código para acceder a los métodos de búsqueda generados desde mi implementación personalizada. Obtener la implementación a través de la fábrica de frijoles evita problemas de creación circular de frijol.

public class MyRepositoryImpl implements MyRepositoryExtensions, BeanFactoryAware {

    private BrandRepository myRepository;

    public MyBean findOne(int first, int second) {
        return myRepository.findOne(new Id(first, second));
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        myRepository = beanFactory.getBean(MyRepository.class);
    }
}

Answer 4

Hay otro problema para considerar aquí. Algunas personas esperan que agregar un método personalizado a su repositorio las exponga automáticamente como servicios REST en el enlace ''/ buscar''. Desafortunadamente, este no es el caso. Spring no es compatible con eso actualmente.

Esta función es ''por diseño'', el repositorio de datos de primavera verifica explícitamente si el método es un método personalizado y no lo expone como un enlace de búsqueda de REST:

private boolean isQueryMethodCandidate(Method method) {    
  return isQueryAnnotationPresentOn(method) || !isCustomMethod(method) && !isBaseClassMethod(method);
}

Esto es un qoute de Oliver Gierke:

Esto es por diseño. Los métodos de repositorio personalizados no son métodos de consulta, ya que pueden implementar de manera efectiva cualquier comportamiento. Por lo tanto, actualmente nos es imposible decidir sobre el método HTTP para exponer el método. POST sería la opción más segura, pero eso no está en línea con los métodos de consulta genéricos (que reciben GET).

Para obtener más detalles, consulte este tema: https://jira.spring.io/browse/DATAREST-206

Answer 5

Si desea poder realizar operaciones más sofisticadas, es posible que necesite acceder a las DATAJPA-422 internas de Spring Data, en cuyo caso funciona lo siguiente (como mi solución provisional para DATAJPA-422 ):

public class AccountRepositoryImpl implements AccountRepositoryCustom {

    @PersistenceContext
    private EntityManager entityManager;

    private JpaEntityInformation<Account, ?> entityInformation;

    @PostConstruct
    public void postConstruct() {
        this.entityInformation = JpaEntityInformationSupport.getMetadata(Account.class, entityManager);
    }

    @Override
    @Transactional
    public Account saveWithReferenceToOrganisation(Account entity, long referralId) {
        entity.setOrganisation(entityManager.getReference(Organisation.class, organisationId));
        return save(entity);
    }

    private Account save(Account entity) {
        // save in same way as SimpleJpaRepository
        if (entityInformation.isNew(entity)) {
            entityManager.persist(entity);
            return entity;
        } else {
            return entityManager.merge(entity);
        }
    }

}

Answer 6

Teniendo en cuenta el fragmento de código, tenga en cuenta que solo puede pasar objetos nativos al método findBy ###, supongamos que quiere cargar una lista de cuentas que pertenece a determinados clientes, una solución es hacer esto,

 @Query("Select a from Account a where a."#nameoffield"=?1")
      List<Account> findByCustomer(String "#nameoffield");

Hacer que el nombre de la tabla que se va a consultar sea lo mismo que la clase Entidad. Para más implementaciones, eche un vistazo a this

Answer 7

Tiene un uso limitado, pero para métodos personalizados simples puede usar métodos de interfaz predeterminados como:

import demo.database.Customer;
import org.springframework.data.repository.CrudRepository;

public interface CustomerService extends CrudRepository<Customer, Long> {


    default void addSomeCustomers() {
        Customer[] customers = {
            new Customer("Józef", "Nowak", "[email protected]", 679856885, "Rzeszów", "Podkarpackie", "35-061", "Zamknięta 12"),
            new Customer("Adrian", "Mularczyk", "[email protected]", 867569344, "Krosno", "Podkarpackie", "32-442", "Hynka 3/16"),
            new Customer("Kazimierz", "Dejna", "[email protected]", 996435876, "Jarosław", "Podkarpackie", "25-122", "Korotyńskiego 11"),
            new Customer("Celina", "Dykiel", "[email protected]", 947845734, "Żywiec", "Śląskie", "54-333", "Polna 29")
        };

        for (Customer customer : customers) {
            save(customer);
        }
    }
}

EDITAR:

En este tutorial de primavera está escrito:

Spring Data JPA también le permite definir otros métodos de consulta simplemente declarando su firma de método.

Entonces, incluso es posible declarar un método como:

Customer findByHobby(Hobby personHobby);

y si el objeto Hobby es propiedad del Cliente, Spring automáticamente definirá el método para usted.