An excerpt from
here.
I�ll just quote the list, to make it more clear:
* You need to be proficient in object-oriented analysis and design (OOA/D), design
patterns (GoF, J2EEDP), and integration patterns.
You should be intimately familiar with UML, especially class, object, interaction, and state diagrams.
* You need to learn
Java the language and its core class libraries (collections, serialization, streams, networking, multithreading, reflection, event handling, NIO, localization, etc.).
* You should understand how the JVM, class loaders, and garbage collector work in general. You should be able to decompile a class file and comprehend basic byte code instructions.
* If you�re going to write clients, you need to learn
applets for the web and Swing, AWT, or SWT for the desktop. You should also be familiar with the JavaBeans component model for UI widgets. JavaBeans are also used in
JSP to isolate business logic from the presentation tier.
* You need to learn the
JDBC API and how to use at least one persistence/ORM framework like Hibernate, JDO, CocoBase, TopLink, or iBatis. You also need to understand the implications of the object-relation impedance mismatch, how it will affect your business objects� interactions with a relational database, and its performance consequences.
* You need to learn about the Java sandbox security model (class loaders, byte code verification, managers, policy and permissions, code signing, digital signatures, cryptography, certification, Kerberos, etc) and the various security/authentication APIs, like JAAS (Java Authentication and Authorization Service), JCE (Java Cryptography Extension), JSSE (Java Secure Socket Extension), and JGSS (Java General Security Service).
* You need to learn
Servlets, JSP, and optionally JSTL (Standard Tag Libraries).
* You need to be familiar with popular web frameworks, like
JSF,
Struts, Tapestry, Cocoon, WebWork, and their underlying design models, such as MVC/Model2.
* You need to learn how to use and administer web containers, like
Tomcat, and how to deploy and maintain web applications on them.
* You need to learn about distributed objects and remoting APIs, like RMI and RMI/IIOP.
* You need to learn at least one XML API, like JAXP (Java API for XML Processing), JDOM (Java for XML Document Object Model), or DOM4J.
* You need to learn how to build Web Services using Java APIs and tools, such as JAX-RPC (Java API for XML/RPC), SAAJ (
SOAP with Attachments API for Java), JAXB (Java Architecture for XML Binding), JAXM (Java API for XML Messaging), JAXR (Java API for XML Registeries), and JWSDP (Java Web Services Developer Pack).
* You need to learn a lightweight application framework, like Spring, PicoContainer, Avalon, and their IoC/DI idiom (setter, constructor, interface injection).
* You need to be familiar with various
J2EE technologies, like JNDI (Java Naming and Directory Interface), JMS (Java Message Service), JTA/JTS (Java Transaction API/Java Transaction Service), JMX (Java Management eXtensions), and JavaMail.
* You need to learn about Enterprise Java Beans (EJB) and their various component models: Stateless/Stateful Session Beans, Entity Beans (with Bean-Managed Persistence [BMP] or Container-Managed Persistence [CMP] and its EJB-QL), and Message-Driven Beans (MDB).
* You need to learn how to manage and configure a J2EE application server, such as WebLogic, and utilize its add-on services, like clustering, connection pools, and distributed transactions support. You should also learn how to package and deploy applications on it, and be able to monitor its performance and tune it.
* You need to be familiar with Aspect Oriented Programming and Attribute Oriented Programming � both are confusingly abbreviated as AOP - and their popular Java specifications and implementations, like AspectJ and AspectWerkz.
* You need to be familiar with various utility APIs and frameworks, like Log4J (logging/tracing), Quartz (scheduling), JGroups (network group communication), JCache (distributed caching), Lucene (full-text search), Jakarta Commons, etc.
* If you�re going to interface or integrate with legacy systems or native platforms, you need to learn JNI (Java Native Interface) and JCA (Java Connector Architecture).
* You should be familiar with Jini technology as it relates to distributing systems.
* You should be familiar with the Java Community Process (JCP) and its various Java Specification Requests (JSRs), like Portlets (168), JOLAP (69), Data Mining API (73), etc.
* You should master a Java
IDE, like JetBrains IntelliJ IDEA or Eclipse. (Some people prefer vi/emacs with make files. Whatever makes you tick!)
* Java is verbose and requires a lot of code artifacts (e.g. EJB); therefore you should be familiar with code generation tools, like XDoclet.
* You need to be familiar with a
unit testing framework (
JUnit) and learn various build and deployment tools (
Ant, Maven).
* You should be familiar with several software engineering processes commonly used in Java development, like RUP (Rational Unified Process) and Agile methodologies.
Aargh! Kill me!
