如何向Spring Data JPA添加自定义方法

时间：2012-08-09 10:00:08

标签： java spring-data spring-data-jpa

我正在研究Spring Data JPA。考虑下面的示例，我将默认使用所有crud和finder功能，如果我想自定义查找器，那么也可以在界面本身轻松完成。

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

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

我想知道如何为上述AccountRepository添加完整的自定义方法及其实现？由于它是一个接口，我无法在那里实现该方法。

15 个答案:

答案 0 :(得分：239)

您需要为自定义方法创建单独的界面：

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

public interface AccountRepositoryCustom {
    public void customMethod();
}

并为该接口提供实现类：

public class AccountRepositoryImpl implements AccountRepositoryCustom {

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

    public void customMethod() { ... }
}

另见：

答案 1 :(得分：67)

除了axtavt的answer之外，请不要忘记，如果您需要它来构建查询，可以在自定义实现中注入实体管理器：

public class AccountRepositoryImpl implements AccountRepositoryCustom {

    @PersistenceContext
    private EntityManager em;

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

答案 2 :(得分：10)

这在使用上受到限制，但对于简单的自定义方法，您可以使用默认接口方法，例如：

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

编辑：

在this spring教程中写道：

  

Spring Data JPA还允许您通过定义其他查询方法   简单地声明他们的方法签名。

所以甚至可以声明如下方法：

Customer findByHobby(Hobby personHobby);

如果对象Hobby是Customer的属性，那么Spring将自动为您定义方法。

答案 3 :(得分：6)

可接受的答案有效，但是存在三个问题：

  • 将自定义实现命名为AccountRepositoryImpl时，它将使用未记录的Spring Data功能。 documentation明确指出必须将其命名为AccountRepositoryCustomImpl，自定义接口名称加上Impl
  • 您不能仅使用@Autowired的构造函数注入，这被认为是不好的做法
  • 自定义实现中有一个循环依赖关系（这就是为什么不能使用构造函数注入的原因）。

我找到了一种使其完美的方法，尽管并非没有使用另一个未公开的Spring Data功能：

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

答案 4 :(得分：5)

我使用以下代码从我的自定义实现中访问生成的find方法。通过bean工厂实现实现可以防止循环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);
    }
}

答案 5 :(得分：4)

考虑到您的代码段，请注意您只能将Native对象传递给findBy ###方法，假设您要加载属于某些客户的帐户列表，一个解决方案是执行此操作，

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

使sue要查询的表的名称与Entity类相同。 如需进一步实施，请查看this

答案 6 :(得分：3)

如果您希望能够执行更复杂的操作，您可能需要访问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);
        }
    }

}

答案 7 :(得分：3)

这里还有另一个问题需要考虑。有些人希望在您的存储库中添加自定义方法会在“/ search”链接下自动将它们公开为REST服务。遗憾的是，情况并非如此。 Spring目前不支持。

这是'按设计'功能，spring data rest显式检查方法是否为自定义方法，并且不将其公开为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

答案 8 :(得分：2)

向所有存储库添加自定义行为：

要将自定义行为添加到所有存储库，请首先添加一个中间接口以声明共享行为。

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

Spring Data Repositories Part I. Reference

enter image description here

答案 9 :(得分：0)

我扩展了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。

答案 10 :(得分：0)

根据documented functionality的具体说明，使用Impl前缀可以使我们拥有一个非常干净的解决方案：

  • 在@Repository界面中定义MyEntityRepository，使用Spring Data方法或自定义方法
  • 在仅实现自定义方法的任何地方（甚至不需要放在同一程序包中）创建一个类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类。 （而在常规片段接口实现the docs suggest中，您可以有很多。）

答案 11 :(得分：0)

旁注：

在为Spring数据存储库创建自定义实现时：

  

类名最重要的部分，它对应于   片段接口是 Impl 后缀。

答案 12 :(得分：0)

我使用SimpleJpaRepository作为存储库实现的基类，并在接口中添加自定义方法，例如：

public interface UserRepository  {
    User FindOrInsert(int userId);
}

@Repository
public class UserRepositoryImpl extends SimpleJpaRepository implements UserRepository {

    private RedisClient redisClient;

    public UserRepositoryImpl(RedisClient redisClient, EntityManager em) {
        super(User.class, em);
        this.redisClient = redisClient;
    }


@Override
public User FindOrInsert(int userId) {

    User u = redisClient.getOrSet("test key.. User.class, () -> {
        Optional<User> ou = this.findById(Integer.valueOf(userId));
        return ou.get();
    });
    …………
    return u;
}

答案 13 :(得分：0)

我喜欢Danila的解决方案并开始使用它，但是团队中没有其他人喜欢为每个存储库创建4个类。 Danila的解决方案是这里唯一的一个让您使用Impl类中的Spring Data方法的解决方案。但是，我找到了一种只用一个类就可以做到的方法：

public interface UserRepository extends MongoAccess, PagingAndSortingRepository<User> {

    List<User> getByUsername(String username);


    default List<User> getByUsernameCustom(String username) {
        // Can call Spring Data methods!
        findAll();

        // Can write your own!
        MongoOperations operations = getMongoOperations();
        return operations.find(new Query(Criteria.where("username").is(username)), User.class);
    }
}

您只需要某种方式即可访问您的db bean（在此示例中为MongoOperations）。 MongoAccess通过直接检索Bean提供对所有存储库的访问：

public interface MongoAccess {
    default MongoOperations getMongoOperations() {
        return BeanAccessor.getSingleton(MongoOperations.class);
    }
}

BeanAccessor在哪里：

@Component
public class BeanAccessor implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    public static <T> T getSingleton(Class<T> clazz){
        return applicationContext.getBean(clazz);
    }

    public static <T> T getSingleton(String beanName, Class<T> clazz){
        return applicationContext.getBean(beanName, clazz);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        BeanAccessor.applicationContext = applicationContext;
    }

}

不幸的是，您不能在界面中使用@Autowire。您可以将bean自动连接到MongoAccessImpl中，并在接口中提供一种访问它的方法，但是Spring Data崩溃了。我认为它不希望看到Impl与PagingAndSortingRepository间接相关。

答案 14 :(得分：0)

我使用 mongo 和 spring 来解决这个问题。所以让我们假设我们使用 MongoRepository 来提供基本的 crud 操作，并且假设我们需要使用 mongoTemplate 实现一些自定义条件查询操作。要实现一个接口来为 crud 和 custom 注入存储库，我们需要指定：

自定义界面：

public interface UserCustomRepository {
 List<User> findAllUsersBySomeCriteria(UserCriteriaRequest criteriaRequest);
}

UserRepository 接口'必须'首先扩展 UserCustomRepository 然后是 MongoRepository

@Repository
public interface UserRepository extends UserCustomRepository, MongoRepository<User, ObjectId> {
}

UserRepositoryImpl 必须与带有 *Impl 后缀的 crud 接口同名。

@Component
@NoArgsConstructor
@AllArgsConstructor(onConstructor = @__(@Autowired))
public class UserRepositoryImpl implements UserCustomRepository {

 private MongoTemplate mongoTemplate;

 @Override
 public List<User> findAllUsersBySomeCriteria(UserCriteriaRequest criteriaRequest){
  //some impl
 }
}

让我们实现一些服务 - 这里我们只注入 UserRepository 接口并使用来自 crud 存储库和自定义类 impl 的方法。

@Service
@NoArgsConstructor
@AllArgsConstructor(onConstructor = @__(@Autowired))
public class UserService {

 private UserRepository userReposityry;

 public List<User> getUserByCriteria(UserCriteriaRequest request) {
   userRepository.findById(request.getUserId); // Crud repository method
   userRepository.findAllUsersBySomeCriteria(request); // custom method.
 }
}
相关问题
最新问题