Spring.NET框架详解与使用指南

需积分: 10 179 浏览量更新于2024-08-02 收藏 3.63MB PDF 举报

"Spring.NET 是一个开源的应用程序框架，旨在简化企业级.NET应用程序的开发。它提供了基于成熟设计模式的组件，可以集成到应用程序架构的各个层，帮助提高开发效率，提升应用质量和性能。该文档是Spring.NET 1.3.0版本的参考文档，更新日期为2009年12月17日，由多个开发者共同创作，并遵循特定的版权条款。" Spring.NET框架是一个全面的开发工具包，它引入了Inversion of Control（IoC，控制反转）的概念，以帮助开发者构建松耦合、可测试和可维护的.NET应用程序。以下是关于Spring.NET的一些核心知识点： 1. ** Preface** - 引言部分通常会概述文档的目的、适用人群以及如何使用文档。 2. **Introduction** - 介绍部分将提供Spring.NET框架的基本概述，包括其设计目标、背景信息以及它如何适应不同的使用场景。它还可能包含快速启动应用程序的指导，帮助开发者快速入门。 3. **Background information** - 背景信息章节深入探讨了IoC概念，这是Spring.NET的核心原则之一。IoC允许应用程序组件之间的依赖关系被外部容器管理，而不是组件内部硬编码，这样可以提高灵活性和可测试性。 4. **Migrating from 1.1 M2** - 这个部分为从1.1 M2版本升级到1.3.0版本的用户提供指导，列出重要的变化，如命名空间、核心模块、Web模块和数据模块的更新，帮助开发者顺利迁移代码。 5. **Core Technologies** - 核心技术章节将详细介绍Spring.NET框架的基础组件，这可能包括IoC容器、AOP（面向切面编程）、事务管理、数据访问支持等。 6. **The IoC container** - IoC容器章节是Spring.NET的关键部分，它解释了容器如何管理对象的生命周期和依赖关系。容器通过配置元数据（可能是XML、注解或其他形式）来实例化、配置和组装对象。 - **Container overview** - 容器概览部分会讲解容器如何工作，包括配置元数据的作用和容器如何根据这些元数据创建和管理对象。 - **Configuration metadata** - 配置元数据涉及如何定义对象的属性、依赖关系和初始化行为。 - **Instantiating a container** - 实例化容器的步骤和方法，以及如何从中获取和使用配置的对象。以上内容只是Spring.NET参考文档的一部分，实际文档会更详细地涵盖更多主题，例如AOP、数据库支持、Web应用集成、测试工具和其他高级特性。这些知识点对于理解并有效利用Spring.NET框架构建.NET应用程序至关重要。

Spring Framework (Version 1.3.0) 2

Chapter 2. Introduction

2.1. Overview

Spring.NET is an application framework that provides comprehensive infrastructural support for developing

enterprise .NET applications. It allows you to remove incidental complexity when using the base class libraries

makes best practices, such as test driven development, easy practices. Spring.NET is created, supported and

sustained by SpringSource.

The design of Spring.NET is based on the Java version of the Spring Framework, which has shown real-world

benefits and is used in thousands of enterprise applications world wide. Spring .NET is not a quick port from the

Java version, but rather a 'spiritual port' based on following proven architectural and design patterns in that are

not tied to a particular platform. The breadth of functionality in Spring .NET spans application tiers which allows

you to treat it as a ‘one stop shop’ but that is not required. Spring .NET is not an all-or-nothing solution. You can

use the functionality in its modules independently. These modules are described below.

Enterprise applications typically are composed of a number of a variety of physical tiers and within each tier

functionality is often split into functional layers. The business service layer for example typically uses a objects

in the data access layer to fulfill a use-case. No matter how your application is architected, at the end of the day

there are a variety of objects that collaborate with one another to form the application proper. The objects in an

application can thus be said to have dependencies between themselves.

The .NET platform provides a wealth of functionality for architecting and building applications, ranging all the

way from the very basic building blocks of primitive types and classes (and the means to define new classes), to

rich full-featured application servers and web frameworks. One area that is decidedly conspicuous by its absence

is any means of taking the basic building blocks and composing them into a coherent whole; this area has typically

been left to the purvey of the architects and developers tasked with building an application (or applications). Now

to be fair, there are a number of design patterns devoted to the business of composing the various classes and

object instances that makeup an all-singing, all-dancing application. Design patterns such as Factory, Abstract

Factory, Builder, Decorator, and Service Locator (to name but a few) have widespread recognition and acceptance

within the software development industry (presumably that is why these patterns have been formalized as patterns

in the first place). This is all very well, but these patterns are just that: best practices given a name, typically

together with a description of what the pattern does, where the pattern is typically best applied, the problems

that the application of the pattern addresses, and so forth. Notice that the last paragraph used the phrase “... a

description of what the pattern does...”; pattern books and wikis are typically listings of such formalized best

practice that you can certainly take away, mull over, and then implement yourself in your application.

The Spring Framework takes best practices that have been proven over the years in numerous applications and

formalized as design patterns, and actually codifies these patterns as first class objects that you as an architect

and developer can take away and integrate into your own application(s). This is a Very Good Thing Indeed as

attested to by the numerous organizations and institutions that have used the Spring Framework to engineer robust,

maintainable applications. For example, the IoC component of the Spring Framework addresses the enterprise

concern of taking the classes, objects, and services that are to compose an application, by providing a formalized

means of composing these various disparate components into a fully working application ready for use

2.2. Background

In early 2004, Martin Fowler asked the readers of his site: when talking about Inversion of Control: “the question

is, what aspect of control are [they] inverting?”. Fowler then suggested renaming the principle (or at least giving

Introduction

Spring Framework (Version 1.3.0) 4

Spring.Data.NHibernate - Use this module to integrate NHibernate with Spring’s declarative transaction

management functionality allowing easy mixing of ADO.NET and NHibernate operations within the same

transaction. NHibernate 1.0 users will benefit from ease of use APIs to perform data access operations.

Spring.Web - Use this module to raise the level of abstraction when writing ASP.NET web applications allowing

you to effectively address common pain-points in ASP.NET such as data binding, validation, and ASP.NET page/

control/module/provider configuration.

Spring.Web.Extensions - Use this module to raise the level of abstraction when writing ASP.NET web

applications allowing you to effectively address common pain-points in ASP.NET such as data binding,

validation, and ASP.NET page/control/module/provider configuration.

Spring.Services - Use this module to adapt plain .NET objects so they can be used with a specific distributed

communication technology, such as .NET Remoting, Enterprise Services, and ASMX Web Services. These

services can be configured via dependency injection and ‘decorated’ by applying AOP.

Spring.Testing.NUnit - Use this module to perform integration testing with NUnit.

The Spring.Core module also includes the following additional features

• Expression Language - provides efficient querying and manipulation of an object graphs at runtime.

• Validation Framework - a robust UI agnostic framework for creating complex validation rules for business

objects either programatically or declaratively.

• Data binding Framework - a UI agnostic framework for performing data binding.

• Dynamic Reflection - provides a high performance reflection API

• Threading - provides additional concurrency abstractions such as Latch, Semaphore and Thread Local Storage.

• Resource abstraction - provides a common interface to treat the InputStream from a file and from a URL in a

polymorphic and protocol-independent manner.

2.4. Usage Scenarios

With the building blocks described above you can use Spring in all sorts of scenarios, from simple stand alone

console applications to fully-fledged enterprise applications using Spring's transaction management functionality

and web framework integration.

It is important to note that the Spring Framework does not force you to use everything within it; it is not an all-

or-nothing solution. Existing front-ends built using standard ASP.NET can be integrated perfectly well with a

Spring-based middle-tier, allowing you to use the transaction and/or data access features that Spring offers. The

only things you need to do is wire up your business logic using Spring's IoC container and integrate it into your

web layer using WebApplicationContext to locate middle tier services and/or configure your standard ASP.NET

pages with depdenency injection.

While the Spring framework does not force any particular application architecure it encourages the use of a well

layered application architecture with distinct tiers for the presentation, service, data access, and database.

2.5. Quickstart applications

There are several sample applications that showcase individual features. If you are already familiar with the

concepts of dependency injection, AOP, or have experience using the Java version of the Spring framework you

Introduction

Spring Framework (Version 1.3.0) 5

may find jumping into the examples a better way to bootstrap the learning processing process. The following

quickstart applications are available and can be found in the examples directory in the distribution. Click on the

links for additional information.

• Movie Finder - A simple demonstration of Dependency Injection (DI) techniques using Spring's Inversion of

Control (IoC) container.

• Application Context - Demonstrates IoC container features such as localization, accessing of ResourceSet

objects, and applying resources to object properties.

• Aspect Oriented Programming - Demonstrates use of the AOP framework to add additional behavior to your

existing objects. Examples of programmatic and declarative AOP configuration are shown.

• Distributed Computing - A calculator demonstrating remote service abstractions that let you 'export' a

plain .NET object (PONO) via .NET Remoting, Web Services, or an EnterpriseService ServiceComponent.

Corresponding client side proxies are also demonstrated.

• WCF - Shows a WCF based calculator example that configures your WCF service via dependency injection

and apply AOP advice.

• Web Application - SpringAir -A ticket booking application that demonstrates the ASP.NET framework

showing features such as DI for ASP.NET pages, data binding, validation, and localization.

• Web Development - Introductory examples showing use of dependency injection and Spring's bi-directional

data binding in ASP.NET.

• Data Access - Demonstrates the ADO.NET framework showing how to simplify developing ADO.NET based

data access layers.

• Transaction Management : Demonstrates the use of declarative transaction management for both local and

distributed transaction in both .NET 1.1 and 2.0.

• AJAX : Demonstrates how to access a plain .NET object as a webservice in client side JavaScript

• NHibernate Northwind: Demonstrates use of Spring's NHibernate integration to simplify the use of NHibernate.

Web tier is also included showing how to use the Open-Session In View approach to session management in

the web tier.

• Quartz Quickstart - Application that shows the use of Quartz.NET integration for scheduling.

• NMS - Applicatoin demonstrating NMS helper classes.

2.6. License Information

Spring.NET is licensed according to the terms of the Apache License, Version 2.0. The full text of this license are

available online at http://www.apache.org/licenses/LICENSE-2.0 . You can also view the full text of the license

in the license.txt file located in the root installation directory.

2.7. Support

Training and support are available through SpringSource in addition to the mailing lists and forums you can find

on the main Spring.NET website.

剩余498页未读，继续阅读

tonymazn

粉丝: 0
资源: 2

Spring.NET框架详解与使用指南

spring.NET 1.2.0

Spring。net 的帮助

.NET版Spring框架参考文档

Spring Framework 1.3.0RC1 Reference Documentation

springcloud报java.net.ConnectException: Connection refused: connect

springcloud-nacos报java.net.ConnectException: Connection refused: connect

org.springframework.amqp.AmqpConnectException: java.net.ConnectException: Connection timed out: connect

Caused by: org.springframework.amqp.AmqpConnectException: java.net.ConnectException: Connection refused (Connection refused)

spring spring boot

spring spring security

最新资源