Training: Ontwikkel je van Javanista naar Java Master (incl. begeleiding)
Java
64 uur
Engels (US)

Training: Ontwikkel je van Javanista naar Java Master (incl. begeleiding)

Snel navigeren naar:

  • Informatie
  • Inhoud
  • Kenmerken
  • Meer informatie
  • Reviews
  • FAQ

Productinformatie

Wil jij jezelf ontwikkelen van Javanista naar Java Master? Dan is dit ontwikkelpad ideaal voor jou! Deze training is bedoeld voor Java ontwikkelaars die hun vaardigheden willen verbeteren in Java enterprise frameworks en beter willen worden in de ontwikkeling van enterprise applicaties.

Wanneer je kiest voor dit ontwikkelpad, krijg jij:

  • Toegang tot trainingen, livelabs en examens op het gebied van Java.
  • Begeleiding van ons Learning & Development team, samen met jou stellen we doelen, maken we een planning en monitoren we je voortgang.

Dit ontwikkelpad bestaat uit de volgende 4 onderdelen:

Unit Testing

In dit onderdeel van de Javanista tot Java Master training, leer je hoe je JUnit tests kunt schrijven en uitvoeren en hoe je de juiste situatie kunt identificeren om mock objecten te construeren en gebruiken.

Java EE

In dit onderdeel, leer je hoe Jakarta Enterprise Edition (JEE) een eenvoudige en uitgebreide aanpak biedt voor het bouwen van state-of-the-art enterprise applicaties. Je leert hoe je rijke webgebaseerde interfaces kunt maken met behulp van Java Server Faces (JSF) en hoe je effectief business logica kunt construeren met behulp van Enterprise JavaBeans (EJB).

Spring Basics

Hier leer je over de principes van Spring, Inversion of Control en Aspect Oriented Programming. Je leert ook over database-integratie met behulp van ORM-frameworks zoals JPS & Hibernate.

Spring Data

In het laatste onderdeel leer je werken met Spring Data JDBC, Spring Data JPA en Spring Batch voor het verwerken van batchgegevens.

Inhoud van de training

Ontwikkel je van Javanista naar Java Master (incl. begeleiding)

64 uur

Unit Testing: An Introduction to the JUnit Framework

JUnit, an open-source unit testing framework, can be used by Java developers who employ a test-driven development methodology. The platform allows you to write and run tests on sections of code repeatedly. Use this course as a quick theoretical and hands-on introduction to the JUnit framework. Begin by looking at the process of software testing in general, then unit-testing with JUnit in particular. Next, move on to writing a simple Java app for which you will write JUnit test cases to ensure that its functions behave in line with expectations. Moving along, learn how to use annotations to mark out methods as test cases and set up work to be carried out before test case executions and tasks to be performed after they have run. When you're done, you'll be able to get started writing unit tests for your code using the JUnit framework.

Unit Testing: Assertions & Assumptions in JUnit

Assertions, a collection of utility methods in in JUnit, help assert the pass or fail status of test cases. The focus of this course is on assertions that allow you to set the conditions for the success and failure of test cases and assumptions to control the flow of execution in a test case. Begin with simple assert methods to compare the actual values of fields or return values of methods with their expected values. Then, use assertions that ensure your app's performance by failing a test if it takes too long to run, followed by assert methods that check an exception is thrown when invalid data is passed to a method. Next, use assumptions that check for conditions before executing a code block - effectively serving as control structures. When you're done, you'll have a working knowledge of using assertions in JUnit.

Unit Testing: Advanced Annotations in JUnit

Using annotations in JUnit allows you to add a special form of syntactic meta-data to Java source code for better code readability and structure. The aim of this course is to give you hands-on experience with JUnit annotations which allow you to set when and how test-cases should be run. Kick things off with a basic annotation to set the name of a test case that appears in execution summaries. Move on to using annotations that simplify the setting of conditions in which test cases should run - based on the current operating system, JRE version, and even environment variables. Explore the definition of a custom annotation composed of a combination of pre-built annotations. Then, apply annotations that control the order of test case executions and enable parallel runs of tests. When you're done, you'll be able to use JUnit annotations for several useful tasks.

Unit Testing: Parameterized JUnit Tests

Parameterized tests in JUnit help developers save time by running the same tests repeatedly, using only different inputs, and getting different results. The focus of this course is on scaling test case executions using repeated and parameterized tests. Start by setting a particular test case to run multiple times using the RepeatedTest annotation. Next, move on to defining test cases that can accept parameters. Then, look into different ways in which the parameters can be fed into your test case - from hard-coded values defined in your test class to CSV files and method invocations. Finally, learn how to build a specialized class to pre-process your parameters before being fed into test cases. Upon completion, you'll know how to conduct repeated executions of JUnit test cases with or without parameters.

Unit Testing: Executing JUnit Tests

JUnit, the Java unit testing framework, can be used with an IDE but also with a build system, such as Maven. Furthermore, JUnit ConsoleLauncher, a stand-alone application, can be used to launch the platform from the command line. This course will dive deep into the use of Maven as well as the JUnit ConsoleLauncher to run all and specific test cases in your application. Begin by running all test cases you have written for your app using Maven. Then run specific tests and define groups of tests using JUnit tags. Next, run the tests from the command line. Finally, execute such tests using the JUnit ConsoleLauncher, which can be run from a shell without other tools such as Maven. Upon completing the course, you'll be able to execute JUnit test cases from the command line using Apache Maven and the JUnit ConsoleLauncher.

Unit Testing with Mocks: Getting Started with Mockito

Mockito is a Java framework for building mocks during unit testing. When performing unit tests on an object, you often have other, complex objects that the object under test depends upon. Rather than using those complex objects, you can use Mockito to create mocks of those objects and stub their methods to simulate expected behavior. Use this course to get to grips with mocking and its relationship with unit testing. Set up a Maven project and add the required Mockito and JUnit dependencies. Create mocks of built-in classes, such as the ArrayList, and built-in interfaces, such as the Comparator. Then, work with stub methods using Mockito's when().thenReturn() syntax. When you're done, you'll be able to identify situations where using mocks is a good idea, construct mocks, stub methods in them using Mockito, and use mock objects in unit tests.

Unit Testing with Mocks: Creating Mocks & Verifying Behavior

Mocks built in Mockito do more than just simulate the behavior of complex objects that your object under test depends upon. Mockito makes it easy for you to verify specific aspects of how the object under test and the mock interact. In this course, learn how to build mocks using annotations and use them to perform dependency injection into the object. Then, learn how to work with constructor, setter property, and field injection. Moving along, verify the behavior of the object under test and its interaction with the mock using Mockito constructs, such as verify(), verifyNoInteractions(), and various argument matchers. When you're done, you'll be able to use annotations to construct mocks in a clean and simple manner and test very specific aspects of the interactions between the stubs in your mocks and the object under test.

Unit Testing with Mocks: Mocking Exceptions & Using Spies

Unlike a mock, which has no real state, and in which all behavior must be stubbed, a spy is built atop a real object of the class being mocked and has almost full functionality. Only specific methods of the spy are stubbed, which is useful if it is too complex or cumbersome to mock. Use this course to learn how to identify when spies are a better choice than mocks, how to construct spies and stub specific methods, and how to raise exceptions in stubbed methods of your mocks. Then, use different methods to check how the object under test copes with those exceptions. Moving on, learn how to stub void methods and when to make use of the doNothing().when() syntax. When you're done, you'll be able to correctly use spies, mock exceptions and test their handling, mock void methods, and use argument captors.

Final Exam: Unit Testing

Final Exam: Unit Testing will test your knowledge and application of the topics presented throughout the Unit Testing track of the Skillsoft Aspire Javanista to Java Master Journey.

Building User Interfaces with JSF: Getting Started with Jakarta Server Faces

One of the best technologies for a Java-based web app is Jakarta Server Faces (JSF). Use this course to get your head around the various components of a JSF app and how to join them together to build a powerful website. After a theoretical overview of the components and design patterns of the JSF framework, practice building a simple JSF app using the Apache MyFaces API. Through this process, recognize how JSF Facelets can be used to define the UI of your app, how these bind to data stored in a backing bean, and how they can be deployed to a Jakarta EE container, such as Apache TomEE. By the end of the course, you'll have the knowledge and skills to develop and deploy a basic web app using Jakarta Server Faces.

Building User Interfaces with JSF: Building User Interactions with JSF

Once you've created a Jakarta Server Faces (JSF) app, you'll likely want to define how users interact with it. This course demonstrates just how to do that. You'll begin by defining multiple pages in your app and setting up navigation among them. Next, you'll practice defining responses to user-triggered events, such as changing a value in a UI component or clicking a button. Moving along, you'll build a form to accept user input before configuring a variety of built-in and custom validators for each of the form's fields. By the end of the course, you'll be able to set your JSF app to respond to user actions and accept user input in the manner you require.

Building User Interfaces with JSF: Integrating a Database with a JSF App

Jakarta Server Faces (JSF), a component-based framework, helps build rich and dynamic Java-based web apps. As part of this process, you might want to allow users to interact with a server-side database. Use this course to learn how to implement this capability in your JSF app. Begin by loading a database with data. Then, set up your JSF app to connect to the database, read that data, and render it in a dataTable. Next, allow for adding data by accepting user input and editing and deleting data through user interactions. Upon completion, you'll be able to allow your JSF app users to perform read, insert, update, and delete operations on a database.

Encapsulating Business Logic with Jakarta: An Overview of Enterprise Beans

An enterprise bean is a server-side component written in the Java programming language that simplifies the development of large, distributed applications. Get familiar with the fundamentals of enterprise beans and the most basic form of such beans, i.e., session beans using this course. You'll get a chance to examine the implementation of enterprise beans, set up an application server that can host enterprise beans, and explore different types of session beans. You'll also investigate how to develop a basic session bean, deploy it to the application server, and access it from a client application. Upon completion of this course, you'll have a foundational understanding of enterprise beans and how they encapsulate the business logic of an application.

Encapsulating Business Logic with Jakarta: Advanced Topics in Enterprise Beans

Through this course, learn how to perform specialized tasks using advanced forms of enterprise beans, such as message-driven beans, the timer service, and the integration of beans with a relational database. You'll examine how to set up a message queue in an application server, develop both the consumer bean and the producer program, and implement the enterprise beans timer service. This course will also help you explore the steps involved in setting up a data source to connect to a relational database and using it to integrate your enterprise beans to such a database. After finishing this course, you'll have gained a deeper understanding of the different use cases and features of Jakarta Enterprise Beans.

Final Exam: Java EE

Final Exam: Java EE will test your knowledge and application of the topics presented throughout the Java EE track of the Skillsoft Aspire Javanista to Java Master Journey.

Spring: An Overview of the Spring Framework

The Spring framework enables developers to create high-performing, reusable, and easily testable enterprise Java applications. Through this course, get a theoretical overview of the Spring framework, its components, and its use cases. Begin by exploring how the Spring framework simplifies application development and delve deeper into the core concepts that allow this. You will then examine dependency injections and inversion of control (IoC). This course will also help you discover how complex dependencies can be managed in an application using Spring Boot. Finally, you'll get a chance to investigate various Spring modules, which can be applied to web development, data integration, and API building. Once you have completed this course, you'll have a solid grasp of the fundamentals of developing enterprise applications using the Spring framework.

Spring Framework: The Fundamentals of Dependency Injection

A fundamental aspect of the Spring framework, dependency injections allow for loose coupling of components. Use this course to learn more about the elements that come together to configure and inject dependencies into a portion of a large application. Investigate concepts around dependency injection, such as inversion of control, beans, and the Spring Inversion of Control (IoC) framework. The course will also help you get hands-on experience implementing dependency injections and explore BeanFactory, ApplicationContext, and Java-based bean configuration. After you're done with this course, you'll be able to implement dependency injections within the Spring framework to eliminate or reduce unnecessary dependencies in your code.

Spring Framework: Configuring Beans with Autowiring

The Autowiring feature in Spring enables the injection of object dependency implicitly using a setter or constructor injection. Use this course to explore complex beans with dependencies on other beans and how the autowiring feature links them together. Examine how to create beans in reference to other beans, use the @Autowired annotation, and build a bean with multiple dependencies. You will also investigate different types of autowiring and discover how autowiring manages the linking of beans. After completing this course, you will have the skills to construct a complex bean with 1-1 or 1-many dependencies and configure beans with Autowiring.

Spring: Extending Applications with Aspect-oriented Programming

Using aspect-oriented programming (AOP), global properties of a program, such as logging, auditing, declarative transactions, security, and caching, can be added to your application after you've developed the core features. This course explores the core concepts of AOP before getting hands-on with one of its basic features, the pointcut. Examine the fundamental terminology and use cases of AOP before adding functionality to an application by defining and configuring a function (an aspect) to run before some core operations in your app. As you advance, practice different ways to define pointcuts (the set of core operations in your app) around which the new functionality or aspects need to be added. By the end of the course, you'll have a basic, working knowledge of AOP and pointcuts.

Spring: Exploring Advices in Aspect-oriented Programming

Aspect-oriented programming (AOP) allows significant, global functionality to be added to your application using a modular and non-intrusive method. The action taken before or after method execution is determined by a piece of code called the "advice." Use this course to practice working with different types of advices, starting with the before advice and after advice. Then, work with around advices, which run checks to determine whether a core operation should run at all and what goes on before and after its execution. Move on to use the after-throwing advice to set an action after an error has been thrown and the after-returning advice to determine the steps after a successful run of a method. Upon completing the course, you'll be able to attach different types of advices to aspects in an application.

Database Integration: Overview of Using JPA & Hibernate

Object-relational mapping (ORM) allows Java objects to be mapped to database tables and vice versa. Use this course to learn more about the Java Persistence API (JPA), which defines how Java objects and relational data should be mapped, and Hibernate, an object-relational mapping solution for Java environments. Start by exploring how to create an application that uses Hibernate APIs directly to interact with a database and examining hibernate configuration files in greater detail. You'll also investigate how Java objects can be created in an app and then persisted in a database and discover how the same operations can be implemented by applying JPA configurations, which then use Hibernate under the hood. Once you've completed this course, you'll be able to distinguish between JPA and Hibernate while also recognizing how they are connected.

Database Integration: Modeling Data Using JPA & Hibernate

In order to build effective applications in Java, developers must understand how the apps interact with a database. Through this course, gain hands-on experience in defining entities and the relationship between them in a JPA application and their implementation with Hibernate. Begin by defining entities in an app that have identifiers based on a single as well as a combination of properties - i.e., single value primary keys and composite keys. You'll then explore CRUD operations (create, read, update, and delete) using JPA APIs. Finally, you'll delve into defining one-to-one, one-to-many, and many-to-many relationships between entities in an application. After you're done with this course, you'll have a solid grasp of how to define entities using JPA, model their relationships, and how Hibernate translates these into database relations.

Final Exam: Spring Basics

Final Exam: Spring Basics will test your knowledge and application of the topics presented throughout the Spring Basics track of the Skillsoft Aspire Javanista to Java Master Journey.

Working with Spring Data JDBC: An Introduction to JDBC & Spring

Java Database Connectivity (JDBC) is a Java API that provides developers with a common interface for connecting to a database, issuing queries and commands, and handling responses from the database. Learn more about JDBC in Spring and JdbcTemplate class through this course. Start by exploring the Spring framework and its JDBC APIs to understand the features available in relation to database integration. You will then get hands-on experience using Spring Boot to set up an application that uses Spring JDBC to connect to a database and run queries against it. The course will also help you investigate the implementation of CRUD (i.e., create, read, update, and delete) operations using a JdbcTemplate class, mapping a database table to a Java class, and the role of Spring's RowMapper interface to translate rows from a query execution to Java objects. After completing this course, you'll have a solid grasp of how the Spring framework simplifies database integration from a Java app.

Working with Spring Data JDBC: Spring Data JDBC & the CrudRepository

CrudRepository is a Spring Data interface that helps perform generic CRUD operations on specific types of repositories. Take this course to familiarize yourself with Spring Data's CrudRepository interface and modeling of relationships between entities in a Spring application. Delve into how CrudRepository is used to persist Java objects into a database table and examine Spring Data JDBC's Query annotations to map custom queries to CrudRepository methods. You'll then turn your attention to modeling relationships between entities in a Spring application and configure and implement many-to-one and many-to-many relationships. Having finished this course, you'll have a broader understanding of the features in the Spring Framework that make JDBC tasks easier.

Working with Spring Data JDBC: Configuring Derived Query Methods

Configuring derived query methods in Spring Data's CrudRepository enables the execution of complex queries and the processing of their results without the developer having to write any SQL. Use this course to explore CrudRepository and different query methods in greater detail. Learn more about the steps involved in enabling logging for your Spring application and configuring methods in your CrudRepository that retrieve specific entities from a database table based on the method's signature. You'll also examine different types of queries that can be implemented, such as exact match lookups, range searches, and ordering of results. After completing this course, you'll have acquired the skills to build robust and easy-to-maintain applications.

Working with Spring Data JPA: The Fundamentals of Spring Data JPA

Spring Data JPA eases the development of applications that need to access Java Persistence API (JPA) by providing repository support. Use this course to get familiar with the basics of Spring Data JPA from a theoretical and practical standpoint. Through this course, you'll examine the concepts around Spring Data JPA and why this technology is a boon for developers, explore how to build a project that uses Spring Data JPA to connect to a database, and discover the use of the Spring Boot module. You'll also get a glimpse into the pieces which must come together to build an app that uses Spring Data JPA - data sources, a JPA implementation, and a CrudRepository. After finishing this course, you'll have the skills and knowledge to persist data using Spring Data JPA.

Working with Spring Data JPA: Derived Query Methods

In this course, you'll learn more about configuring derived query methods in Spring Data JPA using the CrudRepository. Get hands-on experience using some of the methods of a CrudRepository, which are automatically implemented by the Spring Framework to retrieve entities from a database table and load them into Java objects. You will also examine how to configure new query methods, search for entities based on their properties, and implement create, read, update, and delete (CRUD) operations. After you are done with this course, you'll be able to efficiently work with persisted data in Spring Data JPA.

Working with Spring Data JPA: Custom Queries

Through this course, explore how to map your own SQL queries to methods in a CrudRepository and leave the implementation of running the queries and processing the results to the Spring Framework. You'll investigate the use of @Query annotation to map simple select queries to methods in a CrudRepository and learn how the rest of the workaround connections, query executions, and processing of results is handled by Spring. This course will also help you discover named queries and how to add complexity to your query by substituting parameters that can be supplied when calling your methods. Once you are finished with this course, you'll have the skills to build efficient, robust, and easy-to-maintain applications by reducing the amount of boiler-plate code required.

Processing Batch Data: Spring Batch Configurations and Transformations

Processing vast amounts of data is an essential organizational task, which can become complicated with customized solutions. Luckily, Spring Batch makes batch processing easy to execute regardless of the types of data involved. Use this course to learn how to develop and configure a Spring Batch process for different data sources and destinations. You'll use Java annotation-based configurations to set up the beans for a Spring Batch process, read data from a relational database, write its contents to a JSON file, and perform the reverse transformation. While doing so, you'll apply various Spring and Spring Batch components, such as a RowMapper, an ItemPreparedStatementSetter, and customized data type adapters. Upon completion, you'll be able to use Spring Batch to build enterprise-grade solutions for various cases.

Final Exam: Spring Data

Final Exam: Spring Data will test your knowledge and application of the topics presented throughout the Spring Data track of the Skillsoft Aspire Javanista to Java Master Journey.

Kenmerken

Docent inbegrepen
Bereidt voor op officieel examen
Engels (US)
64 uur
Java
365 dagen online toegang
HBO

Meer informatie

Doelgroep Softwareontwikkelaar, Webontwikkelaar
Voorkennis

Deze training is geschikt voor Java-ontwikkelaars die al enige ervaring hebben in het schrijven van Java-code. Het is belangrijk dat je bekend met met basis concepten zoals variabelen, datatypen, loops, condities en functies.

Resultaat

Na het afronden van deze training ben jij Java Master en ben je in staat om complexe enterprise applicaties te ontwikkelen met behulp van verschillende frameworks en tools.

Positieve reacties van cursisten

Training: Leidinggeven aan de AI transformatie

Nuttige training. Het bestelproces verliep vlot, ik kon direct beginnen.

- Mike van Manen

Onbeperkt Leren Abonnement

Onbeperkt Leren aangeschaft omdat je veel waar voor je geld krijgt. Ik gebruik het nog maar kort, maar eerste indruk is goed.

- Floor van Dijk

Training: Leidinggeven aan de AI transformatie

Al jaren is icttrainingen.nl onze trouwe partner op het gebied van kennisontwikkeling voor onze IT-ers. Wij zijn blij dat wij door het platform van icttrainingen.nl maatwerk en een groot aanbod aan opleidingen kunnen bieden aan ons personeel.

- Loranne, Teamlead bij Inwork

Hoe gaat het te werk?

1

Training bestellen

Nadat je de training hebt besteld krijg je bevestiging per e-mail.

2

Toegang leerplatform

In de e-mail staat een link waarmee je toegang krijgt tot ons leerplatform.

3

Direct beginnen

Je kunt direct van start. Studeer vanaf nu waar en wanneer jij wilt.

4

Training afronden

Rond de training succesvol af en ontvang van ons een certificaat!

Veelgestelde vragen

Veelgestelde vragen

Op welke manieren kan ik betalen?

Je kunt bij ons betalen met iDEAL, PayPal, Creditcard, Bancontact en op factuur. Betaal je op factuur, dan kun je met de training starten zodra de betaling binnen is.

Hoe lang heb ik toegang tot de training?

Dit verschilt per training, maar meestal 180 dagen. Je kunt dit vinden onder het kopje ‘Kenmerken’.

Waar kan ik terecht als ik vragen heb?

Je kunt onze Learning & Development collega’s tijdens kantoortijden altijd bereiken via support@icttrainingen.nl of telefonisch via 026-8402941.

Background Frame
Background Frame

Onbeperkt leren

Met ons Unlimited concept kun je onbeperkt gebruikmaken van de trainingen op de website voor een vast bedrag per maand.

Bekijk de voordelen

Heb je nog twijfels?

Of gewoon een vraag over de training? Blijf er vooral niet mee zitten. We helpen je graag verder. Daar zijn we voor!

Contactopties