Sto esaminando l'APP di Spring Data. Considera l'esempio di seguito in cui farò funzionare tutte le funzionalità crud e finder per impostazione predefinita e se voglio personalizzare un finder, ciò può essere fatto facilmente anche nell'interfaccia stessa.

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

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

Vorrei sapere come posso aggiungere un metodo personalizzato completo con la sua implementazione per il suddetto AccountRepository? Dal momento che è un'interfaccia non posso implementare il metodo lì.

Devi creare un'interfaccia separata per i tuoi metodi personalizzati:

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

public interface AccountRepositoryCustom {
    public void customMethod();
}

e fornire una classe di implementazione per tale interfaccia:

public class AccountRepositoryImpl implements AccountRepositoryCustom {

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

    public void customMethod() { ... }
}

Guarda anche:

• 4.6 Implementazioni personalizzate per i repository di dati di primavera

• Si noti che lo schema di denominazione è cambiato tra le versioni. Per maggiori dettagli, consultare https://stackoverflow.com/a/52624752/66686 .

Oltre alla risposta di axtavt , non dimenticare che puoi inserire Entity Manager nella tua implementazione personalizzata se ne hai bisogno per creare le tue query:

public class AccountRepositoryImpl implements AccountRepositoryCustom {

    @PersistenceContext
    private EntityManager em;

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

La risposta accettata funziona, ma presenta tre problemi:

• Utilizza una funzione Spring Data non documentata quando si nomina l'implementazione personalizzata come AccountRepositoryImpl. La documentazione afferma chiaramente che deve essere chiamato AccountRepositoryCustomImpl, il nome dell'interfaccia personalizzata piùImpl
• Non è possibile utilizzare solo l'iniezione del costruttore @Autowired, che sono considerate cattive pratiche
• All'interno dell'implementazione personalizzata esiste una dipendenza circolare (ecco perché non è possibile utilizzare l'iniezione del costruttore).

Ho trovato un modo per renderlo perfetto, anche se non senza usare un'altra funzionalità Spring Data non documentata:

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

L'utilizzo è limitato, ma per semplici metodi personalizzati è possibile utilizzare metodi di interfaccia predefiniti come:

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

MODIFICARE:

In questo tutorial di primavera è scritto:

Spring Data JPA consente inoltre di definire altri metodi di query dichiarando semplicemente la loro firma del metodo.

Quindi è anche possibile dichiarare un metodo come:

Customer findByHobby(Hobby personHobby);

e se l'oggetto Hobbyè di proprietà del Cliente, Spring definirà automaticamente il metodo per te.

Sto usando il seguente codice per accedere ai metodi di ricerca generati dalla mia implementazione personalizzata. Ottenere l'implementazione attraverso la factory bean evita problemi di creazione di bean circolare.

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

Come specificato nella funzionalità documentata , il Implsuffisso ci consente di avere una soluzione pulita:

• Definire @Repositorynell'interfaccia, ad esempio MyEntityRepository, metodi Spring Data o metodi personalizzati
• Crea una classe MyEntityRepositoryImpl(il Implsuffisso è la magia) ovunque (non è nemmeno necessario essere nello stesso pacchetto) che implementa solo i metodi personalizzati e annota tale classe con @Component** ( @Repository non funzionerà).
  • Questa classe può anche essere iniettata MyEntityRepositorytramite @Autowiredper l'uso nei metodi personalizzati.

Esempio:

Classe di entità:

package myapp.domain.myentity;

@Entity
public class MyEntity {

    @Id
    private Long id;

    @Column
    private String comment;

}

Interfaccia del repository:

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 di implementazione dei metodi personalizzati:

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

}

I piccoli inconvenienti che ho identificato sono:

• I metodi personalizzati in Impl classe sono contrassegnati come non utilizzati dal compilatore, quindi il @SuppressWarnings("unused")suggerimento.
• Hai un limite di una Implclasse. (Mentre nella normale implementazione delle interfacce di frammenti i documenti suggeriscono che potresti averne molti.)

Se vuoi essere in grado di eseguire operazioni più sofisticate potresti aver bisogno di accedere agli interni di Spring Data, nel qual caso funziona come la mia soluzione intermedia a 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);
        }
    }

}

Considerando il tuo frammento di codice, tieni presente che puoi solo passare oggetti nativi al metodo findBy ###, supponiamo che tu voglia caricare un elenco di account che appartiene a determinati clienti, una soluzione è fare questo,

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

Fai causa il nome della tabella da interrogare è la stessa classe Entità. Per ulteriori implementazioni, dai un'occhiata a questo

C'è un altro problema da considerare qui. Alcune persone prevedono che l'aggiunta di un metodo personalizzato al repository li esporrà automaticamente come servizi REST nel collegamento "/ cerca". Purtroppo non è così. Spring non lo supporta attualmente.

Questa è la funzionalità "in base alla progettazione", il resto dei dati di primavera controlla esplicitamente se il metodo è un metodo personalizzato e non lo espone come collegamento di ricerca REST:

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

Questo è un qoute di Oliver Gierke:

Questo è di progettazione. I metodi di repository personalizzati non sono metodi di query in quanto possono implementare in modo efficace qualsiasi comportamento. Pertanto, al momento è impossibile per noi decidere il metodo HTTP per esporre il metodo sotto. Il POST sarebbe l'opzione più sicura ma non è in linea con i metodi di query generici (che ricevono GET).

Per maggiori dettagli vedi questo numero: https://jira.spring.io/browse/DATAREST-206

Aggiunta di comportamento personalizzato a tutti i repository:

Per aggiungere un comportamento personalizzato a tutti i repository, è innanzitutto necessario aggiungere un'interfaccia intermedia per dichiarare il comportamento condiviso.

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

    void sharedCustomMethod( ID id );
}

Ora le tue singole interfacce di repository estenderanno questa interfaccia intermedia anziché l'interfaccia del repository per includere la funzionalità dichiarata.

Quindi, creare un'implementazione dell'interfaccia intermedia che estende la classe base del repository specifica della tecnologia di persistenza. Questa classe fungerà quindi da classe di base personalizzata per i proxy repository.

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

Repository di dati di primavera Parte I. Riferimento

Estendo il 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;
    }
}

e aggiunge questa classe a repositoryBaseClass @EnableJpaRepositoryries.