Spring data quaries:

---------------------

@Query("select p from Product p")

List<Product> getListOfAllProducts();

@Query("select p from Product p where p.name=?1")

List<Product> getListOfAllProductsBasedOnName(String name);

@Query("select p from Product p where p.name=:name")

List<Product> getListOfAllProductsBasedOnNameV2(@Param("name") String name);

@Query("select p from Product p where p.name=?1 and p.price=?2")

List<Product> getListOfAllProductsBasedOnNameAndPrice(String name, BigDecimal
price);

@Query("select p from Product p where p.name=?1 or p.price=?2")

List<Product> getListOfAllProductsBasedOnNameOrPrice(String name, BigDecimal
price);

List<Product> findByName(String name);

List<Product> findByNameContaining(String name);

List<Product> findByNameLike(String name);
List<Product> findByNameStartingWith(String name);

List<Product> findByNameEndingWith(String name);

List<Product> findByNameIgnoreCase(String name);

List<Product> findByMfgDateAfter(LocalDate date);

List<Product> findByMfgDateBefore(LocalDate date);
List<Product> findByMfgDateBetween(LocalDate date1, LocalDate date);

Spring data pagination:

----------------------

adding multiple products

-----------------------------

List<Product>products=IntStream.rangeClosed(1, 2000)
.mapToObj(i-> new Product("product "+i, new
Random().nextDouble(5000)))
.toList();

//productRepo.saveAll(products);
service layer:
-------------------
public List<Product> getAllProductSorted(String field);
public Page<Product> getAllProductPage(int offset, int pageSize);
public Page<Product> getAllProductPageSorted(String field,int offset, int
pageSize);

service layer implementation

--------------------------

@Override
public List<Product> getAllProductSorted(String field) {
return productRepo.findAll(Sort.by(Sort.Direction.DESC, field));
}

@Override
public Page<Product> getAllProductPage(int offset, int pageSize) {
return productRepo.findAll(PageRequest.of(offset, pageSize));
}

@Override
public Page<Product> getAllProductPageSorted(String field, int offset, int
pageSize) {
return productRepo.findAll(PageRequest.of(offset,
pageSize).withSort(Sort.by(field)));
}

controller layer:
---------------

@GetMapping(path = "productsorted")
public List<Product> getAllProductSorted(@RequestParam(name="field") String
field) {
return productService.getAllProductSorted(field);
}

//productpage?offset=4&pageSize=20
@GetMapping(path = "productpage")
public Page<Product> getAllProductPage(@RequestParam(name="offset") int
offset,@RequestParam(name="pageSize") int pageSize) {
return productService.getAllProductPage(offset, pageSize);
}

//productpagesorted?offset=4&pageSize=20&field=id
@GetMapping(path = "productpagesorted")
public Page<Product> getAllProductPageSorted(int offset, int pageSize,String
field) {
return productService.getAllProductPageSorted(field, offset, pageSize);
}
Joins:
---------

one to one:
-------------
Employee ------------<>-------- Parking

POJO:
------

public class Employee {

private int eid;
private String name;
private double salary;

private Parking parking;

}

public class Parking {

private int pid;
private String loc;
private Employee employee;
}

Entities:
-----------

@Entity
@Table(name = "emp_table")
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int eid;
private String name;
private double salary;

@OneToOne(mappedBy = "employee", cascade = CascadeType.ALL, fetch =

FetchType.LAZY)
private Parking parking;

@Entity
@Table(name = "parking_table")
public class Parking {

@Id @GeneratedValue(strategy = GenerationType.IDENTITY)

private int pid;
private String loc;

@JoinColumn(name = "eid_fk")
@OneToOne
 private Employee employee;
}

Repository:
------------
@Repository
public interface EmployeeRepo extends JpaRepository<Employee, Integer>{

@Repository
public interface ParkingRepo extends JpaRepository<Parking, Integer>{
}

populate some data:

--------------------
Parking parking1=new Parking("A34");
Parking parking2=new Parking("Mw6");
Parking parking3=new Parking("F40");

Employee emp1=new Employee("ekta", 4000.00, parking1);

Employee emp2=new Employee("keshav", 7000.00, parking2);
Employee emp3=new Employee("gunika", 3400.00, parking3);

parking1.setEmployee(emp1);
parking2.setEmployee(emp2);
parking3.setEmployee(emp3);

empRepo.save(emp1);
empRepo.save(emp2);
empRepo.save(emp3);

parkingRepo.save(parking1);
parkingRepo.save(parking2);
parkingRepo.save(parking3);

one to many:
-------------
Department <>-------- Employee

Pojo:
--------

public class Department {

private int did;
private String dname;

private List<Employee>employees=new ArrayList<>();

}
public class Employee {
private int eid;
private String name;
private double salary;

private Department department;

}

Entities:
--------

@Entity
@Table(name = "dept_table")
public class Department {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int did;

private String dname;

@OneToMany(mappedBy = "department", cascade = CascadeType.ALL, fetch =

FetchType.LAZY)
private List<Employee>employees=new ArrayList<>();
}

@Entity
@Table(name = "empdept_table")
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int eid;
private String name;

private double salary;

@JoinColumn(name = "did_fk")
@ManyToOne
private Department department;

Initilizing data:
-----------------

Department d1=new Department("fin");

Department d2=new Department("IT");
Department d3=new Department("sales");

Employee emp1=new Employee("ravi", 6000.00, d1);

Employee emp2=new Employee("ekta", 4000.00, d1);
 Employee emp3=new Employee("keshav", 7000.00, d2);
Employee emp4=new Employee("gunika", 3400.00, d2);

Employee emp5=new Employee("raj", 7800.00, d3);

//dept 1 have 1,2 emps

d1.getEmployees().add(emp1);
d1.getEmployees().add(emp2);

d2.getEmployees().add(emp3);
d2.getEmployees().add(emp4);

d3.getEmployees().add(emp5);

deptRepo.save(d1);
deptRepo.save(d2);
deptRepo.save(d3);

empRepo.save(emp1);
empRepo.save(emp2);
empRepo.save(emp3);
empRepo.save(emp4);
empRepo.save(emp5);

Repositories:
-------------

dname ename salary

@Repository
public interface DepartmentRepo extends JpaRepository<Department, Integer>{
@Query("SELECT new com.demo.dto.DeptEmpResponse(d.dname, e.name, e.salary)
FROM Department d INNER JOIN d.employees e")
List<DeptEmpResponse> deptEmployeeInformation();
}

@Query("SELECT new com.demo.dto.DeptEmpResponse(d.dname, e.name, e.salary)

FROM Department d INNER JOIN d.employees e")
List<DeptEmpResponse> deptEmployeeInformation();

@Repository
public interface EmployeeRepo extends JpaRepository<Employee, Integer>{
@Query("SELECT e FROM Employee e WHERE e.eid IN (:eid)")
public List<Employee> findEmployeessByIds(@Param("eid") List<Integer> eid);
}

Requst/response DTO:
----------------------

@JsonIgnoreProperties({"rank","location"})
public class DeptEmpResponse {
private String dname;
private String name;
private double salary;
//@JsonIgnore
private int rank;
//@JsonIgnore
private String location;
}

public class EmployeeRequest {

private List<Integer> ids;
}

{
"ids": [1,5]
}

Exception:
---------
public class ResourceNotFoundException extends RuntimeException{
}

Controllers:
------------

@RestController
public class DeptartmentRestController {

private DepartmentRepo deptRepo;

@Autowired
public DeptartmentRestController(DepartmentRepo deptRepo) {
this.deptRepo = deptRepo;
}

@GetMapping(path = "department", produces = MediaType.APPLICATION_JSON_VALUE)

public List<Department> getAllDepartments(){
List<Department> departments=deptRepo.findAll();
return departments;
}

@GetMapping(path = "department/{did}", produces =

MediaType.APPLICATION_JSON_VALUE)
public Department getAnDepartment(@PathVariable(name="did") int did){
Department
department=deptRepo.findById(did).orElseThrow(ResourceNotFoundException::new);
return department;
}
}
@RestController
public class EmployeeRestController {

@Autowired
private DepartmentRepo deptRepo;

@Autowired
private EmployeeRepo empRepo;

@GetMapping(path = "employee", produces = MediaType.APPLICATION_JSON_VALUE)

public List<Employee> getAllEmp() {
List<Employee>employees=empRepo.findAll();
return employees;
}

@GetMapping(path = "selectedemployee", produces =

MediaType.APPLICATION_JSON_VALUE)
public List<Employee> getSelectedEmp(@RequestBody EmployeeRequest
employeeRequest) {

List<Employee>employees=empRepo.findEmployeessByIds(employeeRequest.getIds());
return employees;
}

@GetMapping(path = "empinfo", produces = MediaType.APPLICATION_JSON_VALUE)

public List<DeptEmpResponse> getAllEmployeesWithDeptName() {
List<DeptEmpResponse> empsWithDeptNames =
deptRepo.deptEmployeeInformation();
return empsWithDeptNames;
}

Problem: recursion :
---------------------
one to one

one to many

many to many

Solving Infinite Recursion using @JsonManagedReference and @JsonBackReference

---------------------------------------------------------------------

@JsonIgnore

@JsonManagedReference:
is used on the OneToMany side
it is the forward part of the mapping/reference and the data
gets serialized normally.

@JsonBackReference :
 is used at the @ManyToOne side
@JsonBackReference is is the backward side of the mapping and the
data does not get serialized

Steps:
Add @JsonManagedReference to the getPosts method in the User entity
Add @JsonBackReference to the getUser method of the Post entity
Add @JsonManagedReference to the getUsers method of the Location entity
@JsonBackReference to the getLocation method of the User entity

@JsonIdentifyInfo and @JsonIgnore

-------------------------------------

@JsonIgnore
it is an alternative for the @JsonBackReference.
So we can used @JsonIgnore in place of @JsonBackReference

@JsonIdentityInfo
it can be used in place of the both @JsonManagedReference and
@JsonBackReference.
@JsonIdentityInfo annotation is added to the class and NOT to the
methods.

Also, the @JsonIdentityInfo requires some attributes as shown in the code

below:

@JsonIdentityInfo(
generator = ObjectIdGenerators.PropertyGenerator.class,
property = "id")

public interface DepartmentRepository extends JpaRepository<Department, Integer> {

@Query("SELECT new new demo.EmpDataResponse(d.name, e.name, e.salary) FROM

Department d INNER JOIN d.employees e")
List<EmpDataResponse> deptEmployeeInformation();

EmpDataResponse{
private String dname;
private String name;
private double salary;
}

dname enam ,salary

public class Department {

//
private String dname;
private List<Employee>employees=new ArrayList<>();
public class Employee {

private int eid;

private String name;
private double salary;

private Department department;

Ref:
-----
https://www.appsdeveloperblog.com/infinite-recursion-in-objects-with-bidirectional-
relationships/

Spring boot join: many to many

---------------------------------
N M
Employee--------- <>------- Project

POJO:
------
public class Employee {
private int eid;
private String name;
private double salary;

private List<Project> projects=new ArrayList<>();

}

public class Project {

private int pid;
private String pname;
private String manager;
private LocalDate startDate;

private List<Employee> employees=new ArrayList<>();

}

Entities:
--------
@Entity
@Table(name = "emp_proj_table")
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int eid;
private String name;
private double salary;

@ManyToMany(mappedBy = "employees", cascade = CascadeType.ALL)

private List<Project> projects=new ArrayList<>();
}
@Entity
@Table(name = "project_table")
public class Project {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int pid;
private String pname;
private String manager;
private LocalDate startDate;

@JoinTable(name="emp_project_join", joinColumns = @JoinColumn(name="pid_fk"),

inverseJoinColumns = @JoinColumn(name="eid_fk"))
@ManyToMany(cascade = CascadeType.ALL)
private List<Employee> employees=new ArrayList<>();
}

Data init:
-------
Employee emp1 = new Employee("sunita", 4000.00);
Employee emp2 = new Employee("keshav", 7000.00);
Employee emp3 = new Employee("gunika", 3400.00);

Employee emp4 = new Employee("anil", 3400.00);

Employee emp5 = new Employee("sumit", 7900.00);
Employee emp6 = new Employee("umesh", 5600.00);

Employee emp7 = new Employee("vikas", 4000.00);

Employee emp8 = new Employee("neetu", 7000.00);
Employee emp9 = new Employee("kapil", 3400.00);

Project project1=new Project("shopping cart", "raj", LocalDate.of(2021,

Month.JANUARY, 2));
Project project2=new Project("bank app", "ekta", LocalDate.of(2020,
Month.NOVEMBER, 22));
Project project3=new Project("bookstore", "indu", LocalDate.of(2020,
Month.DECEMBER, 12));

project1.getEmployees().add(emp1);
project1.getEmployees().add(emp2);
project1.getEmployees().add(emp3);

project2.getEmployees().add(emp4);
project2.getEmployees().add(emp5);
project2.getEmployees().add(emp6);

project3.getEmployees().add(emp7);
project3.getEmployees().add(emp8);
project3.getEmployees().add(emp9);
 emp1.getProjects().add(project1);
emp2.getProjects().add(project1);
emp3.getProjects().add(project1);

emp4.getProjects().add(project2);
emp5.getProjects().add(project2);
emp6.getProjects().add(project2);

emp7.getProjects().add(project3);
emp8.getProjects().add(project3);
emp9.getProjects().add(project3);

projectRepo.save(project1);
projectRepo.save(project2);
projectRepo.save(project3);

empRepo.save(emp1);
empRepo.save(emp2);
empRepo.save(emp3);

empRepo.save(emp4);
empRepo.save(emp5);
empRepo.save(emp6);

empRepo.save(emp7);
empRepo.save(emp8);
empRepo.save(emp9);

Repo:
-----
@Repository
public interface EmployeeRepo extends JpaRepository<Employee, Integer>{

@Repository
public interface ProjectRepo extends JpaRepository<Project, Integer>{

Spring boot data configuration:

---------------------------------
step 1:
-----------
spring.datasource.url=jdbc:mysql://localhost:3306/cris1?
autoReconnect=true&useSSL=false&allowPublicKeyRetrieval=true
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name= com.mysql.jdbc.Driver
#spring.jpa.hibernate.ddl-auto=create-drop

spring.jpa.properties.hibernate.dialect= org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.hibernate.ddl-auto= update

step 2:
-------------
@Configuration
@PropertySource("classpath:db.properties")
public class DbConfig {

@Autowired
private Environment environment;

@Bean
public DriverManagerDataSource getDriverManagerDataSource() {
DriverManagerDataSource ds=new DriverManagerDataSource();
ds.setUsername(environment.getProperty("jdbc.username"));
ds.setPassword(environment.getProperty("jdbc.password"));
ds.setDriverClassName(environment.getProperty("jdbc.drivername"));
ds.setUrl(environment.getProperty("jdbc.url"));

return ds;
}

@Configuration
@ComponentScan(basePackages = {"com.productapp"})
@EnableTransactionManagement
@Import(DbConfig.class)
@EnableJpaRepositories(basePackages = "com.productapp.repo",
entityManagerFactoryRef = "emf1", transactionManagerRef = "tx1")
public class AppConfig {

@Bean
public LocalContainerEntityManagerFactoryBean emf1(DataSource dataSource) {
LocalContainerEntityManagerFactoryBean factoryBean=new
LocalContainerEntityManagerFactoryBean();
factoryBean.setDataSource(dataSource);
factoryBean.setPackagesToScan(new String[] {"com.productapp.entity"});

factoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());

factoryBean.setJpaProperties(jpaProperites());
return factoryBean;
}

private Properties jpaProperites() {

 Properties properties=new Properties();
properties.setProperty("hibernate.hbm2ddl.auto", "update");
properties.setProperty("hibernate.show_sql", "true");
properties.setProperty("hibernate.dialect",
"org.hibernate.dialect.MySQL57Dialect");

return properties;
}

@Bean
public JpaTransactionManager tx1(EntityManagerFactory emf) {
return new JpaTransactionManager(emf);
}
}