blocks|key|727857|text|安全-在执行某些方法之前检查用户是否有适当的权限。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|727858|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Security - checking that users have appropriate permissions prior to executing certain methods.

blocks|key|728145|text|公共不变检验由于PostSharp+1.5将附带方面继承，甚至通过接口，它将提供许多新的机会。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|728146|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Public invariant checking. Since PostSharp 1.5 will come with aspect inheritance, even through interfaces, it will give a lot of new opportunities.

blocks|key|388475|text|安全性|type|unstyled|depth|inlineStyleRanges|entityRanges|data|388476|注入检查权限和阻止访问的代码。|unordered-list-item|388477|用于asp.net+for控件/for部件的更友好的错误消息|388478|注入代码，它捕获异常并在调试编译时写入堆栈跟踪，或者在错误编译时写入友好消息(如此处的内容：asp.net+/+MOSS2007的透明通用异常处理(带代码)+)。|offset|length|388479|性能|388480|注入设置perf计数器的代码，以了解应用程序运行速度慢的地方。|388481|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/280412/transparent-generic-exception-handling-for-aspnet-moss2007-with-code^0|0|0|0|1A|W|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|Y|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|Z|8|@]|9|@$I|10|J|11|1|12]]|A|$]]|$1|K|3|L|5|6|7|13|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|14|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Security

<ul>
<li>Inject code that checks permissions and blocks access</li>
</ul>

Friendlier error msgs for asp.net webcontrols/webparts

<ul>
<li>Inject code that catches exceptions and writes stacktrace when debug-compiled or friendly messages when error-compiled (like the stuff here: <a href="https://stackoverflow.com/questions/280412/transparent-generic-exception-handling-for-aspnet-moss2007-with-code">Transparent generic exception handling for asp.net / MOSS2007 (with code)</a> )</li>
</ul>

Performance

<ul>
<li>Inject code that sets perf counters to get an overview of where your app is slow</li>
</ul>

blocks|key|1923648|text|审定：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1923649|[NotNull]
public+string+Property1+{+get;+set;+}

[Length(Min+=+10,+Max+=+20)]
public+string+Property2+{+get;+set;+}

[Regex(Expression+=+@"[abc]{2}")]
public+string+Property3+{+get;+set;+}|code-block|syntax|javascript|1923650|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Validation:

<pre><code>[NotNull]
public string Property1 { get; set; }

[Length(Min = 10, Max = 20)]
public string Property2 { get; set; }

[Regex(Expression = @"[abc]{2}")]
public string Property3 { get; set; }
</code></pre>

blocks|key|728287|text|从这个面向方面的编程:模块的激进研究，Youtube视频直接借出的例子之一是绘画到一个显示器。在这个示例中，您有一个绘图程序，它由点、形状等组成，当这些对象发生更改时，您需要告诉显示更新自己。如果没有在一个方面处理它，你最终会重复你自己很多次。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|728288|正如我所理解的，AOP的创建是为了避免重复可能与业务逻辑无关的横切关注点。使用方面，您可以将这些关注点模块化为方面。其中一个例子是日志记录，但是有很多不同的事情可能最终会重复。从那以后，它一直在发展，不再是面向方面的编程，而是面向方面的建模。|728289|有关面向方面的编程的更多信息可以从以下来源找到：|728290|阅读：|unordered-list-item|728291|维基百科面向方面的编程|728292|728293|收听：|728294|软件工程无线电.第106集:+AOP简介|728295|软件工程电台-第11集:采访Gregor+Kiczales|728296|728297|观看：|728298|Google视频-+Anurag+Mendhekar:面向方面的编程(丹·弗里德曼的60岁生日)|728299|面向方面的编程:模块化的激进研究|728300|Youtube+-面向方面的建模-它是什么，它有什么好处|728301|728302|entityMap|0|LINK|mutability|MUTABLE|url|http://www.youtube.com/watch?v=cq7wpLI0hco|1|http://en.wikipedia.org/wiki/Aspect-oriented_programming|2|http://www.se-radio.net/2008/08/episode-106-introduction-to-aop/|3|http://www.se-radio.net/podcast/2006-04/episode-11-interview-gregor-kiczales|4|http://video.google.com/videoplay?docid=1875973989673234551&ei=xW4lSeWTD4Li2gL-son3Bg|5|6|http://www.youtube.com/watch?v=tzjRr3usV6I^0|3|P|0|0|0|0|1|0|B|1|1|0|1|0|K|2|1|0|T|3|1|0|1|0|1C|4|1|0|G|5|1|0|S|6|1|0^^$0|@$1|2|3|4|5|6|7|1M|8|@]|9|@$A|1N|B|1O|1|1P]]|C|$]]|$1|D|3|E|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1R|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1S|8|@]|9|@]|C|$]]|$1|K|3|L|5|J|7|1T|8|@]|9|@$A|1U|B|1V|1|1W]]|C|$]]|$1|M|3|-4|5|6|7|1X|8|@]|9|@]|C|$]]|$1|N|3|O|5|J|7|1Y|8|@]|9|@]|C|$]]|$1|P|3|Q|5|J|7|1Z|8|@]|9|@$A|20|B|21|1|22]]|C|$]]|$1|R|3|S|5|J|7|23|8|@]|9|@$A|24|B|25|1|26]]|C|$]]|$1|T|3|-4|5|6|7|27|8|@]|9|@]|C|$]]|$1|U|3|V|5|J|7|28|8|@]|9|@]|C|$]]|$1|W|3|X|5|J|7|29|8|@]|9|@$A|2A|B|2B|1|2C]]|C|$]]|$1|Y|3|Z|5|J|7|2D|8|@]|9|@$A|2E|B|2F|1|2G]]|C|$]]|$1|10|3|11|5|J|7|2H|8|@]|9|@$A|2I|B|2J|1|2K]]|C|$]]|$1|12|3|-4|5|6|7|2L|8|@]|9|@]|C|$]]|$1|13|3|-4|5|6|7|2M|8|@]|9|@]|C|$]]]|14|$15|$5|16|17|18|C|$19|1A]]|1B|$5|16|17|18|C|$19|1C]]|1D|$5|16|17|18|C|$19|1E]]|1F|$5|16|17|18|C|$19|1G]]|1H|$5|16|17|18|C|$19|1I]]|1J|$5|16|17|18|C|$19|1A]]|1K|$5|16|17|18|C|$19|1L]]]]

One of the examples which was loaned straight from this <a href="http://www.youtube.com/watch?v=cq7wpLI0hco" rel="noreferrer">Aspect Oriented Programming: Radical Research in Modularity, Youtube video</a> was painting to a display. In the example you have a drawing program, which consists of points, shapes, etc and when changes to those objects occur you need to tell the display to update itself. Without handling it in an aspect you end up repeating yourself quite a bit.

AOP, as I've understood it, was created for not repeating yourself for cross cutting concerns which might not have anything to do with business logic. With aspects you can modularize these concerns to aspects. One of the examples was logging but there are bunch of different things you might end up repeating. It has been evolving since and it's not any more about aspect-oriented programming but there's also aspect-oriented modelling.

More information about aspect oriented programming can be found from these sources:

<ul>
 <li>to read:
 <ul>
 <li><a href="http://en.wikipedia.org/wiki/Aspect-oriented_programming" rel="noreferrer">Wikipedia - Aspect-oriented programming</a></li>
 </ul>
 </li>
 <li>to listen:
 <ul>
 <li><a href="http://www.se-radio.net/2008/08/episode-106-introduction-to-aop/" rel="noreferrer">Software engineering radio - Episode 106: Introduction to AOP</a></li>
 <li><a href="http://www.se-radio.net/podcast/2006-04/episode-11-interview-gregor-kiczales" rel="noreferrer">Software engineering radio - Episode 11: Interview Gregor Kiczales</a></li>
 </ul>
 </li>
 <li>to watch:
 <ul>
 <li><a href="http://video.google.com/videoplay?docid=1875973989673234551&ei=xW4lSeWTD4Li2gL-son3Bg" rel="noreferrer">Google Video - Anurag Mendhekar: Aspect-Oriented Programming (Dan Friedman's 60th Birthday)</a></li>
 <li><a href="http://www.youtube.com/watch?v=cq7wpLI0hco" rel="noreferrer">Youtube - Aspect Oriented Programming: Radical Research in Modularity</a></li>
 <li><a href="http://www.youtube.com/watch?v=tzjRr3usV6I" rel="noreferrer">Youtube - Aspect-Oriented Modeling - what it is and what it's good for</a></li>
 </ul>
 </li>
</ul>

blocks|key|728010|text|在Java和AspectJ+(Hannemann和Kiczales)中的设计模式实现：http://www.cs.ubc.ca/labs/spl/papers/2002/oopsla02-patterns.pdf|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|728011|本文展示了一些GoF设计模式如何在Java中使用AspectJ更好地实现。|728012|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cs.ubc.ca/labs/spl/papers/2002/oopsla02-patterns.pdf^0|17|1R|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Design Pattern Implementation in Java and AspectJ (Hannemann and Kiczales): <a href="http://www.cs.ubc.ca/labs/spl/papers/2002/oopsla02-patterns.pdf" rel="nofollow noreferrer">http://www.cs.ubc.ca/labs/spl/papers/2002/oopsla02-patterns.pdf</a>

The paper shows how some of the GoF design patterns can implemented in a better way in Java using AspectJ

blocks|key|728319|text|在Java中不能有多个继承。但是，通过使用AOP，您可以拥有“有限”的多重继承。试着在谷歌上找到一些例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|728320|我也同意艾维德的观点。Hannemann和Kiczales的论文对于学习设计模式的基础知识和获取一些优秀的AOP示例非常有用。|728321|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You cannot have multiple inheritance in Java. However by using AOP you can have "limited" multiple inheritance.
Try to google this to see some examples.

I also agree with Eyvid. Hannemann and Kiczales paper is great for learning the basics on design patterns and getting some great AOP examples.

blocks|key|728058|text|我的相册使用aspectj做三件事：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|728059|将观察者“模式”实现为可重用的代码段。|ordered-list-item|728060|为特定类型的呼叫销毁会话。|728061|在发生变异时，在DTO上设置脏标志。|728062|第一个，特别是直接从一个谷歌科技谈AOP。这是关于模块化的一种不同于大多数人所认为的方式。如果你对如何永远使用它感兴趣的话，绝对推荐看它。|728063|entityMap|0|LINK|mutability|MUTABLE|url|http://github.com/dustin/photo|1|http://github.com/dustin/photo/tree/master/src/aspectj/net/spy/photo/aspects/ObservableMixin.aj|2|http://github.com/dustin/photo/tree/master/src/aspectj/net/spy/photo/aspects/RestSessionDestroyAspect.aj|3|http://github.com/dustin/photo/tree/master/src/aspectj/net/spy/photo/aspects/SavableModifierAspect.aj|4|http://video.google.com/videoplay?docid=8566923311315412414^0|0|4|0|0|0|J|1|0|0|D|2|0|0|I|3|0|C|8|4|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|G|3|H|5|F|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|I|3|J|5|F|7|1E|8|@]|9|@$A|1F|B|1G|1|1H]]|C|$]]|$1|K|3|L|5|6|7|1I|8|@]|9|@$A|1J|B|1K|1|1L]]|C|$]]|$1|M|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]|W|$5|P|Q|R|C|$S|X]]|Y|$5|P|Q|R|C|$S|Z]]|10|$5|P|Q|R|C|$S|11]]]]

<a href="http://github.com/dustin/photo" rel="nofollow noreferrer">My photo album</a> uses aspectj for three things:

<ol>
<li><a href="http://github.com/dustin/photo/tree/master/src/aspectj/net/spy/photo/aspects/ObservableMixin.aj" rel="nofollow noreferrer">Implementing the observer "pattern" as a reusable piece of code.</a></li>
<li><a href="http://github.com/dustin/photo/tree/master/src/aspectj/net/spy/photo/aspects/RestSessionDestroyAspect.aj" rel="nofollow noreferrer">Destroying a session for a specific type of call.</a></li>
<li><a href="http://github.com/dustin/photo/tree/master/src/aspectj/net/spy/photo/aspects/SavableModifierAspect.aj" rel="nofollow noreferrer">Setting dirty flags on DTOs when mutation occurs.</a></li>
</ol>

The first, in particular was pretty much straight out of a <a href="http://video.google.com/videoplay?docid=8566923311315412414" rel="nofollow noreferrer">google tech talk on AOP</a>. It's about modularity in a different way than most people consider. Definitely recommend watching that if you're interested in how to use it for good.

blocks|key|388813|text|另一个典型的例子(如日志记录)是缓存。但其他的例子则更有趣。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|388814|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Another classic example (like logging) is caching. But other examples are more interesting.

blocks|key|388860|text|撤消-我正在调用支持撤消操作的第三方程序集。它要求调用方创建撤消上下文，调用程序集中的某些方法，然后销毁撤消上下文。上下文可以嵌套。此外，如果一个上下文被创建，但处于不受欢迎的状态，则需要重新启动应用程序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|388861|通常使用撤销，我会写这样的东西|388862|++++void+foo()
++++{
++++++++int+id+=+lib.create_undo_context();
++++++++try
++++++++{
++++++++++++lib.performsomeaction();
++++++++++++lib.performsomeaction();
++++++++++++lib.performsomeaction();

++++++++}
++++++++finally
++++++++{
++++++++++++lib.destroy_undo_context(id);
++++++++}
++++}|code-block|syntax|javascript|388863|使用PostSharp，我定义了一个名为Undo的属性，它在方法启动时创建撤销上下文，并在方法退出时销毁它(即使抛出异常)--因此代码如下所示|388864|++++[Undo]
++++void+foo()
++++{
++++++++lib.performsomeaction();
++++++++lib.performsomeaction();
++++++++lib.performsomeaction();
++++}|388865|实现这一点要比我所展示的要复杂一些，因为我已经确保所有撤销上下文都被清理了，即使在存在嵌套撤销上下文的情况下也是如此--但是您知道了。|388866|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Undo - I am calling a third-party assembly that supports undo operations. It requires callers to create an undo context, call some methods in the assembly, adn then destroy the undo context. Contexts can be nested. Also, if a context is created but left in an undesirable state that requires an app restart.

Normally to use undo I would write something like this

<pre><code> void foo()
 {
 int id = lib.create_undo_context();
 try
 {
 lib.performsomeaction();
 lib.performsomeaction();
 lib.performsomeaction();

 }
 finally
 {
 lib.destroy_undo_context(id);
 }
 }
</code></pre>

with PostSharp I define an attribute called [Undo] that creates the undo context when the method starts and destroys it when the method exits (even if an exception is thrown) - so the code looks like this

<pre><code> [Undo]
 void foo()
 {
 lib.performsomeaction();
 lib.performsomeaction();
 lib.performsomeaction();
 }
</code></pre>

It's a little more complicated to implement this than I am showing because I have ensure that all undo contexts are cleaned up even in cases where there are nested Undo contexts - but you get the idea.

blocks|key|728399|text|事务管理。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|728400|在我看来，您不希望可能是事务一部分的对象知道它们在事务中。使用AOP，您可以根据需要将对象组合到事务中，而事务中的对象不需要知道它们在事务中的事实，甚至不需要知道AOP框架的存在。|728401|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Transaction management.

To my mind, you do not want objects that may be part of a transaction to be aware that they are in a transaction. Using AOP, you can compose objects into transactions as required without the objects in the transaction needing to be aware of either the fact that they are in a transaction or even of the existence of the AOP framework.

blocks|key|388933|text|我使用面向方面的编程来实现关键字搜索引擎。它更像是一个实验，但它展示了AOP如何用于日志记录和跟踪以外的其他目的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|388934|基本上：|388935|(i)引擎的使用者将其类别标记为KeywordSearchable，|388936|(ii)引擎开始跟踪这些KeywordSearchable实例的创建和销毁，|388937|(iii)引擎从这些KeywordSearchable对象中提取关键字，|388938|(iv)给定对象和关键字，该算法负责搜索。|388939|关于这个问题的更多细节，可以在http://montrealistic.blogspot.com/2011/08/aspect-oriented-implementation-of.html上找到。|offset|length|388940|entityMap|0|LINK|mutability|MUTABLE|url|http://montrealistic.blogspot.com/2011/08/aspect-oriented-implementation-of.html^0|0|0|0|0|0|0|F|28|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|12|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|13|8|@]|9|@$N|14|O|15|1|16]]|A|$]]|$1|P|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]]]

I have used aspect-oriented programming to implement a keyword search engine. It was more like an experiment, but it shows how AOP can be used for purposes other than logging and tracing.

Basically: 
(i) The user of the engine marks his/her classes as KeywordSearchable, 
(ii) The engine starts tracking the creation &amp; destruction of these KeywordSearchable instances, 
(iii) The engine extracts the keywords from these KeywordSearchable objects, 
(iv) Given the objects and the keywords, the algorithm takes care of the search.

More details on this can be found at <a href="http://montrealistic.blogspot.com/2011/08/aspect-oriented-implementation-of.html" rel="nofollow"> <a href="http://montrealistic.blogspot.com/2011/08/aspect-oriented-implementation-of.html" rel="nofollow">http://montrealistic.blogspot.com/2011/08/aspect-oriented-implementation-of.html</a></a>.

blocks|key|388963|text|依赖注入|type|unstyled|depth|inlineStyleRanges|entityRanges|data|388964|严格地说，依赖注入只不过是横切关注点。许多依赖项注入框架使用基于属性的编程风格，如下所示：|388965|public+class+Car:IDisposable
{
++++[Inject]
++++public+IGearBox+Gearbox+{+get;+set;+}
+++...
}|code-block|syntax|javascript|388966|Inject属性也可以设计为一个方面，而不依赖于外部框架。|388967|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Dependency Injection

Strictly speaking, dependency injection is nothing more than a crosscutting concern. A lot of dependency injection frameworks use a attribute-based programming style like this:

<pre><code>public class Car:IDisposable
{
 [Inject]
 public IGearBox Gearbox { get; set; }
 ...
}
</code></pre>

The [Inject] attribute could also designed as an aspect without any dependency to an external framework.

blocks|key|728487|text|AOP的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|728488|算术表达式的解析器和计算器。这可以使用访问者模式编程，但我认为方面是一个更好的选择。|unordered-list-item|728489|一个简单的文本编辑器，其中一些管理任务(例如，维护“文件已更改”标志和窗口标题)被视为单独的方面。|728490|字符串的一种数据结构，其中字符串被表示为树，这样就可以在不复制的情况下实现级联和子字符串选择。为了保持效率，树有时需要被重新平衡；平衡代码被看作是一个方面。|728491|让我们假设您希望在域模型的方法中记录一条消息：|728492|示例:没有AOP的日志：|728493|namespace+Examples\Forum\Domain\Model;

class+Forum+{

++++/**
+++++*+@Flow\Inject
+++++*+@var+\Examples\Forum\Logger\ApplicationLoggerInterface
+++++*/
++++protected+$applicationLogger;

++++/**
+++++*+Delete+a+forum+post+and+log+operation
+++++*
+++++*+@param+\Examples\Forum\Domain\Model\Post+$post
+++++*+@return+void
+++++*/
++++public+function+deletePost(Post+$post)+{
++++++++++++$this->applicationLogger->log('Removing+post+'+.+$post->getTitle(),+LOG_INFO);
++++++++++++$this->posts->remove($post);
++++}

}|code-block|syntax|javascript|728494|如果您必须在许多地方这样做，日志记录将成为您域模型逻辑的一部分。您必须在模型中注入所有日志依赖项。由于日志记录并不是域模型应该关心的问题，这是一个非功能性需求和所谓的横切关注点的例子。|728495|使用AOP，模型中的代码将不了解日志记录。它只会专注于业务逻辑。|728496|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|Z|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|13|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|6|7|14|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|15|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|W|$]]

Examples of AOP:

<ul>
<li>A parser and evaluator for arithmetic expressions. This could have been programmed using the visitor pattern, but I believe that aspects are a better alternative.</li>
<li>A simple text editor, in which some management tasks (e.g., maintaining the "file has changed" flag, and the window caption) are treated as separate aspects.</li>
<li>A data structure for character strings, in which strings are represented as trees so that concatenation and substring selection can be implemented without copying. To maintain efficiency, the trees sometimes need to be rebalanced; the balancing code is treated as an aspect.</li>
</ul>

Let's imagine you want to log a message inside methods of your domain model:

Example: Logging without AOP:

<pre><code>namespace Examples\Forum\Domain\Model;

class Forum {

 /**
 * @Flow\Inject
 * @var \Examples\Forum\Logger\ApplicationLoggerInterface
 */
 protected $applicationLogger;

 /**
 * Delete a forum post and log operation
 *
 * @param \Examples\Forum\Domain\Model\Post $post
 * @return void
 */
 public function deletePost(Post $post) {
 $this-&gt;applicationLogger-&gt;log('Removing post ' . $post-&gt;getTitle(), LOG_INFO);
 $this-&gt;posts-&gt;remove($post);
 }

}
</code></pre>

If you have to do this in a lot of places, the logging would become a part of you domain model logic. You would have to inject all the logging dependencies in your models. Since logging is nothing that a domain model should care about, this is an example of a non-functional requirement and a so-called cross-cutting concern.

With AOP, the code inside your model would know nothing about logging. It will just concentrate on the business logic.

Can anyone post an example of Aspect-oriented programming (AOP) that is not logging?

I've looked at several resources but all the examples are trivial logging. What is it useful for?

Aspect-oriented programming examples

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有人能发布一个不属于日志记录的面向方面编程(AOP)的示例吗？我看过几个资源，但所有的例子都是琐碎的日志记录。它有什么用？

问面向方面的编程示例
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问面向方面的编程示例EN