Udemy - The Java Spring Tutorial; Learn Java's Popular Web Framework

Category: Tutorial


Posted on 2019-09-27, by phaelx.

Description



Date: Jan 2016
Author: John Purcell

Size: 4.8 GB
Format: MP4
Download     >>    https://usersdrive.com/o5ss8pkwqkhc.html
What you'll learn
   *Understand the fundamentals of the Java Spring framework
   *Learn how to develop web and database applications with Spring
   *Understand the basics of Hibernate for SQL-free database connectivity


Course content

Getting Started
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts

Basic Bean Configuration
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties

Autowiring
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities

Wiring with Annotations
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations

Spring Expression Language (SPEL)
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators

Working with Databases
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions

Web Application Basics with Spring MVC
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions
   A Basic Non-Spring Web App
   Bringing in Maven
   The Dispatcher Servlet
   Adding a Controller
   View Resolvers
   Adding Data to the Session
   Using Spring Data Models
   Using JSTL (JSP Standard Tag Library)
   Configuring a JNDI Data Source
   Bringing in the DAO Code
   Loading Bean Containers with ContextLoaderListener
   Creating a Datasource Bean
   Adding a Service Layer
   Adding a New Controller
   Getting URL Parameters

Working with Web Forms
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions
   A Basic Non-Spring Web App
   Bringing in Maven
   The Dispatcher Servlet
   Adding a Controller
   View Resolvers
   Adding Data to the Session
   Using Spring Data Models
   Using JSTL (JSP Standard Tag Library)
   Configuring a JNDI Data Source
   Bringing in the DAO Code
   Loading Bean Containers with ContextLoaderListener
   Creating a Datasource Bean
   Adding a Service Layer
   Adding a New Controller
   Getting URL Parameters
   Creating a Form
   Getting Form Values
   Adding CSS Styles
   Serving Static Resources
   Adding Hibernate Form Validation Support
   More Form Validation Tags
   Making Forms Remember Values
   Displaying Form Validation Errors
   Creating a Custom Validation Annotation
   Hooking Up the Controller and Database Code
   Exception Handling in Spring MVC

Aspect-Oriented Programming (AOP)
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions
   A Basic Non-Spring Web App
   Bringing in Maven
   The Dispatcher Servlet
   Adding a Controller
   View Resolvers
   Adding Data to the Session
   Using Spring Data Models
   Using JSTL (JSP Standard Tag Library)
   Configuring a JNDI Data Source
   Bringing in the DAO Code
   Loading Bean Containers with ContextLoaderListener
   Creating a Datasource Bean
   Adding a Service Layer
   Adding a New Controller
   Getting URL Parameters
   Creating a Form
   Getting Form Values
   Adding CSS Styles
   Serving Static Resources
   Adding Hibernate Form Validation Support
   More Form Validation Tags
   Making Forms Remember Values
   Displaying Form Validation Errors
   Creating a Custom Validation Annotation
   Hooking Up the Controller and Database Code
   Exception Handling in Spring MVC
   A Base Project for Working with Aspects
   A Simple Aspect Example
   Annotation-Based Aspects
   Wildcards in Pointcut Expressions
   Advice Types: After, Around and Others
   Proxies, Interfaces and Aspects
   The “Within” Pointcut Designator
   “This”, “Target” and Matching Subpackages
   Annotation-Specific PCDs
   The “Bean” PCD
   The “Args” PCD
   Getting Target Method Arguments
   Getting Arguments Using “Args”
   Combining Pointcuts
   Introductions: Adding Functionality Using Aspects

Spring Security and Managing Users
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions
   A Basic Non-Spring Web App
   Bringing in Maven
   The Dispatcher Servlet
   Adding a Controller
   View Resolvers
   Adding Data to the Session
   Using Spring Data Models
   Using JSTL (JSP Standard Tag Library)
   Configuring a JNDI Data Source
   Bringing in the DAO Code
   Loading Bean Containers with ContextLoaderListener
   Creating a Datasource Bean
   Adding a Service Layer
   Adding a New Controller
   Getting URL Parameters
   Creating a Form
   Getting Form Values
   Adding CSS Styles
   Serving Static Resources
   Adding Hibernate Form Validation Support
   More Form Validation Tags
   Making Forms Remember Values
   Displaying Form Validation Errors
   Creating a Custom Validation Annotation
   Hooking Up the Controller and Database Code
   Exception Handling in Spring MVC
   A Base Project for Working with Aspects
   A Simple Aspect Example
   Annotation-Based Aspects
   Wildcards in Pointcut Expressions
   Advice Types: After, Around and Others
   Proxies, Interfaces and Aspects
   The “Within” Pointcut Designator
   “This”, “Target” and Matching Subpackages
   Annotation-Specific PCDs
   The “Bean” PCD
   The “Args” PCD
   Getting Target Method Arguments
   Getting Arguments Using “Args”
   Combining Pointcuts
   Introductions: Adding Functionality Using Aspects
   Servlets Filters: A Review
   Adding a Spring Security Filter
   Adding a Spring Login Form
   Serving Static Resources: Access Rules
   Customising the Login Form
   Displaying Login Errors
   Authorising Users from a Database
   Adding a “Create Account” Form
   Making the “Create Account” Form Work
   Adding Validation to the User Form
   Dealing with Duplicate Usernames
   Storing Validation Messages in a Property File
   Using JQuery to verify the password
   Using Property File Values in JSPs
   Adding a Logout Link
   Working With Roles
   Outputting Text Based on Authentication Status
   Row Mapping with BeanPropertyRowMapper
   Using Custom Authentication Queries: Case Sensitive Usernames
   Method-Level Access Control
   Catching Secure Annotation Violations
   Adding “Remember Me” Functionality
   Encrypting Passwords

Apache Tiles and Spring MVC
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions
   A Basic Non-Spring Web App
   Bringing in Maven
   The Dispatcher Servlet
   Adding a Controller
   View Resolvers
   Adding Data to the Session
   Using Spring Data Models
   Using JSTL (JSP Standard Tag Library)
   Configuring a JNDI Data Source
   Bringing in the DAO Code
   Loading Bean Containers with ContextLoaderListener
   Creating a Datasource Bean
   Adding a Service Layer
   Adding a New Controller
   Getting URL Parameters
   Creating a Form
   Getting Form Values
   Adding CSS Styles
   Serving Static Resources
   Adding Hibernate Form Validation Support
   More Form Validation Tags
   Making Forms Remember Values
   Displaying Form Validation Errors
   Creating a Custom Validation Annotation
   Hooking Up the Controller and Database Code
   Exception Handling in Spring MVC
   A Base Project for Working with Aspects
   A Simple Aspect Example
   Annotation-Based Aspects
   Wildcards in Pointcut Expressions
   Advice Types: After, Around and Others
   Proxies, Interfaces and Aspects
   The “Within” Pointcut Designator
   “This”, “Target” and Matching Subpackages
   Annotation-Specific PCDs
   The “Bean” PCD
   The “Args” PCD
   Getting Target Method Arguments
   Getting Arguments Using “Args”
   Combining Pointcuts
   Introductions: Adding Functionality Using Aspects
   Servlets Filters: A Review
   Adding a Spring Security Filter
   Adding a Spring Login Form
   Serving Static Resources: Access Rules
   Customising the Login Form
   Displaying Login Errors
   Authorising Users from a Database
   Adding a “Create Account” Form
   Making the “Create Account” Form Work
   Adding Validation to the User Form
   Dealing with Duplicate Usernames
   Storing Validation Messages in a Property File
   Using JQuery to verify the password
   Using Property File Values in JSPs
   Adding a Logout Link
   Working With Roles
   Outputting Text Based on Authentication Status
   Row Mapping with BeanPropertyRowMapper
   Using Custom Authentication Queries: Case Sensitive Usernames
   Method-Level Access Control
   Catching Secure Annotation Violations
   Adding “Remember Me” Functionality
   Encrypting Passwords
   Tiles Dependencies
   “Hello World” Apache Tiles
   Adding Headers and Footers
   Formatting the Offers Application
   Creating Tiles from JSP Files

Logging and Testing
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions
   A Basic Non-Spring Web App
   Bringing in Maven
   The Dispatcher Servlet
   Adding a Controller
   View Resolvers
   Adding Data to the Session
   Using Spring Data Models
   Using JSTL (JSP Standard Tag Library)
   Configuring a JNDI Data Source
   Bringing in the DAO Code
   Loading Bean Containers with ContextLoaderListener
   Creating a Datasource Bean
   Adding a Service Layer
   Adding a New Controller
   Getting URL Parameters
   Creating a Form
   Getting Form Values
   Adding CSS Styles
   Serving Static Resources
   Adding Hibernate Form Validation Support
   More Form Validation Tags
   Making Forms Remember Values
   Displaying Form Validation Errors
   Creating a Custom Validation Annotation
   Hooking Up the Controller and Database Code
   Exception Handling in Spring MVC
   A Base Project for Working with Aspects
   A Simple Aspect Example
   Annotation-Based Aspects
   Wildcards in Pointcut Expressions
   Advice Types: After, Around and Others
   Proxies, Interfaces and Aspects
   The “Within” Pointcut Designator
   “This”, “Target” and Matching Subpackages
   Annotation-Specific PCDs
   The “Bean” PCD
   The “Args” PCD
   Getting Target Method Arguments
   Getting Arguments Using “Args”
   Combining Pointcuts
   Introductions: Adding Functionality Using Aspects
   Servlets Filters: A Review
   Adding a Spring Security Filter
   Adding a Spring Login Form
   Serving Static Resources: Access Rules
   Customising the Login Form
   Displaying Login Errors
   Authorising Users from a Database
   Adding a “Create Account” Form
   Making the “Create Account” Form Work
   Adding Validation to the User Form
   Dealing with Duplicate Usernames
   Storing Validation Messages in a Property File
   Using JQuery to verify the password
   Using Property File Values in JSPs
   Adding a Logout Link
   Working With Roles
   Outputting Text Based on Authentication Status
   Row Mapping with BeanPropertyRowMapper
   Using Custom Authentication Queries: Case Sensitive Usernames
   Method-Level Access Control
   Catching Secure Annotation Violations
   Adding “Remember Me” Functionality
   Encrypting Passwords
   Tiles Dependencies
   “Hello World” Apache Tiles
   Adding Headers and Footers
   Formatting the Offers Application
   Creating Tiles from JSP Files
   Adding Log4J Logging
   Resolving Logging Conflicts
   Using Logging
   Creating a MySQL Test Database
   Using Spring Profiles
   Creating JUnit Tests
   Coding the JUnit DAO Tests

Improving the 'Offers' Web Application
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions
   A Basic Non-Spring Web App
   Bringing in Maven
   The Dispatcher Servlet
   Adding a Controller
   View Resolvers
   Adding Data to the Session
   Using Spring Data Models
   Using JSTL (JSP Standard Tag Library)
   Configuring a JNDI Data Source
   Bringing in the DAO Code
   Loading Bean Containers with ContextLoaderListener
   Creating a Datasource Bean
   Adding a Service Layer
   Adding a New Controller
   Getting URL Parameters
   Creating a Form
   Getting Form Values
   Adding CSS Styles
   Serving Static Resources
   Adding Hibernate Form Validation Support
   More Form Validation Tags
   Making Forms Remember Values
   Displaying Form Validation Errors
   Creating a Custom Validation Annotation
   Hooking Up the Controller and Database Code
   Exception Handling in Spring MVC
   A Base Project for Working with Aspects
   A Simple Aspect Example
   Annotation-Based Aspects
   Wildcards in Pointcut Expressions
   Advice Types: After, Around and Others
   Proxies, Interfaces and Aspects
   The “Within” Pointcut Designator
   “This”, “Target” and Matching Subpackages
   Annotation-Specific PCDs
   The “Bean” PCD
   The “Args” PCD
   Getting Target Method Arguments
   Getting Arguments Using “Args”
   Combining Pointcuts
   Introductions: Adding Functionality Using Aspects
   Servlets Filters: A Review
   Adding a Spring Security Filter
   Adding a Spring Login Form
   Serving Static Resources: Access Rules
   Customising the Login Form
   Displaying Login Errors
   Authorising Users from a Database
   Adding a “Create Account” Form
   Making the “Create Account” Form Work
   Adding Validation to the User Form
   Dealing with Duplicate Usernames
   Storing Validation Messages in a Property File
   Using JQuery to verify the password
   Using Property File Values in JSPs
   Adding a Logout Link
   Working With Roles
   Outputting Text Based on Authentication Status
   Row Mapping with BeanPropertyRowMapper
   Using Custom Authentication Queries: Case Sensitive Usernames
   Method-Level Access Control
   Catching Secure Annotation Violations
   Adding “Remember Me” Functionality
   Encrypting Passwords
   Tiles Dependencies
   “Hello World” Apache Tiles
   Adding Headers and Footers
   Formatting the Offers Application
   Creating Tiles from JSP Files
   Adding Log4J Logging
   Resolving Logging Conflicts
   Using Logging
   Creating a MySQL Test Database
   Using Spring Profiles
   Creating JUnit Tests
   Coding the JUnit DAO Tests
   Normalizing the Database
   Querying Tables with Foreign Keys and Refactoring the DAO Layer
   Refactoring the Web Layer
   Getting the Username of the Logged-In User
   Deleting from Tables with Foreign Keys and a Little Bugfix
   Custom RowMappers
   Conditional Database-Dependent Text in JSPs
   Editing Database Objects with Forms
   Multiple Form Submits and Optional Parameters
   Adding a Confirm Dialog with JQuery

Hibernate
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions
   A Basic Non-Spring Web App
   Bringing in Maven
   The Dispatcher Servlet
   Adding a Controller
   View Resolvers
   Adding Data to the Session
   Using Spring Data Models
   Using JSTL (JSP Standard Tag Library)
   Configuring a JNDI Data Source
   Bringing in the DAO Code
   Loading Bean Containers with ContextLoaderListener
   Creating a Datasource Bean
   Adding a Service Layer
   Adding a New Controller
   Getting URL Parameters
   Creating a Form
   Getting Form Values
   Adding CSS Styles
   Serving Static Resources
   Adding Hibernate Form Validation Support
   More Form Validation Tags
   Making Forms Remember Values
   Displaying Form Validation Errors
   Creating a Custom Validation Annotation
   Hooking Up the Controller and Database Code
   Exception Handling in Spring MVC
   A Base Project for Working with Aspects
   A Simple Aspect Example
   Annotation-Based Aspects
   Wildcards in Pointcut Expressions
   Advice Types: After, Around and Others
   Proxies, Interfaces and Aspects
   The “Within” Pointcut Designator
   “This”, “Target” and Matching Subpackages
   Annotation-Specific PCDs
   The “Bean” PCD
   The “Args” PCD
   Getting Target Method Arguments
   Getting Arguments Using “Args”
   Combining Pointcuts
   Introductions: Adding Functionality Using Aspects
   Servlets Filters: A Review
   Adding a Spring Security Filter
   Adding a Spring Login Form
   Serving Static Resources: Access Rules
   Customising the Login Form
   Displaying Login Errors
   Authorising Users from a Database
   Adding a “Create Account” Form
   Making the “Create Account” Form Work
   Adding Validation to the User Form
   Dealing with Duplicate Usernames
   Storing Validation Messages in a Property File
   Using JQuery to verify the password
   Using Property File Values in JSPs
   Adding a Logout Link
   Working With Roles
   Outputting Text Based on Authentication Status
   Row Mapping with BeanPropertyRowMapper
   Using Custom Authentication Queries: Case Sensitive Usernames
   Method-Level Access Control
   Catching Secure Annotation Violations
   Adding “Remember Me” Functionality
   Encrypting Passwords
   Tiles Dependencies
   “Hello World” Apache Tiles
   Adding Headers and Footers
   Formatting the Offers Application
   Creating Tiles from JSP Files
   Adding Log4J Logging
   Resolving Logging Conflicts
   Using Logging
   Creating a MySQL Test Database
   Using Spring Profiles
   Creating JUnit Tests
   Coding the JUnit DAO Tests
   Normalizing the Database
   Querying Tables with Foreign Keys and Refactoring the DAO Layer
   Refactoring the Web Layer
   Getting the Username of the Logged-In User
   Deleting from Tables with Foreign Keys and a Little Bugfix
   Custom RowMappers
   Conditional Database-Dependent Text in JSPs
   Editing Database Objects with Forms
   Multiple Form Submits and Optional Parameters
   Adding a Confirm Dialog with JQuery
   Introducing Hibernate
   A Simple Hibernate Query
   Saving Objects
   Validation Groups and Password Encryption
   Translating Hibernate Exceptions to Spring Exceptions
   Queries with Criteria
   Mapping Many-to-One Relationships
   Restrictions on Joined Tables
   Multiple Criteria
   Updating Objects
   Deleting Objects
   Completing the Offers DAO

Spring Webflow
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions
   A Basic Non-Spring Web App
   Bringing in Maven
   The Dispatcher Servlet
   Adding a Controller
   View Resolvers
   Adding Data to the Session
   Using Spring Data Models
   Using JSTL (JSP Standard Tag Library)
   Configuring a JNDI Data Source
   Bringing in the DAO Code
   Loading Bean Containers with ContextLoaderListener
   Creating a Datasource Bean
   Adding a Service Layer
   Adding a New Controller
   Getting URL Parameters
   Creating a Form
   Getting Form Values
   Adding CSS Styles
   Serving Static Resources
   Adding Hibernate Form Validation Support
   More Form Validation Tags
   Making Forms Remember Values
   Displaying Form Validation Errors
   Creating a Custom Validation Annotation
   Hooking Up the Controller and Database Code
   Exception Handling in Spring MVC
   A Base Project for Working with Aspects
   A Simple Aspect Example
   Annotation-Based Aspects
   Wildcards in Pointcut Expressions
   Advice Types: After, Around and Others
   Proxies, Interfaces and Aspects
   The “Within” Pointcut Designator
   “This”, “Target” and Matching Subpackages
   Annotation-Specific PCDs
   The “Bean” PCD
   The “Args” PCD
   Getting Target Method Arguments
   Getting Arguments Using “Args”
   Combining Pointcuts
   Introductions: Adding Functionality Using Aspects
   Servlets Filters: A Review
   Adding a Spring Security Filter
   Adding a Spring Login Form
   Serving Static Resources: Access Rules
   Customising the Login Form
   Displaying Login Errors
   Authorising Users from a Database
   Adding a “Create Account” Form
   Making the “Create Account” Form Work
   Adding Validation to the User Form
   Dealing with Duplicate Usernames
   Storing Validation Messages in a Property File
   Using JQuery to verify the password
   Using Property File Values in JSPs
   Adding a Logout Link
   Working With Roles
   Outputting Text Based on Authentication Status
   Row Mapping with BeanPropertyRowMapper
   Using Custom Authentication Queries: Case Sensitive Usernames
   Method-Level Access Control
   Catching Secure Annotation Violations
   Adding “Remember Me” Functionality
   Encrypting Passwords
   Tiles Dependencies
   “Hello World” Apache Tiles
   Adding Headers and Footers
   Formatting the Offers Application
   Creating Tiles from JSP Files
   Adding Log4J Logging
   Resolving Logging Conflicts
   Using Logging
   Creating a MySQL Test Database
   Using Spring Profiles
   Creating JUnit Tests
   Coding the JUnit DAO Tests
   Normalizing the Database
   Querying Tables with Foreign Keys and Refactoring the DAO Layer
   Refactoring the Web Layer
   Getting the Username of the Logged-In User
   Deleting from Tables with Foreign Keys and a Little Bugfix
   Custom RowMappers
   Conditional Database-Dependent Text in JSPs
   Editing Database Objects with Forms
   Multiple Form Submits and Optional Parameters
   Adding a Confirm Dialog with JQuery
   Introducing Hibernate
   A Simple Hibernate Query
   Saving Objects
   Validation Groups and Password Encryption
   Translating Hibernate Exceptions to Spring Exceptions
   Queries with Criteria
   Mapping Many-to-One Relationships
   Restrictions on Joined Tables
   Multiple Criteria
   Updating Objects
   Deleting Objects
   Completing the Offers DAO
   Introducing Webflow
   Creating a Flow Registry
   Hooking Up URLs to Webflows
   Connecting Webflow and Apache Tiles
   Creating a “Messages” Table
   Creating a “Message” Class
   Adding a Message Form
   Transitions
   Action States
   Linking to Webflows
   Validating Webflow Forms
   Accessing User Details in Webflow

JSON and AJAX
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions
   A Basic Non-Spring Web App
   Bringing in Maven
   The Dispatcher Servlet
   Adding a Controller
   View Resolvers
   Adding Data to the Session
   Using Spring Data Models
   Using JSTL (JSP Standard Tag Library)
   Configuring a JNDI Data Source
   Bringing in the DAO Code
   Loading Bean Containers with ContextLoaderListener
   Creating a Datasource Bean
   Adding a Service Layer
   Adding a New Controller
   Getting URL Parameters
   Creating a Form
   Getting Form Values
   Adding CSS Styles
   Serving Static Resources
   Adding Hibernate Form Validation Support
   More Form Validation Tags
   Making Forms Remember Values
   Displaying Form Validation Errors
   Creating a Custom Validation Annotation
   Hooking Up the Controller and Database Code
   Exception Handling in Spring MVC
   A Base Project for Working with Aspects
   A Simple Aspect Example
   Annotation-Based Aspects
   Wildcards in Pointcut Expressions
   Advice Types: After, Around and Others
   Proxies, Interfaces and Aspects
   The “Within” Pointcut Designator
   “This”, “Target” and Matching Subpackages
   Annotation-Specific PCDs
   The “Bean” PCD
   The “Args” PCD
   Getting Target Method Arguments
   Getting Arguments Using “Args”
   Combining Pointcuts
   Introductions: Adding Functionality Using Aspects
   Servlets Filters: A Review
   Adding a Spring Security Filter
   Adding a Spring Login Form
   Serving Static Resources: Access Rules
   Customising the Login Form
   Displaying Login Errors
   Authorising Users from a Database
   Adding a “Create Account” Form
   Making the “Create Account” Form Work
   Adding Validation to the User Form
   Dealing with Duplicate Usernames
   Storing Validation Messages in a Property File
   Using JQuery to verify the password
   Using Property File Values in JSPs
   Adding a Logout Link
   Working With Roles
   Outputting Text Based on Authentication Status
   Row Mapping with BeanPropertyRowMapper
   Using Custom Authentication Queries: Case Sensitive Usernames
   Method-Level Access Control
   Catching Secure Annotation Violations
   Adding “Remember Me” Functionality
   Encrypting Passwords
   Tiles Dependencies
   “Hello World” Apache Tiles
   Adding Headers and Footers
   Formatting the Offers Application
   Creating Tiles from JSP Files
   Adding Log4J Logging
   Resolving Logging Conflicts
   Using Logging
   Creating a MySQL Test Database
   Using Spring Profiles
   Creating JUnit Tests
   Coding the JUnit DAO Tests
   Normalizing the Database
   Querying Tables with Foreign Keys and Refactoring the DAO Layer
   Refactoring the Web Layer
   Getting the Username of the Logged-In User
   Deleting from Tables with Foreign Keys and a Little Bugfix
   Custom RowMappers
   Conditional Database-Dependent Text in JSPs
   Editing Database Objects with Forms
   Multiple Form Submits and Optional Parameters
   Adding a Confirm Dialog with JQuery
   Introducing Hibernate
   A Simple Hibernate Query
   Saving Objects
   Validation Groups and Password Encryption
   Translating Hibernate Exceptions to Spring Exceptions
   Queries with Criteria
   Mapping Many-to-One Relationships
   Restrictions on Joined Tables
   Multiple Criteria
   Updating Objects
   Deleting Objects
   Completing the Offers DAO
   Introducing Webflow
   Creating a Flow Registry
   Hooking Up URLs to Webflows
   Connecting Webflow and Apache Tiles
   Creating a “Messages” Table
   Creating a “Message” Class
   Adding a Message Form
   Transitions
   Action States
   Linking to Webflows
   Validating Webflow Forms
   Accessing User Details in Webflow
   Creating a JSON Server
   Updating Dynamically with jQuery
   Generating Pages with Javascript
   Adding Reply Boxes
   Showing and Hiding the Reply Forms
   Stopping and Starting the Timer
   Getting the Text from the Right TextArea
   Posting Back JSON Data
   Giving the User Feedback
   Sending Email with Springmail

Outro
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions
   A Basic Non-Spring Web App
   Bringing in Maven
   The Dispatcher Servlet
   Adding a Controller
   View Resolvers
   Adding Data to the Session
   Using Spring Data Models
   Using JSTL (JSP Standard Tag Library)
   Configuring a JNDI Data Source
   Bringing in the DAO Code
   Loading Bean Containers with ContextLoaderListener
   Creating a Datasource Bean
   Adding a Service Layer
   Adding a New Controller
   Getting URL Parameters
   Creating a Form
   Getting Form Values
   Adding CSS Styles
   Serving Static Resources
   Adding Hibernate Form Validation Support
   More Form Validation Tags
   Making Forms Remember Values
   Displaying Form Validation Errors
   Creating a Custom Validation Annotation
   Hooking Up the Controller and Database Code
   Exception Handling in Spring MVC
   A Base Project for Working with Aspects
   A Simple Aspect Example
   Annotation-Based Aspects
   Wildcards in Pointcut Expressions
   Advice Types: After, Around and Others
   Proxies, Interfaces and Aspects
   The “Within” Pointcut Designator
   “This”, “Target” and Matching Subpackages
   Annotation-Specific PCDs
   The “Bean” PCD
   The “Args” PCD
   Getting Target Method Arguments
   Getting Arguments Using “Args”
   Combining Pointcuts
   Introductions: Adding Functionality Using Aspects
   Servlets Filters: A Review
   Adding a Spring Security Filter
   Adding a Spring Login Form
   Serving Static Resources: Access Rules
   Customising the Login Form
   Displaying Login Errors
   Authorising Users from a Database
   Adding a “Create Account” Form
   Making the “Create Account” Form Work
   Adding Validation to the User Form
   Dealing with Duplicate Usernames
   Storing Validation Messages in a Property File
   Using JQuery to verify the password
   Using Property File Values in JSPs
   Adding a Logout Link
   Working With Roles
   Outputting Text Based on Authentication Status
   Row Mapping with BeanPropertyRowMapper
   Using Custom Authentication Queries: Case Sensitive Usernames
   Method-Level Access Control
   Catching Secure Annotation Violations
   Adding “Remember Me” Functionality
   Encrypting Passwords
   Tiles Dependencies
   “Hello World” Apache Tiles
   Adding Headers and Footers
   Formatting the Offers Application
   Creating Tiles from JSP Files
   Adding Log4J Logging
   Resolving Logging Conflicts
   Using Logging
   Creating a MySQL Test Database
   Using Spring Profiles
   Creating JUnit Tests
   Coding the JUnit DAO Tests
   Normalizing the Database
   Querying Tables with Foreign Keys and Refactoring the DAO Layer
   Refactoring the Web Layer
   Getting the Username of the Logged-In User
   Deleting from Tables with Foreign Keys and a Little Bugfix
   Custom RowMappers
   Conditional Database-Dependent Text in JSPs
   Editing Database Objects with Forms
   Multiple Form Submits and Optional Parameters
   Adding a Confirm Dialog with JQuery
   Introducing Hibernate
   A Simple Hibernate Query
   Saving Objects
   Validation Groups and Password Encryption
   Translating Hibernate Exceptions to Spring Exceptions
   Queries with Criteria
   Mapping Many-to-One Relationships
   Restrictions on Joined Tables
   Multiple Criteria
   Updating Objects
   Deleting Objects
   Completing the Offers DAO
   Introducing Webflow
   Creating a Flow Registry
   Hooking Up URLs to Webflows
   Connecting Webflow and Apache Tiles
   Creating a “Messages” Table
   Creating a “Message” Class
   Adding a Message Form
   Transitions
   Action States
   Linking to Webflows
   Validating Webflow Forms
   Accessing User Details in Webflow
   Creating a JSON Server
   Updating Dynamically with jQuery
   Generating Pages with Javascript
   Adding Reply Boxes
   Showing and Hiding the Reply Forms
   Stopping and Starting the Timer
   Getting the Text from the Right TextArea
   Posting Back JSON Data
   Giving the User Feedback
   Sending Email with Springmail
   Some Final Words ...

Appendix
   What is Spring?
   About Spring 4, and bug fix for final project
   Setting Up Your System
   Introducing Maven
   Using Maven on the Command Line
   Spring 'Hello World'
   Class Path Contexts
   Constructor Arguments
   Setting Bean Properties
   Dependency Injection
   Bean Scope
   Init and Destroy Methods
   Factory Beans and Methods
   The P Namespace
   Setting List Properties
   Lists of Beans
   Inner Beans
   Property Maps
   Arbitrary Maps as Bean Properties
   Autowiring by Type
   Autowiring by Name
   Autowiring by Constructor
   Default Autowiring
   Removing Autowire Ambiguities
   Adding Support for Annotation-Based Wiring
   The 'Autowired' Annotation
   Optional Beans
   Using Qualifiers
   The Resource Annotation (JSR-250)
   Annotation-Based Init and Destroy Methods
   The Inject annotation (JSR-330)
   Automatic Bean Discovery
   Setting Property Values via Annotations
   Introducing SPEL
   Using SPEL with Annotations
   Some useful SPEL Operators
   Creating a Database with MySQL
   Using Property Files
   Implementing the DAO Pattern
   Downloading a Connector Jar
   Configuring Connection Pooling with Apache DBCP
   JDBC Templates
   Querying the Database
   Database Exceptions
   Named Parameters
   Update Statements
   Getting Placeholder Values from Beans
   Adding an Update Method to the DAO
   Batch Updates: Prepared Statements
   Transactions
   A Basic Non-Spring Web App
   Bringing in Maven
   The Dispatcher Servlet
   Adding a Controller
   View Resolvers
   Adding Data to the Session
   Using Spring Data Models
   Using JSTL (JSP Standard Tag Library)
   Configuring a JNDI Data Source
   Bringing in the DAO Code
   Loading Bean Containers with ContextLoaderListener
   Creating a Datasource Bean
   Adding a Service Layer
   Adding a New Controller
   Getting URL Parameters
   Creating a Form
   Getting Form Values
   Adding CSS Styles
   Serving Static Resources
   Adding Hibernate Form Validation Support
   More Form Validation Tags
   Making Forms Remember Values
   Displaying Form Validation Errors
   Creating a Custom Validation Annotation
   Hooking Up the Controller and Database Code
   Exception Handling in Spring MVC
   A Base Project for Working with Aspects
   A Simple Aspect Example
   Annotation-Based Aspects
   Wildcards in Pointcut Expressions
   Advice Types: After, Around and Others
   Proxies, Interfaces and Aspects
   The “Within” Pointcut Designator
   “This”, “Target” and Matching Subpackages
   Annotation-Specific PCDs
   The “Bean” PCD
   The “Args” PCD
   Getting Target Method Arguments
   Getting Arguments Using “Args”
   Combining Pointcuts
   Introductions: Adding Functionality Using Aspects
   Servlets Filters: A Review
   Adding a Spring Security Filter
   Adding a Spring Login Form
   Serving Static Resources: Access Rules
   Customising the Login Form
   Displaying Login Errors
   Authorising Users from a Database
   Adding a “Create Account” Form
   Making the “Create Account” Form Work
   Adding Validation to the User Form
   Dealing with Duplicate Usernames
   Storing Validation Messages in a Property File
   Using JQuery to verify the password
   Using Property File Values in JSPs
   Adding a Logout Link
   Working With Roles
   Outputting Text Based on Authentication Status
   Row Mapping with BeanPropertyRowMapper
   Using Custom Authentication Queries: Case Sensitive Usernames
   Method-Level Access Control
   Catching Secure Annotation Violations
   Adding “Remember Me” Functionality
   Encrypting Passwords
   Tiles Dependencies
   “Hello World” Apache Tiles
   Adding Headers and Footers
   Formatting the Offers Application
   Creating Tiles from JSP Files
   Adding Log4J Logging
   Resolving Logging Conflicts
   Using Logging
   Creating a MySQL Test Database
   Using Spring Profiles
   Creating JUnit Tests
   Coding the JUnit DAO Tests
   Normalizing the Database
   Querying Tables with Foreign Keys and Refactoring the DAO Layer
   Refactoring the Web Layer
   Getting the Username of the Logged-In User
   Deleting from Tables with Foreign Keys and a Little Bugfix
   Custom RowMappers
   Conditional Database-Dependent Text in JSPs
   Editing Database Objects with Forms
   Multiple Form Submits and Optional Parameters
   Adding a Confirm Dialog with JQuery
   Introducing Hibernate
   A Simple Hibernate Query
   Saving Objects
   Validation Groups and Password Encryption
   Translating Hibernate Exceptions to Spring Exceptions
   Queries with Criteria
   Mapping Many-to-One Relationships
   Restrictions on Joined Tables
   Multiple Criteria
   Updating Objects
   Deleting Objects
   Completing the Offers DAO
   Introducing Webflow
   Creating a Flow Registry
   Hooking Up URLs to Webflows
   Connecting Webflow and Apache Tiles
   Creating a “Messages” Table
   Creating a “Message” Class
   Adding a Message Form
   Transitions
   Action States
   Linking to Webflows
   Validating Webflow Forms
   Accessing User Details in Webflow
   Creating a JSON Server
   Updating Dynamically with jQuery
   Generating Pages with Javascript
   Adding Reply Boxes
   Showing and Hiding the Reply Forms
   Stopping and Starting the Timer
   Getting the Text from the Right TextArea
   Posting Back JSON Data
   Giving the User Feedback
   Sending Email with Springmail
   Some Final Words ...
   Database SQL
   All-in-one source code zip
   Frequently Asked Questions: Problems? Check here ...
   Recommended Books
   50%+ Discount: Servlets, JSPs and JSTL


Sponsored High Speed Downloads
8621 dl's @ 3105 KB/s
Download Now [Full Version]
5842 dl's @ 2526 KB/s
Download Link 1 - Fast Download
7185 dl's @ 3498 KB/s
Download Mirror - Direct Download



Search More...
Udemy - The Java Spring Tutorial; Learn Java's Popular Web Framework

Search free ebooks in ebookee.com!


Links
Download this book

No active download links here?
Please check the description for download links if any or do a search to find alternative books.


Related Books


Comments

No comments for "Udemy - The Java Spring Tutorial; Learn Java's Popular Web Framework".


    Add Your Comments
    1. Download links and password may be in the description section, read description carefully!
    2. Do a search to find mirrors if no download links or dead links.
    Back to Top