104

依存性注入自体の利点を理解しています。スプリングを例にとってみましょう。また、AOP、さまざまな種類のヘルパーなど、他の Spring 機能の利点も理解しています。次のような XML 構成の利点は何ですか?

<bean id="Mary" class="foo.bar.Female">
  <property name="age" value="23"/>
</bean>
<bean id="John" class="foo.bar.Male">
  <property name="girlfriend" ref="Mary"/>
</bean>

次のような単純な古い Java コードと比較して:

Female mary = new Female();
mary.setAge(23);
Male john = new Male();
john.setGirlfriend(mary);

これは、デバッグやコンパイル時間のチェックが容易で、Java しか知らない人なら誰でも理解できます。依存性注入フレームワークの主な目的は何でしょうか? (またはその利点を示すコードの一部。)


更新:
の場合

IService myService;// ...
public void doSomething() {  
  myService.fetchData();
}

IC フレームワークは、複数ある場合に注入したい myService の実装をどのように推測できますか? 特定のインターフェイスの実装が 1 つしかない場合、IoC コンテナーに自動的にそれを使用するように決定させると、2 番目の実装が表示された後に壊れます。また、インターフェイスの可能な実装が意図的に 1 つしかない場合は、それを注入する必要はありません。

その利点を示す IoC の構成の小さな部分を見ることは本当に興味深いでしょう。私はしばらくSpringを使用してきましたが、そのような例を提供することはできません. また、休止状態、dwr、および私が使用するその他のフレームワークの利点を示す 1 行を示すことができます。


更新 2:
再コンパイルせずに IoC 構成を変更できることを認識しています。それは本当に良い考えですか?誰かが再コンパイルせずに DB 資格情報を変更したいときは理解できます - 彼は開発者ではないかもしれません。実際に、開発者以外の誰かが IC 構成を変更する頻度はどれくらいですか? 開発者にとって、構成を変更する代わりにその特定のクラスを再コンパイルする努力はないと思います。また、開発者以外の場合は、おそらく彼の生活を楽にして、より単純な構成ファイルを提供したいと思うでしょう。


更新 3:

インターフェイスとその具体的な実装の間のマッピングの外部構成

それを外部化することの何がそんなに良いのですか?すべてのコードを外部にするわけではありませんが、ClassName.java.txt ファイルに配置し、その場で手動で読み取り、コンパイルすることはできますが、再コンパイルを回避できます。なぜコンパイルを避けるべきなのですか?!

手続き型コードではなく宣言的にマッピングを提供するため、コーディング時間を節約できます

宣言型アプローチが時間を節約する場合があることを理解しています。たとえば、Bean プロパティと DB 列の間のマッピングを 1 回だけ宣言すると、Hibernate はこのマッピングをロード、保存、HSQL に基づく SQL の構築などに使用します。ここで宣言的アプローチが機能します。Springの場合(私の例では)、宣言はより多くの行を持ち、対応するコードと同じ表現力を持っていました。そのような宣言がコードよりも短い例があれば、それを見てみたいです。

制御原理の反転により、実際の実装を偽の実装に置き換えることができるため (SQL データベースをインメモリのものに置き換えるなど)、単体テストが容易になります。

制御の反転の利点は理解しています (ここで説明する設計パターンを依存性注入と呼びたいと思います。なぜなら、IoC はより一般的だからです。多くの種類の制御があり、そのうちの 1 つ (初期化の制御) だけを反転しています)。なぜ誰かがプログラミング言語以外の何かを必要とするのかと尋ねていました。コードを使用して、実際の実装を偽の実装に置き換えることは間違いなくできます。そして、このコードは構成と同じことを表現します-フィールドを偽の値で初期化するだけです。

mary = new FakeFemale();

DIの利点は理解しています。同じことを行うコードを構成する場合と比較して、外部 XML 構成によって追加される利点がわかりません。私はコンパイルを避けるべきだとは思いません - 私は毎日コンパイルし、今も生きています。DI の構成は、宣言型アプローチの悪い例だと思います。宣言は、一度宣言され、さまざまな方法で何度も使用される場合に役立ちます。たとえば、hibernate cfg のように、Bean プロパティと DB 列の間のマッピングが保存、ロード、検索クエリの作成などに使用されます。Spring DI 構成は、次のように簡単に変換できます。この質問の冒頭のように、コードを構成することはできませんか? そして、それは Bean の初期化にのみ使用されますよね? つまり、宣言型アプローチでは何も追加されないということですよね?

休止状態のマッピングを宣言するとき、休止状態にいくつかの情報を与えるだけで、それに基づいて機能します-何をすべきかは教えません。春の場合、私の宣言は春に何をすべきかを正確に伝えます-では、なぜそれを宣言し、なぜそれをしないのですか?


最終更新:
みんな、多くの回答が依存性注入について教えてくれています。私はそれが良いことを知っています。質問は、コードを初期化するのではなく、DI 構成の目的に関するものです。コードを初期化する方が短くてわかりやすいと思う傾向があります。私の質問に対するこれまでの唯一の答えは、構成が変更されたときに再コンパイルを回避することです。別の質問を投稿する必要があると思います。これは私にとって大きな秘密であるためです。この場合、コンパイルを避ける必要があるのはなぜですか。

4

16 に答える 16

41

私自身にとって、IoCを使用する(そして外部構成を利用する)主な理由の1つは、次の2つの領域にあります。

  • テスト
  • 生産メンテナンス

テスト

テストを3つのシナリオに分割する場合(これは大規模な開発ではかなり正常です):

  1. ユニットテスト
  2. 統合テスト
  3. ブラックボックステスト

最後の2つのテストシナリオ(統合とブラックボックス)では、アプリケーションのどの部分も再コンパイルしません。

テストシナリオのいずれかで構成を変更する必要がある場合(つまり、別のコンポーネントを使用して銀行統合を模倣したり、パフォーマンスの負荷をかけたりする場合)、これは簡単に処理できます(これは、しかしIoC。

さらに、アプリが複数のサイトで使用されている場合(サーバーとコンポーネントの構成が異なる場合)、またはライブ環境で構成が変更されている場合は、テストの後の段階を使用して、アプリがそれらの変更を処理することを確認できます。

製造

開発者として、本番環境を制御できない(そしてすべきではない)ので(特にアプリが複数の顧客や個別のサイトに配布されている場合)、これはIoCと外部構成の両方を使用することの本当の利点です。 、開発者に戻ったりテストを行ったりすることなく、ライブ環境を微調整および調整するのはインフラストラクチャ/本番環境のサポート次第です(開発者がコンポーネントを移動するだけの場合はコストが高くなります)。

概要

IoCの外部構成の主な利点は、他のユーザー(開発者以外)にアプリケーションを構成する権限を与えることです。私の経験では、これは限られた状況でのみ役立ちます。

  • アプリケーションは、環境が異なる複数のサイト/クライアントに配布されます。
  • 本番環境とセットアップに対する限定的な開発制御/入力。
  • テストシナリオ。

実際には、実行される環境を制御できるものを開発する場合でも、時間の経過とともに、他の誰かに構成を変更する機能を与える方がよいことがわかりました。

  • 開発するとき、いつ変更されるかわかりません(このアプリは、会社が他の人に販売するのに非常に便利です)。
  • 適切な構成モデルを設定して使用することで処理できた可能性のあるわずかな変更が要求されるたびに、コードを変更することに固執したくありません。

注:アプリケーションは(実行可能ファイルだけでなく)完全なソリューションを指すため、アプリケーションの実行に必要なすべてのファイル

于 2008-10-08T12:20:02.153 に答える
14

依存性注入は、オブジェクトの委任が通常、オブジェクトの継承よりも有用なデザインパターンであるという観察にルーツを持つコーディングスタイルです(つまり、オブジェクトが持つ-関係はオブジェクトよりも有用です-関係)。ただし、DIが機能するには、オブジェクトインターフェイスを作成するためのもう1つの要素が必要です。これらの2つの強力なデザインパターンを組み合わせることで、ソフトウェアエンジニアは、柔軟な疎結合コードを作成できることにすぐに気付き、依存性注入の概念が生まれました。ただし、DIが実際に普及したのは、特定の高級言語でオブジェクトリフレクションが利用可能になるまではありませんでした。反射コンポーネントは、今日のほとんどの中核です。

言語は、通常のオブジェクト指向プログラミング手法と、オブジェクトインターフェイスおよびオブジェクトリフレクション(JavaやC#など)の両方を適切にサポートする必要があります。C ++システムでDIパターンを使用してプログラムを構築できますが、適切な言語内でのリフレクションサポートがないため、アプリケーションサーバーやその他のDIプラットフォームをサポートできず、DIパターンの表現力が制限されます。

DIパターンを使用して構築されたシステムの長所:

  1. 「依存」機能が明確に定義されたインターフェイスに外挿されるため、DIコードの再利用がはるかに簡単になり、適切なアプリケーションプラットフォームによって構成が処理される個別のオブジェクトを他のオブジェクトに自由にプラグインできます。
  2. DIコードはテストがはるかに簡単です。オブジェクトによって表現される機能は、アプリケーションロジックで期待されるインターフェイスを実装する「モック」オブジェクトを構築することにより、ブラックボックスでテストできます。
  3. DIコードはより柔軟です。それは本質的に緩く結合されたコードです-極端に。これにより、プログラマーは、一方の端で必要なインターフェースともう一方の端で表現されたインターフェースのみに基づいて、オブジェクトの接続方法を選択できます。
  4. DIオブジェクトの外部(Xml)構成は、他の人が予期しない方向にコードをカスタマイズできることを意味します。
  5. 外部構成は、オブジェクトの初期化とオブジェクトの相互依存性管理のすべての問題をアプリケーションサーバーで処理できるという点で、関心の分離パターンでもあります。
  6. DIパターンを使用するために外部構成は必要ないことに注意してください。単純な相互接続には、小さなビルダーオブジェクトで十分な場合がよくあります。2つの間の柔軟性にはトレードオフがあります。ビルダーオブジェクトは、外部から見える構成ファイルほど柔軟なオプションではありません。DIシステムの開発者は、柔軟性と利便性の利点を比較検討する必要があります。構成ファイルに示されているように、オブジェクトの構築を小規模で細かく制御すると、混乱と保守コストが増加する可能性があることに注意してください。

確かにDIコードはもっと面倒に思えますが、オブジェクトを他のオブジェクトに挿入するように構成するXMLファイルをすべて持つことの欠点は難しいようです。ただし、これがDIシステムのポイントです。一連の構成設定としてコードオブジェクトを組み合わせることができるため、最小限のコーディングでサードパーティのコードを使用して複雑なシステムを構築できます。

質問で提供された例は、適切に因数分解されたDIオブジェクトライブラリが提供できる表現力の表面に触れているだけです。ある程度の練習と多くの自己規律により、ほとんどのDI実践者は、アプリケーションコードのテストカバレッジが100%のシステムを構築できることに気付きます。この一点だけでも並外れたものです。これは、数百行のコードの小さなアプリケーションの100%のテストカバレッジではなく、数十万行のコードで構成されるアプリケーションの100%のテストカバレッジです。このレベルのテスト容易性を提供する他のデザインパターンを説明することができなくなっています。

たった数十行のコードのアプリケーションは、いくつかのオブジェクトと一連のXML構成ファイルよりも理解しやすいという点で正しいです。ただし、最も強力なデザインパターンと同様に、システムに新しい機能を追加し続けると、メリットが見られます。

つまり、大規模なDIベースのアプリケーションは、デバッグと理解の両方が容易です。Xml構成は「コンパイル時チェック」されていませんが、この作成者が認識しているすべてのアプリケーションサービスは、互換性のないインターフェイスを持つオブジェクトを別のオブジェクトに挿入しようとすると、開発者にエラーメッセージを提供します。そして、ほとんどは、すべての既知のオブジェクト構成をカバーする「チェック」機能を提供します。これは、注入されるオブジェクトAが、構成されたすべてのオブジェクト注入にオブジェクトBが必要とするインターフェイスを実装していることを確認することで、簡単かつ迅速に実行できます。

于 2008-09-25T08:21:37.907 に答える
7

これは少し難しい質問ですが、膨大な量の xml 構成が実際にはあまりメリットがないことに同意する傾向があります。重いフレームワークを含め、アプリケーションの依存関係をできるだけ軽くしたいと思っています。

多くの場合、コードは単純化されますが、複雑なオーバーヘッドがあり、問題を追跡するのがかなり困難になります (私はそのような問題を直接見たことがありますが、ストレートな Java の方がはるかに快適に処理できます)。

それはスタイルにもよると思いますが、あなたが何に慣れているか...独自のソリューションを飛ばして、それを裏返しに知っているという利点がありますか、それとも、構成がうまくいかないときに難しいことが判明する可能性のある既存のソリューションを利用するのが好きですか?ちょうどいいの?それはすべてトレードオフです。

ただし、XML 構成は私のちょっとした不満です... 私はそれを絶対に避けようとしています。

于 2008-09-25T07:44:53.563 に答える
5

コードをデータに変更できるときはいつでも、正しい方向への一歩を踏み出しています。

何かをデータとしてコーディングするということは、コード自体がより一般的で再利用可能であることを意味します。また、データが正確に適合する言語で指定される可能性があることも意味します。

また、XML ファイルを GUI やその他のツールに読み込んで、実用的に簡単に操作することもできます。コード例でそれをどのように行いますか?

私は、ほとんどの人がコードとしてデータに実装するものを常に因数分解しています。これにより、残っているコードが非常にきれいになります。人々がメニューをデータとしてではなくコードで作成することは考えにくいと思います.定型文のために、コードでメニューを作成することが明らかに間違っていることは明らかです.

于 2009-04-15T19:23:08.233 に答える
3

DI コンテナーを使用する理由は、単純なゲッターとセッターである何十億ものプロパティをコードに事前構成する必要がないからです。これらすべてを new X() でハードコーディングしますか? 確かに、デフォルトを設定できますが、DI コンテナーを使用すると、非常に簡単にシングルトンを作成でき、初期化の雑多なタスクではなく、コードの詳細に集中できます。

たとえば、Spring では、InitializingBean インターフェースを実装し、afterPropertiesSet メソッドを追加できます (コードを Spring に結合することを避けるために、「init-method」を指定することもできます)。これらのメソッドを使用すると、クラス インスタンスのフィールドとして指定されたインターフェイスが起動時に正しく構成されていることを確認でき、getter と setter を null チェックする必要がなくなります (シングルトンをスレッド セーフのままにしておくことを前提としています)。 )。

さらに、複雑な初期化を自分で行うよりも、DI コンテナーを使用して行う方がはるかに簡単です。たとえば、私は XFire の使用を支援しています (CeltiXFire ではなく、Java 1.4 のみを使用しています)。このアプリは Spring を使用していましたが、残念ながら XFire の services.xml 構成メカニズムを使用していました。要素の Collection が 1 つ以上のインスタンスではなく 0 つ以上のインスタンスを持つことを宣言する必要がある場合、この特定のサービス用に提供された XFire コードの一部をオーバーライドする必要がありました。

Spring Bean スキーマで定義された特定の XFire デフォルトがあります。したがって、Spring を使用してサービスを構成していた場合は、Bean を使用できたはずです。その代わりに、Bean を使用する代わりに、services.xml ファイルで特定のクラスのインスタンスを提供する必要がありました。これを行うには、コンストラクターを提供し、XFire 構成で宣言された参照を設定する必要がありました。実際に変更を加えるには、1 つのクラスをオーバーロードする必要がありました。

しかし、services.xml ファイルのおかげで、4 つの新しいクラスを作成し、コンストラクターの Spring 構成ファイルのデフォルトに従ってデフォルトを設定する必要がありました。Spring 構成を使用できた場合、次のように言えます。

<bean id="base" parent="RootXFireBean">
    <property name="secondProperty" ref="secondBean" />
</bean>

<bean id="secondBean" parent="secondaryXFireBean">
    <property name="firstProperty" ref="thirdBean" />
</bean>

<bean id="thirdBean" parent="thirdXFireBean">
    <property name="secondProperty" ref="myNewBean" />
</bean>

<bean id="myNewBean" class="WowItsActuallyTheCodeThatChanged" />

代わりに、次のようになりました。

public class TheFirstPointlessClass extends SomeXFireClass {
    public TheFirstPointlessClass() {
        setFirstProperty(new TheSecondPointlessClass());
        setSecondProperty(new TheThingThatWasHereBefore());
    }
}

public class TheSecondPointlessClass extends YetAnotherXFireClass {
    public TheSecondPointlessClass() {
        setFirstProperty(TheThirdPointlessClass());
    }
}

public class TheThirdPointlessClass extends GeeAnotherXFireClass {
    public TheThirdPointlessClass() {
        setFirstProperty(new AnotherThingThatWasHereBefore());
        setSecondProperty(new WowItsActuallyTheCodeThatChanged());
    }
}

public class WowItsActuallyTheCodeThatChanged extends TheXFireClassIActuallyCareAbout {
    public WowItsActuallyTheCodeThatChanged() {
    }

    public overrideTheMethod(Object[] arguments) {
        //Do overridden stuff
    }
}

したがって、最終的な結果として、追加の 4 つの Java クラスをコードベースに追加して、1 つの追加クラスといくつかの単純な依存関係コンテナー情報を実現する必要がありました。これは「ルールを証明する例外」ではなく、これがルールです... プロパティが DI コンテナーで既に提供されており、特別な状況に合わせてプロパティを変更するだけの場合、コードでの癖の処理ははるかにクリーンです。これは頻繁に発生します。

于 2008-10-01T02:12:36.563 に答える
3

私はあなたの答えを持っています

それぞれのアプローチには明らかにトレードオフがありますが、外部化された XML 構成ファイルは、IDE ではなくビルド システムを使用してコードをコンパイルするエンタープライズ開発に役立ちます。ビルド システムを使用すると、特定の値をコードに挿入することができます。たとえば、ビルドのバージョン (コンパイルするたびに手動で更新するのは面倒です)。ビルド システムがバージョン管理システムからコードを引き出す場合、問題はさらに大きくなります。コンパイル時に単純な値を変更するには、ファイルを変更し、コミットし、コンパイルし、変更のたびに元に戻す必要があります。これらは、バージョン管理にコミットしたい変更ではありません。

ビルド システムと外部構成に関するその他の有用な使用例:

  • 異なるビルドの単一のコード ベースにスタイル/スタイルシートを挿入する
  • 単一のコード ベースにさまざまな動的コンテンツのセット (またはそれらへの参照) を挿入する
  • 異なるビルド/クライアントのローカリゼーション コンテキストを注入する
  • Web サービス URI をバックアップ サーバーに変更する (メイン サーバーがダウンした場合)

更新: 上記の例はすべて、必ずしもクラスへの依存関係を必要としないものに関するものでした。ただし、複雑なオブジェクトと自動化の両方が必要なケースを簡単に構築できます。たとえば、次のようになります。

  • Web サイトのトラフィックを監視するシステムがあるとします。同時ユーザー数に応じて、ロギング メカニズムのオン/オフを切り替えます。おそらく、メカニズムがオフになっている間に、スタブ オブジェクトがその場所に配置されます。
  • ユーザーの数に応じて、参加者の数に応じて P2P を実行する機能を切り替えたい Web 会議システムがあるとします。
于 2011-02-24T01:35:08.720 に答える
2

ガールフレンドの新しい実装を挿入できます。したがって、コードを再コンパイルせずに新しい女性を挿入できます。

<bean id="jane" class="foo.bar.HotFemale">
  <property name="age" value="19"/>
</bean>
<bean id="mary" class="foo.bar.Female">
  <property name="age" value="23"/>
</bean>
<bean id="john" class="foo.bar.Male">
  <property name="girlfriend" ref="jane"/>
</bean>

(上記は Female と Hot Female が同じ GirlfFriend インターフェイスを実装していることを前提としています)

于 2008-09-25T08:02:59.213 に答える
2

設定を変更するたびにコードを再コンパイルする必要はありません。これにより、プログラムの展開と保守が簡素化されます。たとえば、構成ファイルを 1 回変更するだけで、あるコンポーネントを別のコンポーネントと交換できます。

于 2008-09-25T07:43:52.053 に答える
1

春の展望から、私はあなたに2つの答えを与えることができます。

まず、XML構成は、構成を定義する唯一の方法ではありません。ほとんどのことはアノテーションを使用して構成でき、XMLで実行する必要があるのは、ライブラリから使用している接続プールのように、とにかく記述していないコードの構成です。Spring 3には、例の手巻きDI構成と同様に、Javaを使用してDI構成を定義する方法が含まれています。したがって、Springを使用することは、XMLベースの構成ファイルを使用する必要があることを意味するわけではありません。

第二に、Springは単なるDIフレームワーク以上のものです。トランザクション管理やAOPなど、他にも多くの機能があります。Spring XML構成では、これらすべての概念が混在しています。多くの場合、同じ構成ファイルで、Beanの依存関係、トランザクション設定を指定し、バックグラウンドでAOPを使用して実際に処理されるセッションスコープのBeanを追加しています。XML構成は、これらすべての機能を管理するためのより良い場所を提供すると思います。また、アノテーションベースの構成とXML構成は、Javaベースの構成よりもスケールアップしやすいと感じています。

しかし、私はあなたの主張を理解しており、Javaで依存性注入構成を定義することに何の問題もありません。私は通常、単体テストでそれを自分で行います。DIフレームワークを追加していないほど小さいプロジェクトで作業しているときは、私は通常、Javaで構成を指定しません。これは、Springを使用することを選択したときに、Javaで構成を記述しないようにしようとしている種類の配管コードだからです。これは好みですが、XML構成がJavaベースの構成よりも優れているという意味ではありません。

于 2011-04-05T21:04:20.220 に答える
1

多くの場合、重要な点は、プログラムを作成した後で誰が構成を変更しているかということです。コード内の構成では、それを変更する人が元の作成者と同じスキルとソース コードなどへのアクセス権を持っていると暗黙のうちに想定します。

実稼働システムでは、設定のサブセット (たとえば、年齢) を XML ファイルに抽出し、システム管理者やサポート担当者が、ソース コードやその他の設定に対する完全な権限を与えずに値を変更できるようにすることが非常に実用的です。それらを複雑さから切り離します。

于 2010-06-17T22:22:29.517 に答える
1

.NET の世界では、ほとんどの IoC フレームワークが XML とコード構成の両方を提供します。

たとえば、StructureMap と Ninject は流暢なインターフェイスを使用してコンテナーを構成します。XML 構成ファイルを使用するように制限されることはなくなりました。.NET にも存在する Spring は、XML ファイルに大きく依存しています。これは、Spring が彼の歴史的な主要な構成インターフェースであるためです。ただし、コンテナーをプログラムで構成することは依然として可能です。

于 2008-09-25T07:43:34.237 に答える
1

部分的な構成を最終的な完全な構成に簡単に結合できます。

たとえば、Web アプリケーションでは、モデル、ビュー、およびコントローラーは通常、個別の構成ファイルで指定されます。宣言型アプローチを使用すると、次のようにロードできます。

  UI-context.xml
  Model-context.xml
  Controller-context.xml

または、別の UI といくつかの追加のコントローラーをロードします。

  AlternateUI-context.xml
  Model-context.xml
  Controller-context.xml
  ControllerAdditions-context.xml

コードで同じことを行うには、部分的な構成を組み合わせるためのインフラストラクチャが必要です。コードで実行することは不可能ではありませんが、IoC フレームワークを使用すると簡単に実行できます。

于 2008-09-26T04:01:54.247 に答える
0

Spring にはプロパティ ローダーもあります。このメソッドを使用して、環境に依存する変数を設定します (開発、テスト、受け入れ、生産など)。これは、たとえばリッスンするキューである可能性があります。

プロパティが変更される理由がない場合は、このように構成する理由もありません。

于 2008-09-25T07:45:13.623 に答える
0

あなたのケースは非常に単純であるため、Spring のような IoC (制御の反転) コンテナーは必要ありません。一方、「実装ではなくインターフェイスにプログラムする」場合 (これは OOP の良い習慣です)、次のようなコードを作成できます。

IService myService;
// ...
public void doSomething() {
  myService.fetchData();
}

(myService のタイプは IService であることに注意してください。具体的な実装ではなく、インターフェイスです)。IoC コンテナーが初期化中に IService の正しい具象インスタンスを自動的に提供できるようにすると便利です。多くのインターフェイスと多くの実装がある場合、手動でそれを行うのは面倒な場合があります。IoC コンテナー (依存性注入フレームワーク) の主な利点は次のとおりです。

  • インターフェイスとその具体的な実装の間のマッピングの外部構成
  • IoC コンテナーは、複雑な依存関係グラフの解決、コンポーネントの有効期間の管理など、いくつかのトリッキーな問題を処理します。
  • 手続き型コードではなく宣言的にマッピングを提供するため、コーディング時間を節約できます
  • 制御原理の反転により、実際の実装を偽の実装に置き換えることができるため (SQL データベースをインメモリのものに置き換えるなど)、単体テストが容易になります。
于 2008-09-25T07:51:11.770 に答える
0

XML 構成ファイルで初期化すると、コンピューターにアプリを展開しているクライアントでのデバッグ/適応作業が簡素化されます。(再コンパイル+バイナリファイルの差し替えが不要なため)

于 2010-11-12T15:58:36.710 に答える
-2

最も魅力的な理由の1つは、「ハリウッドの原則」です。電話しないでください。電話します。コンポーネントは、他のコンポーネントやサービス自体を検索する必要はありません。代わりに、それらは自動的に提供されます。Javaでは、これは、コンポーネント内でJNDIルックアップを実行する必要がなくなったことを意味します。

また、コンポーネントを個別に単体テストする方がはるかに簡単です。必要なコンポーネントの実際の実装を提供する代わりに、(場合によっては自動生成された)モックを使用するだけです。

于 2008-09-25T08:54:46.407 に答える