Java for Experienced .NET Developers

Fast track conversion course for experienced .NET developers moving to Java

Overview

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.

Outline

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

Requirements

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

Sign up and stay in the loop

Be the first to know about upcoming workshops, courses, talks and events

Learn more

The course was extremely informative and helpful, a lot of content covered in a comprehensive and easy to understand manner. Would definitely recommend to anyone wanting to learn Java or reinforce any knowledge you already have of it.