Spring MVC Request Mapping Validation
1.0.0
Un Spring MVC est un cadre Java qui est utilisé pour créer des applications Web. Il suit le modèle de conception de contrôleur de vue de modèle. Un Spring MVC fournit une solution élégante pour utiliser MVC dans le cadre de printemps à l'aide de DispatcherServlet.
@Annotations
Le printemps est un préloadeur d'application Rails. Il accélère le développement en gardant votre application en cours en arrière-plan afin que vous n'ayez pas besoin de le démarrer à chaque fois que vous exécutez un test, une tâche ou une migration.
rails new pour générer votre application) Spring utilise considérablement Process.fork .
Ajoutez le printemps à votre gemfile:
gem "spring" , group : :development (Remarque: en utilisant gem "spring", git: "..." ne fonctionnera pas et n'est pas un moyen pris en charge d'utiliser le printemps.)
Il est recommandé de «Springifier» les exécutables dans votre bin/ répertoire:
$ bundle install
$ bundle exec spring binstub --all
Cela génère un exécutable bin/spring et insère un petit extrait de code en exécutables existants pertinents. L'extrait ressemble à ceci:
begin
load File . expand_path ( '../spring' , __FILE__ )
rescue LoadError
endSur les plates-formes où le ressort est installé et pris en charge, ces crochets d'extraits poussent dans l'exécution des commandes. Dans d'autres cas, l'extrait sera simplement ignoré et les lignes après qu'elle sera exécutée normalement.
Si vous ne souhaitez pas préfixer chaque commande que vous tapez avec bin/ , vous pouvez utiliser direnv pour ajouter automatiquement ./bin à votre PATH lorsque vous cd dans votre application. Créez simplement un fichier .envrc avec le PATH_add bin dans votre répertoire Rails.
Pour cette procédure pas à pas, j'ai généré une nouvelle application Rails et que rails generate scaffold post name:string .
Exécutons un test:
$ time bin/rake test test/controllers/posts_controller_test.rb
Running via Spring preloader in process 2734
Run options:
# Running tests:
.......
Finished tests in 0.127245s, 55.0121 tests/s, 78.5887 assertions/s.
7 tests, 10 assertions, 0 failures, 0 errors, 0 skips
real 0m2.165s
user 0m0.281s
sys 0m0.066s
Ce n'était pas particulièrement rapide parce que c'était la première course, donc Spring a dû démarrer l'application. Il fonctionne maintenant:
$ bin/spring status
Spring is running:
26150 spring server | spring-demo-app | started 3 secs ago
26155 spring app | spring-demo-app | started 3 secs ago | test mode
La prochaine course est plus rapide:
$ time bin/rake test test/controllers/posts_controller_test.rb
Running via Spring preloader in process 8352
Run options:
If we edit any of the application files, or test files, the changes will
be picked up on the next run without the background process having to
restart. This works in exactly the same way as the code reloading
which allows you to refresh your browser and instantly see changes during
development.
But if we edit any of the files which were used to start the application
(configs, initializers, your gemfile), the application needs to be fully
restarted. This happens automatically.
Let's "edit" `config/application.rb`:
$ touch config / application.rb $ bin / spring status ressort est en cours d'exécution:
26150 Spring Server | Spring-Demo-App | Démarré il y a 36 secondes 26556 Spring App | Spring-Demo-App | Démarré il y a 1 sec | mode de test
The application detected that `config/application.rb` changed and
automatically restarted itself.
If we run a command that uses a different environment, then that
environment gets booted up:
$ bin / rake routes en cours via Spring Preloader dans le processus 2363 Posts Get /Posts(.:Format) Posts # index post /posts(.:Format) Posts # Create New_Post get /posts/new(.:Format) Posts # edit_post get get /posts/:id/edit(. / Posts/:id(.:Format) Postes # Mise à jour delete /posts/:id(.:Format) Posts # Détroi
$ Bin / Spring Status Spring est en cours d'exécution:
26150 Spring Server | Spring-Demo-App | Démarré il y a 1 min 26556 application printemps | Spring-Demo-App | a commencé il y a 42 secondes | Mode de test 26707 Application Spring | Spring-Demo-App | a commencé il y a 2 secondes | mode de développement
There's no need to "shut down" Spring. This will happen automatically
when you close your terminal. However if you do want to do a manual shut
down, use the `stop` command:
$ bac / stop print, le printemps s'est arrêté.
From within your code, you can check whether Spring is active with `if defined?(Spring)`.
### Removal
To remove Spring:
* 'Unspring' your bin/ executables: `bin/spring binstub --remove --all`
* Remove spring from your Gemfile
### Deployment
You must not install Spring on your production environment. To prevent it from
being installed, provide the `--without development test` argument to the
`bundle install` command which is used to install gems on your production
machines:
$ Installation du bundle - sans test de développement
## Commands
### `rake`
Runs a rake task. Rake tasks run in the `development` environment by
default. You can change this on the fly by using the `RAILS_ENV`
environment variable. The environment is also configurable with the
`Spring::Commands::Rake.environment_matchers` hash. This has sensible
defaults, but if you need to match a specific task to a specific
environment, you'd do it like this:
``` ruby
Spring::Commands::Rake.environment_matchers["perf_test"] = "test"
Spring::Commands::Rake.environment_matchers[/^perf/] = "test"
# To change the environment when you run `rake` with no arguments
Spring::Commands::Rake.environment_matchers[:default] = "development"
rails console , rails generate , rails runner Ceux-ci exécutent la commande Rails que vous connaissez et aimez déjà. Si vous exécutez une sous-commande différente (par exemple rails server ), le ressort le passera automatiquement aux rails sous-jacents exécutables (sans l'accélération).
Vous pouvez les ajouter à votre gemfile pour des commandes supplémentaires:
Test::Unit sur Rails 3, car seuls Rails 4 vous permet d'utiliser rake test path/to/test pour exécuter un test / répertoire particulier.Si vous ne voulez pas que le code lié à Spring est enregistré dans votre référentiel source, il est possible d'utiliser Spring sans ajouter à votre Gemfile. Cependant, l'utilisation de bintubs de ressort sans ajouter de ressort au gemfile n'est pas pris en charge.
Pour utiliser le ressort comme celui-ci, effectuez un gem install spring , puis préfixez les commandes avec spring . Par exemple, plutôt que d'exécuter bin/rake -T , vous exécuteriez spring rake -T .
Si vous utilisez Spring BinStubs, mais que temporairement ne veulent pas que les commandes exécutent le ressort, définissez la variable d'environnement DISABLE_SPRING .
Spring utilise le mécanisme de rechargement de la classe de Rails ( ActiveSupport::Dependencies ) pour garder votre code à jour entre les essais. Il s'agit du même mécanisme qui vous permet de voir des modifications pendant le développement lorsque vous actualisez la page. Cependant, vous n'avez peut-être jamais utilisé ce mécanisme avec votre environnement test auparavant, ce qui peut causer des problèmes.
Il est important de réaliser que le rechargement du code signifie que les constantes de votre application sont des objets différents après que les fichiers ont changé:
$ bin/rails runner 'puts User.object_id'
70127987886040
$ touch app/models/user.rb
$ bin/rails runner 'puts User.object_id'
70127976764620
Supposons que vous ayez un initialiseur config/initializers/save_user_class.rb comme tel:
USER_CLASS = User Cela enregistre la première version de la classe User , qui ne sera pas le même objet que User après le rechargement du code:
$ bin/rails runner 'puts User == USER_CLASS'
true
$ touch app/models/user.rb
$ bin/rails runner 'puts User == USER_CLASS'
false
Donc, pour éviter ce problème, n'enregistrez pas de références aux constantes d'application dans votre code d'initialisation.
Depuis le printemps 1.7, il y a un certain soutien pour ce faire. Voir cet exemple de référentiel pour savoir comment le faire avec Docker.
Spring aura lieu ~/.spring.rb et config/spring.rb pour les paramètres personnalisés. Notez que ~/.spring.rb est chargé avant Bundler, mais config/spring.rb est chargé après Bundler. Donc, si vous avez installé des communs spring-commands-* que vous souhaitez être disponible dans tous les projets sans avoir à être ajouté au gemfile du projet, nécessitez-les dans votre ~/.spring.rb .
config/spring_client.rb est également chargé avant Bundler et avant le démarrage d'un processus de serveur, il peut être utilisé pour ajouter de nouvelles commandes de niveau supérieur.
Le printemps doit savoir comment trouver votre application Rails. Si vous avez une application normale, tout fonctionne hors de la boîte. Si vous travaillez sur un projet avec une configuration spéciale (un moteur par exemple), vous devez dire à Spring où se trouve votre application:
Spring . application_root = './test/dummy' Il n'y a pas de rappel Spring.before_fork . Pour exécuter quelque chose avant la fourche, vous pouvez le placer dans ~/.spring.rb ou config/spring.rb ou dans l'un des fichiers qui sont exécutés lorsque votre application initialise, telles que config/application.rb , config/environments/*.rb ou config/initializers/*.rb .
Vous voudrez peut-être exécuter du code après que Spring ait détruit le processus, mais avant l'exécution de la commande réelle. Vous voudrez peut-être utiliser un rappel after_fork si vous devez vous connecter à un service externe, effectuer un nettoyage général ou configurer la configuration dynamique.
Spring . after_fork do
# run arbitrary code
end Si vous souhaitez enregistrer plusieurs rappels, vous pouvez simplement appeler Spring.after_fork plusieurs fois avec différents blocs.
Spring détectera automatiquement les modifications du fichier dans tout fichier chargé lorsque le serveur démarre. Les changements entraîneront le redémarrage des environnements affectés.
S'il y a des fichiers ou des répertoires supplémentaires qui devraient déclencher un redémarrage d'application, vous pouvez les spécifier avec Spring.watch :
Spring . watch "config/some_config_file.yml"Par défaut, Spring interroge le système de fichiers pour les modifications une fois toutes les 0,2 secondes. Cette méthode nécessite une configuration zéro, mais si vous constatez qu'elle utilise trop de CPU, vous pouvez utiliser un système de fichiers basé sur des événements en installant la gemme Spring-Watcher-Listen.
Pour désactiver le message "Running via Spring Preloader" qui est affiché à chaque fois qu'une commande s'exécute:
Spring . quiet = trueLes variables d'environnement suivantes sont utilisées par le printemps:
DISABLE_SPRING - Si défini, Spring sera contourné et votre application démarrera dans un processus de premier planSPRING_LOG - Le chemin d'accès à un fichier sur lequel Spring écrira des messages de journal.SPRING_TMP_PATH - Le répertoire où Spring doit écrire ses fichiers temporaires (un pidfile et une prise). Par défaut, nous utilisons la variable d'environnement XDG_RUNTIME_DIR , ou bien Dir.tmpdir , puis créons un répertoire dans ce spring-$UID nommé. Nous n'utilisons pas tmp/ Directory de votre application Rails, car cela peut être sur un système de fichiers qui ne prend pas en charge les sockets UNIX.SPRING_APPLICATION_ID - Utilisé pour identifier des applications de rails distinctes. Par défaut, il s'agit d'un hachage MD5 du RUBY_VERSION actuel et du chemin vers la racine du projet Rails.SPRING_SOCKET - le chemin qui doit être utilisé pour la prise Unix que Spring utilise pour communiquer avec le processus de serveur Spring à long terme. Par défaut, il s'agit SPRING_TMP_PATH/SPRING_APPLICATION_ID .SPRING_PIDFILE - Le chemin qui doit être utilisé pour stocker le PID du processus Spring Server de longue date. Par défaut, cela est lié au chemin de socket; Si le chemin de socket est /foo/bar/spring.sock le pidfile sera /foo/bar/spring.pid .SPRING_SERVER_COMMAND - La commande à exécuter pour démarrer le serveur Spring lorsqu'il n'est pas déjà en cours d'exécution. Par défaut est spring _[version]_ server --background . Si vous souhaitez obtenir plus d'informations sur ce que fait Spring, vous pouvez exécuter explicitement Spring dans un terminal séparé:
$ spring server
La sortie de l'enregistrement sera imprimée à STDOUT. Vous pouvez également envoyer une sortie de journal à un fichier avec la variable d'environnement SPRING_LOG .
