O problema central aqui é poder compartilhar algum estado entre dois objetivos diferentes de um plugin:um
start objetivo que iniciaria um processo e, em seguida, um stop objetivo que o mataria. Uma boa maneira de fazer isso é usar o ContextEnabled
interface que todos os mojos implementam. Ele fornece um getPluginContext()
método que retorna um mapa (bruto), no qual você pode armazenar objetos para serem compartilhados entre mojos. Com essa abordagem, você pode armazenar algo que criou no
start objetivo de um plugin e recuperá-lo no stop meta. Aqui está um exemplo minimalista para mostrar isso em ação, onde um valor String simples é compartilhado entre mojos. Configurar um projeto de plug-in Maven . Isso basicamente se resume a ter um projeto com o seguinte POM, que é o POM padrão para um plugin Maven, usando Java 8 e anotações para configuração:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>sample.plugin</groupId>
<artifactId>test-maven-plugin</artifactId>
<version>1.0.0</version>
<packaging>maven-plugin</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<build>
<plugins>
<plugin>
<artifactId>maven-plugin-plugin</artifactId>
<version>3.5</version>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.apache.maven</groupId>
<artifactId>maven-plugin-api</artifactId>
<version>3.3.9</version>
</dependency>
<!-- dependencies to annotations -->
<dependency>
<groupId>org.apache.maven.plugin-tools</groupId>
<artifactId>maven-plugin-annotations</artifactId>
<version>3.4</version>
<scope>provided</scope>
</dependency>
</dependencies>
</project>
Observe o empacotamento do tipo
maven-plugin que declara ao Maven que este é um projeto de plugin. Neste novo projeto, considere o seguinte StartMojo :@Mojo(name = "start", defaultPhase = LifecyclePhase.PRE_INTEGRATION_TEST)
public class StartMojo extends AbstractMojo {
@SuppressWarnings("unchecked")
@Override
public void execute() throws MojoExecutionException {
getPluginContext().put("myService", new MyService("foo"));
}
}
Isso está declarando um novo
start bom
que está vinculado por padrão ao pre-integration-test
Estágio. Ele recupera o contexto do plugin e coloca um novo objeto nele. Acima, é um POJO personalizado simples chamado MyService que recebe um valor em seu construtor. Este objeto é mapeado para uma chave de "myService" , que serve como pesquisa. Então, podemos ter:
@Mojo(name = "stop", defaultPhase = LifecyclePhase.POST_INTEGRATION_TEST)
public class StopMojo extends AbstractMojo {
@Override
public void execute() throws MojoExecutionException {
MyService service = (MyService) getPluginContext().get("myService");
getLog().info(service.getValue());
}
}
Isso está declarando um novo
stop mojo que está vinculado por padrão ao post-integration-test
Estágio. Ele recupera o contexto do plugin, extrai o objeto sob a chave "myService" , e finalmente obter seu valor e registrá-lo. Depois de empacotar e instalar este plugin Maven (com
mvn clean install ) em seu repositório local, você pode usá-lo em um projeto de amostra com <plugin>
<groupId>sample.plugin</groupId>
<artifactId>test-maven-plugin</artifactId>
<executions>
<execution>
<id>sample</id>
<goals>
<goal>start</goal>
<goal>stop</goal>
</goals>
</execution>
</executions>
</plugin>
Se você executar
mvn clean verify nesse projeto de amostra, você terá "foo" impresso em seus logs, no post-integration-test Estágio. Isso mostra que o valor foi configurado corretamente pelo start mojo e, em seguida, recuperados corretamente pelo stop mojo. Claro, você pode armazenar objetos complexos neste mapa, não apenas uma
String (para o qual poderia haver soluções mais simples). Notavelmente, pode ser um host para seu process instância que você deseja parar. Você pode se livrar do exec-maven-plugin , crie um novo plugin Maven contendo o código que você já tem para configurar o banco de dados embutido em um start objetivo, armazene a instância do processo no contexto do plug-in neste objetivo e, finalmente, pare esse processo posteriormente em outro stop mojo recuperando-o do contexto do plugin. 
