Este artículo analiza principalmente el concepto de diseño de la arquitectura ósea del marco de primavera del marco de primavera. ¿Por qué estos componentes necesitan estos componentes? ¿Cómo se combinan para formar la arquitectura esquelética de Spring? ¿Cómo usa la función AOP de Spring estas arquitecturas esqueléticas básicas para funcionar? ¿Qué tipo de modelos de diseño se utilizan en Spring para completar este diseño? ¿Cuál es su inspiración de este concepto de diseño para nuestro diseño de software futuro? Este artículo responderá a estas preguntas en detalle.
Arquitectura esquelética de primavera
Hay más de una docena de componentes en Spring, pero solo hay unos pocos componentes centrales reales.
Figura 1. El diagrama general de arquitectura del marco de la transmisión
Se puede ver en la figura anterior que solo hay tres componentes centrales en el marco de resorte: núcleo, contexto y frijoles. Construyen toda la arquitectura esquelética de primavera. Sin ellos, es imposible tener las características de las capas superiores, como AOP y Web. A continuación también analizará el resorte principalmente de estos tres componentes.
Concepto de diseño de primavera
Como se mencionó anteriormente, se introducen los tres componentes centrales de Spring. Bean es el verdadero protagonista en primavera.
El papel de Bean en la primavera es como el significado de objetos para OOP. Al igual que una etapa de actuación, pero no hay actores. ¿Por qué el rol bean o por qué es tan importante en la primavera? administra el archivo de configuración, que es su mecanismo de inyección de dependencia. Y esta relación de inyección se maneja en un contenedor del COI, entonces, ¿cuál es el objeto del contenedor del COI está envuelto por frijoles? La primavera es el propósito de administrar estos objetos y algunas operaciones adicionales empacando objetos en Bean.
Su estrategia de diseño es completamente similar al concepto de diseño de Java para implementar OOP. Este entorno en este entorno de acuerdo con ciertas reglas. Pensando en ello, piense en los otros marcos que usamos en un gran concepto de diseño similar.
Cómo trabajar junto con los componentes centrales
Como se mencionó anteriormente, Bean es un factor clave en la primavera. Si usted es un actor en una actuación, el contexto es el fondo de la etapa de esta actuación, y el núcleo debe ser los accesorios de la actuación. Solo cuando están juntos pueden tener la condición más básica que puede realizar un buen espectáculo. Por supuesto, las condiciones más básicas no pueden hacer que este rendimiento se destaque, y el programa que realiza es lo suficientemente emocionante.
Sabemos que Bean está empaquetado es objeto, y el objeto debe tener datos. ellos y para mantener esta relación. Entonces, el contexto es una colección de relación de frijoles. Entonces, ¿cuál es el uso del componente central? De hecho, el núcleo es algunas columnas necesarias para que la relación entre cada frijol descubra, establezca y mantenga la relación entre cada frijol.
Pueden ser representados por la siguiente figura:
Figura 2. Relaciones de tres componentes
Explicación detallada de los componentes centrales
Aquí presentaremos las relaciones jerárquicas de cada componente en detalle, así como el pedido de pedido en tiempo de ejecución. Deberíamos prestar atención al uso de la primavera.
Componente de frijoles
La importancia del componente de frijoles para la primavera se ha explicado anteriormente. Los componentes de frijoles están empaquetados en Spring's Org.SpringFramework.Beans. Todas las categorías en este paquete resuelven tres cosas: la definición de Bean, la creación de Bean y el análisis de Bean. Para los usuarios de primavera, lo único que debe ser cuidadoso es la creación de Bean.
Se creó el modelo de fábrica típico de Springbean.
Figura 4. La relación de herencia de la fábrica de The Bean
BeanFactory tiene tres subclases: fábrica de frijoles capaces de AutOtableBeanFeanFeany, jerárquicos y capaces de AutoWire. Pero de la figura anterior, podemos encontrar que la clase de implementación predeterminada final es predeterminada. Entonces, ¿por qué definir tantos niveles de interfaces? Consulte el código fuente y las instrucciones de estas interfaces. el proceso de operación. Por ejemplo, la interfaz de Factory enumerable indica que estos frijoles son listables, y Jerárquico BeanFactory significa que estos frijoles tienen relaciones de herencia, es decir, cada bean puede tener un frijol padre. La interfaz AutoWirecapableBeanFactory define las reglas de ensamblaje automático de Bean. Estas cuatro interfaces definen conjuntamente la recolección de frijoles, la relación entre el comportamiento de frijoles y frijoles.
La definición de Bean incluye principalmente la descripción de BeanDefinition.
Figura 5. El diagrama de relación jerárquica de clase definió Bybean
La definición de Bean es una descripción completa de toda la información en los nodos que definió en el archivo de configuración de Spring, incluidos varios subnodos. Cuando la primavera analizó con éxito un nodo que definió, se transformó en un objeto Beandefinition dentro de la primavera. Todas las operaciones se realizarán para este objeto en el futuro.
El proceso de análisis de Bean es muy complicado, y la función se divide en detalles, porque hay muchos lugares para extenderse aquí, y deben garantizar una flexibilidad suficiente para hacer frente a posibles cambios. El análisis de Bean es principalmente para analizar el archivo de configuración de Spring. Este proceso de análisis se completa principalmente a través de la clase en la figura a continuación:
Figura 6. Clase analítica de Bean
Por supuesto, también hay un análisis específico de TAG.
Componente de contexto
El contexto está empaquetado bajo Spring's Org.SpringFramework.Context. Echemos un vistazo a cómo se construye este entorno.
AplicationContext es la principal clase de contexto principal. A continuación se muestra el diagrama de la estructura del contexto:
Figura 7. Diagrama de estructura de clases relacionada con el contexto
Se puede ver a partir de la figura anterior que las aplicaciones Heredar BeanFactory, que también muestra que el objeto principal del contenedor de resorte es Bean.
Las subclases de ApplicationContext incluyen principalmente dos aspectos:
ConfiguableApplicationContext indica que el contexto se modifica, es decir, el usuario puede agregar o modificar dinámicamente la información de configuración existente en el contexto.
WebApplicationContext es el nombre del nombre, que es el contexto preparado para la web.
Luego, el sub -ddown es construir el tipo de contexto, seguido de la forma de acceder al contexto. Tal nivel de primer nivel constituye un nivel de nivel de contexto completo.
En general, el aplicaciones de la aplicación debe completar lo siguiente:
◆ Haga un entorno de aplicación
◆ Use BeanFactory para crear el objeto Bean
◆ Guardar la tabla de relación de objetos
◆ Puede capturar varios eventos
Como contenedor de COI Spring, el contexto básicamente integra la mayoría de las características de Spring, o es la base de la mayoría de las características.
Componente central
Los componentes centrales, como componente central de Spring, contienen muchas categorías clave. Vale la pena aprender a abstrae todos los recursos en una interfaz en el diseño futuro. Echemos un vistazo al papel de esta parte en la primavera.
La siguiente figura es el diagrama estructural relacionado con los recursos relacionados:
Figura 8. Diagrama de estructura de clase relacionada con el rato
Se puede ver en la figura anterior que la interfaz de recursos encapsula varios tipos de recursos posibles, es decir, la diferencia en el tipo de archivo está bloqueada para los usuarios. Para el proveedor de recursos, cómo empacar recursos para otras personas también es un problema. De esta manera, todos los recursos se pueden obtener a través de la clase InputStream, por lo que el proveedor de recursos también está protegido. Otro problema es que el problema de la carga de los recursos, es decir, el cargador de los recursos debe unificarse desde la figura anterior, puede la interfaz puede cargar todos los recursos, y su implementación predeterminada es el DeFaultresourceloader.
Echemos un vistazo a cómo el contexto y los recursos han establecido una relación. Primera mira al diagrama de su relación:
Figura 9. El diagrama de relación de recursos y recursos
Como se puede ver en la figura anterior, el contexto confía el trabajo de carga, análisis y descripción de los recursos a la clase de recursos para completar. Hay muchas formas similares a los componentes centrales.
Cómo trabajar en el contenedor del COI
Como se mencionó anteriormente, la estructura y la interdependencia de los componentes centrales, los componentes de frijoles y los componentes de contexto.
Cómo crear una fábrica de factor de bean
Como se describe en la Figura 2, el contenedor IOC es en realidad una red de relaciones de frijoles combinada con los otros dos componentes. La entrada Built -in está en el método de actualización de la clase AbstractApplicationContext. El código de este método es el siguiente:
Lista 1.AbstractApplicationContext.Refresh
Public void rect () lanza BeanSexception, IlegalStateException {Synchronized (this.StartUpshutdownmonitor) {// Prepara esta fábrica contexto. Registro de los procesadores de frijoles. Subclases. Catch (BeanSexception EX) {// Destruye los singletones creados para evitar recursos ();Este método es construir un código completo para todo el proceso de contenedores del COI y comprender que cada línea de código en el interior entiende básicamente los principios y funciones de la mayoría de la primavera.
Este código contiene principalmente tales pasos:
◆ Build BeanFactory en orden
◆ El evento puede estar interesado en el registro
◆ Crear un objeto de instancia de Bean
◆ Actualización de eventos que escuchan
A continuación combinado con el análisis de código de estos procesos.
La segunda y tercera oración es crear y configurar la factura de bean. Esta es una actualización, es decir, actualizar la configuración. El siguiente es el código de método para actualizar el beanfactory:
Lista 2. AbstractrefreshableApplicationContext.
Final de refrescos Final de BeanSexception {if (HasBeanFactory ()) {DestroyBeSS (); ; Sincronizado (this.BeanFactoryMonitor) {this.BeanFactory = BeanFactory;} Catch (IOException ex) {Throw New ApplicationContextExCeXCE PionEste método realiza el método abstracto de AbstractApplicationContext RefreshBeanFactory. Tenga en cuenta que los tipos de objetos de Factory tienen una variedad de tipos de objetos. El objeto original de BeanFactory es el valor predeterminado de Factory.
Figura 10.defaultListableBeanFactory Class Diagrama de herencia
Además de la clase relacionada con BeanFactory, se descubrió que también estaba relacionado con el registro de frijoles. En el método RefreshBeanFactory, hay una línea de carga de carga (BeanFactory) que encontrará la respuesta. contenedores.
Este proceso puede explicarse en el siguiente mapa secuencial:
Figura 11. Cree el prefacio de tiempo de laFactory
El análisis de análisis y registro de Bean es el siguiente:
Higo
Después de crear el BeanFactory, agregue algunas clases de herramientas que se necesitan por la primavera misma.
El siguiente código de tres líneas en AbstractApplicationContext juega un papel vital en la expansión de la función de Spring. Las dos primeras líneas se permiten principalmente modificar la configuración de BeanFactory construida ahora. Por lo tanto, todos extienden la función de Spring, por lo que debemos aprender a usar esta parte del uso de Spring.
Entre ellos, en el método InvokeBeanFactoryPostProcessors, es principalmente para obtener subclases para implementar la interfaz BeanFactoryPostProcessor. Y ejecutar su método PostProcessBeanFactory, la declaración de este método es la siguiente:
Listado 3.BeanFactoryPostProcessor.PostProcessBeanFactory
Void PostProcessBeanFactory (configuraciónBeanFactory BeanFactory) lanza BeanSexception;
Sus parámetros son BeanFactory, lo que indica que puede ser modificado por BeanFactory. Datos. Los usuarios los modifican a voluntad.
El método RegistroBeanPostProcessors también puede obtener una subclase de la definición del usuario de la interfaz BeanPostProcessor y ejecutarlos a la variable BeanPostProcessors en el objeto BeanFactory. Los dos métodos se declaran en BeanPostProcessor: PostProcessbeForinitialization y PostProcessAfterinilization se utilizan para ejecutar durante la inicialización del objeto Bean. Puede realizar operaciones definidas por el usuario.
El último código de línea es el registro de la inicialización del evento de monitoreo y los otros oyentes del sistema.
Cómo crear una instancia de Bean y construir la red de relaciones del bean
El siguiente es el código instanciado de frijol, que comienza con el método de finura de información de facturación.
Listado 4.AbstractApplicationContext.FinishBeanFactoryInitialización
Void finkBeanFactoryInitialization (configururawlistableFactory BeanFactory) {// Lazy-Init) Singletons.Se puede encontrar que la instancia de Bean se puede encontrar en la Factory de Bean. El código del método preinstantiatesingletons es el siguiente:
Lista 5.DefaultListableBeanFactory.Preinstantialsingletons
Public void preinstantiatesingletons () lanza BeanSexception {if (this.logger.isinfoEnabled ()) {this.logger.info ("preinstantantes singletons en";} sincronizado (this.beanDefinitionMap) {para (string beanName: this: this: this: this. BeanDefinitionNames) {rootBeanDefinition bd = getMergedLocalBeanDefinition (BeanName); IsEagerInit; . IISEAGERINIT (); ;}}}}}}}}Hay un frijol muy importante aquí, se puede decir que la función de la mayor parte de la expansión de Spring está relacionada con este frijol. Puede definir el método para generar un objeto de instancia siempre que se implementa su método GetObject. Sin embargo, el objeto de instancia de este frijol dentro de la primavera es fábrica. El objeto de la fábrica de obtención de Spring se completa con y para completar.
Cómo crear un objeto de instancia del bean y cómo construir una clave central en la relación asociada entre los objetos de instancia de Bean, el siguiente es el diagrama de flujo de este proceso.
Figura 13. Diagrama de flujo de creación de instancias de Bean
Si es un frijol ordinario, crea su instancia directamente, llamando al método GetBean. El siguiente es el mapa de la creación de una instancia de Bean:
Figura 14. Gráfico secuencial de creación de instancia de Bean
Otra parte muy importante es establecer la relación entre las instancias de objeto Bean.
Figura 15. Establecimiento de relación de objetos abiertos
Punto de expansión del contenedor del COI
Otro problema es cómo hacer que estos objetos de frijoles tengan una cierta extensibilidad, es decir, se pueden agregar algunas operaciones. Entonces, ¿cuáles son las extensiones? ¿Cómo llaman a estas extensiones de primavera?
Para el contenedor del COI de la primavera, hay tantos. BeanFactoryPostprocessor, BeanPostProcessor. Se llaman cuando se construyen objetos de frijol y construcción de frijoles. Inicializan a Bean y se llaman cuando son creados y destruidos por la instancia de Bean. Los usuarios pueden implementar el método definido en estas interfaces, y Spring los llamará en el momento apropiado. Otro es FactoryBean.
Estos puntos de expansión suelen ser donde usamos la primavera para completar nuestras tareas específicas. . Puede usar la siguiente metáfora para explicar.
Comparamos el contenedor IOC con una caja. Entonces, su relación correspondiente es BeanFactory es el modelo de fabricación de máquinas, el modo de bola es Bean y la bola del modo de bola es la instancia del frijol. ¿Dónde se mencionan las extensiones anteriormente? BeanFactoryPostProcessor corresponde a la creación de un modelo de pelota, y tendrá la oportunidad de hacer una corrección, es decir, puede ayudarlo a modificar el modo de bola. Inicializando a Bean y DisposableBean están al principio y al final de los modelos de pelota, y puede completar algunos preparativos y trabajos de cola. BeanPostProcessor le permite hacer correcciones apropiadas al modo de bola. Finalmente, hay una fábrica, que es un modelo de pelota mágica. Este modo de pelota no está de antemano, pero determinará su forma para él. las bolas que quieres
Cómo usar el contenedor IOC para mí
La introducción previa del proceso de construcción del contenedor de primavera, ¿qué puede hacer por Spring por nosotros y qué puede hacer el contenedor del COI de Spring? Primero debemos construir un contenedor IOC usando Spring.
El COI en realidad está construyendo un cubo de Rubik para ti. Entonces, ¿cómo participamos? Esto es lo que dije anteriormente para comprender algunas extensiones en la primavera, y cambiamos el comportamiento común de la primavera al lograr esos puntos extendidos. En cuanto a cómo lograr el punto de expansión para obtener los resultados de la personalidad que queremos, hay muchos ejemplos en la primavera. utilizado para referencia.
Explicación detallada de las características de AOP en primavera
El principio de implementación de proxy dinámico
Para comprender el AOP de Spring, el principio de la agencia dinámica debe entenderse primero, porque AOP se implementa en función del proxy dinámico. El agente dinámico debe comenzar con el propio JDK.
Hay una clase proxy bajo el paquete Java.lang.reflet de JDK, que es la entrada a la clase de agencia. La estructura de esta clase:
Figura 16. Estructura de la estructura de proximidad
De la imagen de arriba, los cuatro son métodos públicos. El último método NewProxyInstance es el método para crear objetos proxy. El código fuente de este método es el siguiente:
Lista 6.Proxy.NewProxyInstance
Interfaces públicas de objeto estático newProxyInStance (ClassLoader Loader, class> [], InvocatchHandler H) lanza IlegalAgumentException {if (H == NULL) {th Row New NullPoInterException ();} class cl = getProxyClass (cargador, interfaces); = cl.getConstructor (constructorParams); );} Catch (InstanciationException e) {tire nuevo Internet (E.ToString ());} Catch New Internet (e.ToString ());}}Este método requiere tres parámetros: ClassLoader, que se utiliza para cargar la clase de cargador de clase proxy. Las interfaces son esas interfaces que se representan. InvocationHandler, se utiliza para ejecutar el funcionamiento de los usuarios que son personalizados por los usuarios, además de los métodos en la interfaz proxy. El usuario llama al método de destino está representado por el método único definido en la clase InvacationHandler Invoke. Esto se explicará en detalle más adelante.
Veamos cómo proxy produce la clase de proxy. Se revela a continuación.
Figura 17. Crear objetos proxy
De hecho, se puede encontrar en la figura anterior que la clase de agente está en el método de GenerateProxyClass de proxyGenerator. La clase Proxygient está envuelta bajo Sun.misc.
Si hay tal interfaz, como sigue:
Lista 7. Clase de SimpleProxy
interfaz pública SimpleProxy {public void sizeMethod1 ();La estructura de clase generada por el agente es la siguiente:
Lista 8. Class $ proxy2
Public Class $ proxy2 extiende java.lang.rang.reflect.proxy implementa sencillo {java.lang.reflect.method m0; Método M3El método de esta clase llamará al método Invoke de InvocationHandler, y cada método correspond a una variable de propiedad. Así es como se realiza todo el agente.
Cómo lograr Spreraop
Del principio del agente anterior, sabemos que el propósito del proxy es que cuando se llama el método de destino, podemos ejecutar el método de invocación de la clase Invocathandler, por lo que cómo hacer un artículo sobre InvocationHandler es la clave para implementar AOP .
La implementación de AOP de Spring es un acuerdo para cumplir con la Alianza AOP. Al mismo tiempo, Spring lo ha expandido, agregando algunas interfaces como PointCut y Advisor para que sea más flexible.
A continuación se muestra un diagrama de clase del proxy dinámico JDK:
Figura 18.JDK Diagrama de clase dinámica de proxy
La imagen de arriba muestra claramente la interfaz definida por la definición de AOP Alliance. No discutamos cómo Spring amplía AOP Alliance.
Lista 9. Configurar Proxy Bean
<bean id = "testBeAnsingleton"> <Property name = "proxyInterfaces"> <alon> org.springframework.ap.framework.prototypettests $ testbean valor> p rOperty> <propiedad name = "target"> <ref local = "testbeanTarget" > Ref> Propiedad> <Property Name = "Singleton"> <value> TrueValue> Propiedad> <Property Name = "Interceptors"> <List> <Value> TestIntercepteRValue> <Val UE> TestInterceptor2Value> List> Property> Bean> Bean>
En la configuración, consulte que se establece la interfaz del agente, la clase de implementación de la interfaz es la clase de destino y se llama al interceptor antes de ejecutar el método de destino definido en el resorte aquí puede elegir usarlo. Esencia
Veamos cómo Spring completa el agente y cómo llamar al interceptor.
Como se mencionó anteriormente, Spring AOP también logra su propio punto de expansión para completar esta función de esta Por supuesto, el objeto proxy debe generarse dinámicamente a través de la clase proxy.
La siguiente es la tabla de sincronización del objeto proxy creado por Spring:
Figura 19. La aparición del objeto objeto
Después de que Spring crea un objeto proxy, cuando llame al método en el objeto de destino, se representará en el método Invoke de la clase InvocationHandler, que se ha explicado anteriormente. Aquí la clase Jdkdynamicaopproxy implementa la interfaz InvocationHandler.
Echemos un vistazo a cómo la primavera llama al interceptor.
Figura 20. Spring llama al interceptor
El anterior es el agente dinámico JDK.
Análisis de modo de diseño en primavera
También hay muchos patrones de diseño utilizados en Spring, como modo de fábrica, modo de solteros, modo de plantilla, etc., en "El modelo de arquitectura y diseño del sistema del marco WebX", "Tomcat's System Architecture and Mode Design Analysis", es ya introducido. Aquí presentamos principalmente el modo de agencia y el modo de estrategia.
Modo proxy
Principio de modo proxy
El modo proxy es crear un objeto proxy para un determinado objeto, y el objeto proxy controla la referencia al objeto original, y la creación de este objeto proxy puede agregar algunas operaciones adicionales al objeto original. A continuación se muestra la estructura del modo proxy:
Figura 21. La estructura del modo proxy
Asunto: tema abstracto, es una interfaz para realizar el objeto real del objeto de agente.
ProxySubject: además de la interfaz de la definición de temas abstractos, la clase proxy también debe contener una referencia del objeto del agente
RealSubject: la clase del agente es el objeto objetivo.
Cómo implementar el modo proxy en primavera
El agente dinámico JDK en Spring AOP se logra utilizando la tecnología de modo de agencia. Además de la interfaz del objeto proxy en la primavera, también habrá org.springframework.aop.springproxy y org.springframework.apork.advise. El constructor de usar el modo proxy en primavera es el siguiente:
Figura 22. El diagrama estructural del modo proxy se usa en el cableado
$ Proxy es el objeto proxy creado, y el sujeto es un tema abstracto, y el objeto proxy es mantener una referencia al objeto de destino a través de InvocationHandler.
Una verdadera estructura de objeto proxy en primavera es la siguiente:
Lista 10 Proxy Object $ proxy4
Public Class $ proxy4 extiende java.lang.reflect.proxy implementa org.springframework.ap.framework.prototypettests $ testbean work.aop.springproxy org.springframework.aop.framework.Advned {java.lang.reflecthod M16; reflejo.method m9; .Method M26; java.lang.reflect.Method M6; java.lang.reflect.method m28; java.lang.reflethod m14; java.lang. Reflect.method m12; java . Lang.reflet.Method M27; java.lang .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);策略模式
策略模式原理
The strategy model, as the name suggests, is a strategy to do something. This usually means that there may be multiple methods to complete a certain operation in programming. These methods may have different occasions and may have different adaptation. However, these methods may utilizarse.各一个操作方法都当作一个实现策略，使用者可能根据需要选择合适的策略。
下面是策略模式的结构：
图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中是如何实现这些理念的，以及在设计模式上是如何使用的。