Spring MVC Request Mapping Validation
1.0.0
Um MVC de primavera é uma estrutura Java que é usada para criar aplicativos da Web. Segue-se o padrão de design do Model-View-Controller. Um MVC de primavera fornece uma solução elegante para usar o MVC na estrutura da primavera pela ajuda do DispatcheserServlet.
@Annotações
A primavera é um pré -atendente de aplicação do Rails. Ele acelera o desenvolvimento mantendo seu aplicativo em execução em segundo plano, para que você não precise inicializá -lo toda vez que executar um teste, tarefa de rake ou migração.
rails new para gerar seu aplicativo) A primavera faz uso extensivo do Process.fork .
Adicione a mola ao seu GemFile:
gem "spring" , group : :development (Nota: Usando gem "spring", git: "..." não funciona e não é uma maneira suportada de usar a primavera.)
É recomendável 'Springify' os executáveis em seu bin/ diretório:
$ bundle install
$ bundle exec spring binstub --all
Isso gera um executável bin/spring e insere um pequeno trecho de código em executáveis existentes relevantes. O trecho se parece com o seguinte:
begin
load File . expand_path ( '../spring' , __FILE__ )
rescue LoadError
endNas plataformas onde a primavera é instalada e suportada, este snippet ganchos se transforma na execução de comandos. Em outros casos, o snippet será silenciosamente ignorado e as linhas depois que serão executadas normalmente.
Se você não deseja prefixar todos os comandos que você digita com bin/ , pode usar o DIRENV para adicionar automaticamente ./bin ao seu PATH quando você cd no seu aplicativo. Basta criar um arquivo .envrc com o comando PATH_add bin no diretório do seu Rails.
Para este passo a passo, gerei um novo aplicativo Rails e o Run rails generate scaffold post name:string .
Vamos fazer um teste:
$ 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
Isso não foi particularmente rápido porque foi a primeira execução, então a Spring teve que inicializar o aplicativo. Agora está correndo:
$ 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
A próxima corrida é mais rápida:
$ 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 Spring está em execução:
26150 Spring Server | primavera-deem-app | Iniciado 36 segundos atrás 26556 Spring App | primavera-deem-app | Iniciado há 1 seg. modo de teste
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:
Rotas $ bin /ancinho em execução através do pré -montador da primavera no processo 2363 Postagens Get /posts(.:format) postagens#Índice post /posts(.:fformat) postagens#crie new_post get /posts/new(.::format) Posts#edit_post get /posts /:id/edit/: :::fformat)#edit_post get /posts/pos /Posts/:id(.:Format) Publica#atualização delete /posts/:id(.:format) postagens#Destroy
$ bin/status de primavera A primavera está em execução:
26150 Spring Server | primavera-deem-app | Iniciado 1 minuto atrás 26556 Spring App | primavera-deem-app | Iniciado há 42 segundos | Modo de teste 26707 Spring App | primavera-deem-app | Iniciado há 2 segundos | modo de desenvolvimento
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:
$ bin/parada de primavera A primavera parou.
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:
$ Bundle Instale -Teste de desenvolvimento
## 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 Estes executam o comando dos trilhos que você já conhece e ama. Se você executar um Sub Command diferente (por exemplo, rails server ), a Spring o passará automaticamente para o executável rails subjacente (sem a aceleração).
Você pode adicioná -los ao seu GemFile para comandos adicionais:
Test::Unit no Rails 3, pois apenas o Rails 4 permite que você use rake test path/to/test para executar um teste/diretório específico.Se você não deseja que o código relacionado à primavera seja verificado no seu repositório de origem, é possível usar o Spring sem adicionar ao seu GemFile. No entanto, o uso de bancos de primavera sem adicionar mola ao GEMFILE não é suportado.
Para usar a mola como essa, faça uma gem install spring e, em seguida, prefixo comandos com spring . Por exemplo, em vez de executar bin/rake -T , você executaria spring rake -T .
Se você estiver usando binscubs de primavera, mas temporariamente não deseja que os comandos sejam executados na primavera, defina a variável DISABLE_SPRING Environment.
A primavera usa o mecanismo de recarga da aula dos Rails ( ActiveSupport::Dependencies ) para manter seu código atualizado entre as execuções de teste. Este é o mesmo mecanismo que permite ver as alterações durante o desenvolvimento quando você atualiza a página. No entanto, você pode nunca ter usado esse mecanismo com seu ambiente test antes, e isso pode causar problemas.
É importante perceber que a recarga do código significa que as constantes em seu aplicativo são objetos diferentes depois que os arquivos foram alterados:
$ bin/rails runner 'puts User.object_id'
70127987886040
$ touch app/models/user.rb
$ bin/rails runner 'puts User.object_id'
70127976764620
Suponha que você tenha um Initializer config/initializers/save_user_class.rb Like So:
USER_CLASS = User Isso salva a primeira versão da classe User , que não será o mesmo objeto que User após o código ter sido recarregado:
$ bin/rails runner 'puts User == USER_CLASS'
true
$ touch app/models/user.rb
$ bin/rails runner 'puts User == USER_CLASS'
false
Portanto, para evitar esse problema, não economize referências às constantes de aplicativos em seu código de inicialização.
A partir da primavera 1.7, há algum apoio para fazer isso. Consulte este exemplo repositório para obter informações sobre como fazê -lo com o Docker.
A primavera lerá ~/.spring.rb e config/spring.rb para configurações personalizadas. Observe que ~/.spring.rb é carregado antes do Bundler, mas config/spring.rb é carregado após o Bundler. Portanto, se você tiver algum spring-commands-* Gems instalado que deseja estar disponível em todos os projetos sem precisar ser adicionado ao GemFile do projeto, exige-os no seu ~/.spring.rb .
config/spring_client.rb também é carregado antes do Bundler e, antes que um processo de servidor seja iniciado, ele pode ser usado para adicionar novos comandos de nível superior.
A primavera deve saber como encontrar seu aplicativo Rails. Se você tiver um aplicativo normal, tudo funciona fora da caixa. Se você estiver trabalhando em um projeto com uma configuração especial (um mecanismo, por exemplo), deve dizer à primavera onde seu aplicativo está localizado:
Spring . application_root = './test/dummy' Não há Spring.before_fork Retorno de chamada. Para executar algo antes do garfo, você pode colocá -lo em ~/.spring.rb ou config/spring.rb ou em qualquer um dos arquivos que são executados quando seu aplicativo inicializar, como config/application.rb , config/environments/*.rb ou config/initializers/*.rb .
Você pode querer executar o código após a primavera bifurcada no processo, mas antes que o comando real seja executado. Você pode querer usar um retorno de chamada after_fork Se precisar se conectar a um serviço externo, fazer uma limpeza geral ou configurar a configuração dinâmica.
Spring . after_fork do
# run arbitrary code
end Se você deseja registrar vários retornos de chamada, basta ligar para Spring.after_fork várias vezes com blocos diferentes.
A mola detectará automaticamente as alterações de arquivo em qualquer arquivo carregado quando o servidor inicializar. As alterações farão com que os ambientes afetados sejam reiniciados.
Se houver arquivos ou diretórios adicionais que devem acionar um aplicativo reiniciar, você poderá especificá -los com Spring.watch :
Spring . watch "config/some_config_file.yml"Por padrão, as pesquisas de primavera pesquisam o sistema de arquivos para alterações uma vez a cada 0,2 segundos. Esse método requer uma configuração zero, mas se você achar que está usando muita CPU, poderá usar o sistema de arquivos baseado em eventos, instalando a gema de listamento de listre de mola.
Para desativar a mensagem "Running via Spring Preloader", que é mostrada sempre que um comando é executado:
Spring . quiet = trueAs seguintes variáveis de ambiente são usadas pela primavera:
DISABLE_SPRING - Se definido, a primavera será ignorada e seu aplicativo inicializará em um processo de primeiro planoSPRING_LOG - o caminho para um arquivo no qual a primavera gravará mensagens de log.SPRING_TMP_PATH - o diretório em que a mola deve escrever seus arquivos temporários (um pidfile e um soquete). Por padrão, usamos a variável de ambiente XDG_RUNTIME_DIR , ou então Dir.tmpdir e, em seguida, criamos um diretório naquele chamado spring-$UID . Não usamos tmp/ diretório do seu aplicativo Rails, porque isso pode estar em um sistema de arquivos que não suporta soquetes Unix.SPRING_APPLICATION_ID - usado para identificar aplicativos de trilhos distintos. Por padrão, é um hash do MD5 do RUBY_VERSION atual e o caminho para a raiz do seu projeto Rails.SPRING_SOCKET - o caminho que deve ser usado para o soquete Unix que a mola usa para se comunicar com o processo de servidor de primavera de longa duração. Por padrão, isso é SPRING_TMP_PATH/SPRING_APPLICATION_ID .SPRING_PIDFILE - o caminho que deve ser usado para armazenar o PID do processo de servidor de primavera de longa duração. Por padrão, isso está relacionado ao caminho do soquete; Se o caminho do soquete for /foo/bar/spring.sock , o pidfile será /foo/bar/spring.pid .SPRING_SERVER_COMMAND - o comando a ser executado para iniciar o servidor Spring quando ainda não estiver em execução. Padrão para spring _[version]_ server --background . Se você deseja obter mais informações sobre o que a primavera está fazendo, poderá executar o Spring explicitamente em um terminal separado:
$ spring server
A saída de log será impressa no stdout. Você também pode enviar saída de log para um arquivo com a variável SPRING_LOG Environment.
