Curso [2-7-2] Arquitectura Empresarial Java Edición Empresarial JEE 1.6 Parte 2 - Online

Contacta sin compromiso con INCAPROG ONLINE

Para enviar la solicitud debes aceptar la política de privacidad

Comentarios sobre Curso [2-7-2] Arquitectura Empresarial Java Edición Empresarial JEE 1.6 Parte 2 - Online

  • Contenido
        Capítulo 21 - Ejecutar la aplicación Avanzada JAX-RS Ejemplo
            21.1. El ejemplo de aplicación customer
                21.1.1. Aplicación archivos de código fuente
                21.1.2. La Clase customerService
                21.1.3. El esquema XSD para la aplicación customer
                21.1.4. La clase CustomerClient
                21.1.5. Construcción, embalaje, implementar y ejecutar el ejemplo customer
                    21.1.5.1. Para construir, paquete, e implementar el ejemplo customer mediante el uso de NetBeans IDE
                    21.1.5.2. Para construir, paquete, e implementar el aplicativo customer usando Ant
                    21.1.5.3. Para ejecutar el aplicativo customer que utiliza el cliente de Jersey
                    21.1.5.4. Para ejecutar el ejemplo customer el uso de Web Services Tester
                    21.1.5.5. Uso de Curl para ejecutar el aplicativo cliente de aplicaciones
        Capítulo 22 - Enterprise Bean
            22.1. ¿Qué es un Enterprise Bean?
                22.1.1. Beneficios de los Enterprise Beans
                22.1.2. Cuándo utilizar un Enterprise Bean
                22.1.3. Tipos de Enterprise Beans
            22.2. ¿Qué es un bean de sesión?
                22.2.1. Tipos de beans de sesión
                    22.2.1.1. Stateful Session Beans
                    22.2.1.2. Stateless Session Beans
                    22.2.1.3. Singleton Session Beans
                22.2.2. Cuándo utilizar beans de sesión
            22.3. ¿Qué es un beans controlados por mensajes?
                22.3.1. ¿Qué hace en mensajes de beans controlados por diferencia de beans de sesión?
                22.3.2. Cuándo utilizar beans controlados por mensajes
            22.4. Acceso a Beans Enterprise
                22.4.1. Uso de Beans Enterprise en clientes
                    22.4.1.1. Portable JNDI Sintaxis
                22.4.2. La decisión sobre el acceso remoto o local
                22.4.3. Los clientes locales
                    22.4.3.1. Beans acceso local o empresa que utilice la interfaz de Vista no-
                    22.4.3.2. Acceso a Beans Enterprise locales que implementan interfaces de Negocios
                22.4.4. Clientes remotos
                22.4.5. Clientes de servicios Web
                22.4.6. Método de los parámetros y el acceso
                    22.4.6.1. Aislamiento
                    22.4.6.2. Granularidad de los datos de Acceso
            22.5. El contenido de un Bean Enterprise
                22.5.1. Embalaje Beans Enterprise en los módulos EJB JAR
                22.5.2. Embalaje Beans Enterprise en los módulos WAR
            22.6. Convenciones de nomenclatura para los Beans Enterprise
            22.7. Los ciclos de vida de los Beans Enterprise
                22.7.1. El ciclo de vida de un bean de sesión con estado
                22.7.2. El ciclo de vida de un bean de sesión sin estado
                22.7.3. El ciclo de vida de un bean de sesión Singleton
                22.7.4. El ciclo de vida de beans controlados por mensajes
            22.8. Más información acerca de Beans Enterprise
        Capítulo 23 - Introducción a los Beans Enterprise
            23.1. Crear el Bean Enterprise
                23.1.1. Codificación de la clase Bean Enterprise
                23.1.2. Crear el cliente Web converter
                23.1.3. Construcción, embalaje, implementar y ejecutar el ejemplo converter
                    23.1.3.1. Para construir, paquete, e implementar el ejemplo converter en NetBeans IDE
                    23.1.3.2. Para construir, paquete, e implementar el ejemplo converter de Uso de Ant
                    23.1.3.3. Para ejecutar el ejemplo converter
            23.2. Modificación de la aplicación Java EE
                23.2.1. Para modificar un archivo de clase
        Capítulo 24 - Ejecución de los ejemplos Bean Enterprise
            24.1. El ejemplo cart
                24.1.1. La interfaz de negocio
                24.1.2. Sesión de clase Bean
                    24.1.2.1. Ciclo de Vida de los métodos de devolución de llamada
                    24.1.2.2. Métodos de negocios
                24.1.3. El método @remove
                24.1.4. Ayudante de Clases
                24.1.5. Construcción, embalaje, implementar y ejecutar el ejemplo de la cesta
                    24.1.5.1. Para construir, implementar paquetes, y ejecutar el ejemplo de uso de la cesta de NetBeans IDE
                    24.1.5.2. Para construir, implementar paquetes, y ejecutar el ejemplo de carrito de Ant
                    24.1.5.3. La tarea all
            24.2. Una sesión Singleton Bean Ejemplo: Contador
                24.2.1. Creación de un bean de sesión Singleton
                    24.2.1.1. Beans de sesión al inicializar Singleton
                    24.2.1.2. Administración del acceso concurrente en un bean de sesión Singleton
                    24.2.1.3. Control de errores en un bean de sesión Singleton
                24.2.2. La arquitectura del ejemplo contra
                24.2.3. Construcción, embalaje, implementar y ejecutar el ejemplo counter
                    24.2.3.2. Para construir, implementar paquetes, y ejecutar el ejemplo de la lucha contra el uso de NetBeans IDE
                    24.2.3.3. Para construir, implementar paquetes, y ejecutar el ejemplo de la lucha contra uso de Ant
            24.3. Un servicio Web de ejemplo: helloservice
                24.3.1. El servicio Web de extremo Clase de implementación
                24.3.2. Bean de sesión sin estado Implementación de clase
                24.3.3. Construcción, embalaje, implementar y probar el ejemplo helloservice
                    24.3.3.1. Para construir, Paquete, e implementar el ejemplo helloservice Con NetBeans IDE
                    24.3.3.2. Para construir, paquete, e implementar el ejemplo helloservice Usando Ant
                    24.3.3.3. Para probar el servicio sin cliente
            24.4. Utilizando el servicio de temporizador
                24.4.1. Crear expresiones temporizador Basados ​​en el Calendario
                    24.4.1.1. Especificar varios valores en expresiones Calendario
                24.4.2. Programáticas temporizadores
                24.4.3. El método @timeout
                24.4.4. Crear contadores de tiempo mediante programación
                24.4.5. Automática de contadores de tiempo
                24.4.6. Cancelación y Ahorro de temporizadores
                24.4.7. Obtención de información del temporizador
                24.4.8. Transacciones y Temporizadores
                24.4.9. El ejemplo timersession
                24.4.10. Construcción, embalaje, implementar y ejecutar el ejemplo timersession
                    24.4.10.1. Para construir, implementar paquetes, y ejecutar el ejemplo timersession Con NetBeans IDE
                    24.4.10.2. Para construir, paquete, e implementar el ejemplo timersession Usando Ant
                    24.4.10.3. Para ejecutar el cliente Web
                24.4.11. Manejo de excepciones
        Capítulo 25 - Un beans controlados por mensajes Ejemplo
            25.1. simplemessage Ejemplo de aplicación general
            25.2. La aplicación cliente simplemessage
            25.3. Los beans controlados por mensajes de clase
                25.3.1. El Método onMessage
            25.4. Embalaje, implementar y ejecutar el ejemplo simplemessage
                25.4.1. La creación de los objetos administrados para el Ejemplo simplemessage
                25.4.2. Para crear, implementar y ejecutar el simplemessage aplicación con NetBeans IDE
                25.4.3. Para crear, implementar y ejecutar la aplicación mediante simplemessage Ant
                25.4.4. Extracción de los objetos administrados para el Ejemplo simplemessage
        Capítulo 26 - Uso del Contenedor Enterprise Bean incorporado
            26.1. Vista general de la empresa de contenedores Bean incorporado
            26.2. Desarrollo de Aplicaciones insertable Bean Enterprise
                26.2.1. Ejecución de aplicaciones incrustadas
                26.2.2. Crear el contenedor Bean Enterprise
                    26.2.2.1. Especificar explícitamente los módulos Enterprise Bean ser iniciada
                26.2.3. Mirar hacia arriba Referencias Bean de sesión
                26.2.4. Apagando el contenedor Bean Enterprise
            26.3. El independiente Ejemplo de Aplicación
                26.3.1. Ejecución de la independiente Ejemplo de Aplicación
        Capítulo 27 - Utilizando el método de invocación asíncrona de beans de sesión
            27.1. Asincrónica la llamada a métodos
                27.1.1. Creación de un método de negocio asincrónico
                27.1.2. Llamar a métodos asincrónicos de Empresa Clientes Bean
                    27.1.2.1. Recuperar el resultado final de una invocación asincrónica Método
                    27.1.2.2. Cancelación de una llamada a métodos asincrónicos
                    27.1.2.3. Comprobación del estado de una llamada a métodos asincrónicos
            27.2. El ejemplo de aplicaciones asíncronas
                27.2.1. Arquitectura de la Aplicación Ejemplo asíncrona
                27.2.2. Configuración del almacén de claves y almacén de confianza en el servidor GlassFish
                27.2.3. Ejecutar el Ejemplo asíncrona aplicación en NetBeans IDE
                27.2.4. Ejecutar el Ejemplo asíncrona aplicación con Ant
        Capítulo 28 - Introducción a los contextos y de inyección de dependencia para la plataforma Java EE
            28.1. Vista general de la CDI
            28.2. Acerca de los Beans
            28.3. Acerca de los beans gestionados
            28.4. Frijoles como objetos inyectables
            28.5. Clasificación para el Uso de
            28.6. Inyectando beans
            28.7. Uso de alcances
            28.8. Otorgamiento de nombres EL a los beans
            28.9. Agregar métodos setter y getter
            28.10. El uso de un bean gestionado en una página de Facelets
            28.11. Inyección de objetos mediante el uso de métodos de productores
            28.12. Configuración de una aplicación de CDI
            28.13. Para más información sobre CDI
        Capítulo 29 - Ejecución de los contextos básicos y ejemplos inyección de dependencia
            29.1. El simplegreeting Ejemplo CDI
                29.1.1. El simplegreeting Archivos de código fuente
                29.1.2. La plantilla y Facelets página
                29.1.3. Archivos de configuración
                29.1.4. Construcción, embalaje, implementar y ejecutar el ejemplo simplegreeting CDI
                    29.1.4.1. Para construir, paquete, e implementar el ejemplo simplegreeting Con NetBeans IDE
                    29.1.4.2. Para construir, paquete, e implementar el ejemplo simplegreeting Usando Ant
                    29.1.4.3. Para ejecutar el ejemplo de simplegreeting
            29.2. El guessNumber CDI Ejemplo
                29.2.1. La Fuente guessNumber Archivos
                    29.2.1.1. Running the Enterprise Bean Examples
                    29.2.1.2. El generador Gestionado Bean
                    29.2.1.3. El UserNumberBean Gestionado Bean
                29.2.2. La página Facelets
                29.2.3. Construcción, embalaje, implementar y ejecutar el ejemplo guessNumber CDI
                    29.2.3.1. Para construir, paquete, e implementar el ejemplo guessNumber Con NetBeans IDE
                    29.2.3.2. Para construir, paquete, e implementar el ejemplo guessNumber Usando Ant
                    29.2.3.3. Para ejecutar el ejemplo de guessNumber
        Capítulo 30 - Contextos y la inyección de dependencias para la plataforma Java EE: Temas avanzados
            30.1. Uso de alternativas
                30.1.1. Uso de Especialización
            30.2. Uso de Métodos de productores y los campos
            30.3. Utilizar eventos
                30.3.1. Definición de Eventos
                30.3.2. Uso de Métodos de Observación para controlar los eventos
                30.3.3. Eventos de disparo
            30.4. Uso de interceptores
            30.5. Uso de decoradores
            30.6. Uso de los estereotipos

     

        Capítulo 31 - Ejecución de los Contextos de avanzada y ejemplos inyección de dependencia
            31.1. El ejemplo de codificador: El uso de alternativas
                31.1.1. La interfaz de codificador y puestas en práctica
                31.1.2. El codificador Facelets página y Bean Gestionado
                31.1.3. Construcción, embalaje, implementar y ejecutar el ejemplo del codificador
                    31.1.3.1. Para construir, paquete, e implementar el ejemplo del codificador con NetBeans IDE
                    31.1.3.2. Para ejecutar el ejemplo de codificador Con NetBeans IDE
                    31.1.3.3. Para construir, paquete, e implementar el ejemplo del codificador con Ant
                    31.1.3.4. Para ejecutar el ejemplo de codificador Usando Ant
            31.2. El ejemplo producermethods: El uso de un método de productor elegir una aplicación Bean
                31.2.1. Componentes del ejemplo producermethods
                31.2.2. Construcción, embalaje, implementar y ejecutar el ejemplo producermethods
                    31.2.2.1. Para construir, paquete, e implementar el ejemplo producermethods Con NetBeans IDE
                    31.2.2.2. Para construir, paquete, e implementar el ejemplo producermethods Usando Ant
                    31.2.2.3. Para ejecutar el ejemplo de producermethods
            31.3. El producerfields Ejemplo: Uso de los campos productores para generar recursos
                31.3.1. El productor de campo para el Ejemplo producerfields
                31.3.2. El producerfields y entidades Bean de sesión
                31.3.3. El producerfields páginas Facelets y Bean Gestionado
                31.3.4. Construcción, embalaje, implementar y ejecutar el ejemplo producerfields
                    31.3.4.1. Para construir, paquete, e implementar el ejemplo producerfields Con NetBeans IDE
                    31.3.4.2. Para construir, paquete, e implementar el ejemplo producerfields Usando Ant
                    31.3.4.3. Para ejecutar el ejemplo de producerfields
            31.4. El ejemplo billpayment: Eventos de Uso y Interceptores
                31.4.1. La clase de evento PaymentEvent
                31.4.2. El detector de eventos PaymentHandler
                31.4.3. El billpayment Facelets Páginas y Bean Gestionado
                31.4.4. La clase interceptor LoggedInterceptor
                31.4.5. Construcción, embalaje, implementar y ejecutar el ejemplo billpayment
                    31.4.5.1. Para construir, paquete, e implementar el ejemplo billpayment Con NetBeans IDE
                    31.4.5.2. Para construir, paquete, e implementar el ejemplo billpayment Usando Ant
                    31.4.5.3. Para ejecutar el ejemplo de billpayment
            31.5. Los decoradores Ejemplo: Decoración de un Bean
                31.5.1. Componentes del ejemplo decoradores
                    31.5.1.2. Construcción, embalaje, implementar y ejecutar el ejemplo decoradores
                        31.5.1.2.1. Para construir, paquete, e implementar el ejemplo decoradores Con NetBeans IDE
                        31.5.1.2.2. Para construir, paquete, e implementar el ejemplo decoradores Usando Ant
                        31.5.1.2.3. Para ejecutar el ejemplo de decoradores
        Capítulo 32 - Introducción a la API Java Persistence
            32.1. Entidades
                32.1.1. Requisitos para clases de entidad
                32.1.2. Persistentes Campos y Propiedades en clases de entidad
                    32.1.2.1. Persistentes Campos
                    32.1.2.2. Persistentes Propiedades
                    32.1.2.3. Uso de las colecciones en los campos de la entidad y Propiedades
                    32.1.2.4. Validar persistentes Campos y Propiedades
                32.1.3. Las claves principales de entidades
                32.1.4. Multiplicidad de relaciones entre entidades
                32.1.5. Dirección de Relaciones Entidad
                    32.1.5.1. Las relaciones bidireccionales
                    32.1.5.2. Las relaciones unidireccionales
                    32.1.5.3. Consultas y Dirección de Relación con
                    32.1.5.4. Cascada de Operaciones y Relaciones
                    32.1.5.5. Huérfanos de eliminación en las relaciones
                32.1.6. Clases insertable en Entidades
            32.2. Entidad de la herencia
                32.2.1. Resumen Entidades
                32.2.2. Superclase asignada
                32.2.3. No-entidad superclase
                32.2.4. Entidad Estrategias asignar la herencia
                    32.2.4.1. El cuadro individual por la Estrategia jerarquía de las clases
                    32.2.4.2. La Mesa por la estrategia de clase de hormigón
                    32.2.4.3. La Subclase acumulados Estrategia
            32.3. Gestión de Entidades
                32.3.1. La interfaz EntityManager
                    32.3.1.1. Administrada por contenedor Agentes Entidad
                    32.3.1.2. Aplicación Gestionado administradores de entidades
                    32.3.1.3. Búsqueda de Entidades Uso del EntityManager
                    32.3.1.4. Gestión del ciclo de vida de una instancia de la Entidad
                    32.3.1.5. La persistencia de instancias de entidad
                    32.3.1.6. Extracción de instancias de entidad
                    32.3.1.7. Sincronización de datos de entidad a la base de datos
                32.3.2. Persistencia unidades
            32.4. Consulta de Entidades
            32.5. Más información sobre la persistencia
        Capítulo 33 - Ejecución de los ejemplos de persistencia
            33.1. El orden de aplicación
                33.1.2. Entidad de relaciones en el orden de aplicación
                    33.1.2.1. Las relaciones auto-referencial
                    33.1.2.2. Uno-a-uno
                    33.1.2.3. Relación de uno a varios asignada a la superposición de claves principales y Exteriores
                    33.1.2.4. Las relaciones unidireccionales
                33.1.3. Las claves principales en el orden de aplicación
                    33.1.3.1. Generado Primaria claves
                    33.1.3.2. Compuesto claves principales
                33.1.4. Entidad asignada a la tabla de base de datos más de una
                33.1.5. Cascada de operaciones en el orden de aplicación
                33.1.6. BLOB y CLOB base de datos de tipos en el orden de aplicación
                33.1.7. Tipos temporal en el orden de aplicación
                33.1.8. Gestión de la orden de aplicación de Entidades
                    33.1.8.1. Creación de Entidades
                    33.1.8.2. Búsqueda de Entidades
                    33.1.8.3. Marco relaciones entre entidades
                    33.1.8.4. Utilizar consultas
                    33.1.8.5. Extracción de Entidades
                33.1.9. Construcción, embalaje, implementar y ejecutar la orden de aplicación
                    33.1.9.1. Para construir, empaquetar, implementar, y ejecutar para UsingNetBeans IDE
                    33.1.9.2. Para construir, implementar paquetes, y en ejecutar para uso de Ant
                    33.1.9.3. La tarea all
            33.2. La aplicación roster
                33.2.1. Las relaciones en la lista de aplicaciones
                    33.2.1.1. Las muchas-a-muchos relación en lista
                33.2.2. Entidad de la herencia en la lista de aplicaciones
                33.2.3. Criterios de consultas en la lista de aplicaciones
                    33.2.3.1. Metamodelo de clases en la lista de aplicaciones
                    33.2.3.2. Obtención de una instancia de CriteriaBuilder en RequestBean
                    33.2.3.3. Creación de criterios de consultas en los métodos de negocio de RequestBean
                33.2.4. Generación automática de la tabla en la lista de aplicaciones
                33.2.5. Construcción, embalaje, implementar y ejecutar la lista de aplicaciones
                    33.2.5.1. Para construir, empaquetar, implementar, y ejecutar lista Usando NetBeans IDE
                    33.2.5.2. Para construir, implementar paquetes, y ejecutar lista Uso de Ant
                    33.2.5.3. La tarea all
            33.3. La libreta de direcciones de aplicaciones
                33.3.1. De bean de validación de restricciones en la libreta de direcciones
                33.3.2. Especificación de mensajes de error de restricciones en la libreta de direcciones
                33.3.3. Póngase en contacto con la validación de entrada de una aplicación JavaServer Faces
                33.3.4. Construcción, embalaje, implementar y ejecutar la libreta de direcciones de aplicaciones
                    33.3.4.1. Construcción, embalaje, implementar y ejecutar la libreta de direcciones de aplicación en NetBeans IDE
                    33.3.4.2. Construcción, embalaje, implementar y ejecutar la libreta de direcciones de aplicación mediante la hormiga
        Capítulo 34 - El Java Persistence Query Language
            34.1. Lenguaje de consulta de terminología
            34.2. Creación de consultas Uso del Lenguaje de consulta de Java Persistence
                34.2.1. Parámetros con nombre en las consultas
                34.2.2. Los parámetros de posición en las consultas
            34.3. Consulta simplificada del lenguaje Sintaxis
                34.3.1. Sentencias select
                34.3.2. Sentencias update y delete
            34.4. Ejemplo de consultas
                34.4.1. Consultas simples
                    34.4.1.1. Una consulta de selección básica
                    34.4.1.2. La eliminación de los valores duplicados
                    34.4.1.3. Utilizar parámetros con nombre
                34.4.2. Las consultas que navegan a las entidades relacionadas
                    34.4.2.1. Una simple consulta con relaciones
                    34.4.2.2. Navegando a los campos de la relación individual con valores
                    34.4.2.3. Atravesando las relaciones con un parámetro de entrada
                    34.4.2.4. Atravesando las relaciones múltiples
                    34.4.2.5. Navegación De acuerdo con los campos relacionados
                34.4.3. Las consultas con otras expresiones condicionales
                    34.4.3.1. La expresión LIKE
                    34.4.3.2. La expresión IS NULL
                    34.4.3.3. La expresión IS EMPTY
                    34.4.3.4. La expresión BETWEEN
                    34.4.3.5. Operadores de comparación
                34.4.4. A granel actualizaciones y eliminaciones
                    34.4.4.1. Consultas de actualización
                    34.4.4.2. Consultas de eliminación
            34.5. Full Query Language Syntax
                34.5.1. BNF Símbolos
                34.5.2. BNF Gramática de la Lengua de consulta de Java Persistencia
                34.5.3. La clausula FROM
                    34.5.3.1. Identificadores
                    34.5.3.2. Identificación de las variables
                    34.5.3.3. Rango de Declaraciones de variables
                    34.5.3.4. Colección de declaraciones de miembros
                    34.5.3.5. Joins
                34.5.4. Expresiones de ruta
                    34.5.4.1. Ejemplos de expresiones de ruta
                    34.5.4.2. Tipos de expresión
                    34.5.4.3. Navegación
                34.5.5. La clausula WHERE
                    34.5.5.1. Literales
                    34.5.5.2. Parámetros de entrada
                    34.5.5.3. Expresiones condicionales
                    34.5.5.4. Los operadores y su precedencia
                    34.5.5.5. Expresiones BETWEEN
                    34.5.5.6. Expresiones IN
                    34.5.5.7. Expresiones LIKE
                    34.5.5.8. Comparación de las expresiones NULL
                    34.5.5.9. Vaciar las expresiones Colección Comparación
                    34.5.5.10. Colección expresiones miembros
                    34.5.5.11. Subconsultas
                    34.5.5.12. Expresiones funcionales
                    34.5.5.13. Caso las expresiones
                    34.5.5.14. Valores NULL
                    34.5.5.15. Igualdad Semántica
                34.5.6. Cláusula SELECT
                    34.5.6.1. Tipos de Retorno
                    34.5.6.2. La palabra clave DISTINCT
                    34.5.6.3. Constructor de expresiones
                34.5.7. Cláusula ORDER BY
                34.5.8. GROUP BY y HAVING Cláusulas
        Capítulo 35 - Uso de la API de criterios para crear consultas
            35.1. Resumen de los criterios y las API metamodelo
            35.2. Uso de la API metamodelo al modelo de clases de entidad
                35.2.1. Con clases metamodelo
            35.3. Utilizando los criterios de la API y metamodelo API para crear consultas de base Typesafe
                35.3.1. Crear una consulta Criterios
                35.3.2. Consulta Raíces
                35.3.3. Consultar relaciones mediante une
                35.3.4. Ruta de navegación en los Criterios consultas
                35.3.5. Restringir los resultados criterios de consulta
                    35.3.5.1. Los métodos de interfaz de Expresión
                    35.3.5.2. Métodos de Expresión en la interfaz de CriteriaBuilder
                35.3.6. Administración de los resultados criterios de consulta
                    35.3.6.1. Ordenar los resultados
                    35.3.6.2. Agrupar los resultados de
                35.3.7. Ejecutar consultas
                    35.3.7.1. Un solo valor resultados de una consulta
                    35.3.7.2. Colección con valores de resultados de una consulta
        Capítulo 36 - Creación y uso de criterios basados ​​en cadena-Consultas
            36.1. Información general de las consultas criterios basados ​​en cadena-API
                36.1.1. Crear consultas basadas en cadenas
                36.1.2. Ejecutar consultas basadas en cadenas
        Capítulo 37 - El control de acceso concurrente a la Entidad de datos con bloqueo
            37.1. Listado de bloqueo de la entidad y de concurrencia
                37.1.1. Usando el bloqueo optimista
            37.2. Modos de bloqueo
                37.2.1. Ajuste del modo de bloqueo
                37.2.2. Usando el bloqueo pesimista
                    37.2.2.1. Tiempos de espera de bloqueo pesimista
        Capítulo 38 - Mejorar el rendimiento de las aplicaciones Java API de Persistencia estableciendo una caché de segundo nivel
            38.1. Visión general de la caché de segundo nivel
                38.1.1. Controlar si las entidades pueden almacenar en caché
            38.2. Especificación de la configuración del modo de caché para mejorar el rendimiento
                38.2.1. Ajuste de los modos de recuperación de caché y de la tienda
                    38.2.1.1. Modo de caché de recuperación
                    38.2.1.2. Modo de caché de la tienda
                    38.2.1.3. Ajuste de la Recuperación de la caché o el modo de tienda
                38.2.2. Control de la caché de segundo nivel mediante programación
                    38.2.2.1. Comprobar si los datos de la entidad está en caché
                    38.2.2.2. Extracción de una Entidad de la caché
                    38.2.2.3. Eliminación de todos los datos de la caché
        Capítulo 39 - Introducción a la seguridad en la Plataforma Java EE
            39.1. Información general sobre seguridad de Java EE
                39.1.1. Un ejemplo simple de Seguridad
                    39.1.1.1. Paso 1: Solicitud inicial
                    39.1.1.2. Paso 2: autenticación inicial
                    39.1.1.3. Paso 3: Autorización de URL
                    39.1.1.4. Paso 4: El cumplimiento de la solicitud original
                    39.1.1.5. Paso 5: La invocación de la Empresa Métodos de negocios Bean
                39.1.2. Características de un mecanismo de seguridad
                39.1.3. Características de seguridad de las aplicaciones
            39.2. Mecanismos de Seguridad
                39.2.1. Java SE Mecanismos de Seguridad
                39.2.2. Mecanismos de seguridad de Java EE
                    39.2.2.1. Seguridad de la capa de aplicación
                    39.2.2.2. Transporte-Seguridad de la capa
                    39.2.2.3. Mensaje de Seguridad de la capa-
            39.3. Proteger los contenedores
                39.3.1. Uso de anotaciones para especificar Seguridad de la Información
                39.3.2. Uso de los descriptores de despliegue para la seguridad declarativa
                39.3.3. Usar la seguridad mediante programación
            39.4. Asegurando el servidor GlassFish
            39.5. Trabajar con Reinos, usuarios, grupos y roles
                39.5.1. ¿Qué son los Reinos, usuarios, grupos y roles?
                    39.5.1.1. ¿Qué es un reino?
                    39.5.1.2. ¿Qué es un Usuario?
                    39.5.1.3. ¿Qué es un Grupo?
                    39.5.1.4.¿Qué es una función?
                    39.5.1.5.Algunos otros Terminología
                39.5.2. Administrar usuarios y grupos en el servidor GlassFish
                    39.5.2.1. Para agregar usuarios al servidor GlassFish
                    39.5.2.2. Adición de usuarios al Reino Certificado
                39.5.3. Configuración de las funciones de seguridad
                39.5.4. Asignación de funciones a los usuarios y grupos
            39.6. El establecimiento de una conexión segura mediante SSL
                39.6.1. Verificación y configuración de la compatibilidad con SSL
                39.6.2. Trabajar con Certificados Digitales
                    39.6.2.1. Creación de un certificado de servidor
            39.7. Para más información acerca de la seguridad
        Capítulo 40. Introducción Proteger las aplicaciones Web
            40.1. Información general sobre seguridad de aplicaciones Web
            40.2. Proteger las aplicaciones Web
                40.2.1. Especificación de restricciones de seguridad
                    40.2.1.1. Especificación de una colección de recursos web
                    40.2.1.2. Especificación de una restricción de autorización
                    40.2.1.3. Especificación de una conexión segura
                    40.2.1.4. Especificación de restricciones de seguridad independientes para los diferentes recursos
                40.2.2. Especificación de los mecanismos de autenticación
                    40.2.2.1. Autenticación básica HTTP
                    40.2.2.2. Autenticación basada en formularios
                    40.2.2.3. Recopilación de autenticación
                    40.2.2.4. Autenticación del cliente
                    40.2.2.5. Autenticación mutua
                    40.2.2.6. La especificación de un mecanismo de autenticación en el descriptor de despliegue
                40.2.3. Declarar las funciones de seguridad
            40.3. Uso de programación de Seguridad de Aplicaciones Web
                40.3.1. La autenticación de usuario mediante programación
                40.3.2. Comprobación de identidad del llamante mediante programación
                40.3.3. Ejemplo de código para la Seguridad programático
                40.3.4. Declarar y Vinculación de referencias papel
            40.4. Ejemplos: Proteger las aplicaciones Web
                40.4.1. Para configurar su sistema para ejecutar los ejemplos de Seguridad
                40.4.2.  Ejemplo: la autenticación básica con un servlet
                    40.4.2.1. Especificación de seguridad para la autenticación básica con anotaciones
                    40.4.2.2. Para construir, paquete, e implementar el ejemplo de servlet de autenticación básica con NetBeans IDE
                    40.4.2.3. Para construir, paquete, e implementar el ejemplo de servlet de autenticación básica con Ant
                    40.4.2.4. Para ejecutar el servlet de autenticación básica
                40.4.3. Ejemplo:-Formulario de autenticación basada en una aplicación JavaServer Faces
                    40.4.3.1. Crear el formulario de acceso y la página de error
                    40.4.3.2. Especificación de seguridad para el ejemplo de autenticación basada en formularios
                    40.4.3.3. Para construir, paquete, e implementar el ejemplo de autenticación basada en formularios Uso de NetBeans IDE
                    40.4.3.4. Para construir, paquete, e implementar el ejemplo de autenticación basada en formularios utilizando Ant
                    40.4.3.5. Para ejecutar el ejemplo de autenticación basada en formularios


        Capítulo 41 - Introducción Proteger las aplicaciones de Enterprise
            41.1. Asegurar Beans Enterprise
                41.1.1. Garantizar un Bean Enterprise uso de seguridad declarativa
                    41.1.1.1. Especificación de los usuarios autorizados por la Declaración de las funciones de seguridad
                    41.1.1.2. La especificación de un mecanismo de autenticación y conexión segura
                41.1.2. Garantizar un Bean Enterprise programación
                    41.1.2.1. Acceso a una llamada Bean Enterprise contexto de seguridad
                41.1.3. La difusión de una identidad de seguridad (Run-As)
                    41.1.3.1. Configurar la identidad de un componente de seguridad Propagado
                    41.1.3.2. La confianza entre los contenedores
                41.1.4. Implementación de frijoles Secure Enterprise
            41.2. Ejemplos: Asegurar Beans Enterprise
                41.2.1. Ejemplo: Garantizar un Bean Enterprise con seguridad declarativa
                    41.2.1.1. Describiendo el Bean
                    41.2.1.2. Para construir, empaquetar, implementar y ejecutar el ejemplo de la cesta de seguro con NetBeans IDE
                    41.2.1.3. Para construir, empaquetar, implementar y ejecutar el ejemplo de la cesta de seguro con Ant
                41.2.2. Ejemplo: Garantizar un Bean Enterprise con seguridad mediante programación
                    41.2.2.1. Modificación de ConverterBean
                    41.2.2.2. Modificación de ConverterServlet
                    41.2.2.3. Para construir, paquete, e implementar el ejemplo de convertidor de seguro con NetBeans IDE
                    41.2.2.4. Para construir, paquete, e implementar el ejemplo de convertidor de seguro con Ant
                    41.2.2.5. Para ejecutar el ejemplo de convertidor de seguro
            41.3. Protección de clientes de aplicaciones
                41.3.1. Utilizando módulos de registro
                41.3.2. Uso de inicio de sesión mediante programación
            41.4. Proteger los sistemas de información de la empresa Aplicaciones
                41.4.1. Gestionado por el contenedor de inicio de sesión
                41.4.2. Componente gestionados de inicio de sesión
                41.4.3. Configuración de la seguridad del adaptador de recursos
                41.4.4. Para un mapa de Aplicación a los Directores Principales EIS
        Capítulo 42 - Introducción a Java EE Tecnologías de Apoyo
            42.1. Transacciones
            42.2. Recursos
                42.2.1. La arquitectura Java EE Connector y adaptadores de recursos
                42.2.2. Base de datos Java Software de conectividad
            42.3. Java Message Service
        Capítulo 43 - Transacciones
            43.1. ¿Qué es una transacción?
            43.2. Las transacciones administradas por contenedor
                43.2.1. Atributos de tran

Otra formación relacionada con java y javascript

Este sitio utiliza cookies.
Si continua navegando, consideramos que acepta su uso.
Ver más  |