意料之外，情理之中，Spring.NET 3.0 版本发布-

最新推荐文章于 2021-06-18 13:23:59 发布
最新推荐文章于 2021-06-18 13:23:59 发布
阅读量411 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/farway000/article/details/89346219
版权

意料之外，情理之中，Spring.NET 3.0 版本发布-

意料之外，情理之中，Spring.NET 3.0 版本发布-

    备受社区和企业开发者广泛关注的Spring.NET在上周发布了3.0版本，并且目前已经保持着持续的更新，让我们一起来看一看他究竟发布了哪些令人激动的新特性吧！

Github上的原贴地址为：https://github.com/spring-projects/spring-net。

1.引言

Spring.NET 3.0.0版本包含

  • 一个功能齐全的控制反转容器
  • 面向方面的编程框架
  • 轻量级脚本的表达式语言
  • UI不可知的验证框架
  • ASP.NET框架
    • 页面和用户控件的依赖注入，双向数据绑定等。
  • ASP.NET MVC和ASP.NET WebAPI框架
    • MVC的依赖注入（包括WebAPI）。
  • 声明式事务管理抽象
    • 通过跨不同事务API使用通用XML配置和属性进行声明式事务管理
  • ADO.NET框架
    • 简化ADO.NET的使用。DAO支持类并与Spring的声明式事务管理功能集成
  • 便携式服务抽象
    • 通过.NET Remoting，Web Service或.NET Serviced Component导出纯.NET对象，并根据端点URL和服务接口创建客户端代理。
  • NHibernate整合
    • NHibernate 5集成简化了NHibernate的使用并参与了Spring的声明式事务管理功能。
  • ASP.NET AJAX集成
    • 导出器用于公开已将依赖注入和AOP应用于JavaScript的普通对象。
  • NUnit和MSTest集成
    • 提供依赖注入测试用例和Spring容器加载和缓存。。数据访问和事务管理功能有助于集成测试。
  • WCF集成
    • 提供依赖注入和AOP建议应用于WCF服务
  • Quartz 集成
    • 使用依赖注入和Spring的事务支持配置Quartz作业以保留作业详细信息
  • MSMQ集成
    • 通过为消息发送和接收提供帮助程序类来简化MSMQ的使用。与Spring的事务管理功能集成。
  • NMS集成
    • 通过为消息发送和接收提供帮助程序类来简化NMS的使用。
  • TIBCO EMS集成
    • 通过为消息发送和接收提供帮助程序类，简化了TIBCO EMS的使用。
  • NVelocity集成
    • 简化配置NVelocity的用法

Spring.NET是基于Java的Spring Framework的一个端口。反过来，Java / J2EE Spring Framework基于Rod Johnson（Wrox，2002）的“Expert One-on-One J2EE Design and Development”中发布的代码。

2.支持的.NET框架版本

Spring.NET 3.0.0支持.NET 4.5.2和.NET Standard 2.0及更高版本。

3.已知问题

4.发布信息

发布内容：

  • “src”包含框架的C＃源文件
  • “test”包含Spring.NET测试套件的C＃源文件
  • “bin”包含各种Spring.NET分发dll文件
  • “lib / Net”包含构建框架所需的共享第三方库
  • “lib / NHibernate3”包含NHibernate 3.3 dll
  • “doc”包含参考文档，MSDN风格的API帮助和Spring.NET xsd。
  • “examples”包含示例应用程序。
  • “build-support”包含需要使用NAnt构建的附加应用程序作为一些方便的VS.NET解决方案文件。
  • “dev-support”包含“开发人员支持”工具和代码，例如VS.NET的解决方案模板

使用/ DEBUG完成调试构建：使用/ DEBUG：pdbonly标记发布版本。

提供了用于框架和示例的VS.NET解决方案。

有关最新信息，请访问公共网站：http：//www.springframework.net/

Spring Framework是根据Apache软件许可证的条款发布的（请参阅license.txt）。

5.分发DLL

“bin”目录包含以下不同的dll文件，供应用程序使用。依赖关系不是.NET BCL上的依赖关系。

  • Spring.Core（~765 KB）
  • Spring.Aop（~150 KB）
  • Spring.Data（~320 KB）
  • Spring.Data.NHibernate5（~90 KB）
  • Spring.Services（~70 KB）
  • Spring.Web（~165 KB）
  • Spring.Web.Extensions（~8 KB）
  • Spring.Web.Mvc5（~8 KB）
  • Spring.Testing.NUnit（~24 KB）
  • Spring.Testing.Microsoft（~24 KB）
  • Spring.Messaging（约65 KB）
  • Spring.Messaging.Nms（~100 KB）
  • Spring.Scheduling.Quartz3（~44 KB）
  • Spring.Template.Velocity（~44 KB）
    • 内容：控制容器的反转。集合类。
    • 依赖关系：Common.Logging
    • 内容：面向抽象的编程框架。
    • 依赖关系：Spring.Core，Common.Logging
    • 内容：Transaction和ADO.NET Framework。
    • 依赖关系：Spring.Core，Spring.Aop
    • 内容：NHibernate 5.x集成
    • 依赖关系：Spring.Core，Spring.Aop，Spring.Data，NHibernate
    • 内容：Web服务，远程处理和基于企业组件的服务。
    • 依赖关系：Spring.Core，Spring.Aop
    • 内容：基于ASP.NET的Web应用程序框架。
    • 依赖关系：Spring.Core，Spring.Aop
    • 内容：ASP.NET AJAX Integartion
    • 依赖关系：Spring.Core，Spring.Aop，System.Web.Extensions
    • 内容：ASP.NET MVC5和WebAPI Integartion
    • 依赖关系：Spring.Core，Spring.Web
    • 内容：NUnit集成
    • 依赖关系：Spring.Core，Spring.Data，NUnit
    • 内容：MSTest集成
    • 依赖关系：Spring.Core，Spring.Data，MSTest
    • 内容：MSMQ集成
    • 依赖关系：Spring.Core，Spring.Data，System.Messaging
    • 内容：NMS集成
    • 依赖关系：Spring.Core，Spring.Data，Apache NMS
    • 内容：Quartz32.x集成
    • 依赖关系：Spring.Core，Spring.Data，Quartz
    • 内容：NVelocity集成
    • 依赖关系：Spring.Core，NVelocity

6.从哪里开始？

文档可以在“docs”目录中找到：

  • Spring参考文档

记录的示例应用程序可以在“示例”中找到：

  • IoCQuickStart.MovieFinder - 一个演示基本IoC容器行为的简单示例。
  • IoCQuickStart.AppContext - 显示各种IApplicationContext功能的使用。
  • IoCQuickStart.EventRegistry - 显示松散耦合事件功能的使用。
  • AopQuickStart - 显示AOP功能的使用。
  • CachingQuickStart - 显示缓存抽象的使用。
  • SpringAir - 显示Spring.Web功能的使用。
  • 计算器 - 显示Spring.Services功能的使用。
  • WebQuickStart - 显示Spring.Web功能的逐步使用。
  • Web.Extensions.Example - 显示ASP.NET AJAX integartion。
  • DataQuickStart - 显示使用Spring.Data数据访问功能。
  • TxQuickStart - 显示Spring的事务功能。
  • Data.NHibernate.Northwind - 显示使用Spring的NHibernate功能。
  • WCFQuickStart - 显示在WCF中使用DI和AOP
  • NMSQuickStart - 使用NMS的示例应用程序
  • MSMQ快速入门 - 使用MSMQ的示例应用程序
  • Quartz示例 - 使用Quartz进行调度
  • Mvc5QuickStart - 显示ASP.NET MVC 5支持的配置

7.如何建立

VS.NET

Visual Studio 2017需要打开并构建解决方案。Visual Studio的免费社区版本应该足够了。

NAnt

构建脚本随下载包一起提供。

构建源并运行单元测试类型

构建测试

如果要运行构建以创建强签名程序集，可以通过执行以下命令生成密钥文件（假设sn.exe在搜索路径上正确）：

sn -k Spring.Net.snk

您需要将Spring.NET.snk文件放入源树的根文件夹中。执行以下nant命令时，使用此密钥文件强烈命名所有构建：

nant -D：project.build.sign = true

InnovaSys Document X！用于生成SDK文档。

8.支持

http://forum.springframework.net/上的用户论坛可供您提交问题，支持请求以及与其他Spring.NET用户交互。

可以在https://jira.springsource.org/browse/SPRNET找到错误和问题跟踪

Fisheye存储库浏览器位于https://fisheye.springframework.org/browse/spring-net

要获取源代码，请在https://github.com/SpringSource/spring-net上分享github

我们很乐意在论坛上收到您的反馈。如果您认为发现了错误，请提出改进​​建议或功能请求，请在JIRA中提交一张票（请参阅上面的链接）。

关于错误报告的一句话：如果可能，请尝试在http://www.springframework.net/downloads/nightly/下载其中一个夜间快照，看看是否已修复此错误。如果问题仍然存在，请不要忘记提及您正在使用的Spring.NET版本（检查Spring.NET dll的文件版本），运行的.NET版本以及如何重现问题的说明。理想情况下，将一些重现问题的示例代码附加到JIRA票证上。

 

 

        

posted @ 2018-10-22 23:04 溪源More 阅读( ...) 评论( ...) 编辑 收藏
溪源More
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring3.0中文版
07-22
Spring3.0中文版.CHM(3.2API文档，所有类，常量字段值)
全国卷作文公布：出乎意料与情理之中
12-07
小编整理了一篇全国卷作文公布：出乎意料与情理之中，为不会书写的朋友提供一篇良好的范例，不知道怎么写...该文档为全国卷作文公布：出乎意料与情理之中，是一份很不错的参考资料，具有较高参考价值，感兴趣的可以...
Spring.Net.FrameworkV3.0 版本发布了，感谢大家的支持
weixin_34197488的博客
01-05 154
　　Spring.Net.FrameworkV3.0 版本发布了，感谢大家的支持。 　　Spring.Net.Framework，基于.NET的快速信息化系统开发、整合框架，为企业或个人在.NET环境下快速开发系统提供了强大的支持，开发人员不需要开发系统的基础功能和公共模块，框架自身提供了强大的函数库和开发包，开发人员只须集中精力专注于业务部分的开发，因此大大提高开发效率和节约开发成本。框架采用...
浅析Spring.NET（一）：Spring.NET及简单使用
热门推荐
ruisenLi的博客
10-25 1万+
浅析Spring.NET 文章目录浅析Spring.NET一、Spring.NET 简单使用1. 什么是 Spring.NET ?2.快速创建第一个使用 Spring.NET 的程序注意事项： 一、Spring.NET 简单使用 最近用到了 Spring.NET ,不过在第一次使用的时候就遇到了一些问题，打算整理成系列博客，不断的总结和分享。 同时也非常感谢在学习过程中给予我非常多帮助的前辈们，...
spring3.0就是这么简单——spring Ioc容器
程序员爱酸奶
01-02 1245
Ioc 概述 beanFactory和applicationContext Bean 工厂是spring 框架最核心的接口，它提供了高级IoC的配置机制。应用上下文（applicationContext）是建立在BeanFactory的基础上，提供了更多面向应用的功能。 一般称BeanFactory为IoC容器，而称applicationContext为应用上下文，也称为spring容器。 资源...
spring最新版本下载地址
chunrudikai的博客
05-10 651
https://repo.spring.io/libs-release-local/org/springframework/spring/4.3.8.RELEASE/spring-framework-4.3.8.RELEASE-dist.zip
意料之外全在情理之中
08-19
意料之外全在情理之中
全国卷作文公布：出乎意料与情理之中.doc
02-14
全国卷作文公布：出乎意料与情理之中.doc
Java并发编程（5）volatile变量修饰符-意料之外
11-22
然而，使用`volatile`并非总是如我们所期望的那样简单，有时会出现一些意料之外的问题。本篇文章将深入探讨`volatile`关键字在并发编程中的作用、限制以及可能导致的问题。 首先，`volatile`关键字的主要功能是解决...
nhibernate+spring.net+mvc3.0项目
12-03
对应博客园系列的源码,http://www.cnblogs.com/lippor/p/4137224.html
spring-net:.NET的Spring框架
04-27
SPRING.NET FRAMEWORK，版本3.0.0（预发布） 1.引言 Spring.NET的3.0.0版本包含 功能齐全的控制容器倒置 面向方面的编程框架 用于轻量级脚本编写的表达语言 与UI无关的验证框架 ASP.NET框架页面和用户控件的依赖注入，双向数据绑定等。 ASP.NET MVC和ASP.NET WebAPI框架MVC依赖注入（包括WebAPI）。 声明式事务管理抽象通过使用跨不同事务API的通用XML配置和属性进行声明式事务管理 ADO.NET框架 简化ADO.NET的使用。 DAO支持类以及与Spring的声明式事务管理功能的集成 可移植服务抽象通过.NET Remoting，Web Service或.NET Serviced Component导出纯.NET对象，并基于终结点URL和服务接口创建客户端代理。 NHibernate整合NHibernate
Spring.net框架
06-11
你真的了解Ioc与AOP吗？ 收藏 你真的了解Ioc与AOP吗？我现在还不是很了解，而且越学习越发现自己了解的很少，Ioc与AOP中蕴涵了大量的能量等待我们去开发。在这个系列 中，我仅仅利用Sping.net这个框架向大家展示一下Ioc与AOP的强大功能（呵呵，其实写这段话的目的是因为“文章题目”牛皮吹得有点大了，给自 己个台阶下罢了）。 在这个系列中一共包含6个案例，从简单到复杂，也是对问题分解、思考和解决的一个过程，它们分别是： （1）类之间的依赖； 降低 （2）接口依赖； （3）基 于配置文件和Reflection的工厂模式； （4）使用Spring.net实现Ioc； （5）Romoting； （6）利用Ioc在不动一行代码的情 况下实现Remoting。为了更好的理解文中的内容，最好顺序阅读。 作为一个应用系统，代码复用至关重要。如果在你的设计中，类与类存在很强的相互关联，那么你会发现在重用这些组件时就存在很严重的问题。在 Step1到Step3-Reflection的例子中，我们试图 利用“针对接口编程”以及自己设计的Ioc对系统进行解耦。在Step3到Step5的例子中，我们将利用Spring.net提供的Ioc框架，轻松完 成解耦以及系统改造等工作。 一、类之间的依赖 我们的第一个例子主要用于说明程序的基本构造，并且作为一个反面典型，引出为什么要解耦，以及如何下手。在这个例子中，我们将创建三个程序集，分别是MainApp.exe、HelloGenerator.dll以及SayHello.dll。它们之间的关系如下图所示： HelloGenerator类根据提供的姓名产生一个问候字符串，代码如下： using System; namespace IocInCSharp { public class EnHelloGenerator { public string GetHelloString(string name) { return String.Format("Hello, {0}", name); } } } SayHello类持有一个对EnHelloGenerator的引用，并负责将生成出来的问候字符串打印出来。 using System; namespace IocInCSharp { public class SayHello { private EnHelloGenerator _helloGen; public EnHelloGenerator HelloGenerator { get { return _helloGen; } set { _helloGen = value; } } public void SayHelloTo(string name) { if(_helloGen != null) Console.WriteLine(_helloGen.GetHelloString(name)); else Console.WriteLine("Client.hello is not initialized"); } } } MainApp.exe负责完成对象的创建、组装以及调用工作： using System; namespace IocInCSharp { public class MainApp { public static void Main() { SayHello sayHello = new SayHello(); sayHello.HelloGenerator = new EnHelloGenerator(); sayHello.SayHelloTo("zhenyulu"); } } } 在这个设计中，组件与组件之间、类与类之间存在着紧密的耦合关系。SayHello类中的_helloGen字段类型为 EnHelloGenerator，这将导致我们很难给它赋予一个其它的HelloGenerator（例如CnHelloGenerator，用于生成 中文问候语）。另外MainApp也严重依赖于SayHello.dll以及HelloGenerator.dll，在程序中我们可以看到类似new SayHello();new EnHelloGenerator();的命令。 这种紧密的耦合关系导致组件的复用性降低。试想，如果想复用SayHello组件，那么我们不得不连同HelloGenerator一同拷贝过去， 因为SayHello.dll是依赖与HelloGenerator.dll的。解决这个问题的办法就是“针对抽象（接口）”编程 （依赖倒置原则）。这里的抽象既包括抽象类也包括接口。我不想过多的去谈抽象类和接口的区别，在后续的例子中我们将使用接口。由于接口在进行“动态代理” 时仍能保持类型信息，而抽象类可能由于代理的原因导致继承关系的“截断”（如MixIn等）。除此之外，对于单继承的C#语言而言，使用接口可以拥有更大 的弹性。 二、接口依赖 既然类之间的依赖导致耦合过于紧密，按照《设计模式》的理论，我们要依赖于接口。但是人们往往发现，仅仅依赖于接口似乎并不能完全解决问题。我们从上面的例子中抽象出接口后，组件间的依赖关系可能变成如下图所示： 经过改造后，SayHello不再依赖于具体的HelloGenerator，而是依赖于IHelloGenerator接口，如此一来，我们可以 动态的将EnHelloGenerator或是CnHelloGenerator赋给SayHello，其打印行为也随之发生改变。接口的定义以及改造后 的SayHello代码如下（为了节省空间，将代码合并书写）： using System; namespace IocInCSharp { public interface IHelloGenerator { string GetHelloString(string name); } public interface ISayHello { IHelloGenerator HelloGenerator{ get; set; } void SayHelloTo(string name); } public class SayHello : ISayHello { private IHelloGenerator _helloGen; public IHelloGenerator HelloGenerator { get { return _helloGen; } set { _helloGen = value; } } public void SayHelloTo(string name) { if(_helloGen != null) Console.WriteLine(_helloGen.GetHelloString(name)); else Console.WriteLine("Client.hello is not initialized"); } } } 但是我们的MainApp似乎并没有从接口抽象中得到什么好处，从图中看，MainApp居然依赖于三个组件：ICommon.dll、 HelloGenerator.dll以及SayHello.dll。这是由于MainApp在这里负责整体的“装配”工作。如果这三个组件中的任何一个 发生变化，都将导致MainApp.exe的重新编译和部署。从这个角度来看，似乎“针对接口编程”并没有为我们带来太多的好处。 如果能够将“组件装配”工作抽象出来，我们就可以将MainApp的复杂依赖关系加以简化，从而 进一步实现解耦。为此，我们引入“工厂”模式，并利用配置文件和反射技术，动态加载和装配相关组件。 三、基于配置文件和Reflection的工厂模式 为了消除MainApp对其它组件的依赖性，我们引入工厂模式，并且根据配置文件指定的装配规程，利用.net提供的反射技术完成对象的组装工作。 本部分代码仅仅提供一种功能演示，如果实际应用仍需进一步完善（建议使用一些成型的Ioc框架，例如Spring.net或Castle等）。经过改造后 的系统，组件间依赖关系如下图： 可以看出这次实现了真正的“针对接口编程”。所有的组件只依赖于接口。MainApp所需的对象是由工厂根据配置文件动态创建并组装起来的。当系统 需求发生变化时，只需要修改一下配置文件就可以了。而且MainApp、SayHello和HelloGenerator之间不存在任何的依赖关系，实现 了松耦合。 这是如何实现的呢？我们首先要能够解析配置文件中的信息，然后建立包含相关信息的对象。最后根据这些信息利用反射机制完成对象的创建。首先我们看一下配置文件所包含的内容： 从中我们可以看出，我们实现了一个IocInCSharp.ConfigHandler类，用来处理配置文件中IocInCSharp\ objects结点中的内容。ConfigHandler类将根据该结点下的内容处理并创建一ConfigInfo对象（关于ConfigInfo、 ObjectInfo以及PropertyInfo的代码可自行查看源代码，这里就不再赘述）。ConfigHandler类的代码实现如下： using System; using System.Configuration; using System.Xml; namespace IocInCSharp { public class ConfigHandler:IConfigurationSectionHandler { public object Create(object parent, object configContext, System.Xml.XmlNode section) { ObjectInfo info; PropertyInfo propInfo; ConfigInfo cfgInfo = new ConfigInfo(); foreach(XmlNode node in section.ChildNodes) { info = new ObjectInfo(); info.name = node.Attributes["name"].Value; info.assemblyName = node.Attributes["assembly"].Value; info.typeName = node.Attributes["typeName"].Value; foreach(XmlNode prop in node) { propInfo = new PropertyInfo(); propInfo.propertyName = prop.Attributes["name"].Value; propInfo.assemblyName = prop.Attributes["assembly"].Value; propInfo.typeName = prop.Attributes["typeName"].Value; info.properties.Add(propInfo); } cfgInfo.Objects.Add(info); } return cfgInfo; } } } 通过ConfigHandler的解析，我们最终得到一个ConfigInfo实例，Factory就是根据这个实例中所包含的配置信息，利用反射技术对所需对象生成并组装的。SayHelloFactory的代码如下： using System; using System.IO; using System.Configuration; using System.Reflection; namespace IocInCSharp { public class SayHelloFactory { public static object Create(string name) { Assembly assembly; object o = null; object p; string rootPath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) + Path.DirectorySeparatorChar; ConfigInfo cfgInfo = (ConfigInfo)ConfigurationSettings.GetConfig("IocInCSharp/objects"); ObjectInfo info = cfgInfo.FindByName(name); if(info != null) { assembly = Assembly.LoadFile(rootPath + info.assemblyName); o = assembly.CreateInstance(info.typeName); Type t = o.GetType(); for(int i=0; i<info.properties.Count; i++) { PropertyInfo prop = (PropertyInfo)info.properties[i]; assembly = Assembly.LoadFile(rootPath + prop.assemblyName); p = assembly.CreateInstance(prop.typeName); t.InvokeMember(prop.propertyName, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.SetProperty, null, o, new Object[] {p}); } } return o; } } } 在上面这段代码中，重点注意三条命令的使用方法： assembly = Assembly.LoadFile(rootPath + prop.assemblyName); p = assembly.CreateInstance(prop.typeName); t.InvokeMember(prop.propertyName, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.SetProperty, null, o, new Object[] {p}); Assembly.LoadFile()用于将外部文件装载进来；assembly.CreateInstance()根据装载进来的程序集创建一指定类型的对象；t.InvokeMember(prop.propertyName, ........BindingFlags.SetProperty, null, o, new Object[] {p})利用反射机制对创建出来的对象设置属性值。 我们的Factory就是利用这种方式根据配置文件动态加载程序集，动态创建对象并设置属性的。有了这个Factory，MainApp中的内容就很简单了： using System; namespace IocInCSharp { public class MainApp { public static void Main() { ISayHello sayHello = (ISayHello)SayHelloFactory.Create("SayHello"); if(sayHello != null) sayHello.SayHelloTo("zhenyulu"); else Console.WriteLine("Got an Error!"); } } } 现在，MainApp只依赖于接口，不再依赖于其它组件，实现了松耦合。在本例子中，大家可以尝试将配置文件中的IocInCSharp.CnHelloGenerator更改为IocInCSharp.EnHelloGenerator，看看是否输出内容由中文变为了英文。这便是“注入”的效果。 从上面这个例子我们可以看出，通过自定义配置文件和.net中的Reflection技术，我们自己就可以开发Ioc应用，根据配置文件的信息自行 组装相应的对象。但是Reflection编程的技术门槛还是比较高的，并且在实际应用中配置文件的格式、Handler的设计都不是象上面代码那样的简 单。不过幸好我们现在有很多的Ioc容器可供选择，它们都提供了完整的依赖注入方式，并且比自己写代码更加成熟、更加稳定。使用这些框架可以让程序员在三 两行代码里完成“注入”工作。在我们下一个案例中，我们将使用Spring.net实现依赖注入。我们会发现仅仅添加几行代码并更改一下配置文件就可轻松 实现依赖注入。 四、使用Spring.net实现依赖注入 Spring在Java界可是响当当的名字，现在也有.net平台下的Spring框架了，那就是Spring.net。用户可以从http://www.springframework.net/下载到Spring.net的最新版本。本例子中使用的版本为“Spring Interim Build August 15, 2005 ”，并对Spring.Services组件中的Remoting部分做了微小调整，删除了代码中用于输出的部分命令。 Spring.net为我们提供了一种基于配置文件的注入方式，目前Spring.net允许将值注入到属性，也允许将一个工厂绑定到属性，工厂的 产品将注入属性；除此之外，Spring.net还允许将一个方法的返回结果绑定到属性；它还可以在绑定之前强制进行初始化。另外Spring.net还 专门针对.net提供了Remoting以及Windows Service的“注入”方式。Spring.AOP允许完成横切（不过目前是调用的是AopAlliance的代码）。 尽管我对基于配置文件的注入方式仍然有些偏见（我认为它很难Debug、难于理解、没有编译时错误校验、编写效率比较低。另外它还存在安全隐患 ，恶意用户可以借助修改配置文件将恶意代码注入系统。因此，Spring.net在Web开发中应当更具优势），但这并不能掩盖Spring.net的光 芒（据说Castle比Spring.net要好，但目前我还没有尝试过使用Castle）。使用Spring.net，我们只需修改两三行代码，并提供 相应配置文件，就可以轻松实现Ioc。应用Spring.net后，我们的系统依赖关系如下图所示： 　 从图中可以看出，MainApp、SayHello、HelloGenerator之间并不存在任何依赖关系，它们都依赖于抽象出来的接口文件。除 此之外，MainApp还依赖于Spring.net，这使得MainApp可以借助Spring.net实现组件动态创建和组装。 对于原有代码，我们几乎不用作任何调整，唯一需要修改的就是MainApp中的调用方法，代码如下： using System; using System.Configuration; using Spring.Context; namespace IocInCSharp { public class MainApp { public static void Main() { try { IApplicationContext ctx = ConfigurationSettings.GetConfig("spring/context") as IApplicationContext; ISayHello sayHello = (ISayHello)ctx.GetObject("mySayHello"); sayHello.SayHelloTo("zhenyulu"); } catch (Exception e) { Console.WriteLine(e); } } } } 首先我们要添加对Spring.Context命名空间的引用，然后解析配置文件的"spring/context"结点，得到一 IApplicationContext对象（就好比在上一个例子中我们得到的ConfigInfo对象一样），剩下的事情就是向该Context索要相 关的对象了(ISayHello)ctx.GetObject("mySayHello")，其中"mySayHello"由配置文件指定生成方式和注入 方式。 配置文件的内容如下： 注意观察结点，就是由这里定义对象间相互依赖关系的。其中的结点定义了对什么属性执行注入，以及注入的内容是什么（）。大家可以尝试将改为，看一看程序执行结果有什么变化来体会Spring.net的Ioc功能。 如果读者读到这里仍然觉得Ioc没有什么的话，那让我们再来看一个更为复杂的例子。在当前例子中，MainApp通过依赖注入调用了 HelloGenerator的功能，但所有的调用都发生在本地。当前程序是一个地地道道的本地应用程序。现在如果要求在不更改一行代码的情况下，将 HelloGenerator.dll放到另外一台计算机上，MainApp通过远程调用（Remoting）来访问HelloGenerator的功 能。这似乎就有一定的难度了。 这么作并不是没有任何依据，其实Ioc除了可以实现依赖注入外，我们还应当看到它可以将我们从复杂的物理架构中解脱出来，专心于业务代码的开发。系 统开发中关键是逻辑分层。在一个系统不需要Remoting时，开发的系统就是本地应用程序；当需要Remoting时，不用修改任何代码就可以将系统移 植为分布式系统。Ioc使这一切成为可能。Rod Johnson在他的《J2EE without EJB》一书中有着详细的论述，很值得一读。据说该书的中文译本今年九月份出版（呵呵，就是这个月，不过我还没有看到市面上有卖的）。 为了能够更深入的分析在“Remoting”改造过程中我们可能遇到的麻烦，在后续两部分内容中，我们将分别介绍不使用Ioc的Remoting改造以及使用Ioc的改造，并比较两者之间的区别。 五、使用Remoting对原有系统进行改造 如果使用Remoting技术对HelloGenerator进行改造，使其具有分布式远程访问能力，那么在不使用Ioc技术的情况下，我们将会作出如下调整： （1）让HelloGenerator继承自MarshalByRefObject类 如果要让某个对象具有分布式的功能，必须使其继承自MarshalByRefObject，这样才可以具有远程访问的能力。因此我们需要调整EnHelloGenerator和CnHelloGenerator的代码。这里以EnHelloGenerator为例: using System; namespace IocInCSharp { public class EnHelloGenerator : MarshalByRefObject, IHelloGenerator { public string GetHelloString(string name) { return String.Format("Hello, {0}", name); } } } （2）将修改后的HelloGenerator发布出去 在这一步中，我们创建了一个新的Console应用程序RemotingServer，并在其中注册了一个Channel，发布服务并进行监听。代码如下： using System; using System.Configuration; using System.Collections; using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Http; using System.Runtime.Serialization.Formatters; namespace IocInCSharp { public class Server { public static void Main() { int port = Convert.ToInt32(ConfigurationSettings.AppSettings["LocalServerPort"]); try { BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider(); BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider(); serverProvider.TypeFilterLevel = TypeFilterLevel.Full; IDictionary props = new Hashtable(); props["port"] = port; props["timeout"] = 2000; HttpChannel channel = new HttpChannel(props, clientProvider, serverProvider); ChannelServices.RegisterChannel(channel); RemotingConfiguration.RegisterWellKnownServiceType( typeof(EnHelloGenerator), "HelloGenerator.soap", WellKnownObjectMode.Singleton); Console.WriteLine("Server started!\r\nPress ENTER key to stop the server..."); Console.ReadLine(); } catch { Console.WriteLine("Server Start Error!"); } } } } （3）全新的客户端调用代码 为了使得客户端MainApp能够调用到远程的对象，我们需要修改它的代码，注册相应的Channel并进行远程访问。修改后的MainApp代码如下： using System; using System.Configuration; using System.Collections; using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Http; using System.Runtime.Serialization.Formatters; namespace IocInCSharp { public class MainApp { public static void Main() { //建立连接 BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider(); BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider(); serverProvider.TypeFilterLevel = TypeFilterLevel.Full; IDictionary props = new Hashtable(); props["port"] = System.Convert.ToInt32(ConfigurationSettings.AppSettings["ClientPort"]); HttpChannel channel = new HttpChannel(props, clientProvider, serverProvider); ChannelServices.RegisterChannel(channel ); //创建远程对象 ISayHello sayHello = new SayHello(); string RemoteServerUrl = ConfigurationSettings.AppSettings["RemoteServerUrl"]; sayHello.HelloGenerator = (IHelloGenerator)Activator.GetObject(typeof(IHelloGenerator), RemoteServerUrl); sayHello.SayHelloTo("zhenyulu"); } } } 在这段代码中，远程对象的创建是通过(IHelloGenerator)Activator.GetObject(typeof(IHelloGenerator), RemoteServerUrl)实现的。到此为止，我们就完成了对原有系统的Remoting改造。 经过调整后的系统，其组件间相互依赖关系如下图所示： 注意ICommon.dll文件在Client和Server端都有。 在整个调整过程中，我们修改了Server端的EnHelloGenerator以及CnHelloGenerator的代码，Client端的 MainApp也 作了修改，以加入了远程访问机制。那么能不能对原有代码不作任何修改就实现远程访问机制呢？当然可以！不过我们还要请出Sping.net帮助我们实现这 一切。 六、利用Ioc在不修改任何原有代码的情况下实现Remoting 上文我们提到，为了实现对HelloGenerator.dll的分布式调用，我们不得不修改了原有程序的多处代码。那么有没有可能在不动任何原有 代码的情况下，单纯靠添加组件、修改配置文件实现远程访问呢？当然可以。这次我们还是使用Spring.net完成这个工作。 经过调整后的系统组件构成如下图所示： 该方案没有修改“src\Step3”中的任何代码，仅仅通过修改配置文件和添加了若干个组件就实现了远程访问。修改方案如下： （1）使用Proxy模式代理原有HelloGenerator 如果要让某个对象具有分布式的功能，必须使其继承自MarshalByRefObject。但是由于不能修改任何原有代码，所以这次我们只能绕道而 行， 借助Proxy模式代理原有的HelloGenerator。在RemotingServer项目中，我们定义了一个新类 HelloGeneratorProxy继承自MarshalByRefObject，通过委派的方式对原有的HelloGenerator进行调用，代 码如下： using System; namespace IocInCSharp { public class HelloGeneratorProxy : MarshalByRefObject, IHelloGenerator { private IHelloGenerator _helloGen; public IHelloGenerator HelloGenerator { get { return _helloGen; } set { _helloGen = value; } } public string GetHelloString(string name) { if(_helloGen != null) return _helloGen.GetHelloString(name); return null; } } } 仔细观察，我们会发现HelloGeneratorProxy持有一个对IHelloGenerator的引用，该属性是可以Set的，因此我们可 以借助Ioc的威力，通过调整Sping.net的配置文件动态决定远程服务器究竟发布EnHelloGenerator还是 CnHelloGenerator。 （2）发布HelloGeneratorProxy 通过RemotingServer.exe，我们将HelloGeneratorProxy发布出去，客户端实际上调用的是Proxy对象（不用担心，由于“针对接口编程”，客户端只知道它是IHelloGenerator类型对象）。服务器端代码如下： using System; using System.Configuration; using System.Collections; using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Http; using System.Runtime.Serialization.Formatters; using Spring.Context; namespace IocInCSharp { public class Server { public static void Main() { int port = Convert.ToInt32(ConfigurationSettings.AppSettings["LocalServerPort"]); try { BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider(); BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider(); serverProvider.TypeFilterLevel = TypeFilterLevel.Full; IDictionary props = new Hashtable(); props["port"] = port; props["timeout"] = 2000; HttpChannel channel = new HttpChannel(props, clientProvider, serverProvider); ChannelServices.RegisterChannel(channel); IApplicationContext ctx = ConfigurationSettings.GetConfig("spring/context") as IApplicationContext; HelloGeneratorProxy proxy = (HelloGeneratorProxy)ctx.GetObject("myHelloGeneratorProxy"); RemotingServices.Marshal(proxy, "HelloGenerator.soap"); Console.WriteLine("Server started!\r\nPress ENTER key to stop the server..."); Console.ReadLine(); } catch { Console.WriteLine("Server Start Error!"); } } } } 注意其中的几条命令： IApplicationContext ctx = ConfigurationSettings.GetConfig("spring/context") as IApplicationContext; HelloGeneratorProxy proxy = (HelloGeneratorProxy)ctx.GetObject("myHelloGeneratorProxy"); RemotingServices.Marshal(proxy, "HelloGenerator.soap"); 我们使用Ioc向HelloGeneratorProxy注入具体的HelloGenerator对象，并通过 RemotingServices.Marshal(proxy, "HelloGenerator.soap")命令将该实例发布出去。服务器端的配置文件如下： 用户可以尝试将配置文件中更改为，重新启动服务后看看客户端调用结果是什么？ （3）客户端实现技术-1 客户端实现起来要麻烦一些。由于不允许修改MainApp中的任何代码，我们必须能够在合适的时机拦截代码运行并创建远程连接，同时确保在Ioc注 入时注入的是远程对象。所有这些工作Sping.net都考虑的很周到。它提供了depends-on属性，允许在执行某一操作前强制执行某段代码。在客 户端的配置文件中，我们可以看到如下的配置选项： ......... 这表示，当我们初始化mySayHello时，要先去调用ForceInit.dll文件中ForceInit类的Init方法。ForceInit是一个新编写的类，其主要目的就是创建并注册一个用于远程通讯的Channel。代码实现如下： using System; using System.Collections; using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Http; using System.Runtime.Serialization.Formatters; namespace IocInCSharp { public class ForceInit { public static void Init() { //建立连接 BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider(); BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider(); serverProvider.TypeFilterLevel = TypeFilterLevel.Full; IDictionary props = new Hashtable(); props["port"] = 8199; props["name"] = "myHttp"; HttpChannel channel = new HttpChannel(props, clientProvider, serverProvider); //获得当前已注册的通道； IChannel[] channels = ChannelServices.RegisteredChannels; //关闭指定名为MyHttp的通道； foreach (IChannel eachChannel in channels) if (eachChannel.ChannelName == "myHttp") ChannelServices.UnregisterChannel(eachChannel); ChannelServices.RegisterChannel(channel); } } } （4）客户端实现技术-2 剩下的工作就是为mySayHello的HelloGenerator注入远程对象。通常情况下我们需要使用 Activator.GetObject方法调用远程对象，不过Spring.net已经将其封装起来，我们只需修改一下配置文件，就可以确保调用到远程 对象。配置文件对应部分如下： ...... IocInCSharp.IHelloGenerator, ICommon http://127.0.0.1:8100/HelloGenerator.soap 借助Spring.Remoting.SaoFactoryObject，我们轻松实现了远程对象访问，不必书写一行代码。（目前SAO在 Spring.net的实现尚不完整，按照Spring.net帮助手册上的做法，通过配置文件只能实现客户端访问远程对象，还做不到服务器端发布远程对 象） （5）使用AOP拦截调用 Sping.net目前已经实现AOP功能，我们可以很容易的对方法进行拦截和调用。需要做的工作就是设计相应的Interceptor，然后修改 配置文件。目前Sping.net使用的AOP功能是AopAlliance的实现，因此代码编写时命名空间引用让人感觉多少有些别扭，不是以Sping 开头。我编写的MethodInterceptor代码如下： using System; using AopAlliance.Intercept; namespace IocInCSharp { class MethodInterceptor : IMethodInterceptor { public object Invoke(IMethodInvocation invocation) { Console.WriteLine("Before Method Call..."); object returnValue = invocation.Proceed(); Console.WriteLine("After Method Call..."); return returnValue; } } } 在方法调用前打印"Before Method Call..."，在方法调用后打印"After Method Call..."。剩下的工作就是修改配置文件，将其应用到相应的方法上。配置文件片断如下： ...... MethodAdvice 通过以上操作，我们在没有修改任何原有代码的情况下，让原有系统实现了远程分布式访问。 请大家访问示例代码的“bin\Step5"目录，下面有3个子目录：Server、Client、WithoutRemoting。首先运行 Server目录下的RemotingServer.exe，然后运行Client目录下的MainApp.exe进行远程调用。系统通过 Remoting完成远程调用。关闭所有程序后，进入到WithoutRemoting目录，里面有个Readme.txt文件，按照操作步骤将文件： ..\Server\HelloGenerator.dll ..\Client\MainApp.exe ..\Client\ICommon.dll ..\Client\SayHello.dll ..\Client\Spring.Core.dll ..\Client\log4net.dll 　 拷贝到该目录，再次运行MainApp.exe，你会发现它是一个地地道道的本地应用程序！本地与远程唯一的区别就是配置文件的不同以及增加了几个其它的DLL。这正式我们这个示例的价值体现。 到此为止，我们完成了对Ioc应用的一系列模拟。Ioc写得多一些，AOP写得少了点。欢迎大家批评指正。
Spring.Net-功能
dxm809的博客
02-18 279
Spring.Net主要有以下三个功能： 1 IoC：Inversion of Control 控制翻转：就是创建对象的权利由开发人员自己控制New，转到了由容器来控制。 2 DI:Dependency Injection 依赖注入：就是在通过容器来创建对象的时候，在对象的初始化是可以给一些属性、构造方法的参数等注入默认值（可以是复杂的类型. 3 Aop--权限校验--日志处理。类似微软的...
spring.net 基本用法
sd6275832ght的博客
05-02 320
首先明白两个概念 Ioc:控制翻转 就是创建对象的权利由开封人员自己控制New,转到了由容器来控制 DI: 依赖注入，就是通过容器来创建对象的时候，在对象初始化是可以给一些属性，构造方法的参数等注入默认值可以是复杂类型 而spring.net 本质就是在容器中解决对象的创建问题 首先要引入相关的DLL 文件 Spring.Core.dll ，Spring.Core.pdb ，Spring.Core...
Spring.NET初识
学习编程，热爱编程
04-17 1564
最近参与的ITOO高校平台开发过程中用到了Spring.Net很多东西，IOC，AOP等，下面对Spring.Net做一个基本的认识。 什么是Spring.Net        Spring.NET是一个应用程序框架，其目的是协助开发人员创建企业级的.NET应用程序。它提供了很多方面的功能，比如依赖注入、面向方面编程（AOP）、数据访问抽象及ASP.NET扩展等等。Spring.NET以Jav
spring.net结合普通三层（实现IOC 及AOP中的异常记录功能）
Littleree的博客
06-18 97
spring.net结合普通三层（实现IOC 及AOP中的异常记录功能）
C#/.Net企业级系统架构设计实战精讲教程
12-03
课程通过实际项目融入常用开发技术架构，讲授风格独特，提供详细上课日志及答疑，赠送配套的项目架构源码注释详细清晰且表达通俗，均能直接在实际项目中应用，正真的物超所值，价格实惠任务作业：综合运用《C#/.Net企业级系统架构设计实战精讲教程》课程所学知识技能设计一个学生成绩管理系统的架构。要求：1.系统基于MVC的三层架构，各层单独建不同的解决方案文件夹。2.采用Model First开发方式，设计架构时只需要设计学生表（TbStudent）和课程表（TbCourse）。学生表必须有的字段是ID、stuName、age；课程表必须有的字段是ID、courseName、content。3.数据访问层采用Entity Framework或NHibernate来实现，必须封装对上述表的增删改查方法。4.必须依赖接口编程，也就是必须要有数据访问层的接口层、业务逻辑层的接口层等接口层。层层之间必须减少依赖，可以通过简单工厂或抽象工厂。5.至少采用简单工厂、抽象工厂、Spring.Net等技术中的2种来减少层与层之间的依赖等。6.封装出DbSession类，让它拥有所有Dal层实例和SaveChanges方法。7.设计出数据访问层及业务逻辑层主要类的T4模板，以便实体增加时自动生成相应的类。8.表现层要设计相关的控制器和视图来验证设计的系统架构代码的正确性，必须含有验证增删改查的方法。9.开发平台一定要是Visual Studio平台，采用C#开发语言，数据库为SQL Server。10.提交整个系统架构的源文件及生成的数据库文件。（注意： 作业需写在CSDN博客中，请把作业链接贴在评论区，老师会定期逐个批改~~）
Spring的IOC原理
渣渣想逆袭
04-16 752
1. IoC理论的背景 我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。 图1：软件系统中耦合的对象 如果我们打开机械式手表的后盖，就会看到与上面类似的情形，各个齿轮分别带动时针、分针和秒针顺时针旋转，从而在表盘上产生正确的时间。图1中描述的就是这样的一个齿轮组，它拥有多个独立的齿轮，这些齿轮相互啮合在一起，
方正证券_0823_“聚沙成塔”创新产品系列之四：杠杆反向基金，意料之外的收益.pdf
最新发布
07-28
市场普遍认为杠反基金在趋势明显的市场中表现较好，而在震荡市中表现不佳。这一观点基于波动率拖累理论，即当市场波动率较低且涨跌幅偏离0时，杠反基金的收益差距会扩大，从而可能跑赢预期。然而，杠杆的选择并非...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值