.NET to Java Conversion Training in Nigeria

We can host this training at your preferred location. Contact us!

This is a fast paced course for C# coders who are converting to Java / JEE application development. By the end of the course delegates will be able to program using all the features of Java 8 and build server-side infastructure using both JEE specifications (such as JAX-RS and JPA) and popular open source frameworks (such as Spring Boot and JOOQ). There is also a strong focus on continuous testing and deployment via Agile tools such as Gradle, JUnit and Mockito.

Each topic in the course is introduced in terms of the corresponding .NET technology, enabling delegates to leverage their existing skills and make the transition rapidly. The amount of Java language training included depends on the core prevous experience of the delegates. Please note that topics listed below are representative of a typical delivery, but can be tailored based on the projects the delegates will be moving to. For example Hibernate might be substituted for JPA, JEE CDI for Spring Core and JAX-RS for Spring MVC. By default the course uses the Eclipse IDE but alternatives, such as IntelliJ, can be supported if required.

Delegates must be proficient C# or VB .NET developers, ideally with several years commercial programming experience

Fundamental Concepts of Java / JEE

Making sense of the distinction between JSE and JEE
Comparing Bytecode to Intermediate Language
Comparing the Java Virtual Machine to the CLR
Comparing Java Archives to .NET Assemblies
The role of JEE Containers and the JEE Architecture
Microservices and Cloud Computing in JEE and .NET
The importance of open source frameworks to JEE

Building Java / JEE Applications using Eclipse (or IntelliJ)

How Eclipse is built around SWT, OSGi and plugins
Working with perspectives, views, editors and actions
Writing standalone programs and simple JEE components
Making the most of the support for code generation
Refactoring and Unit Testing your code within Eclipse
An overview of writing your own refactoring plug-ins

Converting to Java (Part 1)

The core Java syntax and type system
The package hierarchy and classpath
Similarities in selection and iteration
Similarities when working with arrays
Comparing the Java and .NET object models
Class declarations in Java verses in C#
Key differences in the use of interfaces

Converting to Java (Part 2)

Properites as accessors and the JavaBean conventions
The typesafe enum pattern and its integration into Java
Using inner classes rather than delegates for event handling
The theory of compiler checked exceptions and proper usage
Non-reified generics, type erasure and bounded wildcards
Creating and decorating your code with annotations
Using compiler plugins to extend the language

Converting to Java (Part 3)

Making basic use of the standard collections
Working with the newer thread safe collections
Functional programming in Java 8 verses .NET LINQ
Declaring and working with lambdas and method refs
Using the streams API as your ‘functional toolkit’
Idioms for getting maximum performance from streams
Using streams outside of the standard collections
Using parallel streams for simplified concurrency

An Overview of the Key Java Libraries

Investigating types using the reflection library
Performing file I/O, basic networking and multicasting
Writing concurrent code using executors and futures
Working with localized dates and times in Java 8

Building Standard JEE Web Applications

Deploying WAR’s and EAR’s into a JEE Container
Writing Servlets and using the Servlets API
Creating control-based UI’s via JSF and Facelets
Injecting dependencies via annotations like @Resource

Using the Java Persistence API (JPA)

How the JPA evolved from tools like Hibernate and Toplink
The concept of a Persistence Unit and its role in JEE Design
Creating basic entity classes and building Persistence Units
Using annotations to define embedded types and many-to-one links
Using annotations to map collections of basic types and entities
How entities move between the transient, perisitent and detached states
Using the EntityManager API to more entities between states
Writing parameterized queries via JPA-QL and CriteriaBuilder objects
Combining JPA with Generics to create a universal DAO base class

Dependency Injection In Spring

Declaring Spring beans via @Component and @Service
Dependency injection by type using @Autowired
Injecting by name using @Autowired and @Qualifier
Specifying the scope of a bean and lifecycle methods
Cusomizing dependency injection via Spring EL

Building MicroServices via Spring MVC and Boot

Declaring RESTful services via Spring MVC
Associating methods with HTTP verbs and MIME types
Marshalling content to and from XML and JSON
Cusomizing the response and handling errors
Accessing the services via an Angular UI
Injecting services into the REST controllers
Simplifying database access via Spring Data JPA
Deploying the application via Spring Boot
Unit and integration testing the application

Additional JEE Specs and Frameworks

JAX-RS as a standardised alternative to Spring MVC
JOOQ as a simpler more performant alternative to JPA
Writing SOAPy Web Services via JAX-WS and JAXB
Using JMS to interact with Messaging Servers
The JTA and managing transactions in JEE