Build an application from scratch: JEE 7, Java 8 and Wildfly
3.9 (226 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
2,127 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Build an application from scratch: JEE 7, Java 8 and Wildfly to your Wishlist.

Add to Wishlist

Build an application from scratch: JEE 7, Java 8 and Wildfly

Learn Java EE 7, Java 8, Wildfly and more by building an application from scratch.
3.9 (226 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
2,127 students enrolled
Created by Luciano Molinari
Last updated 3/2017
English
English
Current price: $10 Original price: $40 Discount: 75% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 15 hours on-demand video
  • 21 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Create a Java enterprise application from scratch.
  • Work and combine a variety of Java EE technologies.
  • Create automated (unit and integration) tests.
  • Understand some new Java 8 features and see them working in practice.
  • Work with Wildfly/JBoss.
  • Use maven as build tool.
View Curriculum
Requirements
  • Some Java/JavaEE knowledge.
Description

This project based course will lead you step-by-step throughout the development of a Java application from the scratch. If you have already felt frustrated by reading a lot of tutorials and not realizing how to put together all these technologies, I guarantee you will not have this feeling here, as we will be coding together a whole application, passing through the project creation, coding, writing unit and integration tests, creating the database, configuring the application server, deploying the application and performing real tests!

This course will cover a lot of Java technologies that will be used in practice while we create our project, including:

  • Java EE 7: JPA 2.1, Bean Validation 1.1, JMS 2.0, EJB 3.2, CDI 1.1, JAX-RS 2.0, security.
  • Java 8: Lambda expressions, Date and Time API, streams and more.
  • Libraries such as Gson, JUnit, Mockito and Hamcrest.
  • Arquillian for integration tests.
  • Wildfly 8 (former JBoss) as Application Server.
  • PostgreSQL for production and HSQLDB/H2 for unit and integration tests.
  • Maven.
  • Eclipse IDE (this is a Maven project, so you can use other IDE).
  • Postman Chrome extension to test all our REST endpoints.


This course is not only about technologies, but also about best practices, such as writing automated tests (both unit and integration) for most of the code, refactoring, OOP (object-oriented programming) and much more.

Who is this course for:

  • Honestly, for every Java developer that wants to see how to create a real enterprise application using state-of-the-art technologies and best practices. Seriously! However, if you are beginner in the Java world, you will need to explore more the details of some technologies, as this course in really hands on.

If you are still unsure about enrolling in this course, watch the first free videos so you can get more details about the architecture, technologies and requirements about the project that will be created throughout this course.

Who is the target audience?
  • This course is meant for students who already have some knowledge about Java/Java EE. It can be somewhat difficult for Java Beginners.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
86 Lectures
14:51:31
+
Training introduction
5 Lectures 23:07

This lecture will give you a basic overview of this training, touching points related about how it will be conducted and technologies used.

Preview 03:21

You will now have the opportunity to get more details about the requirements of the project that will be built during this course.

Preview 03:45

Summary of the technologies approached throughout this training and that will be used to create our project.

Preview 07:14

General idea of the architecture of the project.

Preview 02:41

In this lecture you will see how the project will be built in terms of methodologies.

Preview 06:06
+
Introduction to some of the technologies used in this training
8 Lectures 36:20

All the lectures of this section will provide you a basic overview of each of one of these technologies, going through some of their characteristics and a few examples.

Introduction
00:55

In this video we will provide an overview about EJBs and what they are, how they are configured and some of its features. You will also see some basic examples of Stateless and Singleton beans.

EJB
07:18

In this lecture we will see what JPA is and some of its characteristics. You will also see a simple example of an Entity.

JPA
04:23

In this video, we will talk about CDI and some of its characteristics and features.

CDI
03:43

This video will provide you and overview of JAX-RS, going though its characteristics, features and a basic example of creating a web service and a client for it using JAX-RS.

JAX-RS
04:39

Let's see in this video an overview about JMS and its characteristics, features and a basic example of sending and receiving a message to/from a queue.

JMS
04:27

In this video we will see what Arquillian is and understand more about its main goal and go through some of its features.

Arquillian
03:55

This lecture will give you and overview about Wildfly, some of its characteristics and folder structure.

Wildfly
07:00
+
Category Management
17 Lectures 03:57:01

This video will give you an overview of what is going to be covered in this section, as well as some basic requirements for this feature.

Introduction
02:48

In this class we will define the coding standards for our project and configure Eclipse to obey to them. We will also create the initial Maven project.

Starting the project
09:32

In this lecture, we will create our first JPA entity: Category. We will also start the implementation of the CategoryRepository and to write unit tests for this class, which involves setting up the in memory database and creating the data source.

Model and repository layer
18:36

In this video, we will refactor the common code from our test case to some helper classes and then use Java 8 to make the code even cleaner.

Refactoring the existing code
06:56

In this class we will finish the implementation of CategoryRepository as well as its test cases.

Finishing repository layer
16:12

Now that we have finished our CategoryRepository, we will start creating the CategoryServices and its unit test cases. We will get into creating mocks with Mockito and how to use bean validation and exceptions to validate the input.

Service Layer
17:46

In this lecture, we will be finishing the implementation of CategoryService and its related test cases.

Service Layer - Finishing implementation and test cases
14:02

In this video we will create the new module library-resource, that will hold our REST interfaces. We will also create some helper code and unit tests. Besides, we will see how to use Mockito with annotations. And that is not all, JAX-RS, Json and Gson will also be covered. To finish, we will create our first test case for this class.

REST endpoints - Preparing the basics
15:23

In this video, we will:

  • Start the implementation of CategoryResource class.
  • Create the class CategoryJSONConverter using Gson.
  • Create helper classes used by our REST endpoints.
REST endpoints - Starting the implementation
18:28

Now that we have the helper classes, we will finish the implementation and test cases for all scenarios for the add operation.

REST endpoints - Finishing the implementation and test cases for add() operation
20:05

At this point, we will be able to complete the implementation and test cases for all operations for CategoryResource.

REST endpoints - Adding implementation and test cases for all operations
14:43

In this video, we will start to create the infrastructure needed to support our integration tests:

  • Define 2 profiles in Maven, 1 for default compilation/unit test execution and one that will also run the integration tests.
  • Configure Maven to unpack Wildfly to the target folder and configure it.
  • Add JAX-RS, EJB and CDI annotations to our classes.
  • Create a basic JAX-RS Client that will allow us to access our REST endpoints.
Integration tests - Preparing the basics
18:56

In this lecture, we will:

  • Add our first integration test.
  • Configure Wildfly to be used in the integration tests.
  • Use Shrinkwratp to create the deployment package, with all required files.
  • Create the first test case.
Integration tests - Creating and running first test case
17:08

During this video, we will see how to convert RuntimeExceptions in application exceptions. We will also create some helper classes and add more test cases.

Integration tests - Adding more test cases
13:49

In this lecture, we will solve the issue around cleaning database before running each integration test using a REST interface and EJB. Then we will see how to load data to create the test case for the findAll() operation.

Integration tests - Adding test case for findAll() operation
12:17

Now that our feature is ready, we will create two more projects with maven: library-resource-war.war and library.ear. Then we will create the database and the table for category feature.

Preparing the project to be deployed
08:56

To finish this section, we will:

  • Configure Wildfly to add the PostreSQL JDBC Driver and create the datasource.
  • Deploy application.
  • Test Category REST interfaces with postman.
Manual testing
11:24
+
Author management
9 Lectures 01:42:09

In this lecture we will see what is going to be created in this section, some technologies used and requirements for Author management.

Introduction
01:53

In this video we will:

  • Create Author entity.
  • Create AuthorRepository.
  • Create some unit tests.
  • Start to work with real pagination by creating some basic classes.
Model and repository layer
12:59

Now that we have the basic classes for pagination, we will implement and create tests for the findByFilter() operation.

Repository layer - Implementing/testing findByFilter() operation with pagination
15:26

At this point, we have some duplicated code in the Repository classes that can be extracted to a common class. The same is valid for our test code, so we will also refactor them. During this process, you will see how our tests can give us safety to make these changes.

Repository layer - Refactoring
12:03

In this lecture we will create the service layer and its unit tests. Again we will be refactoring some code.

Service layer
10:48

Let's now implement the REST endpoints along with its unit tests. We will also refactor the JSON converter code using generics and see how Java 8 can help us in defining a common interace.

REST endpoints
15:32

In this video we will complete the AuthorResource and its tests. We will also see how to extract the filter parameters from URL using JAX-RS API. And to finish, we will refactor some code to create JSON with list of results and pagination.

REST endpoints - Finishing implementation and test cases
17:18

In this lecture, we will write the integration tests for this feature.

Integration tests
11:37

To finish this section, we will create the table for author management feature, deploy our application in the Wildfly and test this new feature with Postman.

Manual testing
04:33
+
User management
12 Lectures 02:32:52

In this lecture, you will have the chance to know the topics covered in this section, as well as the requirements for User Management feature.

Introduction
03:10

Let's now create the User abstract class and its implementations Customer and Employee using JPA and its inheritance support. We will also start to work in the UserRepository and its test cases.

Model and repository layer
17:45

In this lecture we will add a few more test cases to our repository layer and refactor findByFilter() method to GenericRepository.

Repository layer - Finishing implementation and refactoring more code
16:44

In this video we will star to work in the service layer and then add a custom ArgumentMatcher in Mockito to improve our tests' accuracy.

Service layer - Going deeper with Mockito
17:08

In this this video we will be finishing the implementation of UserServices along with its unit tests.

Service layer - Completing implementation and test cases
12:11

In this lecture, we will create the REST endpoints and a few test cases. We will also start to use security in the REST endpoints.

REST endpoints
18:15

Let's now continue with the implementation of user REST endpoints and unit tests and some refactoring.

REST endpoints - Finishing implementation and refactoring more code
17:54

In this lecture we will configure security in our application and in Wildfly, for testing purposes.

Integration tests - Running first test case with security enabled
14:59

In this video we will change our REST client to add an authentication filter.

Integration tests - Adding security filter on the client side
05:23

In this video we will finish the implementation of integration tests for user management.

Integration tests - Adding more test cases with security
10:59

Now, we we will update the existing features (Category and Author) to both add security and update their integration tests.

Integration tests - Update existing features and test cases to consider security
07:03

To complete this section, we will create the tables related to user, configure Wildfly for security and run manual tests using Postman.

Manual testing
11:21
+
Book Management
8 Lectures 01:25:20

This lecture will give you an overview of what will be covered in this section and also the requirements for Book Management.

Introduction
01:59

In this video, we will define the Book entity and its relationships. We will also create the Repository Class and its unit tests, looking into how to manage dependencies to other entities.

Model and repository layer
15:39

During this lecture, we will be finishing the implementation of the BookRepository class and its unit tests.

Repository layer - Completing implementation and test cases
06:53

In this lecture we will work in the implementation and tests of our service layer, also looking into how to validate dependencies.

Service layer
15:28

In this video we will implement the REST endpoints and unit tests.

REST endpoints
15:44

We will start now to create the integration tests and see how we can manage the dependencies required to create and update a book.

Integration Tests
15:16

In this lecture we will finish the implementation of the integration tests.

Integration Tests
08:50

To finish this section, we will create the tables related to book management and test our application using Postman.

Manual testing
05:31
+
Order management
12 Lectures 02:10:02

In this lecture, you will have the chance to know the topics covered in this section, as well as the requirements for Order management feature.

Introduction
03:16

In this lecture, we will define the Order entity and its relationships. We will also use embedded entities.

Model layer
15:27

In this video, we will start to implement the OrderRepository.

Repository layer
11:45

Let's now finish the implementation of OrderRepository and its test cases.

Repository layer - Completing implementation and test cases
09:08

In this lecture, we will start the implementation of the service layer, applying the business rules and coding some test cases.

Service layer
14:53

In this video, we will finish the implementation of the service layer along with its test cases.

Service layer - Finishing implementation and test cases
19:02

During this video, we will be implementing the order REST endpoints and its test cases.

REST endpoints - Creating the test cases
15:23

During this video, we will be implementing the order REST endpoints to comply with the test cases created in the previous lecture.

REST endpoints - Working in the implementation
08:24

We had an issue with the Comparator in the previous lecture and now you will have the chance to understand and fix it.

REST endpoints - Fixing issue with Comparator
01:02

In this video, we will implement the integration tests for the order REST endpoints.

Integration Tests
18:58

In this lecture we will be refactoring 2 points in our code:

  • Understand eager x lazy initialization of relationships in JPA and change that for Order.
  • Extract findByPropertyNameAndValue() to a common class.
Refactoring
06:10

To complete this section, we will create the tables related to the order management and test our application.

Manual testing
06:34
+
Auditing the system
6 Lectures 47:49

This lecture will provide you an overview of what will explored within this section.

Introduction
02:13

In this video, we will create both entity and repository with its unit tests for the log audit feature.

Model and repository layer
04:36

In this video we will create an annotation and add it to the service layer classes. We will also create and EJB interceptor reponsible for processing this annotation.

Defining annotation and interceptor
12:34

In this lecture, we will implement the REST web services and its unit tests.

REST endpoints
08:39

Let's now create integration tests for log audit feature and change integration tests for author, category and book features to consider the log audit feature.

Integration Tests
16:35

To finish this section, we will create the table for log audit and test this feature using Postman.

Manual testing
03:12
+
Order expiration
5 Lectures 46:32

In this lecture, we will see what will be covered within this section.

Introduction
02:07

In this video, we will create a properties file to hold the number of days for and order to be expired and a CDI bean responsible for reading this file. We will also see how to use a singleton EJB with timer and PostConstruct annotation.

Defining and reading the number of days before expiring an order
09:06

Let's now test our feature by creating some integration tests. These test cases will be executed in the container rather than in the client (like we did in the previous sections) and we will also see how to use InSequence annotation in Arquillian tests.

Integration tests
15:31

Now that our feature is working, we will create our own annotation to inject properties automatically in the OrderExpiratorJob using CDI annotations. We will also improve our Shrinkwrap usage to not inform the dependencies version.

Refactor the implementation to use CDI extensions
15:34

To finish this section, we will see how to change log level in Wildfly and we will also test the order expiration feature.

Manual testing
04:14
+
Miscellaneous and conclusion
4 Lectures 30:19

In this video, you will see how to use CDI specification to send and receive events.

CDI events
08:43

During this lecture, you will be guided through the process of configuring a JMS queue in Wildfly and how to send and receive events using that queue.

JMS
09:36

In this lecture, you will see an AngularJS application interacting with our REST web services. Then you will see how we can tackle CORS (Cross Origin Resource Sharing) with JAX-RS filters. And to perform manual tests, you will learn how to declare static resources in Wildfly and how to start 2 Wildfly instances in the same machine.

Accessing our system's WS from an AngularJS application and dealing with CORS
10:33

In this video, we will be concluding this course.

Conclusion
01:27
About the Instructor
Luciano Molinari
3.9 Average rating
225 Reviews
2,127 Students
1 Course
Software engineer/architect

My name is Luciano Davoglio Molinari, I have over 8 years of experience in software development and architecture, especially with Java, and have worked in a variety of projects and industries. I currently have the following Java certifications: SCJP, SCWCD, SCBCD and SCEA/OCMJEA.

All this gives me enough idea and knowledge of what companies look in their Java professionals. And that is the main goal with my courses, teach you Java based on real scenarios, always focusing on technologies highly demanded by the market.