Información del
Programa
Curso Gad-des03 Spring Framework
El curso de Spring Framework es una oportunidad para adquirir conocimientos y habilidades en el desarrollo de aplicaciones Java utilizando el popular framework Spring. El alumno explorará los fundamentos de Spring y aprenderá a construir aplicaciones robustas y escalables utilizando sus potentes características y herramientas. Esta formación prepara al estudiante para sumergirle en el mundo del desarrollo de software y descubrir cómo Spring puede impulsar sus proyectos hacia el éxito.
Temario
Modulo 2 – Introduction to Spring Framework
- Dependency Injection and Inversion of Control
- Modules
- Core Container
- Data Access/Integration
- Web
- AOP and Instrumentation
- Test
- Usage scenarios
- Dependency Management and Naming Conventions
- Logging
- Not Using Commons Logging
- Using SLF4J
- Using Log4J
Modulo 3 – What’s New in Spring 3.0
- New Features and Enhancements in Spring 3.0
- Java 5
- Improved documentation
- New module organization and build system
- Overview of new features
- Core APIs updated for Java 5
- Spring Expression Language
- The Inversion of Control (IoC) container
- Java based bean metadata
- Defining bean metadata within components
- General purpose type conversion system and field formatting system
- The Data Tier
- The Web Tier
- Comprehensive REST support
- @MVC additions
- Declarative model validation
- Early support for Java EE 6
- Support for embedded databases
Modulo 4 – Core Technologies
- The IoC container
- Introduction to the Spring IoC container and beans
- Bean overview
- Dependencies
- 3.4.1. Dependency injection
- 3.4.2. Dependencies and configuration in detail
- 3.4.3. Using depends-on
- 3.4.4. Lazy-initialized beans
- 3.4.5. Autowiring collaborators
- 3.4.6. Method injection
- 3.4.6.1. Lookup method injection
- 3.4.6.2. Arbitrary method replacement
- Bean scopes
- 3.5.1. The singleton scope
- 3.5.2. The prototype scope
- 3.5.3. Singleton beans with prototype-bean dependencies
- 3.5.4. Request, session, and global session scopes
- 3.5.5. Custom scopes
- Customizing the nature of a bean
- 3.6.1. Lifecycle callbacks
- 3.6.2. ApplicationContextAware and BeanNameAware
- 3.6.3. Other Aware interfaces
- Bean definition inheritance
- Container extension points
- Annotation-based container configuration
- Classpath scanning and managed components
- Java-based container configuration
- Registering a LoadTimeWeaver
- Additional Capabilities of the ApplicationContext
- The BeanFactory
- Resources
- Introduction
- The Resource interface
- Built-in Resource implementations
- The ResourceLoader
- The ResourceLoaderAware interface
- Resources as dependencies
- Application contexts and Resource paths
- Validation, Data Binding, and Type Conversion
- Introduction
- Validation using Spring’s Validator interface
- Resolving codes to error messages
- Bean manipulation and the BeanWrapper
- Spring 3 Type Conversion
- Spring 3 Field Formatting
- Spring 3 Validation
- Spring Expression Language (SpEL)
- Introduction
- Feature Overview
- Expression Evaluation using Spring’s Expression Interface
- The EvaluationContext interface
- Type Conversion
- The EvaluationContext interface
- Expression support for defining bean definitions
- XML based configuration
- Annotation-based configuration
- Language Reference
- Literal expressions
- Properties, Arrays, Lists, Maps, Indexers
- Inline lists
- Array construction
- Methods
- Operators
- Relational operators
- Logical operators
- Mathematical operators
- Assignment
- Types
- Constructors
- Variables
- The #this and #root variables
- Functions
- Bean references
- Ternary Operator (If-Then-Else)
- The Elvis Operator
- Safe Navigation operator
- Collection Selection
- Collection Projection
- Expression templating
- Classes used in the examples
- Aspect Oriented Programming with Spring
- Introduction
- AOP concepts
- Spring AOP capabilities and goals
- AOP Proxies
- @AspectJ support
- Enabling @AspectJ Support
- Declaring an aspect
- Declaring a pointcut
- Declaring advice
- Schema-based AOP support
- Declaring an aspect
- Declaring a pointcut
- Declaring advice
- Introductions
- Aspect instantiation models
- Advisors
- Choosing which AOP declaration style to use
- Spring AOP or full AspectJ?
- @AspectJ or XML for Spring AOP?
- Mixing aspect types
- Proxying mechanisms
- Understanding AOP proxies
- Programmatic creation of @AspectJ Proxies
- Using AspectJ with Spring applications
- Using AspectJ to dependency inject domain objects with Spring
- Other Spring aspects for AspectJ
- Configuring AspectJ aspects using Spring IoC
- Load-time weaving with AspectJ in the Spring Framework
- Further Resources
- Introduction
- Spring AOP APIs
- Introduction
- Pointcut API in Spring
- Concepts
- Operations on pointcuts
- AspectJ expression pointcuts
- Convenience pointcut implementations
- Advice API in Spring
- Advice lifecycles
- Advice types in Spring
- Advisor API in Spring
- Using the ProxyFactoryBean to create AOP proxies
- Basics
- JavaBean properties
- JDK- and CGLIB-based proxies
- Proxying interfaces
- Proxying classes
- Using ‘global’ advisors
- Concise proxy definitions
- Creating AOP proxies programmatically with the ProxyFactory
- Manipulating advised objects
- Using the «autoproxy» facility
- Using TargetSources
- Defining new Advice types
- Further resources
- Testing
- Introduction to testing
- Unit testing
- Mock objects
- Unit testing support classes
- Integration testing
- Overview
- Goals of integration testing
- JDBC testing support
- Annotations
- Spring TestContext Framework
- PetClinic example
- Further Resources
Modulo 5 – Data Access
- Transaction Management
- Introduction to Spring Framework transaction management
- Advantages of the Spring Framework’s transaction support model
- Understanding the Spring Framework transaction abstraction
- Synchronizing resources with transactions
- Declarative transaction management
- Programmatic transaction management
- Choosing between programmatic and declarative transaction management
- Application server-specific integration
- Solutions to common problems
- DAO support
- Introduction
- Consistent exception hierarchy
- Annotations used for configuring DAO or Repository classes
- Data access with JDBC
- Introduction to Spring Framework JDBC
- Using the JDBC core classes to control basic JDBC processing and error handling
- Controlling database connections
- JDBC batch operations
- Simplifying JDBC operations with the SimpleJdbc classes
- Modeling JDBC operations as Java objects
- Common problems with parameter and data value handling
- Embedded database support
- Why use an embedded database?
- Creating an embedded database instance using Spring XML
- Creating an embedded database instance programmatically
- Extending the embedded database support
- Using HSQL
- Using H2
- Using Derby
- Initializing a DataSource
- Object Relational Mapping (ORM) Data Access
- Introduction to ORM with Spring
- General ORM integration considerations
- Hibernate
- SessionFactory setup in a Spring container
- Implementing DAOs based on plain Hibernate 3 API
- Declarative transaction demarcation
- Programmatic transaction demarcation
- Transaction management strategies
- Comparing container-managed and locally defined resources
- Spurious application server warnings with Hibernate
- JDO
- PersistenceManagerFactory setup
- Implementing DAOs based on the plain JDO API
- Transaction management
- JdoDialect
- JPA
- Three options for JPA setup in a Spring environment
- LocalEntityManagerFactoryBean
- Obtaining an EntityManagerFactory from JNDI
- LocalContainerEntityManagerFactoryBean
- Dealing with multiple persistence units
- Implementing DAOs based on plain JPA
- Transaction Management
- JpaDialect
- Three options for JPA setup in a Spring environment
- iBATIS SQL Maps
- Setting up the SqlMapClient
- Using SqlMapClientTemplate and SqlMapClientDaoSupport
- Implementing DAOs based on plain iBATIS API
- Marshalling XML using O/X Mappers
- Introduction
- Marshaller and Unmarshaller
- Marshaller
- Unmarshaller
- XmlMappingException
- Using Marshaller and Unmarshaller
- XML Schema-based Configuration
- JAXB
- Jaxb2Marshaller
- XML Schema-based Configuration
- Jaxb2Marshaller
- Castor
- CastorMarshaller
- Mapping
- XMLBeans
- XmlBeansMarshaller
- XML Schema-based Configuration
- XmlBeansMarshaller
- JiBX
- JibxMarshaller
- XML Schema-based Configuration
- JibxMarshaller
- XStream
- XStreamMarshaller
- V. The Web
- Web MVC framework
- Introduction to Spring Web MVC framework
- Features of Spring Web MVC
- Pluggability of other MVC implementations
- The DispatcherServlet
- Implementing Controllers
- Defining a controller with @Controller
- Mapping requests with @RequestMapping
- Handler mappings
- Intercepting requests – the HandlerInterceptor interface
- Resolving views
- Resolving views with the ViewResolver interface
- Chaining ViewResolvers
- Redirecting to views
- ContentNegotiatingViewResolver
- Using locales
- Using themes
- Spring’s multipart (fileupload) support
- Introduction
- Using the MultipartResolver
- Handling a file upload in a form
- Handling exceptions
- HandlerExceptionResolver
- @ExceptionHandler
- Convention over configuration support
- ETag support
- Configuring Spring MVC
- More Spring Web MVC Resources
- Introduction to Spring Web MVC framework
- View technologies
- Introduction
- JSP & JSTL
- Tiles
- Dependencies
- How to integrate Tiles
- Velocity & FreeMarker
- Dependencies
- Context configuration
- Creating templates
- Advanced configuration
- Bind support and form handling
- XSLT
- Introduction
- Bean definitions
- Standard MVC controller code
- Convert the model data to XML
- Defining the view properties
- Document transformation
- Introduction
- Document views (PDF/Excel)
- Introduction
- Configuration and setup
- Document view definitions
- Controller code
- Subclassing for Excel views
- Subclassing for PDF views
- JasperReports
- Dependencies
- Configuration
- Configuring the ViewResolver
- Configuring the Views
- About Report Files
- Using JasperReportsMultiFormatView
- Populating the ModelAndView
- Working with Sub-Reports
- Configuring Exporter Parameters
- Feed Views
- XML Marshalling View
- JSON Mapping View
- Integrating with other web frameworks
- Introduction
- Common configuration
- JavaServer Faces 1.1 and 1.2
- DelegatingVariableResolver (JSF 1.1/1.2)
- SpringBeanVariableResolver (JSF 1.1/1.2)
- SpringBeanFacesELResolver (JSF 1.2+)
- FacesContextUtils
- Apache Struts 1.x and 2.x
- ContextLoaderPlugin
- DelegatingRequestProcessor
- DelegatingActionProxy
- ActionSupport Classes
- ContextLoaderPlugin
- WebWork 2.x
- Tapestry 3.x and 4.x
- Injecting Spring-managed beans
- Further Resources
- Portlet MVC Framework
- Introduction
- Controllers – The C in MVC
- Views – The V in MVC
- Web-scoped beans
- The DispatcherPortlet
- The ViewRendererServlet
- Controllers
- Handler mappings
- Introduction
- 18.8. Handling exceptions
- 18.9. Annotation-based controller configuration
- 18.10. Portlet application deployment
Modulo 6 – Integration
- Remoting and web services using Spring
- Introduction
- Exposing services using RMI
- Using Hessian or Burlap to remotely call services via HTTP
- Exposing services using HTTP invokers
- Web services
- Exposing servlet-based web services using JAX-RPC
- Accessing web services using JAX-RPC
- Registering JAX-RPC Bean Mappings
- Registering your own JAX-RPC Handler
- Exposing servlet-based web services using JAX-WS
- Exporting standalone web services using JAX-WS
- Exporting web services using the JAX-WS RI’s Spring support
- Accessing web services using JAX-WS
- JMS
- Server-side configuration
- Client-side configuration
- Auto-detection is not implemented for remote interfaces
- Accessing RESTful services on the Client
- RestTemplate
- HTTP Message Conversion
- Enterprise JavaBeans (EJB) integration
- Introduction
- Accessing EJBs
- Concepts
- Accessing local SLSBs
- Accessing remote SLSBs
- Accessing EJB 2.x SLSBs versus EJB 3 SLSBs
- Using Spring’s EJB implementation support classes
- EJB 2.x base classes
- EJB 3 injection interceptor
- JMS (Java Message Service)
- Introduction
- Using Spring JMS
- JmsTemplate
- Connections
- Destination Management
- Message Listener Containers
- Transaction management
- Sending a Message
- Receiving a message
- Support for JCA Message Endpoints
- JMS Namespace Support
- JMX
- Introduction
- Exporting your beans to JMX
- Creating an MBeanServer
- Reusing an existing MBeanServer
- Lazy-initialized MBeans
- Automatic registration of MBeans
- Controlling the registration behavior
- Controlling the management interface of your beans
- Controlling the ObjectNames for your beans
- JSR-160 Connectors
- Server-side Connectors
- Client-side Connectors
- JMX over Burlap/Hessian/SOAP
- Accessing MBeans via Proxies
- Notifications
- Registering Listeners for Notifications
- Publishing Notifications
- Further Resources
- JCA CCI
- Introduction
- Configuring CCI
- Using Spring’s CCI access support
- Modeling CCI access as operation objects
- Transactions
- Email
- Introduction
- Usage
- Using the JavaMail MimeMessageHelper
- Task Execution and Scheduling
- Introduction
- The Spring TaskExecutor abstraction
- The Spring TaskScheduler abstraction
- The Task Namespace
- Annotation Support for Scheduling and Asynchronous Execution
- Using the OpenSymphony Quartz Scheduler
- Using JDK Timer support
- Dynamic language support
- Introduction
- Defining beans that are backed by dynamic languages
- Scenarios
- Scripted Spring MVC Controllers
- Scripted Validators
- Bits and bobs
