Spring Data JPA를 찾고 있습니다. 기본적으로 모든 크루 드 및 파인더 기능이 작동하는 아래 예제를 고려하고 파인더를 사용자 정의하려면 인터페이스 자체에서 쉽게 수행 할 수 있습니다.

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

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

위의 AccountRepository에 대한 구현으로 완전한 사용자 정의 메소드를 추가하는 방법을 알고 싶습니다. 인터페이스 때문에 메소드를 구현할 수 없습니다.

사용자 정의 메소드에 대해 별도의 인터페이스를 작성해야합니다.

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

public interface AccountRepositoryCustom {
    public void customMethod();
}

해당 인터페이스에 대한 구현 클래스를 제공하십시오.

public class AccountRepositoryImpl implements AccountRepositoryCustom {

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

    public void customMethod() { ... }
}

또한보십시오:

• 스프링 데이터 저장소를위한 커스텀 구현

• 이름 지정 체계는 버전간에 변경되었습니다. 자세한 내용은 https://stackoverflow.com/a/52624752/66686 을 참조하십시오.

axtavt의 답변 외에도 쿼리를 작성하는 데 필요한 경우 사용자 정의 구현에 Entity Manager를 삽입 할 수 있음을 잊지 마십시오.

public class AccountRepositoryImpl implements AccountRepositoryCustom {

    @PersistenceContext
    private EntityManager em;

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

수락 된 답변은 효과가 있지만 세 가지 문제가 있습니다.

• 커스텀 구현을로 명명 할 때 문서화되지 않은 스프링 데이터 기능을 사용합니다 AccountRepositoryImpl. 문서는 명확하게 호출 할 것을 명시 AccountRepositoryCustomImpl, 사용자 정의 인터페이스 이름과Impl
• @Autowired나쁜 습관으로 간주되는 생성자 주입 만 사용할 수 없습니다.
• 사용자 정의 구현 내부에 순환 종속성이 있습니다 (따라서 생성자 삽입을 사용할 수 없습니다).

문서화되지 않은 다른 스프링 데이터 기능을 사용하지 않고도 완벽하게 만드는 방법을 찾았습니다.

public interface AccountRepository extends AccountRepositoryBasic,
                                           AccountRepositoryCustom 
{ 
}

public interface AccountRepositoryBasic extends JpaRepository<Account, Long>
{
    // standard Spring Data methods, like findByLogin
}

public interface AccountRepositoryCustom 
{
    public void customMethod();
}

public class AccountRepositoryCustomImpl implements AccountRepositoryCustom 
{
    private final AccountRepositoryBasic accountRepositoryBasic;

    // constructor-based injection
    public AccountRepositoryCustomImpl(
        AccountRepositoryBasic accountRepositoryBasic)
    {
        this.accountRepositoryBasic = accountRepositoryBasic;
    }

    public void customMethod() 
    {
        // we can call all basic Spring Data methods using
        // accountRepositoryBasic
    }
}

사용에는 제한이 있지만 간단한 사용자 정의 메소드의 경우 다음 과 같은 기본 인터페이스 메소드를 사용할 수 있습니다 .

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", "nowakJ@o2.pl", 679856885, "Rzeszów", "Podkarpackie", "35-061", "Zamknięta 12"),
            new Customer("Adrian", "Mularczyk", "adii333@wp.pl", 867569344, "Krosno", "Podkarpackie", "32-442", "Hynka 3/16"),
            new Customer("Kazimierz", "Dejna", "sobieski22@weebly.com", 996435876, "Jarosław", "Podkarpackie", "25-122", "Korotyńskiego 11"),
            new Customer("Celina", "Dykiel", "celina.dykiel39@yahoo.org", 947845734, "Żywiec", "Śląskie", "54-333", "Polna 29")
        };

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

편집하다:

이번 봄 튜토리얼 에서는 다음과 같이 작성되었습니다.

Spring Data JPA를 사용하면 메소드 서명을 선언하여 다른 쿼리 메소드를 정의 할 수도 있습니다.

따라서 다음과 같은 메소드를 선언하는 것조차 가능합니다.

Customer findByHobby(Hobby personHobby);

객체 Hobby가 Customer의 속성이라면 Spring은 자동으로 메소드를 정의합니다.

내 사용자 정의 구현에서 생성 된 찾기 메소드에 액세스하기 위해 다음 코드를 사용하고 있습니다. Bean Factory를 통해 구현하면 순환 Bean 작성 문제가 방지됩니다.

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);
    }
}

문서화 된 기능 에 Impl명시된 바와 같이 접미사를 사용하면 다음과 같이 깨끗한 솔루션을 얻을 수 있습니다.

• 에 정의 @Repository말하자면, 인터페이스 MyEntityRepository방법 또는 사용자 정의 방법을 어느 봄 데이터
• 커스텀 메소드 만 구현 하는 클래스 MyEntityRepositoryImpl( Impl접미사는 마술 임)를 작성 하고 ** ( 작동 하지 않음 )로 클래스에 주석을 달십시오 . @Component@Repository
  • 이 클래스도 삽입 할 수 MyEntityRepository를 통해 @Autowired사용자 정의 방법에 사용합니다.

예:

엔터티 클래스 :

package myapp.domain.myentity;

@Entity
public class MyEntity {

    @Id
    private Long id;

    @Column
    private String comment;

}

리포지토리 인터페이스 :

package myapp.domain.myentity;

@Repository
public interface MyEntityRepository extends JpaRepository<MyEntity, Long> {

    // EXAMPLE SPRING DATA METHOD
    List<MyEntity> findByCommentEndsWith(String x);

    List<MyEntity> doSomeHql(Long id);

    List<MyEntity> useTheRepo(Long id);

}

사용자 정의 메소드 구현 Bean :

package myapp.infrastructure.myentity;

@Component // Must be @Component !!
public class MyEntityRepositoryImpl { // must have the repo name + Impl !!

    @PersistenceContext
    private EntityManager entityManager;

    @Autowired
    private MyEntityRepository myEntityRepository;

    @SuppressWarnings("unused")
    public List<MyEntity> doSomeHql(Long id) {
        String hql = "SELECT eFROM MyEntity e WHERE e.id = :id";
        TypedQuery<MyEntity> query = entityManager.createQuery(hql, MyEntity.class);
        query.setParameter("id", id);
        return query.getResultList();
    }

    @SuppressWarnings("unused")
    public List<MyEntity> useTheRepo(Long id) {
        List<MyEntity> es = doSomeHql(id);
        es.addAll(myEntityRepository.findByCommentEndsWith("DO"));
        es.add(myEntityRepository.findById(2L).get());
        return es;
    }

}

내가 확인한 작은 단점은 다음과 같습니다.

• Impl클래스 의 사용자 정의 메소드 는 컴파일러에서 사용하지 않는 것으로 표시되어 @SuppressWarnings("unused")제안됩니다.
• 한 Impl클래스 로 제한 됩니다. (정규 조각 인터페이스 구현 에서 문서 는 많은 것을 가질 수 있다고 제안 합니다.)

좀 더 정교한 작업을 수행하려면 Spring Data의 내부에 액세스해야 할 수 있습니다.이 경우 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);
        }
    }

}

코드 스 니펫을 고려하면 기본 객체를 findBy ### 메소드에만 전달할 수 있으며 특정 costumers에 속한 계정 목록을로드하려고한다고 말할 수 있습니다. 하나의 해결책은이를 수행하는 것입니다.

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

쿼리 할 테이블의 이름이 Entity 클래스와 동일해야합니다. 추가 구현에 대해서는 이것을 살펴보십시오.

여기서 고려해야 할 또 다른 문제가 있습니다. 어떤 사람들은 사용자 정의 메소드를 저장소에 추가하면 자동으로 '/ search'링크 아래에서 REST 서비스로 표시 할 것으로 기대합니다. 불행히도 그렇지 않습니다. Spring은 현재이를 지원하지 않습니다.

이것은 '디자인에 의한'기능이며 스프링 데이터 레스트는 메소드가 사용자 정의 메소드인지 명시 적으로 확인하고 REST 검색 링크로 표시하지 않습니다.

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

올리버 지 에르케 (Oliver Gierke)

이것은 의도적으로 설계된 동작입니다. 사용자 정의 리포지토리 방법은 동작을 효과적으로 구현할 수 있으므로 쿼리 방법이 아닙니다. 따라서 현재 메소드를 공개 할 HTTP 메소드를 결정하는 것은 불가능합니다. POST는 가장 안전한 옵션이지만 GET을받는 일반적인 쿼리 방법과 일치하지 않습니다.

자세한 내용은이 문제를 참조하십시오 : https://jira.spring.io/browse/DATAREST-206

모든 리포지토리에 사용자 지정 동작 추가 :

모든 리포지토리에 사용자 지정 동작을 추가하려면 먼저 중간 인터페이스를 추가하여 공유 동작을 선언하십시오.

public interface MyRepository <T, ID extends Serializable> extends JpaRepository<T, ID>
{

    void sharedCustomMethod( ID id );
}

이제 개별 리포지토리 인터페이스는 리포지토리 인터페이스 대신이 중간 인터페이스를 확장하여 선언 된 기능을 포함합니다.

다음으로, 지속성 기술 특정 저장소 기본 클래스를 확장하는 중간 인터페이스의 구현을 작성하십시오. 그런 다음이 클래스는 저장소 프록시의 사용자 정의 기본 클래스로 작동합니다.

public class MyRepositoryImpl <T, ID extends Serializable> extends SimpleJpaRepository<T, ID> implements MyRepository<T, ID>
{

    private EntityManager entityManager;

       // There are two constructors to choose from, either can be used.
    public MyRepositoryImpl(Class<T> domainClass, EntityManager entityManager)
    {
        super( domainClass, entityManager );

        // This is the recommended method for accessing inherited class dependencies.
        this.entityManager = entityManager;
    }


    public void sharedCustomMethod( ID id )
    {
        // implementation goes here
    }
}

스프링 데이터 리포지토리 Part I. Reference

SimpleJpaRepository를 확장합니다.

public class ExtendedRepositoryImpl<T extends EntityBean> extends SimpleJpaRepository<T, Long>
    implements ExtendedRepository<T> {

    private final JpaEntityInformation<T, ?> entityInformation;

    private final EntityManager em;

    public ExtendedRepositoryImpl(final JpaEntityInformation<T, ?> entityInformation,
                                                      final EntityManager entityManager) {
       super(entityInformation, entityManager);
       this.entityInformation = entityInformation;
       this.em = entityManager;
    }
}

이 클래스를 @EnableJpaRepositoryries repositoryBaseClass에 추가합니다.