Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-27T00:42:08Z

Psdeshp2: /* UML Class Diagram */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a [http://en.wikipedia.org/wiki/Collaboration collaboration] between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern], you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==[http://en.wikipedia.org/wiki/Unified_Modeling_Language UML] Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

===Comparison of Decorator pattern and Facade pattern===
*Facade gives the impression that your create a facade object over different desperate objects, or you actually decorate them with another layer, or they are two different name for the same pattern
*Decorator pattern is a design pattern that allows new/additional behavior to be added to an existing class dynamically, it also provides a flexible alternative to sub classing for extending functionality.
*Facade is more like a simple gateway to a complicated set of functionality. You make a black-box for your clients to worry less i.e. make interfaces simpler
*Where as decorator is used to add more gunpowder to your objects (note the term objects -- you typically decorate objects dynamically at runtime). You do not hide/impair the existing interfaces of the object but simply extend it at runtime.

===Comparison of Composite pattern and Decorator pattern===
*The composite pattern allows you to build a hierarchical structure (such as a tree of elements) in a way that allows your external code to view the entire structure as a single entity. So the interface to a leaf entity is exactly the same as the entity for a compound entity.
*The decorator pattern allows an entity to completely contain another entity so that using the decorator looks identical to the contained entity. This allows the decorator to modify the behavior and/or content of whatever it is encapsulating without changing the outward appearance of the entity
*Composite pattern: gives an unified interface to a leaf and composite.
*Decorator: composite gives additional feature to leaf, while giving unified interface.

==References==
*[http://en.wikipedia.org/wiki/Software_design_pattern Software design patterns]
*[http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy Computer science design patterns]
*[http://www.dofactory.com/Patterns/ Patterns]
*[http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern]
*[http://www.oodesign.com/ O-O design]
*[http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison Pattern Comparisons ]
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern Stack Overflow- Difference between adapter and bridge pattern]
*[http://sarosh.wordpress.com/2009/09/22/difference-between-facade-and-decorator-pattern/ Decorator vs Facade]
*[http://stackoverflow.com/questions/2233952/difference-between-the-composite-pattern-and-decorator-pattern Composite vs Decorator]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-27T00:41:10Z

Psdeshp2: /* Design Pattern */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a [http://en.wikipedia.org/wiki/Collaboration collaboration] between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern], you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

===Comparison of Decorator pattern and Facade pattern===
*Facade gives the impression that your create a facade object over different desperate objects, or you actually decorate them with another layer, or they are two different name for the same pattern
*Decorator pattern is a design pattern that allows new/additional behavior to be added to an existing class dynamically, it also provides a flexible alternative to sub classing for extending functionality.
*Facade is more like a simple gateway to a complicated set of functionality. You make a black-box for your clients to worry less i.e. make interfaces simpler
*Where as decorator is used to add more gunpowder to your objects (note the term objects -- you typically decorate objects dynamically at runtime). You do not hide/impair the existing interfaces of the object but simply extend it at runtime.

===Comparison of Composite pattern and Decorator pattern===
*The composite pattern allows you to build a hierarchical structure (such as a tree of elements) in a way that allows your external code to view the entire structure as a single entity. So the interface to a leaf entity is exactly the same as the entity for a compound entity.
*The decorator pattern allows an entity to completely contain another entity so that using the decorator looks identical to the contained entity. This allows the decorator to modify the behavior and/or content of whatever it is encapsulating without changing the outward appearance of the entity
*Composite pattern: gives an unified interface to a leaf and composite.
*Decorator: composite gives additional feature to leaf, while giving unified interface.

==References==
*[http://en.wikipedia.org/wiki/Software_design_pattern Software design patterns]
*[http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy Computer science design patterns]
*[http://www.dofactory.com/Patterns/ Patterns]
*[http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern]
*[http://www.oodesign.com/ O-O design]
*[http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison Pattern Comparisons ]
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern Stack Overflow- Difference between adapter and bridge pattern]
*[http://sarosh.wordpress.com/2009/09/22/difference-between-facade-and-decorator-pattern/ Decorator vs Facade]
*[http://stackoverflow.com/questions/2233952/difference-between-the-composite-pattern-and-decorator-pattern Composite vs Decorator]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-27T00:40:46Z

Psdeshp2: /* Design Pattern */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a [http://en.wikipedia.org/wiki/Collaboration collaboration] between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern], you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

===Comparison of Decorator pattern and Facade pattern===
*Facade gives the impression that your create a facade object over different desperate objects, or you actually decorate them with another layer, or they are two different name for the same pattern
*Decorator pattern is a design pattern that allows new/additional behavior to be added to an existing class dynamically, it also provides a flexible alternative to sub classing for extending functionality.
*Facade is more like a simple gateway to a complicated set of functionality. You make a black-box for your clients to worry less i.e. make interfaces simpler
*Where as decorator is used to add more gunpowder to your objects (note the term objects -- you typically decorate objects dynamically at runtime). You do not hide/impair the existing interfaces of the object but simply extend it at runtime.

===Comparison of Composite pattern and Decorator pattern===
*The composite pattern allows you to build a hierarchical structure (such as a tree of elements) in a way that allows your external code to view the entire structure as a single entity. So the interface to a leaf entity is exactly the same as the entity for a compound entity.
*The decorator pattern allows an entity to completely contain another entity so that using the decorator looks identical to the contained entity. This allows the decorator to modify the behavior and/or content of whatever it is encapsulating without changing the outward appearance of the entity
*Composite pattern: gives an unified interface to a leaf and composite.
*Decorator: composite gives additional feature to leaf, while giving unified interface.

==References==
*[http://en.wikipedia.org/wiki/Software_design_pattern Software design patterns]
*[http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy Computer science design patterns]
*[http://www.dofactory.com/Patterns/ Patterns]
*[http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern]
*[http://www.oodesign.com/ O-O design]
*[http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison Pattern Comparisons ]
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern Stack Overflow- Difference between adapter and bridge pattern]
*[http://sarosh.wordpress.com/2009/09/22/difference-between-facade-and-decorator-pattern/ Decorator vs Facade]
*[http://stackoverflow.com/questions/2233952/difference-between-the-composite-pattern-and-decorator-pattern Composite vs Decorator]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-27T00:39:25Z

Psdeshp2: /* Design Pattern */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a [http://en.wikipedia.org/wiki/Collaboration collaboration] between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

===Comparison of Decorator pattern and Facade pattern===
*Facade gives the impression that your create a facade object over different desperate objects, or you actually decorate them with another layer, or they are two different name for the same pattern
*Decorator pattern is a design pattern that allows new/additional behavior to be added to an existing class dynamically, it also provides a flexible alternative to sub classing for extending functionality.
*Facade is more like a simple gateway to a complicated set of functionality. You make a black-box for your clients to worry less i.e. make interfaces simpler
*Where as decorator is used to add more gunpowder to your objects (note the term objects -- you typically decorate objects dynamically at runtime). You do not hide/impair the existing interfaces of the object but simply extend it at runtime.

===Comparison of Composite pattern and Decorator pattern===
*The composite pattern allows you to build a hierarchical structure (such as a tree of elements) in a way that allows your external code to view the entire structure as a single entity. So the interface to a leaf entity is exactly the same as the entity for a compound entity.
*The decorator pattern allows an entity to completely contain another entity so that using the decorator looks identical to the contained entity. This allows the decorator to modify the behavior and/or content of whatever it is encapsulating without changing the outward appearance of the entity
*Composite pattern: gives an unified interface to a leaf and composite.
*Decorator: composite gives additional feature to leaf, while giving unified interface.

==References==
*[http://en.wikipedia.org/wiki/Software_design_pattern Software design patterns]
*[http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy Computer science design patterns]
*[http://www.dofactory.com/Patterns/ Patterns]
*[http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern]
*[http://www.oodesign.com/ O-O design]
*[http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison Pattern Comparisons ]
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern Stack Overflow- Difference between adapter and bridge pattern]
*[http://sarosh.wordpress.com/2009/09/22/difference-between-facade-and-decorator-pattern/ Decorator vs Facade]
*[http://stackoverflow.com/questions/2233952/difference-between-the-composite-pattern-and-decorator-pattern Composite vs Decorator]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-26T21:05:15Z

Psdeshp2: /* References */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a collaboration between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

===Comparison of Decorator pattern and Facade pattern===
*Facade gives the impression that your create a facade object over different desperate objects, or you actually decorate them with another layer, or they are two different name for the same pattern
*Decorator pattern is a design pattern that allows new/additional behavior to be added to an existing class dynamically, it also provides a flexible alternative to sub classing for extending functionality.
*Facade is more like a simple gateway to a complicated set of functionality. You make a black-box for your clients to worry less i.e. make interfaces simpler
*Where as decorator is used to add more gunpowder to your objects (note the term objects -- you typically decorate objects dynamically at runtime). You do not hide/impair the existing interfaces of the object but simply extend it at runtime.

===Comparison of Composite pattern and Decorator pattern===
*The composite pattern allows you to build a hierarchical structure (such as a tree of elements) in a way that allows your external code to view the entire structure as a single entity. So the interface to a leaf entity is exactly the same as the entity for a compound entity.
*The decorator pattern allows an entity to completely contain another entity so that using the decorator looks identical to the contained entity. This allows the decorator to modify the behavior and/or content of whatever it is encapsulating without changing the outward appearance of the entity
*Composite pattern: gives an unified interface to a leaf and composite.
*Decorator: composite gives additional feature to leaf, while giving unified interface.

==References==
*[http://en.wikipedia.org/wiki/Software_design_pattern Software design patterns]
*[http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy Computer science design patterns]
*[http://www.dofactory.com/Patterns/ Patterns]
*[http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern]
*[http://www.oodesign.com/ O-O design]
*[http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison Pattern Comparisons ]
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern Stack Overflow- Difference between adapter and bridge pattern]
*[http://sarosh.wordpress.com/2009/09/22/difference-between-facade-and-decorator-pattern/ Decorator vs Facade]
*[http://stackoverflow.com/questions/2233952/difference-between-the-composite-pattern-and-decorator-pattern Composite vs Decorator]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-26T21:01:58Z

Psdeshp2: /* References */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a collaboration between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

===Comparison of Decorator pattern and Facade pattern===
*Facade gives the impression that your create a facade object over different desperate objects, or you actually decorate them with another layer, or they are two different name for the same pattern
*Decorator pattern is a design pattern that allows new/additional behavior to be added to an existing class dynamically, it also provides a flexible alternative to sub classing for extending functionality.
*Facade is more like a simple gateway to a complicated set of functionality. You make a black-box for your clients to worry less i.e. make interfaces simpler
*Where as decorator is used to add more gunpowder to your objects (note the term objects -- you typically decorate objects dynamically at runtime). You do not hide/impair the existing interfaces of the object but simply extend it at runtime.

===Comparison of Composite pattern and Decorator pattern===
*The composite pattern allows you to build a hierarchical structure (such as a tree of elements) in a way that allows your external code to view the entire structure as a single entity. So the interface to a leaf entity is exactly the same as the entity for a compound entity.
*The decorator pattern allows an entity to completely contain another entity so that using the decorator looks identical to the contained entity. This allows the decorator to modify the behavior and/or content of whatever it is encapsulating without changing the outward appearance of the entity
*Composite pattern: gives an unified interface to a leaf and composite.
*Decorator: composite gives additional feature to leaf, while giving unified interface.

==References==
*http://en.wikipedia.org/wiki/Software_design_pattern
*http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy
*http://www.dofactory.com/Patterns/
*http://en.wikipedia.org/wiki/Proxy_pattern
*http://www.oodesign.com/
*http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern Stack Overflow- Difference between adapter and bridge pattern]
*[http://sarosh.wordpress.com/2009/09/22/difference-between-facade-and-decorator-pattern/ Decorator vs Facade]
*[http://stackoverflow.com/questions/2233952/difference-between-the-composite-pattern-and-decorator-pattern Composite vs Decorator]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-26T21:01:17Z

Psdeshp2: /* Comparisons */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a collaboration between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

===Comparison of Decorator pattern and Facade pattern===
*Facade gives the impression that your create a facade object over different desperate objects, or you actually decorate them with another layer, or they are two different name for the same pattern
*Decorator pattern is a design pattern that allows new/additional behavior to be added to an existing class dynamically, it also provides a flexible alternative to sub classing for extending functionality.
*Facade is more like a simple gateway to a complicated set of functionality. You make a black-box for your clients to worry less i.e. make interfaces simpler
*Where as decorator is used to add more gunpowder to your objects (note the term objects -- you typically decorate objects dynamically at runtime). You do not hide/impair the existing interfaces of the object but simply extend it at runtime.

===Comparison of Composite pattern and Decorator pattern===
*The composite pattern allows you to build a hierarchical structure (such as a tree of elements) in a way that allows your external code to view the entire structure as a single entity. So the interface to a leaf entity is exactly the same as the entity for a compound entity.
*The decorator pattern allows an entity to completely contain another entity so that using the decorator looks identical to the contained entity. This allows the decorator to modify the behavior and/or content of whatever it is encapsulating without changing the outward appearance of the entity
*Composite pattern: gives an unified interface to a leaf and composite.
*Decorator: composite gives additional feature to leaf, while giving unified interface.

==References==
*http://en.wikipedia.org/wiki/Software_design_pattern
*http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy
*http://www.dofactory.com/Patterns/
*http://en.wikipedia.org/wiki/Proxy_pattern
*http://www.oodesign.com/
*http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern Stack Overflow- Difference between adapter and bridge pattern]
*[http://sarosh.wordpress.com/2009/09/22/difference-between-facade-and-decorator-pattern/ Decorator vs Facade]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-26T20:36:29Z

Psdeshp2: /* Comparison of Decorator pattern and Facade pattern */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a collaboration between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

===Comparison of Decorator pattern and Facade pattern===
*Facade gives the impression that your create a facade object over different desperate objects, or you actually decorate them with another layer, or they are two different name for the same pattern
*Decorator pattern is a design pattern that allows new/additional behavior to be added to an existing class dynamically, it also provides a flexible alternative to sub classing for extending functionality.
*Facade is more like a simple gateway to a complicated set of functionality. You make a black-box for your clients to worry less i.e. make interfaces simpler
*Where as decorator is used to add more gunpowder to your objects (note the term objects -- you typically decorate objects dynamically at runtime). You do not hide/impair the existing interfaces of the object but simply extend it at runtime.

==References==
*http://en.wikipedia.org/wiki/Software_design_pattern
*http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy
*http://www.dofactory.com/Patterns/
*http://en.wikipedia.org/wiki/Proxy_pattern
*http://www.oodesign.com/
*http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern Stack Overflow- Difference between adapter and bridge pattern]
*[http://sarosh.wordpress.com/2009/09/22/difference-between-facade-and-decorator-pattern/ Decorator vs Facade]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-26T20:35:17Z

Psdeshp2: /* References */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a collaboration between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

===Comparison of Decorator pattern and Facade pattern===
*Facade gives the impression that your create a facade object over different desperate objects, or you actually decorate them with another layer, or they are two different name for the same pattern
*Decorator pattern is a design pattern that allows new/additional behavior to be added to an existing class dynamically, it also provides a flexible alternative to sub classing for extending functionality.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

==References==
*http://en.wikipedia.org/wiki/Software_design_pattern
*http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy
*http://www.dofactory.com/Patterns/
*http://en.wikipedia.org/wiki/Proxy_pattern
*http://www.oodesign.com/
*http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern Stack Overflow- Difference between adapter and bridge pattern]
*[http://sarosh.wordpress.com/2009/09/22/difference-between-facade-and-decorator-pattern/ Decorator vs Facade]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-26T20:34:53Z

Psdeshp2: /* Comparisons */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a collaboration between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

===Comparison of Decorator pattern and Facade pattern===
*Facade gives the impression that your create a facade object over different desperate objects, or you actually decorate them with another layer, or they are two different name for the same pattern
*Decorator pattern is a design pattern that allows new/additional behavior to be added to an existing class dynamically, it also provides a flexible alternative to sub classing for extending functionality.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

==References==
*http://en.wikipedia.org/wiki/Software_design_pattern
*http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy
*http://www.dofactory.com/Patterns/
*http://en.wikipedia.org/wiki/Proxy_pattern
*http://www.oodesign.com/
*http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern Stack Overflow- Difference between adapter and bridge pattern]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-26T20:29:48Z

Psdeshp2: /* References */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a collaboration between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

==References==
*http://en.wikipedia.org/wiki/Software_design_pattern
*http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy
*http://www.dofactory.com/Patterns/
*http://en.wikipedia.org/wiki/Proxy_pattern
*http://www.oodesign.com/
*http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern Stack Overflow- Difference between adapter and bridge pattern]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-26T20:29:30Z

Psdeshp2: /* References */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a collaboration between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

==References==
*http://en.wikipedia.org/wiki/Software_design_pattern
*http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy
*http://www.dofactory.com/Patterns/
*http://en.wikipedia.org/wiki/Proxy_pattern
*http://www.oodesign.com/
*http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern Stack Overflow]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-26T20:29:00Z

Psdeshp2: /* References */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a collaboration between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

==References==
*http://en.wikipedia.org/wiki/Software_design_pattern
*http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy
*http://www.dofactory.com/Patterns/
*http://en.wikipedia.org/wiki/Proxy_pattern
*http://www.oodesign.com/
*http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
*[http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-26T20:28:41Z

Psdeshp2: /* References */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a collaboration between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

==References==
*http://en.wikipedia.org/wiki/Software_design_pattern
*http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy
*http://www.dofactory.com/Patterns/
*http://en.wikipedia.org/wiki/Proxy_pattern
*http://www.oodesign.com/
*http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]
http://stackoverflow.com/questions/1425171/difference-between-bridge-pattern-and-adapter-pattern

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-26T20:28:28Z

Psdeshp2: /* Comparison of Bridge pattern and Adapter pattern */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a collaboration between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*A Bridge Pattern decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

==References==
*http://en.wikipedia.org/wiki/Software_design_pattern
*http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy
*http://www.dofactory.com/Patterns/
*http://en.wikipedia.org/wiki/Proxy_pattern
*http://www.oodesign.com/
*http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]

CSC/ECE 517 Fall 2012/ch2a 2w17 pt

2012-10-26T20:27:55Z

Psdeshp2: /* Comparisons */

==Design Pattern==
A [http://en.wikipedia.org/wiki/Software_design_pattern software design pattern] is a problem-solution pair that gives a general re-usable solution to a commonly occurring problem and can be applied in a similar fashion in new contexts. A design pattern is a [http://en.wikipedia.org/wiki/Template template] that gives a solution to many similar situations. It cannot be directly transformed into code.
The solution is usually a simple mechanism because it is a collaboration between two or more [http://en.wikipedia.org/wiki/Class_%28computer_programming%29 classes], [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCYQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FObject_(computer_science)&ei=e8x9UP76EYfO9QSaqIHgAw&usg=AFQjCNEi_fFQxGdN5EgaYjs39AP1_WV9Vg objects], services, processes, [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&ved=0CDgQFjAC&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThread_(computing)&ei=jMx9UJDfFofA9gSCvYDIBA&usg=AFQjCNHVNxWptDxJ9hDcMD_N5JtVFZX9Ow threads], components, or nodes that work together to solve the underlying architecture or development challenge
Design patterns documents simple mechanism that work. They provide a common vocabulary and taxonomy for developers and architects. They allow solutions to be described concisely as combinations of patterns. They enable reuse of architecture, design, and implementation decisions. All these features make design patterns very useful to software developers and architects.
Design patterns are typically represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. For instance consider the Adapter pattern. [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&sqi=2&ved=0CCoQFjAB&url=http%3A%2F%2Fwww.oodesign.com%2Fadapter-pattern.html&ei=u8x9UMmUI4aK8QSE7YHoDg&usg=AFQjCNHBiT1X1w8RNvDaj_11MvharrKziA Adapter pattern] provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are not compatible. To implement the Adapter pattern, you create a custom class that honors the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
There are many design patterns like [http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FStrategy_pattern&ei=zcx9UMKnFIXA9gTVmIHwCQ&usg=AFQjCNGl3o_1x2n2_FUSSLX9qu5qjlOGmA Algorithm strategy patterns], [http://www.computationaldesign.ca/projects Computational design patterns], [http://pic.dhe.ibm.com/infocenter/brjrules/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FJRules%2Fps_JRules_Global933.html Execution patterns], [http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Implementation strategy patterns], [http://gsraj.tripod.com/design/structural.html Structural design patterns].

==Proxy pattern==
The [http://en.wikipedia.org/wiki/Proxy_pattern Proxy pattern], also known as a surrogate pattern, is a Structural design pattern. A proxy provides a surrogate or placeholder for another object to control access to it. There will be situations in which a client does not or cannot reference an object directly but still wants to interact with the object. A proxy object can act as an intermediary between the client and the target object. A [http://msdn.microsoft.com/en-us/library/windows/desktop/dd373867%28v=vs.85%29.aspx proxy object] has the same interface as the target object. The proxy holds a reference to the target object and can forward requests to the target as required. In effect, the proxy object has the authority to act on behalf of the client to interact with the target object.

==UML Class Diagram==

[[File:pt.jpg]]

By defining a Subject interface, the presence of the Proxy object standing in place of the RealSubject is transparent to the client.

==Applications of Proxy Pattern==
*A proxy can interface a network connection, a large object in memory, a file or any other resource that is expensive or impossible to duplicate.
*Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide.
*In situations where multiple copies of a complex object must exist, the proxy pattern can be used to reduce the application’s memory requirements. A single instance of the complex object and multiple proxy objects are created all of which are references to the original complex object. Any operation on the proxy is forwarded to the original object.

==Types of proxies==
===Remote Proxy===
A [http://c2.com/cgi/wiki?RemoteProxy remote proxy] provides a reference to an object located in a different address space on the same or different machine. They are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space.

===Virtual Proxy===
A [http://www.javabeat.net/2007/09/working-with-virtual-proxy-pattern/ virtual proxy] allows the creation of a memory intensive object on demand. The object will not be created until it is really needed.

===Copy-on-Write Proxy===
A [http://users.soe.ucsc.edu/~pohl/Winter01/Design2/sld047.htm copy-on-write] defers cloning a target object until required by client actions. It is really a form of virtual proxy.

===Protection Proxy===
A [http://www.cymphonix.com/AnonymousProxy.html protection proxy] provides different clients with different levels of access to a target object.

===Cache Proxy===
A [http://www.blackwasp.co.uk/Proxy.aspx cache proxy] provides temporary storage of the results of expensive target operations so that multiple clients can share the results.

===Firewall Proxy===
A [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/proxy.htm firewall proxy] protects targets from bad clients (or vice versa).

===Synchronization Proxy===
A [http://rezagh.wikidot.com/sync-proxy-pattern synchronization proxy] provides multiple accesses to a target object.

===Smart reference Proxy===
A [http://www.theserverside.com/discussions/thread.tss?thread_id=10880 smart reference proxy] provides additional actions whenever a target object is referenced such as counting the number of references to the object.

==Examples of Proxy pattern==
===C++===
====Example 1====
class RealImage
{
int m_id;
public:
RealImage(int i)
{
m_id = i;
cout << " $$ ctor: " << m_id << '\n';
}
~RealImage()
{
cout << " dtor: " << m_id << '\n';
}
void draw()
{
cout << " drawing image " << m_id << '\n';
}
};
// 1. Design an "extra level of indirection" wrapper class
class Image
{
// 2. The wrapper class holds a pointer to the real class
RealImage *m_the_real_thing;
int m_id;
static int s_next;
public:
Image()
{
m_id = s_next++;
// 3. Initialized to null
m_the_real_thing = 0;
}
~Image()
{
delete m_the_real_thing;
}
void draw()
{
// 4. When a request comes in, the real object is
// created "on first use"
if (!m_the_real_thing)
m_the_real_thing = new RealImage(m_id);
// 5. The request is always delegated
m_the_real_thing->draw();
}
};
int Image::s_next = 1;
int main()
{
Image images[5];
for (int i; true;)
{
cout << "Exit[0], Image[1-5]: ";
cin >> i;
if (i == 0)
break;
images[i - 1].draw();
}
}

'''Explanation of Proxy Pattern'''
*The Wrapper class has an extra level on indirection
*The Wrapper class contains a pointer to the original class and it is initialized to NULL
*Lazy initialization is implemented.
*Request is always delegated.

'''Output'''
Exit[0], Image[1-5]: 2
$$ ctor: 2 drawing image 2
Exit[0], Image[1-5]: 4
$$ ctor: 4 drawing image 4
Exit[0], Image[1-5]: 2
drawing image 2
Exit[0], Image[1-5]: 0
dtor: 4
dtor: 2

====Exmaple 2====
class Subject
{
public:
virtual void execute() = 0;
};
class RealSubject: public Subject
{
string str;
public:
RealSubject(string s)
{
str = s;
}
/*virtual*/void execute()
{
cout << str << '\n';
}
};
class ProxySubject: public Subject
{
string first, second, third;
RealSubject *ptr;
public:
ProxySubject(string s)
{
int num = s.find_first_of(' ');
first = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
second = s.substr(0, num);
s = s.substr(num + 1);
num = s.find_first_of(' ');
third = s.substr(0, num);
s = s.substr(num + 1);
ptr = new RealSubject(s);
}
~ProxySubject()
{
delete ptr;
}
RealSubject *operator->()
{
cout << first << ' ' << second << ' ';
return ptr;
}
/*virtual*/void execute()
{
cout << first << ' ' << third << ' ';
ptr->execute();
}
};
int main()
{
ProxySubject obj(string("the quick brown fox jumped over the dog"));
obj->execute();
obj.execute();
}

'''Explanation of Proxy Pattern'''
*Here ”->” and “.” operators give different results.

'''Output'''
the quick fox jumped over the dog
the brown fox jumped over the dog

===Java===
import java.io.*; import java.net.*;
// 5. To be compatible, an interface is created between the proxy and target
interface SocketInterface {
String readLine();
void writeLine( String str );
void dispose();
}
public class ProxyDemo {
public static void main( String[] args ) {
// 3. The client deals with the proxy
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false );
String str = null;
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) {
skip = ! skip;
}
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
}
}
class SocketProxy implements SocketInterface {
// 1. A proxy is created for the expensive or remote or sensitive object(target)
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
// 2. A level of abstraction is created to encapsulate the complexity is the target
ServerSocket server = new ServerSocket( port );
socket = server.accept();
} else
socket = new Socket( host, port );
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) {
e.printStackTrace();
}
}
public String readLine() {
String str = null;
try {
str = in.readLine();
} catch( IOException e ) {
e.printStackTrace();
}
return str;
}
public void writeLine( String str ) {
// 4. The proxy delegates the target
out.println( str );
}
public void dispose() {
try {
socket.close();
} catch( IOException e ) {
e.printStackTrace();
}
}
}

'''Explanation of Proxy Pattern'''
*A proxy is created for the expensive or remote or sensitive object(target)
*A level of abstraction is created to encapsulate the complexity is the target
*The client deals with the proxy
*The proxy delegates the target
*To be compatible, an interface is created between the proxy and target.

===C#===
using System;
// MainApp test application
class MainApp
{
static void Main()
{
// Create proxy and request a service
Proxy proxy = new Proxy();
proxy.Request();
// Wait for user
Console.Read();
}
}
// "Subject"
abstract class Subject
{
public abstract void Request();
}
// "RealSubject"
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("Called RealSubject.Request()");
}
}
// "Proxy"
class Proxy : Subject
{
RealSubject realSubject;
public override void Request()
{
// Use 'lazy initialization'
if (realSubject == null)
{
realSubject = new RealSubject();
}
realSubject.Request();
}
}

'''Explanation of Proxy Pattern'''
*A surrogate is provided for another object to control access to it.

'''Output'''
Called RealSubject.Request()

===PHP===
<?php
class ProxyBookList {
private $bookList = NULL;
//bookList is not instantiated at construct time
function __construct() {
}
function getBookCount() {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBookCount();
}
function addBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->addBook($book);
}
function getBook($bookNum) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->getBook($bookNum);
}
function removeBook($book) {
if (NULL == $this->bookList) {
$this->makeBookList();
}
return $this->bookList->removeBook($book);
}
//Create
function makeBookList() {
$this->bookList = new bookList();
}
}
class BookList {
private $books = array();
private $bookCount = 0;
public function __construct() {
}
public function getBookCount() {
return $this->bookCount;
}
private function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBook($bookNumberToGet) {
if ( (is_numeric($bookNumberToGet)) && ($bookNumberToGet <= $this->getBookCount())) {
return $this->books[$bookNumberToGet];
} else {
return NULL;
}
}
public function addBook(Book $book_in) {
$this->setBookCount($this->getBookCount() + 1);
$this->books[$this->getBookCount()] = $book_in;
return $this->getBookCount();
}
public function removeBook(Book $book_in) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($book_in->getAuthorAndTitle() == $this->books[$counter]->getAuthorAndTitle()) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->books[$x] = $this->books[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
class Book {
private $author;
private $title;
function __construct($title_in, $author_in) {
$this->author = $author_in;
$this->title = $title_in;
}
function getAuthor() {
return $this->author;
}
function getTitle() {
return $this->title;
}
function getAuthorAndTitle() {
return $this->getTitle().' by '.$this->getAuthor();
}
}
writeln( 'BEGIN TESTING PROXY PATTERN';
writeln('');
$proxyBookList = new ProxyBookList();
$inBook = new Book('PHP for Cats','Larry Truett');
$proxyBookList->addBook($inBook);
writeln('test 1 - show the book count after a book is added');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('test 2 - show the book');
$outBook = $proxyBookList->getBook(1);
writeln($outBook->getAuthorAndTitle());
writeln('');
$proxyBookList->removeBook($outBook);
writeln('test 3 - show the book count after a book is removed');
writeln($proxyBookList->getBookCount());
writeln('');
writeln('END TESTING PROXY PATTERN');
function writeln($line_in) {
echo $line_in." ";
}
?>

'''Explanation of Proxy Pattern'''
* ProxyBookList is created in place of the more resource intensive BookList. ProxyBookList will only instantiate BookList the first time a method in BookList is called.

'''Output'''
BEGIN TESTING PROXY PATTERN
test 1 - show the book count after a book is added
1
test 2 - show the book
PHP for Cats by Larry Truett
test 3 - show the book count after a book is removed
0
END TESTING PROXY PATTERN

==Similar patterns==
===Adapter Pattern===
An [http://www.oodesign.com/adapter-pattern.html adapter pattern] translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface

===Bridge Pattern===
A [http://www.oodesign.com/bridge-pattern.html Bridge Pattern] decouples an abstraction from its implementation so that the two can vary independently". The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

===Composite Pattern===
A [http://www.dofactory.com/Patterns/PatternComposite.aspx composite pattern] is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

===Decorator Pattern===
The [http://www.oodesign.com/decorator-pattern.html decorator pattern] can be used to extend (decorate) the functionality of a certain object dynamically, independently of other instances of the same class, provided some groundwork is done at design time. This is achieved by designing a new decorator class that wraps the original class.

===Facade Pattern===
A [http://www.dofactory.com/Patterns/PatternFacade.aspx facade] is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can make a software library easier to use, understand and test, since the facade has convenient methods for common tasks. It can make the library more readable, for the same reason. It can reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system. It wraps a poorly designed collection of API’s with a single well-designed API .

===Flyweight Pattern===
A [http://www.oodesign.com/flyweight-pattern.html flyweight] is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the flyweight objects temporarily when they are used.

===Front Controller Pattern===
[http://www.corej2eepatterns.com/Patterns2ndEd/FrontController.htm Front controllers] are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages might be used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

===Module Pattern===
A [http://briancray.com/posts/javascript-module-pattern module pattern] is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language that does not support it, or only supports it, partially.

==Comparisons==
===Comparison of Proxy pattern and Facade Pattern===
*The proxy pattern adds behavior whereas the façade pattern simplifies behavior.
*Proxies are optional, facades are not.

===Comparison of Adapter Pattern and Facade Pattern===
*In adapter pattern, the interface that is being adapted might already exist.
*The adapter pattern preserves polymorphism. A façade provides an idealized flexible interface which can be modified anytime as requirements come in.
*Adapters are usually small and hence do not have performance issues whereas facades are huge.

===Comparison of Proxy pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*In adapter pattern client can use the service entity only by using the adapter whereas in proxy pattern a client can use the proxy or the adapter in the same way.
*The Proxy can be cast to the interface of the Service. The Adapter can be cast to the interface the Client expects.

===Comparison of Bridge pattern and Adapter pattern===
*An adapter pattern changes the interface of the service whereas proxy pattern changes the behavior.
*An adapter pattern preserves the behavior of the service whereas the proxy pattern preserves the interface.
*Bridge pattern serves to decouple an abstraction class from its implementation, where as an adaptor pattern converts between classes with less inheritance
*One main difference according to GOF is that "Adapter makes things work after they're designed; Bridge makes them work before they are"

==References==
*http://en.wikipedia.org/wiki/Software_design_pattern
*http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy
*http://www.dofactory.com/Patterns/
*http://en.wikipedia.org/wiki/Proxy_pattern
*http://www.oodesign.com/
*http://www.netobjectivestest.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison
*[http://www.csc.ncsu.edu/faculty/efg/517/f12/schedule Class notes]
*[http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&tp=&arnumber=4383091&contentType=Conference+Publications&sortType%3Dasc_p_Sequence%26filter%3DAND%28p_IS_Number%3A4383083%29 IEEE paper 1]
*[http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5982228&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5982228 IEEE Paper 2]
*[http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.75.3386%26rep%3Drep1%26type%3Dpdf&ei=Vdp9UKinJpD09gTr8oCwDA&usg=AFQjCNERJnpeBDZjXH6PrZnR_8zRQPkIZQ IEEE Paper 3]

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-20T19:57:46Z

Psdeshp2: /* References */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some of the difficulties which are observed when these two types of object orientation are mixed. We will then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic object oriented code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static object oriented code makes use of generics. For example, in case we are using Java, the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you have to undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved using the following two flavors. 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to the native libraries you can access Java libraries with Ruby syntax (or Java syntax, if you want). 
* JRuby runs faster than Ruby, except at startup. <ref>{{ url=http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy |title=Performance comparison |accessdate=2012-06-0 }}</ref>. 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language. 
* Ruby has the following good features which are missing from Java. 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby Explained ==
In addition to the advantages mentioned in the above section, some other features of JRuby are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes. This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like. Note that these additions will be visible only on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is sometimes necessary to synchronize on an object for thread safety. To support this functionality, in JRuby, a synchronize method is provided on every wrapped Java object.

Let us see the two implementations of JRuby.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby code. This includes adding some Java functionality in the Ruby code. The final code will be run on the JVM. Ruby code can load and interact with Java libraries. As a simple example we can use an ArrayList from Java and integrate it with the Ruby code as seen below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as name conflicts in both Ruby and Java can result in losing the Ruby functionality. For example, if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless.

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using:

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create a new file using the File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby. The following code shows an example of embedding Ruby in Java.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the lib folder of the JRuby installation directory. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. The JSR 223 Scripting APIs can be used with any JSR 223-compliant scripting engine such as JRuby.

The steps are:
*Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located [https://scripting.dev.java.net here]
*Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
*Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

The above program prints "Hello".

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types. The table below shows this conversion.
For example if we have a ruby method that returns a string object then we can convert it into a java.lang.String object on the Java side. The table shown below provides a quick overview of the mapping of types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time - Difficulty over Java. 

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that we can expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than [http://en.wikipedia.org/wiki/Ruby_MRI MRI].

No native C extension - Difficulty over Ruby.

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI. However, big frameworks like Rails are tested with JRuby.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. JRuby combines a lot of advantages of Java and Ruby by enabling us to reopen Java Classes, mixing Java interfaces in Ruby, letting JRuby classes implement more than one Java interface by mixing the interfaces in the classes, catching the native Java exceptions and throwing them via Ruby code etc. There are three ways of calling Ruby from Java namely Embedding JRuby, using JSR 223 and by using the Bean Scripting Framework and this provides better flexibility to the programmer. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages] 
[12] Ruby Performance
| name rubyPerf
| website= JRubyhttp://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy 

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby: Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-20T19:57:19Z

Psdeshp2: /* References */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some of the difficulties which are observed when these two types of object orientation are mixed. We will then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic object oriented code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static object oriented code makes use of generics. For example, in case we are using Java, the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you have to undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved using the following two flavors. 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to the native libraries you can access Java libraries with Ruby syntax (or Java syntax, if you want). 
* JRuby runs faster than Ruby, except at startup. <ref>{{ url=http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy |title=Performance comparison |accessdate=2012-06-0 }}</ref>. 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language. 
* Ruby has the following good features which are missing from Java. 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby Explained ==
In addition to the advantages mentioned in the above section, some other features of JRuby are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes. This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like. Note that these additions will be visible only on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is sometimes necessary to synchronize on an object for thread safety. To support this functionality, in JRuby, a synchronize method is provided on every wrapped Java object.

Let us see the two implementations of JRuby.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby code. This includes adding some Java functionality in the Ruby code. The final code will be run on the JVM. Ruby code can load and interact with Java libraries. As a simple example we can use an ArrayList from Java and integrate it with the Ruby code as seen below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as name conflicts in both Ruby and Java can result in losing the Ruby functionality. For example, if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless.

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using:

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create a new file using the File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby. The following code shows an example of embedding Ruby in Java.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the lib folder of the JRuby installation directory. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. The JSR 223 Scripting APIs can be used with any JSR 223-compliant scripting engine such as JRuby.

The steps are:
*Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located [https://scripting.dev.java.net here]
*Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
*Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

The above program prints "Hello".

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types. The table below shows this conversion.
For example if we have a ruby method that returns a string object then we can convert it into a java.lang.String object on the Java side. The table shown below provides a quick overview of the mapping of types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time - Difficulty over Java. 

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that we can expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than [http://en.wikipedia.org/wiki/Ruby_MRI MRI].

No native C extension - Difficulty over Ruby.

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI. However, big frameworks like Rails are tested with JRuby.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. JRuby combines a lot of advantages of Java and Ruby by enabling us to reopen Java Classes, mixing Java interfaces in Ruby, letting JRuby classes implement more than one Java interface by mixing the interfaces in the classes, catching the native Java exceptions and throwing them via Ruby code etc. There are three ways of calling Ruby from Java namely Embedding JRuby, using JSR 223 and by using the Bean Scripting Framework and this provides better flexibility to the programmer. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages] 
[12] {{Ruby Performance
| name rubyPerf
| website= JRubyhttp://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy}} 

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby: Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-20T19:51:06Z

Psdeshp2: /* Advantages of JRuby over Ruby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some of the difficulties which are observed when these two types of object orientation are mixed. We will then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic object oriented code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static object oriented code makes use of generics. For example, in case we are using Java, the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you have to undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved using the following two flavors. 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to the native libraries you can access Java libraries with Ruby syntax (or Java syntax, if you want). 
* JRuby runs faster than Ruby, except at startup. <ref>{{ url=http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy |title=Performance comparison |accessdate=2012-06-0 }}</ref>. 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language. 
* Ruby has the following good features which are missing from Java. 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby Explained ==
In addition to the advantages mentioned in the above section, some other features of JRuby are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes. This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like. Note that these additions will be visible only on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is sometimes necessary to synchronize on an object for thread safety. To support this functionality, in JRuby, a synchronize method is provided on every wrapped Java object.

Let us see the two implementations of JRuby.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby code. This includes adding some Java functionality in the Ruby code. The final code will be run on the JVM. Ruby code can load and interact with Java libraries. As a simple example we can use an ArrayList from Java and integrate it with the Ruby code as seen below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as name conflicts in both Ruby and Java can result in losing the Ruby functionality. For example, if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless.

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using:

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create a new file using the File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby. The following code shows an example of embedding Ruby in Java.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the lib folder of the JRuby installation directory. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. The JSR 223 Scripting APIs can be used with any JSR 223-compliant scripting engine such as JRuby.

The steps are:
*Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located [https://scripting.dev.java.net here]
*Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
*Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

The above program prints "Hello".

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types. The table below shows this conversion.
For example if we have a ruby method that returns a string object then we can convert it into a java.lang.String object on the Java side. The table shown below provides a quick overview of the mapping of types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time - Difficulty over Java. 

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that we can expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than [http://en.wikipedia.org/wiki/Ruby_MRI MRI].

No native C extension - Difficulty over Ruby.

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI. However, big frameworks like Rails are tested with JRuby.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. JRuby combines a lot of advantages of Java and Ruby by enabling us to reopen Java Classes, mixing Java interfaces in Ruby, letting JRuby classes implement more than one Java interface by mixing the interfaces in the classes, catching the native Java exceptions and throwing them via Ruby code etc. There are three ways of calling Ruby from Java namely Embedding JRuby, using JSR 223 and by using the Bean Scripting Framework and this provides better flexibility to the programmer. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages] 
[12] http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy 

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby: Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-20T19:50:46Z

Psdeshp2: /* Advantages of JRuby over Ruby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some of the difficulties which are observed when these two types of object orientation are mixed. We will then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic object oriented code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static object oriented code makes use of generics. For example, in case we are using Java, the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you have to undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved using the following two flavors. 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to the native libraries you can access Java libraries with Ruby syntax (or Java syntax, if you want). 
* JRuby runs faster than Ruby, except at startup. <ref>{{cite web|url=http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy |title=Performance comparison |accessdate=2012-06-0 }}</ref>. 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language. 
* Ruby has the following good features which are missing from Java. 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby Explained ==
In addition to the advantages mentioned in the above section, some other features of JRuby are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes. This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like. Note that these additions will be visible only on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is sometimes necessary to synchronize on an object for thread safety. To support this functionality, in JRuby, a synchronize method is provided on every wrapped Java object.

Let us see the two implementations of JRuby.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby code. This includes adding some Java functionality in the Ruby code. The final code will be run on the JVM. Ruby code can load and interact with Java libraries. As a simple example we can use an ArrayList from Java and integrate it with the Ruby code as seen below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as name conflicts in both Ruby and Java can result in losing the Ruby functionality. For example, if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless.

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using:

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create a new file using the File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby. The following code shows an example of embedding Ruby in Java.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the lib folder of the JRuby installation directory. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. The JSR 223 Scripting APIs can be used with any JSR 223-compliant scripting engine such as JRuby.

The steps are:
*Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located [https://scripting.dev.java.net here]
*Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
*Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

The above program prints "Hello".

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types. The table below shows this conversion.
For example if we have a ruby method that returns a string object then we can convert it into a java.lang.String object on the Java side. The table shown below provides a quick overview of the mapping of types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time - Difficulty over Java. 

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that we can expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than [http://en.wikipedia.org/wiki/Ruby_MRI MRI].

No native C extension - Difficulty over Ruby.

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI. However, big frameworks like Rails are tested with JRuby.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. JRuby combines a lot of advantages of Java and Ruby by enabling us to reopen Java Classes, mixing Java interfaces in Ruby, letting JRuby classes implement more than one Java interface by mixing the interfaces in the classes, catching the native Java exceptions and throwing them via Ruby code etc. There are three ways of calling Ruby from Java namely Embedding JRuby, using JSR 223 and by using the Bean Scripting Framework and this provides better flexibility to the programmer. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages] 
[12] http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy 

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby: Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-20T19:50:09Z

Psdeshp2: /* Advantages of JRuby over Ruby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some of the difficulties which are observed when these two types of object orientation are mixed. We will then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic object oriented code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static object oriented code makes use of generics. For example, in case we are using Java, the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you have to undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved using the following two flavors. 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to the native libraries you can access Java libraries with Ruby syntax (or Java syntax, if you want). 
* JRuby runs faster than Ruby, except at startup. <ref>{{cite web|url=http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy |title=Performance comparison |accessdate=2012-06-02 |date=2009-07-28publisher=[[PCWorld (magazine)|PCWorld]]}}</ref>. 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language. 
* Ruby has the following good features which are missing from Java. 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby Explained ==
In addition to the advantages mentioned in the above section, some other features of JRuby are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes. This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like. Note that these additions will be visible only on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is sometimes necessary to synchronize on an object for thread safety. To support this functionality, in JRuby, a synchronize method is provided on every wrapped Java object.

Let us see the two implementations of JRuby.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby code. This includes adding some Java functionality in the Ruby code. The final code will be run on the JVM. Ruby code can load and interact with Java libraries. As a simple example we can use an ArrayList from Java and integrate it with the Ruby code as seen below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as name conflicts in both Ruby and Java can result in losing the Ruby functionality. For example, if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless.

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using:

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create a new file using the File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby. The following code shows an example of embedding Ruby in Java.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the lib folder of the JRuby installation directory. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. The JSR 223 Scripting APIs can be used with any JSR 223-compliant scripting engine such as JRuby.

The steps are:
*Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located [https://scripting.dev.java.net here]
*Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
*Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

The above program prints "Hello".

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types. The table below shows this conversion.
For example if we have a ruby method that returns a string object then we can convert it into a java.lang.String object on the Java side. The table shown below provides a quick overview of the mapping of types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time - Difficulty over Java. 

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that we can expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than [http://en.wikipedia.org/wiki/Ruby_MRI MRI].

No native C extension - Difficulty over Ruby.

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI. However, big frameworks like Rails are tested with JRuby.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. JRuby combines a lot of advantages of Java and Ruby by enabling us to reopen Java Classes, mixing Java interfaces in Ruby, letting JRuby classes implement more than one Java interface by mixing the interfaces in the classes, catching the native Java exceptions and throwing them via Ruby code etc. There are three ways of calling Ruby from Java namely Embedding JRuby, using JSR 223 and by using the Bean Scripting Framework and this provides better flexibility to the programmer. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages] 
[12] http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy 

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby: Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-20T19:47:01Z

Psdeshp2: /* Advantages of JRuby over Ruby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some of the difficulties which are observed when these two types of object orientation are mixed. We will then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic object oriented code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static object oriented code makes use of generics. For example, in case we are using Java, the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you have to undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved using the following two flavors. 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to the native libraries you can access Java libraries with Ruby syntax (or Java syntax, if you want). 
* JRuby runs faster than Ruby, except at startup. <ref name="engineyardmove">{{cite web|url=http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy |title=Performance comparison |accessdate=2012-06-02 |date=2009-07-28publisher=[[PCWorld (magazine)|PCWorld]]}}</ref>. 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language. 
* Ruby has the following good features which are missing from Java. 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby Explained ==
In addition to the advantages mentioned in the above section, some other features of JRuby are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes. This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like. Note that these additions will be visible only on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is sometimes necessary to synchronize on an object for thread safety. To support this functionality, in JRuby, a synchronize method is provided on every wrapped Java object.

Let us see the two implementations of JRuby.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby code. This includes adding some Java functionality in the Ruby code. The final code will be run on the JVM. Ruby code can load and interact with Java libraries. As a simple example we can use an ArrayList from Java and integrate it with the Ruby code as seen below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as name conflicts in both Ruby and Java can result in losing the Ruby functionality. For example, if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless.

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using:

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create a new file using the File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby. The following code shows an example of embedding Ruby in Java.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the lib folder of the JRuby installation directory. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. The JSR 223 Scripting APIs can be used with any JSR 223-compliant scripting engine such as JRuby.

The steps are:
*Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located [https://scripting.dev.java.net here]
*Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
*Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

The above program prints "Hello".

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types. The table below shows this conversion.
For example if we have a ruby method that returns a string object then we can convert it into a java.lang.String object on the Java side. The table shown below provides a quick overview of the mapping of types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time - Difficulty over Java. 

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that we can expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than [http://en.wikipedia.org/wiki/Ruby_MRI MRI].

No native C extension - Difficulty over Ruby.

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI. However, big frameworks like Rails are tested with JRuby.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. JRuby combines a lot of advantages of Java and Ruby by enabling us to reopen Java Classes, mixing Java interfaces in Ruby, letting JRuby classes implement more than one Java interface by mixing the interfaces in the classes, catching the native Java exceptions and throwing them via Ruby code etc. There are three ways of calling Ruby from Java namely Embedding JRuby, using JSR 223 and by using the Bean Scripting Framework and this provides better flexibility to the programmer. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages] 
[12] http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy 

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby: Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-20T19:45:36Z

Psdeshp2: /* Advantages of JRuby over Ruby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some of the difficulties which are observed when these two types of object orientation are mixed. We will then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic object oriented code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static object oriented code makes use of generics. For example, in case we are using Java, the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you have to undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved using the following two flavors. 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to the native libraries you can access Java libraries with Ruby syntax (or Java syntax, if you want). 
* JRuby runs faster than Ruby, except at startup. <ref name="engineyardmove">{{cite web|url=http://www.pcworld.com/article/169145/suns_jruby_team_jumps_ship_to_engine_yard.html |title=Sun's JRuby Team Jumps Ship to Engine Yard |accessdate=2012-06-02 |date=2009-07-28publisher=[[PCWorld (magazine)|PCWorld]]}}</ref>. 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language. 
* Ruby has the following good features which are missing from Java. 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby Explained ==
In addition to the advantages mentioned in the above section, some other features of JRuby are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes. This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like. Note that these additions will be visible only on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is sometimes necessary to synchronize on an object for thread safety. To support this functionality, in JRuby, a synchronize method is provided on every wrapped Java object.

Let us see the two implementations of JRuby.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby code. This includes adding some Java functionality in the Ruby code. The final code will be run on the JVM. Ruby code can load and interact with Java libraries. As a simple example we can use an ArrayList from Java and integrate it with the Ruby code as seen below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as name conflicts in both Ruby and Java can result in losing the Ruby functionality. For example, if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless.

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using:

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create a new file using the File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby. The following code shows an example of embedding Ruby in Java.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the lib folder of the JRuby installation directory. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. The JSR 223 Scripting APIs can be used with any JSR 223-compliant scripting engine such as JRuby.

The steps are:
*Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located [https://scripting.dev.java.net here]
*Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
*Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

The above program prints "Hello".

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types. The table below shows this conversion.
For example if we have a ruby method that returns a string object then we can convert it into a java.lang.String object on the Java side. The table shown below provides a quick overview of the mapping of types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time - Difficulty over Java. 

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that we can expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than [http://en.wikipedia.org/wiki/Ruby_MRI MRI].

No native C extension - Difficulty over Ruby.

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI. However, big frameworks like Rails are tested with JRuby.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. JRuby combines a lot of advantages of Java and Ruby by enabling us to reopen Java Classes, mixing Java interfaces in Ruby, letting JRuby classes implement more than one Java interface by mixing the interfaces in the classes, catching the native Java exceptions and throwing them via Ruby code etc. There are three ways of calling Ruby from Java namely Embedding JRuby, using JSR 223 and by using the Bean Scripting Framework and this provides better flexibility to the programmer. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages] 
[12] http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy 

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby: Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-20T19:43:28Z

Psdeshp2: /* Difficulties with JRuby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some of the difficulties which are observed when these two types of object orientation are mixed. We will then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic object oriented code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static object oriented code makes use of generics. For example, in case we are using Java, the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you have to undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved using the following two flavors. 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to the native libraries you can access Java libraries with Ruby syntax (or Java syntax, if you want). 
* JRuby runs faster than Ruby, except at startup. 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language. 
* Ruby has the following good features which are missing from Java. 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby Explained ==
In addition to the advantages mentioned in the above section, some other features of JRuby are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes. This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like. Note that these additions will be visible only on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is sometimes necessary to synchronize on an object for thread safety. To support this functionality, in JRuby, a synchronize method is provided on every wrapped Java object.

Let us see the two implementations of JRuby.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby code. This includes adding some Java functionality in the Ruby code. The final code will be run on the JVM. Ruby code can load and interact with Java libraries. As a simple example we can use an ArrayList from Java and integrate it with the Ruby code as seen below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as name conflicts in both Ruby and Java can result in losing the Ruby functionality. For example, if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless.

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using:

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create a new file using the File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby. The following code shows an example of embedding Ruby in Java.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the lib folder of the JRuby installation directory. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. The JSR 223 Scripting APIs can be used with any JSR 223-compliant scripting engine such as JRuby.

The steps are:
*Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located [https://scripting.dev.java.net here]
*Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
*Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

The above program prints "Hello".

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types. The table below shows this conversion.
For example if we have a ruby method that returns a string object then we can convert it into a java.lang.String object on the Java side. The table shown below provides a quick overview of the mapping of types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time - Difficulty over Java. 

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that we can expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than [http://en.wikipedia.org/wiki/Ruby_MRI MRI].

No native C extension - Difficulty over Ruby.

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI. However, big frameworks like Rails are tested with JRuby.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. JRuby combines a lot of advantages of Java and Ruby by enabling us to reopen Java Classes, mixing Java interfaces in Ruby, letting JRuby classes implement more than one Java interface by mixing the interfaces in the classes, catching the native Java exceptions and throwing them via Ruby code etc. There are three ways of calling Ruby from Java namely Embedding JRuby, using JSR 223 and by using the Bean Scripting Framework and this provides better flexibility to the programmer. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages] 
[12] http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy 

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby: Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-20T19:42:58Z

Psdeshp2:

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some of the difficulties which are observed when these two types of object orientation are mixed. We will then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic object oriented code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static object oriented code makes use of generics. For example, in case we are using Java, the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you have to undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved using the following two flavors. 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to the native libraries you can access Java libraries with Ruby syntax (or Java syntax, if you want). 
* JRuby runs faster than Ruby, except at startup. 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language. 
* Ruby has the following good features which are missing from Java. 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby Explained ==
In addition to the advantages mentioned in the above section, some other features of JRuby are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes. This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like. Note that these additions will be visible only on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is sometimes necessary to synchronize on an object for thread safety. To support this functionality, in JRuby, a synchronize method is provided on every wrapped Java object.

Let us see the two implementations of JRuby.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby code. This includes adding some Java functionality in the Ruby code. The final code will be run on the JVM. Ruby code can load and interact with Java libraries. As a simple example we can use an ArrayList from Java and integrate it with the Ruby code as seen below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as name conflicts in both Ruby and Java can result in losing the Ruby functionality. For example, if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless.

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using:

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create a new file using the File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby. The following code shows an example of embedding Ruby in Java.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the lib folder of the JRuby installation directory. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. The JSR 223 Scripting APIs can be used with any JSR 223-compliant scripting engine such as JRuby.

The steps are:
*Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located [https://scripting.dev.java.net here]
*Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
*Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

The above program prints "Hello".

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types. The table below shows this conversion.
For example if we have a ruby method that returns a string object then we can convert it into a java.lang.String object on the Java side. The table shown below provides a quick overview of the mapping of types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time - Difficulty over Java.

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that we can expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than [http://en.wikipedia.org/wiki/Ruby_MRI MRI].

No native C extension Difficulty over Ruby.

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI. However, big frameworks like Rails are tested with JRuby.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. JRuby combines a lot of advantages of Java and Ruby by enabling us to reopen Java Classes, mixing Java interfaces in Ruby, letting JRuby classes implement more than one Java interface by mixing the interfaces in the classes, catching the native Java exceptions and throwing them via Ruby code etc. There are three ways of calling Ruby from Java namely Embedding JRuby, using JSR 223 and by using the Bean Scripting Framework and this provides better flexibility to the programmer. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages] 
[12] http://blog.dhananjaynene.com/2008/07/performance-comparison-c-java-python-ruby-jython-jruby-groovy 

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby: Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-15T01:06:09Z

Psdeshp2: /* Difficulties with JRuby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you can undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to the native libraries you can access Java libraries with Ruby syntax (or Java syntax, if you want). 
* On an average JRuby, runs two and a half times faster than Ruby, except at startup. 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language. 
* Ruby has the following features which are missing from Java. 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby explained ==
Some of the important features of JRuby are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes. This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like. Note that these additions will be visible only on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is sometimes necessary to synchronize on an object for thread safety. To support this functionality, in JRuby, a synchronize method is provided on every wrapped Java object.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby code. This includes adding some Java functionality in the Ruby code. The final code will be run on the JVM. Ruby code can load and interact with Java libraries. As a simple example we can use an ArrayList from Java and integrate it with the Ruby code as seen below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as name conflicts in both Ruby and Java can result in losing the Ruby functionality. For example, if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless.

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using:

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create a new file using the File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby. The following code shows an example of embedding Ruby in Java.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the lib folder of the JRuby installation directory. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. The JSR 223 Scripting APIs can be used with any JSR 223-compliant scripting engine such as JRuby.

Steps:
*Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
*Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
*Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

The above program prints "Hello".

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types. The table below shows this conversion.

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than [http://en.wikipedia.org/wiki/Ruby_MRI MRI].

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-15T01:03:09Z

Psdeshp2: /* JSR 223, Scripting for the Java Platform */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you can undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to the native libraries you can access Java libraries with Ruby syntax (or Java syntax, if you want). 
* On an average JRuby, runs two and a half times faster than Ruby, except at startup. 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language. 
* Ruby has the following features which are missing from Java. 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby explained ==
Some of the important features of JRuby are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes. This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like. Note that these additions will be visible only on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is sometimes necessary to synchronize on an object for thread safety. To support this functionality, in JRuby, a synchronize method is provided on every wrapped Java object.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby code. This includes adding some Java functionality in the Ruby code. The final code will be run on the JVM. Ruby code can load and interact with Java libraries. As a simple example we can use an ArrayList from Java and integrate it with the Ruby code as seen below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as name conflicts in both Ruby and Java can result in losing the Ruby functionality. For example, if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless.

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using:

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create a new file using the File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby. The following code shows an example of embedding Ruby in Java.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the lib folder of the JRuby installation directory. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. The JSR 223 Scripting APIs can be used with any JSR 223-compliant scripting engine such as JRuby.

Steps:
*Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
*Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
*Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

The above program prints "Hello".

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-15T01:02:18Z

Psdeshp2: /* JSR 223, Scripting for the Java Platform */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you can undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to the native libraries you can access Java libraries with Ruby syntax (or Java syntax, if you want). 
* On an average JRuby, runs two and a half times faster than Ruby, except at startup. 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language. 
* Ruby has the following features which are missing from Java. 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby explained ==
Some of the important features of JRuby are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes. This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like. Note that these additions will be visible only on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is sometimes necessary to synchronize on an object for thread safety. To support this functionality, in JRuby, a synchronize method is provided on every wrapped Java object.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby code. This includes adding some Java functionality in the Ruby code. The final code will be run on the JVM. Ruby code can load and interact with Java libraries. As a simple example we can use an ArrayList from Java and integrate it with the Ruby code as seen below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as name conflicts in both Ruby and Java can result in losing the Ruby functionality. For example, if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless.

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using:

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create a new file using the File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby. The following code shows an example of embedding Ruby in Java.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the lib folder of the JRuby installation directory. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. The JSR 223 Scripting APIs can be used with any JSR 223-compliant scripting engine such as JRuby.

Steps:
*Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here] *Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).Look in the uncompressed files for the jruby/build/jruby-engine.jar file. *Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

The above program prints "Hello".

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-15T00:47:29Z

Psdeshp2: /* Advantages of JRuby over Ruby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you can undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively. 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby explained ==
JRuby features are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes.This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like.Note that these additions will only be visible on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is occasionally necessary to synchronize on an object for thread safety. In JRuby, a synchronize method is provided on every wrapped Java object to support this functionality.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-15T00:46:10Z

Psdeshp2: /* Difficulties in mixing static and dynamic oo code */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you can undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby explained ==
JRuby features are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes.This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like.Note that these additions will only be visible on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is occasionally necessary to synchronize on an object for thread safety. In JRuby, a synchronize method is provided on every wrapped Java object to support this functionality.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-15T00:42:22Z

Psdeshp2: /* Introduction */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspects in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you can undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby explained ==
JRuby features are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes.This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like.Note that these additions will only be visible on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is occasionally necessary to synchronize on an object for thread safety. In JRuby, a synchronize method is provided on every wrapped Java object to support this functionality.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Conversion of Types ==

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-15T00:26:48Z

Psdeshp2: /* JRuby explained */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you can undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby explained ==
JRuby features are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes.This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like.Note that these additions will only be visible on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is occasionally necessary to synchronize on an object for thread safety. In JRuby, a synchronize method is provided on every wrapped Java object to support this functionality.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-15T00:26:31Z

Psdeshp2: /* JRuby explained */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you can undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby explained ==
JRuby features are: *Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes.This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like.Note that these additions will only be visible on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is occasionally necessary to synchronize on an object for thread safety. In JRuby, a synchronize method is provided on every wrapped Java object to support this functionality.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-15T00:25:24Z

Psdeshp2:

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you can undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

== JRuby explained ==
JRuby features are:
*Reopening Java Classes In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes.
This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like.
Note that these additions will only be visible on the JRuby side.
*Mixing Java Interfaces JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
*Exception handling Native Java exceptions can be caught and thrown in Ruby code.
*Synchronization When interacting with Java APIs from JRuby, it is occasionally necessary to synchronize on an object for thread safety. In JRuby, a synchronize method is provided on every wrapped Java object to support this functionality.

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-15T00:22:07Z

Psdeshp2: /* Advantages of JRuby over Java */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.
* JRuby automatically binds the following names in the context of a class to the top-level Java packages: com, org, java, javax. This means that you can reference these packages without having to explicitly require or import them. This takes effect for all Ruby classes in an application where a require 'java' appears. If you do not want this behaviour for a specific class, you can undefine it for that class.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL).

In addition to the above, JRuby has other features like
**Reopening Java Classes
In Ruby, classes are always open, which means that you can later add methods to existing classes. This also works with Java classes.
This comes in handy when adding syntactic sugar like overloaded operators to Java classes, or other methods to make them behave more Ruby-like.
Note that these additions will only be visible on the JRuby side.
** Mixing Java Interfaces
JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
** Exception handling
Native Java exceptions can be caught and thrown in Ruby code.
** Synchronization
When interacting with Java APIs from JRuby, it is occasionally necessary to synchronize on an object for thread safety. In JRuby, a synchronize method is provided on every wrapped Java object to support this functionality.

== JRuby explained ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-15T00:04:09Z

Psdeshp2: /* Driving Java from Ruby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

When primitive Java types are passed to JRuby they are converted to the following Ruby types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-15T00:03:44Z

Psdeshp2: /* Driving Java from Ruby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Java Type || Ruby Type 
|-
| public String || String
|-
| public byte || Fixnum
|-
| public short || Fixnum
|-
| public char || Fixnum
|-
| public int || Fixnum
|-
| public float || Float
|-
| public double|| Float
|}

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:59:23Z

Psdeshp2: /* JRuby explained in details */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:56:40Z

Psdeshp2: /* Driving Java from Ruby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained in details ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| "foo" || java.lang.String
|-
| 1|| java.lang.Long
|-
| 1.0 || java.lang.Double
|-
| true, false|| java.lang.Boolean
|-
| 1|| java.math.BigInteger
|}

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== Conclusion ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:54:53Z

Psdeshp2: /* Driving Java from Ruby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained in details ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

{| style="background:#FFFFFB; margin-left: 4em;" border="1" cellpadding="4" cellspacing="0"
|-
| Ruby Type|| Java Type 
|-
| assert_equal || assert_in_delta
|-
| assert_includes|| assert_instance_of
|-
| assert_match || assert_nil
|-
| assert_respond_to|| assert_same
|-
| assert_raises|| assert_send
|}

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== References ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java. Thus mixing static and dynamic code combines the power of dynamic languages with the stability of static languages.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:51:49Z

Psdeshp2: /* Driving Java from Ruby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained in details ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== References ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:51:03Z

Psdeshp2: /* Driving Java from Ruby */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained in details ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

When calling Java from JRuby, primitive Ruby types are converted to default boxed Java types:

Ruby Type Java Type
"foo" java.lang.String
1 java.lang.Long
1.0 java.lang.Double
true, false java.lang.Boolean
1 java.math.BigInteger

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== References ==
The JRuby interpreter combines Ruby's simplicity and ease of use with Java's extensive libraries and technologies, a potent blend that opens new possibilities for Ruby, Rails, and Java.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:42:55Z

Psdeshp2: /* Difficulties in mixing static and dynamic oo code */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained in details ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:41:32Z

Psdeshp2: /* Difficulties in mixing static and dynamic oo code */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility. As a result for a dynamically types language like Ruby, there will be problems with type conversion.
For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained in details ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:40:50Z

Psdeshp2: /* Difficulties in mixing static and dynamic oo code */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility.
As a result for a dynamically types language like Ruby, there will be problems with type conversion.
For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. - In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance - Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained in details ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:40:02Z

Psdeshp2: /* Difficulties in mixing static and dynamic oo code */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

If the static oo makes use of generics. For e.g. Java, then the generic types are erased during compilation for backward compatibility.
As a result for a dynamically types language like Ruby, there will be problems with type conversion.
For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection.
If you have a class name ambiguity between Java and Ruby. - In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread
Inheritance - Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained in details ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:39:23Z

Psdeshp2: /* Difficulties in mixing static and dynamic oo code */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

If the static oo makes use of generics.For e.g. Java, then the generic types are erased during compilation for backward compatibility.
As a result for a dynamically types language like Ruby, there will be problems with type conversion.
For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection.
* If you have a class name ambiguity between Java and Ruby. - In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread
* Inheritance - Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained in details ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:38:33Z

Psdeshp2: /* Difficulties in mixing static and dynamic oo code */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. - For e.g. Java, then the generic types are erased during compilation for backward compatibility.
As a result for a dynamically types language like Ruby, there will be problems with type conversion.
For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection.
* If you have a class name ambiguity between Java and Ruby. - In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread
* Inheritance - Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained in details ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:36:33Z

Psdeshp2: /* Difficulties in mixing static and dynamic oo code */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. 
For e.g. Java, then the generic types are erased during compilation for backward compatibility.
As a result for a dynamically types language like Ruby, there will be problems with type conversion.
For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. 
In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance
Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained in details ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011

CSC/ECE 517 Fall 2012/ch1 1w6 pp

2012-09-14T23:35:56Z

Psdeshp2: /* Difficulties in mixing static and dynamic oo code */

Mixing static and dynamic [http://en.wikipedia.org/wiki/Object_oriented Object Oriented] code helps us to achieve a peaceful integration of static and dynamic aspect in the same language. This page will mention some difficulties when these two types of object orientation are mixed and then will give a practical example of this using [http://en.wikipedia.org/wiki/JRuby JRuby]. JRuby is a [http://en.wikipedia.org/wiki/Programming_language programming language] which is a mix of [http://en.wikipedia.org/wiki/Java Java] and [http://en.wikipedia.org/wiki/Ruby Ruby]. We will cover the different implementations of JRuby with examples. 

== Introduction ==

Object oriented programming is a [http://en.wikipedia.org/wiki/Programming_paradigm programming paradigm] using "objects" – usually instances of a class – consisting of data fields and methods together with their interactions – to design applications and computer programs. In static object orientation, this instantiation is static, that is the class to which an object belongs is defined before the execution of the code. This gives a strong binding of the objects, and ensures that the correct instance variables and methods are accessed by that object. In Dynamic object orientation, also known as interpreted object orientation, there is no fixed type. The type the object belongs to is determined during runtime, hence that gives additional flexibility. Static typing should be used where possible, dynamic typing when needed.

== Difficulties in mixing static and dynamic oo code ==

There can be some issues in mixing static and dynamic object oriented code.

* If the static oo makes use of generics. 
For e.g. Java, then the generic types are erased during compilation for backward compatibility.
As a result for a dynamically types language like Ruby, there will be problems with type conversion.
For example, if you have a Map<String,String>, it will be seen as a simple Map, and JRuby will not be able to determine the correct types using reflection. 
* If you have a class name ambiguity between Java and Ruby. 
In such a case, the class name will reference the Ruby construct within the Ruby code. For instance, if you import java.lang.Thread and then write JThread < Thread, JThread will in fact inherit the Ruby Thread object, not the Java Thread. The solution is to use the full Java Class name, such as: JThread < java.lang.Thread 
* Inheritance
Java classes can't inherit from a JRuby class. Hopefully this feature will be added in the planned re-write of the Java integration layer in a future release of JRuby.

== JRuby ==

[http://en.wikipedia.org/wiki/JRuby JRuby] is the Ruby Programming Language on the [http://en.wikipedia.org/wiki/JVM JVM].
Ruby is a reflective, dynamic, and interpreted object-oriented scripting language. JRuby is a Java programming language implementation of the Ruby language syntax with all the core libraries plus the standard libraries. With JRuby, you get all of the advantages of Ruby plus access to the full range of Java platform functionality. This can be achieved in 2 flavors . 

* Driving Ruby from Java
* Driving Java from Ruby

Some examples where this integration can be done are:

* From a JRuby script, you can call the Java platform Math library to access its powerful computational capabilities or call the Java platform Swing library to display a dialog box that requires end-user input before allowing the script to proceed. 
* You can use the [http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform JSR 223] Scripting APIs or the [http://en.wikipedia.org/wiki/Bean_Scripting_Framework Bean Scripting Framework (BSF)] APIs to call a JRuby script from within a Java application to, for example, invoke back-end processing scripts from a servlet to update or generate web content. 

== Advantages of JRuby ==

=== Advantages of JRuby over Ruby ===

* With JRuby you get the best of both worlds: Ruby applications and libraries, plus Java libraries. Anthreads, JRuby supports Unicode natively 
* Code can be fully compiled ahead of time or just in time. 
* In addition to native you can access those libraries with Ruby syntax (or Java syntax, if you want). 
* On average JRuby, runs 2 and a half times faster than Ruby, except at startup 

=== Advantages of JRuby over Java ===

* Ruby is fun, beautiful, and powerful language 
* Ruby has features which are missing from Java 
**[http://en.wikipedia.org/wiki/Closure_(computer_science) Closure (blocks)] 
**Open classes 
**[http://en.wikipedia.org/wiki/Meta_programming Meta programming] 
**[http://en.wikipedia.org/wiki/Duck_typing Duck-typing] 
**[http://en.wikipedia.org/wiki/Domain_Specific_Language Domain Specific Language] (DSL)

== JRuby explained in details ==

=== Driving Java from Ruby===
This involves calling Java methods from Ruby. This includes adding some java functionality in the Ruby code. The final code will be run on JVM. Ruby code can load and interact with Java Libraries. As a simple example we can use an ArrayList from java into Ruby code as below:

<pre>
require ‘java’

list = java.util.ArrayList.new

list << ‘List of’
list << 3
list << :assorted_items

list.each do |item|
puts “#{item.class}: #{item}”
end
</pre>

Instead of just requiring a specific class you can also require the entire package. This can be done as follows:

<pre>
module JavaLangDemo
include_package "java.lang"
# alternately, use the #import method
import "java.lang"
end
</pre>

One has to be careful in doing this as with name conflicts in both Ruby and Java can lead to losing the Ruby functionality. For example if a File object is created using Java’s java.io.File class, then the Ruby constant File becomes useless -

<pre>
import java.io.File
newfile = File.new("file.txt")
</pre>
and then using -

<pre>
File.open('README', 'r') {|f| puts f.readline }
</pre>

This will give the error - NoMethodError: private method `open' called for Java::JavaIo::File:Class

This situation can be avoided by including the package in the module definition and then using that module scope to create using that File object.

<pre>
newfile = JavaIO::File.new("file.txt")
</pre>

JRuby will forward any option to the underlying Java runtime if you preface it with -J.

===Driving Ruby from Java===

There are three ways for using the JRuby Interpreter from Java namely, Embedding JRuby, using JSR 223 and the Bean Scripting Framework.

====Embedding JRuby====
Embed Core is the main embedding API that ships with JRuby. This API offers a great deal of interoperability. You can call a Ruby method, crunch the results in Java, and hand data back into Ruby.

<pre>
import java.util.ArrayList;
import org.jruby.Ruby;
import org.jruby.RubyRuntimeAdapter;
import org.jruby.javasupport.JavaEmbedUtils;

public class MyEmbedRubyExample {
public static void main(String[] args) throws Exception {
// Create runtime instance
Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());
RubyRuntimeAdapter evaler = JavaEmbedUtils.newRuntimeAdapter();

evaler.eval(runtime, "puts 1+2");

// Shutdown and terminate instance
JavaEmbedUtils.terminate(runtime);
}
}
</pre>

To run the above code you need to include jruby.jar in the classpath. This jar is present in the JRuby installation in lib folder. The above example outputs "3" as expected.

====JSR 223, Scripting for the Java Platform====
This provides an API framework for calling scripting code from within a Java application and passing data between the application and the script. These features make it possible to combine existing scripts with Java applications and to extend a Java application with general-purpose scripts that other Java applications can also use.
JSR 223 Scripting APIs are available in JDK 6 software, and by default, the APIs support the JavaScript programming language. With a little setup as described in the section JRuby Scripting Engine Setup, you can use the JSR 223 Scripting APIs with any JSR 223-compliant scripting engine such as JRuby.

Steps:
Java integration with Java 6 will be using the standard scripting API (JSR223). A JRuby scripting engine already exists and is located at [https://scripting.dev.java.net here]
Download and unzip the collection of jars from the documents and files section of the site (jsr223-engines.tar.gz or jsr223-engines.zip).
Look in the uncompressed files for the jruby/build/jruby-engine.jar file.
Add this file to your classpath and then use the code below to access the engine.

<pre>
import javax.script.*;

public class jrubytry {
public static void main(String[] args) throws Exception {
ScriptEngineManager factory = new ScriptEngineManager();

// Create a JRuby engine.
ScriptEngine engine = factory.getEngineByName("jruby");

// Evaluate JRuby code from string.
try {
engine.eval("puts('Hello')");
} catch (ScriptException exception) {
exception.printStackTrace();
}
}
}
</pre>

====The Bean Scripting Framework (BSF)====
This is another way to call scripting code from within a Java application.

The Bean Scripting Framework, when used with JRuby, will allow you to conveniently to pass your own Java objects to your JRuby script. You can then use these objects in JRuby, and changes will affect your Java program directly. To run a JRuby script using BSF, you must first copy the BSF.jar file into your JAVA_HOME/lib/ext/ folder. Then, try the following:

<pre>
import org.jruby.Ruby.*;
import org.jruby.*;
import org.jruby.javasupport.bsf.*;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
{...}
JLabel mylabel = new JLabel();
BSFManager.registerScriptingEngine("ruby",
"org.jruby.javasupport.bsf.JRubyEngine",
new String[] { "rb" });

BSFManager manager = new BSFManager();

/* Import an object using declareBean then you can access it in JRuby with $<name> */

manager.declareBean("label", mylabel, JFrame.class);
manager.exec("ruby", "(java)", 1, 1, "$label.setText(\"This is a test.\")");
</pre>

== Difficulties with JRuby ==

Larger memory footprint and startup time

A single JRuby instance needs more memory than a single Ruby instance, but in a typical production server environment with multiple mongrels, memory can be shared so that I expect a lower or at least equal memory usage in total. JRuby’s startup time is higher than MRI, but once the JVM has “warmed up” after a few minutes, it usually runs faster than MRI.

No native C extension

Due to the nature of Java, it is impossible to run any native extension. So there are several gems that don’t work since they rely on a C extension. However, there’s ongoing effort to create alternative gems that are compatible to JRuby. E.g. mongrel uses a native C extension, but if you install the mongrel gem using JRuby, it automatically installs a java-enhanced version.

JRuby is not technically complete

It’s told that there are cases where JRuby is not 100% compatible with MRI, however, I think these are very special cases; at least I didn’t encounter any problems yet. Big Frameworks like Rails are tested with JRuby, so I currently don’t expect any problems with it.

== References ==

[1] http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html 
[2] http://java.sun.com/developer/technicalArticles/scripting/jruby/ 
[3] http://en.wikipedia.org/wiki/JRuby 
[4] http://rubysource.com/learning-more-about-jruby-from-charles-nutter/ 
[5] https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby 
[6] http://media.pragprog.com/titles/jruby/embed.pdf 
[7] http://www.coderanch.com/t/461625/Ruby/JRuby-benefits 
[8] http://zargony.com/2008/09/26/why-i-m-starting-to-like-jruby-even-though-i-dislike-java 
[9] https://github.com/jruby/jruby/wiki/JavaIntegration#wiki-Java_6_using_JSR_223_Scripting 
[10] https://github.com/jruby/jruby/wiki/DirectJRubyEmbedding 
[11] Kutner, Joe (August 22, 2012), [http://research.microsoft.com/en-us/um/people/emeijer/Papers/RDL04Meijer.pdf Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages]

== Further Reading ==

Charles O Nutter, Thomas Enebo, Nick Sieger, Ola Bini, and Ian Dees, Using JRuby:Bringing Ruby to Java, 2011