Java and I

A JavaBean is a special type of Java class that you can use in several interesting ways to simplify program development. Some beans, such as Swing components, are designed to be visual components that you can use in a GUI editor to quickly build user interfaces. Other beans, known as Enterprise JavaBeans, are designed to run on special EJB servers and can run the data access and business logic for large Web applications.

In this chapter, I look at a more modest type of JavaBean that's designed to simplify the task of building Java Server Pages. In a nutshell, you can use the simple JavaBeans to build Java Server Pages without writing any Java code in the JSP itself. JavaBeans let you access Java classes by using special HTML-like tags in the JSP page.

REMEMBER - The property name is capitalized in the methods that access it, but the property name itself isn't. Thus setAddress sets a property named address, not Address.

That's all there is to it. More advanced beans can also have other characteristics that allow them to have a visual interface so they can be used drag-and-drop style in an IDE. And some beans implement an interface that allows their state to be written to an output stream so they can be re-created later. But those features are optional; any class that meets the three criteria stated here is a bean and can be used as a bean in JSP pages.

You've already seen plenty of classes that have methods with names like getCount and setStatus. These names are part of a design pattern called the Accessor pattern, which is covered in Book III, Chapter 2. Thus you've seen many examples of beans throughout this book, and you've probably written many bean classes yourself already.

REMEMBER - Any class that conforms to this pattern is a bean. There's no JavaBean class you have to extend, nor is there a Bean interface you have to implement to be a bean. All a class has to do to be a bean is stick to the pattern.

EJB

Enterprise Java Bean (EJB) is a managed, server-sided component for modular construction of enterprise applications.
The EJB specification is one of the several Java APIs in the Java Platform, Enterprise Edition. EJB is a server-side component that encapsulates the business logic of an application.

Accordingly, the EJB specification details how an application server provides:

Persistence
Transaction processing
Concurrency control
Events using Java Message Service
naming and directory services ( JNDI )
Security ( JCE and JAAS )
Deployment of software components in an application server
Remote procedure calls using RMI-IIOP
Exposing business methods as Web Services

Additionally, the Enterprise JavaBean specification defines the roles played by the EJB container and the EJBs as well as how to deploy the EJBs in a container.

An EJB container can hold three major categories of beans:

Session Beans
- Stateless Session Beans
- Stateful Session Beans
Entity Beans
Message Driven Beans (MDBs or Message Beans)

Stateless Session Beans are distributed objects that do not have state associated with them thus allowing concurrent access to the bean. The contents of instance variables are not guaranteed to be preserved across method calls. The lack of overhead to maintain a conversation with the calling program makes them less resource-intensive than stateful beans.

Stateful Session Beans are distributed objects having state, that is, they keep track of which calling program they are dealing with throughout a session.

Entity Beans are distributed objects having persistent state.

Message Driven Beans are distributed objects that behave asynchronously, that is, they handle operations that do not require an immediate response. These beans subscribe to JMS (Java Message Service) message queues or message topics. They were added in the EJB 2.0 specification to allow event-driven processing inside EJB Container. Unlike other types of beans, MDB does not have a client view (Remote/Home interfaces), i.e. clients can not look-up an MDB instance. It just listens for any incoming message on a JMS queue (or topic) and processes them automatically.

EJBs are deployed in an EJB container within the application server. The specification describes how an EJB interacts with its container and how client code interacts with the container/EJB combination.

Because these are merely Java interfaces and not concrete classes, the EJB container must generate classes for these interfaces that will act as a proxy in the client. Client code invokes a method on the generated proxies, which in turn places the method arguments into a message and sends the message to the EJB server.

url

MDB

A Message Driven Bean (MDB) is an Enterprise JavaBean (EJB) similar to a session bean, except it responds to a JMS message rather than an RMI event. MDBs were introduced in the EJB 2.0 specification which is supported by Java 2 Platform, Enterprise Edition 1.3 or higher. The message bean represents the integration of JMS (Java Message Service) with EJB to create an entirely new type of bean designed to handle asynchronous JMS messages.

url, url

Singleton

Most commonly, you implement a singleton in Java by having a single instance of the class as a static field. You can create that instance at class-loading time by assigning a newly created object to the static field in the field declaration :

public class MySingleton { private static MySingleton _instance = new MySingleton(); private MySingleton() { // construct object . . . } public static MySingleton getInstance() { return _instance; } // Remainder of class definition . . .

Alternatively, you can instantiate it lazily, on first demand. You keep the constructor private to prevent instantiation by outside callers.

public class MySingleton { private static MySingleton _instance; private MySingleton() { // construct object . . . } // For lazy initialization public static synchronized MySingleton getInstance() { if (_instance==null) { _instance = new MySingleton(); } return _instance; } // Remainder of class definition . . . }

url, url

Implementing the Singleton Pattern in Java :

/** * A utility class of which at most one instance can exist per VM. * * Use Singleton.instance() to access this instance. * */ public class Singleton { /** * The constructor could be made private * to prevent others from instantiating this class. * But this would also make it impossible to * create instances of Singleton subclasses. */ protected Singleton() { // ... } /** * A handle to the unique Singleton instance. */ static private Singleton _instance = null; /** * @return The unique instance of this class. */ static public Singleton instance() { if(null == _instance) { _instance = new Singleton(); } return _instance; } /. ...additional methods omitted... }

url

Una altra descripció :

url

Snoop

public void service(ServletRequest arg0, ServletResponse arg1) throws ServletException, IOException { // TODO Apéndice de método generado automáticamente arg1.getOutputStream().print("<HTML>"); arg1.getOutputStream().print("<HEAD>"); arg1.getOutputStream().print("<TITLE> Pagina Snoop d'en Sebas i en Fernando. </TITLE>"); arg1.getOutputStream().print("</HEAD>"); arg1.getOutputStream().print("<BODY>"); arg1.getOutputStream().print("<HR>"); arg1.getOutputStream().print("Que passa Sebas ! Com estas ?"); arg1.getOutputStream().print("<HR>"); arg1.getOutputStream().print("Properties List es : <BR>"); System.getProperties().list(new PrintStream(arg1.getOutputStream())); arg1.getOutputStream().print("<HR>"); arg1.getOutputStream().print("JAVA.CLASS.PATH es : <BR>"); arg1.getOutputStream().print( System.getProperties().getProperty("java.class.path")); arg1.getOutputStream().print("</BODY>"); arg1.getOutputStream().print("</HTML>"); }

 System.out.println("HOLA. +++ Voy a buscar SnoopyJSP.jsp ...");
 arg0.getRequestDispatcher("SnoopyJSP.jsp");
 System.out.println("HOLA. --- He vuelto de buscar SnoopyJSP.jsp ...");

Cridem a un JAVA des un JSP

public class SnoopyBean {

     /*
      * ...
      */

     public SnoopyBean() {
          super();
          // TODO Apendice de constructor generado automáticamente
     }

     public String getText() {
          System.out.println("HOLA. +++ Voy a retornar un String ...");
          return "El Paco es collonut ... (version DEMO) ";
     }

 </HEAD>
 <f:view>
     <BODY>

     <jsp:useBean id="SnoopyBean" class="pagecode.SnoopyBean" scope="page">
     </jsp:useBean>
     <jsp:getProperty name="SnoopyBean" property="text"/>

     <p> Hola Sebas !
     <P> Fet per en Paco el 2 del 3 de 2006.</P>

     </BODY>
 </f:view>
 </HTML>

Envir var(s)

Abans :

103 if ( StrCodSvr.equals ( "ADP_ECO_WAS" ) )

Després :

public class MdbsvrBean implements javax.ejb.MessageDrivenBean, javax.jms.MessageListener { public static final String ECO_ID_PARAM = "ECO_ID"; protected String ecoId = null; . . . public void ejbCreate() { ecoId = System.getProperty(ECO_ID_PARAM); ecoId = ecoId!=null ? ecoId : "ADP_ECO_WAS"; . . . if ( StrCodSvr.equals( ecoId ) ) . . . rspmq.exec_snd(StrEntDst,StrEntOrg,StrTypMsg,"C", DatUsr, "Eco MDB J2EE V2 " + DtaMsg);

Que es configura passant-li paràmetres a la JVM :

-DECO_ID="ADP_ECO_WAS01"

JVM parameters in WAS

JVM arguments are used for configuring how the JVM executed. Any changes to JVM arguments needs restart of that JVM.

WebSphere Application Server 7.0

In the Administration Console select Servers
Expand Server Type and select WebSphere application servers
Click on the name of your server
Expand Java and Process Management and select Process Definition > Java Virtual Machine
Scroll down and locate the textbox for Generic JVM arguments.

WebSphere Application Server 6.1

In the Administration Console select Servers
Select Application Servers
Click on the name of your server
In the Additional Properties section, expand Java and Process Management and select Process Definition > Java Virtual Machine
Scroll down and locate the textbox for Generic JVM arguments.

WebSphere Application Server 6.0

In the Administration Console select Servers
Select Application Servers
Click on the name of your server
Under Server Infrastructure, expand Java and Process Management, and click Process Definition.
Under the Additional Properties section, click Java Virtual Machine
Scroll down and locate the textbox for Generic JVM arguments.

Gracias, Francisco !

RedBooks

Versions : JDK, .JAR ...

des-compilar Java

cavaj - des-compilador de Java
decompiled by JAD : http://www.kpdus.com/jad.html

Top

Java is losing the battle for the modern Web. Can the JVM save the vendors?

A few years ago I worked on a very big Enterprise IBM Websphere project. We had some brilliant engineers in the project both in the development and architecture groups. I remember having had several discussions with some of the brightest people on the team regarding PHP and dynamic languages and generally they were looked upon as toy languages without a bright future. Lack of strict typing, scripting performance, and other reasons were given for why Java would persevere as the language of choice.

This was the typical reaction dynamic languages would get from the Java community. There were many believable reasons for why these languages, especially the ones gaining fame on top of the LAMP stack, would not last. However, one thing which the Java community ignored for many years was the radical shift to the Web, not only for media and e-commerce Web sites but for a large majority of business applications including CRM, ERP, reporting, document management, etc As a result Java EE (then called J2EE) was not built with the Web in mind but rather focused on enterprise integration, transaction management and other back-end processing. While Java EE has long supported Web development with servlets and JSP the companies driving the standards ignored the RESTful nature of the Web and rather continued to drive a general purpose platform.

In parallel, the LAMP-like architecture built on top of the C language's eco-system of libraries and tools started becoming the most popular platform for developing Web applications. This trend grew in the second half of the 90s and with a recession following the burst of the .com bubble it greatly accelerated due to the lower TCO that the LAMP solutions had to offer. While there are a variety of dynamic languages which make up the LAMP development and deployment paradigm, the most ubiquitous language has been PHP. As a result of PHP being domain specific to the Web it has been shaped in a way which makes it fit the Web paradigm like a glove. By focusing on solving the common Web patterns quickly and easily it holds the biggest market share on the Web. In two separate surveys of one of the most popular Ajax Web sites, the Ajaxian.com, around 50% of Rich Internet Applications developers are using PHP. The trend has also been significantly accelerated as a result of the many popular PHP packages including Wordpress, Drupal, mediaWiki, osCommerce, SugarCRM, and more

When it became apparent to the large Java vendors that the Web paradigm was being built and innovated without Java they started backing a variety of both standards and non-standards driven Java Web application frameworks which promised to adapt Java to the Web. Such frameworks included Java Server Faces, Struts, Spring MVC and others. Some of these frameworks have been more successful than others but in general none of them managed to resolve one of Javas main pain points on the Web. The strict typing and overly complex architecture of Java applications meant longer development times and a need for more skilled engineers in order to push Java applications into the market, i.e. Java's TCO on the Web was unsatisfactory.

In the meanwhile the large Java vendors were trying to hold the stick at both ends. On one hand trying to be part of the Web paradigm shift and on the other hand protecting their multi-billion dollar businesses built on the Java language. Even the pervasiveness of dynamic languages in the Web space didn't change the vendor's behavior significantly. The big change came when Microsoft aggressively pursued a multi-language runtime environment for the .NET platform. Not only did they support C# and VB on their virtual machine but they worked with their developer community to add a large amount of languages including Cobol, Eiffel, Ruby, Python, and others. As dynamic languages continued to grow to the point where industry analysts started defining categories (e.g. Forrester Research on dynamic languages) Microsoft continued to leverage their common runtime which was designed from the get go to support multiple languages.

As mentioned earlier the de-facto standard implementations of the successful dynamic languages including PHP, Perl, Python and Ruby are all written in C and leverage the breadth and depth of the eco-system of C libraries. As community driven projects these languages do not have a specification nor is their development hindered by corporate bureaucracy. On the contrary, these languages are being developed by their users who have only one end goal get the job done, quickly As a result the languages are constantly evolving often adding significant enhancements in minor releases. With the rapid changes in how modern Web applications are being built and deployed this agile nature is a must-have to keep up with the latest trends.

In addition, the LAMP deployment paradigm has significant advantages. By featuring a multi-process architecture, faults in the Web Server and dynamic language software will typically not lead to sites going down. While one process may crash all other processes serving Web requests will continue running. This is in contrast to multi-threaded environments like the JVM (Java Virtual Machine, Java's execution environment) where software faults including crashes and deadlocks will typically lead to system down situations. In addition, the ability to recycle processes after a set time will prevent memory leaks and memory fragmentation, two common software memory problems, from degrading the system efficiency over time. Another key advantage LAMP developers enjoy is the easy deployment paradigm. Software updates can easily and incrementally be pushed out to LAMP servers without requiring prolonged build and packaging processes. While this may lead to unorthodox and sometimes too lax of a process, when done correctly it makes the lives of the developers and the operations personnel much easier.

While LAMP's growth was fueled by many of these development and deployment advantages, the Java vendors were stuck with the JVM which was very closely aligned to the Java language and had little support for targeting multiple languages. Instead of shifting towards a loosely coupled model of LAMP technology and Java technology in order to deliver the best of both worlds to their customers, most hesitated to lose control over the customer's workload and entered an arms race to deliver dynamic languages on top of the JVM. With Microsoft on one side and the Java competitors on the other, each vendor set out to develop their own dynamic languages strategy.

Today Sun is investing in JRuby (Ruby) and Jython (Python) support for its Java EE solution; the IBM Websphere group has realized the ineffectiveness of the Java EE platform for running modern Web workloads and has invested heavily in Project Zero which aims to make big blue a Web 2.0 player and initially delivers support for Groovy and PHP; BEA has also had some incubation projects going but with the upcoming sale to Oracle it is unclear whether any of those efforts will materialize. Project Zero's Chief Architect is one of the first IBMers to admit in public that Java today can be considered as a system language and is not desirable for building RESTful Web applications which is Project Zero's goal (slide #4 of the presentation- see slide #11 to see how a simple "Hello, World" in Java compares to dynamic languages like Groovy and PHP). It has taken over 10 years for the Java stronghold to admit Java's poor ROI on the Web and with the current recession it is likely that many Java customers are going to be making more informed investments. As a result there will be considerable rise in uptake of dynamic languages. Similar to the mainframe Java is heavily entrenched in enterprise IT and business-critical applications and is therefore not going away. That said for fueling modern Web applications the Java language will likely see a steep decline in market share.

The question to be asked is whether the non-Microsoft Web market will buy into the JVM implementations of dynamic languages or whether they will move to the LAMP stack which hosts the de-facto standards for the most popular languages. While I believe there will be customers who are attracted to the JVM implementations especially the ones who are heavily influenced by their relationships with the Java companies, the majority of the market is going to prefer to go down the route of the LAMP stack. Reasons include:

The popular dynamic languages are all backed by very vibrant developer communities and are constantly evolving and adapting. The JVM ports of these languages will always lag behind the community driven de-facto standards implementation and therefo re compatibility will be an issue. This is very similar to the problems the Mono community has in keeping up with .NET and this is even after help they get from Microsoft.
The JVM was not originally designed to host dynamic languages. For the foreseeable future the vendors will have significant challenges in keeping up with real-world use-cases. While they may show good performance in synthetic benchmarks such as fo r loops where JVMs are often superior in real world scenarios they will likely be impaired due to the dynamic nature of these languages which include closures, indirect method calls and a significant amount of type juggling. See an example of how JRuby c ompares to Ruby's current C implementation. Also, we have to consider whether it's truly in the hardware vendors interest to pursue the most optimized runtimes. With open-source community driven technologies the answer is clear.
The scalability requirements of the modern Web will require an increasing amount of processing density on the Web tier. C-based architectures are much more likely to be able to deliver the highest possible density by most efficiently interfacing w ith the operating system primitives and by delivering efficient, small foot print architectures. Such examples include high-performance Web Servers such as lighttpd, Zeus, IIS 7; high-performance caching systems such as memcached which is used by some of the largest Web sites including Facebook; and other performance critical subsystems such as memory management.
Multi-core systems work very well with the LAMP stack's multi-process paradigm. With the chip industry now focusing primarily on multi-core as opposed to hyper-threading technology, the benefits of multi-threaded environments such as the JVM are n ot substantially realized on today's hardware. Instead the multi-process paradigm delivers more stability and reliability.
Due to its simplicity, the LAMP stack delivers a very low barrier to entry for developers while still delivering the scalability of large scale production systems such as Yahoo! and Facebook.

In conclusion, it is becoming clear that dynamic languages are going to increasingly become the standard for Web development. Microsoft and the Java vendors have all recognized this trend and are now aggressively pursuing solutions on top of their software stacks. However, as the core dynamic language communities thrive outside of the .NET CLR and Java JVM software stacks the vendors will be in a challenging position if they solely depend on the uphill battle of cloning the successful dynamic languages onto their software stacks. Some vendors are aware of this challenge and have built hybrid strategies which also aim to deliver the de-facto standard dynamic languages to their customers even if they don't have full synergy with their solution stack, this includes Microsoft's investment in making PHP work with their solution stack and Sun's initial attempts to deliver native Ruby and PHP implementations to their customer base. I believe that while the JVM approach to dynamic languages may appeal to some Java customers it will never be able to catch up with the broader open-source movement around native dynamic languages implementations. The JVM dynamic languages implementations will not be enough for the Java vendors to catch up and they will need to embrace the native de-facto standard community driven dynamic languages.

posted by Andi Gutmans @ 3/24/2008 11:07:00 AM

URL

64-bit OS vs 32-bit browser

We have detected you may be viewing this page in a 32-bit browser. If you use 32-bit and 64-bit browsers interchangeably, you will need to install both 32-bit and 64-bit Java in order to have the Java plug-in for both browsers.

Verify installed Java

Top

Java GUI development using Eclipse

raw : red / blue score sample
"designer" plugin, *** not complete
visual editor {developerworks}
Jigloo - sample : read at button + write ;
WindowBuilder (eclipse)
Visual Swing
eHecht

from here

Estupideses

Class names, 'HelloWorld', are only accepted if annotation processing is explicitly requested

You forgot to include the .java suffix when compiling the program. Remember, the command is "javac HelloWorldApp.java" not "javac HelloWorldApp"

Error: Could not find or load main class my.samples.SimplePTP

El fitxer es diu SimplePTP i dintre porta

package my.samples ;

java.lang.NoClassDefFoundError

Add the location of your .class file to your classpath

java -cp . NomFitxerClass {sense extensio}

Top

Jython

Jython script to create a server, file create_server.py

#-------------------------------------------# import sys,java from java.util import Properties from java.io import FileInputStream from org.python.modules import time lineSep = java.lang.System.getProperty('line.separator') def server_create(node,server): node=AdminConfig.getid('/Node:'+node+'/') attr=[['name', server]] print "creating server .." AdminConfig.create('Server',node,attr) print "server created .." AdminConfig.save() print "saving config .." arglen=len(sys.argv) number_of_argument=2 if ( arglen != number_of_argument): print "pass 2 arguments .." sys.exit(-1) server=sys.argv[0] node=sys.argv[1] server_create(node,server) #----------------------------------------#

Execute it using wsadmin:

./wsadmin.sh -f create_server.py -lang jython -port 8879 -conntype SOAP -user wasadmin -password wasadmin test_server test_node

Jython Script to check the status of listener ports of all servers of cluster

lineSeparator = java.lang.System.getProperty('line.separator') clusterName='CLUSTER_NAME' cId = AdminConfig.getid("/ServerCluster:"+ clusterName +"/" ) cList = AdminConfig.list("ClusterMember", cId ).split(lineSeparator) for sId in cList: server = AdminConfig.showAttribute(sId, "memberName" ) node = AdminConfig.showAttribute(sId, "nodeName" ) cell = AdminControl.getCell() s1 = AdminControl.completeObjectName('cell='+ cell +',node='+node +',name='+ server +',type=Server,*') if len(s1) > 0: print server + " state is started" else: print server + " is down" print "Server " + server + " has the following Listener Ports" lPorts = AdminControl.queryNames('type=ListenerPort,cell='+ cell+',node='+ node +',process='+ server +',*') lPortsArray = lPorts.split(lineSeparator) for lPort in lPortsArray: lpcfgId = AdminControl.getConfigId(lPort) lpName = AdminConfig.showAttribute(lpcfgId, "name") lpstate = AdminControl.getAttribute(lPort, 'started') if lpstate == 'true': print lpName + " is started " else : print lpName + " is stopped " print ""

Dubtes, temes pendents

quina es la estructura de un programa Java ?
Com es fa per a que corri com un Applet ? public class JMSTestApplet extends javax.swing.JApplet
Com es fa per a que corri as an Application ? public static void main(java.lang.String[] args)
Vull tenir un programa Java que, en premer un boto, llegeixi ho escrit en un camp (del browser/finestra propia) i ho posi en un altre camp (idem)

Links

download last Java (6.31 @ 28032012) ; manual (7.5, 20 MB, 20120709) ;
Java documentation [***] and tutorial (oracle)
download Verify
The Java EE 5 Tutorial & 2 case studies {****}
IBM intro
Como crear una aplicación con Java y Eclipse
Good links (classificats)
Good Recommended reading list J2EE and WebSphere Application Server [*****]
Impresionante : Magic Cube [no source]
Garbage collector - GC
- Eye on performance: Trash talk
- Eye on performance: Tuning garbage collection in the HotSpot JVM
url
Free Java (no source)
JSP Best Practices [***]
JSP pages for beginners
J2EE Tutorial - pdf - [\\Java\LlibresJAVA\J2EETutorial.pdf] 15 MB !
Java CLASSPATH details. CLASSPATH tutorial. CLASSPATH problems.
Identifying classpath conflicts & A general tool for resolving classpath questions
What was needed was a simple, non-intrusive way to ask a running WebSphere instance from what JAR file a particular class was being loaded at run time
\\Java\Classpath_Problems
Developer's Reference
Java game : NetHack
Curs de programació en Java (+ curs de Física + "procedimientos numéricos" )
Curs Introduction to Scientific and Technical Computing with Java Clark S. Lindsey, Octubre 2005. [24 capitols]
Java applets de física
Java puzzle : cariatides
Java programming warnings
Java on Linux tutorial. (lots of links)
Java en castellano + código, etc
AIX JDK 1.3.1 for POWER (sembla interessant)
Soluciona el cub de'n Rubik Online
Verify the Java installation, es es.
Java 1 .. 5
Introduccion al AOP - Java en castellano. Versió original
Azul Virtual Machine (AVM), ... to 670 GB of memory and hundreds of processor cores
I love Java (youtube)
5 things you didn't know about ... Command-line flags for the JVM ; everyday Java tools ;
Article Java vs LAMP
que és un fitxer JNLP : jnlp_href:'http://cssjs.chesscomfiles.com/assets/java/vscomp/ChessApplet.jnlp' @ chess.com
Previous page
Tinet
Back to main page
Site map
Escriu-me !

BPEL	Business Process Execution Language
EAR	Enterprise Archive (JAR = Java Archive, WAR = Web Archive)
EJB	Enterprise JavaBeans [url]
J2EE	Java 2 Enterprise Edition (rival to .NET)
JDB	Java Debugger
JNDI	Java Naming and Directory Interface
MDB	Message Driver Bean
POJO	Plain Old Java Object
SOAP	Simple Object Access Protocol
XML	data type for Java
WSDL	Web Service Definition Language - url

Java and me

Applet's

Servlet's

Domino

Sigles, etc

Snoop

Cridem a un JAVA des un JSP

RedBooks

Versions : JDK, .JAR ...