Re: [Springframework-developer] Extending Spring AOP

[Dmitriy K. <dko...@ru...>]

Rob/Rod,

can you please summarize the reasons to create another proxy 
implementation strategy?

Thanks,
Dmitriy.

Rob Harrop wrote:

> I agree, I'll put together a quick prototype either today or next week 
> to see how a specificically created proxy will perform.
>
> Rob
>
> Rod Johnson wrote:
>
>> Rob
>>
>> I would favour the Java code-based approach, using Velocity. I think 
>> that should deliver extremely good performance, and would rather we 
>> don't commit to maintaining a byte code approach.
>>
>> I don't believe there is any problem using code generation with our 
>> API. Indeed, I always meant to implement it, but performance 
>> optimization of the AOP framework has never been of any significance 
>> in practice. Only for marketing, as has been apparent recently :-)
>>
>> A Java based approach should definitely allow significant 
>> optimization, and would hopefully be simpler than the CGLIB approach 
>> and more maintainable. So there would be a real advantage, besides 
>> performance. There should be a particular optimization for methods 
>> with only before or after advice, skipping the present use of an 
>> interceptor to wrap them. The
>>
>> I would recommend hand-authoring a Java class, and benchmarking, to 
>> see exactly what the gains are, before putting a lot of effort into 
>> the approach. (But I'm sure they'll be large.) But I think this is 
>> definitely good stuff!
>>
>> Rgds
>> Rod
>>
>> Rob Harrop wrote:
>>
>>> All,
>>>
>>> I am planning to add to an additional proxy implementation to Spring 
>>> to solve some of the problems we are experiencing with other 
>>> approaches and to allow for additional optimizations and advice 
>>> types to be added in the most efficient way.
>>>
>>> Currently, I'm looking at two separate approaches - Java-based using 
>>> Janino and Bytecode-based using SERP. The Java-based approach should 
>>> be quite simple to create and could be coupled with Velocity to 
>>> externalize much of the boilerplate code needed for the creation of 
>>> proxy classes. Alternatively we could add a simple abstraction layer 
>>> on top of Janino, a la .NET CodeDOM (good idea James). The bytecode 
>>> approach is much more complex and will be harder to debug but it 
>>> would probably allow for absolute raw performance.
>>>
>>> I am comfortable with either approach although I think that Janino 
>>> would be ideal for our purposes.
>>>
>>> Your thoughts?
>>>
>>> Rob
>>>
>>>
>>> -------------------------------------------------------
>>> SF email is sponsored by - The IT Product Guide
>>> Read honest & candid reviews on hundreds of IT Products from real 
>>> users.
>>> Discover which products truly live up to the hype. Start reading 
>>> now. http://productguide.itmanagersjournal.com/
>>> _______________________________________________
>>> Springframework-developer mailing list
>>> Spr...@li...
>>> https://lists.sourceforge.net/lists/listinfo/springframework-developer
>>>
>>
>
>
> -------------------------------------------------------
> SF email is sponsored by - The IT Product Guide
> Read honest & candid reviews on hundreds of IT Products from real users.
> Discover which products truly live up to the hype. Start reading now. 
> http://productguide.itmanagersjournal.com/
> _______________________________________________
> Springframework-developer mailing list
> Spr...@li...
> https://lists.sourceforge.net/lists/listinfo/springframework-developer