How to run program examples
---------------------------
JDK 1.4 or later is needed.
### 0. If you have Apache Ant
Run the sample-all task.
Otherwise, follow the instructions below.
### 1. Move to the directory where this `Examples.md` file is located.
In the following instructions, we assume that the `javassist.jar`
file is included in the class path.
For example, the javac and java commands must receive
the following `classpath` option:
```
-classpath ".:javassist.jar"
```
If the operating system is Windows, the path
separator must be not `:` (colon) but
`;` (semicolon). The java command can receive
the `-cp` option
as well as `-classpath`.
If you don't want to use the class-path option, you can make
`javassist.jar` included in the `CLASSPATH`
environment:
```
export CLASSPATH=.:javassist.jar
```
or if the operating system is Windows:
```
set CLASSPATH=.;javassist.jar
```
Otherwise, you can copy `javassist.jar` to the directory
<_java-home_>`/jre/lib/ext`.
<_java-home_> depends on the system. It is usually
`/usr/local/java` or `c:\j2sdk1.4\`, etc.
### 2. `sample/Test.java`
This is a very simple program using Javassist.
To run, type the commands:
```
% javac sample/Test.java
% java sample.Test
```
For more details, see `sample/Test.java`
### 3. `sample/reflect/*.java`
This is the "verbose metaobject" example well known in reflective
programming. This program dynamically attaches a metaobject to
a Person object. The metaobject prints a message if a method
is called on the Person object.
To run, type the commands:
```
% javac sample/reflect/*.java
% java javassist.tools.reflect.Loader sample.reflect.Main Joe
```
Compare this result with that of the regular execution without reflection:
```
% java sample.reflect.Person Joe
```
For more details, see sample/reflect/Main.java
Furthermore, the Person class can be statically modified so that
all the Person objects become reflective without sample.reflect.Main.
To do this, type the commands:
```
% java javassist.tools.reflect.Compiler sample.reflect.Person -m sample.reflect.VerboseMetaobj
```
Then,
```
% java sample.reflect.Person Joe
```
### 4. `sample/duplicate/*.java`
This is another example of reflective programming.
To run, type the commands:
```
% javac sample/duplicate/*.java
% java sample.duplicate.Main
```
Compare this result with that of the regular execution without reflection:
```
% java sample.duplicate.Viewer
```
For more details, see
`sample/duplicate/Main.java`
### 5. `sample/vector/*.java`
This example shows the use of Javassit for producing a class representing
a vector of a given type at compile time.
To run, type the commands:
```
% javac sample/vector/*.java
% java sample.preproc.Compiler sample/vector/Test.j
% javac sample/vector/Test.java
% java sample.vector.Test
```
Note: `javassist.jar` is unnecessary to compile and execute
`sample/vector/Test.java`.
For more details, see
`sample/vector/Test.j` and `sample/vector/VectorAssistant.java`.
### 6. `sample/rmi/*.java`
This demonstrates the `javassist.rmi` package.
To run, type the commands:
```
% javac sample/rmi/*.java
% java sample.rmi.Counter 5001
```
The second line starts a web server listening to port 5001.
Then, open sample/rmi/webdemo.html
with a web browser running
on the local host. (`webdemo.html` trys to fetch an applet from
`http://localhost:5001/`, which is the web server we started above.)
Otherwise, run `sample.rmi.CountApplet` as an application:
```
% java javassist.web.Viewer localhost 5001 sample.rmi.CountApplet
```
### 7. `sample/evolve/*.java`
This is a demonstration of the class evolution mechanism implemented
with Javassist. This mechanism enables a Java program to reload an
existing class file under some restriction.
To run, type the commands:
```
% javac sample/evolve/*.java
% java sample.evolve.DemoLoader 5003
```
The second line starts a class loader DemoLoader, which runs a web
server DemoServer listening to port 5003.
Then, open `http://localhost:5003/demo.html` with a web browser running
on the local host.
(Or, see sample/evolve/start.html.)
### 8. `sample/hotswap/*.java`
This shows dynamic class reloading by the JPDA. It needs JDK 1.4 or later.
To run, first type the following commands:
```
% cd sample/hotswap
% javac *.java
% cd logging
% javac *.java
% cd ..
```
If your Java is 1.4, then type:
```
% java -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000 Test
```
If you are using Java 5, then type:
```
% java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8000 Test
```
Note that the class path must include `JAVA_HOME/lib/tools.jar`.
d='n47' href='#n47'>47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|