Wiosna JPA @Query z LIKE

Próbuję stworzyć metodę w CrudRepository, która będzie w stanie podać mi listę użytkowników, których nazwy użytkowników są TAKIE JAK parametr wejściowy (nie tylko zaczynają się, ale również zawierają). Próbowałem użyć metody, "findUserByUsernameLike(@Param("username") String username)"ale jak jest powiedziane w dokumentacji Spring, ta metoda jest równa " where user.username like ?1". Nie jest to dla mnie dobre, ponieważ już powiedziałem, że próbuję zdobyć wszystkich użytkowników, których nazwa użytkownika zawiera ...

Napisałem zapytanie do metody, ale ona nawet się nie wdraża.

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

Czy ktoś może mi w tym pomóc?

Spróbuj zastosować następujące podejście (u mnie działa):

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

Uwaga: nazwa tabeli w JPQL musi zaczynać się wielką literą.

Używając tworzenia zapytań na podstawie nazw metod , sprawdź tabelę 4, w której objaśniono niektóre słowa kluczowe.

1. Korzystanie z Like: select ... like :username

    List<User> findByUsernameLike(String username);
   

2. Począwszy od: select ... like :username%

    List<User> findByUsernameStartingWith(String username);
   

3. Kończące się: select ... like %:username

    List<User> findByUsernameEndingWith(String username);
   

4. Zawierający: select ... like %:username%

    List<User> findByUsernameContaining(String username);
   

Zwróć uwagę, że odpowiedź, której szukasz, to numer 4 . Nie musisz używać @Query

Inny sposób: zamiast CONCATfunkcji możemy użyć podwójnej kreski:: lastname || „%”

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

Możesz wstawić dowolne miejsce, prefiks, sufiks lub oba

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

List<User> findByUsernameContainingIgnoreCase(String username);

aby zignorować problemy ze sprawami

W twoim przypadku możesz bezpośrednio użyć metod JPA. To jest jak poniżej:

Zawiera: wybierz ... jak%: nazwa użytkownika%

List<User> findByUsernameContainingIgnoreCase(String username);

tutaj IgnoreCase pomoże ci wyszukać element z ignorowaniem przypadku.

Oto kilka powiązanych metod:

1. Lubić findByFirstnameLike

   … Gdzie x.firstname jak? 1

2. Zaczynając od findByFirstnameStartingWith

   … Gdzie x.firstname jak? 1 (parametr powiązany z dołączonym%)

3. EndingWith findByFirstnameEndingWith

   … Gdzie x.firstname jak? 1 (parametr powiązany z przedrostkiem%)

4. Zawierający findByFirstnameContaining

   … Gdzie x.firstname jak? 1 (parametr powiązany z%)

Więcej informacji, zobacz ten link i ten link

Mam nadzieję, że to ci pomoże :)

Łatwy w użyciu (nie ma potrzeby używania CONCAT lub ||):

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

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

Ten sposób działa dla mnie (używając Spring Boot w wersji 2.0.1. RELEASE):

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

Wyjaśnienie:? 1,? 2,? 3 itd. To symbole zastępcze pierwszego, drugiego, trzeciego parametru itd. W tym przypadku wystarczy, aby parametr był otoczony przez%, tak jakby to było standardowe zapytanie SQL, ale bez pojedyncze cytaty.

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

Wypróbowałem ten kod i działa.