Aspire Journeys

Javanista to Java Master

  • 28 Courses | 40h 15m 9s
Likes 16 Likes 16
Javanista to Java Master is the journey intended for Java developers who aspire to sharpen their skills in Java enterprise frameworks and wish to become master’s in enterprise application development.  In this journey, you will first learn how to write and run JUnit tests and identify the right situation to construct and use mock object. The journey continues by discovering how Jakarta Enterprise Edition (JEE) offers a straightforward and comprehensive approach to building state-of-the-art enterprise applications that enables you to create rich web-based interfaces using Java Server Faces (JSF) and effectively construct business logic using Enterprise JavaBeans (EJB). Finally, the journey takes you deeper into the Spring framework where you gradually progress from the Spring principles, Inversion of Control and Aspect Oriented Programming to the Database Integration using ORM frameworks such as JPA & Hibernate, Spring Data JDBC, and Spring Data JPA. You will complete this journey with a clear exploration on Spring Batch for processing batch data.

Track 1: Unit Testing

In this track of the Javanista to Java Master journey, the focus will be on how to write and run JUnit tests and identify the right situation to construct and use mock object.

  • 8 Courses | 10h 55m 49s

Track 2: Java EE

In this track of the Javanista to Java Master journey, the focus will be on how Jakarta Enterprise Edition (JEE) offers a straightforward and comprehensive approach to building state-of-the-art enterprise applications that enables you to create rich web-based interfaces using Java Server Faces (JSF) and effectively construct business logic using Enterprise JavaBeans (EJB). 

  • 5 Courses | 7h 53m 20s

Track 3: Spring Basics

In this track of the Javanista to Java Master journey, the focus will be on Spring principles, Inversion of Control and Aspect Oriented Programming, and database Integration using ORM frameworks such as JPA & Hibernate.

  • 7 Courses | 11h 2m 46s

Track 4: Spring Data

In this track of the Javanista to Java Master journey, the focus will be on working with Spring Data JDBC, Spring Data JPA, and Spring Batch for processing batch data.

  • 8 Courses | 10h 23m 14s

COURSES INCLUDED

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.
10 videos | 1h has Assessment available Badge
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.
9 videos | 1h has Assessment available Badge
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.
9 videos | 1h has Assessment available Badge
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.
6 videos | 51m has Assessment available Badge
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.
6 videos | 47m has Assessment available Badge
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.
15 videos | 1h has Assessment available Badge
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.
14 videos | 2h has Assessment available Badge
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.
12 videos | 1h has Assessment available Badge
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.
1h has Assessment available Badge
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.
10 videos | 1h has Assessment available Badge
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.
10 videos | 1h has Assessment available Badge
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.
2h has Assessment available Badge
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.
12 videos | 1h has Assessment available Badge
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.
8 videos | 1h has Assessment available Badge
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.
12 videos | 1h has Assessment available Badge
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.
12 videos | 1h has Assessment available Badge
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.
14 videos | 2h has Assessment available Badge
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.
9 videos | 1h has Assessment available Badge
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.
1h has Assessment available Badge
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.
1h has Assessment available Badge
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.
10 videos | 1h has Assessment available Badge
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.
8 videos | 1h has Assessment available Badge
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.
57m has Assessment available Badge
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.
12 videos | 1h has Assessment available Badge
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.
9 videos | 1h has Assessment available Badge
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.
7 videos | 1h has Assessment available Badge
Processing Batch Data: The Fundamentals of Spring Batch
For most organizations, processing large amounts of data is an essential task. However, it's often done using unoptimized and difficult-to-maintain solutions. Spring Batch rectifies these constraints, making batch processing a lot more efficient. Use this course as both a theoretical and practical introduction to Spring Batch. After a theoretical overview, learn how to build a batch process to transform CSV data to XML. In doing this, set up an ItemReader to read from a CSV file, an ItemProcessor to transform the data, and an ItemWriter to write the data to an XML file. When you've completed this course, you'll be able to identify how Spring Batch addresses the common limitations of batch processing and set up and run a Spring Batch application.
10 videos | 1h has Assessment available Badge
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.
10 videos | 1h has Assessment available Badge
FREE ACCESS

EARN A DIGITAL BADGE WHEN YOU COMPLETE THESE TRACKS

Skillsoft is providing you the opportunity to earn a digital badge upon successful completion on some of our courses, which can be shared on any social network or business platform.

Digital badges are yours to keep, forever.

YOU MIGHT ALSO LIKE