Spring Boot JPA Sample Maven Project With Query Methods

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Contest {
  
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String contestName;
    private String contestDescription;

    protected Contest() {
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }
    
    public String getContestName() {
        return contestName;
    }

    public void setContestName(String contestName) {
        this.contestName = contestName;
    }

    public String getContestDescription() {
        return contestDescription;
    }

    public void setContestDescription(String contestDescription) {
        this.contestDescription = contestDescription;
    }

    @Override
    public String toString() {
        return "Contest [contestName=" + contestName + ", contestDescription=" + contestDescription + "]";
    }

}

import javax.persistence.EntityManagerFactory;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalEntityManagerFactoryBean;

@Configuration
// Entire package contents of 
// com.gfg.jpaquerymethods need to be looked
@EnableJpaRepositories(basePackages = {"com.gfg.jpaquerymethods"})
public class ContestAppConfiguration {
    @Bean
    public LocalEntityManagerFactoryBean entityManagerFactory() {
        LocalEntityManagerFactoryBean factoryBean = new LocalEntityManagerFactoryBean();
        factoryBean.setPersistenceUnitName("GeeksDB");
        
        return factoryBean;
    }
    
    @Bean
    public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactory);
        
        return transactionManager;
    }    
}

import java.util.List;
import java.util.Optional;
import java.util.concurrent.Future;
import java.util.stream.Stream;

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;
import org.springframework.scheduling.annotation.Async;

public interface ContestRepositoryWithQuery extends CrudRepository<Contest, Long> {

    @Query("SELECT contest.contestName FROM Contest contest where contest.id = :id") 
    String findContestByIdString(@Param("id") Long id);
    
    @Query("SELECT contest.contestName FROM Contest contest where contest.contestName = :contestName") 
    String findContestByContestName(@Param("contestName") String contestName);
    
    List<Contest> findByContestName(String contestName);
    
    // Position based parameter binding
    // We cannot change the order of the method parameters
    // We cannot change the order of the placeholders 
    // without breaking our database query
    @Query("SELECT contest FROM Contest contest where contest.contestName = ?1 AND contest.id = ?2")
    public Optional<Contest> findByContestNameAndId(String contestName, Long id);
    
    // Named Parameter
    // The @Param annotation configures the name of the 
    // named parameter that is replaced with the value
    // of the method parameter.
    // This will be more helpful than positional based
    @Query("SELECT contest FROM Contest contest where contest.contestName = :contestName AND contest.id = :id")
    public Optional<Contest> findByNamedParameter(@Param("contestName") String contestName, 
                                                    @Param("id") Long id);
    
    @Async
    Future<Contest> findContest1ById(Long id);
     
    @Async
    Future<Optional<Contest>> findContest2ById(Long id);
 
    @Async
    Future<Contest> findContestAsyncByContestName(String contestName);
     
    @Async
    Future<Stream<Contest>> findContestAsyncStreamByContestName(String contestName);
    
    @Async
    @Query("SELECT contest.contestName FROM Contest contest where contest.id = :id") 
    Future<Optional<String>> findContestById(@Param("id") Long id);
    
    @Async
    @Query("SELECT contest.contestName FROM Contest contest where contest.id = :id") 
    Future<String> findContestAsyncById(@Param("id") Long id);    
    
}

import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("contestQueryService")
public class ContestQueryService {
  
    @Autowired
    private ContestRepositoryWithQuery contestRepositoryWithQuery;
    
    public void test() {
        // Save a new contest
        Contest geekContest = new Contest();
        geekContest.setContestName("PremierLeague");
        geekContest.setContestDescription("Inviting Geeks To submit articles in plenty");
        
        contestRepositoryWithQuery.save(geekContest);
        
        Contest hackthoContest = new Contest();
        hackthoContest.setContestName("Hackathon");
        hackthoContest.setContestDescription("Coding Round Challenge");        
        contestRepositoryWithQuery.save(hackthoContest);
        
        Optional<Contest> result = contestRepositoryWithQuery.findById(1L);
        result.ifPresent(contest -> System.out.println(contest));
        
        // Positional based test
        Optional<Contest> result1 = contestRepositoryWithQuery.findByContestNameAndId("PremierLeague",6L);
        result1.ifPresent(contest -> System.out.println("Searched for PremierLeague.." + contest));
        
        // Named query test
        Optional<Contest> namedQueryResult = contestRepositoryWithQuery.findByNamedParameter("PremierLeague",6L);
        namedQueryResult.ifPresent(contest -> System.out.println("Searched for PremierLeague.." + contest));
        
        // Find contest by contest name
        List<Contest> contests = contestRepositoryWithQuery.findByContestName("Hackathon");
        contests.forEach(contest -> System.out.println("Searched for Hackathon.." + contest));
        
        // List all contests
        Iterable<Contest> iterator = contestRepositoryWithQuery.findAll();
        iterator.forEach(contest -> System.out.println(contest));
        
        // Count number of contest
        long countOfContest = contestRepositoryWithQuery.count();
        System.out.println("Number of contest held: " + countOfContest);
        
        // Async way of testing
        Future<Contest> resultAsync = contestRepositoryWithQuery.findContest1ById(6L);
        try {
            System.out.println("Async way of getting contestname.." + resultAsync.get().getContestName());
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } catch (ExecutionException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        
        Future<Optional<Contest>> hackathonAsyncResult = contestRepositoryWithQuery.findContest2ById(7L);
        result.ifPresent(hackathonContest -> System.out.println(hackathonContest));
        
        Future<Contest> asyncContest = contestRepositoryWithQuery.findContestAsyncByContestName("Hackathon");
        try {
            System.out.println("contestname retrieval in async way .." + asyncContest.get().getContestName());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        Future<Optional<String>> contestDetails = contestRepositoryWithQuery.findContestById(10L);
        //contestDetails.ifPresent(hackathonContest -> System.out.println(hackathonContest));
        
        Future<String> contestString = contestRepositoryWithQuery.findContestAsyncById(10L);
        System.out.println(contestString);
    }
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class ContestTestIncludingQueryMethods {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext appContext = new AnnotationConfigApplicationContext();
        appContext.scan("com.gfg.jpaquerymethods");
        appContext.refresh();

        ContestQueryService contestService = (ContestQueryService) appContext.getBean("contestQueryService");
        contestService.test();

        appContext.close();
    }

}