Handson
- Create JPA Relationship for the following diagram
JPA Relationship
- used to establish relationship between entity classes
4 types
1. One to one
2. One to many
3. Many to One
4. Many to Many
1. One to One
- One user has only one vehicle using foreign key concepts
- In User class, we will be creating object for Vehicle class
User table Vehicle table
user_id(pk) user_name vehicle_id(fk) vehicle_id(pk) vehicle_name
1. Configure db info and hibernate properties in persistence.xml
2. Create Vehicle entity class
@Entity
@Table(name="veh100")
public class Vehicle {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name="vehcile_id")
private Integer id;
@Column(name="vehicle_name")
private String name;
//getter,setter,constructor
}
3. Create User entity class
@Entity
@Table(name="usr100")
public class User {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name="user_id")
private Integer id;
@Column(name="user_name")
private String name;
@OneToOne(cascade = CascadeType.ALL)
@JoinColumn(name="vehicle_id")
private Vehicle vehicle; //one user has only one vehicle
//getter,setter,constructor
}
4. Configure entity class in persistence.xml file
<class>com.pack.User</class>
<class>com.pack.Vehicle</class>
5. Create main class
public class Main {
public static void main(String[] args) {
EntityManagerFactory emf=Persistence.createEntityManagerFactory("student-info");
EntityManager em=emf.createEntityManager();
EntityTransaction et=em.getTransaction();
et.begin();
Vehicle v1=new Vehicle();
v1.setName("Benz");
Vehicle v2=new Vehicle();
v2.setName("BMW");
User u1=new User();
u1.setName("Ram");
u1.setVehicle(v1);
User u2=new User();
u2.setName("Sam");
u2.setVehicle(v2);
//em.persist(v1);
//em.persist(v2);
em.persist(u1);
em.persist(u2);
et.commit();
System.out.println("Success");
em.close();
emf.close();
}
}
Cascading operation
- used only in mapping concepts, if we perform any operation on one entity class then it automatically affects the another entity class - 4 types
1. CascadeType.PERSIST
2. CascadeType.UPDATE
3. CascadeType.REMOVE
4. CascadeType.ALL
mysql> select * from veh100;
+------------+--------------+
| vehcile_id | vehicle_name |
+------------+--------------+
| 9 | Benz |
| 11 | BMW |
+------------+--------------+
2 rows in set (0.00 sec)
mysql> select * from usr100;
+---------+-----------+------------+
| user_id | user_name | vehicle_id |
+---------+-----------+------------+
| 8 | Ram | 9 |
| 10 | Sam | 11 |
+---------+-----------+------------+
2 rows in set (0.00 sec)
2. One to Many
- one user has many vehicles, it will create a separate join table which contains primary key from user table as well as vehicle table
Usr101 table Veh101 table
user_id(pk) user_name vehicle_id(pk) vehicle_name
usr101_veh101 table
user_id(fk) vehicle_id(fk)
1. Configure db info and hibernate properties in persistence.xml
2. Create Vehicle1 entity class
@Entity
@Table(name="veh101")
public class Vehicle1 {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name="vehicle_id")
private Integer id;
@Column(name="vehicle_name")
private String name;
//getter,setter,constructor
}
3. Create User1 entity class
@Entity
@Table(name="usr101")
public class User1 {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name="user_id")
private Integer id;
@Column(name="user_name")
private String name;
/*@OneToMany(cascade = CascadeType.ALL)
@JoinTable(name="user_vehicle",joinColumns = @JoinColumn(name="user_id"),
inverseJoinColumns = @JoinColumn(name="vehicle_id"))
private List<Vehicle1> vehicle=new ArrayList<>(); */ //one user has many vehicle
@OneToMany(cascade = CascadeType.ALL, targetEntity = Vehicle1.class)
private List<Vehicle1> vehicle=new ArrayList<>(); //one user has many vehicle
//getter,setter,constructor
}
4. Configure entity class in persistence.xml file
<class>com.pack.User1</class>
<class>com.pack.Vehicle1</class>
5. Create main class
public class Main {
public static void main(String[] args) {
EntityManagerFactory emf=Persistence.createEntityManagerFactory("student-info");
EntityManager em=emf.createEntityManager();
EntityTransaction et=em.getTransaction();
et.begin();
Vehicle1 v1=new Vehicle1();
v1.setName("Ford");
Vehicle1 v2=new Vehicle1();
v2.setName("Audi");
List<Vehicle1> list=new ArrayList<>();
list.add(v1);
list.add(v2);
User1 u1=new User1();
u1.setName("Raj");
u1.setVehicle(list);
//em.persist(v1);
//em.persist(v2);
em.persist(u1);
et.commit();
System.out.println("Success");
em.close();
emf.close();
}
}
mysql> select * from veh101;
+------------+--------------+
| vehicle_id | vehicle_name |
+------------+--------------+
| 13 | Ford |
| 14 | Audi |
+------------+--------------+
2 rows in set (0.00 sec)
mysql> select * from usr101;
+---------+-----------+
| user_id | user_name |
+---------+-----------+
| 12 | Raj |
+---------+-----------+
1 row in set (0.00 sec)
mysql> select * from usr101_veh101;
+---------------+--------------------+
| User1_user_id | vehicle_vehicle_id |
+---------------+--------------------+
| 12 | 13 |
| 12 | 14 |
+---------------+--------------------+
2 rows in set (0.00 sec)
Fetch type
1. Lazy - fetch when needed, @OneToMany, @ManyToMany - Lazy(default) - associated entity is fetched on demand
public class Main {
public static void main(String[] args) {
EntityManagerFactory emf=Persistence.createEntityManagerFactory("student-info");
EntityManager em=emf.createEntityManager();
EntityTransaction et=em.getTransaction();
et.begin();
/*Vehicle1 v1=new Vehicle1();
v1.setName("Ford");
Vehicle1 v2=new Vehicle1();
v2.setName("Audi");
List<Vehicle1> list=new ArrayList<>();
list.add(v1);
list.add(v2);
User1 u1=new User1();
u1.setName("Raj");
u1.setVehicle(list);
//em.persist(v1);
//em.persist(v2);
em.persist(u1);*/
User1 u1=(User1)em.find(User1.class, 12);
System.out.println(u1.getName());
List<Vehicle1> l1=u1.getVehicle();
for(Vehicle1 v1:l1)
System.out.println(v1.getName());
et.commit();
System.out.println("Success");
em.close();
emf.close();
}
}
2. Eager - fetch immediately, @OneToOne,@ManyToOne - Eager(default) - associated entity is loaded immediately along with parent entity class and uses left outer join to fetch the data
@Entity
@Table(name="usr101")
public class User1 {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name="user_id")
private Integer id;
@Column(name="user_name")
private String name;
/*@OneToMany(cascade = CascadeType.ALL)
@JoinTable(name="user_vehicle",joinColumns = @JoinColumn(name="user_id"),
inverseJoinColumns = @JoinColumn(name="vehicle_id"))
private List<Vehicle1> vehicle=new ArrayList<>(); */ //one user has many vehicle
@OneToMany(cascade = CascadeType.ALL, targetEntity = Vehicle1.class, fetch=FetchType.EAGER)
private List<Vehicle1> vehicle=new ArrayList<>(); //one user has many vehicle
}
public class Main {
public static void main(String[] args) {
EntityManagerFactory emf=Persistence.createEntityManagerFactory("student-info");
EntityManager em=emf.createEntityManager();
EntityTransaction et=em.getTransaction();
et.begin();
/*Vehicle1 v1=new Vehicle1();
v1.setName("Ford");
Vehicle1 v2=new Vehicle1();
v2.setName("Audi");
List<Vehicle1> list=new ArrayList<>();
list.add(v1);
list.add(v2);
User1 u1=new User1();
u1.setName("Raj");
u1.setVehicle(list);
//em.persist(v1);
//em.persist(v2);
em.persist(u1);*/
User1 u1=(User1)em.find(User1.class, 12);
System.out.println(u1.getName());
/*List<Vehicle1> l1=u1.getVehicle();
for(Vehicle1 v1:l1)
System.out.println(v1.getName());*/
et.commit();
System.out.println("Success");
em.close();
emf.close();
}
}
3. ManyToOne - Many Vehicle belongs to one user
4. ManyToMany - Many user has many vehicle
1. Configure db info and hibernate properties in persistence.xml
2. Create Vehicle2 entity class
@Entity
@Table(name="veh102")
public class Vehicle2 {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name="vehicle_id")
private Integer id;
@Column(name="vehicle_name")
private String name;
@ManyToMany(cascade=CascadeType.ALL,targetEntity=User2.class)
private List<User2> user=new ArrayList<>();
//getter,setter,constructor
}
3. Create User2 entity class
@Entity
@Table(name="usr102")
public class User2 {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name="user_id")
private Integer id;
@Column(name="user_name")
private String name;
@ManyToMany(cascade=CascadeType.ALL,targetEntity=Vehicle2.class)
private List<Vehicle2> vehicle=new ArrayList<>();
//getter,setter,constructor
}
4. Configure entity class in persistence.xml file
<class>com.pack.User2</class>
<class>com.pack.Vehicle2</class>
5. Create main class
public class Main {
public static void main(String[] args) {
EntityManagerFactory emf=Persistence.createEntityManagerFactory("student-info");
EntityManager em=emf.createEntityManager();
EntityTransaction et=em.getTransaction();
et.begin();
Vehicle2 v1=new Vehicle2();
v1.setName("Ford");
Vehicle2 v2=new Vehicle2();
v2.setName("Audi");
List<Vehicle2> list=new ArrayList<>();
list.add(v1);
list.add(v2);
User2 u1=new User2();
u1.setName("Raj");
u1.setVehicle(list);
User2 u2=new User2();
u2.setName("Tim");
u2.setVehicle(list);
//em.persist(v1);
//em.persist(v2);
em.persist(u1);
em.persist(u2);
et.commit();
System.out.println("Success");
em.close();
emf.close();
}
}
mysql> select * from veh102;
+------------+--------------+
| vehicle_id | vehicle_name |
+------------+--------------+
| 16 | Ford |
| 17 | Audi |
+------------+--------------+
2 rows in set (0.00 sec)
mysql> select * from usr102;
+---------+-----------+
| user_id | user_name |
+---------+-----------+
| 15 | Raj |
| 18 | Tim |
+---------+-----------+
2 rows in set (0.00 sec)
mysql> select * from usr102_veh102;
+---------------+--------------------+
| User2_user_id | vehicle_vehicle_id |
+---------------+--------------------+
| 15 | 16 |
| 15 | 17 |
| 18 | 16 |
| 18 | 17 |
+---------------+--------------------+
4 rows in set (0.00 sec)
JPA Inheritance
- entity classes can also be inherited
3 types
1. Single table/Table per class inheritance
- For all entity classes it stores the data in a single table
@DiscriminatorColumn - used to differentiate the type of employee
@DiscriminatorValue - used to provide value for the discriminator column we generated
1. Create Employee entity class
@Entity
@Table(name="emp100")
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name="empType",discriminatorType = DiscriminatorType.STRING)
@DiscriminatorValue(value="empl")
public class Employee {
@Id
private Integer id;
private String name;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
@Entity
@DiscriminatorValue(value="regempl")
public class RegularEmployee extends Employee{
private Double salary;
private Double bonus;
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
public Double getBonus() {
return bonus;
}
public void setBonus(Double bonus) {
this.bonus = bonus;
}
}
@Entity
@DiscriminatorValue(value="contempl")
public class ContractEmployee extends Employee{
private Double payPerHour;
private Integer duration;
public Double getPayPerHour() {
return payPerHour;
}
public void setPayPerHour(Double payPerHour) {
this.payPerHour = payPerHour;
}
public Integer getDuration() {
return duration;
}
public void setDuration(Integer duration) {
this.duration = duration;
}
}
2. Configure entity class in xml file
<class>com.pack.Employee</class>
<class>com.pack.RegularEmployee</class>
<class>com.pack.ContractEmployee</class>
3. Create Main class
public class Main {
public static void main(String[] args) {
EntityManagerFactory emf=Persistence.createEntityManagerFactory("student-info");
EntityManager em=emf.createEntityManager();
EntityTransaction et=em.getTransaction();
et.begin();
Employee e1=new Employee();
e1.setId(100);
e1.setName("Ramu");
RegularEmployee r1=new RegularEmployee();
r1.setId(101);
r1.setName("Tim");
r1.setSalary(20000.0);
r1.setBonus(2000.0);
ContractEmployee c1=new ContractEmployee();
c1.setId(102);
c1.setName("Jim");
c1.setPayPerHour(2000.0);
c1.setDuration(5);
em.persist(e1);
em.persist(r1);
em.persist(c1);
et.commit();
System.out.println("Success");
em.close();
emf.close();
}
}
mysql> select * from emp100;
+----------+-----+------+----------+------------+-------+--------+
| empType | id | name | duration | payPerHour | bonus | salary |
+----------+-----+------+----------+------------+-------+--------+
| empl | 100 | Ramu | NULL | NULL | NULL | NULL |
| regempl | 101 | Tim | NULL | NULL | 2000 | 20000 |
| contempl | 102 | Jim | 5 | 2000 | NULL | NULL |
+----------+-----+------+----------+------------+-------+--------+
3 rows in set (0.00 sec)
2. Table per concrete class inheritance
- For each entity class it creates a separate table
1. Create Employee entity class
@Entity
@Table(name="emp101")
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
public class Employee1 {
@Id
private Integer id;
private String name;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
@Entity
@Table(name="regemp101")
@AttributeOverrides({
@AttributeOverride(name="id",column=@Column(name="id")),
@AttributeOverride(name="name",column=@Column(name="name"))
})
public class RegularEmployee1 extends Employee1{
private Double salary;
private Double bonus;
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
public Double getBonus() {
return bonus;
}
public void setBonus(Double bonus) {
this.bonus = bonus;
}
}
@Entity
@Table(name="contemp101")
@AttributeOverrides({
@AttributeOverride(name="id",column=@Column(name="id")),
@AttributeOverride(name="name",column=@Column(name="name"))
})
public class ContractEmployee1 extends Employee1{
private Double payPerHour;
private Integer duration;
public Double getPayPerHour() {
return payPerHour;
}
public void setPayPerHour(Double payPerHour) {
this.payPerHour = payPerHour;
}
public Integer getDuration() {
return duration;
}
public void setDuration(Integer duration) {
this.duration = duration;
}
}
2. Configure entity class in xml file
<class>com.pack.Employee1</class>
<class>com.pack.RegularEmployee1</class>
<class>com.pack.ContractEmployee</class>
3. Create Main class
public class Main {
public static void main(String[] args) {
EntityManagerFactory emf=Persistence.createEntityManagerFactory("student-info");
EntityManager em=emf.createEntityManager();
EntityTransaction et=em.getTransaction();
et.begin();
Employee1 e1=new Employee1();
e1.setId(200);
e1.setName("Ramu");
RegularEmployee1 r1=new RegularEmployee1();
r1.setId(201);
r1.setName("Tim");
r1.setSalary(20000.0);
r1.setBonus(2000.0);
ContractEmployee1 c1=new ContractEmployee1();
c1.setId(202);
c1.setName("Jim");
c1.setPayPerHour(2000.0);
c1.setDuration(5);
em.persist(e1);
em.persist(r1);
em.persist(c1);
et.commit();
System.out.println("Success");
em.close();
emf.close();
}
}
mysql> select * from emp101;
+-----+------+
| id | name |
+-----+------+
| 200 | Ramu |
+-----+------+
1 row in set (0.00 sec)
mysql> select * from regemp101;
+-----+------+-------+--------+
| id | name | bonus | salary |
+-----+------+-------+--------+
| 201 | Tim | 2000 | 20000 |
+-----+------+-------+--------+
1 row in set (0.00 sec)
mysql> select * from contemp101;
+-----+------+----------+------------+
| id | name | duration | payPerHour |
+-----+------+----------+------------+
| 202 | Jim | 5 | 2000 |
+-----+------+----------+------------+
1 row in set (0.00 sec)
2. Joined/Table per subclass inheritance
- used to join the table based on primary key and foreign key relationship
1. Create Employee2 entity class
@Entity
@Table(name="emp102")
@Inheritance(strategy=InheritanceType.JOINED)
public class Employee2 {
@Id
private Integer id;
private String name;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
@Entity
@Table(name="regemp102")
@PrimaryKeyJoinColumn(name="id")
public class RegularEmployee2 extends Employee2{
private Double salary;
private Double bonus;
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
public Double getBonus() {
return bonus;
}
public void setBonus(Double bonus) {
this.bonus = bonus;
}
}
@Entity
@Table(name="contemp102")
@PrimaryKeyJoinColumn(name="id")
public class ContractEmployee2 extends Employee2{
private Double payPerHour;
private Integer duration;
public Double getPayPerHour() {
return payPerHour;
}
public void setPayPerHour(Double payPerHour) {
this.payPerHour = payPerHour;
}
public Integer getDuration() {
return duration;
}
public void setDuration(Integer duration) {
this.duration = duration;
}
}
2. Configure entity class in xml file
<class>com.pack.Employee2</class>
<class>com.pack.RegularEmployee2</class>
<class>com.pack.ContractEmployee2</class>
3. Create Main class
public class Main {
public static void main(String[] args) {
EntityManagerFactory emf=Persistence.createEntityManagerFactory("student-info");
EntityManager em=emf.createEntityManager();
EntityTransaction et=em.getTransaction();
et.begin();
Employee1 e2=new Employee2();
e1.setId(200);
e1.setName("Ramu");
RegularEmployee2 r1=new RegularEmployee2();
r1.setId(201);
r1.setName("Tim");
r1.setSalary(20000.0);
r1.setBonus(2000.0);
ContractEmployee2 c1=new ContractEmployee2);
c1.setId(202);
c1.setName("Jim");
c1.setPayPerHour(2000.0);
c1.setDuration(5);
em.persist(e1);
em.persist(r1);
em.persist(c1);
et.commit();
System.out.println("Success");
em.close();
emf.close();
}
}
mysql> select * from emp102;
+-----+------+
| id | name |
+-----+------+
| 200 | Ramu |
| 201 | Tim |
| 202 | Jim |
+-----+------+
3 rows in set (0.00 sec)
mysql> select * from regemp102;
+-------+--------+-----+
| bonus | salary | id |
+-------+--------+-----+
| 2000 | 20000 | 201 |
+-------+--------+-----+
1 row in set (0.00 sec)
mysql> select * from contemp102;
+----------+------------+-----+
| duration | payPerHour | id |
+----------+------------+-----+
| 5 | 2000 | 202 |
+----------+------------+-----+
1 row in set (0.00 sec)
Springboot 3.x framework
- minimum JDK17 or above
- open source framework, used to develop faster and both Java based and web based appl, it is not a replacement of Spring framework, but it provides a production ready appl so as a developer we are focussing only on business logic rather than doing all external configuration and downloading all jar files
- developed by Pivotal team
Logging framework - Log4j, Slf4j
Advantage
1. easy to understand, develop faster appl so increase productivity
2. reduce ur development time
3. Avoid xml configuration
4. Everything is autoconfigured, so no need for manual configuration
5. Springboot comes with embedded server like Apache Tomcat(default), Jetty, Undertow
6. Springboot comes with in-memory db called H2 database, used for testing purpose
7. Springboot comes with in-built logging framework like Logback, Slf4j
Disadvantage
1. Migration effort - converting from existing spring project to springboot project is not straight forward
2. Deploying Springboot appl on other servers like JBoss, Weblogic etc is not straight forward
3. Developed Springboot appl by keeping Microservice and cloud in mind
Spring
1. Used to develop JavaEE framework for building appl (client+server)
2. Main features is Dependency injection
3. Develop loosely coupled appl
4. Write lot of boilerplate code
5. Explicitly configure the server
6. Explicitlty configure db
7. Manaually configure all dependency in pom.xml
8. Requries xml file for bean configuration
Springboot
1. Used to develop REST endpoints(server part) based on MVC architecture
2. Main features is Autoconfiguration
3. Create standalone appl with less configuration
4. Reduce boilerplate code
5. Comes with embedded server
6. Comes with in-memory database
7. Springboot comes with spring-boot-starter-parent which will internally download all necessary jar file
8. No need for xml configuration
Springboot Dependency Management
- spring-boot-starter-parent is a project starter provide all basic configuration (jar files) to develop springboot appl
- manage dependencies and configuration in single place automatically
- avoid version conflicts
- dependency section tells maven what jar files to be downloaded and parent section tells what version of jar file to be downloaded
No comments:
Post a Comment