Cursuri Java

Cursuri Programare Java

Cursurile sunt acreditate ANC – Programator ajutor – COR 351201

Cursurile sunt scutite de plata TVA.

Pretul include suportul de curs in format electronic, masa de pranz, coffee breaks si certificatul ANC.

Diploma este recunoscuta de Ministerul Muncii, Familiei si Protectiei Sociale si Ministerul Educatiei, Cercetarii si Inovarii si atesta toate competentele profesionale ale ocupatiei.

Informatii despre cursurile disponibile

CodDescriereDurataPret (scutit de plata TVA)Data urmatorului curs
Java 1Limbajul JAVA: Nivel Incepator – Mediu40 ore480 EURO03.09.2018
Java 2Limbajul JAVA: Nivel Mediu – Avansat40 ore480 EURON/A
Java 3Design Patterns24 ore500 EURON/A
Java 4Java WebServices32 ore410 EURON/A

Informatii despre cursurile disponibile

CodDescriereDurataPret (scutit de plata TVA)Data urmatorului curs
DP&CCDesign Patterns & Clean Code16 oreN/A
PUTProfessional Unit Testing16 ore N/A
SPRINGSpring16/24 ore N/A
JPAHibernate/JPA 16 ore N/A

Informatii despre cursurile disponibile

CodDescriereDurataPret (scutit de plata TVA)Data urmatorului curs
Java 8Java 88 ore N/A
JPOJava Performance Optimizations16/24 ore N/A
CC&CDClean Code & Coding Dojo8 ore N/A
ScalaScala40 oreN/A
Agenda curs Limbajul JAVA – Nivel Incepator - Mediu

Limbajul JAVA –Nivel Incepator si Mediu

 

1.Programare orientata pe obiecte – principii de baza
Conceptul de clasa; conceptul de obiect
Avantaje specifice
Constructia obiectelor: constructori / destructori
Mostenire
Compunere
Vizibilitate
Polimorfism
Clase abstracte; metode abstracte
Tipuri generice
Limbaje “strongly typed” / limbaje “weakly typed”

 

2. Fundamentele limbajului Java
Tipuri primitive de date
Variabile; declararea variabilelor
Instructiuni; cuvinte-cheie
Cuvinte-cheie de modificare (Modifiers)
Transmiterea argumentelor
Operatori
Conversii de date
Tablouri, stringuri
Blocuri si Statement-uri
Tratarea exceptiilor
Clase si obiecte, gestionarea dinamica a memoriei
Initializare si clean-up (garbage collector, initializarea membrilor)
Interfete
Java Beans
Lucrul cu colectii de obiecte
Fire de executie (threads); sincronizare
Stream-uri, operatii de I/O, new I/O, serializarea obiectelor

 

3. Java New IO API
Java new I/O (NIO): generalitati
Citirea datelor
Scrierea datelor
Copierea directa a fisierelor
Citirea si scrierea din / in mai multe buffere simultan
Fisiere mapate in memorie
Operatiuni I/O neblocante – generalitati
Multiplexarea operatiunilor I/O – generalitati

 

4. Java logging
Java logging
log4j

 

5. Securitate Java
Conceptul de “sandbox”
Elemente de securitate implicite ale limbajului Java
Java Cryptography Extension (JCE)

 

6. Accesul la baze de date folosind JDBC
Baze de date relationale: generalitati
Notiuni generale de SQL
Conectarea la o baza de date folosind JDBC: Connection, Statement, ResultSet
Maparea tipurilor de date SQL / Java
Inserarea / stergerea / modificarea datelor
Parametrizarea unui query
Folosirea tranzactiilor
Framework-uri de acces la baza de date (Hibernate)

 

7. JEE
Modelul JEE; tiers (presentation, Web, business, data)
Notiuni de HTML
Formulare; GET versus POST
Notiuni de Javascript
Protocolul HTTP; reqest, response, headers
Servlets
Preluarea informatiilor: Interfetele HttpServletRequest si HttpSession
Trimiterea de informatii catre client: HttpServletResponse
Trimiterea de alte informatii decit HTML: content type
Internationalizare (entitati HTML)
Cooperarea intre servlet-i
Java Server Pages (JSP)
Tag-uri JSP standard
JSP Beans
Combinarea de servlets si pagini JSP
Tag-uri personalizate (custom tags)
Tipuri de tag-uri personalizate
Definirea si utilizarea tag-urilor personalizate
Cooperarea intre tag-uri (partajarea de obiecte)

 

8. Aplicatii applet-uri si instrumente de lucru cu ferestre
AWT
Componente Swing de baza: descriere generala
Thread-uri Swing
Crearea unui program Swing
Layout; Layout managers
Evenimente

 

9. Internationalizare
Definitii, generalitati; concepte generale
Clasa java.util.Locale
Fisiere de proprietati
Clasa java.util.ResourceBundle

 

10. Standarde de scriere a codului si de documentare
Standarde de formatare a codului: conventii de denumire, conventii de aliniere
JavaDoc; generare de documentatie pornind de la comentariile JavaDoc

 

11. Design patterns
Definitii; deosebiri intre design patterns si algoritmi
Pattern-uri de creatie
Pattern-uri structurale
Pattern-uri de comportament

Agenda curs Limbajul JAVA – Nivel Mediu - Avansat

Limbajul JAVA – nivel Mediu si Avansat

 

1. Java API for XML Processing.doc
XML – introducere
Fisierul Data Type Definition
XML Schema
JAXP – generalitati
SAX
DOM
XSLT
Documente XSL

2. Java Beans
Generalitati
Evenimente
Serializare

3. Enterprise Java Beans
Generalitati
Interfetele Home, Remote si Local
Entity Beans
Session Beans
Message Driven Beans
Java Messagind API (JMS)
EJB 3 – Adnotari
EJB 3 – Session beans
EJB3 – Declararea unui entity bean
EJB3 – Obiecte Embeddable
EJB3 – Relatii intre entitati
EJB3 – Mostenirea in cazul Entity Beans
EJB3 – Metode callback
EJB3 – Utilizarea de resurse externe
EJB 3 – Injectarea de referinte la alte bean-uri

 

4. Struts
MVC – concepte
Arhitectura Struts: view, controler, model
Configurare Struts
Action Forward, Action Mappings
Action Form
Tag-uri JSP specifice
Struts 2: comparatie cu Struts 1
Struts 2 – ciclul de procesare al unui request
Obiectele Interceptor
Obiectele de tip Action
Validarea in Struts2
Limbajul OGNL ( Object Graph Notation Language )

 

5. Java Server Faces
Generalitati
Structura JSF
Fisiere de configurare JSF
Componente JSF
Evenimente si listener-i
Ciclul de viata al unei cereri in JSF
Structura unei pagini JSF
JSF Expression Language
Internationalizare

 

6. Web Services
Java API for XML Registries (JAXR) – generalitati
JAXR – Gasirea unui serviciu intr-un registry
JAX-RPC: Generalitati
JAX-RPC: Implementare
WSDL
Web Services

Agenda curs Design Patterns

Design Patterns

 

Capitolul 1: Introducere

1. Ce este un design pattern?

2. De ce se studiaza design pattern-urile

3. Istoria design pattern-urilor

4. Catalogarea design pattern-urilor

5. Pattern-urile prezentate in acest curs

6. „Teme” de design patterns

Capitolul 2: Pattern-ul Singleton

1. Prezentare generala

2. Implementarea Java

3. Exemplu de Java API

Capitolul 3: Pattern-ul Composite

1. Prezentare generala

2. Structura

3. Implementarea Java

4. Exemplu de Java API

5. Exemplu de cod sursa Java

Capitolul 4: Pattern-ul Factory Method

1. Prezentare generala

2. Structura

3. Implementarea Java

4. Exemplu de Java API

5. Exemplu de cod sursa Java

Capitolul 5: Pattern-ul Observer

1. Prezentare generala

2. Structura

3. Implementarea Java

4. Exemplu de Java API

5. Exemplu de cod sursa Java

Capitolul 6: Pattern-ul Template Method

1. Prezentare generala

2. Structura

3. Implementarea Java

4. Exemplu de Java API

5. Exemplu de cod sursa Java

Capitolul 7: Pattern-ul Iterator

1. Prezentare generala

2. Structura

3. Implementarea Java

4. Exemplu de Java API

5. Exemplu de cod sursa Java

Capitolul 8: Pattern-ul Strategy

1. Prezentare generala

2. Structura

3. Implementarea Java

4. Exemplu de Java API

5. Exemplu de cod sursa Java

Capitolul 9: Alte pattern-uri creationale

1. Pattern-ul Abstract Factory

2. Pattern-ul Prototype

3. Pattern-ul Builder

4. Pattern-uri creationale – Sumar

Capitolul 10: Alte pattern-uri structurale

1. Pattern-ul Adapter

2. Pattern-ul Bridge

3. Pattern-ul Decorator

4. Pattern-uri structurale – Sumar

Capitolul 11: Alte pattern-uri comportamentale

1. Pattern-ul Memento

2. Pattern-ul Chain of Responsibility

3. Pattern-ul Visitor

4. Pattern-uri comportamentale – Sumar

Agenda curs Java WebServices

Java WebServices

 

Web Services Overview

Interoperable applications with SOA

• Designing an SOA integration architecture

• Evaluating alternatives to SOA

 

Implementing SOA with web services

• Core technologies: HTTP, XML, SOAP, WSDL, JSON

• What SOA does not provide

 

XML Processing in Java

 

XML essentials

• XML syntax and namespaces

• Describing XML with schema

 

Interacting with XML from Java

• Marshaling and unmarshaling with JAXB

• Customizing XML to Java bindings

 

Defining SOAP Messages with WSDL

 

Structure of SOAP messages

• Role of SOAP in web services

• Operations, messages and faults

 

Anatomy of a WSDL document

• Defining the interfaces of a web service

• Specifying implementation

 

Generating WSDL-First Web Services

 

Architecting a web service

• Designing a service endpoint

• Specifying protocol of message interchange

• Preserving flexibility and extensibility

 

Importing a WSDL document

• Building interoperable applications by conforming to Web Services Interoperability

(WSI) standards

• Implementing a web service end point using JAX-WS

 

Customizing JAX-WS web services

• Deploying a web service WAR file

• Intercepting traffic between web services and clients

• Optimizing message transmission

 

Exposing Plain Old Java Objects(POJOs) as Web Services

 

Implementing code-first web services

• Choosing between WSDL-first and code-first web services

• Preserving maintainability with proxies and adapters

 

Designing reliable and scalable services

• Creating highly parallel web services

• Bulletproofing multithreaded web services

 

Improving generated WSDL

• Annotating Java services

• Deploying end points

 

Implementing Web Service Clients in Java

Generating client code from WSDL

• Accessing web services through their WSDL

• Customizing generated source files with JAX-WS

 

Synchronous, polling and asynchronous services

• Designing and creating one-way services and clients

• Interception and modifying SOAP messages

 

Providing Server-Side Support for Mobile and Ajax Clients

 

Stateless processing of XML requests

• Building RESTful web services using JAX-RS

• Providing client-side interactivity

 

Lightweight clients

• Invoking web services with the Dispatch API

• Processing received XML messages

 

Securing Web Services

 

Authenticating and authorizing clients

• Limiting access to web services and methods

• Providing authentication information to web services

 

Message-level security

• Transport security vs. end-to-end security

• Turning on WS-Security

Agenda curs Design Patterns & Clean Code

  • Design Principles
    • 3 Principles of OO Design
    • The SOLID principles
    • DRY
    • SRP
    • Patterns vs Simplicity. KISS
  • Creational Patterns:
      • Singleton
      • Fluent Builder
      • Abstract Factory

     

  • Factory Method
  • Structural Patterns:
      • Adapter
      • Proxy. Aspect-Oriented-Programming
      • Decorator
      • Facade

     

  • Composite
  • Behavioral Patterns:
      • Observer

     

  • Iterator
    • Strategy
    • Command
    • Template Method
    • Visitor
    • Chain of responsibility
    • Passing-a-block (Functional Programming)
  • Antipatterns
  • What is Clean Code
    • Names
      • Expressing intent
      • Parts of speech
      • Length
      • Comprehension Refactoring
    • Functions
      • Function Size
      • Factoring Methods
      • Exceptions: Best Practices
      • Function Signature
      • Extracting Method Objects
  • Side Effects & Temporal Coupling
  • Command/Query separation

 

    • Classes
      • True Encapsulation
      • Data Structures vs. True Objects
      • Logic Containers
      • Switch+Data Structures vs. Polymorphic Objects
  • ‘Tell, Don’t Ask’ Principle

 

      • Feature Envy
  • The Plugin Model: Dependency Inversion Principle

 

  • Code Formatting
  • Comments are failures
    • Expressive Code
Agenda curs Professional Unit Testing
  • Principles
  • Basics: Arrange-Act-Assert
  • Expressive tests
  • Robust Tests
  • DRY Tests
  • Fluent Builders. Object Mother Pattern.
  • Hamcrest Matchers vs Java8 asserts
  • Strategies for Testing Persistence
  • Advanced JUnit
  • Lifecycle
  • Runners
  • ExpectedException
  • Parameterized Tests
  • Mocking (Mockito or your favourite..)
  • Basic expectations
  • Throwing exceptions
  • Verifying method was called
  • [opt] Mocking methods with callbacks
  • Partial mocks, and why they are evil
  • Test-Driven Development (TDD)
  • The 3 Rules of TDD
  • TDD Mantra: Red-Green-Refactor
  • A TDD Exercise (Coding Kata)
  • Pros and Cons. When to use
  • Behavior-Driven Design (BDD) with Cucumber
  • Intro
  • Writing a .feature file: basic, data grid, parameterization
  • Mockito Integration
  • Spring Integration
  • [opt] Selenium Integration

1h talk, 1h hands-on (Bowling game kata)

Agenda curs Spring

Spring Core

  • What is Spring? Why Spring?
  • Defining and Wiring Beans: XML and @nnotation
  • Bean Lifecycles: scopes
  • Setting up Spring
  • Spring AOP
  • Externalizing Configuration; SpEL; i18n
  • Advanced Topics: @Inject, Extension points
  • Java config
  • Testing Support
  • Spring DAO
  • Spring DB access Philosophy
  • Working with JDBC: JDBCTemplate
  • Configuring JPA
  • Transaction Management
    • ACID
    • Business vs DB Transactions. Threads
    • Automatic rollback on Exception
    • Transaction Propagation
    • Declarative Transaction Management
    • Transaction Isolation
    • Spring MVC / REST
    • Basic Concepts
    • Annotation-driven Controllers
      • @RequestMapping, …
    • Working with JSPs and Forms
      • Basics: JSP, Request, Session, Servlets, Filters, web.xml
      • View Resolvers
      • JSP- and Backend Security
      • Spring Forms
    • Exposing REST endpoints
      • @RequestBody, @ResponseBody
      • @RestControllerAdvice
      • REST Security overview
  • Exposing and Consuming JAX-WS web services
  • Consuming RESTful web services

 

  • Spring Boot
  • start.spring.io
  • Auto-Configuration
  • Environment Abstraction
  • Profiles
  • Embedded Servlet Container
  • Deploying to an App Server
  • Developing a REST app with JPA
  • Spring Cloud: Bootiful Microservices copy-cat
  • start.spring.io
  • Rest JPA Repositories
  • Config Server/Client
  • Eureka Service Registry + discovery
  • Hystrix circuit breaker + fallback
  • Eventual Consistency via async messagesThis part will be finalized upon your request. I have the necessary experience: I have built and delivered several applications using Spring Batch.
  • Spring Batch
Agenda curs Hibernate/JPA
  • Phylosophy
  • References

 

  • Object-Relational Mapping 1
  • Mapping basic fields, clobs
  • Mapping relationships (1:1, 1:n, n:n); Owner side
  • Access Mode
  • Object-Relational Mapping 2
  • Mapping inheritance
  • Embeddable
  • Element Collection
  • List or Set of Children?
  • HOWTO implement Entity hashCode and equals
  • Ordered Children
  • JPA Runtime
  • EntityManager: Principles and Concepts
  • Entity Lifecycle
  • PK Generation
  • LAZY vs EAGER loading; best practices
  • Cascading
  • Orphan Removal
  • Persistence Context = 1st level cache
  • Transactions: programatic / declarative
  • @Transaction propagation; flush vs commit; rollback only
  • Auto-flush changes
  • .merge() explained
  • Concurrency Control: Optimistic, Pessimistic
  • Entity Listeners
  • JPQL
  • Basic Travelsals
  • JOIN
  • Polimorphic Queries
  • Query-specific Projections
  • JOIN FETCH
  • Syntax limitations and workarounds
  • Debugging
  • Search Query strategies: jpql+=, Criteria API, metamodel,..
  • Bootstrapping JPA
  • Standalone / with Spring
  • hbm2ddl
  • Incremental DB migrations scripts
  • DB Integration Tests: strategies, setup
  • Spring Data JPA
  • Deriving queries from method names
  • @Query
  • @Modifying and native
  • Extending common API
  • Optional and Stream support
  • Audit columns
  • Extra (on demand): fetch graphs, projections, specifications…
  • Object-Relational Mapping on Existing DB
  • Composite PK
  • Non-PK Join Conditions
  • More DB metadata: @Column and @Table, unique, index
  • Entity Validation – strategies and best practices
  • Mapping to a VIEW
  • Calling stored procedures
  • Tables with no PK
  • JPA Performance
  • Optimization Principles
  • N+1 Queries problem: 3 solutions
  • 1st Level Cache
  • Avoid selecting useless columns
  • Debate: where to process data?
  • Batch export / import strategies
  • Efficient PK generation
  • The big bad slow query
  • Batch Updates
  • fetch_size
  • 2nd Level Cache

Agenda curs Java 8
  • Java 7 features (Quick recap – warm-up)
    • Try-with-resources: Supressed Exception
    • Diamond notation
    • String switch
    • Multi-catch
  • Lambdas and Streams
    • Filtering Streams
    • Transforming Streams
    • Collecting Streams
    • Writing Clean Code with Java 8: Best Practices and Anti-patterns
  • Async and Parallel Processing with Java 8
    • Short Introduction to Performance: Why to parallelize?
    • Parallel Streams
    • Controlling Parallelism
    • CompletableFuture
Agenda curs Java Performance Optimizations
  1. Introduction
  • Your Own Performance Challenges…
  • Measure Don’t Guess
  • Core Concepts: Responsivity, Throughput, Load, Work Load, Utilization
  • Gowing Slower to go Faster: discharge the bottleneck
  • Time Budgeting
  • Stress Tests: Types2. Concurrency Patterns
  • This module explains the core Java Concurrency principles, with special emphasis on the most useful topics in day-to-day practice: the monitor object, wait()/notify() primitives and the Thread Pool Executor. The included hands-on lab will exercise these concepts and classes.
  • Basic Concepts
    • Deadlock, Live Lock, Race
    • Atomicity
    • Thread Safety
    • Cancelling an execution
  • Patterns in JDK
    • Lock
    • Semaphore
    • Latches
    • Barrier
    • Readers-Writers Lock
  • Monitor: synchronized, wait(), notify()
  • Thread Pools, Executors
  • Thread Local Storage
  • Best practices & Pitfalls3. Just-In-Time Compiler
  • Interpreted vs Compiled Code
  • Hot Spot Compiler
  • Optimizations: Static vs Dynamic
  • Example: Dynamic Optimizations with Escape Analysis
  • JIT Compiler: Levels, Monitoring
  • Code Cache
  • General Coding Advices4. Garbage Collector
  • GC Principles: Generations, Heap Fragmentation, ..
  • GC Algorithms
    • Serial Collector
    • Parallel/Throughput Collector
    • CMS Collector
    • G1 Collector
  • Choosing a GC: general guidelines
  • System.gc
  • Sizing for Heap, Generations, PermGen/Metaspace
  • Monitoring GC: jvm GC log output, jconsole, jstat, jVisualVM, HPJMeter
  • Tuning GC: Throughput, CMS
  • Thread Local Allocation Buffers5. Finding Memory Leaks
  • OutOfMemoryError: Causes
  • Out of Heap: possible leak sources
  • GC Roots
  • Investigating Leak using Tools: a full example
    • Visualize the Leak (jvisualVm, hpjmeter)
    • Heap Dump Analysis(jvisualvm, Eclipse MAT): largest set of instances for a class, path to nearest GC Root
    • Memory Profiling (jvisualVm): How many objects were just created, how many generations, by who?
  • GC Recap Quiz6. Tips for Performance Coding
  • This module gives general advice on how to write high-performance code in Java. Throughout the contents, I will often ask the attendees how would THEY implement a certain functionality already available in JVM (example: String.intern()). That’s why this module is more a brainstorm than a classic training, and motivated practitioners would make it a very-very-very interesting session. The discussions may easily divagate to general algorithms and macro-design decisions.
  • Intro: Performance in Java Enterprise App
  • Effective Memory Usage
    • Lazy Init, Eager Deinit
    • Canonicalization, String.intern()
    • Object Pools: WHY ?
    • Thread Locals
    • Weak, Soft References + Practice
  • Effective Multi-Threading
    • Amdhal’s Law
    • Synchronization Cost
    • CPU Register Flushing
    • How to Avoid Synchronization
  • Thread Pools
    • Executor Types
    • Sizing the Queue
    • Sizing the Thread Pool
    • Fork-Join-Pool (1 word)
  • Database
    • JDBC
    • JPA (+Discussions….)
Agenda curs Clean Code & Coding Dojo
  • What is Clean Code
  • Names
    • Expressing intent
    • Parts of speech
    • Length
    • Comprehension Refactoring
  • Functions
      • Function Size
      • Factoring Methods
      • Exceptions: Best Practices
      • Function Signature
      • Extracting Method Objects

     

  • Side Effects & Temporal Coupling
  • Command/Query separation
  • Classes
      • True Encapsulation
      • Data Structures vs. True Objects
      • Logic Containers
      • Switch+Data Structures vs. Polymorphic Objects

     

  • ‘Tell, Don’t Ask’ Principle
      • Feature Envy

     

  • The Plugin Model: Dependency Inversion Principle
  • Code Formatting
  • Comments are failures
    • Expressive Code
Agenda curs Scala

Day 1

  • First lines in Scala – Basic Language Syntax (4h)
    • Set-up IDE. Play with scala Interpreter
    • Variables and Values
    • Functions
    • Your 1st scala script
    • Parameterized types
    • The .apply method
    • Lists – basic stuff
    • Tuples
    • Sets and Maps – syntax
    • Functional style – intro
    • Read a file
  • Classes and Objects (4h)
    • Classes, fields, methods
    • Companion Objects
    • Your 1st main() method. The App trait
    • equals, ==, eq
    • String interpolation
    • Operators are methods. Left or right –apply ?
    • Operator Precedence
    • Rich wrappers
    • Day 2
  • Designing a Functional Object – the Rational class (4h)
    • Constructors, invariants
    • Immutability
    • Method override and overload
    • Class params vs fields
    • Access protection: private, private[this], protected, public
    • Defining an operator
  • Control structures (4h)
    • Imperatrive example
    • The “ternary” if
    • The “imperative” while
    • The “overwhelming” for: ranges, foreach, filter, flatmap, yield
    • Try {}: catch { case, throw new…, error(), Nothing return type
    • match-case
    • Refactoring imperative to functional-style
    • Day 3
  • Functions and closures (4h)
    • Local functions
    • Function literals (anonymous ad-hoc functions)
    • Shorter forms of anonymous functions
    • Partially applied functions
    • Closures
    • Repeated parameters
    • Default parameters. Named arguments
  • Control abstractions (2h)
    • Pass a the variable step as function to reduce duplication
    • Currying
    • The Loan Pattern
    • By-name parameters
  • Composition and inheritance (2h) – fill the gaps exercises
    • The uniform access principle
    • Parametric fields
    • Invoking superclass constructors
    • Factory objects
    • Day 4
  • Scala class hierarchy (2h)
    • General picture
    • Unit, Any, Nothing, AnyRef, AnyVal
    • Int, RichInt, auto-boxing
    • Custom value classes
  • Traits (2h)
    • Thin vs Rich interfaces problem
    • Mixing a trait: exercise
    • The Ordered trait
    • Stackable modifications
  • Packages (1h)
    • Nesting packages
    • Private[this], [outerclass]
    • Package objects
  • Unit tests – ScalaTest(1h)
    • Ensuring, assert
    • assertThrows
    • Day 5
  • Case Classes and Pattern Matching (3h)
    • What “case class” gives you
    • A full example (fill the gaps)
    • Types of match patterns: wildcard, constant, variable, constructor, tuple, type, variable binding
    • Pattern guards
    • Sealed classes
    • The Option type
  • Scala Collections API (2h): Hands-on exercises to explore the API
  • Overview of concepts in Play Framwork (Demo) [opt1, to ellaborate]
  • A Coding Exercise (Coding Kata)