那麼如何確定是否確實使用了 Proxy 呢？ 為了您自己的理解，回到程式碼中並親眼目睹您確實正在使用 Proxy 是很有趣的。

一種簡單的方法是印出類別名稱

AccountService accountService = (AccountService) applicationContext.getBean(AccountService.class);
String accountServiceClassName = accountService.getClass().getName();
logger.info(accountServiceClassName);

在我的電腦上，它顯示以下輸出

INFO : transaction.TransactionProxyTest - $Proxy13

這個類別是一個 Dynamic Proxy，由 Spring 使用 JDK Reflection API 生成（更多資訊請參考 這裡）。

在關閉時（例如，當應用程式停止時），Proxy 類別將被銷毀，並且您將只在檔案系統上擁有 AccountService 和 AccountServiceImpl

Spring 如何將 Proxy 連接到目標類別呢？

@Controller public class AccountController { private AccountService accountService;

private void setAccountService(AccountService accountService) { this.accountService=accountService; }

//… }

<a href="http://blog.springsource.org/wp-content/uploads/2012/05/proxy-and-target1.png"><img class="aligncenter size-full wp-image-11128" title="proxy-and-target" src="http://blog.springsource.org/wp-content/uploads/2012/05/proxy-and-target1.png" alt="" width="316" height="255" /></a>

</div>
<div>

The attribute accountService is of type AccountService (interface). The variable dependency is on the interface type AccountService, not the implementation type, which reduces the coupling between classes. This is a best practice.

As seen before, both AccountServiceImpl and the generated Proxy implement the interface AccountService.
•    If there is a proxy, Spring injects the proxy
•    If not, Spring injects the instance of type AccountServiceImpl.

</div>
&nbsp;
<h3><a name="cache">Caching</a></h3>
<div>

Declarative caching is a new feature in Spring 3.1 that works like Spring’s declarative transaction support.

The @Cacheable annotation should be used in that way:

</div>
<div>
```java

public class AccountServiceImpl  implements AccountService {

@Cacheable(value="accounts", key="#id")
public Account findAccount (long id) {
 // only enter method body if result is not in the cache already
 }
}

您還應該在 Spring 配置中啟用快取，如下所示

<cache:annotation-driven />

以下是預期的結果

accountService.findAccount (1); // Result stored into cache for key “1”
accountService.findAccount (1); // Result retrieved from cache. Target method not called.
accountService.findAccount (2); // Result stored into cache for key “2”

在運行時，使用 Proxy 來添加快取行為。

*注意：Spring 3.1 嵌入了一個相當簡單的快取實作。 通常建議使用其他實作，例如 ehcache。 在此處提供的範例應用程式 (https://github.com/michaelisvy/proxy-samples) 中，您會找到一些使用嵌入式快取實作和 ehcache 的範例。*

如果 Bean 類別沒有實作任何介面怎麼辦？

預設情況下，如果您的 Bean 沒有實作介面，Spring 會使用技術繼承：在啟動時，會建立一個新的類別。 它繼承自您的 Bean 類別，並在子方法中添加行為。

Java 配置 (Java Configuration)

注意：本節需要一些 Spring 中 Java 配置的背景知識。 如果您不熟悉這種新的配置樣式，請隨時跳過它。

您可以在 這裡 了解更多關於 Java 配置的資訊。 還有一個很棒的文章討論了各種配置樣式 這裡。

@Configuration public class JavaConfig {

@Bean public AccountService accountService() {

return new AccountServiceImpl((accountRepository()); } @Bean public AccountRepository accountRepository () { //… }

}

Spring calls the method accountService() every time it needs to wire an instance of the bean “accountService” and this one returns a “new” object of type AccountService. If 10 beans are using a dependency of type AccountService, this method is called 10 times.

However, no matters the Spring configuration has been made using Java Configuration or not, every bean should be a singleton by default. How is that possible and where is the magic happening?
This diagram explains how things work internally:

</div>
<div><a href="http://blog.springsource.org/wp-content/uploads/2012/05/java-config.png"><img class="aligncenter size-full wp-image-11131" title="java-config" src="http://blog.springsource.org/wp-content/uploads/2012/05/java-config.png" alt="" width="507" height="328" /></a></div>
<div>

So the Proxy is adding behavior there. In the case that your bean should be a singleton, the action to turn your Plain Old Java Object into a singleton is performed by a child class (Proxy).

</div>
<div>
&nbsp;
<h3>Conclusion</h3>
We’ve seen some use-cases on how proxies are used inside the Spring framework. There are many other examples: Aspect Oriented Programming, Security (using Spring Security), thread safety, scopes, etc…

If you would like to know more on the impact on performance when using proxies, you can read <a href="http://blog.springsource.org/2007/07/19/debunking-myths-proxies-impact-performance/">Alef Arendsen’s blog entry here</a>.

</div>
<div>

<hr size="1" />

<div><a name="note">[1]</a>to be exact: the proxy class does not contain the transaction code internally. It delegates transaction handling to some classes that are part of the Spring framework. Spring will then handle transactions according to the Transaction Manager you have declared.&nbsp;

</div>
</div>