Spring JPA @Query com LIKE

Estou tentando fazer um método em CrudRepository que será capaz de me dar uma lista de usuários, cujos nomes de usuário são como o parâmetro de entrada (não só começa com, mas também o contém). Tentei usar o método, "findUserByUsernameLike(@Param("username") String username)"mas como é dito na documentação do Spring, esse método é igual a " where user.username like ?1". Não é bom para mim, como já disse que estou tentando obter todos os usuários cujo nome de usuário contenha ...

Eu escrevi uma consulta ao método, mas nem mesmo implanta.

@Repository
public interface UserRepository extends CrudRepository<User, Long> {

@Query("select u from user u where u.username like '%username%'")
List<User> findUserByUsernameLike(@Param("username") String username);
}

Alguém pode me ajudar com isso?

Tente usar a seguinte abordagem (funciona para mim):

@Query("SELECT u.username FROM User u WHERE u.username LIKE CONCAT('%',:username,'%')")
List<String> findUsersWithPartOfName(@Param("username") String username);

Aviso: o nome da tabela em JPQL deve começar com letra maiúscula.

Usando a criação de consulta a partir de nomes de métodos , verifique a tabela 4, onde explicam algumas palavras-chave.

1. Usando Curtir: selecione ... como: nome de usuário

   List<User> findByUsernameLike(String username);

2. Começando com: selecione ... como: nome de usuário%

   List<User> findByUsernameStartingWith(String username);

3. EndingWith: select ... like%: username

   List<User> findByUsernameEndingWith(String username);

4. Contendo: select ... like%: username%

   List<User> findByUsernameContaining(String username);

Observe que a resposta que você está procurando é a número 4 . Você não precisa usar @Query

Outra maneira: em vez da CONCATfunção, podemos usar tubo duplo :: sobrenome || '%'

@Query("select c from Customer c where c.lastName LIKE :lastname||'%'")
List<Customer> findCustomByLastName( @Param("lastname") String lastName);

Você pode colocar em qualquer lugar, prefixo, sufixo ou ambos

:lastname ||'%'  
'%' || :lastname  
'%' || :lastname || '%'  

List<User> findByUsernameContainingIgnoreCase(String username);

a fim de ignorar problemas de caso

Seguimento fácil de usar (sem necessidade de usar CONCAT ou ||):

@Query("from Service s where s.category.typeAsString like :parent%")
List<Service> findAll(@Param("parent") String parent);

Documentado em: http://docs.spring.io/spring-data/jpa/docs/current/reference/html .

Para o seu caso, você pode usar métodos JPA diretamente. É como abaixo:

Contendo: select ... like%: username%

List<User> findByUsernameContainingIgnoreCase(String username);

aqui, IgnoreCase irá ajudá-lo a pesquisar o item ignorando o caso.

Aqui estão alguns métodos relacionados:

1. Gostar findByFirstnameLike

   … Onde x.firstname gosta? 1

2. Começando com findByFirstnameStartingWith

   … Onde x.firstname like? 1 (parâmetro vinculado a% anexado)

3. EndingWith findByFirstnameEndingWith

   … Onde x.firstname like? 1 (parâmetro vinculado a% prefixado)

4. Contendo findByFirstnameContaining

   … Onde x.firstname like? 1 (limite de parâmetro envolvido em%)

Mais informações, veja este link e este link

Espero que isso ajude você :)

Esta maneira funciona para mim, (usando Spring Boot versão 2.0.1. RELEASE):

@Query("SELECT u.username FROM User u WHERE u.username LIKE %?1%")
List<String> findUsersWithPartOfName(@Param("username") String username);

Explicando: O? 1,? 2,? 3 etc. são espaços reservados para o primeiro, segundo, terceiro parâmetros, etc. Neste caso é suficiente ter o parâmetro cercado por% como se fosse uma consulta SQL padrão, mas sem o aspas simples.

@Query("select u from user u where u.username LIKE :username")
List<User> findUserByUsernameLike(@Param("username") String username);

@Query("select b.equipSealRegisterId from EquipSealRegister b where b.sealName like %?1% and b.deleteFlag = '0'" )
    List<String>findBySeal(String sealname);

Eu tentei este código e funciona.