Thread: Re: new to java

Dear All,

I am new to Java and trying to get into Java/J2EE programming.I have been in the IT industry for around 10 years and have coded at lot in C++,C, Perl and other scripting languages but now I want to make a transition into Java/J2EE programming.For the same I have decided to take up a J2EE training in one of the training institutes where there is a choice of either of these two courses with the following topics.

Could you please share your expert opinion which of the two might be best to take based on current demands in industry and future projections?
Do you see the course being adequate covering all in demand topics?If you see any important thing missing from the course please let me know.

Thanks in advance for your expert opinion.

Course1:Java Enterprise Application Training (J2EE)

Building Web Services with JAX-WS
Setting the Port
Creating a Simple Web Service and Client with JAX-WS
Types Supported by JAX-WS
Web Services Interoperability and JAX-WS
Further Information about JAX-WS
Binding between XML Schema and Java Classes
JAXB Architecture
Representing XML Content
Binding XML Schemas
Customizing Generated Classes and Java Program Elements
JAXB Examples
Basic JAXB Examples
Customizing JAXB Bindings
Java-to-Schema Examples
Streaming API for XML
Why StAX?
StAX API
Using StAX
Sun’s Streaming XML Parser Implementation
SOAP with Attachments API for Jav
Overview of SAAJ
SAAJ Tutorial
Enterprise Beans (EJB)
What Is an Enterprise Bean?
What Is a Session Bean?
What Is a Message-Driven Bean?
Defining Client Access with Interfaces
The Contents of an Enterprise Bean
Naming Conventions for Enterprise Beans
The Life Cycles of Enterprise Beans
Getting Started with Enterprise Beans
Creating the Enterprise Bean
Creating the converter Application Client
Creating the converter Web Client
Deploying the converter Java EE Application
Running the converter Application Client
Running the converter Web Client
Modifying the Java EE Application
Session Bean Examples
A Web Service Example: helloservice
Using the Timer Service
Handling Exceptions
A Message-Driven Bean Example
simplemessage Example Application Overview
The simplemessage Application Client
The Message-Driven Bean Class
Packaging, Deploying, and Running the simplemessage Example
Creating Deployment Descriptors for Message-Driven Beans
Introduction to the Java Persistence API
Entities
Managing Entities
Persistence in the Web Tier
Accessing Databases from Web Applications
The Java Persistence Query Language
Query Language Terminology
Simplified Query Language Syntax
Example Queries
Full Query Language Syntax
Introduction to Security in the Java EE Platform
Overview of Java EE Security
Security Implementation Mechanisms
Securing Containers
Securing the Application Server
Working with Realms, Users, Groups, and Roles
Establishing a Secure Connection Using SSL
Securing Java EE Applications
Securing Enterprise Beans
Enterprise Bean Example Applications
Securing Application Clients
Securing EIS Applications
Securing Web Applications
Overview of Web Application Security
Working with Security Roles
Checking Caller Identity Programmatically
Defining Security Requirements for Web Applications
The Java Message Service API
Overview of the JMS API
Basic JMS API Concepts
The JMS API Programming Model
Writing Simple JMS Client Applications
Creating Robust JMS Applications
Using the JMS API in a Java EE Application
Java EE Examples Using the JMS API
A Java EE Application That Uses the JMS API with a Session Bean
A Java EE Application That Uses the JMS API with an Entity
An Application Example That Consumes Messages from a Remote Server
An Application Example That Deploys a Message-Driven Bean on Two Servers
Transactions
What Is a Transaction?
Container-Managed Transactions
Bean-Managed Transactions
Transaction Timeouts
Updating Multiple Databases
Transactions in Web Components
Resource Connections
Resources and JNDI Naming
DataSource Objects and Connection Pools
Resource Injection
The confirmer Example Application
Connector Architecture
About Resource Adapters
Resource Adapter Contracts
Common Client Interface







Course2:Java Web Application Training (J2EE)

Java Servlet Technology
What Is a Servlet?
Servlet Life Cycle
Initializing a Servlet
Writing Service Methods
Filtering Requests and Responses
Accessing the Web Context
Maintaining Client State
Java Server Pages Technology
What Is a JSP Page?
The Life Cycle of a JSP Page
Creating Static Content
Creating Dynamic Content
Unified Expression Language
JavaBeans Components
Using Custom Tags
Reusing Content in JSP Pages
Including an Applet
Java Server Pages Standard Tag Library
Using JSTL
Core Tag Library
XML Tag Library
Internationalization Tag Library
SQL Tag Library
JSTL Functions
Custom Tags in JSP Pages
What Is a Custom Tag?
Types of Tags
Encapsulating Reusable Content Using Tag Files
Tag Library Descriptors
Programming Simple Tag Handlers
Scripting in JSP Pages
Using Scripting
Disabling Scripting
JSP Declarations
JSP Scriptlets
JSP Expressions
Java Server Faces Technology
Java Server Faces Technology User Interface
Java Server Faces Technology Benefits
What Is a Java Server Faces Application?
User Interface Component Model
Navigation Model
Backing Beans
The Life Cycle of a Java Server Faces Page
Using Java Server Faces Technology in JSP Pages
Setting Up a Page
Using the Core Tags
Adding UI Components to a Page Using the HTML Component Tags
Using Localized Data
Using the Standard Converters
Registering Listeners on Components
Using the Standard Validators
Binding Component Values and Instances to External Data Sources
Binding Converters, Listeners, and Validators to Backing Bean Properties
Referencing a Backing Bean Method
Using Custom Objects
Developing with Java Server Faces Technology
Writing Bean Properties
Performing Localization
Creating a Custom Converter
Implementing an Event Listener
Creating a Custom Validator
Writing Backing Bean Methods
Creating Custom UI Components
Determining Whether You Need a Custom Component or Renderer
Understanding the Image Map Example
Steps for Creating a Custom Component
Creating Custom Component Classes
Delegating Rendering to a Renderer
Handling Events for Custom Components
Creating the Component Tag Handler
Defining the Custom Component Tag in a Tag Library Descriptor
Configuring Java Server Faces Applications
Application Configuration Resource File
Configuring Beans
Registering Custom Error Messages
Registering Custom Localized Static Text
Registering a Custom Validator
Registering a Custom Converter
Configuring Navigation Rules
Registering a Custom Renderer with a Render Kit
Registering a Custom Component
Basic Requirements of a Java Server Faces Application
Internationalizing and Localizing Web Applications
Java Platform Localization Classes
Providing Localized Messages and Labels
Date and Number Formatting
Character Sets and Encodings