-
Comment fonctionne Hibernate et pourquoi devriez-vous l’utiliser ?
principe:
1. Lisez et analysez le fichier de configuration
2. Lisez et analysez les informations de mappage et créez SessionFactory
3. Séance ouverte
4. Créer une transaction Transaction
5. Opérations de persistance
6. Soumettre la transaction
7.Fermer la session
8. Fermez SessionFactory
Pourquoi utiliser :
1. Le code d'accès JDBC à la base de données est encapsulé, ce qui simplifie grandement le code fastidieux et répétitif dans la couche d'accès aux données.
2. Hibernate est un framework de persistance grand public basé sur JDBC et une excellente implémentation ORM. Cela simplifie grandement le travail de codage de la couche DAO.
3. hibernate utilise le mécanisme de réflexion Java au lieu du programme d'amélioration du bytecode pour assurer la transparence.
4. Les performances d'hibernate sont très bonnes car il s'agit d'un framework léger. La flexibilité de la cartographie est exceptionnelle. Il prend en charge diverses bases de données relationnelles, allant des relations complexes un-à-un à plusieurs-à-plusieurs.
2. Comment Hibernate se charge-t-il paresseusement ?
1. Implémentation du chargement paresseux d'Hibernate2 : a) objet d'entité b) collection (Collection)
2. Hibernate3 fournit une fonction de chargement paresseux des propriétés
Lorsque Hibernate interroge les données, les données n'existent pas dans la mémoire. Lorsque le programme opère réellement sur les données, l'objet existe dans la mémoire, ce qui permet d'économiser la surcharge de mémoire du serveur, améliorant ainsi les performances du serveur. . performance.
3. Comment réaliser la relation entre les classes dans Hibernate (telle que : relation un-à-plusieurs, plusieurs-à-plusieurs) ?
La relation entre les classes se reflète principalement dans le fonctionnement de la relation entre les tables.Elles opèrent toutes sur des objets.Toutes les tables et classes sont mappées ensemble dans notre programme, et elles sont mappées ensemble via many-to dans le fichier de configuration. un à plusieurs, plusieurs à plusieurs,
4. Parlons du mécanisme de mise en cache d'Hibernate
1. Le cache interne existe dans Hibernate, également appelé cache de premier niveau, qui appartient au cache de niveau transaction de l'application.
2. Cache de deuxième niveau :
a) Application et cache
b) Conditions du cache distribué : les données ne seront pas modifiées par un tiers, la taille des données se situe dans une plage acceptable, la fréquence de mise à jour des données est faible, les mêmes données sont fréquemment utilisées par le système, données non critiques
c) Implémentation de cache tiers
5. Méthode de requête Hibernation
SQL, critères, composition d'objets
Hql：
1. Requête d'attribut
2. Requête de paramètres, nommée requête de paramètres
3. Requête associée
4. Requête de pagination
5. Fonctions statistiques
6. Comment optimiser la mise en veille prolongée ?
1. Utilisez une association bidirectionnelle un-à-plusieurs au lieu d’une association unidirectionnelle un-à-plusieurs.
2. Utilisation flexible des associations unidirectionnelles un-vers-plusieurs
3. Au lieu de un à un, utilisez plutôt plusieurs à un.
4. Configurez le cache d'objets et n'utilisez pas le cache de collection
5. Utilisez Bag pour les collections un-à-plusieurs et Set pour les collections plusieurs-à-plusieurs.
6. Utiliser le polymorphisme explicite dans les classes héritées
7. Il devrait y avoir moins de champs de table, n'ayez pas peur d'un trop grand nombre d'associations de tables et bénéficiez de la prise en charge du cache de deuxième niveau.
7. Comment fonctionne Struts ? Pourquoi utiliser Struts ?
Mécanisme de travail :
Flux de travail Struts :
Lorsque l'application Web démarre, l'ActionServlet d'initialisation sera chargé. L'ActionServlet démarrera à partir de.
Lisez les informations de configuration à partir du fichier struts-config.xml et stockez-les dans divers objets de configuration. Lorsque ActionServlet reçoit une demande client, il exécute le processus suivant.
-(1) Récupérez l'instance ActionMapping qui correspond à la demande de l'utilisateur. Si elle n'existe pas, renvoie les informations de chemin de demande non valides.
-(2) Si l'instance ActionForm n'existe pas, créez un objet ActionForm et enregistrez les données du formulaire soumises par le client dans l'objet ActionForm ;
-(3) Déterminez si la validation du formulaire est requise en fonction des informations de configuration. Si une validation est requise, appelez la méthode validate() d'ActionForm ;
-(4) Si la méthode validate() d'ActionForm renvoie null ou renvoie un objet ActuibErrors qui ne contient pas de ActionMessage, cela signifie que la validation du formulaire est réussie ;
-(5) ActionServlet décide à quelle action transmettre la demande en fonction des informations de mappage contenues dans ActionMapping. Si l'instance d'action correspondante n'existe pas, créez d'abord cette instance, puis appelez la méthodeexecute() de l'action ;
-(6) La méthode execute() d'Action renvoie un objet ActionForward et ActionServlet transmet la demande du client au composant JSP pointé par l'objet ActionForward ;
-(7) L'objet ActionForward pointe vers le composant JSP pour générer une page Web dynamique et la renvoie au client ;
Pourquoi utiliser :
L'émergence des technologies JSP, Servlet et JavaBean nous permet de créer de puissants systèmes d'applications d'entreprise. Mais les systèmes construits avec ces technologies sont très compliqués, donc en plus de cela, nous avons besoin d'une règle, une règle pour organiser ces technologies. C'est le cadre, et Struts est né.
Les applications développées sur la base de Struts sont composées de trois types de composants : les composants de contrôleur, les composants de modèle et les composants de vue.
8. Comment le cadre de validation de Struts est-il vérifié ?
Configurez des invites d'erreur spécifiques dans le fichier de configuration Struts, puis appelez spécifiquement la méthode validate() dans FormBean.
9. Parlons du modèle de conception de Struts
Mode MVC : ActionServler est chargé et initialisé au démarrage de l'application Web. Lorsque l'utilisateur soumet le formulaire, un objet ActionForm configuré est créé et rempli avec les données correspondantes du formulaire. ActionServler détermine si la validation du formulaire est requise en fonction des paramètres configurés dans le fichier Struts-config.xml. Si nécessaire, il appelle. Validate() d'ActionForm. Après vérification, sélectionnez à quelle action envoyer la requête. Si l'action n'existe pas, ActionServlet créera d'abord cet objet puis appellera la méthode execute() de l'action. Execute() obtient les données de l'objet ActionForm, complète la logique métier et renvoie un objet ActionForward, puis transmet la demande du client au composant jsp spécifié par l'objet ActionForward. le renvoie au client.
10. Comment fonctionne le ressort et pourquoi doit-il être utilisé ?
1. Spring MVC demande que toutes les demandes soient soumises à DispatcherServlet, qui confiera à d'autres modules du système d'application la responsabilité du traitement réel des demandes.
2.DispatcherServlet interroge un ou plusieurs HandlerMapping pour trouver le contrôleur qui gère la demande.
3.DispatcherServlet, veuillez soumettre la demande au contrôleur cible
4. Une fois que le contrôleur a effectué le traitement de la logique métier, il renvoie un ModelAndView
5.Dispathcher interroge un ou plusieurs analyseurs de vue ViewResolver pour trouver l'objet de vue spécifié par l'objet ModelAndView.
6. L'objet de vue est responsable du rendu et de son renvoi au client.
Pourquoi utiliser :
{AOP permet aux développeurs de créer des préoccupations non comportementales, appelées préoccupations transversales, et de les insérer dans le code de l'application. Après avoir utilisé AOP, les services publics (tels que la journalisation, la persistance, les transactions, etc.) peuvent être décomposés en aspects et appliqués aux objets de domaine sans augmenter la complexité du modèle objet des objets de domaine.
IOC permet la création d'un environnement d'application capable de construire des objets puis de transmettre à ces objets leurs objets collaborateurs. Comme l’indique le mot inversion, IOC est comme JNDI inversé. Au lieu d'utiliser un ensemble d'usines abstraites, de localisateurs de services, de singletons et de constructions simples, chaque objet est construit à partir de ses objets collaborateurs. Le conteneur gère donc l'objet de collaboration (collaborateur).
Même si Spring est un framework AOP, c'est aussi un conteneur IOC. La meilleure chose à propos de Spring est qu'il vous aide à remplacer des objets. Avec Spring, ajoutez simplement des dépendances (objets collaborateurs) à l'aide des propriétés et des fichiers de configuration JavaBean. Il est alors facile de remplacer les objets collaboratifs par des interfaces similaires lorsque cela est nécessaire. }
Le framework Spring est une architecture en couches composée de 7 modules bien définis. Les modules Spring sont construits au-dessus du conteneur principal, qui définit comment créer, configurer et gérer les beans, comme le montre la figure 1.
Chaque module (ou composant) qui compose le framework Spring peut exister seul ou être implémenté en conjonction avec un ou plusieurs autres modules. Les fonctions de chaque module sont les suivantes :
☆ Conteneur principal : Le conteneur principal fournit les fonctions de base du framework Spring. Le composant principal du conteneur principal est BeanFactory, qui est l'implémentation du modèle d'usine. BeanFactory utilise le modèle d'inversion de contrôle (IOC) pour séparer les spécifications de configuration et de dépendance de l'application du code réel de l'application.
☆ Contexte Spring : le contexte Spring est un fichier de configuration qui fournit des informations de contexte au framework Spring. Le contexte Spring comprend des services d'entreprise tels que les fonctions JNDI, EJB, de messagerie électronique, d'internationalisation, de validation et de répartition.
☆ Spring AOP : Grâce aux fonctionnalités de gestion de configuration, le module Spring AOP intègre directement les fonctions de programmation orientées aspect dans le framework Spring. Par conséquent, il est facile de faire en sorte que n’importe quel objet géré par le framework Spring prenne en charge AOP. Le module Spring AOP fournit des services de gestion de transactions pour les objets dans les applications basées sur Spring. En utilisant Spring AOP, vous pouvez intégrer la gestion déclarative des transactions dans votre application sans recourir aux composants EJB.
☆ Spring DAO : la couche d'abstraction JDBC DAO fournit une hiérarchie d'exceptions significative qui peut être utilisée pour gérer la gestion des exceptions et les messages d'erreur émis par différents fournisseurs de bases de données. La hiérarchie des exceptions simplifie la gestion des erreurs et réduit considérablement la quantité de code d'exception à écrire (comme l'ouverture et la fermeture de connexions). Les exceptions orientées JDBC de Spring DAO suivent la hiérarchie commune des exceptions DAO.
☆ Spring ORM : le framework Spring insère plusieurs frameworks ORM pour fournir des outils relationnels objet ORM, notamment JDO, Hibernate et iBatis SQL Map. Tous ces éléments sont conformes à la hiérarchie des transactions génériques et des exceptions DAO de Spring.
☆ Module Web Spring : le module de contexte Web est construit sur le module de contexte d'application et fournit un contexte pour les applications Web. Par conséquent, le framework Spring prend en charge l’intégration avec Jakarta Struts. Le module Web simplifie également la gestion des requêtes multiparts et la liaison des paramètres de requête aux objets de domaine.
☆ Framework Spring MVC : le framework MVC est une implémentation MVC complète pour la création d'applications Web. Grâce à l'interface de stratégie, le framework MVC devient hautement configurable et MVC prend en charge un grand nombre de technologies d'affichage, notamment JSP, Velocity, Tiles, iText et POI.
Les fonctionnalités de Spring Framework peuvent être utilisées sur n'importe quel serveur J2EE, et la plupart des fonctionnalités conviennent également aux environnements non gérés. L'objectif principal de Spring est de prendre en charge des objets métier et d'accès aux données réutilisables qui ne sont pas liés à des services J2EE spécifiques. Il ne fait aucun doute que de tels objets peuvent être réutilisés entre différents environnements J2EE (Web ou EJB), applications autonomes et environnements de test.
CIO et AOP
Le concept de base du modèle d'inversion de contrôle (également appelé intervention de dépendance) est que vous ne créez pas d'objets, mais que vous décrivez comment les créer. Il n'est pas directement connecté aux objets et aux services dans le code, mais au composant qui nécessite quel service est décrit dans le fichier de configuration. Le conteneur (dans le framework Spring, le conteneur IOC) est chargé de les lier ensemble.
Dans un scénario IOC typique, le conteneur crée tous les objets et définit les propriétés nécessaires pour les connecter entre eux et décider quand appeler les méthodes. Le tableau suivant répertorie un mode de mise en œuvre d'IOC.
Le conteneur IOC du framework Spring est implémenté en utilisant le type 2 et le type 3.
programmation orientée aspect
La programmation orientée aspect, ou AOP, est une technique de programmation qui permet aux programmeurs de modulariser des comportements qui recoupent des préoccupations ou des lignes de responsabilité typiques, telles que la journalisation et la gestion des transactions. La construction principale d'AOP est constituée d'aspects, qui encapsulent le comportement qui affecte plusieurs classes dans des modules réutilisables.
AOP et IOC sont des technologies complémentaires qui utilisent une approche modulaire pour résoudre des problèmes complexes de développement d'applications d'entreprise. Dans une approche typique de développement orienté objet, les instructions de journalisation peuvent être placées dans toutes les méthodes et classes Java pour implémenter la fonctionnalité de journalisation. Dans l'approche AOP, les services de journalisation peuvent à leur tour être modularisés et appliqués de manière déclarative aux composants nécessitant une journalisation. Bien entendu, l'avantage est que la classe Java n'a pas besoin de connaître l'existence du service de journalisation, ni de prendre en compte le code associé. Par conséquent, le code d’application écrit dans Spring AOP est faiblement couplé.
La fonctionnalité d'AOP est entièrement intégrée dans le contexte de la gestion des transactions Spring, de la journalisation et de diverses autres fonctionnalités.
Conteneur CIO
Le cœur de la conception de Spring est le package org.springframework.beans, conçu pour être utilisé avec les composants JavaBean. Ce package n'est généralement pas utilisé directement par l'utilisateur, mais est utilisé par le serveur comme intermédiaire de bas niveau pour la plupart des autres fonctions. Le prochain niveau d'abstraction le plus élevé est l'interface BeanFactory, qui est une implémentation du modèle de conception Factory et permet de créer et de récupérer des objets par leur nom. BeanFactory peut également gérer les relations entre les objets.
BeanFactory prend en charge deux modèles d'objet.
□ Le modèle monomorphe fournit une instance partagée d'un objet avec un nom spécifique qui peut être récupéré au moment de la requête. Singleton est le modèle objet par défaut et le plus couramment utilisé. Idéal pour les objets de service apatrides.
□ Le modèle prototype garantit qu'un objet distinct est créé pour chaque récupération. Le modèle prototype est mieux adapté lorsque chaque utilisateur a besoin de son propre objet.
Le concept de fabrique de haricots est à la base de Spring en tant que conteneur IOC. IOC transfère la responsabilité de gérer les choses du code de l'application au framework. Comme je le démontrerai dans l'exemple suivant, le framework Spring utilise les propriétés JavaBean et les données de configuration pour indiquer quelles dépendances doivent être définies.
Interface BeanFactory
Étant donné que org.springframework.beans.factory.BeanFactory est une interface simple, elle peut être implémentée pour diverses méthodes de stockage sous-jacentes. La définition BeanFactory la plus couramment utilisée est XmlBeanFactory, qui charge les beans en fonction des définitions d'un fichier XML, comme indiqué dans le listing 1.
Liste 1. XmlBeanFactory
BeanFactory factory = new XMLBeanFactory(new FileInputSteam("mybean.xml"));
Les beans définis dans les fichiers XML sont chargés passivement, ce qui signifie que le bean lui-même n'est pas initialisé tant qu'il n'est pas nécessaire. Pour récupérer un bean depuis BeanFactory, appelez simplement la méthode getBean(), en passant le nom du bean à récupérer, comme indiqué dans le listing 2.
Liste 2. getBean()
MonBean monbean = (MonBean) factory.getBean("monbean");
Chaque définition de bean peut être un POJO (défini avec un nom de classe et des propriétés d'initialisation JavaBean) ou un FactoryBean. L'interface FactoryBean ajoute un niveau d'indirection aux applications créées à l'aide du framework Spring.
Exemple du CIO
La manière la plus simple de comprendre l’inversion du contrôle est de la voir en action. J'ai conclu la première partie de ma série Spring en trois parties avec un exemple qui montre comment injecter les dépendances de votre application (au lieu de les intégrer) via le conteneur Spring IOC.
J'ai utilisé le cas d'utilisation de l'ouverture d'un compte de crédit en ligne comme point de départ. Pour cette implémentation, l'ouverture d'un compte de crédit nécessite que l'utilisateur interagisse avec les services suivants :
☆Service de notation de crédit, interrogez les informations sur l'historique de crédit de l'utilisateur.
☆ Service de liaison de messages à distance pour insérer les informations client et connecter les informations client avec les informations de carte de crédit et bancaires pour un débit automatique (si nécessaire).
☆ Service de messagerie pour envoyer des e-mails sur l'état de la carte de crédit aux utilisateurs.
trois interfaces
Pour cet exemple, je suppose que les services existent déjà et les intègrent idéalement de manière faiblement couplée. La liste suivante présente les API des trois services.
Liste 3. Interface d'évaluation du crédit
interface publique CreditRatingInterface {
public boolean getUserCreditHistoryInformation(ICustomer iCustomer);
}
L'interface de notation de crédit présentée dans le listing 3 fournit des informations sur l'historique de crédit. Il nécessite un objet Customer contenant des informations client. L'implémentation de cette interface est assurée par la classe CreditRating.
Liste 4. CreditLinkingInterface
interface publique CreditLinkingInterface {
chaîne publique getUrl();
public void setUrl (URL de chaîne);
public void linkCreditBankAccount() lance une exception ;
}
L'interface de liaison de crédit relie les informations d'historique de crédit aux informations bancaires (si nécessaire) et insère les informations de carte de crédit de l'utilisateur. L'interface de lien de crédit est un service distant et sa requête est effectuée via la méthode getUrl(). L'URL est définie par le mécanisme de configuration du bean du framework Spring, dont je parlerai plus tard. L'implémentation de cette interface est assurée par la classe CreditLinking.
Liste 5. Interface de messagerie
interface publique EmailInterface {
public void sendEmail(ICustomer iCustomer);
chaîne publique getFromEmail();
public void setFromEmail(String fromEmail);
public String getPassword();
public void setPassword (chaîne de mot de passe);
public String getSmtpHost();
public void setSmtpHost(String smtpHost);
public String getUserId() ;
public void setUserId (String userId);
Cet article provient du blog CSDN Veuillez indiquer la source lors de la réimpression : http://blog.csdn.net/loshu2003/archive/2009/12/31/5111344.aspx.
-