- Do not provide public setters
- java.util.Collections.unmodifiableCollection(c)
Thursday, October 18, 2007
Sunday, October 14, 2007
Unix HowTo
To Keep commonly used unix commands ..
1.extract-tar-files-to-stdout
tar -xOf freedb-complete-20040908.tar|grep DTITLE|less
2.To Send mail with attachment
Only mail:
mailx -s[Subject] to_address [space seperated] -f[from address]
Then type in messages and when finished - enter EOF - [Ctrl+d]
For attachments:
You can encode the source file which can piped to mailx
uuencode sourceFile outputFile
E.g
uuencode attach.txt attach.txt| mailx -s "mail from unix" e026784@mc.com
How to get Host name/ machine implementation
uname -a # to get host name,implementation, release etc
hostname # equivalent to uname -n; just gives the hostname
1.extract-tar-files-to-stdout
tar -xOf freedb-complete-20040908.tar|grep DTITLE|less
2.To Send mail with attachment
Only mail:
mailx -s[Subject] to_address [space seperated] -f[from address]
Then type in messages and when finished - enter EOF - [Ctrl+d]
For attachments:
You can encode the source file which can piped to mailx
uuencode sourceFile outputFile
E.g
uuencode attach.txt attach.txt| mailx -s "mail from unix" e026784@mc.com
How to get Host name/ machine implementation
uname -a # to get host name,implementation, release etc
hostname # equivalent to uname -n; just gives the hostname
Java Pointers
We know object references are implemented via pointers,then why we don't have access of pointers in java...
There are many reasons, but the two big ones are probably....
Security:
You can't implementment the security model needed for applets. Or even needed in a shared model used in application servers, if an application can do pointer arithmetic to access portions of memory that they are not allowed to touch.
Garbage Collection.
It would be impossible to detect whether something has been dereferenced, if the program can convert a pointer to an integer, so that it can calculate the reference later.
Since References are pointers, the JVM uses pointers and developers have access to them and can do pointer arithmatic on them.
There are many reasons, but the two big ones are probably....
Security:
You can't implementment the security model needed for applets. Or even needed in a shared model used in application servers, if an application can do pointer arithmetic to access portions of memory that they are not allowed to touch.
Garbage Collection.
It would be impossible to detect whether something has been dereferenced, if the program can convert a pointer to an integer, so that it can calculate the reference later.
Since References are pointers, the JVM uses pointers and developers have access to them and can do pointer arithmatic on them.
Saturday, October 13, 2007
TinyURL
Make ur long url references with shorter link which redirects to actual url.
Example
The following URL:
http://nambi-adhimoolam.blogspot.com/
has a length of 37 characters and resulted in the following TinyURL which has a length of 25 characters:
http://tinyurl.com/2zu38k
It never expires....
Example
The following URL:
http://nambi-adhimoolam.blogspot.com/
has a length of 37 characters and resulted in the following TinyURL which has a length of 25 characters:
http://tinyurl.com/2zu38k
It never expires....
Wednesday, October 10, 2007
Javascript - call() and apply()
In JavaScript 1.2 you could construct an object only within a single method. JavaScript 1.3 extends object construction to any number of methods.Object being built consecutively by two different methods is a real advantage.
The call() and apply() methods helps in multi-method object construction.
The apply() method lets you pass the parameters from one method to the other whereasthe call() method requires the full list of parameters.
outer = function(a){
this.player=a;
this.kick = function(){
alert('This is outer:'+this.player);
inner.call(this,this.player);
};
};
inner = function(b){
alert('This is inner:'+b);
ininner.apply(this,arguments);
};
ininner = function (c){
alert('This is inner of inner:'+c);
};
var outin=new outer('B');
outin.kick();
Output
This is outer:B
This is inner:B
This is inner of inner:B
Reference:
Learn, implement and share
http://www.webreference.com/js/column26/call.html
Tuesday, October 9, 2007
JMS - Ideal SOA !
JMS - Java Messaging service First published in 1998 and current version 1.1 in April 2002
Its is an asynchronous communication between software components/applications
Sender sends to/receives the messages from messaging client. hence NO need to know about the other side of the communicator - who is receiving/sending.
It enables loosely coupled distributed communication
Ensures 100% reliability - Message is delivered to the client[acknowledgement] only once [accuracy]
Platform independent interface for Existing - Message Oriented Middleware System [MOM] like MQSeries from IBM.
It can be implemented through -EJB - Message driven beans, web components , application clients ....Or infact through simple POJOs.
Supports Distributed Transactions and allows concurrent consumption of messages as per EJB 3.0 specification
Through Java EE Connector Architecture [Resource Adapters - rsadapter], multiple JMS providers can be integrated with single Java EE application server.
Architecture:
A JMS application is composed of the following parts.
■ A JMS provider is a messaging system that implements the JMS interfaces and provides
administrative and control features. An implementation of the Java EE platform includes a
JMS provider.
■ JMS clients are the programs or components, written in the Java programming language,
that produce and consume messages. Any Java EE application component can act as a JMS
client.
■ Messages are the objects that communicate information between JMS clients.
■ Administered objects are preconfigured JMS objects created by an administrator for the use
of clients. The two kinds of JMS administered objects are destinations and connection factories. Administrative tools allow you to bind destinations and connection factories into a JNDI namespace. A JMS client can then use resource injection to access the administered objects in the namespace and then establish a logical connection to the same objects through the JMS provider.
JMS API Programming Model
1. Admininistered Objects
Destination and Connection Factories are maintained by JMS Provider.
These objects can be located through JNDI
@Resource(mappedName="jms/ConnectionFactory")
private static ConnectionFactory connectionFactory;
@Resource(mappedName="jms/Queue")
private static Queue queue;
@Resource(mappedName="jms/Topic")
private static Topic topic;
2.Connections
A connection encapsulates a virtual connection with a JMS provider. A connection could
represent an open TCP/IP socket between a client and a provider service daemon. You use a
connection to create one or more sessions.
Connection connection = connectionFactory.createConnection();
3.Sessions
Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
A session is a single-threaded context for producing and consuming messages. You use sessions
to create the following:
■ Message producers -created by a session and used for sending messages to adestination
MessageProducer producer = session.createProducer(dest);
producer.send(message);
■ Message consumers - created by a session and used for receiving messages sent
to a destination
MessageConsumer consumer = session.createConsumer(dest);
connection.start();
Message m = consumer.receive();
■ JMS Message Listener
A message listener is an object that acts as an asynchronous event handler for messages. Thisobject implements the MessageListener interface, which contains one method, onMessage. Inthe onMessage method, you define the actions to be taken when a message arrives.You register the message listener with a specific MessageConsumer by using thesetMessageListener method. For example, if you define a class named Listener thatimplements the MessageListener interface, you can register the message listener as follows:
Listener myListener = new Listener();
consumer.setMessageListener(myListener);
After you register the message listener, you call the start method on the Connection to beginmessage delivery
■ Messages
Message has three parts - Message Headers, Message Properties and Message Bodies
Headers contains number of predefined fields that contain values that both clients and providers use to identify and to route messages like JMSMessagID, JMSDestination, JMSPriority etc
Message Properties are used to provide compatibility with other messaging systems.
Following message body formats are defined
Text Message -String message
MapMessage - A set of name value pairs with names as String and value as primitive
BytesMessage - a stream of uninterpreted bytes
StreamMessage- Primitives processed sequentially
ObjectMessage - Java Serialized object
Message - Message with just header and properties
Ex :
Sender
TextMessage message = session.createTextMessage();
message.setText(msg_text); // msg_text is a String
producer.send(message);
Receiver:
Message m = consumer.receive();
if (m instanceof TextMessage) {
TextMessage message = (TextMessage) m;
System.out.println("Reading message: " + message.getText());
} else {
// Handle error
}
8.JMS Message Selectors
To filter the messages
9.JMS Queue Browsers
To browse queue to chk specific message
10.JMS Exception
Root level checked exception JMSException
--------------------------------------
Its is an asynchronous communication between software components/applications
Sender sends to/receives the messages from messaging client. hence NO need to know about the other side of the communicator - who is receiving/sending.
It enables loosely coupled distributed communication
Ensures 100% reliability - Message is delivered to the client[acknowledgement] only once [accuracy]
Platform independent interface for Existing - Message Oriented Middleware System [MOM] like MQSeries from IBM.
It can be implemented through -EJB - Message driven beans, web components , application clients ....Or infact through simple POJOs.
Supports Distributed Transactions and allows concurrent consumption of messages as per EJB 3.0 specification
Through Java EE Connector Architecture [Resource Adapters - rsadapter], multiple JMS providers can be integrated with single Java EE application server.
Architecture:
A JMS application is composed of the following parts.
■ A JMS provider is a messaging system that implements the JMS interfaces and provides
administrative and control features. An implementation of the Java EE platform includes a
JMS provider.
■ JMS clients are the programs or components, written in the Java programming language,
that produce and consume messages. Any Java EE application component can act as a JMS
client.
■ Messages are the objects that communicate information between JMS clients.
■ Administered objects are preconfigured JMS objects created by an administrator for the use
of clients. The two kinds of JMS administered objects are destinations and connection factories. Administrative tools allow you to bind destinations and connection factories into a JNDI namespace. A JMS client can then use resource injection to access the administered objects in the namespace and then establish a logical connection to the same objects through the JMS provider.
Admin Tool ---- Bind -->JNDI Namespace [Connection Factory & Destination]----inject Resouce---> JMS Client
JMS Client ---- Logical Connection ---> JMS Provider
Messaging Domains
Point to Point [PTP] - Messaging Domain[Queue]
A point-to-point (PTP) product or application is built on the concept of message queues,
senders, and receivers. Each message is addressed to a specific queue, and receiving clients
extract messages from the queues established to hold their messages. Queues retain all messages sent to them until the messages are consumed or until the messages expire.
Each message has only one consumer.
■ A sender and a receiver of a message have no timing dependencies. The receiver can fetch
the message whether or not it was running when the client sent the message.
■ The receiver acknowledges the successful processing of a message.
Use PTP messaging when every message you send must be processed successfully by one
consumer.
Client A --Msg-->Queue <--->Consumes & Acknowledges <--->Client B
Publish/Subscribe Messaging Domain [Topic]
In a publish/subscribe (pub/sub) product or application, clients address messages to a topic,
which functions somewhat like a bulletin board. Publishers and subscribers are generally
anonymous and can dynamically publish or subscribe to the content hierarchy. The system
takes care of distributing the messages arriving from a topic’s multiple publishers to its multiple
subscribers. Topics retain messages only as long as it takes to distribute them to current
subscribers.
Pub/sub messaging has the following characteristics.
■ Each message can have multiple consumers.
■ Publishers and subscribers have a timing dependency. A client that subscribes to a topic can
consume only messages published after the client has created a subscription, and the
subscriber must continue to be active in order for it to consume messages.
The JMS API relaxes this timing dependency to some extent by allowing subscribers to create
durable subscriptions, which receive messages sent while the subscribers are not active. Durable subscriptions provide the flexibility and reliability of queues but still allow clients to send messages to many recipients. Use pub/sub messaging when each message can be processed by zero, one, or many consumers.
JMS API Programming Model
1. Admininistered Objects
Destination and Connection Factories are maintained by JMS Provider.
These objects can be located through JNDI
@Resource(mappedName="jms/ConnectionFactory")
private static ConnectionFactory connectionFactory;
@Resource(mappedName="jms/Queue")
private static Queue queue;
@Resource(mappedName="jms/Topic")
private static Topic topic;
2.Connections
A connection encapsulates a virtual connection with a JMS provider. A connection could
represent an open TCP/IP socket between a client and a provider service daemon. You use a
connection to create one or more sessions.
Connection connection = connectionFactory.createConnection();
3.Sessions
Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
A session is a single-threaded context for producing and consuming messages. You use sessions
to create the following:
■ Message producers -created by a session and used for sending messages to adestination
MessageProducer producer = session.createProducer(dest);
producer.send(message);
■ Message consumers - created by a session and used for receiving messages sent
to a destination
MessageConsumer consumer = session.createConsumer(dest);
connection.start();
Message m = consumer.receive();
■ JMS Message Listener
A message listener is an object that acts as an asynchronous event handler for messages. Thisobject implements the MessageListener interface, which contains one method, onMessage. Inthe onMessage method, you define the actions to be taken when a message arrives.You register the message listener with a specific MessageConsumer by using thesetMessageListener method. For example, if you define a class named Listener thatimplements the MessageListener interface, you can register the message listener as follows:
Listener myListener = new Listener();
consumer.setMessageListener(myListener);
After you register the message listener, you call the start method on the Connection to beginmessage delivery
■ Messages
Message has three parts - Message Headers, Message Properties and Message Bodies
Headers contains number of predefined fields that contain values that both clients and providers use to identify and to route messages like JMSMessagID, JMSDestination, JMSPriority etc
Message Properties are used to provide compatibility with other messaging systems.
Following message body formats are defined
Text Message -String message
MapMessage - A set of name value pairs with names as String and value as primitive
BytesMessage - a stream of uninterpreted bytes
StreamMessage- Primitives processed sequentially
ObjectMessage - Java Serialized object
Message - Message with just header and properties
Ex :
Sender
TextMessage message = session.createTextMessage();
message.setText(msg_text); // msg_text is a String
producer.send(message);
Receiver:
Message m = consumer.receive();
if (m instanceof TextMessage) {
TextMessage message = (TextMessage) m;
System.out.println("Reading message: " + message.getText());
} else {
// Handle error
}
8.JMS Message Selectors
To filter the messages
9.JMS Queue Browsers
To browse queue to chk specific message
10.JMS Exception
Root level checked exception JMSException
--------------------------------------
Sunday, October 7, 2007
JBoss - Seam
What is JBoss Seam
EJB 3.0 and JSF are perhaps the most exciting new developments in the Java EE 5 platform. Seam is an innovative new application framework that integrates the EJB 3.0 component model with JSF as a presentation tier. Seam builds upon the standard extension points provided by both specifications and provides a set of Java annotations that extends the standard annotations defined by the EJB specification. In addition, Seam introduces several innovative new ideas: managed conversations, declarative and contextual application state management, bijection and integrated business process management.
Traditional web applications are incredibly vulnerable to bugs and performance problems relating to state management. Developers are forced to handle issues like back button navigation, multi-window browsing, session size management in an utterly ad-hoc fashion. Access to transactional components from the web tier has also been problematic. J2EE provided no way to have simultaneous access to state held in contexts associated with the web request, and state held in transactional resources accessed via EJB. Finally, J2EE had no first-class construct for representing state associated with a long-running business process. Seam tackles all these problems, and provides a uniform model for stateful components in Java EE 5.
Like all JBoss software, this entire software stack is free. The full source code of this sample application is available in the examples/booking directory of the Seam distribution. There is even a 10-minute flash demo showing how to build a Seam web application from ground up.
The first application framework for EJB 3.0
EJB 3.0 has changed the notion of EJB components as coarse-grained, heavy-weight objects to EJBs as lightweight POJOs with fine-grained annotations. In Seam, any class may be an EJB - Seam eliminates the distinction between presentation tier components and business logic components and brings a uniform component model to the EE platform.
Backward compatible with J2EE
But Seam is not limited to environments that support EJB 3.0. Seam may be used in any J2EE environment, or even in plain Tomcat.
The easy way to do AJAX
Seam 1.1 integrates open source JSF-based AJAX solutions like ICEfaces and Ajax4JSF with Seam's unique state and concurrency management engine. You can add AJAX to your applications with ease, without the need to learn JavaScript, and you will be protected from potential bugs and performance problems associated with the switch to AJAX.
A revolutionary approach to state management
Before Seam, the HTTP session was the only way to manage Web application state. Seam provides multiple stateful contexts of different granularity from the conversation scope to the business process scope, liberating developers from the limitation of HTTP sessions. For example, developers can write Web applications with multiple workspaces that behave like a multi-window rich client.
Manage "flow"
Seam integrates transparent business process management via JBoss jBPM, making it easier than ever to model, implement and optimize complex collaborations (workflow) and complex user interactions (pageflow).
Easy integration testing
Seam components, being POJOs, are by nature unit testable. But for complex applications, unit testing alone is insufficient. Therefore, Seam provides for easy testability of Seam applications as a core feature of the framework. You can write JUnit or TestNG tests that reproduce a whole interaction with a user, exercising all components of the system, and run them inside your IDE.
References
http://www.jboss.com/products/seam
http://www.oreillynet.com/onjava/blog/2007/10/after_struts_what.html
http://labs.jboss.com/jbossseam/gettingstarted
EJB 3.0 and JSF are perhaps the most exciting new developments in the Java EE 5 platform. Seam is an innovative new application framework that integrates the EJB 3.0 component model with JSF as a presentation tier. Seam builds upon the standard extension points provided by both specifications and provides a set of Java annotations that extends the standard annotations defined by the EJB specification. In addition, Seam introduces several innovative new ideas: managed conversations, declarative and contextual application state management, bijection and integrated business process management.
Traditional web applications are incredibly vulnerable to bugs and performance problems relating to state management. Developers are forced to handle issues like back button navigation, multi-window browsing, session size management in an utterly ad-hoc fashion. Access to transactional components from the web tier has also been problematic. J2EE provided no way to have simultaneous access to state held in contexts associated with the web request, and state held in transactional resources accessed via EJB. Finally, J2EE had no first-class construct for representing state associated with a long-running business process. Seam tackles all these problems, and provides a uniform model for stateful components in Java EE 5.
Like all JBoss software, this entire software stack is free. The full source code of this sample application is available in the examples/booking directory of the Seam distribution. There is even a 10-minute flash demo showing how to build a Seam web application from ground up.
The first application framework for EJB 3.0
EJB 3.0 has changed the notion of EJB components as coarse-grained, heavy-weight objects to EJBs as lightweight POJOs with fine-grained annotations. In Seam, any class may be an EJB - Seam eliminates the distinction between presentation tier components and business logic components and brings a uniform component model to the EE platform.
Backward compatible with J2EE
But Seam is not limited to environments that support EJB 3.0. Seam may be used in any J2EE environment, or even in plain Tomcat.
The easy way to do AJAX
Seam 1.1 integrates open source JSF-based AJAX solutions like ICEfaces and Ajax4JSF with Seam's unique state and concurrency management engine. You can add AJAX to your applications with ease, without the need to learn JavaScript, and you will be protected from potential bugs and performance problems associated with the switch to AJAX.
A revolutionary approach to state management
Before Seam, the HTTP session was the only way to manage Web application state. Seam provides multiple stateful contexts of different granularity from the conversation scope to the business process scope, liberating developers from the limitation of HTTP sessions. For example, developers can write Web applications with multiple workspaces that behave like a multi-window rich client.
Manage "flow"
Seam integrates transparent business process management via JBoss jBPM, making it easier than ever to model, implement and optimize complex collaborations (workflow) and complex user interactions (pageflow).
Easy integration testing
Seam components, being POJOs, are by nature unit testable. But for complex applications, unit testing alone is insufficient. Therefore, Seam provides for easy testability of Seam applications as a core feature of the framework. You can write JUnit or TestNG tests that reproduce a whole interaction with a user, exercising all components of the system, and run them inside your IDE.
References
http://www.jboss.com/products/seam
http://www.oreillynet.com/onjava/blog/2007/10/after_struts_what.html
http://labs.jboss.com/jbossseam/gettingstarted
JavaFx - New RIA[Rich Interactive Applications] for content Driven web!
The JavaFX Script programming language (hereinafter referred to as JavaFX) is a declarative, statically typed scripting language from Sun Microsystems, Inc. As mentioned on the Open JavaFX (OpenJFX) web site, JavaFX technology has a wealth of features, including the ability to make direct calls to Java technology APIs. Because JavaFX Script is statically typed, it also has the same code structuring, reuse, and encapsulation features -- such as packages, classes, inheritance, and separate compilation and deployment units -- that make it possible for your to create and maintain very large programs using Java technology.
Open Source
https://openjfx.dev.java.net/
- The JavaFX Pad Application
- References
http://java.sun.com/developer/technicalArticles/scripting/javafxpart1/
More from experts:
JavaFX Script, is an open-source scripting language designed to facilitate rapid content authoring. JavaFX Script provides a highly-expressive syntax for declarative construction of 2D graphics and dynamic user interfaces. Although JavaFX Script is statically typed, the language is heavily inspired by popular dynamic programming languages like Python and incorporates compelling syntactic features like support for list comprehensions and first-class functions.
JavaFX isn't a completely independent runtime; it is essentially designed as a layer that sits on top of Java in order to make Java better-suited for rich application development. There are advantages and disadvantages to this approach. Sun clearly went to great lengths to make sure that JavaFX uses as much existing Java infrastructure as possible in order to simplify the process of integration. As a result, JavaFX feels like a very natural extension of the Java ecosystem. Developers can use Java libraries directly in JavaFX Script, and the language's declarative syntax for interface development is tightly bound to Swing and Java2D. The downside is that JavaFX Script doesn't really give developers the ability to do much they couldn't do already, its function is primarily to make existing Java technologies easier to use together.
As a result of JavaFX's dependence on existing Java technologies, developers with Java expertise will find that their existing skills easily translate over to JavaFX development. The broad availability of existing libraries for Java also ensures that a lot of useful functionality is available in JavaFX right out of the box. Additionally, since JavaFX runs on top of the JRE, it is highly portable and can target a wide variety of platforms.
Although JavaFX has a lot of potential, the technology also has a lot of weaknesses. JavaFX Script fixes many of Java's most frustrating syntactic deficiencies, but at the present time, very few convenience mechanisms are provided to support the kind of functionality currently required by modern interactive web applications. In particular, I think that JavaFX Script really needs some heavy syntactic sugar for consuming and manipulating remote XML and JSON content. One thing it does seem to handle relatively well, however, is integration of embedded HTML for application styling and content.
Wait and see how it progresses.......................
Open Source
https://openjfx.dev.java.net/
- The JavaFX Pad Application
- References
http://java.sun.com/developer/technicalArticles/scripting/javafxpart1/
More from experts:
JavaFX Script, is an open-source scripting language designed to facilitate rapid content authoring. JavaFX Script provides a highly-expressive syntax for declarative construction of 2D graphics and dynamic user interfaces. Although JavaFX Script is statically typed, the language is heavily inspired by popular dynamic programming languages like Python and incorporates compelling syntactic features like support for list comprehensions and first-class functions.
JavaFX isn't a completely independent runtime; it is essentially designed as a layer that sits on top of Java in order to make Java better-suited for rich application development. There are advantages and disadvantages to this approach. Sun clearly went to great lengths to make sure that JavaFX uses as much existing Java infrastructure as possible in order to simplify the process of integration. As a result, JavaFX feels like a very natural extension of the Java ecosystem. Developers can use Java libraries directly in JavaFX Script, and the language's declarative syntax for interface development is tightly bound to Swing and Java2D. The downside is that JavaFX Script doesn't really give developers the ability to do much they couldn't do already, its function is primarily to make existing Java technologies easier to use together.
As a result of JavaFX's dependence on existing Java technologies, developers with Java expertise will find that their existing skills easily translate over to JavaFX development. The broad availability of existing libraries for Java also ensures that a lot of useful functionality is available in JavaFX right out of the box. Additionally, since JavaFX runs on top of the JRE, it is highly portable and can target a wide variety of platforms.
Although JavaFX has a lot of potential, the technology also has a lot of weaknesses. JavaFX Script fixes many of Java's most frustrating syntactic deficiencies, but at the present time, very few convenience mechanisms are provided to support the kind of functionality currently required by modern interactive web applications. In particular, I think that JavaFX Script really needs some heavy syntactic sugar for consuming and manipulating remote XML and JSON content. One thing it does seem to handle relatively well, however, is integration of embedded HTML for application styling and content.
Wait and see how it progresses.......................
Saturday, October 6, 2007
SOA - Only XML ?
XML Services: A Brief Synopsis
•XML documents: Rendering a request or response as an XML document tends to be both CPU and memory intensive
•Networking: Passing textually-encoded XML documents is a poor use of bandwidth
•Connection Management: Connectionless HTTP is far more expensive than a socket
•Parsing: Validation and parsing of XML documents is extremely CPU intensive
•Summary: Big money, high latency
Appropriate Uses
•Exposing Platform-Independent Services
–XML-based services are the one thing that Java and Microsoft .NET can agree on
•Loose Coupling
–The service provider and the service consumer can be completely unknown to each other
•Public Network Capable
–Securable at the low level (e.g. HTTPS) and the high level (document signing, encryption, etc.)
•Defensible Uses
–Among separate applications
–Among different organizations
Other Options
XML-based SOA has appropriate uses
•SOA and its underlying principles do not require SOAP, XML, HTTP, etc.
•Java has a rich set of built-in capabilities for supporting SOA withinan application, such as:
–JMS –Message bus-based SOA
–RMI –Synchronous Java-centric remote invocation
•When the internal (Java) and external (XML) service interfaces are identical, then layer the XML-based interfaces on top ofthe higher-performing and more efficient Java API, and use the Java API within the app
•XML documents: Rendering a request or response as an XML document tends to be both CPU and memory intensive
•Networking: Passing textually-encoded XML documents is a poor use of bandwidth
•Connection Management: Connectionless HTTP is far more expensive than a socket
•Parsing: Validation and parsing of XML documents is extremely CPU intensive
•Summary: Big money, high latency
Appropriate Uses
•Exposing Platform-Independent Services
–XML-based services are the one thing that Java and Microsoft .NET can agree on
•Loose Coupling
–The service provider and the service consumer can be completely unknown to each other
•Public Network Capable
–Securable at the low level (e.g. HTTPS) and the high level (document signing, encryption, etc.)
•Defensible Uses
–Among separate applications
–Among different organizations
Other Options
XML-based SOA has appropriate uses
•SOA and its underlying principles do not require SOAP, XML, HTTP, etc.
•Java has a rich set of built-in capabilities for supporting SOA withinan application, such as:
–JMS –Message bus-based SOA
–RMI –Synchronous Java-centric remote invocation
•When the internal (Java) and external (XML) service interfaces are identical, then layer the XML-based interfaces on top ofthe higher-performing and more efficient Java API, and use the Java API within the app
Choose appropos Data Access!
Popular Methods for Data Access
•JDBC API –a CLI view of RDBMS data
•Apache iBATIS–simplifying common JDBC usage patterns
•EJB v1, v2 –a "record oriented"approach
•Object Relational Mapping (ORM)
–Hibernate, Castor
–JDO v2 (Including KODO, OpenAccess)
–EJB v3 (Including Hibernate, Toplink, KODO)
Data Access: JDBC
•The "assembly language"of RDBMS –you can do anything, but you have to do everything
•Best choice when the form of the data being accessed is unknown, such as in a reporting engine in which the number and types of result columns are unknown
•Good choice for dealing with extremely large result sets and accessing rarely-used driver functionality
•Worst choice for rapid application development
•Worst choice for large engineering teams and large code bases
•Worst choice for building maintainable applications
Data Access: ORM
•The "object oriented"model for RDBMS –you only deal with objects, but the ORM has to deal with the RDBMS
•Best choice when the form of the data being accessed is well known, and the wide-spread use of the data throughout the application logic far exceeds the investment in defining the object schema and its mapping to the database
•Good choice for enabling data caching
•Definitely nota silver bullet
–Still requires good development processes and careful design
–Using ORM, some common application use cases are very inefficient compared to hand-coded JDBC
Why the Choice is so Critical
•I have witnessed more applications fail to meet their business goals due to poor choices around data access than any other category
•Once a choice is made, it tends to be reflected in every aspect of the application, making later changes more difficult and incredibly costly
•The predictability and cost of scalability of a large-scale application is tightly bound to the application’s data access model
Choosing a Data Access Model
•Understand the high-level requirements
–The "-ilities": Scalability, Reliability, Availability, …
•Visualize the data flows in the running system
–For each page or service request, what actually goes through to the database, and why?
•Understand the impact of concurrent users
–How will database contention be minimized?
–How will cache effectiveness be maximized?
•Understand the application’s data granularity
–Set-centric or identity-centric?
•JDBC API –a CLI view of RDBMS data
•Apache iBATIS–simplifying common JDBC usage patterns
•EJB v1, v2 –a "record oriented"approach
•Object Relational Mapping (ORM)
–Hibernate, Castor
–JDO v2 (Including KODO, OpenAccess)
–EJB v3 (Including Hibernate, Toplink, KODO)
Data Access: JDBC
•The "assembly language"of RDBMS –you can do anything, but you have to do everything
•Best choice when the form of the data being accessed is unknown, such as in a reporting engine in which the number and types of result columns are unknown
•Good choice for dealing with extremely large result sets and accessing rarely-used driver functionality
•Worst choice for rapid application development
•Worst choice for large engineering teams and large code bases
•Worst choice for building maintainable applications
Data Access: ORM
•The "object oriented"model for RDBMS –you only deal with objects, but the ORM has to deal with the RDBMS
•Best choice when the form of the data being accessed is well known, and the wide-spread use of the data throughout the application logic far exceeds the investment in defining the object schema and its mapping to the database
•Good choice for enabling data caching
•Definitely nota silver bullet
–Still requires good development processes and careful design
–Using ORM, some common application use cases are very inefficient compared to hand-coded JDBC
Why the Choice is so Critical
•I have witnessed more applications fail to meet their business goals due to poor choices around data access than any other category
•Once a choice is made, it tends to be reflected in every aspect of the application, making later changes more difficult and incredibly costly
•The predictability and cost of scalability of a large-scale application is tightly bound to the application’s data access model
Choosing a Data Access Model
•Understand the high-level requirements
–The "-ilities": Scalability, Reliability, Availability, …
•Visualize the data flows in the running system
–For each page or service request, what actually goes through to the database, and why?
•Understand the impact of concurrent users
–How will database contention be minimized?
–How will cache effectiveness be maximized?
•Understand the application’s data granularity
–Set-centric or identity-centric?
Java EE 5 - First Look!
Java 1.5 version is called Java 5 and its no more J2EE 1.5 instead Java Enterprise Edition 5
1. XML deployment descriptors can be java-coded using annotations. Spring already provides this feature as bean configurations can also be java-coded as well.
2.Dependency Injection can be used in all levels - EJB container,Web container and application clients
3.Java Persistence API - can be used either in Java EE or Java SE applications .This replaces Entity Beans from EJB 3.0 [Java EE 5 ]
4.Java Server Faces - GUI Component Framework[since 1.4]
1. XML deployment descriptors can be java-coded using annotations. Spring already provides this feature as bean configurations can also be java-coded as well.
2.Dependency Injection can be used in all levels - EJB container,Web container and application clients
3.Java Persistence API - can be used either in Java EE or Java SE applications .This replaces Entity Beans from EJB 3.0 [Java EE 5 ]
4.Java Server Faces - GUI Component Framework[since 1.4]
Everything is considered under Service Oriented Architecture - SOA
- Synchronous Services - EJB[remote/local] - session/entity or Spring Remote/local, Web Services
- Asynchronous Services - Java Messaging Service [Topic/Queue]
Friday, October 5, 2007
Inversion of Control-Don't call me;I'll call you!
We all know the benefits of interfaces.
Programming to interfaces is a new way of Enterprise architecture for multi-layered, test driven, loosely coupled systems.
Service oriented Architecture - [SOA]
There are various ways of inversioning the control.The leightweight containers try to invert "hard-wire" coupling of interface-concreate implementation to "configurable" injection so that the "atomic" independent services are developed that can be used without knowing the actual implementation details. The service client can just concentrate on the Service API for their usage.
This kind of "IoC" is also called "Dependency Injection".
Following are the Java Community Dependency injection methods
1.Constructors injection
- Pica Container, Spring
2.Setter Injection
- Spring
3.Interface Injection
- Avlon
Spring - Setter Injection : Dependency Injection
This is the most widely used IOC methodology adopted by Spring and supported by various other IoC frameworks
The injections can be java-coded or XML configured as bean definitions.
Singleton/Non-Singleton beans are created and managed by Spring Framework.
Detailed code example on the way.....
Refer for more details : http://martinfowler.com/articles/injection.html
Programming to interfaces is a new way of Enterprise architecture for multi-layered, test driven, loosely coupled systems.
Service oriented Architecture - [SOA]
There are various ways of inversioning the control.The leightweight containers try to invert "hard-wire" coupling of interface-concreate implementation to "configurable" injection so that the "atomic" independent services are developed that can be used without knowing the actual implementation details. The service client can just concentrate on the Service API for their usage.
This kind of "IoC" is also called "Dependency Injection".
Following are the Java Community Dependency injection methods
1.Constructors injection
- Pica Container, Spring
2.Setter Injection
- Spring
3.Interface Injection
- Avlon
Spring - Setter Injection : Dependency Injection
This is the most widely used IOC methodology adopted by Spring and supported by various other IoC frameworks
The injections can be java-coded or XML configured as bean definitions.
Singleton/Non-Singleton beans are created and managed by Spring Framework.
Detailed code example on the way.....
Refer for more details : http://martinfowler.com/articles/injection.html
Subscribe to:
Posts (Atom)