eagleyan的专栏

Windows 2000上的驱动开发，环境搭建，参考和一些基本指南

You get huge development advantages with Microsoft visual Studio .NET 2003—but you need a new bag of debugging tricks to take full advantage of them in today’s .NET and Win32 development worlds. Learn lethally effective, real-world application debugging techniques for .NET Framework 1.1 and windows with this fully updated programming guide. Debugging expert John Robbins expands the first edition of his classic debugging book with all-new scenarios and bug-killing tools, tips, and techniques. You’ll see every .NET and Windows debugging scenario here—from XML Web services and Microsoft ASP.NET to Windows services and exceptions. Along with John’s expert guidance, you get more than 6 MB of his battle-tested source code—for the tools and tactics you need to ship better software faster! Topics covered include: Where bugs come from and how to think about solving them Debugging during coding Operating system debugging support and how Win32 debuggers work Advanced debugger usage and .NET debugging with Visual Studio .NET Advanced native code techniques with Visual Studio .NET and WinDBG Extending the Visual Studio .NET integrated development environment Managed exception monitoring Flow tracing and performance Finding source and line information with just a crash address Crash handlers Debugging Windows services and DLLs that load into services Multithreaded deadlocks Automated testing The Debug C run-time library A high-performance tracing tool for server applications Smoothing the working set Appendixes: Reading Dr. Watson log files, plus resources for .NET and Windows developers About the Author John Robbins is a co-founder of Wintellect, a .NET and Windows consulting, debugging, and education firm whose mission is to help companies ship better software faster. As a recognized debugging expert, John “takes an evil delight in finding and fixing impossible bugs in other people’s programs.” He leads Wintellect’s debugging and consulting services as well as develops and teaches its debugging curriculum. Hon has debugged and tuned a wide variety of applications for eBay, Microsoft, AutoDesk, and other companies. He’s also well known as a contributing editor at MSDN Magazine, where he writes the popular “Bugslayer” column.

What You Will and Won't Find Here Chapter 1 introduces caching and provides some background material to help the rest of the book make sense. In addition, companies that provide caching products are listed here. In Chapter 2, we'll dive into the Hypertext Transfer Protocol and explore its features for caching. Chapter 3 is relatively nontechnical and discusses some of the controversies that surround web caching, such as copyrights and privacy. In Chapter 4, you'll see the various ways to configure user agents (browsers) for caching, with a focus on Netscape Navigator and Microsoft Internet Explorer. Many administrators prefer to automatically intercept and divert HTTP connections to a cache. We'll talk about that in Chapter 5. Then, in Chapter 6, we'll turn to servers and see how content providers can make their information cache-friendly. Chapter 7 and Chapter 8 are about cache hierarchies. First we'll talk about them in general, including why you should or should not participate in a hierarchy. Then you'll learn about the protocols caches use to communicate with each other. Chapter 9 is a short chapter about cache clusters. Although clusters have some things in common with cache hierarchies, it is easier to understand some of the nuances after you've learned about the intercache protocols. In Chapter 10, I'll walk you through some of the decisions you'll face in procuring and building a caching service for your organization. Following that, Chapter 11 offers advice on monitoring the health of your caches once they are operational. For the Unix-savvy, I'll show how to set up UCD-SNMPD and RRDTool for this purpose. Chapter 12 is about benchmarking the performance of caches. I analyze some logfiles from production caches in Appendix A. Here you can see some sample file size distributions, content types, HTTP headers, and hit ratio simulations. The next four appendixes are about intercache protocols. Appendix B describes the technical details of ICP. Appendix D does the same for HTCP, Appendix C for CARP, and Appendix E for cache digests. Appendix F is a list of HTTP status codes from RFC 2616. Appendix G contains the text of a U.S. copyright statute that mentions caching. Finally, in Appendix H, you'll find definitions for many of the acronyms I use in this book. The new, hot topics in the caching industry are streaming media and content distribution networks. This book focuses on HTTP and FTP caching techniques with proven results, eschewing technology that is still evolving.

This book covers the following topics not found in other books on Axis: • How to work with Axis2 1.3. • How to use Eclipse Europa (WTP 2.0) with Axis2. • How to invoke asynchronous operations using WS-Addressing. • How to encrypt and sign SOAP messages using Rampart. • How to send user authentication information using Rampart. • How to send and receive binary files using MTOM. • How to integrate Axis2 with Spring.

PART 1 SPRING ESSENTIALS ........................................................ 1 1 ■ A Spring jump start 3 2 ■ Wiring beans 42 3 ■ Creating aspects 91 PART 2 SPRING IN THE BUSINESS LAYER .............................. 131 4 ■ Hitting the database 133 5 ■ Managing transactions 173 6 ■ Remoting 207 7 ■ Accessing enterprise services 240 PART 3 SPRING IN THE WEB LAYER ....................................... 267 8 ■ Building the web layer 269 9 ■ View layer alternatives 319 10 ■ Working with other web frameworks 346 11 ■ Securing Spring applications 367 brief contents

  ,    -  a long-standing gap in the documentation and literature of the Java™ programming language and platform, by providing fundamental and in-depth coverage of #  and  networking from the point of view of the Java API, and by discussing advanced networking programming techniques.1 The new I/O and networking features introduced in " 1.4 provide further justification for the appearance of this text. Much of the information in this book is either absent from or incorrectly specified in the Java documentation and books by other hands, as I have noted throughout. In writing this book, I have drawn on nearly twenty years’ experience in network programming, over a great variety of protocols, APIs, and languages, on a number of platforms (many now extinct), and on networks ranging in size from an Ethernet a few inches in length, to a corporate  between cities thousands of miles apart, to the immense geographic spread of the Internet. This book covers both ‘traditional’ Java stream-based I/O and so-called ‘new I/O’ based on buffers and channels, supporting non-blocking I/O and multiplexing, for both ‘plain’ and secure sockets, specfically including non-blocking # and % . Server and client architectures, using both blocking and non-blocking I/O schemes, are discussed and analysed from the point of view of scalability and with a particular emphasis on performance analysis. An extensive list of TCP/IP platform dependencies, not documented in Java, is provided, along with a handy reference to the various states a TCP/IP port can assume.

This book was written with one goal in mind: to provide Java programmers with the expertise needed to build efficient, scalable Java code. The author shares his experience in server-side performance tuning through measured performance assessments, called optimizations. Each optimization discusses techniques to improve the performance and scalability of your code. Every claim is substantiated with hard numbers and an experience-based evaluation. Java(TM) Performance and Scalability, Volume 1, provides invaluable advice that you will, no doubt, find useful in your coding. Presented in 48 concise lessons that target the most common and critical performance pitfalls, this book offers a plethora of practical tips and solutions for boosting the performance of your programs. These lessons cover performance-critical areas such as memory management, garbage collection, caching, and multithreading.

This book is about system programming, which is the art of writing system software. System software lives at a low level, interfacing directly with the kernel and core system libraries. System software includes your shell and your text editor, your compiler and your debugger, your core utilities and system daemons. These components are entirely system software, based on the kernel and the C library. Much other software (such as high-level GUI applications) lives mostly in the higher levels, delving into the low level only on occasion, if at all. Some programmers spend all day every day writing system software; others spend only part of their time on this task. There is no programmer, however, who does not benefit from some understanding of system programming. Whether it is the programmer’s raison d’être, or merely a foundation for higher-level concepts, system programming is at the heart of all software that we write. In particular, this book is about system programming on Linux. Linux is a modern Unix-like system, written from scratch by Linus Torvalds, and a loose-knit community of hackers around the globe. Although Linux shares the goals and ideology of Unix, Linux is not Unix. Instead, Linux follows its own course, diverging where desired, and converging only where practical. Generally, the core of Linux system programming is the same as on any other Unix system. Beyond the basics, however, Linux does well to differentiate itself—in comparison with traditional Unix systems, Linux is rife with additional system calls, different behavior, and new features.