Add files using upload-large-folder tool

.gitattributes

@@ -129,3 +129,13 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 13[[:space:]]-[[:space:]]Object-oriented[[:space:]]programming/009[[:space:]]Object,[[:space:]]JNI[[:space:]]and[[:space:]]Object[[:space:]]class[[:space:]]overview.mp4 filter=lfs diff=lfs merge=lfs -text
 13[[:space:]]-[[:space:]]Object-oriented[[:space:]]programming/013[[:space:]]Liskov[[:space:]]Substitution[[:space:]]Principle.mp4 filter=lfs diff=lfs merge=lfs -text
 13[[:space:]]-[[:space:]]Object-oriented[[:space:]]programming/014[[:space:]]Interface[[:space:]]Segregation[[:space:]]Principle.mp4 filter=lfs diff=lfs merge=lfs -text
+13[[:space:]]-[[:space:]]Object-oriented[[:space:]]programming/015[[:space:]]Dependency[[:space:]]Inversion[[:space:]]Principle.mp4 filter=lfs diff=lfs merge=lfs -text
+17[[:space:]]-[[:space:]]GIT/001[[:space:]]Version[[:space:]]Control[[:space:]]Systems[[:space:]]&[[:space:]]Git[[:space:]]-[[:space:]]Overview.mp4 filter=lfs diff=lfs merge=lfs -text
+16[[:space:]]-[[:space:]]===[[:space:]]EXAM[[:space:]]OOP[[:space:]]&[[:space:]]Object[[:space:]]Oriented[[:space:]]e-Commerce[[:space:]]console[[:space:]]applications[[:space:]]===/001[[:space:]]Exam[[:space:]]and[[:space:]]homework[[:space:]]for[[:space:]]OOP[[:space:]]topic.mp4 filter=lfs diff=lfs merge=lfs -text
+17[[:space:]]-[[:space:]]GIT/004[[:space:]]Git[[:space:]]repo[[:space:]]init,[[:space:]]First[[:space:]]commit[[:space:]]and[[:space:]]main[[:space:]]bracnh.mp4 filter=lfs diff=lfs merge=lfs -text
+17[[:space:]]-[[:space:]]GIT/005[[:space:]]Git[[:space:]]ignoring[[:space:]]&[[:space:]]Git[[:space:]]log.mp4 filter=lfs diff=lfs merge=lfs -text
+17[[:space:]]-[[:space:]]GIT/002[[:space:]]How[[:space:]]to[[:space:]]Install[[:space:]]Git[[:space:]]and[[:space:]]Basic[[:space:]]Git[[:space:]]Configuration.mp4 filter=lfs diff=lfs merge=lfs -text
+17[[:space:]]-[[:space:]]GIT/006[[:space:]]Git[[:space:]]undoing[[:space:]]things[[:space:]]&[[:space:]]Vi[[:space:]]text[[:space:]]editor.mp4 filter=lfs diff=lfs merge=lfs -text
+17[[:space:]]-[[:space:]]GIT/007[[:space:]]Git[[:space:]]remote[[:space:]]repositories.mp4 filter=lfs diff=lfs merge=lfs -text
+17[[:space:]]-[[:space:]]GIT/008[[:space:]]SSH[[:space:]]Connection.mp4 filter=lfs diff=lfs merge=lfs -text
+17[[:space:]]-[[:space:]]GIT/010[[:space:]]Pull[[:space:]]Requests[[:space:]]&[[:space:]]Merge[[:space:]]Requests.mp4 filter=lfs diff=lfs merge=lfs -text

13 - Object-oriented programming/015 Dependency Inversion Principle.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4839fd3d0b1411e30add8cf0f50a648927c520582c774aa9487fa2cced8add20
+size 97920838

16 - === EXAM OOP & Object Oriented e-Commerce console applications ===/001 Exam and homework for OOP topic.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10683a9dfc1d5f7fb211f447a48dab53b3f98038444979089255d4ee0a180ce6
+size 153802800

17 - GIT/001 Version Control Systems & Git - Overview.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fee90b68e09558b6d846df640bad96f49f8d3f2b2baadaa9d61f3210b43d5bb
+size 57399220

17 - GIT/002 How to Install Git and Basic Git Configuration.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8ada8b8b5e0e12969640b928bd897baa5209608777aecf750847b3ccf974ee4
+size 158468542

17 - GIT/004 Git repo init, First commit and main bracnh.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c13262001a8309cdd0954965676b57ea401c0758db2a02b3d2eaae49c6e391d1
+size 38282816

17 - GIT/005 Git ignoring & Git log.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1be93c5595bd47cb49c7079acfb695a6c90941d35f21b52f5adb6a1c148a1e0
+size 133419159

17 - GIT/006 Git undoing things & Vi text editor.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a7de076f8653cd0d370273844dab3154041cb461d1521c2c9f9354731f57daf6
+size 147540639

17 - GIT/007 Git remote repositories.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1eba26a36847641bc5071a7daa9bca13ed5ebae58553a9b23607abd89ffa61a
+size 105054427

17 - GIT/008 SSH Connection.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b09ac33aaf19880dba5d977f30da4c0eb7b0ac7be1670dab5c17433b34bae49e
+size 108866715

17 - GIT/010 Pull Requests & Merge Requests.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f270121a98d4f62d1be9c2a62ecd828eac4ed9ce45f4377b8bf9e40e0a7aae4
+size 140071769

84 - Spring Security/external-links.txt

@@ -0,0 +1,12 @@
+
+002 Source-code-of-examples-commit-with-changes-
+https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/fa1f32b831ae40f681525076f3c8bd8928807f48
+
+003 Source-code-of-examples-commit-with-changes-
+https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/54608d3a38dc7bf0ec826a5210082f931bcf4ce4
+
+004 Source-code-of-examples-commit-with-changes-
+https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/9c0322078c8402104870492f91fc9713fc5f615a
+
+005 Source-code-of-examples-commit-with-changes-
+https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/8dddc2feb47bce4664713763e10e3fd9fda9648b

85 - ===== EXAM Spring Security - Online Shop =====/001 EXAM Spring Security - Online Shop_en.srt

@@ -0,0 +1,1240 @@
+1
+00:00:06,000 --> 00:00:06,000
+Hello, team.
+
+2
+00:00:06,000 --> 00:00:13,000
+We have learned a lot about spring security and now it is time for you to practice your skills and realize
+
+3
+00:00:13,000 --> 00:00:16,000
+how much you already learned in the course.
+
+4
+00:00:16,000 --> 00:00:22,000
+As you know, with all my students during the whole course Java from zero to first job, we develop
+
+5
+00:00:22,000 --> 00:00:25,000
+our online shop from scratch.
+
+6
+00:00:25,000 --> 00:00:32,000
+I truly believe that real business case will help you to understand how to apply gained knowledge on
+
+7
+00:00:32,000 --> 00:00:33,000
+practice.
+
+8
+00:00:33,000 --> 00:00:39,000
+And in this exam task we are going to improve our existing web application by adding spring security
+
+9
+00:00:39,000 --> 00:00:40,000
+features to it.
+
+10
+00:00:40,000 --> 00:00:44,000
+Let's review this document with the exam task description.
+
+11
+00:00:44,000 --> 00:00:48,000
+We'll make sure that you understand the task.
+
+12
+00:00:48,000 --> 00:00:51,000
+After that, you will try to implement the task.
+
+13
+00:00:51,000 --> 00:00:56,000
+And at the end of the video lesson, I am going to share with you my solution, and we are going to
+
+14
+00:00:56,000 --> 00:00:57,000
+discuss it.
+
+15
+00:00:57,000 --> 00:01:01,000
+So let's start with the review of the exam task.
+
+16
+00:01:02,000 --> 00:01:07,000
+The first thing that you need to do is to clone repository with our online shop.
+
+17
+00:01:07,000 --> 00:01:13,000
+In my course, Java from zero to first job will develop online shop from scratch and usually during
+
+18
+00:01:13,000 --> 00:01:19,000
+each following exam task, we continue from the point where we stopped last time.
+
+19
+00:01:20,000 --> 00:01:23,000
+So here is the link to the repository.
+
+20
+00:01:23,000 --> 00:01:24,000
+It is solution.
+
+21
+00:01:24,000 --> 00:01:30,000
+After completion of the previous exam task, when we finished integration of the Spring core and spring
+
+22
+00:01:30,000 --> 00:01:32,000
+MVC into our solution.
+
+23
+00:01:33,000 --> 00:01:38,000
+And now it is time to add spring security features into our application.
+
+24
+00:01:38,000 --> 00:01:46,000
+So once you clone the repository, try to run the application and make sure that you don't have errors
+
+25
+00:01:46,000 --> 00:01:47,000
+during the startup.
+
+26
+00:01:47,000 --> 00:01:51,000
+It would also require you to configure database.
+
+27
+00:01:51,000 --> 00:01:57,000
+Basically, you can refer to the README inside the repository and follow simple steps.
+
+28
+00:01:57,000 --> 00:02:04,000
+The main thing is to configure the database server, create schema, configure the schema inside the
+
+29
+00:02:04,000 --> 00:02:09,000
+application, and after that you can let hibernate, create all necessary tables.
+
+30
+00:02:09,000 --> 00:02:16,000
+But after that, in order to bring life to the application, you need to insert some data manually.
+
+31
+00:02:16,000 --> 00:02:21,000
+For example, information about products, about orders and things like that.
+
+32
+00:02:22,000 --> 00:02:23,000
+Everything is prepared for you.
+
+33
+00:02:23,000 --> 00:02:27,000
+You just need to follow the steps described in the README file.
+
+34
+00:02:27,000 --> 00:02:31,000
+You can find the folder with data to insert into the database.
+
+35
+00:02:31,000 --> 00:02:38,000
+Once you configure it application and manage to start it successfully, just navigate between pages,
+
+36
+00:02:38,000 --> 00:02:42,000
+Try to understand how it works just in case.
+
+37
+00:02:42,000 --> 00:02:48,000
+All business requirements that we implemented in the online shop are located in this file.
+
+38
+00:02:48,000 --> 00:02:54,000
+Feel free to look through it to understand the functionality of the application better.
+
+39
+00:02:54,000 --> 00:03:00,000
+It is recommended to make this overview of the functionality in order you can make sure that nothing
+
+40
+00:03:00,000 --> 00:03:03,000
+is broken Once you completed the home task.
+
+41
+00:03:03,000 --> 00:03:08,000
+And now you can start with the integration of the spring security with our application.
+
+42
+00:03:08,000 --> 00:03:15,000
+The first thing that you need to do is to configure authentication and security filter in the application.
+
+43
+00:03:15,000 --> 00:03:22,000
+We already have login page, So like we already learned in one of the lessons we need to configure spring
+
+44
+00:03:22,000 --> 00:03:25,000
+security with the custom login page.
+
+45
+00:03:25,000 --> 00:03:26,000
+Be attentive.
+
+46
+00:03:26,000 --> 00:03:32,000
+During the integration we learned everything you need to know to complete this part of the task.
+
+47
+00:03:32,000 --> 00:03:37,000
+So in case you need to refresh your knowledge, feel free to get back to the lessons that we already
+
+48
+00:03:37,000 --> 00:03:38,000
+watched.
+
+49
+00:03:38,000 --> 00:03:40,000
+Secure Protected Resources.
+
+50
+00:03:40,000 --> 00:03:47,000
+You need to secure order management resources to be accessible only to users with the admin and manager
+
+51
+00:03:47,000 --> 00:03:53,000
+roles and make admin resource available only for users with admin role.
+
+52
+00:03:53,000 --> 00:03:59,000
+Just remember that we don't have to store passwords in the database in the raw format.
+
+53
+00:04:00,000 --> 00:04:05,000
+Always encode passwords before putting them into the database.
+
+54
+00:04:05,000 --> 00:04:12,000
+Our current solution uses custom encoder, but within the task I want to use password encoder been to
+
+55
+00:04:12,000 --> 00:04:19,000
+encode passwords and too much raw password and encoded version of the password when needed.
+
+56
+00:04:20,000 --> 00:04:27,000
+I want you to implement application in the way where we can assign user to multiple roles.
+
+57
+00:04:27,000 --> 00:04:33,000
+In simple words, you need to be able to store array of roles inside the user.
+
+58
+00:04:33,000 --> 00:04:36,000
+Your user can have manager and admin role simultaneously.
+
+59
+00:04:36,000 --> 00:04:37,000
+For example.
+
+60
+00:04:38,000 --> 00:04:41,000
+Each role in turn can have multiple privileges.
+
+61
+00:04:41,000 --> 00:04:48,000
+For example, admin role can have read, write and delete privilege and manager user can have only read
+
+62
+00:04:48,000 --> 00:04:49,000
+and write privilege.
+
+63
+00:04:50,000 --> 00:04:57,000
+This is just an example, but I believe that you understood that role may contain multiple privileges
+
+64
+00:04:57,000 --> 00:05:00,000
+and each privilege can have multiple roles.
+
+65
+00:05:01,000 --> 00:05:02,000
+There will be many to many relation.
+
+66
+00:05:02,000 --> 00:05:03,000
+ActionScript.
+
+67
+00:05:04,000 --> 00:05:08,000
+Also want to implement Remember me functionality.
+
+68
+00:05:08,000 --> 00:05:15,000
+Be attentive because this would also require you to put authenticated user into the session when needed
+
+69
+00:05:15,000 --> 00:05:24,000
+because such element as header in our online shop relies on the user that is stored in the session taking
+
+70
+00:05:24,000 --> 00:05:25,000
+into account user.
+
+71
+00:05:25,000 --> 00:05:31,000
+In the session we show username and we change button in the header.
+
+72
+00:05:31,000 --> 00:05:39,000
+Namely when the user is logged in, we don't need to show button sign in and sign up, we just need
+
+73
+00:05:39,000 --> 00:05:41,000
+to show sign out button.
+
+74
+00:05:41,000 --> 00:05:44,000
+Think about how you will implement this.
+
+75
+00:05:44,000 --> 00:05:49,000
+For users who just registered, we need to set customer role by default.
+
+76
+00:05:49,000 --> 00:05:56,000
+Make sure that the registration login logout remember me and access restrictions functionality works
+
+77
+00:05:56,000 --> 00:05:57,000
+as expected.
+
+78
+00:05:58,000 --> 00:06:03,000
+I believe you can easily complete this task because there is nothing what we didn't discuss during the
+
+79
+00:06:04,000 --> 00:06:05,000
+learning course.
+
+80
+00:06:05,000 --> 00:06:11,000
+So now I recommend you to put on pause the video and proceed with the implementation.
+
+81
+00:06:11,000 --> 00:06:19,000
+And once you are done we are going to review my solution and changes that I did to compare yours and
+
+82
+00:06:19,000 --> 00:06:20,000
+my solution.
+
+83
+00:06:20,000 --> 00:06:27,000
+As you see all conditions and development environment is super close to the reality when you will get
+
+84
+00:06:27,000 --> 00:06:31,000
+new task assigned on you in real life.
+
+85
+00:06:31,000 --> 00:06:37,000
+Because in real life nobody would specify what files you need to fix or change.
+
+86
+00:06:38,000 --> 00:06:45,000
+You need to find the files that are needed to be changed in order to meet the requirements of the task.
+
+87
+00:06:45,000 --> 00:06:50,000
+And this is also part of your education in this course to be ready for real life.
+
+88
+00:06:51,000 --> 00:06:57,000
+So I bet that you completed the home task and now you're ready to review the solution together with
+
+89
+00:06:57,000 --> 00:06:58,000
+me.
+
+90
+00:06:58,000 --> 00:07:04,000
+First of all, I want to highlight that completely working solution is located in the separate repository.
+
+91
+00:07:04,000 --> 00:07:07,000
+You can find link here.
+
+92
+00:07:07,000 --> 00:07:13,000
+Feel free to clone it on your local computer to run it and explore it better.
+
+93
+00:07:14,000 --> 00:07:21,000
+In case you want to explore only changes, here is a commit with all changes that I did to implement
+
+94
+00:07:21,000 --> 00:07:22,000
+this coding exercise.
+
+95
+00:07:23,000 --> 00:07:28,000
+Let's review it together and I will give you my comments as we will go over.
+
+96
+00:07:28,000 --> 00:07:31,000
+I opened the commit with changes.
+
+97
+00:07:31,000 --> 00:07:33,000
+Let's review each file.
+
+98
+00:07:33,000 --> 00:07:41,000
+I introduced Ralph Facade in my business layer, just to remind you that when we learned layered architecture,
+
+99
+00:07:41,000 --> 00:07:45,000
+we made a decision to follow layered architecture pattern.
+
+100
+00:07:45,000 --> 00:07:51,000
+And in the solution we have strict separation between business layer and persistence layer.
+
+101
+00:07:51,000 --> 00:07:55,000
+So you can see that row facade is in our core module.
+
+102
+00:07:55,000 --> 00:07:57,000
+In the business layer.
+
+103
+00:07:57,000 --> 00:08:00,000
+We need to be able to extract role by name.
+
+104
+00:08:01,000 --> 00:08:05,000
+The implementation of the role facade is default role facade.
+
+105
+00:08:06,000 --> 00:08:13,000
+Inject role DAO into this class and role to roll converter.
+
+106
+00:08:13,000 --> 00:08:14,000
+On the business layer.
+
+107
+00:08:14,000 --> 00:08:18,000
+We operate with the business models on the persistence layer.
+
+108
+00:08:18,000 --> 00:08:21,000
+We work with the data transfer objects.
+
+109
+00:08:21,000 --> 00:08:27,000
+That's why we need converters to convert from object to the business model.
+
+110
+00:08:27,000 --> 00:08:34,000
+Moreover, this architecture in the future will allow you to add any business behavior to your business
+
+111
+00:08:34,000 --> 00:08:41,000
+model because methods with business logic, it is not something what you have to store in the objects
+
+112
+00:08:41,000 --> 00:08:42,000
+on the persistence layer.
+
+113
+00:08:42,000 --> 00:08:48,000
+That's why from one side this architecture gives you better scalability.
+
+114
+00:08:48,000 --> 00:08:55,000
+But at the same time, this architecture adds code complexity because of the additional classes.
+
+115
+00:08:55,000 --> 00:09:00,000
+This challenge is addressed in different frameworks in different way.
+
+116
+00:09:00,000 --> 00:09:07,000
+For example, there are already invented code generation tools that generates code automatically, taking
+
+117
+00:09:07,000 --> 00:09:10,000
+into account the structure of the data.
+
+118
+00:09:10,000 --> 00:09:18,000
+Object and converter is easy to define, and you can also create a code that will generate source code
+
+119
+00:09:18,000 --> 00:09:23,000
+of dtos and converters based on the XML configuration by yourself.
+
+120
+00:09:23,000 --> 00:09:31,000
+In other words, you can define your data types in the XML file, for example, and generate all required
+
+121
+00:09:31,000 --> 00:09:32,000
+details automatically.
+
+122
+00:09:32,000 --> 00:09:39,000
+This is just an additional food for thought for you in case you are interested about software architecture.
+
+123
+00:09:39,000 --> 00:09:44,000
+So the implementation of the default rule facade is pretty straightforward.
+
+124
+00:09:44,000 --> 00:09:49,000
+The next file that we updated is default user facade.
+
+125
+00:09:49,000 --> 00:09:58,000
+I've removed setting role name here and instead I added setting array of roles, taking into account
+
+126
+00:09:58,000 --> 00:10:01,000
+that we can register only user with a customer role.
+
+127
+00:10:01,000 --> 00:10:07,000
+You can see here that I passed the array of roles that contains only one element.
+
+128
+00:10:07,000 --> 00:10:08,000
+Customer role.
+
+129
+00:10:09,000 --> 00:10:16,000
+I added spring security core dependency in order to use password encoder in persistence module.
+
+130
+00:10:17,000 --> 00:10:21,000
+The next file that you can see here in the list is the setup data loader.
+
+131
+00:10:21,000 --> 00:10:27,000
+If you watched our lessons attentively, we already had this similar file in our code examples during
+
+132
+00:10:27,000 --> 00:10:28,000
+the previous lessons.
+
+133
+00:10:28,000 --> 00:10:33,000
+We are using it to configure privileges admin and manager users.
+
+134
+00:10:33,000 --> 00:10:39,000
+I will not make a detailed overview of this file because we already did the detailed overview of this
+
+135
+00:10:39,000 --> 00:10:47,000
+file during one of the coding exercises in the lesson, when we learned how to work with roles and privileges.
+
+136
+00:10:47,000 --> 00:10:54,000
+Basically just create or just check that all required roles, privileges and admin users exist in the
+
+137
+00:10:54,000 --> 00:11:01,000
+system and you can see that this class implements application listener of context refreshed event.
+
+138
+00:11:01,000 --> 00:11:06,000
+That means that mass will be triggered on the event of the context refresh.
+
+139
+00:11:07,000 --> 00:11:11,000
+In this solution I introduced new entity privilege.
+
+140
+00:11:11,000 --> 00:11:17,000
+That means that I need to create and implement all the related classes to support operations with this
+
+141
+00:11:17,000 --> 00:11:18,000
+entity.
+
+142
+00:11:18,000 --> 00:11:25,000
+This includes privilege, DAO, privilege, DTO privilege, business entity and privilege detail to
+
+143
+00:11:25,000 --> 00:11:27,000
+privilege business model converter.
+
+144
+00:11:27,000 --> 00:11:34,000
+Here you can see I declared two masses in the privilege DAO interface in the role Dao.
+
+145
+00:11:34,000 --> 00:11:37,000
+I declared one more method safe.
+
+146
+00:11:37,000 --> 00:11:43,000
+It is required for us to create all required roles from the setup data loader class.
+
+147
+00:11:43,000 --> 00:11:48,000
+The next thing here in the list is the implementation of the privilege.
+
+148
+00:11:48,000 --> 00:11:50,000
+Dao privilege.
+
+149
+00:11:50,000 --> 00:11:55,000
+Dao implements a contract using the entity manager factory and entity manager.
+
+150
+00:11:56,000 --> 00:11:58,000
+Also we slightly updated role DAO.
+
+151
+00:11:59,000 --> 00:12:06,000
+I fixed a typo in the class name changed role name attribute and implemented safe method.
+
+152
+00:12:06,000 --> 00:12:12,000
+Again, this is something that you have to be familiar with because we learned literally the similar
+
+153
+00:12:12,000 --> 00:12:15,000
+examples in lessons about GPA.
+
+154
+00:12:15,000 --> 00:12:21,000
+In case you want to refresh your knowledge, feel free to check my course Java from zero to first job
+
+155
+00:12:21,000 --> 00:12:24,000
+and name the section about GPA Hibernate.
+
+156
+00:12:24,000 --> 00:12:26,000
+Let's move on.
+
+157
+00:12:26,000 --> 00:12:29,000
+Here you can see privileged class.
+
+158
+00:12:29,000 --> 00:12:37,000
+And again, I just use the examples that I have shared with you in one of our lessons from this course.
+
+159
+00:12:37,000 --> 00:12:43,000
+So it contains ID, name and list of roles in the role detail.
+
+160
+00:12:43,000 --> 00:12:45,000
+I added privileges property.
+
+161
+00:12:45,000 --> 00:12:50,000
+It is many to many relation and you can see list of privileges here.
+
+162
+00:12:50,000 --> 00:12:53,000
+The rest is just getters and setters.
+
+163
+00:12:54,000 --> 00:13:02,000
+Also, I made changes in the user class configure it many to many relationship with the roles.
+
+164
+00:13:02,000 --> 00:13:05,000
+Also I added is enabled flag.
+
+165
+00:13:05,000 --> 00:13:11,000
+It is not mandatory according to the task requirements, but I just decided to add it for the future.
+
+166
+00:13:11,000 --> 00:13:18,000
+Probably we will implement with you security from the brute force and will disable account in case of
+
+167
+00:13:18,000 --> 00:13:22,000
+multiple failed login attempts or things like that.
+
+168
+00:13:22,000 --> 00:13:28,000
+Anyway, you can just turn on your imagination and come up with different similar business requirements.
+
+169
+00:13:29,000 --> 00:13:30,000
+I leave it here.
+
+170
+00:13:31,000 --> 00:13:35,000
+The next class here in the list is a converter class.
+
+171
+00:13:35,000 --> 00:13:40,000
+It is required to convert privilege to privilege business model.
+
+172
+00:13:40,000 --> 00:13:48,000
+Also based on the changes that we did in the raw entity, I also need to update row to row converter
+
+173
+00:13:48,000 --> 00:13:51,000
+and user to user converter.
+
+174
+00:13:52,000 --> 00:13:57,000
+The next thing here in the list is privileged role and user types.
+
+175
+00:13:57,000 --> 00:14:04,000
+And again, we just need to make proper changes to reflect changes in the relationships that we did
+
+176
+00:14:04,000 --> 00:14:05,000
+in our architecture.
+
+177
+00:14:05,000 --> 00:14:12,000
+Just to remind you that in this task we configured many to many relationships between role and privilege
+
+178
+00:14:12,000 --> 00:14:15,000
+and between user and role entities.
+
+179
+00:14:16,000 --> 00:14:22,000
+And after that goes implementation of these types namely default village.
+
+180
+00:14:22,000 --> 00:14:24,000
+Default role and default user.
+
+181
+00:14:25,000 --> 00:14:31,000
+This is exactly our business entities where we can put any business related behavior associated with
+
+182
+00:14:31,000 --> 00:14:33,000
+these entities.
+
+183
+00:14:33,000 --> 00:14:39,000
+In Pom.xml I added all necessary dependencies to work with spring security.
+
+184
+00:14:40,000 --> 00:14:46,000
+And the web application initializer add spring security filter to the select context.
+
+185
+00:14:46,000 --> 00:14:53,000
+In the next file in the web.config, I created all necessary beans required for implementation of our
+
+186
+00:14:53,000 --> 00:14:54,000
+task.
+
+187
+00:14:54,000 --> 00:15:01,000
+First of all, this is password encoder that we are going to use for password encoding and verification
+
+188
+00:15:01,000 --> 00:15:06,000
+of the raw password with its encoded version during the login.
+
+189
+00:15:06,000 --> 00:15:10,000
+The next bin is the authentication success handler.
+
+190
+00:15:10,000 --> 00:15:13,000
+We are going to review implementation a little bit later.
+
+191
+00:15:13,000 --> 00:15:20,000
+In short, I will use it for putting user into session and configuring redirection based on the roles
+
+192
+00:15:20,000 --> 00:15:21,000
+assigned.
+
+193
+00:15:22,000 --> 00:15:30,000
+Then we have configuration of the security filter chain authorization of requests, custom login form.
+
+194
+00:15:30,000 --> 00:15:31,000
+Pay attention.
+
+195
+00:15:31,000 --> 00:15:34,000
+I change the name of the username parameter.
+
+196
+00:15:34,000 --> 00:15:41,000
+As you remember, in case you use custom attribute name for username in the login form, you need to
+
+197
+00:15:41,000 --> 00:15:44,000
+specify it in the configuration.
+
+198
+00:15:44,000 --> 00:15:49,000
+And in my case I decided not to change existing login form.
+
+199
+00:15:49,000 --> 00:15:53,000
+An existing form uses email name parameter.
+
+200
+00:15:54,000 --> 00:15:58,000
+I said success handler and failure handler.
+
+201
+00:15:58,000 --> 00:16:04,000
+Failure handler is used to limit failed amount of the attempts to login with the same period of time.
+
+202
+00:16:04,000 --> 00:16:08,000
+We are going to review implementation a little bit later.
+
+203
+00:16:08,000 --> 00:16:12,000
+Actually, it was already implemented in the template of the code.
+
+204
+00:16:13,000 --> 00:16:18,000
+I just took it from the in controller and moved it into failure handler.
+
+205
+00:16:18,000 --> 00:16:21,000
+Configure it, log out and remember me feature.
+
+206
+00:16:22,000 --> 00:16:28,000
+Remember me configuration used literally in the same way like I showed you in the lesson about Remember
+
+207
+00:16:28,000 --> 00:16:29,000
+Me functionality.
+
+208
+00:16:30,000 --> 00:16:32,000
+The next bin is failure Handler.
+
+209
+00:16:32,000 --> 00:16:36,000
+We are going to review its implementation soon.
+
+210
+00:16:37,000 --> 00:16:42,000
+Also user details, service authentication provider and registration of the authentication provider
+
+211
+00:16:42,000 --> 00:16:45,000
+in the authentication manager.
+
+212
+00:16:45,000 --> 00:16:48,000
+Admin controller is the next file in the list.
+
+213
+00:16:48,000 --> 00:16:50,000
+This is just simple controller.
+
+214
+00:16:50,000 --> 00:16:56,000
+In order to resolve admin panel view that according to requirements should be protected.
+
+215
+00:16:57,000 --> 00:17:03,000
+There are no specific requirements to this panel in general, and this particular exam task will practice
+
+216
+00:17:03,000 --> 00:17:06,000
+our skills and configuration of the spring security.
+
+217
+00:17:07,000 --> 00:17:10,000
+That's why the simple page is enough.
+
+218
+00:17:10,000 --> 00:17:12,000
+In the edit profile controller.
+
+219
+00:17:12,000 --> 00:17:20,000
+I also made some changes because it used as encoder and now inject password encoder being that we declared.
+
+220
+00:17:21,000 --> 00:17:28,000
+I removed a lot from the sign in controller because part of the functionality described here goes to
+
+221
+00:17:28,000 --> 00:17:29,000
+the spring security.
+
+222
+00:17:29,000 --> 00:17:36,000
+Another part of the functionality is moved into authentication success handler and the last part of
+
+223
+00:17:36,000 --> 00:17:40,000
+the functionality is moved into the authentication failure handler.
+
+224
+00:17:41,000 --> 00:17:45,000
+Signout controller was removed because we don't need it.
+
+225
+00:17:45,000 --> 00:17:53,000
+Spring security will take care of Signout and we configure it Signout already in signup controller.
+
+226
+00:17:53,000 --> 00:18:01,000
+I also had to make changes in order to inject password and quarter bean and use its API.
+
+227
+00:18:01,000 --> 00:18:06,000
+Admin filter and management filter were removed because right now there is no need in them.
+
+228
+00:18:07,000 --> 00:18:11,000
+Authentication is performed by the spring security now.
+
+229
+00:18:12,000 --> 00:18:15,000
+Remember me filter is important and interesting.
+
+230
+00:18:15,000 --> 00:18:18,000
+One let me explain you why we need it.
+
+231
+00:18:18,000 --> 00:18:26,000
+So as you may notice, some behavior in the application relies on the presence of the user in the session.
+
+232
+00:18:26,000 --> 00:18:34,000
+Namely, we need to hide signing button in the header in case user is logged in and show his name.
+
+233
+00:18:34,000 --> 00:18:42,000
+And also we need to hide sign up button in case user is logged in and to show sign out button instead
+
+234
+00:18:42,000 --> 00:18:50,000
+we implemented Remember Me feature in the scenario when I close the web browser and open it again based
+
+235
+00:18:50,000 --> 00:18:59,000
+on the cookie set application authenticates our user, but the session is actually destroyed and new
+
+236
+00:18:59,000 --> 00:19:00,000
+one is created.
+
+237
+00:19:00,000 --> 00:19:09,000
+So this filter intercepts all the requests in case there is no user in the session configured, I check
+
+238
+00:19:09,000 --> 00:19:16,000
+whether there is somebody authenticated in the security context holder and in case there is somebody
+
+239
+00:19:16,000 --> 00:19:22,000
+authenticated, we get this user by email from the persistent storage and we set it into the session.
+
+240
+00:19:22,000 --> 00:19:24,000
+That's it.
+
+241
+00:19:24,000 --> 00:19:31,000
+Another challenge that you may face with in general with injecting beans into the web filters because
+
+242
+00:19:31,000 --> 00:19:39,000
+of the way how initialization happens, you can't inject beans by simply putting auto wired annotation.
+
+243
+00:19:40,000 --> 00:19:47,000
+One of the possible ways of how to initialize a property with the bin that you want is to get the reference
+
+244
+00:19:47,000 --> 00:19:51,000
+to the application context and extract bin from it.
+
+245
+00:19:51,000 --> 00:19:53,000
+How to do this?
+
+246
+00:19:53,000 --> 00:20:00,000
+You can see in these lines, the next class here is a default authentication failure handler.
+
+247
+00:20:00,000 --> 00:20:07,000
+And as already mentioned before, this code is part of the code that I took from the sign in controller
+
+248
+00:20:07,000 --> 00:20:09,000
+of the project template.
+
+249
+00:20:09,000 --> 00:20:16,000
+Taking into account that authentication is handled by the spring security, I need to put some part
+
+250
+00:20:16,000 --> 00:20:18,000
+of logic into the event handlers.
+
+251
+00:20:19,000 --> 00:20:26,000
+Namely, in this handler, I handle cases of the failure during the authentication in case there will
+
+252
+00:20:26,000 --> 00:20:32,000
+be three unsuccessful attempts of login, we update the variable of the unsuccessful login in order
+
+253
+00:20:32,000 --> 00:20:38,000
+to prevent brute force and stop wrong usage of the web application.
+
+254
+00:20:38,000 --> 00:20:42,000
+His next file here is a authentication success handler.
+
+255
+00:20:42,000 --> 00:20:50,000
+The purpose of this handler, first of all, is to make sure that we put user into the session in order
+
+256
+00:20:50,000 --> 00:20:57,000
+to use it later in the application during the purchase flow and other business related actions, and
+
+257
+00:20:57,000 --> 00:21:03,000
+taking into account that redirection to the configured success here doesn't work when we declare a success
+
+258
+00:21:03,000 --> 00:21:04,000
+handler.
+
+259
+00:21:04,000 --> 00:21:12,000
+Considering this, I also need to manage redirection of the user based on their roles in this event
+
+260
+00:21:12,000 --> 00:21:12,000
+handler.
+
+261
+00:21:13,000 --> 00:21:19,000
+So users with the admin role are redirected to the admin panel and all other users are redirected to
+
+262
+00:21:19,000 --> 00:21:22,000
+the home page according to our requirements.
+
+263
+00:21:23,000 --> 00:21:26,000
+Default authentication provider.
+
+264
+00:21:26,000 --> 00:21:30,000
+I used the same that we used and reviewed in the lesson.
+
+265
+00:21:30,000 --> 00:21:35,000
+Just checking username and password and returning authentication object.
+
+266
+00:21:36,000 --> 00:21:40,000
+The fork user details service almost the similar story.
+
+267
+00:21:40,000 --> 00:21:43,000
+I took the same implementation that I used in the lesson.
+
+268
+00:21:44,000 --> 00:21:47,000
+I believe there is no need for me to repeat myself on everything.
+
+269
+00:21:47,000 --> 00:21:53,000
+What we have reviewed in the lessons because in this case the length of this video will be the summary
+
+270
+00:21:53,000 --> 00:21:55,000
+length of all previous lessons.
+
+271
+00:21:55,000 --> 00:22:00,000
+Feel free to get back to the previous lessons in case you want to refresh your knowledge.
+
+272
+00:22:00,000 --> 00:22:07,000
+And in this video I will focus only on the specifics of the implementation of the application.
+
+273
+00:22:08,000 --> 00:22:14,000
+I removed and quarters that we used in the previous solution because now we are going to use password
+
+274
+00:22:14,000 --> 00:22:23,000
+encoder been added some changes in the profile personal tag taking into account we have array of roles
+
+275
+00:22:23,000 --> 00:22:24,000
+associated with the user.
+
+276
+00:22:24,000 --> 00:22:28,000
+Let's not display all the possible role names.
+
+277
+00:22:28,000 --> 00:22:31,000
+Here is the template file for admin panel.
+
+278
+00:22:31,000 --> 00:22:38,000
+So team, the main thing for us is to practice our skills in the configuration of the spring security.
+
+279
+00:22:38,000 --> 00:22:43,000
+That's why there is not so much JavaScript or anything else on this page.
+
+280
+00:22:43,000 --> 00:22:49,000
+It exists just for you to practice in configuring access to the admin resources.
+
+281
+00:22:50,000 --> 00:22:54,000
+Also, I introduced improvements in the not found page.
+
+282
+00:22:54,000 --> 00:23:02,000
+I used the URL from the core STL in order to not have problems with the relative paths in case Page
+
+283
+00:23:02,000 --> 00:23:08,000
+is not found, not in the root of our application, but in some other places.
+
+284
+00:23:08,000 --> 00:23:15,000
+Because previously we had issues with not being able to find required CSS resources using relative paths.
+
+285
+00:23:16,000 --> 00:23:22,000
+This improvement is not specified directly in the requirements of the exam task.
+
+286
+00:23:22,000 --> 00:23:29,000
+I just gradually improve our solution in case I found something strange or typos like here, for example.
+
+287
+00:23:30,000 --> 00:23:36,000
+Because our goal is to make completely ready to use online shop by the end of the course.
+
+288
+00:23:36,000 --> 00:23:38,000
+Java from zero to first job.
+
+289
+00:23:39,000 --> 00:23:45,000
+On the sign in page, I added Remember me checkbox and updated action in my form.
+
+290
+00:23:45,000 --> 00:23:48,000
+According to the configuration defined.
+
+291
+00:23:48,000 --> 00:23:56,000
+Also, I fixed type in the template project because for the password it is recommended to use password
+
+292
+00:23:56,000 --> 00:23:58,000
+element for the security reasons.
+
+293
+00:23:59,000 --> 00:24:06,000
+I've removed redundant sinks from the web.xml and also I had to adjust the styling for the checkbox
+
+294
+00:24:06,000 --> 00:24:12,000
+because opacity was set to zero and absolute position was a shift to the left.
+
+295
+00:24:13,000 --> 00:24:19,000
+So without commenting these styles in the style CSS, you won't be able to see the checkbox that you
+
+296
+00:24:19,000 --> 00:24:21,000
+put on the sign in page.
+
+297
+00:24:22,000 --> 00:24:23,000
+Be attentive.
+
+298
+00:24:23,000 --> 00:24:26,000
+I also made checkbox slightly bigger.
+
+299
+00:24:27,000 --> 00:24:31,000
+Basically that's all solutions that I've implemented.
+
+300
+00:24:32,000 --> 00:24:38,000
+And remember, in programming, especially on such advanced level and using such flexible framework
+
+301
+00:24:38,000 --> 00:24:43,000
+as spring, there are always multiple solutions to solve the same task.
+
+302
+00:24:43,000 --> 00:24:50,000
+So don't worry in case your implementation is slightly different, no need to worry about that is also
+
+303
+00:24:50,000 --> 00:24:56,000
+fine because like I said, there are multiple possible solutions of the same task.
+
+304
+00:24:57,000 --> 00:25:04,000
+I'm sure that this learning module was super useful for you, and we learned really a lot of things.
+
+305
+00:25:04,000 --> 00:25:11,000
+After completion of this exam task, you can consider yourself as professional in spring security.
+
+306
+00:25:11,000 --> 00:25:13,000
+Congratulations with this.
+
+307
+00:25:13,000 --> 00:25:20,000
+And always remember that in case you have any questions, you can put them below the video and I will
+
+308
+00:25:20,000 --> 00:25:21,000
+be happy to answer.
+
+309
+00:25:22,000 --> 00:25:24,000
+So thanks a lot for your attention.
+
+310
+00:25:25,000 --> 00:25:28,000
+We should agree today and see you in the next lesson.
+

85 - ===== EXAM Spring Security - Online Shop =====/001 Exam-task-description-with-the-reference-to-the-solution.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://docs.google.com/document/d/1HjR-heOVqGgGVdtqf1_5r_T21Ax45lynDktLJzngHTU/edit?usp=sharing

85 - ===== EXAM Spring Security - Online Shop =====/external-links.txt

@@ -0,0 +1,3 @@
+
+001 Exam-task-description-with-the-reference-to-the-solution
+https://docs.google.com/document/d/1HjR-heOVqGgGVdtqf1_5r_T21Ax45lynDktLJzngHTU/edit?usp=sharing

86 - Spring Data/001 Spring Data & Spring Data JPA Overview_en.srt

@@ -0,0 +1,664 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, team.
+
+2
+00:00:06,000 --> 00:00:09,000
+Welcome to the first lesson of the new module.
+
+3
+00:00:09,000 --> 00:00:16,000
+We are continuing learning spring framework and with this lesson we start learning of the Spring data
+
+4
+00:00:16,000 --> 00:00:17,000
+module.
+
+5
+00:00:17,000 --> 00:00:24,000
+In this first video we are going to learn what is spring data is we will make an overview in order.
+
+6
+00:00:24,000 --> 00:00:27,000
+You can understand what it is.
+
+7
+00:00:27,000 --> 00:00:34,000
+We will learn what spring data modules exists and we will focus our attention on the review of the Spring
+
+8
+00:00:34,000 --> 00:00:36,000
+Data JPA module.
+
+9
+00:00:36,000 --> 00:00:42,000
+You are going to understand the challenge that spring data JPA is supposed to help us with.
+
+10
+00:00:43,000 --> 00:00:46,000
+I will explain what spring data repositories are.
+
+11
+00:00:46,000 --> 00:00:53,000
+Also, we'll talk about repository pattern and at the end of the lesson we are going to use spring data,
+
+12
+00:00:53,000 --> 00:00:55,000
+JPA advantages and disadvantages.
+
+13
+00:00:55,000 --> 00:01:01,000
+This will be introductory lessons that will give you more context before we jump to practical coding
+
+14
+00:01:01,000 --> 00:01:06,000
+exercises in the following lessons, let's start our lesson.
+
+15
+00:01:06,000 --> 00:01:11,000
+Let's start with a brief overview of what actually spring data is.
+
+16
+00:01:11,000 --> 00:01:19,000
+The spring data is an umbrella project, having many subprojects or modules to provide uniform abstractions
+
+17
+00:01:19,000 --> 00:01:27,000
+and uniform utility methods for the data access layer in an application and supports a wide range of
+
+18
+00:01:27,000 --> 00:01:30,000
+databases and data stores.
+
+19
+00:01:30,000 --> 00:01:32,000
+What kind of projects?
+
+20
+00:01:32,000 --> 00:01:33,000
+For example?
+
+21
+00:01:33,000 --> 00:01:40,000
+Data graph data, JDBC data, JPA data, Mongo data, Solr, etcetera.
+
+22
+00:01:40,000 --> 00:01:47,000
+And it is important to understand that spring data is not a specification to implement or some kind
+
+23
+00:01:47,000 --> 00:01:48,000
+of standard.
+
+24
+00:01:48,000 --> 00:01:50,000
+It is just an abstraction.
+
+25
+00:01:50,000 --> 00:01:57,000
+It contains many different modules starting from the core Spring Data Commons module to specific ones
+
+26
+00:01:57,000 --> 00:02:01,000
+like spring data radius, spring data, Mongo, etcetera.
+
+27
+00:02:02,000 --> 00:02:08,000
+The goal of this abstraction is to bring consistency between the ways we access data on multiple data
+
+28
+00:02:08,000 --> 00:02:14,000
+stores, no matter whether we are talking about relational or NoSQL databases.
+
+29
+00:02:14,000 --> 00:02:20,000
+Another important thing to understand is to know what a spring data JPA is.
+
+30
+00:02:20,000 --> 00:02:29,000
+So as I already said, spring data is a common name that is used to group multiple sub projects and
+
+31
+00:02:29,000 --> 00:02:30,000
+spring data.
+
+32
+00:02:30,000 --> 00:02:35,000
+JPA is just one out of many other projects, but probably one of the most popular.
+
+33
+00:02:35,000 --> 00:02:40,000
+A lot of people saying that Spring Data JPA is a GP implementation.
+
+34
+00:02:40,000 --> 00:02:42,000
+Actually, it is not.
+
+35
+00:02:42,000 --> 00:02:48,000
+In reality, Spring Data JPA uses hibernate GP implementation.
+
+36
+00:02:48,000 --> 00:02:57,000
+GPA is a specification that defines an API for object relational mappings and for managing persistent
+
+37
+00:02:57,000 --> 00:02:58,000
+objects.
+
+38
+00:02:58,000 --> 00:03:04,000
+Hibernate and Eclipselink are two the most popular implementations of this specification and in the
+
+39
+00:03:04,000 --> 00:03:08,000
+case spring data JPA is not a GP implementation.
+
+40
+00:03:08,000 --> 00:03:14,000
+Then what it is, we can say that spring Data JPA is an add on for GPA.
+
+41
+00:03:15,000 --> 00:03:21,000
+It provides a framework that works with GPA and provides a complete abstraction over the data access
+
+42
+00:03:21,000 --> 00:03:22,000
+layer.
+
+43
+00:03:22,000 --> 00:03:27,000
+Taking into account that spring data JPA is add on on top of GPA.
+
+44
+00:03:28,000 --> 00:03:36,000
+It uses all features defined by the GPA specification, including entity mappings, lifecycle management
+
+45
+00:03:36,000 --> 00:03:39,000
+and GPA query capabilities.
+
+46
+00:03:39,000 --> 00:03:47,000
+And on top of that, spring data, JPA adds its own features like no code implementation of the DAO
+
+47
+00:03:47,000 --> 00:03:51,000
+and creation of database queries from the method names.
+
+48
+00:03:51,000 --> 00:03:56,000
+We are going to start learning the spring data from the Spring Data JPA module.
+
+49
+00:03:57,000 --> 00:04:02,000
+To begin with, let's understand the problem that we are going to address with the spring data.
+
+50
+00:04:02,000 --> 00:04:09,000
+If you are a student of my course Java from zero to first job and you learned DAO pattern in one of
+
+51
+00:04:09,000 --> 00:04:17,000
+the lessons, then you already realize what does it mean to define interface for DAO to implement it
+
+52
+00:04:17,000 --> 00:04:24,000
+and you have multiple entities and also in case you want to switch to another database, for example,
+
+53
+00:04:24,000 --> 00:04:29,000
+from relational to Non-relational, you need to implement all those again.
+
+54
+00:04:29,000 --> 00:04:33,000
+And imagine doing this for all entities in your application.
+
+55
+00:04:33,000 --> 00:04:41,000
+It is really big amount of code and it is good in case you don't have too much entities, but in case
+
+56
+00:04:41,000 --> 00:04:48,000
+you have a lot of models, you feel all the pain and most of the code looks similar.
+
+57
+00:04:49,000 --> 00:04:51,000
+What if we could simplify this?
+
+58
+00:04:51,000 --> 00:04:59,000
+There are a lot of advantages of such simplification, like, for example, decreasing the number of
+
+59
+00:04:59,000 --> 00:05:05,000
+artifacts that we need to create and support consistency of data access patterns and consistency of
+
+60
+00:05:05,000 --> 00:05:10,000
+configuration and spring data helps us to simplify this.
+
+61
+00:05:10,000 --> 00:05:17,000
+Spring data is going to address the challenge of the implementation of different DAO and their support.
+
+62
+00:05:18,000 --> 00:05:19,000
+Spring data.
+
+63
+00:05:19,000 --> 00:05:22,000
+JPA brings the concept of the repositories.
+
+64
+00:05:23,000 --> 00:05:24,000
+What are they?
+
+65
+00:05:25,000 --> 00:05:32,000
+Repositories are a set of interfaces that define ready to use methods to work with the data from the
+
+66
+00:05:32,000 --> 00:05:33,000
+repositories.
+
+67
+00:05:33,000 --> 00:05:40,000
+The JPA repository represents the layer in our application according to the concept.
+
+68
+00:05:40,000 --> 00:05:46,000
+You don't necessarily need to write queries anymore, but still you can.
+
+69
+00:05:46,000 --> 00:05:52,000
+And sometimes you have to write SQL queries using spring data JPA.
+
+70
+00:05:52,000 --> 00:05:55,000
+You don't need to write SQL statements.
+
+71
+00:05:55,000 --> 00:06:01,000
+So taking into account spring GPA uses hibernate GP implementation.
+
+72
+00:06:01,000 --> 00:06:07,000
+It uses entity manager for persistent and retrieving entities from the databases.
+
+73
+00:06:07,000 --> 00:06:11,000
+It also enables entity object and their mappings.
+
+74
+00:06:11,000 --> 00:06:19,000
+So in order to understand how spring data JPA works, it is nice to have experience of working with
+
+75
+00:06:19,000 --> 00:06:20,000
+Hibernate.
+
+76
+00:06:20,000 --> 00:06:26,000
+And in case you want to refresh your knowledge, I have a lot of detailed lessons about Hibernate in
+
+77
+00:06:26,000 --> 00:06:28,000
+my course Java from zero to first job.
+
+78
+00:06:29,000 --> 00:06:36,000
+Now it is time to review advantages and disadvantages of Spring Data JPA and we are going to start with
+
+79
+00:06:36,000 --> 00:06:37,000
+advantages.
+
+80
+00:06:38,000 --> 00:06:45,000
+The first advantage of the spring data JPA is its seamless integration with the rest of the spring framework.
+
+81
+00:06:45,000 --> 00:06:52,000
+Just imagine integration with all other spring based components in your application.
+
+82
+00:06:52,000 --> 00:06:55,000
+Accessing property configurations.
+
+83
+00:06:55,000 --> 00:07:00,000
+Auto wiring of the repositories into the application service layer.
+
+84
+00:07:00,000 --> 00:07:06,000
+When we will start learn Spring boot, you will understand how easily it is also configured in the spring
+
+85
+00:07:06,000 --> 00:07:11,000
+boot where we only need to provide the data source details.
+
+86
+00:07:12,000 --> 00:07:17,000
+The next advantage that I already mentioned previously is no code repositories.
+
+87
+00:07:17,000 --> 00:07:21,000
+Spring Data JPA implements repository pattern.
+
+88
+00:07:21,000 --> 00:07:24,000
+The repository pattern is pretty simple.
+
+89
+00:07:24,000 --> 00:07:33,000
+An interface defines the repository with all logical read and write operations for a specific entity.
+
+90
+00:07:33,000 --> 00:07:34,000
+That's it.
+
+91
+00:07:35,000 --> 00:07:42,000
+Implementing that pattern isn't too complicated, but writing the standard CRUD operations for each
+
+92
+00:07:42,000 --> 00:07:46,000
+entity creates a lot of repetitive code.
+
+93
+00:07:46,000 --> 00:07:54,000
+Spring Data JPA provides you a set of repository interfaces which you only need to extend to define
+
+94
+00:07:54,000 --> 00:07:58,000
+a specific repository for one of your entities.
+
+95
+00:07:58,000 --> 00:08:03,000
+On this slide, you can see example of the repository that can do the following things.
+
+96
+00:08:04,000 --> 00:08:09,000
+Persist update and remove one or multiple book entities.
+
+97
+00:08:09,000 --> 00:08:14,000
+Find one or more books by their primary keys.
+
+98
+00:08:14,000 --> 00:08:15,000
+Count.
+
+99
+00:08:15,000 --> 00:08:17,000
+Get and remove all books.
+
+100
+00:08:18,000 --> 00:08:21,000
+Check if a book with a given primary key exists.
+
+101
+00:08:22,000 --> 00:08:29,000
+And yes, this is literally all the code that you need by extending CRUD repository.
+
+102
+00:08:29,000 --> 00:08:32,000
+You can take advantage of spring data JPA.
+
+103
+00:08:33,000 --> 00:08:38,000
+This is probably one of the most impressive and attractive feature of spring data JPA.
+
+104
+00:08:39,000 --> 00:08:43,000
+The third advantage is reducing code.
+
+105
+00:08:43,000 --> 00:08:49,000
+Reducing the code means you also reduce the probability of bugs and mistakes.
+
+106
+00:08:49,000 --> 00:08:53,000
+Also, it just makes your life a little bit easier.
+
+107
+00:08:54,000 --> 00:08:59,000
+The next advantage is query generation based on the method names.
+
+108
+00:09:00,000 --> 00:09:07,000
+This is a super interesting feature, even in case you don't have masses that you need in one of the
+
+109
+00:09:07,000 --> 00:09:09,000
+predefined repositories.
+
+110
+00:09:09,000 --> 00:09:17,000
+You just need to name method in your interface according to pattern and required query will be automatically
+
+111
+00:09:17,000 --> 00:09:18,000
+generated for you.
+
+112
+00:09:18,000 --> 00:09:19,000
+Can you imagine that?
+
+113
+00:09:20,000 --> 00:09:23,000
+For example, pay attention to the example on the slide.
+
+114
+00:09:24,000 --> 00:09:30,000
+In this case we defined method find by title with the string parameter.
+
+115
+00:09:30,000 --> 00:09:38,000
+Now I can simply inject this repository in any class of the service layer and use the method to extract
+
+116
+00:09:38,000 --> 00:09:43,000
+book by fieldname where field name will be called title.
+
+117
+00:09:43,000 --> 00:09:53,000
+So we removed a lot of advantages and as experienced engineer IT director, I can sell spring data JPA
+
+118
+00:09:53,000 --> 00:09:54,000
+when it is needed.
+
+119
+00:09:54,000 --> 00:10:01,000
+But taking into account with this course, I want to share with you everything what I know.
+
+120
+00:10:01,000 --> 00:10:03,000
+I will be completely honest with you.
+
+121
+00:10:04,000 --> 00:10:07,000
+Spring Data JPA has its own disadvantages.
+
+122
+00:10:08,000 --> 00:10:09,000
+I will try to be short.
+
+123
+00:10:10,000 --> 00:10:17,000
+We already learned that spring data is an addition layer above common technologies for storing data.
+
+124
+00:10:17,000 --> 00:10:25,000
+Spring Data JPA is the most commonly used part of spring data is supposed to simplify GPU based code
+
+125
+00:10:25,000 --> 00:10:28,000
+by eliminating recurrent pieces of code.
+
+126
+00:10:29,000 --> 00:10:37,000
+But in reality, spring data JPA simplifies the code by sacrificing performance and flexibility sometimes.
+
+127
+00:10:37,000 --> 00:10:45,000
+Also, it doesn't provide a lot of new things because it still uses hibernate and hidden entity manager.
+
+128
+00:10:45,000 --> 00:10:53,000
+So it looks like the key feature of spring data JPA is just to save time on writing code rather than
+
+129
+00:10:53,000 --> 00:10:59,000
+to achieve better performance or optimization in the way how queries are generated.
+
+130
+00:11:00,000 --> 00:11:07,000
+There is a thought that overall spring data JPA is the best suited for demo application with empty databases,
+
+131
+00:11:07,000 --> 00:11:11,000
+primarily because of the performance concerns.
+
+132
+00:11:11,000 --> 00:11:19,000
+Of course, the project is evolving and of course it is getting better with each release and each new
+
+133
+00:11:19,000 --> 00:11:23,000
+version, you know, using spring data JPA or something else.
+
+134
+00:11:23,000 --> 00:11:26,000
+It is just a matter of style and habit.
+
+135
+00:11:27,000 --> 00:11:31,000
+Somebody likes cars with an automatic gearbox.
+
+136
+00:11:31,000 --> 00:11:36,000
+But I'm the guy who prefer to have manual gearbox in the programming.
+
+137
+00:11:36,000 --> 00:11:44,000
+I like the granularity and control that I get with the JDBC, but I accept the fact that somebody may
+
+138
+00:11:44,000 --> 00:11:48,000
+not like this as me, and that is fine.
+
+139
+00:11:48,000 --> 00:11:55,000
+As I said, it is a matter of style and as professionals we need to know different ways to achieve the
+
+140
+00:11:55,000 --> 00:11:56,000
+same goal.
+
+141
+00:11:56,000 --> 00:12:01,000
+As you may already guess, I prefer JDBC and I'm not joking.
+
+142
+00:12:01,000 --> 00:12:08,000
+You know that I am CEO of IT company and we have our own products, including mobile and web applications
+
+143
+00:12:08,000 --> 00:12:11,000
+and because of many different reasons I still.
+
+144
+00:12:11,000 --> 00:12:13,000
+Prefer using JDBC.
+
+145
+00:12:13,000 --> 00:12:18,000
+If you just want to use spring, there is also spring data JDBC module.
+
+146
+00:12:18,000 --> 00:12:22,000
+Like I said, my main concern is performance.
+
+147
+00:12:22,000 --> 00:12:28,000
+Yes, using JDBC is not so fancy and it takes longer to write the code.
+
+148
+00:12:28,000 --> 00:12:30,000
+But that's the way how I work.
+
+149
+00:12:31,000 --> 00:12:38,000
+I also saw how Spring Data JPA is applied in production environment and I can confirm that it is also
+
+150
+00:12:38,000 --> 00:12:39,000
+possible.
+
+151
+00:12:39,000 --> 00:12:47,000
+But in my opinion, spring data JPA brings not so much things besides fancy way to define Daos by just
+
+152
+00:12:47,000 --> 00:12:52,000
+creating interfaces and using non-optimized massive wrappers.
+
+153
+00:12:52,000 --> 00:13:00,000
+But even despite all these advantages, just remember that spring data also has advantages, and this
+
+154
+00:13:00,000 --> 00:13:06,000
+true professionals will have to understand what the spring data JPA is and be ready to apply gained
+
+155
+00:13:06,000 --> 00:13:09,000
+knowledge on practice when it is needed.
+
+156
+00:13:09,000 --> 00:13:14,000
+That's all what I wanted to share with you in this introductory lesson.
+
+157
+00:13:14,000 --> 00:13:17,000
+Let's recap what we have learned today.
+
+158
+00:13:17,000 --> 00:13:20,000
+Today we did an overview of spring data.
+
+159
+00:13:21,000 --> 00:13:24,000
+We reviewed what spring data modules exists.
+
+160
+00:13:25,000 --> 00:13:28,000
+Also, we learned what a spring data JPA is.
+
+161
+00:13:29,000 --> 00:13:31,000
+I explained what repositories are.
+
+162
+00:13:32,000 --> 00:13:34,000
+We discussed briefly repository pattern.
+
+163
+00:13:35,000 --> 00:13:41,000
+And at the end of the lesson we learned advantages and disadvantages of the Spring Data JPA.
+
+164
+00:13:41,000 --> 00:13:43,000
+That's it for today.
+
+165
+00:13:43,000 --> 00:13:45,000
+Thanks a lot for your attention.
+
+166
+00:13:45,000 --> 00:13:48,000
+Have a great day and see you in the next lesson.
+

86 - Spring Data/002 Source-code-of-examples-commit-with-changes-.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/e9e37fb6749af4c7ec493a54acea7cadbbafd612

86 - Spring Data/002 Spring Data JPA Practice_en.srt

@@ -0,0 +1,996 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello Tim.
+
+2
+00:00:06,000 --> 00:00:11,000
+We already hold an overview of spring data and spring data JPA.
+
+3
+00:00:11,000 --> 00:00:18,000
+We learned advantages and disadvantages and key concepts and now it is time for practice.
+
+4
+00:00:18,000 --> 00:00:22,000
+This lesson will be completely dedicated to the practical examples.
+
+5
+00:00:22,000 --> 00:00:28,000
+Today we are going to configure our spring application to work with Spring Data JPA.
+
+6
+00:00:28,000 --> 00:00:35,000
+We are going to define all the necessary beans, configure data, source, add all necessary dependencies
+
+7
+00:00:35,000 --> 00:00:37,000
+and things like that.
+
+8
+00:00:37,000 --> 00:00:43,000
+During the video together we are going to create our first spring data JPA repository.
+
+9
+00:00:43,000 --> 00:00:48,000
+I'm going to show you how to define methods in the repository.
+
+10
+00:00:48,000 --> 00:00:55,000
+I will show you how we can use GPG and Native SQL queries in our repository.
+
+11
+00:00:56,000 --> 00:01:01,000
+Also, we will learn naming convention for masses in other spring data.
+
+12
+00:01:01,000 --> 00:01:06,000
+JPA can generate queries based on the method names in the interface of our repository.
+
+13
+00:01:06,000 --> 00:01:13,000
+We need to name masses according to the specific pattern and we will learn such keywords.
+
+14
+00:01:13,000 --> 00:01:20,000
+And during the live demo you are going to see end to end example to understand how spring data JPA repository
+
+15
+00:01:20,000 --> 00:01:24,000
+can be integrated into your application.
+
+16
+00:01:24,000 --> 00:01:26,000
+Let's start our lesson.
+
+17
+00:01:26,000 --> 00:01:32,000
+Before we start our lesson, I want to highlight that it is important that you watch previous theoretical
+
+18
+00:01:32,000 --> 00:01:40,000
+lessons because the key terms and concepts about spring data JPA were discussed in the previous video.
+
+19
+00:01:40,000 --> 00:01:46,000
+So as I promised, this lesson will be completely focused on the practical examples.
+
+20
+00:01:47,000 --> 00:01:51,000
+Let me jump to the practical code examples and screen sharing.
+
+21
+00:01:52,000 --> 00:01:58,000
+During the demo, I am going to use our spring training project that we used in our spring course from
+
+22
+00:01:58,000 --> 00:01:58,000
+the beginning.
+
+23
+00:01:59,000 --> 00:02:05,000
+And as always, you will be able to find all source code examples in attachments to the video.
+
+24
+00:02:05,000 --> 00:02:12,000
+So the first thing that we need to do, let's add all required dependencies into our POM XML.
+
+25
+00:02:12,000 --> 00:02:16,000
+Let me open pom XML and review what I have added.
+
+26
+00:02:16,000 --> 00:02:21,000
+The main dependency for our lesson is spring data JPA dependency.
+
+27
+00:02:21,000 --> 00:02:26,000
+You can check Maven repository and add latest available version from there.
+
+28
+00:02:27,000 --> 00:02:35,000
+Also additional dependencies that I have added is Jackson data bind few words about this dependency.
+
+29
+00:02:36,000 --> 00:02:41,000
+I added it in order to convert objects into JSON.
+
+30
+00:02:41,000 --> 00:02:50,000
+If you remember, JSON is a JavaScript object notation, very popular string format for data, serialization
+
+31
+00:02:50,000 --> 00:02:53,000
+and passing objects as strings in the network.
+
+32
+00:02:54,000 --> 00:03:02,000
+In our today's example, I am going to build a rest service that is going to return US user objects
+
+33
+00:03:02,000 --> 00:03:03,000
+in the JSON format.
+
+34
+00:03:04,000 --> 00:03:07,000
+Don't worry, we are going to learn rest.
+
+35
+00:03:07,000 --> 00:03:09,000
+Topic in the separate lesson.
+
+36
+00:03:09,000 --> 00:03:17,000
+There is nothing super complex in it and conversion into JSON is optional for this lesson and it is
+
+37
+00:03:17,000 --> 00:03:19,000
+done just for demo purposes.
+
+38
+00:03:19,000 --> 00:03:26,000
+The next changes that I introduced in this example are changes in the web config file.
+
+39
+00:03:26,000 --> 00:03:27,000
+Our configuration.
+
+40
+00:03:28,000 --> 00:03:30,000
+Let me open web config class.
+
+41
+00:03:31,000 --> 00:03:33,000
+Let's start from the top here.
+
+42
+00:03:33,000 --> 00:03:36,000
+I added few important annotations.
+
+43
+00:03:36,000 --> 00:03:39,000
+They are enable transaction management.
+
+44
+00:03:39,000 --> 00:03:45,000
+This annotation allows users to use transaction management in application.
+
+45
+00:03:46,000 --> 00:03:51,000
+Enables springs annotation driven transaction management capability.
+
+46
+00:03:51,000 --> 00:03:54,000
+Enable repositories.
+
+47
+00:03:54,000 --> 00:04:01,000
+This annotation indicates where the repositories classes are present and you can see that I specified
+
+48
+00:04:01,000 --> 00:04:06,000
+full package name where my repositories will be stored.
+
+49
+00:04:06,000 --> 00:04:11,000
+For the sake of the demo, we are going to implement only one repository today.
+
+50
+00:04:12,000 --> 00:04:15,000
+Properties Source with a database properties.
+
+51
+00:04:15,000 --> 00:04:17,000
+Let's review this file.
+
+52
+00:04:17,000 --> 00:04:21,000
+It is located in the SRC main resources.
+
+53
+00:04:21,000 --> 00:04:28,000
+As you can see, there is a similar properties that we usually use for configuration of the data source
+
+54
+00:04:28,000 --> 00:04:37,000
+because in spring data JPA we also need to configure data, source, driver name, URL, user password,
+
+55
+00:04:37,000 --> 00:04:43,000
+dialect and also specified property to show SQL queries.
+
+56
+00:04:43,000 --> 00:04:47,000
+Later in the configuration we are going to use this properties.
+
+57
+00:04:47,000 --> 00:04:53,000
+It is just a rule of thumb to keep variable properties separately from the source code.
+
+58
+00:04:53,000 --> 00:04:56,000
+Let's get back to web.config file.
+
+59
+00:04:56,000 --> 00:05:03,000
+For the sake of the demo, I separated spring data JPA configuration with markers here.
+
+60
+00:05:03,000 --> 00:05:10,000
+Taking into account, we add new feature with each new lesson to our imaginary project.
+
+61
+00:05:10,000 --> 00:05:18,000
+You can find here source code from other examples, but I use such markers to separate configurations
+
+62
+00:05:18,000 --> 00:05:21,000
+for different features that will learn.
+
+63
+00:05:21,000 --> 00:05:25,000
+The redundant code from previous lessons is just commanded.
+
+64
+00:05:26,000 --> 00:05:31,000
+For example, if you remember we configured spring security in the previous learning module.
+
+65
+00:05:32,000 --> 00:05:39,000
+I just commented that section in order to not deal with the security configuration in this lesson.
+
+66
+00:05:39,000 --> 00:05:47,000
+I also commanded configuration of the spring security filter in our application initializer, but feel
+
+67
+00:05:47,000 --> 00:05:50,000
+free to uncomment it if you wish.
+
+68
+00:05:50,000 --> 00:05:54,000
+So here you can see constants.
+
+69
+00:05:54,000 --> 00:06:00,000
+These are properties names in order we could extract required properties values from the properties
+
+70
+00:06:00,000 --> 00:06:01,000
+file.
+
+71
+00:06:02,000 --> 00:06:06,000
+The first thing that we need to do is to configure data source.
+
+72
+00:06:06,000 --> 00:06:10,000
+Here you can see that I use driver manager data source.
+
+73
+00:06:10,000 --> 00:06:19,000
+I set URL username password driver class name using values from the properties file that we already
+
+74
+00:06:19,000 --> 00:06:20,000
+reviewed.
+
+75
+00:06:20,000 --> 00:06:29,000
+Data source beam is configured and also we already had lesson where we learned how to extract properties
+
+76
+00:06:29,000 --> 00:06:29,000
+in spring.
+
+77
+00:06:30,000 --> 00:06:37,000
+We inject environment type and call get property name Passing the property name.
+
+78
+00:06:37,000 --> 00:06:42,000
+Then we need to configure local container entity manager factory bean.
+
+79
+00:06:43,000 --> 00:06:48,000
+We need this been to control the entities in this been.
+
+80
+00:06:48,000 --> 00:06:56,000
+You must specify the persistence provider that is hibernate persistence provider in our case.
+
+81
+00:06:56,000 --> 00:07:05,000
+Also, as you can see, I set data source packages to scan and I pass package name where all my entities
+
+82
+00:07:05,000 --> 00:07:09,000
+are stored and I set GPA properties.
+
+83
+00:07:09,000 --> 00:07:10,000
+Let's review.
+
+84
+00:07:10,000 --> 00:07:11,000
+What are they?
+
+85
+00:07:12,000 --> 00:07:18,000
+There is a separate method and you can see that I extract properties from the database.
+
+86
+00:07:18,000 --> 00:07:20,000
+Properties file that we configure it.
+
+87
+00:07:21,000 --> 00:07:27,000
+And the last but not the least, being that we are going to configure in this file is transaction manager.
+
+88
+00:07:27,000 --> 00:07:31,000
+In our case it is GP transaction manager.
+
+89
+00:07:31,000 --> 00:07:38,000
+Note that without configuring transaction manager we can't use transactional annotation.
+
+90
+00:07:39,000 --> 00:07:42,000
+Now let's review entities.
+
+91
+00:07:42,000 --> 00:07:48,000
+We created our entities during the lesson from the spring Security module when we configured authentication
+
+92
+00:07:48,000 --> 00:07:54,000
+with the users extracted from the database based on the roles and privileges.
+
+93
+00:07:54,000 --> 00:07:57,000
+So let me just make a brief overview.
+
+94
+00:07:57,000 --> 00:08:02,000
+Basically, each user can have multiple roles assigned.
+
+95
+00:08:02,000 --> 00:08:05,000
+Each role can have multiple privileges.
+
+96
+00:08:05,000 --> 00:08:09,000
+To be honest, nothing is extraordinary here.
+
+97
+00:08:10,000 --> 00:08:13,000
+I use GP annotations to configure entities.
+
+98
+00:08:14,000 --> 00:08:21,000
+In case you want to learn more, feel free to check GP section in my course Java from zero to first
+
+99
+00:08:21,000 --> 00:08:22,000
+job.
+
+100
+00:08:22,000 --> 00:08:28,000
+Now we are ready to create our first repository in the Repositories package.
+
+101
+00:08:28,000 --> 00:08:35,000
+I created sub package for spring data and here is user repository that I created.
+
+102
+00:08:36,000 --> 00:08:39,000
+I extended from the craft repository.
+
+103
+00:08:39,000 --> 00:08:43,000
+I believe it is important for you to know what a crowd repository is.
+
+104
+00:08:43,000 --> 00:08:46,000
+Let me open its source code.
+
+105
+00:08:47,000 --> 00:08:54,000
+So this is an interface for generic CRUD operations on a repository for a specific type.
+
+106
+00:08:54,000 --> 00:08:57,000
+You can see that this is parameterized type.
+
+107
+00:08:58,000 --> 00:09:05,000
+The first type should be the type of the entity you want to work with, and the second type is a type
+
+108
+00:09:05,000 --> 00:09:05,000
+of ID.
+
+109
+00:09:06,000 --> 00:09:16,000
+By extending CRUD repository by default, you can use methods like save save all find by ID exists by
+
+110
+00:09:16,000 --> 00:09:20,000
+the and other methods that you can see on the screen.
+
+111
+00:09:21,000 --> 00:09:29,000
+Basically there are sufficient to execute standard, create, read, update, delete operations and
+
+112
+00:09:29,000 --> 00:09:36,000
+as we discussed in the previous lesson, in case we need some additional data operations, we can easily
+
+113
+00:09:36,000 --> 00:09:38,000
+define new methods in our repository.
+
+114
+00:09:39,000 --> 00:09:42,000
+Let's get back to define few other methods.
+
+115
+00:09:43,000 --> 00:09:50,000
+For example, let's define method that will return us a list of users with the same first name.
+
+116
+00:09:50,000 --> 00:10:00,000
+We use spring data JPA predefined pattern find by and field name first name and parameter.
+
+117
+00:10:00,000 --> 00:10:01,000
+First name.
+
+118
+00:10:01,000 --> 00:10:02,000
+That's it.
+
+119
+00:10:03,000 --> 00:10:05,000
+That's literally everything.
+
+120
+00:10:05,000 --> 00:10:11,000
+What we need to do to define the behavior of finding all users by the first name field.
+
+121
+00:10:12,000 --> 00:10:19,000
+But what are the prefixes I can use when I define method name in Spring data JPA Repository?
+
+122
+00:10:20,000 --> 00:10:23,000
+What is the pardon and naming convention?
+
+123
+00:10:23,000 --> 00:10:29,000
+That's a great question and there are really different options and combinations that you can use while
+
+124
+00:10:29,000 --> 00:10:31,000
+naming your methods.
+
+125
+00:10:31,000 --> 00:10:39,000
+Spring Data JPA developers have tried to take into account the majority of possible options that you
+
+126
+00:10:39,000 --> 00:10:40,000
+might need.
+
+127
+00:10:40,000 --> 00:10:48,000
+This is one of the most important feature of spring data JPA because it reduces a lot of boilerplate
+
+128
+00:10:48,000 --> 00:10:48,000
+code.
+
+129
+00:10:49,000 --> 00:10:56,000
+Also, the chances of errors are less because these spring methods are well tested by many projects
+
+130
+00:10:56,000 --> 00:10:58,000
+already using them.
+
+131
+00:10:59,000 --> 00:11:06,000
+I don't think that it would be useful me creating each of the possible variation because the main thing
+
+132
+00:11:06,000 --> 00:11:12,000
+is that you understand operations, how to create method and how to call it.
+
+133
+00:11:13,000 --> 00:11:20,000
+And now let me show you the slides with the list of words that you can use when naming method, and
+
+134
+00:11:20,000 --> 00:11:25,000
+I will elaborate a little bit more on naming convention in Spring Data JPA.
+
+135
+00:11:26,000 --> 00:11:32,000
+I gathered all the keywords that you can use when declaring new method in repository.
+
+136
+00:11:33,000 --> 00:11:40,000
+Also, each keyword has sample and shows how it will be transformed into the gql.
+
+137
+00:11:40,000 --> 00:11:48,000
+You can see here's example of and or is equals between less than and other keywords.
+
+138
+00:11:48,000 --> 00:11:53,000
+Please put the video on the post now and explore the slides.
+
+139
+00:11:53,000 --> 00:11:56,000
+As you can see, there are multiple of them.
+
+140
+00:11:57,000 --> 00:12:01,000
+Feel free to get back to these examples when it will be needed.
+
+141
+00:12:02,000 --> 00:12:08,000
+Once you finished review, press play and continue with the next examples.
+
+142
+00:12:08,000 --> 00:12:14,000
+In case we want a more control, we can specify customized query using gql.
+
+143
+00:12:14,000 --> 00:12:17,000
+Take a look at this example.
+
+144
+00:12:17,000 --> 00:12:25,000
+In case I want to retrieve users by the first name ignoring case, I can specify this query using lower
+
+145
+00:12:25,000 --> 00:12:31,000
+function right on top of the method that I'm going to use a little bit later.
+
+146
+00:12:31,000 --> 00:12:34,000
+I'm going to show you this method in action to.
+
+147
+00:12:35,000 --> 00:12:40,000
+Also, if we need, we can use native SQL queries.
+
+148
+00:12:40,000 --> 00:12:42,000
+The principle is the same.
+
+149
+00:12:42,000 --> 00:12:49,000
+We use query annotation above the method and we specify native equals to true.
+
+150
+00:12:50,000 --> 00:12:51,000
+Let's proceed now.
+
+151
+00:12:53,000 --> 00:12:57,000
+To continue with creation of our imaginary business case.
+
+152
+00:12:57,000 --> 00:13:04,000
+The next thing that we need to do is actually some service that is located in our business layer of
+
+153
+00:13:04,000 --> 00:13:08,000
+application that is going to use our repository.
+
+154
+00:13:08,000 --> 00:13:15,000
+For this, I created user service class and injected my user repository here.
+
+155
+00:13:15,000 --> 00:13:20,000
+In our particular case, we just delegate calls to the repository.
+
+156
+00:13:21,000 --> 00:13:25,000
+But theoretically, this is the place where you can implement your business.
+
+157
+00:13:25,000 --> 00:13:33,000
+Logic, for example, is a make multiple requests with a repository to get the data that you need or
+
+158
+00:13:33,000 --> 00:13:35,000
+to process the data received.
+
+159
+00:13:35,000 --> 00:13:40,000
+In another way, it is up to you and your business logic.
+
+160
+00:13:41,000 --> 00:13:47,000
+Transactional annotation indicates that the message will be executed in the transaction.
+
+161
+00:13:47,000 --> 00:13:54,000
+Spring will take care of the transaction management and now we need to create controller class in order
+
+162
+00:13:54,000 --> 00:13:58,000
+to interact with a business layer over the web.
+
+163
+00:13:58,000 --> 00:14:02,000
+In our today's example, I'm going to implement Rest controller.
+
+164
+00:14:02,000 --> 00:14:09,000
+Don't worry, we are going to cover rest, architecture, topic and topic of rest controllers in other
+
+165
+00:14:09,000 --> 00:14:10,000
+lessons.
+
+166
+00:14:10,000 --> 00:14:17,000
+But right now I'm going to make just short and brief overview to help you understand what is happening
+
+167
+00:14:17,000 --> 00:14:17,000
+here.
+
+168
+00:14:18,000 --> 00:14:22,000
+I used a rest controller annotation in simple words.
+
+169
+00:14:22,000 --> 00:14:29,000
+Rest controller annotation is a combination of controller and response body annotation.
+
+170
+00:14:29,000 --> 00:14:36,000
+You already know what a controller annotation is, and I believe I showed you a response body annotation
+
+171
+00:14:36,000 --> 00:14:37,000
+once.
+
+172
+00:14:37,000 --> 00:14:41,000
+But let me remind you was the response body annotation.
+
+173
+00:14:41,000 --> 00:14:49,000
+Our view resolver is not triggered and we write the value that is returned from the method in controller
+
+174
+00:14:49,000 --> 00:14:54,000
+directly into the response body of our response object.
+
+175
+00:14:54,000 --> 00:14:56,000
+Why we need this?
+
+176
+00:14:56,000 --> 00:15:05,000
+Very often we implement applications that talk not directly to the end user, but talk with other applications
+
+177
+00:15:05,000 --> 00:15:07,000
+and just passing data.
+
+178
+00:15:07,000 --> 00:15:15,000
+In this case, there is no need to implement view layer and present data on the nice looking web pages,
+
+179
+00:15:15,000 --> 00:15:23,000
+or you can use other framework on the front end and you just need to supply data to its components.
+
+180
+00:15:23,000 --> 00:15:31,000
+That's why we don't need to resolve separate view and we can just put the data into the response body.
+
+181
+00:15:31,000 --> 00:15:37,000
+Anyway, the cases can be different and we are going to review them in other lessons too.
+
+182
+00:15:37,000 --> 00:15:45,000
+In our today's lesson, I just didn't want to resolve views because we need just to make sure that our
+
+183
+00:15:45,000 --> 00:15:51,000
+spring data JPA works well and to seize data that is actually returned.
+
+184
+00:15:51,000 --> 00:15:59,000
+And this is exactly why we added Jackson dependency for data serialization from Java objects into JSON
+
+185
+00:15:59,000 --> 00:16:00,000
+and vice versa.
+
+186
+00:16:01,000 --> 00:16:08,000
+When I return some object and we tell Spring to write it into the response body how spring should handle
+
+187
+00:16:08,000 --> 00:16:16,000
+this because we can't put Java object into the response body, but we can put string into the response
+
+188
+00:16:16,000 --> 00:16:17,000
+body.
+
+189
+00:16:17,000 --> 00:16:25,000
+So spring uses Jackson in order to serialize Java, object into the JSON and return it to the client.
+
+190
+00:16:25,000 --> 00:16:26,000
+Is it clear?
+
+191
+00:16:27,000 --> 00:16:34,000
+So I use rest controller annotation and here a lot of different methods to interact with our business
+
+192
+00:16:34,000 --> 00:16:35,000
+layer.
+
+193
+00:16:35,000 --> 00:16:41,000
+Our goal for today's demo is to them a message from our user repository.
+
+194
+00:16:42,000 --> 00:16:46,000
+Let's review today how we work such methods.
+
+195
+00:16:46,000 --> 00:16:47,000
+Get user by ID.
+
+196
+00:16:48,000 --> 00:16:56,000
+We'll just pass ID of one saved user and we expect to get back json of user.
+
+197
+00:16:57,000 --> 00:16:59,000
+Net users by first name.
+
+198
+00:16:59,000 --> 00:17:03,000
+Will pass first name and we expect two users to be returned.
+
+199
+00:17:04,000 --> 00:17:07,000
+Get user by first name case insensitive.
+
+200
+00:17:08,000 --> 00:17:15,000
+The goal of this endpoint invocation is to prove that GPU queries work as expected.
+
+201
+00:17:16,000 --> 00:17:24,000
+If you remember, for such behavior, we declared GPU query get users ordered by first name.
+
+202
+00:17:24,000 --> 00:17:30,000
+We will check this endpoint too in order to prove that native queries work as expected.
+
+203
+00:17:30,000 --> 00:17:30,000
+To.
+
+204
+00:17:31,000 --> 00:17:39,000
+The rest of the masses can be checked via a special client like Postman because we need to send requests
+
+205
+00:17:39,000 --> 00:17:48,000
+via post, delete, put HTTP methods, but don't pay too much attention to those methods so far.
+
+206
+00:17:48,000 --> 00:17:52,000
+We are going to learn how they work in separate lesson.
+
+207
+00:17:53,000 --> 00:17:57,000
+So I started Web server and deployed our application.
+
+208
+00:17:57,000 --> 00:18:03,000
+Now it is time to send some queries to the web server and see what will be returned.
+
+209
+00:18:03,000 --> 00:18:10,000
+We are going to start from extracting user by ID user slash seven.
+
+210
+00:18:11,000 --> 00:18:15,000
+Seven is an ID of one of our users from the database.
+
+211
+00:18:15,000 --> 00:18:21,000
+I just checked beforehand in the database and made requests.
+
+212
+00:18:21,000 --> 00:18:25,000
+So we can see that JSON is returned.
+
+213
+00:18:25,000 --> 00:18:34,000
+If you wish, you can use any JSON file that is available online to see how our Java object is transformed
+
+214
+00:18:34,000 --> 00:18:36,000
+into the JSON string.
+
+215
+00:18:36,000 --> 00:18:40,000
+By the way, this is a good way to learn JSON structure.
+
+216
+00:18:41,000 --> 00:18:42,000
+This is pretty intuitive.
+
+217
+00:18:43,000 --> 00:18:51,000
+You can see the name of the fields and field values ID first name, last name, email, password, etcetera.
+
+218
+00:18:51,000 --> 00:18:57,000
+There is an array of roles and each role may have array of privileges.
+
+219
+00:18:57,000 --> 00:19:05,000
+Anyway, we can see that our repository returned us the data that we expected because this user has
+
+220
+00:19:05,000 --> 00:19:06,000
+ID seven.
+
+221
+00:19:07,000 --> 00:19:09,000
+Let's check another endpoint.
+
+222
+00:19:10,000 --> 00:19:13,000
+Users by first name slash admin.
+
+223
+00:19:14,000 --> 00:19:19,000
+The next endpoint that we are going to check is getting users by first name.
+
+224
+00:19:19,000 --> 00:19:27,000
+I use admin as a first name parameter and when I send request I receive two users in return because
+
+225
+00:19:27,000 --> 00:19:31,000
+in my database there are two users with admin first name.
+
+226
+00:19:32,000 --> 00:19:35,000
+Everything is simple and predictable.
+
+227
+00:19:35,000 --> 00:19:41,000
+We implemented SQL query that returns US users ignoring case.
+
+228
+00:19:41,000 --> 00:19:43,000
+Let's try that endpoint.
+
+229
+00:19:44,000 --> 00:19:52,000
+Users by first name case insensitive slash admin starting from the lower case.
+
+230
+00:19:53,000 --> 00:20:01,000
+And when I use case insensitive and point, I again see our two users with admin first name because
+
+231
+00:20:01,000 --> 00:20:05,000
+in the SQL query we used lower function.
+
+232
+00:20:05,000 --> 00:20:14,000
+Let's now check the last endpoint in our today's demo to make sure that native queries also work users
+
+233
+00:20:14,000 --> 00:20:15,000
+ordered by first name.
+
+234
+00:20:16,000 --> 00:20:19,000
+And you can see we have three users returned.
+
+235
+00:20:19,000 --> 00:20:27,000
+The first two users with the first name admin and the third one is with test first name.
+
+236
+00:20:27,000 --> 00:20:35,000
+That proves that ordering by first name works as expected, and that means that we can apply other native
+
+237
+00:20:35,000 --> 00:20:36,000
+SQL queries.
+
+238
+00:20:37,000 --> 00:20:37,000
+Super.
+
+239
+00:20:38,000 --> 00:20:41,000
+That's all what I wanted to share with you in this lesson.
+
+240
+00:20:41,000 --> 00:20:45,000
+Let's recap what we have learned in the video.
+
+241
+00:20:46,000 --> 00:20:49,000
+In this video, we configure it Spring Data JPA.
+
+242
+00:20:49,000 --> 00:20:52,000
+We created our GPA repository.
+
+243
+00:20:53,000 --> 00:20:58,000
+I explained how we can work with a SQL queries in our GPA repositories.
+
+244
+00:20:59,000 --> 00:21:04,000
+I showed how we can declare native SQL queries in our GPA repositories.
+
+245
+00:21:04,000 --> 00:21:13,000
+We discussed naming convention and learned how to name methods in the GPA repository and also we reviewed
+
+246
+00:21:13,000 --> 00:21:19,000
+live demo with a spring data JPA to understand how it works and to end.
+
+247
+00:21:20,000 --> 00:21:21,000
+That's all for this lesson.
+
+248
+00:21:21,000 --> 00:21:23,000
+Thanks a lot for your attention.
+
+249
+00:21:23,000 --> 00:21:27,000
+Have a great day and see you in the next lesson.
+

86 - Spring Data/external-links.txt

@@ -0,0 +1,3 @@
+
+002 Source-code-of-examples-commit-with-changes-
+https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/e9e37fb6749af4c7ec493a54acea7cadbbafd612

87 - ===== EXAM Spring Data JPA - Online Shop =====/001 EXAM Spring Data JPA - Online Shop.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>EXAM Spring Data JPA - Online Shop</title>
+
+        <style>
+            * {
+                box-sizing: border-box;
+                margin: 0;
+                padding: 0;
+            }
+            body {
+                font-family: var(--font-stack-text);
+                font-weight: 400;
+                line-height: 1.4;
+                font-size: 1.6rem;
+                color: #2d2f31;
+            }
+            .container {
+                position: relative;
+                height: 100%;
+                overflow-y: auto;
+            }
+            .content {
+                padding: 3.2rem 4.8rem;
+                word-break: break-word;
+                max-width: 69.6rem;
+                margin: 0 auto;
+            }
+            .heading {
+                margin-bottom: 24px;
+                font-family: -apple-system, BlinkMacSystemFont, Roboto, "Segoe UI", Helvetica, Arial, sans-serif,
+                    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+                font-weight: 700;
+                line-height: 1.2;
+                letter-spacing: 0;
+                font-size: 32px;
+                max-width: 36em;
+            }
+            .article-asset-container {
+                padding: 2.4rem;
+            }
+            .article-asset-container p {
+                font-size: 19px;
+            }
+            code {
+                background-color: #fff;
+                border: 1px solid #d1d7dc;
+                color: #b4690e;
+                font-size: 80%;
+                padding: 0.2rem 0.4rem;
+                font-family: sfmono-regular, Consolas, liberation mono, Menlo, Courier, monospace;
+            }
+            p {
+                font-weight: 400;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="content">
+                <div class="heading">EXAM Spring Data JPA - Online Shop</div>
+                <div class="article-asset-container"><p>During the exam task you are going to take template of the multimodule project - online shop, and integrate Spring Data JPA into the persistence module of the application.</p><h4>Attachments:</h4><p>Exam Task - <a href="https://docs.google.com/document/d/16Gx8rIHynGErVA5iSfmV7xLJ7VHKmWwKsCKbDIu3g6A/edit?usp=sharing" rel="noopener noreferrer" target="_blank">https://docs.google.com/document/d/16Gx8rIHynGErVA5iSfmV7xLJ7VHKmWwKsCKbDIu3g6A/edit?usp=sharing</a></p></div>
+            </div>
+        </div>
+    </body>
+</html>

88 - Spring JDBC/001 Spring JDBC Overview_en.srt

@@ -0,0 +1,624 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, team.
+
+2
+00:00:06,000 --> 00:00:13,000
+Today we continue learning spring and in this lesson we are going to talk about spring JDBC.
+
+3
+00:00:14,000 --> 00:00:20,000
+We are going to start our lesson from remembering what JDBC is in general.
+
+4
+00:00:20,000 --> 00:00:26,000
+I'm bad that if you watch spring module of my course, you already know what JDBC is.
+
+5
+00:00:26,000 --> 00:00:32,000
+But we will just briefly remember after that we'll talk about why we should use spring JDBC.
+
+6
+00:00:33,000 --> 00:00:38,000
+What problems of JDBC API are solved with the spring JDBC.
+
+7
+00:00:39,000 --> 00:00:40,000
+I will explain.
+
+8
+00:00:40,000 --> 00:00:45,000
+What is the difference between spring JDBC and spring data JDBC.
+
+9
+00:00:46,000 --> 00:00:49,000
+Then we'll review different spring JDBC classes.
+
+10
+00:00:49,000 --> 00:00:59,000
+Namely we are going to learn JDBC template named parameter jdbc template simple jdbc insert simple JDBC
+
+11
+00:00:59,000 --> 00:01:00,000
+call.
+
+12
+00:01:00,000 --> 00:01:01,000
+Let's start our lesson.
+
+13
+00:01:02,000 --> 00:01:05,000
+Let's start from overview of JDBC.
+
+14
+00:01:05,000 --> 00:01:11,000
+I believe that if you watch this course then you already have understanding of what JDBC is.
+
+15
+00:01:11,000 --> 00:01:17,000
+But for the sake of this lesson, let me just briefly remind you what the JDBC is.
+
+16
+00:01:17,000 --> 00:01:21,000
+JDBC stands for Java Database Connectivity.
+
+17
+00:01:21,000 --> 00:01:27,000
+JDBC is a Java API to connect and execute the query with the database.
+
+18
+00:01:27,000 --> 00:01:30,000
+It is a part of Java Standard Edition.
+
+19
+00:01:30,000 --> 00:01:36,000
+JDBC API uses JDBC drivers to connect with the database.
+
+20
+00:01:36,000 --> 00:01:42,000
+We can use JDBC API to access data stored in any relational database.
+
+21
+00:01:42,000 --> 00:01:49,000
+With the help of JDBC API, we can save, update, delete and fetch data from the database.
+
+22
+00:01:50,000 --> 00:01:53,000
+If you want to learn more about Java JDBC.
+
+23
+00:01:53,000 --> 00:02:00,000
+Just to remind you that in my course Java from zero to first job I have separate section about JDBC.
+
+24
+00:02:00,000 --> 00:02:08,000
+So why we can't just use plane JDBC and why we should use spring JDBC instead?
+
+25
+00:02:08,000 --> 00:02:10,000
+What are benefits?
+
+26
+00:02:10,000 --> 00:02:12,000
+Let's try to figure it out.
+
+27
+00:02:13,000 --> 00:02:20,000
+First of all, I would like to highlight that spring JDBC is a powerful mechanism to connect to the
+
+28
+00:02:20,000 --> 00:02:23,000
+database and execute SQL queries.
+
+29
+00:02:23,000 --> 00:02:31,000
+As you may already guess, it uses JDBC API under the hood and it helps us to deal with different problems
+
+30
+00:02:31,000 --> 00:02:32,000
+of JDBC API.
+
+31
+00:02:33,000 --> 00:02:36,000
+What kind of problems?
+
+32
+00:02:36,000 --> 00:02:44,000
+When we use JDBC, we need to write a lot of code before and after executing the query, such as creating
+
+33
+00:02:44,000 --> 00:02:48,000
+connection statement, closing the result, set connection, etcetera.
+
+34
+00:02:48,000 --> 00:02:55,000
+Even despite we can use try with resources block still, we need to remember about it and implement
+
+35
+00:02:55,000 --> 00:02:57,000
+it carefully.
+
+36
+00:02:57,000 --> 00:03:02,000
+We need to perform exception handling code on the database logic.
+
+37
+00:03:02,000 --> 00:03:04,000
+We need to handle transactions.
+
+38
+00:03:04,000 --> 00:03:11,000
+You remember that with the JDBC, we can manage transactions by manually committing transactions when
+
+39
+00:03:11,000 --> 00:03:12,000
+needed.
+
+40
+00:03:12,000 --> 00:03:17,000
+Repetition of all this code in different methods is a time consuming task.
+
+41
+00:03:18,000 --> 00:03:24,000
+If you follow my course and don't skip lessons, then you should know already that there is spring data
+
+42
+00:03:24,000 --> 00:03:26,000
+JDBC sub project.
+
+43
+00:03:26,000 --> 00:03:29,000
+So is it the same as spring JDBC?
+
+44
+00:03:30,000 --> 00:03:32,000
+No, it is not the same.
+
+45
+00:03:32,000 --> 00:03:37,000
+And if it is different then what is the difference?
+
+46
+00:03:37,000 --> 00:03:45,000
+Spring JDBC project just provides all of the spring abstractions over the plain JDBC data source that
+
+47
+00:03:45,000 --> 00:03:47,000
+you can use with the spring framework.
+
+48
+00:03:47,000 --> 00:03:55,000
+For example, Spring's data source, which nicely hook into spring's transaction management capabilities
+
+49
+00:03:55,000 --> 00:03:57,000
+like transactional annotation.
+
+50
+00:03:57,000 --> 00:04:05,000
+Also, the JDBC template is part of this module which allows you to execute SQL statements and extract
+
+51
+00:04:05,000 --> 00:04:13,000
+objects from the result sets without dealing with exception handling or details of properly closing
+
+52
+00:04:13,000 --> 00:04:17,000
+statements, connections and things like that.
+
+53
+00:04:17,000 --> 00:04:25,000
+Spring data JDBC, on the other hand, provides the spring data abstraction over spring JDBC.
+
+54
+00:04:25,000 --> 00:04:35,000
+That is, you can create a spring data crud repository and simple entity, not a GPA entity and a spring
+
+55
+00:04:35,000 --> 00:04:36,000
+data does.
+
+56
+00:04:36,000 --> 00:04:43,000
+It will create your queries for you without you having to write native CRUD queries over JDBC.
+
+57
+00:04:44,000 --> 00:04:51,000
+Basically, this is the key difference between spring JDBC project and spring data.
+
+58
+00:04:51,000 --> 00:04:55,000
+JDBC sub project of Spring data project.
+
+59
+00:04:55,000 --> 00:04:57,000
+Hope you are not confused now.
+
+60
+00:04:58,000 --> 00:05:04,000
+Let's get back to the spring JDBC and discuss the main classes in the spring JDBC.
+
+61
+00:05:05,000 --> 00:05:08,000
+There are different ways how you can work with the spring JDBC.
+
+62
+00:05:09,000 --> 00:05:19,000
+I can name four main approaches with JDBC template named parameter jdbc template simple JDBC insert
+
+63
+00:05:19,000 --> 00:05:21,000
+and simple JDBC call.
+
+64
+00:05:22,000 --> 00:05:27,000
+So basically you can use these classes to interact with the JDBC API.
+
+65
+00:05:27,000 --> 00:05:31,000
+During the practical examples, we are going to review how to work with them.
+
+66
+00:05:31,000 --> 00:05:37,000
+JDBC template is a classic spring JDBC approach and the most popular.
+
+67
+00:05:37,000 --> 00:05:43,000
+This is lowest level approach and all others use a JDBC template under the hood.
+
+68
+00:05:44,000 --> 00:05:50,000
+Pay attention to the part where I said that all others use a JDBC template.
+
+69
+00:05:50,000 --> 00:05:51,000
+Under the hood.
+
+70
+00:05:51,000 --> 00:05:59,000
+Let's make brief overview of different approaches and we will try to understand what are the differences
+
+71
+00:05:59,000 --> 00:06:02,000
+between them and when to use what.
+
+72
+00:06:03,000 --> 00:06:11,000
+And we are going to start from review of the JDBC template class taking into account it is used under
+
+73
+00:06:11,000 --> 00:06:11,000
+the hood.
+
+74
+00:06:11,000 --> 00:06:21,000
+Even in other classes, you can understand that it takes a central place among spring JDBC support classes.
+
+75
+00:06:21,000 --> 00:06:29,000
+It takes care of creation and release of resources such as creating and closing of connection, object,
+
+76
+00:06:29,000 --> 00:06:29,000
+etcetera.
+
+77
+00:06:29,000 --> 00:06:33,000
+So it will not lead to any problem.
+
+78
+00:06:33,000 --> 00:06:41,000
+If you forget to close the connection, it handles the exception and provides the informative exception
+
+79
+00:06:41,000 --> 00:06:48,000
+messages with the help of exception classes defined in the work Spring Framework DAO package.
+
+80
+00:06:49,000 --> 00:06:57,000
+We can perform all the database operations with the help of JDBC template class such as insertion,
+
+81
+00:06:57,000 --> 00:07:06,000
+update, deletion and retrieval of the data from the database instances of the template class are thread
+
+82
+00:07:06,000 --> 00:07:15,000
+safe once configured so you can configure a single instance of a JDBC template and then safely inject
+
+83
+00:07:15,000 --> 00:07:18,000
+this shared reference into multiple Daos.
+
+84
+00:07:19,000 --> 00:07:26,000
+A common practice when using the JDBC template class is to configure a data source in your spring configuration
+
+85
+00:07:26,000 --> 00:07:28,000
+file and then dependency.
+
+86
+00:07:28,000 --> 00:07:32,000
+Inject that shared data source bean into your DAO classes.
+
+87
+00:07:33,000 --> 00:07:42,000
+Now let's review named parameter JDBC template and to understand it better, let's compare it with JDBC
+
+88
+00:07:42,000 --> 00:07:42,000
+template.
+
+89
+00:07:42,000 --> 00:07:50,000
+When you use JDBC template, you give it SQL that has a question mark placeholder for each parameter
+
+90
+00:07:50,000 --> 00:07:52,000
+you want to substitute in the SQL.
+
+91
+00:07:53,000 --> 00:08:01,000
+When you assign parameters in the code, you have to pass input arguments in an array and they are used
+
+92
+00:08:01,000 --> 00:08:07,000
+in the order in which they appear in the array like you can see on the slide.
+
+93
+00:08:08,000 --> 00:08:11,000
+You can see I created an array of arguments.
+
+94
+00:08:12,000 --> 00:08:22,000
+I created SQL query with question marks, and then I pass SQL query array of arguments and result set
+
+95
+00:08:22,000 --> 00:08:23,000
+extractor.
+
+96
+00:08:24,000 --> 00:08:26,000
+I'm going to explain you what it is.
+
+97
+00:08:26,000 --> 00:08:30,000
+Later during the practical coding exercise.
+
+98
+00:08:31,000 --> 00:08:39,000
+Named parameter JDBC template allows you to assign names to the parameter placeholders and pass in a
+
+99
+00:08:39,000 --> 00:08:44,000
+map so the template can match the map names to the placeholders.
+
+100
+00:08:44,000 --> 00:08:54,000
+So your code would look like other example on the slide we create again SQL query pay attention that
+
+101
+00:08:54,000 --> 00:08:59,000
+we use named parameter my A and my B.
+
+102
+00:08:59,000 --> 00:09:10,000
+After that I create map object and I put in the map keys and values and after that I call query method
+
+103
+00:09:10,000 --> 00:09:14,000
+and pass SQL arguments and result set extractor.
+
+104
+00:09:14,000 --> 00:09:23,000
+The idea is that matching the arguments by name is less error prone than having to specify them in a
+
+105
+00:09:23,000 --> 00:09:24,000
+particular order.
+
+106
+00:09:25,000 --> 00:09:33,000
+In real life applications, you store SQL queries in the separate files and it may be easy to accidentally
+
+107
+00:09:33,000 --> 00:09:36,000
+put the parameters in the wrong order.
+
+108
+00:09:37,000 --> 00:09:39,000
+Few words about simple jdbc.
+
+109
+00:09:39,000 --> 00:09:40,000
+Insert.
+
+110
+00:09:41,000 --> 00:09:42,000
+Simple JDBC.
+
+111
+00:09:42,000 --> 00:09:48,000
+Insert optimized database metadata to limit the amount of necessary configuration.
+
+112
+00:09:48,000 --> 00:09:56,000
+This approach simplifies coding so that you only need to provide the name of the table or procedure
+
+113
+00:09:56,000 --> 00:10:02,000
+and provide a map of parameters matching the column names to help you understand it better.
+
+114
+00:10:02,000 --> 00:10:05,000
+Let's look on the example on the slide.
+
+115
+00:10:06,000 --> 00:10:12,000
+If you need to make an insert with the JDBC template, you would have something like you can see on
+
+116
+00:10:12,000 --> 00:10:13,000
+the slide.
+
+117
+00:10:14,000 --> 00:10:17,000
+You would create JDBC template object.
+
+118
+00:10:17,000 --> 00:10:19,000
+SQL insert statement.
+
+119
+00:10:19,000 --> 00:10:25,000
+And after that you would call update method on JDBC template passing parameters.
+
+120
+00:10:25,000 --> 00:10:33,000
+In case we use simple JDBC insert clause, our code will look like on the example on the slide.
+
+121
+00:10:33,000 --> 00:10:38,000
+As you can see, I create instance of simple jdbc insert type.
+
+122
+00:10:38,000 --> 00:10:40,000
+I specify concrete table.
+
+123
+00:10:40,000 --> 00:10:46,000
+After that I create object of map type and they put values into it.
+
+124
+00:10:46,000 --> 00:10:51,000
+The keys are column names in the table that we specified.
+
+125
+00:10:51,000 --> 00:10:56,000
+The returned value is the number of rows affected by the query.
+
+126
+00:10:56,000 --> 00:11:04,000
+As you can see with a simple JDBC insert, you don't have to write SQL, insert statement and using
+
+127
+00:11:04,000 --> 00:11:05,000
+named parameters.
+
+128
+00:11:05,000 --> 00:11:09,000
+Same as the column names make the code more readable.
+
+129
+00:11:10,000 --> 00:11:13,000
+Let's now talk about simple JDBC call.
+
+130
+00:11:14,000 --> 00:11:20,000
+In simple words, this is a tool provided by spring JDBC to invoke stored procedures.
+
+131
+00:11:21,000 --> 00:11:26,000
+If you don't remember what stored procedures are, please refer to my course Java from zero to first
+
+132
+00:11:26,000 --> 00:11:27,000
+job.
+
+133
+00:11:27,000 --> 00:11:33,000
+There is a section about SQL where I have separate lesson about stored procedures.
+
+134
+00:11:34,000 --> 00:11:42,000
+A simple JDBC call is a multi-threaded reusable object representing a call to a stored procedure or
+
+135
+00:11:42,000 --> 00:11:43,000
+a stored function.
+
+136
+00:11:43,000 --> 00:11:51,000
+It provides metadata processing to simplify the code needed to access basic stored procedures functions.
+
+137
+00:11:51,000 --> 00:11:58,000
+All you need to provide is the name of the procedure or function and the map containing the parameters
+
+138
+00:11:58,000 --> 00:12:00,000
+when you execute the call.
+
+139
+00:12:01,000 --> 00:12:08,000
+The names of the supplied parameters will be matched up within and out parameters declared when the
+
+140
+00:12:08,000 --> 00:12:10,000
+stored procedure was created.
+
+141
+00:12:11,000 --> 00:12:13,000
+Let's look at the example on the slide.
+
+142
+00:12:13,000 --> 00:12:16,000
+Create object of simple JDBC call.
+
+143
+00:12:17,000 --> 00:12:22,000
+Then I can specify in parameters if required by the procedure.
+
+144
+00:12:23,000 --> 00:12:31,000
+Then we can execute the procedure and get the values of the out parameters into map and then we can
+
+145
+00:12:31,000 --> 00:12:34,000
+read out the values returned from the procedure.
+
+146
+00:12:35,000 --> 00:12:43,000
+Note the names of in and out parameters must match the names declared by the stored procedure of function.
+
+147
+00:12:44,000 --> 00:12:48,000
+Basically, that's all what I wanted to share with you in this video.
+
+148
+00:12:48,000 --> 00:12:55,000
+In the next lesson, we are going to have practical examples and full lesson of coding exercises.
+
+149
+00:12:55,000 --> 00:12:59,000
+And right now, let's recap what we have learned in the video.
+
+150
+00:13:00,000 --> 00:13:03,000
+Today we learned what a spring JDBC is.
+
+151
+00:13:03,000 --> 00:13:10,000
+I explained what problems of JDBC API can be easily solved with a spring JDBC.
+
+152
+00:13:11,000 --> 00:13:19,000
+After this lesson, we understand the difference between spring JDBC and spring data JDBC projects.
+
+153
+00:13:19,000 --> 00:13:28,000
+We learned different classes from spring JDBC, namely JDBC template named parameter JDBC template simple
+
+154
+00:13:28,000 --> 00:13:32,000
+JDBC insert simple JDBC call.
+
+155
+00:13:33,000 --> 00:13:34,000
+Thanks a lot for your attention.
+
+156
+00:13:34,000 --> 00:13:37,000
+Have a great day and see you in the next lesson.
+

88 - Spring JDBC/002 Source-code-of-examples-commit-with-changes-.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/914fe50d4a0da192c913cd2d91560f3a03d60fa1

88 - Spring JDBC/002 Spring JDBC Practice_en.srt

@@ -0,0 +1,1396 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello team.
+
+2
+00:00:06,000 --> 00:00:09,000
+Today we are going to have a lesson full of practical examples.
+
+3
+00:00:09,000 --> 00:00:13,000
+And today we continue learning Spring JDBC.
+
+4
+00:00:14,000 --> 00:00:20,000
+We're going to start this lesson from the overview of the main packages in the Spring JDBC Library.
+
+5
+00:00:20,000 --> 00:00:28,000
+This is supposed to help you to navigate in the documentation and understand how classes are grouped
+
+6
+00:00:28,000 --> 00:00:29,000
+in the library.
+
+7
+00:00:30,000 --> 00:00:33,000
+After that, we will jump to practical code examples.
+
+8
+00:00:33,000 --> 00:00:37,000
+We'll configure the dependencies needed in our PWM XML.
+
+9
+00:00:37,000 --> 00:00:44,000
+For all practical examples, we are going to configure all required beans and then I'm going to show
+
+10
+00:00:44,000 --> 00:00:48,000
+you in action how to work with key classes from Spring JDBC.
+
+11
+00:00:49,000 --> 00:00:56,000
+Namely, we are going to have examples with JDBC template named parameter JDBC template simple jdbc
+
+12
+00:00:56,000 --> 00:00:59,000
+insert simple JDBC call.
+
+13
+00:01:00,000 --> 00:01:07,000
+I'm going to show you how to do batch updates and what parameter source utils class is.
+
+14
+00:01:07,000 --> 00:01:15,000
+Also, during the lesson, I'm going to explain you what row mapper is, how and when to use it.
+
+15
+00:01:15,000 --> 00:01:17,000
+Let's start our lesson.
+
+16
+00:01:18,000 --> 00:01:21,000
+And as I said before, we jump to practical code examples.
+
+17
+00:01:21,000 --> 00:01:28,000
+Let me just make a brief overview of packages in Spring JDBC library in order you could understand the
+
+18
+00:01:28,000 --> 00:01:35,000
+logic of grouping classes and in order to help you to navigate in the documentation in case you would
+
+19
+00:01:35,000 --> 00:01:37,000
+like to find something.
+
+20
+00:01:37,000 --> 00:01:43,000
+So all classes in spring JDBC are grouped into four separate packages.
+
+21
+00:01:43,000 --> 00:01:50,000
+They are core in this package located the core functionality of JDBC.
+
+22
+00:01:50,000 --> 00:01:55,000
+There are a few sub packages like metadata named Param.
+
+23
+00:01:55,000 --> 00:01:57,000
+Simple support.
+
+24
+00:01:58,000 --> 00:02:06,000
+Some of the important classes under this package include JDBC template simple JDBC insert simple JDBC
+
+25
+00:02:06,000 --> 00:02:10,000
+call and named parameter JDBC template.
+
+26
+00:02:10,000 --> 00:02:16,000
+In the previous lesson we made a review of these classes, so make sure you watch the previous lesson
+
+27
+00:02:17,000 --> 00:02:18,000
+config.
+
+28
+00:02:18,000 --> 00:02:23,000
+This package defines the spring JDBC configuration namespace.
+
+29
+00:02:23,000 --> 00:02:32,000
+It contains such classes as JDBC namespace handler and sorted resources Factory Bin data source.
+
+30
+00:02:32,000 --> 00:02:37,000
+In this package, you can find utility classes to access a data source.
+
+31
+00:02:37,000 --> 00:02:44,000
+It also has various data source implementation for testing JDBC code outside of the Jakarta Enterprise
+
+32
+00:02:44,000 --> 00:02:46,000
+Edition container.
+
+33
+00:02:47,000 --> 00:02:47,000
+Object.
+
+34
+00:02:48,000 --> 00:02:53,000
+The classes in this package represent relational database management system queries.
+
+35
+00:02:53,000 --> 00:02:58,000
+Updates and stored procedures as thread safe reusable objects.
+
+36
+00:02:58,000 --> 00:03:03,000
+It is also about database access in an object oriented manner.
+
+37
+00:03:03,000 --> 00:03:07,000
+It allows running queries and returns the results as a business object.
+
+38
+00:03:07,000 --> 00:03:13,000
+It also maps the query results between the columns and properties of business objects.
+
+39
+00:03:14,000 --> 00:03:15,000
+Support.
+
+40
+00:03:15,000 --> 00:03:22,000
+This package contains support classes for classes on the core and object packages.
+
+41
+00:03:22,000 --> 00:03:27,000
+For example, it provides a SQL exception translation functionality.
+
+42
+00:03:27,000 --> 00:03:28,000
+That's it.
+
+43
+00:03:29,000 --> 00:03:35,000
+As I promised you at the beginning of the lesson today, we are going to have a lot of practical examples.
+
+44
+00:03:35,000 --> 00:03:40,000
+So let me start with the screen sharing and jump to the coding exercises.
+
+45
+00:03:40,000 --> 00:03:44,000
+All source code examples you can find in attachments to the video.
+
+46
+00:03:45,000 --> 00:03:48,000
+Just use the link attached to the video.
+
+47
+00:03:48,000 --> 00:03:54,000
+You can clone repository if you wish and try the source code on your computer.
+
+48
+00:03:55,000 --> 00:04:00,000
+We're going to start with adding dependency into our pom.xml.
+
+49
+00:04:00,000 --> 00:04:04,000
+We just need to add spring JDBC dependency and that's it.
+
+50
+00:04:04,000 --> 00:04:09,000
+In my case I use the same version as for other spring dependencies.
+
+51
+00:04:09,000 --> 00:04:15,000
+You are welcome to check Maven repository and to select the version that you need.
+
+52
+00:04:16,000 --> 00:04:22,000
+Also, if you follow the course attentively, then you remember that in previous lessons we added all
+
+53
+00:04:22,000 --> 00:04:25,000
+the Jackson data bind dependency.
+
+54
+00:04:25,000 --> 00:04:30,000
+It is needed in order to convert objects into the JSON and vice versa.
+
+55
+00:04:30,000 --> 00:04:36,000
+Spring internally is going to use this dependency when we will use response body.
+
+56
+00:04:36,000 --> 00:04:37,000
+Let's move on.
+
+57
+00:04:38,000 --> 00:04:41,000
+Now let's configure all necessary bins.
+
+58
+00:04:42,000 --> 00:04:44,000
+I open Web.config class.
+
+59
+00:04:44,000 --> 00:04:48,000
+We need to make sure that our data source bin is configured.
+
+60
+00:04:48,000 --> 00:04:54,000
+We configure it it already in our previous lessons when we learned spring data JPA.
+
+61
+00:04:54,000 --> 00:04:55,000
+Here it is.
+
+62
+00:04:56,000 --> 00:05:01,000
+Also, pay attention that it takes values from the property resource.
+
+63
+00:05:01,000 --> 00:05:07,000
+Just to remind you that here on top we also declared property source with the database properties.
+
+64
+00:05:07,000 --> 00:05:12,000
+Database Properties file is located in our resources folder.
+
+65
+00:05:12,000 --> 00:05:19,000
+I'm going to use the same properties because nothing is changed in our database configurations.
+
+66
+00:05:19,000 --> 00:05:24,000
+I mean JDBC driver username and password.
+
+67
+00:05:24,000 --> 00:05:30,000
+Also, there is an interesting question about whether you need to create multiple JDBC template instances
+
+68
+00:05:30,000 --> 00:05:37,000
+or no, or just to create one instance and inject it in each DAO implementation.
+
+69
+00:05:38,000 --> 00:05:43,000
+Let's answer this question based on the example of the JDBC template.
+
+70
+00:05:43,000 --> 00:05:51,000
+JDBC template is thread safe, lock free, meaning it should not cause performance degradation when
+
+71
+00:05:51,000 --> 00:05:53,000
+shared between concurrent threads.
+
+72
+00:05:53,000 --> 00:06:00,000
+Thus, there are no compelling reasons for more than one instance per data source.
+
+73
+00:06:00,000 --> 00:06:05,000
+There is no problem to inject JDBC template to your multiple DAO.
+
+74
+00:06:05,000 --> 00:06:14,000
+The template is used to wire your data to the physical resource database connection when you need to
+
+75
+00:06:14,000 --> 00:06:15,000
+run database query.
+
+76
+00:06:16,000 --> 00:06:22,000
+Spring manages the life cycle of the beans you need for working with your persistence layer.
+
+77
+00:06:22,000 --> 00:06:25,000
+The advantages of using a template are.
+
+78
+00:06:25,000 --> 00:06:32,000
+JDBC template manages physical resources required to interact with the database automatically.
+
+79
+00:06:32,000 --> 00:06:37,000
+By saying this, I mean create and release the database connections.
+
+80
+00:06:37,000 --> 00:06:44,000
+The spring JDBC template converts the standard JDBC SQL exceptions into runtime exceptions.
+
+81
+00:06:44,000 --> 00:06:48,000
+This allows you to react more flexible to the errors.
+
+82
+00:06:49,000 --> 00:06:56,000
+The spring JDBC template converts also the vendor specific error messages into better understandable
+
+83
+00:06:56,000 --> 00:06:57,000
+error messages.
+
+84
+00:06:58,000 --> 00:07:02,000
+So I created bin of the JDBC template here.
+
+85
+00:07:02,000 --> 00:07:07,000
+Pay attention that I inject data source into this class.
+
+86
+00:07:08,000 --> 00:07:12,000
+I created such been as named parameter jdbc template.
+
+87
+00:07:12,000 --> 00:07:15,000
+Also using data source been.
+
+88
+00:07:15,000 --> 00:07:19,000
+The next files that I would like to review with you is user Dao.
+
+89
+00:07:20,000 --> 00:07:26,000
+If you want to refresh your knowledge about Dao pattern, please refer to my course Java from zero to
+
+90
+00:07:26,000 --> 00:07:26,000
+first job.
+
+91
+00:07:27,000 --> 00:07:32,000
+There you can find separate lesson about data access object design pattern.
+
+92
+00:07:32,000 --> 00:07:39,000
+So our user DAO class will be in charge of the interaction with the relational database.
+
+93
+00:07:39,000 --> 00:07:47,000
+Basically, this is a class where we will use objects created based on the spring JDBC libraries classes
+
+94
+00:07:47,000 --> 00:07:50,000
+in order to build and execute queries.
+
+95
+00:07:50,000 --> 00:07:52,000
+Let's look through it.
+
+96
+00:07:53,000 --> 00:08:00,000
+I injected JDBC template named parameter JDBC template and data source beans for the sake of examples
+
+97
+00:08:00,000 --> 00:08:03,000
+that I described in this file.
+
+98
+00:08:03,000 --> 00:08:05,000
+Let's review the first simple example.
+
+99
+00:08:05,000 --> 00:08:13,000
+Just simple select statement that returns us integer total count of users in the database.
+
+100
+00:08:14,000 --> 00:08:22,000
+I use method query for object of JDBC template object and pass the SQL query and class to which I want
+
+101
+00:08:22,000 --> 00:08:24,000
+to cast the result.
+
+102
+00:08:24,000 --> 00:08:32,000
+As you can see, I want to extract total count of users present in the database in the table user.
+
+103
+00:08:33,000 --> 00:08:36,000
+Obviously the result will be integer number.
+
+104
+00:08:36,000 --> 00:08:39,000
+That's why class for casting is integer.
+
+105
+00:08:40,000 --> 00:08:46,000
+Just to note, I believe that you understand that SQL queries can be stored in different files.
+
+106
+00:08:46,000 --> 00:08:54,000
+For example, you can store SQL queries in properties files and fetch them when needed.
+
+107
+00:08:54,000 --> 00:09:00,000
+In this lesson, I decided to keep SQL queries as part of the source code for demo purposes in order
+
+108
+00:09:00,000 --> 00:09:08,000
+to not switch screens very fast and do not navigate between multiple files a lot of times.
+
+109
+00:09:08,000 --> 00:09:12,000
+So just look at this first simple example.
+
+110
+00:09:13,000 --> 00:09:19,000
+I just injected JDBC template and just call methods that I need with a SQL query.
+
+111
+00:09:19,000 --> 00:09:20,000
+That's it.
+
+112
+00:09:20,000 --> 00:09:24,000
+No more creating Connection Creating Statement Objects.
+
+113
+00:09:24,000 --> 00:09:26,000
+Closing Connection.
+
+114
+00:09:26,000 --> 00:09:27,000
+Closing Statements.
+
+115
+00:09:27,000 --> 00:09:30,000
+Extracting ResultSet Closing Result Set.
+
+116
+00:09:30,000 --> 00:09:34,000
+Can you see how simple code looks like?
+
+117
+00:09:34,000 --> 00:09:41,000
+That's one of the biggest advantages of spring simplification and removing of boilerplate code.
+
+118
+00:09:42,000 --> 00:09:47,000
+Basically, I have nothing more to add here with regards to this first example.
+
+119
+00:09:48,000 --> 00:09:54,000
+Integer will be returned and I'm going to demo how this code works at the end of the lesson.
+
+120
+00:09:55,000 --> 00:09:56,000
+Let's continue.
+
+121
+00:09:57,000 --> 00:10:00,000
+Let's review simple insert statement.
+
+122
+00:10:00,000 --> 00:10:03,000
+Here you can see method at sample user.
+
+123
+00:10:03,000 --> 00:10:09,000
+This is how you can execute insert statement with the JDBC template object.
+
+124
+00:10:10,000 --> 00:10:17,000
+Pay attention that I use question marks for SQL query parameters instead of string concatenation in
+
+125
+00:10:17,000 --> 00:10:19,000
+order to avoid SQL injection.
+
+126
+00:10:19,000 --> 00:10:27,000
+After the SQL statement, I pass parameters that should be injected into the SQL statement similar to
+
+127
+00:10:27,000 --> 00:10:29,000
+the prepared statement from the JDBC.
+
+128
+00:10:29,000 --> 00:10:31,000
+If you remember.
+
+129
+00:10:31,000 --> 00:10:38,000
+Of course, all these parameters should go from the outside and should be passed to the method.
+
+130
+00:10:38,000 --> 00:10:46,000
+But in order to not complicate example and put all focus on the spring JDBC, I decided to hardcode
+
+131
+00:10:46,000 --> 00:10:47,000
+some values here.
+
+132
+00:10:48,000 --> 00:10:53,000
+Now let's review how we can work with the named parameter JDBC template.
+
+133
+00:10:54,000 --> 00:11:01,000
+I believe that from previous theoretical lessons you already know the purpose of this type.
+
+134
+00:11:01,000 --> 00:11:08,000
+But just to remind you, we are going to use a special template in order to use named parameters instead
+
+135
+00:11:08,000 --> 00:11:09,000
+of question marks.
+
+136
+00:11:09,000 --> 00:11:17,000
+This makes sense because in general it is considered that risk of making mistake was named parameters
+
+137
+00:11:17,000 --> 00:11:18,000
+is less.
+
+138
+00:11:18,000 --> 00:11:26,000
+Imagine in case your SQL queries are stored in another file and you need to pass parameters in a strict
+
+139
+00:11:26,000 --> 00:11:32,000
+sequence and you need to make sure that you passed all parameters correctly.
+
+140
+00:11:32,000 --> 00:11:40,000
+Or let's imagine that somebody adjusted SQL statement and you have wrong sequence of arguments right
+
+141
+00:11:40,000 --> 00:11:42,000
+now configured in the source code.
+
+142
+00:11:43,000 --> 00:11:50,000
+Anyway, haven't parameter name and associated value will give you better visibility and control over
+
+143
+00:11:50,000 --> 00:11:53,000
+building the and SQL query.
+
+144
+00:11:54,000 --> 00:11:55,000
+Under the hood.
+
+145
+00:11:55,000 --> 00:12:03,000
+It substitutes the named parameters to jdbc question mark placeholder and delegates to the wrapped JDBC
+
+146
+00:12:03,000 --> 00:12:06,000
+template to run the queries.
+
+147
+00:12:06,000 --> 00:12:15,000
+So here is the method that is called get last name of user by id where I use named parameter JDBC template.
+
+148
+00:12:15,000 --> 00:12:19,000
+I declare a variable of the SQL parameter source type.
+
+149
+00:12:20,000 --> 00:12:29,000
+This interface is intended to wrap various implementations like a map or a Java bean with a consistent
+
+150
+00:12:29,000 --> 00:12:30,000
+interface.
+
+151
+00:12:30,000 --> 00:12:34,000
+I create object of map parameter source.
+
+152
+00:12:34,000 --> 00:12:42,000
+Basically, this is implementation of SQL parameter source that holds a given map of parameters into
+
+153
+00:12:42,000 --> 00:12:43,000
+the map.
+
+154
+00:12:43,000 --> 00:12:47,000
+I added parameter with value passed as method argument.
+
+155
+00:12:48,000 --> 00:12:53,000
+After that I pass SQL query to the query for object method.
+
+156
+00:12:53,000 --> 00:12:56,000
+Pay attention how I use named parameter.
+
+157
+00:12:57,000 --> 00:13:05,000
+Here's a ye named parameter and I pass my map in order to inject parameter values into the SQL query.
+
+158
+00:13:05,000 --> 00:13:08,000
+Basically that's how it works.
+
+159
+00:13:08,000 --> 00:13:16,000
+But you can use not only map of parameters, you can also use bean for mapping parameters.
+
+160
+00:13:16,000 --> 00:13:18,000
+Let me show you how.
+
+161
+00:13:18,000 --> 00:13:20,000
+Below you can see similar method.
+
+162
+00:13:20,000 --> 00:13:22,000
+There are few differences.
+
+163
+00:13:22,000 --> 00:13:32,000
+Instead of passing just integer id, I pass user object and instead of creation map SQL parameter source
+
+164
+00:13:32,000 --> 00:13:34,000
+or object, I create bean property.
+
+165
+00:13:35,000 --> 00:13:40,000
+SQL Parameter Source object and pass my user object into the constructor.
+
+166
+00:13:40,000 --> 00:13:47,000
+This object obtains parameter values from bean properties of a given Java bean object.
+
+167
+00:13:47,000 --> 00:13:53,000
+The names of the bean properties have to match the parameter names.
+
+168
+00:13:53,000 --> 00:13:55,000
+The rest is the same.
+
+169
+00:13:56,000 --> 00:14:00,000
+I pass named parameters to the query for object method.
+
+170
+00:14:01,000 --> 00:14:04,000
+Also here you can see example of batch update.
+
+171
+00:14:05,000 --> 00:14:12,000
+In this particular example, I update our database by executing multiple insert statements and inserting
+
+172
+00:14:12,000 --> 00:14:13,000
+users.
+
+173
+00:14:13,000 --> 00:14:22,000
+I bet you remember that in JDBC we also can make batch updates and I showed you examples if you remember.
+
+174
+00:14:22,000 --> 00:14:30,000
+So this is needed in order to optimize amount of queries sent to the database from our application in
+
+175
+00:14:30,000 --> 00:14:39,000
+case we send batch request, all requests are sent at once and executed in one cycle in database, and
+
+176
+00:14:39,000 --> 00:14:42,000
+this gives us additional optimization.
+
+177
+00:14:43,000 --> 00:14:49,000
+This is helpful when you want to update multiple records in one table.
+
+178
+00:14:50,000 --> 00:14:53,000
+I use class that is called SQL parameter source utils.
+
+179
+00:14:53,000 --> 00:14:59,000
+It helps me to create batch source based on the array of my objects.
+
+180
+00:14:59,000 --> 00:15:05,000
+And after that, having the SQL query, I can just pass the batch for execution.
+
+181
+00:15:06,000 --> 00:15:13,000
+Another super interesting and useful feature of spring JDBC is possibility to map query results to Java
+
+182
+00:15:13,000 --> 00:15:17,000
+objects by implementing row mapper interface.
+
+183
+00:15:18,000 --> 00:15:24,000
+In the simple JDBC, I believe you remember that you had to work with a result set and extract values
+
+184
+00:15:24,000 --> 00:15:26,000
+from the result set.
+
+185
+00:15:26,000 --> 00:15:35,000
+Actually there is a way how to create reusable code even in JDBC, but in spring JDBC it is implemented
+
+186
+00:15:35,000 --> 00:15:39,000
+out of the box and in the very elegant way.
+
+187
+00:15:39,000 --> 00:15:45,000
+Let's review an example in the separate package that is called Row Mappers.
+
+188
+00:15:45,000 --> 00:15:47,000
+I implemented Row mapper.
+
+189
+00:15:48,000 --> 00:15:50,000
+Everything is simple here.
+
+190
+00:15:50,000 --> 00:15:56,000
+I declare a class that is called user row mapper that implements row mapper interface.
+
+191
+00:15:57,000 --> 00:16:03,000
+This interface makes me implement one single method that is called map row.
+
+192
+00:16:03,000 --> 00:16:09,000
+This method takes result set as method, argument and row numbers.
+
+193
+00:16:09,000 --> 00:16:16,000
+Inside I will create user object and will do mapping between data from the result set and user object
+
+194
+00:16:16,000 --> 00:16:17,000
+properties.
+
+195
+00:16:17,000 --> 00:16:21,000
+I just return the user object from this method.
+
+196
+00:16:21,000 --> 00:16:25,000
+Let me now open my user dialogue class here.
+
+197
+00:16:25,000 --> 00:16:28,000
+I have method that is called Get User by ID.
+
+198
+00:16:28,000 --> 00:16:36,000
+You can see that I use JDBC template to submit the SQL statement to extract all values from the user
+
+199
+00:16:36,000 --> 00:16:40,000
+table where ID is equal to the one specified.
+
+200
+00:16:41,000 --> 00:16:49,000
+According to the API, I need to pass an array with parameters and the second int array of argument
+
+201
+00:16:49,000 --> 00:16:50,000
+types.
+
+202
+00:16:50,000 --> 00:16:52,000
+Y int array.
+
+203
+00:16:52,000 --> 00:16:58,000
+Because according to the API, I need to use constants from the java types class.
+
+204
+00:16:59,000 --> 00:17:03,000
+I passed integer argument, so I just specify integer.
+
+205
+00:17:04,000 --> 00:17:11,000
+I believe that it is clear and logical for you that there should be mapping between types in this array
+
+206
+00:17:11,000 --> 00:17:14,000
+and actual types of arguments passed.
+
+207
+00:17:14,000 --> 00:17:20,000
+And the fourth argument is our row mapper and we have user object returned.
+
+208
+00:17:20,000 --> 00:17:21,000
+That's it.
+
+209
+00:17:22,000 --> 00:17:28,000
+Just to remind you that in case you have any questions, please do not hesitate to ask your questions
+
+210
+00:17:28,000 --> 00:17:31,000
+below the video and I will be happy to answer.
+
+211
+00:17:31,000 --> 00:17:33,000
+Let's move on.
+
+212
+00:17:33,000 --> 00:17:41,000
+So the only things that we still didn't review are examples with simple JDBC classes, the ones that
+
+213
+00:17:41,000 --> 00:17:49,000
+we reviewed in theoretical Lesson two, namely simple JDBC insert and simple JDBC call.
+
+214
+00:17:50,000 --> 00:17:53,000
+Let's start review from the simple JDBC insert.
+
+215
+00:17:53,000 --> 00:18:01,000
+As you remember, I can use simple JDBC insert to generate the insert statement based on the configurations
+
+216
+00:18:01,000 --> 00:18:02,000
+provided.
+
+217
+00:18:02,000 --> 00:18:08,000
+All we need is to provide the table name column names and values.
+
+218
+00:18:08,000 --> 00:18:13,000
+We already had method that inserts simple user data.
+
+219
+00:18:14,000 --> 00:18:20,000
+I created the similar method, but just using simple jdbc insert object.
+
+220
+00:18:20,000 --> 00:18:27,000
+I need to create object itself and you can see that I configure the table during the creation of the
+
+221
+00:18:27,000 --> 00:18:28,000
+object.
+
+222
+00:18:28,000 --> 00:18:32,000
+We're going to work with the user test table.
+
+223
+00:18:32,000 --> 00:18:37,000
+After that I create map where I will put all required parameters.
+
+224
+00:18:37,000 --> 00:18:44,000
+The key will be column name and the value will be the value that we want to insert.
+
+225
+00:18:44,000 --> 00:18:49,000
+After that I just call execute method and pass all my parameters.
+
+226
+00:18:49,000 --> 00:18:56,000
+Pay attention that using simple JDBC insert object, I don't create any SQL statements.
+
+227
+00:18:57,000 --> 00:18:58,000
+That's how it works.
+
+228
+00:18:59,000 --> 00:19:02,000
+You can see commanded line here.
+
+229
+00:19:02,000 --> 00:19:06,000
+This is just a useful reminder about the API.
+
+230
+00:19:06,000 --> 00:19:14,000
+Sometimes it is nice to get the primary key after insertion in order to proceed using this data further
+
+231
+00:19:14,000 --> 00:19:16,000
+in our business logic.
+
+232
+00:19:16,000 --> 00:19:24,000
+For this, you need to configure auto generated column and use method, execute and return key, just
+
+233
+00:19:24,000 --> 00:19:26,000
+like you can see in the example here.
+
+234
+00:19:27,000 --> 00:19:35,000
+And also we can pass data by using the map parameter source and being property parameter source.
+
+235
+00:19:36,000 --> 00:19:42,000
+And the last but not the least for code examples for today is example of simple JDBC call.
+
+236
+00:19:42,000 --> 00:19:49,000
+As you remember from previous lesson, object of this type is used to invoke stored procedure to invoke
+
+237
+00:19:49,000 --> 00:19:50,000
+stored procedure.
+
+238
+00:19:50,000 --> 00:19:55,000
+Let's make sure that stored procedure is created in the database.
+
+239
+00:19:55,000 --> 00:20:02,000
+In the comments on top of the related demo method, I pasted code that you can execute in the database
+
+240
+00:20:02,000 --> 00:20:04,000
+in order to create stored procedure.
+
+241
+00:20:05,000 --> 00:20:10,000
+And once stored procedure is created, this code will work.
+
+242
+00:20:11,000 --> 00:20:17,000
+I create object of simple JDBC call and I specify procedure name.
+
+243
+00:20:17,000 --> 00:20:20,000
+This is the name of procedure that I've created before.
+
+244
+00:20:20,000 --> 00:20:24,000
+The lesson in the database using the script above.
+
+245
+00:20:24,000 --> 00:20:29,000
+Our procedure has in parameter and out parameters.
+
+246
+00:20:30,000 --> 00:20:32,000
+Our in parameter is ID.
+
+247
+00:20:33,000 --> 00:20:36,000
+Our out parameters are first name and last name.
+
+248
+00:20:37,000 --> 00:20:42,000
+I create map parameters source and pass parameter into it.
+
+249
+00:20:43,000 --> 00:20:49,000
+I use this parameter source object during the execution of the stored procedure here.
+
+250
+00:20:49,000 --> 00:20:58,000
+As a result of execution, I receive map where string and names of output parameters and object is actually
+
+251
+00:20:58,000 --> 00:21:00,000
+values of output parameters.
+
+252
+00:21:00,000 --> 00:21:07,000
+I create user object and populate user with values that I received as out parameters.
+
+253
+00:21:07,000 --> 00:21:13,000
+Just to remind you that in case you want to learn more about stored procedures, feel free to check
+
+254
+00:21:13,000 --> 00:21:20,000
+my course Java from zero to first job and there you will find the separate lesson about stored procedures.
+
+255
+00:21:20,000 --> 00:21:24,000
+Basically that's it about simple JDBC call.
+
+256
+00:21:25,000 --> 00:21:29,000
+The only thing that is left is to make sure that everything works as expected.
+
+257
+00:21:30,000 --> 00:21:33,000
+So create a service layer.
+
+258
+00:21:33,000 --> 00:21:40,000
+This is just to help you understand how this DAO may be integrated in real life application.
+
+259
+00:21:40,000 --> 00:21:46,000
+Most likely you are going to have some clos on the service layer where you will apply all your business
+
+260
+00:21:46,000 --> 00:21:47,000
+logic.
+
+261
+00:21:47,000 --> 00:21:51,000
+In my particular demo I created a new class in the service package.
+
+262
+00:21:52,000 --> 00:21:55,000
+The class is called User Service JDBC Dao.
+
+263
+00:21:56,000 --> 00:22:03,000
+I inject my DAO class here and on this level you can apply any application business logic that you need.
+
+264
+00:22:04,000 --> 00:22:08,000
+And the service will be injected into the controller in Chan.
+
+265
+00:22:08,000 --> 00:22:14,000
+I created another class called User Rest Controller JDBC Demo.
+
+266
+00:22:14,000 --> 00:22:21,000
+Basically, I created here endpoints in order to be able to demo you all the methods that we have just
+
+267
+00:22:21,000 --> 00:22:23,000
+reviewed in the user dao.
+
+268
+00:22:23,000 --> 00:22:27,000
+I believe there is nothing new for you in this controller.
+
+269
+00:22:27,000 --> 00:22:36,000
+Please make sure you don't skip lessons when you watch my course because I count on this few lessons
+
+270
+00:22:36,000 --> 00:22:44,000
+ago we learned spring GPA and I showed you similar example of rest controller and explained that rest
+
+271
+00:22:44,000 --> 00:22:51,000
+controller annotation is basically a combination of two annotations, controller and response body.
+
+272
+00:22:52,000 --> 00:22:59,000
+Let me run the server and show you that all methods work as expected and that we receive the data that
+
+273
+00:22:59,000 --> 00:23:00,000
+we expect to receive.
+
+274
+00:23:01,000 --> 00:23:06,000
+First of all, here is how our user table looks like in the database.
+
+275
+00:23:06,000 --> 00:23:11,000
+Three records and such columns, nothing extraordinary.
+
+276
+00:23:11,000 --> 00:23:14,000
+Now let me open the web browser.
+
+277
+00:23:14,000 --> 00:23:20,000
+In the web browser, I'm going to send requests and demo the methods in the sequence that we reviewed
+
+278
+00:23:20,000 --> 00:23:21,000
+them.
+
+279
+00:23:21,000 --> 00:23:26,000
+We're going to start with the first method where one extract total user count.
+
+280
+00:23:27,000 --> 00:23:34,000
+This is a simple request that we created with a JDBC template, and as you can see, we receive value
+
+281
+00:23:34,000 --> 00:23:40,000
+three as expected, because as you saw, I have three records in the user table.
+
+282
+00:23:40,000 --> 00:23:46,000
+The next example is about adding sample user using JDBC template.
+
+283
+00:23:49,000 --> 00:23:53,000
+After sending this request, I receive one.
+
+284
+00:23:54,000 --> 00:23:56,000
+Because one record has been inserted.
+
+285
+00:23:56,000 --> 00:24:01,000
+Let me also show you the database In the database.
+
+286
+00:24:01,000 --> 00:24:04,000
+You can see that additional record is added.
+
+287
+00:24:04,000 --> 00:24:09,000
+The next example is about using named parameter JDBC template.
+
+288
+00:24:09,000 --> 00:24:13,000
+We are going to extract a last name by user ID.
+
+289
+00:24:14,000 --> 00:24:19,000
+User ID seven has first name admin and last name admin.
+
+290
+00:24:19,000 --> 00:24:23,000
+So everything works as expected.
+
+291
+00:24:24,000 --> 00:24:29,000
+The next demo was about injecting parameters into the query using bin properties.
+
+292
+00:24:29,000 --> 00:24:31,000
+SQL Parameter Source.
+
+293
+00:24:31,000 --> 00:24:37,000
+I used user with a yy7 and I received the same last name.
+
+294
+00:24:37,000 --> 00:24:44,000
+By the way, this trick is pretty useful when you need to inject multiple parameters into the SQL query
+
+295
+00:24:44,000 --> 00:24:48,000
+in order to not list them all manually.
+
+296
+00:24:49,000 --> 00:24:55,000
+You just pass bean and spring automatically matches parameters with properties.
+
+297
+00:24:56,000 --> 00:25:03,000
+The next example is related to the case when you use feature of query execution in batch.
+
+298
+00:25:03,000 --> 00:25:06,000
+Do you remember we implemented batch in set demo?
+
+299
+00:25:06,000 --> 00:25:14,000
+So to review this code in action, you can send request to the following resource user batch and set
+
+300
+00:25:14,000 --> 00:25:15,000
+demo.
+
+301
+00:25:15,000 --> 00:25:21,000
+And after that we can open database our user test table.
+
+302
+00:25:21,000 --> 00:25:26,000
+And just to be sure that new records were created in one batch.
+
+303
+00:25:26,000 --> 00:25:33,000
+As I already mentioned, this should help you to increase performance in cases when you need to update
+
+304
+00:25:33,000 --> 00:25:36,000
+the same table with multiple records.
+
+305
+00:25:37,000 --> 00:25:41,000
+Let me now show you the example of user row mapper in action.
+
+306
+00:25:41,000 --> 00:25:48,000
+So in the browser I send a request to the user JDBC demo seven.
+
+307
+00:25:48,000 --> 00:25:56,000
+And as you can see, JSON is returned, user is converted into JSON because we configured our controller
+
+308
+00:25:56,000 --> 00:26:01,000
+in such way it would write output directly into the response body.
+
+309
+00:26:01,000 --> 00:26:09,000
+And taking into account that our method returns user object, it is automatically serialized into the
+
+310
+00:26:09,000 --> 00:26:14,000
+JSON using JSON library that is added into the pom.xml.
+
+311
+00:26:14,000 --> 00:26:22,000
+And as you can see, all fields that we populated inside our user role mapper are successfully populated.
+
+312
+00:26:22,000 --> 00:26:24,000
+Also the danger lesson.
+
+313
+00:26:24,000 --> 00:26:29,000
+We learned how to work with simple insert objects.
+
+314
+00:26:29,000 --> 00:26:30,000
+Let's check the demo.
+
+315
+00:26:31,000 --> 00:26:37,000
+We also implemented method that inserts the user with a simple JDBC insert.
+
+316
+00:26:38,000 --> 00:26:42,000
+Let me send request to the foreign resource user.
+
+317
+00:26:42,000 --> 00:26:44,000
+Add test user too.
+
+318
+00:26:45,000 --> 00:26:50,000
+As you remember, for the sake of the demo, I did request to the user test table.
+
+319
+00:26:50,000 --> 00:26:51,000
+Let's check.
+
+320
+00:26:51,000 --> 00:26:53,000
+That record has been added.
+
+321
+00:26:53,000 --> 00:26:55,000
+And here it is.
+
+322
+00:26:55,000 --> 00:26:56,000
+The record has been added.
+
+323
+00:26:57,000 --> 00:27:02,000
+And the last but not the least, is the demo of the stored procedure invocation.
+
+324
+00:27:02,000 --> 00:27:07,000
+Let me send the request to the following resource user.
+
+325
+00:27:07,000 --> 00:27:10,000
+Last Name Procedure demo seven.
+
+326
+00:27:11,000 --> 00:27:17,000
+As you can see, we have populated on the first name and last name in our user object because our stored
+
+327
+00:27:17,000 --> 00:27:21,000
+procedure has only two output parameters.
+
+328
+00:27:21,000 --> 00:27:25,000
+Anyway, you can create any stored procedure you wish.
+
+329
+00:27:25,000 --> 00:27:32,000
+The main thing is for you to understand the mechanics and how everything works under the hood.
+
+330
+00:27:32,000 --> 00:27:37,000
+Knowing this, you can change parameters or queries by examples.
+
+331
+00:27:37,000 --> 00:27:40,000
+It will be like a piece of cake for you.
+
+332
+00:27:41,000 --> 00:27:44,000
+You're going to find source code examples in attachments to the video.
+
+333
+00:27:45,000 --> 00:27:47,000
+Feel free to explore examples.
+
+334
+00:27:47,000 --> 00:27:53,000
+Also, in case you have any questions, please put your questions below the video and I will be happy
+
+335
+00:27:53,000 --> 00:27:54,000
+to answer.
+
+336
+00:27:55,000 --> 00:27:59,000
+Now let's recap what we have learned in this lesson.
+
+337
+00:28:00,000 --> 00:28:04,000
+Today we made overview of the spring JDBC packages.
+
+338
+00:28:04,000 --> 00:28:08,000
+Now you know how the library is structured and where to search.
+
+339
+00:28:08,000 --> 00:28:10,000
+What we learned.
+
+340
+00:28:11,000 --> 00:28:12,000
+Spring JDBC configuration.
+
+341
+00:28:12,000 --> 00:28:14,000
+Now you know everything.
+
+342
+00:28:14,000 --> 00:28:19,000
+What we need to configure in order to start using features of spring JDBC.
+
+343
+00:28:19,000 --> 00:28:27,000
+I showed you today a lot of practical code examples, namely examples with JDBC template with named
+
+344
+00:28:27,000 --> 00:28:33,000
+parameter JDBC template simple JDBC insert and simple JDBC call.
+
+345
+00:28:33,000 --> 00:28:39,000
+Also during the lesson I explained you what row mapper is and how to use it.
+
+346
+00:28:39,000 --> 00:28:45,000
+And we learned how to make batch update with SQL parameter source utils class.
+
+347
+00:28:46,000 --> 00:28:48,000
+That's all for this lesson.
+
+348
+00:28:48,000 --> 00:28:50,000
+Thanks a lot for your attention.
+
+349
+00:28:50,000 --> 00:28:53,000
+Have a great day and see you in the next lesson.
+

88 - Spring JDBC/external-links.txt

@@ -0,0 +1,3 @@
+
+002 Source-code-of-examples-commit-with-changes-
+https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/914fe50d4a0da192c913cd2d91560f3a03d60fa1

89 - ===== EXAM Spring JDBC - Online Shop =====/001 EXAM Spring JDBC - Online Shop.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>EXAM Spring JDBC - Online Shop</title>
+
+        <style>
+            * {
+                box-sizing: border-box;
+                margin: 0;
+                padding: 0;
+            }
+            body {
+                font-family: var(--font-stack-text);
+                font-weight: 400;
+                line-height: 1.4;
+                font-size: 1.6rem;
+                color: #2d2f31;
+            }
+            .container {
+                position: relative;
+                height: 100%;
+                overflow-y: auto;
+            }
+            .content {
+                padding: 3.2rem 4.8rem;
+                word-break: break-word;
+                max-width: 69.6rem;
+                margin: 0 auto;
+            }
+            .heading {
+                margin-bottom: 24px;
+                font-family: -apple-system, BlinkMacSystemFont, Roboto, "Segoe UI", Helvetica, Arial, sans-serif,
+                    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+                font-weight: 700;
+                line-height: 1.2;
+                letter-spacing: 0;
+                font-size: 32px;
+                max-width: 36em;
+            }
+            .article-asset-container {
+                padding: 2.4rem;
+            }
+            .article-asset-container p {
+                font-size: 19px;
+            }
+            code {
+                background-color: #fff;
+                border: 1px solid #d1d7dc;
+                color: #b4690e;
+                font-size: 80%;
+                padding: 0.2rem 0.4rem;
+                font-family: sfmono-regular, Consolas, liberation mono, Menlo, Courier, monospace;
+            }
+            p {
+                font-weight: 400;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="content">
+                <div class="heading">EXAM Spring JDBC - Online Shop</div>
+                <div class="article-asset-container"><p>During the exam task you are going to take a template of the multimodule project - online shop, and integrate Spring JDBC into the persistence module of the application.</p><h4>Attachments:</h4><p>Exam Task - <a href="https://docs.google.com/document/d/1hUrihSGAdMao8_xp6IKkzniD7NdAzVyq5fmas1PyvJg/edit?usp=sharing" rel="noopener noreferrer" target="_blank">https://docs.google.com/document/d/1hUrihSGAdMao8_xp6IKkzniD7NdAzVyq5fmas1PyvJg/edit?usp=sharing</a></p></div>
+            </div>
+        </div>
+    </body>
+</html>

90 - Spring AOP/001 Aspect Oriented Programming_en.srt

@@ -0,0 +1,860 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello Tim.
+
+2
+00:00:06,000 --> 00:00:11,000
+With this video lesson, we start a new and very important topic.
+
+3
+00:00:11,000 --> 00:00:14,000
+We are going to learn aspect oriented programming.
+
+4
+00:00:14,000 --> 00:00:20,000
+Today we will start our lesson from learning the definition of aspect oriented programming.
+
+5
+00:00:20,000 --> 00:00:28,000
+To understand what it is, I will explain you what cross-cutting concern is, What is an aspect?
+
+6
+00:00:28,000 --> 00:00:32,000
+Why we need AOP and where to use it.
+
+7
+00:00:32,000 --> 00:00:37,000
+We will review the most common examples of using aspect oriented programming.
+
+8
+00:00:38,000 --> 00:00:44,000
+I will present you the most common and the most popular AOP implementations, and after that we are
+
+9
+00:00:44,000 --> 00:00:50,000
+going to focus our attention on learning the key terms and concepts of the AOP.
+
+10
+00:00:50,000 --> 00:01:00,000
+Namely, I am going to explain you what joint point is Pointcut advice Introduction Target Object Interceptor,
+
+11
+00:01:00,000 --> 00:01:08,000
+AOP Proxy and we even and at the end of the lesson we are going to summarize the advantages and disadvantages
+
+12
+00:01:08,000 --> 00:01:08,000
+of the AOP.
+
+13
+00:01:09,000 --> 00:01:11,000
+Let's start our lesson.
+
+14
+00:01:12,000 --> 00:01:18,000
+Let's start from the overview of and understanding better what it actually is.
+
+15
+00:01:18,000 --> 00:01:23,000
+As you may already guess, AOP stands for aspect oriented programming.
+
+16
+00:01:23,000 --> 00:01:27,000
+This is not the easiest topic for understanding, to be honest.
+
+17
+00:01:27,000 --> 00:01:30,000
+That's why we learn it just now.
+
+18
+00:01:30,000 --> 00:01:38,000
+Also, it is relatively rare used directly, but it is very often used in different frameworks under
+
+19
+00:01:38,000 --> 00:01:39,000
+the hood.
+
+20
+00:01:39,000 --> 00:01:44,000
+And also this often pops up as a topic during the technical interview.
+
+21
+00:01:45,000 --> 00:01:52,000
+AOP is a paradigm that supposed to increase the modularity of the different parts of an application
+
+22
+00:01:52,000 --> 00:01:54,000
+by separating cross-cutting concerns.
+
+23
+00:01:55,000 --> 00:02:00,000
+The most of my students often ask me what are cross-cutting concerns?
+
+24
+00:02:01,000 --> 00:02:03,000
+Okay, let me answer that.
+
+25
+00:02:03,000 --> 00:02:11,000
+Cross-cutting concern is an aspect of a program that affects several modules without the possibility
+
+26
+00:02:11,000 --> 00:02:14,000
+of being encapsulated in any of them.
+
+27
+00:02:14,000 --> 00:02:22,000
+For example, if writing an application for handling medical records, the indexing of such records
+
+28
+00:02:22,000 --> 00:02:31,000
+is a core concern while logging a history of changes to the record database or user database or an authentication
+
+29
+00:02:31,000 --> 00:02:38,000
+system would be cross-cutting concerns since they interact with more parts of the program.
+
+30
+00:02:38,000 --> 00:02:45,000
+So AOP breaks the program logic into separate parts that are called concerns.
+
+31
+00:02:45,000 --> 00:02:53,000
+The functions that span multiple points of an application, unnamed cross-cutting concerns and these
+
+32
+00:02:53,000 --> 00:02:59,000
+cross-cutting concerns are conceptually separate from the application's business logic.
+
+33
+00:03:00,000 --> 00:03:07,000
+A cross-cutting concern is a type of concern that has the power to impact the entire application and
+
+34
+00:03:07,000 --> 00:03:12,000
+should always be centralized in one location in the program as possible.
+
+35
+00:03:12,000 --> 00:03:18,000
+But probably now you have another question What is an aspect of a program?
+
+36
+00:03:19,000 --> 00:03:26,000
+An aspect of a program is a feature linked to many other parts of the program, but which is not related
+
+37
+00:03:26,000 --> 00:03:28,000
+to the program's primary function.
+
+38
+00:03:29,000 --> 00:03:37,000
+An aspect crosscuts the program's core concerns, therefore violating its separation of concerns that
+
+39
+00:03:37,000 --> 00:03:40,000
+tries to encapsulate unrelated functions.
+
+40
+00:03:40,000 --> 00:03:46,000
+And again, the most clear example in my opinion, is about login.
+
+41
+00:03:46,000 --> 00:03:51,000
+For example, login code can crosscut many modules.
+
+42
+00:03:51,000 --> 00:03:57,000
+The aspect of login should be separate from the functional concerns of the module.
+
+43
+00:03:57,000 --> 00:03:58,000
+It crosscuts.
+
+44
+00:03:59,000 --> 00:04:01,000
+What are the examples?
+
+45
+00:04:01,000 --> 00:04:05,000
+There are various useful examples of aspects in software development.
+
+46
+00:04:05,000 --> 00:04:14,000
+Like, for example, login, auditing, data validation, declarative transactions, security caching,
+
+47
+00:04:14,000 --> 00:04:15,000
+etcetera.
+
+48
+00:04:15,000 --> 00:04:16,000
+Is it clear?
+
+49
+00:04:17,000 --> 00:04:20,000
+So let's get back to again.
+
+50
+00:04:20,000 --> 00:04:26,000
+And the question is how it is actually done and how it is implemented.
+
+51
+00:04:26,000 --> 00:04:33,000
+The AOP is implemented by adding additional behavior to the existing code without making changes to
+
+52
+00:04:33,000 --> 00:04:35,000
+the original code.
+
+53
+00:04:35,000 --> 00:04:38,000
+Sounds interesting already, isn't it?
+
+54
+00:04:39,000 --> 00:04:45,000
+So basically, in order to add some additional functionality to some methods, you don't need to open
+
+55
+00:04:45,000 --> 00:04:49,000
+the class and actually fix the source code.
+
+56
+00:04:49,000 --> 00:04:54,000
+You can add additional functionality actually without editing the source code.
+
+57
+00:04:54,000 --> 00:04:56,000
+Sounds like magic.
+
+58
+00:04:56,000 --> 00:04:57,000
+Don't you think so?
+
+59
+00:04:58,000 --> 00:05:07,000
+We can also compare AOP with OP object oriented programming to understand better.
+
+60
+00:05:08,000 --> 00:05:16,000
+The key unit of modularity in AOP is the class, whereas in aspect oriented programming, the unit of
+
+61
+00:05:16,000 --> 00:05:19,000
+modularity is the aspect.
+
+62
+00:05:19,000 --> 00:05:27,000
+AOP allows you to decouple cross-cutting concerns from the objects that they affect in the development
+
+63
+00:05:27,000 --> 00:05:27,000
+process.
+
+64
+00:05:28,000 --> 00:05:30,000
+Now let me explain you.
+
+65
+00:05:30,000 --> 00:05:32,000
+Why do we need AOP?
+
+66
+00:05:32,000 --> 00:05:38,000
+I believe that you already had a chance to understand the advantages that we expect to get by using
+
+67
+00:05:38,000 --> 00:05:39,000
+AOP approach.
+
+68
+00:05:39,000 --> 00:05:45,000
+But let me elaborate a little bit more and explain you based on examples.
+
+69
+00:05:45,000 --> 00:05:51,000
+Imagine that we have the following test class with the three methods that you can see on the screen.
+
+70
+00:05:52,000 --> 00:05:59,000
+And imagine that you need to ensure a login after each method in this class is completed without AOP.
+
+71
+00:05:59,000 --> 00:06:00,000
+What would you do?
+
+72
+00:06:01,000 --> 00:06:07,000
+You would create instance of logger and you would adjust source code of each method by adding logging
+
+73
+00:06:07,000 --> 00:06:08,000
+in each method.
+
+74
+00:06:08,000 --> 00:06:09,000
+Is that correct?
+
+75
+00:06:10,000 --> 00:06:13,000
+With aspect oriented programming approach.
+
+76
+00:06:13,000 --> 00:06:16,000
+You don't need to adjust each method.
+
+77
+00:06:16,000 --> 00:06:22,000
+You just need to declare, let's say, rules when and what should be executed.
+
+78
+00:06:23,000 --> 00:06:26,000
+Let's imagine that rule sounds like this.
+
+79
+00:06:26,000 --> 00:06:30,000
+Log the method name according to the predefined pattern.
+
+80
+00:06:30,000 --> 00:06:32,000
+One method is completed.
+
+81
+00:06:32,000 --> 00:06:42,000
+So to sum it up when we should use AOP, it can be used when we need allow users to implement custom
+
+82
+00:06:42,000 --> 00:06:43,000
+elements.
+
+83
+00:06:43,000 --> 00:06:49,000
+These elements can be really helpful for adding some additional features and functionalities that were
+
+84
+00:06:49,000 --> 00:06:52,000
+not present in the software at the beginning.
+
+85
+00:06:53,000 --> 00:07:01,000
+I believe you understand that AUP is an approach and to implement AUP in your program, you need some
+
+86
+00:07:01,000 --> 00:07:01,000
+tool.
+
+87
+00:07:02,000 --> 00:07:07,000
+There are different libraries that can help you to implement in Java.
+
+88
+00:07:07,000 --> 00:07:12,000
+They are aspect Spring, AOP, JBoss, AOP.
+
+89
+00:07:13,000 --> 00:07:20,000
+All implementations use the same terminology that we are going to learn today, but the details of implementation
+
+90
+00:07:20,000 --> 00:07:22,000
+can be different.
+
+91
+00:07:22,000 --> 00:07:28,000
+Anyway, in my opinion aspect and spring AOP the most popular ones.
+
+92
+00:07:29,000 --> 00:07:34,000
+Okay, let's learn the key terms and concepts that are widely used in AOP.
+
+93
+00:07:34,000 --> 00:07:37,000
+No matter what implementation do you use?
+
+94
+00:07:38,000 --> 00:07:43,000
+So on this slide, you can see the key concepts.
+
+95
+00:07:43,000 --> 00:07:45,000
+They are joint point.
+
+96
+00:07:45,000 --> 00:07:48,000
+Point Cut Advice.
+
+97
+00:07:48,000 --> 00:07:54,000
+Introduction Target Object aspect Interceptor.
+
+98
+00:07:54,000 --> 00:07:57,000
+AOP Proxy even.
+
+99
+00:07:58,000 --> 00:08:03,000
+Let's now spend some time understanding each of these key concepts.
+
+100
+00:08:03,000 --> 00:08:04,000
+Let's go one by one.
+
+101
+00:08:05,000 --> 00:08:08,000
+The first one in our list is Joint Point.
+
+102
+00:08:09,000 --> 00:08:16,000
+Durant point is any point in your program, such as method execution, exception, handling, field
+
+103
+00:08:16,000 --> 00:08:18,000
+access, etcetera.
+
+104
+00:08:18,000 --> 00:08:23,000
+The different libraries that you can use to apply your approach.
+
+105
+00:08:23,000 --> 00:08:29,000
+But if we talk about spring AOP, for example, it supports only massive execution.
+
+106
+00:08:29,000 --> 00:08:30,000
+Join point.
+
+107
+00:08:31,000 --> 00:08:40,000
+Join point symbolizes a point in your application where you can easily plug in the aspect of your software.
+
+108
+00:08:41,000 --> 00:08:42,000
+Point cut.
+
+109
+00:08:43,000 --> 00:08:46,000
+Let's understand now what a point cut is.
+
+110
+00:08:46,000 --> 00:08:51,000
+It is an expression language of AOP that matches join points.
+
+111
+00:08:52,000 --> 00:08:59,000
+Point cut is an expression that is matched with joint points to determine whether advice needs to be
+
+112
+00:08:59,000 --> 00:09:01,000
+executed or not.
+
+113
+00:09:01,000 --> 00:09:07,000
+Point cut uses different kinds of expressions that are matched with the joint points.
+
+114
+00:09:07,000 --> 00:09:13,000
+For example, Spring Framework uses the point cut expression language.
+
+115
+00:09:13,000 --> 00:09:18,000
+The next key concept from our list is advice.
+
+116
+00:09:19,000 --> 00:09:24,000
+Advice represents an action taken by an aspect at a particular joint point.
+
+117
+00:09:24,000 --> 00:09:27,000
+If you don't understand the statement, don't worry.
+
+118
+00:09:27,000 --> 00:09:31,000
+I will try to explain advice in different ways now.
+
+119
+00:09:32,000 --> 00:09:38,000
+Advices are actions taken for a particular joint point in terms of programming.
+
+120
+00:09:38,000 --> 00:09:47,000
+The methods that get executed when a certain joint point with matching point is reached in the application.
+
+121
+00:09:48,000 --> 00:09:52,000
+You can think of advices as servlet filters, for example.
+
+122
+00:09:53,000 --> 00:09:58,000
+Based on the execution strategy of advice, there are the following types.
+
+123
+00:09:58,000 --> 00:10:05,000
+Before advice, these advices run before the execution of join point.
+
+124
+00:10:06,000 --> 00:10:14,000
+After returning advice in case you want to execute advice only if the join point method executes normally,
+
+125
+00:10:14,000 --> 00:10:18,000
+then you should use after returning advice.
+
+126
+00:10:18,000 --> 00:10:24,000
+We can use after returning annotation to mark a method as after returning advice.
+
+127
+00:10:24,000 --> 00:10:32,000
+After throwing advice, this advice gets executed only when join point method throws an exception.
+
+128
+00:10:33,000 --> 00:10:36,000
+We can use it to roll back the transaction declaratively.
+
+129
+00:10:37,000 --> 00:10:46,000
+After finally advice and advice that gets executed after the joint point finished execution, whether
+
+130
+00:10:46,000 --> 00:10:48,000
+normally or by throwing an exception.
+
+131
+00:10:49,000 --> 00:10:51,000
+Around the device.
+
+132
+00:10:51,000 --> 00:10:54,000
+This is the most important and powerful advice.
+
+133
+00:10:54,000 --> 00:11:01,000
+This advice surrounds the join point method, and we can also choose whether to execute the join point
+
+134
+00:11:01,000 --> 00:11:03,000
+method or not.
+
+135
+00:11:03,000 --> 00:11:10,000
+We can write advice code that gets executed before and after the execution of the join point method.
+
+136
+00:11:11,000 --> 00:11:18,000
+It is the responsibility of around advice to invoke the join point method and return values if the market
+
+137
+00:11:18,000 --> 00:11:20,000
+returns something.
+
+138
+00:11:21,000 --> 00:11:22,000
+Introduction.
+
+139
+00:11:22,000 --> 00:11:28,000
+Introduction concept means introduction of additional masses and fields for a type.
+
+140
+00:11:29,000 --> 00:11:34,000
+It allows you to introduce new interface to any advanced object.
+
+141
+00:11:35,000 --> 00:11:43,000
+An introduction is another term in spring that helps you to add new methods or features to the existing
+
+142
+00:11:43,000 --> 00:11:43,000
+classes.
+
+143
+00:11:43,000 --> 00:11:51,000
+It basically means the introduction of additional methods and domains for a particular type as per the
+
+144
+00:11:51,000 --> 00:11:53,000
+requirements of the software.
+
+145
+00:11:53,000 --> 00:12:00,000
+It allows you to introduce a new interface to any advanced object for your particular system.
+
+146
+00:12:00,000 --> 00:12:03,000
+So in short, about introduction.
+
+147
+00:12:03,000 --> 00:12:07,000
+Declaring additional methods or fields on behalf of a type.
+
+148
+00:12:08,000 --> 00:12:17,000
+Spring allows you to introduce new interfaces and the corresponding implementation to any advanced object.
+
+149
+00:12:17,000 --> 00:12:25,000
+For example, you could use an introduction to make a bean implement and is modified interface to simplify
+
+150
+00:12:25,000 --> 00:12:26,000
+caching.
+
+151
+00:12:27,000 --> 00:12:31,000
+The next important concept in AOP is target object.
+
+152
+00:12:31,000 --> 00:12:33,000
+What is it?
+
+153
+00:12:33,000 --> 00:12:37,000
+This is the object on which advices are applied.
+
+154
+00:12:37,000 --> 00:12:41,000
+Our business object is it contains some business logic.
+
+155
+00:12:41,000 --> 00:12:46,000
+In spring it is also known as proxied object.
+
+156
+00:12:46,000 --> 00:12:53,000
+That is because target object in spring AOP is implemented using runtime proxies.
+
+157
+00:12:53,000 --> 00:12:57,000
+So this object is always a proxied object.
+
+158
+00:12:57,000 --> 00:13:06,000
+It means that a subclass is created at the runtime, whereas the target method is overridden and device
+
+159
+00:13:06,000 --> 00:13:10,000
+is included based on its configuration.
+
+160
+00:13:10,000 --> 00:13:11,000
+Is it clear?
+
+161
+00:13:12,000 --> 00:13:14,000
+In order to apply the advice.
+
+162
+00:13:14,000 --> 00:13:19,000
+The method that is invoked on target object is overridden.
+
+163
+00:13:19,000 --> 00:13:24,000
+Well already learned such key concepts in as aspect.
+
+164
+00:13:24,000 --> 00:13:26,000
+But just to recap.
+
+165
+00:13:26,000 --> 00:13:29,000
+Taking into account, we are looking through all the key concepts.
+
+166
+00:13:29,000 --> 00:13:32,000
+First of all, aspect it is a class.
+
+167
+00:13:32,000 --> 00:13:36,000
+This class contains advices during points.
+
+168
+00:13:36,000 --> 00:13:37,000
+ET cetera.
+
+169
+00:13:37,000 --> 00:13:44,000
+Aspect can be a normal class configured through spring XML configuration, or we can use spring aspect
+
+170
+00:13:45,000 --> 00:13:48,000
+integration to define a class as aspect.
+
+171
+00:13:48,000 --> 00:13:50,000
+Using aspect annotation.
+
+172
+00:13:50,000 --> 00:13:57,000
+An aspect is a modularization of a concern that cuts across multiple classes.
+
+173
+00:13:57,000 --> 00:14:03,000
+For example, the class that contains after returning advice can be named aspect.
+
+174
+00:14:03,000 --> 00:14:09,000
+An application can have any number of aspects depending on the requirement of the software.
+
+175
+00:14:10,000 --> 00:14:14,000
+Now let's learn what an interceptor is.
+
+176
+00:14:14,000 --> 00:14:20,000
+In simple words, it is an aspect that contains only one advice.
+
+177
+00:14:20,000 --> 00:14:23,000
+The next concept is AOP Proxy.
+
+178
+00:14:24,000 --> 00:14:31,000
+AOP Proxy is used to implement aspect contracts created by AOP framework.
+
+179
+00:14:31,000 --> 00:14:38,000
+It will be a dynamic proxy or CG lip proxy in spring framework.
+
+180
+00:14:38,000 --> 00:14:47,000
+Spring implementation uses JDK Dynamic proxy to create the proxy classes with target classes and advice
+
+181
+00:14:47,000 --> 00:14:48,000
+invocations.
+
+182
+00:14:48,000 --> 00:14:51,000
+These are called AOP proxy classes.
+
+183
+00:14:51,000 --> 00:14:59,000
+We can also use CG lip proxy by adding it as a dependency in the spring AOP project.
+
+184
+00:15:00,000 --> 00:15:03,000
+And the last but not the least from our list is we even.
+
+185
+00:15:05,000 --> 00:15:13,000
+Leven is a process of linking aspect with other application types or objects to create an advanced object.
+
+186
+00:15:13,000 --> 00:15:18,000
+We even can be done at compile time, load time or runtime.
+
+187
+00:15:19,000 --> 00:15:23,000
+Spring performs even at runtime.
+
+188
+00:15:24,000 --> 00:15:29,000
+And the last thing that I would like to talk with you today is about advantages and disadvantages of
+
+189
+00:15:29,000 --> 00:15:31,000
+the aspect oriented programming.
+
+190
+00:15:32,000 --> 00:15:35,000
+And one advantages it is worth to mention the following ones.
+
+191
+00:15:36,000 --> 00:15:39,000
+AOP respects modularity.
+
+192
+00:15:39,000 --> 00:15:42,000
+It reduces the coupling of dependencies.
+
+193
+00:15:43,000 --> 00:15:47,000
+It makes code more readable, reusable and maintainable.
+
+194
+00:15:48,000 --> 00:15:53,000
+If we want to discuss disadvantages, then we should mention the following ones.
+
+195
+00:15:54,000 --> 00:16:02,000
+The bargain can be more difficult because there is more code than I can see at the beginning to configure
+
+196
+00:16:02,000 --> 00:16:03,000
+breakpoints properly.
+
+197
+00:16:04,000 --> 00:16:09,000
+A requires discipline to refrain from overuse.
+
+198
+00:16:10,000 --> 00:16:18,000
+In general, aspect oriented programming can be called as dark art because it can perform some black
+
+199
+00:16:18,000 --> 00:16:19,000
+magic behind the scenes.
+
+200
+00:16:19,000 --> 00:16:28,000
+In the old world and in your code, I believe you can understand that with AOP, we can change the way
+
+201
+00:16:28,000 --> 00:16:34,000
+of method execution, replace the result, or even prevent it from running at all.
+
+202
+00:16:35,000 --> 00:16:45,000
+Taking into account APIs such power you always should remember about it and use with caution and understanding
+
+203
+00:16:45,000 --> 00:16:52,000
+and necessary use of in your application can be dangerous and result into unexpected errors.
+
+204
+00:16:53,000 --> 00:16:55,000
+That's all what I wanted to discuss with you.
+
+205
+00:16:56,000 --> 00:16:59,000
+Let's recap what we have learned in this lesson.
+
+206
+00:17:00,000 --> 00:17:05,000
+So the day we learned what an aspect oriented programming is.
+
+207
+00:17:06,000 --> 00:17:11,000
+I explained you what cross-cutting concern and what aspect actually are.
+
+208
+00:17:11,000 --> 00:17:16,000
+We learned why we need AOP and where to use AOP.
+
+209
+00:17:17,000 --> 00:17:20,000
+I showed you main AOP implementations.
+
+210
+00:17:20,000 --> 00:17:29,000
+We learned key terms and concepts of AOP like Joint Point, point cut and voice introduction, target
+
+211
+00:17:29,000 --> 00:17:33,000
+object Interceptor, AOP, proxy weaving.
+
+212
+00:17:33,000 --> 00:17:39,000
+And at the end of the lesson, we learned the advantages and disadvantages of the AOP.
+
+213
+00:17:40,000 --> 00:17:41,000
+That's all for this lesson.
+
+214
+00:17:42,000 --> 00:17:43,000
+Thanks a lot for your attention.
+
+215
+00:17:43,000 --> 00:17:47,000
+Have a great day and see you in the next lesson.
+

90 - Spring AOP/002 Source-code-of-examples-commit-with-changes-.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/ab0084445a16c0c8897cc80308c28817d9dace8a

90 - Spring AOP/002 Spring AOP with AspectJ Practice_en.srt

@@ -0,0 +1,1076 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello Tim.
+
+2
+00:00:06,000 --> 00:00:09,000
+We continue learning aspect oriented programming.
+
+3
+00:00:09,000 --> 00:00:15,000
+I hope that you watched previous theoretical lesson about AOP in this video.
+
+4
+00:00:15,000 --> 00:00:21,000
+We are going to have a lot of practical examples with Spring, AOP and aspect J.
+
+5
+00:00:22,000 --> 00:00:28,000
+We're going to start our lesson from review of required dependencies that we need to add into our project.
+
+6
+00:00:29,000 --> 00:00:34,000
+Together we are going to create aspect and configure point cards and advices.
+
+7
+00:00:34,000 --> 00:00:41,000
+I'm going to show you different pointcut designators that can be used and recognized by spring AOP.
+
+8
+00:00:42,000 --> 00:00:50,000
+Also, I will show you how to enable aspect configuration support with enable aspect Autoproxy annotation
+
+9
+00:00:50,000 --> 00:00:53,000
+and after everything will be configured.
+
+10
+00:00:53,000 --> 00:00:58,000
+We are going to see live examples and how all the code works together.
+
+11
+00:00:58,000 --> 00:01:05,000
+Let's start our lesson and as I already mentioned today, we are going to have a lesson full of practical
+
+12
+00:01:05,000 --> 00:01:06,000
+examples.
+
+13
+00:01:06,000 --> 00:01:08,000
+So let me start screen sharing.
+
+14
+00:01:09,000 --> 00:01:14,000
+As always, you can find the reference to the source code examples in attachments to the video.
+
+15
+00:01:14,000 --> 00:01:21,000
+And in case you have any questions, please let me know in comments below the video.
+
+16
+00:01:21,000 --> 00:01:28,000
+As we already learned in the previous lesson aspect, oriented programming complements object oriented
+
+17
+00:01:28,000 --> 00:01:33,000
+programming by providing another way of thinking about program structure.
+
+18
+00:01:33,000 --> 00:01:38,000
+The key unit of modularity in OOP is the class.
+
+19
+00:01:38,000 --> 00:01:42,000
+Whereas in AOP, the unit of modularity is the aspect.
+
+20
+00:01:43,000 --> 00:01:47,000
+Let's start from adding required dependencies.
+
+21
+00:01:47,000 --> 00:01:55,000
+I opened pom.xml, so there is a separate library spring AOP that contains interfaces and classes by
+
+22
+00:01:55,000 --> 00:01:59,000
+implementing which you can configure advices that you need.
+
+23
+00:01:59,000 --> 00:02:08,000
+But I can say that approach based on aspect annotations is popular and so widespread that in my personal
+
+24
+00:02:08,000 --> 00:02:15,000
+experience this is dominated approach of configuring aspects even in spring based applications.
+
+25
+00:02:15,000 --> 00:02:22,000
+Spring framework recognizes aspect annotations and introduces aspect support.
+
+26
+00:02:22,000 --> 00:02:28,000
+That's why in this particular practical example we will add aspect dependencies only.
+
+27
+00:02:29,000 --> 00:02:36,000
+Aspect refers to a style of declaring aspects as a regular Java classes annotated with annotations.
+
+28
+00:02:36,000 --> 00:02:41,000
+The aspect style was introduced by aspect project.
+
+29
+00:02:41,000 --> 00:02:49,000
+Spring interprets the same annotations as aspect j using a library supplied by aspect J for Pointcut
+
+30
+00:02:49,000 --> 00:02:51,000
+parsing and matching.
+
+31
+00:02:51,000 --> 00:02:57,000
+So I added aspect j runtime and aspect j tools dependencies here.
+
+32
+00:02:58,000 --> 00:03:00,000
+Just for logging purposes.
+
+33
+00:03:00,000 --> 00:03:08,000
+I also added self for G and log back, but this is optional in case you don't need and don't want to
+
+34
+00:03:08,000 --> 00:03:09,000
+configure login.
+
+35
+00:03:09,000 --> 00:03:11,000
+This is not necessary.
+
+36
+00:03:11,000 --> 00:03:18,000
+The main thing for the sake of today's demo is to add these aspect dependencies.
+
+37
+00:03:18,000 --> 00:03:21,000
+Let's now review our business object.
+
+38
+00:03:21,000 --> 00:03:25,000
+In our today's example, we are going to deal with the user class.
+
+39
+00:03:25,000 --> 00:03:31,000
+All examples related to today's lesson will be located in the AOP package here.
+
+40
+00:03:31,000 --> 00:03:37,000
+Nothing is extraordinary, just properties like first name and last name.
+
+41
+00:03:37,000 --> 00:03:44,000
+I also preconfigured default first name and last name just for the sake of example getters and setters
+
+42
+00:03:44,000 --> 00:03:47,000
+and one message that throws exception.
+
+43
+00:03:47,000 --> 00:03:53,000
+This is created for the sake of example in order I can demonstrate different types of advices.
+
+44
+00:03:54,000 --> 00:03:56,000
+Now let's create aspect.
+
+45
+00:03:57,000 --> 00:04:03,000
+Please make sure you watch the previous lesson because in previous lesson we discussed all the terminologies
+
+46
+00:04:03,000 --> 00:04:05,000
+that I use in this lesson.
+
+47
+00:04:05,000 --> 00:04:11,000
+But just to recap aspect is a class that contains advices and point cards.
+
+48
+00:04:12,000 --> 00:04:17,000
+I open class that is called demo aspect, as I already mentioned.
+
+49
+00:04:17,000 --> 00:04:21,000
+Actually Spring app can be configured in different ways.
+
+50
+00:04:21,000 --> 00:04:24,000
+There are three ways of configuration.
+
+51
+00:04:24,000 --> 00:04:29,000
+They are by spring old style DTD based.
+
+52
+00:04:29,000 --> 00:04:38,000
+I'm not sure you will use it ever again by aspect annotation style by spring XML configuration style
+
+53
+00:04:39,000 --> 00:04:47,000
+schema based, but the most widely used approach is spring aspect, annotation style, and in this lesson
+
+54
+00:04:47,000 --> 00:04:51,000
+we will use aspect annotations for configuration.
+
+55
+00:04:52,000 --> 00:05:00,000
+With the aspect support enabled any been defined in your application context with a class that is aspect
+
+56
+00:05:01,000 --> 00:05:03,000
+aspect has the aspect annotation.
+
+57
+00:05:03,000 --> 00:05:12,000
+Mean will be automatically detected by spring and used to configure spring AOP taking into account the
+
+58
+00:05:12,000 --> 00:05:14,000
+use annotation based configuration.
+
+59
+00:05:14,000 --> 00:05:22,000
+I also added component annotation in order inversion of control container create been of such type.
+
+60
+00:05:23,000 --> 00:05:29,000
+If you use XML based configuration, then you need to register your bean in XML.
+
+61
+00:05:29,000 --> 00:05:36,000
+Having just aspect annotation is not enough for auto detection in the classpath, you need to register
+
+62
+00:05:36,000 --> 00:05:39,000
+it as a spring bean for proper configuration.
+
+63
+00:05:40,000 --> 00:05:41,000
+Aspects.
+
+64
+00:05:41,000 --> 00:05:47,000
+Classes annotated with aspect may have masses and fields just like any other class.
+
+65
+00:05:47,000 --> 00:05:54,000
+They may also contain point, card advice and introduction inter-type declarations.
+
+66
+00:05:55,000 --> 00:06:03,000
+Another interesting and important question Can you advise on aspects with other aspects in spring AOP?
+
+67
+00:06:03,000 --> 00:06:09,000
+It is not possible to have aspects themselves be the target of advice from other aspects.
+
+68
+00:06:10,000 --> 00:06:18,000
+The aspect annotation on a class marks it as an aspect and hence excludes it from autoproxy.
+
+69
+00:06:18,000 --> 00:06:21,000
+So we declare it aspect.
+
+70
+00:06:21,000 --> 00:06:22,000
+Put annotation.
+
+71
+00:06:22,000 --> 00:06:23,000
+All good.
+
+72
+00:06:23,000 --> 00:06:25,000
+What's next?
+
+73
+00:06:25,000 --> 00:06:29,000
+The next thing let's declare a different point class.
+
+74
+00:06:29,000 --> 00:06:38,000
+Just to remind you that point cards determine joint points of interest and thus enable us to control
+
+75
+00:06:38,000 --> 00:06:40,000
+when advice executes.
+
+76
+00:06:40,000 --> 00:06:44,000
+Spring AOP only supports method execution.
+
+77
+00:06:44,000 --> 00:06:52,000
+Join points for spring beans so you can think of a pointcut as matching the execution of methods on
+
+78
+00:06:52,000 --> 00:06:53,000
+spring beans.
+
+79
+00:06:54,000 --> 00:06:56,000
+A Pointcut declaration has two parts.
+
+80
+00:06:57,000 --> 00:07:05,000
+A signature comprising a name and any parameters and the pointcut expressions that determines exactly
+
+81
+00:07:05,000 --> 00:07:08,000
+which message executions were interested in.
+
+82
+00:07:08,000 --> 00:07:16,000
+In the aspect annotation style of AOP, a Pointcut signatures provided by a regular method definition
+
+83
+00:07:16,000 --> 00:07:22,000
+and the Pointcut expression is indicated using the Pointcut annotation.
+
+84
+00:07:22,000 --> 00:07:27,000
+The method seven as a Pointcut signature must have a void return type.
+
+85
+00:07:28,000 --> 00:07:29,000
+Pay attention to this.
+
+86
+00:07:30,000 --> 00:07:33,000
+Let's review the first and the most simple example.
+
+87
+00:07:34,000 --> 00:07:42,000
+The point card named Select all will match the execution of any message in the current package, namely
+
+88
+00:07:42,000 --> 00:07:45,000
+package with our examples.
+
+89
+00:07:45,000 --> 00:07:46,000
+Is it clear?
+
+90
+00:07:46,000 --> 00:07:53,000
+So here we specified execution as it is obviously related directly to the method execution.
+
+91
+00:07:53,000 --> 00:07:55,000
+What else we can specify here?
+
+92
+00:07:56,000 --> 00:08:01,000
+Aspect G provides a lot of different pointcut designators.
+
+93
+00:08:01,000 --> 00:08:08,000
+Unfortunately or fortunately, not all of them are supported by spring aspect oriented programming.
+
+94
+00:08:08,000 --> 00:08:15,000
+On this slide you can see only those pointcut designators that are supported by spring AOP.
+
+95
+00:08:16,000 --> 00:08:18,000
+Let's review them.
+
+96
+00:08:18,000 --> 00:08:23,000
+Execution for matching method execution join points.
+
+97
+00:08:23,000 --> 00:08:28,000
+This is probably the most popular pointcut designator when working with spring AOP.
+
+98
+00:08:29,000 --> 00:08:38,000
+Within this one limits matching the join points within certain types simply as execution of master declared
+
+99
+00:08:38,000 --> 00:08:40,000
+within a matching type when using spring AOP.
+
+100
+00:08:41,000 --> 00:08:45,000
+This limits matching to join points.
+
+101
+00:08:45,000 --> 00:08:48,000
+The execution of matches when using spring AOP.
+
+102
+00:08:49,000 --> 00:08:54,000
+Whereas a reference spring AOP proxy is an instance of the given type.
+
+103
+00:08:55,000 --> 00:08:57,000
+And the rest are on the slide.
+
+104
+00:08:58,000 --> 00:09:01,000
+I believe there is no need to be reading out loud.
+
+105
+00:09:01,000 --> 00:09:09,000
+Each one just press on, pause the video and read through the slide and remember that in case you have
+
+106
+00:09:09,000 --> 00:09:16,000
+any questions, you are always welcome to post your questions below the video and I will be happy to
+
+107
+00:09:16,000 --> 00:09:17,000
+answer.
+
+108
+00:09:17,000 --> 00:09:23,000
+Because Spring AOP limits matching to only method execution join points.
+
+109
+00:09:23,000 --> 00:09:31,000
+The discussion of the Pointcut designators gives a narrower definition than you will find in the aspect
+
+110
+00:09:31,000 --> 00:09:33,000
+programming guide.
+
+111
+00:09:33,000 --> 00:09:41,000
+The full aspect Pointcut language supports additional Pointcut designators that are not supported in
+
+112
+00:09:41,000 --> 00:09:41,000
+spring.
+
+113
+00:09:42,000 --> 00:09:46,000
+So once you look through the slide, we are good to continue.
+
+114
+00:09:48,000 --> 00:09:52,000
+On this slide, you are going to see different examples of point cuts.
+
+115
+00:09:52,000 --> 00:10:00,000
+For example, the execution of any public method is execution of any method with the name beginning
+
+116
+00:10:00,000 --> 00:10:01,000
+with set.
+
+117
+00:10:01,000 --> 00:10:08,000
+The execution of any method defined by the account service interface and so on.
+
+118
+00:10:09,000 --> 00:10:17,000
+Again, I would ask you to put the video on pause and look through the slide at your own pace, taking
+
+119
+00:10:17,000 --> 00:10:20,000
+into account the different variety of combinations.
+
+120
+00:10:20,000 --> 00:10:25,000
+I tried to specify different examples to highlight different cases.
+
+121
+00:10:25,000 --> 00:10:32,000
+I'm sure you will find these examples useful when you will need to come up with your own expression
+
+122
+00:10:32,000 --> 00:10:33,000
+at work.
+
+123
+00:10:33,000 --> 00:10:39,000
+Once you looked through the examples, you're welcome to press play button to continue.
+
+124
+00:10:40,000 --> 00:10:47,000
+That was a lot of examples and I'm sure they are super helpful because next time when you will think
+
+125
+00:10:47,000 --> 00:10:54,000
+about creation of the point card, you can just check these examples and create them according to the
+
+126
+00:10:54,000 --> 00:10:55,000
+pattern.
+
+127
+00:10:56,000 --> 00:11:00,000
+So you saw examples of the point cards on the slide.
+
+128
+00:11:00,000 --> 00:11:05,000
+I believe you have understanding what it is and how to declare a point cut.
+
+129
+00:11:05,000 --> 00:11:11,000
+Now, I want to you understand the mechanics and how to use point cut in the application.
+
+130
+00:11:12,000 --> 00:11:18,000
+I believe there is no need for me to create all possible combinations of point cuts because we reviewed
+
+131
+00:11:18,000 --> 00:11:21,000
+different examples already on the slides.
+
+132
+00:11:21,000 --> 00:11:27,000
+So here in the application I'm going to have two point cuts, ones that we have already created.
+
+133
+00:11:27,000 --> 00:11:32,000
+It is for all masses execution from the current package.
+
+134
+00:11:32,000 --> 00:11:40,000
+And here's one more like you have seen already on the example, this type of point cut designators that
+
+135
+00:11:40,000 --> 00:11:42,000
+can be used only in spring AOP.
+
+136
+00:11:43,000 --> 00:11:46,000
+It is designator called beam.
+
+137
+00:11:46,000 --> 00:11:51,000
+You can limit the matching of join points to a particular spring bin.
+
+138
+00:11:51,000 --> 00:11:56,000
+Here on the screen you can see how I created user bin point cut.
+
+139
+00:11:56,000 --> 00:12:01,000
+You can see a right bin and name of my bin user.
+
+140
+00:12:01,000 --> 00:12:04,000
+I'm going to show you advice demo with this point.
+
+141
+00:12:04,000 --> 00:12:05,000
+Cut to.
+
+142
+00:12:06,000 --> 00:12:07,000
+Amazing.
+
+143
+00:12:07,000 --> 00:12:14,000
+Now we reviewed how to declare a pointcut and what syntax we can use to declare a pointcut.
+
+144
+00:12:14,000 --> 00:12:17,000
+Now it is time to learn how to declare advices.
+
+145
+00:12:17,000 --> 00:12:20,000
+As you remember, we have five types of advices.
+
+146
+00:12:20,000 --> 00:12:22,000
+Let's remember them.
+
+147
+00:12:22,000 --> 00:12:25,000
+We learned them in our previous theoretical lesson.
+
+148
+00:12:25,000 --> 00:12:36,000
+They are before advice, after returning, advice after throwing advice after finally advice and round
+
+149
+00:12:36,000 --> 00:12:36,000
+advice.
+
+150
+00:12:37,000 --> 00:12:40,000
+Let's configure advices of each type here.
+
+151
+00:12:40,000 --> 00:12:42,000
+Let's go one by one.
+
+152
+00:12:43,000 --> 00:12:45,000
+Before advice.
+
+153
+00:12:45,000 --> 00:12:53,000
+Advice that executes before a join point, but which doesn't have the ability to prevent execution flow
+
+154
+00:12:53,000 --> 00:12:58,000
+proceeding to the join point unless it throws an exception.
+
+155
+00:12:59,000 --> 00:13:03,000
+You can see that I declared before advice for the select all point cut.
+
+156
+00:13:03,000 --> 00:13:11,000
+So this code will be applied, whereas the point cut expression from the select all point cut will match.
+
+157
+00:13:11,000 --> 00:13:13,000
+Is that clear?
+
+158
+00:13:13,000 --> 00:13:16,000
+And also for the sake of the demo I created.
+
+159
+00:13:16,000 --> 00:13:23,000
+One more advice for the user being point cut just to show you that everything will work as expected
+
+160
+00:13:23,000 --> 00:13:25,000
+for another point, cut to.
+
+161
+00:13:26,000 --> 00:13:30,000
+The next advice here is after returning advice.
+
+162
+00:13:30,000 --> 00:13:36,000
+After returning the device to be executed after join point completes normally.
+
+163
+00:13:37,000 --> 00:13:44,000
+For example, if a message returns without throwing an exception in case we want to get access to the
+
+164
+00:13:44,000 --> 00:13:50,000
+returned value and work with it, somehow you just declare, return an attribute and declare a message
+
+165
+00:13:50,000 --> 00:13:51,000
+parameter.
+
+166
+00:13:52,000 --> 00:13:56,000
+Return value will be injected into this local variable.
+
+167
+00:13:56,000 --> 00:14:02,000
+In our particular case, I would just print it to console to show you how it works.
+
+168
+00:14:03,000 --> 00:14:10,000
+I believe that it is clear and sounds logical that the name used in the return attribute must correspond
+
+169
+00:14:10,000 --> 00:14:13,000
+to the name of a parameter in the advice method.
+
+170
+00:14:15,000 --> 00:14:22,000
+And returning clause also restricts matching to only those method executions that return a value of
+
+171
+00:14:22,000 --> 00:14:28,000
+the specified type object in this case, which will match any return value.
+
+172
+00:14:29,000 --> 00:14:35,000
+Please note that it is not possible to return a totally different reference when using after returning
+
+173
+00:14:35,000 --> 00:14:36,000
+advice.
+
+174
+00:14:36,000 --> 00:14:38,000
+Okay, let's move on.
+
+175
+00:14:39,000 --> 00:14:48,000
+After throwing advice, this advice to be executed if a method exits by throwing an exception in the
+
+176
+00:14:48,000 --> 00:14:49,000
+similar way.
+
+177
+00:14:49,000 --> 00:14:54,000
+In case you want to get access to the exception thrown, you need to declare this in the annotation
+
+178
+00:14:54,000 --> 00:15:02,000
+configuration where throwing attribute and declare a method parameter with the same name as thrown clause
+
+179
+00:15:02,000 --> 00:15:10,000
+also restricts matching to only those method executions that throw an exception of the specified type.
+
+180
+00:15:11,000 --> 00:15:13,000
+Exception in our specific case.
+
+181
+00:15:14,000 --> 00:15:19,000
+The next type of advice is after finally advice.
+
+182
+00:15:20,000 --> 00:15:28,000
+After finally advice to be executed regardless of the means by which a join point exits normal or exceptional
+
+183
+00:15:28,000 --> 00:15:35,000
+return, we are going just to print text into the console in order to indicate that this advice has
+
+184
+00:15:35,000 --> 00:15:36,000
+been executed.
+
+185
+00:15:37,000 --> 00:15:43,000
+And the last but not the least advice type example here is around advice.
+
+186
+00:15:43,000 --> 00:15:49,000
+Around advice surrounds a joint point such as method invocation.
+
+187
+00:15:49,000 --> 00:15:53,000
+This is the most powerful kind of advice around.
+
+188
+00:15:53,000 --> 00:15:58,000
+Advice can perform custom behavior before and after the method invocation.
+
+189
+00:15:58,000 --> 00:16:05,000
+It is also responsible for choosing whether to proceed to the join point or to shortcut the advice method
+
+190
+00:16:05,000 --> 00:16:10,000
+execution by returning its own return value or throwing an exception.
+
+191
+00:16:11,000 --> 00:16:18,000
+So when it is recommended to use around advice, around advice is often used if you need to share state
+
+192
+00:16:18,000 --> 00:16:27,000
+before and after method execution in a thread safe manner, starting and stopping a timer, for example,
+
+193
+00:16:27,000 --> 00:16:33,000
+always use the least powerful form of advice that meets your requirements.
+
+194
+00:16:33,000 --> 00:16:41,000
+That means that it is not recommended to use a rounded voice if simple before advice is enough for your
+
+195
+00:16:41,000 --> 00:16:42,000
+specific case.
+
+196
+00:16:43,000 --> 00:16:46,000
+A rounded voice is declared using the round annotation.
+
+197
+00:16:47,000 --> 00:16:52,000
+The first parameter of the advice method must be of type preceding joint point.
+
+198
+00:16:53,000 --> 00:17:00,000
+Within the body of that voice, colon precede on the preceding joint point causes the underlying method
+
+199
+00:17:00,000 --> 00:17:02,000
+to execute.
+
+200
+00:17:02,000 --> 00:17:07,000
+The proceed mascot may also be called passing in an object array.
+
+201
+00:17:07,000 --> 00:17:13,000
+The values in the array will be used as the arguments to the method execution when it proceeds.
+
+202
+00:17:14,000 --> 00:17:20,000
+Pay attention that I'm responsible for method invocation and returning the returned value of the method.
+
+203
+00:17:21,000 --> 00:17:23,000
+Also potential is invoked.
+
+204
+00:17:23,000 --> 00:17:25,000
+Method may throw exception.
+
+205
+00:17:25,000 --> 00:17:31,000
+That's why we need either to declare a throws declaration or to handle the potential exception.
+
+206
+00:17:32,000 --> 00:17:40,000
+For the sake of the demo, I will print console output before calling the method from advice and after
+
+207
+00:17:40,000 --> 00:17:42,000
+we called method from advice.
+
+208
+00:17:43,000 --> 00:17:44,000
+That's it.
+
+209
+00:17:44,000 --> 00:17:46,000
+We're getting configuration of advices.
+
+210
+00:17:46,000 --> 00:17:51,000
+Just one minor thing to do and we are ready for running our application.
+
+211
+00:17:51,000 --> 00:17:56,000
+Another important point is to enable aspect support.
+
+212
+00:17:57,000 --> 00:17:58,000
+The use aspect.
+
+213
+00:17:58,000 --> 00:18:06,000
+Aspects In a spring configuration you need to enable spring support for configuring spring AOP based
+
+214
+00:18:06,000 --> 00:18:16,000
+on aspect aspects and auto production beans based on whether or not they are advised by those aspects.
+
+215
+00:18:16,000 --> 00:18:25,000
+By auto proxy, I mean that if spring determines that a bean is advised by one or more aspects, it
+
+216
+00:18:25,000 --> 00:18:33,000
+will automatically generate a proxy for that bean to intercept method invocations and ensure that advice
+
+217
+00:18:33,000 --> 00:18:35,000
+is executed as needed.
+
+218
+00:18:35,000 --> 00:18:41,000
+You can enable it with an XML configuration or with a special annotation.
+
+219
+00:18:41,000 --> 00:18:42,000
+Let me show it to you.
+
+220
+00:18:43,000 --> 00:18:51,000
+Here I have demo a class where I have main method to demo all the examples that we have reviewed, but
+
+221
+00:18:51,000 --> 00:18:54,000
+also this class serves as a configuration.
+
+222
+00:18:54,000 --> 00:18:59,000
+You can see that I added enable aspect auto proxy annotation.
+
+223
+00:18:59,000 --> 00:19:08,000
+That's enough in order to make spring auto detect aspect annotations and configuration and to make proxies
+
+224
+00:19:08,000 --> 00:19:11,000
+when needed to intercept method invocations.
+
+225
+00:19:12,000 --> 00:19:16,000
+And now we are completely fine to run our example.
+
+226
+00:19:16,000 --> 00:19:18,000
+Let's take a look at main method.
+
+227
+00:19:19,000 --> 00:19:22,000
+I create annotation config application context.
+
+228
+00:19:23,000 --> 00:19:26,000
+I scan package with our ALP examples.
+
+229
+00:19:26,000 --> 00:19:35,000
+I extract user bin and in order to show you all type of advices I am going to invoke method that doesn't
+
+230
+00:19:35,000 --> 00:19:36,000
+throw any exception.
+
+231
+00:19:36,000 --> 00:19:44,000
+And then I will call one method that deliberately throws exception in order to demo you all kind of
+
+232
+00:19:44,000 --> 00:19:45,000
+advices configure it.
+
+233
+00:19:46,000 --> 00:19:47,000
+That's it.
+
+234
+00:19:47,000 --> 00:19:52,000
+Let me run the program and explore the console output together with you.
+
+235
+00:19:53,000 --> 00:19:58,000
+At the beginning you can see that we entered rounded voice before calling method.
+
+236
+00:19:59,000 --> 00:20:02,000
+After that we have to before advices.
+
+237
+00:20:02,000 --> 00:20:09,000
+If you remember, we created before advice for select all pointcut and one before advice for the user
+
+238
+00:20:09,000 --> 00:20:10,000
+being pointcut.
+
+239
+00:20:11,000 --> 00:20:18,000
+Then we have after returning advice and we print returned values that we got inside the advice.
+
+240
+00:20:18,000 --> 00:20:22,000
+Here is the first name of configure it user bin.
+
+241
+00:20:22,000 --> 00:20:26,000
+After that, after finally advice worked.
+
+242
+00:20:26,000 --> 00:20:32,000
+And only after that we can say that we are about to leave our around advice.
+
+243
+00:20:32,000 --> 00:20:37,000
+That's why we can see console output from around advice here.
+
+244
+00:20:38,000 --> 00:20:42,000
+Then I actually print returned first name to console.
+
+245
+00:20:42,000 --> 00:20:43,000
+That's it.
+
+246
+00:20:44,000 --> 00:20:50,000
+Now we have the second method demo in the similar way you can see first console output from the round
+
+247
+00:20:50,000 --> 00:20:55,000
+advice and then we see console output from two before advices.
+
+248
+00:20:56,000 --> 00:21:04,000
+Then we don't see after returning advice because method didn't finish execution properly and exception
+
+249
+00:21:04,000 --> 00:21:05,000
+was thrown.
+
+250
+00:21:06,000 --> 00:21:10,000
+I see the console output from the method that exception has been thrown.
+
+251
+00:21:10,000 --> 00:21:18,000
+Then I entered after throwing advice and I print the class of the exception to console because I got
+
+252
+00:21:18,000 --> 00:21:26,000
+access to it inside the advice and then I see console output from the after finally advice and stack
+
+253
+00:21:26,000 --> 00:21:28,000
+trace of exception.
+
+254
+00:21:29,000 --> 00:21:35,000
+Pay attention that you can't see the last console output from the rounded device because during the
+
+255
+00:21:35,000 --> 00:21:38,000
+method execution exception was thrown.
+
+256
+00:21:38,000 --> 00:21:40,000
+And team please.
+
+257
+00:21:40,000 --> 00:21:46,000
+Even in case something is not clear, let me know and I will be happy to help you.
+
+258
+00:21:46,000 --> 00:21:47,000
+Amazing.
+
+259
+00:21:47,000 --> 00:21:48,000
+That's how it works.
+
+260
+00:21:48,000 --> 00:21:51,000
+And that's all what I wanted to share with you.
+
+261
+00:21:51,000 --> 00:21:54,000
+Let's recap what we have learned today.
+
+262
+00:21:55,000 --> 00:21:58,000
+We learned on practice.
+
+263
+00:21:58,000 --> 00:22:03,000
+Now you know how to create aspect, how to configure pointcuts and advices.
+
+264
+00:22:04,000 --> 00:22:07,000
+We learned different pointcut designators.
+
+265
+00:22:07,000 --> 00:22:13,000
+You saw how to activate spring AOP support of aspect annotations.
+
+266
+00:22:13,000 --> 00:22:16,000
+And we reviewed live code examples.
+
+267
+00:22:17,000 --> 00:22:19,000
+That's all what I wanted to share with you today.
+
+268
+00:22:19,000 --> 00:22:21,000
+Thanks a lot for your attention.
+
+269
+00:22:21,000 --> 00:22:24,000
+Have a great day and see you in the next lesson.
+

90 - Spring AOP/external-links.txt

@@ -0,0 +1,3 @@
+
+002 Source-code-of-examples-commit-with-changes-
+https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/ab0084445a16c0c8897cc80308c28817d9dace8a

91 - REST Architecture/001 REST Architecture Overview and Key Principles_en.srt

@@ -0,0 +1,1012 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, team.
+
+2
+00:00:06,000 --> 00:00:09,000
+Today we start learning interesting and important topic.
+
+3
+00:00:09,000 --> 00:00:12,000
+We're going to learn rest architecture.
+
+4
+00:00:13,000 --> 00:00:19,000
+This is going to be theoretical lesson, but it is important to understand concepts that we are going
+
+5
+00:00:19,000 --> 00:00:26,000
+to use in the following practical lessons where we are going to learn different ways of how we can implement
+
+6
+00:00:26,000 --> 00:00:28,000
+rest architecture in the application.
+
+7
+00:00:29,000 --> 00:00:35,000
+We'll start the video from the understanding such definitions as Rest and Rest API.
+
+8
+00:00:36,000 --> 00:00:41,000
+After that, we are going to talk about key principles of rest architectural style.
+
+9
+00:00:41,000 --> 00:00:45,000
+These principles distinguish rest approach uniquely.
+
+10
+00:00:45,000 --> 00:00:51,000
+Namely, we are going to talk about client server communication, stateless communication caching,
+
+11
+00:00:51,000 --> 00:00:55,000
+uniform interface, layered system code on demand.
+
+12
+00:00:56,000 --> 00:01:02,000
+After that, I'm going to explain the concept of the resource in rest and resource methods.
+
+13
+00:01:03,000 --> 00:01:09,000
+And at the end of the lesson, I'm going to compare rest with HTTP because a lot of people use these
+
+14
+00:01:09,000 --> 00:01:16,000
+two terms interchangeably, but actually they are different and we are going to understand why.
+
+15
+00:01:17,000 --> 00:01:19,000
+Let's start our lesson.
+
+16
+00:01:19,000 --> 00:01:21,000
+Let's start with definition.
+
+17
+00:01:21,000 --> 00:01:24,000
+So what is rest?
+
+18
+00:01:25,000 --> 00:01:29,000
+Rest stands for representational state transfer.
+
+19
+00:01:29,000 --> 00:01:34,000
+It is an architectural style for distributed hypermedia systems.
+
+20
+00:01:34,000 --> 00:01:37,000
+It was presented the first time in the 2000.
+
+21
+00:01:38,000 --> 00:01:44,000
+It was established with the goal of improving performance, scalability and simplicity by enforcing
+
+22
+00:01:44,000 --> 00:01:47,000
+specific limits on an API.
+
+23
+00:01:47,000 --> 00:01:55,000
+It has gained popularity because of the opportunity to cover various devices and applications in rest
+
+24
+00:01:55,000 --> 00:01:56,000
+architecture.
+
+25
+00:01:56,000 --> 00:02:04,000
+A rest server simply provides access to resources and rest client accesses and modifies the resources.
+
+26
+00:02:04,000 --> 00:02:05,000
+Here.
+
+27
+00:02:05,000 --> 00:02:10,000
+Each resource is identified by Uri's global IDs.
+
+28
+00:02:10,000 --> 00:02:17,000
+Rest uses various representation to represent a resource like text JSON.
+
+29
+00:02:17,000 --> 00:02:18,000
+XML.
+
+30
+00:02:18,000 --> 00:02:20,000
+JSON is the most popular one.
+
+31
+00:02:21,000 --> 00:02:26,000
+A web API or API of a web service that is conforming to the rest.
+
+32
+00:02:26,000 --> 00:02:30,000
+Architectural style is called Rest API.
+
+33
+00:02:31,000 --> 00:02:38,000
+These Web services utilize a stateless protocol to make textual representations of their online resources
+
+34
+00:02:38,000 --> 00:02:41,000
+available for reading and processing.
+
+35
+00:02:42,000 --> 00:02:48,000
+A client performs well known HTTP protocol based activities like Fetch, Update and delete.
+
+36
+00:02:49,000 --> 00:02:57,000
+And similar to other architectural styles and patterns, Rest has its own guiding principles and constraints.
+
+37
+00:02:57,000 --> 00:03:04,000
+These principles must be satisfied if a service interface needs to be referred as restful.
+
+38
+00:03:04,000 --> 00:03:12,000
+Let's now review key rest principles guidelines of how they're also called in other sources.
+
+39
+00:03:12,000 --> 00:03:13,000
+Constraints.
+
+40
+00:03:13,000 --> 00:03:22,000
+They are client server communication, stateless communication caching Uniform interface layer system
+
+41
+00:03:22,000 --> 00:03:24,000
+code on demand.
+
+42
+00:03:24,000 --> 00:03:26,000
+Let's review them one by one.
+
+43
+00:03:27,000 --> 00:03:32,000
+The first rest principle is about client server separation.
+
+44
+00:03:32,000 --> 00:03:39,000
+The client server design pattern enforces the separation of concerns, which helps the client and the
+
+45
+00:03:39,000 --> 00:03:42,000
+server components evolve independently.
+
+46
+00:03:42,000 --> 00:03:45,000
+What does it mean for the rest architecture?
+
+47
+00:03:45,000 --> 00:03:52,000
+This means that according to rest architectural approach, client and server can be developed independently
+
+48
+00:03:52,000 --> 00:03:54,000
+and don't have to know about each other.
+
+49
+00:03:55,000 --> 00:04:00,000
+The server side shouldn't affect the way how client is implemented.
+
+50
+00:04:00,000 --> 00:04:06,000
+The server should just provide the API to send the essential data when requested.
+
+51
+00:04:06,000 --> 00:04:09,000
+This also gives us another advantage.
+
+52
+00:04:09,000 --> 00:04:16,000
+You can change client without changing the server side and changing the server side shouldn't impact
+
+53
+00:04:16,000 --> 00:04:17,000
+the client side.
+
+54
+00:04:18,000 --> 00:04:27,000
+By separating the user interface concerns client from the data storage concerns server side, we improve
+
+55
+00:04:27,000 --> 00:04:33,000
+the portability of the user interface across multiple platforms and improves scalability by simplifying
+
+56
+00:04:33,000 --> 00:04:35,000
+the server components.
+
+57
+00:04:36,000 --> 00:04:40,000
+The next rest principle can be called as stateless communication.
+
+58
+00:04:40,000 --> 00:04:48,000
+Statelessness mandates that each request from the client to the server must contain all of the information
+
+59
+00:04:48,000 --> 00:04:51,000
+necessary to understand and complete the request.
+
+60
+00:04:52,000 --> 00:04:55,000
+Rest based systems are stateless.
+
+61
+00:04:55,000 --> 00:05:01,000
+This means that the client state remains unknown to the server and vice versa.
+
+62
+00:05:01,000 --> 00:05:09,000
+This constraint allows the server and the client to understand any sent message, even if they haven't
+
+63
+00:05:09,000 --> 00:05:11,000
+seen the preceding ones.
+
+64
+00:05:11,000 --> 00:05:18,000
+The server can't take advantage of any previously stored context information on the server.
+
+65
+00:05:19,000 --> 00:05:24,000
+For this reason, the session state should be entirely stored on the client side.
+
+66
+00:05:25,000 --> 00:05:26,000
+Let's move on.
+
+67
+00:05:27,000 --> 00:05:35,000
+Now let's talk about such constraint of rest architecture as caching or like it also called cacheable
+
+68
+00:05:35,000 --> 00:05:36,000
+data.
+
+69
+00:05:37,000 --> 00:05:44,000
+The cacheable constraint requires that the response should implicitly or explicitly label itself as
+
+70
+00:05:44,000 --> 00:05:47,000
+cacheable or non-cacheable.
+
+71
+00:05:47,000 --> 00:05:54,000
+Data and response caching are critical in today's world because it results in better client side performance.
+
+72
+00:05:55,000 --> 00:05:57,000
+Why it is so important.
+
+73
+00:05:57,000 --> 00:06:03,000
+Because caching is one of the ways to improve performance and performance is one of the key goals of
+
+74
+00:06:03,000 --> 00:06:05,000
+rest architecture.
+
+75
+00:06:05,000 --> 00:06:11,000
+Basically, this is logical why you should send new request to fetch the data.
+
+76
+00:06:11,000 --> 00:06:17,000
+If it's state not changed and it is cached already on the client side.
+
+77
+00:06:17,000 --> 00:06:25,000
+This increases performance if the response is cacheable the client application gets the right to reuse
+
+78
+00:06:25,000 --> 00:06:28,000
+the response data later for equivalent requests.
+
+79
+00:06:29,000 --> 00:06:37,000
+It also gives a server more scalability options due to the smaller burden on the server by using HTTP
+
+80
+00:06:37,000 --> 00:06:45,000
+headers and origin server indicates whether response can be cached and if so, for how long.
+
+81
+00:06:45,000 --> 00:06:50,000
+Optimizes the network using cache and improves the overall quality of service.
+
+82
+00:06:50,000 --> 00:06:52,000
+In the following ways.
+
+83
+00:06:52,000 --> 00:06:53,000
+Reduce bandwidth.
+
+84
+00:06:53,000 --> 00:06:55,000
+Reduce latency.
+
+85
+00:06:55,000 --> 00:06:57,000
+Reduce load on servers.
+
+86
+00:06:57,000 --> 00:06:59,000
+Hide network Failures.
+
+87
+00:06:59,000 --> 00:07:07,000
+Talking about recommendations, it is worth to mention get requests should be cacheable by default until
+
+88
+00:07:07,000 --> 00:07:10,000
+a special condition arises.
+
+89
+00:07:10,000 --> 00:07:14,000
+Usually browsers treat all get requests as cacheable.
+
+90
+00:07:15,000 --> 00:07:23,000
+Post requests are not cacheable by default, but can be made cacheable if is an express header or a
+
+91
+00:07:23,000 --> 00:07:30,000
+cache control header with a directive to explicitly allows, caching is added to the response.
+
+92
+00:07:30,000 --> 00:07:34,000
+Responses to put and delete requests are not cacheable at all.
+
+93
+00:07:35,000 --> 00:07:43,000
+The uniform interface constraint that any restful architecture should comply with actually means that,
+
+94
+00:07:43,000 --> 00:07:49,000
+along with the data server responses, should also announce available actions and resources.
+
+95
+00:07:50,000 --> 00:07:57,000
+In other words, querying resources should allow the client to request other actions and resources without
+
+96
+00:07:57,000 --> 00:07:59,000
+knowing them in advance.
+
+97
+00:07:59,000 --> 00:08:02,000
+Let's look at the example of response.
+
+98
+00:08:02,000 --> 00:08:08,000
+You can see it on the slide just by analyzing the single response.
+
+99
+00:08:08,000 --> 00:08:12,000
+A client knows what entities were queried.
+
+100
+00:08:12,000 --> 00:08:14,000
+Articles in this example.
+
+101
+00:08:14,000 --> 00:08:17,000
+How are these entities are structured?
+
+102
+00:08:17,000 --> 00:08:25,000
+Articles have fields ID title author commands how to retrieve related entities.
+
+103
+00:08:25,000 --> 00:08:35,000
+For example, the author and the comments that there are more entities of type articles than based on
+
+104
+00:08:35,000 --> 00:08:38,000
+the current response length and pagination links.
+
+105
+00:08:39,000 --> 00:08:47,000
+Using interfaces to decouple classes from the implementation of their dependencies is a pretty old concept
+
+106
+00:08:47,000 --> 00:08:48,000
+in rust.
+
+107
+00:08:48,000 --> 00:08:55,000
+You use the same concept to decouple the client from the implementation of the rest service in order
+
+108
+00:08:55,000 --> 00:09:00,000
+to define such an interface, a contract between the client and the service.
+
+109
+00:09:00,000 --> 00:09:02,000
+You have to use standards.
+
+110
+00:09:02,000 --> 00:09:10,000
+This is because if you want an internet size network of rest services, you have to enforce global concepts
+
+111
+00:09:10,000 --> 00:09:14,000
+like standards to make them understand each other.
+
+112
+00:09:14,000 --> 00:09:21,000
+By applying the principle of generality to the components interface, we can simplify the overall system
+
+113
+00:09:21,000 --> 00:09:25,000
+architecture and improve the visibility of interactions.
+
+114
+00:09:25,000 --> 00:09:32,000
+Multiple architectural constraints help in obtaining a uniform interface and guiding the behavior of
+
+115
+00:09:32,000 --> 00:09:33,000
+components.
+
+116
+00:09:33,000 --> 00:09:38,000
+The following four constraints can achieve a uniform rest interface.
+
+117
+00:09:39,000 --> 00:09:42,000
+The first one an amplification of resources.
+
+118
+00:09:42,000 --> 00:09:47,000
+You use the UI standard to identify a resource.
+
+119
+00:09:47,000 --> 00:09:54,000
+The interface must uniquely identify each resource involved in the interaction between the client and
+
+120
+00:09:54,000 --> 00:09:54,000
+the server.
+
+121
+00:09:55,000 --> 00:10:01,000
+The second constraint Manipulation of resources through representations.
+
+122
+00:10:01,000 --> 00:10:05,000
+You use the HTTP standard to describe communication.
+
+123
+00:10:05,000 --> 00:10:13,000
+So for example, get means that you want to retrieve data about the UI identified resource.
+
+124
+00:10:13,000 --> 00:10:18,000
+You can describe an operation with an HTTP method and the URI.
+
+125
+00:10:19,000 --> 00:10:23,000
+The third constraint Self-descriptive messages.
+
+126
+00:10:23,000 --> 00:10:30,000
+Each resource representation should carry enough information to describe how to process the message.
+
+127
+00:10:30,000 --> 00:10:37,000
+It should also provide information of the additional actions that the client can perform on the resource.
+
+128
+00:10:37,000 --> 00:10:47,000
+You use standard meme types and standard RDF vocabulary to make messages self-descriptive so the client
+
+129
+00:10:47,000 --> 00:10:53,000
+can find the data by checking the semantics and it doesn't have to know the application specific data
+
+130
+00:10:53,000 --> 00:10:54,000
+structure.
+
+131
+00:10:54,000 --> 00:10:56,000
+This service uses.
+
+132
+00:10:57,000 --> 00:11:01,000
+I used here the term RDF vocabulary.
+
+133
+00:11:01,000 --> 00:11:03,000
+Let me explain you what it is.
+
+134
+00:11:04,000 --> 00:11:08,000
+RDF stands for the Resource Description Framework.
+
+135
+00:11:08,000 --> 00:11:15,000
+It is a world wide Web consortium standard originally designed as a data model for metadata.
+
+136
+00:11:15,000 --> 00:11:23,000
+It has come to be used as a general method for description and exchange of graph data.
+
+137
+00:11:23,000 --> 00:11:31,000
+RDF provides a variety of syntax, notations and data serialization formats that you potentially may
+
+138
+00:11:31,000 --> 00:11:35,000
+reuse while designing your rest services.
+
+139
+00:11:36,000 --> 00:11:37,000
+Don't worry about formats.
+
+140
+00:11:37,000 --> 00:11:43,000
+We are going to have practical examples and lessons full of practical exercises where we will build
+
+141
+00:11:43,000 --> 00:11:47,000
+our rest services and I will show you how it works.
+
+142
+00:11:47,000 --> 00:11:50,000
+And the force constraint.
+
+143
+00:11:50,000 --> 00:11:59,000
+Hypermedia as the engine of application state, also known as Hateoas, you use hyperlinks and possibly
+
+144
+00:11:59,000 --> 00:12:05,000
+you write templates to decouple the client from the application specific structure.
+
+145
+00:12:05,000 --> 00:12:11,000
+You can annotate these hyperlinks so the client will understand what they mean.
+
+146
+00:12:12,000 --> 00:12:16,000
+The client should have only the initial UI of the application.
+
+147
+00:12:17,000 --> 00:12:25,000
+The client application should dynamically drive all other resources and interactions with use of hyperlinks.
+
+148
+00:12:26,000 --> 00:12:34,000
+Uniform interface Rest Architectural constraint is not the one the easiest to understand, but the one
+
+149
+00:12:34,000 --> 00:12:35,000
+which is also important.
+
+150
+00:12:36,000 --> 00:12:42,000
+Remember that in case you have any questions, you can always ask your questions below the video and
+
+151
+00:12:42,000 --> 00:12:44,000
+I will be happy to answer.
+
+152
+00:12:44,000 --> 00:12:46,000
+Let's continue.
+
+153
+00:12:47,000 --> 00:12:48,000
+The next rest.
+
+154
+00:12:48,000 --> 00:12:51,000
+Architectural constraint is called layered system.
+
+155
+00:12:52,000 --> 00:12:58,000
+If you remember previously in the course we had a lesson that is called layered architecture.
+
+156
+00:12:58,000 --> 00:13:05,000
+It is kind of similar thing that I'm going to explain you now and also in my course, Java from zero
+
+157
+00:13:05,000 --> 00:13:11,000
+to first job together with my students, we implemented online shop according to the layered architecture
+
+158
+00:13:11,000 --> 00:13:13,000
+design pattern.
+
+159
+00:13:13,000 --> 00:13:20,000
+The key concept in the layered system is that each layer has specific function and code is structured
+
+160
+00:13:20,000 --> 00:13:28,000
+accordingly and separated logically between layers according to the rest architectural approach.
+
+161
+00:13:28,000 --> 00:13:36,000
+Layered system term has slightly different shape and form, but the concept is the same to divide responsibilities
+
+162
+00:13:36,000 --> 00:13:41,000
+between modules that are located in different logical layers.
+
+163
+00:13:41,000 --> 00:13:50,000
+If you remember when we learned layered architecture, I highlighted that in layered system, each component
+
+164
+00:13:50,000 --> 00:13:55,000
+can't see beyond the immediate layer they're interacting with.
+
+165
+00:13:56,000 --> 00:14:04,000
+That means that changes in one layer theoretically may impact only the nearest level, but not impacting
+
+166
+00:14:04,000 --> 00:14:06,000
+the whole graph of layers.
+
+167
+00:14:07,000 --> 00:14:13,000
+The rest API layers have their responsibilities and come in hierarchical order.
+
+168
+00:14:13,000 --> 00:14:18,000
+For example, one layer may be responsible for storing data on the server.
+
+169
+00:14:19,000 --> 00:14:26,000
+The second for deploying the APIs on another server and the third for authenticating requests in another
+
+170
+00:14:26,000 --> 00:14:27,000
+server.
+
+171
+00:14:27,000 --> 00:14:34,000
+All layers act as mediators between the client and applications deployed on the server side.
+
+172
+00:14:35,000 --> 00:14:43,000
+In this way we prevent direct interaction between the client and server side applications and as a result,
+
+173
+00:14:43,000 --> 00:14:46,000
+a client doesn't know which server.
+
+174
+00:14:46,000 --> 00:14:48,000
+A component is a address.
+
+175
+00:14:48,000 --> 00:14:54,000
+And the most important thing they don't want to know and don't need to know.
+
+176
+00:14:55,000 --> 00:15:01,000
+This gives us different advantages, namely, it improves the APIs overall security.
+
+177
+00:15:02,000 --> 00:15:11,000
+Also, it improves flexibility because adding altering or removing APIs on other levels shouldn't impact
+
+178
+00:15:11,000 --> 00:15:16,000
+the key components that are in charge of interaction with client.
+
+179
+00:15:17,000 --> 00:15:20,000
+The next constraint is called code on demand.
+
+180
+00:15:21,000 --> 00:15:29,000
+Rest also allows client functionality to extend by downloading and executing code in the form of applets
+
+181
+00:15:29,000 --> 00:15:30,000
+or scripts.
+
+182
+00:15:31,000 --> 00:15:39,000
+The downloaded code simplifies clients by reducing the number of features required to be implemented.
+
+183
+00:15:39,000 --> 00:15:46,000
+Servers can provide part of features delivered to the client in the form of code, and the client only
+
+184
+00:15:46,000 --> 00:15:48,000
+needs to execute the code.
+
+185
+00:15:48,000 --> 00:15:56,000
+Rest Architectural style allows users to download and run code in the form of Java applets or scripts
+
+186
+00:15:56,000 --> 00:15:58,000
+such as JavaScript.
+
+187
+00:15:58,000 --> 00:16:05,000
+I wouldn't say that Java applets are popular and working nowadays at all, but with regard to JavaScript,
+
+188
+00:16:05,000 --> 00:16:07,000
+this can be relevant.
+
+189
+00:16:07,000 --> 00:16:14,000
+For example, clients can retrieve the rendering code for UI widgets by calling your API.
+
+190
+00:16:15,000 --> 00:16:22,000
+But still, the most common scenario of using rest APIs is to deliver static resource representations
+
+191
+00:16:22,000 --> 00:16:24,000
+in XML or JSON.
+
+192
+00:16:25,000 --> 00:16:31,000
+It also worth to mention that the key concept in the rest architecture is the concept of resource.
+
+193
+00:16:31,000 --> 00:16:36,000
+The key abstraction of information in rest is a resource.
+
+194
+00:16:36,000 --> 00:16:39,000
+An information that we can name can be a resource.
+
+195
+00:16:40,000 --> 00:16:47,000
+For example, a rest resource can be a document or image, a temporal service, a collection of other
+
+196
+00:16:47,000 --> 00:16:48,000
+resources.
+
+197
+00:16:49,000 --> 00:16:54,000
+A rest API consists of an assembly of interlinked resources.
+
+198
+00:16:55,000 --> 00:17:00,000
+This set of resources is known as the Rest APIs Resource model.
+
+199
+00:17:01,000 --> 00:17:07,000
+Another important thing to understand in the rest terminology is resource masses.
+
+200
+00:17:07,000 --> 00:17:14,000
+These are masses that are used to perform the desired transition between two states of any resource.
+
+201
+00:17:14,000 --> 00:17:21,000
+There is a common misunderstanding that HTTP methods and rest masses are the same thing.
+
+202
+00:17:21,000 --> 00:17:23,000
+No, they are not.
+
+203
+00:17:23,000 --> 00:17:33,000
+For example, rest dictates the usage of delete to erase a document, be it a file state etcetera behind
+
+204
+00:17:33,000 --> 00:17:34,000
+the URI.
+
+205
+00:17:34,000 --> 00:17:45,000
+Whereas with HTTP you would misuse probably a get or post query like this product and post with a parameter
+
+206
+00:17:45,000 --> 00:17:46,000
+delete ID.
+
+207
+00:17:47,000 --> 00:17:56,000
+Another example is if we decide that application APIs will use HTTP post for updating a resource rather
+
+208
+00:17:56,000 --> 00:17:59,000
+than most people recommend http put.
+
+209
+00:17:59,000 --> 00:17:59,000
+It's all.
+
+210
+00:18:00,000 --> 00:18:08,000
+Still, the application interface will be restful, but just an advice to remember taking into account
+
+211
+00:18:08,000 --> 00:18:10,000
+a rest doesn't have a standard.
+
+212
+00:18:11,000 --> 00:18:17,000
+Make sure that everyone working on the product uses the same definition.
+
+213
+00:18:17,000 --> 00:18:21,000
+This should be set by the development lead of your team.
+
+214
+00:18:22,000 --> 00:18:27,000
+So we already started the topic about comparison of rest and HTTP.
+
+215
+00:18:28,000 --> 00:18:32,000
+I would like to highlight that rest is not the same as HTTP.
+
+216
+00:18:33,000 --> 00:18:36,000
+We can say it in the following way.
+
+217
+00:18:36,000 --> 00:18:40,000
+Rest is the way HTTP should be used.
+
+218
+00:18:40,000 --> 00:18:42,000
+Rest is not a standard.
+
+219
+00:18:43,000 --> 00:18:45,000
+It is also not a protocol like HTTP.
+
+220
+00:18:46,000 --> 00:18:48,000
+It is not even a specification.
+
+221
+00:18:48,000 --> 00:18:57,000
+We already learned that rest is just an architectural style approach for distributed hypermedia systems
+
+222
+00:18:57,000 --> 00:19:02,000
+and architectural principles and constraints that we discuss.
+
+223
+00:19:02,000 --> 00:19:10,000
+It may help to create large interconnected systems such as the Internet and make them very efficient
+
+224
+00:19:10,000 --> 00:19:11,000
+with high performance.
+
+225
+00:19:12,000 --> 00:19:16,000
+On the other hand, HTTP is a protocol standard.
+
+226
+00:19:16,000 --> 00:19:19,000
+While it is not the same as rest.
+
+227
+00:19:19,000 --> 00:19:25,000
+It exhibits many features of a restful system in the world of HTTP.
+
+228
+00:19:25,000 --> 00:19:29,000
+Resources are typically files on a remote server.
+
+229
+00:19:30,000 --> 00:19:40,000
+This could be HTML, CSS, JavaScript images and all the other files that comprise modern web pages.
+
+230
+00:19:40,000 --> 00:19:46,000
+Each file is treated as distinct resource that is addressable using a unique URL.
+
+231
+00:19:47,000 --> 00:19:56,000
+One more difference between rest and the HTTP rest is not a communication protocol while HTTP is.
+
+232
+00:19:57,000 --> 00:20:04,000
+And another difference pretty formal one, but still the most modern web servers use cookies and sessions
+
+233
+00:20:04,000 --> 00:20:06,000
+to store state.
+
+234
+00:20:06,000 --> 00:20:13,000
+And as you may already know that using cookies, we get access to the session object that is stored
+
+235
+00:20:13,000 --> 00:20:15,000
+on the server side.
+
+236
+00:20:15,000 --> 00:20:24,000
+And you remember that rest architecture says that client stores the state and the server is stateless.
+
+237
+00:20:24,000 --> 00:20:31,000
+So when we use cookies and sessions on the server side formally, this is not anymore rest style.
+
+238
+00:20:32,000 --> 00:20:36,000
+This is one of the controversial points to think about.
+
+239
+00:20:36,000 --> 00:20:44,000
+So to sum it up, you are going to hear that different people still use such terms as rest and HTTP
+
+240
+00:20:44,000 --> 00:20:46,000
+interchangeably.
+
+241
+00:20:46,000 --> 00:20:50,000
+But as we already discussed, these are different things.
+
+242
+00:20:50,000 --> 00:20:52,000
+And now you know why?
+
+243
+00:20:53,000 --> 00:20:56,000
+That's all what I wanted to share with you in this lesson.
+
+244
+00:20:56,000 --> 00:20:59,000
+Let's recap what we have learned today.
+
+245
+00:21:00,000 --> 00:21:04,000
+Today we learned what rest and rest terms mean.
+
+246
+00:21:05,000 --> 00:21:09,000
+I explained key principles of the rest architectural style.
+
+247
+00:21:09,000 --> 00:21:18,000
+Namely, we talked about client server communication, stateless communication, caching, uniform interface,
+
+248
+00:21:18,000 --> 00:21:21,000
+layered system and code on demand.
+
+249
+00:21:22,000 --> 00:21:27,000
+Also I explained your concept of the resource in the rest architecture.
+
+250
+00:21:27,000 --> 00:21:36,000
+We talked about resource methods and we compared rest with HTTP protocol to understand the difference.
+
+251
+00:21:36,000 --> 00:21:38,000
+That's all for today.
+
+252
+00:21:38,000 --> 00:21:40,000
+Thanks a lot for your attention.
+
+253
+00:21:40,000 --> 00:21:44,000
+Have a great day and see you in the next lesson.
+

91 - REST Architecture/002 Naming Convention for RESTful Services_en.srt

@@ -0,0 +1,820 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, team.
+
+2
+00:00:06,000 --> 00:00:12,000
+In this video we are going to learn important things about naming convention in RESTful services.
+
+3
+00:00:12,000 --> 00:00:17,000
+This is important topic before we started creation of your rest API.
+
+4
+00:00:17,000 --> 00:00:24,000
+We are going to start our lesson from review and understanding of why it is important to follow guidelines
+
+5
+00:00:24,000 --> 00:00:29,000
+and naming convention during the creation of restful service and the rest.
+
+6
+00:00:29,000 --> 00:00:36,000
+Part of the lesson will be dedicated to the discussion of the principles, rules, guidelines, recommendations.
+
+7
+00:00:36,000 --> 00:00:41,000
+They are use nouns to represent resources, not verbs.
+
+8
+00:00:41,000 --> 00:00:50,000
+Use pluralized nouns for resources, use hyphens and lowercase use forward slashes for Iraqi but not
+
+9
+00:00:50,000 --> 00:00:59,000
+trailing forward slash avoid using file extensions API versioning use query parameters punctuation for
+
+10
+00:00:59,000 --> 00:01:05,000
+list intuitive names no jargon no abridging.
+
+11
+00:01:05,000 --> 00:01:11,000
+Avoid using special characters and keep your API consistent.
+
+12
+00:01:11,000 --> 00:01:13,000
+So let's start our lesson.
+
+13
+00:01:14,000 --> 00:01:20,000
+Let's try to understand first why this topic is so important and why I decided to dedicate the whole
+
+14
+00:01:20,000 --> 00:01:22,000
+lesson to this topic.
+
+15
+00:01:22,000 --> 00:01:24,000
+Design of the API.
+
+16
+00:01:24,000 --> 00:01:30,000
+It is super important task because most likely multiple clients and very often multiple generations
+
+17
+00:01:30,000 --> 00:01:33,000
+of other developers and clients are going to use it.
+
+18
+00:01:33,000 --> 00:01:41,000
+And to ensure scalability of your API efficient support, it is better to follow some standards and
+
+19
+00:01:41,000 --> 00:01:44,000
+guidelines during the naming your APIs.
+
+20
+00:01:45,000 --> 00:01:51,000
+This will save us from having additional issues related with misunderstanding and potential errors.
+
+21
+00:01:52,000 --> 00:01:58,000
+Because at the end of the day our API should be intuitive and built in the logical way.
+
+22
+00:01:58,000 --> 00:02:06,000
+Very often I don't even look at the documentation because I assume that in case entity is named in this
+
+23
+00:02:06,000 --> 00:02:13,000
+way, then end point for collection of entities should be available with this name using this rest method.
+
+24
+00:02:14,000 --> 00:02:15,000
+Do you understand my point?
+
+25
+00:02:15,000 --> 00:02:21,000
+Knowing the best practices for naming your restful APIs is particularly important.
+
+26
+00:02:21,000 --> 00:02:28,000
+Using Rest API and naming conventions dramatically lowers the learning curve and makes it easier for
+
+27
+00:02:28,000 --> 00:02:33,000
+new developers and third party users to start with the API.
+
+28
+00:02:33,000 --> 00:02:39,000
+The more people understand how to use the proper methods, the easier it is for everyone.
+
+29
+00:02:39,000 --> 00:02:45,000
+These standards should be required for every UI naming process.
+
+30
+00:02:45,000 --> 00:02:52,000
+That's why I decided to hold this lesson before we started learning the implementation part of the rest
+
+31
+00:02:52,000 --> 00:02:53,000
+Architecture.
+
+32
+00:02:54,000 --> 00:02:59,000
+The Danger lesson we are going to review the most popular and important guidelines is that I strongly
+
+33
+00:02:59,000 --> 00:03:04,000
+recommend you to follow during designing your API and naming endpoints.
+
+34
+00:03:05,000 --> 00:03:11,000
+I've already shared the list of recommendations that we are going to review today during the agenda.
+
+35
+00:03:11,000 --> 00:03:18,000
+So let's just go one by one and the first recommendations that we are going to review sounds like this.
+
+36
+00:03:19,000 --> 00:03:23,000
+Use nouns to represent resources, but not verbs.
+
+37
+00:03:23,000 --> 00:03:32,000
+Basically the resource identifier its UI shouldn't declare any create, read, update or delete operations.
+
+38
+00:03:32,000 --> 00:03:38,000
+You have request methods for that to define what should be done with the resource.
+
+39
+00:03:38,000 --> 00:03:41,000
+Read, create, update or delete.
+
+40
+00:03:41,000 --> 00:03:48,000
+But instead you need to define the noun, the name of the resource that you interact with.
+
+41
+00:03:49,000 --> 00:03:58,000
+RESTful Uris should refer to a resource that is a sink noun instead of referring to an action verb.
+
+42
+00:03:59,000 --> 00:04:03,000
+Because nouns have properties which verbs do not have.
+
+43
+00:04:03,000 --> 00:04:06,000
+Similar to resources have attributes.
+
+44
+00:04:07,000 --> 00:04:10,000
+On the slide you can see good and bad examples.
+
+45
+00:04:10,000 --> 00:04:13,000
+Pay attention also to the delete orders.
+
+46
+00:04:13,000 --> 00:04:14,000
+Uri.
+
+47
+00:04:14,000 --> 00:04:18,000
+It is kind of a verb noun combination.
+
+48
+00:04:18,000 --> 00:04:21,000
+It is also not recommended to do like that.
+
+49
+00:04:22,000 --> 00:04:28,000
+Looking at the good examples, I believe you can agree with me that they are readable and intuitive.
+
+50
+00:04:29,000 --> 00:04:37,000
+Obviously that resource with employees identifier and employee ID requested via get method should read
+
+51
+00:04:37,000 --> 00:04:41,000
+the resource with an ID of specific employee entity.
+
+52
+00:04:42,000 --> 00:04:46,000
+This is simple rule to follow, so just please don't forget it.
+
+53
+00:04:47,000 --> 00:04:53,000
+The next thing that probably you are thinking about right now, if we use nouns, should we use plural
+
+54
+00:04:53,000 --> 00:04:54,000
+or singular?
+
+55
+00:04:55,000 --> 00:05:01,000
+Of course this is a matter of your own preference, but the rule of thumb is to use plurals for all
+
+56
+00:05:01,000 --> 00:05:06,000
+resources unless they are singleton resources, for example.
+
+57
+00:05:06,000 --> 00:05:09,000
+Config y plurals.
+
+58
+00:05:09,000 --> 00:05:16,000
+Well, they are just more preferred because they represent more of something generic in a sense.
+
+59
+00:05:17,000 --> 00:05:23,000
+On this slide you can see bad and good examples with item and employee endpoints.
+
+60
+00:05:23,000 --> 00:05:25,000
+Let's continue.
+
+61
+00:05:25,000 --> 00:05:33,000
+The next recommendation to follow is to use hyphens to separate words and use lowercase for all words.
+
+62
+00:05:33,000 --> 00:05:34,000
+Don't use camel.
+
+63
+00:05:35,000 --> 00:05:45,000
+Don't use underscores the RFC 1786 specification for your rise standards also denotes that your eyes
+
+64
+00:05:45,000 --> 00:05:52,000
+are case sensitive except for the scheme and host components of the URL.
+
+65
+00:05:52,000 --> 00:06:00,000
+Given the widespread use of it, avoid any unnecessary confusion due to inconsistent capitalization.
+
+66
+00:06:00,000 --> 00:06:08,000
+Rest API can be developed by backend developers with different primary skills, and you know that in
+
+67
+00:06:08,000 --> 00:06:11,000
+different programming languages there are different names.
+
+68
+00:06:11,000 --> 00:06:12,000
+Style.
+
+69
+00:06:12,000 --> 00:06:16,000
+For example, in PHP it is common to use underscores.
+
+70
+00:06:16,000 --> 00:06:23,000
+In Java and C sharp, it is common to use camelcase and sometimes engineers either forget or just want
+
+71
+00:06:23,000 --> 00:06:28,000
+to apply their own habits while designing the rest API.
+
+72
+00:06:28,000 --> 00:06:33,000
+So remember the recommendation is to use hyphens to separate words.
+
+73
+00:06:33,000 --> 00:06:36,000
+It is more readable and user friendly.
+
+74
+00:06:36,000 --> 00:06:43,000
+Also, hyphens are much better for Google search as hyphens are recommended by Google itself to make
+
+75
+00:06:43,000 --> 00:06:49,000
+its web crawling job easier, thus creating more consistent results.
+
+76
+00:06:50,000 --> 00:06:53,000
+You can review good and bad examples on the slide.
+
+77
+00:06:54,000 --> 00:07:00,000
+The next rule is to use forward slashes for Iraqi but not trailing forward slash.
+
+78
+00:07:00,000 --> 00:07:03,000
+Let me explain what this rule is all about.
+
+79
+00:07:04,000 --> 00:07:09,000
+Usually forward slashes are used for the show in the Iraqi normal.
+
+80
+00:07:09,000 --> 00:07:15,000
+People might not know why the words in the link are separated by forward slashes.
+
+81
+00:07:16,000 --> 00:07:23,000
+As a developer, you should be familiar with the reason the forward slashes denote the UI.
+
+82
+00:07:23,000 --> 00:07:32,000
+Iraqi APIs are typically structured in Iraqi, but there is no need to use slash at the end of the endpoint.
+
+83
+00:07:33,000 --> 00:07:34,000
+Okay, let's move on.
+
+84
+00:07:35,000 --> 00:07:41,000
+The next guideline that I would like to review with you is about not adding file extensions to the Uris.
+
+85
+00:07:41,000 --> 00:07:45,000
+There is just no need in adding file extensions to the URI.
+
+86
+00:07:46,000 --> 00:07:50,000
+File extension simply adds unnecessary length and complexity.
+
+87
+00:07:51,000 --> 00:07:58,000
+Imagine that you would like to change the format of response instead of JSON to return XML and what
+
+88
+00:07:58,000 --> 00:07:59,000
+to do.
+
+89
+00:07:59,000 --> 00:08:07,000
+You need to change API to update the endpoint and you also need to update your client and documentation.
+
+90
+00:08:07,000 --> 00:08:14,000
+There are unnecessary actions that you can avoid in case you just don't use the file extensions as a
+
+91
+00:08:14,000 --> 00:08:15,000
+part of the URI.
+
+92
+00:08:16,000 --> 00:08:22,000
+Again, I recommend you observe bad and good examples presented on the slide.
+
+93
+00:08:22,000 --> 00:08:26,000
+Another important recommendation is to version your API.
+
+94
+00:08:27,000 --> 00:08:34,000
+Always mark your API with the version because imagine that you want to introduce improvements or upgrades
+
+95
+00:08:34,000 --> 00:08:41,000
+that change the way how API works or change even the name of a resource which is not recommended.
+
+96
+00:08:41,000 --> 00:08:46,000
+But still there can be cases and you have a few challenges.
+
+97
+00:08:46,000 --> 00:08:52,000
+The first one How to ensure compatibility of your client with the existing API.
+
+98
+00:08:52,000 --> 00:08:59,000
+The second one How to make all clients aware that significant changes are released and they need to
+
+99
+00:08:59,000 --> 00:09:03,000
+take changes into consideration when they process the response.
+
+100
+00:09:03,000 --> 00:09:09,000
+So never think about your API like something final and usable forever.
+
+101
+00:09:10,000 --> 00:09:16,000
+There is always a chance that new features will be added or some changes to the existing API will be
+
+102
+00:09:16,000 --> 00:09:23,000
+introduced and you never want to break your existing and working API that is already used by clients.
+
+103
+00:09:23,000 --> 00:09:30,000
+Also, when you are using versioning from the very beginning and documented, it indirectly tells the
+
+104
+00:09:30,000 --> 00:09:34,000
+users that there might be changes in the future.
+
+105
+00:09:34,000 --> 00:09:39,000
+It is good to prepare your users for any upcoming changes ahead of time.
+
+106
+00:09:39,000 --> 00:09:44,000
+You can specify a version in the left part of the endpoint in order.
+
+107
+00:09:44,000 --> 00:09:46,000
+The version has the highest scope.
+
+108
+00:09:47,000 --> 00:09:53,000
+Your clients will be interested only in the major version updates, so it will be enough to specify
+
+109
+00:09:53,000 --> 00:09:58,000
+just major versions like version one or version two, etcetera.
+
+110
+00:09:59,000 --> 00:10:01,000
+Just like in the example on the slide.
+
+111
+00:10:02,000 --> 00:10:10,000
+By doing so, if the API is being used by external entities, changing the endpoint will not really
+
+112
+00:10:10,000 --> 00:10:12,000
+affect the existing ones.
+
+113
+00:10:13,000 --> 00:10:17,000
+I like this approach, but there are also four other ways of versioning.
+
+114
+00:10:18,000 --> 00:10:26,000
+They are versioning in the subdomain versioning as an additional header, versioning as an additional
+
+115
+00:10:26,000 --> 00:10:32,000
+field in the accept content type header, versioning as a media type.
+
+116
+00:10:32,000 --> 00:10:33,000
+Let's review them.
+
+117
+00:10:34,000 --> 00:10:36,000
+Versioning in the subdomain.
+
+118
+00:10:36,000 --> 00:10:43,000
+This one puts the version within the UI but makes it associated with the domain like you can see on
+
+119
+00:10:43,000 --> 00:10:44,000
+the slide.
+
+120
+00:10:44,000 --> 00:10:48,000
+This is very similar to the version in placed at the end.
+
+121
+00:10:48,000 --> 00:10:56,000
+However, this approach has one advantage that can allow you to host your API on different servers.
+
+122
+00:10:57,000 --> 00:11:00,000
+Another approach is versioning as an additional header.
+
+123
+00:11:00,000 --> 00:11:04,000
+This version uses Mimetypes to include the API version.
+
+124
+00:11:05,000 --> 00:11:08,000
+It looks something like you can see on this slide.
+
+125
+00:11:09,000 --> 00:11:13,000
+Version as an additional field in the accept Content-type header.
+
+126
+00:11:13,000 --> 00:11:19,000
+This one is similar to the previous point that we discussed on how to include it.
+
+127
+00:11:19,000 --> 00:11:22,000
+Except is the result is different.
+
+128
+00:11:22,000 --> 00:11:24,000
+Here is how it looks like.
+
+129
+00:11:24,000 --> 00:11:28,000
+Pay attention to this slide to understand the difference.
+
+130
+00:11:29,000 --> 00:11:31,000
+Versioning as a media type.
+
+131
+00:11:31,000 --> 00:11:37,000
+This is also similar as the three previous ways all use the Mimetypes sync.
+
+132
+00:11:38,000 --> 00:11:42,000
+The only differences are where or how to put the versioning.
+
+133
+00:11:42,000 --> 00:11:46,000
+Here are some examples presented on the slide.
+
+134
+00:11:47,000 --> 00:11:53,000
+The next guideline that we are going to discuss is about using query parameters in your API.
+
+135
+00:11:53,000 --> 00:12:00,000
+Very often you are going to have requirements to support filtering or sorting or pagination, and to
+
+136
+00:12:00,000 --> 00:12:04,000
+implement this requirement you would need to take into account input parameters.
+
+137
+00:12:04,000 --> 00:12:13,000
+It can be field that is used for sorting and sorting order or filtering criteria and instead of creating
+
+138
+00:12:13,000 --> 00:12:16,000
+new API use query parameters.
+
+139
+00:12:16,000 --> 00:12:23,000
+For example, if you want to filter users to keep in the collection, only those where location is equal
+
+140
+00:12:23,000 --> 00:12:29,000
+to USA, then you can use location query parameter like you can see on the slide.
+
+141
+00:12:30,000 --> 00:12:36,000
+Or in case you want to declare multiple filtering criteria, you can use something like you can see
+
+142
+00:12:36,000 --> 00:12:42,000
+in another example on the slide when I used department and region criteria.
+
+143
+00:12:43,000 --> 00:12:48,000
+Another helpful advice that I want to give you is to use punctuation for lists.
+
+144
+00:12:48,000 --> 00:12:53,000
+Sometimes we want to allow client to fetch multiple resources.
+
+145
+00:12:53,000 --> 00:13:01,000
+In such cases we can use punctuation, comma or semicolon, but comma is used more often.
+
+146
+00:13:01,000 --> 00:13:05,000
+If client wants to access multiple user resources.
+
+147
+00:13:05,000 --> 00:13:10,000
+We can design our API in the way like you can see on the screen.
+
+148
+00:13:10,000 --> 00:13:15,000
+You can see that between ID one and two there is a comma.
+
+149
+00:13:15,000 --> 00:13:18,000
+The next guidelines that I would like to review is use.
+
+150
+00:13:18,000 --> 00:13:20,000
+Sounds pretty logical and simple.
+
+151
+00:13:20,000 --> 00:13:23,000
+Make your names intuitive.
+
+152
+00:13:23,000 --> 00:13:30,000
+Try to select simplest and the most commonly used word to refer to a given concept.
+
+153
+00:13:30,000 --> 00:13:37,000
+Your endpoint names and resource names should be self-describing and easy to understand.
+
+154
+00:13:37,000 --> 00:13:42,000
+It should save time of clients and developers when interacting with the API.
+
+155
+00:13:42,000 --> 00:13:49,000
+When you design an API and trying to come up with the name, try to position yourself as a consumer,
+
+156
+00:13:49,000 --> 00:13:53,000
+as someone who doesn't know anything about your services.
+
+157
+00:13:54,000 --> 00:14:01,000
+I would expect to be able to understand the basic use of API just by reading the API endpoints naming.
+
+158
+00:14:02,000 --> 00:14:07,000
+If I would like to fully understand how to use it, then I would read deeper.
+
+159
+00:14:07,000 --> 00:14:11,000
+Ideally, the name has to be something that represents a whole.
+
+160
+00:14:12,000 --> 00:14:19,000
+In addition, you would like to avoid causing confusion by avoiding abbreviations or shorthand as well.
+
+161
+00:14:19,000 --> 00:14:26,000
+For example, when you name a resource as users from the name, it is clear that with this endpoint
+
+162
+00:14:26,000 --> 00:14:31,000
+you can access user resource and get user information.
+
+163
+00:14:31,000 --> 00:14:33,000
+Resource has a lot of data.
+
+164
+00:14:33,000 --> 00:14:40,000
+We can make this conclusion by plural version of the noun and logical addition to this rule.
+
+165
+00:14:40,000 --> 00:14:43,000
+Avoid using jargon.
+
+166
+00:14:43,000 --> 00:14:46,000
+Clients shouldn't spend time guessing.
+
+167
+00:14:47,000 --> 00:14:50,000
+Use less domain centric jargon.
+
+168
+00:14:50,000 --> 00:14:57,000
+Sometimes that's common and more understandable is going to make your APIs a lot more usable.
+
+169
+00:14:58,000 --> 00:15:00,000
+Pay attention to the example on the slide.
+
+170
+00:15:01,000 --> 00:15:06,000
+For example, in this case, what does f n mean?
+
+171
+00:15:06,000 --> 00:15:07,000
+Function?
+
+172
+00:15:07,000 --> 00:15:08,000
+Which function?
+
+173
+00:15:08,000 --> 00:15:09,000
+This is not clear.
+
+174
+00:15:09,000 --> 00:15:15,000
+So stick with your common sense and choose intuitive, clear names.
+
+175
+00:15:16,000 --> 00:15:23,000
+Another guideline that we partially discussed recommendations that is also follows from the previous
+
+176
+00:15:23,000 --> 00:15:24,000
+one.
+
+177
+00:15:24,000 --> 00:15:28,000
+Avoid obliging and point resource names.
+
+178
+00:15:28,000 --> 00:15:37,000
+In fact, branch names can actually create confusion in your API as developers struggle to guess and
+
+179
+00:15:37,000 --> 00:15:40,000
+sometimes understand the names you have chosen.
+
+180
+00:15:40,000 --> 00:15:45,000
+For example, there is no need to use tell no end point.
+
+181
+00:15:45,000 --> 00:15:48,000
+It is better to use phone number.
+
+182
+00:15:48,000 --> 00:15:55,000
+Another simple but also important recommendation is to avoid using special characters.
+
+183
+00:15:55,000 --> 00:16:00,000
+I understand that this is logical, but still it is a guideline to remember.
+
+184
+00:16:01,000 --> 00:16:07,000
+Sinks like person signed 20 which represents the space character should not be used either.
+
+185
+00:16:08,000 --> 00:16:15,000
+Again, Z is in itself already goes against the intuitive naming convention.
+
+186
+00:16:15,000 --> 00:16:23,000
+So try to avoid using characters like person signed 20 in your naming as those have other meanings already.
+
+187
+00:16:24,000 --> 00:16:28,000
+We review today a lot of guidelines and recommendations.
+
+188
+00:16:28,000 --> 00:16:35,000
+And the last but not the least guideline is about consistency in your API because consistency is a key
+
+189
+00:16:35,000 --> 00:16:38,000
+and it deserves special recognition.
+
+190
+00:16:39,000 --> 00:16:47,000
+Always use the same name to refer to a given concept within your API, because even in case you follow
+
+191
+00:16:47,000 --> 00:16:51,000
+all other guidelines that we reviewed, they were nothing.
+
+192
+00:16:51,000 --> 00:16:54,000
+If your API is inconsistent.
+
+193
+00:16:55,000 --> 00:16:57,000
+That's all what I wanted to share with you today.
+
+194
+00:16:57,000 --> 00:17:01,000
+Let's recap what we have learned in the lesson.
+
+195
+00:17:01,000 --> 00:17:07,000
+Today we learn two key principles and guidelines that are recommended to follow while designing your
+
+196
+00:17:07,000 --> 00:17:09,000
+Rest API and RESTful services.
+
+197
+00:17:09,000 --> 00:17:15,000
+We learned such guidelines use nouns to represent resources, not verbs.
+
+198
+00:17:15,000 --> 00:17:24,000
+We use pluralized nouns for resources, use hyphens and lowercase use forward slashes for Iraqi but
+
+199
+00:17:24,000 --> 00:17:33,000
+not trailing forward slash avoid using file extensions API versioning use query parameters punctuation
+
+200
+00:17:33,000 --> 00:17:38,000
+for lists intuitive names No jargon no abridging.
+
+201
+00:17:39,000 --> 00:17:41,000
+Avoid using special characters.
+
+202
+00:17:41,000 --> 00:17:43,000
+Keep your API consistent.
+
+203
+00:17:44,000 --> 00:17:45,000
+That's it.
+
+204
+00:17:45,000 --> 00:17:47,000
+Thanks a lot for your attention.
+
+205
+00:17:47,000 --> 00:17:50,000
+Have a great day and see you in the next lesson.
+

91 - REST Architecture/003 RESTful Service Implementation with Spring MVC_en.srt

@@ -0,0 +1,1092 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, team.
+
+2
+00:00:06,000 --> 00:00:15,000
+By this moment in our course, we learned what raster architecture is and learned RESTful service naming
+
+3
+00:00:15,000 --> 00:00:16,000
+convention.
+
+4
+00:00:16,000 --> 00:00:24,000
+We are ready to jump to the practical exercises and start implementation of our own restful service.
+
+5
+00:00:24,000 --> 00:00:30,000
+I must admit that there are different frameworks, different tools, and different programming languages
+
+6
+00:00:30,000 --> 00:00:33,000
+that you can use to create restful service.
+
+7
+00:00:33,000 --> 00:00:37,000
+In this lesson, we are going to create our restful service using Spring MVC.
+
+8
+00:00:37,000 --> 00:00:43,000
+We will start our lesson with the configuration of the required dependencies.
+
+9
+00:00:43,000 --> 00:00:48,000
+Then we will jump to creation of our first custom rest web service.
+
+10
+00:00:48,000 --> 00:00:55,000
+I'm going to explain you how to use rest controller annotation and how it is different from the controller
+
+11
+00:00:55,000 --> 00:00:56,000
+annotation.
+
+12
+00:00:56,000 --> 00:01:01,000
+We will learn such annotations and configurations as response body.
+
+13
+00:01:01,000 --> 00:01:08,000
+Request body pass a variable request param response status response entity.
+
+14
+00:01:08,000 --> 00:01:15,000
+And at the end of the lesson I'm going to show you how we can read HTTP headers in rest controller We
+
+15
+00:01:15,000 --> 00:01:17,000
+are request header annotation.
+
+16
+00:01:18,000 --> 00:01:24,000
+Let's start our lesson and take into account that this is going to be practical lesson.
+
+17
+00:01:24,000 --> 00:01:27,000
+Let's jump to practical exercises.
+
+18
+00:01:27,000 --> 00:01:32,000
+As always, you can find source code examples in attachments to the lesson.
+
+19
+00:01:33,000 --> 00:01:38,000
+Feel free to clone the repository and run the code examples from the lesson locally.
+
+20
+00:01:39,000 --> 00:01:41,000
+I'm starting screen sharing.
+
+21
+00:01:41,000 --> 00:01:48,000
+Just a reminder that this is the lesson about creation of restful service with spring MVC, but not
+
+22
+00:01:48,000 --> 00:01:51,000
+about spring MVC itself.
+
+23
+00:01:51,000 --> 00:01:54,000
+So my assumption is that you have clear understanding already.
+
+24
+00:01:54,000 --> 00:02:00,000
+What is spring MVC is, you know, how to configure component scanning of the elements, how to declare
+
+25
+00:02:00,000 --> 00:02:04,000
+configuration, how to use web application, initializer.
+
+26
+00:02:04,000 --> 00:02:10,000
+I will not stop on the questions that we have already learned in the spring MVC section of my course.
+
+27
+00:02:10,000 --> 00:02:12,000
+Java from zero to first job.
+
+28
+00:02:12,000 --> 00:02:18,000
+If you would like to learn more, feel free to check the section of the course about Spring MVC where
+
+29
+00:02:18,000 --> 00:02:23,000
+I explained in the details how to kick off spring MVC application.
+
+30
+00:02:24,000 --> 00:02:28,000
+Okay, let's continue with the dependencies overview.
+
+31
+00:02:28,000 --> 00:02:35,000
+If you follow my course Java from zero to first job where we implement our own online shop from scratch,
+
+32
+00:02:35,000 --> 00:02:41,000
+then you should already have all required dependencies in your pom.xml file declared.
+
+33
+00:02:41,000 --> 00:02:46,000
+But just in case you jump directly to this lesson, let me recap.
+
+34
+00:02:46,000 --> 00:02:53,000
+What are the key dependencies should be present in the classpath in order you can succeed with examples
+
+35
+00:02:53,000 --> 00:02:55,000
+from this lesson.
+
+36
+00:02:55,000 --> 00:03:01,000
+The main thing is that you have spring MVC dependency, spring context and Jackson data bind.
+
+37
+00:03:02,000 --> 00:03:06,000
+These dependencies are the key for today's examples.
+
+38
+00:03:06,000 --> 00:03:13,000
+The rest of the dependencies depend on the tools and frameworks that you are going to use on the persistence
+
+39
+00:03:13,000 --> 00:03:14,000
+level.
+
+40
+00:03:14,000 --> 00:03:20,000
+If you follow my course Java from zero to first job, then by this moment in our course you already
+
+41
+00:03:20,000 --> 00:03:28,000
+learned how to work with Spring data JPA and Spring JDBC and can work with any of these tools on the
+
+42
+00:03:28,000 --> 00:03:29,000
+persistence layer.
+
+43
+00:03:30,000 --> 00:03:35,000
+So I assume that you can add all relevant dependencies for the persistence layer.
+
+44
+00:03:36,000 --> 00:03:43,000
+All examples that I prepared for this lesson are located under the rest package in the user rest controller
+
+45
+00:03:43,000 --> 00:03:44,000
+class.
+
+46
+00:03:44,000 --> 00:03:51,000
+All other classes that are going to be used today were reviewed in previous lessons, so I wouldn't
+
+47
+00:03:51,000 --> 00:03:51,000
+stop on them.
+
+48
+00:03:52,000 --> 00:04:00,000
+For example, pay attention that I inject user service here and user service in turn uses user repository.
+
+49
+00:04:01,000 --> 00:04:07,000
+As I said, if you want to get more detailed comments about persistence layer, feel free to check previous
+
+50
+00:04:07,000 --> 00:04:14,000
+lessons from my course Java from zero to first job about spring data, JPA and Spring JDBC.
+
+51
+00:04:14,000 --> 00:04:20,000
+And in this lesson we will focus only on designing of our rest endpoints.
+
+52
+00:04:20,000 --> 00:04:25,000
+And the first concept that we need to talk about is understanding the difference between controller
+
+53
+00:04:25,000 --> 00:04:27,000
+and rest controller.
+
+54
+00:04:27,000 --> 00:04:35,000
+So when we implement controller in spring, usually we market with controller annotation.
+
+55
+00:04:35,000 --> 00:04:42,000
+This is just a specialization of the component annotation that we use to mark our components in order.
+
+56
+00:04:42,000 --> 00:04:45,000
+Spring can manage life cycles of these beans.
+
+57
+00:04:45,000 --> 00:04:50,000
+It allows to auto detect implementation classes by classpath scanning.
+
+58
+00:04:51,000 --> 00:04:56,000
+Rest controller is a specialized version of the controller annotation.
+
+59
+00:04:56,000 --> 00:05:02,000
+If we open source code of rest controller annotation we would notice it is.
+
+60
+00:05:02,000 --> 00:05:07,000
+Is marked with controller annotation and response body annotation.
+
+61
+00:05:07,000 --> 00:05:09,000
+So in simple words.
+
+62
+00:05:09,000 --> 00:05:16,000
+Rest controller annotation is just a combination of controller and response body annotations.
+
+63
+00:05:16,000 --> 00:05:23,000
+This simplifies the implementation from the development side because in case you use rest controller.
+
+64
+00:05:23,000 --> 00:05:27,000
+Annotation you should not use response body annotation.
+
+65
+00:05:27,000 --> 00:05:30,000
+So what does response body annotation do?
+
+66
+00:05:30,000 --> 00:05:37,000
+This annotation tells the controller that the object returned should be serialized into the JSON format
+
+67
+00:05:37,000 --> 00:05:41,000
+and passed back in the HTTP response body.
+
+68
+00:05:41,000 --> 00:05:46,000
+That's why we added Jackson data bind in our dependencies.
+
+69
+00:05:47,000 --> 00:05:52,000
+Jackson Library is responsible for this JSON serialization.
+
+70
+00:05:52,000 --> 00:06:00,000
+In the example you can see that I can add produces attribute and specify media type that this endpoint
+
+71
+00:06:00,000 --> 00:06:06,000
+supposed to produce response body will consider this configuration.
+
+72
+00:06:06,000 --> 00:06:14,000
+In this example, I vividly specified that JSON value will be returned, but JSON is used by default.
+
+73
+00:06:15,000 --> 00:06:22,000
+I can open media type class just to show you that there are different constants available that you can
+
+74
+00:06:22,000 --> 00:06:24,000
+specify instead of the JSON.
+
+75
+00:06:24,000 --> 00:06:31,000
+Theoretically you can have multiple end points that are mapped to the same path, but that just produces
+
+76
+00:06:31,000 --> 00:06:33,000
+output of different type.
+
+77
+00:06:33,000 --> 00:06:41,000
+Depending on the accept header of the HTTP request, it will be identified which endpoint will be invoked,
+
+78
+00:06:41,000 --> 00:06:45,000
+and the first endpoint that is declared here is relatively simple.
+
+79
+00:06:45,000 --> 00:06:52,000
+I just extract all users from the persistence layer and return the list of users.
+
+80
+00:06:52,000 --> 00:06:54,000
+So what will actually happen?
+
+81
+00:06:54,000 --> 00:07:01,000
+Taking into account this is a rest controller, my list of users will be serialized into the JSON array
+
+82
+00:07:01,000 --> 00:07:03,000
+and returned from the method.
+
+83
+00:07:04,000 --> 00:07:09,000
+I'm going to show you this when we will come to testing of our API.
+
+84
+00:07:10,000 --> 00:07:13,000
+There is also annotations that is called request body.
+
+85
+00:07:13,000 --> 00:07:16,000
+It is not the same as response body.
+
+86
+00:07:16,000 --> 00:07:20,000
+So let's find out what is the difference in simple words.
+
+87
+00:07:20,000 --> 00:07:30,000
+The request body annotation Deserialize The HTTP request body into a Java object like this, we can
+
+88
+00:07:30,000 --> 00:07:33,000
+pass resources to the restful service.
+
+89
+00:07:33,000 --> 00:07:37,000
+For example, we can send JSON of our user object.
+
+90
+00:07:37,000 --> 00:07:46,000
+We have post method in order to create resource and in our method insert user you can see how I use
+
+91
+00:07:46,000 --> 00:07:48,000
+request body annotation.
+
+92
+00:07:48,000 --> 00:07:56,000
+Basically it will be again deserialized with the help of spring and Jackson data bind into the Java
+
+93
+00:07:56,000 --> 00:08:05,000
+object and then I will use this Java object to store in my persistent storage by default the type we
+
+94
+00:08:05,000 --> 00:08:12,000
+annotate with the request body annotation must correspond to the JSON sent from our client.
+
+95
+00:08:12,000 --> 00:08:19,000
+The next thing that we need to know in order to use it efficiently while implementing our restful service
+
+96
+00:08:19,000 --> 00:08:27,000
+is pass variable annotation pass Verbal annotation can be used to handle template variables in the request
+
+97
+00:08:27,000 --> 00:08:32,000
+URI mapping and set them as method parameters.
+
+98
+00:08:32,000 --> 00:08:39,000
+Like for example, you can see in the get user buy method, you can see that in the UI.
+
+99
+00:08:39,000 --> 00:08:47,000
+I used variable and in the method parameters I use pass variable annotation in order to tell the spring
+
+100
+00:08:47,000 --> 00:08:55,000
+that this variable value should be injected into this method argument in order, I can use it in the
+
+101
+00:08:55,000 --> 00:09:02,000
+method during the implementation of the endpoint, you can use multiple pass variables as much as you
+
+102
+00:09:02,000 --> 00:09:05,000
+need and to handle multiple pass variables.
+
+103
+00:09:05,000 --> 00:09:10,000
+We can use map like you can see here in the command line.
+
+104
+00:09:10,000 --> 00:09:17,000
+By default, values for all pass variables are mandatory in case it will be needed.
+
+105
+00:09:17,000 --> 00:09:25,000
+You can set required attribute of pass variable to false because in case you would leave pass variable
+
+106
+00:09:25,000 --> 00:09:33,000
+as required and you wouldn't send it, exception will be produced, but actually usually we specify
+
+107
+00:09:33,000 --> 00:09:36,000
+pass variables to make them required.
+
+108
+00:09:36,000 --> 00:09:40,000
+So you shouldn't do something which is not logical during the development.
+
+109
+00:09:40,000 --> 00:09:43,000
+Just be aware that you have such tool set.
+
+110
+00:09:44,000 --> 00:09:52,000
+If you want to use optional API, then you can map pass variable with optional what optional API is
+
+111
+00:09:52,000 --> 00:09:54,000
+and when to use it.
+
+112
+00:09:54,000 --> 00:10:01,000
+You can check in the separate lesson in my course, but just quickly to remind you this API helps you
+
+113
+00:10:01,000 --> 00:10:02,000
+to handle different.
+
+114
+00:10:03,000 --> 00:10:06,000
+This was no values, including no checks.
+
+115
+00:10:06,000 --> 00:10:13,000
+And setting some default values in case is a reason now and many, many other different things.
+
+116
+00:10:13,000 --> 00:10:18,000
+The next important configurations that we are going to use in our restful services.
+
+117
+00:10:18,000 --> 00:10:23,000
+Building it with spring MVC is request param annotation.
+
+118
+00:10:23,000 --> 00:10:29,000
+Request parameterization helps us to extract query parameters from the request.
+
+119
+00:10:29,000 --> 00:10:36,000
+Like in this example, when I want to fetch all users filtering them by the first name, you can see
+
+120
+00:10:36,000 --> 00:10:39,000
+that first name is a query parameter.
+
+121
+00:10:39,000 --> 00:10:42,000
+In this case it is not pass variable.
+
+122
+00:10:42,000 --> 00:10:52,000
+Also pay attention that the resource name is the same in different request mapping users and in order
+
+123
+00:10:52,000 --> 00:10:59,000
+to not have an exception, that tells us that I have multiple same request mappings, I need to keep
+
+124
+00:10:59,000 --> 00:11:07,000
+them different In case you would use different request method, the endpoints will become different.
+
+125
+00:11:07,000 --> 00:11:16,000
+But in this particular case, everywhere I use get request method and in real life too you may have
+
+126
+00:11:16,000 --> 00:11:24,000
+end point with the same name, same request method and you need to come up how to make these endpoints
+
+127
+00:11:24,000 --> 00:11:25,000
+different.
+
+128
+00:11:26,000 --> 00:11:33,000
+I can keep them different by specifying the request parameters, but how was the question mark in the
+
+129
+00:11:33,000 --> 00:11:36,000
+URI to keep them different?
+
+130
+00:11:36,000 --> 00:11:39,000
+You don't need to use question mark in the URL mapping.
+
+131
+00:11:40,000 --> 00:11:47,000
+What you have to do instead is to use params attribute in order to specify parameters name.
+
+132
+00:11:47,000 --> 00:11:54,000
+This is how spring will differentiate endpoints with the same resource name but with different query
+
+133
+00:11:54,000 --> 00:11:55,000
+parameters.
+
+134
+00:11:55,000 --> 00:12:01,000
+It is important for you to understand that we are talking about not pass variable here.
+
+135
+00:12:02,000 --> 00:12:05,000
+But the way how we work with it is similar.
+
+136
+00:12:05,000 --> 00:12:13,000
+You use request param annotation with the type and request parameter is injected into the method parameter.
+
+137
+00:12:13,000 --> 00:12:19,000
+This is the simplest and the most common use case of using request parameter annotation.
+
+138
+00:12:20,000 --> 00:12:27,000
+In the next example, you can see that I declared sort by request parameter and you can build logic
+
+139
+00:12:27,000 --> 00:12:31,000
+for sorting based on the value passed with this parameter.
+
+140
+00:12:31,000 --> 00:12:39,000
+In this example, in case somebody passed first name field, in this case I sort results by the first
+
+141
+00:12:39,000 --> 00:12:40,000
+name.
+
+142
+00:12:40,000 --> 00:12:43,000
+Otherwise I just return all users.
+
+143
+00:12:44,000 --> 00:12:48,000
+Also created a few more requests parameter demo methods.
+
+144
+00:12:48,000 --> 00:12:50,000
+Let's review them together.
+
+145
+00:12:50,000 --> 00:12:56,000
+You can use request parameter with optional in order to get benefits of the optional API.
+
+146
+00:12:56,000 --> 00:13:01,000
+You can specify whether the request parameter is required or no.
+
+147
+00:13:01,000 --> 00:13:09,000
+In this case I specified that the request parameter is not mandatory and in case it will be absent there
+
+148
+00:13:09,000 --> 00:13:11,000
+will not be any error.
+
+149
+00:13:11,000 --> 00:13:19,000
+In case you expect to process multiple request parameters, you can use request parameter notation together
+
+150
+00:13:19,000 --> 00:13:22,000
+with map during the program execution.
+
+151
+00:13:22,000 --> 00:13:30,000
+All your request parameters will be injected into the map and after that you can iterate over the entries
+
+152
+00:13:30,000 --> 00:13:33,000
+set to interact with the parameters.
+
+153
+00:13:33,000 --> 00:13:41,000
+What to do In case I want to have endpoints that would read form data request parameters similar to
+
+154
+00:13:41,000 --> 00:13:45,000
+the ones that we send via HTML forms.
+
+155
+00:13:45,000 --> 00:13:49,000
+But note that we pass after the question mark in the URI.
+
+156
+00:13:50,000 --> 00:13:56,000
+In this case, you can vividly specify what type of data is consumed by this endpoint.
+
+157
+00:13:56,000 --> 00:14:04,000
+You can declare the JSON point, consumes application form data and in this case you don't need to use
+
+158
+00:14:04,000 --> 00:14:06,000
+request param annotation.
+
+159
+00:14:06,000 --> 00:14:09,000
+You need to use request body annotation.
+
+160
+00:14:10,000 --> 00:14:16,000
+This annotation will help you to inject key value pairs into multi-value map object.
+
+161
+00:14:16,000 --> 00:14:24,000
+Also, in case one parameter has multiple values, you can map values into the list like you can see
+
+162
+00:14:24,000 --> 00:14:26,000
+in the following example.
+
+163
+00:14:26,000 --> 00:14:31,000
+You can see in the command lines that this can be applied to the cases.
+
+164
+00:14:31,000 --> 00:14:37,000
+When you have list of the separate parameters or just comma separated values.
+
+165
+00:14:38,000 --> 00:14:42,000
+There is also an option to specify default value for the request param.
+
+166
+00:14:43,000 --> 00:14:49,000
+I encourage you to look through the source code of the annotation and read attribute names.
+
+167
+00:14:49,000 --> 00:14:54,000
+In most cases they are self describing requisite default value, for example.
+
+168
+00:14:54,000 --> 00:15:01,000
+And even in case you have any questions, please feel free to post your questions below the video and
+
+169
+00:15:01,000 --> 00:15:03,000
+I will be happy to answer.
+
+170
+00:15:03,000 --> 00:15:08,000
+Let's learn now how to use response status in Spring MVC.
+
+171
+00:15:08,000 --> 00:15:15,000
+You have opportunity to set the status code of an HTTP response if you want to set response status of
+
+172
+00:15:15,000 --> 00:15:16,000
+your controller method.
+
+173
+00:15:17,000 --> 00:15:24,000
+You can just use annotation response status over the method like you can see in this example.
+
+174
+00:15:24,000 --> 00:15:31,000
+You may need to set up different statuses based on the defined and agreed contract.
+
+175
+00:15:31,000 --> 00:15:36,000
+You can use response status just with HTTP status code.
+
+176
+00:15:36,000 --> 00:15:39,000
+Or you can also specify the reason.
+
+177
+00:15:40,000 --> 00:15:44,000
+Reason will be specified as a separate message in the response.
+
+178
+00:15:44,000 --> 00:15:46,000
+Here you can see an example.
+
+179
+00:15:46,000 --> 00:15:51,000
+In this case I return I'm a post response status.
+
+180
+00:15:51,000 --> 00:15:56,000
+This response status is equivalent to the 418 status code.
+
+181
+00:15:57,000 --> 00:15:59,000
+The HTTP 418.
+
+182
+00:15:59,000 --> 00:16:00,000
+I'm a teapot.
+
+183
+00:16:00,000 --> 00:16:08,000
+Client error response code indicates that the server refuses to brew coffee because it is permanently
+
+184
+00:16:08,000 --> 00:16:09,000
+teapot.
+
+185
+00:16:10,000 --> 00:16:10,000
+Yes.
+
+186
+00:16:10,000 --> 00:16:12,000
+This is an interesting joke.
+
+187
+00:16:13,000 --> 00:16:21,000
+This error message was designed as a one of the April Fools jokes, and the error states that any teapot
+
+188
+00:16:21,000 --> 00:16:26,000
+that has been asked to brew coffee shall respond with this message.
+
+189
+00:16:27,000 --> 00:16:31,000
+Funnily enough, also the status code is not used.
+
+190
+00:16:31,000 --> 00:16:34,000
+It is supported by many HTTP libraries.
+
+191
+00:16:34,000 --> 00:16:42,000
+Some time ago there was an effort to have this error removed so that the number can be used in an official
+
+192
+00:16:42,000 --> 00:16:43,000
+capacity.
+
+193
+00:16:43,000 --> 00:16:52,000
+However, this was met with a resistance and led to the creation of the SAFE 418 initiative.
+
+194
+00:16:52,000 --> 00:16:56,000
+As such, the message and status code remain.
+
+195
+00:16:56,000 --> 00:17:03,000
+Also, you can specify HTTP status as a return type if you wish, and after processing the request,
+
+196
+00:17:03,000 --> 00:17:05,000
+you can return the status.
+
+197
+00:17:05,000 --> 00:17:13,000
+For example, when we delete user, there is no resource that we can return after sending the request,
+
+198
+00:17:13,000 --> 00:17:20,000
+we via delete method to user's resource and return no content status but attention.
+
+199
+00:17:21,000 --> 00:17:29,000
+In this case it will be returned as message body because response status code will actually be 200.
+
+200
+00:17:30,000 --> 00:17:31,000
+Be attentive with that.
+
+201
+00:17:32,000 --> 00:17:38,000
+If we want to have different status code in response, you need to use response status annotation.
+
+202
+00:17:39,000 --> 00:17:47,000
+In case user has been successfully created and inserted, I send confirmation create it will be returned
+
+203
+00:17:47,000 --> 00:17:48,000
+in response body.
+
+204
+00:17:49,000 --> 00:17:55,000
+When I send request was put method to update the resource and in case the resource has been updated,
+
+205
+00:17:56,000 --> 00:17:58,000
+return accepted status.
+
+206
+00:17:59,000 --> 00:18:02,000
+But what to do in case I need more flexibility?
+
+207
+00:18:02,000 --> 00:18:10,000
+And like in this case I want to identify what response status to return during the execution.
+
+208
+00:18:10,000 --> 00:18:11,000
+And not always.
+
+209
+00:18:11,000 --> 00:18:16,000
+I can specify it in the annotation before methods gets executed.
+
+210
+00:18:16,000 --> 00:18:18,000
+There are different workarounds that you can apply.
+
+211
+00:18:18,000 --> 00:18:23,000
+One of them is to work with the HTTP response object directly.
+
+212
+00:18:23,000 --> 00:18:26,000
+Another one is to use response entity.
+
+213
+00:18:26,000 --> 00:18:30,000
+So let's learn how to work with the response entity object.
+
+214
+00:18:31,000 --> 00:18:37,000
+If you are familiar with Spring framework, then you know that there are different ways of how you can
+
+215
+00:18:37,000 --> 00:18:39,000
+achieve the same result in spring.
+
+216
+00:18:39,000 --> 00:18:43,000
+The similar story is here you have different options.
+
+217
+00:18:43,000 --> 00:18:45,000
+How to tune your HTTP response.
+
+218
+00:18:45,000 --> 00:18:51,000
+And I prepared examples for you to show how you can tune HTTP response via response.
+
+219
+00:18:51,000 --> 00:19:00,000
+Entity response Entity is a type to represent the whole HTTP response, including status code headers
+
+220
+00:19:00,000 --> 00:19:01,000
+and response body.
+
+221
+00:19:02,000 --> 00:19:04,000
+Do you use response entity?
+
+222
+00:19:04,000 --> 00:19:11,000
+You need to declare it as return type of your method and spring will take the rest with regards to processing
+
+223
+00:19:11,000 --> 00:19:14,000
+this object and preparing the response.
+
+224
+00:19:15,000 --> 00:19:17,000
+Let's look at examples.
+
+225
+00:19:17,000 --> 00:19:22,000
+In the first example you can see that I set return type as response entity.
+
+226
+00:19:22,000 --> 00:19:31,000
+Important thing is that there are builders that you can use to build response entity to static masses
+
+227
+00:19:31,000 --> 00:19:38,000
+will return object of header builder type and four methods will return object of body builder type.
+
+228
+00:19:38,000 --> 00:19:41,000
+Body builder extends header builder.
+
+229
+00:19:41,000 --> 00:19:50,000
+In this example I invoke okay method and they use body builder to create response entity with the header
+
+230
+00:19:50,000 --> 00:19:55,000
+method I can specify header with the body mass that I can specify body.
+
+231
+00:19:55,000 --> 00:20:01,000
+I believe everything is clear and there is no need in the additional explanation because methods are
+
+232
+00:20:01,000 --> 00:20:02,000
+self-describing.
+
+233
+00:20:03,000 --> 00:20:10,000
+And of course remember that in case something is not clear to you, you can always ask your questions
+
+234
+00:20:10,000 --> 00:20:14,000
+below the video in comments and I will be happy to answer.
+
+235
+00:20:15,000 --> 00:20:18,000
+There is also another way to create response entity.
+
+236
+00:20:18,000 --> 00:20:21,000
+You can see commanded lines here.
+
+237
+00:20:21,000 --> 00:20:26,000
+Basically you can create response entity object with a new keyword.
+
+238
+00:20:26,000 --> 00:20:34,000
+In this particular example, I created headers and then I created Object of the Response entity type
+
+239
+00:20:34,000 --> 00:20:40,000
+using constructor with response body headers and HTTP status.
+
+240
+00:20:40,000 --> 00:20:46,000
+You can check the source code and make sure that there are different constructors that you can use to
+
+241
+00:20:46,000 --> 00:20:49,000
+create response entity object.
+
+242
+00:20:49,000 --> 00:20:56,000
+And the last but not the least for today, let's learn how to read HTTP headers in rest controller.
+
+243
+00:20:56,000 --> 00:21:03,000
+You can use request header annotation to read headers individually as well as all together.
+
+244
+00:21:04,000 --> 00:21:11,000
+In the first example here you can see how I put request header annotation before the parameter.
+
+245
+00:21:11,000 --> 00:21:14,000
+I believe you already know how this will work.
+
+246
+00:21:14,000 --> 00:21:20,000
+Spring will take care of injecting the request header value into the parameter.
+
+247
+00:21:20,000 --> 00:21:25,000
+Basically you just need to specify which request header you want to parse.
+
+248
+00:21:26,000 --> 00:21:32,000
+You can use one of the constants of the HTTP headers like you can see in this example.
+
+249
+00:21:33,000 --> 00:21:35,000
+Basically that will be enough.
+
+250
+00:21:35,000 --> 00:21:43,000
+Optionally, you can use required attribute to specify whether this request header is required or no
+
+251
+00:21:43,000 --> 00:21:51,000
+default is set to true, which causes an exception in case such header is absent.
+
+252
+00:21:51,000 --> 00:21:54,000
+Alternatively, you can provide a default value.
+
+253
+00:21:55,000 --> 00:22:02,000
+In this case, you will not receive exception because of missing value due to the default value is there.
+
+254
+00:22:02,000 --> 00:22:09,000
+In the second example you can see how I use request header annotation with the map parameter.
+
+255
+00:22:09,000 --> 00:22:17,000
+This will lead us to reading of all request headers and inject all the values into the map together
+
+256
+00:22:17,000 --> 00:22:19,000
+with the request headers names.
+
+257
+00:22:19,000 --> 00:22:27,000
+In this particular example, I just iterate over all headers and brings them to console and in response
+
+258
+00:22:27,000 --> 00:22:29,000
+I return total amount of headers.
+
+259
+00:22:30,000 --> 00:22:31,000
+That's it.
+
+260
+00:22:31,000 --> 00:22:37,000
+We learned a lot today and created our restful service with Spring MVC.
+
+261
+00:22:37,000 --> 00:22:44,000
+We still have to learn how to test our restful service, but I would keep this topic for our next lesson,
+
+262
+00:22:44,000 --> 00:22:46,000
+so stay tuned.
+
+263
+00:22:47,000 --> 00:22:51,000
+And now let's recap what we have learned in the lesson.
+
+264
+00:22:51,000 --> 00:22:56,000
+In this lesson, we learned how to create restful service with Spring MVC.
+
+265
+00:22:57,000 --> 00:23:00,000
+We learned and configured all required dependencies.
+
+266
+00:23:00,000 --> 00:23:06,000
+Now you know the difference between rest controller and controller annotations in spring.
+
+267
+00:23:07,000 --> 00:23:14,000
+I explained you what the response body annotation is among other annotations and configurations that
+
+268
+00:23:14,000 --> 00:23:16,000
+we learned during the lesson.
+
+269
+00:23:16,000 --> 00:23:24,000
+It is worth to mention request body pass, variable request param response status response entity and
+
+270
+00:23:24,000 --> 00:23:29,000
+request header to read http headers in rest controller.
+
+271
+00:23:29,000 --> 00:23:31,000
+That's all for today.
+
+272
+00:23:31,000 --> 00:23:33,000
+Thanks a lot for your attention.
+
+273
+00:23:33,000 --> 00:23:36,000
+Have a great day and see you in the next lesson.
+

91 - REST Architecture/003 Source-code-of-examples-commit-with-changes-.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/5f6b4f695bb88865978fb7cbe622855783c17cfa

91 - REST Architecture/004 Review of tools for API testing & Postman Installation_en.srt

@@ -0,0 +1,664 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello team.
+
+2
+00:00:06,000 --> 00:00:11,000
+In this video lesson, we are going to make an overview of the tools for testing.
+
+3
+00:00:12,000 --> 00:00:19,000
+I believe that this will give you directions for further learning and you will understand what you need
+
+4
+00:00:19,000 --> 00:00:22,000
+and what to suit your needs is the best.
+
+5
+00:00:23,000 --> 00:00:29,000
+During the review of the API testing tools, I will make a short overview of soap messaging protocol
+
+6
+00:00:29,000 --> 00:00:33,000
+and tools for testing web services that use soap.
+
+7
+00:00:34,000 --> 00:00:39,000
+I will focus your attention on the three very popular tools for testing.
+
+8
+00:00:39,000 --> 00:00:44,000
+They are Postman, Fiddler and Wireshark.
+
+9
+00:00:44,000 --> 00:00:49,000
+We will compare them between each other and the remaining part of the lesson.
+
+10
+00:00:49,000 --> 00:00:54,000
+We are going to talk about postman comparison of desktop and web version.
+
+11
+00:00:54,000 --> 00:01:00,000
+By the end of this lesson you are going to have postman installed on your computer and you will be prepared
+
+12
+00:01:00,000 --> 00:01:01,000
+for the following lessons.
+
+13
+00:01:01,000 --> 00:01:03,000
+Let's start our lesson.
+
+14
+00:01:04,000 --> 00:01:07,000
+Let's review tools for API testing.
+
+15
+00:01:07,000 --> 00:01:10,000
+There are several tools available for API testing.
+
+16
+00:01:10,000 --> 00:01:12,000
+Here are some popular ones.
+
+17
+00:01:13,000 --> 00:01:14,000
+Postman.
+
+18
+00:01:14,000 --> 00:01:21,000
+Postman is a popular tool for API testing that allows you to send requests and analyze responses in
+
+19
+00:01:21,000 --> 00:01:23,000
+a user friendly interface.
+
+20
+00:01:23,000 --> 00:01:29,000
+We are going to talk about it more in this video and in the following ones.
+
+21
+00:01:29,000 --> 00:01:30,000
+Fiddler.
+
+22
+00:01:30,000 --> 00:01:35,000
+It is indeed another popular tool for testing and debugging.
+
+23
+00:01:35,000 --> 00:01:43,000
+Particularly for analyzing and manipulating http https traffic between a client and the server.
+
+24
+00:01:43,000 --> 00:01:50,000
+It offers features like request interception, debugging, and performance testing.
+
+25
+00:01:51,000 --> 00:01:56,000
+Wireshark is another popular tool that can be used for testing and debugging.
+
+26
+00:01:56,000 --> 00:02:04,000
+It is a network protocol analyzer that captures and displays network packets in real time, allowing
+
+27
+00:02:04,000 --> 00:02:10,000
+you to inspect the details of the packets exchanged between the client and the server.
+
+28
+00:02:10,000 --> 00:02:18,000
+While Wireshark may not be specialized for API testing as some of other tools I mentioned earlier,
+
+29
+00:02:18,000 --> 00:02:27,000
+it can still be a useful tool for troubleshooting and diagnosing network related issues in communication.
+
+30
+00:02:27,000 --> 00:02:35,000
+So in addition to the tools I mentioned earlier, Wireshark is also a valuable tool for testing and
+
+31
+00:02:35,000 --> 00:02:36,000
+debugging.
+
+32
+00:02:37,000 --> 00:02:38,000
+Swap UI.
+
+33
+00:02:38,000 --> 00:02:47,000
+Swap UI is an open source API testing tool that allows you to create and run automated functional regression
+
+34
+00:02:47,000 --> 00:02:51,000
+compliance and load tests for rest and soap APIs.
+
+35
+00:02:51,000 --> 00:02:54,000
+But what is soap?
+
+36
+00:02:54,000 --> 00:02:58,000
+Soap stands for Simple Object Access Protocol.
+
+37
+00:02:58,000 --> 00:03:04,000
+It is a messaging protocol that is used to exchange structure data between different applications over
+
+38
+00:03:04,000 --> 00:03:05,000
+the Internet.
+
+39
+00:03:05,000 --> 00:03:15,000
+It relies on XML as its message format and is typically used in web services to send requests and receive
+
+40
+00:03:15,000 --> 00:03:16,000
+responses.
+
+41
+00:03:17,000 --> 00:03:23,000
+Soap is a tool used for testing and developing web services that use soap.
+
+42
+00:03:24,000 --> 00:03:25,000
+Insomnia.
+
+43
+00:03:25,000 --> 00:03:34,000
+Insomnia is a free and open source rest client that enables you to send HTTP requests and user response
+
+44
+00:03:34,000 --> 00:03:36,000
+in a user friendly interface.
+
+45
+00:03:37,000 --> 00:03:38,000
+G matter.
+
+46
+00:03:38,000 --> 00:03:45,000
+Apache G matter is a popular open source tool for load testing and performance measurement of APIs,
+
+47
+00:03:45,000 --> 00:03:48,000
+web applications and other services.
+
+48
+00:03:49,000 --> 00:03:49,000
+You, man.
+
+49
+00:03:50,000 --> 00:03:56,000
+It is a common line tools that allows you to run and test postman collections from the command line,
+
+50
+00:03:56,000 --> 00:04:02,000
+making it a Gil for automated testing and integration with CI CD pipelines.
+
+51
+00:04:03,000 --> 00:04:09,000
+Rest assured it is a Java based library for testing restful APIs.
+
+52
+00:04:09,000 --> 00:04:17,000
+It allows you to write tests in Java and provides built in support for various HTTP methods, authentication
+
+53
+00:04:17,000 --> 00:04:19,000
+and response validation.
+
+54
+00:04:20,000 --> 00:04:25,000
+These are just few examples of the many tools available for API testing.
+
+55
+00:04:25,000 --> 00:04:32,000
+The choice of tool will depend on your specific needs, preferences and technical expertise.
+
+56
+00:04:33,000 --> 00:04:39,000
+All eight tools that I mentioned on the previous slide are really popular ones, but I would like to
+
+57
+00:04:39,000 --> 00:04:42,000
+draw your attention to three out of them.
+
+58
+00:04:42,000 --> 00:04:46,000
+They are Postman, fiddler and Wireshark.
+
+59
+00:04:47,000 --> 00:04:54,000
+I can't say that these tools are better than other API testing and debugging tools as the suitability
+
+60
+00:04:54,000 --> 00:04:58,000
+of a particular tool will depend on your specific needs and preferences.
+
+61
+00:04:58,000 --> 00:05:06,000
+However, these tools are widely used and have some advantages that make them popular choices among
+
+62
+00:05:06,000 --> 00:05:08,000
+developers and testers.
+
+63
+00:05:08,000 --> 00:05:11,000
+Postman is user friendly tools.
+
+64
+00:05:11,000 --> 00:05:17,000
+It provides a graphical user interface for creating testing and documenting APIs.
+
+65
+00:05:17,000 --> 00:05:25,000
+It supports a wide range of HTTP methods and formats and provides features like automatic request generation.
+
+66
+00:05:25,000 --> 00:05:27,000
+Code snippets and request history.
+
+67
+00:05:28,000 --> 00:05:35,000
+It is also used for easy collaboration with team members and integrates well with other tools in the
+
+68
+00:05:35,000 --> 00:05:37,000
+API development workflow.
+
+69
+00:05:37,000 --> 00:05:41,000
+Fiddler is a powerful web debugging proxy.
+
+70
+00:05:41,000 --> 00:05:49,000
+It can also be used to simulate network conditions such as low bandwidth or high latency.
+
+71
+00:05:49,000 --> 00:05:58,000
+To test the behavior of APIs under different network conditions, Wireshark is a network protocol analyzer.
+
+72
+00:05:58,000 --> 00:06:06,000
+It is often used to diagnose and troubleshoot network related issues and can be a valuable tool in identifying
+
+73
+00:06:06,000 --> 00:06:08,000
+and resolving issues.
+
+74
+00:06:09,000 --> 00:06:15,000
+Overall, the choice of tool will depend on the specific requirements of your API.
+
+75
+00:06:15,000 --> 00:06:21,000
+Testing and debugging tasks, as well as your personal preferences and experience.
+
+76
+00:06:21,000 --> 00:06:26,000
+All three tools used for debugging and testing network traffic.
+
+77
+00:06:26,000 --> 00:06:32,000
+Postman is an HTTP client that allows you to send HTTP requests and receive responses.
+
+78
+00:06:32,000 --> 00:06:40,000
+Fiddler is a web debugging proxy that captures and analyzes HTTP traffic between your computer and the
+
+79
+00:06:40,000 --> 00:06:41,000
+Internet.
+
+80
+00:06:41,000 --> 00:06:48,000
+And Wireshark is a network protocol analyzer that captures and displays network packets in real time.
+
+81
+00:06:48,000 --> 00:06:50,000
+That is a short summary.
+
+82
+00:06:50,000 --> 00:06:57,000
+So let's talk about Postman right now, because it is the most popular tool in my opinion.
+
+83
+00:06:58,000 --> 00:07:03,000
+As you already learned from the agenda today, we are going to talk about Postman.
+
+84
+00:07:04,000 --> 00:07:09,000
+I already told you on the high level about this tool during the review of previous slides.
+
+85
+00:07:09,000 --> 00:07:16,000
+In my opinion, Postman is tool number one that should be installed on your computer if you develop
+
+86
+00:07:16,000 --> 00:07:16,000
+for web.
+
+87
+00:07:17,000 --> 00:07:24,000
+It is relatively lightweight, it is super intuitive and you are going to see that it wouldn't take
+
+88
+00:07:24,000 --> 00:07:31,000
+too much time of yours to understand the interface and this is a huge advantage.
+
+89
+00:07:31,000 --> 00:07:36,000
+Let's learn this tool better to learn postman tool better.
+
+90
+00:07:36,000 --> 00:07:39,000
+Let's learn key components of this tool.
+
+91
+00:07:39,000 --> 00:07:42,000
+They are request builder.
+
+92
+00:07:42,000 --> 00:07:49,000
+Postman provides a user friendly interface for creating HTTP requests, allowing you to specify parameters
+
+93
+00:07:49,000 --> 00:07:55,000
+like HTTP method, URL headers and body response view.
+
+94
+00:07:56,000 --> 00:08:02,000
+Explore the response Status Code Size Response Time Headers Response Body.
+
+95
+00:08:03,000 --> 00:08:04,000
+Collection.
+
+96
+00:08:04,000 --> 00:08:11,000
+A collection in Postman is a group of related requests that can be organized and saved together.
+
+97
+00:08:11,000 --> 00:08:18,000
+It allows you to group and organize your requests for easier management and sharing with others.
+
+98
+00:08:18,000 --> 00:08:20,000
+Environment.
+
+99
+00:08:20,000 --> 00:08:26,000
+An environment in Postman allows you to configure variables that can be used across multiple requests.
+
+100
+00:08:27,000 --> 00:08:35,000
+This feature can be used to specify things like server URLs, authentication tokens or other parameters
+
+101
+00:08:35,000 --> 00:08:38,000
+that may change based on the environment.
+
+102
+00:08:40,000 --> 00:08:41,000
+Test scripts.
+
+103
+00:08:41,000 --> 00:08:48,000
+Postman provides a scripting feature that allows you to write JavaScript code to automate tasks, customize
+
+104
+00:08:48,000 --> 00:08:52,000
+requests, and perform assertions on responses.
+
+105
+00:08:52,000 --> 00:08:56,000
+Test scripts can be used to validate the response data.
+
+106
+00:08:56,000 --> 00:09:01,000
+Automate test cases and perform other custom operations.
+
+107
+00:09:02,000 --> 00:09:02,000
+Runner.
+
+108
+00:09:03,000 --> 00:09:09,000
+The postman runner allows it to execute a collection of requests automatically and generate reports.
+
+109
+00:09:09,000 --> 00:09:16,000
+It can be used for testing APIs, generating test reports and monitoring API performance.
+
+110
+00:09:17,000 --> 00:09:18,000
+Integrations.
+
+111
+00:09:18,000 --> 00:09:26,000
+Postman integrates with other tools in the API development workflow, such as Git, Jenkins and Swagger,
+
+112
+00:09:26,000 --> 00:09:30,000
+allowing for easier collaboration and workflow management.
+
+113
+00:09:30,000 --> 00:09:39,000
+Postman also offers several advanced features that help developers automate testing and improve productivity,
+
+114
+00:09:39,000 --> 00:09:43,000
+such as the ability to write test scripts in JavaScript.
+
+115
+00:09:43,000 --> 00:09:48,000
+Set environment variables and integrate with other development tools.
+
+116
+00:09:48,000 --> 00:09:56,000
+Overall, Postman plays a crucial role in the development process by making it easier for developers
+
+117
+00:09:56,000 --> 00:09:58,000
+to test and debug APIs.
+
+118
+00:09:58,000 --> 00:10:05,000
+Collaborate with team members and improve the overall quality and reliability of their APIs.
+
+119
+00:10:06,000 --> 00:10:10,000
+Let's now install the postman on your laptop.
+
+120
+00:10:10,000 --> 00:10:14,000
+I will provide you with step by step installation guide.
+
+121
+00:10:14,000 --> 00:10:19,000
+First of all, open a web browser and navigate to the Postman website.
+
+122
+00:10:20,000 --> 00:10:29,000
+You can easily get navigated directly to the downloads page or find hyper references on the home page.
+
+123
+00:10:30,000 --> 00:10:36,000
+Now you need to select whether you want to download desktop version or to use browser version.
+
+124
+00:10:36,000 --> 00:10:40,000
+Each version has its own advantages and disadvantages.
+
+125
+00:10:40,000 --> 00:10:46,000
+The desktop version of Postman is a standalone application that can be installed on your computer.
+
+126
+00:10:46,000 --> 00:10:52,000
+It offers more features and customization options compared to the browser version.
+
+127
+00:10:52,000 --> 00:10:59,000
+With the desktop version, you can create and manage collections of requests, write the scripts and
+
+128
+00:10:59,000 --> 00:11:05,000
+collaborate with the team members using features like version control and shared workspaces.
+
+129
+00:11:05,000 --> 00:11:13,000
+The desktop version also offers a more streamlined and faster user experience as it doesn't rely on
+
+130
+00:11:13,000 --> 00:11:14,000
+a web browser.
+
+131
+00:11:15,000 --> 00:11:21,000
+On the other hand, the browser version of Postman is a lightweight extension that can be installed
+
+132
+00:11:21,000 --> 00:11:23,000
+directly in your web browser.
+
+133
+00:11:23,000 --> 00:11:31,000
+It is a yield for quick testing and debugging of APIs as it doesn't require any installation or setup.
+
+134
+00:11:31,000 --> 00:11:38,000
+The browser version is also useful for users who prefer to work within their web browser and do not
+
+135
+00:11:38,000 --> 00:11:41,000
+want to switch between multiple applications.
+
+136
+00:11:41,000 --> 00:11:46,000
+However, it may have limited features compared to the desktop version.
+
+137
+00:11:47,000 --> 00:11:53,000
+Ultimately, the choice between the desktop and browser version of Postman depends on your specific
+
+138
+00:11:53,000 --> 00:11:55,000
+needs and preferences.
+
+139
+00:11:55,000 --> 00:12:03,000
+If you need advanced features and customizations or you work with APIs, frequently, the desktop version
+
+140
+00:12:03,000 --> 00:12:05,000
+may be a better fit.
+
+141
+00:12:05,000 --> 00:12:12,000
+However, if you only need basic API testing capabilities or prefer to work within your web browser,
+
+142
+00:12:12,000 --> 00:12:16,000
+the browser version may be more suitable.
+
+143
+00:12:16,000 --> 00:12:24,000
+So I believe that we will go with desktop version for that just download installer by clicking the biggest
+
+144
+00:12:24,000 --> 00:12:26,000
+button that you can see on the screen.
+
+145
+00:12:26,000 --> 00:12:33,000
+It automatically detects that have Windows and it offers me to download installer for Windows.
+
+146
+00:12:33,000 --> 00:12:39,000
+But in case you have other operating system, you can select another one below.
+
+147
+00:12:40,000 --> 00:12:47,000
+Once the download is complete, locate the downloaded file in your downloads folder or wherever you
+
+148
+00:12:47,000 --> 00:12:50,000
+saved it and just run installation file.
+
+149
+00:12:51,000 --> 00:12:55,000
+What will happen after doesn't require explanation.
+
+150
+00:12:55,000 --> 00:13:02,000
+Postman will be installed by default in the program files folder and will ask you nothing.
+
+151
+00:13:02,000 --> 00:13:04,000
+Now you can launch it.
+
+152
+00:13:04,000 --> 00:13:11,000
+When you launched it, you need to select whether you want to create an account and log in using credentials
+
+153
+00:13:11,000 --> 00:13:15,000
+or you will continue without registration.
+
+154
+00:13:15,000 --> 00:13:20,000
+Basically, you can click this link, skip, and go to the app and that's it.
+
+155
+00:13:21,000 --> 00:13:26,000
+In the next lesson, I'm going to make practical exercises together with you, and I will do screen
+
+156
+00:13:26,000 --> 00:13:31,000
+sharing to give you more practical experience of working with Postman.
+
+157
+00:13:31,000 --> 00:13:39,000
+Together we'll test our Rest API that we created in the previous lesson, But now let's recap what we
+
+158
+00:13:39,000 --> 00:13:41,000
+have learned in this video.
+
+159
+00:13:42,000 --> 00:13:46,000
+Today we did an overview of tools for API testing.
+
+160
+00:13:46,000 --> 00:13:51,000
+Now you know the difference between them and which one to choose.
+
+161
+00:13:51,000 --> 00:13:55,000
+I explained you what a soap messaging protocol is.
+
+162
+00:13:55,000 --> 00:14:01,000
+You know, such popular tools as Postman, Fiddler and Wireshark.
+
+163
+00:14:01,000 --> 00:14:07,000
+We learned key components of Postman compared desktop and web version.
+
+164
+00:14:07,000 --> 00:14:12,000
+And in the end of the lesson, we installed Postman desktop version on your computer.
+
+165
+00:14:12,000 --> 00:14:14,000
+Thanks a lot for your attention.
+
+166
+00:14:14,000 --> 00:14:17,000
+Have a great day and see you in the next lesson.
+

91 - REST Architecture/005 API Testing with Postman_en.srt

@@ -0,0 +1,1140 @@
+1
+00:00:06,000 --> 00:00:07,000
+Hello, Tim.
+
+2
+00:00:07,000 --> 00:00:09,000
+We created a restful service.
+
+3
+00:00:09,000 --> 00:00:15,000
+We did an overview of tools for the API testing, and we installed Postman.
+
+4
+00:00:15,000 --> 00:00:18,000
+This all we did in previous lessons.
+
+5
+00:00:18,000 --> 00:00:22,000
+And now it is time to learn how we can test our API.
+
+6
+00:00:23,000 --> 00:00:29,000
+This is going to be less full of practical examples, so we'll start lesson directly from the screen
+
+7
+00:00:29,000 --> 00:00:30,000
+sharing.
+
+8
+00:00:30,000 --> 00:00:37,000
+I'm going to make an overview of Postman interface and main UI elements that we are going to interact
+
+9
+00:00:37,000 --> 00:00:38,000
+with.
+
+10
+00:00:38,000 --> 00:00:45,000
+Also, I'm going to share with you a collection of requests and I will show you how you can import those
+
+11
+00:00:45,000 --> 00:00:50,000
+in your postman in order to repeat after me all my queries.
+
+12
+00:00:50,000 --> 00:00:56,000
+I will show how to export existing collections or how to create new collections.
+
+13
+00:00:57,000 --> 00:01:01,000
+I'm going to show you how you can send requests with different methods.
+
+14
+00:01:01,000 --> 00:01:03,000
+We'll read response.
+
+15
+00:01:03,000 --> 00:01:08,000
+We are going to learn how to work with responses and how to analyze them.
+
+16
+00:01:09,000 --> 00:01:14,000
+Also, we'll learn how to send and read custom headers.
+
+17
+00:01:14,000 --> 00:01:19,000
+We'll perform testing of our restful service that we created in previous lesson.
+
+18
+00:01:19,000 --> 00:01:23,000
+So we'll test all endpoints that we created.
+
+19
+00:01:24,000 --> 00:01:31,000
+We'll test, create, read, update, delete operations with a resource using our rest API.
+
+20
+00:01:32,000 --> 00:01:38,000
+Also, I'm going to explain you the difference between form data and form URL encoded.
+
+21
+00:01:38,000 --> 00:01:45,000
+Let's start our lesson and from this point we can jump to the live demo and I will proceed with the
+
+22
+00:01:45,000 --> 00:01:46,000
+screen sharing.
+
+23
+00:01:46,000 --> 00:01:50,000
+So here you can see Interface of the Postman.
+
+24
+00:01:50,000 --> 00:01:55,000
+Let me make a high level overview of the key UI elements here.
+
+25
+00:01:55,000 --> 00:02:00,000
+And after that we will dive deeper in details of each section by using it.
+
+26
+00:02:00,000 --> 00:02:07,000
+As you may already see, the Postman desktop version has a clean and user friendly interface that is
+
+27
+00:02:07,000 --> 00:02:10,000
+divided into several sections.
+
+28
+00:02:10,000 --> 00:02:14,000
+The main sections of the interface include sidebar.
+
+29
+00:02:14,000 --> 00:02:22,000
+The sidebar is located on the left hand side of the screen and provides access to all the features and
+
+30
+00:02:22,000 --> 00:02:24,000
+functions in Postman.
+
+31
+00:02:24,000 --> 00:02:33,000
+It includes tabs for collections, APIs, environments, mock servers, monitors and history request
+
+32
+00:02:33,000 --> 00:02:34,000
+builder.
+
+33
+00:02:34,000 --> 00:02:41,000
+The request builder is located in the center of the screen and allows you to create and send requests
+
+34
+00:02:41,000 --> 00:02:42,000
+to APIs.
+
+35
+00:02:42,000 --> 00:02:49,000
+It includes fields for the request mask, URL, parameters, headers and body.
+
+36
+00:02:50,000 --> 00:02:55,000
+Also, in case endpoint requires authorization, you can configure it here too.
+
+37
+00:02:55,000 --> 00:02:58,000
+You can capture cookies.
+
+38
+00:02:59,000 --> 00:03:00,000
+Quote, pain.
+
+39
+00:03:00,000 --> 00:03:03,000
+Here on the right you can find really useful tool.
+
+40
+00:03:03,000 --> 00:03:06,000
+It is called code snippet.
+
+41
+00:03:06,000 --> 00:03:14,000
+Basically, you can generate the code to execute required query no matter what you want to use curl
+
+42
+00:03:14,000 --> 00:03:17,000
+request or C-sharp or Java.
+
+43
+00:03:17,000 --> 00:03:22,000
+Just use this dropdown list to select what you need.
+
+44
+00:03:22,000 --> 00:03:28,000
+Later, you can use this code in your program in order to execute the query that you need.
+
+45
+00:03:29,000 --> 00:03:30,000
+Response.
+
+46
+00:03:30,000 --> 00:03:32,000
+Pain is a response.
+
+47
+00:03:32,000 --> 00:03:39,000
+Pain is located to the bottom of the request builder and displays the response data returned by the
+
+48
+00:03:39,000 --> 00:03:39,000
+API.
+
+49
+00:03:40,000 --> 00:03:45,000
+It includes tabs for the response body headers and cookies.
+
+50
+00:03:45,000 --> 00:03:50,000
+That's the place where we will observe what server responded us.
+
+51
+00:03:50,000 --> 00:03:53,000
+Test and console panes.
+
+52
+00:03:53,000 --> 00:04:01,000
+The test and console panes are located at the bottom of the screen and allow you to write and run tests
+
+53
+00:04:01,000 --> 00:04:03,000
+for your API requests.
+
+54
+00:04:03,000 --> 00:04:09,000
+The console pane displays log messages and errors generated by postman.
+
+55
+00:04:10,000 --> 00:04:11,000
+Top bar.
+
+56
+00:04:12,000 --> 00:04:18,000
+The top bar is located at the very top of the screen and includes the work space management.
+
+57
+00:04:19,000 --> 00:04:27,000
+Also, you can create an account if you want to personalize your experience or use Postman without account.
+
+58
+00:04:27,000 --> 00:04:28,000
+It is up to you.
+
+59
+00:04:29,000 --> 00:04:33,000
+Also, you can use search bar and settings.
+
+60
+00:04:33,000 --> 00:04:40,000
+Overall, the possible interface is designed to be intuitive and user friendly, with key UI elements
+
+61
+00:04:40,000 --> 00:04:44,000
+organized in a logical and easy to use manner.
+
+62
+00:04:45,000 --> 00:04:48,000
+So it is time to start using Postman.
+
+63
+00:04:48,000 --> 00:04:54,000
+For the sake of the demo, I started the web server and deployed the rest APIs that we developed together
+
+64
+00:04:54,000 --> 00:05:02,000
+in the previous lesson to interact with user resource and more demo endpoints.
+
+65
+00:05:02,000 --> 00:05:05,000
+Make sure that your server is running.
+
+66
+00:05:05,000 --> 00:05:10,000
+And now I'm going to execute queries imitating the development process.
+
+67
+00:05:11,000 --> 00:05:19,000
+Usually during the development you design and point implement it and then you want to test how it works.
+
+68
+00:05:19,000 --> 00:05:25,000
+You just open the postman and send some queries and explore what is returned.
+
+69
+00:05:26,000 --> 00:05:31,000
+So now when we know the interface, we can start working with Postman.
+
+70
+00:05:32,000 --> 00:05:40,000
+In the previous lesson we created our rest API and now let's learn Postman better by actually working
+
+71
+00:05:40,000 --> 00:05:40,000
+with it.
+
+72
+00:05:40,000 --> 00:05:49,000
+I will just imitate the regular flow that I would do as a developer or when I was supposed to test endpoints.
+
+73
+00:05:49,000 --> 00:05:54,000
+Today I'm going to show you how to create your own collections of requests.
+
+74
+00:05:55,000 --> 00:06:01,000
+But before we start, I want to say that in attachments to this lesson, you are going to find the reference
+
+75
+00:06:01,000 --> 00:06:03,000
+to the export of collections.
+
+76
+00:06:03,000 --> 00:06:11,000
+Basically, you can click import here and import my collections that I have shared in the attachments
+
+77
+00:06:11,000 --> 00:06:12,000
+to this lesson.
+
+78
+00:06:12,000 --> 00:06:18,000
+You just need drag and drop my export file into the area inside your postman.
+
+79
+00:06:19,000 --> 00:06:27,000
+Taking into account I already have such a collection, I would import it as a copy and after importing
+
+80
+00:06:27,000 --> 00:06:33,000
+you are going to have the same list of requests that I'm going to review with you today.
+
+81
+00:06:33,000 --> 00:06:39,000
+Or you can just follow my examples and create your own collection as you wish.
+
+82
+00:06:39,000 --> 00:06:46,000
+In case you want to export your collection, you can just find three dots here and click export.
+
+83
+00:06:46,000 --> 00:06:47,000
+That's it.
+
+84
+00:06:48,000 --> 00:06:50,000
+Let's send our first request.
+
+85
+00:06:51,000 --> 00:06:53,000
+Everything is simple here.
+
+86
+00:06:53,000 --> 00:06:59,000
+You just paste the URL into query pane where I take this URL.
+
+87
+00:06:59,000 --> 00:07:03,000
+Well, I deployed my web application.
+
+88
+00:07:03,000 --> 00:07:08,000
+It is available at localhost at default port 8080.
+
+89
+00:07:08,000 --> 00:07:12,000
+Our deployed application is called Spring Web.
+
+90
+00:07:12,000 --> 00:07:15,000
+And then goes, name of my endpoint.
+
+91
+00:07:16,000 --> 00:07:18,000
+Let me open the source code.
+
+92
+00:07:18,000 --> 00:07:19,000
+Here it is.
+
+93
+00:07:20,000 --> 00:07:21,000
+Users.
+
+94
+00:07:21,000 --> 00:07:24,000
+Let's get back to the postman.
+
+95
+00:07:24,000 --> 00:07:29,000
+Now we need to check which request method we are going to use to reach the resource.
+
+96
+00:07:29,000 --> 00:07:36,000
+By default, it is get method here, but you can use drop down to select the method that you need.
+
+97
+00:07:37,000 --> 00:07:39,000
+I'm ready to send the request.
+
+98
+00:07:39,000 --> 00:07:43,000
+I click send button and here is the response.
+
+99
+00:07:43,000 --> 00:07:46,000
+Let's explore it together.
+
+100
+00:07:46,000 --> 00:07:50,000
+This endpoint should return a collection of users.
+
+101
+00:07:50,000 --> 00:07:51,000
+You can see 200.
+
+102
+00:07:51,000 --> 00:07:52,000
+Okay.
+
+103
+00:07:52,000 --> 00:07:55,000
+Status code time of response.
+
+104
+00:07:55,000 --> 00:07:57,000
+Size of the response.
+
+105
+00:07:58,000 --> 00:07:58,000
+Here.
+
+106
+00:07:58,000 --> 00:08:05,000
+You can also use navigation pane to explore is a body or cookies or headers.
+
+107
+00:08:05,000 --> 00:08:09,000
+In this case there are no cookies, but there are some headers.
+
+108
+00:08:09,000 --> 00:08:14,000
+You can explore the response in the pretty or raw format.
+
+109
+00:08:14,000 --> 00:08:21,000
+Usually it is hard to work with raw format because it is not readable with pretty format.
+
+110
+00:08:21,000 --> 00:08:25,000
+You can collapse and expand the elements of the response.
+
+111
+00:08:26,000 --> 00:08:29,000
+The format of the response is auto detected.
+
+112
+00:08:29,000 --> 00:08:35,000
+But in case you need to change the format of the response, you can use this dropdown.
+
+113
+00:08:35,000 --> 00:08:40,000
+So in the response, you can see that I have multiple users here.
+
+114
+00:08:41,000 --> 00:08:49,000
+What you also would like to do usually is to store the request in order to not create the same request
+
+115
+00:08:49,000 --> 00:08:50,000
+each time from scratch.
+
+116
+00:08:51,000 --> 00:08:53,000
+So let's click Save Button.
+
+117
+00:08:54,000 --> 00:09:02,000
+But taking into account that this request is already saved in my postman, let's use save as option.
+
+118
+00:09:02,000 --> 00:09:06,000
+Specify meaningful name for the query in order.
+
+119
+00:09:06,000 --> 00:09:09,000
+You can easily understand what it is about.
+
+120
+00:09:10,000 --> 00:09:17,000
+You can also add the description to the query if you want to be able to recall what it is about later.
+
+121
+00:09:17,000 --> 00:09:21,000
+Each request should be a part of some collection.
+
+122
+00:09:21,000 --> 00:09:25,000
+You can see that I have collections here created already.
+
+123
+00:09:25,000 --> 00:09:33,000
+You can create new collection by clicking new collection button or just select one of the existing collections
+
+124
+00:09:33,000 --> 00:09:35,000
+in order to save the query.
+
+125
+00:09:36,000 --> 00:09:42,000
+Inside the collection, you can create folders in case you want to group your queries in another way.
+
+126
+00:09:42,000 --> 00:09:48,000
+Also, you can navigate between collections and folders using these breadcrumbs.
+
+127
+00:09:49,000 --> 00:09:50,000
+Taking into account.
+
+128
+00:09:50,000 --> 00:09:53,000
+I have this query saved already.
+
+129
+00:09:53,000 --> 00:09:58,000
+I would just click cancel button, but you can click save button.
+
+130
+00:09:58,000 --> 00:10:04,000
+All your collections you can find in the left pane collections.
+
+131
+00:10:04,000 --> 00:10:09,000
+Here they just double click on the request and you will open it.
+
+132
+00:10:10,000 --> 00:10:18,000
+The next request is to fetch user by ID using the endpoint that we created in previous lesson I specify
+
+133
+00:10:18,000 --> 00:10:21,000
+users end point and user ID.
+
+134
+00:10:22,000 --> 00:10:27,000
+Send request and here is my user with ID seven.
+
+135
+00:10:27,000 --> 00:10:30,000
+Everything works as expected.
+
+136
+00:10:30,000 --> 00:10:36,000
+I will not stop too much on this request because it is pretty straightforward.
+
+137
+00:10:36,000 --> 00:10:43,000
+Even in case you have any questions, remember that you can ask your questions below the video and I
+
+138
+00:10:43,000 --> 00:10:45,000
+will be happy to answer those.
+
+139
+00:10:45,000 --> 00:10:46,000
+Let's continue.
+
+140
+00:10:47,000 --> 00:10:50,000
+The next request is with request parameter.
+
+141
+00:10:50,000 --> 00:10:58,000
+This time we want to filter users by the first name and we learned that it is a good practice to use
+
+142
+00:10:58,000 --> 00:11:01,000
+request parameters for filtering and sorting.
+
+143
+00:11:01,000 --> 00:11:10,000
+In this case, I specify first name request parameter that is equal to admin, and in the response I
+
+144
+00:11:10,000 --> 00:11:14,000
+have multiple users who have first name admin.
+
+145
+00:11:15,000 --> 00:11:24,000
+Feel free to use query params section in order to add, enable or disable some query parameters and
+
+146
+00:11:24,000 --> 00:11:26,000
+it will help you to build the query.
+
+147
+00:11:27,000 --> 00:11:35,000
+The main thing is to specify key and value, but optionally for the documenting purposes you can specify
+
+148
+00:11:35,000 --> 00:11:41,000
+description to the next request is similar to the one that we have removed.
+
+149
+00:11:41,000 --> 00:11:46,000
+We use sort by query parameter to sort results by first name field.
+
+150
+00:11:47,000 --> 00:11:53,000
+You can notice that users in our response will be sorted by first name values.
+
+151
+00:11:53,000 --> 00:11:57,000
+The next thing is to demo post request.
+
+152
+00:11:57,000 --> 00:12:01,000
+We created request parameters demo endpoint.
+
+153
+00:12:01,000 --> 00:12:04,000
+Let me show it to you in the source code.
+
+154
+00:12:04,000 --> 00:12:11,000
+Just to remind you, this is the endpoint that can be accessed via post method and request.
+
+155
+00:12:11,000 --> 00:12:18,000
+Params still means not something what is sent in body of the request, but something what is specified
+
+156
+00:12:18,000 --> 00:12:20,000
+in the query as a parameter.
+
+157
+00:12:21,000 --> 00:12:29,000
+So in this case, when I send a request and pass one parameter, it is taken into account on the server
+
+158
+00:12:29,000 --> 00:12:35,000
+side and according to the logic that we created will return it back in the response.
+
+159
+00:12:35,000 --> 00:12:36,000
+Is it clear?
+
+160
+00:12:37,000 --> 00:12:38,000
+Amazing.
+
+161
+00:12:38,000 --> 00:12:44,000
+We also created an endpoint that passes all requests parameters into the map.
+
+162
+00:12:45,000 --> 00:12:54,000
+You can pass multiple parameters and in Java source code you can work with all of them as with the map.
+
+163
+00:12:55,000 --> 00:12:57,000
+And here is how this endpoint works.
+
+164
+00:12:58,000 --> 00:13:03,000
+I send request and return entry set of parameters.
+
+165
+00:13:04,000 --> 00:13:12,000
+In case you want to pass information in the request body similar to the way how we transmit this data
+
+166
+00:13:12,000 --> 00:13:16,000
+with the help of HTML forms, you can do it too.
+
+167
+00:13:16,000 --> 00:13:24,000
+Let's navigate to the body tab, specify the data type that you want to send as form data.
+
+168
+00:13:25,000 --> 00:13:29,000
+Select is a form data or form URL encoded.
+
+169
+00:13:29,000 --> 00:13:32,000
+What is the difference between these?
+
+170
+00:13:32,000 --> 00:13:40,000
+The main difference between the two is in how the data is formatted and send form.
+
+171
+00:13:40,000 --> 00:13:47,000
+Data is used to send binary data such as images or files as well as text data.
+
+172
+00:13:47,000 --> 00:13:55,000
+It is commonly used when uploading files or submitting forms with file inputs in form data.
+
+173
+00:13:55,000 --> 00:14:03,000
+Each key value pair is separated by a boundary string and is sent in a separate section, which makes
+
+174
+00:14:03,000 --> 00:14:07,000
+it more suitable for sending large files.
+
+175
+00:14:08,000 --> 00:14:11,000
+X3W form urlencoded.
+
+176
+00:14:11,000 --> 00:14:20,000
+On the other hand, is used to send simple text data in the format of key value pairs separated by an
+
+177
+00:14:20,000 --> 00:14:22,000
+ampersand symbol.
+
+178
+00:14:22,000 --> 00:14:29,000
+It is commonly used when submitting form data without file inputs in form.
+
+179
+00:14:29,000 --> 00:14:30,000
+Urlencoded.
+
+180
+00:14:30,000 --> 00:14:35,000
+The data is encoded and sent as a single string in the request body.
+
+181
+00:14:36,000 --> 00:14:42,000
+In summary, if you need to send binary data or large files, use form data.
+
+182
+00:14:42,000 --> 00:14:49,000
+If you are sending simple text data, use X3W form URL encoded.
+
+183
+00:14:49,000 --> 00:14:55,000
+So in this case I select form URL encoded and send the request.
+
+184
+00:14:56,000 --> 00:15:00,000
+In response we can see form data from the request body.
+
+185
+00:15:00,000 --> 00:15:08,000
+And just to remind you that on the backend side we need to specify that this endpoint consumes specific
+
+186
+00:15:08,000 --> 00:15:11,000
+media type in the source code.
+
+187
+00:15:11,000 --> 00:15:17,000
+You can see that I specified that this endpoint consumes application form URL encoded.
+
+188
+00:15:17,000 --> 00:15:19,000
+That's how it works.
+
+189
+00:15:19,000 --> 00:15:26,000
+Also, I wanted to show you that theoretically you can pass list of parameters, comma, separated values
+
+190
+00:15:26,000 --> 00:15:29,000
+like you can see in this example.
+
+191
+00:15:29,000 --> 00:15:37,000
+You can send multiple IDs at once, putting them in one request parameter that is called IDs.
+
+192
+00:15:38,000 --> 00:15:42,000
+On the backend side, they are passed into the list of values.
+
+193
+00:15:43,000 --> 00:15:46,000
+I just print the list of values into the response.
+
+194
+00:15:46,000 --> 00:15:52,000
+Nothing special, but you can build your business logic around the list of values.
+
+195
+00:15:52,000 --> 00:15:53,000
+As you wish.
+
+196
+00:15:54,000 --> 00:16:01,000
+The next thing that I would like to show you is how you can test that custom response status is returned.
+
+197
+00:16:02,000 --> 00:16:08,000
+Just to remind you that on the backend for one of our endpoints, we configure it.
+
+198
+00:16:08,000 --> 00:16:16,000
+I'm a T port response status and when I send requests to this endpoint in the Postman, I can see that
+
+199
+00:16:16,000 --> 00:16:20,000
+the response status code is 418.
+
+200
+00:16:20,000 --> 00:16:22,000
+You can see status code here.
+
+201
+00:16:23,000 --> 00:16:28,000
+This is achieved by using response status annotation in the source code.
+
+202
+00:16:28,000 --> 00:16:36,000
+Another interesting thing about Postman, you can see that server generated HTML page for us.
+
+203
+00:16:36,000 --> 00:16:41,000
+You can use preview mode in order to preview page markup.
+
+204
+00:16:41,000 --> 00:16:49,000
+Also here you can see the reason that we also specified in the response status annotation demo endpoint
+
+205
+00:16:49,000 --> 00:16:50,000
+reason.
+
+206
+00:16:50,000 --> 00:16:54,000
+Now let's delete the resource using rest API.
+
+207
+00:16:55,000 --> 00:17:00,000
+If you remember, we have test user John Doe with a 12.
+
+208
+00:17:00,000 --> 00:17:02,000
+Let's remove it.
+
+209
+00:17:02,000 --> 00:17:08,000
+I specify user ID that I want to delete and send request via delete method.
+
+210
+00:17:09,000 --> 00:17:13,000
+Pay attention that no content string has been returned.
+
+211
+00:17:13,000 --> 00:17:14,000
+Why?
+
+212
+00:17:14,000 --> 00:17:21,000
+Because I used HTTP status as a returned value and it was casted to string value.
+
+213
+00:17:22,000 --> 00:17:25,000
+The actual status of the response is 200.
+
+214
+00:17:25,000 --> 00:17:26,000
+Okay.
+
+215
+00:17:27,000 --> 00:17:27,000
+Why?
+
+216
+00:17:27,000 --> 00:17:28,000
+I show you this.
+
+217
+00:17:29,000 --> 00:17:36,000
+Just to highlight that in case you want to control response status, setting up the returned value is
+
+218
+00:17:36,000 --> 00:17:37,000
+not enough.
+
+219
+00:17:37,000 --> 00:17:42,000
+You need to use response status annotation to configure custom response status.
+
+220
+00:17:43,000 --> 00:17:50,000
+And this time, in case we would request user's resource, we are going to see that there is no John
+
+221
+00:17:50,000 --> 00:17:52,000
+Doe user object anymore.
+
+222
+00:17:53,000 --> 00:17:57,000
+Thus, we can be sure that endpoint works as expected.
+
+223
+00:17:58,000 --> 00:18:00,000
+Let's now create the resource.
+
+224
+00:18:00,000 --> 00:18:03,000
+Usually we create resources with the post method.
+
+225
+00:18:04,000 --> 00:18:07,000
+In our rest service we have users endpoint.
+
+226
+00:18:08,000 --> 00:18:12,000
+Does it create resource in case resource is reached with a post method?
+
+227
+00:18:13,000 --> 00:18:23,000
+In this case we need to open body tab, select row form of data and insert the JSON of your user resource.
+
+228
+00:18:24,000 --> 00:18:33,000
+You can see here that I pass key value pairs That reflects the state of the user object and I just click
+
+229
+00:18:33,000 --> 00:18:34,000
+send request button.
+
+230
+00:18:35,000 --> 00:18:36,000
+That's it.
+
+231
+00:18:36,000 --> 00:18:38,000
+Resource is created.
+
+232
+00:18:38,000 --> 00:18:43,000
+Let's now call all users to make sure that the new user is created.
+
+233
+00:18:44,000 --> 00:18:49,000
+And in the bottom we can see that new user with fake data was created.
+
+234
+00:18:50,000 --> 00:18:51,000
+Amazing.
+
+235
+00:18:51,000 --> 00:18:55,000
+Let's imagine now that we want to update resource.
+
+236
+00:18:55,000 --> 00:18:58,000
+Usually we update resource, we have put method.
+
+237
+00:18:59,000 --> 00:19:08,000
+So in the next example, I also send JSON in the body of the request, but I want to update an email.
+
+238
+00:19:09,000 --> 00:19:13,000
+I want to change email in order it would have test email domain.
+
+239
+00:19:14,000 --> 00:19:16,000
+Let me send the request.
+
+240
+00:19:16,000 --> 00:19:19,000
+Web server accepted my request.
+
+241
+00:19:19,000 --> 00:19:21,000
+Let's check all users again.
+
+242
+00:19:23,000 --> 00:19:32,000
+And you can see that email value right now ends up not with Email.com but with test email.com.
+
+243
+00:19:32,000 --> 00:19:40,000
+And pay attention that in real life, in case you have applications that consists from multiple services,
+
+244
+00:19:40,000 --> 00:19:45,000
+the services can exchange the data and communicate in the similar way.
+
+245
+00:19:45,000 --> 00:19:53,000
+We just use Postman as a client now, but in real life this can be any other application generating
+
+246
+00:19:53,000 --> 00:19:57,000
+requests and acting as a client of our application.
+
+247
+00:19:57,000 --> 00:20:04,000
+The next thing that I wanted you to demo is how to return an object of response entity type.
+
+248
+00:20:04,000 --> 00:20:11,000
+You can remember that in previous lesson when we created our restful service, I showed you that you
+
+249
+00:20:11,000 --> 00:20:19,000
+can return response entity in order to configure response status response headers and response body
+
+250
+00:20:19,000 --> 00:20:20,000
+in one object.
+
+251
+00:20:21,000 --> 00:20:29,000
+In this particular example, you can see that after I send request, I receive custom response body
+
+252
+00:20:29,000 --> 00:20:31,000
+and custom response header.
+
+253
+00:20:31,000 --> 00:20:34,000
+Let me show it to you on the header.
+
+254
+00:20:34,000 --> 00:20:34,000
+Stop.
+
+255
+00:20:35,000 --> 00:20:39,000
+Here you can see custom header and fake data.
+
+256
+00:20:40,000 --> 00:20:45,000
+Also, if you wish, you can configure custom status code.
+
+257
+00:20:46,000 --> 00:20:51,000
+The next example is to demo and check request header annotation.
+
+258
+00:20:52,000 --> 00:20:59,000
+I can specify custom headers and submit them to the rest API on the header stop.
+
+259
+00:20:59,000 --> 00:21:05,000
+You can see headers that are added by default here and additional custom header.
+
+260
+00:21:05,000 --> 00:21:14,000
+For example, in case I want to send accept language header, I just add it here and specify value for
+
+261
+00:21:14,000 --> 00:21:14,000
+it.
+
+262
+00:21:14,000 --> 00:21:22,000
+And as usual, you're welcome to leave any description in case it would help us in documenting the requests.
+
+263
+00:21:23,000 --> 00:21:31,000
+When I send a request, my endpoint passes, request header and return header value in response.
+
+264
+00:21:32,000 --> 00:21:34,000
+Everything works as expected.
+
+265
+00:21:34,000 --> 00:21:36,000
+Let's move on.
+
+266
+00:21:36,000 --> 00:21:43,000
+In the next example, I demonstrate endpoints that parses all the headers into the map and in the source
+
+267
+00:21:43,000 --> 00:21:49,000
+code you can work with the map of key value pairs that represent headers.
+
+268
+00:21:49,000 --> 00:21:54,000
+In this particular case, I just send them back in the response.
+
+269
+00:21:54,000 --> 00:21:55,000
+That's it.
+
+270
+00:21:55,000 --> 00:21:58,000
+We tested all our endpoints.
+
+271
+00:21:59,000 --> 00:22:04,000
+I hope that this lesson was useful for you and it will help you during the daily activities.
+
+272
+00:22:04,000 --> 00:22:08,000
+Let's recap what we have learned in the lesson.
+
+273
+00:22:09,000 --> 00:22:14,000
+Today we learned postman user interface and key UI elements.
+
+274
+00:22:14,000 --> 00:22:22,000
+I showed you how we can work with collections, how to import export collections, and how to create
+
+275
+00:22:22,000 --> 00:22:23,000
+new collections of requests.
+
+276
+00:22:24,000 --> 00:22:28,000
+You saw how to work with requests and responses.
+
+277
+00:22:28,000 --> 00:22:33,000
+During the lesson, we sent requests with a different HTTP methods.
+
+278
+00:22:33,000 --> 00:22:37,000
+Also, you saw how to read responses.
+
+279
+00:22:38,000 --> 00:22:43,000
+We worked with custom headers by sending them and receiving custom headers.
+
+280
+00:22:43,000 --> 00:22:48,000
+We tested our restful service and all its endpoints.
+
+281
+00:22:49,000 --> 00:22:56,000
+Also, you learned how to execute, create, read, update and delete operations with resource.
+
+282
+00:22:56,000 --> 00:23:04,000
+And at the end of the lesson, we learned the difference between form data and X3W form URL encoded.
+
+283
+00:23:05,000 --> 00:23:07,000
+That's all for this lesson.
+
+284
+00:23:07,000 --> 00:23:09,000
+Thanks a lot for your attention.
+
+285
+00:23:09,000 --> 00:23:12,000
+Have a great day and see you in the next lesson.
+

91 - REST Architecture/005 Commit-with-changes.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/36722187fd1478db83cd95bd24f6204e4e228092

91 - REST Architecture/005 Postman-collections.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/java-learnit-spring-web/tree/master/src/main/resources/postman-collections

91 - REST Architecture/external-links.txt

@@ -0,0 +1,9 @@
+
+003 Source-code-of-examples-commit-with-changes-
+https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/5f6b4f695bb88865978fb7cbe622855783c17cfa
+
+005 Postman-collections
+https://github.com/AndriiPiatakha/java-learnit-spring-web/tree/master/src/main/resources/postman-collections
+
+005 Commit-with-changes
+https://github.com/AndriiPiatakha/java-learnit-spring-web/commit/36722187fd1478db83cd95bd24f6204e4e228092

92 - Spring Boot/001 Spring Boot Introduction_en.srt

@@ -0,0 +1,1084 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, Kim.
+
+2
+00:00:06,000 --> 00:00:13,000
+With this lesson, we start learning Spring Boot taking into account this is an introduction to Spring
+
+3
+00:00:13,000 --> 00:00:13,000
+boot.
+
+4
+00:00:13,000 --> 00:00:20,000
+This is going to be theoretical lesson, but I'm sure that it is super important in order we can set
+
+5
+00:00:20,000 --> 00:00:27,000
+the context, understand what spring boot is, when to use it, and other general things.
+
+6
+00:00:27,000 --> 00:00:34,000
+We're going to start from the important question that students ask me very often where to start learning
+
+7
+00:00:34,000 --> 00:00:35,000
+of Spring boot.
+
+8
+00:00:35,000 --> 00:00:39,000
+Do we need to start learning other modules from spring framework?
+
+9
+00:00:39,000 --> 00:00:42,000
+Or we can start learning of the spring boot directly?
+
+10
+00:00:42,000 --> 00:00:47,000
+We are going to review this question and we will try to answer it.
+
+11
+00:00:47,000 --> 00:00:53,000
+You're going to understand what is the difference and what a connection between Spring framework and
+
+12
+00:00:53,000 --> 00:00:54,000
+Spring boot.
+
+13
+00:00:54,000 --> 00:00:57,000
+I will explain you what Spring Boot is.
+
+14
+00:00:57,000 --> 00:01:05,000
+We'll discuss its key features, take into account that opinionated development approach is used in
+
+15
+00:01:05,000 --> 00:01:06,000
+the spring boot.
+
+16
+00:01:06,000 --> 00:01:08,000
+We're going to learn what it is.
+
+17
+00:01:09,000 --> 00:01:14,000
+I will explain when to use and when not to use Spring Boot.
+
+18
+00:01:14,000 --> 00:01:20,000
+And at the end of the lesson, we are going to summarize advantages and disadvantages of Spring Boot.
+
+19
+00:01:20,000 --> 00:01:22,000
+Let's start our lesson.
+
+20
+00:01:22,000 --> 00:01:26,000
+Let's start from the first and important question.
+
+21
+00:01:26,000 --> 00:01:33,000
+A lot of students of mine ask me where to start learning Spring Boot and what's it worth to start learning
+
+22
+00:01:33,000 --> 00:01:40,000
+Spring Boot straight away in case there is no understanding about Spring Framework and its other projects.
+
+23
+00:01:40,000 --> 00:01:47,000
+Because very often students hear Spring boot like a buzzword and believes that they need to learn it
+
+24
+00:01:47,000 --> 00:01:54,000
+as soon as possible and start learning it without understanding of what spring framework is.
+
+25
+00:01:54,000 --> 00:02:02,000
+In general, if a student of my course Java from zero to first job, then you remember that when we
+
+26
+00:02:02,000 --> 00:02:08,000
+started learning of spring modules, different spring projects, I said that there are two different
+
+27
+00:02:08,000 --> 00:02:10,000
+approaches in learning Spring framework.
+
+28
+00:02:10,000 --> 00:02:18,000
+The first one is to run projects from spring framework and only then start learning Spring Boot and
+
+29
+00:02:18,000 --> 00:02:25,000
+the second approach start learning of spring boot and gradually learn all the projects of Spring framework.
+
+30
+00:02:25,000 --> 00:02:33,000
+Based on my experience and work with many students during multiple years, I can confirm that In my
+
+31
+00:02:33,000 --> 00:02:38,000
+opinion, you should start from learning Spring framework and its different projects.
+
+32
+00:02:38,000 --> 00:02:39,000
+Why?
+
+33
+00:02:39,000 --> 00:02:44,000
+Because at the end of the day, Spring Boot is built on top of spring framework.
+
+34
+00:02:44,000 --> 00:02:51,000
+So understanding spring frameworks, core concepts and features is essential.
+
+35
+00:02:51,000 --> 00:02:58,000
+Before diving into spring boot, Spring Framework provides a strong foundation for building enterprise
+
+36
+00:02:58,000 --> 00:03:05,000
+level Java applications, and it includes several modules that cover different aspects of application
+
+37
+00:03:05,000 --> 00:03:11,000
+development, such as core container data, access, web and more.
+
+38
+00:03:11,000 --> 00:03:19,000
+Familiarity with these modules will give you a better understanding of how Spring Boot works and its
+
+39
+00:03:19,000 --> 00:03:21,000
+underlying mechanisms.
+
+40
+00:03:21,000 --> 00:03:27,000
+Once you have a good understanding of spring framework, you can then move on to spring boot.
+
+41
+00:03:27,000 --> 00:03:34,000
+Spring Boot simplifies the setup and configuration of spring based applications, making it easier to
+
+42
+00:03:34,000 --> 00:03:40,000
+create standalone production grade spring applications quickly.
+
+43
+00:03:40,000 --> 00:03:47,000
+However, it is important to note that Spring Boot doesn't replace spring framework entirely, as it
+
+44
+00:03:47,000 --> 00:03:50,000
+still relies on many of its core components.
+
+45
+00:03:50,000 --> 00:03:58,000
+So it is best for students to learn spring framework first and then move on to Spring Boot to gain a
+
+46
+00:03:58,000 --> 00:04:05,000
+deeper understanding of how both frameworks work together to create powerful and scalable applications.
+
+47
+00:04:05,000 --> 00:04:12,000
+By saying this, I want to highlight that in case you didn't watch previous lessons about spring, I
+
+48
+00:04:12,000 --> 00:04:18,000
+would recommend you to start from them because it will help you to understand some basic concepts about
+
+49
+00:04:18,000 --> 00:04:21,000
+spring framework and some terminology.
+
+50
+00:04:21,000 --> 00:04:24,000
+In this lesson we start learning spring Boot.
+
+51
+00:04:24,000 --> 00:04:27,000
+So let's understand what a spring boot is.
+
+52
+00:04:28,000 --> 00:04:35,000
+Spring Boot is a popular Java based framework that is used to create standalone production, ready spring
+
+53
+00:04:35,000 --> 00:04:40,000
+applications quickly and with minimal setup like we already discussed.
+
+54
+00:04:40,000 --> 00:04:47,000
+It is built on top of the spring framework and provides a number of additional features and improvements
+
+55
+00:04:47,000 --> 00:04:55,000
+to simplify the development process and reduce the time and effort required to build complex applications.
+
+56
+00:04:55,000 --> 00:05:01,000
+Also, we can say that Spring Boot is a spring module that provides the rapid application development
+
+57
+00:05:01,000 --> 00:05:03,000
+feature to the spring framework.
+
+58
+00:05:03,000 --> 00:05:11,000
+It is used to create a standalone spring based application that you can just run because it needs minimal
+
+59
+00:05:11,000 --> 00:05:12,000
+spring configuration.
+
+60
+00:05:13,000 --> 00:05:21,000
+In short, Spring Boot is a combination of spring framework and embedded server, so you even don't
+
+61
+00:05:21,000 --> 00:05:24,000
+need to configure Tomcat separately.
+
+62
+00:05:24,000 --> 00:05:32,000
+The web server is built in and you can run the application with Java very simply because the application
+
+63
+00:05:32,000 --> 00:05:35,000
+is packaged into the jar archive.
+
+64
+00:05:36,000 --> 00:05:36,000
+In spring boot.
+
+65
+00:05:37,000 --> 00:05:42,000
+There is no requirement for XML configuration deployment descriptor.
+
+66
+00:05:42,000 --> 00:05:47,000
+It uses convention over configuration software design paradigm.
+
+67
+00:05:47,000 --> 00:05:50,000
+That means it decreases the effort of the developer.
+
+68
+00:05:51,000 --> 00:05:58,000
+One of the key features of Spring Boot is its opinionated approach to application development, which
+
+69
+00:05:58,000 --> 00:06:06,000
+means that it provides a set of defaults and conventions that are optimized for common use cases.
+
+70
+00:06:06,000 --> 00:06:13,000
+This approach minimizes the need for developers to make many decisions about configuration and setup,
+
+71
+00:06:13,000 --> 00:06:17,000
+allowing them to focus on writing business logic instead.
+
+72
+00:06:18,000 --> 00:06:23,000
+We're going to talk more about the opinionated approach on the separate slide.
+
+73
+00:06:23,000 --> 00:06:31,000
+Spring Boot also includes a number of built in features and tools that are designed to make common tasks,
+
+74
+00:06:31,000 --> 00:06:39,000
+such as setting up a web server, handling data persistence, or integrating with external services
+
+75
+00:06:39,000 --> 00:06:42,000
+as simple and straightforward as possible.
+
+76
+00:06:42,000 --> 00:06:49,000
+Additionally, Spring Boot has a large and active community, which means that developers can easily
+
+77
+00:06:49,000 --> 00:06:56,000
+find help, resources and third party plugins to extend its functionality.
+
+78
+00:06:57,000 --> 00:07:04,000
+Overall, Spring Boot is an excellent choice for Java developers who want to create robust, scalable
+
+79
+00:07:04,000 --> 00:07:08,000
+and maintainable applications quickly and efficiently.
+
+80
+00:07:09,000 --> 00:07:11,000
+Let's now learn features of Spring boot.
+
+81
+00:07:12,000 --> 00:07:14,000
+This will help you to understand it better.
+
+82
+00:07:15,000 --> 00:07:22,000
+Spring Boot comes with a rich set of features that make it an excellent choice for developing modern
+
+83
+00:07:22,000 --> 00:07:24,000
+Java applications.
+
+84
+00:07:24,000 --> 00:07:26,000
+Here are some of its key features.
+
+85
+00:07:27,000 --> 00:07:29,000
+Easy setup and configuration.
+
+86
+00:07:29,000 --> 00:07:30,000
+Spring Boot.
+
+87
+00:07:30,000 --> 00:07:38,000
+Opinionated approach to application development simplifies the setup process and provides a set of default
+
+88
+00:07:38,000 --> 00:07:42,000
+configurations that are optimized for common use cases.
+
+89
+00:07:43,000 --> 00:07:50,000
+Developers can get up and running with a new project quickly without having to spend a lot of time on
+
+90
+00:07:50,000 --> 00:07:51,000
+configuration and setup.
+
+91
+00:07:52,000 --> 00:07:54,000
+Built in web server.
+
+92
+00:07:54,000 --> 00:08:00,000
+I already told you that Spring Boot includes an embedded web server which allows developers to easily
+
+93
+00:08:00,000 --> 00:08:07,000
+create web based applications without having to configure and manage an external web server.
+
+94
+00:08:07,000 --> 00:08:15,000
+So there is no problems with questions which Tomcat version to download and how to run it and how to
+
+95
+00:08:15,000 --> 00:08:17,000
+deploy our web application.
+
+96
+00:08:18,000 --> 00:08:19,000
+Dependency management.
+
+97
+00:08:19,000 --> 00:08:26,000
+Spring Boot includes a powerful dependency management system that makes it easy to manage the dependencies
+
+98
+00:08:26,000 --> 00:08:29,000
+required by an application.
+
+99
+00:08:29,000 --> 00:08:36,000
+It automatically manages versions and conflicts and can then load and cache dependencies automatically.
+
+100
+00:08:36,000 --> 00:08:40,000
+But be aware that each feature comes with a price.
+
+101
+00:08:40,000 --> 00:08:47,000
+A little bit later in the lesson, I am going to explain that automatic dependency management can lead
+
+102
+00:08:47,000 --> 00:08:48,000
+to troubles.
+
+103
+00:08:48,000 --> 00:08:53,000
+Basically, everything what is happened without our control can lead to troubles.
+
+104
+00:08:53,000 --> 00:08:55,000
+Just remember this.
+
+105
+00:08:56,000 --> 00:08:57,000
+Automatic configuration.
+
+106
+00:08:58,000 --> 00:09:04,000
+Spring Boot uses convention over configuration to automatically configure common components such as
+
+107
+00:09:04,000 --> 00:09:11,000
+data sources, messaging systems, and web servers based on the dependencies that are included in an
+
+108
+00:09:11,000 --> 00:09:12,000
+application.
+
+109
+00:09:13,000 --> 00:09:14,000
+Actuator.
+
+110
+00:09:14,000 --> 00:09:23,000
+Spring boot actuator provides a set of endpoints and tools that make it easy to monitor and manage an
+
+111
+00:09:23,000 --> 00:09:25,000
+application at runtime.
+
+112
+00:09:25,000 --> 00:09:33,000
+It includes health checks, metrics and other diagnostic tools that can be used to monitor and troubleshoot
+
+113
+00:09:33,000 --> 00:09:35,000
+an application in production.
+
+114
+00:09:36,000 --> 00:09:38,000
+Spring Boot Common Line interface.
+
+115
+00:09:38,000 --> 00:09:44,000
+Spring Boot includes a command line interface that makes it easy to quickly prototype and develop new
+
+116
+00:09:44,000 --> 00:09:46,000
+applications.
+
+117
+00:09:46,000 --> 00:09:53,000
+The command line interface provides a set of commands for creating testing and running applications.
+
+118
+00:09:54,000 --> 00:09:55,000
+Integrations.
+
+119
+00:09:55,000 --> 00:10:02,000
+Spring Boot integrates with a wide range of other technologies and frameworks, including Spring Cloud
+
+120
+00:10:02,000 --> 00:10:03,000
+and more.
+
+121
+00:10:03,000 --> 00:10:10,000
+Overall, Spring Boot is a powerful and flexible framework that makes it easy to develop, deploy and
+
+122
+00:10:10,000 --> 00:10:13,000
+manage modern Java applications.
+
+123
+00:10:13,000 --> 00:10:21,000
+Its rich set of features and tools make it a popular choice for developers of all levels of experience.
+
+124
+00:10:21,000 --> 00:10:26,000
+Previously, I mentioned that Spring Boot uses opinionated development approach.
+
+125
+00:10:26,000 --> 00:10:29,000
+Let's understand what it is.
+
+126
+00:10:29,000 --> 00:10:36,000
+Opinionated development is an approach that emphasizes a strong point of view on how software should
+
+127
+00:10:36,000 --> 00:10:39,000
+be designed, built and deployed.
+
+128
+00:10:39,000 --> 00:10:46,000
+In this approach, a framework or toolset provides a set of predefined conventions and best practices
+
+129
+00:10:46,000 --> 00:10:52,000
+that guide developers towards a specific way of building applications.
+
+130
+00:10:53,000 --> 00:10:59,000
+According to another definition, an opinionated approach is a software design pattern that guides users
+
+131
+00:10:59,000 --> 00:11:07,000
+when creating spring apps, that helps developers add and customize starter dependencies.
+
+132
+00:11:07,000 --> 00:11:15,000
+Spring Boots Opinionated approach chooses the right values and packages to install saving developers
+
+133
+00:11:15,000 --> 00:11:15,000
+time.
+
+134
+00:11:16,000 --> 00:11:22,000
+An opinionated framework like Spring Boot is designed to make certain decisions for developers, reducing
+
+135
+00:11:22,000 --> 00:11:27,000
+the amount of time and effort required to set up an application.
+
+136
+00:11:27,000 --> 00:11:33,000
+For example, Spring Boots Auto Configuration feature automatically configures many common components
+
+137
+00:11:33,000 --> 00:11:41,000
+like data sources, web servers and messaging systems based on the dependencies included in the application.
+
+138
+00:11:42,000 --> 00:11:49,000
+This opinionated approach can have several benefits, such as faster development, reduced complexity
+
+139
+00:11:49,000 --> 00:11:51,000
+and improved consistency.
+
+140
+00:11:51,000 --> 00:11:58,000
+Developers can focus on building the application's unique features and business logic rather than spending
+
+141
+00:11:58,000 --> 00:12:02,000
+time on routine tasks like configuration and setup.
+
+142
+00:12:03,000 --> 00:12:11,000
+However, be attentive, the opinionated approach can also be a disadvantage if developers need to deviate
+
+143
+00:12:11,000 --> 00:12:15,000
+from the frameworks predefined conventions.
+
+144
+00:12:15,000 --> 00:12:23,000
+This can require more effort and expertise as developers must understand the frameworks, architecture
+
+145
+00:12:23,000 --> 00:12:27,000
+and implementation details to customize it effectively.
+
+146
+00:12:27,000 --> 00:12:36,000
+That's exactly what I mean when I say that you need to understand how spring works, then it will be
+
+147
+00:12:36,000 --> 00:12:44,000
+easier for you to master spring boot and also level of flexibility of spring boot potentially may become
+
+148
+00:12:44,000 --> 00:12:50,000
+as one of the disadvantages, in my opinion, that we're going to talk about, when we will talk about
+
+149
+00:12:50,000 --> 00:12:52,000
+advantages and disadvantages.
+
+150
+00:12:52,000 --> 00:12:59,000
+An opinionated development approach can be a powerful tool for improving productivity and consistency,
+
+151
+00:12:59,000 --> 00:13:06,000
+but it is important to weigh the benefits and tradeoffs for your specific project and team.
+
+152
+00:13:07,000 --> 00:13:10,000
+We already learned the definition of spring boot.
+
+153
+00:13:10,000 --> 00:13:16,000
+Let's understand when it is more applicable and when it is less applicable.
+
+154
+00:13:16,000 --> 00:13:20,000
+Let's start from learning of when it is good idea to use spring boot.
+
+155
+00:13:21,000 --> 00:13:28,000
+Spring Boot is an excellent choice for developing a wide range of Java based applications, but it is
+
+156
+00:13:28,000 --> 00:13:33,000
+particularly well suited for projects that require rapid development.
+
+157
+00:13:33,000 --> 00:13:41,000
+Spring Boots Opinionated approach to application development along with its easy setup and configuration,
+
+158
+00:13:41,000 --> 00:13:47,000
+make it an ideal choice for rapid prototyping and development of new applications.
+
+159
+00:13:47,000 --> 00:13:49,000
+Microservices.
+
+160
+00:13:49,000 --> 00:13:56,000
+Spring Boot is well suited for developing microservices based architectures as it provides built in
+
+161
+00:13:56,000 --> 00:14:03,000
+support for restful web services, messaging systems and service discovery, among other features.
+
+162
+00:14:04,000 --> 00:14:06,000
+Cloud Native applications.
+
+163
+00:14:06,000 --> 00:14:13,000
+Spring Boot is designed to work well in cloud native environments and includes built in support for
+
+164
+00:14:13,000 --> 00:14:19,000
+containerization and deployment to cloud platforms like Kubernetes and Cloud Foundry.
+
+165
+00:14:20,000 --> 00:14:22,000
+Robustness and scalability.
+
+166
+00:14:22,000 --> 00:14:29,000
+Spring boots built in features for handling data, persistence, caching and security, among other
+
+167
+00:14:29,000 --> 00:14:35,000
+things, make it a robust and scalable framework for building complex applications.
+
+168
+00:14:36,000 --> 00:14:38,000
+Integration with other technologies.
+
+169
+00:14:38,000 --> 00:14:44,000
+Spring Boot is highly extensible and can be easily integrated with a wide range of other technologies
+
+170
+00:14:44,000 --> 00:14:52,000
+and frameworks, making it a popular choice for projects that require integration with multiple systems.
+
+171
+00:14:52,000 --> 00:14:58,000
+In general, if you are developing Java based applications, it requires rapid development, robustness,
+
+172
+00:14:58,000 --> 00:15:01,000
+scalability and integration with other technologies.
+
+173
+00:15:01,000 --> 00:15:04,000
+Spring Boot is an excellent choice.
+
+174
+00:15:04,000 --> 00:15:10,000
+Additionally, if you are developing microservices based or cloud native applications.
+
+175
+00:15:10,000 --> 00:15:16,000
+Spring Boot provides many features and tools that can make the development process much smoother and
+
+176
+00:15:16,000 --> 00:15:18,000
+more efficient.
+
+177
+00:15:18,000 --> 00:15:25,000
+While Spring Boot is a powerful and flexible framework that is well suited for developing many different
+
+178
+00:15:25,000 --> 00:15:32,000
+types of Java applications, there are some cases where it may not be the best choice.
+
+179
+00:15:32,000 --> 00:15:37,000
+Here are some situations where you may want to consider using a different framework.
+
+180
+00:15:37,000 --> 00:15:39,000
+Small applications.
+
+181
+00:15:39,000 --> 00:15:45,000
+If you are developing a small lightweight application that doesn't require a lot of additional features
+
+182
+00:15:45,000 --> 00:15:49,000
+or functionality, spring boot may be overkill.
+
+183
+00:15:49,000 --> 00:15:54,000
+In this case, a simpler, more lightweight framework may be a better choice.
+
+184
+00:15:55,000 --> 00:15:58,000
+Tight control over application configuration.
+
+185
+00:15:58,000 --> 00:16:04,000
+While Spring Boot is opinionated, approach to configuration can simplify development.
+
+186
+00:16:04,000 --> 00:16:10,000
+It may be a disadvantage if you need tight control over application configuration.
+
+187
+00:16:10,000 --> 00:16:16,000
+In this case, a more flexible framework like spring framework may be a better choice.
+
+188
+00:16:16,000 --> 00:16:19,000
+Applications with specific performance requirements.
+
+189
+00:16:20,000 --> 00:16:27,000
+While Spring Boot is designed to be fast and efficient, there may be cases where more specialized framework
+
+190
+00:16:27,000 --> 00:16:30,000
+is required for high performance applications.
+
+191
+00:16:31,000 --> 00:16:34,000
+Projects with existing architecture technology stack.
+
+192
+00:16:35,000 --> 00:16:41,000
+If you are working on a project that has an existing architecture or technology stack, it may be more
+
+193
+00:16:41,000 --> 00:16:45,000
+difficult to integrate Spring Boot into the existing environment.
+
+194
+00:16:45,000 --> 00:16:50,000
+In this case, it may be better to stick with the existing tools and technologies.
+
+195
+00:16:51,000 --> 00:16:56,000
+Projects that require tight control over application startup time.
+
+196
+00:16:56,000 --> 00:17:03,000
+While spring boots, rapid development and easy setup can be a big advantage, it may come at the cost
+
+197
+00:17:03,000 --> 00:17:06,000
+of slower startup times for the application.
+
+198
+00:17:07,000 --> 00:17:14,000
+If your project requires tight control over application startup time, a more lightweight framework
+
+199
+00:17:14,000 --> 00:17:15,000
+may be a better choice.
+
+200
+00:17:15,000 --> 00:17:22,000
+Overall, Spring Boot is an excellent choice for many Java based projects, but there may be cases where
+
+201
+00:17:22,000 --> 00:17:26,000
+a different framework or approach is more appropriate.
+
+202
+00:17:26,000 --> 00:17:33,000
+It is important to evaluate your project requirements carefully and choose the framework that best meets
+
+203
+00:17:33,000 --> 00:17:34,000
+your needs.
+
+204
+00:17:35,000 --> 00:17:39,000
+Based on what we have learned, let's try to summarize.
+
+205
+00:17:39,000 --> 00:17:42,000
+Advantages and disadvantages of Spring Boot.
+
+206
+00:17:42,000 --> 00:17:44,000
+Let's start from advantages.
+
+207
+00:17:45,000 --> 00:17:50,000
+Spring Boot has numerous advantages that make it a popular choice for Java developers.
+
+208
+00:17:50,000 --> 00:17:53,000
+Here are some of the key advantages of Spring boot.
+
+209
+00:17:53,000 --> 00:17:56,000
+Rapid Application Development.
+
+210
+00:17:56,000 --> 00:18:02,000
+Spring Boot is opinionated approach and easy setup allowed developers to quickly create new applications
+
+211
+00:18:02,000 --> 00:18:04,000
+and get them up and running.
+
+212
+00:18:05,000 --> 00:18:06,000
+Simplified Configuration.
+
+213
+00:18:07,000 --> 00:18:13,000
+Spring Boots Auto Configuration Feature simplifies the configuration process, reducing the amount of
+
+214
+00:18:13,000 --> 00:18:16,000
+boilerplate code that developers need to write.
+
+215
+00:18:17,000 --> 00:18:18,000
+Embedded Web Server.
+
+216
+00:18:18,000 --> 00:18:25,000
+Spring Boot includes an embedded web server, which allows developers to easily create web based applications
+
+217
+00:18:25,000 --> 00:18:29,000
+without having to configure and manage an external web server.
+
+218
+00:18:30,000 --> 00:18:31,000
+Dependency Management.
+
+219
+00:18:31,000 --> 00:18:38,000
+Spring Boots Dependency Management System automatically manages versions and conflicts, making it easier
+
+220
+00:18:38,000 --> 00:18:43,000
+for developers to manage the dependencies required by an application.
+
+221
+00:18:43,000 --> 00:18:45,000
+Automatic configuration.
+
+222
+00:18:45,000 --> 00:18:52,000
+Spring Boot automatically configures common components such as data sources, messaging systems and
+
+223
+00:18:52,000 --> 00:18:57,000
+web servers based on the dependencies included in an application.
+
+224
+00:18:57,000 --> 00:18:58,000
+Actuator.
+
+225
+00:18:58,000 --> 00:19:06,000
+Spring boot actuator provides a set of endpoints and tools that make it easy to monitor and manage an
+
+226
+00:19:06,000 --> 00:19:13,000
+application at runtime, including health checks, metrics and other diagnostic tools.
+
+227
+00:19:13,000 --> 00:19:15,000
+Microservices.
+
+228
+00:19:15,000 --> 00:19:22,000
+Spring Boot is well suited for developing microservices based architecture as it provides built in support
+
+229
+00:19:22,000 --> 00:19:27,000
+for restful web services, messaging systems and service discovery.
+
+230
+00:19:28,000 --> 00:19:32,000
+Cloud Native Spring Boot is designed to work well in a cloud.
+
+231
+00:19:32,000 --> 00:19:37,000
+Native environments with built in support for containerization and deployment to cloud platforms like
+
+232
+00:19:37,000 --> 00:19:39,000
+Kubernetes and Cloud Foundry.
+
+233
+00:19:40,000 --> 00:19:42,000
+Integration with other technologies.
+
+234
+00:19:42,000 --> 00:19:49,000
+Spring Boot is highly extensible and can be easily integrated with a wide range of other technologies
+
+235
+00:19:49,000 --> 00:19:55,000
+and frameworks, making it a popular choice for projects that require integration with multiple systems.
+
+236
+00:19:56,000 --> 00:20:01,000
+So as you can see, this is a summary of what we have learned already.
+
+237
+00:20:02,000 --> 00:20:08,000
+While Spring Boot has numerous advantages, there are also some potential disadvantages to consider
+
+238
+00:20:08,000 --> 00:20:12,000
+when choosing whether to use it for your project or not.
+
+239
+00:20:12,000 --> 00:20:15,000
+Here are some of the key disadvantages of spring boot.
+
+240
+00:20:16,000 --> 00:20:18,000
+Limited flexibility.
+
+241
+00:20:18,000 --> 00:20:19,000
+As we already discussed.
+
+242
+00:20:19,000 --> 00:20:26,000
+But just to summarize, while spring Boots opinionated approach can simplify development, it can also
+
+243
+00:20:26,000 --> 00:20:33,000
+limit flexibility, making it more difficult to customize the application to meet specific requirements.
+
+244
+00:20:33,000 --> 00:20:35,000
+Learning Curve.
+
+245
+00:20:35,000 --> 00:20:42,000
+While Spring Boot is designed to be easy to use, there is still a learning curve involved, particularly
+
+246
+00:20:42,000 --> 00:20:46,000
+for developers who are new to the spring ecosystem.
+
+247
+00:20:46,000 --> 00:20:48,000
+Increased application size.
+
+248
+00:20:49,000 --> 00:20:56,000
+Spring boots, extensive set of features and auto configuration can lead to larger application sizes,
+
+249
+00:20:56,000 --> 00:21:02,000
+which may be a disadvantage for applications with strict size requirements.
+
+250
+00:21:03,000 --> 00:21:10,000
+Overhead Spring Boot's, auto configuration and other features can introduce some additional overhead,
+
+251
+00:21:10,000 --> 00:21:15,000
+which may be a disadvantage for applications with strict performance requirements.
+
+252
+00:21:16,000 --> 00:21:18,000
+Opinionated approach.
+
+253
+00:21:18,000 --> 00:21:24,000
+While spring boots opinionated approach can be a benefit for developers who are looking for a quick
+
+254
+00:21:24,000 --> 00:21:31,000
+and easy way to build an application, it can also be a disadvantage for developers who prefer more
+
+255
+00:21:31,000 --> 00:21:36,000
+control over their application architecture and implementation.
+
+256
+00:21:36,000 --> 00:21:38,000
+Steep dependency.
+
+257
+00:21:39,000 --> 00:21:46,000
+Spring boot dependency management system can result in a deep Iraqi of dependencies, which can be difficult
+
+258
+00:21:46,000 --> 00:21:51,000
+to manage and may cause conflicts or compatibility issues.
+
+259
+00:21:51,000 --> 00:21:53,000
+Complexity for small projects.
+
+260
+00:21:53,000 --> 00:22:01,000
+For very small projects that don't require many features, Spring Boot may be overkill and introduce
+
+261
+00:22:01,000 --> 00:22:03,000
+unnecessary complexity.
+
+262
+00:22:03,000 --> 00:22:07,000
+Basically, that's all what I wanted to share with you today.
+
+263
+00:22:07,000 --> 00:22:11,000
+Let's recap what we have learned in the video.
+
+264
+00:22:11,000 --> 00:22:14,000
+We learned what a spring boot is.
+
+265
+00:22:14,000 --> 00:22:16,000
+We learned its key features.
+
+266
+00:22:17,000 --> 00:22:21,000
+I explained what an opinionated development approach is.
+
+267
+00:22:21,000 --> 00:22:27,000
+Now you know when to use spring boot and when not to use spring boot.
+
+268
+00:22:27,000 --> 00:22:32,000
+And at the end of the lesson, we learned its advantages and disadvantages.
+
+269
+00:22:33,000 --> 00:22:35,000
+That's it for this lesson.
+
+270
+00:22:35,000 --> 00:22:37,000
+Thanks a lot for your attention.
+
+271
+00:22:37,000 --> 00:22:40,000
+Have a great day and see you in the next lesson.
+

92 - Spring Boot/002 Source-code-of-the-first-Spring-Boot-project-from-the-lesson-commit-with-changes-.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/java-learnit-spring-boot/commit/ed97cff607917d923b693146b5fcdc08d507d422

92 - Spring Boot/002 Spring-Initializr-Tool.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://start.spring.io/

92 - Spring Boot/002 The First Spring Boot Project_en.srt

@@ -0,0 +1,876 @@
+1
+00:00:05,000 --> 00:00:10,000
+Hello, dear students, we already learned what a spring boot is in the previous lesson.
+
+2
+00:00:10,000 --> 00:00:14,000
+And in this lesson, we are going to have practical activities.
+
+3
+00:00:14,000 --> 00:00:19,000
+We are going to create our first spring boot project and run it.
+
+4
+00:00:19,000 --> 00:00:26,000
+We are going to start this lesson from London Spring Initializer two because we are going to use it
+
+5
+00:00:26,000 --> 00:00:28,000
+for the Spring Boot project generation.
+
+6
+00:00:29,000 --> 00:00:36,000
+In total, I'm going to show you two main ways to generate your first spring boot project where spring
+
+7
+00:00:36,000 --> 00:00:41,000
+initializer web tool and directly in your eclipse IDE.
+
+8
+00:00:41,000 --> 00:00:47,000
+We will learn these two ways and will set up projects in the IDE for further development.
+
+9
+00:00:48,000 --> 00:00:51,000
+And we are going to have a lot of practical activity today.
+
+10
+00:00:52,000 --> 00:00:57,000
+We will create our first spring MVC controller in our first spring boot application.
+
+11
+00:00:57,000 --> 00:00:59,000
+Let's start our lesson.
+
+12
+00:01:00,000 --> 00:01:04,000
+The first thing that I want to demo you is spring initializer tool.
+
+13
+00:01:04,000 --> 00:01:10,000
+Let me explain what it is, because we are going to use this tool today in the lesson to create our
+
+14
+00:01:10,000 --> 00:01:12,000
+first spring boot project.
+
+15
+00:01:12,000 --> 00:01:20,000
+Spring Initializer is a web based tool provided by the Spring Team to help bootstrap and generate spring
+
+16
+00:01:20,000 --> 00:01:21,000
+boot projects with ease.
+
+17
+00:01:21,000 --> 00:01:28,000
+It simplifies the process of setting up a new spring boot project by generating a project structure
+
+18
+00:01:28,000 --> 00:01:34,000
+with the required dependencies and configurations based on your selections.
+
+19
+00:01:35,000 --> 00:01:41,000
+Key features of spring initializer include project customization.
+
+20
+00:01:41,000 --> 00:01:49,000
+Spring Initializer allows you to customize various aspects of your project, such as project, metadata,
+
+21
+00:01:49,000 --> 00:01:52,000
+dependencies and build systems.
+
+22
+00:01:52,000 --> 00:01:56,000
+You can specify the project's group and artifact name.
+
+23
+00:01:56,000 --> 00:02:05,000
+Select the desired spring boot version and add dependencies like Spring Web, spring data, JPA security
+
+24
+00:02:05,000 --> 00:02:07,000
+testing frameworks and more.
+
+25
+00:02:08,000 --> 00:02:10,000
+Starter dependencies.
+
+26
+00:02:10,000 --> 00:02:19,000
+Spring initializer leverages starter dependencies which are opinionated dependency descriptors to simplify
+
+27
+00:02:19,000 --> 00:02:24,000
+the inclusion of common libraries and frameworks in your project.
+
+28
+00:02:24,000 --> 00:02:30,000
+Starters provide a convenient way to add functionality to your spring boot project by automatically
+
+29
+00:02:30,000 --> 00:02:34,000
+configuring the necessary dependencies and boilerplate code.
+
+30
+00:02:35,000 --> 00:02:36,000
+Configuration options.
+
+31
+00:02:37,000 --> 00:02:43,000
+The tool offers additional configuration options for your project, including choosing the Build System
+
+32
+00:02:43,000 --> 00:02:51,000
+MAVEN or Gradle Java version, packaging format, Java and more.
+
+33
+00:02:51,000 --> 00:02:59,000
+It also allows you to specify advanced settings like choosing a specific spring boot version or enabling
+
+34
+00:02:59,000 --> 00:03:01,000
+specific features like Kotlin support.
+
+35
+00:03:02,000 --> 00:03:04,000
+Project generation.
+
+36
+00:03:04,000 --> 00:03:11,000
+Once you have customized your project settings, Spring Initializer generates a downloadable project
+
+37
+00:03:11,000 --> 00:03:17,000
+archive that contains the project structure and the necessary configuration files.
+
+38
+00:03:17,000 --> 00:03:25,000
+You can choose to download the project as zip file or directly import it into your favorite IDE.
+
+39
+00:03:25,000 --> 00:03:28,000
+Integration with Ides.
+
+40
+00:03:28,000 --> 00:03:35,000
+Spring initializer provides seamless integration with popular IDES, making it easier to create and
+
+41
+00:03:35,000 --> 00:03:38,000
+import projects directly from the IDE.
+
+42
+00:03:38,000 --> 00:03:42,000
+Supported ides include IntelliJ Eclipse.
+
+43
+00:03:42,000 --> 00:03:49,000
+The integration helps you skip manual project setup steps and jump straight into development.
+
+44
+00:03:50,000 --> 00:03:56,000
+A little bit later today during the demo, I'm going to show you which extension you can install into
+
+45
+00:03:56,000 --> 00:04:02,000
+your eclipse IDE in order to generate spring boot project directly from the IDE.
+
+46
+00:04:02,000 --> 00:04:09,000
+As you can see, spring initializer simplifies the process of creating spring boot projects by providing
+
+47
+00:04:09,000 --> 00:04:17,000
+an intuitive web based interface, customizable options and a streamlined project generation mechanism.
+
+48
+00:04:17,000 --> 00:04:25,000
+It helps developers get started quickly with Spring Boot and reduces the initial setup overhead, allowing
+
+49
+00:04:25,000 --> 00:04:28,000
+them to focus on building their applications.
+
+50
+00:04:29,000 --> 00:04:33,000
+As I already said, this is going to be practical lesson.
+
+51
+00:04:33,000 --> 00:04:38,000
+So let me start screen sharing and we will jump directly to practical examples.
+
+52
+00:04:39,000 --> 00:04:43,000
+So you already learned what a spring initializer tool is.
+
+53
+00:04:43,000 --> 00:04:45,000
+Let me show you how to work with it.
+
+54
+00:04:45,000 --> 00:04:53,000
+On practice, you can get access to it using this URL, I will leave a link in attachments to the video.
+
+55
+00:04:53,000 --> 00:04:55,000
+Here we have user friendly UI.
+
+56
+00:04:56,000 --> 00:05:00,000
+Let me comment on some UI elements and key labels here.
+
+57
+00:05:01,000 --> 00:05:02,000
+Project.
+
+58
+00:05:02,000 --> 00:05:09,000
+It defines the kind of project we can create is a MAVEN project or GRADLE project.
+
+59
+00:05:09,000 --> 00:05:15,000
+If you are a student of my Java from zero to first job course and you watched the section about automation
+
+60
+00:05:15,000 --> 00:05:21,000
+build tools, then you already know my opinion and why I select Maven.
+
+61
+00:05:21,000 --> 00:05:26,000
+If you want to learn more, you can check the relevant section in my course Java from zero to first
+
+62
+00:05:26,000 --> 00:05:29,000
+Job language.
+
+63
+00:05:29,000 --> 00:05:35,000
+Spring Initializer provides the choice among three languages Java, Kotlin and Groovy.
+
+64
+00:05:36,000 --> 00:05:43,000
+Java is selected by default and in this lesson we will not discuss which language is better.
+
+65
+00:05:43,000 --> 00:05:49,000
+You're welcome to select the one you like the most, but I keep Java selected.
+
+66
+00:05:49,000 --> 00:05:50,000
+Spring boot.
+
+67
+00:05:50,000 --> 00:05:53,000
+We can select the spring boot version.
+
+68
+00:05:54,000 --> 00:05:55,000
+Project metadata.
+
+69
+00:05:55,000 --> 00:06:01,000
+It contains information related to the project, such as group, artifact, etcetera.
+
+70
+00:06:02,000 --> 00:06:06,000
+Usually group is used in package name.
+
+71
+00:06:06,000 --> 00:06:11,000
+Artifact denotes the application name and also used in package name.
+
+72
+00:06:11,000 --> 00:06:20,000
+I will change group name to the common name that I use in my course and also set artifact name to reflect
+
+73
+00:06:20,000 --> 00:06:22,000
+the goal of this project.
+
+74
+00:06:23,000 --> 00:06:24,000
+Name.
+
+75
+00:06:24,000 --> 00:06:28,000
+It is the same as artifact description.
+
+76
+00:06:28,000 --> 00:06:34,000
+In the description field, we can write a description of the project package name.
+
+77
+00:06:34,000 --> 00:06:38,000
+Usually it is a combination of our group name and artifact name.
+
+78
+00:06:38,000 --> 00:06:42,000
+If you are familiar with Maven, you should be aware about such practice.
+
+79
+00:06:43,000 --> 00:06:44,000
+Packaging.
+
+80
+00:06:44,000 --> 00:06:47,000
+We can select the packaging of the project.
+
+81
+00:06:47,000 --> 00:06:50,000
+We can choose either jar or war.
+
+82
+00:06:50,000 --> 00:06:57,000
+I select Jar because one of the advantages of the spring boot is to have just Java installed on your
+
+83
+00:06:57,000 --> 00:07:05,000
+computer in order to run web application and you can run Jar archives with Java Command.
+
+84
+00:07:05,000 --> 00:07:06,000
+Java.
+
+85
+00:07:07,000 --> 00:07:11,000
+We can select the JVM version which we want to use.
+
+86
+00:07:11,000 --> 00:07:17,000
+We'll use Java 11 version because it is latest long term support version.
+
+87
+00:07:17,000 --> 00:07:25,000
+I know that Oracle releases new version of Java each six months, but even despite this crazy enumeration,
+
+88
+00:07:25,000 --> 00:07:32,000
+Steal Java Version eight is the most popular around the world, and Java version 11 is the latest long
+
+89
+00:07:32,000 --> 00:07:34,000
+term support version.
+
+90
+00:07:34,000 --> 00:07:40,000
+If you want to learn more about versions and what is long term support version, please refer to my
+
+91
+00:07:40,000 --> 00:07:42,000
+course Java from zero to first job.
+
+92
+00:07:43,000 --> 00:07:49,000
+This is a lesson about Java installation where I explained more about Java versions.
+
+93
+00:07:50,000 --> 00:07:51,000
+Dependencies.
+
+94
+00:07:51,000 --> 00:07:56,000
+Dependencies are the collection of artifacts that we can add to our project.
+
+95
+00:07:57,000 --> 00:08:01,000
+There are multiple dependencies you can choose from on this stage.
+
+96
+00:08:01,000 --> 00:08:05,000
+Don't worry, you can always add dependencies later.
+
+97
+00:08:05,000 --> 00:08:11,000
+For the sake of the demo, I just added spring boot dev tools and spring lab.
+
+98
+00:08:11,000 --> 00:08:19,000
+Spring lab is important dependency in order to have embedded tomcat web server and the spring boot dev
+
+99
+00:08:19,000 --> 00:08:27,000
+tools is a dependency that enhance development experience like fast application restarts and life reload
+
+100
+00:08:27,000 --> 00:08:31,000
+without need to recompile and restart application.
+
+101
+00:08:32,000 --> 00:08:36,000
+You can click Explore button to review the source code.
+
+102
+00:08:36,000 --> 00:08:43,000
+Just in case you want to configure the project manually and you want to copy and paste content of files
+
+103
+00:08:43,000 --> 00:08:47,000
+or or you just want to take a look at the structure.
+
+104
+00:08:47,000 --> 00:08:51,000
+Anyway, that is not something what we are interested in right now.
+
+105
+00:08:51,000 --> 00:08:56,000
+Instead, let's close this view and click Generate button.
+
+106
+00:08:56,000 --> 00:08:58,000
+It will download a zip archive.
+
+107
+00:08:59,000 --> 00:09:07,000
+The next thing what we have to do is to extract the project from archive and import it into our IDE.
+
+108
+00:09:08,000 --> 00:09:13,000
+For example, I extracted the content of the archive in the workspace folder.
+
+109
+00:09:13,000 --> 00:09:15,000
+Now let me open the eclipse ide.
+
+110
+00:09:16,000 --> 00:09:25,000
+I click file import existing Maven project and I select the project that was generated by Spring Initializer
+
+111
+00:09:25,000 --> 00:09:26,000
+Tool.
+
+112
+00:09:26,000 --> 00:09:28,000
+And that's it.
+
+113
+00:09:28,000 --> 00:09:33,000
+I already imported Spring Boot demo project into Eclipse IDE.
+
+114
+00:09:33,000 --> 00:09:38,000
+That's why I can see a conflict in the namespace here.
+
+115
+00:09:39,000 --> 00:09:40,000
+But you can do this.
+
+116
+00:09:40,000 --> 00:09:43,000
+Similar steps and everything will be okay for you.
+
+117
+00:09:44,000 --> 00:09:49,000
+That's how you can generate your first spring boot project with spring initializer tool.
+
+118
+00:09:50,000 --> 00:09:55,000
+Now let me show you another way to generate your first spring boot project directly from the Eclipse
+
+119
+00:09:55,000 --> 00:09:56,000
+IDE.
+
+120
+00:09:56,000 --> 00:10:01,000
+First of all, we need to install extension into our eclipse.
+
+121
+00:10:01,000 --> 00:10:02,000
+Click help.
+
+122
+00:10:03,000 --> 00:10:08,000
+Then eclipse marketplace in the search bar type spring tools.
+
+123
+00:10:14,000 --> 00:10:20,000
+In this list, I select Spring Tools for and click install button.
+
+124
+00:10:20,000 --> 00:10:23,000
+Taking into account it is already installed.
+
+125
+00:10:23,000 --> 00:10:29,000
+I don't have installed button, but you are going to see install button here.
+
+126
+00:10:29,000 --> 00:10:32,000
+Just click it and follow the instructions.
+
+127
+00:10:33,000 --> 00:10:37,000
+After installation you would be asked to restart the eclipse.
+
+128
+00:10:37,000 --> 00:10:40,000
+Follow these instructions and restart it.
+
+129
+00:10:41,000 --> 00:10:49,000
+Once it is installed, you can click file new and just search for spring starter project.
+
+130
+00:10:49,000 --> 00:10:56,000
+And here you can see literally the similar configurations that we saw on the web application.
+
+131
+00:10:56,000 --> 00:11:04,000
+Let's configure the application in the similar way, but let's just change the artifact name and add
+
+132
+00:11:04,000 --> 00:11:10,000
+two at the end of the artifact name in order to not have conflicts in names.
+
+133
+00:11:11,000 --> 00:11:15,000
+On the next page you can configure dependencies and spring boot version.
+
+134
+00:11:16,000 --> 00:11:25,000
+Let's add spring boot devtools and Spring Web similarly to the way we did when we generated our application
+
+135
+00:11:25,000 --> 00:11:27,000
+where spring initializer web app.
+
+136
+00:11:28,000 --> 00:11:32,000
+Then just click, finish and project will be generated.
+
+137
+00:11:32,000 --> 00:11:34,000
+It is super easy.
+
+138
+00:11:34,000 --> 00:11:35,000
+Don't you think so?
+
+139
+00:11:36,000 --> 00:11:37,000
+So what to do now?
+
+140
+00:11:37,000 --> 00:11:40,000
+Let's just run it and see.
+
+141
+00:11:40,000 --> 00:11:47,000
+Anyway, I recommend you to install Spring Tools because it adds a lot of different integrations for
+
+142
+00:11:47,000 --> 00:11:49,000
+spring boot applications.
+
+143
+00:11:49,000 --> 00:11:56,000
+For example, you don't need to build your application where console in order to run it because you
+
+144
+00:11:56,000 --> 00:12:00,000
+have nice button run as spring boot app.
+
+145
+00:12:00,000 --> 00:12:07,000
+By default, spring application is deployed in the root of the server and available at localhost at
+
+146
+00:12:07,000 --> 00:12:12,000
+port 8080 the default port of tomcat server.
+
+147
+00:12:12,000 --> 00:12:15,000
+Let's check it in the browser.
+
+148
+00:12:15,000 --> 00:12:19,000
+Taking into account we don't have any mappings or resources configured.
+
+149
+00:12:19,000 --> 00:12:27,000
+We see error page, but the fact that server replies us with the error page is enough to understand
+
+150
+00:12:27,000 --> 00:12:30,000
+that our application is up and running.
+
+151
+00:12:30,000 --> 00:12:36,000
+Congratulations you created and started your first spring boot application.
+
+152
+00:12:37,000 --> 00:12:44,000
+And in order to make this lesson complete, let's create at least one simple controller that would redirect
+
+153
+00:12:44,000 --> 00:12:50,000
+us to the home page, and we'll get rid of this error page specially for this lesson.
+
+154
+00:12:50,000 --> 00:12:56,000
+I already prepared source code example in attachments to the video lesson.
+
+155
+00:12:56,000 --> 00:13:02,000
+You can find the reference to the git repository where you can find the source code of example that
+
+156
+00:13:02,000 --> 00:13:04,000
+I prepared for you.
+
+157
+00:13:04,000 --> 00:13:12,000
+You can just clone the repository locally and run it on your computer or explore the source code in
+
+158
+00:13:12,000 --> 00:13:13,000
+details.
+
+159
+00:13:13,000 --> 00:13:17,000
+And right now I will walk you through the prepared source code examples.
+
+160
+00:13:18,000 --> 00:13:25,000
+In case you watched my previous lessons about spring and you are familiar with spring MVC, there will
+
+161
+00:13:25,000 --> 00:13:27,000
+be nothing new for you.
+
+162
+00:13:27,000 --> 00:13:34,000
+In case you are not familiar with spring MVC, then, like I already said in the first theoretical lesson
+
+163
+00:13:34,000 --> 00:13:40,000
+about Spring Boot, make sure you learn spring framework first before learning Spring Boot.
+
+164
+00:13:40,000 --> 00:13:45,000
+You can check my lessons about spring MVC in my course Java from zero to first job.
+
+165
+00:13:46,000 --> 00:13:50,000
+So let's start an overview of the example.
+
+166
+00:13:50,000 --> 00:13:51,000
+Here it is.
+
+167
+00:13:52,000 --> 00:13:58,000
+I added simple controller in controllers package that is called Home Controller.
+
+168
+00:13:58,000 --> 00:14:02,000
+I configured mapping using get mapping annotation.
+
+169
+00:14:03,000 --> 00:14:09,000
+The next thing in application properties that are located in the resources source folder.
+
+170
+00:14:10,000 --> 00:14:18,000
+I added few details for the view resolver, namely I specified spring MVC view prefix and suffix.
+
+171
+00:14:18,000 --> 00:14:19,000
+That's it.
+
+172
+00:14:20,000 --> 00:14:26,000
+I don't need to configure view resolver separately like we did in spring MVC because Spring Boot will
+
+173
+00:14:26,000 --> 00:14:32,000
+configure view resolver automatically based on our configurations provided.
+
+174
+00:14:32,000 --> 00:14:40,000
+In general, this file application properties we are going to use a lot in order to pass required configuration
+
+175
+00:14:40,000 --> 00:14:41,000
+for the spring boot.
+
+176
+00:14:42,000 --> 00:14:45,000
+Also I added web app folder.
+
+177
+00:14:45,000 --> 00:14:52,000
+I believe you remember that all our web resources should be placed in the separate folder by default
+
+178
+00:14:52,000 --> 00:14:53,000
+in spring boot.
+
+179
+00:14:53,000 --> 00:15:00,000
+You should put your web resources in web app folder under src main sub folder.
+
+180
+00:15:01,000 --> 00:15:04,000
+I created here Web-inf folder.
+
+181
+00:15:04,000 --> 00:15:11,000
+And we also already learned that content of the Web-inf is not accessible directly from the outside
+
+182
+00:15:11,000 --> 00:15:13,000
+of the application.
+
+183
+00:15:13,000 --> 00:15:21,000
+That's why clients won't be able to access the resource in the web in folder directly.
+
+184
+00:15:21,000 --> 00:15:29,000
+Instead, according to the MVC pattern, client will be able to access only the controller and on the
+
+185
+00:15:29,000 --> 00:15:36,000
+server side controller will forward the request to the resource in the web in folder if needed.
+
+186
+00:15:37,000 --> 00:15:41,000
+And here in Views folder, I created two JSP files.
+
+187
+00:15:42,000 --> 00:15:43,000
+The first one is home.
+
+188
+00:15:43,000 --> 00:15:52,000
+It contains simple HTML markup and just the text to indicate that we are on the home page and error
+
+189
+00:15:52,000 --> 00:15:53,000
+page.
+
+190
+00:15:53,000 --> 00:16:01,000
+Here request will be forwarded in case of any errors, even despite the fact we didn't create any specific
+
+191
+00:16:01,000 --> 00:16:04,000
+controller or exception handler.
+
+192
+00:16:04,000 --> 00:16:11,000
+There is a spring boot internal error handling mechanism which is automatically applied if no custom
+
+193
+00:16:11,000 --> 00:16:13,000
+error handling is defined.
+
+194
+00:16:13,000 --> 00:16:19,000
+Again, this is something what we talked about in the first lesson about Spring Boot.
+
+195
+00:16:19,000 --> 00:16:22,000
+Convention over configuration.
+
+196
+00:16:22,000 --> 00:16:27,000
+And during the course we are going to learn such conventions and agreements.
+
+197
+00:16:27,000 --> 00:16:34,000
+In a minute I'm going to show you how Error page is resolved and just in case I will make an overview
+
+198
+00:16:34,000 --> 00:16:36,000
+of POM XML.
+
+199
+00:16:36,000 --> 00:16:43,000
+But in case you selected spring web tools during the project generation, you should be good and nothing
+
+200
+00:16:43,000 --> 00:16:45,000
+should be added manually on top of that.
+
+201
+00:16:45,000 --> 00:16:47,000
+Basically, that's it.
+
+202
+00:16:48,000 --> 00:16:54,000
+Let's make sure that our previous web server and previous spring boot application is stopped and let's
+
+203
+00:16:54,000 --> 00:16:56,000
+run this one.
+
+204
+00:17:00,000 --> 00:17:08,000
+Once application is started, I open the web browser and when I hit the root resource, I see the content
+
+205
+00:17:08,000 --> 00:17:15,000
+of my home page that proves that request was forwarded to the home JSP page.
+
+206
+00:17:15,000 --> 00:17:22,000
+In case I tried to reach non-existent resource, you can see that I am redirected to the error page.
+
+207
+00:17:22,000 --> 00:17:30,000
+This proves that default error handler that is present in spring boot resolves error view automatically.
+
+208
+00:17:31,000 --> 00:17:35,000
+Congratulations with your first spring boot application.
+
+209
+00:17:36,000 --> 00:17:42,000
+This is just a beginning and we still have a lot of things to learn, but we already did significant
+
+210
+00:17:42,000 --> 00:17:43,000
+progress.
+
+211
+00:17:43,000 --> 00:17:47,000
+Let's recap what we have learned in the lesson.
+
+212
+00:17:48,000 --> 00:17:52,000
+Today we learned what spring initializer tool is and how to use it.
+
+213
+00:17:53,000 --> 00:18:00,000
+We generated our first spring boot project with the help of the spring initializer tool and directly
+
+214
+00:18:00,000 --> 00:18:06,000
+from the Eclipse IDE with the help of Spring Tools extension that we installed during the lesson.
+
+215
+00:18:07,000 --> 00:18:15,000
+We created simple MVC controller in our first spring boot application and we saw how all this works
+
+216
+00:18:15,000 --> 00:18:21,000
+in practice because we reviewed the source code and run our spring boot application.
+
+217
+00:18:22,000 --> 00:18:24,000
+That's all for this lesson.
+
+218
+00:18:24,000 --> 00:18:26,000
+Thanks a lot for your attention.
+
+219
+00:18:26,000 --> 00:18:29,000
+Have a great day and see you in the next lesson.
+

92 - Spring Boot/003 Source-code-of-examples-commit-with-changes-.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/java-learnit-spring-boot/commit/4b8bea15fe2262ce27a63fc8a0c9059549e39c4c

92 - Spring Boot/003 Spring Boot Starters_en.srt

@@ -0,0 +1,1612 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello team.
+
+2
+00:00:06,000 --> 00:00:10,000
+In this video lesson, we are going to learn more about spring boot starters.
+
+3
+00:00:11,000 --> 00:00:15,000
+Today we are going to have mixed lesson, some theory and practical examples.
+
+4
+00:00:15,000 --> 00:00:18,000
+In order you can understand the topic.
+
+5
+00:00:18,000 --> 00:00:24,000
+We'll start the lesson from learning and understanding what starters are and why do we need them.
+
+6
+00:00:24,000 --> 00:00:31,000
+I will explain benefits and advantages that we as developers expect to get by using them.
+
+7
+00:00:31,000 --> 00:00:38,000
+We'll review the list of starters that you potentially may use in your spring boot applications.
+
+8
+00:00:38,000 --> 00:00:45,000
+And after learning some theory about starters, we'll jump to practical exercises and review real life
+
+9
+00:00:45,000 --> 00:00:46,000
+examples.
+
+10
+00:00:47,000 --> 00:00:52,000
+I'm going to show you how you can add Spring Boot starter into your application.
+
+11
+00:00:52,000 --> 00:00:56,000
+We'll review web starter and create Rest API.
+
+12
+00:00:57,000 --> 00:00:59,000
+I'm going to show you test starter.
+
+13
+00:00:59,000 --> 00:01:06,000
+We'll create few tests and we will also review data starter for the GPA.
+
+14
+00:01:06,000 --> 00:01:12,000
+I will show you how built in support of H2 database is configured in Spring boot.
+
+15
+00:01:12,000 --> 00:01:18,000
+And then I will also show you how to configure data source for MySQL database.
+
+16
+00:01:18,000 --> 00:01:21,000
+And at the end of the lesson we'll learn security starter.
+
+17
+00:01:22,000 --> 00:01:23,000
+Let's start our lesson.
+
+18
+00:01:24,000 --> 00:01:27,000
+Let's first learn the definition.
+
+19
+00:01:27,000 --> 00:01:30,000
+What are spring boot starters?
+
+20
+00:01:30,000 --> 00:01:31,000
+I will explain you what.
+
+21
+00:01:31,000 --> 00:01:35,000
+Spring boot starters is with simple real life scenario.
+
+22
+00:01:36,000 --> 00:01:42,000
+Imagine that you need to start development of rest service instead of adding dependencies of spring
+
+23
+00:01:42,000 --> 00:01:50,000
+context, Spring MVC, Tomcat, Jackson select proper versions and check compatibility.
+
+24
+00:01:50,000 --> 00:01:57,000
+Why don't you just add one dependency that is called web starter and spring wood will do the rest.
+
+25
+00:01:57,000 --> 00:02:00,000
+This should be much easier and great.
+
+26
+00:02:00,000 --> 00:02:09,000
+So we can say that in the context of spring boot starters are set of opinionated dependencies, dependencies,
+
+27
+00:02:09,000 --> 00:02:18,000
+descriptors that provide a convenient way to add commonly used frameworks, libraries and features to
+
+28
+00:02:18,000 --> 00:02:20,000
+your spring boot application.
+
+29
+00:02:20,000 --> 00:02:30,000
+They help simplify the configuration and setup process by providing predefined dependencies and configurations,
+
+30
+00:02:30,000 --> 00:02:37,000
+allowing you to focus more on developing your application logic rather than managing dependencies.
+
+31
+00:02:37,000 --> 00:02:45,000
+Spring boot starters follows the principle of convention over configuration, providing sensible defaults
+
+32
+00:02:45,000 --> 00:02:49,000
+and reducing the need for manual configuration.
+
+33
+00:02:49,000 --> 00:02:57,000
+Each starter is focused on a specific aspect of application development, such as web development,
+
+34
+00:02:57,000 --> 00:03:02,000
+data, access, security, messaging, testing, etcetera.
+
+35
+00:03:02,000 --> 00:03:10,000
+By including a starter dependency in your spring boot project, you automatically bring in all the necessary
+
+36
+00:03:10,000 --> 00:03:16,000
+dependencies and configurations required for that specific feature or functionality.
+
+37
+00:03:16,000 --> 00:03:24,000
+For example, including the Spring Boot starter Web starter will automatically configure the web related
+
+38
+00:03:24,000 --> 00:03:31,000
+dependencies such as Embedded Tomcat Server, Spring MVC and other related components.
+
+39
+00:03:31,000 --> 00:03:39,000
+Starters are designed to work together seamlessly and you can combine multiple starters in your project
+
+40
+00:03:39,000 --> 00:03:41,000
+to incorporate various features.
+
+41
+00:03:41,000 --> 00:03:50,000
+They help promote modularization and maintain a consistent and standardized approach to building spring
+
+42
+00:03:50,000 --> 00:03:52,000
+boot applications.
+
+43
+00:03:52,000 --> 00:03:59,000
+Starters not only simplifies the initial project setup, but also provides ongoing maintenance benefits
+
+44
+00:03:59,000 --> 00:04:04,000
+when new versions of libraries or frameworks are released.
+
+45
+00:04:04,000 --> 00:04:11,000
+The Spring Boot team ensures that the starters are up to date and compatible, making it easier to keep
+
+46
+00:04:11,000 --> 00:04:13,000
+your dependencies up to date.
+
+47
+00:04:14,000 --> 00:04:21,000
+So spring boot starters provide a convenient and efficient way to bootstrap your spring boot projects
+
+48
+00:04:21,000 --> 00:04:28,000
+by reducing the complexity of dependency management and configuration, enabling you to quickly build
+
+49
+00:04:28,000 --> 00:04:32,000
+applications with the desired features and functionalities.
+
+50
+00:04:33,000 --> 00:04:38,000
+Now it is time for us to understand why do we need spring boot starters?
+
+51
+00:04:39,000 --> 00:04:40,000
+Efficiently?
+
+52
+00:04:40,000 --> 00:04:47,000
+Managing dependencies is crucial in complex projects, and manual management can be suboptimal as it
+
+53
+00:04:47,000 --> 00:04:54,000
+consumes valuable time as it could be spent on other essential project aspects.
+
+54
+00:04:54,000 --> 00:05:00,000
+I believe if you already watch this lesson of the course, then you are not completely beginner in Java
+
+55
+00:05:00,000 --> 00:05:01,000
+development.
+
+56
+00:05:01,000 --> 00:05:09,000
+Thus you had cases in your life when you specified dependencies that are not comparable because of different
+
+57
+00:05:09,000 --> 00:05:17,000
+versions or you forget to specify some dependency and Java applications throws class not found exception
+
+58
+00:05:17,000 --> 00:05:18,000
+during the runtime.
+
+59
+00:05:19,000 --> 00:05:25,000
+With spring boot starters, you reduce chances of doing mistake during the dependency management.
+
+60
+00:05:25,000 --> 00:05:30,000
+Spring boot starters were specifically developed to tackle this issue.
+
+61
+00:05:30,000 --> 00:05:36,000
+Let's summarize advantages that we expect to get by using spring boot starters.
+
+62
+00:05:36,000 --> 00:05:42,000
+Spring boot starters are designed to simplify the process of setting up and configuring spring boot
+
+63
+00:05:42,000 --> 00:05:43,000
+applications.
+
+64
+00:05:43,000 --> 00:05:50,000
+Here are a few reasons why we need spring boot starters and what advantages we get when we use spring
+
+65
+00:05:50,000 --> 00:05:51,000
+boot starters.
+
+66
+00:05:51,000 --> 00:05:59,000
+The first one Convenience starters provide a convenient way to add commonly used frameworks, libraries
+
+67
+00:05:59,000 --> 00:06:03,000
+and features to your spring boot application.
+
+68
+00:06:03,000 --> 00:06:10,000
+They package together all necessary dependencies, configurations and auto configurations related to
+
+69
+00:06:10,000 --> 00:06:13,000
+a specific functionality or feature.
+
+70
+00:06:13,000 --> 00:06:20,000
+This saves you from manually searching for and adding individual dependencies, reducing the setup time
+
+71
+00:06:20,000 --> 00:06:22,000
+and complexity.
+
+72
+00:06:22,000 --> 00:06:30,000
+Opinionated configuration Spring boot starters Follow an opinionated approach to configuration, providing
+
+73
+00:06:30,000 --> 00:06:35,000
+sensible defaults and reducing the need for extensive manual configuration.
+
+74
+00:06:35,000 --> 00:06:42,000
+They encapsulate best practices and predefined configurations for specific use cases, allowing you
+
+75
+00:06:42,000 --> 00:06:48,000
+to get started quickly without spending time on boilerplate configuration.
+
+76
+00:06:48,000 --> 00:06:54,000
+Modularization Starters Promote modularization in your application.
+
+77
+00:06:54,000 --> 00:07:02,000
+By using starters, you can easily include all the dependencies and features that your application requires.
+
+78
+00:07:02,000 --> 00:07:09,000
+This helps keep the application lightweight, improves maintainability and reduces the risk of including
+
+79
+00:07:09,000 --> 00:07:11,000
+unnecessary dependencies.
+
+80
+00:07:12,000 --> 00:07:14,000
+Compatibility and version management.
+
+81
+00:07:15,000 --> 00:07:21,000
+Starters are designed to work together seamlessly ensuring compatibility between different dependencies.
+
+82
+00:07:22,000 --> 00:07:30,000
+Rapid development With starters, you can focus more on writing, application logic and implementing
+
+83
+00:07:30,000 --> 00:07:36,000
+business requirements rather than spending time on dependency management and configuration.
+
+84
+00:07:37,000 --> 00:07:44,000
+They provide a streamlined development experience by abstracting away the complexities of dependency
+
+85
+00:07:44,000 --> 00:07:44,000
+management.
+
+86
+00:07:45,000 --> 00:07:47,000
+Community support.
+
+87
+00:07:47,000 --> 00:07:51,000
+Spring boot starters have a great community and ecosystem around them.
+
+88
+00:07:52,000 --> 00:08:00,000
+You can find extensive documentation, tutorials and resources related to each starter as well as commonly
+
+89
+00:08:00,000 --> 00:08:05,000
+support through forums, blogs and stack overflow.
+
+90
+00:08:05,000 --> 00:08:12,000
+This makes it easier to find help and guidance when working with specific functionalities or features.
+
+91
+00:08:12,000 --> 00:08:17,000
+Probably you might be wondering which spring boot starters you can use.
+
+92
+00:08:17,000 --> 00:08:20,000
+There are more than 30 spring boot starters.
+
+93
+00:08:20,000 --> 00:08:25,000
+Let me present you the most common and popular ones in my opinion.
+
+94
+00:08:26,000 --> 00:08:27,000
+Starter web.
+
+95
+00:08:28,000 --> 00:08:31,000
+Starter for building web applications using spring MVC.
+
+96
+00:08:33,000 --> 00:08:34,000
+Starter data GPA.
+
+97
+00:08:35,000 --> 00:08:40,000
+This starter is for using spring data JPA for database access.
+
+98
+00:08:40,000 --> 00:08:42,000
+Start the security.
+
+99
+00:08:42,000 --> 00:08:48,000
+Obviously, this one for adding spring security to secure your application.
+
+100
+00:08:48,000 --> 00:08:50,000
+Starter test.
+
+101
+00:08:50,000 --> 00:08:57,000
+Based on the name, you can guess that this one is for writing unit tests and integration tests for
+
+102
+00:08:57,000 --> 00:09:00,000
+your spring boot application starter seam.
+
+103
+00:09:02,000 --> 00:09:08,000
+This starter is for using the seam lift templating engine for server side rendering.
+
+104
+00:09:08,000 --> 00:09:15,000
+If you don't know, seam leave is a modern server side Java template engine that is commonly used in
+
+105
+00:09:15,000 --> 00:09:20,000
+web applications, especially in conjunction with Spring Framework and Spring Boot.
+
+106
+00:09:20,000 --> 00:09:28,000
+It aims to bring natural templating capabilities to HTML by providing a seamless integration with Java
+
+107
+00:09:28,000 --> 00:09:29,000
+ecosystem.
+
+108
+00:09:29,000 --> 00:09:31,000
+Starter actuator.
+
+109
+00:09:32,000 --> 00:09:37,000
+This starter for monitoring and managing your application in production.
+
+110
+00:09:38,000 --> 00:09:41,000
+We're going to have a separate lesson about actuator to.
+
+111
+00:09:42,000 --> 00:09:44,000
+Starter Amqp.
+
+112
+00:09:45,000 --> 00:09:52,000
+This starter for using spring advanced message queuing protocol for messaging.
+
+113
+00:09:53,000 --> 00:09:57,000
+Startup data MongoDB startup for using spring data.
+
+114
+00:09:57,000 --> 00:10:01,000
+MongoDB for MongoDB database access starter login.
+
+115
+00:10:02,000 --> 00:10:12,000
+This one is for login using a server and Logback libraries Starter validation for using bean validation
+
+116
+00:10:12,000 --> 00:10:21,000
+API Starter cache for using spring's caching support Starter mail for Send an email using Javamail.
+
+117
+00:10:22,000 --> 00:10:28,000
+The rest of the popular starters and their description you can find on the slide.
+
+118
+00:10:28,000 --> 00:10:33,000
+But in reality, there are even more spring boot starters.
+
+119
+00:10:33,000 --> 00:10:38,000
+Just take a look at this repository with the source code of spring boot starters.
+
+120
+00:10:39,000 --> 00:10:42,000
+I'm sure you will be able to find the ones that you need.
+
+121
+00:10:43,000 --> 00:10:46,000
+Important thing is that you can create custom spring boot starter.
+
+122
+00:10:46,000 --> 00:10:51,000
+And as I already said, spring community is huge.
+
+123
+00:10:51,000 --> 00:10:57,000
+And before developing your own spring boot starter, just check whether such spring boot starter already
+
+124
+00:10:57,000 --> 00:11:00,000
+exists in the attachments to the lesson.
+
+125
+00:11:00,000 --> 00:11:02,000
+I will leave a link to the GitHub.
+
+126
+00:11:02,000 --> 00:11:09,000
+The links that I present right now on the screen here you can find a list of spring boot starters and
+
+127
+00:11:09,000 --> 00:11:14,000
+also a list of the custom spring boot starters created by the community.
+
+128
+00:11:15,000 --> 00:11:19,000
+So we learned a lot about spring boot starters.
+
+129
+00:11:19,000 --> 00:11:21,000
+I believe that now you understand.
+
+130
+00:11:21,000 --> 00:11:22,000
+What are they?
+
+131
+00:11:22,000 --> 00:11:26,000
+The only thing that is left is to learn how to use them.
+
+132
+00:11:26,000 --> 00:11:31,000
+Let me start the screen sharing and review practical examples with you.
+
+133
+00:11:31,000 --> 00:11:38,000
+The first and probably the most logical question from you is how to add starter into your spring boot
+
+134
+00:11:38,000 --> 00:11:38,000
+project.
+
+135
+00:11:39,000 --> 00:11:40,000
+Everything is simple.
+
+136
+00:11:41,000 --> 00:11:47,000
+You just need to add dependency into your form XML and that's it.
+
+137
+00:11:47,000 --> 00:11:54,000
+You can find the required dependency in the open repositories like Maven Repository, for example.
+
+138
+00:11:54,000 --> 00:11:58,000
+The group ID would be org spring framework boot.
+
+139
+00:11:59,000 --> 00:12:06,000
+The artifact ID would usually follow the pattern spring boot starter followed by the name of functionality
+
+140
+00:12:06,000 --> 00:12:08,000
+or feature you want to include.
+
+141
+00:12:09,000 --> 00:12:15,000
+Once the starter is added to your project's dependencies, Spring Boot will automatically configure
+
+142
+00:12:15,000 --> 00:12:20,000
+the required components, dependencies and defaults for that specific functionality.
+
+143
+00:12:21,000 --> 00:12:27,000
+In today's practical exercise, we are going to review different starters and we'll configure different
+
+144
+00:12:27,000 --> 00:12:29,000
+spring features.
+
+145
+00:12:29,000 --> 00:12:32,000
+Let's start with you from the web starter.
+
+146
+00:12:33,000 --> 00:12:35,000
+I opened my pom.xml.
+
+147
+00:12:35,000 --> 00:12:42,000
+In this file we specify all the required dependencies and MAVEN will handle the download of all the
+
+148
+00:12:42,000 --> 00:12:48,000
+required dependencies, including additional transitive dependencies if required.
+
+149
+00:12:48,000 --> 00:12:51,000
+Here you can see spring boot starter web.
+
+150
+00:12:52,000 --> 00:13:00,000
+What features are added into my spring boot project after I added the starter support of web MVC Framework.
+
+151
+00:13:00,000 --> 00:13:08,000
+Embedded Servlet Container Apache Tomcat Dispatcher Servlet configuration Auto configuration of web
+
+152
+00:13:08,000 --> 00:13:15,000
+related dependencies such as HTTP message converters, error handling, static resource handling and
+
+153
+00:13:15,000 --> 00:13:16,000
+session management.
+
+154
+00:13:17,000 --> 00:13:25,000
+Support for restful APIs by including features like request response, conversion to JSON, XML and
+
+155
+00:13:25,000 --> 00:13:29,000
+HTTP method mapping to not repeat myself.
+
+156
+00:13:29,000 --> 00:13:35,000
+I will not repeat the example of the simple MVC controller because that's what we did in the previous
+
+157
+00:13:35,000 --> 00:13:38,000
+lesson when we created our first spring boot project.
+
+158
+00:13:38,000 --> 00:13:46,000
+You can check all the details there, but just to remind you, here we have simple home controller and
+
+159
+00:13:46,000 --> 00:13:47,000
+application properties.
+
+160
+00:13:47,000 --> 00:13:56,000
+I configure prefix and suffix for your resolver and create a web app folder in the main insight web
+
+161
+00:13:56,000 --> 00:13:57,000
+app folder.
+
+162
+00:13:57,000 --> 00:14:04,000
+Created web in folder views and put the home JSP file and error JSP file.
+
+163
+00:14:05,000 --> 00:14:05,000
+Error.
+
+164
+00:14:05,000 --> 00:14:12,000
+JSP view is resolved automatically because spring boot configured error handler automatically.
+
+165
+00:14:12,000 --> 00:14:16,000
+That's in short what we have learned in previous lesson.
+
+166
+00:14:16,000 --> 00:14:22,000
+Even in case you still have any questions, you are welcome to ask your questions below the video in
+
+167
+00:14:22,000 --> 00:14:25,000
+the comments and I will be happy to answer them.
+
+168
+00:14:26,000 --> 00:14:33,000
+If you are a student of my course Java from zero to first job, then you remember that we have module
+
+169
+00:14:33,000 --> 00:14:39,000
+about rest architecture and I showed you how to implement rest API with spring.
+
+170
+00:14:40,000 --> 00:14:42,000
+The same story in spring boot.
+
+171
+00:14:42,000 --> 00:14:48,000
+So just to make it clear, spring boot is not something completely different.
+
+172
+00:14:48,000 --> 00:14:51,000
+It is the same spring framework and everything.
+
+173
+00:14:51,000 --> 00:14:57,000
+What we have learned in previous lessons about spring framework and about its different projects is
+
+174
+00:14:57,000 --> 00:15:00,000
+absolutely applicable in spring boot.
+
+175
+00:15:01,000 --> 00:15:08,000
+As you can see, we just added Spring Boot Starter Web and you can proceed with implementation of Rest
+
+176
+00:15:08,000 --> 00:15:11,000
+API and how to implement Rest API.
+
+177
+00:15:11,000 --> 00:15:17,000
+We learned in separate lessons and there is no need for me to repeat the lessons about Rest Architecture
+
+178
+00:15:17,000 --> 00:15:19,000
+and Rest API.
+
+179
+00:15:19,000 --> 00:15:25,000
+If you would like to learn more about rest then please refer to the separate module about rest architecture.
+
+180
+00:15:25,000 --> 00:15:32,000
+And in this lesson I'm going to show you just a simple example of rest endpoint developed in spring
+
+181
+00:15:32,000 --> 00:15:33,000
+boot application.
+
+182
+00:15:34,000 --> 00:15:36,000
+I created class as it is called.
+
+183
+00:15:36,000 --> 00:15:37,000
+Rest Demo Controller.
+
+184
+00:15:37,000 --> 00:15:39,000
+Let me open it.
+
+185
+00:15:39,000 --> 00:15:46,000
+As you can see, I marked this class with rest controller annotation from the lesson about Rest API.
+
+186
+00:15:46,000 --> 00:15:47,000
+With Spring framework.
+
+187
+00:15:47,000 --> 00:15:54,000
+You remember that rest controller is a combination of controller annotation with response body.
+
+188
+00:15:54,000 --> 00:16:01,000
+In order to not make this example super complex, I don't use database connections here.
+
+189
+00:16:01,000 --> 00:16:08,000
+I use the in-memory storage which is my array list in order to store demo entities.
+
+190
+00:16:08,000 --> 00:16:15,000
+Demo entity is simple entity type with only two fields ID and label.
+
+191
+00:16:15,000 --> 00:16:16,000
+That's it.
+
+192
+00:16:17,000 --> 00:16:26,000
+I implemented three end points to fetch all entities, to add entity and to fetch entity by ID.
+
+193
+00:16:27,000 --> 00:16:35,000
+Again, we already learned naming convention for sources in Rest API and all related annotations, including
+
+194
+00:16:35,000 --> 00:16:37,000
+path variable annotation.
+
+195
+00:16:37,000 --> 00:16:40,000
+That's why don't stop too much on this.
+
+196
+00:16:41,000 --> 00:16:45,000
+Let's now just check and make sure that everything works as expected.
+
+197
+00:16:46,000 --> 00:16:49,000
+I can open Postman and send few requests.
+
+198
+00:16:52,000 --> 00:17:00,000
+When I fetch all entities, I receive two entities that I added during the initialization of the list.
+
+199
+00:17:00,000 --> 00:17:10,000
+Then I send post requests and add one more entity with ID three and we can see that it is added.
+
+200
+00:17:11,000 --> 00:17:18,000
+I can fetch all entities one more time and we can see that entity with ID number three is added at the
+
+201
+00:17:18,000 --> 00:17:19,000
+end of the list.
+
+202
+00:17:20,000 --> 00:17:25,000
+And the certain point that we created it is fetching entity by ID.
+
+203
+00:17:26,000 --> 00:17:29,000
+As you can see, it also works as expected.
+
+204
+00:17:30,000 --> 00:17:37,000
+So as you can see, this is how easily we can boost development of Rest API with Spring boot.
+
+205
+00:17:37,000 --> 00:17:44,000
+In case you want to learn more about Rest API, I invite you to check separate section about rest API
+
+206
+00:17:44,000 --> 00:17:45,000
+in this course.
+
+207
+00:17:45,000 --> 00:17:47,000
+At the meantime, we continue.
+
+208
+00:17:48,000 --> 00:17:51,000
+Let me show you this starter in action now.
+
+209
+00:17:51,000 --> 00:17:55,000
+What dependencies do we usually need for testing?
+
+210
+00:17:55,000 --> 00:17:56,000
+Spring tests.
+
+211
+00:17:56,000 --> 00:17:58,000
+JUnit Hamcrest.
+
+212
+00:17:58,000 --> 00:17:59,000
+Mockito.
+
+213
+00:17:59,000 --> 00:18:05,000
+By the way, there is a separate module about testing for software engineers in my course Java from
+
+214
+00:18:05,000 --> 00:18:06,000
+zero to first job.
+
+215
+00:18:06,000 --> 00:18:14,000
+If you want to learn more, I invite you to check that module so we can use Spring boot starter to include
+
+216
+00:18:14,000 --> 00:18:19,000
+all required dependencies for testing automatically in the POM XML.
+
+217
+00:18:19,000 --> 00:18:22,000
+I added dependency for spring boot starter test.
+
+218
+00:18:23,000 --> 00:18:29,000
+And by the way, pay attention that you don't need to specify a version of the dependency.
+
+219
+00:18:29,000 --> 00:18:30,000
+Why?
+
+220
+00:18:30,000 --> 00:18:37,000
+Because during the generation of Spring boot project we also generated this POM with a declaration of
+
+221
+00:18:37,000 --> 00:18:42,000
+the spring boot starter parent as a parent for this project.
+
+222
+00:18:42,000 --> 00:18:44,000
+And we specified version here.
+
+223
+00:18:45,000 --> 00:18:48,000
+After that, spring boot will take care of versions compatible.
+
+224
+00:18:49,000 --> 00:18:52,000
+So I added this starter.
+
+225
+00:18:52,000 --> 00:19:00,000
+Also, pay attention that I specified scope of the dependency to test because I don't need these dependencies
+
+226
+00:19:00,000 --> 00:19:02,000
+in my production ready archive.
+
+227
+00:19:03,000 --> 00:19:06,000
+I just need these dependencies for the test phase.
+
+228
+00:19:07,000 --> 00:19:12,000
+Let's now test the controller that we created in the previous example.
+
+229
+00:19:12,000 --> 00:19:14,000
+Under Test Java folder.
+
+230
+00:19:14,000 --> 00:19:18,000
+I created class that is called Demo Controller test.
+
+231
+00:19:19,000 --> 00:19:21,000
+Everything is simple here.
+
+232
+00:19:21,000 --> 00:19:27,000
+That is because Spring Boot provides excellent integration with five out of the box.
+
+233
+00:19:27,000 --> 00:19:36,000
+JUnit five has its own built in test runner called JUnit platform, which is automatically used when
+
+234
+00:19:36,000 --> 00:19:39,000
+running tests in a spring boot application.
+
+235
+00:19:39,000 --> 00:19:46,000
+This means that you don't need to explicitly specify a custom runner using run with for your spring
+
+236
+00:19:46,000 --> 00:19:53,000
+boot tests in spring boot test configuration and setup can be achieved using annotations like Spring
+
+237
+00:19:53,000 --> 00:19:58,000
+Boot Test, Web MVC test or data test.
+
+238
+00:19:59,000 --> 00:20:07,000
+These annotations, along with other specialized annotations, provide a streamlined approach to configuring
+
+239
+00:20:07,000 --> 00:20:10,000
+and running tests in different contexts.
+
+240
+00:20:10,000 --> 00:20:15,000
+Web database without the need for a custom test Runner.
+
+241
+00:20:15,000 --> 00:20:22,000
+The Spring Boot test annotation is used to specify that a particular class or classes should be treated
+
+242
+00:20:22,000 --> 00:20:29,000
+as a test class, and it triggers the setup of the spring boot testing infrastructure.
+
+243
+00:20:29,000 --> 00:20:37,000
+The specified class serves as an entry point for building the context, including scanning for components,
+
+244
+00:20:37,000 --> 00:20:41,000
+setting up configurations and initializing the necessary beans.
+
+245
+00:20:42,000 --> 00:20:50,000
+And you can see here I used enable web MVC annotation using enable weapon can be beneficial in certain
+
+246
+00:20:50,000 --> 00:20:57,000
+scenarios when you need to customize the web configuration specifically for your tests.
+
+247
+00:20:57,000 --> 00:21:06,000
+By using enable web MVC, you can ensure that the complete MVC infrastructure is enabled for your tests,
+
+248
+00:21:06,000 --> 00:21:10,000
+giving you access to the full range of MVC capabilities.
+
+249
+00:21:10,000 --> 00:21:17,000
+In the properties, you can see that I declared web application context and mock MVC.
+
+250
+00:21:17,000 --> 00:21:23,000
+Mock MVC is a special type that would allow us to test spring MVC behavior.
+
+251
+00:21:23,000 --> 00:21:25,000
+Before each test.
+
+252
+00:21:25,000 --> 00:21:27,000
+I will configure Mock MVC.
+
+253
+00:21:27,000 --> 00:21:34,000
+I would use Mock MVC Builders and web application contexts to build mock MVC.
+
+254
+00:21:34,000 --> 00:21:38,000
+What I recommend you to do is to download the source code.
+
+255
+00:21:39,000 --> 00:21:46,000
+I would leave a link in attachments to the lesson and just spend some time up to 30 minutes just by
+
+256
+00:21:46,000 --> 00:21:50,000
+reading the documentation and looking through the API of these types.
+
+257
+00:21:50,000 --> 00:21:55,000
+For example, mock MVC Builder's class has just two methods.
+
+258
+00:21:56,000 --> 00:22:01,000
+It wouldn't take too much time for reading, but will be useful for you.
+
+259
+00:22:01,000 --> 00:22:03,000
+The same story with other classes.
+
+260
+00:22:04,000 --> 00:22:08,000
+Taking into account scope and agenda of the lesson, I would continue.
+
+261
+00:22:08,000 --> 00:22:15,000
+But even in case you have any questions, you can always leave your questions in comments below the
+
+262
+00:22:15,000 --> 00:22:17,000
+video and I will be happy to answer.
+
+263
+00:22:18,000 --> 00:22:23,000
+So I configured mock MVC and here is example of the test.
+
+264
+00:22:23,000 --> 00:22:33,000
+The test verifies that when we send requests to the entities endpoint, we receive status of 200 and
+
+265
+00:22:33,000 --> 00:22:41,000
+we receive response with expected content type, which is application JSON, and that there are two
+
+266
+00:22:41,000 --> 00:22:43,000
+items in the JSON.
+
+267
+00:22:44,000 --> 00:22:51,000
+Just to remind you two items, because by default, I initialize the state of the list with two items.
+
+268
+00:22:52,000 --> 00:22:57,000
+Json.parse is a static method from MVC result matchers.
+
+269
+00:22:57,000 --> 00:23:03,000
+I recommend you to check the documentation about these matches to the different matchers that can be
+
+270
+00:23:03,000 --> 00:23:07,000
+useful for testing purposes in json.parse.
+
+271
+00:23:07,000 --> 00:23:14,000
+I pass expression and matcher in the context of the Json.parse method in spring boots mock and we see
+
+272
+00:23:14,000 --> 00:23:16,000
+result matches.
+
+273
+00:23:16,000 --> 00:23:21,000
+The dollar sign represents the root element of the JSON document.
+
+274
+00:23:22,000 --> 00:23:30,000
+When using Json.parse to perform assertions on the JSON response of a mock MVC test, the dollar sign
+
+275
+00:23:30,000 --> 00:23:35,000
+is used to specify the starting point for the JSON parse expression.
+
+276
+00:23:35,000 --> 00:23:40,000
+It allows you to navigate and extract values from the JSON structure.
+
+277
+00:23:40,000 --> 00:23:49,000
+But in this case we just referred to the root element, namely the array of elements and confirmed that
+
+278
+00:23:49,000 --> 00:23:51,000
+there are two elements.
+
+279
+00:23:52,000 --> 00:23:58,000
+When I run this test, I can see that my test is passed successfully.
+
+280
+00:23:58,000 --> 00:24:00,000
+So you have the source code.
+
+281
+00:24:00,000 --> 00:24:07,000
+I recommend you to play with it, read documentation, and think about potentially other scenarios.
+
+282
+00:24:07,000 --> 00:24:11,000
+Please let me know in case you would have any questions.
+
+283
+00:24:11,000 --> 00:24:14,000
+Let's continue and check another starter.
+
+284
+00:24:15,000 --> 00:24:19,000
+Also in the course we learned how to work with Spring Data JPA.
+
+285
+00:24:20,000 --> 00:24:27,000
+Again, this is not a lesson about spring data JPA because I had dedicated module for that, so feel
+
+286
+00:24:27,000 --> 00:24:30,000
+free to refer to those lessons.
+
+287
+00:24:30,000 --> 00:24:38,000
+In this video I will just hold the demo and overview of Spring Boot Starter Data JPA because all the
+
+288
+00:24:38,000 --> 00:24:44,000
+principles that we learned in lessons about spring data JPA are applied for Spring Boot to.
+
+289
+00:24:45,000 --> 00:24:52,000
+So in the POM maximum I added starter data GPA and I also added H2 database.
+
+290
+00:24:52,000 --> 00:24:59,000
+H2 is an in-memory database engine written in Java that provides several advantages for development
+
+291
+00:24:59,000 --> 00:25:01,000
+and testing purposes.
+
+292
+00:25:01,000 --> 00:25:08,000
+I used H2 database because it is lightweight and I don't want to over complicate this example.
+
+293
+00:25:08,000 --> 00:25:16,000
+H2 supports an in-memory mode allowing you to create and run databases entirely in memory.
+
+294
+00:25:16,000 --> 00:25:24,000
+This eliminates the need for disk input output operations, resulting in faster data access.
+
+295
+00:25:24,000 --> 00:25:32,000
+Additionally, H2 can be embedded within your application, making it ideal for unit tests or scenarios
+
+296
+00:25:32,000 --> 00:25:37,000
+where you don't want to set up separate database server.
+
+297
+00:25:37,000 --> 00:25:44,000
+But in case there is a need in database server, again, just for the reference, there is a section
+
+298
+00:25:44,000 --> 00:25:48,000
+about databases in my course Java from zero to first job.
+
+299
+00:25:48,000 --> 00:25:56,000
+I am going to show you example with H2 database in order, you could see how easily you can create development
+
+300
+00:25:56,000 --> 00:25:58,000
+environment and start testing.
+
+301
+00:25:58,000 --> 00:26:03,000
+And then I'm going to show you another example with the MySQL integration.
+
+302
+00:26:03,000 --> 00:26:06,000
+So let's start from H2 database example.
+
+303
+00:26:06,000 --> 00:26:12,000
+First I added dependency and that's it really.
+
+304
+00:26:12,000 --> 00:26:17,000
+Now you can use H2 database for testing or development purposes.
+
+305
+00:26:17,000 --> 00:26:22,000
+Let's declare GP repository in the package repositories.
+
+306
+00:26:22,000 --> 00:26:27,000
+You can see that I created class that is called Demo Entity Repository.
+
+307
+00:26:27,000 --> 00:26:34,000
+We already learned the concept of repositories in the spring data module of the course, so I wouldn't
+
+308
+00:26:34,000 --> 00:26:37,000
+stop too much on this repeating myself.
+
+309
+00:26:38,000 --> 00:26:45,000
+I specified that this repository is for demo entity type that we created and primary key has integer
+
+310
+00:26:45,000 --> 00:26:45,000
+type.
+
+311
+00:26:46,000 --> 00:26:50,000
+I also introduced some changes in the entity itself.
+
+312
+00:26:50,000 --> 00:26:58,000
+I added entity annotation and specified ID because each managed entity should have a field for ID.
+
+313
+00:26:59,000 --> 00:27:00,000
+Basically.
+
+314
+00:27:00,000 --> 00:27:00,000
+That's it.
+
+315
+00:27:01,000 --> 00:27:03,000
+Let's test our repository.
+
+316
+00:27:03,000 --> 00:27:09,000
+I created separate test in the repositories package that is called demo Entity Repository test.
+
+317
+00:27:09,000 --> 00:27:11,000
+Nothing special here.
+
+318
+00:27:11,000 --> 00:27:18,000
+I injected been of my repository that is under the test and I have one test case just for the sake of
+
+319
+00:27:18,000 --> 00:27:19,000
+example.
+
+320
+00:27:20,000 --> 00:27:26,000
+I created demo entity object and as you can see, I use my repository to save it.
+
+321
+00:27:26,000 --> 00:27:35,000
+Then I use repository to extract the entity that was just saved by ID and in assertion part.
+
+322
+00:27:35,000 --> 00:27:42,000
+I just want to be sure that founded entity is not null and that label of the entity that I found is
+
+323
+00:27:42,000 --> 00:27:46,000
+the same as the label of entity that I saved.
+
+324
+00:27:46,000 --> 00:27:54,000
+No need to test the quality of IDs because I used this ID to extract the entity from the database.
+
+325
+00:27:55,000 --> 00:27:56,000
+Let me run the test.
+
+326
+00:28:02,000 --> 00:28:05,000
+And you can see that it is passed as expected.
+
+327
+00:28:05,000 --> 00:28:13,000
+As you saw, we didn't specify user username or password database URL, literally nothing.
+
+328
+00:28:14,000 --> 00:28:19,000
+That is because springboot has out of the box support of H2O database.
+
+329
+00:28:20,000 --> 00:28:25,000
+But what to do in case you need to integrate with other database.
+
+330
+00:28:25,000 --> 00:28:26,000
+You can do it easily.
+
+331
+00:28:26,000 --> 00:28:29,000
+Let me show you the steps.
+
+332
+00:28:29,000 --> 00:28:35,000
+First of all, you need to add the required connector driver into the classpath.
+
+333
+00:28:35,000 --> 00:28:38,000
+In our case I would comment now.
+
+334
+00:28:38,000 --> 00:28:40,000
+Dependency of H2O database.
+
+335
+00:28:40,000 --> 00:28:47,000
+You know, the spring boot wouldn't configure it automatically and I would uncomment my SQL dependency.
+
+336
+00:28:48,000 --> 00:28:55,000
+Then I need to configure data source and you already know that all configurations for Spring boot should
+
+337
+00:28:55,000 --> 00:28:58,000
+be placed in the application properties file.
+
+338
+00:28:58,000 --> 00:29:02,000
+Here you can find configurations for the MySQL database.
+
+339
+00:29:03,000 --> 00:29:07,000
+It is just a URL to the database that I created before this lesson.
+
+340
+00:29:08,000 --> 00:29:10,000
+Username Password.
+
+341
+00:29:10,000 --> 00:29:14,000
+Driver Class Name and Auto Generation Strategy.
+
+342
+00:29:14,000 --> 00:29:22,000
+Update strategy means to update the tables that already were created and it will create tables in case
+
+343
+00:29:22,000 --> 00:29:23,000
+it was absent.
+
+344
+00:29:25,000 --> 00:29:28,000
+I also created an end point in the demo controller.
+
+345
+00:29:29,000 --> 00:29:34,000
+It is endpoint that accepts JSON and saves entity to the database.
+
+346
+00:29:35,000 --> 00:29:37,000
+Let me run the application.
+
+347
+00:29:38,000 --> 00:29:43,000
+I open Postman and I send request to this endpoint.
+
+348
+00:29:44,000 --> 00:29:45,000
+In the body.
+
+349
+00:29:45,000 --> 00:29:49,000
+I send the entity that I want to save in the database.
+
+350
+00:29:49,000 --> 00:29:50,000
+In response.
+
+351
+00:29:50,000 --> 00:29:54,000
+I see message is that entity was saved successfully.
+
+352
+00:29:54,000 --> 00:30:03,000
+Let me open now the MySQL workbench and you can see that I have a table created and entity with a three
+
+353
+00:30:03,000 --> 00:30:05,000
+was created successfully.
+
+354
+00:30:05,000 --> 00:30:06,000
+That's it.
+
+355
+00:30:06,000 --> 00:30:08,000
+Congratulations.
+
+356
+00:30:08,000 --> 00:30:11,000
+That's how easily we can integrate MySQL.
+
+357
+00:30:11,000 --> 00:30:16,000
+In case you want to connect any other database, the algorithm is the same.
+
+358
+00:30:17,000 --> 00:30:21,000
+Also, I wanted to show you security starter in action.
+
+359
+00:30:21,000 --> 00:30:28,000
+And again, just for the reference, remember that we have separate module about spring security, where
+
+360
+00:30:28,000 --> 00:30:35,000
+I covered a lot of possible configurations of spring security and we also did practical activities and
+
+361
+00:30:35,000 --> 00:30:36,000
+home tasks.
+
+362
+00:30:36,000 --> 00:30:42,000
+So in this video we don't have a goal to learn spring security from scratch.
+
+363
+00:30:42,000 --> 00:30:47,000
+I just want to show you how you can easily enable spring security in your application.
+
+364
+00:30:47,000 --> 00:30:54,000
+As you may already notice and understand, most of the required dependencies are easily imported by
+
+365
+00:30:54,000 --> 00:30:55,000
+using starters.
+
+366
+00:30:55,000 --> 00:31:00,000
+So the first thing that we need to do is to add security starter.
+
+367
+00:31:00,000 --> 00:31:07,000
+After that, all required dependencies will be present in the classpath and you can jump to the configuration
+
+368
+00:31:07,000 --> 00:31:08,000
+of security rules.
+
+369
+00:31:09,000 --> 00:31:16,000
+After adding this starter, all endpoints are secured by default and in case you would run the application
+
+370
+00:31:16,000 --> 00:31:23,000
+just with this starter and would try to reach out any endpoint, you are going to see 401.
+
+371
+00:31:23,000 --> 00:31:26,000
+Unauthorized response status code.
+
+372
+00:31:27,000 --> 00:31:32,000
+In order to avoid this, it is recommended you to configure security filter chain.
+
+373
+00:31:33,000 --> 00:31:33,000
+Here.
+
+374
+00:31:33,000 --> 00:31:36,000
+I have class with security configuration.
+
+375
+00:31:36,000 --> 00:31:44,000
+I marked it with configuration annotation and enable web security, and I declared the bin of security
+
+376
+00:31:44,000 --> 00:31:45,000
+filter chain.
+
+377
+00:31:45,000 --> 00:31:51,000
+And then I configured security filter chain in order to allow access to all resources.
+
+378
+00:31:52,000 --> 00:31:59,000
+But I believe that you remember that you can configure access based on roles and privileges to the different
+
+379
+00:31:59,000 --> 00:31:59,000
+resources.
+
+380
+00:32:00,000 --> 00:32:06,000
+So everything that you have learned in spring Security module is applied in spring boot to.
+
+381
+00:32:07,000 --> 00:32:10,000
+That's all what I wanted to share with you in this lesson.
+
+382
+00:32:10,000 --> 00:32:16,000
+The main thing that I want you to learn from this lesson is that in case you are familiar with different
+
+383
+00:32:16,000 --> 00:32:23,000
+projects of spring framework, it takes you almost nothing to be familiar with Spring Boot, as you
+
+384
+00:32:23,000 --> 00:32:24,000
+saw today.
+
+385
+00:32:24,000 --> 00:32:30,000
+We worked with different starters and configured many different things using the knowledge that we already
+
+386
+00:32:30,000 --> 00:32:32,000
+learned in previous lessons.
+
+387
+00:32:32,000 --> 00:32:41,000
+Moreover, taking into account spring boot, automate a lot of things, more things left in the shadow
+
+388
+00:32:41,000 --> 00:32:47,000
+and you can even understand what is happening on the background in order to be able to troubleshoot
+
+389
+00:32:47,000 --> 00:32:54,000
+issues in case of any and search for required property name in the documentation if needed in order
+
+390
+00:32:54,000 --> 00:32:57,000
+to add it in application properties.
+
+391
+00:32:57,000 --> 00:33:01,000
+Let's recap now what we have learned in the lesson.
+
+392
+00:33:02,000 --> 00:33:04,000
+We learned what starters in Spring Boot are.
+
+393
+00:33:05,000 --> 00:33:11,000
+I hope that you understood why we need them and what advantages of spring boot starters are.
+
+394
+00:33:11,000 --> 00:33:19,000
+We reviewed a list of spring boot starters that you potentially can use in your projects on real examples.
+
+395
+00:33:19,000 --> 00:33:23,000
+We reviewed and learned how to add Spring boot starter.
+
+396
+00:33:23,000 --> 00:33:29,000
+We learned web starter and developed our rest API in Spring boot.
+
+397
+00:33:30,000 --> 00:33:34,000
+I showed you Test starter Spring data JPA starter.
+
+398
+00:33:34,000 --> 00:33:41,000
+We configured H2 database for our spring boot application and we also learned how to declare a data
+
+399
+00:33:41,000 --> 00:33:43,000
+source for my SQL database.
+
+400
+00:33:43,000 --> 00:33:47,000
+And at the end of the lesson we learned security starter.
+
+401
+00:33:47,000 --> 00:33:49,000
+That's all for this lesson.
+
+402
+00:33:49,000 --> 00:33:51,000
+Thanks a lot for your attention.
+
+403
+00:33:51,000 --> 00:33:54,000
+Have a great day and see you in the next lesson.
+

92 - Spring Boot/003 Spring-Boot-Starters-on-Github.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-starters

92 - Spring Boot/004 Common-Spring-Boot-Application-Properties.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html

92 - Spring Boot/004 Source-code-of-examples-commit-with-changes-.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/java-learnit-spring-boot/commit/1ca891ad59a291a71a5ba1df5ae4c91b87dc2734

92 - Spring Boot/004 Spring Boot Configurations & Application Properties_en.srt

@@ -0,0 +1,1448 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, Tim.
+
+2
+00:00:06,000 --> 00:00:10,000
+By this moment in our course, we already learned what a spring boot is.
+
+3
+00:00:10,000 --> 00:00:17,000
+We learned spring boot starters, and we did practical exercises by running our spring boot application
+
+4
+00:00:17,000 --> 00:00:19,000
+with different starters.
+
+5
+00:00:19,000 --> 00:00:26,000
+In this video, we are going to extend our understanding of spring boot configurations and application
+
+6
+00:00:26,000 --> 00:00:27,000
+properties.
+
+7
+00:00:28,000 --> 00:00:34,000
+I know that you already watched previous lessons and you saw me configuring Spring Boot with the help
+
+8
+00:00:34,000 --> 00:00:36,000
+of application Properties file.
+
+9
+00:00:36,000 --> 00:00:44,000
+But in this lesson, let's go deeper and understand more about this configuration file.
+
+10
+00:00:44,000 --> 00:00:51,000
+We will start the lesson from the brief overview of what application properties are in Spring boot and
+
+11
+00:00:51,000 --> 00:00:52,000
+why we need them.
+
+12
+00:00:52,000 --> 00:00:59,000
+Then we'll review different use cases about precedence order of properties from different sources.
+
+13
+00:00:59,000 --> 00:01:05,000
+This is kind of advanced level, but I believe this can help you in real life.
+
+14
+00:01:05,000 --> 00:01:10,000
+You are going to understand how to override properties in case it would be needed.
+
+15
+00:01:11,000 --> 00:01:17,000
+We are going to review some default spring boot properties and least of the most common spring boot
+
+16
+00:01:17,000 --> 00:01:18,000
+properties.
+
+17
+00:01:19,000 --> 00:01:24,000
+After we reviewed everything, what I have just mentioned, we will jump to practical examples.
+
+18
+00:01:24,000 --> 00:01:29,000
+I will start screen sharing and we will learn how to change web server port.
+
+19
+00:01:29,000 --> 00:01:37,000
+Yes, this is simple example, but it will help you to understand how to work with application properties.
+
+20
+00:01:37,000 --> 00:01:39,000
+File a little bit more.
+
+21
+00:01:39,000 --> 00:01:42,000
+Complex topic would be to configure SSL.
+
+22
+00:01:42,000 --> 00:01:48,000
+TLS in the spring boot will generate Self-signed certificate.
+
+23
+00:01:48,000 --> 00:01:50,000
+I'm going to show you how to do this.
+
+24
+00:01:50,000 --> 00:01:57,000
+Also, I will teach you how to change the context path of the application and configure login level.
+
+25
+00:01:57,000 --> 00:02:04,000
+And at the end of the lesson I am going to explain you when and how we can use configuration properties.
+
+26
+00:02:04,000 --> 00:02:05,000
+Annotation.
+
+27
+00:02:05,000 --> 00:02:07,000
+Let's start our lesson.
+
+28
+00:02:08,000 --> 00:02:12,000
+Let's start from learning more details about application properties.
+
+29
+00:02:12,000 --> 00:02:19,000
+It seems to be easy and straightforward at the first glance, but I bet that in this lesson you are
+
+30
+00:02:19,000 --> 00:02:21,000
+going to learn something new.
+
+31
+00:02:22,000 --> 00:02:29,000
+Spring boot application Properties file is an essential part of configuring and customizing spring boot
+
+32
+00:02:29,000 --> 00:02:30,000
+applications.
+
+33
+00:02:30,000 --> 00:02:39,000
+It provides a convenient way to externalize configuration settings and modify the behavior of your application
+
+34
+00:02:39,000 --> 00:02:42,000
+without modifying the application code.
+
+35
+00:02:42,000 --> 00:02:48,000
+So basically, if you watched previous lessons, you should be aware that application properties file
+
+36
+00:02:48,000 --> 00:02:57,000
+in Spring Boot is a text file that contains key value pairs used to configure various aspects of the
+
+37
+00:02:57,000 --> 00:02:58,000
+application.
+
+38
+00:02:58,000 --> 00:03:06,000
+It follows a specific naming convention and can be written in various formats such as properties or
+
+39
+00:03:06,000 --> 00:03:07,000
+YAML.
+
+40
+00:03:08,000 --> 00:03:10,000
+Where files should be located.
+
+41
+00:03:10,000 --> 00:03:16,000
+By default, spring boot looks for application properties file in the classpath root.
+
+42
+00:03:17,000 --> 00:03:18,000
+See main resources.
+
+43
+00:03:19,000 --> 00:03:28,000
+But you can also specify a custom location using the spring config name and spring config location properties.
+
+44
+00:03:29,000 --> 00:03:33,000
+In spring boot, you may have multiple sources of application properties.
+
+45
+00:03:33,000 --> 00:03:39,000
+All configurations are merged together based on the predefined precedence order.
+
+46
+00:03:40,000 --> 00:03:41,000
+Why is this is needed?
+
+47
+00:03:42,000 --> 00:03:49,000
+Because sometimes we don't have access to the application properties file itself or we don't want to
+
+48
+00:03:49,000 --> 00:03:50,000
+adjust it.
+
+49
+00:03:50,000 --> 00:03:57,000
+For example, we create deployment scripts and we want to automate deployment of our application in
+
+50
+00:03:57,000 --> 00:04:01,000
+different environments and we need to override some properties.
+
+51
+00:04:02,000 --> 00:04:05,000
+Also, there can be security concern.
+
+52
+00:04:05,000 --> 00:04:13,000
+It is best practice to externalize sensitive information such as passwords or API keys from the application
+
+53
+00:04:13,000 --> 00:04:14,000
+code.
+
+54
+00:04:14,000 --> 00:04:18,000
+Springboot supports the use of environment variables.
+
+55
+00:04:18,000 --> 00:04:26,000
+Command line arguments or external configuration files to provide these sensitive values.
+
+56
+00:04:26,000 --> 00:04:34,000
+This helps in maintaining a separation of configuration and code and improves security by supporting
+
+57
+00:04:34,000 --> 00:04:35,000
+multiple sources.
+
+58
+00:04:35,000 --> 00:04:43,000
+Springboot provides flexibility in configuring and customizing applications based on specific requirements
+
+59
+00:04:43,000 --> 00:04:44,000
+and environments.
+
+60
+00:04:45,000 --> 00:04:52,000
+Properties specified in files with high precedence overrides those with lower precedence.
+
+61
+00:04:52,000 --> 00:04:57,000
+The order of precedence from highest to lowest is the following.
+
+62
+00:04:58,000 --> 00:05:03,000
+The highest precedence have properties specified through command line arguments.
+
+63
+00:05:04,000 --> 00:05:10,000
+For example, instead of specifying server port in the application properties file, you can pass it
+
+64
+00:05:10,000 --> 00:05:15,000
+as a command line argument like you can see in the example on the slide.
+
+65
+00:05:16,000 --> 00:05:23,000
+Not so often you will run your application manually, but your DevOps will create deployment scripts
+
+66
+00:05:23,000 --> 00:05:29,000
+that supposed to run your application on different environments or on the same environments but with
+
+67
+00:05:29,000 --> 00:05:37,000
+different configurations and DevOps will not extract your archive and adjust your application properties.
+
+68
+00:05:37,000 --> 00:05:44,000
+So property will be passed from the outside of the archive and will have higher precedence.
+
+69
+00:05:44,000 --> 00:05:45,000
+Is it clear?
+
+70
+00:05:45,000 --> 00:05:49,000
+Can you understand now the business case when this can be helpful?
+
+71
+00:05:50,000 --> 00:05:57,000
+The next properties specified using spring application JSON environment variable.
+
+72
+00:05:57,000 --> 00:06:03,000
+Do you remember like we created Javahome environment variable in the similar way you can create spring
+
+73
+00:06:03,000 --> 00:06:10,000
+application JSON environment variable by setting the spring application JSON environment variable,
+
+74
+00:06:10,000 --> 00:06:16,000
+you can provide custom configuration properties to your spring boot application without modifying the
+
+75
+00:06:16,000 --> 00:06:18,000
+applications properties files.
+
+76
+00:06:19,000 --> 00:06:26,000
+These properties will take precedence over properties defined in other sources such as properties,
+
+77
+00:06:26,000 --> 00:06:28,000
+files or system properties.
+
+78
+00:06:28,000 --> 00:06:31,000
+It may look like you can see on the slide.
+
+79
+00:06:32,000 --> 00:06:35,000
+Properties specified in the Java system properties.
+
+80
+00:06:36,000 --> 00:06:40,000
+System properties can be specified in various ways, but one common method.
+
+81
+00:06:40,000 --> 00:06:46,000
+Is by using the D flag when running the Java application.
+
+82
+00:06:46,000 --> 00:06:51,000
+On this slide you can see how you can specify system properties.
+
+83
+00:06:51,000 --> 00:06:53,000
+By using the D flag.
+
+84
+00:06:54,000 --> 00:06:58,000
+You can set a specific system property for your spring boot application.
+
+85
+00:06:59,000 --> 00:07:02,000
+These properties will be available through the system.
+
+86
+00:07:02,000 --> 00:07:03,000
+Get property method.
+
+87
+00:07:03,000 --> 00:07:05,000
+In your application code.
+
+88
+00:07:05,000 --> 00:07:12,000
+In the context of Spring boot, this system properties can be used to configure and customize various
+
+89
+00:07:12,000 --> 00:07:16,000
+aspects of your application based on the specific requirements.
+
+90
+00:07:17,000 --> 00:07:21,000
+Properties in the config directory of the current directory.
+
+91
+00:07:21,000 --> 00:07:23,000
+Here is how it works.
+
+92
+00:07:23,000 --> 00:07:31,000
+Create a directory named config in the current directory where you are running your spring boot application.
+
+93
+00:07:31,000 --> 00:07:38,000
+Inside the config directory place a properties file with the desired configuration properties.
+
+94
+00:07:38,000 --> 00:07:42,000
+The file should typically have a properties or YAML extension.
+
+95
+00:07:43,000 --> 00:07:50,000
+Start your spring boot application by placing a properties file in the config directory.
+
+96
+00:07:50,000 --> 00:07:55,000
+Spring boot will automatically load and merge the properties from that file.
+
+97
+00:07:55,000 --> 00:08:02,000
+This allows you to provide additional or overriding configuration properties specific to the deployment,
+
+98
+00:08:02,000 --> 00:08:06,000
+environment or machine where the application is running.
+
+99
+00:08:06,000 --> 00:08:14,000
+The config directory serves as a externalized configuration location that is considered during the configuration
+
+100
+00:08:14,000 --> 00:08:16,000
+merging process.
+
+101
+00:08:16,000 --> 00:08:23,000
+It provides a way to externalize configuration files separate from the applications classpath or packaged
+
+102
+00:08:23,000 --> 00:08:24,000
+jar file.
+
+103
+00:08:26,000 --> 00:08:28,000
+Properties specified in the class pass route.
+
+104
+00:08:29,000 --> 00:08:37,000
+For example, in SRC main resources in a standard spring boot project structure, the SRC main resources
+
+105
+00:08:37,000 --> 00:08:42,000
+directory is where you would typically place your application properties files.
+
+106
+00:08:43,000 --> 00:08:47,000
+Properties specified using spring config name environment variable.
+
+107
+00:08:48,000 --> 00:08:54,000
+The spring config name environment variable allows you to specify the name of the configuration file
+
+108
+00:08:54,000 --> 00:09:00,000
+without the file extension by setting the spring config name environment variable.
+
+109
+00:09:00,000 --> 00:09:06,000
+You can override the default name of the configuration file used by spring boot.
+
+110
+00:09:07,000 --> 00:09:11,000
+The default configuration file name is application.
+
+111
+00:09:11,000 --> 00:09:15,000
+So setting spring config name to a different value.
+
+112
+00:09:15,000 --> 00:09:23,000
+For example, custom config will make spring boot look for custom config properties or custom config
+
+113
+00:09:23,000 --> 00:09:26,000
+yaml instead of application properties.
+
+114
+00:09:27,000 --> 00:09:32,000
+Properties specified using the spring config location environment variable.
+
+115
+00:09:33,000 --> 00:09:39,000
+The spring config location environment variable allows you to specify the location of the configuration
+
+116
+00:09:39,000 --> 00:09:41,000
+file or directory.
+
+117
+00:09:42,000 --> 00:09:49,000
+By setting the spring config location environment variable, you can override the default location where
+
+118
+00:09:49,000 --> 00:09:52,000
+spring boot searches for the configuration files.
+
+119
+00:09:53,000 --> 00:09:59,000
+The default location is the classpath root src main resources.
+
+120
+00:10:00,000 --> 00:10:01,000
+And the last but not the least.
+
+121
+00:10:01,000 --> 00:10:07,000
+And the configuration precedents are default properties provided by Spring Boot.
+
+122
+00:10:07,000 --> 00:10:10,000
+We are going to learn what is a on the separate slide.
+
+123
+00:10:11,000 --> 00:10:18,000
+The default properties provided by Spring Boot refer to the built in default configuration properties.
+
+124
+00:10:18,000 --> 00:10:24,000
+That spring boot automatically applies if no explicit configuration is provided.
+
+125
+00:10:24,000 --> 00:10:32,000
+These default properties are part of spring boot opinionated configuration approach and are designed
+
+126
+00:10:32,000 --> 00:10:38,000
+to provide sensible and convenient defaults for common application configurations.
+
+127
+00:10:38,000 --> 00:10:45,000
+Here are a few examples of default properties provided by Spring Boot Server port.
+
+128
+00:10:45,000 --> 00:10:51,000
+The default port on which the embedded web server listens is 8080.
+
+129
+00:10:52,000 --> 00:10:54,000
+Spring application admin enabled.
+
+130
+00:10:54,000 --> 00:11:00,000
+Whether to enable admin features for the application is false by default.
+
+131
+00:11:01,000 --> 00:11:02,000
+Spring config name.
+
+132
+00:11:03,000 --> 00:11:05,000
+This is the file name with configuration.
+
+133
+00:11:05,000 --> 00:11:11,000
+By default, it is application spring task Execution Pool.
+
+134
+00:11:11,000 --> 00:11:12,000
+Core size.
+
+135
+00:11:13,000 --> 00:11:14,000
+Core number of threads.
+
+136
+00:11:14,000 --> 00:11:16,000
+The default value is eight.
+
+137
+00:11:17,000 --> 00:11:19,000
+These are just few of them.
+
+138
+00:11:19,000 --> 00:11:23,000
+You are going to learn more default spring boot properties soon.
+
+139
+00:11:23,000 --> 00:11:31,000
+These default properties are automatically loaded and applied by spring boot unless overridden by explicit
+
+140
+00:11:31,000 --> 00:11:39,000
+configuration provided through other means such as application properties, files, command line arguments
+
+141
+00:11:39,000 --> 00:11:41,000
+or environment variables.
+
+142
+00:11:41,000 --> 00:11:48,000
+The default properties provided by Spring Boot help streamline the development process by offering sensible
+
+143
+00:11:48,000 --> 00:11:55,000
+and opinionated defaults, allowing developers to quickly bootstrap and configure their applications
+
+144
+00:11:55,000 --> 00:12:00,000
+without explicitly specifying every configuration property.
+
+145
+00:12:01,000 --> 00:12:06,000
+Let me start screen sharing and we'll review more interesting configurations on examples.
+
+146
+00:12:07,000 --> 00:12:10,000
+Here is the page from the Spring Boot documentation.
+
+147
+00:12:10,000 --> 00:12:14,000
+It is used to list common application properties.
+
+148
+00:12:14,000 --> 00:12:22,000
+You can find property name description to understand what it is about and default value in case of any.
+
+149
+00:12:23,000 --> 00:12:29,000
+On the left, you can find groups of properties, so you can start from searching through the group
+
+150
+00:12:29,000 --> 00:12:33,000
+of properties or just use search on the web page.
+
+151
+00:12:33,000 --> 00:12:39,000
+I will leave this link in attachments to the video and I recommend you to watch it.
+
+152
+00:12:39,000 --> 00:12:43,000
+Just spend from 10 to 15 minutes looking through this page.
+
+153
+00:12:44,000 --> 00:12:45,000
+Definitely.
+
+154
+00:12:45,000 --> 00:12:52,000
+You will not be able to learn all possible properties at once, but the goal of this exercise is to
+
+155
+00:12:52,000 --> 00:13:00,000
+understand on the high level which properties do we have and what group of properties we can spend hours
+
+156
+00:13:00,000 --> 00:13:03,000
+during the video learning each property.
+
+157
+00:13:03,000 --> 00:13:10,000
+But the truth is that you will not be able to remember them all until you start using them.
+
+158
+00:13:10,000 --> 00:13:16,000
+So I really encourage you to look through these properties and be ready for development.
+
+159
+00:13:17,000 --> 00:13:24,000
+In case you have any questions, please put your questions below the video and I will be happy to answer.
+
+160
+00:13:25,000 --> 00:13:29,000
+And now let me switch to the eclipse workspace.
+
+161
+00:13:29,000 --> 00:13:34,000
+I am going to show you a real life example of changing properties.
+
+162
+00:13:34,000 --> 00:13:35,000
+Definitely.
+
+163
+00:13:35,000 --> 00:13:41,000
+I don't have any plans to show you each property, but just some key sayings that will help you to work
+
+164
+00:13:41,000 --> 00:13:44,000
+with other properties by analogy.
+
+165
+00:13:45,000 --> 00:13:47,000
+Port number by default.
+
+166
+00:13:47,000 --> 00:13:53,000
+Applications that are deployed on Tomcat web server are accessible via default.
+
+167
+00:13:53,000 --> 00:13:54,000
+Port 8080.
+
+168
+00:13:55,000 --> 00:13:59,000
+We can easily configure spring boot to use a different port.
+
+169
+00:14:00,000 --> 00:14:06,000
+I open application properties and here I have section with examples for our today's lesson.
+
+170
+00:14:07,000 --> 00:14:12,000
+I will share with you the link to the source code in attachments to the video and you will be able to
+
+171
+00:14:12,000 --> 00:14:17,000
+check it if you wish and run examples on your local computer.
+
+172
+00:14:17,000 --> 00:14:23,000
+In this particular case, our web server will be started at the port 8888.
+
+173
+00:14:24,000 --> 00:14:25,000
+That was easy.
+
+174
+00:14:26,000 --> 00:14:33,000
+And just in case you work in Eclipse, there is Autocompletion available for spring boot properties.
+
+175
+00:14:34,000 --> 00:14:41,000
+Just feel free to use control and space simultaneously as usual in order to see Autocompletion suggestions
+
+176
+00:14:41,000 --> 00:14:42,000
+for properties.
+
+177
+00:14:44,000 --> 00:14:46,000
+SSL class configuration.
+
+178
+00:14:46,000 --> 00:14:52,000
+Another important and interesting set of properties is related to SSL, TLS configuration.
+
+179
+00:14:53,000 --> 00:14:56,000
+Just few words about semantics here.
+
+180
+00:14:56,000 --> 00:15:05,000
+Both SSL, which stands for Secure Sockets Layer and TLS, which stands for Transport Layer Security
+
+181
+00:15:05,000 --> 00:15:11,000
+are cryptographic protocols used to secure network communications.
+
+182
+00:15:11,000 --> 00:15:19,000
+It is more accurate and up to date to refer to the current standard as TLS rather than SSL.
+
+183
+00:15:19,000 --> 00:15:28,000
+SSL was the predecessor of TLS and is now considered insecure and deprecated due to security vulnerabilities.
+
+184
+00:15:29,000 --> 00:15:35,000
+So let me review with you properties that are required for SSL, TLS configuration.
+
+185
+00:15:36,000 --> 00:15:43,000
+The first one server SSL Keystore Type Pkcs12.
+
+186
+00:15:43,000 --> 00:15:50,000
+This property specifies the type of keystore file used for SSL TLS configuration.
+
+187
+00:15:50,000 --> 00:16:00,000
+In this case it is set to Pkcs12, which is a popular format for storing cryptographic objects such
+
+188
+00:16:00,000 --> 00:16:04,000
+as private keys, certificates and certificate chains.
+
+189
+00:16:05,000 --> 00:16:10,000
+The next property server SSL keystore.
+
+190
+00:16:10,000 --> 00:16:14,000
+It is equal to root dot P12.
+
+191
+00:16:14,000 --> 00:16:20,000
+This property specifies the path or location of the keystore file.
+
+192
+00:16:20,000 --> 00:16:29,000
+The file name Root Point P12 indicates that the Keystore file is named Root P12.
+
+193
+00:16:29,000 --> 00:16:37,000
+This file contains the necessary cryptographic material, including the private key and associated certificates
+
+194
+00:16:37,000 --> 00:16:40,000
+used for SSL TLS encryption.
+
+195
+00:16:40,000 --> 00:16:46,000
+In this particular example, I'm going to use Self-signed certificate for development purposes.
+
+196
+00:16:46,000 --> 00:16:47,000
+What is it?
+
+197
+00:16:48,000 --> 00:16:54,000
+A Self-signed certificate is a type of digital certificate that is signed by the entity to which it
+
+198
+00:16:54,000 --> 00:16:55,000
+belongs.
+
+199
+00:16:56,000 --> 00:17:03,000
+Unlike certificates issued by a trusted third party certificate authority, Self-signed certificates
+
+200
+00:17:03,000 --> 00:17:07,000
+are not validated or verified by an external party.
+
+201
+00:17:07,000 --> 00:17:12,000
+Instead, the entity generates and signs the certificate itself.
+
+202
+00:17:13,000 --> 00:17:20,000
+You can't get trusted certificate just for an IP address and your home server.
+
+203
+00:17:20,000 --> 00:17:24,000
+You should have some domain name, but for development purposes.
+
+204
+00:17:24,000 --> 00:17:29,000
+Like I already said, you can use self-signed certificates.
+
+205
+00:17:29,000 --> 00:17:37,000
+And taking into account we already touched this topic, let's also review how to generate key for TLS
+
+206
+00:17:37,000 --> 00:17:39,000
+for Self-signed certificate.
+
+207
+00:17:40,000 --> 00:17:46,000
+To generate a Pkcs 12 key using the Java Key two command line tool.
+
+208
+00:17:46,000 --> 00:17:49,000
+Follow these instructions.
+
+209
+00:17:50,000 --> 00:17:58,000
+Open a command prompt or terminal run the following Keytool command to generate a new keystore and key
+
+210
+00:17:58,000 --> 00:17:59,000
+pair.
+
+211
+00:17:59,000 --> 00:18:02,000
+You can find command on the screen.
+
+212
+00:18:03,000 --> 00:18:05,000
+Explanation of the options used.
+
+213
+00:18:06,000 --> 00:18:09,000
+Jan Keypair generates a new key pair.
+
+214
+00:18:10,000 --> 00:18:15,000
+Alice My LHS specifies the alias for the key pair.
+
+215
+00:18:16,000 --> 00:18:17,000
+Key algorithm.
+
+216
+00:18:17,000 --> 00:18:24,000
+RSA specifies the algorithm to use for the key pair RSA in this case.
+
+217
+00:18:25,000 --> 00:18:26,000
+He sighs.
+
+218
+00:18:26,000 --> 00:18:31,000
+2048 specifies the key size in bits.
+
+219
+00:18:32,000 --> 00:18:33,000
+Keystore.
+
+220
+00:18:33,000 --> 00:18:34,000
+Keystore.
+
+221
+00:18:34,000 --> 00:18:39,000
+P12 specifies the name of the Keystore file to be generated.
+
+222
+00:18:40,000 --> 00:18:43,000
+Store type Pkcs12.
+
+223
+00:18:43,000 --> 00:18:49,000
+Specifies the type of the Keystore as Pkcs12.
+
+224
+00:18:49,000 --> 00:18:56,000
+Follow the prompts to enter the required information such as keystore, password, name, organization,
+
+225
+00:18:56,000 --> 00:18:57,000
+key, etcetera.
+
+226
+00:18:57,000 --> 00:19:00,000
+Provide the necessary details as prompted.
+
+227
+00:19:01,000 --> 00:19:09,000
+Once process is complete, the Keystore P12 file will be generated containing the private key and the
+
+228
+00:19:09,000 --> 00:19:11,000
+corresponding certificate.
+
+229
+00:19:11,000 --> 00:19:19,000
+You now have pkcs12 keystore file containing the private key and certificate.
+
+230
+00:19:19,000 --> 00:19:27,000
+This format allows you to store both the private key and the associated certificate in a single file.
+
+231
+00:19:27,000 --> 00:19:35,000
+Please make sure to keep the Keystore file secure and protect it with a strong password as it contains
+
+232
+00:19:35,000 --> 00:19:37,000
+sensitive information.
+
+233
+00:19:37,000 --> 00:19:46,000
+So I generated the key following these instructions and put it in the keys folder under src main resources.
+
+234
+00:19:46,000 --> 00:19:48,000
+Here it is.
+
+235
+00:19:48,000 --> 00:19:55,000
+And in the application properties specify the path to the file using the class pass reference.
+
+236
+00:19:56,000 --> 00:19:59,000
+Let's review the next properties from this list.
+
+237
+00:20:00,000 --> 00:20:02,000
+Server SSL Keystore.
+
+238
+00:20:02,000 --> 00:20:03,000
+Password.
+
+239
+00:20:04,000 --> 00:20:04,000
+Root.
+
+240
+00:20:04,000 --> 00:20:05,000
+Root.
+
+241
+00:20:05,000 --> 00:20:13,000
+This property defines the password required to access and unlock the keystore file specified earlier.
+
+242
+00:20:13,000 --> 00:20:16,000
+In this case, the password is set to root.
+
+243
+00:20:16,000 --> 00:20:17,000
+Root.
+
+244
+00:20:17,000 --> 00:20:22,000
+This is the one I used during the generation of my certificate.
+
+245
+00:20:23,000 --> 00:20:29,000
+It is important to choose a strong and secure password to protect the Keystore file.
+
+246
+00:20:30,000 --> 00:20:33,000
+Seven SSL key route.
+
+247
+00:20:34,000 --> 00:20:39,000
+Again, this is another property that is specified on the generation stage.
+
+248
+00:20:40,000 --> 00:20:46,000
+This property identifies the UN name for the key entry within the Keystore file.
+
+249
+00:20:46,000 --> 00:20:54,000
+The key entry represents the specific cryptographic key pair, private key and associated public key
+
+250
+00:20:54,000 --> 00:20:59,000
+that the server will use for SSL TLS connections.
+
+251
+00:20:59,000 --> 00:21:03,000
+In this case, the key is set to root.
+
+252
+00:21:04,000 --> 00:21:10,000
+These properties are used to configure SSL, TLS settings for a server.
+
+253
+00:21:10,000 --> 00:21:17,000
+Specifically related to the Keystore file, its type password and the alias of the key entry.
+
+254
+00:21:18,000 --> 00:21:25,000
+By properly configuring these properties, the server can establish secure connections using SSL, TLS
+
+255
+00:21:25,000 --> 00:21:31,000
+protocols and protect the confidentiality and integrity of the transmitted data.
+
+256
+00:21:32,000 --> 00:21:35,000
+I'm going to show you how it works in a minute.
+
+257
+00:21:35,000 --> 00:21:42,000
+Let me just add a few more configurations and we'll run the application and we'll check all adjustments
+
+258
+00:21:42,000 --> 00:21:43,000
+at once.
+
+259
+00:21:44,000 --> 00:21:45,000
+Context sparse.
+
+260
+00:21:45,000 --> 00:21:50,000
+Let's learn how to change context sparse by default.
+
+261
+00:21:50,000 --> 00:21:53,000
+Our application is available at root.
+
+262
+00:21:53,000 --> 00:21:56,000
+If you need to change it, you can do it too.
+
+263
+00:21:57,000 --> 00:21:57,000
+Why?
+
+264
+00:21:57,000 --> 00:22:00,000
+You may need to change context Sparse.
+
+265
+00:22:00,000 --> 00:22:03,000
+There can be several reasons for that.
+
+266
+00:22:03,000 --> 00:22:11,000
+For example, you have multiple applications on the same server or SEO optimization, Search engine
+
+267
+00:22:11,000 --> 00:22:13,000
+optimization.
+
+268
+00:22:13,000 --> 00:22:20,000
+You might want to include keywords or relevant information in the URL path to improve search engine
+
+269
+00:22:20,000 --> 00:22:21,000
+rankings.
+
+270
+00:22:22,000 --> 00:22:24,000
+Compliance with organization standards.
+
+271
+00:22:25,000 --> 00:22:29,000
+It also can be a reason anyway, in case you need to change the context.
+
+272
+00:22:29,000 --> 00:22:33,000
+Plus, you can easily do this like you can see on the screen.
+
+273
+00:22:33,000 --> 00:22:37,000
+In this case, my context path would be spring boot demo.
+
+274
+00:22:39,000 --> 00:22:42,000
+Configure the login levels if you want.
+
+275
+00:22:42,000 --> 00:22:47,000
+You can easily configure login levels in spring boot application.
+
+276
+00:22:47,000 --> 00:22:54,000
+Probably you saw many times the crazy amount of logs in our console during the execution of spring boot
+
+277
+00:22:54,000 --> 00:22:55,000
+application.
+
+278
+00:22:55,000 --> 00:23:02,000
+You can configure many different properties related to login and you can check them using the link I
+
+279
+00:23:02,000 --> 00:23:03,000
+provided.
+
+280
+00:23:03,000 --> 00:23:11,000
+I mean the link from the documentation with the list of common spring boot application properties.
+
+281
+00:23:11,000 --> 00:23:17,000
+But in this particular example, let's just change lock level to warn.
+
+282
+00:23:17,000 --> 00:23:25,000
+So basically right now we are supposed to see only warn and high levels like error and fatal.
+
+283
+00:23:26,000 --> 00:23:30,000
+Pay attention that you may have many different loggers in your application.
+
+284
+00:23:30,000 --> 00:23:37,000
+You can configure level for each of them, but for the sake of the demo, I will set warn level for
+
+285
+00:23:37,000 --> 00:23:39,000
+the root logger.
+
+286
+00:23:39,000 --> 00:23:47,000
+The root logger is a top level logger in the login hierarchy and it provides a default configuration
+
+287
+00:23:47,000 --> 00:23:50,000
+for logging in an application.
+
+288
+00:23:50,000 --> 00:23:58,000
+If no other loggers explicitly defined when will run application, you are going to see only logs from
+
+289
+00:23:58,000 --> 00:24:00,000
+warn level in the console.
+
+290
+00:24:01,000 --> 00:24:07,000
+All other possible configurations like for example, registering of the file with properties with the
+
+291
+00:24:07,000 --> 00:24:14,000
+help of properties, source annotation error handling, using a value, annotation and everything.
+
+292
+00:24:14,000 --> 00:24:20,000
+What we have learned in the Spring framework course is applicable in the same way in the spring boot.
+
+293
+00:24:21,000 --> 00:24:23,000
+That's why I will not repeat myself.
+
+294
+00:24:24,000 --> 00:24:30,000
+I believe that you understand how to use application properties for configuration of your spring boot
+
+295
+00:24:30,000 --> 00:24:31,000
+application.
+
+296
+00:24:31,000 --> 00:24:39,000
+The last and interesting things that I want to show you in this lesson is how to use configuration properties
+
+297
+00:24:39,000 --> 00:24:40,000
+with beans.
+
+298
+00:24:40,000 --> 00:24:48,000
+Imagine the case that you have set body component that is outside of your control and you need to bind
+
+299
+00:24:48,000 --> 00:24:50,000
+your custom properties to it.
+
+300
+00:24:51,000 --> 00:24:52,000
+What to do in this case?
+
+301
+00:24:53,000 --> 00:24:59,000
+In this case, we can use configuration properties annotation with bin configuration.
+
+302
+00:24:59,000 --> 00:25:07,000
+The configuration properties, annotation and spring boot is used to bind external configuration properties
+
+303
+00:25:07,000 --> 00:25:08,000
+to a Java object.
+
+304
+00:25:09,000 --> 00:25:12,000
+It allows you to map properties from various sources.
+
+305
+00:25:12,000 --> 00:25:17,000
+Do you remember that we have demo entity in our project here?
+
+306
+00:25:17,000 --> 00:25:25,000
+In the entities package, let's imagine that I need to bind properties to the bin of demo entity type.
+
+307
+00:25:26,000 --> 00:25:29,000
+I created separate class that is called bin configuration.
+
+308
+00:25:30,000 --> 00:25:32,000
+In this class I want to configure one bin.
+
+309
+00:25:33,000 --> 00:25:37,000
+You can see that I use bin annotation as usual.
+
+310
+00:25:37,000 --> 00:25:41,000
+And here is configuration properties annotation bin.
+
+311
+00:25:41,000 --> 00:25:45,000
+I specify prefix what this prefix for.
+
+312
+00:25:45,000 --> 00:25:48,000
+Let me now open application properties.
+
+313
+00:25:48,000 --> 00:25:52,000
+Here you can see properties that are started from the entity verb.
+
+314
+00:25:53,000 --> 00:25:59,000
+And after the point, I specified the name of the objects property.
+
+315
+00:26:00,000 --> 00:26:01,000
+In entity.
+
+316
+00:26:01,000 --> 00:26:09,000
+I have ID and label fields and here is a SO spring is smart enough to bind the properties with a similar
+
+317
+00:26:09,000 --> 00:26:10,000
+names.
+
+318
+00:26:10,000 --> 00:26:11,000
+That's it.
+
+319
+00:26:11,000 --> 00:26:20,000
+In beans configuration I do nothing more, but when the bean will be created, spring will make sure
+
+320
+00:26:20,000 --> 00:26:26,000
+that properties values are equal to the one provided in the application properties file.
+
+321
+00:26:27,000 --> 00:26:34,000
+For the sake of the demo, I also created an endpoint in the class demo entity Properties controller.
+
+322
+00:26:34,000 --> 00:26:41,000
+I will just request this resource and we are going to see the state of the demo entity Bean, namely
+
+323
+00:26:41,000 --> 00:26:48,000
+its ID and label to make sure that these properties have value as it is specified in the properties
+
+324
+00:26:48,000 --> 00:26:49,000
+file.
+
+325
+00:26:50,000 --> 00:26:53,000
+So now we are ready to run the application.
+
+326
+00:26:55,000 --> 00:26:56,000
+The server is started.
+
+327
+00:26:57,000 --> 00:26:59,000
+Take a look at console output.
+
+328
+00:27:00,000 --> 00:27:03,000
+You can see only worn logs.
+
+329
+00:27:03,000 --> 00:27:07,000
+That is because we configured login level for root logger.
+
+330
+00:27:08,000 --> 00:27:13,000
+Now let's open the browser and check all our configurations.
+
+331
+00:27:14,000 --> 00:27:21,000
+The first time you open the web page using the Self-signed certificate browser will ask you whether
+
+332
+00:27:21,000 --> 00:27:29,000
+you really trust the certificate because browser understands that the certificate used for TLS connection
+
+333
+00:27:29,000 --> 00:27:32,000
+is not issued by trusted authority.
+
+334
+00:27:32,000 --> 00:27:40,000
+You just need to expand for additional details and click this hyper reference in order to tell the browser
+
+335
+00:27:40,000 --> 00:27:42,000
+that you are agreed to.
+
+336
+00:27:42,000 --> 00:27:43,000
+Proceed with the connection.
+
+337
+00:27:44,000 --> 00:27:48,000
+And then we can proceed to the root of our application.
+
+338
+00:27:48,000 --> 00:27:57,000
+Pay attention that our application is available at the Spring Boot demo context with the port 8888.
+
+339
+00:27:58,000 --> 00:28:02,000
+Also, you can see that I use HTTPS protocol for connection.
+
+340
+00:28:02,000 --> 00:28:05,000
+That is because we configured TLS SSL.
+
+341
+00:28:05,000 --> 00:28:13,000
+It shows that it is not protected because I use Self-signed certificate, but not the certificate from
+
+342
+00:28:13,000 --> 00:28:14,000
+the trusted authority.
+
+343
+00:28:14,000 --> 00:28:17,000
+But for development purposes that is fine.
+
+344
+00:28:17,000 --> 00:28:23,000
+In production you are going to substitute the certificate itself, but configurations will remain the
+
+345
+00:28:23,000 --> 00:28:24,000
+same.
+
+346
+00:28:24,000 --> 00:28:31,000
+And now let me reach our test endpoint in order to check the state of the demo entity object.
+
+347
+00:28:32,000 --> 00:28:41,000
+And here we can see that ID of our entity is 100 and label is test label as it was configured in application
+
+348
+00:28:41,000 --> 00:28:42,000
+properties.
+
+349
+00:28:43,000 --> 00:28:46,000
+So that's all what I wanted to share with you today.
+
+350
+00:28:46,000 --> 00:28:50,000
+Let's recap what we have learned in the lesson.
+
+351
+00:28:50,000 --> 00:28:54,000
+We learned more about application properties.
+
+352
+00:28:54,000 --> 00:29:01,000
+Now you know the precedence order of properties and how to override properties in case this will be
+
+353
+00:29:01,000 --> 00:29:01,000
+needed.
+
+354
+00:29:02,000 --> 00:29:08,000
+We learned list of the most common spring boot properties and default values for some of them.
+
+355
+00:29:09,000 --> 00:29:16,000
+Now you know how to change port number, how to configure SSL, TLS and spring boot application.
+
+356
+00:29:17,000 --> 00:29:24,000
+On real example, you saw how you can generate Self-signed certificate with changed context pass of
+
+357
+00:29:24,000 --> 00:29:25,000
+the application.
+
+358
+00:29:25,000 --> 00:29:32,000
+Also, we configured login level and at the end of the lesson we learned how to work with configuration
+
+359
+00:29:32,000 --> 00:29:34,000
+properties annotation.
+
+360
+00:29:34,000 --> 00:29:35,000
+That's it.
+
+361
+00:29:35,000 --> 00:29:37,000
+Thanks a lot for your attention.
+
+362
+00:29:37,000 --> 00:29:40,000
+Have a great day and see you in the next lesson.
+

92 - Spring Boot/005 Source-code-of-examples-commit-with-changes-.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/java-learnit-spring-boot/commit/94ba22d51d1e1413056b7fc6bd1f4722ef39c0f5

92 - Spring Boot/005 Spring Boot Actuator - Monitoring Tools_en.srt

@@ -0,0 +1,1184 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello team.
+
+2
+00:00:06,000 --> 00:00:10,000
+In this video lesson we are going to learn spring boot actuator.
+
+3
+00:00:10,000 --> 00:00:15,000
+We are going to start this lesson from understanding of what spring boot actuator is.
+
+4
+00:00:16,000 --> 00:00:23,000
+I will explain you the key features of actuator and what benefits we expect to get by using it in our
+
+5
+00:00:23,000 --> 00:00:25,000
+spring boot application.
+
+6
+00:00:25,000 --> 00:00:32,000
+Then we will hold an overview of the existing predefined and points in spring boot actuator.
+
+7
+00:00:32,000 --> 00:00:37,000
+After learning the theory, we are going to have a practical examples and demo.
+
+8
+00:00:37,000 --> 00:00:44,000
+I will start screen sharing and will show you everything you need to know in order to start work with
+
+9
+00:00:44,000 --> 00:00:46,000
+spring boot actuator from scratch.
+
+10
+00:00:47,000 --> 00:00:52,000
+We will add required dependency will expose actuator and points.
+
+11
+00:00:52,000 --> 00:00:58,000
+And in case you would like to exclude some end points, I will also show you how you can do this.
+
+12
+00:00:58,000 --> 00:01:06,000
+We will learn how to change base parts of the actuator and see how we can actually read different application
+
+13
+00:01:06,000 --> 00:01:07,000
+metrics.
+
+14
+00:01:07,000 --> 00:01:13,000
+And at the end of the lesson as a summary, we are going to learn best practices of working with Spring
+
+15
+00:01:13,000 --> 00:01:14,000
+boot actuator.
+
+16
+00:01:15,000 --> 00:01:17,000
+Let's start our lesson.
+
+17
+00:01:17,000 --> 00:01:20,000
+Let's understand first what is spring boot?
+
+18
+00:01:20,000 --> 00:01:29,000
+Actuator actuator plays a crucial role in enhancing our application with production ready capabilities.
+
+19
+00:01:29,000 --> 00:01:38,000
+By integrating actuator, we gain the ability to monitor our application, collect metrics, gain insights
+
+20
+00:01:38,000 --> 00:01:42,000
+into traffic, and assess the status of our database.
+
+21
+00:01:42,000 --> 00:01:50,000
+The primary advantage of utilizing this feature is that we can leverage enterprise grade tools without
+
+22
+00:01:50,000 --> 00:01:53,000
+the need to develop these functionalities from scratch.
+
+23
+00:01:53,000 --> 00:02:01,000
+Actuator serves to expose essential operational details about our running application, including health
+
+24
+00:02:01,000 --> 00:02:08,000
+status metrics, information on data dumps, environment configurations and more.
+
+25
+00:02:08,000 --> 00:02:15,000
+It offers various methods for interaction such as HTTP endpoints and jmax beans.
+
+26
+00:02:16,000 --> 00:02:18,000
+What are Jmax beans, by the way?
+
+27
+00:02:19,000 --> 00:02:22,000
+Jmax stands for Java Management Extensions.
+
+28
+00:02:22,000 --> 00:02:27,000
+Beans, also known as beans Managed beans.
+
+29
+00:02:28,000 --> 00:02:36,000
+They are Java objects that are exposed from management and monitoring purposes through the technology.
+
+30
+00:02:36,000 --> 00:02:44,000
+Jmax is a standard Java technology for managing and monitoring applications, devices and services in
+
+31
+00:02:44,000 --> 00:02:46,000
+a distributed environment.
+
+32
+00:02:46,000 --> 00:02:53,000
+Once actuator is included in our classpath, a set of preconfigured endpoints become available to us.
+
+33
+00:02:53,000 --> 00:03:02,000
+As is typical with spring modules, actuator can be easily customized and extended to meet our specific
+
+34
+00:03:02,000 --> 00:03:05,000
+requirements in many different ways.
+
+35
+00:03:05,000 --> 00:03:12,000
+So to sum it up, Spring boot Actuator is a sub project of spring boot that provides production ready
+
+36
+00:03:12,000 --> 00:03:18,000
+features to monitor, manage and interact with spring boot applications.
+
+37
+00:03:18,000 --> 00:03:25,000
+It offers a wide range of built in endpoints that expose various operational information and statistics
+
+38
+00:03:25,000 --> 00:03:33,000
+about the application, allowing developers and system administrators to gain insights into the applications,
+
+39
+00:03:33,000 --> 00:03:37,000
+health metrics, configuration, logging and more.
+
+40
+00:03:38,000 --> 00:03:43,000
+Let's now review the key features and benefits of spring boot actuator in order.
+
+41
+00:03:43,000 --> 00:03:47,000
+You can understand why you may need to use it.
+
+42
+00:03:47,000 --> 00:03:55,000
+Some key features and benefits of spring boot actuator include health monitoring Actuator includes a
+
+43
+00:03:55,000 --> 00:04:01,000
+health endpoint that provides a simple way to check the health status of the application.
+
+44
+00:04:01,000 --> 00:04:07,000
+It can indicate whether the application is running properly or if there are any issues.
+
+45
+00:04:08,000 --> 00:04:15,000
+Metrics gathering actuator collects and exposes application level metrics through the metrics and point.
+
+46
+00:04:15,000 --> 00:04:23,000
+It provides valuable insights into important metrics such as request response rates, CPU and memory
+
+47
+00:04:23,000 --> 00:04:28,000
+usage, database connections and other custom defined metrics.
+
+48
+00:04:29,000 --> 00:04:37,000
+Configuration management Actuator offers an environment endpoint that displays the application's current
+
+49
+00:04:37,000 --> 00:04:40,000
+environment, properties and configurations.
+
+50
+00:04:40,000 --> 00:04:47,000
+It enables easy inspection and troubleshooting of the application's configuration at runtime.
+
+51
+00:04:47,000 --> 00:04:55,000
+The login management actuator provides a logger endpoint that allows dynamic modification of the application's
+
+52
+00:04:55,000 --> 00:04:57,000
+logging levels.
+
+53
+00:04:57,000 --> 00:05:03,000
+It enables runtime control over logging levels without requiring application restarts.
+
+54
+00:05:04,000 --> 00:05:12,000
+Request tracing the trace point captures and displays, request tracing information, providing visibility
+
+55
+00:05:12,000 --> 00:05:16,000
+into the flow of requests through the application.
+
+56
+00:05:16,000 --> 00:05:21,000
+It can be useful for debugging and understanding request related issues.
+
+57
+00:05:22,000 --> 00:05:31,000
+Auditing actuator includes an audit events endpoint that shows auditing related events such as user
+
+58
+00:05:31,000 --> 00:05:36,000
+authentication and authorization events logged by the application.
+
+59
+00:05:36,000 --> 00:05:41,000
+It assists in monitoring and tracking security related activities.
+
+60
+00:05:42,000 --> 00:05:50,000
+Extensibility Actuator allows the creation of custom endpoints to expose application specific information
+
+61
+00:05:50,000 --> 00:05:53,000
+or perform custom management tasks.
+
+62
+00:05:53,000 --> 00:06:00,000
+It provides flexibility to integrate additional functionality based on specific application requirements.
+
+63
+00:06:00,000 --> 00:06:07,000
+Spring boot actuator integrates seamlessly with spring boot applications and can be easily configured
+
+64
+00:06:07,000 --> 00:06:10,000
+through properties or annotations.
+
+65
+00:06:10,000 --> 00:06:17,000
+It enhances the operational capabilities of spring boot applications, making them easier to monitor,
+
+66
+00:06:17,000 --> 00:06:21,000
+manage and maintain in production environments.
+
+67
+00:06:21,000 --> 00:06:28,000
+So you can see that spring boot actuator simplifies the task of managing and monitoring spring boot
+
+68
+00:06:28,000 --> 00:06:36,000
+applications by providing a comprehensive set of out-of-the-box features and endpoints, allowing developers
+
+69
+00:06:36,000 --> 00:06:43,000
+and administrators to gain valuable insights into application health, performance and configuration
+
+70
+00:06:43,000 --> 00:06:44,000
+details.
+
+71
+00:06:44,000 --> 00:06:51,000
+Before we jump to practical examples, let me make an overview of some of the predefined endpoints that
+
+72
+00:06:51,000 --> 00:06:54,000
+you can use to monitor your application.
+
+73
+00:06:54,000 --> 00:07:00,000
+We are going to learn Siri now and then we'll jump to practical examples.
+
+74
+00:07:00,000 --> 00:07:07,000
+As you can see on the slide, all actuators and points are located on the actuator pass.
+
+75
+00:07:08,000 --> 00:07:13,000
+You can use this information to configure security rules for these end points.
+
+76
+00:07:13,000 --> 00:07:16,000
+In order to restrict public access to them.
+
+77
+00:07:16,000 --> 00:07:22,000
+Also, I'm going to show you today how to change this base pass, if you wish.
+
+78
+00:07:22,000 --> 00:07:30,000
+Helsing Point provides information about the health status of the application indicating if it's running
+
+79
+00:07:30,000 --> 00:07:33,000
+properly or if there are any issues.
+
+80
+00:07:34,000 --> 00:07:38,000
+Info endpoint displays custom application information.
+
+81
+00:07:38,000 --> 00:07:44,000
+You can configure and customize the details exposed by this endpoint.
+
+82
+00:07:44,000 --> 00:07:53,000
+Metrics and point offers access to a wide range of application metrics such as request response rates,
+
+83
+00:07:53,000 --> 00:07:58,000
+CPU and memory usage, database connections and more.
+
+84
+00:07:58,000 --> 00:08:06,000
+Environment endpoint shows the application's current environment properties and configurations providing
+
+85
+00:08:06,000 --> 00:08:09,000
+insights into the runtime configuration of the application.
+
+86
+00:08:10,000 --> 00:08:17,000
+Login endpoint allows dynamic modification of the login levels of the application at runtime.
+
+87
+00:08:17,000 --> 00:08:23,000
+It enables controlling the log output without requiring application restarts.
+
+88
+00:08:23,000 --> 00:08:31,000
+Trace and point, captures and displays, request tracing information, providing visibility into the
+
+89
+00:08:31,000 --> 00:08:35,000
+flow of requests through the application.
+
+90
+00:08:35,000 --> 00:08:38,000
+It aids in debugging and troubleshooting.
+
+91
+00:08:39,000 --> 00:08:47,000
+Audit events, endpoint presents auditing related events such as user authentication and authorization
+
+92
+00:08:47,000 --> 00:08:49,000
+events logged by the application.
+
+93
+00:08:50,000 --> 00:08:57,000
+Beans and point provides information about spring beans registered in the application context, including
+
+94
+00:08:57,000 --> 00:09:00,000
+their dependencies and configurations.
+
+95
+00:09:01,000 --> 00:09:02,000
+Conditions.
+
+96
+00:09:02,000 --> 00:09:09,000
+End Point displays the conditions that influence the autoconfiguration of the applications bins.
+
+97
+00:09:10,000 --> 00:09:17,000
+Mappings endpoint shows a detailed mapping of all the request mappings defined in the application,
+
+98
+00:09:17,000 --> 00:09:21,000
+including the controller methods and their respective URLs.
+
+99
+00:09:22,000 --> 00:09:28,000
+Shut down endpoint enables graceful shutdown of the application by default.
+
+100
+00:09:28,000 --> 00:09:33,000
+It is not enabled and requires explicit configuration for security reasons.
+
+101
+00:09:34,000 --> 00:09:40,000
+Some other predefined endpoints and their descriptions you can see on the slide.
+
+102
+00:09:40,000 --> 00:09:45,000
+Feel free to press pause for a minute to explore the slide slowly.
+
+103
+00:09:45,000 --> 00:09:50,000
+I believe there is no need for me to read all the slides out loud.
+
+104
+00:09:50,000 --> 00:09:58,000
+Please note that availability and visibility of these endpoints may vary based on the actuator configuration
+
+105
+00:09:58,000 --> 00:10:02,000
+and any security settings in place today.
+
+106
+00:10:02,000 --> 00:10:10,000
+During the demo we are going to configure everything what we need to get access to mentioned endpoints.
+
+107
+00:10:10,000 --> 00:10:16,000
+I believe that we learned enough theory and now we are ready to jump to practical examples in order
+
+108
+00:10:16,000 --> 00:10:19,000
+to see spring boot actuator in action.
+
+109
+00:10:19,000 --> 00:10:25,000
+So let me show you how to configure actuator in your spring boot project.
+
+110
+00:10:25,000 --> 00:10:32,000
+I open Pom.xml file and I add spring boot starter actuator dependency.
+
+111
+00:10:32,000 --> 00:10:36,000
+That's all what you have to add from the dependency side.
+
+112
+00:10:36,000 --> 00:10:40,000
+Now let me open application properties.
+
+113
+00:10:40,000 --> 00:10:41,000
+Don't worry.
+
+114
+00:10:41,000 --> 00:10:46,000
+As usual, I will share with you a link to the source code in attachments to the video.
+
+115
+00:10:46,000 --> 00:10:52,000
+So by default, not all endpoints of the actuator are exposed.
+
+116
+00:10:52,000 --> 00:11:00,000
+In case you want to expose all endpoints, you need to specify this property management endpoints Web
+
+117
+00:11:00,000 --> 00:11:04,000
+exposure include and asterisk as a value.
+
+118
+00:11:05,000 --> 00:11:08,000
+Asterisk means all endpoints.
+
+119
+00:11:08,000 --> 00:11:15,000
+If you don't want to expose all endpoints, then you can list end points separated by commas like you
+
+120
+00:11:15,000 --> 00:11:18,000
+can see in this commanded example.
+
+121
+00:11:18,000 --> 00:11:22,000
+But I will keep all endpoints exposed for the sake of the demo.
+
+122
+00:11:23,000 --> 00:11:30,000
+In case you want to exclude some end points, you need to use exposure, exclude property.
+
+123
+00:11:30,000 --> 00:11:37,000
+And in the similar way, in case you need to exclude multiple end points, you can pass comma separated
+
+124
+00:11:37,000 --> 00:11:41,000
+list of values like you can see in this commanded example.
+
+125
+00:11:42,000 --> 00:11:45,000
+The next property here is health.
+
+126
+00:11:45,000 --> 00:11:46,000
+Show details.
+
+127
+00:11:47,000 --> 00:11:49,000
+Let me tell you more about it.
+
+128
+00:11:50,000 --> 00:11:56,000
+This property in spring boot actuator controls the level of detail displayed in the health endpoint
+
+129
+00:11:56,000 --> 00:11:57,000
+response.
+
+130
+00:11:57,000 --> 00:12:06,000
+It determines whether or not to include detailed information about the health status of individual components
+
+131
+00:12:06,000 --> 00:12:07,000
+or subsystems.
+
+132
+00:12:07,000 --> 00:12:12,000
+The possible values for this property are always.
+
+133
+00:12:12,000 --> 00:12:20,000
+This value indicates the detailed health information should always be shown in the health endpoint response.
+
+134
+00:12:20,000 --> 00:12:27,000
+It includes information about the health status of each individual component or subsystem, along with
+
+135
+00:12:27,000 --> 00:12:33,000
+additional details such as error messages or diagnostic information.
+
+136
+00:12:33,000 --> 00:12:35,000
+When authorized.
+
+137
+00:12:35,000 --> 00:12:43,000
+This value specifies the detailed health information should only be shown when the requester is authorized
+
+138
+00:12:43,000 --> 00:12:44,000
+to access it.
+
+139
+00:12:44,000 --> 00:12:52,000
+This allows you to restrict access to detailed health information based on authentication and authorization
+
+140
+00:12:52,000 --> 00:12:53,000
+rules.
+
+141
+00:12:53,000 --> 00:12:54,000
+Never.
+
+142
+00:12:54,000 --> 00:13:01,000
+This value means that detailed health information should never be shown in the health endpoint response.
+
+143
+00:13:01,000 --> 00:13:06,000
+Only the high level health status, such as up or down, will be returned.
+
+144
+00:13:07,000 --> 00:13:14,000
+By setting management and point health show details to always you ensure that health endpoint response
+
+145
+00:13:14,000 --> 00:13:20,000
+includes detailed information regardless of the requesters authorization.
+
+146
+00:13:20,000 --> 00:13:26,000
+This can be helpful during the development or troubleshooting scenarios when you need more visibility
+
+147
+00:13:26,000 --> 00:13:29,000
+into the health status of individual components.
+
+148
+00:13:30,000 --> 00:13:35,000
+The next commanded property here is management endpoints, web based POS.
+
+149
+00:13:36,000 --> 00:13:43,000
+It determines the common prefix that is added to the POS of each actuator endpoint.
+
+150
+00:13:43,000 --> 00:13:51,000
+You already learned that base POS for all API in actuator is basically actuator, but you can change
+
+151
+00:13:51,000 --> 00:13:52,000
+it if you wish.
+
+152
+00:13:53,000 --> 00:14:01,000
+So in case I would uncomment this property, the base POS would be management by customizing the base
+
+153
+00:14:01,000 --> 00:14:01,000
+paths.
+
+154
+00:14:01,000 --> 00:14:10,000
+You can align the actuator endpoints URL structure with the rest of your application API or match your
+
+155
+00:14:10,000 --> 00:14:12,000
+desired POS conventions.
+
+156
+00:14:12,000 --> 00:14:16,000
+Another interesting thing is creation of groups.
+
+157
+00:14:16,000 --> 00:14:23,000
+We can organize health indicators into groups and apply the same configuration to all the group members.
+
+158
+00:14:23,000 --> 00:14:30,000
+For example, we can create a health group named Custom by adding this to our application properties
+
+159
+00:14:30,000 --> 00:14:32,000
+like you can see here on the screen.
+
+160
+00:14:33,000 --> 00:14:39,000
+In this case, the custom group contains the disk space and pink health indicators.
+
+161
+00:14:40,000 --> 00:14:47,000
+We can configure the group to show more details in the similar way we already did with the health endpoint.
+
+162
+00:14:47,000 --> 00:14:51,000
+And few more words about show components property.
+
+163
+00:14:51,000 --> 00:14:58,000
+When you create custom health indicators in your application, they can be included in the details group
+
+164
+00:14:58,000 --> 00:15:00,000
+by default.
+
+165
+00:15:00,000 --> 00:15:08,000
+However, by setting management end point health group custom show components to always you are instructing
+
+166
+00:15:08,000 --> 00:15:16,000
+actuator to include the components of the custom group in the response of the health end point regardless
+
+167
+00:15:16,000 --> 00:15:19,000
+of their individual health status.
+
+168
+00:15:19,000 --> 00:15:26,000
+This property is useful when you want to expose specific components or aspects of your applications.
+
+169
+00:15:26,000 --> 00:15:33,000
+Health status in the actuator health endpoint response even if they're in custom group.
+
+170
+00:15:33,000 --> 00:15:42,000
+By setting it to always you ensure that the components of the custom group will always be visible regardless
+
+171
+00:15:42,000 --> 00:15:44,000
+of their individual health status.
+
+172
+00:15:45,000 --> 00:15:48,000
+Basically that's all configuration that we had to do.
+
+173
+00:15:48,000 --> 00:15:51,000
+So now you can run your server.
+
+174
+00:15:51,000 --> 00:15:54,000
+My server is up and running already.
+
+175
+00:15:54,000 --> 00:15:58,000
+Let me switch to the Chrome browser to make some demo.
+
+176
+00:15:58,000 --> 00:16:05,000
+Spring Boot includes a discovery endpoint that provides links to all available actuator endpoints,
+
+177
+00:16:05,000 --> 00:16:10,000
+simplifying the process of discovering the endpoints and their associated URLs.
+
+178
+00:16:10,000 --> 00:16:18,000
+By default, this discovery endpoint can be accessed through the actuator endpoint and you already know
+
+179
+00:16:18,000 --> 00:16:20,000
+how to change this basic path.
+
+180
+00:16:20,000 --> 00:16:23,000
+We have just reviewed configuration for that.
+
+181
+00:16:24,000 --> 00:16:31,000
+The JSON shows a collection of available actuator endpoints along with their corresponding URLs.
+
+182
+00:16:32,000 --> 00:16:35,000
+Let's now check some specific endpoints.
+
+183
+00:16:35,000 --> 00:16:38,000
+For example, let's check how endpoint.
+
+184
+00:16:38,000 --> 00:16:45,000
+It provides information about the health status of various components or subsystems in the application.
+
+185
+00:16:45,000 --> 00:16:51,000
+And just to remind you that in case you want to have more readable view of this information, there
+
+186
+00:16:51,000 --> 00:16:55,000
+are multiple JSON beautifier tools that you can find online.
+
+187
+00:16:56,000 --> 00:17:03,000
+You can copy JSON response and paste it in another tool in order to see readable format and explore
+
+188
+00:17:03,000 --> 00:17:04,000
+the content.
+
+189
+00:17:04,000 --> 00:17:12,000
+Here is what the response shows Status, the overall health status of the application which is indicated
+
+190
+00:17:12,000 --> 00:17:13,000
+as app.
+
+191
+00:17:13,000 --> 00:17:19,000
+In this case, it signifies that the application is functioning properly.
+
+192
+00:17:19,000 --> 00:17:20,000
+Components.
+
+193
+00:17:20,000 --> 00:17:27,000
+It contains detailed information about individual components or subsystems and their health status.
+
+194
+00:17:28,000 --> 00:17:36,000
+DB represents a component named DB and its health status, which is up in this example.
+
+195
+00:17:36,000 --> 00:17:44,000
+It also includes additional details about the component, such as the database being used and the validation
+
+196
+00:17:44,000 --> 00:17:44,000
+query.
+
+197
+00:17:45,000 --> 00:17:54,000
+Disk space represents a component named disk space and its health status, which is up in this case.
+
+198
+00:17:54,000 --> 00:18:02,000
+It provides details about the disk space, including the total space free space threshold file path
+
+199
+00:18:02,000 --> 00:18:04,000
+and whether it exists.
+
+200
+00:18:05,000 --> 00:18:13,000
+Pink represents a component named Pink and its health status, which is up in this example groups.
+
+201
+00:18:13,000 --> 00:18:17,000
+Do you remember we configured custom group in application properties.
+
+202
+00:18:17,000 --> 00:18:24,000
+So here is a confirmation of the fact that we have custom group and we can send requests to the endpoint
+
+203
+00:18:24,000 --> 00:18:28,000
+of the group to see the state of only preconfigured components.
+
+204
+00:18:29,000 --> 00:18:36,000
+Overall, the actuator health endpoint provides a snapshot of the health status of various components
+
+205
+00:18:36,000 --> 00:18:43,000
+in the application, allowing you to monitor and assess the overall health and availability of your
+
+206
+00:18:43,000 --> 00:18:43,000
+system.
+
+207
+00:18:44,000 --> 00:18:50,000
+Taking into account we have the group configured, we can send requests to the health custom endpoint
+
+208
+00:18:50,000 --> 00:18:54,000
+and explore the details in the application properties.
+
+209
+00:18:54,000 --> 00:18:59,000
+We configure it only two components for this group disk space and ping.
+
+210
+00:18:59,000 --> 00:19:02,000
+And here we can see only two components.
+
+211
+00:19:03,000 --> 00:19:05,000
+Now let's check metrics endpoint.
+
+212
+00:19:06,000 --> 00:19:11,000
+As you can see, this endpoint replies us with a list of metrics that we can check.
+
+213
+00:19:12,000 --> 00:19:17,000
+You can select the metrics that you are interested in and put it into the URL.
+
+214
+00:19:18,000 --> 00:19:22,000
+For example, let's check amount of current sessions.
+
+215
+00:19:22,000 --> 00:19:31,000
+We take the metric name, which is Tomcat sessions, active current and put it into the URL and we can
+
+216
+00:19:31,000 --> 00:19:34,000
+see the response with the details.
+
+217
+00:19:34,000 --> 00:19:38,000
+We can see that there is one active session currently.
+
+218
+00:19:38,000 --> 00:19:45,000
+By monitoring this metric, you can gain insights into the workload and utilization of session related
+
+219
+00:19:45,000 --> 00:19:48,000
+resources in your Tomcat server.
+
+220
+00:19:48,000 --> 00:19:56,000
+It can help you understand the current session activity, track the usage of several resources and identify
+
+221
+00:19:56,000 --> 00:20:04,000
+any potential issues related to session management, such as an excessive session creation or improper
+
+222
+00:20:04,000 --> 00:20:05,000
+session handling.
+
+223
+00:20:06,000 --> 00:20:12,000
+Or let's now check another metric metric that is called gvm info.
+
+224
+00:20:12,000 --> 00:20:16,000
+The metric provides information about the Gvm version.
+
+225
+00:20:16,000 --> 00:20:20,000
+The available tags provide additional details about the vendor.
+
+226
+00:20:21,000 --> 00:20:29,000
+Eclipse Adoption Runtime, OpenGL runtime, environment and version associated with the gvm.
+
+227
+00:20:29,000 --> 00:20:36,000
+This metric can be useful for monitoring and understanding the Gvm environment in which your application
+
+228
+00:20:36,000 --> 00:20:37,000
+is running.
+
+229
+00:20:37,000 --> 00:20:41,000
+Using the similar approach, you can check other metrics.
+
+230
+00:20:41,000 --> 00:20:44,000
+I believe you understood how it works.
+
+231
+00:20:44,000 --> 00:20:48,000
+Just spend some time checking different metrics.
+
+232
+00:20:48,000 --> 00:20:50,000
+I bet that you can find it useful.
+
+233
+00:20:51,000 --> 00:20:55,000
+Those are the key things that I wanted to show you during the demo.
+
+234
+00:20:55,000 --> 00:21:01,000
+Also wanted to make a note that you can create custom endpoints in spring boot actuator.
+
+235
+00:21:02,000 --> 00:21:10,000
+Actuator allows you to extend its functionality by adding your own custom endpoints to expose additional
+
+236
+00:21:10,000 --> 00:21:15,000
+management or monitoring information specific to your application.
+
+237
+00:21:15,000 --> 00:21:18,000
+We reviewed what Spring boot actuator is.
+
+238
+00:21:19,000 --> 00:21:21,000
+Now you have a better understanding.
+
+239
+00:21:22,000 --> 00:21:29,000
+And before I wrap up this lesson, let's discuss best practices for leveraging actuator effectively.
+
+240
+00:21:30,000 --> 00:21:36,000
+When discussing best practices for leveraging actuators effectively, there are several key considerations
+
+241
+00:21:36,000 --> 00:21:38,000
+to keep in mind.
+
+242
+00:21:38,000 --> 00:21:41,000
+Secure actuator endpoints.
+
+243
+00:21:42,000 --> 00:21:46,000
+Actuator endpoints provide sensitive information about your application.
+
+244
+00:21:46,000 --> 00:21:51,000
+It's crucial to secure these endpoints to prevent unauthorized access.
+
+245
+00:21:51,000 --> 00:21:58,000
+You can configure authentication and authorization mechanisms in our spring boot application.
+
+246
+00:21:58,000 --> 00:22:05,000
+We have spring security enabled already, and I believe you watched spring security lessons and you
+
+247
+00:22:05,000 --> 00:22:10,000
+already can imagine how to secure these endpoints knowing the basic pass.
+
+248
+00:22:11,000 --> 00:22:17,000
+You can basically just secure actuator pass and all child pass and that's it.
+
+249
+00:22:18,000 --> 00:22:20,000
+Limit exposed endpoints.
+
+250
+00:22:21,000 --> 00:22:27,000
+It's recommended to limit the exposed end points to only those that are necessary for monitoring and
+
+251
+00:22:27,000 --> 00:22:29,000
+management purposes.
+
+252
+00:22:29,000 --> 00:22:36,000
+This helps reduce the attack surface and minimizes the risk of exposing sensitive information.
+
+253
+00:22:36,000 --> 00:22:38,000
+How to limit Exposed endpoints.
+
+254
+00:22:38,000 --> 00:22:41,000
+We also learned on examples.
+
+255
+00:22:42,000 --> 00:22:50,000
+Customize and point pass activate endpoints have default paths such as actuator has or actuator info.
+
+256
+00:22:50,000 --> 00:22:59,000
+It's advisable to customize these paths to make them less predictable and less susceptible to potential
+
+257
+00:22:59,000 --> 00:23:00,000
+security vulnerabilities.
+
+258
+00:23:00,000 --> 00:23:04,000
+And we already learned how to adjust the base path.
+
+259
+00:23:05,000 --> 00:23:12,000
+Monitor Essential Metrics Actuator provides various metrics to monitor the health and performance of
+
+260
+00:23:12,000 --> 00:23:14,000
+your application.
+
+261
+00:23:14,000 --> 00:23:22,000
+It identifies the most critical metrics for your specific use case and ensure they're actively monitored.
+
+262
+00:23:22,000 --> 00:23:32,000
+This can include metrics related to request rates, response times, error rates, CPU and memory usage,
+
+263
+00:23:32,000 --> 00:23:39,000
+database connections, and any other relevant metrics specific to your application's behavior.
+
+264
+00:23:40,000 --> 00:23:47,000
+Leverage custom end points Actuator allows you to create custom endpoints to expose application specific
+
+265
+00:23:47,000 --> 00:23:49,000
+monitoring and management information.
+
+266
+00:23:50,000 --> 00:23:57,000
+Consider creating custom endpoints tailored to your applications requirements, providing insights into
+
+267
+00:23:57,000 --> 00:24:03,000
+specific aspects of your system or exposing custom management operations.
+
+268
+00:24:04,000 --> 00:24:11,000
+Utilize health indicators, actuators, health and point provides information about the health of your
+
+269
+00:24:11,000 --> 00:24:12,000
+application.
+
+270
+00:24:12,000 --> 00:24:19,000
+Implement Custom Health indicators to incorporate additional checks specific to your applications,
+
+271
+00:24:19,000 --> 00:24:22,000
+dependencies and critical components.
+
+272
+00:24:22,000 --> 00:24:29,000
+This allows you to have a comprehensive view of the overall health status and proactively address any
+
+273
+00:24:29,000 --> 00:24:31,000
+potential issues.
+
+274
+00:24:32,000 --> 00:24:35,000
+Integrate with monitoring and alerting systems.
+
+275
+00:24:36,000 --> 00:24:43,000
+Actuator complements, monitoring and alerting systems by exposing valuable information about your application.
+
+276
+00:24:44,000 --> 00:24:52,000
+Integrate actuator with your preferred monitoring and alerting tools such as Prometheus, Grafana or
+
+277
+00:24:52,000 --> 00:24:53,000
+Elastic Logstash.
+
+278
+00:24:53,000 --> 00:25:00,000
+Kibana Stack To gain a centralized view of your applications, health metrics and logs.
+
+279
+00:25:01,000 --> 00:25:07,000
+Document, exit and points document the available exit and points.
+
+280
+00:25:07,000 --> 00:25:10,000
+The purpose and the information they provide.
+
+281
+00:25:10,000 --> 00:25:19,000
+This documentation helps both developers and operations teams to understand the capabilities and usage
+
+282
+00:25:19,000 --> 00:25:27,000
+of actuate and points, facilitating effective monitoring, troubleshooting and management of the application.
+
+283
+00:25:28,000 --> 00:25:35,000
+By following these best practices, you can leverage actuator effectively to gain insights into your
+
+284
+00:25:35,000 --> 00:25:42,000
+applications, health metrics and management aspects, enabling efficient monitoring, troubleshooting
+
+285
+00:25:42,000 --> 00:25:45,000
+and optimization of your spring boot applications.
+
+286
+00:25:46,000 --> 00:25:49,000
+That's all what I wanted to review with you today.
+
+287
+00:25:49,000 --> 00:25:52,000
+Let's recap what we have learned in the lesson.
+
+288
+00:25:53,000 --> 00:25:56,000
+We learned what spring boot actuator is.
+
+289
+00:25:57,000 --> 00:26:01,000
+Now you know the key features and benefits of spring boot actuator.
+
+290
+00:26:02,000 --> 00:26:08,000
+I showed you existing predefined endpoints that are available in spring boot actuator.
+
+291
+00:26:08,000 --> 00:26:15,000
+On real examples, you saw how to configure spring boot actuator in your application and how to read
+
+292
+00:26:15,000 --> 00:26:17,000
+applications metrics.
+
+293
+00:26:18,000 --> 00:26:23,000
+And at the end of the lesson, we learned best practices of working with Spring Boot Actuator.
+
+294
+00:26:24,000 --> 00:26:25,000
+That's it.
+
+295
+00:26:25,000 --> 00:26:27,000
+Thanks a lot for your attention.
+
+296
+00:26:27,000 --> 00:26:30,000
+Have a great day and see you in the next lesson.
+