fbpx
  • nl

Course Advanced Java and Performance

Course Advanced Java and Performance
Regio:
  • Modules
  • Cursus
  • Inhoud
  • Algemene informatie
    Algemeen
  • Reviews
  • Module 1 : Java NetworkingModule 2 : ConcurrencyModule 3 : Java Management Extensions
    Java Networking Intro
    Network Protocols
    Using URL Class
    Reading from an URL
    InetAddress Class
    Sockets
    Socket Communication
    Socket Types
    Socket Ports
    ServerSocket Class
    Socket Class
    Datagram Sockets
    DatagramPacket Class
    Multicast Sockets
    Socket Programming
    Concurrency Package
    Concurrency Package Benefits
    Contents Concurrency Package
    Task Scheduling Framework
    Executor Interface
    ExecutorService
    Executors Class
    Callables and Futures
    ScheduledExecutorService
    Synchronizers
    Semaphores
    CountdownLatch
    CyclicBarrier
    Exchanger
    Concurrent Collections
    BlockingQueue Interface
    Lock Interface
    Atomic Variables
    What is JMX?
    JMX Goal
    JMX Usage
    Managed Beans
    MBean Flavors
    JMX Architecture Levels
    JMX Architecture
    MBeans Instrumenting JVM
    Accessing JMX Agent
    Standard MBeans
    Naming MBeans
    MBean Server
    MBean Server Interface
    Registering MBeans
    JMX Notifications
    Notification Class
    Notification Listeners
    Module 4 : ReflectionModule 5 : Remote Method InvocationModule 6 : Database Access with JDBC
    What is Reflection?
    Reflection Classes
    Class Loading
    Creating Objects
    Reflection Methods in Class
    Field Class
    Field Class Usage
    Constructor Class
    Constructor Class Usage
    Method Class
    Method Class Usage
    AccessibleObject Class
    Dynamic Proxies
    Invocation Handler
    What is RMI?
    RMI Characteristics
    RMI Architecture
    Remote Interface
    Stubs and Skeletons
    Remote Object
    Remote Object Registration
    RMI Client
    Exporting Objects
    Locating Remote Objects
    RMI Control Flow
    Serialization
    Parameter Passing
    Dynamic Class Loading
    Activation
    JDBC Architecture
    JDBC Drivers and URL's
    Database Connections
    Executing Statements
    Querying Databases
    Update Statements
    Retrieving Results
    Handling Errors
    Prepared Statements
    Database Metadata
    Transactions
    Commit and Rollback
    Rowset Interfaces
    Using RowsetProvider
    Module 7 : Memory ManagementModule 8 : Java Native Interface (JNI)Module 9 : Java Logging
    JVM Internal Architecture
    Java Memory Management
    Object Lifecycle
    Strong Object References
    Invisible and Unreachable
    Circular References
    Garbage Collection
    Generational GC
    Heap Space Organization
    GC Algorithms
    Serial Collector
    Parallel Collector
    Reference Objects
    Soft and Weak References
    Phantom References
    Finalization
    Java Native Interface
    Java to C
    C to Java
    JNI Boundary
    Header Files
    Required Parameters
    Java Language
    Writing Native Methods
    Declaring Native Methods
    JNIEnv Interface Pointer
    Mapping Table
    Accessing Java Strings
    JNI Functions
    Accessing Arrays
    Logging
    Logging in Java
    Java Util Logging
    Levels and Log Methods
    Logging Configuration
    log4j Characteristics
    log4j Configuration
    Loggers
    Logger Output Hierarchy
    Inheriting Logging Levels
    Logger Names
    Log Levels
    Appenders and Layouts
    Log Analyzer Tools
    Module 10 : New IOModule 11 : Java API XML Binding (JAXB)Module 12 : Java Performance
    What is NIO?
    Synchronous I/O Processing
    Asychronous I/O Processing
    Working with Buffers
    IO Channels
    Selectable Channels
    Selectors
    Selection Keys
    Character Sets
    Using Path Class
    Directory Traversing
    PathMatcher class
    Using WatchService
    XML Processing Options
    What is JAXB?
    JAXB versus DOM and SAX
    JAXB Design Goals
    Building JAXB Applications
    JAXB Architecture
    JAXB Binding Life Cycle
    Role of Binding Compiler
    XML tot Java Mapping Rules
    Mapping of XML Schema Types
    Binding Elements and Attributes
    Named Complex Types
    Customized Mappings
    Adapter Classes
    JAXB Annotations Types
    JAXB API
    What is Performance?
    Influences on Performance
    Important Performance Aspects
    History of Java Performance
    JIT Compilation and JIT Compiler
    Client and Server Hotspot VM
    Garbage Collection
    Garbage Collection Algorithms
    Java Performance Myths
    Perceived Performance
    BenchMarking
    Monitoring and Profiling
    Performance Tuning
    Heap Tuning
    Application Performance Process
    Heap Activity Monitoring
    Common Performance Problems
    Java Performance Tips
    Module 13 : Java API PerformanceModule 14 : Performance ProfilingModule 15 : Tuning Garbage Collection
    Java API Performance Pitfalls
    String Handling
    Buffered I/O
    New I/O
    Synchronization
    Concurrency Package
    Primitives versus Wrappers
    Collections
    Array Copying
    Exception Handling
    Serialization
    Native methods
    Lazy Loading
    Object Reuse
    Profiling
    Profiling tools
    Netbeans Profiler
    Sun Studio Analyzer
    CPU profiling
    CPU Profiling Approach
    Profiling a subset
    Profiling Points
    Type of Profiling Points
    Monitoring Threads
    Lock contention
    Identifying problematic patterns
    Stress Testing
    GC and Performance
    Java Object Behavior
    Heap Space Organisation
    Heap Area Characteristics
    Young Generation Layout
    GC Performance Metrics
    Used GC Algorithms
    Performance Considerations
    Serial collector
    Parallel collector
    Parallel compact collector
    Concurrent Mark-Sweep (CMS)
    Ergonomics
    Module 16 : JDBC and Java EE Performance
    JDBC Optimization
    Optimization Techniques
    JDBC connection pooling
    Single Batch Transactions
    Smart Queries
    Tuning Servlets and JSP's
    HTTP Session Tuning
    Web Server Tuning
    Clustering
    Clustering Types
    Load Balancing
    Sticky Sessions
  • Cursusvorm

    Al onze cursussen zijn klassikale cursussen waarbij de cursisten aan de hand van een ervaren trainer met diepgaande materie kennis door de stof worden geleid. Theorie wordt steeds afgewisseld met oefeningen.

    Maatwerk

    We doen ook maatwerk  en passen dan de cursusinhoud aan op uw wensen. Op verzoek gaan we ook in op uw praktijkcases.

    Cursustijden

    De cursustijden zijn in pricipe van 9.30 tot 16.30. Maar we zijn hierin flexibel. Soms moeten mensen namelijk kinderen naar de opvang brengen of halen en komen andere tijden hun beter uit. In goed overleg kunnen we dan andere cursustijden afspreken.

    Hardware

    Wij zorgen voor de computers waarop de cursus gehouden kan worden. Op deze computer is de voor de cursus benodigde software al geinstalleerd. U hoeft geen laptop mee te nemen om aan de cursus te kunnen deelnemen. Als u liever op uw eigen laptop werkt kunt u hem desgewenst meenemen. De benodigde software wordt dan aan het begin van de cursus geinstalleerd.

    Software

    Onze cursussen worden over het algemeen gegeven met Open Source software zoals Eclipse, IntelliJ, Tomcat, Pycharm, Anaconda en Netbeans. Het digitale cursusmateriaal krijgt u na de cursus mee naar huis.

    Lunch

    De cursus is inclusief lunch die we in een restaurantje op loopafstand van het cursuslokaal gebruiken.

    Locaties

    De cursussen worden op diverse plaatsen in het land gepland. Een cursus gaat op een locatie door als er zich minimaal 3 mensen voor die locatie inschrijven. Als er inschrijvingen voor verschillende locaties zijn gaat de cursus door op onze hoofdlocatie is Houten net onder Utrecht. Een cursus op onze hoofdlocatie gaat ook door bij 2 inschrijvingen en regelmatig ook bij 1 inschrijving.  Overigens doen we ook cursussen op de locatie van de klant als men daar prijs op stelt.