Dati primaverili: metodo di sostituzione dell'override

Question

Sto considerando i dati di primavera per un progetto. È possibile sovrascrivere il metodo di salvataggio generato per impostazione predefinita? E se si, come?

Answer 1

Non ha funzionato correttamente, quindi ho inserito la logica necessaria in una classe di servizio e ho lasciato invariato il metodo di salvataggio dei repository.

Answer 2

Credo che si estende SimpleJpaRepository:

public class **CustomSimpleJpaRepository** extends SimpleJpaRepository { 

@Transactional 
public <S extends T> S save(S entity) { //do what you want instead } 
} 

quindi assicurarsi che questo è usato al posto del SimpleJpaRepository predefinito estendendo:

public class CustomJpaRepositoryFactory extends JpaRepositoryFactory { 

    protected <T, ID extends Serializable> JpaRepository<?, ?> getTargetRepository(RepositoryMetadata metadata, EntityManager entityManager) { 

     Class<?> repositoryInterface = metadata.getRepositoryInterface(); 
     JpaEntityInformation<?, Serializable> entityInformation = getEntityInformation(metadata.getDomainType()); 

     SimpleJpaRepository<?, ?> repo = isQueryDslExecutor(repositoryInterface) ? new QueryDslJpaRepository(
      entityInformation, entityManager) : new CustomSimpleJpaRepository(entityInformation, entityManager); 
    repo.setLockMetadataProvider(lockModePostProcessor.getLockMetadataProvider()); 

     return repo; 
    } 
} 

Non ancora fatto, abbiamo anche bisogno di avere la tua propria fabbrica bean per utilizzarlo nella configurazione xml:

public class CustomRepositoryFactoryBean <T extends JpaRepository<S, ID>, S, ID extends Serializable> extends JpaRepositoryFactoryBean<T, S, ID> { 

protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityManager) { 
    return new **CustomJpaRepositoryFactory**(entityManager); 
} 

}

config:

<jpa:repositories base-package="bla.bla.dao" factory-class="xxxx.**CustomRepositoryFactoryBean**"/> 

Speranza che aiuta.

Answer 3

Utilizzare listener di eventi JPA come @PrePersist, @PreUpdate. Ciò funzionerà se il provider JPA sottostante supporta queste funzionalità. Questa è la caratteristica di JPA 2, quindi l'ultima versione di Hibernate, EclipseLink ecc. Dovrebbe supportarla.

Answer 4

Semplicemente crea la tua interfaccia personalizzata come al solito e dichiara i metodi che vuoi sovrascrivere con la stessa firma di quella esposta da CrudRepository (o JpaRepository, ecc.). Supponiamo di avere un MyEntity un'entità e un repository MyEntityRepository e si desidera ignorare l'auto-generata save metodo predefinito di MyEntityRepository che prende un solo esempio entità, quindi definire:

public interface MyEntityRepositoryCustom { 
    <S extends MyEntity> S save(S entity); 
} 

e implementare questo metodo come ti piace nella tua MyEntityRepositoryImpl, come al solito:

@Transactional 
public class MyEntityRepositoryImpl implements MyEntityRepositoryCustom { 
    public <S extends MyEntity> S save(S entity) { 
    // your implementation 
    } 
} 

E poi, come al solito, diamo MyEntityRepository implementare MyEntityRepositoryCustom.

In questo modo, Spring Data JPA chiamerà il metodo save del proprio MyEntityRepositoryImpl invece dell'implementazione predefinita. Almeno questo funziona per me con il metodo delete in Spring Data JPA 1.7.2.

Answer 5

Per fornire l'override del metodo di salvataggio generato predefinito, è necessario utilizzare l'aggregazione dell'implementazione del repository Spring Data all'interno dell'implementazione del repository personalizzato.

interfaccia Repository:

public interface UserRepository extends CrudRepository<User, String>{ 

} 

Il repository implementazione:

@Repository("customUserRepository") 
public class CustomUserRepository implements UserRepository { 

    @Autowired 
    @Qualifier("userRepository") // inject Spring implementation here 
    private UserRepository userRepository; 

    public User save(User user) { 
     User user = userRepository.save(entity); 
     // Your custom code goes here 
     return user; 
    } 

    // Delegate other methods here ... 

    @Override 
    public User findOne(String s) { 
     return userRepository.findOne(s); 
    } 
} 

quindi utilizzare l'un'implementazione personalizzata nel vostro servizio:

@Autowired 
@Qualifier("customUserRepository") 
private UserRepository userRepository; 

Answer 6

Questo potrebbe essere utile se si ar E intenzione di riutilizzare il metodo originale. È sufficiente iniettare EntityManager nella classe di implementazione.

public interface MyEntityRepositoryCustom { 
    <S extends MyEntity> S save(S entity); 
} 

public class MyEntityRepositoryImpl implements MyEntityRepositoryCustom { 

    // optionally specify unitName, if there are more than one 
    @PersistenceContext(unitName = PRIMARY_ENTITY_MANAGER_FACTORY) 
    private EntityManager entityManager; 

    /** 
    * @see org.springframework.data.jpa.repository.support.SimpleJpaRepository 
    */ 
    @Transactional 
    public <S extends MyEntity> S save(S entity) { 
     // do your logic here 
     JpaEntityInformation<MyEntity, ?> entityInformation = JpaEntityInformationSupport.getMetadata(MyEntity.class, entityManager); 
     if (entityInformation.isNew(entity)) { 
      entityManager.persist(entity); 
      return entity; 
     } else { 
      return entityManager.merge(entity); 
     } 
    } 
}