Curso [2-12-1] Spring Framework Parte 1 - En línea

Comentarios sobre Curso [2-12-1] Spring Framework Parte 1 - Online

• Contenido
      I. Visión general de Spring Framework
          1. Introducción a Spring Framework
              1.1. Inyección de dependencia y Inversión de Control
              1.2. Módulos
                  1.2.1. Core Container
                  1.2.2. Acceso a datos / Integración
                  1.2.3. Web
                  1.2.4. AOP e Instrumentación
                  1.2.5. Prueba
              1.3. Escenarios de uso
                  1.3.1. Dependencia de Gestión y Convenciones de nomenclatura
                      1.3.1.1. Primavera Dependencias y dependiendo de Primavera
                      1.3.1.2. Maven Dependencia de Gestión
                      1.3.1.3. Ivy Dependencia de Gestión
                  1.3.2. Inicio de sesión
                      1.3.2.1. No utilizar Commons Logging
                      1.3.2.2. Usando SLF4J
                      1.3.2.3. Usando Log4J
      II. ¿Qué hay de nuevo en Spring 3
          2. Nuevas características y mejoras en Spring 3.0
              2.1. Java 5
              2.2. Documentación mejorada
              2.3. Nuevos artículos y tutoriales
              2.4. Nuevo módulo de organización y sistema de construcción
              2.5. Descripción de las características nuevas
                  2.5.1. Core API actualizada para Java 5
                  2.5.2. Spring Expression Language
                  2.5.3. La inversión de control (IoC) contenedor
                      2.5.3.1. Java bean metadatos basados ​​en
                      2.5.3.2. Definición de metadatos de frijol dentro de los componentes
                  2.5.4. Tipo de propósito general y un sistema de conversión del sistema de formato de campo
                  2.5.5. El nivel de datos
                  2.5.6. El nivel Web
                      2.5.6.1. Soporte de apoyo integral
                      2.5.6.2. @ MVC adiciones
                  2.5.7. Validación del modelo declarativo
                  2.5.8. Apoyo temprano para Java EE 6
                  2.5.9. Soporte para bases de datos integradas
          3. Nuevas características y mejoras en Spring 3.1
              3.1. Descripción de las características nuevas
                  3.1.1. Caché de abstracción
                  3.1.2. Definición de frijol perfiles
                  3.1.3. Medio Ambiente Abstracción
                  3.1.4. Abstracción PropertySource
                  3.1.5. Equivalentes de código para espacios de nombres XML de Spring
                  3.1.6. Soporte para Hibernate 4.x
                  3.1.7. TestContext marco de apoyo para las clases de configuración y los perfiles de frijol @ definición
                  3.1.8. c: namespace para más concisa inyección de constructor
                  3.1.9. Apoyo a la inyección contra no estándar JavaBeans setters
                  3.1.10. Soporte para servlets 3 Código de configuración basada en Contenedor Servlet
                  3.1.11. Soporte para servlets 3 MultipartResolver
                  3.1.12. JPA EntityManagerFactory bootstrapping sin persistence.xml
                  3.1.13. Nuevos HandlerMethod basados ​​en clases de apoyo para el procesamiento de Controlador anotado
                  3.1.14. "Consume" y "produce" las condiciones en @ RequestMapping
                  3.1.15. Flash de atributos y RedirectAttributes
                  3.1.16. Mejoras en la plantilla URI variables
                  3.1.17. @ @ Los argumentos válidos sobre Método RequestBody Controlador
                  3.1.18. @ Anotación RequestPart sobre los argumentos de método de control
                  3.1.19. UriComponentsBuilder y UriComponents
      III. Core Technologies
          4. El contenedor IoC
              4.1. Introducción al contenedor de Spring IoC y frijoles
              4.2. Contenedor visión general
                  4.2.1. Configuración de metadatos
                  4.2.2. Crear instancias de un contenedor
                      4.2.2.1. Composición de metadatos basado en XML de configuración
                  4.2.3. Uso del contenedor
              4.3. Frijol visión general
                  4.3.1. Frijoles de nombres
                      4.3.1.1. Aliasing un grano fuera de la definición de frijol
                  4.3.2. Frijoles Instanciación
                      4.3.2.1. De instancias con un constructor
                      4.3.2.2. De instancias con un método estático de fábrica
                      4.3.2.3. Instanciación utilizando un método de fábrica instancia
              4.4. Dependencias
                  4.4.1. Inyección de dependencia
                      4.4.1.1. Constructor basado en la inyección de dependencia
                      4.4.1.2. Setter basado en la inyección de dependencia
                      4.4.1.3. Dependencia proceso de resolución
                      4.4.1.4. Ejemplos de inyección de dependencias
                  4.4.2. Dependencias y configuración en detalle
                      4.4.2.1. Valores rectos (primitivos. cadenas. etc)
                      4.4.2.2. Las referencias a otros beans (colaboradores)
                      4.4.2.3. Frijoles interiores
                      4.4.2.4. Colecciones
                      4.4.2.5. Nulos y los valores de cadena vacía
                      4.4.2.6. Atajo XML con el p-namespace
                      4.4.2.7. Atajo XML con espacio de nombres c-
                      4.4.2.8. Nombres compuestos de propiedad
                  4.4.3. El uso depende. en
                  4.4.4. Lazy-inicializadas frijoles
                  4.4.5. Colaboradores autowiring
                      4.4.5.1. Limitaciones y desventajas de autoconexión
                      4.4.5.2. La exclusión de un bean de autowiring
                  4.4.6. Método de inyección
                      4.4.6.1. Lookup inyección método
                      4.4.6.2. Método de sustitución arbitraria
              4.5. Frijol ámbitos
                  4.5.1. El alcance singleton
                  4.5.2. El alcance prototipo
                  4.5.3. Singleton con frijoles prototipo de frijol dependencias
                  4.5.4. Solicitar. sesión y sesión global ámbitos
                      4.5.4.1. Configuración web inicial
                      4.5.4.2. Solicitud de alcance
                      4.5.4.3. Sesión alcance
                      4.5.4.4. Ámbito de sesión global
                      4.5.4.5. Frijoles con ámbito como dependencias
                  4.5.5. Custom ámbitos
                      4.5.5.1. La creación de un ámbito personalizado
                      4.5.5.2. El uso de un ámbito personalizado
              4.6. Personalización de la naturaleza de un grano
                  4.6.1. Devoluciones de llamada de ciclo de vida
                      4.6.1.1. Devoluciones de llamada de inicialización
                      4.6.1.2. Callbacks Destrucción
                      4.6.1.3. Predeterminado de inicialización y destruir métodos
                      4.6.1.4. La combinación de los mecanismos del ciclo de vida
                      4.6.1.5. Inicio y cierre de devoluciones de llamada
                      4.6.1.6. Apagado del contenedor de IoC Primavera con gracia en aplicaciones no web
                  4.6.2. ApplicationContextAware y BeanNameAware
                  4.6.3. Otras interfaces Aware
              4.7. Frijol definición herencia
              4.8. Puntos contenedor de extensión
                  4.8.1. Personalización de los frijoles con un BeanPostProcessor
                      4.8.1.1. Ejemplo: Hola a todos. BeanPostProcessor de estilo
                      4.8.1.2. Ejemplo: El RequiredAnnotationBeanPostProcessor
                  4.8.2. Personalización de metadatos de configuración con un BeanFactoryPostProcessor
                      4.8.2.1. Ejemplo: la PropertyPlaceholderConfigurer
                      4.8.2.2. Ejemplo: la PropertyOverrideConfigurer
                  4.8.3. Personalización de la lógica de instancias con una FactoryBean
              4.9. Anotación basada en contenedor de configuración
                  4.9.1. @ Required
                  4.9.2. @ Autoconectados
                  4.9.3. Ajuste de anotación basado autowiring con los calificadores
                  4.9.4. CustomAutowireConfigurer
                  4.9.5. @ Resource
                  4.9.6. @ PostConstruct y PreDestroy @
              4.10. Exploración Classpath y componentes administrados
                  4.10.1. @ Component y anotaciones posteriores estereotipo
                  4.10.2. La detección automática de clases y el registro de las definiciones de frijol
                  4.10.3. Uso de filtros para personalizar la exploración
                  4.10.4. Definición de metadatos de frijol dentro de los componentes
                  4.10.5. Nombrar los componentes detectados automáticamente
                  4.10.6. Proporcionar un espacio para componentes autodetectadas
                  4.10.7. Proporcionar metadatos calificador con anotaciones
              4.11. Utilizando Anotaciones JSR 330 estándar
                  4.11.1. Inyección de Dependencia con @ Inject y con nombre @
                  4.11.2. @ Named: una norma equivalente a la anotación @ Component
                  4.11.3. Limitaciones del enfoque estándar
              4.12. Basado en Java contenedor de configuración
                  4.12.1. Conceptos básicos: Configuración y Bean @ @
                  4.12.2. Instanciar el contenedor Spring usando AnnotationConfigApplicationContext
                      4.12.2.1. Construcción simple
                      4.12.2.2. La construcción del contenedor mediante programación con registro (Class <?> ...)
                      4.12.2.3. Habilitación componente de exploración con escáner (String. ..)
                      4.12.2.4. Soporte para aplicaciones web con AnnotationConfigWebApplicationContext
                  4.12.3. Redacción basadas en Java configuraciones
                      4.12.3.1. Con la anotación @ Import
                      4.12.3.2. La combinación de Java y XML de configuración
                  4.12.4. Uso de la anotación @ Frijol
                      4.12.4.1. Declarar un bean
                      4.12.4.2. Inyección de dependencias
                      4.12.4.3. Recepción de las devoluciones de llamada de ciclo de vida
                      4.12.4.4. Especificación del ámbito de frijol
                      4.12.4.5. Personalización de frijol de nomenclatura
                      4.12.4.6. Frijol aliasing
                  4.12.5. Para más información acerca de cómo la configuración basada en Java funciona internamente
              4.13. Registro de una LoadTimeWeaver
              4.14. Capacidades adicionales de la ApplicationContext
                  4.14.1. Internacionalización mediante MessageSource
                  4.14.2. Eventos estándar y personalizados
                  4.14.3. La facilidad de acceso a bajo nivel de recursos
                  4.14.4. Conveniente instancia ApplicationContext para aplicaciones web
                  4.14.5. Implementación de un ApplicationContext primavera como un archivo RAR J2EE
              4.15. El BeanFactory
                  4.15.1. BeanFactory o ApplicationContext?
                  4.15.2. Pegue el código y el mal singleton
          5. Recursos
              5.1. Introducción
                  5.2. La interfaz de Recursos
                  5.3. Construido en implementaciones de recursos
                      5.3.1. UrlResource
                      5.3.2. ClassPathResource
                      5.3.3. FileSystemResource
                      5.3.4. ServletContextResource
                      5.3.5. InputStreamResource
                      5.3.6. ByteArrayResource
                  5.4. El ResourceLoader
                  5.5. La interfaz ResourceLoaderAware
                  5.6. Recursos como dependencias
                  5.7. Contextos de aplicación y caminos de recursos
                      5.7.1. La construcción de contextos de aplicación
                          5.7.1.1. Construir instancias ClassPathXmlApplicationContext - atajos
                      5.7.2. Los comodines en las rutas de aplicaciones contextuales recursos constructor
                          5.7.2.1. Estilo Ant-Patrones
                          5.7.2.2. El * classpath: prefijo
                          5.7.2.3. Otras notas relacionadas con comodines
                      5.7.3. Advertencias FileSystemResource
          6. Validación. enlace de datos y el tipo de conversión
              6.1. Introducción
              6.2. Validación mediante la interfaz Validator Primavera
              6.3. La resolución de los códigos de mensajes de error
              6.4. Frijol manipulación y el BeanWrapper
                  6.4.1. Establecer y obtener propiedades básicas y anidados
                  6.4.2. Construido en implementaciones PropertyEditor
                      6.4.2.1. Registro adicionales PropertyEditors personalizados
              6.5. Spring 3 Tipo de conversión
                  6.5.1. Convertidor de SPI
                  6.5.2. ConverterFactory
                  6.5.3. GenericConverter
                      6.5.3.1. ConditionalGenericConverter
                  6.5.4. ConversionService API
                  6.5.5. Configuración de un ConversionService
                  6.5.6. El uso de un ConversionService programáticamente
              6.6. Spring 3 Campo de formato
                  6.6.1. Formatter SPI
                  6.6.2. Anotación basada formato
                      6.6.2.1. Formato API anotación
                  6.6.3. FormatterRegistry SPI
                  6.6.4. FormatterRegistrar SPI
                  6.6.5. Configuración de formato en Spring MVC
              6.7. Spring 3 Validación
                  6.7.1. Visión general de la API JSR-303 Frijol de validación
                  6.7.2. Configuración de una aplicación Bean Validation
                      6.7.2.1. La inyección de un validador
                      6.7.2.2. Configuración de restricciones personalizadas
                      6.7.2.3. Opciones de configuración adicionales
                  6.7.3. Configuración de un DataBinder
                  6.7.4. Spring MVC 3 Validación
                      6.7.4.1. Disparo @ validación de entrada del controlador
                  6.7.4.2. Configuración de un validador para el uso de Spring MVC
                      6.7.4.3. Configuración de un validador de JSR-303 para el uso de Spring MVC
          7. Spring Expression Language (SPEL)
              7.1. Introducción
              7.2. Descripción general de características
              7.3. Evaluación de expresiones con la interfaz de Spring Expresión
                  7.3.1. La interfaz EvaluationContext
                      7.3.1.1. Conversión de tipos
              7.4. Expresión de apoyo para definir las definiciones de frijol
                  7.4.1. Configuración basada en XML
                  7.4.2. Anotación de configuración basada en
              7.5. Referencia del lenguaje
                  7.5.1. Expresiones literales
                  7.5.2. Propiedades. matrices. listas. mapas. indizadores
                  7.5.3. Listas Inline
                  7.5.4. Matriz construcción
                  7.5.5. Métodos
                  7.5.6. Operadores
                      7.5.6.1. Los operadores relacionales
                      7.5.6.2. Los operadores lógicos
                      7.5.6.3. Los operadores matemáticos
                  7.5.7. Asignación
                  7.5.8. Tipos
                  7.5.9. Constructores
                  7.5.10. Variables
                      7.5.10.1. Las variables de raíz y # # esto
                  7.5.11. Funciones
                  7.5.12. Referencias de frijol
                  7.5.13. Ternario del operador (If-Then-Else)
                  7.5.14. El Operador Elvis
                  7.5.15. Operador navegación segura
                  7.5.16. Colección de Selección
                  7.5.17. Colección de proyección
                  7.5.18. Expresión de plantillas
              7.6. Clases utilizadas en los ejemplos
          8. Programación Orientada a Aspectos con Spring
              8.1. Introducción
                  8.1.1. AOP conceptos
                  8.1.2. Spring AOP capacidades y objetivos
                  8.1.3. AOP Proxies
              8.2. @ AspectJ apoyo
                  8.2.1. Habilitación @ Soporte AspectJ
                  8.2.2. Declarar un aspecto
                  8.2.3. La declaración de un punto de corte
                      8.2.3.1. Compatibles Designadores pointcut
                      8.2.3.2. Combinando las expresiones pointcut
                      8.2.3.3. Compartiendo definiciones comunes pointcut
                      8.2.3.4. Ejemplos
                      8.2.3.5. Escribir buenos puntos de corte
                  8.2.4. La declaración de asesoramiento
                      8.2.4.1. Antes de asesoramiento
                      8.2.4.2. Después de regresar asesoramiento
                      8.2.4.3. Después de lanzar asesoramiento
                      8.2.4.4. Después (por fin) el asesoramiento
                      8.2.4.5. Alrededor de asesoramiento
                      8.2.4.6. Consejos parámetros
                      8.2.4.7. Consejos de pedido
                      8.2.5. Presentaciones
                  8.2.6. Los modelos de instancias de aspecto
                  8.2.7. Ejemplo
              8.3. Esquema basado en AOP apoyo
                  8.3.1. Declarar un aspecto
                  8.3.2. La declaración de un punto de corte
                  8.3.3. La declaración de asesoramiento
                      8.3.3.1. Antes de asesoramiento
                      8.3.3.2. Después de regresar asesoramiento
                      8.3.3.3. Después de lanzar asesoramiento
                      8.3.3.4. Después (por fin) el asesoramiento
                      8.3.3.5. Alrededor de asesoramiento
                      8.3.3.6. Consejos parámetros
                      8.3.3.7. Consejos de pedido
                  8.3.4. Presentaciones
                  8.3.5. Los modelos de instancias de aspecto
                  8.3.6. Asesores
                  8.3.7. Ejemplo
              8.4. Elegir qué tipo de declaración a utilizar AOP
                  8.4.1. Spring AOP o AspectJ completo?
                  8.4.2. @ AspectJ o XML para Spring AOP?
              8.5. Mezclar tipos de aspecto
              8.6. Mecanismos Proxying
                  8.6.1. Entender proxies AOP
              8.7. Creación programática de los Proxies @ AspectJ
              8.8. Usando AspectJ con aplicaciones de primavera
                  8.8.1. Usando AspectJ a la dependencia inyectar objetos de dominio con la primavera
                      8.8.1.1. Las pruebas unitarias @ objetos configurables
                      8.8.1.2. Trabajar con múltiples contextos de aplicación
                  8.8.2. Otros aspectos de primavera para AspectJ
                  8.8.3. Configuración de los aspectos AspectJ utilizando Spring COI
                  8.8.4. Carga en tiempo tejiendo con AspectJ en el Spring Framework
                      8.8.4.1. Un ejemplo primero
                      8.8.4.2. Aspectos
                      8.8.4.3. 'META-INF/aop.xml'
                      8.8.4.4. Bibliotecas necesarias (JARS)
                      8.8.4.5. Primavera configuración
                      8.8.4.6. Medio Ambiente configuración específica
              8.9. Recursos adicionales
          9. Spring AOP APIs
              9.1. Introducción
              9.2. Pointcut API en la primavera
                  9.2.1. Conceptos
                  9.2.2. Las operaciones en puntos de corte
                  9.2.3. AspectJ expresión de puntos de corte
                  9.2.4. Implementaciones de Conveniencia pointcut
                      9.2.4.1. Puntos de corte estático
                      9.2.4.2. Puntos de corte dinámico
                  9.2.5. Superclases pointcut
                  9.2.6. Puntos de corte personalizados
              9.3. Consejos de API en la primavera
                  9.3.1. Ciclos de vida de Asesoramiento
                  9.3.2. Tipos de asesoramiento en primavera
                      9.3.2.1. Interceptación alrededor asesoramiento
                      9.3.2.2. Antes de asesoramiento
                      9.3.2.3. Emite consejo
                      9.3.2.4. Después de regresar asesoramiento
                      9.3.2.5. Introducción consejo
              9.4. Asesor de Programas en la primavera
              9.5. Uso de la ProxyFactoryBean para crear proxies AOP
                  9.5.1. Lo esencial
                  9.5.2. JavaBean propiedades
                  9.5.3. JDK-y CGLIB proxies basados ​​en
                  9.5.4. Interfaces de conexiones proxy
                  9.5.5. Clases de conexiones proxy
                  9.5.6. Usando "globales" asesores
              9.6. Definiciones concisas de proxy
              9.7. La creación de proxies AOP mediante programación con el ProxyFactory
              9.8. Manipulación de objetos asesorados
              9.9. Uso de la "autoproxy" instalación
                  9.9.1. AutoProxy frijol definiciones
                      9.9.1.1. BeanNameAutoProxyCreator
                      9.9.1.2. DefaultAdvisorAutoProxyCreator
                      9.9.1.3. AbstractAdvisorAutoProxyCreator
                  9.9.2. El uso de metadatos basada en auto-proxy
              9.10. Usando TargetSources
                  9.10.1. Hot swappable fuentes de destino
                  9.10.2. La combinación de fuentes de destino
                  9.10.3. Fuentes prototipo de destino
                  9.10.4. Fuentes ThreadLocal objetivo
              9.11. Definición de nuevos tipos de Asesoramiento
              9.12. Otros recursos
          10. Pruebas
              10.1. Introducción a las pruebas de primavera
              10.2. Pruebas unitarias
                  10.2.1. Mock Objects
                      10.2.1.1. JNDI
                      10.2.1.2. Servlet API
                      10.2.1.3. Portlet API
                  10.2.2. Unidad de apoyo a las clases de prueba
                      10.2.2.1. Utilidades Generales
                      10.2.2.2. Spring MVC
              10.3. Pruebas de Integración
                  10.3.1. Visión de conjunto
                  10.3.2. Objetivos de las Pruebas de Integración
                      10.3.2.1. Contexto y almacenamiento en caché
                      10.3.2.2. Inyección de Dependencia de accesorios de prueba
                      10.3.2.3. Gestión de transacciones
                      10.3.2.4. Las clases de apoyo para las pruebas de integración
              10.3.3. JDBC Soporte Pruebas
              10.3.4. Anotaciones
                  10.3.4.1. Anotaciones Primavera Pruebas
                  10.3.4.2. Soporte de anotación estándar
                  10.3.4.3. Primavera Pruebas JUnit Anotaciones
                  10.3.5. Spring Framework TestContext
                      10.3.5.1. Abstracciones clave
                      10.3.5.2. Contexto de la gestión
                      10.3.5.3. Inyección de dependencia de accesorios de prueba
                      10.3.5.4. Gestión de transacciones
                      10.3.5.5. TestContext clases de apoyo
                  10.3.6. Ejemplo PetClinic
              10.4. Recursos adicionales
      IV. Acceso a datos
          11. Administración de transacciones
              11.1. Introducción a la gestión de transacciones Spring Framework
              11.2. Ventajas del modelo Spring Framework de transacciones de apoyo
                  11.2.1. Las transacciones globales
                  11.2.2. Las transacciones locales
                  11.2.3. Modelo de programación coherente Spring Framework
              11.3. Comprender el Spring Framework abstracción transacción
              11.4. Sincronización de los recursos con transacciones
                  11.4.1. Alto nivel de sincronización enfoque
                  11.4.2. Bajo nivel de sincronización enfoque
                  11.4.3. TransactionAwareDataSourceProxy
              11.5. Gestión de transacciones declarativa
                  11.5.1. Comprender la implementación del Marco de Spring transacción declarativa
                  11.5.2. Ejemplo de implementación de transacciones declarativa
                  11.5.3. Anulación de una transacción declarativa
                  11.5.4. Configuración de diferentes semántica transaccional para las semillas de diferentes
                  11.5.5. <tx:advice/> ajustes
                  11.5.6. El uso de @ Transactional
                      11.5.6.1. @ Programación transaccionales
                      11.5.6.2. Los administradores múltiples transacciones con @ Transactional
                      11.5.6.3. Anotaciones personalizadas de acceso directo
                  11.5.7. Transacción propagación
                      11.5.7.1. Necesario
                      11.5.7.2. RequiresNew
                      11.5.7.3. Nested
                  11.5.8. Asesorar a las operaciones transaccionales
                  11.5.9. El uso de @ transaccional con AspectJ
              11.6. Gestión de transacciones programática
                  11.6.1. Uso de la TransactionTemplate
                      11.6.1.1. Especificación de los valores de transacción
                  11.6.2. Uso de la PlatformTransactionManager
              11.7. Elegir entre la gestión de transacciones programáticas y declarativas
              11.8. Servidor de aplicaciones específicas de integración
                  11.8.1. IBM WebSphere
                  11.8.2. BEA WebLogic Server
                  11.8.3. Oracle OC4J
              11.9. Las soluciones a los problemas comunes
                  11.9.1. El uso del gestor de transacciones mal para un determinado origen de datos
              11.10. Recursos adicionales
          12. DAO apoyo
              12.1. Introducción
              12.2. Jerarquía excepción consistente
              12.3. Anotaciones utilizados para la configuración de las clases DAO o depósito
          13. Acceso a los datos con JDBC
              13.1. Introducción a Spring Framework JDBC
                  13.1.1. Elección de un método de acceso de base de datos JDBC
                  13.1.2. Paquete de jerarquía
              13.2. Uso de las clases principales de JDBC para controlar el procesamiento básico JDBC y manejo de errores
                  13.2.1. JdbcTemplate
                      13.2.1.1. Ejemplos de utilización de la clase JdbcTemplate
                      13.2.1.2. JdbcTemplate mejores prácticas
                  13.2.2. NamedParameterJdbcTemplate
                  13.2.3. SimpleJdbcTemplate
                  13.2.4. SQLExceptionTranslator
                  13.2.5. Ejecución de sentencias
                  13.2.6. Ejecución de consultas
                  13.2.7. Actualización de la base de datos
                  13.2.8. Recuperación automática de claves generadas
              13.3. Controlar las conexiones de base de datos
                  13.3.1. DataSource
                  13.3.2. DataSourceUtils
                  13.3.3. SmartDataSource
                  13.3.4. AbstractDataSource
                  13.3.5. SingleConnectionDataSource
                  13.3.6. DriverManagerDataSource
                  13.3.7. TransactionAwareDataSourceProxy
                  13.3.8. DataSourceTransactionManager
                  13.3.9. NativeJdbcExtractor
              13.4. JDBC operaciones por lotes
                  13.4.1. Operaciones básicas de proceso por lotes con el JdbcTemplate
                  13.4.2. Las operaciones por lotes con una lista de objetos
                  13.4.3. Las operaciones por lotes con varios lotes
              13.5. La simplificación de las operaciones con las clases JDBC SimpleJdbc
                  13.5.1. Insertar datos utilizando SimpleJdbcInsert
                  13.5.2. Recuperación automática de claves generadas utilizando SimpleJdbcInsert
                  13.5.3. Especificación de las columnas para un SimpleJdbcInsert
                  13.5.4. Uso de SqlParameterSource para proporcionar valores de parámetro

Otra formación relacionada con informática