Dane sprężyny: Zastąp metodę zapisu

Question

Rozważam dane źródłowe dla projektu. Czy można zastąpić domyślnie wygenerowaną metodę zapisu? A jeśli tak, to w jaki sposób?

Answer 1

Nie działało to dobrze, więc wprowadziłem wymaganą logikę do klasy usług i pozostawiłem metodę zapisywania nienaruszonych repozytoriów.

Answer 2

Chyba przedłużyć SimpleJpaRepository:

public class **CustomSimpleJpaRepository** extends SimpleJpaRepository { 

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

następnie upewnij się, to jest używana zamiast domyślnej SimpleJpaRepository poprzez rozszerzenie:

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

Jeszcze nie zrobione, musimy też mieć własną fabrykę bean użyć w konfiguracji 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**"/> 

Nadzieję, że to pomaga.

Answer 3

Służy do korzystania z detektorów zdarzeń JPA, takich jak @PrePersist, @PreUpdate. To zadziała, jeśli bazowy dostawca JPA obsługuje te funkcje. Jest to funkcja JPA 2, więc najnowsza wersja Hibernate, EclipseLink itp. Powinna ją obsługiwać.

Answer 4

Po prostu utwórz niestandardowy interfejs i zadeklaruj tam metody, które chcesz ovverride z tą samą sygnaturą, która jest wystawiona przez CrudRepository (lub JpaRepository, itp.). Załóżmy, że masz MyEntity podmiot i MyEntityRepository repozytorium i chcesz zastąpić domyślny automatycznie wygenerowane save metodę MyEntityRepository który odbywa się tylko wystąpienie encji, a następnie określić:

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

i wdrożenie tej metody, jak chcesz w swojej MyEntityRepositoryImpl, jak zwykle:

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

a potem, jak zwykle, niech MyEntityRepository wdrożyć MyEntityRepositoryCustom.

Wykonując to, Spring Data JPA zadzwoni na metodę save Twojego MyEntityRepositoryImpl zamiast domyślnej implementacji. Przynajmniej to działa dla mnie z metodą delete w Spring Data JPA 1.7.2.

Answer 5

Aby zapewnić zastąpienie domyślnie wygenerowanej metody składowania, należy użyć agregacji implementacji repozytorium danych sprężynowych w ramach własnej implementacji własnego repozytorium.

Repository interfejs:

public interface UserRepository extends CrudRepository<User, String>{ 

} 

Repozytorium realizacja:

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

Następnie za pomocą implementacji niestandardowych w usłudze:

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

Answer 6

Może to być pomocne, jeśli ar zamierzamy ponownie użyć oryginalnej metody. Wystarczy wprowadzić EntityManager w klasie implementującej.

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