Xtykutl

In addition to Raheela Aslam post:

Spring-data documentation has an example of how you can override standard repository methods, for example:

interface CustomizedSave<T> {

  <S extends T> S save(S entity);

}



class CustomizedSaveImpl<T> implements CustomizedSave<T> {



  public <S extends T> S save(S entity) {

    // Your custom implementation

  }

}



interface UserRepository extends CrudRepository<User, Long>, CustomizedSave<User> {

}

You can read about it there:
https://docs.spring.io/spring-data/jpa/docs/2.1.2.RELEASE/reference/html/#repositories.custom-implementations

UPD:
Read it carefully, because there are some important things, e.g
The most important part of the class name that corresponds to the fragment interface is the Impl postfix.

Also the documentation says:
Custom implementations have a higher priority than the base implementation and repository aspects.

There are several ways to do this depending on what you're trying to do:

• Use method naming, and let Spring derive the JPQL query from the naming (https://www.petrikainulainen.net/programming/spring-framework/spring-data-jpa-tutorial-creating-database-queries-from-method-names/)


• Use the Query annotation and add the desired JPQL query in the annotation (https://www.petrikainulainen.net/programming/spring-framework/spring-data-jpa-tutorial-creating-database-queries-with-the-query-annotation/)


• Use a named query (https://www.petrikainulainen.net/programming/spring-framework/spring-data-jpa-tutorial-creating-database-queries-with-named-queries/)

I prefer to use method naming if possible, the method name gets long, but you know exactly what it does by looking at it.

In your case code will be like as below:

public interface UserRepo extends JpaRepository<User, Long>

{

    findUserById(long id);



    findUserByEmail(String email);



    // etc...

}



public interface UserRepositoryCustom {



    void deleteByEmail(String email);

}



public interface UserRepositoryImpl implements UserRepositoryCustom {



    public void deleteByEmail(String email) {

        //provide your custom implimentation

    }

}

If you want to keep Spring's behavior for deletion, but want to have some logic to be executed either before or after, you may utilize java8's interface default methods, and try the following :

public interface UserRepo extends JpaRepository<User, Long> {



    default void customDelete(User user) {

       // before logic

       // ..

       delete(user); // actual call to deletion

       // after logic

       // ..

     }



}

Hi you can write your own Interface write implementation with EntityManager and
extend in you interface here is the sample :

• https://dzone.com/articles/accessing-the-entitymanager-from-spring-data-jpa

Actually one more way is writing by soemthing like :

 User findByUsername(String username) // it will find the user by specific username 

spring data will create you an implementation of this method
The same way you can create your own delete method

Here is useful links:

https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories.custom-implementations

In this link you can go to part 2.3 QueryMethods:

• https://docs.spring.io/spring-data/jpa/docs/1.6.0.RELEASE/reference/html/jpa.repositories.html

You can also define @NameQuery in your entity class:

@Entity

@Table(name = "employee", schema="spring_data_jpa_example")

@NamedQuery(name = "Employee.yourMethodQueryName",

        query = "yourQuery"

)

public class Employee {}



@Repository

public interface EmployeeRepository extends JpaRepository<Employee,Long> {



    List<Employee> yourMethodQueryName(Your list of params);

}

Here is link with sample:

• https://www.logicbig.com/tutorials/spring-framework/spring-data/jpa-named-queries.html

I think this is helpful for you

public interface UserRepo extends JpaRepository<User, Long> {

    @Modifying

    @Query("delete from User u where u.email = ?1")

    void deleteByEmail(String email);



}