Java Training Courses

Java Training

Java Programming Language courses

Testi...Client Testimonials

Tomcat

This was extremely informative and packed with useful information. Fulvios is a very knowledgeable trainer and very patient. I have learnt a huge amount and have a much better idea of insfrastructure. In addition, as a former trainer I have to say that the session was very well structured with each topic moving along so logically that even with brand new concepts I did not get lost. I have learnt things on this course which I have only had a fuzzy understanding of in the past. I am very glad indeed that I made the time for this. Thank you very much Fulvio!

 

Elinor Mountford - Manchester University

Tomcat

Very good course although NYSE only paid for the cut down version (2 days instead of 4) so a little more detail with the 4 day course would have need nice.

 


Lee Payne - NYSE, New York Stock Exchange

WildFly Server Administration

Trainer was excellent.

100% hands on. Very effective way of learning.

Steve Kirkland-Walton - Purple Secure Systems

Apache Tomcat and Java EE Administration

What did you like the most about the training?

There were many advises and examples on how to maintain and monitor the system. Trainer had a big knowledge on the topics.

Manuel Ruiz Santiago - RRDonnelley GDS

Java Fundamentals

What did you like the most about the training?:

Trainer was friendly and open to questions.

Ravi Shankar - AB Sandvik Coromant

Apache Tomcat Administration

What did you like the most about the training?:

Hands on, the trainer is very helpful.

The trainer is knowledgeable about the training course, he delivered it well and explained things especially with regards to our question about our environment. Training course was beneficial.

Edralyn Delos Reyes - ZE PowerGroup

Java Programming

His very good knowledge and experience.

Jérémy Coppe - PSImetals

Java Programming

I like how the trainer explain the subject. Providing real life example is beneficial.

Rhearose Holonowicz - Monika Meyer-Palus Educonnect

Apache Tomcat and Java EE Administration

Lots of information.

Matthew Wise - Matthew Wise

Apache Tomcat and Java EE Administration

Lots of information.

Matthew Wise

Apache Tomcat and Java EE Administration

Numerous topics / covered spectrum

Edward Fennen - Lippert Components

Java Spring

- Many exercices.
- Reactivity and flexibility of the Trainer.

Badii Bayoudh - PITERION GmbH

Java Spring

chances to play with code during exercises (not only coding, what trainer prepared)

- PITERION GmbH

Apache Tomcat and Java EE Administration

Trainer knowledge about the matter. Exercises done along the training.Trainer was absolutely friendly and approachable.

Jorge Peinado Prado - European Central Bank

Apache Tomcat and Java EE Administration

The trainers deep understanding of the subject matter

Andrew Gorham - European Central Bank

Apache Tomcat Administration

Training was very interactive

Mahmoud Farag - Community Network Services Ltd

Apache Tomcat and Java EE Administration

Materials, labs and extensive knowledge shown by the trainer

Richard Hennessy - Dassault Systemes Ltd

Java fundamentals with Maven

Very practical scenario and lot of hand on exercises.

Michel PRAYAG - BNPParibas Asset Management

Apache Maven

Way of approaching the subject and content of the course.

Pavithra Srinivasa - Max Planck Institute

Apache Tomcat and Java EE Administration

I liked it was intresting with lot of hot subject, absolutly can understand better the product

Annamaria Vilner - NNIT Czech Republic s. r. o.

Apache Tomcat and Java EE Administration

The training was very relevant to our work. and provided us with detailed overview and hands-on experience with Apache Tomcat technology.

Anton HIkov - NNIT Czech Republic s. r. o.

Apache Tomcat and Java EE Administration

the content of the course is good. It covers most of the important topics which we use in our day to day activities.

Prem Nandivada - NNIT Czech Republic s. r. o.

Unit Testing with JUnit

The high number of execices

Subcategories

Java Course Outlines

Code Name Duration Overview
javaprog Java Programming 28 hours This course is intended for developers who are familiar with any other procedural or structural language (such as C, Pascal, C + +, Delphi). During the training participants will learn how it is built into the Java virtual machine to install Java to write basic programs use standard libraries and create an application with a graphical interface. The course also introduces the multi-threaded programming. Introduction to Java Versions of Java Installing Virtual Machine Platform Tools Using the documentation and selected books Java Development Directions Discussion of options The syntax of the language Declarations and Data Types Simple types Reference types Flow Control Instructions Boards Object-Oriented Programming Modeling Objects: Properties and Methods Creating Objects Objects and references Classes Interfaces Packages Inheritance Abstract Classes Polymorphism Error handling exceptions The try ... catch Create your own exception types Actions inputs and outputs Streams and Filters File Handling Object Serialization Data Collections Multi-threaded Programming Multi-threaded Applications The life cycle of thread Synchronization Data protection Fundamentals of Web Application Development in Java Overview s most popular framework for creating web applications Multi-tier architecture Applications in Architecture Request / Response Call and work with the database Modeling the business application Service request and controller layer. Create views Discussion of the popular use cases
gwt GWT: Write Ajax web applications in Java, deploy as Javascript 28 hours Google Web Toolkit (GWT or GWT Web Toolkit) is a set of open-source tools for building, optimizing and maintaining complex JavaScript browser-based applications in Java. GWT is used by many products at Google, including Google AdWords and Google Wallet. In this instructor-led, live training, participants will learn the GWT programming concepts needed to get a web application up and running. By the end of this training, participants will be able to Write client-side AJAX applications in Java and deploy them as JavaScript across multiple browsers (desktop, Android, iPhone, etc.) Develop a high-performance web application while overcoming the idiosyncrasies of browser behavior, XMLHttpRequest, and JavaScript Understand and overcome the challenges of Ajax programming Use GWT's tools to optimize a web application Audience Front-end web developers Format of the course Part lecture, part discussion, exercises and heavy hands-on practice To request a customized course outline for this training, please contact us.  
RxJS Reactive Programing with Javascript and RxJS 7 hours Reactive programing is an asynchronous programing paradigm that focuses on data streams and the propagation of data by establishing a defined dependency between the underlying execution models and the emitted data streams from one component to another. RxJS is one of the most comprehensive reactive programing libraries for managing UI events, asynchronous HTTP requests, and other data streams. In this instructor-led, live training, participants will become familiar with RxJS's tools and functions as they apply them to a variety of coding problems associated with interactive-heavy based mobile and web apps. Participants will also learn how to create and deploy a UI heavy web app. By the end of this training, participants will be able to: Understand the reactive programing paradigm and its usefulness for UI heavy application development Build UI heavy applications with scalability, flexibility, and responsiveness in mind Easily and freely create and manage a multitude of UI events, asynchronous HTTP requests, and other data streams Audience Developers Format of the course Part lecture, part discussion, exercises and heavy hands-on practice To request a customized course outline for this training, please contact us.
dsgpat Design Patterns - efficient code reusability 21 hours The course will cover the design patterns. We provide design patterns trainings divided in two groups: Core patterns include (selected patterns from GoF package) some basic design patterns used throughout all modern applications and systems. They significantly increase productivity and decrease complexity of these applications introducing ready and checked ways to accomplish certain functionalities. Creational patterns: Builder Factory Prototype Singleton Structural patterns: Delegator Interface Facade Composite Immutable Adapter Decorator Activity patterns: Interpreter Command Template method Observer Proxy Java EE Patterns include (SUN Microsystems selected patterns). This selection of patterns helps to build and maintain complex and huge Java EE based projects. Following design patterns simplify design via introduction of multi-tier application design and well controlled responsibility flow. View tier patterns: Intercepting filter Front controller Application controller View helper Composite view Dispatcher view Business tier patterns: Business delegate Service locator Session facade Application service Business object Value object Integration tier patterns: Data Access Object Service activator Web service broker
atomjeeadm Apache Tomcat and Java EE Administration 21 hours Teaches attendees the fundamentals of administering Apache Tomcat and other Java EE environments. The course is a mixture of lectures and hands-on exercises. Delegates learn by doing, with immediate opportunities to apply the material they learn to real-world problems. Introduction to the Java Platform The JVM, JRE, and JDK Java SE versus EE Apache Tomcat as a lightweight servlet/JSP container, and how this differs from full-blown Java EE application servers such as WebLogic, WebSphere, JBoss, and GlassFish Architecture of Applications installed to Tomcat Understanding classes versus JARs Servlets JSPs JavaBeans JNDI and datasources Resources that your applications may call on other servers (web services, EJBs, etc.) Installing Tomcat Installing the Java Runtime Environment (JRE) Tweaking the JRE for performance Performing the actual Tomcat installation Examining the Tomcat installation directories bin conf lib logs temp webapps work Configuring Tomcat server.xml (detailed walkthrough) web.xml context.xml Deploying Java EE Applications Packaging JARs for deployment to Tomcat Packaging WARs for deployment to Tomcat Application server-neutral configuration versus application server-specific configuration Overview of EARs and other archive types not supported by Tomcat, but supported by other Java EE application servers Versioning Java EE applications Managing the deployment of updated applications Tomcat Valves AccessLog and FastCommonAccessLog RequestFilterValve SingleSignOnValve (by request) RequestDumperValve (by request) Memory management and JMX monitoring Understanding Java garbage collection Using JAVA_OPTS, JMX and JConsole to monitor and tune Tomcat memory usage Sizing Tomcat's JVM memory heap Using JMX and JConsole to configure Tomcat via Tomcat's MBeans Updating Tomcat's configuration via JMX "on the fly" without restarting Tomcat Load testing with JMeter Using VisualVM (new monitoring tool built into JDK 6) and PSI Probe Controlling JMX MBeans via Ant Logging and Troubleshooting JULI logging log4j logging Understanding exceptions and thread dumps Troubleshooting errors that occur in Tomcat Troubleshooting errors generated by your deployed applications Troubleshooting strategies applicable to application servers other than tomcat Connecting databases with Tomcat applications Classic JDBC approach Better approach: JNDI resources Setting up and monitoring database connection pools Security File system security Java security manager Realms, authentication, and authorization SSL Java VM and Tomcat Performance tuning strategies Additional JVM tuning tips Enabling parallel garbage collection Building native connectors Disabling/removing unneeded applications Tuning incoming connections and database connection pools Turning off Jasper development mode Precompiling JSPs Preloading servlets Application-specific tuning suggestions Tuning levers available in other application servers The World Beyond Tomcat: Understanding Java EE Applications Explanation of the Java EE APIs not supported by Tomcat: EJB, JMS, and many others 3rd party application frameworks overview (what they are and what administrators should know): Spring, Struts 1/Struts 2, JSF (including a discussion of ICEfaces, RichFaces, etc.) Data tier frameworks and what administrators should know (Hibernate, JPA, etc.) Features offered by WebLogic, WebSphere, and JBoss that are not found in Tomcat Tomcat Other Features Memory leak prevention and detection Servlet 3.0, JSP 2.2, and EL 2.2 support (and the practical implications of this for Tomcat admins) Cross-site request forgery prevention (and how to configure) How Tomcat 7's new session management features prevent session fixation attacks Alias support (which allow static content to be stored outside the WAR file) Running Tomcat behind Apache httpd or IIS [this section would be taught using your web server and connector module of choice] Why run Tomcat behind Apache httpd or IIS? Installing mod_jk (Apache or Tomcat) or mod_proxy_ajp and mod_proxy_balancer (Apache 2.2 or later only) Proxying traffic to Tomcat via AJP Monitoring the status of your web server's connection to Tomcat Load balancing Tomcat via mod_jk or mod_proxy_balancer Tomcat Clustering Configuring mod_jk (in Apache or IIS) or mod_proxy_balancer (Apache 2.2 or later only) as a load balancer Hardware load balancing as an alternative to software load balancing Sticky sessions Configuring a shared session back-end FileStore/JDBCStore (older approach, generally not recommended) Using the <Cluster> tag Configuring the application to be distributable Setting up and testing failover
reactivex Reactive Programing with Javascript and ReactiveX 14 hours ReactiveX is a comprehensive library for creating asynchronous data streams using observable sequences. It enables developers to take advantage of observable streams and their ability to capture emitted events and execute functions accordingly. This instructor-led, live training introduces participants to ReactiveX's comprehensive library for developing responsive applications and walks participants through a series of cases, demonstrating the usefulness and functionality of key features of ReactiveX. By the end of this training, participants will be able to: Understand the reactive programing paradigm and the functionality of observables and their common use when developing UI heavy applications Successfully setup an environment for ReactiveX Create observable events form a multitude of varying items Apply ReactiveX's transforming and filtering functions Audience Developers   Format of the course Part lecture, part discussion, exercises and heavy hands-on practice To request a customized course outline for this training, please contact us.
javaappsh Spring and Hibernate in Java Applications 21 hours The course covers issues related to the creation of Java applications with particular emphasis on technology widely used today in applications such as application frameworks for building Spring and Hibernate. The participants at the end will have knowledge to design applications and to select the appropriate technology for a specific solution. Enable understanding of known issues discussed in the course of libraries, specifications and technologies. Component-oriented programming Design Pattern Inversion of Control and Dependency Injection Architectural Overview Spring Spring Application Context Configuration files Mapping objects Factory components and its use Programming in Spring AOP The use of new technologies in the Spring MVC Spring Create an application using Spring MVC Combining Spring MVC with Java Server Faces Introduction to Hibernate Architecture/Structure The life cycle of objects and identify objects Hibernate in Action Mapping tables on POJO category Construction of POJO category Mapping properties of the columns in the tables Establishing relationships between objects Transactions in Hibernate Local and global transactions Overview of API transactions Levels of transaction Language HQL - Hibernate Query Language Combining Hibernate and Spring applications
OpenSearchServer OpenSearchServer 7 hours OpenSearchServer is an open-source application server used to develop index-based applications such as search engines. Written in Java, it can be integrated into other applications without using Java code. In this instructor-led, live training, participants will learn set up, configure, manage and extend OpenSearchServer. By the end of this training, participants will be able to: Run OpenSearchServer as a standalone server with a servlet container Configure OpenSearchServer's integrated crawler for databases, web pages and rich documents Develop a sample application using OpenSearchServer's Zkoss-based web UI Integrate search results into a page using the HTML renderer Monitor and administer OpenSearchServer Extend OpenSearchServer's features using its plugin architecture Audience System administrators DevOps engineers Format of the course Part lecture, part discussion, exercises and heavy hands-on practice To request a customized course outline for this training, please contact us.  
jav9functional Functional Reactive Programing with Java 9 and RxJava 14 hours Java 9 coupled with the robust RxJava 2.0 reactive programing library, enables Java developers to adopt and apply the reactive programing paradigm into their application and systems development processes with great ease.  In this instructor-led, live training, participants will learn the advantages and functions of Java 9, Spring, Jersey, and RxJava 2.0 in developing reactive applications as they step through the creation and deployment of a real-life reactive application using Java 9's flow API, Spring, the Akka framework, and RxJava 2.0 functional reactive programing library. By the end of this training, participants will be able to: Understand the importance and significance of reactive programing in applications and systems development Run Unit test on RxJava 2.0 Use the Akka framework under reactive programing principles Employ Spring to handle the development of concurrent applications Use Java 9's flow API to develop reactive apps Audience Developers Format of the course Part lecture, part discussion, exercises and heavy hands-on practice To request a customized course outline for this training, please contact us.
javatesting Introduction to Java for test automation 28 hours This course is designed for anyone interested in learning Java for the purpose of test automation. It is a streamlined, intensive course with plenty of hands-on exercises to get participants ramped up quickly with the essential programming skills needed to apply to software automation testing. The focus is on the Java fundamentals which can be directly and immediately applied to test automation. This course does not cover in depth test automation frameworks such as Selenium. It also bypasses the conventional "Hello World" approach to learning Java, as this is not a course on application development. This course is squarely aimed at getting participants up and running quickly with test automation. If you are already versed in Java and wish to get straight into testing with Selenium, please check out: Introduction to Selenium (https://www.nobleprog.com/introduction-selenium-training). Audience Beginner testers who wish to learn Java for automation testing Professional testers with experience in other programming language such as Javascript and C# who wish to transfer their skills to Java. Format of the course Part lecture, part discussion, heavy hands-on practice Introduction Installation and setup Java programming - getting started Overview of JUnit Writing your first Unit test Understanding JUnit assertions JUnit annotations (@Test) Java methods as @Test methods Using and creating Java classes Importing packages Java data types and operators Implementing conditions and loops in your test script Understanding Java arrays Other ways to iterate through your code Catching and throwing exceptions Understanding Java inheritance Handling exceptions Manipulating strings Working with numbers Working with dates and times Java Property files Reading and writing files Logging Using abstract classes Using regular expressions Closing remarks
wfsadm WildFly Server Administration 14 hours This course is created for Administrators, Developers or anyone who is interested in managing WildFly Application Server (AKA JBoss Application Server). This course usually runs on the newest version of the Application Server, but it can be tailored (as a private course) to older versions starting from version 5.1. Module 1: Installing Core Components Installing the Java environment  Installing JBoss AS Application server features Creating a custom server configuration Module 2: Customizing JBoss AS Services How to monitor JBoss AS services JBoss AS thread pool Configuring logging services Configuring the connection to the database Configuring the transaction service Module 3. Deploying EJB 3 Session Beans Developing Enterprise JavaBeans Configuring the EJB container Module 4: Deploying a Web Application Developing web layout Configuring JBoss Web Server Module 5: Deploying Applications with JBoss Messaging Service The new JBoss Messaging system Developing JMS applications Advanced JBoss Messaging Module 6: Managing JBoss AS Introducing Java Management Extension JBoss AS Administration Console Managing applications Administering resources
apachetomcat Apache Tomcat Administration 21 hours An overview and explanation of how Tomcat relates to Java EE (J2EE) and compares to other application servers The Installation and setting up Tomcat on both Windows and UNIX-type environments Deploy, support, and troubleshoot applications on Tomcat Navigate Tomcat's directory structure Tomcat's architecture and configuration files: server.xml, context.xml, .properties, etc. Web application structure and configuration: web.xml Secure Tomcat and applications running on it and Setting up Tomcat for SSL Tune Tomcat's performance Exploration of different load-balancing and high-availability strategies with Tomcat Tomcat Overview  Quick overview of Apache Apache Software Foundation Jakarta Project Tomcat Licensing J2EE Technologies Java Web Development Servlet/JSP Containers Java Web Applications An Overview of Servlets The Advantages of Servlets & The Lifecycle JavaServer Pages JSP, JavaBeans and JSP Tag Libraries MVC frameworks Installing Tomcat Downloading and Installing Apache Tomcat Download and install a JVM, Download Tomcat, Download and install Ant Windows installer Java memory management and tweaking the JVM for performance Tomcat Directories Tomcat Installation Directories, Tomcat Directory Structure, The bin Directory, Common and shared Directories The conf Directory, logs Directory. server directory, work Directory, temp Directory, webapps Directory Stucture of the Web Application Directory Structure Deploying HTML and JSP Pages and Web Context JSP Page and the Generated Code Deploying a Web App ConfiguringTomcat Configuration of Tomcat and looking at the Techniques Tomcat's Component Architecture The <Server> Element, <Service> Element, <Connector> Element, <Engine> Element, <Host> Element, <Context> Element, <Realm> Element, <Valve> Element, <Listener> Element, <Loader> Element, <Manager> Element Server.xml File Modifying server.xml Web Applications Web Application Administration & Deploying Directory Structure of a Web App web.xml configuration file Deployment Descriptors The <web-app></web-app> Element Mapping a Servlet to a URL The <resource-ref></resource-ref> Element The <env-entry></env-entry> Element The <ejb-ref></ejb-ref> Element A Sample web.xml file Deploying a Web Application Tomcat's default conf/web.xml file Tuning default JSP and Static-content servlets Tomcat Manager Deploying and Managing Web Application using the Tomcat Manager Starting the Tomcat Manager and looking at Tomcat Manager Looking at the Manager Section Applications, Deploy, Server Information Creating a WAR File Lab 4: Deploying a WAR File Java Management Extensions (JMX) on Tomcat Tomcat integration with Ant Advanced Features Using Some of the Advanced Features of Tomcat Valves, Access Log Valve, Single Sign-on Valve Remote Address Filter and Remote Host Filter Request Dumper Valve Configuring the JNDI Resources JNDI: Java Naming and Directory Interface and Defining a JNDI Resource The <environment></environment>Element and The <resource></resource>Element Configuring a JavaMail Session Global Resources JDBC Connectivity Configuring Tomcat to Connect to a Database Overview of JDBC JDBC Drivers Connecting to a Database and Connection Pools Download and Install MySQL Configure MySQL for Tomcat Create a Database in MySQL Download and Deploy a JDBC Driver Defining a DataSource in Tomcat and Defining a Data Source Manually Modifying the Deployment Descriptor Detecting and closing leaked database connections Tomcat Security Looking at Security on Tomcat and the configuration Security Considerations File System Security and Filesystem Recommendations Java Security Manager Granting Permissions to Java Apps and looking at Java Permissions Creating and Adding Your Own Policies Enabling the Java Security Manager Security Manager Tips and Security Realms Looking at the different Types of Realms and Configuring a Realm Users and Roles (authentication and authorization) Creating a Data Source Realm The protection of passwords FORM-based authentication Configuring Tomcat for SSL Requiring SSL in applications Connecting Connect Tomcat to Apache Looking at Connectors HTTP Connectors Advantages of Using a Web Server Connector Protocols Configure an AJP Connector Download mod_jk Create the mod_jk.conf file Start Tomcat Create a Worker Configure httpd.conf Test the Setup Load balancing applications across multiple Tomcat instances Issues with load balancing Server affinity via sticky sessions Shared session storage Replicated sessions via Tomcat clustering Shared Hosting Tomcat Virtual Hosting Configure Tomcat to enable virtual hosting as a stand-alone server Configure Tomcat to enable virtual hosting using jk2 or webapp. Configure Tomcat as Stand-alone Configure Tomcat with AJP Separate JVM for Each Host Load Testing JMeter Application Load Testing with JMeter Install and run JMeter Creating a Test Plan Configure the Thread Group and adding a task Configure the HTTP Request Add a Report Listener Run the Test Plan Viewing the Results
undertow Undertow: Embed a Web Server into Your Application 7 hours Undertow is a lightweight web server written in Java. It is used by JBoss's WilfFly internally and is popular as an embedded web server for JVM-based applications. In this course, participants will learn how to set up an Undertow web server as a standalone and embedded web server. By the end of the course, participants will have an understanding of Undertow's architecture, features and capabilities and will be able to: Deploy and manage an Undertow server in standalone as well as embedded mode Embed Undertow into application code using Undertow's embedded APIs Integrate Undertow into a Wildfly Application Server Set up Undertow as the embedded servlet container for Spring Boot Audience System administrators Enterprise web application developers DevOps engineeers Developers Format of the course Part lecture, part discussion, exercises and heavy hands-on practice To request a customized course outline for this training, please contact us.
springboot Spring Boot: Rapidly build Spring-based web applications 14 hours Spring Boot is a Java-based web application development framework that favors convention over configuration. Spring Boot allows developers to create stand-alone, production-grade applications that "just run", typically on an embedded instance of Tomcat, Jetty, or Undertow. Spring Boot's "opinionated view" of the Spring platform and third-party libraries allows for minimum-fuss application development that requires very little configuration. These Spring Boot applications require no code generation or XML configuration. They feature integrated health monitoring, simplified Maven configuration, and a host of other features that make building, deploying, and running Spring applications relatively straightforward. In this training, participants learn the key features and architecture of Spring Boot, and its relationship to the underlying Spring framework. Ample opportunities for applying this knowledge and receiving feedback is provided by the instructor as participants step through live, hands-on exercises on defining, configuring and deploying Spring applications. By the end of the course participants will have the necessary knowledge and practice to rapidly deploy their own Spring application. Audience     Java web application developers Format of the course      Heavy emphasis on hands-on practice. Most of the concepts are learned through samples, exercises and hands-on development. Introduction      Spring Framework: from 2002 to now      Spring Boot: building on top of the Spring framework Spring Boot architecture and fundamentals Overview of MVC Initializing your project in Eclipse Using Groovy to script Spring Boot Using Spring Boot CLI Building and deploying an application Using templates to serve up dynamic HTML Running Spring Boot application starters Accessing data with Spring Data Configuring Spring Boot properties Spring Boot metrics and health checks Securing your application with Spring Security Authentication and authorization Interacting with a JMS broker Closing remarks
564 Java SE 7 Programmer Certification Preparation 21 hours Java Basics Working With Java Data Types Using Operators and Decision Constructs Creating and Using Arrays Using Loop Constructs Working with Methods and Encapsulation Working with Inheritance Handling Exceptions Java Class Design Advanced Class Design Object-Oriented Design Principles Generics and Collections String Processing Exceptions and Assertions Java I/O Fundamentals Java File I/O (NIO.2) Building Database Applications with JDBC Threads Concurrency Localization
resin Resin: Setting up a Java Application server for web applications spanning hundreds of servers 14 hours Resin is a fast and reliable open-source Java Application Server for web applications spanning hundreds of servers. Originating as a Servlet and JSP engine, Resin today supports Web Profile, CDI and EJB. Resin includes a high performance JTA transaction manager, a JMS provider, clustering, connection pooling, and a management console. Resin is used by companies such as CNET, Motorola and Salesforce.com. In this course, we cover the essentials of installing, configuring, securing, optimizing and managing a Resin application server. By the end of the course, participants will have a firm understanding of Resin's architecture, features and capabilities and will have will the practice needed to deploy and manage their own Resin application server. Audience     System administrators     Enterprise web application developers     DevOps engineeers Format of the course     Part lecture, part discussion, heavy hands-on practice Introduction Installation Overview of the Resin directory structure Starting the Resin server Configuring Resin Monitoring and administration Deploying local and distributed applications Connecting to multiple databases Using Resin's logging features Working with the Resin HTTP server Security: setting up authentication and authorization in Resin Developing applications with Resin Testing applications with Resin API for JUnit Deploying with Resin Clustering and load balancing your Resin server Performance tuning for Resin Closing remarks
cubaplatform Cuba Platform for Enterprise Application Development 7 hours Cuba Platform is an open-source Java web framework for enterprise applications. In this instructor-led, live training, participants will learn how to use Cuba Platform to develop enterprise applications with rich web interfaces. By the end of this training, participants will be able to: Develop Java applications and UIs using a declarative user interface, without using HTML, CSS or JavaScript Reduce boilerplate code and facilitate rapid development Use the CUBA Studio web development tool with existing Java IDEs Customize applications without branching the code Audience Developers Format of the course Part lecture, part discussion, exercises and heavy hands-on practice To request a customized course outline for this training, please contact us.
accumulo Apache Accumulo: Building highly scalable big data applications 21 hours Apache Accumulo is a sorted, distributed key/value store that provides robust, scalable data storage and retrieval. It is based on the design of Google's BigTable and is powered by Apache Hadoop, Apache Zookeeper, and Apache Thrift.   This courses covers the working principles behind Accumulo and walks participants through the development of a sample application on Apache Accumulo. Audience     Application developers     Software engineers     Technical consultants Format of the course     Part lecture, part discussion, hands-on development and implementation, occasional tests to gauge understanding Introduction Installing Accumulo Configuring Accumulo Understanding Accumulo's data model, architecture, and components Working with the shell Database operations Configuring your tables Accumulo iterators Developing an application in Accumulo Securing your application Reading and writing secondary indexes Working with Mapreduce, Spark, and Thrift Proxy Testing your application Troubleshooting Deploying your application Accumulo Administrative tasks
gfsjeeint Administering GlassFish Server with Java EE applications introduction 21 hours Introduction to GlassFish Server Overview of the Java EE Architecture GlassFish Background GlassFish Basic Architecture GlassFish Basic Features Installing and upgrading Installation Upgrade Administering and deploying applications Administration High Availability Administration Security Application Deployment Message Queue Administration Troubleshooting Troubleshooting Error Message Scaling and tuning the performance Deployment Planning Performance Tuning Developing applications Your First Cup: An Introduction to the Java EE Platform The Java EE Tutorial Application Development Guide Message Queue Developer's Guide for Java Clients Message Queue Developer's Guide for JMX Clients Message Queue Developer's Guide for C Clients Extending and embedding Add-On Component Development Guide Embedded Server Guide
javaeejboss Enterprise Java Programming with Java EE and JBoss (EJB 3.0) 28 hours This 4-day course is for programmers who already know the Java language and wish to exploit the Enterprise Java Beans 2.0 technology while becoming aware of the security implications of distributing applications. This course has a large practical component which includes developing an e-commerce application based on Enterprise Java Beans. The course uses the JBoss Application Server. Enterprise Java Programming From client-server to 3-tier architecture Design considerations Security considerations Naming Services Comparison of RMI, CORBA and EJB Java Naming and Directory Interface (JNDI) JNDI Architecture Service Providers and the Service Provider Interface The Initial Naming Context Looking up objects Creating, searching and destroying directory entries Exercise 1: JNDI File Search Introducing Enterprise Java Beans (EJB) EJB concepts and versions Component Transaction Monitors Commercial implementations The EJB Architecture Persistence and transactions Java EE and EJB Deployment The JEE environment and tools Configuring Java EE JEE and JNDI Naming EJB packaging and deployment The deployment tool The Hypersonic Database Exercise 2: Set up JBoss EJB Clients Types of client Java clients Web and JSP clients Servlets and WAR files Exercise 3: Write and Deploy a Servlet Client JPA The role of an JPA Configuring an JPA Exercise 4: JPA/li> Stateless Session Beans The roles of Session Beans Creating Session Beans Stateless Session Beans Exercise 6: Stateless Session Bean Stateful Session Beans Stateful Session Beans Exercise 7: Stateful Session Bean EJB Implementation Issues Meta data Transaction management 1-1, 1-many, many-1 and many-many associations EJB versions The Java Messaging System The Java Messaging System (JMS) Exercise 8: JMS Security Users and roles Access control Authentication Exercise 9: JBoss Security Message Driven Beans The Message Driven Enterprise Bean Exercise 10: Message Driven Bean
jbehave JBehave: BDD with Java 7 hours JBehave is an open-source, Java-based BDD framework for writing tests in a natural language style. BDD, or Behavior Driven Development, is an agile software development technique that encourages collaboration among developers, QA and non-technical business people in a software project. This training begins with a discussion of BDD and how the JBehave framework can be used to carry out BDD testing for web applications. Participants are given ample opportunity to interact with the instructor and peers while implementing the concepts and tactics learned in this hands-on, practice-based lab environment. By the end of this training, participants will have a firm understanding of BDD and JBehave, as well as the necessary practice and toolset to write test cases for real-world software test scenarios. Audience Testers and Developers Format of the course Heavy emphasis on hands-on practice. Most of the concepts are learned through samples, exercises and hands-on development. Introduction     Business Driven Development (BDD) and Acceptance Test Driven Development (ATDD)     BDD as a collaboration tool for software engineers, test engineers and business people Defining your project requirements Setting up your environment for web application testing Writing your stories in a user-friendly language The anatomy of a textual scenario Writing your first textual scenario Writing and annotating the Java method Passing parameters to the method Passing multiple arguments Sharing data between methods Organizing your scenarios Setup and teardown Closing remarks
apachemaven Apache Maven 21 hours According to your profile Maven will help you in your day to day work. As we mention some of the benefits: Developers: As a developer you will be using Maven to create projects, manage the dependencies, compile your code, run your tests, deploy your components … Maven will become part of your every day development tools. Technical lead profiles: Integrating Maven as a build tool will have significant impact on the project:  Managing dependencies will become easy (Maven dependency management) Complex builds will be significantly simplified (Maven build profiles) The project architecture will be managed smoothly (inheritance and multimodule projects) …. Project Managers: Maven will enforce standardization and collaboration: “Project Object Model” is the standard Maven introduces for projects Maven uses build lifecycles for developers to compile , test and report, deploy Maven repositories will act as a common store and gather releases and third party libraries …. Release Managers: Maven repository managers will act as highly configurable proxies between your organization and public Maven repositories they also provide an organization with a deployment destination for your builds. This course is a sequence of theory and hands on practice. A multimodule project is developed throughout the session and all the introduced concepts are apprehended by the graduates.  Introducing Maven Why Maven o Maven’s objectives  Key features Comparing Maven and Ant  Eclipse IDE and Maven installation Getting started Project specification Creating the first modules Project directory structure First concepts Project coordinates Maven repository The POM Build Lifecycle, plugins and goals Clean lifecycle Default lifecycle Site lifecycle Package specific lifecycles Common lifecycle goals Site generation Building a project site Customizing the site descriptor Site directory structure Project documentation Unit test and reports (Surefire Report Plugin) Goals Usage  Using JUnit Dependencies Maven's Dependency mechanism Dependency Scope Viewing Dependencies Transitive Dependencies Conflict resolution Dependency management Properties Maven properties Project Properties Settings properties Environment variable properties User defined properties Resource filtering Build profiles Build portability Override a POM Profile activation External profiles Settings profiles More about the POM POM Inheritance Multimodule projects POM Best practices  Repository management Nexus and the enterprise Repository Using Nexus Configuring Maven for Nexus Nexus configuration Repository operations
jcapsdaadv OpenESB-Java CAPS for developers and architects advanced level 14 hours This course is dedicated to developers and architects who want to be operational immediately on OpenESB and want to start and be involved on real OpenESB projects. The training scope covers the advanced OpenESB concepts frequently used in projects like correlation and compensation. This 2 day course will allow you to serenely tackle your integration in operational OpenESB projects. SOA development Process Introduction to service oriented development process Fault and exception management in BPEL Faults and Exception management in BPEL Faults, exceptions, Catch, Handlers Advanced concept and exercises BPEL Compensation Introduction to compensation in a BPEL process Advanced concept and exercises BPEL Correlation Introduction to Correlation in a BPEL process Advanced concept and exercises BPEL mapper advanced Features BPEL mapper advanced Features (Predicate, Java calls…) Transaction, Guarantee of delivery, consistency with OpenESB Advanced lecture on Guarantee of delivery consistency concept with OpenESB Exercises 50% of the time is dedicated to practical use cases and exercises
javaadvanced Java Advanced - one day 7 hours Introduces contect for Advanced java programmers, usually developing large scale applications, frameworks or libraries. This course is mostly labs (around 60%), the rest is discussions and presentation. We mostly use the newest version of Java for this course, but it can also be delivered as a private course on older versions of Java.Generics Why, when and benefit/cost of Genercis Type Erasure Type Boundaries Wildcards Generic Methods Multithreading Java Thread System Managing Threads Interacting with Threads and Thread State Thread Synchronization Volatile Fields and Synchronized Methods wait and notify pattern join and sleep pattern Concurrency API Atomic Operations Thread Pools Reflection When to use and when not to use reflection Uses for Meta-Data The Reflection API The Class<T> Class The java.lang.reflect Package Reading Type Information Navigating Inheritance Trees Dynamic Instantiation Dynamic Invocation Reflecting on Generics Accessing private fields using reflection Annotations Aspect-Oriented Programming (AOP) Built-In Annotations Annotations Model Annotation Types and Annotations Annotations vs. Descriptors (XML) Multi process communication  Shared memory Socekts Non-Blocking Sockets TCP URL Objects HTTP and Other TCP Servers Datagram Clients and Servers Multi-Threading in Servers
java8spring Java 8 and Spring 35 hours This 5 day course is for Java developers who wish to gain familiarity with the new features of Java 8 and with the Spring framework. Java 8 Lambdas Predicate Generics revisited Optional Streams Date and time API Spring Framework OO principles Inversion of Control Spring ApplicationContext BeanFactory XML configuration files Dependency Injection Why dependency injection? Injection through setters Injection through constructors Setters versus constructors Spring JDBC DAO design pattern POJO to database mapping Database queries Spring MVC MVC design pattern DispatcherServlet Controllers Models JSPs Spring Validation Validation mechanisms Displaying error messages
javafunandroid Java Fundamentals for Android 14 hours Applications for the Android platform are developed primarily in Java. This course was developed for software programmers with a strong OOP background (whether in PHP, Scala, C++, C# or Objective C) that plan to learn how to develop Java applications for the android platform. This course covers the Java programming language grammar and focuses on those specific Java capabilities the android platform uses more than others. Let's Start History JVM JDK JRE Hello World JavaDoc Classes & Packages API Documentation The Basic Java comparing with C++ Simple Output Remarks Native Data Types Variables Keywords Identifiers Expressions & Operators Simple & Compound Statements Control Statements Looping Statements Assignments Local Variables Assertion Annotations Introduction to OOP Software Development Cycle Objects & Classes Key Features of OOP Relationships between Objects Object Oriented Programming Objects Classes & Class Type Variables Declaring Classes, Class Type Variables Calling a Method The 'this' Special Keyword Class Declaration Declaring Attributes Declaring Methods Methods Overloading Declaring Constructors Default Constructors Overloading Constructors Using 'this' within Constructors Static Variables Static Methods Static Initializers Final Variables Software Packages Package Statement The 'import' Statement Declaring Enums Java API Documentation Arrays & Strings Array of Native Type Values Array of Objects Square Brackets Position Copying Array Values Multi Dimensional Array The 'length' Variable The 'String' Class Instantiating String Comparing Strings The 'toString()' Method The StringBuffer Class The StringBuilder Class The StringTokenizer Class Passing Arguments to 'main' Method Inheritance Introduction to Inheritance Inheritance in Java Derivation Syntax Inheritance Meaning Constructors & Inheritance Access Modifiers Overriding Methods Polymorphism Constructors & 'super' Keyword Abstract Class Interfaces The 'instanceof' Operator Casting References Deprecated Methods The 'object' Class Inner Classes Inner Classes Types In-Depth Meaning Inner Classes within Methods Anonymous Inner Class Static Inner Class Exceptions Handling The Exceptions Handling Mechanism Exceptions Classes Hierarchy Three Types of Exceptions Try&Catch Statement The 'throw' Command The Throwing Chain The 'finally' Block The 'throws' Adding The 'Handle or Declare' Rule Methods Overloading, Samples Threads Basics What is a Thread? The Thread Parts Creating New Thread Starting The Thread Multiple Threads I/O Streams Java I/O Overview I/O Streams Categories Byte & Char Streams The InputStream Abstract Class The OutputStream Abstract Class Writing/Reading To/From Files Generics Introduction Subtypes Wildcards Collections Introduction Performance Set List Queue Map
javaint Java Intermediate - one day 7 hours Participants who are already Java programmers who want to extend their horizon and used more Java language concepts.Review Inheritance and Intefances Object References vs Inheritence Polymorphism Interface Static and Default Methods Collections and Generics Generics (Inheritance, Wildcards) Writing Generic Types Design Patterns Object Creation Static methods and fields new Operator Creation Patterns Inheritance vs Composition / Pros and Cons Composite Pattern Inner Classes Reflection The class called Class Finding Fields, Methods, and Constructors Accessing Fields, Invoking Methods Examining Arrays Annotations Annotations in the Java API (@Override, @Deprecated) Defining Annotations Functional Programming Lambda Expression Overview Lambda Expressions and Functional Interfaces Using Lambda Expressions Working with Method References The Stream API Streams and Collections Filtering Collections Chaining and Pipelining Date/Time API Legecy APIs The Date/Time API (JSR 310) Date-Based and Time-Based Events Timestamps, Periods, and Durations Performing Calculations Formatting Localization / Time Zones JUnit Basics JUnit Overview, Test Driven Development Tests and Assertions Working With Exceptions Organizing Tests with JUnit Writing Fixtures - @Before, @After Test Suites, and Other Capabilities Mock Objects Overview Build Tools Ant Overview Maven Overview
javafunmanven Java fundamentals with Maven 28 hours The course covers the basics of Java development and introduces the Apache Maven software project management and comprehension tool. Getting Started The Java Technology Phenomenon How to write basic "hello world" application How to compile and execute Java code How to make the code a bit more complex Introducing Apache Maven Convention over Configuration Maven Plugins Conceptual Model of a Project Installing and Running Maven Downloading and Installing Maven Testing a Maven Installation Getting Help with Maven A Simple Maven Project Creating a Simple Project Building a Simple Project Simple Project Object Model Java Syntax Object-Oriented Programming Concepts Variables, arrays, data types, operators, and control flow What are reference variables Classes and objects What inheritance is and how it works What Interfaces are, why they are written and how How to use Java String and Number objects and how to format data for output What packages are for and why we must use import directive Java Objects Java classes overview Java class life cycle Class modifiers and inheritance Overloading" and overriding Class constructors Polymorphism Relationships: IS and HAS 'static' keyword When to use static members Using objects within an application deployed with Maven Customizing a Maven Project Customize Project Information Add New Dependencies Add Resources Building a Packaged Command-Line Application Optimizing and Refactoring Maven POMs POM Cleanup Optimizing Dependencies Optimizing Plugins Final POMs Java Collections Collection interface Lists, maps and sets Collections and arrays Concurrency Manage collections with an application deployed with Maven Java Memory Garbage collector Heap and stack Object life cycle 'finalize()' method Java Exceptions The general idea of Java Exceptions Runtime and 'real' exceptions Throwing an exception 'try...catch' statements 'throws' declaration Designing your own exceptions Test and manage exceptions with an application deployed with Maven A multimodule project with Maven Building the Multimodule project Running the Multimodule application Java Concurrency Threads and concurrency Threaded tasks Joining threads Class variables visibility Build and run a multithread application with Maven
struts2 Struts 2 Framework 21 hours This course deals with developing MVC (Model-View-Controller) web application using the features of Struts2 framework. The participants will learn how to work with the actions and the data, how to develop interceptors and the OGNL for type conversion. This course will also cover concepts like validation, internationalization and how to persist data. Introduction to Struts2 Web applications: a quick study Why use a framework for web applications The Struts2 framework and the declarative architecture The support of annotations Actions and Interceptors The role of actions Implementing and packaging actions How to dialogue with data The role of interceptors Developing and declaring interceptors The request/response life cycle OGNL (Object-Graph Navigation Language) The common tasks in a web application Data transfer and type conversion The built-in converters How to build a custom type converter How to validate data The validation framework Using the built-in rules Writing a custom validator Writing the actions for validation Internationalization Java i18n and Struts2 framework How to use Struts2 i18n The default local determination Struts2 integration and the persistence layer Using Spring with Struts2 The concept of injection Why use the JPA with Struts2 Integrating Struts2 with Hibernate
apakar Apache Karaf 21 hours Apache Karaf training is for developer and system administrators who need to discover and understand how to use Apache Karaf as an operating environment in the best possible way. Developers will learn the best practices for designing applications that fully integrate into the system, while administrators gain operational experience. Installing Apache Karaf Prerequisites Obtaining Apache Karaf Commanding the Runtime Command Review Common commands Remote console access Apache Karaf client Custom command creation Karaf command archetype Karaf custom command project JMX console Configuration and Tuning Startup properties Logging properties File logging Console logging System properties Configuring Karaf Environment variables Configuring hot deployment Console configuration commands Web console Failover configuration Startup properties Provisioning Apache Maven repositories The Karaf system repository Apache Karaf features Deploying Applications Deploying bundles Building bundle Deploying the bundle using Maven Deploying a bundle using the file handler Deploying a bundle using  HTTP Deploying a bundle using  hot deployments Deploying afeature description Deploying non-OSGi JARs (wrap) Deploying WAR Deploying Spring/Blueprint Creating and deploying a Karaf Archive Deploying Production-grade Apache Karaf Offline repositories Improving application logging Installing Karaf as a service Master-slave failover Child instances Basic security configuration Managing roles Password encription Locking down JMX access Apache Karaf Cellar Node discovery Cluster groups Cloud discovery  
3627 Introduction to Programming 35 hours The purpose of the training is to provide a basis for programming from the ground up to the general syntax of programming paradigms. The training is supported by examples based on programming languages ​​such as C, Java, Python, Scala, C #, Closure and JavaScript. During the training, participants gain a general understanding of both the programming patterns, best practices, commonly used design and review of the implementation of these topics through various platforms. Each of the issues discussed during the course are illustrated with examples of both the most basic and more advanced and based on real problems. Introduction What is programming and why should devote his attention History of programming Opportunity to automate tasks using the software The role of the programmer and the computer in the enterprise Programming today the development of the current market trends Declarative and imperative programming. How or What? Turing machine Consolidation, compilation and interpretation "on the fly". Reminder issues of logic and Boolean algebra predicates logical sentences tautologies Boolean algebra The first program structurally functionally object And how else? Simple types Representation of strings Integers Floating-point numbers Boolean Type Null A blank or Uninitialized Strong and weak typing Data structures Concepts FIFO and FILO Stacks Queues Declaring arrays and lists Indexing Maps Records Trees Operators Assignment Operators. Arithmetic operators. comparison Operators And a comparison of the values ​​in different languages Bitwise Concatenation Increment and decrement operators The most common errors Controlling the program The if, if else instructions Goto instructions, discuss the problems of application. The switch The for loop, for-in The while loop, do-while foreach loop Stopping loop Creating a reusable code Functional Programming Object-Oriented Programming Functional programming paradigms What is the function of Function and procedure Fundamentals of lambda calculus Function Arguments Returning values Functions as arguments Anonymous functions Closures Recursion The paradigms of object-oriented programming Representation of entities from the real world entities in philosophy, ontology Deciding what you want to object, or other types of Declaration of classes Creating instances of classes Fields, a state of the object Methods, as the behavior of an object abstraction Encapsulation Inheritance polymorphism Association and aggregation Delegation and separation of relationships between objects Modules, packages and libraries Sharing API The modeling of the system as classes and objects Describing and programming relationships between classes Program from a business perspective Good programming practice Pitfalls and common errors High-level code in the interpretation of low-level Code optimization KISS principle DRY principle Principle Worse is Better Separation abstraction of implementation Methods of error detection logic programs Conventions godowania Commenting the code Software Metrics Overview of these technologies and languages The area of application of these languages The main features of language Prospects for development The future direction of development: algorithmic, optimization of code, implementing patterns, design patterns, architectural patterns, analytical standards Reduction of the control structure - the use of artificial intelligence and automated decision-making Which platform to choose? Individual consultations
javaperf Java Performance 35 hours What will you learn? Performance tips all come with a shelf life that is linked to the particular technology to which they are applied. Once that technology changes or is no longer used, the tips become useless at best and harmful at worst. For this reason we have purposely designed a course that focuses on providing you with something more than just tricks to get the latest and greatest framework to meet your performance needs. One of the tools we aim to leave you with is a methodology that we've used over the years on a regular basis. This methodology has helped us quickly identify and solve hard performance issues. The other equally important aspect of performance tuning is tooling. A good portion of the course focuses on a number of open source tools that we have found to be useful in our campaigns to stamp out performance bottlenecks. Beyond methodology and tooling, we look at some of the fundamentals of Java technology. This includes the inner workings of the Java memory management and HotSpot/JIT technologies. Objectives how to apply rigor to the task of performance tuning how to setup a performance tuning environment importance of performance tuning requirements and goals tools needed to conduct a performance investigation benchmarking and micro-benchmarking skills Java memory and execution models Tools & Methodology Defining performance and performance tuning Common performance problems Profiling, and monitoring with professional tools Execution, memory and thread profilers System level monitoring Java Management eXtentions Architecture Planning for performance Patterns and anti-patterns Messaging Architectures for performance Coding Best Practices Big gains user perceptions Macro and micro benchmarking Selected Java Libraries including String, I/O and Collections XML parsing Serialization Concurrency Memory Management Java Virtual Machine heap spaces Garbage collection algorithms Object life-cycle Garbage collection logging and monitoring Heap tuning strategies
vertx Vert.x: Build a Reactive application on JVM 14 hours Vert.x is a library for building reactive applications. In this instructor-led, live training, participants will learn how to use Vert.x to create an asynchronous, event-based web application. By the end of this training, participants will be able to: Understand and use the different components (core, web, client, etc.) in the Vert.x stack. Use Vert.x to create network utilities, HTTP/REST microservices, high volume event processing, back-end message-bus applications, etc. Execute an app that can handle high concurrency using minimal kernel threads Use Vert.x's APIs to support Java, JavaScript, Groovy, Ruby, Ceylon, Scala, Kotlin, etc. Unit test asynchronous code with Vert.x-Unit Deploy and scale an app with minimal hardware Audience Developers Format of the course Part lecture, part discussion, exercises and heavy hands-on practice To request a customized course outline for this training, please contact us.
qaci Quality Assurance and Continuous Integration 14 hours Training is open to both developers, Scrum Masters, Product Owner and also some aspects of the business department. The purpose of training is to introduce topics Quality Assurance and Continuous Integration and their place in projects conducted agile methodologies. Participants will gain a broad perspective on the issues discussed as well as practical knowledge of the tools and processes of software development in line with the QA / CI. Representatives of business, will be able to know the benefits of implementing those tools and processes and translate into both the time and cost of software development. The issues presented are based on PHP or Java, depending on customer requirements. QA/CI What is QA? What is CI? The costs of software development, refactoring and fix errors Identifying and understanding the project Profit for the organization DDD Software development based on business requirements, assumptions DDD Problems in communication IT-Business Domain Model Best Practices KISS principle and DRY Coding standards Creating reusable code through OOP and design patterns Identifying and reducing cyclomatic complexity Software Metrics Weight Method per Class Response For a Class Depth of Inheritance Tree Coupling Between Objects Lack of Cohesion of Methods Number of Children Cyclomatic complexity Metrics class Model Metrics Metrics for use Software Testing What, when and how to test? The method of "white-box" and "black box" The role of testing in agile methodologies TDD only a potential increase in the cost of the project Unit testing with JUnit (Java), PHPUnit (PHP) Behavioral tests of JBehave (Java), Behat and Mink (PHP) Functional tests Refactoring What is refactoring? Debt technology Code smell Refactoring patterns Documentation The role of documentation in agile methodologies What to document? Types of documentation Documentation and agile methodologies, or you can call (Working software over comprehensive documentation)? Standard XMI Automatic generation of documentation from the Javadoc (Java), ApiGen (PHP) Tools and Environment CI Tools and Environment CI PMD (Java), phpmd (PHP) CPD (Java), phpcpd (PHP) Lines Of Code Counter (Java), phploc (PHP) UCDetector (Java), phpdcd (PHP) Jdepend (Java), phpdepend (PHP) Jenkins Continuous Integration Server Agile and CI/QA Planning and incremental development Embracing Change Short stages Interdisciplinary team Extreme Programming, Code Review Individuals and interactions over processes and tools Summation Discussion Questions How do you begin the process of implementation?
javaph Java Persistence with Hibernate 14 hours This course teaches the practical use of Hibernate for persisting Java objects in a relational database. Introduction to Hibernate Introducing Hibernate The Object/Relational Mapping Problem JDBC The Users-Roles Schema Tools and Environment Setup Creating the Database Configuring Hibernate Hibernate Distributions Required Libraries Configuration Files hibernate.properties hibernate.cfg.xml Hibernate Persistence The Hibernate Architecture SessionFactory Methods Hibernate Sessions Object States State Transitions Session Methods Transactions Session-Per-Operation Session-Per-Request The Data Access Object Pattern Object/Relational Mapping Object-Oriented Design Relational Mapping Bidirectional Association O/R Mapping Techniques The Mapping Document The Mapping XML Model Primary Keys and Identity Generating Identifiers Other Mapping Elements Components Mapping Associations The Mapping XML Model for Associations Unidirectional Many-to-One Eager Fetching Bidirectional One-To-Many Bidirectional One-To-One Mapping Inheritance Inheritance and Databases Single-Table Inheritance Mapping Single-Table Inheritance Table-Per-Subclass Table-Per-Subclass Mapping Table-Per-Concrete-Class The Hibernate Query Language The Hibernate Query Language Fundamentals HQL Queries Polymorphism Named Parameters Entity Parameters Joining on Associations Aggregate Methods Updates and Deletes Named Queries Using Native SQL
junit Unit Testing with JUnit 21 hours JUnit jumpstart Proving it works Starting from scratch Understanding unit testing frameworks Setting up JUnit Testing with JUnit Exploring JUnit Exploring core JUnit Launching tests with test runners Composing tests with TestSuite Collecting parameters with TestResult Observing results with TestListener Working with TestCase Stepping through TestCalculator Sampling JUnit Introducing the controller component Let's test it! Testing exception-handling Setting up a project for testing Examining software tests Why we need unit tests Kinds of tests Determining how good tests are Test-driven development Automating JUnit A day in the life Running tests from Ant Running tests from Maven Running tests from Eclipse Coarse-grained testing with stubs Introducing Stubs Practicing on an HTTP Connection sample Stubbing the web server's resources Stubbing the connection Testing in isolation with mock objects Introducing mock objects Mock tasting's simple example Using mock objects as a refactoring technique Practicing on a HTTP connection sample Using mocks as Trojan horses Deciding when to use mock objects In-container testing with Cactus The problem with unit-testing components Testing components using mock objects Integration unit tests Introducing Cactus Testing components using Cactus How Cactus works Unit-testing servlets and filters Presenting the Administration application Writing servlet tests with Cactus Testing servlets with mock objects Writing filter tests with Cactus When to use Cactus, and when to use mock objects Unit-testing JSPs and taglibs Revisiting the Administration application JSP unit testing Unit-testing a JSP in isolation with Cactus Unit-testing taglibs with Cactus Unit-testing taglibs with mock objects When to use mock objects, and when to use Cactus Unit-testing database applications Database unit testing Testing business logic in isolation from the database Testing persistence code in isolation from the database Writing database integration unit tests Running the Cactus test using Ant Tuning for build performance Overall database unit-testing strategy Unit-testing EJBs Defining a sample EJB application Using a fa?ade strategy Unit testing JNDI code using mock objects Unit-testing session beans Using mock objects to test message-driven beans Using mock objects to test entity beans Choosing the right mock object strategy Using integration unit tests Using JUnit and remote calls Using Cactus
restapi REST API - a pattern of exchange of information between sites 14 hours The course is designed for developers, web applications, aims to provide opportunities offered by the REST architectural pattern by which you can communicate between sites. REST - base The need for the exchange of information between sites HTTP POST / GET / PUT / DELETE Services such MushUp and popular applications Services using REST Conventions Rest Mapping CRUD operations on HTTP calls Conventions API URL structure Passing Parameters Return Values HTTP statuses JSON - a universal format for the exchange of information API services Examples of the popular API RESTful frameworks Create a REST API - Server Gathering requirements and identify functionality Design and API documentation Installing the required libraries Business Object - mapping the class Controller methods Representation of a business object as JSON HTTP Headers - as metadata Testing the API using cURL Authentication mechanisms
javafun Java Fundamentals 28 hours The course covers the basics of Java development. It introduces students to Java technology and teaches them basic Java syntax and concepts, leading to the creation of a simple program. Training goes through the essential concepts and features of the Java Programming Language, focusing on exceptions, basic input/output, concurrency, regular expressions, Java collections framework and the platform environment. The course finishes when all basic Java features have been explained and trained. Getting Started The Java Technology Phenomenon How to write basic "hello world" application How to compile and execute Java code How to make the code a bit more complex Java Syntax Object-Oriented Programming Concepts Variables, arrays, data types, operators, and control flow What are reference variables Classes and objects What inheritance is and how it works What Interfaces are, why they are written and how How to use Java String and Number objects and how to format data for output What packages are for and why we must use import directive Java Objects Java classes overview Java class life cycle Class modifiers and inheritance Overloading" and overriding Class constructors Polymorphism Relationships: IS and HAS 'static' keyword When to use static members Java Collections Collection interface Lists, maps and sets Collections and arrays Concurrency Java Memory Garbage collector Heap and stack Object life cycle 'finalize()' method Java Exceptions The general idea of Java Exceptions Runtime and 'real' exceptions Throwing an exception 'try...catch' statements 'throws' declaration Designing your own exceptions Java Concurrency Threads and concurrency Threaded tasks Joining threads Class variables visibility
akka Akka: Build reactive, concurrent, and distributed applications 28 hours Akka is an open-source toolkit and runtime for building concurrent and distributed applications for Java and Scala. In this instructor-led, live training, participants will learn the design principles behind Akka, including the Actor Model and Reactive Manifesto, as they build and deploy an asynchronous, message-driven application in Akka. By the end of this training, participants will be able to: Apply the "let it crash" model to build applications that self-heal and systems that never stop Understand Actors, actor lifecycle and how to employ them to create proper, concurrent parallel systems Build Reactive Architecture that is responsive, elastic, resilient, and message driven Integrate remoting and clustering features with third party systems Deploy the Akka toolkit in production systems, scaling it to multiple nodes and third party systems Manage system behavior and horizontal distribution Build systems that "react" to environmental changes Audience Developers Architects Format of the course Part lecture, part discussion, exercises and heavy hands-on practice To request a customized course outline for this training, please contact us.
gfadm GlassFish Administration 21 hours GlassFish Administration Training introduces participants to the secrets of the installation, configuration, management, monitoring GlassFish server. Training is open to future GlassFish server administrators. Introduction and Installation GlassFish Overview and architecture of Java EE GlassFish White Basic GlassFish Architecture Download and install GlassFish Starting and Stopping the GlassFish Structure and architecture File structure Server profiles, domains, and configuration Configuration Files - Setup.xml and domain.xml Login and login configuration The Admin Console The asadmin Command Line Interface Deployment The structure of the Java EE Application (Jars, Wars, Ears, Sars) GlassFish Deployment Details Deploying with the Admin Console and asadmin Deploying Using autodeploy Deploying with asant Tasks Directory (Expanded) Deployments GlassFish Classloading, and Effect on Deployment Configuration Services (Web, JNDI, Datasource, EJB, Web Service) Web Container Overview Configuring the Web Container / HTTP Service Virtual Hosts and Listeners JNDI and Naming Overview Configuration GlassFish Naming Configuration klienta JNDI Review DataSource i JCA Configuration DataSource i Connection Pool Container EJB EJB Pooling and Caching Container Management EJB Web Service Overview and Deployment Viewing, Monitoring, and Managing Web Services Messaging JMS - Java Message Service Overview GlassFish Messaging Overview - Sun Message Queue Creating Connection Factories and Destinations (Queue/Topic) Configuring the JMS Provider Safety Overview Java security EE GlassFish Security Architecture Manage Users, Groups file, JDBC, LDAP, and other Realms Password security - password encryption, Master and adminstracja password SSL / TLS and HTTPS Overview Configuring and Using GlassFish keytool Security other sites Monitoring and Tuning GlassFish Monitoring Tuning Clustering GlassFish Clustering Overview Cluster Configuration The Repository, Cluster Instances, and the DAS Clustering Architecture (Client Interceptor, Load Balancing and Fault Tolerance, State Replication) Clustered Services Load Balancers and Clustered Http Configuring Apache httpd for Use with the Load Balancer Conclusions
springcloud Spring Cloud: Building microservices with Spring Cloud 14 hours Spring Cloud builds on Spring Boot to enable the development of distributed systems and microservices. In this training we start with a discussion of microservice architecture. Participant knowledge is put to the test through exercises and the step-by-step development of sample microservices. By the end of this training participants will have a solid understanding of how to use Spring Cloud and related Spring technologies to rapidly develop their own cloud-scale, cloud-ready microservices. Audience     Java developers wishing to rapidly build and deploy microservices Format of the course       Heavy emphasis on hands-on practice. Most of the concepts are learned through samples, exercises and hands-on development. Introduction     Microservice architecture, PaaS, and cloud-native design Overview of Spring Cloud sub-projects     Config Server & Bus, Eureka, Ribbon, Feign, and Hystrix Overview of Spring Boot Setting up your development environment Creating a Spring Boot application Centralized, versioned configuration management with Spring Cloud Config Dynamic configuration updates with Spring Cloud Bus Service discovery with Eureka Load balancing with Ribbon Applying circuit breakers with Hystrix Declarative REST clients with Feign Working with API Gateway Securing your microservices Tracing microservices to uncover latencies Troubleshooting Closing remarks
encogintro Encog: Introduction to Machine Learning 14 hours Encog is an open-source machine learning framework for Java and .Net. In this instructor-led, live training, participants will learn how to create various neural network components using ENCOG. Real-world case studies will be discussed and machine language based solutions to these problems will be explored. By the end of this training, participants will be able to: Prepare data for neural networks using the normalization process Implement feed forward networks and propagation training methodologies Implement classification and regression tasks Model and train neural networks using Encog's GUI based workbench Integrate neural network support into real-world applications Audience Developers Analysts Data scientists Format of the course Part lecture, part discussion, exercises and heavy hands-on practice To request a customized course outline for this training, please contact us.
javah Java Hibernate 28 hours Introduction to the issue of transaction and sustainability components (Optional) Introduction to transaction management in web applications and in particular in the context of Java EE The introduction of the architecture of the transaction and transaction manager and then transition to the idea of ​​a light framework of transaction management and data durability Hibernate Architecture Overview of the most important elements and the idea behind PHP framework Hibernate Discussion of how to implement a mechanism to hide component life through the implementation of the framework and to hide the drivers and as the database itself How is used for communication with the database via Hibernate? Hibernate in Action Example of use Hibernate framework in a simple Spring web application that requires consolidation of object Introduction to the theme of the DAO - their interfaces and implementations Mapping tables on POJO class The use of POJOs as realizing the idea of ​​entity objects within a web application The use of declarative mechanisms mapping database table rows to objects POJO Creating relationships between objects Discussion of the implementation of the transfer relation strictly object model database using Hibernate framework Transactions in Hibernate Discussion of the transaction abstraction within the Hibernate framework, defining global and regional transaction and define their level. Hibernate Query Language (OPTIONAL 1day) Discussion of the high-level abstraction definition language database queries within the framework Hibernate Connection example Spring MVC application with Hibernate mechanism On this example application will be shown how to combine the two frameworks of integration within the web application
DEVOPSJEE Fundamentals of Devops for Java Enterprise Edition Projects 21 hours This training course introduces the core DevOps concepts and principles as well as the ways to stand up the DevOps practice in your organization. It is specifically focused on projects on the Java Platform. Upon completion of this training course, students will have a fundamental understanding of DevOps’ value proposition; they will also gain practical experience working with select DevOps tools, including Puppet, Jenkins, Git and others. This training course is supplemented by hands-on labs that help attendees reinforce their theoretical knowledge of the learned material. Topics: DevOps practices and tools Puppet Technical introduction to cloud computing Jenkins 1. Introduction Establish Goals and Current State The Goal of DevOps 2. What Is DevOps? Background and History Symptoms and Problems in Today's Environment The IT Core Chronic Conflict DevOps Roles DevOps Defined Core Concepts 3. Ball Point Game 4. Why Do DevOps? Driving Factors Amazon's Process: A Case Study State of DevOps Report Manufacturing and DevOps 5. DevOps at Microsoft – a Case Study Dark Launches Feature Flags Agile to DevOps Branching Teams Live Site Culture 6. How Does DevOps Work Continuous Integration Continuous Deployment Continuous Delivery Continuous Testing Continuous Monitoring Automation Kanban End-to-End 7. Culture and DevOps People and Trust Resilience Engagement is Key Change the Metrics! Law of Motivation Keys to Successful DevOps Culture 9. Tool Time Build Automation Test Automation Deployment Automation Git Environment Provisioning Automated Feedback and Monitoring 10. DevOps Assessment 12. Summary and Next Steps In-Class Exercises: Individual and Team Goals – Identifying current issues and goals The Ball Point Game – Creative team game to learn about process optimization The Penny Game – see how Kanban and batch sizes affect delivery DISC Assessment – personality / culture exercise DevOps Assessment – Where Are We?
jetty Jetty: Embedding a web server inside your application 7 hours Enterprise Java development does not need to be heavyweight and Ant-driven. Learn to bypass the complexity of setting up and maintaining a standalone web container. Instead learn how to embed the web server into your application with embedded Jetty.   "Don’t deploy your application in Jetty, deploy Jetty in your application!" Some of the topics covered in this instructor-led, live training include: Instantiating Jetty as a POJO (Plain Old Java Object) Replacing Tomcat with Jetty for Spring Boot integration Automatically deploying embedded Jetty with Maven Request this course now! Audience Developers Format of the course Part lecture, part discussion, exercises and heavy hands-on practice Request a custom course outline now!
javaspring Java Spring 35 hours Oriented programming interfaces Modeling and programming based on the interfaces idea Problems solved by the programming-oriented interfaces Component-oriented programming The role of the components in the web application model, the introduction of the concept of POJO objects as objects performing the function of the components in the web application Design Pattern Inversion of Control and Dependency Injection Pattern of inversion  Control and its variants Dependency Injection, IoC container Declarative as dependencies between the components of a web application Architectural Overview Spring Spring application context-a and its role as an IoC container. How to realize the function of an application framework? Where begins the life cycle of a web application based on Spring? Is it possible to use the Spring IoC container in your application not necessarily site? The configuration files Dependency Injection declaratively through XML files that define how the creation and application components imparting The dependencies between components File format description of the components and examples of Spring dependency injection Factory components and its use Mapping the components defined in the description file dependency injection and how to implement the injection mechanism by Spring plant components Distinction between the components of a singleton and prototype Component life cycle and identification of components Component life cycle Component identification Programming in Spring AOP Aspect-Oriented Programming (Aspect Oriented Programming) Declarative mapping application aspects in the design and definition of the intersection points Introduction to Spring AOP and application examples MVC Spring-a Discussion of abstraction controllers and views Spring Framework and examples of applications most of them. Introduction to the idea of ​​the model, view and controller Spring applications Create an application using Spring MVC Standard controllers and managers view the Spring web application Wiring properties model with a view and vice versa Introduction to the issue of trade and sustainability components Transaction management (especially Java EE) Transaction manager Light framework and persistence Spring transaction management mechanism Light Spring Framework transaction manager Spring mechanisms for managing transactions Mapping of table rows for POJO objects using Spring Use of data access methods Spring Framework to create database queries To define the data access Create Data Access Objects (DAO) Implementation and use DAO to stabilize application components
scalaadvanced Scala: Advanced object-functional programming 14 hours Scala is a concise, object-oriented language with functional programming features, including currying, type inference, immutability, lazy evaluation, and pattern matching. Scala code runs on a JVM and was designed to address some of the shortcomings of Java. In this instructor-led, live training participants will learn how to use Scala's advanced features, including its type system, to write better code using an object-functional approach.   By the end of this training, participants will be able to: Leverage Scala's type system to maximum benefit Handle exceptions functionally Create libraries and DSLs with Scala Use Scala's advanced features for pattern matching Audience Scala programmers who wish to learn the more advanced and nuanced features of Scala Format of the course Part lecture, part discussion, exercises and heavy hands-on practice Introduction     Scala as a JVM language     Objection-oriented programming vs functional programming Overview of object-functional programming     Tail recursion     Partial functions     Currying and partial function application     Closures     Lazy evaluation Mastering the Scala type system     About traits     Structural types     Path dependent types     Self types     Covariance and contravariance     Type bounds Advanced pattern matching in Scala     Deep matching     Using extractors Using Scala Implicit     Implicit conversion, classes and parameters     Type class pattern     Context and view bounds Libraries and DSLs     Custom control structures with by-name parameters     Building well-designed libraries and internal DSLs Working with Scala collections     Working with Streams     Manifests and class tags     Builders     CanBuildFrom     Building custom collections Functional exception handling     Traditional exception handling     Functional exception handling     Using Try with For comprehensions Closing remarks
apachetomcatw Working with Apache Tomcat 21 hours Audience: Developers Format: Hands-on exercises for about 70 % of time Duration: This course can be delivered as either a 2 day (14 hours) or 3 day (21hours) event. Introduction to JEE 7 standard Overview Versions differences Application Servers types and profile compliance Web Tech Introduction What is the WWW HTML basics ( Form, HREF, ...) TCP basics and the HTTP protocol ( GET, POST, ...) WebApp Standard ( 3.0/3.1 ) Older versions comparison Layout, Deployment Descriptor XML Deployment Descriptor Java Servlets ; The Life cycle HttpServletRequest , HttpServletResponse Configuring a Servlet in a Servlet Container Understanding the Contexts/Scopes Session Context / HttpSession Application Context / ServletContext Request Context / HttpServletRequest Java Server Pages (JSPs ) Overview JSP Directives, JSP Scripting, Configuring JSP groups in XML JSP written in XML format and advantages Filters and Listeners Thread safety tips for webapps Multipart Asynch Way What is a WebSocket Overview of Apache Tomcat 7/8 The Apache Tomcat Servlet ContaineServer Overview packages / versions / standard versions / ... The Tomcat Manager Web Application Specialized Realm Implementations Tomcat Valves Tomcat Architecture Server Service Connector Engine Host Context Connector Engine Host Context Installing and Configuring Tomcat Requirements for Installing and Configuring Tomcat Installing Tomcat Using Windows Service Installer Manually Installing on Windows Installing to Linux Configuring and Deploying Web Applications to Tomcat The Tomcat Directory Structure Tomcat bin scripts Passing Runtime Options to Catalina Script Tomcat Configuration Files Java Web Applications Manually Deploying Web Applications to Tomcat Deploying WAR Archive Other Methods of Deployment Configuring Hosts and Contexts Configuring Hosts Configuring Web Application Contexts Working with Eclipse IDE NetBeans way How to Debug remote Tomcat Instance Tomcat Web Application Manager Gaining Access to the Manager Web Application Accessing the Manager Web Application Using Web Interface Listing Deployed Web Applications Checking Server Status Deploying a New Web Application Reloading an Existing Web Application Sessions Stop, Start, Undeploy Tomcat CLI Web Application Manager Introduction to Ant, Installing Ant Configuring Tomcat’s Ant Tasks Running Ant Scripts Tomcat Embedded Requirements Implementing a Sample Application with Embedded Tomcat Testing Servlets with Embedded Tomcat JNDI with Tomcat Introduction to JNDI JNDI API Overview Tomcat JNDI Configuration Introducing JDBC Configuring the Database Connection Configuring Data Source as a JNDI Resource Configuring Mail Session Introducing JavaMail Configuring Mail Session as a JNDI Resource Set Up a server for serving Tomcat webapps Introduction and alternatives and motivations Using Apache HTTP or IIS in front AJP, ModProxy, Jconnector, ... Example on how to set up multiple Tomcat Instances, with different configurations (Java version, Memory, ...) on same host. Architecture Best Practices MVC Model 2 with standard components Examples of architectures Overview Spring MVC way Pure JEE way MVC on client side with angular Packaging War archives Using Ant Using Maven Tomcat Performance Tuning Introduction The Java garbage collector Load-Testing Tools Jmeter External and Internal tuning tips Sizing JVM Heap Using JAVA_OPTS ... Exercises
3059 Java Advanced 28 hours During the training participant will know the specific use of selected issues, the basic problems encountered when using them, and the role of the application model. The training also includes a basic knowledge of the language standard library functions. Training requires knowledge of the development environment IDE used to build Java applications (e.g.. Eclipse, Netbeans). Training does not include a user interface issues. Abstract class Declaration principles and implementation of abstract classes Typical problems encountered when working with abstract classes The role of classes, abstract classes and interfaces in the application model Grades Java object-oriented abstraction The complete object model in Java Program model oriented  for interfaces, abstract classes and interfaces for application more flexibility and independence of each of its sub-systems from each other in their implementation Applications of abstract classes in order to extract common functionality extended by the implementation of the flexibility that they offer interfaces The role of dynamic and static objects in the application model Static Java classes and dynamic properties of these classes Making a distinction in the functionality of both types of entities within Java and typical uses, and their example of good practice in the design of solutions based on static and dynamic beings Java Introduction to the design patterns Introduction to the factory design pattern Operations with simple types and wrapper classes Very important facts and techniques to extend the use of simple types in the Java object model. Discussion of the role of wrapper classes simple types and typical applications of this type in the application Special Objects Java, the class String, StringBuilder and StringBuffer Reminder basic properties of the String class and discuss the treatment of String objects by the virtual machine The use of buffer classes and operate on chains Formatting and parsing, regular expressions Introduction to regular expressions in Java Discussion of both basic techniques for handling regular expressions (String class) as well as advanced techniques based on dedicated classes for this type of construction Tokenization, search and pattern matching for string types I / O operations A detailed discussion of the mechanisms I / O Java - class streaming, Writer and Reader class, class wrapper and buffering streams of Java. Opening, closing and writing to files and sockets Classes inside - detailed discussion Discusses how to implement and use inner classes in Java and so-called anonymous classes Topics - detailed discussion, applications and problems Discussion subject topics ranging from abstraction mechanism of threads in Java and ending with the synchronization of threads connecting threads in a group to present and discuss topics pools of common problems related to the work of threads, such as deadlocks Reflections Java - Introduction and application Introduction to Java reflection mechanism Lecture topics include discussion of the implementation of reflection in Java, load and run methods of classes, instantiation of classes and getting to know the structure of the classes Java Serialization Introduction to Java object serialization What is serialization, how to serialize an object, objects dependent on each other and how to avoid common problems encountered with these types of issues Typical uses the example of serialization and RMI CORBA
scalaadvancedfunctional Scala: Advanced functional programming 14 hours Scala is a concise, object-oriented language with functional programming features, including currying, type inference, immutability, lazy evaluation, and pattern matching. In this instructor-led, live training participants will learn how to use Scala's advanced features to develop well-constructed software that is easy to write, read, test, and change. The focus of this training is on functional programming, using real-world case studies and discussion as a reference for lab exercises and activities. By the end of this training, participants will be able to: Implement advanced functional programming techniques Make sense of complex type signatures Understand code through types and substitution Handle exceptions functionally Create libraries and DSLs with Scala Use Scala's advanced features for pattern matching Audience Scala programmers who wish to learn the more advanced and nuanced features of Scala Format of the course Part lecture, part discussion, exercises and heavy hands-on practice Introduction     Who uses Scala?     Developing large-scale, purely-functional programs Overview of functional programming in Scala     Higher-Order Functions     Combinators     Polymorphic Functions Mastering Scala Types     Product types & Sum types     Supertypes & Subtypes     Universals & Existentials     Higher-Kinded Types     Type Lambdas Mastering Scala Type Classes     Classes & Instances     Tricks with Implicits     Polymorphic Constraints Case study: Highly-stateful programs with complex external systems Coding exercise Working with Data     Immutable Data & Recursion     Catamorphisms & Church Encoding     Fixed-Point Data     Recursion Schemes Advanced pattern matching in Scala     Deep matching     Using extractors Case study: Scala and Big Data Coding exercise Using Functional Patterns     Options, Eithers & Validations     Semigroups & Monoids     Functors     Applicatives     Monads     Foldables & Traversables     Lenses Working with Effects     IO     State     Reader     Combining Effects Case study     TBD Coding exercise Functional Architecture     Modern Architecture for FP     Reified Computation & Deferred Evaluation     Compositional Evaluators     Optimization Techniques     Purely Functional Mocking Libraries and DSLs     Custom control structures with by-name parameters     Building well-designed libraries and internal DSLs Functional exception handling     Traditional exception handling     Functional exception handling     Using Try with For comprehensions Final coding exercise and evaluation Closing remarks
shiro Apache Shiro: Securing your Java application 7 hours Apache Shiro is a powerful Java security framework that performs authentication, authorization, cryptography, and session management. In this instructor-led, live training, participants will learn how to secure a web application with Apache Shiro. By the end of this training, participants will be able to: Use Shiro's API to secure various types of applications, including mobile, web and enterprise Enable logins from various data sources, including LDAP, JDBC, Active Directory, etc. Audience Developers Security engineers Format of the course Part lecture, part discussion, exercises and heavy hands-on practice Introduction Overview of Shiro features Project setup and configuration Overview of the Security Manager Securing an application with Shiro Authentication Authorization Realm configuration Logging out Session management Using Shiro with Spring Integrating with Java EE Securing a mobile application Troubleshooting Deploying and monitoring your application Closing remarks

Upco...Upcoming Courses

Other regions

Weekend Java courses, Evening Java training, Java boot camp, Java instructor-led , Java coaching, Java on-site, Java private courses, Java trainer , Java training courses,Weekend Java training, Java instructor, Java one on one training , Java classes

Course Discounts

Course Discounts Newsletter

We respect the privacy of your email address. We will not pass on or sell your address to others.
You can always change your preferences or unsubscribe completely.

Some of our clients