To understand the many to one and one to many associations between entities, let's go first create a new entity class called product. So I'm going to right click on the entity package, new class here, call it as product. Press Enter. This is also a plain ordinary Java object. I'm going to have some variables here called private integer product ID, private string product name, it also will have some kind of a quantity per unit. Let's give it a price.

Double unit price. A product also belongs to a category. So the association between a product and category here would be like many products belong to one category. Hence the association is many to one. As a general rule of thumb, if you have a foreign key in a table that is represented using a many to one Association To say that the product has association with a category. Let's create a variable here called category of type category.

Let's also add a constructor here. And then generate getters and setters by going to source menu, generate getters and setters. Select All, say, OK, and let's also add a two string by going to source generate to string and then say, Okay, we got the two string, representing even the category also, in order to map this to a table called products. Let's first add at the rate entity. And then at the rate table, name equals two products. Since we don't have this particular table called products, because of HBM to DDL dot auto equals to update, hibernate will automatically add this table that's imported.

Let's also artists as at the rate ID at the rate generated value. Once again. In the previous case, we'll add the same strategy, which is identity, which means there will be an auto increment added to this particular field. We'll also say that this is mapped to a column whose name is product underscore ID. This is going to be a product name with an underscore. This is going to be a quantity underscore or underscore unit unit underscore price.

And this one is not a column mapping. If you just leave the category without any column mapping, hibernate will automatically assumes that this is a column in your table and it tries to create such a column because we have given HBM to DDL auto but this is not a scalar type, which means there is no data type called category in an RDBMS. So we have to say that this is not a column by itself, but this corresponds to a foreign key called category underscore ID. So we're going to say here at the rate many to one. And then we say, at the rate join column, we say name equals to category underscore ID. What it does is it's going to create a new column called category underscore ID in products table makes it as a foreign key to the primary key of the table corresponding to this category, which is category stable.

Now that we have this product class, we also have to tell in hibernate util that there is another class that hibernate should manage by adding this CFG dot add annotated class entry. So CFG dot add annotated class of product class. Now hibernate is aware that there is another entity class. Now if you run any of the previous programs, hibernate will automatically synchronize the entity classes and the tables It's going to create the products table as well. But to see if this association works, let's go and create a new Java class. Under the programs package, I'm going to call this as x 05 package, called the class as mean.

Also add the main function over here. Let's fullscreen this, delete the to do, and then I'm going to paste this snippets which we used earlier as well, I'm going to import the packages. So we got the session and we have begun the transaction. So I'm going to create a new product object here and then associate that with our existing category called beverages. So first I'll give the category called beverages by typing c one equals to session dot get. And then I type your category class ID is one and then this C one has to be created as a category object.

Let's also create a new product object by typing product, p one equals two new product. Let's give some values to that P one dot set product name of, let's say, p one dot set quantity per unit, let's say 10 boxes into 20 bags. Let's give it a price of let's say for example, eating point zero dollars, ID is automatically generated. But I'm going to say p one dot set category of C one. And now if I come down here and say session dot persist, p one, p one will now be inserted with the primary key value of c one as its category ID. So I'm going to type your system dot out dot print ln, new product saved with ID and then I type your P one dot get product ID.

Save this run the same and you will see that There is a new CREATE TABLE command with ALTER TABLE also here because there is a foreign key being added over here. This is to retrieve the category object. And then we have an insert into products with all these values and say new products here with ID one. Let's go and have a look at the same. So first I go here and refresh this, you will see that there is a products table. I'm going to click on the products here.

So select star from products appears. I click on Run, and you will see that there is a new product ID auto generated ID here, the values have come but importantly category underscore ID is one. And that's because we did an association mapping over here, many to one also brings us other features. For example, if I retrieve a product object based on the ID, the corresponding category also will be retrieved to demonstrate the same Let's take another program. So I go to this package, new class. And then I type your package names six The program name is mean.

Let's also add the main function fullscreen this, get rid of this, I will also add the basic code snippet that we have been using. And now we don't need a transaction this time because we're only going to retrieve the data. So I'm going to type your P one equals to session dot get, and then say product dot class ID of one, that's the newly added product. And p one is going to be a product object, we close the session and then I'm going to type your sis out p one, you will see that the product object comes with not only the data from the products table, but also from the corresponding category table. So if I save this and run the same, you should see that the product along with the category has been returned over here and it says your category ID is one name is beverages description is so on.

So, you can see that it has achieved that by using the joint statement here. So it is Join the products table with the categories table. This kind of retrieval of one entity based on another entity is called as eager fetch, because we only asked for a product object, but hibernate went ahead and brought the corresponding category also. There is also another concept called lazy fetch, where you ask for one entity, even though there are other entities that this entity refers to. hibernate will only fetch the Ask the entity which is called lazy fetch. By default, many to one is an eager fetch and one to many is lazy fit