知識のポイント：BeanPostProcessorとApplicationListener
春の初歩的な知識のレビュー
春といえば、IOCとAOPが最初に言及されますが、知識のポイントは何ですか？
1. Spring Bootプロセスで、Bをインストールするためのソースコードを確認します。（Bean定義BeanDefinitionのロード、Beanファクトリの作成など）---ソースコードを覚えるのはあまり意味がありません。読んで忘れてしまいました。インタビューが怖いだけです。
2. Beanのスコープ（単一のケース、複数のケース）、Beanのライフサイクル：1。インスタンス化2.初期化3.破棄の使用[属性の割り当て、つまり依存性の注入、および認識されたインターフェイスの拡張（ BeanNameAware）、BeanPostProcessorプロセッサなど]
（1）Springはデフォルトでシングルトンであり、Springコンテナに追加されたすべてのBeanはシングルトンプールに保持されます。
（2）Beanの初期化には3つのメソッドがあります。@ PostConstruct>は、InitializingBeanメソッドを実装します。afterPropertiesSet> init-メソッドのパラメーター指定
（3）依存性注入には、コンストラクター注入、setメソッド注入、属性注入（autowireまたはresorce）、インターフェース注入（一般的には使用されない）の4つの方法があります。
3.注解：@ Restcontroller / @ Controller、@ getMapping / @ RequestMapping / @ Pathvariable、@ Autowired / @ Resource、Scope、RequestBody / ResponseBody、@ Bean
（4.1）@ Restcontroller / @ Controllerの違いは何ですか？
（4.2）@RequestMappingのパス属性と値属性の違いは？
（4.3）@ Autowired / @ Resourceの違いは？
4.スプリングコンテナBeanFactory とApplicationContextを 理解します。前者は基本的な関数を実装しますが、後者はAOPを含むより多くの関数を備えています。前者はgetBeanのときにインスタンス化され、すべてのBeanは後者の開始後にインスタンス化されます。
5. Springは循環依存関係を解決します：3レベルキャッシュ singletonObjects / EarlySingletonObjects / singletonFactories
6.springmvcプロセスとインターセプター/フィルターの違い
7.動的プロキシJDKおよびCGLIBに関しては、AOP原則の動的プロキシ（デフォルトのJDK）。前者は、インターフェイスを実装するクラスへのリフレクションの生成エージェントであり、後者は、サブクラスカバレッジを生成するためのバイトコードテクノロジの使用です。
動的エージェントと言えば、Springトランザクションが最も一般的な動的エージェントです。@Transitionalが失敗するとどうなりますか？
8. Springbootの改善：自動構成、起動の依存関係、組み込みのTomcat、アクチュエーターの動作監視。スプリングブート自動構成の原理？
以上が基本的にSpringの要点を踏襲しており、Springの予備知識があります！！
長編映画が始まります！！！
実際の戦闘：BeanPostProcessorとApplicationListenerを使用して、APIインターフェースが新しいかどうかを確認します
背景はこれです。マイクロサービスのRequestMappingは、一意に識別されたインターフェイスを形成します。APIが外部にリリースされていない場合は、新しいインターフェイスを外部にリリースする必要があります。新しい開発者が新しいインターフェースを受け取ったが、APIをリリースするようにメンテナンスに通知するのを忘れた場合、それは無駄になります。
したがって、APIインターフェース（ファイル/データベース）は、Springの開始時に一度永続化でき、次にプログラムを起動したときに、プログラムはテスト環境で起動したときに新しいAPIがあるかどうかを確認できます。どうすればよいですか。行う？
ステップ1：MyBeanPostProcessorを追加してBeanPostProcessorを実装する
import org.apache.servicecomb.provider.rest.common.RestSchema;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.util.ReflectionUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@Component
public class MyBeanPostProcessor implements BeanPostProcessor, Ordered {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
//初始化前执行当前方法
//doWithMethos的功能是可以执行类中的所有方法，并且提供回调函数方法
Class<?> cl = bean.getClass();
RestSchema restSchema = cl.getAnnotation(RestSchema.class);
String classRequestMappingValue = "";
if (restSchema != null) {
List<String> valueList = new ArrayList<>();
RequestMapping classMapping = cl.getAnnotation(RequestMapping.class);
if (classMapping != null) {
classRequestMappingValue = classMapping.path()[0];
MyCache.mappingMapList.put(classRequestMappingValue, valueList);
}
ReflectionUtils.doWithMethods(bean.getClass(), new ReflectionUtils.MethodCallback() {
public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
MyBeanPostProcessor.this.processConsumerMethod(bean, method, valueList);
}
});
}
return bean;
}
private void processConsumerMethod(Object bean, Method method, List<String> valueList) {
//获取方法上的注解
if (method != null) {
RequestMapping methodRequestMapping = method.getAnnotation(RequestMapping.class);
if (methodRequestMapping != null) {
String[] values = methodRequestMapping.value();
if (values != null && values.length > 0) {
valueList.add(values[0]);
}
}
}
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
//初始化后执行当前方法 ,可以做什么事情？
// 1.修改注解中的属性值，比如增加前缀标识，比如有调用多个公司的项目，可以增加分支标识自己的公司，这样就可以区分
//获取Class对象中的注解信息
return bean;
}
@Override
public int getOrder() {
return 0;
}
}
重要な内容について話します。
1. postProcessBeforeInitializationこれは初期化前の操作であり、postProcessAfterInitializationは初期化後の操作です。
2.主にClassオブジェクトを使用して内部のアノテーション情報を取得します。getAnnotation（）メソッド。RestSchemaアノテーションはクラスの一意の識別子です（これはservicecombオープンソースマイクロサービスフレームワークのアノテーションです）。これはクラスと同等です。 RequestMapping。
3.ReflectionUtils.doWithMethodsこれは、スプリングに付属するリフレクションツールクラスです。これは何のためにありますか？主に、メソッドのアノテーションを取得するために、クラスのすべてのメソッドをトラバースできます。
ソースコードのorg.springframework.util.ReflectionUtils部分
public static void doWithMethods(Class<?> clazz, MethodCallback mc, MethodFilter mf) {
// Keep backing up the inheritance hierarchy.
Method[] methods = getDeclaredMethods(clazz);
for (Method method : methods) {
if (mf != null && !mf.matches(method)) {
continue;
}
try {
mc.doWith(method);
}
catch (IllegalAccessException ex) {
throw new IllegalStateException("Not allowed to access method '" + method.getName() + "': " + ex);
}
}
if (clazz.getSuperclass() != null) {
doWithMethods(clazz.getSuperclass(), mc, mf);
}
else if (clazz.isInterface()) {
for (Class<?> superIfc : clazz.getInterfaces()) {
doWithMethods(superIfc, mc, mf);
}
}
}4. MethodCallbackはコールバックインターフェイスです。ここでは、RequestMappingアノテーションをリストに取得した後にいくつかの操作を行います。
5.注文されたのはスプリングのインターフェースですが、用途は何ですか？BeanPostProcessorは、春までに公開されるインターフェイスです。複数の実装クラスが存在する可能性があります。Orderedの役割は、これらの実装クラスの実行順序を決定することです。値が小さいほど、早く実行されます。ここでの注文は気にしません。
ステップ2：MyApplicationListenerはApplicationListener <ContextRefreshedEvent>を実装します
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;
@Component
public class MyApplicationListener implements ApplicationListener <ContextRefreshedEvent>{
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
if(event.getApplicationContext().getParent()==null){//保证只执行一次
System.out.println("============================================spring容器启动完毕，现在再做一些自己的操作！");
new Thread(new ApiCheck()).start();
}
}
}
説明：ここでのApplicationListenerの役割は、他に何かする必要がある場合に、Springコンテナーがロードされた後にこのインターフェースを実装することです。ApplicationRunnerインターフェースは、そのような操作を実装するためにspringbootで提供されます。
3番目のステップ：事業運営ApiCheck.java
public class MyCache {
public static Map<String,List<String>> mappingMapList = new HashMap<>();
public static Map<String, List<String>> getMappingMapList() {
return mappingMapList;
}
public static void setMappingMapList(Map<String, List<String>> mappingMapList) {
MyCache.mappingMapList = mappingMapList;
}
}
import lombok.SneakyThrows;
import org.apache.servicecomb.core.SCBEngine;
import org.apache.servicecomb.core.SCBStatus;
import org.springframework.stereotype.Component;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@Component
public class ApiCheck implements Runnable {
@SneakyThrows
@Override
public void run() {
for (; ; ) {
SCBStatus currentStatus = SCBEngine.getInstance().getStatus();
if (currentStatus.equals(SCBStatus.UP)) {//如果一开始就改成UP，启动流程还没走完，发现是UP，不会往下走
Map<String, List<String>> mappingMapList = MyCache.getMappingMapList();
List<String> apiListNew = new ArrayList<>();
for (Map.Entry<String, List<String>> stringListEntry : mappingMapList.entrySet()) {
String schemaId = stringListEntry.getKey();
List<String> list = stringListEntry.getValue();
for (String s : list) {
apiListNew.add(schemaId+s);
}
}
File file = new File("C:\\....\\api.txt");
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "gbk"));
String s = "";
List<String> apiOldList = new ArrayList<>();
while (( s = bufferedReader.readLine()) != null) {
apiOldList.add(s);
}
for (String s1 : apiListNew) {
boolean haveFlag = false;
for (String s2 : apiOldList) {
if(s1.equals(s2)){
haveFlag = true;
break;
}
}
if(!haveFlag){
System.out.println("------------api不存在："+s1);
}
}
System.out.println("============================================API检查分析完毕！");
break;
}
TimeUnit.SECONDS.sleep(3);
}
}
}api.txt
/aa/query
/bb/insert
/cc/delete
/dd/xxquery説明：一般的に、APIはSpringの開始時にキャッシュマップに配置され、永続的なapi.txtと比較されます。api.txtよりも大きいことが判明した場合は、APIが追加されて達成されたことを意味します。検査の目的と機能が完了しました。！
効果画像：
要約：あなたが知る必要があること
- 基本的に、BeanPostProcessorとApplicationListenerおよびApplicationRunnerの使用法を知っています。
- ReflectionUtils.doWithMethodsのツールを知っている
- MethodCallbackコールバックインターフェイスを知っている
- Orderedインターフェースの役割を理解する
- Classオブジェクトは、クラスのアノテーションとメソッドのアノテーションをどのように取得しますか
これは高レベルの春とは見なされないかもしれませんが、少なくとも他の人に言うと、IOC、AOP、許可制御の反転、その他の理論的知識だけではありません。行きたいです。！！春の打ち上げに参加し、一歩踏み出しました！！