FYI I got the injection to work. When I was putting together a demonstration the injection started working. The problem has to do with dependencies in the pom.xml. I am not sure if there was something extra causing the problem or perhaps the order of the jars in the classpath. I am uploading an example

By the way this example demonstrations embedding openEJB in Jetty. The important piece of the puzzle is in the WAR/pom.xml:


<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>maven-jetty-plugin</artifactId>
<configuration>
<scanIntervalSeconds>5</scanIntervalSeconds>
<contextPath>/example</contextPath>
<systemProperties>
<systemProperty>
<name>java.naming.factory.initial</name> <value>org.apache.openejb.client.LocalInitialContextFactory</value>
</systemProperty>
<systemProperty>
<name>java.naming.factory.url.pkgs</name>
<value>org.mortbay.naming</value>
</systemProperty>
</systemProperties>
</configuration>
<dependencies>
</dependencies>
</plugin>


The system property “java.naming.factory.url.pkgs” is the key. From what I can tell openEJB’s IvmContext will attempt to do JNDI lookups and if it fails will look for additional ObjectFactories and delegate to them. By adding the “org.morbay.naming” system property IvmContext finds the Jetty JNDI context. Without this setting the jetty plugin will fail with the error: “javax.naming.NameNotFoundException: Name “java:comp” not found.”

source : http://www.nabble.com/Re:-Tomcat—Injection:-No-such-property-p16421933.html

Salah satu alasan bahasa scripting semakin populer adalah karena kesederhanaannya, powerful, dan sangat mudah digunakan serta dikembangkan. Bahasa scripting semakin diakui keberadaannya, salah satu buktinya adalah Google dan Nokia yang menggunakan bahasa scripting Python dalam produk mereka.

Mungkin Anda selama ini sudah cukup puas dengan bahasa pemrograman yang ada seperti Java, C, C++, VB, dan sebagainya.

Mengapa kita memerlukan bahasa scripting?
Bahasa scripting dirancang untuk tipe aplikasi yang berbeda dengan bahasa pemrograman
sistem seperti C dan C++. Bahasa scripting sangat cocok digunakan sebagai glue language(bahasa perekat) misalnya untuk membuat interface antarkomponenkomponen.

Walaupun bahasa scripting bersifat interpreter dan lebih lambat dibandingkan dengan bahasa compiler seperti C dan C++, hal tersebut jarang diungkit sebab bagian penting dari suatu program misalnya yang berhubungan dengan sistem tetap akan dibuat dengan bahasa pemrograman sistem seperti C dan C++, sedangkan bahasa scripting berfungsi sebagai glue
language untuk menghubungkan antar komponen–komponen sistem tersebut misalnya untuk GUI interface.

Pada umumnya, bahasa scripting memiliki string processing yang sangat akurat misalnya regular expression sehingga sangat cocok untuk administrator sistem untuk membuat shell script yang powerful. Di pihak lain, bahasa scripting menawarkan pengembangan aplikasi yang cepat misalnya pembuatan aplikasi GUI, web scripts, system utilities, dan aplikasi yang membutuhkan pemrosesan string ataupun perhitungan yang akurat.

Dalam perhitungan, bahasa scripting tidak kalah jika dibandingkan dengan bahasa compiler seperti C dan C++.

Bahasa Ruby lahir pada tanggal 23 Februari 1993 dan masuk ke Amrik pada tahun 2000. Pada awalnya, pembuat bahasa ini Yukihiro “Matz” Matsumoto semasa kuliahnya sangat menyenangi pemrograman berorientasi objek dan bahasa scripting, kemudian dia melakukan riset terhadap bahasa scripting Perl dan Python.

Akan tetapi dia tidak menemukan yang diinginkannya. Menurutnya bahasa Perl kurang powerful dan bahasa Python kurang object-oriented, sehingga ia memutuskan untuk
membuat suatu bahasa yang lebih powerful daripada Perl dan lebih object-oriented dari Python. Lahirlah bahasa baru yang dinamakan Ruby yang berarti sejenis batu permata.

Dewasa ini, Ruby sudah mulai diterima oleh para programmer dunia. Konon, Ruby lebih
populer daripada Python di Jepang.

• Ruby merupakan bahasa interpreter.
• Ruby memiliki sintaks yang sederhana, mudah dipelajari dan dipahami.
• Ruby mendukung exception handling seperti halnya Java dan Python.
• Ruby murni merupakan bahasa berorientasi objek di mana semua datanya adalah objek, begitu pula dengan angka 8 yang merupakan instansi dari kelas FixNum.
• Ruby mendukung single-inheritance dan modul mix-in yang serupa dengan interface di Java.(Multiple-inheritance dapat digantikan dengan menggunakan fitur mix-in ini).
• Ruby memiliki portabilitas yang tinggi antar-platform sehingga dapat berjalan di berbagai OS seperti UNIX, Linux, DOS, Windows 95/98/Me/NT/2000/XP, MacOS, BeOS, OS/2, dan sebagainya.
• Ruby mendukung dynamic-typing, seperti halnya Python di mana kita tidak perlu mendeklarasikan tipe untuk suatu variabel.
• Ruby mendukung garbage collection seperti halnya Java dan Python di mana Anda tidak perlu membebaskan memory yang dialokasi( mis. free() di C) . Variabel yang tidak lagi digunakan akan segera dibebaskan oleh garbage collector. Dengan demikian, Anda tidak perlu berhubungan dengan manajemen memory yang merumitkan.
• Ruby mudah dikembangkan dengan bahasa C seperti halnya Python misalnya dengan menggunakan interface SWIG.
• Ruby lahir dari komunitas, sehingga Ruby memiliki dukungan komunitas yang siap membantu Anda jika menemui kesulitan.
• Dan yang terakhir, tentunya Ruby gratis bahkan untuk aplikasi komersial.

NGOPAS source : Dasar Pemrograman Ruby

Ruby can be used as a fully object oriented language, in which case you’d create classes and objects to accomplish everything. However, it can be used quite nicely with only the objects and classes that ship with Ruby, in which case it can be used as a procedural language, except that functions are typically methods of the program’s variables.

If that doesn’t make any sense to you, don’t worry, it’s just a way of saying that Ruby can be very easy to learn and use.

Even if you want to become a Ruby expert, you need to learn the basic functionality before you can become a Ruby OOP ninja. This tutorial gives you those basics.

Hello World
This is the simplest possible Ruby program, hello.rb. As you’d expect, it prints “Hello World” on the screen. Be sure to set it executable.

#!/usr/bin/ruby
print “Hello World\n”

Although this program works as expected, it goes against the philosophy of Ruby because it’s not object oriented. But as a proof of concept that Ruby’s working on your computer, it’s just fine.

Besides print, there’s also a puts keyword. The difference is that puts automatically inserts a newline at the end of the string being printed, whereas print does not. In other words, puts is more convenient, but print is necessary if separate statements print to the same line. Througout this tutorial we’ll use both print and puts.
Loops
Let’s count to 10…

#!/usr/bin/ruby
for ss in 1…10
print ss, ” Hello\n”;
end

The elipses (…) indicate the range through which to loop. The for is terminated by an end. You don’t need braces for a loop. Whew!

The following is the output:

[slitt@mydesk slitt]$ ./loop.rb
1 hello
2 hello
3 hello
4 hello
5 hello
6 hello
7 hello
8 hello
9 hello
[slitt@mydesk slitt]$

Notice that it stops on 9. The number following the elipses causes termination at the top of the loop. The 1…10 means 1 TO BUT NOT INCLUDING 10, it does NOT mean 1 through 10. Please remember this when using Ruby loops.

NOTE

There are actually two versions of the elipses operator, the three period version as shown previously, and the two period version. The two period version is inclusive. In other words, 1…3 means 1 up to but not including 3, while 1..3 means one through 3.

By using the appropriate version of the elipses operator you can save having to code convoluted end conditions.

Now let’s iterate through an array.

#!/usr/bin/ruby
presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
for ss in 0…presidents.length
print ss, “: “, presidents[ss], “\n”;
end

We defined an array of presidents using a Perl like syntax (except we used brackets instead of parens), and we iterated from 0 (Ruby is 0 based, like most languages), through the final subscript in the presidents array. Remember, the triple dot stops before executing the final number, which is why it doesn’t count to 6. If you had wanted it to count to 6 (which in this case would have walked off the end of the array), you would have used the double dot. The output of the preceding code follows:

[slitt@mydesk slitt]$ ./loop.rb
0: Ford
1: Carter
2: Reagan
3: Bush1
4: Clinton
5: Bush2
[slitt@mydesk slitt]$

Now lets iterate backwards through the array, using the fact that array[-1] is the last item, array[-2] is the second to last, etc:

#!/usr/bin/ruby
presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
for ss in 0…presidents.length
print ss, “: “, presidents[presidents.length - ss - 1], “\n”;
end

The preceding program produces the following output:

[slitt@mydesk slitt]$ ./hello.rb
0: Bush2
1: Clinton
2: Bush1
3: Reagan
4: Carter
5: Ford
[slitt@mydesk slitt]$

Of course, the preceding was a very contrived example just to demonstrate negative subscripts. Note that the subscripts no longer match the presidents, which is probably not what you want. You probably want to do it like you’d do it in any language — tweak the subscript to the end value and decrease it:

#!/usr/bin/ruby
presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
for ss in 0…presidents.length
ss_tweaked = presidents.length - ss - 1
print ss_tweaked, “: “, presidents[ss_tweaked], “\n”
end

If you’re familiar with C, Pascal or Perl, you’re probably dissappointed you couldn’t just use presidents.length…0. Backwards iteration doesn’t work in Ruby — it must iterate up.

Iterators and Blocks
Another way to loop through an array is to use an iterator (in red in the following code) and a block (in blue in the following code:

#!/usr/bin/ruby
presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
presidents.each {|prez| puts prez}

In the preceding code, the block argument (prez) contains the current array element, and everything else until the closing brace contains code to operate on the block argument. The block argument is always enclosed in vertical lines (pipe symbols). The following is the output of the preceding code:

[slitt@mydesk slitt]$ ./hello.rb
Ford
Carter
Reagan
Bush1
Clinton
Bush2
[slitt@mydesk slitt]$

The block needn’t be on one line:

#!/usr/bin/ruby
presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
presidents.each {
|prez|
puts prez
}

As shown in the previous examples, you can define the block by enclosing it in curly braces. You can also define it by enclosing it in a do and an end, where the do replaces the opening brace, and the end replaces the closing brace:

#!/usr/bin/ruby
presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
presidents.each do
|prez|
puts prez
end

Personally, I greatly prefer the do/end syntax for multiline blocks, because as a Perl/C/C++ guy I have a very different perception of braces than their limited use in Ruby, and also because of all the brace placement religious wars I’ve endured (I’m a Whitesmith type guy myself). However, on short single line blocks, using the braces saves valuable line space. From what I understand, the methods are interchangeable in features and performance, with one small exception…

Speaking of performance, if you declare the block argument outside the block (in other words, make it a local variable), performance improves because Ruby needn’t recreate a variable every iteration. HOWEVER, the loop messes with the value of the variable, so it’s best to use a specific variable for that purpose, and do not use it for other purposes within the subroutine. Here’s an example of using a local variable as a block argument:

#!/usr/bin/ruby
i = -99
puts “Before: ” + i.to_s
(1..10).each{|i| puts i}
puts “After : ” + i.to_s

[slitt@mydesk slitt]$ ./loop.rb
Before: -99
1
2
3
4
5
6
7
8
9
10
After : 10
[slitt@mydesk slitt]$

If you use a local variable for a block argument, do so only in loops with huge numbers of iterations, and use only variables that are specifically intended to serve as block arguuments and nothing else.
A Difference Between {} and do/end
As mentioned, there’s one small difference between brace enclosed blocks and do/end enclosed blocks: Braces bind tighter. Watch this:

#!/usr/bin/ruby
my_array = ["alpha", "beta", "gamma"]
puts my_array.collect {
|word|
word.capitalize
}
puts “======================”
puts my_array.collect do
|word|
word.capitalize
end

[slitt@mydesk slitt]$ ./test.rb
Alpha
Beta
Gamma
======================
alpha
beta
gamma
[slitt@mydesk slitt]$

The braces bound tightly like this:

puts (my_array.collect {|word| word.capitalize})

Whereas do/end bind more loosely, like this:

puts (my_array.collect) do |word| word.capitalize} end

Note that the latter represents a syntax error anyway, and I’ve found no way to coerce do/end into doing the right thing simply by using parentheses. However, by assigning the iterator’s results to a new array, that array can be used. It’s one more variable and one more line of code. If the code is short, use braces. If it’s long, the added overhead is so small a percentage that it’s no big deal:

#!/usr/bin/ruby
my_array = ["alpha", "beta", "gamma"]
puts my_array.collect {
|word|
word.capitalize
}
puts “======================”
new_array = my_array.collect do
|word|
word.capitalize
end
puts new_array

[slitt@mydesk slitt]$ ./test.rb
Alpha
Beta
Gamma
======================
Alpha
Beta
Gamma
[slitt@mydesk slitt]$

Generally speaking, if you want to directly use the result of iterators, use braces. For longer blocks, do/end is more readable, and the overhead for the extra variable and line of code is trivial.
while Loops
All the loops previously discussed looped through either an array or a set of numbers. Sometimes you need a more generic loop. That’s when you use a while loop:

#!/usr/bin/ruby
ss = 4
while ss > 0
puts ss
ss -= 1
end
puts “======================”
while ss < 5
puts ss
ss += 1
break if ss > 2
end
puts “======================”
ss = 5
while ss > 0
puts ss
ss -= 2
if ss == 1
ss += 5
end
end

[slitt@mydesk slitt]$ ./loop.rb
4
3
2
1
======================
0
1
2
======================
5
3
6
4
2
[slitt@mydesk slitt]$

The first while loop iterated from 4 down to 1, quitting when ss became 0 and hit the while condition. The second loop was intended to iterate up to 4 and quit when 5 was encountered, but a break statement inside the loop caused it to terminate after printing 2 and then incrementing to 3. This demonstrates the break statement.

The third loop was intended to loop from 5 down to 1, quitting after printing 1 and then decrementing. However, the statement in the body of the loop added 5 when it reached 1, pushing it back up to 6, so it had to count down again. On the second countdown, the numbers were even, so it didn’t trigger the if statement. This shows that unlike Pascal, it’s OK to tamper with the loop variable inside the loop.

(lagi…)

Dalam artikel ini akan dijelaskan bagaimana menggunakan Grizzly. Grizzly mempermudah kita dalam managemen NIO.

1. Membuat class GrizzlyConnectionListener, bertugas me-listen pesan pada port tertentu apabila ada pesan yang
masuk.

public class GrizzlyConnectionListener {
private static final int PORT=8000;
/**
* Init
*/
public void init() {

System.out.println(”listening for incomming TCP Connections on port : ” + f_port);
try {
//[1].
Controller controller = new Controller();
TCPSelectorHandler tcpSelectorHandler = new TCPSelectorHandler();
tcpSelectorHandler.setPort(PORT); // TODO: abstract to JMX configuration

Pipeline pipeline = new DefaultPipeline();
pipeline.setMaxThreads(5); // TODO: abstract to JMX configuration
controller.setPipeline(pipeline);

// we need to create a listener that will not impose a timeout value, hence a BaseSelectionKeyHandler object is defined
// refer to: http://www2.sebastiendionne.ca:8282/grizzly/grizzly-migration-guide-part-3/print.html
BaseSelectionKeyHandler keyHandler = new BaseSelectionKeyHandler();
tcpSelectorHandler.setSelectionKeyHandler(keyHandler);
controller.addSelectorHandler(tcpSelectorHandler);

final ProtocolChain protocolChain = new DefaultProtocolChain();

protocolChain.addFilter(new TacProtocolFilter());
//protocolChain.addFilter(new TacManagerFilter());
protocolChain.addFilter(new TacValidatorFilter());
((DefaultProtocolChain)protocolChain).setContinuousExecution(true);

ProtocolChainInstanceHandler pciHandler = new DefaultProtocolChainInstanceHandler() {
public ProtocolChain poll() {
return protocolChain;
}

public boolean offer(ProtocolChain instance) {
return true;
}
};

controller.setProtocolChainInstanceHandler(pciHandler);

try {
controller.start();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public static void main(String[] args) {
System.out.println(”Starting Grizzly Listener …. on port “+PORT);
System.out.println(”Waiting for connection ……!”);
init();
}

Sedikit penjelasan tentang code diatas, lihat comment number :
[1]. Start grizzly untuk listen pesan yang datang melalui koneksi TCP.

Controller controller = new Controller();
TCPSelectorHandler tcpSelectorHandler = new TCPSelectorHandler();
tcpSelectorHandler.setPort(f_port);
controller.addSelectorHandler(tcpSelectorHandler);

Jika ingin menggunakan koneksi UDP atau SSL tambahkan SelectorHandler baru.
Grizzly menangani beberapa protocol handler : TCPSelectorHandler, UDPSelectorHandler, SSLSelectorHandler. Kita juga bisa membuatt handler sendiri jika diinginkan dengan cara implements SelectorHandler.

I said that Grizzly came with lot of default settings that will do the job for most of us. One of these settings is the build in ThreadPool. In Grizzly it’s called : Pipeline. You can change the Pipeline in the controller with a few lines.

Pipeline pipeline = new DefaultPipeline();
pipeline.setMaxThreads(5);
controller.setPipeline(pipeline);

Secara default SelectionKeyHandler pada Grizzly mempunyai timeout koneksi. Kita bisa mengubah timeout koneksi ini sesuai dengan yang kita inginkan, atau membuat permanen koneksi dengan server.
Gunakan kode di bawah ini bila ingin mengubah nilai timeout :

DefaultSelectionKeyHandler keyHandler = new DefaultSelectionKeyHandler();
//keep connection for 30 minutes
keyHandler.setTimeout(30 * 1000 * 60);

tcpSelectorHandler.setSelectionKeyHandler(keyHandler);

Pada contoh class listener di atas menciptakan koneksi yang permanen, tidak menggunakan timeout jadi harus menggunakan handler : BaseSelectionKeyHandler.

tcpSelectorHandler.setSelectionKeyHandler(new BaseSelectionKeyHandler());


2. Bagaimana kita membaca pesan dari client dan bagaimana kita memberi respon kepada mereka.
ada 3 langkah :

Pertama : buat sebuah class ParserProtocolFilter : Class filter ini akan mem-parse pesan yang datang dari client dan meng-extract kueri yang valid.

Kedua : buat sebuah class ProtocolFilter : Class filter ini akan menerima kueri yang dikirimkan oleh filter sebelumnya dan akan memproses kueri.

Ketiga : buat sebuah class ProtocolHandler yang akan menangani filter sebelumnya dan menentukan urutan

final ProtocolChain protocolChain = new DefaultProtocolChain();

protocolChain.addFilter(new ParserProtocolFilter());
//protocolChain.addFilter(new TacManagerFilter());
protocolChain.addFilter(new ProtocolFilter());
((DefaultProtocolChain)protocolChain).setContinuousExecution(true);

ProtocolChainInstanceHandler pciHandler = new DefaultProtocolChainInstanceHandler() {
public ProtocolChain poll() {
return protocolChain;
}

public boolean offer(ProtocolChain instance) {
return true;
}
};

controller.setProtocolChainInstanceHandler(pciHandler);

(lagi…)

Beberapa catatan saya dalam mempelajari Ruby :
Saat ini saya menggunakan linux Ubuntu 8.04 so :
* Untuk masuk ke editor ruby buka shell dan ketik irb, kemudian tekan enter.
Atau kalau yang pake windows
* Klik menu start->program files->Ruby->klik fxri.

Untuk pertama kali seperti yang sudah-sudah (like what usually people do), I am trying to print “Hello Word” in console
this is the code :
irb(main):001:0> puts "Hello World"
Hello World
=>nil

Ternyata editor ruby tidak menyusahkan. Ketika kita ketik dan tekan enter maka hasilnya akan muncul, dibawahnya.
perintah puts merupakan perintah untuk mencetak sesuatu di Ruby.
=>nil artinya perintah puts memberi nilai kembalian nil yaitu tidak mempunyai nilai, tidak mengenmablikan apa-apa.

How to get the information data from Map or SortedMap in your JSP page.
Here is the example :

1. Set iterator value with map.entrySet(), will get all the value set. Remember that the Set type is not sorted.


2. This is how to get the key of Map.

3. This is how to get the value of Map.



Complete code :





Chain result type is used for Action Chaining which means that the source result invokes an entire other action, complete with it’s own interceptor stack and result.

Redirect Action result type is used to redirect to another Action which means making your source Action, after it has successfully executed, result in a redirect.

As a rule, Action Chaining is not recommended. Redirect Result or the Redirect Action Result is preferred over Chain Result.