1. Contexte
Récemment, pendant le processus de développement du projet, j'ai rencontré le problème dont j'avais besoin pour définir certaines variables personnalisées dans le fichier Properties pour la lecture dynamique et la modification des variables des programmes Java, et il n'avait plus besoin de modifier le code. J'ai profité de cette occasion pour régler et analyser le contenu du fichier de propriétés dans le projet de développement intégré de Spring + SpringMVC + MyBatis via les programmes Java, et le partager avec vous en premier.
2. Introduction de l'environnement du projet
Trois ou cinq façons de l'implémenter
Méthode 1. Chargez le contenu dans le fichier de configuration JDBC.Properties à travers le contexte: propriété-placeholder
<Context: propriété-placeholder location = "classpath: jdbc.properties" ignore-unrsolvable = "true" />
La configuration ci-dessus est équivalente à la configuration suivante, qui est une simplification de la configuration suivante
<bean id = "PropertyConfigurer"> <propriété name = "ignoreUnResolVablePlaceHolders" value = "true" /> <propriété name = "Locations"> <sist> <value> classpath: jdbc.properties </ value> </sist> </ propriété> </ bean>
Remarque: De cette manière, si vous avez la configuration suivante dans le fichier Spring-Mvc.xml, vous ne devez pas manquer la partie rouge suivante, sur sa fonction et son principe.
<! - Configurer la numérisation des composants, seules les annotations du contrôleur sont numérisées dans le conteneur SpringMvc -> <context: composant-scan Base-Package = "com.hafiz.www" use-default-filters = "false"> <context: include-filter type = "annotation" expression = "org.springframe.stereType.Controller"
Méthode 2. Injection utilisant des annotations, injectant principalement la valeur correspondante dans le fichier de propriétés en utilisant des annotations dans le code Java.
<bean id = "prop"> <! - Ceci est la classe PropertiesFactoryBean. Il dispose également d'une propriété d'emplacements, qui reçoit également un tableau, tout comme ce qui précède -> <propriété name = "Locations"> <Array> <Avalue> CLASSPATH: JDBC.Properties </value> </ray> </ Property> </bEAN>
Méthode 3. Utilisez la balise Util: Properties pour exposer le contenu dans le fichier Propriétés
<util: Properties id = "PropertiesReader" location = "classpath: jdbc.properties" />
Remarque: En utilisant la configuration de ligne ci-dessus, vous devez déclarer la partie rouge suivante dans l'en-tête du fichier Spring-dao.xml
<Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: context = "http://www.springframework xmlns: util = "http://www.springframework.org/schema/util" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/Beans/www... http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/utilil http://www.springframework.org/schema/util/spring-util.xsd ">
Méthode 4. Exposer les propriétés aux propriétés de la sous-classe personnalisée pour une utilisation dans le programme lors du chargement du contexte via PropertyPlaceHolderConfigurer
<bean id = "PropertyConfigurer"> <propriété name = "ignoreUnResolVablePlaceHolders" value = "true" /> <propriété name = "ignoreResourceNotFound" value = "true" /> <propriété name = "Locations"> <sist> </value> </pomage>
La déclaration de la classe de la classe personnalisée est la suivante:
package com.hafiz.www.util; import org.springframework.beans.beansexception; import org.springframework.beans.factory.config.configurableListableBeanfactory; import org.springframework.beans.factory.config.propertyplaceholderconfigurer; import; import; java.util.properties; / ** * DESC: Propriétés Classe de lecture de fichiers de configuration * Créée par Hafiz.zhang le 2016/9/14. * / classe publique PropertyConfigurer étend PropertyPlaceHolderConfigurer {Private Properties Props; // Accédez aux propriétés Fichier de configuration Key-Value Result @Override Protected void processProperties (configurableListableBeanfactory beanfactoryToprocess, Properties props) lève BeanSexception {super.processProperties (beanfactoryToprocess, props); this.props = accessoires; } public String getProperty (string key) {return this.props.getProperty (key); } public String getProperty (string key, string defaultValue) {return this.props.getProperty (key, defaultValue); } public Object SetProperty (String Key, String Value) {return this.props.setProperty (key, value); }}Comment utiliser: utilisez simplement l'injection d'annotation @Autowired dans la classe que vous devez utiliser.
Méthode 5. Personnalisez le PropertyUtil de la classe d'outils et lisez le contenu du fichier Properties dans le bloc de code statique statique de la classe et enregistrez-le dans la propriété statique à utiliser par d'autres programmes.
Package com.hafiz.www.util; import org.slf4j.logger; import org.slf4j.loggerfactory; importer java.io. *; import java.util.properties; / ** * desc: properties de fichiers de fichiers de la classe d'outils * créé par Habiz.zhang en 2016/9/9/15. * / classe publique PropertyUtil {private static final logger logger = loggerfactory.getLogger (propriétéUtil.class); accessoires de propriétés statiques privées; statique {loadProps (); } synchronisé statique privé void loadProps () {logger.info ("Démarrer le contenu des fichiers de propriétés ......"); Props = nouvelles propriétés (); InputStream dans = null; essayez {<! - First Type, Obtenez le flux de fichiers Propriétés via le chargeur de classe -> in = propriétéUtil.class.getClassloadher (). getResourceSstream ("jdbc.properties"); <! - Deuxième type, Obtenez un flux de fichiers Propriétés via la classe -> // dans = propriétéUtil.class.getResourceSstream ("/ jdbc.properties"); Prophes.load (in); } catch (filenotfoundException e) {logger.error ("jdbc.properties fichier introuvable"); } catch (ioException e) {logger.error ("ioException apparaît"); } enfin {try {if (null! = in) {in.close (); }} catch (ioException e) {Logger.Error ("Exception clôturée avec JDBC.Properties File Stream closed"); }} logger.info ("Chargement du contenu du fichier de propriétés ........."); Logger.info ("Contenu du fichier Properties:" + Props); } public static String getProperty (string key) {if (null == props) {loadProps (); } return props.getProperty (key); } public static String getProperty (string key, string defaultValue) {if (null == props) {loadProps (); } return props.getProperty (key, defaultValue); }}Remarque: De cette façon, lorsque la classe est chargée, il lira automatiquement le contenu du fichier de configuration à l'emplacement spécifié et l'enregistrera dans des propriétés statiques, ce qui est efficace et pratique, et peut être chargé à la fois et utilisé plusieurs fois.
4. Précautions et suggestions
Les trois premières méthodes sont rigides dans les cinq méthodes ci-dessus. Et si vous souhaitez les utiliser dans un bean avec @Controller Annotation, vous devez les déclarer dans le fichier de configuration de Springmvc Spring-Mvc.xml. Si vous souhaitez les utiliser dans un bean avec @Service, @Prespository, etc., vous devez les déclarer dans Spring.xml dans le fichier de configuration de Spring.
Je recommande personnellement les quatrième et cinquième méthodes de configuration. Le cinquième est le meilleur. Il n'a même pas besoin d'être injecté dans l'objet en forme d'outil, et il appelle directement la méthode statique pour l'acquisition, et il ne le charge qu'une seule fois, ce qui est également très efficace. De plus, les trois premières méthodes ne sont pas très flexibles et la valeur clé de @Value est requise.
5. Testez pour vérifier s'il est disponible
1. Nous créons d'abord ProperTesservice
Package com.hafiz.www.service; / ** * DESC: Java Program obtient le service du contenu du fichier Propriétés * Créé par Hafiz.zhang le 2016/9/16. * / Interface publique PropertiseService {/ ** * La première méthode d'implémentation obtient la valeur de la clé spécifiée dans le fichier Propriétés * * @return * / string getProperyByFirstway (); / ** * La deuxième méthode d'implémentation obtient la valeur de la touche spécifiée dans le fichier Propriétés * * @return * / string getProperyBySecondway (); / ** * La troisième méthode d'implémentation obtient la valeur de la clé spécifiée dans le fichier Propriétés * * @return * / string getProperyByThirdway (); / ** * La quatrième méthode d'implémentation obtient la valeur de la clé spécifiée dans le fichier Propriétés * * @param clé * * @return * / string getProperyFourthway (key string); / ** * La quatrième méthode d'implémentation obtient la valeur de la clé spécifiée dans le fichier Propriétés * * @param clé * * @param defaultValue * * @return * / string getProperyByFourthway (clé de chaîne, chaîne defaultValue); / ** * La cinquième méthode d'implémentation obtient la valeur de la clé spécifiée dans le fichier Propriétés * * @param clé * * @return * / string getProperyFifThway (clé de chaîne); / ** * La cinquième méthode d'implémentation pour obtenir la valeur de la clé spécifiée dans le fichier Propriétés * * @param clé * * @param defaultValue * * @return * / string getProperyByFifthway (clé de chaîne, chaîne defaultValue);}2. Créez et implémentez la classe ProperTesserviceImpl
package com.hafiz.www.service.impl; import com.hafiz.www.service.propertiseservice; import com.hafiz.www.util.propertyconfigurer; import com.hafiz.www.util.propertyutil; import org.springframework.beans.factory.annoting.Autowired; org.springframework.beans.factory.annotation.value; import org.springframework.sterreotype.service; / ** * desc: le programme java obtient la classe d'implémentation du service du service qui obtient le contenu du fichier de propriétés * créé par Hafiz.zhang en 2016/9/16. * / @ ServicePublic Class ProperTeSServiceIMPl implémente ProperTeSService {@Value ("$ {test}") String privé testDatabyFirst; @Value ("# {Prop.Test}") String privé TestDataBySecond; @Value ("# {PropertiesReader [test]}") String privé testDataByTHIRD; @Autowired PRIVERSPERSCONFIGURING PC; @Override public String getProperyByFirstway () {return testDatabyFirst; } @Override public String getProperyBySecondway () {return testDataBySecond; } @Override public String getProperyByThirdway () {return testDataByTHIRD; } @Override public String getProperyByFourthway (String Key) {return pc.getProperty (key); } @Override public String getProperyByFourthway (String Key, String DefaultValue) {return pc.getProperty (key, defaultValue); } @Override public String getProperyByFifthway (String Key) {return propertyUtil.getPropery (key); } @Override public String getProperyByFifthway (String Key, String DefaultValue) {return propertyUtil.getProperty (key, defaultValue); }}3. Contrôleur Classe PropertyController
package com.hafiz.www.controller; import com.hafiz.www.service.propertiserservice; import com.hafiz.www.util.propertyutil; import org.springframework.beans.factory.annotation.autowired; import org.springframework.sterreotype.Controller; org.springframework.web.bind.annotation.pathvariable; import org.springframework.web.bind.annotation.requestmapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframe.web.bind.annotation.ResponseRody; Contrôleur * Créé par Hafiz.zhang le 2016/9/16. * / @ Contrôleur @ requestMapping ("/ Prop") Public Class PropertyController {@autowired Private PropertiseService PS; @RequestMapping (value = "/ way / first", méthode = requestMethod.get) @ResponseBody public String getPropertyByFirstway () {return ps.GetProperyByFirstway (); } @RequestMapping (value = "/ way / second", méthode = requestMethod.get) @ResponseBody public String GetProperTyBySecondway () {return ps.GetProperyBySecondway (); } @RequestMapping (value = "/ way / tiers", méthode = requestMethod.get) @ResponseBody public String GetPropertyBirdway () {return ps.GetProperyByThirdway (); } @RequestMapping (value = "/ way / quatrith / {key}", méthode = requestMethod.get) @ResponseBody public String getPropertyByFourthway (@PathVariable ("key") string key) {return ps.getProperyByFourThway (key, "DefaulValue"); } @RequestMapping (value = "/ way / cinquième / {key}", méthode = requestMethod.get) @ResponseBody public String getPropertyBifThway (@PathVariable ("key") string key) {return propertyUtil.getProperty (key, "defaugnvalue"); }}4.jdbc.properties Fichier
jdbc.driver = com.mysql.jdbc.Driverjdbc.url = jdbc: mysql: //192.168.1.196: 3306 / dev? useunicode = true & caractères) ctive = 200jdbc.minIdle = 5jdbc.InitialSize = 1jdbc.maxwait = 60000jdbc.TimeBetweenEvictionRunsmillis = 60000jdbc.MinevictableIdleTimemillis = 300000jdbc. t_Userjdbc.Test WhiteIdle = truejdbc.testonreturn = falsejdbc.poolPreparedStatements = truejdbc.maxpoolPreparedStatementPerConnectionsize = 20Jdbc.Filters = stat # test datatest = com.hafiz.wwwww
5. Diagramme du résultat du projet
6. Téléchargement du projet: Demo http://xiazai.vevb.com/201612/yuanma/propertiesconfigurer_jb51.zip
7. Résultats des tests
La première méthode
La deuxième façon
La troisième façon
La quatrième méthode
La cinquième méthode
6. Résumé
Grâce à cette revue et aux tests, nous comprenons le rôle et le principe de la relation de conteneur parent-enfant entre Spring et SpringMVC et l'attribut usage-défaut-filtres qui est le plus facilement négligé lors de la numérisation du package de balise contextuel: composant-étalon. Être en mesure de mieux localiser et de résoudre rapidement les problèmes rencontrés à nouveau. Quoi qu'il en soit, super ~~~
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.