Index
A
- @AspectJ annotation
- declaring / Declaring an @Aspect annotation
- pointcuts / Pointcuts
- Advices / Advices
- @AspectJ annotation based AOP
- about / @AspectJ annotation-based AOP
- ACID (Atomic, Consistent, Isolated, Durable)
- about / Spring Transaction support
- Advices, @AspectJ annotation
- about / Advices
- annotations / Advices
- @Around Advice / The @Around Advice
- Advice parameters, accessing / Accessing Advice parameters
- AngularJS
- about / SPA frameworks
- annotations
- defining / Auditing with Spring Data
- @CreatedBy / Auditing with Spring Data
- @CreatedDate / Auditing with Spring Data
- @LastModifiedBy / Auditing with Spring Data
- @LastModifiedDate / Auditing with Spring Data
- API endpoints
- building, for Taskify app / Building API endpoints for the Taskify app
- UserController.java / UserController.java
- TaskController.java / TaskController.java
- API server app
- building / Building the API server app
- project, setting up / Setting up and configuring the project
- User and Task, defining / Defining the model definitions – User and Task
- Aspect Oriented Programing (AOP)
- about / Aspect Oriented Programming
- static AOP / Static and dynamic AOP
- dynamic AOP / Static and dynamic AOP
- concepts / AOP concepts and terminology
- terminology / AOP concepts and terminology
- Spring AOP / Spring AOP – definition and configuration styles
- XML schema based AOP / XML schema-based AOP
- @AspectJ annotation based AOP / @AspectJ annotation-based AOP
- asynchronous request processing
- in Spring MVC / Asynchronous request processing in Spring MVC
- authentication
- about / Authentication
- authorization
- about / Authorization
B
- bean definition profiles
- working with / Working with bean definition profiles
- bean dependencies
- injecting / Injecting bean dependencies
- constructor-based dependency injection / Constructor-based Dependency Injection
- setter-based dependency injection / Setter-based Dependency Injection
- BeanFactory interface
- about / The Spring IoC container
- bean life cycles
- hooking / Hooking to bean life cycles
- InitializingBean, implementing / Implementing InitializingBean and DisposableBean
- DisposableBean, implementing / Implementing InitializingBean and DisposableBean
- @PostConstruct, annotating on @Components / Annotating @PostConstruct and @PreDestroy on @Components
- @PreDestroy, annotating on @Components / Annotating @PostConstruct and @PreDestroy on @Components
- init-method and destroy-method attributes / The init-method and destroy-method attributes of <bean/>
- beans
- about / The Spring IoC container, Beans in detail
- definition / Bean definition
- instantiating / Instantiating beans
- instantiating, with constructors / With constructors
- instantiating, with static factory-method / With a static factory-method
- instantiating, with instance factory-method / With an instance factory-method
- cleaner bean definitions, with namespace shortcuts / Cleaner bean definitions with namespace shortcuts
- list, wiring as dependency / Wiring a List as a dependency
- map, wiring as dependency / Wiring a Map as a dependency
- dependencies, autowiring / Autowiring dependencies
- scoping / Bean scoping
- Broker channel / STOMP over WebSocket and the fallback option in Spring 4
- BSON (Binary JSON) format
- about / Spring Data MongoDB
C
- @ComponentScan annotation / Creating a simple WebSocket application
- @Configuration annotation / Creating a simple WebSocket application
- component stereotype annotations
- @Component / Component stereotype annotations
- @Service / Component stereotype annotations
- @Repository / Component stereotype annotations
- @Controller / Component stereotype annotations
- @RestController / Component stereotype annotations
- configuration metadata, Dependency Injection
- about / Configuration metadata
- XML-based configuration metadata / XML-based configuration metadata
- annotation-based configuration metadata / Annotation-based configuration metadata
- XML-based, versus annotation-based configuration / XML-based versus annotation-based configuration
- component stereotype annotations / Component stereotype annotations
- Java-based configuration metadata / Java-based configuration metadata
- JSR 330 standard annotations / JSR 330 standard annotations
- constructor-based DI
- container-level default init and destroy methods
- container-managed transactions (CMT)
- about / Relevance of Spring Transaction
- controllers
- about / Controllers in detail
- request URLs, mapping with @RequestMapping / Mapping request URLs with @RequestMapping
- URI template patterns, with @PathVariable annotation / URI template patterns with the @PathVariable annotation
- parameters, binding with @RequestParam annotation / Binding parameters with the @RequestParam annotation
- request handler method arguments / Request handler method arguments
- request handler method return types / Request handler method return types
- model attributes, setting / Setting Model attributes
- RESTful services, building for JSON and XML media / Building RESTful services for JSON and XML media
- RESTful service, building with RestController / Building a RESTful service with RestController
- cross-site request forgery (CSRF) attack
- about / Authentication
- custom scope
- creating / Creating a custom scope
D
- DAO support
- data access objects (DAOs) / XML-based configuration metadata
- DataSource
- configuring / Configuring DataSource
- reference / Configuring DataSource
- declarative transaction management
- about / Declarative transaction management
- proxy mode / Transactional modes – proxy and AspectJ
- AspectJ mode / Transactional modes – proxy and AspectJ
- transactional behavior, defining / Defining transactional behavior
- rollback rules, setting / Setting rollback rules
- Dependency Injection (DI) / The Spring Framework modules
- about / Dependency Injection
- Spring IoC container / The Spring IoC container
- configuration metadata / Configuration metadata
- Dependency Injection, with scoped beans
- development environment
- setting up / Setting up the development environment
- DispatcherServlet
- about / DispatcherServlet explained
- WebApplicationContext, using / WebApplicationContext – ApplicationContext for the Web
- supporting beans / Beans supporting DispatcherServlet and their roles
- beans supporting / Beans supporting DispatcherServlet and their roles
- domain objects and entities
- about / Domain objects and entities
- Query resolution methods / Query resolution methods
- @Query annotation, using / Using the @Query annotation
- Spring Data web support extensions / Spring Data web support extensions
- auditing, with Spring Data / Auditing with Spring Data
E
- @EnableAutoConfiguration annotation / Creating a simple WebSocket application
- embedded databases
- using / Using embedded databases
- Ember.js
- about / SPA frameworks, Introducing Ember.js
- Ember application
- anatomy / The anatomy of an Ember application
- router / Routers
- routes or route handlers / Routes or route handlers
- templates / Templates
- components / Components
- models / Models
- controllers / Controllers
- input helpers / Input helpers
- custom helpers / Custom helpers
- initializers / Initializers
- services / Services
- Ember CLI
- about / Introducing Ember.js, Working with Ember CLI
- working with / Working with Ember CLI
- features / Working with Ember CLI
- setting up / Setting up Ember CLI
- commands / Getting started with Ember CLI commands
- project structure / The Ember project structure
- POD structure / Working with the POD structure
- Ember CLI commands
- about / Getting started with Ember CLI commands
- ember / Getting started with Ember CLI commands
- ember new <appname> / Getting started with Ember CLI commands
- ember init / Getting started with Ember CLI commands
- ember build / Getting started with Ember CLI commands
- ember server (or serve) / Getting started with Ember CLI commands
- ember generate <generatortype> <name> <options> / Getting started with Ember CLI commands
- ember destroy <generatortype> <name> <options> / Getting started with Ember CLI commands
- ember test / Getting started with Ember CLI commands
- ember install <addon-name> / Getting started with Ember CLI commands
- Ember Data
- about / Introducing Ember.js
- data, persisting with / Persisting data with Ember Data
- DS.Model / Persisting data with Ember Data
- DS.Store / Persisting data with Ember Data
- DS.Adapter / Persisting data with Ember Data
- DS.Serializer / Persisting data with Ember Data
- architecture / Ember Data architecture
- models, building / Defining models
- model relationships, defining / Defining model relationships
- Ember development stack
- about / Introducing Ember.js
- Ember Inspector
- about / Introducing Ember.js
- Ember object model
- about / Understanding the Ember object model
- types (classes), declaring / Declaring types (classes) and instances
- instances, declaring / Declaring types (classes) and instances
- properties, accessing / Accessing and mutating properties
- properties, mutating / Accessing and mutating properties
- computed properties / Computed properties
- property observers / Property observers
- collections, working with / Working with collections
- Ember.Array / Working with collections
- Ember.ArrayProxy / Working with collections
- Ember.MutableArray / Working with collections
- Ember.Enumerable / Working with collections
- Ember.NativeArray / Working with collections
- enterprise integration (EAI)
- about / Spring subprojects
- Enterprise Java Beans (EJB)
- about / Relevance of Spring Transaction
- entities, OAuth2
- resource owner / The OAuth2 Authorization Framework
- client or third-party application / The OAuth2 Authorization Framework
- authorization server / The OAuth2 Authorization Framework
- resource server / The OAuth2 Authorization Framework
- exceptions
- handling, in Spring Data layer / Handling exceptions in the Spring Data layer
F
- fallback option
- Fastboot
- about / Introducing Ember.js
- file uploads
- handling / Handling file uploads
I
- IDE (Integrated Development Environment)
- about / Spring Tool Suite (STS)
- Inversion of Control (IoC) container / The Spring Framework modules
J
- Java Server Pages (JSP)
- about / Resolving JSP views
- Java Server Pages Tag Library (JSTL)
- about / Resolving JSP views
- JDBC operations
- with Sql* classes / JDBC operations with Sql* classes
- components / JDBC operations with Sql* classes
- JdbcTemplate
- methods / JdbcTemplate
- callback interfaces / JdbcTemplate
- NamedParameterJdbcTemplate / NamedParameterJdbcTemplate
- JPA (Java Persistence Architecture)
- about / Spring Data JPA
- JTA (Java Transaction API)
- about / Relevance of Spring Transaction
L
- Liquid Fire
- about / Introducing Ember.js
M
- Message Driven Beans (MDB)
- about / Relevance of Spring Transaction
- Model-View-Controller (MVC) architectural pattern
- about / Introducing Ember.js
- Model-View-Controller pattern
- about / The Model-View-Controller pattern
- Model / The Model-View-Controller pattern
- View / The Model-View-Controller pattern
- Controller / The Model-View-Controller pattern
N
- Node.js
- URL / Setting up Ember CLI
O
- OAuth2 Authorization Framework
- about / The OAuth2 Authorization Framework
- entities / The OAuth2 Authorization Framework
- Object Oriented Programming (OOP)
- about / Aspect Oriented Programming
- one thread per HTTP connection strategy / Asynchronous request processing in Spring MVC
P
- Plain Old Java Objects (POJOs)
- about / Domain objects and entities
- POD structure
- working with / Working with the POD structure
- pointcut designators (PCDs)
- about / Pointcut designators
- pointcuts, @AspectJ annotation
- about / Pointcuts
- designators / Pointcut designators
- examples / Pointcut examples
- POJO (Plain Old Java Objects) / Design concepts behind Spring Framework
- properties
- injecting, into Spring environment / Injecting properties into the Spring environment
- PropertyPlaceholderConfigurer
- about / Externalizing properties with PropertyPlaceholderConfigurer
- properties, externalizing with / Externalizing properties with PropertyPlaceholderConfigurer
Q
- query lookup strategies
- defining / Query resolution methods
R
- @Repository annotation
- ReactJS
- about / SPA frameworks
- REpresentational State Transfer (REST)
- Request channel / STOMP over WebSocket and the fallback option in Spring 4
- resources
- handling / Handling resources
- Response channel / STOMP over WebSocket and the fallback option in Spring 4
- routes
- handling / Handling routes
S
- Service classes / XML-based configuration metadata
- setter-based DI
- SimpleJdbc classes / SimpleJdbc classes
- simple WebSocket application
- creating / Creating a simple WebSocket application
- single-page application (SPA)
- motivations / The motivations behind SPAs
- about / SPAs explained
- architectural benefits / The architectural benefits of SPAs
- SPA frameworks
- about / SPA frameworks
- AngularJS / SPA frameworks
- ReactJS / SPA frameworks
- Ember.js / SPA frameworks
- SpEL (Spring Expression Language)
- about / Query resolution methods
- SpEL API
- about / The SpEL API
- interfaces and classes / The SpEL API
- Spring
- testing with / Testing with Spring
- Spring's JSF integration
- about / Spring's JSF integration
- Spring's Struts integration
- about / Spring's Struts integration
- spring-messaging module
- Spring AOP
- definition / Spring AOP – definition and configuration styles
- configuration styles / Spring AOP – definition and configuration styles
- Spring application
- about / Your first Spring application
- Inversion of Control (IoC) / Inversion of Control explained
- Spring Data
- about / Spring Data
- subprojects, defining / Spring Data
- Commons / Spring Data Commons
- repository specification / Spring Data repository specification
- MongoDB / Spring Data MongoDB
- domain objects and entities / Domain objects and entities
- Spring Transaction support / Spring Transaction support
- Spring Data Commons
- defining / Spring Data Commons
- Spring Data layer
- exceptions, handling / Handling exceptions in the Spring Data layer
- Spring Data MongoDB
- about / Spring Data MongoDB
- enabling / Enabling Spring Data MongoDB
- MongoRepository / MongoRepository
- Spring Data repository specification
- about / Spring Data repository specification
- Spring Data JPA / Spring Data JPA
- Spring Data JPA, enabling / Enabling Spring Data JPA
- JpaRepository / JpaRepository
- Spring Expression Language
- about / Spring Expression Language
- features / SpEL features
- annotation support / SpEL annotation support
- Spring forms
- composing, in JSP / Composing a form in JSP
- validating / Validating forms
- Spring form tag libraries
- Spring Framework
- design concepts / Design concepts behind Spring Framework
- Spring Framework modules
- about / The Spring Framework modules
- Spring IoC container
- about / The Spring IoC container
- Spring JDBC
- approaches / Spring JDBC abstraction
- Spring JDBC abstraction
- about / Spring JDBC abstraction
- JdbcTemplate / JdbcTemplate
- SimpleJdbc classes / SimpleJdbc classes
- Spring landscape
- about / The Spring landscape
- Spring Framework modules / The Spring Framework modules
- Spring Tool Suite (STS) / Spring Tool Suite (STS)
- Spring subprojects / Spring subprojects
- Spring MVC
- features / Features of Spring MVC
- architecture / The architecture and components of Spring MVC
- components / The architecture and components of Spring MVC
- asynchronous request processing / Asynchronous request processing in Spring MVC
- Spring MVC application
- creating / Your first Spring MVC application
- setting up / Setting up a Spring MVC application
- project structure / The project structure of a Spring MVC application
- web.xml file / The web.xml file – Springifying the web app
- web app, springifying / The web.xml file – Springifying the web app
- ApplicationContext files / ApplicationContext files in a Spring MVC application
- HomeController / HomeController – @Controller for the home screen
- home.jsp file / The home.jsp file – the landing screen
- incoming requests, handling / Handling incoming requests
- Spring subprojects
- about / Spring subprojects
- URL / Spring subprojects
- Spring Tool Suite (STS)
- Spring Transaction
- defining / Relevance of Spring Transaction, Spring Transaction fundamentals
- declarative transaction management / Declarative transaction management
- @Transactional annotation, using / Using the @Transactional annotation
- programmatic transaction management / Programmatic transaction management
- Sql* classes
- JDBC operations, defining with / JDBC operations with Sql* classes
- STOMP over WebSocket
- supporting beans, DispatcherServlet
- HandlerMapping / Beans supporting DispatcherServlet and their roles
- HandlerAdapter / Beans supporting DispatcherServlet and their roles
- HandlerExceptionResolver / Beans supporting DispatcherServlet and their roles
- ViewResolver / Beans supporting DispatcherServlet and their roles
- LocaleResolver / Beans supporting DispatcherServlet and their roles
- LocaleContextResolver / Beans supporting DispatcherServlet and their roles
- ThemeResolver / Beans supporting DispatcherServlet and their roles
- MultipartResolver / Beans supporting DispatcherServlet and their roles
- FlashMapManager / Beans supporting DispatcherServlet and their roles
T
- @Transactional annotation
- using / Using the @Transactional annotation
- transaction management, enabling for / Enabling transaction management for @Transactional
- Taskify application
- building / Building a Taskify application
- Taskify Ember app
- building / Building the Taskify Ember app
- Taskify, setting up as Ember CLI project / Setting up Taskify as an Ember CLI project
- Ember Data, setting up / Setting up Ember Data
- application routes, configuring / Configuring application routes
- home screen, building / Building the home screen
- user screen, building / Building the user screen
- custom helper, building / Building a custom helper
- action handlers, adding / Adding action handlers
- custom component, building / Building a custom component – modal window
- userEditModal, building with{{modal-window}} / Building userEditModal using {{modal-window}}
- task screen, building / Building the task screen
- Template Method
- about / JdbcTemplate
- terminology, Aspect Oriented Programing (AOP)
- aspect / AOP concepts and terminology
- join point / AOP concepts and terminology
- advice / AOP concepts and terminology
- pointcut / AOP concepts and terminology
- target object / AOP concepts and terminology
- weaving / AOP concepts and terminology
- introduction / AOP concepts and terminology
- test-driven development (TDD) / Testing with Spring
- testing framework
- about / Introducing Ember.js
- testing support, Spring
- mock objects / Mock objects
- unit and integration testing utilities / Unit and integration testing utilities
- Thymeleaf
- about / Resolving Thymeleaf views
- views, resolving / Resolving Thymeleaf views
- transaction
- about / Spring Transaction support
- transaction attributes
- defining / Spring Transaction fundamentals
U
- UI behavior
- handling, components used / Handling UI behavior using components
- ToggleButton component, building step by step / Building a ToggleButton component step by step
- UI templates, building with Handlebars
- about / Building UI templates using Handlebars
- Handlebars helpers / Handlebars helpers
- data binding, with input helpers / Data binding with input helpers
- control flow helpers, using in Handlebars / Using control flow helpers in Handlebars
- event helpers, using / Using event helpers
- Unified Expression Language (UEL) / Spring Expression Language
V
- view resolvers
- AbstractCachingViewResolver / Resolving views
- XmlViewResolver / Resolving views
- ResourceBundleViewResolver / Resolving views
- UrlBasedViewResolver / Resolving views
- InternalResourceViewResolver / Resolving views
- VelocityViewResolver / Resolving views
- FreeMarkerViewResolver / Resolving views
- JasperReportsViewResolver / Resolving views
- TilesViewResolver / Resolving views
- views
- working with / Working with views
- resolving / Resolving views
- JSP views, resolving / Resolving JSP views
- model attributes, binding in JSP pages / Binding Model attributes in JSP pages using JSTL
- view technologies, Spring MVC / More view technologies
W
- WebSocket application
- message, broadcasting to single user / Broadcasting a message to a single user in a WebSocket application
X
- XML schema based AOP
- about / XML schema-based AOP