fankyxu的专栏

如果对Hibernate有兴趣的同学, 我想这本书还是可以帮到你许多的. 当想, 本书是英文版, 需要些英语底子.

Enterprise applications are defined by their need to collect, process, transform, and report on vast amounts of information. And, of course, that information has to be kept somewhere. Storing and retrieving data is a multibillion dollar business, evidenced in part by the growth of the database market as well as the emergence of cloud-based storage services. Despite all the available technologies for data management, application designers still spend much of their time trying to efficiently move their data to and from storage. Despite the success the Java platform has had in working with database systems, for a long time it suffered from the same problem that has plagued other object-oriented programming languages. Moving data back and forth between a database system and the object model of a Java application was a lot harder than it needed to be. Java developers either wrote lots of code to convert row and column data into objects, or found themselves tied to proprietary frameworks that tried to hide the database from them. Fortunately, a standard solution, the Java Persistence API (JPA), was introduced into the platform to bridge the gap between object-oriented domain models and relational database systems. In this book we will introduce version 2.1 of the Java Persistence API and explore everything that it has to offer developers. One of its strengths is that it can be slotted into whichever layer, tier, or framework an application needs it to be in. Whether you are building client-server applications to collect form data in a Swing application or building a web site using the latest application framework, JPA can help you to provide persistence more effectively. To set the stage for JPA, this chapter first takes a step back to show where we’ve been and what problems we are trying to solve. From there we will look at the history of the specification and give you a high-level view of what it has to offer.

Java Reflection in Action is unique in presenting a clear account of all the cool things you can do with reflection, and at the same time pro- viding the sound conceptual basis that developers need to create advanced applications. The book includes careful explanations of sometimes perplexing programming techniques along with enough background to understand how to extend and vary them. This book overcomes reflection’s reputation as a mysterious and esoteric philo- sophical pursuit, or as a set of messy error-prone coding tricks. As reflection becomes increasingly common and useful in all sorts of applications, it is great to finally have a book that features disci- plined yet still creative and fun software engineering practices based on reflection. Even occasional users will immediately adopt the book’s patterns and idioms to solve common problems. Many of the examples can be directly adapted for customized solutions in diverse areas such as XML processing, automated software testing, and pro- gram analysis tools. Readers will also find underlying rationales for code performing introspection, proxies, class loading, and so on, that are often seen but not often explained well in everyday Java pro- grams. And even experts will find new ideas and well-thought out advice for using some of the more subtle aspects of reflection.

When you work with a computer, you can do several things at once. You can hear music while you edit a document in a word processor and read your e-mail. This can be done because your operating system allows the concurrency of tasks. Concurrent programming is about the elements and mechanisms a platform offers to have multiple tasks or programs running at once and communicate with each other to exchange data or to synchronize with each other. Java is a concurrent platform and offers a lot of classes to execute concurrent tasks inside a Java program. With each version, Java increases the functionalities offered to programmers to facilitate the development of concurrent programs. This book covers the most important and useful mechanisms included in Version 7 of the Java concurrency API, so you will be able to use them directly in your applications, which are as follows: f f t e n . d u o l Basic thread management w.codec w w Thread synchronization mechanisms f f Thread creation and management delegation with executors f f Fork/Join framework to enhance the performance of your application f f Data structures for concurrent programs f f Adapting the default behavior of some concurrency classes to your needs f f Testing Java concurrency applications f f What this book covers Chapter 1, Thread Management will teach the readers how to make basic operations with threads. Creation, execution, and status management of the threads are explained through basic examples. Chapter 2, Basic Thread Synchronization will teach the readers to use the low-level Java mechanisms to synchronize a code. Locks and the synchronized keyword are explained in detail. Chapter 3, Thread Synchronization Utilities will teach the readers to use the high-level utilities of Java to manage the synchronization between the threads in Java. It includes an explanation of how to use the new Java 7 Phaser class to synchronize tasks divided into phases. Chapter 4, Thread Executors will teach the readers to delegate the thread management to executors. They allow running, managing, and getting the results of concurrent tasks. Chapter 5, Fork/Join Framework will teach the readers to use the new Java 7 Fork/Join framework. It’s a special kind of executor oriented to execute tasks that will be divided into smaller ones using the divide and conquer technique. Chapter 6, Concurrent Collections will teach the readers to how to use some concurrent data structures provided by the Java language. These data structures must be used in concurrent programs to avoid the use of synchronized blocks of code in their implementation. Chapter 7, Customizing Concurrency Classes will teach the readers how to adapt some of the most useful classes of the Java concurrency API to their needs. Chapter 8, Testing Concurrent Applications will teach the readers how to obtain information about the status of some of the most useful structures of the Java 7 concurrency API. The readers will also learn how to use some free tools to debug concurrent applications, such as the Eclipse, NetBeans IDE, or FindBugs applications to detect possible bugs on their applications.

Foreword .................................................................................................................. xv About the Authors .................................................................................................... xvi About the Technical Reviewer ............................................................................... xviii Acknowledgments ................................................................................................... xix ■Chapter 1: Getting a Jump Start in JavaFX ............................................................. 1 ■Chapter 2: Creating a User Interface in JavaFX ..................................................... 35 ■Chapter 3: Properties and Bindings ....................................................................... 93 ■Chapter 4: Building Dynamic UI Layouts in JavaFX ............................................. 137 ■Chapter 5: Using the JavaFX UI Controls ............................................................. 183 ■Chapter 6: Collections and Concurrency ............................................................. 231 ■Chapter 7: Creating Charts in JavaFX .................................................................. 307 ■Chapter 8: Using the Media Classes .................................................................... 335 ■Chapter 9: Accessing Web Services .................................................................... 391 ■Chapter 10: JavaFX Languages and Markup ....................................................... 431 ■Appendix: The Visage Language in Depth ............................................................ 477 Index ....................................................................................................................... 609

The title of the book says it all: JavaFX 2.0 Introduction by Example. In this book, you will be learning the new JavaFX 2.0 capabilities by following practical recipe examples. These recipes will, in turn, provide you with the knowledge needed to create your own rich client applications. In the same tone with Java’s mantra “Write once, run anywhere,” JavaFX also preserves this same sentiment. Because JavaFX 2.0 is written entirely in Java the language, you will feel right at home. Most of the recipes can be compiled and run under Java 6. However, some recipes will take advantage of Java 7’s language enhancements, so Java 7 will be required. While working through this book with JavaFX 2.0 and Java 7, you will realize that the new APIs and language enhancements will help you to become a more productive developer. Having said this, I encourage you to explore all of Java 7’s new capabilities. To delve deeper into the new capabilities of Java 7, I recommend the book, Java 7 Recipes. On an added note, the recipes in this book can also be found in Java 7 Recipes. This book covers JavaFX 2.0’s fundamentals, graphics and animations, audio and video, and the Web. The fundamentals include how to install prerequisite software (JavaFX 2.0, NetBeans 7.1) and create simple user interfaces. You will also learn the basics of the scene graph, text nodes and font styles, shapes, colors, layouts, menus, UI controls, simple styling (CSS styling), binding expressions, background processes, keyboard shortcuts, and dialog boxes. Next, in graphics and animations you will encounter image handling, drag-and-drop operations, animation APIs, and UI theming (Look ‘n’ Feel). After graphics and animations, you will learn audio and video. This section will include creating an MP3 player, using a video player, responding to media events, handling media marker events, and synchronizing an animation with media events. Finally, you will be using JavaFX 2.0 to interoperate with web technologies such as HTML5, JavaScript, and XML. In this section, you will be learning how to embed JavaFX into a web page, rendering and dynamically manipulating HTML5 content, creating a weather application to respond to HTML events, and creating an RSS feed application using an embedded database (Derby).

Perhaps it’s best to start by explaining one thing this book categorically is not: Java FX in Action is not a retread of readily available online documentation. If you want that kind of thing, no doubt other books will suffice. In the age of search engines and IDE s with context-sensitive help, a complete list of functions for a given class is never more than a few keystrokes away. API documentation is plentiful—what’s usually lacking is an expla- nation of how the various classes fit together, and interact, to solve particular problems. This book seeks to teach Java FX from first principles through practical examples instead of merely repackaging API documentation. The opening third (chapters 1 to 3) introduces the platform and the Java FX Script language, while the remaining two-thirds (chapters 4 to 11) use a project-driven approach to study the Java FX API s. The overriding theme of the book is cool ways to learn a cool technology. The projects are fun, the text permits itself occasional flashes of humor (without being overly flip- pant), and the problem/solution format brightens up even the most mundane parts of the API . But the text doesn’t shy away from hard-nosed technical detail when neces- sary: if you want to understand why, and not just how, this is the book for you. Java FX is a brash, new, energetic, and entertaining technology—this book attempts to capture that spirit: an invaluable desktop companion, alongside the official API documentation

底层开始讲起, 结合实际案例向读者介绍ANDROID内核, 移植和驱动开发的流程

Android in Action, Third Edition is a revision and update of, you guessed it, the Second Edition, published in January 2011. This third edition adds new content related to Android’s push into the tablet space as well as enhancements to various sub-systems within the Android platform. Like its predecessors, this book covers important begin- ner topics such as “What is Android?” and installing and using the development envi- ronment. We then advance to practical working examples of core programming topics any developer will be happy to have at the ready on the reference shelf. The remain- ing chapters present detailed example applications covering advanced topics, includ- ing a complete field-service application, localization, and material on Android web applications, Bluetooth, sensors, AppWidgets, and integration adapters. We even include two chapters on writing applications in C—one for the native side of Android and one using the more generally accepted method of employing the Android Native Development Kit. Brand-new content covering tablet programming is found in chap- ters 20 through 22. Chapters 20–22 specifically require Android SDK 3.0 and beyond, whereas the balance of the book is compatible with 2.x versions of Android. Although you can read the book from start to finish, you can also consider it a few books in one. If you’re new to Android, focus first on chapter 1, appendix A, and then chapter 2. With that foundation, you can work your way through chapters 3–12. Chap- ters 13 and on are more in-depth in nature and can be read independently of the oth- ers. Chapters 20–22 focuses on important topics related to Android 3.0 and tablets.

By combining introductions, overviews, and how-to examples, the In Action books are designed to help learning and remembering. According to research in cognitive science the things people remember are things they discover during self-motivated exploration. Although no one at Manning is a cognitive scientist, we are convinced that for learn- ing to become permanent it must pass through stages of exploration, play, and, inter- estingly, retelling of what is being learned. People understand and remember new things, which is to say they master them, only after actively exploring them. Humans learn in action. An essential part of an In Action guide is that it is example-driven. It encourages the reader to try things out, to play with new code, and explore new ideas. There is another, more mundane, reason for the title of this book: our readers are busy. They use books to do a job or solve a problem. They need books that allow them to jump in and jump out easily and learn just what they want just when they want it. They need books that aid them in action. The books in this series are designed for such readers.

Aspect-oriented software design (ASOD), which follows the Java philosophy of "write once, run anywhere", is a new way of thinking about program construction. It is a rapidly growing and evolving programming methodology that some feel may eventually replace object-orientation as the dominant programming paradigm. The first public release of the AspectJ programming language was in 1998 and has been gaining momentum ever since. This book is an introduction to AOP with AspectJ and Eclipse and shows how to create a productive AO development environment by using the AspectJ Development Tools for Eclipse (AJDT). Tools have an important role to play in learning aspect-orientation (AO) and Eclipse tools help Java developers better understand AOP. In fact the growing interest in AOP can be attributed to the better available tools and this book teaches the reader everything they need to understand AOP and apply it successfully to their own projects.

1、全书结合具体的实例，以独特的风格细致介绍了每种技术的运用方法和适用场合，并且对常见的总是做了特别提示。 2、语言明朗流畅。内容前后贯通.技术循序渐进。

Hiberante是一个面向Java环境的对象/关系数据库映射工具。不仅管理Java类到数据库的映射，还提供了数据查询和获取数据的方法，可以大幅度减少开发时人工使用SQL和JDBC处理数据的时间。

学习PL/SQL的上上之选，言简意赅，易于理解，内容全而丰富，好的学习材料。 不过，本电子书是英文版本，要想看清看透看懂此书，一定的英语基础免不了，但值得一看。

一本很好的参考书，很适用初学者或是想进一步学习标签开发的同志，当然，此本电子是英文版，对于阅读者，还是要有些英文底子的，但绝对是一本不容错过的好书。