Cet article analyse principalement le concept de conception de l'architecture osseuse du cadre printanier du cadre de printemps. Pourquoi ces composants ont-ils besoin de ces composants? Comment se combinent-ils ensemble pour former l'architecture squelettique du printemps? Comment la fonction AOP de Spring utilise-t-elle ces architectures squelettiques de base pour fonctionner? Quels types de modèles de conception sont utilisés au printemps pour compléter cette conception? Quelle est son inspiration de ce concept de conception à notre future conception de logiciels? Cet article répondra en détail à ces questions.
Architecture squelettique du printemps
Il y a plus d'une douzaine de composants au printemps, mais il n'y a que quelques composants de base réels.
Figure 1. Le diagramme d'architecture global du cadre du ressort
On peut voir à partir de la figure ci-dessus qu'il n'y a que trois composants centraux dans le cadre de ressort: noyau, contexte et haricots. Ils construisent toute l'architecture squelettique du printemps. Sans eux, il est impossible d'avoir les caractéristiques des couches supérieures telles que AOP et Web. Ci-dessous, analysera également le ressort principalement de ces trois composants.
Concept de conception du printemps
Comme mentionné précédemment, les trois composants du cœur sont introduits. Bean est le vrai protagoniste au printemps.
Le rôle de Bean dans le printemps est comme l'objet à OOP. Tout comme une scène de performance, mais il n'y a pas d'acteurs. Pourquoi le rythme est-il si important au printemps? Gère le fichier de configuration, qui est son mécanisme d'injection de dépendance. Et cette relation d'injection est gérée dans un conteneur IOC, alors quel est l'objet du conteneur IOC enveloppé de bean. Le printemps est le but de la gestion de ces objets et de quelques opérations supplémentaires en emballant des objets dans Bean.
Sa stratégie de conception est entièrement similaire au concept de conception de Java pour mettre en œuvre la POO. cet environnement dans cet environnement conformément à certaines règles. En y réfléchissant, pensez aux autres cadres que nous utilisons dans un grand concept de conception similaire.
Comment travailler avec les composants centraux
Comme mentionné précédemment, Bean est un facteur clé au printemps. Si vous êtes un acteur dans une performance, le contexte est l'arrière-plan de cette performance et le noyau devrait être les accessoires de la performance. Ce n'est que lorsqu'ils sont ensemble qu'ils peuvent avoir la condition la plus élémentaire qui peut effectuer un bon spectacle. Bien sûr, les conditions les plus élémentaires ne peuvent pas faire ressortir cette performance, et le spectacle qu'il effectue est suffisamment excitant.
Nous savons que le bean est emballé est un objet et que l'objet doit avoir des données. eux et pour maintenir cette relation. Le contexte est donc une collection de relations avec les haricots. Alors, à quoi sert le composant central? En fait, le noyau est quelques colonnes requises pour que la relation entre chaque haricot découvre, établisse et maintient la relation entre chaque haricot.
Ils peuvent être représentés par la figure ci-dessous:
Figure 2. Trois relations composantes
Explication détaillée des composants centraux
Ici, nous présenterons les relations hiérarchiques de chaque composant en détail, ainsi que l'ordre des commandes au moment de l'exécution. Nous devons prêter attention à l'utilisation du printemps.
Composant de haricot
L'importance de la composante de haricots au printemps a été expliquée plus tôt. Les composants Bean sont emballés dans le cadre de l'org.springframework.Beans. Toutes les catégories dans ce package résolvent trois choses: la définition de Bean, la création de Bean et l'analyse de Bean. Pour les utilisateurs de printemps, la seule chose qui doit être attentionnée est la création de Bean.
Le modèle d'usine typique de Springbean a été créé.
Figure 4. La relation d'héritage de l'usine
BeanFactory a trois sous-classes: ListableBeanFactory, HierarchicalBeanFactory et Autowire Capable Bean Factory. Mais à partir de la figure ci-dessus, nous pouvons constater que la classe d'implémentation par défaut finale est par défautListableBeanFactory, et il implémente toutes les interfaces. Alors pourquoi définir autant de niveaux d'interfaces? Consultez le code source et les instructions de ces interfaces. le processus d'opération. Par exemple, l'interface ListableBeanfactory indique que ces haricots sont répertoriés et que HiérarchicalBeanfactory signifie que ces haricots ont des relations d'héritage, c'est-à-dire que chaque haricot peut avoir un farine père. L'interface AutowireCapableBeAnfactory définit les règles d'assemblage automatique de Bean. Ces quatre interfaces définissent conjointement la collection de haricots, la relation entre le haricot et le comportement des haricots.
La définition de Bean inclut principalement la description de la définition de la haricot.
Figure 5. Le diagramme de relations hiérarchiques de classe définie Bybean
La définition du bean est une description complète de toutes les informations des nœuds que vous avez définis dans le fichier de configuration de Spring, y compris divers sous-codes. Lorsque Spring a analysé avec succès un nœud que vous avez défini, il a été transformé en un objet BeanDefinition au printemps. Toutes les opérations seront effectuées pour cet objet à l'avenir.
Le processus d'analyse de Bean est très compliqué, et la fonction est divisée en détail, car il existe de nombreux endroits à étendre ici, et ils doivent assurer une flexibilité suffisante pour faire face aux changements possibles. L'analyse de Bean consiste principalement à analyser le fichier de configuration de ressort. Ce processus d'analyse est principalement achevé par la classe dans la figure ci-dessous:
Figure 6. Classe analytique de la Bénéraire
Bien sûr, il existe également une analyse spécifique de la TAG.
Composant de contexte
Le contexte est emballé dans l'org.springframework de Spring. Jetons un coup d'œil à la construction de cet environnement.
ApplicationContext est la classe parentale de contexte. Vous trouverez ci-dessous le diagramme de structure du contexte:
Figure 7. Diagramme de structure de classe liée à un texte
On peut voir à partir de la figure ci-dessus que les applications Context héritent de beanfactory, ce qui montre également que l'objet principal du conteneur à ressort est le bean.
Les sous-classes d'ApplicationContext incluent principalement deux aspects:
ConfigurableApplicationContext indique que le contexte est modifié, c'est-à-dire que l'utilisateur peut ajouter ou modifier dynamiquement les informations de configuration existantes dans le contexte.
WebApplicationContext est le nom du nom, qui est le contexte préparé pour le Web.
Ensuite, le sous-down consiste à construire le type de contexte, suivi de la voie à accéder au contexte. Un tel niveau de premier niveau constitue un niveau de contexte complet.
En général, l'applicationContext doit compléter les éléments suivants:
◆ Faire un environnement d'application
◆ Utilisez le haricot pour créer l'objet bean
◆ Enregistrer le tableau de la relation objet
◆ Peut capturer divers événements
En tant que conteneur Spring IOC, le contexte intègre essentiellement la plupart des fonctionnalités de Spring, ou est la base de la plupart des fonctionnalités.
Composant central
Les composants principaux, en tant que composante centrale de Spring, contiennent de nombreuses catégories clés. Cette façon de résumer toutes les ressources dans une interface mérite d'être apprise dans la conception future. Jetons un coup d'œil au rôle de cette partie au printemps.
La figure ci-dessous est le diagramme structurel lié aux ressources liées:
Figure 8. Diagramme de structure de classe connexe Rsource
On peut voir à partir de la figure ci-dessus que l'interface de ressource résume divers types de ressources possibles, c'est-à-dire que la différence de type de fichier est bloquée pour les utilisateurs. Pour le fournisseur de ressources, comment emballer les ressources à d'autres personnes à l'utiliser est également un problème. De cette façon, toutes les ressources peuvent être obtenues via la classe ENTROWSTREAM, de sorte que le fournisseur de ressources est également protégé. Un autre problème est que le problème du chargement des ressources, c'est-à-dire que le chargeur des ressources doit être unifié.
Voyons comment le contexte et les ressources ont établi une relation? Regardez d'abord le diagramme de leur relation:
Figure 9. Le diagramme de relation de CONTEXT et RESSOURCE
Comme le montre la figure ci-dessus, le contexte conteste le travail de chargement, d'analyse et de description des ressources à la classe ResourcePatternResolver à terminer. Il existe de nombreuses façons similaires aux composants centraux.
Comment travailler dans le conteneur IOC
Comme mentionné précédemment, la structure et l'interdépendance des composants centraux, des composants de bean et des composants de contexte.
Comment créer une usine de haricot
Comme décrit dans la figure 2, le conteneur IOC est en fait un réseau de relations de bean combiné avec les deux autres composants. L'entrée de construction intégrée se trouve dans la méthode de rafraîchissement de la classe AbstractApplicationContext. Le code de cette méthode est le suivant:
Liste 1.AbstractApplicationContext.refresh
Public Void Refresh () lance le beansexception, illégalStateException {synchronisé (this.startupshutdownmonitor) {// Préparez ce contexte à la rafraîchissement. Contexte. Enregistrer les processeurs de haricots. Sous-classes. Catch (beansexception ex) {// détruire les singletons créés pour éviter les ressources ();Cette méthode consiste à créer un code complet pour l'ensemble du processus de conteneur IOC et à comprendre que chaque ligne de code à l'intérieur comprend essentiellement les principes et les fonctions de la plupart des printemps.
Ce code contient principalement de telles étapes:
◆ Construisez le haricot dans l'ordre
◆ L'événement peut être intéressé par l'enregistrement
◆ Créez un objet d'instance Bean
◆ déclencher des événements à écouter
Ci-dessous, combiné avec l'analyse du code de ces processus.
La deuxième et la troisième phrase consiste à créer et à configurer le beanfactory. Il s'agit de rafraîchir la configuration. Ce qui suit est le code de méthode pour mettre à jour le beanfactory:
Liste 2. AbstractreFreshableApplicationContext.
VOID FINAL VOID PROTÉRÉ () lève la conception {if (HasBeAnfactory () {BleBeanFactory (); ;Cette méthode réalise la méthode abstraite d'AbstractApplicationContex Rafreshbeanfactory. Notez que les types d'objets Beanfactory ont une variété de types d'objets. L'objet d'origine de BeanFactory est le FAUCKABLEFACTAGE par défaut.
Figure 10.DefaultListableBeanfactory Class Héritage de la classe
En plus de la classe liée au haricot, il a été constaté qu'il était également lié au registre du haricot. Dans la méthode Rafreshbeanfactory, il existe une ligne de charge de charge (Beanfactory) qui trouvera la réponse. conteneurs.
Ce processus peut être expliqué dans la carte séquentielle suivante:
Figure 11. Créez la préface du temps du haricot
Le processus d'analyse et d'enregistrement de Bean est le suivant:
figue
Après avoir créé le BeanFactory, ajoutez quelques classes d'outils nécessaires à Spring lui-même.
Le code à trois prochains en ligne dans AbstractApplicationContext joue un rôle vital dans l'expansion de la fonction de Spring. Les deux premières lignes sont principalement autorisées à modifier maintenant la configuration du hEAGFACTORY construit. Ils étendent donc tous la fonction du printemps, nous devons donc apprendre à utiliser cette partie de l'utilisation du printemps.
Parmi eux, dans la méthode InvokeBeanFactoryPostProcessors, il s'agit principalement d'obtenir des sous-classes pour implémenter l'interface BeanfactoryPostProcessor. Et exécuter sa méthode postprocessBeanFactory, l'instruction de cette méthode est la suivante:
Listing 3.BeanFactoryPostProcessor.PostProcessBeanFactory
Void PostProcessBeanFactory (configurableListableBeanfactory beanfactory) lève la conception de BeanSexception;
Ses paramètres sont Beanfactory, indiquant qu'il peut être modifié par Beanfactory. données. Les utilisateurs les modifient à volonté.
La méthode RegisterBeanPostProcessors peut également obtenir une sous-classe de la définition de l'utilisateur de l'interface BeanPostProcessor et les exécuter dans la variable BeanPostProcessors dans l'objet Beanfactory. Les deux méthodes sont déclarées dans lepostprocessor BeanPost: la postprocessBe.foreInitialisation et la postprocessaftérilisation sont utilisées pour s'exécuter lors de l'initialisation de l'objet bean. Peut effectuer des opérations définies par l'utilisateur.
Ce dernier code de ligne est l'enregistrement de l'initialisation de l'événement de surveillance et des autres auditeurs du système.
Comment créer une instance de haricot et construire le réseau relationnel du haricot
Ce qui suit est le code instancié de Bean, qui commence par la méthode FinalBeanfactoryInitity.
Listing 4.AbstractApplicationContext.FinishBeanfactoryInitialisation
VOIDE VOIDE PROTÉRÉE BEAUCOUPELLAGE (CONFIGABLABILITAGE LA CONFIGATION paresseux-init) singletons.
On peut constater que l'instance de haricot peut être trouvée dans le haricot. Le code de la méthode PreinstantiatesingLetons est le suivant:
Liste 5.DefaultListableBeanFactory.PreinstantialSingletons
Public void preinstantiateSingletons () lève BeanSexception {if (this.logger.isinfoenabled ()) {this.logger.info ("singletons préinstantiatifs dans";} synchronisé (this.beandefinitionMap) {pour (strip beename: this: this. BeanDefinitionNames) {rootBeAndeFinition bd = getMergedLocalBeAnDeFinition (beanname); IseeAgerinit; if (System.getSecurityManager ()! = Null &&; factoryof smartFactoryBean) {isea Gerinit = AccessController.Doprivileged (& nb sp; new privilEdAction <boolean> () {& nb sp;) {return ((smartFactoryBean) factor)) . ;}}}}}}}}Il y a un haricot très important ici-factory. Il peut définir la méthode de génération d'un objet d'instance tant que sa méthode GetObject est implémentée. Cependant, l'objet d'instance de ce bean à l'intérieur du printemps est FactoryBean. L'objet de l'obtention de Spring FactoryBean lui-même est complété avec et à terminer.
Comment créer un objet d'instance du bean et comment construire une clé de base dans la relation associée entre les objets d'instance de bean, ce qui suit est l'organigramme de ce processus.
Figure 13. Brassement de flux de création d'instance
S'il s'agit d'un haricot ordinaire, il crée directement son instance, en appelant la méthode Getbean. Ce qui suit est la carte séquentielle du temps de la création d'une instance de haricot:
Figure 14. Création d'instance Brasse séquentielle de création
Une autre partie très importante est d'établir la relation entre les instances d'objet Bean.
Figure 15. Établissement de la relation d'objet
Point d'extension du conteneur IOC
Un autre problème est de savoir comment faire en sorte que ces objets de haricots aient une certaine extensibilité, c'est-à-dire que certaines opérations peuvent être ajoutées. Alors, quelles sont les extensions? Comment le printemps appelle-t-il ces extensions?
Pour le conteneur IOC de Spring, il y en a tellement. BeanfactoryPostprocessor, BeanPostprocessor. Ils sont appelés lors de la construction d'objets de haricot et de création de haricots. Il y a InitializingBean et DisposableBean. Les utilisateurs peuvent implémenter la méthode définie dans ces interfaces et Spring les appellera à l'heure appropriée. Un autre est FactoryBean.
Ces points d'extension sont généralement là où nous utilisons le ressort pour terminer nos tâches spécifiques. . Vous pouvez utiliser la métaphore suivante pour expliquer.
Nous comparons le conteneur IOC à une boîte. Ensuite, leur relation correspondante est le haricot est le modèle de fabrication de machines, le mode de balle est le bean et la balle du mode Ball est l'instance du haricot. Où sont les extensions mentionnées précédemment? BeanfactoryPostProcessor correspond à la création d'un modèle de balle, et vous aurez la possibilité d'en faire une correction, c'est-à-dire qu'il peut vous aider à modifier le mode Ball. InitializingBean et DisposableBean sont au début et à la fin des modèles de balle, et vous pouvez effectuer des préparations et des travaux de queue. BeanPostProcessor vous permet de faire des corrections appropriées au mode Ball. Enfin, il y a un Factorybean, qui est un modèle de balle magique. Ce mode de balle n'est pas à l'avance, mais vous déterminera sa forme pour lui. les boules que tu veux
Comment utiliser le conteneur IOC pour moi
L'introduction précédente du processus de construction du conteneur de printemps, que peut faire le printemps pour nous et que peut faire le conteneur IOC de Spring? Nous devons d'abord construire un conteneur IOC en utilisant Spring.
L'IOC construit en fait un Rubik's Cube pour vous. Alors, comment participons-nous? C'est ce que j'ai dit plus tôt pour comprendre certaines extensions au printemps, et nous modifions le comportement commun du printemps en réalisant ces points prolongés. Quant à la façon d'atteindre le point d'expansion pour obtenir les résultats de la personnalité que nous voulons, il existe de nombreux exemples au printemps. utilisé pour référence.
Explication détaillée des fonctionnalités AOP au printemps
Le principe de mise en œuvre du proxy dynamique
Pour comprendre l'AOP de Spring, le principe de l'agence dynamique doit être compris en premier, car AOP est implémenté en fonction de la procuration dynamique. L'agent dynamique doit commencer par JDK lui-même.
Il y a une classe de proxy dans le cadre du package java.lang.lang.lang de JDK, qui est l'entrée de la classe d'agence. La structure de cette classe:
Figure 16. Structure de la structure du Proxy
Depuis l'image ci-dessus, les quatre sont des méthodes publiques. La dernière méthode NewProxyInstance est la méthode de création d'objets proxy. Le code source de cette méthode est le suivant:
Liste 6.proxy.newproxyinstance
Objet statique public NewProxyInstance (Classloader Loder, classe> [] Interfaces, invocatchHandler h) lance illégalagumentException {if (h == null) {th row new NullPointerException ();} Class Cl = getProxyclass (chargeur, interfaces); = cl.getConstructor (ConstructorArams); return (objet) Cons.NewInstance (Nouveau objet [] {h}); );} Catch (InstantiationException e) {lancer un nouvel Internet (e.toString ());} Catch New Internet (e.ToString ());}}Cette méthode nécessite trois paramètres: Classloadher, qui est utilisé pour charger la classe de chargeur de classe proxy. Les interfaces sont les interfaces à représenter. InvocationHandler, il est utilisé pour exécuter le fonctionnement des utilisateurs personnalisés par les utilisateurs en plus des méthodes de l'interface proxy. L'utilisateur appelle la méthode cible représentée par la méthode unique définie dans la classe InvacationHandler invoque. Cela sera expliqué en détail plus tard.
Voyons comment Proxy produit la classe de proxy. Il est révélé ci-dessous.
Figure 17. Créer des objets proxy
En fait, il peut être trouvé à partir de la figure ci-dessus que la classe d'agent est dans la méthode de GenerateProxyclass de Proxygenerator. La classe Proxygientor est enveloppée sous Sun.Misc.
S'il y a une telle interface, comme suit:
Liste 7. Classe SimpleProxy
interface publique SimpleProxy {public void sizemethod1 ();La structure de classe générée par l'agent est la suivante:
Liste 8. $ Classe Proxy2
La classe publique $ proxy2 étend Java.lang.rang.reflect.proxy implémente SimpleProxy {java.lang.reflect.method m0; Méthode M3; Java.lang.reflet.Method M4;La méthode de cette classe appellera la méthode invoquée d'invocationHandler, et chaque méthode correspondra à une variable de propriété. C'est ainsi que l'ensemble de l'agent est réalisé.
Comment réaliser Springaop
D'après le principe de l'agent précédent, nous savons que le but du proxy est que lorsque la méthode cible est appelée, nous pouvons exécuter la méthode invoquée de la classe InvocationHandler, alors comment faire un article sur InvocationHandler est la clé de la mise en œuvre de l'AOP .
La mise en œuvre de l'AOP de Spring est un accord pour se conformer à l'alliance AOP. Dans le même temps, Spring l'a élargi, ajoutant certaines interfaces telles que Pointcut et Advisor pour le rendre plus flexible.
Vous trouverez ci-dessous un diagramme de classe du proxy dynamique JDK:
Figure 18.JDK Diagramme de classe proxy dynamique
L'image ci-dessus montre clairement l'interface définie par la définition de l'alliance AOP. Ne discutons pas de la façon dont le printemps étend AOP Alliance.
Liste 9. Configurer le haricot proxy
<bean id = "TestBeanSingleton"> <propriété name = "proxyInterfaces"> <value> org.springframework.ap.framework.prototypeTests $ TestBean Value> P roperty> <propriété name = "Target"> <ref local = "TestBeanTarget" > Ref> propriété> <propriété name = "singleton"> <value> trueValue> propriété> <propriété name = "intercepteurs"> <s list> <value> TesterInterceptorValue> <Val Ue> TesterInterceptor2Value> List> propriété> bean>
Dans la configuration, voyez que l'interface de l'agent est définie, la classe d'implémentation de l'interface est la classe cible et l'intercepteur est appelé avant d'exécuter la méthode cible. Essence
Voyons comment le printemps termine l'agent et comment appeler l'intercepteur.
Comme mentionné précédemment, Spring AOP réalise également son propre point d'expansion pour terminer cette fonctionnalité. Bien sûr, l'objet proxy doit être généré dynamiquement via la classe proxy.
Ce qui suit est le tableau de synchronisation de l'objet proxy créé par le printemps:
Figure 19. L'émergence de l'objet objet
Après que le printemps crée un objet proxy, lorsque vous appelez la méthode sur l'objet cible, vous serez représenté dans la méthode invoquée de la classe InvocationHandler, qui a été expliquée plus tôt. Ici, la classe JDKDYMICAOPPROXY implémente l'interface InvocationHandler.
Jetons un coup d'œil à la façon dont le printemps appelle l'intercepteur.
Figure 20.Spring appelle l'intercepteur
Ce qui précède est l'agent dynamique JDK.
Analyse en mode conception au printemps
Il existe également de nombreux modèles de conception utilisés au printemps, comme le mode d'usine, le mode simple, le mode modèle, etc., dans "L'architecture système et le modèle de conception du framework Webx", "Architecture système et analyse de conception du mode de Tomcat", c'est déjà introduit. Ici, nous introduisons principalement le mode d'agence et le mode de stratégie.
Mode proxy
Principe en mode proxy
Le mode proxy consiste à créer un objet proxy pour un certain objet, et l'objet proxy contrôle la référence à l'objet d'origine, et la création de cet objet proxy peut ajouter des opérations supplémentaires à l'objet d'origine. Vous trouverez ci-dessous la structure du mode proxy:
Figure 21. La structure du mode proxy
Sujet: Thème abstrait, c'est une interface pour réaliser l'objet réel de l'objet Agent.
ProxySubject: En plus de l'interface de la définition des thèmes abstraits, la classe proxy doit également contenir une référence de l'objet Agent
RealSubject: La classe de l'agent est l'objet cible.
Comment implémenter le mode proxy au printemps
L'agent dynamique JDK de Spring AOP est réalisé en utilisant la technologie du mode d'agence. En plus de l'interface de l'objet proxy au printemps, il y aura également org.springframework.aop.springproxy et org.springframework.apork.advise. Le constructeur de l'utilisation du mode proxy à Spring est le suivant:
Figure 22. Le diagramme structurel du mode proxy est utilisé dans le câblage
$ Proxy est l'objet proxy créé, et le sujet est un thème abstrait, et l'objet proxy est de maintenir une référence à l'objet cible via InvocationHandler.
Une véritable structure d'objet proxy au printemps est la suivante:
Liste 10 objet proxy $ proxy4
La classe publique $ Proxy4 étend java.lang.reflect.proxy implémente org.springframework.ap.framework.prototypeTtss $ testbean work.aop.springproxy org.springframework.aop.framework.advned {java.lang.reflecthod m16; Réfléchir.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);策略模式
策略模式原理
策略模式顾名思义就是做某事的策略，这在编程上通常是指完成某个操作可能有多种方法，这些方法各有千秋，可能有不同的适应的场合，然而这些操作方法都有可能用到。各一个操作方法都当作一个实现策略，使用者可能根据需要选择合适的策略。
下面是策略模式的结构：
图23.策略模式的结构
Context：使用不同策略的环境，它可以根据自身的条件选择不同的策略实现类来完成所要的操作。它持有一个策略实例的引用。创建具体策略对象的方法也可以由他完成。
◆Strategy：抽象策略，定义每个策略都要实现的策略方法
◆ConcreteStrategy：具体策略实现类，实现抽象策略中定义的策略方法
◆Spring中策略模式的实现
◆Spring中策略模式使用有多个地方，如Bean定义对象的创建以及代理对象的创建等。这里主要看一下代理对象创建的策略模式的实现。
前面已经了解Spring的代理方式有两个Jdk动态代理和CGLIB代理。这两个代理方式的使用正是使用了策略模式。它的结构图如下所示：
图24.Spring中策略模式结构图
在上面结构图中与标准的策略模式结构稍微有点不同，这里抽象策略是AopProxy接口，Cglib2AopProxy和JdkDynamicAopProxy分别代表两种策略的实现方式，ProxyFactoryBean就是代表Context角色，它根据条件选择使用Jdk代理方式还是CGLIB方式，而另外三个类主要是来负责创建具体策略对象，ProxyFactoryBean是通过依赖的方法来关联具体策略对象的，它是通过调用策略对象的getProxy (ClassLoaderclassLoader)方法来完成操作。
Résumer
本文通过从Spring的几个核心组件入手，试图找出构建Spring框架的骨骼架构，进而分析Spring在设计的一些设计理念，是否从中找出一些好的设计思想，对我们以后程序设计能提供一些思路。接着再详细分析了Spring中是如何实现这些理念的，以及在设计模式上是如何使用的。