FORMACIÓN OFICIAL MICROSOFT | CURSOS EN MADRID


GAD-DES03 Curso de Spring Framework

Duración: 25 horas

Curso de 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.


Inicio / Cursos / Cursos Propios de Gadesoft / GAD-DES03 Curso de Spring Framework

Requisitos Previos

No existen requisitos previos para cursar esta formación

Modalidad formativa

  • Presencial en Gadesoft: Madrid o Barcelona.
  • Presencial en cliente: En sus instalaciones. Toda la península.
  • Online Direct: Mediante herramientas de videoconferencia (Microsoft Teams), en directo con el instructor. Pantalla compartida, interacción, seguimiento total.

Objetivos

Lograr un conocimiento profundo de Spring

Contenidos

Para el curso de Spring entregaremos material de apoyo y diapositivas.

Fechas

Próximas fechas de convocatoria para el curso:

  • 17 de junio de 2024
  • 1 de julio de 2024

Certificación

El curso Spring no prepara para ninguna certificación.

TEMARIO

Overview of Spring Framework

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

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

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
    • 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
  • 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

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
    • 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
    • Castor
      • CastorMarshaller
      • Mapping
    • XMLBeans
      • XmlBeansMarshaller
        • XML Schema-based Configuration
    • JiBX
      • JibxMarshaller
        • XML Schema-based Configuration
    • 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
  • 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
    • 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
    • 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
  • 18.8. Handling exceptions
  • 18.9. Annotation-based controller configuration
  • 18.10. Portlet application deployment

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
Ponte en contacto con nosotros