Este artigo analisa principalmente o conceito de design da arquitetura óssea da estrutura da primavera da estrutura da primavera. Por que esses componentes precisam desses componentes? Como eles se combinam para formar a arquitetura esquelética da Spring? Como o recurso AOP da primavera usa essas arquiteturas esqueléticas básicas para funcionar? Que tipo de modelos de design são usados na primavera para concluir este design? Qual é a sua inspiração desse conceito de design para o nosso futuro design de software? Este artigo responderá a essas perguntas em detalhes.
Arquitetura esquelética da primavera
Existem mais de uma dúzia de componentes na primavera, mas existem apenas alguns componentes principais.
Figura 1. O diagrama geral de arquitetura da estrutura da mola
Pode ser visto na figura acima que existem apenas três componentes principais na estrutura da mola: núcleo, contexto e feijão. Eles constroem toda a arquitetura esquelética da primavera. Sem eles, é impossível ter as características das camadas superiores, como AOP e Web. Abaixo também analisará a primavera principalmente a partir desses três componentes.
Conceito de design da primavera
Como mencionado anteriormente, os três componentes principais da mola são introduzidos. Bean é o verdadeiro protagonista na primavera.
O papel de Bean na primavera é como o significado do objeto para OOP. Assim como um estágio de desempenho, mas não há atores. Por que o papel é tão importante na primavera? Gerencia o arquivo de configuração, que é o seu mecanismo de injeção de dependência. E essa relação de injeção é gerenciada em um contêiner do COI, então qual é o objeto do contêiner do COI é embrulhado pelo feijão. A primavera é o objetivo de gerenciar esses objetos e algumas operações adicionais embalando objetos no feijão.
Sua estratégia de design é completamente semelhante ao conceito de design de Java para implementar o OOP. Esse ambiente nesse ambiente de acordo com certas regras. Pensando nisso, pense nas outras estruturas que usamos em um grande conceito de design semelhante.
Como trabalhar em conjunto com os componentes principais
Como mencionado anteriormente, o Bean é um fator -chave na primavera. Se você é um ator em uma performance, o contexto é o fundo do palco desse desempenho, e o núcleo deve ser os adereços do desempenho. Somente quando estão juntos, eles podem ter a condição mais básica que pode realizar um bom show. Obviamente, as condições mais básicas não podem destacar esse desempenho, e o programa que ele executa é suficientemente emocionante.
Sabemos que o Bean é embalado é o objeto e o objeto deve ter dados. eles e para manter esse relacionamento. Portanto, o contexto é uma coleção de relacionamento de feijão. Então, qual é o uso do componente principal? De fato, o núcleo é algumas colunas necessárias para que o relacionamento entre cada feijão descubra, estabeleça e mantenha o relacionamento entre cada bean.
Eles podem ser representados pela figura abaixo:
Figura 2. Três relacionamentos de componentes
Explicação detalhada dos componentes principais
Aqui, apresentaremos as relações hierárquicas de cada componente em detalhes, bem como a ordem de ordem em tempo de execução. Devemos prestar atenção ao uso da primavera.
Componente de feijão
A importância do componente Bean para a primavera foi explicada anteriormente. Os componentes do feijão são embalados sob o org.springframework.beans da primavera. Todas as categorias deste pacote resolvem três coisas: definição de Bean, criação de Bean e análise de Bean. Para os usuários da primavera, a única coisa que precisa ser cuidada é a criação do feijão.
O modelo típico de fábrica do Springbean foi criado.
Figura 4. A relação de herança da fábrica
O BeanFactory possui três subclasses: listableBeanFactory, HierchicalBeanFactory e AutoWire Capable Factory Bean. Mas, a partir da figura acima, podemos descobrir que a classe de implementação padrão final é defaultListableBeanFactory e ele implementa todas as interfaces. Então, por que definir tantos níveis de interfaces? Confira o código -fonte e as instruções dessas interfaces. o processo de operação. Por exemplo, a interface listableBeanFactory indica que esses feijões são listáveis e a fábrica hierárquica significa que esses feijões têm relações de herança, ou seja, cada feijão pode ter um pai feijão. A interface AutowirecapableBeanFactory define as regras automáticas de montagem de Bean. Essas quatro interfaces definem conjuntamente a coleta de feijão, a relação entre feijão e comportamento de feijão.
A definição de Bean inclui principalmente a descrição do BeandEfinition.
Figura 5. O diagrama de relacionamento hierárquico de classe
A definição de feijão é uma descrição completa de todas as informações nos nós que você definiu no arquivo de configuração da mola, incluindo vários sub -nodos. Quando a Spring analisou com sucesso um nó que você definiu, ele foi transformado em um objeto BeaNDefinition na primavera. Todas as operações serão realizadas para esse objeto no futuro.
O processo de análise de Bean é muito complicado e a função é dividida em detalhes, porque há muitos lugares a serem estendidos aqui e eles devem garantir flexibilidade suficiente para lidar com possíveis mudanças. A análise de Bean é principalmente para analisar o arquivo de configuração da mola. Este processo de análise é concluído principalmente através da classe na figura abaixo:
Figura 6. Classe analítica do Beban
Obviamente, também existem análises específicas do TAG.
Componente de contexto
O contexto é embalado sob o org.springframework.CONTEXT da primavera. Vamos dar uma olhada em como esse ambiente é construído.
ApplicationContext é a principal classe de contexto dos pais. Abaixo está o diagrama da estrutura do contexto:
Figura 7. Diagrama de estrutura de classe relacionado
Pode ser visto na figura acima que o ApplicationsContext herda o Beanfactory, que também mostra que o objeto principal do recipiente de mola é o feijão.
As subclasses do ApplicationContext incluem principalmente dois aspectos:
ConfigurableApplicationContext indica que o contexto é modificado, ou seja, o usuário pode adicionar ou modificar as informações de configuração existentes no contexto.
WebApplicationContext é o nome do nome, que é o contexto preparado para a Web.
Em seguida, o sub -redond é construir o tipo de contexto, seguido pela maneira de acessar o contexto. Esse nível de primeiro nível constitui um nível completo de contexto.
Em geral, o ApplicationContext deve concluir o seguinte:
◆ Faça um ambiente de aplicativo
◆ Use Beanfactory para criar o objeto Bean
◆ Salvar a tabela de relacionamento com objeto
◆ Pode capturar vários eventos
Como um contêiner do COI da primavera, o contexto integra basicamente a maioria dos recursos da primavera ou é a base da maioria dos recursos.
Componente central
Os componentes principais, como o componente principal da primavera, contêm muitas categorias -chave. Dessa forma de abstrair todos os recursos em uma interface, vale a pena aprender em um design futuro. Vamos dar uma olhada no papel desta parte na primavera.
A figura abaixo é o diagrama estrutural relacionado ao recurso relacionado:
Figura 8. Diagrama de estrutura de classe relacionado
Pode ser visto na figura acima que a interface de recursos encapsula vários tipos de recursos possíveis, ou seja, a diferença no tipo de arquivo está bloqueada para os usuários. Para o provedor de recursos, como empacotar recursos para outras pessoas para usá -lo também é um problema. Dessa forma, todos os recursos podem ser obtidos através da classe InputStream, para que o fornecedor de recursos também seja protegido. Outro problema é que o problema de carregar recursos, ou seja, o carregador dos recursos deve ser unificado.
Vamos dar uma olhada em como o contexto e o recurso estabeleceram um relacionamento? Primeiro veja o diagrama de seu relacionamento:
Figura 9. O diagrama de relacionamento de CONTEXT e recurso
Como pode ser visto na figura acima, o contexto confia o trabalho de carregamento, análise e descrição dos recursos da classe RecursoConvernResolver para concluir. Existem muitas maneiras semelhantes aos componentes principais.
Como trabalhar no contêiner do COI
Como mencionado anteriormente, a estrutura e a interdependência de componentes principais, componentes de feijão e componentes de contexto.
Como criar uma fábrica de feijão
Conforme descrito na Figura 2, o contêiner do COI é na verdade uma rede de relacionamento de feijão combinada com os outros dois componentes. A entrada de Built -in está no método de atualização da classe AbstractApplicationContext. O código deste método é o seguinte:
Lista 1.AbstractApplicationContext.Refresh
Public void Refresh () lança Beansexception, ilegalStateException {Sincronizada (this.startupshutdownmonitor) {// Prepare esse contexto para refrescar. Contexto. Registre os processadores de bean que o Bean Crea. Subclasse. Catch (Beansexception Ex) {// Destrua Singletons criados para evitar o Dangl Recursos ();Esse método é criar um código completo para todo o processo do contêiner do IOC e entender que cada linha de código dentro de basicamente entende os princípios e funções da maioria das primavera.
Este código contém principalmente essas etapas:
◆ Construir BeanFactory em ordem
◆ Evento pode estar interessado em registro
◆ Crie um objeto de instância do feijão
◆ desencadear eventos ouvindo
Abaixo combinado com a análise de código desses processos.
A segunda e a terceira frase é criar e configurar o Beanfactory. É uma atualização, ou seja, atualize a configuração. A seguir, é apresentado o código do método para atualizar o BeanFactory:
Lista 2. AbstractrefreshableApplicationContext
O Void final protegido refrescou () lança beansexception {if (hasbeanfactory ()) {DestroyBeans (); Sincronizado (this.BeanFactoryMonitor) {this.BeanFactory = BeanFactory;} Catch (IoException Ex) {Throw New ApplicationContextexcexce ("E/S Erro & Nbsp; Parsing Definição de Definição da fonte para" + getDisplayName (), ex);Este método realiza o método abstrato do APLICATIONCIONCIONAL ABRILHATIONFACTORIAL. Observe que os tipos de objetos de Beanfactory têm uma variedade de tipos de tipos de objetos. O objeto original do Beanfactory é o FactableBeanFactory.
Figura 10. Diagrama de herança da classe FaultListableBeanFactory
Além da classe relacionada ao Beanfactory, verificou -se que também estava relacionado ao registro do feijão. No método refrescante, existe uma linha de reflexões de carga (Beanfactory) que encontrará a resposta. contêineres.
Este processo pode ser explicado no seguinte mapa seqüencial:
Figura 11. Crie o prefácio de tempo do Beanfactory
O processo de análise e registro de Bean é o seguinte:
Figo
Depois de criar o Beanfactory, adicione algumas classes de ferramentas necessárias para a própria mola.
O próximo código de três linhas no abstrateApplicationContext desempenha um papel vital na expansão da função da primavera. As duas primeiras linhas podem modificar principalmente a configuração do Built -in BeanFactory agora. Portanto, todos eles estendem a função da mola, então devemos aprender a usar essa parte do uso da mola.
Entre eles, no método InvokeBeanFactoryPostProcessors, é principalmente obter subclasses para implementar a interface BeanFactoryPostProcessor. E executar seu método pós -processador de fábricas, a afirmação deste método é a seguinte:
Listagem 3.BeanFactoryPostProcessor.PostProcessBeanFactory
Void PostprocessBeanFactory (configurableListableBeanFactory BeanFactory) lança beansexception;
Seus parâmetros são feitiços, indicando que ele pode ser modificado pelo Beanfactory. Dados.
O método RegisterBeanPostProcessors também pode obter uma subclasse da definição do usuário da interface BeanPostProcessor e executá -los na variável do BeanPostProcessors no objeto BeanFactory. Os dois métodos são declarados no BEANPOSTPROCESSOR: Pós -processamentoForeInitialização e pós -processadosfterinilização são usados para executar durante a inicialização do objeto Bean. Pode executar operações definidas pelo usuário.
O último código de linha é o registro da inicialização do evento de monitoramento e dos outros ouvintes do sistema.
Como criar uma instância de feijão e construir a rede de relacionamento do feijão
A seguir, é apresentado o código instanciado de Bean, que começa com o método FinalizeBeanFactoryInitity.
Listagem 4.AbstractApplicationContext.FinishBeanFactoryInitialization
O Void Finicor do Void protegido (FACTILIÁRIO DO MESMO FORMULTRA PROCUSTIVO DO FORMO DE PRONTAGEM DO FORMOW MACHOUSTIVOLTEMENTE DESCONTELATIVO DO FORMO DESCOMENTE ENTREGIO DO FORMO DESCOMENTE ENTREGIO DO FORMO DESCOMENTE ENTREGIO DO IMs. Lazy-Init) Singletons.
Pode -se descobrir que a instância do feijão pode ser encontrada no Beanfactory. O Código do Método Pré -Instantiatesingtons é o seguinte:
Lista 5.DefaultListableBeanFactory.PreinStantialSingLetons
Public void pré-instantiatesingLetons () lança beansexception {if (this.logger.isinfoenabled ()) {this.logger.info ("pré-instantando singletens em";} sincronizada (this.beainitionMap) {para (string beaname: this: this. beandefinitionNames) {rootBeandefinition BD = getMergedLocalbeandefinition (Beanname); if (! Bd.isabstract () &&ISSINGLEON () &&! ()) {if (IsfactoryBean (Beanname)) {Final FactoryBean Factory = (FactoryBean) GetBean (Factory_bean_prefix+ Beanname); Boolean Isogerinit; IiseAghtinit (). ;}}}}}}}}Há um feijão muito importante aqui -pode ser dito que a função da maior parte da expansão da primavera está relacionada a este feijão. Ele pode definir o método de gerar um objeto de instância, desde que seu método GetObject seja implementado. No entanto, o objeto de instância deste feijão dentro da primavera é a FactoryBean. O objeto de obtenção de Spring em si é concluído com & para concluir.
Como criar um objeto de instância do feijão e como criar uma chave central no relacionamento associado entre os objetos da instância do feijão, a seguir é o fluxograma desse processo.
Figura 13. Fluxografia de criação da instância do Bean
Se é um feijão comum, ele cria sua instância diretamente, chamando o método getBean. A seguir, é apresentado o mapa sequencial da criação de uma instância do feijão:
Figura 14. Criação seqüencial da criação de instância
Outra parte muito importante é estabelecer o relacionamento entre as instâncias do objeto Bean.
Figura 15. Estabelecimento de relacionamento de objetos do Bean
Ponto de expansão do contêiner do COI
Outro problema é como fazer com que esses objetos de feijão tenham uma certa extensibilidade, ou seja, algumas operações podem ser adicionadas. Então, quais são as extensões? Como a primavera chama essas extensões?
Para o contêiner do IOC da primavera, existem tantos. BeanFactoryPostProcessor, BeanPostProcessor. Eles são chamados ao construir o Beanfactory e construir objetos de feijão. Há inicializando oBean e DisposableBean. Os usuários podem implementar o método definido nessas interfaces e a primavera os ligará no momento apropriado. Outro é a FactoryBean.
Esses pontos de expansão são geralmente onde usamos o Spring para concluir nossas tarefas específicas. . Você pode usar a seguinte metáfora para explicar.
Comparamos o contêiner do IOC com uma caixa. Em seguida, o relacionamento correspondente é o BeanFactory é o modelo de fabricação de máquina, o modo de bola é o feijão e a bola do modo de bola é a instância do feijão. Onde as extensões são mencionadas anteriormente? BeanFactoryPostProcessor corresponde à criação de um modelo de bola, e você terá a oportunidade de fazer uma correção dele, ou seja, ele pode ajudá -lo a modificar o modo de bola. InicializandoBean e DisposableBean estão no início e no final dos modelos de bola, e você pode concluir alguns preparativos e o trabalho de rejeição. O BeanPostProcessor permite que você faça correções apropriadas no modo de bola. Finalmente, há um FactoryBean, que é um modelo de bola mágica. Este modo de bola não é antecipadamente, mas você determinará sua forma para ele. as bolas que você quer
Como usar o contêiner do COI para mim
A introdução anterior do processo de construção do recipiente de mola, o que a primavera pode fazer por nós e o que o contêiner do IOC da primavera pode fazer? Devemos primeiro criar um contêiner do IOC usando o Spring.
O COI está realmente construindo um cubo de Rubik para você. Então, como participamos? Foi o que eu disse anteriormente para entender algumas extensões na primavera e mudamos o comportamento comum da primavera, alcançando esses pontos estendidos. Quanto a como alcançar o ponto de expansão para obter os resultados da personalidade que queremos, há muitos exemplos na primavera. usado para referência.
Explicação detalhada dos recursos da AOP na primavera
O princípio da implementação de proxy dinâmico
Para entender a AOP da Spring, o princípio da agência dinâmica deve ser entendida primeiro, porque a AOP é implementada com base em proxy dinâmico. O agente dinâmico deve começar com o próprio JDK.
Há uma classe de procuração no pacote Java.Lang.Reflet JDK, que é a entrada da classe da agência. A estrutura desta classe:
Figura 16. Estrutura de proxi. Estrutura
Na figura acima, os quatro são métodos públicos. O último método NewProxyInstance é o método de criar objetos proxy. O código -fonte deste método é o seguinte:
Lista 6.Proxy.NewProxyInstance
Objeto estático público NewProxyInstance (ClassLoader carregador, classe> [] interfaces, InvocatchHandler H) lança ilegalagumentException {if (h == null) {th line new nullpointerException ();} classe cl = getProxyclass (carregador, interfaces); = cl.getConstructor (construtorporams); );} Catch (instantionException e) {Troque a nova Internet (e.toString ());} Catch nova Internet (e.toString ());}}Este método requer três parâmetros: Classloader, que é usado para carregar a classe Classe Proxy. Interfaces são aquelas interfaces a serem representadas. InvocationHandler, é usado para executar a operação de usuários personalizados pelos usuários, além dos métodos na interface proxy. O usuário chama o método de destino é representado pelo método exclusivo definido na classe InvacationHandler. Isso será explicado em detalhes posteriormente.
Vamos ver como o proxy produz a classe de proxy. É revelado abaixo.
Figura 17. Crie objetos de proxy
De fato, pode ser encontrado na figura acima que a classe do agente está no método do generateProxyclass of ProxyGenerator. A classe Proxygientor é embrulhada em Sun.Misc.
Se houver essa interface, como segue:
Lista 7. Classe SimpleProxy
interface pública SimpleProxy {public void sizemethod1 ();A estrutura de classe gerada pelo agente é a seguinte:
Lista 8. $ Classe Proxy2
Classe pública $ proxy2 estende Java.lang.rang.reflect.proxy implementa o SimpleProxy {java.lang.reflect.method m0; Método M3;O método nesta classe chamará o método Invoke de InvocationHandler e cada método corresponderá a uma variável de propriedade. É assim que todo o agente é realizado.
Como alcançar o Springlaop
A partir do princípio do agente anterior, sabemos que o objetivo do proxy é que, quando o método de destino é chamado, podemos executar o método de invasão da classe InvocationHandler, portanto, como fazer um artigo sobre o InvocationHandler é a chave para a implementação do AOP .
A implementação da AOP da primavera é um acordo para cumprir a AOP Alliance. Ao mesmo tempo, a primavera expandiu -a, adicionando algumas interfaces como Pointcut e Advisor para torná -lo mais flexível.
Abaixo está um diagrama de classes do proxy dinâmico do JDK:
Figura 18.JDK Diagrama de classes de proxy dinâmico
A figura acima mostra claramente a interface definida pela definição da AOP Alliance. Não vamos discutir como a primavera expande a AOP Alliance.
Lista 9. Configure o feijão proxy
<bean id = "testBeansingleton"> <propriedade name = "proxyInterfaces"> <value> org.springframework.ap.framework.prototypeTests $ testbean value> p roperty> <name da propriedade = "destino"> <ref local = "testbeArTetget" > Ref> Propriedade> <Propriedade Name = "Singleton"> <Value> TrueValue> Propriedade> <Propriedade Name = "Interceptores"> <List> <Value> TEMSINTINTERCECTORVALUE> <Val ue> TestIntercetor2Value> List> Propriedade> Bean>
Na configuração, consulte que a interface do agente está definida, a classe de implementação da interface é a classe de destino e o interceptor é chamado antes de executar o método de destino. Essência
Vamos ver como a primavera completa o agente e como chamar o interceptador.
Como mencionado anteriormente, a Spring AOP também atinge seu próprio ponto de expansão para concluir esse recurso. Obviamente, o objeto proxy deve ser gerado dinamicamente através da classe proxy.
A seguir, é apresentado o gráfico de tempo do objeto proxy criado pela primavera:
Figura 19. O surgimento do objeto objeto
Depois que a primavera cria um objeto de proxy, quando você chama o método no objeto de destino, você será representado no método Invoke da classe InvocationHandler, que foi explicada anteriormente. Aqui, a classe JDkdynamicaopProxy implementa a interface InvocationHandler.
Vamos dar uma olhada em como a primavera chama o interceptador.
Figura 20.Spring chama o interceptador
O acima é o agente dinâmico do JDK.
Análise de modo de design na primavera
Também existem muitos padrões de design usados na primavera, como modo de fábrica, modo de singles, modo de modelo, etc., em "A arquitetura do sistema e o modelo de design da estrutura da Webx", "Arquitetura de sistema e análise de modo de modo do Tomcat", é já apresentado. Aqui, apresentamos principalmente o modo de agência e o modo de estratégia.
Modo proxy
Princípio do modo de proxy
O modo proxy é criar um objeto proxy para um determinado objeto, e o objeto proxy controla a referência ao objeto original, e a criação desse objeto proxy pode adicionar algumas operações adicionais ao objeto original. Abaixo está a estrutura do modo proxy:
Figura 21. A estrutura do modo proxy
Assunto: tema abstrato, é uma interface realizar o objeto real do objeto do agente.
ProxySubject: Além da interface da definição de temas abstratos, a classe de proxy também deve manter uma referência do objeto do agente
RealSubject: A classe do agente é o objeto de destino.
Como implementar o modo proxy na primavera
O agente dinâmico do JDK no Spring AOP é alcançado usando a tecnologia de modo de agência. Além da interface do objeto proxy na primavera, também haverá org.springframework.aop.springproxy e org.springframework.apork.advise. O construtor de usar o modo proxy na primavera é o seguinte:
Figura 22. O diagrama estrutural do modo proxy é usado na fiação
$ Proxy é o objeto de proxy criado, e o assunto é um tema abstrato, e o objeto de proxy é manter uma referência ao objeto de destino através do InvocationHandler.
Uma estrutura de objetos de proxy real na primavera é a seguinte:
Lista 10 Objeto Proxy $ proxy4
Classe pública $ proxy4 estende java.lang.reflect.proxy implementa org.springframework.ap.framework.prototypetSts $ testbean work.aop.springproxy org.springframework.aop.framework.advned {java.lang.reflecthod. reflete.Method M9; .Method M26; .reflect.method m11; java.lang.reflect.method m22; java.lang.reflect.Method m3; java.lang.reflect.Method java.lang.reflect. Method m4; java.lang.reflet.method m19; java .lang.reflect.Method M7; java.lang.reflet.method m15; java.lang.reflet.method m20; left.Method M10; java. LANG.Reflect.Method M1; java.lang.reflect.Method M17; java .lang.reflect.Method M21; java.lang.reflect.Method m0; ava.lang.reflet.method m24; int HashCode (); int indexof (org.SpringFramework.aop.advisor); int interxof (org.aopalliance. aip.advice); ject); java.lang.string tostring (); void sayhello (); void dosomething (); void dosometHing2 (); java.lang.class getProxiedIndIndIndIndIndIndIRFACES (); ProxytargetClass (); Org.SpringFramework.aop .advisor; getadvisors (); void addvisor (int, org.springframework.aip.advisor) Throws org.SpringFramework.aP.framework.aPConfigeXception; void addadvisor (ORG.Sprin gframework.aop.advisor) Throws org.SpringFramework.aop. framework.aPConfigeXception; void SetTargetsource (ORG .springframework.aop.targetsource); ORG.SpringFramework.aop.Targetsource GetTARGETSource (); d (); Boolean IsinterfaceProxied (java.lang.class); Boolean Removeadvisor (org.SpringFramework.aP. advisor );; Boolean SOR, ORG.SpringFramework.aP.Advisor) Throws org.SpringFramework.aop.framework.aPConfigeXception; void addAdvice (ORG.AOPALLIANCE.AOP.ADVICE) Throws org.SpringFramework.aP.framework.aPConfigexception; void addvice (int, org.aopalliance.aop.advic e) Throws org.Springframework.aP.framework.aPConfigeXception; .aop.advice); java.lang.string toproxyconfigstring (); Boolean isfrozen (); void setexposeProxy (Boolean);Modo de estratégia
策略模式原理
策略模式顾名思义就是做某事的策略，这在编程上通常是指完成某个操作可能有多种方法，这些方法各有千秋，可能有不同的适应的场合，然而这些操作方法都有可能用到。各一个操作方法都当作一个实现策略，使用者可能根据需要选择合适的策略。
下面是策略模式的结构：
图23.策略模式的结构
Context：使用不同策略的环境，它可以根据自身的条件选择不同的策略实现类来完成所要的操作。它持有一个策略实例的引用。创建具体策略对象的方法也可以由他完成。
◆Strategy：抽象策略，定义每个策略都要实现的策略方法
◆ConcreteStrategy：具体策略实现类，实现抽象策略中定义的策略方法
◆Spring中策略模式的实现
◆Spring中策略模式使用有多个地方，如Bean定义对象的创建以及代理对象的创建等。这里主要看一下代理对象创建的策略模式的实现。
前面已经了解Spring的代理方式有两个Jdk动态代理和CGLIB代理。这两个代理方式的使用正是使用了策略模式。它的结构图如下所示：
图24.Spring中策略模式结构图
在上面结构图中与标准的策略模式结构稍微有点不同，这里抽象策略是AopProxy接口，Cglib2AopProxy和JdkDynamicAopProxy分别代表两种策略的实现方式，ProxyFactoryBean就是代表Context角色，它根据条件选择使用Jdk代理方式还是CGLIB方式，而另外三个类主要是来负责创建具体策略对象，ProxyFactoryBean是通过依赖的方法来关联具体策略对象的，它是通过调用策略对象的getProxy (ClassLoaderclassLoader)方法来完成操作。
Resumir
本文通过从Spring的几个核心组件入手，试图找出构建Spring框架的骨骼架构，进而分析Spring在设计的一些设计理念，是否从中找出一些好的设计思想，对我们以后程序设计能提供一些思路。接着再详细分析了Spring中是如何实现这些理念的，以及在设计模式上是如何使用的。