Book Description

BEA WebLogic Workshop is a rapid application development tool that makes building Java-based Web service applications simple.With just a basic foundation of Java programming, you can use WebLogic Workshop to develop Web services.BEA WebLogic Workshop Kick Start provides everything you need to get started with WebLogic Workshop, including a quick Java primer and appendixes covering the essentials of XML, SOAP and WSDL.Learn the features of WebLogic Workshop and review hundreds of code examples, and explore the inner workings of this new tool.

The book's CD-ROM contains all the source code and examples from the book, plus a 90-day trial version of BEA WebLogic Platform, which includes WebLogic Workshop.

Foreword

Web services have attracted much attention recently as the next "big thing" in computing technology. Vendors of all shapes and sizes have announced their support for Web services technologies, and every month a new Web services conference is popping up somewhere on the globe. With all this hype and attention, sometimes it's difficult to really discover what Web services are, where they fit in your company, what the business case is, and how you can actually get started taking advantage of this technology.

BEA has been working with customers to answer many of these questions, and provide solutions that enable companies to easily construct Web services that meet their needs today. Contrary to the common conception of Web services as a consumer-focused technology, Web services may have the greatest potential as a technology inside enterprises as a new way of tying disparate applications together using standards-based technologies. To make Web services really work in the enterprise, however, it's essential that they meet core enterprise requirements: Web services applications have to exist in a constantly changing IT environment where different applications are built and modified by different people on different schedules. They must accommodate everything from modern J2EE-based applications, to legacy systems, to applications at business partners. They must be able to handle rich and complex information and transmit it between internal and external applications. They must easily interact with other applications to leverage existing investments. They must be robust, reliable, and they must perform. Perhaps most important of all, they have to be easy to build. For Web services to flourish within an organization, all developers will need to be able to build Web services that meet these requirements.

BEA WebLogic Workshop Kick Start introduces you to BEA's new WebLogic Workshop product, a development tool and runtime framework that makes it easy to build powerful Web services that take advantage of the robust, enterprise features of the WebLogic J2EE application server. WebLogic Workshop provides a graphical tool that makes it easy to visualize, develop, and test Web service applications and visual controls that dramatically simplify access to existing resources like databases, packaged applications, Enterprise Java Beans, and other Web services. The Workshop framework provides out-of-the-box support for building Web services that are loosely coupled so that the internal implementation details of an application can be cleanly separated from the "public contract" that a Web service offers to other applications. This makes Workshop Web services flexible in the face of a constantly changing IT environment. Workshop also provides built-in support for asynchronous messaging so that Web service applications can carry on rich, two-way conversations with their clients and accommodate interaction with legacy systems and human users. Finally, Workshop supports easy manipulation of coarse-grained messages so that rich documents can be handled without resorting to tedious XML DOM programming. All of these capabilities can be accessed in a simple, declarative fashion that enables all developers not just J2EE experts to get started building Web services today.

Even if you are new to the Java programming language, or have never built a J2EE application before, I think you'll be surprised how easy it is to get started with Workshop. Working inside the WebLogic Workshop environment, you can focus on the procedural business code that is important to getting your applications built and leave all of the details of Web service and J2EE plumbing to the application framework. BEA WebLogic Workshop Kick Start will give you an introduction to Web services in general, and teach you the few Java and J2EE concepts you'll need to know along the way. Rich with examples, this book illustrates the power of Web services, and will help you realize the value they can bring to your company.

--Carl Sjogreen, Product Manager, WebLogic Workshop, BEA Systems, Inc

Customer Reviews (6)

Good book if your focus is XML Web Services
It is a good book and the examples are good.I was hoping for more information on web applications.The focus is really XML Web Services.

good book for starters
I have read this book and find that it is a good book if you want to get started with Web services on BEA Weblogic workshop. The starting chapters are good and they really work in Workshop but the ending chapters have lost focus and become very theoretical.If the authors can work the last chapters so that they provide more hands on knowledge to devlopers, it would be great...

Good Starting Point
I like this book. It was a big help for me to get started with Weblogic Workshop. I found it to be organized pretty well and the information extremely helpful.
I would recommend this book to someone that wanted to get started quickly with Workshop. But one problem is by the time I got this book and created Web Services with 7.0 then Weblogic 8.1 hit the market.
Also, the BEA documentation is very good and I could have probably gotten by using their resources. However, the amount of documentation and detail is overwhelming. I found this book helpful as well as an excellent starting point for WebServices and Workshop.

Worth the Money
If you want to learn Workshop, buy this book!By the end of the book you will be flying thru the tool.

The early chapters go easy and introduce the development environment.This is extremely well written.

And the examples in the early chapters work!You can easily create the web services yourself.

The later chapters loose focus on examples and more just explain how to do the task using workshop.And then the final chapter, "An Online Ordering System", seems to be written by an alein; the one web services does not work and will not work the way it is declared, one of the jave files is missing completely from the text but is provided on the CD.This is the reason for only four stars.

And then when you go to SAMSPUBLISHING web site, they have lost the book completely.

Excellent Book
This is a excellent book and does a terrific job taking you through the WorkShop and using it to create Web Services.

I could have probably stumbled through the stuff without going through this book but it would have taken me much longer and I wouldn't have learned as much.

If you want to get up and running quick with this WorkShop tool buy this book and you will be rocking in a short time. ... Read more

Book Description
Theprogrammer s tutorial/reference on Java 1.2that contains detailed descriptions of Sun s Java 1.2 standards, APIs, class libraries, and programming tools

Covers major third-party products like Microsoft s Java SDK 2.0, AFC, and RNI products which are rapidly gaining popularity Contains step-by-step instruction for developers on how to create channels that broadcast sound and video, and how to charge users for accessing them

Covers other relevant Sun, Microsoft, and OMG technologies for Java and ActiveX, including CORBA, Java IDL, Joe, JavaBeans, and Enterprise JavaBeansProvides Web Developers with tools to make information on their sites easily accessible to users, and tips to make the tools more efficient Contains over 20,000 lines of documented Java code that show programmers the detailes of building sophisticated Java applicationsContains all tools necessary to get started:a CD of JavaScript Code, Java Applets, style sheets, and templates There is currently no direct competition with this book-Complete tutorial/reference for experienced users that gives detailed coverage of the Java 1.2 language, APIs, class libraries, and programming tools-Contains a wealth of professional programming techniques, work-arounds, and thousands of lines of code that show programmers how to build sophisticated Java applications-Netscape Netcaster is a new component of the Communicator package that implementspassive browsingby collecting information from the Web and making it available immediately to the user, without the user having to seek it out ... Read more

Customer Reviews (12)

There are better books out there.
If you are looking for a source of complete answers to your questions the book is not for you. The Contents Table looks very promising. In fact, even though the outhor tried to cover many aspects of Java1.2 programming almostall the chapters leave doubts. Some of the chapters are so poorely writtenthat you have to wonder through your HELP or Java Documentation files tofind your own answers to simple questions. Almost every time I composesomething of my own, I have to go through a sequence of tries andcorrections because some topic is not well covered.

Tolerably well written book - not as good as Core Java thu
I highly anticipated this book as the reader reviews at Amazon praised the 'standard' version of the book (Using Java 1.2 by Mike Morgan, Michael Morgan) - some reviewers even compared that book to Thinking in Java.Apparently, this book is very different from that one (except for the sametitle) - actually, this title received quite bad reviews from amazonreaders as well. The Special Edition has nothing to do with Eckel's book -this one is much inferior to Eckel's classic - not as bad as Steyer's bookor the IS Perspective, though, as some chapters are quite well written, butthe book is riddled with severe errors and generally suffering from the badorder of introducing the different subjects.

The book is particularlyweak at using the Java naming conventions (sometimes entire pages havevariable names that start with uppercase letters; a lot of variables haveunderscores in them etc). It does not explain them at all - or, what itsays is plain wrong (p. 176, for example). It's only constant namingconventions that are explained well.

Chapter 1, What Java Can Do For You,presents quite cool examples of Java's usability. Only few pages have been'wasted' on this subject, and the examples presented here are sure to makemost ppl be eagerly waiting for the next chapters.

Chapter 2, JavaDesign, tells the reader the most important aspects of the language: beinginterpreted, platform-independent etc. and what it means in practice. Italso goes in telling not-that-widely known facts about the JVM (addressrange, max. size of methods). Also summarizes the security model verythoroughly - it even shows tables of the possible attacks on memory, OS,CPU, confidential data etc. that a malicious program could do. It lists theJava API libs - showing the 1.1 and (1.)2 libs separately. Also has asection on the new 1.2 Enterprise libs.

Chapter 3, Installing the JDK andGetting Started, shows how JDK (and ADK) should be installed. I don'treally know whether the first JDK 1.2 betas required the users to includert.jar in the CLASSPATH. The entire book tells the user to do so.

Chapter4, JDK Tools, introduces the command-line options of the most important JDKtools (except for javad, which is explained later). Also discusses theirMac equialents.

Part 2, Chapter 5, OOP, is a not very overwhelmingtreatment of basic OOP subjects. That is, the authors don't throw in manysubjects that would be only explained later (this is why this chapter ismuch superior to chapter 2 of Lemay's book - I found the treatment of basicOOP concepts even better than that of Eckel's Thinking in Java) -polymorphism is the only exception, which is only explained later.

Chapter 6, HelloWorld! Your First Java Program, shows the reader thebasic Hello World program as both an application and an applet. It doesn'teven try to explain main() - fortunately, at a later stage, it explains whyit's static. On the other hand, all applet methods are explained (paint,start, stop etc)

p. 91: "it's necessary that the filename be thesame as he class file..." - the authors correct this inaccurateinformation only later (on p. 164: "although only required for publicaccess...").

p. 94: "after the init() method, the browser firstcalls the paint() method, next, the start() method is started" - notreally true - start() is being called before paint() (I've tested it under1.2.1/Win and AV; commercial browsers may behave differently though).

p.95: shows the API documentation, but doesn't actually tell the user how itshould be used. As at the time of writing the new style API docs were alsoavailable, the authors should have presented the new API structure and thedifferences between the old and the new api docs... (speaking of the oldAPI docs presented here, the authors should have at least mentioned to lookup the inherited methods from superclasses).

Chapter 7, Data Types andOther Tokens:

p. 98: the keyword boolean is almost exclusively referredto as Boolean in the entire book. Some example programs also have thismistake.

p. 108: the section (1.5 pages) on arrays could have beenwritten much better. It doesn't show the new 1.1 shorthand forinitialization arrays separated from declaration. Multidimensional arraysare only mentioned as examples, but are not discussed at all.

It was awise move to make a distinction between the two fundamental types ofvariables: basic data types and references.

Chapter 8, Methods, discussesalmost everything: visibility, parameter lists, return value etc.

p. 127:an example of the book's often confusing classes for objects: "when aclass is passed"

p. 127: "in Pascal, [variables] are alwayspassed by reference..." - actually, the opposite is true - you have toexplicitly tell the compiler to pass them by reference (with the keywordvar).

p. 128: another page full of variables beginning with uppercaseletters.

p. 129: labeled statements: Thinking in Java explains them muchmore thoroughly.

p. 130: separators: " {: used both to open aparameter list or used to begin a block of statements or an initializationlist". The two words may have been copied from the previous row, whichdescribed the separator (. The same problem persists in the nextexplanation: " [: used both to open a parameter list for a Precedes anexpression used as an array index " - everything underlined should beremoved from here.

Chapter 9, Using Expressions, operators, associaty,precedence; cool C-comparisons (e.g. ++/-- can be used with any numerictype in Java, unlike in C)

p. 140: casting - I miss a figure of theimplicit casts between basic types from this book, too. Doesn't spend muchtext on object reference casting - this book also lacks at explaining whyyou can't implicitly cast a superclass reference to a subclass.

Chapter10, Control Flow: chapter 9 already discussed bitwise operators - nowlogical operators are also explained. Also introduces short-circuitoperators (without actually calling them so). The authors should haveemphasized short-circuit evaluation only takes place when using theseoperators.

Chapter 11, Classes:

p. 160: the following statement alsolacks any explanation: "you can not perform an operation reserved forthe Bike [sub]class on an instance of rthe Vehicle [superclass]".

p.163: mentions the default class visibility is protected - it's not reallytrue as you can't subclass a class that has default visibility in any otherpackage. The authors must have confused class visibility with method/fieldvisibility - accessing the fields/methods of a superclass in anotherpackage. Another error can be found here - from now on, the authors referto these 'protected' classes as 'friendly'. They don't mention anywhere inthe book what the difference is between Java's protected and C++'sprotected; neither do they explain what happened to the C++'s friend.

p.163: another severe editing error: "may not be not be evident atfirst"

p. 166: a good remark: "by making your code private,you may enable other classes to use static methods of your class withoutenabling them to create an instance of it."

p. 167: override /overload: it presents the caveat referring from using different signatureswhen trying to override. I still missed the comparison to C++ (even if itwas only done by Thinking in Java - it's still worth knowing if you comefrom C++).

p. 168: a clear and clever explanation of how JVM loads bothapplets and applications, paying special attention to emphaizing in whichcase does the class have an implicit instance.

p. 170: another example ofthe class<> object confusion: "this is used whenever it'snecessary to explicitly refer to the class itself" and "beingable to refer to itself is a capability that is very important for a class when a class needs to pass itself as an argument to a method ". Whatis more, the this() constructor call isn't introduced.

p. 172: doesn'texplain when super() must be explicitly used

p. 181: inner classes: fourpages only. Doesn't introduce static (top-level) and anon inner classes.The latter are used a bit later, but without any explanation.

p. 186:explaining / using the naming conventions are painfully missing from heretoo: the authors use package names like Transportation.

p. 189: only thestandard 1.0 Java packages (applet/awt/io/lang/net/util) are listed here,no 1.1 packages at all. Doesn't mention the need for separate subpackageimport either.

Chapter 12, Interfaces:

p. 198: "all methods ininterfaces are public by default this is in contract to class methodswhich default to friendly" - again, I miss the comparison between C++friendly and Java default visibility.

p. 201: also mentions one of thebest capabilities of interfaces: being able to cast up to their type. Istill miss examples like those of Core Java that actually show where it canbe used (the Timer/Timed example with a callback function, forexample).

Chapter 13, Threads: the example is far too large (and is anapplet - another reason

can u say 'deprecated'
alright book i suppose, ive seen much better, half the examples in this book are deprecated, they also use certain concepts in early chapters that are not explained until later chapters which is very confusing for peoplestarting out

Why is it called Using Java 1.2?
This book has nothing to do with Java 1.2.Most of the code examples use deprecated methods, so if you want to learn about Java 1.2, go somewhere else.

Good for reference, Bad for learning.
While the writer writes well, he obviously doesn't believe in proofreading as there are numerous mistakes.Looking up specific topics is very easy and the broad coverage of the Java language is impressive.Theorganization, however, is very poor because more advanced topics tend toappear in chapters about the basics without so much as a "see ch. XXfor more information about YY."This is a great reference book forthose already familiar with the Java language, but for thelearner/beginner, it will be confusing at best. ... Read more

Product Description
Collection of healthcare articles from subject experts including: Electronic Medical Records to improve patient care, Use of Problem Knowledge Couplers, Clinical Decision Support-Making the Transition from hospital to community network, Clinical documentation to improve patient care, Benefits of an electronic clinical information system Automating the Care process, Improving the Quality of Care in a Physician's Office, and Ambulatory Practice CLinical Information Management. ... Read more