序文
休日のため、しばらく更新していません！休暇中、ファンが虐待の経験について話してくれました。休暇前にインターネット会社に面接に行きましたが、面接官の春のAOPから3回続けて直接尋ねられました。力！実際、これはかなり単純ではないでしょうか。
AOPを学ぶ前に、エージェントモデルを知っていれば、とても簡単に学ぶことができます。次に、AOPのこの重要な知識ポイントを紹介します。
エージェンシーモデル
プロキシモードは、Java開発で比較的一般的な設計モードです。設計の目的は、サービスクラスとクライアントクラスの間に他の関数を挿入することです。挿入された関数は、呼び出し元に対して透過的であり、カモフラージュ制御の役割を果たします。賃貸住宅の例：テナント、仲介業者、地主。エージェントモデルに対応します。つまり、顧客クラス、エージェントクラス、コミッションクラス（委任クラス）です。
このオブジェクトへのアクセスを制御するために、オブジェクト（デリゲートクラス）のプロキシ（プロキシクラス）を提供します。デリゲートクラスとプロキシクラスには、共通の親クラスまたは親インターフェイスがあります。プロキシクラスは、リクエストを前処理してフィルタリングし、指定されたオブジェクトにリクエストを割り当てます。
生活の中で一般的な代理店の状況：賃貸代理店、結婚式会社など。
エージェンシーモデルの2つの設計原則：
- プロキシクラスと委任クラスの動作は似ています（共通）
- プロキシクラスは、デリゲートクラスの動作を強化します
一般的に使用されるプロキシモード：
- 静的プロキシ
- 動的プロキシ
静的プロキシ
オブジェクトはプロキシを提供し、プロキシの役割はこのオブジェクトへのアクセスを制御するために固定されています。プロキシクラスとデリゲートクラスには共通の親クラスまたは親インターフェイスがあるため、デリゲートクラスオブジェクトが使用される任意の場所でプロキシオブジェクトを使用できます。プロキシクラスは、要求の前処理、フィルタリング、処理のために委任されたクラスへの要求のディスパッチ、および委任されたクラスが要求を実行した後の後続の処理を担当します。
エージェンシーの3つの要素
-
共通の振る舞い（結婚）を持っている-インターフェース
-
ターゲットの役割（新人）-行動を達成する
- 演技の役割（結婚式会社）-行動強化ターゲットオブジェクトの行動を達成する
静的プロキシの機能
- 固定ターゲットロール
- アプリケーションが実行される前にターゲットの役割を取得する
- プロキシオブジェクトは、ターゲットオブジェクトの動作を強化します
- 複数のエージェントが存在する可能性があり、「クラスの爆発」を引き起こします（デメリット）
静的プロキシの実装
動作を定義する（一般的に）インターフェイスを定義する
/**
* 定义⾏为
*/
public interface Marry {
public void toMarry();
}ターゲットオーディエンス（実装動作）
/**
* 静态代理 ——> ⽬标对象
*/
public class You implements Marry {
// 实现⾏为
@Override
public void toMarry() {
System.out.println("我要结婚了...");
}
}プロキシオブジェクト（動作の実装、ターゲットオブジェクトの動作の強化）
/**
* 静态代理 ——> 代理对象
*/
public class MarryCompanyProxy implements Marry {
// ⽬标对象
private Marry marry;
// 通过构造器将⽬标对象传⼊
public MarryCompanyProxy(Marry marry) {
this.marry = marry;
}
// 实现⾏为
@Override
public void toMarry() {
// 增强⾏为
before();
// 执⾏⽬标对象中的⽅法
marry.toMarry();
// 增强⾏为
after();
}
/**
* 增强⾏为
*/
private void after() {
System.out.println("新婚快乐，早⽣贵⼦！");
}
/**
* 增强⾏为
*/
private void before() {
System.out.println("场地正在布置中...");
}
}プロキシオブジェクトを介してターゲットオブジェクトの機能を実現します
// ⽬标对象
You you = new You();
// 构造代理⻆⾊同时传⼊真实⻆⾊
MarryCompanyProxy marryCompanyProxy = new MarryCompanyProxy(you);
// 通过代理对象调⽤⽬标对象中的⽅法
marryCompanyProxy.toMarry();静的プロキシの役割はプロキシに対して固定されています。たとえば、daoレイヤーには20のdaoクラスがあります。メソッドのアクセス権をプロキシする場合は、この時点で20の静的プロキシの役割を作成する必要があります。これにより、クラスが急増し、本番環境のニーズを満たすことができなくなります。これは、ダイナミックエージェンシーのアイデアを生み出しました。
動的プロキシ
静的プロキシと比較して、動的プロキシはプロキシオブジェクトの作成に柔軟性があります。動的プロキシクラスのバイトコードは、プログラムの実行時にJavaリフレクションメカニズムによって動的に生成されます。プログラマーがソースコードを手動で記述しなくても、必要に応じて、プログラムの実行時にリフレクションメカニズムを介してターゲットオブジェクトのプロキシオブジェクトを動的に作成します。動的プロキシは、プログラミング作業を簡素化するだけでなく、リフレクションメカニズムが任意のタイプの動的プロキシクラスを生成できるため、ソフトウェアシステムのスケーラビリティも向上させます。エージェントの動作は、複数の方法で機能することができます。つまり、共通のコードの目的を達成しながら、本番環境のニーズを満たすことができます。
動的プロキシの2つの実装方法：
- JDK動的プロキシ
- CGLIB動的エージェント
動的エージェントの特性
- ターゲットオーディエンスは固定されていません
- アプリケーションの実行中にターゲットオブジェクトを動的に作成する
- プロキシオブジェクトは、ターゲットオブジェクトの動作を強化します
JDK動的プロキシ
注：JDK動的プロキシのターゲットオブジェクトには、インターフェイスが実装されている必要があります
newProxyInstance
プロキシクラス：
Proxyクラスは、プロキシに特化した操作クラスです。このクラスを使用して、1つ以上のインターフェイスの実装クラスを動的に生成できます。このクラスは、次の操作メソッドを提供します。
/*
返回⼀个指定接⼝的代理类的实例⽅法调⽤分派到指定的调⽤处理程序。 (返回代理对象)
loader：⼀个ClassLoader对象，定义了由哪个ClassLoader对象来对⽣成的代理对象进⾏加载
interfaces：⼀个Interface对象的数组，表示的是我将要给我需要代理的对象提供⼀组什么接⼝，如果
我提供了⼀组接⼝给它，那么这个代理对象就宣称实现了该接⼝(多态)，这样我就能调⽤这组接⼝中的⽅法了
h：⼀个InvocationHandler接⼝，表示代理实例的调⽤处理程序实现的接⼝。每个代理实例都具有⼀个关联
的调⽤处理程序。对代理实例调⽤⽅法时，将对⽅法调⽤进⾏编码并将其指派到它的调⽤处理程序的 invoke ⽅法
（传⼊InvocationHandler接⼝的⼦类）
*/
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)プロキシオブジェクトを取得する
public class JdkHandler implements InvocationHandler {
// ⽬标对象
private Object target; // ⽬标对象的类型不固定，创建时动态⽣成
// 通过构造器将⽬标对象赋值
public JdkHandler(Object target) {
this.target = target;
}
/**
* 1、调⽤⽬标对象的⽅法（返回Object）
* 2、增强⽬标对象的⾏为
* @param proxy 调⽤该⽅法的代理实例
* @param method ⽬标对象的⽅法
* @param args ⽬标对象的⽅法形参
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
// 增强⾏为
System.out.println("==============⽅法前执⾏");
// 调⽤⽬标对象的⽅法（返回Object）
Object result = method.invoke(target,args);
// 增强⾏为
System.out.println("⽅法后执⾏==============");
return result;
}
/**
* 得到代理对象
* public static Object newProxyInstance(ClassLoader loader,
* Class<?>[] interfaces,
* InvocationHandler h)
* loader：类加载器
* interfaces：接⼝数组
* h：InvocationHandler接⼝ (传⼊InvocationHandler接⼝的实现类)
*
*
* @return
*/
public Object getProxy() {
return
Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterface
s(),this);
}
}プロキシオブジェクトを介してターゲットオブジェクトの機能を実現します
// ⽬标对象
You you = new You();
// 获取代理对象
JdkHandler jdkHandler = new JdkHandler(you);
Marry marry = (Marry) jdkHandler.getProxy();
// 通过代理对象调⽤⽬标对象中的⽅法
marry.toMarry(); 質問：Java動的プロキシクラスのinvokeはどのように呼び出されますか？
回答：生成された動的プロキシクラス$ Proxy0.classで、構築メソッドは親クラスProxy.classの構築メソッドを呼び出し、メンバー変数invocationHandlerに値を割り当て、$ Proxy0.classの静的モジュールにプロキシクラスメソッドを作成します。対応するメソッドは、メソッド本体の親クラスのメンバー変数InvocationHandlerのinvoke（）メソッドを呼び出します。
注：JDKの動的プロキシは、インターフェイスの実装に依存しています。一部のクラスにインターフェイスの実装がない場合、JDKプロキシは使用できません。
CGLIB動的プロキシ
JDKの動的プロキシメカニズムは、インターフェイスを実装するクラスのみをプロキシでき、インターフェイスを実装できないクラスはJDKの動的プロキシを使用できません。cglibはクラスのプロキシを実装し、その原則は、指定されたターゲットクラスのサブクラスを生成することです。 、およびメソッドをオーバーライドして拡張を実現しますが、継承されているため、最終的に変更されたクラスをプロキシすることはできません。
依存関係を追加する
pom.xmlファイルにcglibの依存関係を導入します
<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>定義クラス
MethodInterceptorインターフェイスを実装する
public class CglibInterceptor implements MethodInterceptor {
// ⽬标对象
private Object target;
// 通过构造器传⼊⽬标对象
public CglibInterceptor(Object target) {
this.target = target;
}
/**
* 获取代理对象
* @return
*/
public Object getProxy() {
// 通过Enhancer对象的create()⽅法可以⽣成⼀个类，⽤于⽣成代理对象
Enhancer enhancer = new Enhancer();
// 设置⽗类 (将⽬标类作为其⽗类)
enhancer.setSuperclass(target.getClass());
// 设置拦截器 回调对象为本身对象
enhancer.setCallback(this);
// ⽣成⼀个代理类对象，并返回
return enhancer.create();
}
/**
* 拦截器
* 1、⽬标对象的⽅法调⽤
* 2、增强⾏为
* @param object 由CGLib动态⽣成的代理类实例
* @param method 实体类所调⽤的被代理的⽅法引⽤
* @param objects 参数值列表
* @param methodProxy ⽣成的代理类对⽅法的代理引⽤
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object object, Method method, Object[] objects,
MethodProxy methodProxy) throws Throwable {
// 增强⾏为
System.out.println("==============⽅法前执⾏");
// 调⽤⽬标对象的⽅法（返回Object）
Object result = methodProxy.invoke(target,objects);
// 增强⾏为
System.out.println("⽅法后执⾏==============");
return result;
}
}メソッドを呼び出す
// ⽬标对象
You you = new You();
CglibInterceptor cglibInterceptor = new CglibInterceptor(you);
Marry marry = (Marry) cglibInterceptor.getProxy();
marry.toMarry();
User user = new User();
CglibInterceptor cglibInterceptor = new CglibInterceptor(user);
User u = (User) cglibInterceptor.getProxy();
u.test();JDKプロキシとCGLIBプロキシの違い
- JDK動的プロキシ実装インターフェイス、Cglib動的プロキシ継承のアイデア
- JDK動的プロキシ（ターゲットオブジェクトにインターフェイスがある場合）の実行効率はCiglibよりも高くなります
- ターゲットオブジェクトにインターフェイスが実装されている場合はJDKプロキシを選択し、インターフェイスが実装されていない場合はCglibプロキシを選択します
春のAOP
ログ処理に起因する問題
Pay（インターフェース）と2つの実装クラスDollarPayとRmbPayがあります。どちらもpay（）メソッドを書き直す必要があります。このとき、payメソッドのパフォーマンスを監視したり、ログを追加したりする必要があります。
考える最も簡単な方法
以下に示すように、ログコードは文字メソッドごとに記述されます。
短所：コードの繰り返しが多すぎ、追加されたログコードの結合が高すぎる（ログレコードコードの関数要件を変更する必要がある場合は、クラス内のすべてのメソッドを変更する必要があり、エンジニアリングの量が膨大になります）
デコレータモード/エージェントモードを使用してソリューションを改善します
デコレータパターン：オブジェクトにいくつかの追加の責任を動的に追加します。
エージェントモード：上記で説明しました。次の構造が導き出されます。
慎重に検討した結果、元の内部コードは変更されていないものの、クラスごとにログ処理が行われ、対象クラスが参照されていることがわかりましたが、ログに追加するビジネスクラスの数が多い場合は、ビジネスクラスごとに手動で装飾を実装してください。対応するプロキシクラスが作成され、コードの結合も増加します。要件が変更されると、エンジニアリングの変更の量を想像できます。
コードを1回記述すれば、ログレコードを追加したい場所でコードを再利用し、疎結合を実現し、機能を完全に完了することができる、より良い解決策はありますか？
答えはイエスです、そのような技術があり、aopはそれのための完璧な実装を提供しました！
AOPとは何ですか？
アスペクト指向プログラミングはアスペクト指向プログラミングです。oopオブジェクト指向プログラミングと比較して、Aopはプログラムコード内の特定のクラスまたは一部のメソッドに関係しなくなりましたが、aopはより対面的なアプローチを考慮します。層間の一種の切断であるため、切断面と呼ばれます。みんなのハンバーガー（真ん中に肉が入っている）を考えてみてください。では、aopはどのようにして表面全体をインターセプトするのでしょうか？以前に学習したサーブレットフィルター/ *の構成を考慮すると、実際にはaopの実現です。
AOPで何ができますか？
AOPは、主にロギング、パフォーマンス統計、セキュリティ制御、トランザクション処理などで使用され、パブリック関数の繰り返し使用を実現します。
AOPの特徴
- モジュール間の結合の程度を減らし、ビジネスコードの集約の程度を改善します。（高凝集性と低結合）
- コードの再利用性の向上
- コードの再利用性の向上
- 元の機能に影響を与えることなく、新しい機能を追加できます
AOPの基礎となる実装
動的プロキシ（JDK + CGLIB）
AOPの基本概念
インターセプトされるすべてのポイント、スプリングミドルはインターセプトされるすべてのメソッドを指し、スプリングaopの接続ポイントはメソッドの実行を表します。
ポイントカット（エントリーポイント）
インターセプト接続ポイントの定義（一致するルール定義は、インターセプトされるメソッドと処理されるメソッドを指定します）のために、Springには特別な式言語定義があります。
助言
操作後に各接続ポイント（各メソッド）をインターセプトします
- 事前通知（事前拡張）—メソッドを実行する前のbefore（）通知
- リターン通知（リターン拡張）—afterReturnメソッドが正常に終了してリターンした後の通知
- 例外スロー通知（拡張例外スロー）— afetrThrow（）
- 最終通知—メソッドが異常であるかどうかに関係なく、通知が実行された後。
- アドバイス周辺—メソッド呼び出しなど、結合ポイントを囲むアドバイス周辺。これは最も強力なタイプの通知です。サラウンド通知は、メソッドが呼び出される前後にカスタム動作を完了することができます。また、接続ポイントの実行を続行するか、独自の戻り値を直接返すか、例外をスローして実行を終了するかを選択します。
側面
エントリポイントと通知の組み合わせにより、アスペクトの定義が決まります。エントリポイントは、どのクラスのどのメソッドをインターセプトするかを定義します。通知は、メソッドがインターセプトされた後に何をするかを定義します。アスペクトは、クラスと同様に、分野横断的な懸念事項を抽象化したものです。 、クラスはオブジェクトの特性の抽象化であり、アスペクトは分野横断的な懸念の抽象化です。
目標
対象者
織り（織り）
アスペクトをターゲットオブジェクトに適用し、プロキシオブジェクトを生成するプロセスは織り込まれています
前書き
元のアプリケーションコードを変更せずに、プログラムの実行時にメソッドまたはフィールドをクラスに動的に追加するプロセスは、インポートと呼ばれます。
SpringAOPの実装
春のAOP環境構築
依存関係の紹介を調整する
<!--Spring AOP-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
</dependency>spring.xml構成を追加します
名前名を追加
xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd注釈の実装
アスペクトを定義する
/**
* 切⾯
* 切⼊点和通知的抽象 （与⾯向对象中的 类 相似）
* 定义 切⼊点和通知 （切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦截过⽅法后要做什么）
*/
@Component // 将对象交给IOC容器去实例化
@Aspect // 声明当前类是⼀个切⾯
public class LogCut {
/**
* 切⼊点：
* 匹配规则。规定什么⽅法被拦截、需要处理什么⽅法
* 定义切⼊点
* @Pointcut("匹配规则")
*
* Aop 切⼊点表达式简介
* 1. 执⾏任意公共⽅法：
* execution(public *(..))
* 2. 执⾏任意的set⽅法
* execution(* set*(..))
* 3. 执⾏com.xxxx.service包下任意类的任意⽅法
* execution(* com.xxxx.service.*.*(..))
* 4. 执⾏com.xxxx.service 包 以及⼦包下任意类的任意⽅法
* execution(* com.xxxx.service..*.*(..))
*
* 注：表达式中的第⼀个* 代表的是⽅法的修饰范围
* 可选值：private、protected、public （* 表示所有范围）
*/
@Pointcut("execution (* com.xxxx.service..*.*(..) )")
public void cut(){}
/**
* 声明前置通知 并将通知应⽤到定义的切⼊点上
* ⽬标类⽅法执⾏前 执⾏该通知
*
*/
@Before(value = "cut()")
public void before() {
System.out.println("前置通知.....");
}
/**
* 声明返回通知 并将通知应⽤到定义的切⼊点上
* ⽬标类⽅法（⽆异常）执⾏后 执⾏该通知
*
*/
@AfterReturning(value = "cut()")
public void afterReturn() {
System.out.println("返回通知.....");
}
/**
* 声明最终通知 并将通知应⽤到定义的切⼊点上
* ⽬标类⽅法（⽆异常或有异常）执⾏后 执⾏该通知
*
*/
@After(value = "cut()")
public void after() {
System.out.println("最终通知.....");
}
/**
* 声明异常通知 并将通知应⽤到定义的切⼊点上
* ⽬标类⽅法出现异常时 执⾏该通知
*/
@AfterThrowing(value="cut()",throwing = "e")
public void afterThrow(Exception e) {
System.out.println("异常通知....." + " 异常原因：" + e.getCause());
}
/**
* 声明环绕通知 并将通知应⽤到切⼊点上
* ⽅法执⾏前后 通过环绕通知定义相应处理
* 需要通过显式调⽤对应的⽅法，否则⽆法访问指定⽅法 (pjp.proceed();)
* @param pjp
* @return
*/
@Around(value = "cut()")
public Object around(ProceedingJoinPoint pjp) {
System.out.println("前置通知...");
Object object = null;
try {
object = pjp.proceed();
System.out.println(pjp.getTarget() + "======" + pjp.getSignature());
// System.out.println("返回通知...");
} catch (Throwable throwable) {
throwable.printStackTrace();
System.out.println("异常通知...");
}
System.out.println("最终通知...");
return object;
}
}構成ファイル（spring.xml）
<!--配置AOP代理-->
<aop:aspectj-autoproxy/>XMLの実装
アスペクトを定義する
**
* 切⾯
* 切⼊点和通知的抽象 （与⾯向对象中的 类 相似）
* 定义 切⼊点和通知 （切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦截过⽅法后要做什么）
*/
@Component // 将对象交给IOC容器去实例化
public class LogCut02 {
public void cut(){}
/**
* 声明前置通知 并将通知应⽤到定义的切⼊点上
* ⽬标类⽅法执⾏前 执⾏该通知
*/
public void before() {
System.out.println("前置通知.....");
}
/**
* 声明返回通知 并将通知应⽤到定义的切⼊点上
* ⽬标类⽅法（⽆异常）执⾏后 执⾏该通知
*
*/
public void afterReturn() {
System.out.println("返回通知.....");
}
/**
* 声明最终通知 并将通知应⽤到定义的切⼊点上
* ⽬标类⽅法（⽆异常或有异常）执⾏后 执⾏该通知
*
*/
public void after() {
System.out.println("最终通知.....");
}
/**
* 声明异常通知 并将通知应⽤到定义的切⼊点上
* ⽬标类⽅法出现异常时 执⾏该通知
*/
public void afterThrow(Exception e) {
System.out.println("异常通知....." + " 异常原因：" + e.getCause());
}
/**
* 声明环绕通知 并将通知应⽤到切⼊点上
* ⽅法执⾏前后 通过环绕通知定义相应处理
* 需要通过显式调⽤对应的⽅法，否则⽆法访问指定⽅法 (pjp.proceed();)
* @param pjp
* @return
*/
public Object around(ProceedingJoinPoint pjp) {
System.out.println("前置通知...");
Object object = null;
try {
object = pjp.proceed();
System.out.println(pjp.getTarget() + "======" + pjp.getSignature());
// System.out.println("返回通知...");
} catch (Throwable throwable) {
throwable.printStackTrace();
System.out.println("异常通知...");
}
System.out.println("最终通知...");
return object;
}
}構成ファイル（spring.xml）
<!--aop相关配置-->
<aop:config>
<!--aop切⾯-->
<aop:aspect ref="logCut02">
<!-- 定义aop 切⼊点 -->
<aop:pointcut id="cut" expression="execution(* com.xxxx.service..*.*(..))"/>
<!-- 配置前置通知 指定前置通知⽅法名 并引⽤切⼊点定义 -->
<aop:before method="before" pointcut-ref="cut"/>
<!-- 配置返回通知 指定返回通知⽅法名 并引⽤切⼊点定义 -->
<aop:after-returning method="afterReturn" pointcut-ref="cut"/>
<!-- 配置异常通知 指定异常通知⽅法名 并引⽤切⼊点定义 -->
<aop:after-throwing method="afterThrow" throwing="e" pointcut-ref="cut"/>
<!-- 配置最终通知 指定最终通知⽅法名 并引⽤切⼊点定义 -->
<aop:after method="after" pointcut-ref="cut"/>
<!-- 配置环绕通知 指定环绕通知⽅法名 并引⽤切⼊点定义 -->
<aop:around method="around" pointcut-ref="cut"/>
</aop:aspect>
</aop:config>春のAOPの概要
エージェントモデルの3つの要素
- インターフェイスの定義
- ターゲットオブジェクトとプロキシオブジェクトは、統合されたインターフェイスを実装する必要があります
- プロキシオブジェクトはターゲットオブジェクトへの参照を保持し、ターゲットオブジェクトの動作を強化します
エージェントモードは分類と対応する違いを実現します
- 静的プロキシ：ターゲットオブジェクトのプロキシオブジェクトを手動で作成します。つまり、プログラムのコンパイル段階でプロキシオブジェクトの作成を完了します。
- 動的プロキシ：プログラムの実行中に、ターゲットオブジェクトに対応するプロキシオブジェクトを動的に作成します。
- jdk動的プロキシ：プロキシターゲットは、コールバックを介してプロキシオブジェクトを作成するために、特定または特定のインターフェイス実装メソッドのセットを実装する必要があります。
- cglib動的プロキシ：プロキシターゲットオブジェクトはインターフェイスを実装する必要がなく、継承によって実装されます
静的エージェントと比較して、動的エージェントは、開発効率を向上させ、エージェントをバッチで作成し、コードの再利用率を向上させることができます。
Aopの理解
- アスペクト指向、おっとと比較して、コード内のレイヤーまたは面に焦点を当てています
- デカップリング、システムのスケーラビリティの向上
- コードの再利用を改善する
Aopキーワード
- 接続ポイント：すべての方法
- エントリポイント：マッチングメソッドのコレクション
- 側面：接続ポイントとエントリポイントのコレクションは、側面、分野横断的な懸念の抽象化を決定します
- 通知：いくつかの通知
- ターゲットオブジェクト：プロキシオブジェクト
- ウィービング：プログラムの実行時にターゲットオブジェクトにアスペクトを適用し、プロキシオブジェクトを生成するプロセス
- はじめに：元のコードを変更せずに、プログラムの実行時にメソッドまたはフィールドをプログラムに動的に導入するプロセス
やっと
これを見ていただきありがとうございます。記事に欠点があれば訂正してください。記事が役に立ったと思われる場合は、忘れずにいいねをください。