Dans le processus de transfert du projet SpringMVC à Springboot, les choses suivantes ont été principalement réalisées
En plus d'introduire quoi et comment le faire, cet article aura beaucoup de bêtises inutiles. Pour certaines discussions sur le principe, vous devez également connaître la raison.
Configuration de profil
Dans les projets de printemps traditionnels, la méthode de configuration de plusieurs profils consiste à écrire plusieurs profils dans le fichier pom.xml, puis à précharger l'environnement de profil sélectionné en exécutant un fichier maven avant de démarrer le projet. Après le chargement, lors de l'exécution du projet, il décidera quel fichier .properties se chargera dans la variable globale en fonction de l'environnement chargé.
Et gérer plusieurs profils à Springboot est très simple.
Vous pouvez sélectionner le profil lors de l'exécution du package JAR à l'aide de la ligne de commande
java -jar example.jar --spring.profiles.active = test
Ou configurez-le dans l'application de configuration globale.
Ajouter Spring.Profiles.Active = Tester dans Application.Properties
Les deux méthodes ci-dessus peuvent démarrer le profil "test", le premier a une priorité plus élevée dans l'exécution que le second.
(Soit dit en passant, à Springboot, ces deux méthodes utilisent essentiellement la méthode "Configuration externe" pour modifier et remplacer l'environnement)
De plus, chaque profil indépendant est configuré dans le format "Application-xxx.properties" pour chaque environnement différent, par exemple:
Lorsque nous devons tester si le profil est chargé normalement, nous pouvons l'écrire dans le fichier .properties correspondant
server.port = 9080
Vous pouvez voir si ce port a été démarré au démarrage.
Ici, vous pouvez mentionner l'ordre dans lequel Springboot charge les fichiers de configuration
Les variables globales sont lues à partir du fichier de propriétés
Dans la section précédente, nous avons écrit la configuration des propriétés pour différents environnements. Ici, nous écrivons si ces propriétés sont écrites en variables globales, ce qui est pratique pour les appels directs dans d'autres endroits plus tard.
/ ** * Variable globale * / classe publique Global {public static String examplePath; @Value ("$ {example_path}") public void setExamplePath (Exemple de chaîne) {global.examplePath = exampePath; }} De cette façon, nous mettrons le fichier .properties dans le
example_path = http: // localhost: 9090
Cette propriété est lue dans la variable globale.
Source de données et configuration MyBatis
Dans le projet de printemps traditionnel, utilisez MyBatis pour se connecter à la base de données
Tout cela est configuré dans le fichier de configuration XML, ce qui est assez lourd. À Springboot, essayez d'éviter une telle configuration XML.
Mybatis a maintenant fourni un support à Springboot. Nous avons seulement besoin d'ajouter la dépendance MyBatis-Spring-Boot-Starter, et il fera ce qui suit pour nous:
Ainsi, dans la configuration MyBatis de Springboot, nous devons faire ce qui suit:
Remplissez les informations de la base de données dans Application- {Profil} .properties, par exemple:
printemps.datasource.url = jdbc: oracle: mince: @ // localhost: 1234 / exemplespring.datasource.username = rootspring.datasource.password = 123456spring.datas Ource.Driver-Class-Name = Oracle.jdbc.Driver.oracledRiversPring.Datasource.MaxActive = 10Spring.Datasource.Maxidle = 5Spring.DataSource.MaxWait = -1
De cette façon, nous enregistrons le bean de source de données dans le contexte du printemps.
Créez un fichier MyBatiConfig et remplacez XML par Java:
/ ** * Créé par Wutaoyu le 2017/12/7. * / @ Configuration @ idemberansactionManagement @ MAPPERSCAN ("com.example.db.dao") classe publique MyBatiSConfig {@autowired private dataSource dataSource; @Bean (name = "sqlSessionFactory") public sqlSessionFactory sqlSessionFactoryBean () {sqlSessionFactoryBean sqlSession = new sqlSessionFactoryBean (); sqlSession.setDataSource (dataSource); essayez {// ajouter le répertoire XML ResourcePatterNResolver Resolver = new PathMatchingResourcePatterNResolver (); sqlSession.SetMapperLocations (résolver.getResources ("classpath: mapping / *. xml")); return sqlSession.getObject (); } catch (exception e) {e.printStackTrace (); Jetez une nouvelle RuntimeException (E); }} @Bean public sqlSessionTemplate sqlSessionTemplate (sqlSessionFactory sqlSessionFactory) {return new sqlSessionTemplate (sqlSessionFactory); } @Bean Public PlatformTransactionManager AnnotationDriventRansActionManager () {return new DataSourceTransactionManager (DataSource); } @Bean (name = "examplesence") public oraclequencemaxvalueincremeter examplesenceBean () {oraclesequenceMaxValueIncremeter examplequence = new oraclesequenceMaxValueCreder (); examplesequence.setInCremenerName ("Exemple_seq"); exampleSequence.setDataSource (dataSource); retour examplesequence; }} @Mapperscan doit scanner le mappeur sous ce package.
De plus, l'emplacement de Mapper.xml ici est de créer un dossier de mappage dans le dossier de ressources et de le placer ci-dessous.
La fonction ici est similaire à XML. Il s'agit de décrire la méthode d'expression XML traditionnelle dans les fichiers .java et d'injecter essentiellement l'étape par étape.
Étant donné que l'exemple utilise une base de données Oracle, la dernière Examplesence est un exemple pour illustrer comment ajouter une séquence.
Annotation des interfaces à tous les mappeurs @mapper
Par exemple:
@MapperPublic Interface UserMapper {...} Configuration du fichier journal
Logback prend en charge la configuration externe sous forme de propriétés, mais pour des configurations relativement détaillées, il est toujours nécessaire d'utiliser la configuration XML.
Pour que le fichier XML puisse lire certains chemins à partir du fichier .properties, des configurations statiques qui peuvent nécessiter une modification fréquente, il est nécessaire de le configurer dans logback-spring.xml
<propriété ressource = "application.properties" /> <propriété name = "log.root.level" value = "$ {log.root.level}" /> <propriété name = "log.path" value = "$ {log.path}" /> <propriété name = "log.modUlename" value = "$ {log.module}" /> De cette façon, vous pouvez mettre le fichier application.properties dans le
log.path = / home / logs / examplelog.root.level = infolog.module = exemple
Lisez-le dans logback-spring.xml, puis appelez-le.
Configuration WebConfig
La fonction principale de WebConfig est de remplacer Web.xml et Spring-Mvc.xml pour une configuration de base.
1. À propos de web.xml
Les projets de printemps traditionnels configurent tous un fichier web.xml. La fonction de ce fichier est: lorsque nous mettons le package de guerre dans le conteneur d'application (tel que Tomcat) à s'exécuter, le conteneur chargera le filtre (filtre), le servlet, l'erreur-page, la liste de bienvenue, le écouteur (écouteur), le contexte-param (Paramètres de contexte), la ressource-ref (configuration des ressources) et d'autres configurations selon web.xml.
L'auditeur incluant le contextOaderListener est chargé ici pour assembler automatiquement les informations de configuration de l'applicationContext lors du démarrage du conteneur.
<Douger> <écouteur-classe> org.springframework.web.context.contextLoadherListener </ écouteur-classe> </diner>
Cette applicationContext est le cœur du Spring IOC (hérité de BeanFactory), et tous les haricots singleton seront instanciés pour le moment.
En outre, un Dispatcherservlet très important dans SpringMVC est également chargé ici, et il est déterminé quel fichier XML pour configurer le Dispatcherservlet.
<VerTlet> <Serplet-Name> SpringMvc </ Servlet-Name> <Servlet-Class> org.springframework.wisservlet.dispatcherServlet </ Servlet-Class> <Init-Param> <Am param-Name> ContextConfiglocation </ Param-Name> <Am param-Value> ClassPath: Spring-Mvc.xmll </ Param-Value> </ Init-Param> <Charot-on-startup> 1 </ charge-on-startup> <! - <async-supporté> true </ async-supporté> -> </ servlet>
2. À propos de Spring-Mvc.xml
Spring-Mvc.xml est un fichier de configuration SpringMVC. Ici, nous pouvons configurer des fèves qui doivent être personnalisées, telles que ViewResolver, Multipartresolver, HTTP Message Converter, Interceptor personnalisé, etc.
Tout ce qui précède n'a rien à voir avec Springboot, principalement pour connaître la raison et pourquoi. Si vous n'êtes pas intéressé, vous pouvez l'ignorer.
Parlons de la configuration de Springboot. Springboot a un dicton selon lequel "la convention est meilleure que la configuration", ce qui signifie essayer d'utiliser la méthode convenue, plutôt qu'une configuration spécifiquement ciblée (configuration lorsque une configuration spéciale est requise).
Après avoir introduit la dépendance "Out of the Box" de Spring-Boot-Starter-Web, Spring-Boot-Starter-Web contient un Spring-Boot-AutoConfigure.
Avec cette dépendance, vous pouvez utiliser l'annotation @EnableAutoCungiguration. Cette annotation devinera la configuration de ressort dont vous avez besoin en fonction des dépendances introduites et vous aidera à le configurer. Étant donné que Spring-Boot-Starter-Web a été introduit, cette annotation configurera la configuration liée au Web.
De plus, l'annotation @enableAutoCungiguration a été incluse dans l'annotation @springbootapplication. Donc, annotez simplement @springbootapplication sur l'exemple de classe de démarrage pour laapplication et vous pouvez configurer automatiquement le Web pour le configurer.
Bien sûr, nous pouvons avoir des configurations spéciales, et pour le moment, nous pouvons créer un WebConfig pour personnaliser
/ ** * Créé par Wutaoyu le 2017/12/8. * / @ ConfigurationPublic Class WebConfig étend webmvcconfigurerAdapter {@Override public void configureMessageConverters (list <httpMessageConverter <? >> converters) {converters.add (marshallinghttpMessageConverter ()); } public MarshallingHttpMessageConverter MarshallingHttpMessageConverter () {MarshallingHttpMessageConverter MarshallingHttpMessageConverter = New MarshallingHttpMessageConverter (); List <diasyType> mediaTypes = new ArrayList <SediaType> (); mediatypes.add (mediatype.text_xml); mediatypes.add (mediatype.application_xml); XstreamMarshaller xstreamMarshaller = new XStreamMarshaller (); MarshallinghttpMessageConverter.SetSupportedMediaTypes (MediaTypes); MarshallingHttpMessageConverter.SetMarshaller (XStreamMarshaller); MarshallingHttpMessageConverter.SetUnmarShaller (XStreamMarshaller); Retour MarshallingHttpMessageConverter; } // Fichier de configuration Téléchargez @Bean (name = {"MultipartResolver"}) MultipartResolver public MultipartResolver () {CommonsMultipartResolver (); CommonsMultipArTresolver.SetDefaultEncoding ("UTF-8"); CommonsMultipArtresolver.SetMaxuploadSize (10485760000L); CommonsMultipartreSolver.SetMaxInMemorySize (40960); retour CommonsMultipartreSolver; } // exception maniement @bean public exceptionHandler exceptionResolver () {exceptionHandler exceptionHandler = new exceptionHandler (); retourner ExceptionHandler; } // interceptor @Override public void addInterceptors (InterceptorRegistry Registry) {registry.addinterceptor (new Loginterceptor ()). AddPathPatterns ("/ **"); super.addinterceptors (registre); }}J'ai fait quelques choses dans cet exemple de fichier:
Retirer l'injection de haricots excessive
C'est une distraction, mais c'est aussi l'un des problèmes que j'ai rencontrés.
Lors de l'exécution de Springboot Project, j'ai trouvé des problèmes qui ne signalaient pas d'erreurs dans les projets de printemps traditionnels, qui sont une injection de haricots inutile.
Dans les projets de printemps traditionnels, il n'y a pas d'erreur, mais dans les projets Springboot, il est rapporté. Je suppose que c'est parce que lorsque la méthode de classe injectée au haricot est donnée de manière relativement simple, elle sera répétée avec certains beans configurés par Springboot lui-même, et une erreur sera signalée.
Donc, retirez certains haricots qui n'ont pas besoin d'être injectés.
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.