深入浅出AOP（三）--WCF+AOP

Spring.NET的IOC容器解决的，就是如何在应用中将类、对象和服务组合成应用程序的问题。IOC容器通过很正统的方式将分散的组件组合成完整的应用程序。Spring.NET框架就应运而生了。

框架图：

其中Spring.NET Core是整个矿机阿德基础，实现了依赖注入的功能。Spring.AOP为业务对象提供面向切面编程的支持。Spring.WEB提供了客户端。Spring.Services允许将服务发布为企业服务或远程服务（WCF）。Spring.Data定义了一个抽象的数据访问层，可以跨越各种数据访问技术进行数据访问。Spring.ORM包含生命是事物管理等功能。

在ITOO中我们最终实现的AOP是这样的：

U层调用业务层，业务层调用AOP，这一步使用的AOP中拦截的思想，用特性标签进行实现的，AOP调用Service层，使用的是代理和容器，将远程的服务全部配置在配置文件中，应用代理，运行WCF提供的服务。

实现代码：

AOP项目中：

首先写拦截特性类：COntrollerAttribute类：

<span style="font-size:18px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using System.Web;

namespace AOP
{
[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]

       public sealed class ControllerAttribute

          : Attribute, IOperationBehavior

       {

         void IOperationBehavior.AddBindingParameters(OperationDescription operationDescription, BindingParameterCollection bindingParameters) { }

         void IOperationBehavior.ApplyClientBehavior(OperationDescription operationDescription, ClientOperation clientOperation) { }

         void IOperationBehavior.ApplyDispatchBehavior(OperationDescription operationDescription, DispatchOperation dispatchOperation)

         {
              dispatchOperation.Invoker = new ControllerInvoker(dispatchOperation.Invoker);
         }
           void IOperationBehavior.Validate(OperationDescription operationDescription) { }

     }
}</span>

写ControllerInvoker类：

<span style="font-size:18px;">using ITOO.UINonQueryProperties.Contracts;
using Spring.Context;
using Spring.Context.Support;
using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.ServiceModel.Dispatcher;
using System.Web;

namespace AOP
{
    internal sealed class ControllerInvoker

             : IOperationInvoker

        {
           private readonly IOperationInvoker Inner;

           public ControllerInvoker(IOperationInvoker inner)

           {
              Inner = inner;
          }

        public object[] AllocateInputs()
          {
               return Inner.AllocateInputs();
          }
           public object Invoke(object instance, object[] inputs, out object[] outputs)

            {
               // do something before invoking
                //Console.WriteLine("12354566778");

              object result =Inner.Invoke(instance, inputs, out outputs);

              IApplicationContext ctx = ContextRegistry.GetContext();

              try
              {
                  //foreach (IAdd proxy in ctx.GetObjectsOfType(typeof(IAdd)).Values)
                  //{
                  //    Console.WriteLine(string.Format("invocation result is :{0}", proxy.Add(1, 2)));
                  //    (proxy as ICommunicationObject ).Close();
                  //}

                  //
                  IUINonQueryPropertiesService proxy0 = ctx.GetObject("WsHttpBinding_Services") as IUINonQueryPropertiesService;     //应用代理模式提供服务的
                  Console.WriteLine(string.Format("invocation result is :{0}", proxy0.GetOneQueryPropertie("123")));
                  (proxy0 as ICommunicationObject).Close();
              }
              catch (Exception ex)
              {
                  Console.WriteLine(ex.StackTrace);
                  throw;
              }

              // do something after invoking
               return result;
           }
          public IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state)

           {

              throw new NotSupportedException();

           }

          public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result)

          {

               throw new NotSupportedException();

           }

           public bool IsSynchronous

          {

             get { return true; }

        }

     }
}</span>

我们配置XML文件，在该文件中进行配置WCF服务：

<span style="font-size:18px;"><?xml version="1.0" encoding="utf-8" ?>
<objects xmlns="http://www.springframework.net"
         xmlns:wcf="http://www.springframework.net/wcf">
  <!--<wcf:channelFactory channelType="Contracts.IAdd,Contracts"
						endpointConfigurationName="addService" id="addService">
	</wcf:channelFactory>-->
  <wcf:channelFactory channelType="ITOO.UINonQueryProperties.Contracts.IUINonQueryPropertiesService,ITOO.UINonQueryProperties.Contracts"
          endpointConfigurationName="WsHttpBinding_Services" id="WsHttpBinding_Services">
  </wcf:channelFactory>

</objects></span>

在App.config中读取上面的XML文件：

<span style="font-size:18px;"><?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections >
    <sectionGroup name="spring">
      <section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core"/>
      <section name="objects" type="Spring.Context.Support.DefaultSectionHandler,Spring.Core"/>
    </sectionGroup>
  </configSections>

  <spring>
    <context>
      <resource uri="assembly://AOP/AOP.Config/WCFServiceConfig.xml"></resource>
    </context>

  </spring>

  <system.serviceModel>

    <behaviors>
      <serviceBehaviors>
        <behavior name="">
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="true" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <serviceHostingEnvironment multipleSiteBindingsEnabled="true" />
    <bindings>

      <wsHttpBinding>

        <binding name="WsHttpBinding_Default"  transactionFlow="true" >

          <security mode="None">

            <transport clientCredentialType="None" proxyCredentialType="None" realm=""/>

            <message clientCredentialType="UserName" algorithmSuite="Default"/>

          </security>

        </binding>

      </wsHttpBinding>
    </bindings>

    <!--<client>
			<endpoint address="http://127.0.0.1:6633/AddService"
					  binding="basicHttpBinding"
					  contract="Contracts.IAdd" name="addService"></endpoint>
		</client>-->
    <client>
      <!--资源服务-->
      <!--<endpoint address="http://localhost:9914/Service.svc?wsdl"
					  binding="wsHttpBinding"
					  bindingConfiguration="WsHttpBinding_Default"
					  contract="ITOO.UINonQueryProperties.Contracts.IUINonQueryPropertiesService"
					  name="WsHttpBinding_Services"/>-->
      <!--<endpoint address="http://localhost:9914/Service.svc?wsdl"
      binding="wsHttpBinding"
      contract="ITOO.UINonQueryProperties.Contracts.IUINonQueryPropertiesService"
      name="UINonQueryPropertiesService"/>-->
      <endpoint address="http://localhost:9914/Service.svc?wsdl"
        binding="wsHttpBinding"
        bindingConfiguration="WsHttpBinding_Default"
        contract="ITOO.UINonQueryProperties.Contracts.IUINonQueryPropertiesService"
        name="WsHttpBinding_Services"/>
    </client>
  </system.serviceModel>
</configuration></span>

进行测试：

<span style="font-size:18px;">using ITOO.BasicStudent.Contracts;
using ITOO.BasicStudent.ViewModel;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace AOPTest
{
    class Program
    {
        static void Main(string[] args)
        {
            IBasicStudentService studentService = ServiceStudentFactory.GetStudentInfosService();
            List<StudentViewModel> stuclassList = new List<StudentViewModel>();
            StudentViewModel stuclass = new StudentViewModel();
            studentService.AddOneStudent(stuclass);
        }
    }
}
</span>

这里我们想要在AddOneStudent中加上服务，那么我们看到在客户端我们只需要在调用AddOneStudent的服务就可以了，具体在切面上有什么服务，我们直接在AOP项目的COntrollerInvoker中写就可以了。

我们想要在AddOneStudent方法上面家服务，就必须要拦截该方法，如果是MVC就可以使用Filter，如果是WCF我们就可以使用特性，一般普通的类都可以使用特性来进行拦截。

因为AddOneStudent为我们的业务，但是，实际上它也是一种WCF提供的远程服务，这个时候，我们就可以在Constract层中的这个方法上加上特性标签。

具体如下：

<span style="font-size:18px;">        /// <summary>
        /// 添加单个学生
        /// </summary>
        /// <param name="student">单个学生实体</param>
        /// <returns>bool</returns>
        [Controller]
        [OperationContract]
        void AddOneStudent(StudentViewModel student);</span>

这样就可以将该业务进行拦截了，要是改方法不是WCF服务，我们就可以直接在该方法的上面加上特性标签了。

总结：

其实，很多上面说到的一些东西，我并不是特别了解，很多都是人家已经写好资料，拿过来用的，知识在于理解，在于整理，在于积累，在于编织。

时间： 2024-10-28 22:58:55

深入浅出AOP（三）--WCF+AOP的相关文章

Expression&lt;Func&lt;T,TResult&gt;&gt;和Func&lt;T,TResult&gt; 与AOP与WCF

1>>Expression<Func<T,TResult>>和Func<T,TResult>http://www.cnblogs.com/xcsn/p/4520081.htmlhttp://www.cxyclub.cn/n/63037/http://q.cnblogs.com/q/37952/2>>AOP与WCFhttp://www.oschina.net/question/2245602_178068?sort=timehttp://www.c

浅谈Spring（三）AOP原理

一.概念术语 AOP(Aspect Oriented Programming):面向切面编程. 面向切面编程(也叫面向方面编程),是目前软件开发中的一个热点,也是Spring框架中的一个重要内容.利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率. 1. 切面(Aspect) 官方的抽象定义为"一个关注点的模块化,这个关注点可能会横切多个对象",在本例中,"切面"就是类TestAspect所关

spring基础知识（三）——aop

spring基础知识(三)--aop面向切面编程 1.概念术语 aop面向切面编程(Aspect ariented Programming) 在开始之前,需要理解Spring aop 的一些基本的概念术语(总结的个人理解,并非Spring官方定义): 切面(aspect):用来切插业务方法的类. 连接点(joinpoint):是切面类和业务类的连接点,其实就是封装了业务方法的一些基本属性,作为通知的参数来解析. 通知(advice):在切面类中,声明对业务方法做额外处理的方法. 切入点(poin

Spring框架 AOP(三)

AOP理论概述 Aspect Oriented Programming 面向切面编程 业界 AOP 实际上 OOP (面向对象编程 ) 延伸 -- OOP编程语言. AOP设计思想 AOP采取横向抽取机制,取代了传统纵向继承体系重复性代码(性能监视.事务管理.安全检查.缓存) 横向抽取代码复用,基于代理技术,在不修改原有对象代码情况下,对原有对象方法功能进行增强! ---- AOP 思想 Spring框架如何实现AOP Spring1.2 版本开始 开始支持AOP技术 (传统Spring AOP

Spring笔记（三）:Aop详解

一.Aop原理 (一)动态代理 1.详见:java进阶(七):详解JAVA代理 2.主要是Proxy 与 InvocationHandle r接口 (二)Cglib 实现 1.主要是 Enhancer 和 MethodInterceptor 接口 2.实现代码如下: <span style="font-size:18px;"> /** * 利用 cglib 实现 * @param targrt * @return */ public static Object getCgP

详解Spring面向切面编程（AOP)三种实现

一.什么是AOP AOP(Aspect Oriented Programming),即面向切面编程,可以说是OOP(Object Oriented Programming,面向对象编程)的补充和完善.OOP引入封装.继承.多态等概念来建立一种对象层次结构,用于模拟公共行为的一个集合.不过OOP允许开发者定义纵向的关系,但并不适合定义横向的关系,例如日志功能.日志代码往往横向地散布在所有对象层次中,而与它对应的对象的核心功能毫无关系对于其他类型的代码,如安全性.异常处理和透明的持续性也都是如此,这

Spring（三）--AOP【面向切面编程】、通知类型及使用、切入点表达式

1.概念:Aspect Oriented Programming 面向切面编程 在方法的前后添加方法 2.作用:本质上来说是一种简化代码的方式 继承机制 封装方法 动态代理 -- 3.情景举例 ①数学计算器接口[MathCalculator] int add(int i,int j); int sub(int i,int j); int mul(int i, int j); int div(int i,int j); 因为后面的通知方法需要返回值,所以在这里类型声明为 int 类型 public

Spring学习笔记三（AOP中的那些事）

1.前言 前两篇博客介绍了一下,Spring中的IOC容器,这篇来讲解一下Spring中的AOP的知识.  2.AOP基础知识 2.1 概念 AOP是一种面向切面编程,一种软件工程的编程范式.AOP关注的是程序中的共性的功能,开发时,将共性功能抽取出来制作成独立的模块,此时原始代码中将不再具有这些被抽取出来的共性功能代码.因此加强了代码的复用性,同时程序开发时可以只考虑个性化功能,不需要考虑共性的功能. 2.2 基本知识点 连接点:具有特定功能的方法,一般方法 切入点:具有共性功能的方法的统称的

Spring入门介绍-AOP(三)

AOP的概念 AOP是面向切面编程的缩写,它是一种编程的新思想.对我们经常提起的oop(面对对象编程)有一定的联系. AOP和OOP的关系 AOP可以说是oop的某一方便的补充,oop侧重于对静态的属性和方法组合为对象,使得逻辑更加清晰,而aop是是从动态角度考虑,处理过程中某个步骤或者阶段,是从动态角度考虑的. AOP的功能 主要处理事务,日志,安全,异常统计等功能. AOP的价值 AOP专门用于处理分布于各个各个模块中的交叉关注点的问题,在J2ee应用中.通常用AOP来处理一些具有横切性质的

The prefix &quot;aop&quot; for element &quot;aop:aspectj-autoproxy&quot; is not bound.

在使用spring  aop的时候报错了:The prefix "aop" for element "aop:aspectj-autoproxy" is not bound.原因是有一些地址没有被引入: 以下是一个完整配置AOP的例子. 首先是文件项目结构: SpringAOPTest.java import java.util.ArrayList; import java.util.List; import org.junit.Test; import org.s