What is middleware?
Client ---
Middleware(includes servlets,JSP,HTML,XML,webserver)
legacy Appln or Enterprise Information systems. (e.g. RDBMS, ERP, etc).
The client wants to get the service of legacy application (e.g. database transaction).
J2EE defines client tier-middle tier- and back-end tier.
Middleware contains containers and components.
Containers: Web Container (contains servlets, JSP, HTML, etc),
EJB Container (contains business logic).
The containers provide std services by any vendor. The components in
those containers are written by developers.
The containers may be distributed on different platforms.
.The J2SE API consists of two groups: Core Java and Desktop Java.
* Core Java provides essential functionality for writing powerful enterprise-worthy programs in key areas such as database access, security, remote method invocation (RMI), and communications, to name a few.
* Desktop Java consists of deployment products such as Java Plug-in, component modeling APIs such as JavaBeans, graphical user interface (GUI) APIs such as
the Java Foundation Classes (JFC) and Swing, and multimedia APIs such as Java3D.
more on java desktop:
http://javadesktop.org
Java 2 Platform, Enterprise Edition (J2EE) provides the APIs and tools you need to create and deploy interoperable Web services and clients.
Web Services/XML APIs
It is easy to write Web services and clients with the J2EE XML APIs. All you do
is pass parameter data to the method calls and process the data returned, or for document-oriented web services, send documents containing the service data back and forth. No low-level programming is needed. The following list describes the Web services/XML APIs.
The Java API for XML Processing (JAXP) supports the processing of XML documents
using Document Object Model (DOM), Simple API for XML Parsing (SAX), and XML Style sheet Language Transformation (XSLT). The JAXP API enables applications to parse and transform XML documents independently of a particular XML processing implementation.
The Java API for XML Registries (JAXR) lets you access business and general-purpose registries over the Web. JAXR supports the ebXML Registry/Repository standards and the UDDI specifications.
The Java API for XML-based RPC (JAX-RPC) uses the SOAP standard and HTTP so client programs can make XML-based remote procedure calls (RPCs) over the Internet.
JAX-RPC also supports WSDL so you can import and export WSDL documents. With JAX-RPC and a WSDL, you can easily interoperate with clients and services running on Java-based or non-Java-based platforms such as .NET.
The SOAP with Attachments API for Java (SAAJ) enables you to produce and consume messages conforming to the SOAP 1.1 specification and SOAP with Attachments note.
Java Technology and Web Services is organized into these subcategories:
Java Web Services Developer Pack (Java WSDP)
Java API for XML-Based RPC (JAX-RPC)
Java API for XML Registries (JAXR)
Java API for XML Processing (JAXP)
Java Architecture for XML Binding (JAXB)
SOAP with Attachments API for Java (SAAJ)
XML and Web Services Security
Alternatively, check out JConfig:
http://www.tolstoy.com/samizdat/jconfig.html
JConfig is a cross-platform library that fills in many of the gaps in
the core Java API, and makes it possible to work with files, processes,
file types, video monitors, etc. in a much more Windows- and
Mac-friendly manner.
21. (Sect. 7) I did a read from a Buffered stream, and I got fewer bytes
than I specified.
[*] This is the way that BufferedInputStream works up to and including
the current release. The behavior is so unintuitive that it really
represents a bug. Javasoft has "resolved" the bug by writing comments
in the program so that the broken behavior is in the range of legal
outcomes. Ugh.
When you instantiate a buffered input stream, you can specify the size
of buffer it should use. Let's call this the internal buffer. When you
call read() you can say how many bytes to read. Let's call this the
request. If the request is smaller than the internal buffer and not a
multiple of the internal buffer, then the last read returns only the
odd bytes left in the internal buffer! The more reasonable and
intuitive behavior would be for the internal buffer to be refilled, so
that the whole request can be granted.
For example, if you create a BufferedInputStream with an internal
buffer of 1000 bytes, and try to read 512 byte chunks, your first read
will return 512 bytes, but your second read will only return
(1000-512), or 488, bytes. (Assuming that the file has at least that
many bytes in it). The following code illustrates the problem.
// troubleshooting by Tov Are Jacobsen
import java.io.*;
class filebug {
public static void main(String args[])
throws FileNotFoundException, IOException {
BufferedInputStream bis =
new BufferedInputStream(
new FileInputStream("test.txt"), 1000 );
byte[] buf = new byte[2000];
int numread;
System.out.println( "Available: "+bis.available() );
while (true) {
numread = bis.read(buf,0,512);
if (numread<0) break;
System.out.println( "got "+numread
+", avail:"+ bis.available());
}
}
}
Of course, a valid reason for getting less than you asked for is that
you asked for more data than is actually available in the Stream, e.g.
you requested 512 bytes from a file that only contains 40 bytes. In
general, there are no guarantees about how much data is returned for a
given buffered input stream read request. To avoid this problem, push a
DataInputStream on top of your buffered stream. Then you can call
readFully(), which will do what you want.
A similar "got less than I asked for" occurs when reading a socket.
Network protocols frequently packetize data and send it across in
bursts. Nothing is lost of course, and you are always told how many
bytes you actually got. You will get the remaining bytes on a
subsequent read. This happens regardless of the language used. Be sure
to check the "amount of data returned" when using the read(byte[], int,
int) method of BufferedInputStream, or when reading from a socket.
22. (Sect. 7) How do I redirect the System.err stream to a file?
[*] You cannot assign a new FileOutputStream to System.err, as it is
final. Instead use the System.setErr() library call, like this:
FileOutputStream err = new FileOutputStream("stderr.log");
PrintStream errPrintStream = new PrintStream(err);
System.setErr(errPrintStream);
This was introduced with JDK 1.1. There is also a corresponding setIn()
for redirecting standard in, and a setOut() for standard out.
Note that you will get a compiler warning about a deprecated construct
when you do this. PrintStreams are deprecated in favor of PrintWriters,
which handle Unicode properly. The PrintStream is marked as deprecated
by marking all its constructors as deprecated. There is no way to
create the PrintStream needed to redirect System.err or System.out
without triggering the deprecated warning.
24. (Sect. 7) Is there a way to read a char from the keyboard without
having to type carriage-return?
[*] You can do this in a GUI (e.g. in a text component). There is no
pure Java way to do character-by-character I/O without using a GUI.
2. (Sect. 8) How do I print from a Java program?
[*] Use the Toolkit.getPrintJob() method
Component c = this.getParent();
while (c!=null && !(c instanceof Frame))
c=c.getParent();
// With a JComponent use c=getTopLevelAncestor();
PrintJob pj = getToolkit().getPrintJob((Frame) c, "test", null);
Graphics pg = pj.getGraphics();
printAll(pg);
pg.dispose();
pj.end();
7. (Sect. 8) How do you read environment variables from with a Java
program?
java -Dfoo=$foo MyClass (Unix)
or
java -Dfoo=%foo% MyClass (Win95/NT)
This sets the "foo" property to the value of the environment variable
foo, and makes it available in the System properties. Make sure you do
not leave any spaces after the -D or around the = sign. Inside the
program you get the value with:
String env = System.getProperty("foo");
14. (Sect. 8) Where/why should I use the Enumeration interface?
And here's how you might look at all the tokens in a String:
StringTokenizer tokens =
new StringTokenizer (SomeArbitraryString, "\n", false);
Enumeration enum = tokens.elements();
while enum.hasMoreElements()
System.out.println(enum.nextElement());
Second answer: Notepad expects to see a "carriage return/line feed"
pair at the end of each line, rather than just the "newline"
(line-feed) commonly used on Unix. Use this program to expand all
newlines,
..how to change \n to \r\n
/*
* Usage: jre crlf file1.java file2.java ... fileN.java
*/
import java.io.*;
class crlf {
public static void main(String s[]){
byte b[]; byte p;
FileInputStream is;
BufferedOutputStream os;
File f;
for (int i=0; i < s.length;i++){
try{
f=new File(s[i]);
b=new byte[(int)f.length()];
is = new FileInputStream(f);
is.read(b); is.close();
os = new BufferedOutputStream(
new FileOutputStream(s[i]),b.length);
p='?';
for(int j=0; j < b.length; j++){
if((p!='\r')&&(b[j]=='\n')) os.write('\r');
p=b[j]; os.write(p);
}
os.flush(); os.close();
}catch(IOException e){
System.err.println(e.toString());
}
}
}
}
3. (Sect. 11) Where can I find a Swing tutorial?
[*] There is a Swing tutorial at
http://java.sun.com/docs/books/tutorial/ui/swing/index.html which is
part of this tutorial:
http://java.sun.com/docs/books/tutorial/ui/TOC.html
There is also a Swing FAQ at http://www.drye.com/java/faq.html
See also http://www.codeguru.com/java/Swing/index.shtml
There is a Swing Developer Connection website with white papers and
examples at http://www.theswingconnection.com/.
Please let this FAQ maintainer know about other good Swing tutorials
and online resources.
6.8: How do I version a class?
There is no support for versioning classes in Java 1.0. However in Java 1.1 the serialver tool provides a serialVersionUID for one or more classes you can add to your class as a field. This is used in object serialization.
reading from stdin...
static int getNextInteger() {
String line;
DataInputStream in = new DataInputStream(System.in);
try {
line = in.readLine();
int i = Integer.valueOf(line).intValue();
return i;
}
catch (Exception e) {
return -1;
}
} // getNextInteger ends here
reading text from inputline :
try {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String str = "";
while (str != null) {
System.out.print("> prompt ");
str = in.readLine();
process(str);
}
} catch (IOException e) {
}
printing to output file:
FileOutputStream fout = new FileOutputStream("test.out");
// now to the FileOutputStream into a PrintStream
PrintStream myOutput = new PrintStream(fout);
myOutput.println(fahr + " " + celsius);
reading from text file:
import java.io.*;
FileInputStream fin = new FileInputStream(args[i]);
// now turn the FileInputStream into a DataInputStream
DataInputStream myInput = new DataInputStream(fin);
try {
while ((thisLine = myInput.readLine()) != null) { ... }
catch (Exception e) { ... }
Hello World: The Applet
import java.applet.Applet;
import java.awt.Graphics;
public class HelloWorldApplet extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}
Hello World
This is the applet:
Passing Parameters to Applets
import java.applet.Applet;
import java.awt.Graphics;
public class DrawStringApplet extends Applet {
String input_from_page;
public void init() {
input_from_page = getParameter("String");
}
public void paint(Graphics g) {
g.drawString(input_from_page, 50, 25);
}
}
Now you need to create an HTML file that will include your applet. The following simple HTML file will do:
Draw String
This is the applet:
Non-blocking read ?
Use
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
String host = ...;
InetSocketAddress socketAddress =
new InetSocketAddress(host, 80);
channel = SocketChannel.open();
channel.configureBlocking(false);
channel.connect(socketAddress);
Question
When should I use an InputStream, and when should I use a Reader?
Answer
* If you're reading data, such as bytes of information, you are best off to use InputStreams and DataInputStream in particular.
* If you're reading in text, and want to be able to call a readLine() method, its best to use Readers, and BufferedReader in particular.
So what's the difference? Well, DataInputStream's readLine() method is deprecated, because of problems with this method. Readers offer an alternative - though placing a readLine() method in a BufferedReader still seems a little odd to me. Whether its buffered or not has little to do with the fact it can read lines of text - but its easy enough to live with.
------
How can I tell the type of machine and OS my Java program is running on?
System.out.println ( System.getProperty("os.arch") + " running " +
System.getProperty("os.name") ); }
J2SE5.0 support for printf & scanf like things:
The printf function is a new method of the java.io.PrintStream class.
System.out.printf() is now supported.
Also see java.util.Formatter class for sprintf() kind of functionality.
For scanf equivalent, do following:
one can use java.util.Scanner :
Scanner sc = Scanner.create(System.in);
int i = sc.nextInt();
float f = sc.nextFloat(); // String sc.next(String pattern) etc.
note: The java.util.regex.Pattern class can be used to construct a regex.
Use java.util.* StringTokenizer class to tokenize the string:
String speech = "Four score and seven years ago";
StringTokenizer st = new StringTokenizer(speech); // 2nd arg is opt separator
while (st.hasMoreTokens()) {
println(st.nextToken());
}
This can be used for formatted input processing.
Note: You can also use Enumeration to get a snapshot of the set of tokens:
Enumeration enum = st.elements();
while enum.hasMoreElements() System.out.println(enum.nextElement());
Q . How can a Java program determine the level of JDK support given by the underlying VM? I.e. is it running in a JDK 1.0.2 or 1.1 VM?
Ans : Look at the java.version system property with:
String ver = System.getProperty("java.version");
There isn't a lot of standardization on the string contents however.
Another possibility is to try { ... } to load a class that is unique to
one release, like this:
boolean isJDK1_1 = true;
try {
// java.awt.Cursor is available only in the 1.1.x JDK
Class cls = Class.forName("java.awt.Cursor");
} catch (Exception e) {
// we should have written 'ClassNotFoundException e',
// but Communicator generates security exception instead.
isJDK1_1 = false;
}
It can be compiled by any version compiler.
Note: you can create new instances of dynamically loaded classes as below:
Object foo = (Cursor) cls.newInstance(); // etc.
Note:Use javap to verify the class integrity:
javap verify packageFoo.ClassE
Class packageFoo.ClassE succeeds
synchronized (obj) {
... // synchronized block
}
JNI equivalent:
if ((*env)->MonitorEnter(env, obj) != JNI_OK) {
... /* error handling */
}
... /* synchronized block */
if ((*env)->MonitorExit(env, obj) != JNI_OK) {
... /* error handling */
};
netbeans java tutorial:
http://www.netbeans.org/kb/41/j2ee-tut/
Next to do:
- Ant tutorial
- Netbeans sample project
- javap source code debugging
- get debuggable lib source for netbeans
- Learned importing existing project:
-Specify project Folder where build.xml etc would be kept.
-Specify source folder (can be separate from project folder)
-build.xml is auto generated
appserver installation msg:
welcome page: /home/thava/SUNWappserver/docs/about.html
start appserver:
SUNWappserver/bin/asadmin start-domain domain1
start Admin console:
http://localhost:33862
access samples:
http://localhost:33859/samples/index.html
How to create executable jar file ?
% jar cvfm MyApp.jar MyApp.mf *.class *.gif
where MyApp.mf is:
Main-Class: MyAppMain
Class-Path: mylib.jar
% java -jar MyApp.jar
On windows what is the diff between java and javaw ?
javaw does not start with a console where java does.
==================================================================================
Typical notify/wait calls occur in following ways:
Note: When you do wait()/notify(), the executing thread should be the
monitor for the object on which the wait()/notify() is called.
Case 1: any one executing the synchronized instance method becomes monitor
for the "this" object. so the wait()/notify() is actually this.wait()
and this.notify()
class xxx {
synchrnozied public void myfunction(){
if (condition) wait();
.....
if (another_condition) notify();
}
}
Case 2: Any one who does explicit synchronized on "this" object or any object
does explicit notify()/wait()
synchronized (obj) {
if (condition) obj.wait();
....
if (another_condition) obj.notify();
}
Case 3: do explicit synchronized on "this" object.
Note that the "this" object need not be of "thread" type here,
but often this type of usage occurs with in "thread" classes.
synchronized (this) {
if (condition) wait();
....
if (another_condition) notify();
}
==================================================================================
Constructors:
- class A extends B {
public A(String s1, String s2){
super(s1, s2); // By default, first stmt is super();
// this(s2, s2, true); reuses 3 arg constructor.
// use of super() and this() both allowed at same time
// provided super() is called first, and then this().
}
}
- Objects are created from bottom up.
class A extends Object { int k ; }
Provides default construtor automatically like this:
A(){ Create class Reference to "A";
create Parent-Object using this reference;
Assign k = 0; return this reference. }
- If the first statement of constructor does not start with "super" then
automatically "super();" statement is inserted as first statement.
- If constructor with args is defined, then declaring default constructor
is mandatory if you want to use that as well.
*** Watch this out *** If explicit constructor exists, no-arg constructor
must exist if the class is instantiated at runtime or **extended*
at compile time.
- Initialization blocks can be static or non-static.
Non-static initialization blocks can be used to perform initialization
for all constructors. (There by eliminating constructor decln if possible)
e.g. class A (){ int k; static int id = 0;
{ k = id++; } /* This is init block. non-static. */
}
- If a constructor calls a overridable method, surprising results may occur.
If the parent constructor invoked from child constructor, it may end up
calling child overriding method while the child obj is not yet constructed.
- String[] str = new String[10]; => Initializes all 10 strings to be null.
null instanceof Object is false. So be careful in checking the type.
File name Vs Classes:
- File could have multiple class'es. public class should match filename.
- All classes in file A.java (including class A) can be non-public.
Function/Method Declaration/overrides:
- You can define Private function in child for same func in parent!
It is just that you won't get overriding effect.
Usual access restrictions will apply.
- You can also define static func in both parent and child.
This will effectively function hiding not overriding.
- Overriding child func can relax accessibility -- like from protected to public.
but not the other way around.
It is because the child needs to be able to be used in place of parent.
- f(int) can be called for f('c') function call. char autopromoted to int.
If there is f(char), that will be preferred to be called.
- "throws myexception" is part of function signature. If an "unchecked exception"
is declared to be thrown it is ignored from declaration.
- Child can not throw any new exception which is not compatible with the
exceptions thrown by parent.
- Parent function: void f() throws MyException;
Child function: void f(); ==> It is OK. The child is compatible with parent.
Child function need not declare all the throws of parent.
Any runtime exceptions need not be declared as thrown.
- Child overriding method can freely vary: native, synchronized, final parameter, strictfp.
They are implementation details and not part of method signature.
- The fields can only be hidden, not overridden. Same field names are allowed
in children with any different access modifiers.
Tip: You can access the parent's field with super keyword.
- class child extends parent{}
super.method() in child will call parent class's method only
even if it is overridden method.
You can use super.super.method() to access any specific method.
What is static class ?
The class can be declared as :
public, protected, (default-package-visibility), private, static
Top level: only public and default-pkg-level are allowed.
Note: protected is less restrictive than default.
Only member class can be declared as static. what is the use ?
It can be used as new Outerclss.InnerClass() without using
extra packages. Useful to group classes.
---------------------------------------------------
Nested Classes := static Nested Classes | InnerClasses
static Nested Class = public static member class. Like global class.
Just provides namespace nesting.
public Class A { public static Class B { }; }
Types of Innerclasses:
- Member class: Non-static Nested class member inside a class.
This is non-static nested classes = inner class:
This is confusing, so don't use it:
public Class A {
int i;
public Class B { // can also be private.
int m = A.this.i; // Only enclosing class can be referred like this.
};
public void f() { B myB = this.new B(); }
}
- Anonymous. e.g
okButton.addActionListener( new ActionListener(){
public void actionPerformed(ActionEvent e){
dispose();
}
});
- Local classes. similar to local variables. no public, protected, etc
Has access to static & non-static members of enclosing class
* as well as* final variables of enclosing block.
Note: A class defined within a method can only access final fields of
the enclosing method; but can access all fields in enclosing class.
Reason: The local class may outlive the function call.
Implementation: { class-variables; pointer-to-enclosing-class;
pointer-to-final-code-block-variables; }
good example:
public static Enumeration walkThrough(final Object[] objs){
class Enum implements Enumeration{
....
public Object nextElement() { ...; return objs[pos++]; }
}
return new Enum();// create new object on the fly.
// class definition need not be visible outside
}
StaticNested := By definition, static member class. Can be public/protected/ etc.
InnerClass := NonstaticMember | Anonymous | Local
NonstaticMember := Non-static member class.
Class can be declared public/protected/private. (can be accessed from outside)
Can't declare static var, funcs members
Anonymous := Unnamed Class.
Can not be declared public/protected or static/nonstatic.
Can extend static/nonstatic class. (Extending does not influence context)
Assumes static/non-static depending on context.
Can't declare static var, funcs members even in static context.
Local := Can not be declared public/protected or static/nonstatic.
Can extend static/nonstatic class. (Extending does not influence context)
Assumes static/non-static depending on context.
Can't declare static var, funcs members even in static context.
Note: Anonymous and Local Classes assumes static context when defined inside
static func or block Else, assumes non-static context.
i.e. In nonstatic context, the class functions can access instance vars.
Particular instance of Anon/Local class declaration assumes static/nonstatic
context at compile time itself.
- Interface declarations:
- Any class or interface inside interface is public.
- Fiedls in an interface are always static and final (and public)
- All methods in interface are always public and abstract.
- The methods can't be declared if it has to be static or not.
Implementing class decides if it should be static or not.
- Class A implements iface {... Watchout all interface methods must be
declared public here...}
- Any class inside interface is also static(i.e. defn accessible outside)
public interface A { public void f();
interface X { public void foobar(); }
class MyClass { int data = 0; }
MyClass data = new MyClass(); // Common shared dat
// it is like static var shared among implementors.
}
- Classes and interfaces can be declared inside other classes/interfaces
either as members or within blocks of code.
- interface Comparable { int compareTo(Object o); }
- interface Comparator {
int compare(T o1, T o2) ;
boolean equals(Object obj);
}
Note: Default Object.equals() checks only pointer equality.
If you implement your own compare(), better to override equals().
Also, see if you have to override hashCode(), since equal objects
should return equal hash codes.
- Who uses Comprable, who uses Comparator ?
SortedSet, SortedMap content elements should implement Comparable,
so that the insertion into Set itself can be checked for uniqueness and order.
The global static java.util sort methods can be used to sort elements whose
type implement Comparator.
e.g. Collections.sort(collection, comparator_interface);
(note: Collections.sort(collection) will expect the elements to implement Comparable)
- interface SortedSet {
....
Comparator comparator() ;
// Returns the comparator associated with this sorted set,
// or null if it uses its elements' natural ordering.
...
}
Serializable :
- interface Serializable { } -- No functions defined.
- Class ObjectOutputStream implements object serialization.
It verifies if the Obj is declared to be "Serializable" then
executes usual defaultWriteObject() logic.
public class ObjectOutputStream
extends OutputStream
implements ObjectOutput, ObjectStreamConstants
{
public final void writeObject(Object obj)
throws IOException;
public void defaultWriteObject()
throws IOException, NotActiveException;
Write the non-static and non-transient fields of the current class to this stream.
This may only be called from the writeObject method of the class being serialized.
It will throw the NotActiveException if it is called otherwise.
...
Why writeObject() and defaultWriteObject() ?
writeObject() of ObjectOutputStream gives pref to obj.writeObject() if it is defined.
defaultWriteObject() blindly writes the obj to stream.
Thisway, there is no infinite loop of recursive calls.
Typically, object's writeObject() calls ObjectOutputStream's defaultWriteObject();
...
}
- ObjectInputStream implements deserialization :
public class ObjectInputStream extends InputStream
implements ObjectInput, ObjectStreamConstants {
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException;
public void defaultReadObject()
throws IOException, ClassNotFoundException;
...
}
- Synopsis :
FileOutputStream underlyingStream = new FileOutputStream("C:\\temp\\test");
ObjectOutputStream serializer = new ObjectOutputStream(underlyingStream);
serializer.writeObject(serializableObject);
FileInputStream underlyingStream = new FileInputStream("C:\\temp\\test");
ObjectInputStream deserializer = new ObjectInputStream(underlyingStream);
Object deserializedObject = deserializer.readObject( );
- protected Object resolveObject(Object obj) method (in objectInputStram)
can return pre-existing object when you read object.
e.g. useful to implement singleton class.
- interface java.io.Externalizable {
void writeExternal(ObjectOutput stream) throws IOException;
public void readExternal(ObjectInput stream) throws IOException;
}
This interface can be used to completely takeover serializatin/deserialization logic.
This interface is implemented by the Object itself.
- For versioning serialization :
serialver Myclass
> Myclass: static final long serialVersionUID = 10275539472837495L;
Include this defn inside your serializable class.
Generics :
// Generic Class :
public class Box {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
// Generic method
// Other examples:
// public void inspect(U u)
public void inspect(U u){
System.out.println("T: " + t.getClass().getName());
System.out.println("U: " + u.getClass().getName());
}
public static void main(String[] args) {
Box integerBox = new Box();
integerBox.add(new Integer(10));
integerBox.inspect("some text");
}
}
Output: T: java.lang.Integer
U: java.lang.String
- Generic class: A and A both can not be defined.
- class A {}; class B extends A {} => then...
A = A