Koushik Kothagal - Java Brains: Spring Framework
Koushik Kothagal - Java Brains: Spring Framework
English | MP4 | 1280x720 | AVC 221 Kbps 30.000 fps | AAC 119 Kbps 44.1 khz | 2 channels | 3.16 GB
Genre: Video Training
English | MP4 | 1280x720 | AVC 221 Kbps 30.000 fps | AAC 119 Kbps 44.1 khz | 2 channels | 3.16 GB
Genre: Video Training
A series of video tutorials on framework to Hibernate.
01 - Understanding Dependency Injection
In this tutorial, we'll understand the concept of Dependency Injection.
02 - Setting Up
In this tutorial, we'll learn how to set up our Eclipse development environment to write Spring code.
03 - Understanding Spring Bean Factory
In this tutorial, we'll discuss the role of Spring as a bean container. We'll also have a quick discussion on the Factory pattern, and I'll introduce you to the Spring Bean Factory object.
04 - Writing Code Using the Bean Factory
In this tutorial, we'll write code to implement the BeanFactory concept that we learnt in our previous tutorial. We'll write a Spring XML to configure a Spring bean. Then we'll use the BeanFactory to instantiate our bean in the Spring container.
05 - ApplicationContext and Property Initialization
We'll first replace the BeanFactory with the more powerful ApplicationContext. We'll then make Spring initialize a property of an object by specifying the value in the configuration XML.
06 - Using Constructor Injection
We'll now use constructors to set the member variable values for our Spring beans. We'll also look at some techniques to resolve conflicts in the case of overloaded constructors.
07 - Injecting Objects
In this tutorial, we'll use dependency injection to inject an object dependency to a Spring bean.
08 - Inner Beans, Aliases and idref
In this tutorial, we'll look at some concepts related to bean naming and usage like alias and idref. We'll also understand how to write inner beans.
09 - Initializing Collections
In this tutorial, we'll initialize a member variable that's a collection and each of the elements are references to other beans.
10 - Bean Autowiring
We'll now look at a configuration feature provided by Spring to wire dependencies automatically: Bean Autowiring. We'll learn about different types of autowiring, and we'll write some code to implement bean autowiring by name.
11 - Understanding Bean Scopes
This tutorial covers the concepts of Bean Scopes in Spring. We'll understand when beans are created and how to configure different scopes for the beans.
12 - Using ApplicationContextAware
We'll provide our beans with access to the ApplicationContext object by implementing the ApplicationContextAware interface. We'll also use BeanNameAware interface to get the name of the bean configured in the Spring XML.
13 - Bean Definition Inheritance
In this tutorial, we'll learn what bean definition inheritance is, and how to configure a parent bean definition and have children beans inherit the bean definitions.
14 - Lifecycle Callbacks
We'll use two different ways to run methods on initialization and destruction of beans.
15 - Writing a BeanPostProcessor
In this tutorial, we'll understand what a BeanPostProcessor is. We'll also write a BeanPostProcessor that prints a message upon initializing each and every bean in the Spring XML.
16 - Writing a BeanFactoryPostProcessor
In this tutorial, we'll learn about and write our own BeanFactoryPostProcessor. We'll also try out a handy BeanFactoryPostProcessor that comes with Spring: the PropertyPlaceholderConfigurer.
17 - Coding To Interfaces
When using Spring for dependency injection, it's a good practice to use interfaces for referencing dependencies. In this tutorial, we'll learn how to ""code to interfaces"".
18 - Introduction to Annotations and the Required Annota…
Here we'll have our first look at Spring annotations. We'll understand and implement the Required annotation, and we'll also learn how it's actually a BeanPostProcessor that's working behind the scenes.
19 - The Autowired Annotation
In this tutorial, we'll use the Autowired annotation to wire up dependencies. We'll learn how to add dependencies by type and name. We'll also use Qualifiers to narrow down dependency contenders.
20 - Some JSR-250 Annotations
We'll learn and implement three JSR-250 annotations that Spring supports:Resource, PostConstruct and PreDestroy.
21 - Component and Stereotype Annotations
We'll now use the Component annotation to define Spring beans. We'll also look at some Stereotype annotations.
22 - Using MessageSource To Get Text From Property Files
In this tutorial, we'll use the MessageSource interface to retrieve messages out of property files.
23 - Event Handling in Spring
We'll now look at Spring's support for Event Handling. We'll write an event listener in this tutorial. i'll also show you how to write custom events and publish them anywhere in the code.
24 - Introduction to AOP
This video provides a brief introduction to Aspect Oriented Programming concepts.
25 - Setting Up AOP Dependencies
In this tutorial, we'll add the additional dependencies required for Spring AOP and we'll configure our project's class path with these dependencies.
26 - Writing Our First Aspect Part 1
In this first part of the tutorial, we'll create a Spring project that forms the basis for our Aspect. This is a good refresher of some of the core Spring concepts, and it also give us an opportunity to introduce a service layer in our code that we'll build on in the subsequent tutorials.
27 - Writing Our First Aspect Part 2
Now that we have a basic Spring application, we'll implement the Logging aspect. We'll learn how to create a new Aspect using annotations and configure an advice to run before a getter method.
28 - Pointcuts and Wildcard Expressions
We'll now learn what a Pointcut is, the Pointcut annotation and how to apply advice to multiple pointcuts.
29 - A Few More Pointcut Expressions
In this tutorial, we'll learn about a few other Pointcut expressions that can be used to advice different methods.
30 - JoinPoints and Advice Arguments
We'll now learn about join points, and how we can use arguments in the advice methods to get information about join points.
31 - After Advice Types
We'll learn about the After Advice types: After (finally), AfterReturning and AfterThrowing.
32 - Around Advice Type
This tutorial covers the Around advice type. We'll learn how to use it, and we'll also look at some of the unique and powerful features that are specific to this advice type.
33 - Naming Conventions and Custom Advice Annotations
In this video, I share some thoughts on naming conventions, and how it helps in the case of writing aspects in Spring. We will also understand how to write our own custom annotations to apply advice to methods.
34 - AOP XML configuration
We'll learn how to configure aspects, advice and pointcuts using the traditional XML way.
35 - Understanding AOP Proxies
In this video, we go where no Spring AOP tutorial has gone before! We'll understand how Spring AOP works and how it uses proxy classes to apply advice. And we'll do this by implementing our own simple factory service. The way Spring AOP works is much more complicated, but this simple implementation should give us a solid understanding of proxy objects and clarify the core concepts.
36 - Introduction to Spring Data and Setting Up
This tutorial serves as an introduction to Spring Data support. We'll also install a lightweight database Apache Derby that we'll use in subsequent tutorials. We'll learn how to start Derby in Network server mode, and how to connect and run SQL queries using the ij client tool.
37 - Using JDBC without Spring
We'll now implement a simple DAO class that fetches data from the database using JDBC. We'll look at all the boilerplate code we need to write to establish connections, execute queries, close objects and handle exceptions.
38 - Adding Spring and DataSource Configuration
We'll now add the Spring framework to our JDBC project. We'll add dependency injection to our Main and DAO class. We'll also learn how to configure DataSource as a Spring bean and supply connection parameters to it in the XML file.
39 - Using JdbcTemplate
We'll use the JdbcTemplate class provided by Spring to implement a DAO method. We'll see how using the template class makes the DAO methods simple, and how it takes care of much of the boilerplate code we'd have to write otherwise.
40 - Returning Other Datatypes from JdbcTemplate
We returned an integer datatype result from our query in the previous tutorial. In this tutorial, we'll learn how to return other datatypes. We'll implement a method that returns a String query output.
41 - Implementing RowMapper
In this tutorial, we implement a custom RowMapper class to map our domain objects. We then use this class to write fetch methods that return custom model objects.
42 - Performing Write Operations with JdbcTemplate
We'll now implement some database write operations. We'll write a DAO method to update a value in the database, as well as use the execute() method to run a DDL SQL query.
43 - Named Parameter JDBC Template
We'll use the NamedParameterJdbcTemplate class to run queries with named placeholders.
44 - DAO Support Classes
We'll wrap up discussion on the Spring JDBC support by using the DAO support classes that Spring provides out of the box. We'll see how this makes our DAO classes cleaner than ever.
45 - Using Hibernate with Spring
In this video, we'll learn how to integrate the Hibernate framework in our Spring application. We'll create a SessionFactory as a Spring singleton and use that in our DAO class to work with the database.
In this tutorial, we'll understand the concept of Dependency Injection.
02 - Setting Up
In this tutorial, we'll learn how to set up our Eclipse development environment to write Spring code.
03 - Understanding Spring Bean Factory
In this tutorial, we'll discuss the role of Spring as a bean container. We'll also have a quick discussion on the Factory pattern, and I'll introduce you to the Spring Bean Factory object.
04 - Writing Code Using the Bean Factory
In this tutorial, we'll write code to implement the BeanFactory concept that we learnt in our previous tutorial. We'll write a Spring XML to configure a Spring bean. Then we'll use the BeanFactory to instantiate our bean in the Spring container.
05 - ApplicationContext and Property Initialization
We'll first replace the BeanFactory with the more powerful ApplicationContext. We'll then make Spring initialize a property of an object by specifying the value in the configuration XML.
06 - Using Constructor Injection
We'll now use constructors to set the member variable values for our Spring beans. We'll also look at some techniques to resolve conflicts in the case of overloaded constructors.
07 - Injecting Objects
In this tutorial, we'll use dependency injection to inject an object dependency to a Spring bean.
08 - Inner Beans, Aliases and idref
In this tutorial, we'll look at some concepts related to bean naming and usage like alias and idref. We'll also understand how to write inner beans.
09 - Initializing Collections
In this tutorial, we'll initialize a member variable that's a collection and each of the elements are references to other beans.
10 - Bean Autowiring
We'll now look at a configuration feature provided by Spring to wire dependencies automatically: Bean Autowiring. We'll learn about different types of autowiring, and we'll write some code to implement bean autowiring by name.
11 - Understanding Bean Scopes
This tutorial covers the concepts of Bean Scopes in Spring. We'll understand when beans are created and how to configure different scopes for the beans.
12 - Using ApplicationContextAware
We'll provide our beans with access to the ApplicationContext object by implementing the ApplicationContextAware interface. We'll also use BeanNameAware interface to get the name of the bean configured in the Spring XML.
13 - Bean Definition Inheritance
In this tutorial, we'll learn what bean definition inheritance is, and how to configure a parent bean definition and have children beans inherit the bean definitions.
14 - Lifecycle Callbacks
We'll use two different ways to run methods on initialization and destruction of beans.
15 - Writing a BeanPostProcessor
In this tutorial, we'll understand what a BeanPostProcessor is. We'll also write a BeanPostProcessor that prints a message upon initializing each and every bean in the Spring XML.
16 - Writing a BeanFactoryPostProcessor
In this tutorial, we'll learn about and write our own BeanFactoryPostProcessor. We'll also try out a handy BeanFactoryPostProcessor that comes with Spring: the PropertyPlaceholderConfigurer.
17 - Coding To Interfaces
When using Spring for dependency injection, it's a good practice to use interfaces for referencing dependencies. In this tutorial, we'll learn how to ""code to interfaces"".
18 - Introduction to Annotations and the Required Annota…
Here we'll have our first look at Spring annotations. We'll understand and implement the Required annotation, and we'll also learn how it's actually a BeanPostProcessor that's working behind the scenes.
19 - The Autowired Annotation
In this tutorial, we'll use the Autowired annotation to wire up dependencies. We'll learn how to add dependencies by type and name. We'll also use Qualifiers to narrow down dependency contenders.
20 - Some JSR-250 Annotations
We'll learn and implement three JSR-250 annotations that Spring supports:Resource, PostConstruct and PreDestroy.
21 - Component and Stereotype Annotations
We'll now use the Component annotation to define Spring beans. We'll also look at some Stereotype annotations.
22 - Using MessageSource To Get Text From Property Files
In this tutorial, we'll use the MessageSource interface to retrieve messages out of property files.
23 - Event Handling in Spring
We'll now look at Spring's support for Event Handling. We'll write an event listener in this tutorial. i'll also show you how to write custom events and publish them anywhere in the code.
24 - Introduction to AOP
This video provides a brief introduction to Aspect Oriented Programming concepts.
25 - Setting Up AOP Dependencies
In this tutorial, we'll add the additional dependencies required for Spring AOP and we'll configure our project's class path with these dependencies.
26 - Writing Our First Aspect Part 1
In this first part of the tutorial, we'll create a Spring project that forms the basis for our Aspect. This is a good refresher of some of the core Spring concepts, and it also give us an opportunity to introduce a service layer in our code that we'll build on in the subsequent tutorials.
27 - Writing Our First Aspect Part 2
Now that we have a basic Spring application, we'll implement the Logging aspect. We'll learn how to create a new Aspect using annotations and configure an advice to run before a getter method.
28 - Pointcuts and Wildcard Expressions
We'll now learn what a Pointcut is, the Pointcut annotation and how to apply advice to multiple pointcuts.
29 - A Few More Pointcut Expressions
In this tutorial, we'll learn about a few other Pointcut expressions that can be used to advice different methods.
30 - JoinPoints and Advice Arguments
We'll now learn about join points, and how we can use arguments in the advice methods to get information about join points.
31 - After Advice Types
We'll learn about the After Advice types: After (finally), AfterReturning and AfterThrowing.
32 - Around Advice Type
This tutorial covers the Around advice type. We'll learn how to use it, and we'll also look at some of the unique and powerful features that are specific to this advice type.
33 - Naming Conventions and Custom Advice Annotations
In this video, I share some thoughts on naming conventions, and how it helps in the case of writing aspects in Spring. We will also understand how to write our own custom annotations to apply advice to methods.
34 - AOP XML configuration
We'll learn how to configure aspects, advice and pointcuts using the traditional XML way.
35 - Understanding AOP Proxies
In this video, we go where no Spring AOP tutorial has gone before! We'll understand how Spring AOP works and how it uses proxy classes to apply advice. And we'll do this by implementing our own simple factory service. The way Spring AOP works is much more complicated, but this simple implementation should give us a solid understanding of proxy objects and clarify the core concepts.
36 - Introduction to Spring Data and Setting Up
This tutorial serves as an introduction to Spring Data support. We'll also install a lightweight database Apache Derby that we'll use in subsequent tutorials. We'll learn how to start Derby in Network server mode, and how to connect and run SQL queries using the ij client tool.
37 - Using JDBC without Spring
We'll now implement a simple DAO class that fetches data from the database using JDBC. We'll look at all the boilerplate code we need to write to establish connections, execute queries, close objects and handle exceptions.
38 - Adding Spring and DataSource Configuration
We'll now add the Spring framework to our JDBC project. We'll add dependency injection to our Main and DAO class. We'll also learn how to configure DataSource as a Spring bean and supply connection parameters to it in the XML file.
39 - Using JdbcTemplate
We'll use the JdbcTemplate class provided by Spring to implement a DAO method. We'll see how using the template class makes the DAO methods simple, and how it takes care of much of the boilerplate code we'd have to write otherwise.
40 - Returning Other Datatypes from JdbcTemplate
We returned an integer datatype result from our query in the previous tutorial. In this tutorial, we'll learn how to return other datatypes. We'll implement a method that returns a String query output.
41 - Implementing RowMapper
In this tutorial, we implement a custom RowMapper class to map our domain objects. We then use this class to write fetch methods that return custom model objects.
42 - Performing Write Operations with JdbcTemplate
We'll now implement some database write operations. We'll write a DAO method to update a value in the database, as well as use the execute() method to run a DDL SQL query.
43 - Named Parameter JDBC Template
We'll use the NamedParameterJdbcTemplate class to run queries with named placeholders.
44 - DAO Support Classes
We'll wrap up discussion on the Spring JDBC support by using the DAO support classes that Spring provides out of the box. We'll see how this makes our DAO classes cleaner than ever.
45 - Using Hibernate with Spring
In this video, we'll learn how to integrate the Hibernate framework in our Spring application. We'll create a SessionFactory as a Spring singleton and use that in our DAO class to work with the database.
General
Complete name : Java Brains Spring Framework\Spring Tutorial 01 - Understanding Dependency Injection.mp4
Format : MPEG-4
Format profile : Base Media / Version 2
Codec ID : mp42
File size : 36.8 MiB
Duration : 14mn 51s
Overall bit rate mode : Variable
Overall bit rate : 347 Kbps
Encoded date : UTC 2011-06-16 02:02:22
Tagged date : UTC 2011-06-16 02:02:22
Video
ID : 1
Format : AVC
Format/Info : Advanced Video Codec
Format profile : High@L3.1
Format settings, CABAC : Yes
Format settings, ReFrames : 1 frame
Codec ID : avc1
Codec ID/Info : Advanced Video Coding
Duration : 14mn 51s
Bit rate : 221 Kbps
Maximum bit rate : 1 423 Kbps
Width : 1 280 pixels
Height : 720 pixels
Display aspect ratio : 16:9
Frame rate mode : Variable
Frame rate : 30.000 fps
Minimum frame rate : 29.412 fps
Maximum frame rate : 55.556 fps
Color space : YUV
Chroma subsampling : 4:2:0
Bit depth : 8 bits
Scan type : Progressive
Bits/(Pixel*Frame) : 0.008
Stream size : 23.5 MiB (64%)
Tagged date : UTC 2011-06-16 02:02:35
Audio
ID : 2
Format : AAC
Format/Info : Advanced Audio Codec
Format profile : LC
Codec ID : 40
Duration : 14mn 51s
Bit rate mode : Variable
Bit rate : 119 Kbps
Maximum bit rate : 181 Kbps
Channel(s) : 2 channels
Channel positions : Front: L R
Sampling rate : 44.1 KHz
Compression mode : Lossy
Stream size : 12.7 MiB (34%)
Encoded date : UTC 2011-06-16 02:02:26
Tagged date : UTC 2011-06-16 02:02:35
Complete name : Java Brains Spring Framework\Spring Tutorial 01 - Understanding Dependency Injection.mp4
Format : MPEG-4
Format profile : Base Media / Version 2
Codec ID : mp42
File size : 36.8 MiB
Duration : 14mn 51s
Overall bit rate mode : Variable
Overall bit rate : 347 Kbps
Encoded date : UTC 2011-06-16 02:02:22
Tagged date : UTC 2011-06-16 02:02:22
Video
ID : 1
Format : AVC
Format/Info : Advanced Video Codec
Format profile : High@L3.1
Format settings, CABAC : Yes
Format settings, ReFrames : 1 frame
Codec ID : avc1
Codec ID/Info : Advanced Video Coding
Duration : 14mn 51s
Bit rate : 221 Kbps
Maximum bit rate : 1 423 Kbps
Width : 1 280 pixels
Height : 720 pixels
Display aspect ratio : 16:9
Frame rate mode : Variable
Frame rate : 30.000 fps
Minimum frame rate : 29.412 fps
Maximum frame rate : 55.556 fps
Color space : YUV
Chroma subsampling : 4:2:0
Bit depth : 8 bits
Scan type : Progressive
Bits/(Pixel*Frame) : 0.008
Stream size : 23.5 MiB (64%)
Tagged date : UTC 2011-06-16 02:02:35
Audio
ID : 2
Format : AAC
Format/Info : Advanced Audio Codec
Format profile : LC
Codec ID : 40
Duration : 14mn 51s
Bit rate mode : Variable
Bit rate : 119 Kbps
Maximum bit rate : 181 Kbps
Channel(s) : 2 channels
Channel positions : Front: L R
Sampling rate : 44.1 KHz
Compression mode : Lossy
Stream size : 12.7 MiB (34%)
Encoded date : UTC 2011-06-16 02:02:26
Tagged date : UTC 2011-06-16 02:02:35
Screenshots
Koushik Kothagal - Java Brains: Spring Framework
Koushik Kothagal - Java Brains: Spring Framework
Koushik Kothagal - Java Brains: Spring Framework
