Por que usamos o proxy dynamic?

Uma class de proxy dynamic é uma class que implementa uma lista de interfaces especificadas no tempo de execução, de modo que uma chamada de método por meio de uma das interfaces em uma instância da class será codificada e enviada para outro object por meio de uma interface uniforme. Ele pode ser usado para criar um object de proxy de tipo seguro para uma lista de interfaces sem exigir pré-geração da class de proxy. Classes de proxy dynamic são úteis para um aplicativo ou biblioteca que precisa fornecer envio reflexivo de chamadas em objects que APIs de interface presentes insira a descrição da imagem aqui

Acima foto é boa amostra, mas Por que usamos proxy dynamic?

Existe algum exemplo simples que use no mundo real, para mais percepção?

Este link descreve o proxy dynamic no código:

public static class DynamicProxyGenerator { public static T GetInstanceFor() { Type typeOfT = typeof(T); var methodInfos = typeOfT.GetMethods(); AssemblyName assName = new AssemblyName("testAssembly"); var assBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assName, AssemblyBuilderAccess.RunAndSave); var moduleBuilder = assBuilder.DefineDynamicModule("testModule", "test.dll"); var typeBuilder = moduleBuilder.DefineType(typeOfT.Name + "Proxy", TypeAttributes.Public); typeBuilder.AddInterfaceImplementation(typeOfT); var ctorBuilder = typeBuilder.DefineConstructor( MethodAttributes.Public, CallingConventions.Standard, new Type[] { }); var ilGenerator = ctorBuilder.GetILGenerator(); ilGenerator.EmitWriteLine("Creating Proxy instance"); ilGenerator.Emit(OpCodes.Ret); foreach (var methodInfo in methodInfos) { var methodBuilder = typeBuilder.DefineMethod( methodInfo.Name, MethodAttributes.Public | MethodAttributes.Virtual, methodInfo.ReturnType, methodInfo.GetParameters().Select(p => p.GetType()).ToArray() ); var methodILGen = methodBuilder.GetILGenerator(); if (methodInfo.ReturnType == typeof(void)) { methodILGen.Emit(OpCodes.Ret); } else { if (methodInfo.ReturnType.IsValueType || methodInfo.ReturnType.IsEnum) { MethodInfo getMethod = typeof(Activator).GetMethod(/span>"CreateInstance",new Type[]{typeof((Type)}); LocalBuilder lb = methodILGen.DeclareLocal(methodInfo.ReturnType); methodILGen.Emit(OpCodes.Ldtoken, lb.LocalType); methodILGen.Emit(OpCodes.Call, typeofype).GetMethod("GetTypeFromHandle")); )); methodILGen.Emit(OpCodes.Callvirt, getMethod); methodILGen.Emit(OpCodes.Unbox_Any, lb.LocalType); } else { methodILGen.Emit(OpCodes.Ldnull); } methodILGen.Emit(OpCodes.Ret); } typeBuilder.DefineMethodOverride(methodBuilder, methodInfo); } Type constructedType = typeBuilder.CreateType(); var instance = Activator.CreateInstance(constructedType); return (T)instance; } } 

Um caso de uso comum é para Programação Orientada a Aspectos , no qual você procura aplicar funcionalidade comum em vários componentes sem exigir que os próprios componentes implementem a funcionalidade. Nesses casos, você pode usar um proxy dynamic para agrupar todos os componentes de segmentação com comportamento adicional. Fazendo isso

Alguns exemplos:

  • ORMs, como o Hibernate e o Entity Framework, fazem isso para fornecer uma implementação de persistência em torno de um design de primeiro código. As classs de domínio principais são criadas sem qualquer conhecimento de sua persistência e as estruturas envolvem ou estendem essas classs na boot para manipular a implementação real.

  • Envolvendo todos os membros de uma interface com um aspecto como registro ou armazenamento em cache. Por exemplo, se você quiser registrar todas as chamadas de método no ISomeInterface, pode escrever um proxy dynamic que encontre todos os methods de interface, chame um método Log com os detalhes do método e, em seguida, passe a chamada para a implementação real.

Imagine que você tenha dois objects, Car and Motorboat, que implementam as interfaces CanDrive e CanFloat, respectivamente. Agora, você quer ter um terceiro object que implemente ambas as interfaces e reutilize a lógica do Car and Motorboat. Em linguagens como Groovy, Ruby e Scala você poderia resolver isso usando mixin. Em Java, no entanto, não existe tal coisa. É claro que você poderia usar, por exemplo, o padrão de design do conector, mas, em muitos casos (especialmente ao criar estruturas), o proxy dynamic é útil. Considere o exemplo que usa a biblioteca cglib:

 CanDrive car = new Car(); CanFloat motorboat = new Motorboat(); net.sf.cglib.proxy.Mixin amphibian = net.sf.cglib.proxy.Mixin.create(new Object[] { car, motorboat }); TestCase.assertEquals("bzzz bzzz bzzz ...", ((CanFloat) amphibian)._float()); TestCase.assertEquals("pyr pyr pyr pyr ...", ((CanDrive) amphibian).drive()); 

Você deve verificar este excelente artigo:
http://www.ibm.com/developerworks/java/library/j-jtp08305/index.html