|
Best Practices to improve performance in EJB
As a developer, you need not write infrastructure code for these services, rather vendors provide EJB container/server that support all these services. You simply use these services without writing any code for them. But all these services do not come for free , they are expensive and come with a price. So before writing an application you need to carefully look into all the aspects for optimum use of your resources and calculate the tradeoffs involved.
|
|
Building J2EE Applications for performance and scalability
The highly structured nature of applications built using J2EE technologies lends itself well to design patterns for performance optimization. This article examines a number of such patterns and suggests optimal ways of using them to improve latency, throughput, and overall scalability of J2EE applications.
|
|
Designing Entity Beans for Improved Performance
If you've done any work with Enterprise JavaBeansTM components, and particularly if you have used entity beans to model persistent data in a database, then you are most likely aware of the network performance overhead that can come with entity bean usage.
|
|
WebSphere Application Server WebSphere Development Best Practices for Performance and Scalability
If you've done any work with Enterprise JavaBeansTM components, and particularly if you have used entity beans to model persistent data in a database, then you are most likely aware of the network performance overhead that can come with entity bean usage.
|
|
Extreme Performance Tuning
The performance of J2EE-based applications sometimes doesn't live up to users' expectations. Usually it's impossible to quantify exactly where the bottlenecks are. Many developers spend time searching for articles on the Internet only to find the same old tips about using the synchronized keyword and string concatenation without ever finding information that's useful. This article will help you find the holy grail of Java performance.
|
|
The Key to Supperior EJB Design
Over the past several years EJB technology has entered the software development mainstream. This new level of recognition and greater popularity brings an increase in design activities in the EJB space, such as best practices and design patterns.
|
|
Design Patterns for Building Flexible
and Maintainable J2EETM Applications
With the proliferation of JavaTM 2 Enterprise Edition (J2EETM) as a platform of choice for server-side applications, it is crucial for developers to share their experiences and designs. This article introduces some reusable designs you can use to build flexible and easily maintainable J2EE applications.
|
|
Why Choose a CMP Architevcture ?
First, let's talk about the scenarios where BMP is appropriate for use in an entity EJB system.
|
|
J2EE design patterns
Improve performance and manage complexity with enterprise design patterns from Sun
Mark Johnson and Inderjeet Singh presented a conference session on J2EE design patterns. Here's a rundown of the main patterns discussed, including descriptions of situations in which each pattern should be used. (
|
|
Design Patterns for Optimizing the Performance of J2EE Applications
With the proliferation of J2EETM as the platform of choice for server-side applications, the need for sharing developers' experiences and the availability of reusable designs has become crucial.
|
|
Java Tip 78: Recycle broken objects in resource pools
Many distributed (and some local) Java systems use resource pooling to improve performance. Resource pools may also be used when object resources are scarce and objects need to be shared between a number of clients. In this article, Philip and Nigel examine some of the issues involved in using resource pools and develop the recycler idiom, which is used to manage broken complex resources in an object pool. Using recyclers can improve the longevity and performance of Java server systems, for example, where robustness is a key design issue.
|
|
Rules and Patterns for Session Facades
In the past couple of years Enterprise JavaBeans™ (EJBs) have really started to make an impact in the Java™ object design space. During this time, one of the most common EJB patterns that we have seen employed is the notion of a Session Facade. This is a very powerful and simple notion, and one that has been beneficial to a large number of developers. However, I have also seen that there are a number of misconceptions about exactly what this pattern means, and a great deal of misunderstanding about how it should be applied in practice.
|
|
EJB Benchmark
As developers of EJB applications, we are often faced with the question of what architecture or design to use. There is no shortage of proposed and touted architectures and designs out there. We can use fine grained entity beans, coarse grained entity beans, entity beans with a session bean front end, and even stateless session beans to access our data. Lacking any hard data on which we can base our decision, we are often forced to rely on claimed best practices and pure marketing hype.
|
|
Stress Testing J2EE Applications with WEBLogic
How to Stress test J2EE Applications
|
|
Designing Entity Beans for Improved Performance
If you've done any work with Enterprise JavaBeansTM components, and particularly if you have used entity beans to model persistent data in a database, then you are most likely aware of the network performance overhead that can come with entity bean usage.
|
|
Seven Rules for Optimizing Entity Beans
Entity beans provide a clear model to represent persistent business objects in applications and their design. In object models, simple JavaTM objects are normally represented in a straightforward way, but do not include the transactional persistence management functionality usually required for business objects.
|
|
THE ECPERFTM, J2EETM SERVER PERFORMANCE AND SCALABILITY WORKLOAD
The computer software industry has come a long way with the JavaTM 2 Platform, Enterprise Edition (J2EETM) architecture, Enterprise JavaBeansTM (EJBTM) components technology, and all related specifications and technologies. The industry now has real products in the market, supporting these current specifications.
|
|
ENTERPRISE JAVABEANSTM
PERFORMANCE: We're On It!
The design center for Enterprise JavaBeansTM (EJBTM) technology and the JavaTM 2 Platform, Enterprise Edition (J2EETM) is transactional, scalable, distributed server-side reusable components. The business app or bean developer benefits from the EJB architecture value-add in ways that are absent from more traditional approaches to distributed programming.
|
|
Direct network traffic of EJBs
Within a single virtual machine instance, all client-to-EJB communication takes place through a single socket connection, causing network traffic to stall. The technique that Thomas Davis describes for you in this article -- encapsulating your EJB's properties into a serializable object -- can buy you a performance gain and clean encapsulation
|
|
Reduce EJB network traffic with astral clones
Use the bean implementation outside the container to avoid remote calls
The Java 2 Platform, Enterprise Edition specifies the Java community's standard for enterprise distributed computing. Included in this standard are Enterprise JavaBeans (EJB), which provide a set of programming rules and standard interfaces to build business objects. You can deploy these objects in an application server that you don't have to build yourself.
|
|
Unlocking the True Power of Entity EJBs
I've heard too much debate in the application developer community about how flawed the entity EJB model is, and that its performance isn't on par with a stateless session EJB (SLSB). I've sat, listened, and watched the debates. The conversations center around performance, the meaning of distributed component architecture, the relevance of JDO, the cumbersome nature of EJBs, and on and on. And through all of this, my concerns for the community grew, as no one was touting the real reasons entity EJBs are monstrously powerful. I told myself that they must see it -- that it should be clear -- but I still pondered, as the community seemed to be blinded to the true power of entity EJBs.
|
|
Balancing Network Load with Priority Queues
A recent project I was working on required control of lighting zones via a web interface. The final system had to control up to 4000 zones, either by a web GUI or time clock located in the server. Users of the web GUI had to be able to turn lights on/off, or select a lighting level between 1 and 100 percent. The time clock provided events to turn all the lights off at the end of the workday, then on again the next morning.
|
|
Six Common Enterprise Programming Mistakes
Instead of giving you tips to use in your programming (at least directly), I want to look at some common mistakes made in enterprise programming. And instead of focusing on what to do, I want to look at what you should not do.
|
|
WebLogic Server Performance Tuning Guide
This document contains information on how to tune the WebLogic Server to match your application needs. Specifically, tips and instructions are provided that will allow you to configure different operating parameters of the WebLogic Server. Information on how to tune your application running on the WebLogic Server is also provided.
|
|
EJB-Based Services
Java Servlets and JavaServer Pages (JSP) threaten to collapse out there in the mud houses of server land. Developers succumb to the temptation to muddle their pages with complex business logic, and to fill behemoth proprietary libraries with data and subsystem access routines. We find stronger solutions in EJB-based architectures than in fattened JSPs, but molding existing sites into EJB-centric designs strikes most of us as a daunting and expensive task.
|
|
Best Practices for writing EJBs
JavaSoft defined the Enterprise JavaBeans specification to give Java developers a foundation for building distributed business components. EJBs are Java components that implement business logic and follow a contract designated in the EJB specification. Enterprise JavaBeans live inside an EJB container that provides a set of standard services, including transactions, persistence, security, and concurrency. This means that the application programmer is freed from developing these services from scratch.
|
|
EJB 2 Clustering with Application Servers
The Enterprise JavaBeans (EJB) component model is becoming the component framework of choice for enterprise development among Java developers. The EJB specification goes to great lengths to define characteristics that give containers the ability to manage transactions, persistence, environment variables, resource connections, and other infrastructure services.
|
|
J2EE Applications
J2EE applications are becoming the norm rather than the exception in today's distributed computing environment. But organizations are still facing the same issues with this technology set that they did with application models of yesteryear - how to ensure that they can scale quickly, respond dynamically, and maintain flexibility as their business environment changes.
|
|
Local Entity Beans and Relationships
As the EJB 2.0 specification has entered its final stage, many companies are in the process of building server-side J2EE applications. The final draft of the specification has made container-managed persistence (CMP) of entity beans complete and more powerful.
|