Java PDF Books

Mac OS X for Java Geeks delivers a complete and detailed look at the Mac OS X platform, geared specifically at Java developers. The book begins by laying out the Mac OS X tool set, from the included Java Runtime Environment to third-party tools IDEs and Jakarta Ant. You'll then be brought up to speed on the advanced, Mac-specific extensions to Java, including the spelling framework, speech framework, and integration with QuickTime. In addition to clear explanations of these extensions, you'll learn how to write code that falls back to non-Mac specific code when it runs on other platforms, keeping your application portable. Once you have the fundamentals of the Mac OS X Java platform in hand, this book takes you beyond the basics. You'll learn how to get the Apache web server running, and supplement it with the Jakarta Tomcat JSP and servlet container. JSPs and servlets running on Mac OS X are covered, as is installation and connectivity to a database. Once you have your web applications up and running, you'll learn how to interface them with EJBs, as running the JBoss application server on Mac OS X is covered. Finally, the latest developments in web services, including XML-RPC and SOAP, are found within.

Eclipse and the Rich Client Platform (RCP) together form a leading development platform. It provides a lightweight software component framework based on plug–ins. In addition to allowing Eclipse to be extended using other programming languages, it provides the key to the seamless integration of tools with Eclipse. The RPC gives Eclipse its modularity: Eclipse employs plug–ins in order to provide all of its functionality on top of (and including) the RCP, in contrast to some other applications where functionality is typically hard–coded. RCP apps are platform independent: they can be built for all major operating systems such as Windows, Linux, and Mac from a single code base. And the RCP provides a professional look and feel for applications.

Practical Eclipse Rich Client Platform Projects is a clear and technical guide for Eclipse developers to help them enhance their knowledge and achieve their goals quickly.

• The book explains the technical concepts easily and in an engaging way.
• The text provides plenty of source code and images as learning aids.
• Several practical projects and case studies are included.

What you’ll learn

• Understand RCP basics, architecture, and foundations.
• Use and incorporate plug–ins with Eclipse.
• Design and develop user interface components and work with the Eclipse FormsAPIs.
• Add and integrate 2D graphics using the Graphical Editing Framework.
• Build professional–looking and functional reports with Eclipse BIRT.
• Create visually more dynamic 3D graphics by incorporating OpenGL into Eclipse.
• Add help support and automated updates via the Update Manager.

Who is this book for?

The primary audience of this book will be developers and software engineers involved in user interface development with the Eclipse platform. Also, this book will be valuable to scientists, students, practitioners, and all those interested in multiplatform user interface development.

Soon after its launch, Ant succeeded in taking the Java world by storm, becoming the most widely used tool for building applications in Java environments. Like most popular technologies, Ant quickly went through a series of early revision cycles. With each new version, more functionality was added, and more complexity was introduced. Ant evolved from a simple-to-learn build tool into a full-fledged testing and deployment environment. Ant: The Definitive Guide has been reworked, revised and expanded upon to reflect this evolution. It documents the new ways that Ant is being applied, as well as the array of optional tasks that Ant supports. In fact, this new second edition covers everything about this extraordinary build management tool from downloading and installing, to using Ant to test code. Here are just of a few of the features you'll find detailed in this comprehensive, must-have guide:

• Developing conditional builds, and handling error conditions
• Automatically retrieving source code from version control systems
• Using Ant with XML files
• Using Ant with JavaServer Pages to build Web applications
• Using Ant with Enterprise JavaBeans to build enterprise applications

Far exceeding its predecessor in terms of information and detail, Ant: The Definitive Guide, 2nd Edition is a must-have for Java developers unfamiliar with the latest advancements in Ant technology. With this book at your side, you'll soon be up to speed on the premiere tool for cross-platform development. Author Steve Holzner is an award-winning author who s been writing about Java topics since the language first appeared; his books have sold more than 1.5 million copies worldwide.

It takes a book as versatile as its subject to cover Apache Tomcat, the popular open source Servlet and JSP container and high performance web server. Tomcat: The Definitive Guide is a valuable reference for administrators and webmasters, a useful guide for programmers who want to use Tomcat as their web application server during development or in production, and an excellent introduction for anyone interested in Tomcat. Updated for the latest version of Tomcat, this new edition offers a complete guide to installing, configuring, maintaining and securing this servlet container. In fact, with such a wealth of new information, this is essentially a new book rather than a simple revision. You will find details for using Tomcat on all major platforms, including Windows, Linux, OS X, Solaris, and FreeBSD, along with specifics on Tomcat configuration files, and step-by-step advice for deploying and running web applications. This book offers complete information for: Installation and startup procedures Configuring Tomcat-including realms, roles, users, servlet sessions, and JNDI resources including JDBC DataSources Deploying web applications-individual servlets and JSP pages, and web application archive files Tuning Tomcat to measure and improve performance Integrating Tomcat with Apache Web Server Securing Tomcat to keep online thugs at bay Tomcat configuration files-server.xml and web.xml, and more Debugging and Troubleshooting-diagnosing problems with Tomcat or a web application Compiling your own Tomcat, rather than using the pre-built release Running two or more Tomcat servlet containers in parallel This book also offers an overview of the Tomcat open source project's community resources, including docs, mailing lists, and more. Community interest fueled a strong demand for a Tomcat guide from O'Reilly. The result clearly exceeds expectations.

About the Author
Jason Brittain is a Senior Principal Software Engineer for Orbital Sciences Corporation, working at NASA's Ames Research Center on the Kepler Space Telescope mission (http://kepler.nasa.gov).

Jason is a co-author of Tomcat: The Definitive Guide, now in its second edition, and has written some web articles for O'Reilly's OnJava.com web site.

Before joining the team on the Kepler mission, Jason was a Senior Software Engineer at Symantec Corporation working on the Brightmail AntiSpam appliance product line's control center web application.

Jason's specialties include Java software development, Tomcat web application development and deployment, scalability and fault tolerance, and Apache Ant build systems, and Linux system administration. He has contributed to many Apache Jakarta projects, and has been an active open source software developer for several years.

"Every developer working with the Web needs to read this book." -- David Heinemeier Hansson, creator of the Rails framework "RESTful Web Services finally provides a practical roadmap for constructing services that embrace the Web, instead of trying to route around it." -- Adam Trachtenberg, PHP author and EBay Web Services Evangelist You've built web sites that can be used by humans. But can you also build web sites that are usable by machines? That's where the future lies, and that's what RESTful Web Services shows you how to do. The World Wide Web is the most popular distributed application in history, and Web services and mashups have turned it into a powerful distributed computing platform. But today's web service technologies have lost sight of the simplicity that made the Web successful. They don't work like the Web, and they're missing out on its advantages. This book puts the "Web" back into web services. It shows how you can connect to the programmable web with the technologies you already use every day. The key is REST, the architectural style that drives the Web. This book: Emphasizes the power of basic Web technologies -- the HTTP application protocol, the URI naming standard, and the XML markup language Introduces the Resource-Oriented Architecture (ROA), a common-sense set of rules for designing RESTful web services Shows how a RESTful design is simpler, more versatile, and more scalable than a design based on Remote Procedure Calls (RPC) Includes real-world examples of RESTful web services, like Amazon's Simple Storage Service and the Atom Publishing Protocol Discusses web service clients for popular programming languages Shows how to implement RESTful services in threepopular frameworks -- Ruby on Rails, Restlet (for Java), and Django (for Python) Focuses on practical issues: how to design and implement RESTful web services and clients This is the first book that applies the REST design philosophy to real web services. It sets down the best practices you need to make your design a success, and the techniques you need to turn your design into working code. You can harness the power of the Web for programmable applications: you just have to work with the Web instead of against it. This book shows you how.

Published with the developer in mind, firstPress technical briefs explore emerging technologies that have the potential to be critical for tomorrow's industry. Apress keeps developers one step ahead by presenting key information as early as possible in a PDF of 150 pages or less. Explore the future through Apress...

Mule 2: A Developer’s Guide introduces the Mule 2.0 integration platform for developers of enterprise integration applications who wish to leverage the latest Mule as a lightweight messaging framework that contains a distributable object broker for managing communication between applications.

• The book is based on insight, knowledge, and experience resulting from working with Mule.
• The text provides support, consulting, and training to developers implementing Mule in a broad range of scenarios ranging from small projects through to large corporations developing major deployments.
• The author(s) have also developed the official training materials for Mule.

What you’ll learn

The Java Message Service (JMS) provides a way for the components of a distributed application to talk asynchronously, or for welding together legacy enterprise systems. Think of it as application-to-application e-mail. Unlike COM, JMS uses one or more JMS servers to handle the messages on a store-and-forward basis, so that the loss of one or more components doesn't bring the whole distributed application to a halt.

JMS consists of a set of messaging APIs that enable two types of messaging, publish-and-subscribe (one-to-many) and point-to-point (one-to-one). The highly lucid explanation of the ways in which these work makes the technical content a lot more approachable. In practice, however, Java Message Service is still a book for Java programmers who have some business programming experience. You need the background.

After a simple JMS demonstration in which you create a chat application using both messaging types, the authors dissect JMS message structures, explore both types in detail, and then move on to real-world considerations. These include reliability, security, deployment, and a rundown of various JMS server providers. The appendices list and describe the JMS API, and provide message reference material.

Considering the complexity and reach of the subject matter, Java Message Service does a great job of covering both theory and practice in a surprisingly efficient manner. It's easy to see why JMS has become so popular so quickly. Recommended. --Steve Patient, Amazon.co.uk --This text refers to the Paperback edition.

Product Description
Java Message Service, Second Edition, is a thorough introduction to the standard API that supports "messaging" -- the software-to-software exchange of crucial data among network computers. You'll learn how JMS can help you solve many architectural challenges, such as integrating dissimilar systems and applications, increasing scalability, eliminating system bottlenecks, supporting concurrent processing, and promoting flexibility and agility. Updated for JMS 1.1, this second edition also explains how this vendor-agnostic specification will help you write messaging-based applications using IBM's MQ, Progress Software's SonicMQ, ActiveMQ, and many other proprietary messaging services. With Java Message Service, you will:

Build applications using point-to-point and publish-and-subscribe messaging models Use features such as transactions and durable subscriptions to make an application reliable Implement messaging within Enterprise JavaBeans (EJB) using message-driven beans Use JMS with RESTful applications and with the Spring application framework

Messaging is a powerful paradigm that makes it easier to uncouple different parts of an enterprise application. Java Message Service, Second Edition, will quickly teach you how to use the key technology that lies behind it.

At any given moment, somewhere in the world someone struggles with the same software design problems you have. You know you don't want to reinvent the wheel (or worse, a flat tire), so you look to Design Patterns--the lessons learned by those who've faced the same problems. With Design Patterns, you get to take advantage of the best practices and experience of others, so that you can spend your time on... something else. Something more challenging. Something more complex. Something more fun.

You want to learn about the patterns that matter--why to use them, when to use them, how to use them (and when NOT to use them). But you don't just want to see how patterns look in a book, you want to know how they look "in the wild". In their native environment. In other words, in real world applications. You also want to learn how patterns are used in the Java API, and how to exploit Java's built-in pattern support in your own code.

You want to learn the real OO design principles and why everything your boss told you about inheritance might be wrong (and what to do instead). You want to learn how those principles will help the next time you're up a creek without a design paddle pattern.

Most importantly, you want to learn the "secret language" of Design Patterns so that you can hold your own with your co-worker (and impress cocktail party guests) when he casually mentions his stunningly clever use of Command, Facade, Proxy, and Factory in between sips of a martini. You'll easily counter with your deep understanding of why Singleton isn't as simple as it sounds, how the Factory is so often misunderstood, or on the real relationship between Decorator, Facade and Adapter.

With Head First Design Patterns, you'll avoid the embarrassment of thinking Decorator is something from the "Trading Spaces" show. Best of all, in a way that won't put you to sleep! We think your time is too important (and too short) to spend it struggling with academic texts.

If you've read a Head First book, you know what to expect - a visually-rich format designed for the way your brain works. Using the latest research in neurobiology, cognitive science, and learning theory, Head First Design Patterns will load patterns into your brain in a way that sticks. In a way that lets you put them to work immediately. In a way that makes you better at solving software design problems, and better at speaking the language of patterns with others on your team.

For web developers used to wrestling with Java and XML, Grails is a breath of fresh air. Developers are instantly productive, picking up all the benefits of the Ruby-based Rails framework without giving up any of the power of Java.

Grails in Action is a comprehensive look at Grails for Java developers. It covers the nuts and bolts of the core Grails components and is jam-packed with tutorials, techniques, and insights from the trenches.

The book starts with an overview of Grails and how it can help you get your web dev mojo back. Then it walks readers through a Twitter-style social networking app-built in Grails, of course-where they implement high-interest features like mashups, AJAX/JSON, animation effects, full text search, rounded corners, and lots of visual goodness. The book also covers using Grails with existing Java technology, like Spring, Hibernate, and EJBs.

A brief overview about MockEJB. You can Download MockEJB Here!

What is MockEJB?

MockEJB is a lightweight framework for running EJBs. MockEJB implements javax.ejb APIs and creates Home and EJBObject implementation classes for your EJBs. Internally, MockEJB relies on dynamic proxies and interceptors. MockEJB has two primary usages: 

• It allows for running EJBs outside of the container for unit testing.You can run EJBs directly from your favorite IDE with the minimal setup effort. 

• It allows for deploying mock EJBs (i.e., mock EJB implementation classes) into the container. Mock EJBs provide very effective way of isolating EJBs under test from the rest of the application. Mock EJBs return predefined test data and can override the actual "non-mock" deployed EJBs. Once again, the purpose of MockEJB is twofold and it works inside and outside of the container. So you can benefit from it even if you continue running all your test classes inside the container using Cactus. 

Additionally, MockEJB comes with the "mock" implementation of non-EJB APIs. Currently it provides in-memory JNDI and JMS implementations which can be used independently from MockEJB's EJB support. MockEJB is not a full-blown EJB container. It does not fully implement J2EE/EJB specs, however it supports all vital APIs. 

What are the advantages of running EJBs outside of the container?

Deploying EJBs into a container oftentimes becomes a complex operation requiring to run custom scripts and proprietary deployment tools. On the other hand, EJBs are the key components of J2EE applications and usually expose important application APIs/interfaces that must be properly tested. So it is desirable to be able to edit/compile/run EJBs directly from IDE and avoid costly redeployments into the container. This is especially true if you follow test-driven development practice in which case quick edit/compile/run cycle is a must. Therefore, the main advantage of testing outside of the container is the improved developers productivity and the quality of the tests. 

How MockEJB is better than instantiating and invoking a bean (Impl) class directly?

MockEJB allows you to test EJBs that: 

• Rely on JNDI. 

• Call other EJBs. 

• Have logic in ejbCreate/ejbRemove methods. 

• Use EJBMetaData, SessionContext and other javax.ejb APIs. 

• Need container-managed transaction support. 

• Rely on container's CMP services. 

What are the advantages of using mock EJBs?

J2EE applications usually are pretty complex, they consist of multiple layers and modules. This means that any given EJB may depend on a number of other EJBs. So, to be able to test an EJB efficiently, one needs a strategy of isolating the EJB under test from the rest of the application by minimizing its dependencies on other parts of the application that are not in scope of the test. 

MockEJB framework gives you the ability to replace these out of scope EJBs with the classes returning data suitable for your test. Therefore, the changes in the other parts of the application won't affect the functionality of your test. 

MockEJB framework creates mock EJBs in such a way that they only exist for the duration of the test. In other words, mock EJBs don't affect the actual "non-mock" EJBs already deployed in the container. 

Mock EJBs also allow you to write tests for non-EJB classes that have dependencies on EJBs (e.g., Struts action classes). You can run these tests with or without the container. Isn't EJB technology complex? How can it be implemented by a lightweight framework? EJBs are simple if you just want to run them for the purpose of testing your business logic. In this case, the support for numerous features defined by EJB spec is not really needed. You probably don't care too much about instance pooling, proper EJB lifecycle and clustering support when you just want to run your test and see if it passed. This is the key design principle of MockEJB. It only focuses on what's relevant for unit testing and it leaves true enterprise-strength EJB support to the J2EE application server vendors. 

What EJB capabilities are currently supported?

• Stateless and stateful session beans. 

• Local and remote interfaces. 

• Message-driven beans with the ability to deploy to mock JMS destinations. 

• EJBMetaData. 

• EJBContext. 

• Container-managed transactions. 

• Exception handling. 

• CMP and BMP entity beans (with some limitations).

• Security (with limitations). 

What EJB capabilities are not currently supported ?

• Some methods on EJBObject/EJBLocalObject. 

• SessionSynchronization interface. 

• Handles. 

While only a subset of EJB spec is supported, you can always extend MockEJB using interceptors.

The EasyMock project provides a library that simplifies the use of Mock Objects in interfaces. Unit testing is the testing of software units in isolation. However, most units in real world production environments do not work alone, but rather in collaboration with other units. To test a unit in isolation, we have to simulate the collaborators in the test. A Mock Object is a test-oriented replacement for a collaborator configured to simulate the object it replaces. In contrast to a stub, a Mock Object can also verify whether it has been used as expected.

EasyMock was the first dynamic Mock Object generator, relieving the need for users to hand-write Mock Objects, or generate code for them.

EasyMock generates Mock Objects on the fly using Java's proxy mechanism. Due to EasyMock's unique style of recording expectations, most refactorings will not affect the Mock Objects. This makes EasyMock a perfect fit for Test-Driven Development.

You can download EasyMock Here!

Apache ActiveMQ is the most popular and powerful open source Enterprise Messaging and Integration Patterns provider.

Apache ActiveMQ is fast, supports many Cross Language Clients and Protocols, comes with easy to use Enterprise Integration Patterns and many advanced features while fully supporting JMS 1.1 and J2EE 1.4. Apache ActiveMQ is released under the Apache 2.0 License

Grab yourself a Download, try our Getting Started Guide, surf our FAQ or start Contributing and join us on our Discussion Forums.

Features:

• Supports a variety of Cross Language Clients and Protocols from Java, C, C++, C#, Ruby, Perl, Python, PHP
  • OpenWire for high performance clients in Java, C, C++, C#
  • Stomp support so that clients can be written easily in C, Ruby, Perl, Python, PHP, ActionScript/Flash, Smalltalk to talk to ActiveMQ as well as any other popular Message Broker
• full support for the Enterprise Integration Patterns both in the JMS client and the Message Broker
• Supports many advanced features such as Message Groups, Virtual Destinations, Wildcards and Composite Destinations
• Fully supports JMS 1.1 and J2EE 1.4 with support for transient, persistent, transactional and XA messaging
• Spring Support so that ActiveMQ can be easily embedded into Spring applications and configured using Spring's XML configuration mechanism
• Tested inside popular J2EE servers such as Geronimo, JBoss 4, GlassFish and WebLogic
  • Includes JCA 1.5 resource adaptors for inbound & outbound messaging so that ActiveMQ should auto-deploy in any J2EE 1.4 compliant server
• Supports pluggable transport protocols such as in-VM, TCP, SSL, NIO, UDP, multicast, JGroups and JXTA transports
• Supports very fast persistence using JDBC along with a high performance journal
• Designed for high performance clustering, client-server, peer based communication
• REST API to provide technology agnostic and language neutral web based API to messaging
• Ajax to support web streaming support to web browsers using pure DHTML, allowing web browsers to be part of the messaging fabric
• CXF and Axis Support so that ActiveMQ can be easily dropped into either of these web service stacks to provide reliable messaging
• Can be used as an in memory JMS provider, ideal for unit testing JMS

Do you know Java?
If Yes --> Answer my Questions?

1. Do you know Collections?
2. Do you know Generics?
3. Do you know Reflection?

If any one of three is NO you don't know java. Don't worry. I will help read through this book.

Every day we work directly or indirectly with java threads. This pdf will give great internals of Java Threads. Read, create, run, notify, wait, Explore and don't destroy :)

We all do some java. Its good to know some reflection to test program behavior. This pdf will walk through in and out of Java Reflection.

Java -- Don't want to say more about it. But Flex concentrating bit :) This PDF gives you great exposure to Java and Flex Integration. This is a 2009 Version. If you are reading this post after 2009 get out of here right now!... do some hell search for the latest one.