java - servlet - jsp tutorial
¿Cómo puedo obtener el número de versión del proyecto en una página jsp? (10)
Estoy trabajando en una aplicación web java, administrada por maven2. De vez en cuando, hicimos algunos cambios, y queremos hacer nuevas versiones, por supuesto, con un nuevo número de versión. En la página de inicio (jsp), hay texto como
<b>version:</b> 2.3.3...
¿Es posible, cada vez que hago una nueva versión, solo cambio la <version/> en pom.xml, y el número de versión en jsp puede completarse automáticamente con este maven $ {project.version}?
Intenté el perfil de Maven, sin embargo, no parece funcionar.
¿algunas ideas?
Gracias.
En http://mojo.codehaus.org/jspc/jspc-maven-plugin/usage.html
Dice esto:
Proyectos no WAR
También puede usar este complemento con proyectos que no sean de guerra, por ejemplo para validar JSP. Se compilarán, pero no se incluirán en su artefacto final, y no se generará ni modificará ningún archivo web.xml.
Si solo desea validar y compilar sus JSP sin incluir realmente el código generado en su proyecto de guerra, también puede usar el parámetro includeInProject como falso.
Hace un tiempo que esta publicación ha sido creada, pero espero que ayude. Obtendrá propiedades generadas desde Maven:
<%@ page import="java.util.*"%>
<%
java.io.InputStream inputStream = getServletContext().getResourceAsStream("/META-INF/maven/com.filhetallard.fam.ged/famdox/pom.properties");
Properties mavenProperties= new Properties();
mavenProperties.load(inputStream );
String version = (String) mavenProperties.get("version");
String name = (String) mavenProperties.get("artifactId");
%><html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">
<head>
<title>Application <%= name %> v<%= version %></title>
Desafortunadamente, hay algunos inconvenientes:
- tuvo que escribir explícitamente groupId y artifactId en su código
- si implementa su aplicación web directamente desde target / a su servidor, no encontrará el archivo porque éste se encuentra en el directorio maven-archiver, no en META-INF, antes del empaquetado.
Saludos.
Padre pom.xml:
<properties>
<!-- in my case injected by jenkins build job -->
<build.version>dev</build.version>
<build.branch>local</build.branch>
<build.revision />
</properties>
Filtrado de recursos (los marcadores de posición se reemplazan por valores de propiedad pom aquí)
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>conf/version.properties</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
Configuración de marcadores de posición de bean y propiedad en webContext.xml:
<context:property-placeholder location="classpath:conf/version.properties"/>
<bean id="buildVersion" class="de.your.package.cfg.BuildVersion">
<property name="buildBranch" value="${build_branch}"/>
<property name="buildVersion" value="${build_version}"/>
<property name="buildRevision" value="${build_revision}"/>
</bean>
Tu frijol se parece a esto entonces
@Component
public class BuildVersion {
private String buildBranch;
private String buildVersion;
private String buildRevision;
public String getBuildRevision() {
return buildRevision;
}
public void setBuildRevision(String buildRevision) {
this.buildRevision = buildRevision;
}
public String getBuildVersion() {
return buildVersion;
}
public void setBuildVersion(String buildVersion) {
this.buildVersion = buildVersion;
}
public String getBuildBranch() {
return buildBranch;
}
public void setBuildBranch(String buildBranch) {
this.buildBranch = buildBranch;
}
}
Y aquí viene tu fragmento de JSP:
<%@ page language="java"
import="java.util.*,
org.springframework.context.ApplicationContext,
org.springframework.web.context.support.WebApplicationContextUtils,
de.smava.kredithai.cfg.BuildVersion" %>
<%
ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(pageContext.getServletContext());
BuildVersion buildVersion = (BuildVersion) applicationContext.getBean("buildVersion");
String branch = (String) buildVersion.getBuildBranch();
String version = (String) buildVersion.getBuildVersion();
String revision = (String) buildVersion.getBuildRevision();
if (request.getParameter("branch") != null){
out.println(branch);
} else if (request.getParameter("version") != null){
out.println(version);
} else if (request.getParameter("link") != null){
out.println("<a href=/"http://your_server_url"+branch+"/"+version+"/" >" + branch + " build " + version + "</a>");
} else {
out.println(branch + " build " + version + " rev. " + revision);
}
%>
Puede usar esto en su archivo JSP (template.jsp en mi ejemplo)
<head>
<meta name="Historia Social Unica version:${version}" />
Luego, en tu pom.xml de tu proyecto tienes que activar el filtrado:
<resources>
<resource>
<includes>
<include>template.jsp</include>
</includes>
<directory>src/main/webapp/jsp/template</directory>
<targetPath>jsp/template/</targetPath>
<filtering>true</filtering>
</resource>
</resources>
</build>
Y obtienes tu JSP con la versión variable reemplazada.
Puede utilizar el filtrado de proyectos para procesar el JSP, ya que se copia en la ubicación de destino. Si el JSP se especifica con ${project.version} , y la carpeta que contiene se especifica como una ubicación de filtro, el valor debe sustituirse en el JSP a medida que se empaqueta.
Por ejemplo, agregar esto a su POM habilita el filtrado para src / main / resources:
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
Actualización: para el paquete war, es posible que deba configurar el plugin war para que realice el filtrado. Vea la sección de Filtering de la documentación de war-plugin para más detalles y ejemplos.
Esencialmente, el proceso es el mismo, pero se define debajo del plugin war, por lo que tendrías algo como esto:
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>2.0</version>
<configuration>
<webResources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</webResources>
</configuration>
</plugin>
</plugins>
Quería hacer esto mismo pero no estaba satisfecho con ninguna de las soluciones existentes, incluido el uso del enfoque de filtrado de Maven, lo cual está bien, pero estoy intentando alejarme de la modificación de los archivos de código existentes durante el proceso de compilación, así que decidí Ese enfoque sale, aunque es un enfoque razonable.
La forma en que obtengo mi versión del proyecto Maven en mi archivo JSP se basa en un enfoque similar al de here excepto que no creo un archivo Version.java, en vez de eso, Maven escribe la versión en un archivo de propiedades. como "version.properties" como esto:
version.properties:
app.version = 0.1
y haga que Maven lo ponga en el classpath, por ejemplo, en src / main / resources como este:
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.7</version>
<executions>
<execution>
<goals>
<goal>run</goal>
</goals>
<phase>generate-sources</phase>
<configuration>
<!-- Idea from link: http://.com/questions/2469922/generate-a-version-java-file-in-maven -->
<target>
<property name="resources.dir" value="${project.build.sourceDirectory}/../resources" />
<property name="version.filename" value="version.properties" />
<property name="buildtime" value="${maven.build.timestamp}" />
<echo message="Writing project version string to ${resources.dir}/${version.filename} ..." />
<echo file="${resources.dir}/${version.filename}" message="app.version = ${project.version}${line.separator}" />
</target>
</configuration>
</execution>
</executions>
</plugin>
Además, si está utilizando Spring Framework 3.x +, entonces puede agregar la siguiente configuración para cargar las propiedades en version.properties, si existe, de lo contrario, solo muestre "v0.0" o lo que sea:
@Configuration
@EnableWebMvc
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class WebHomeConfig extends WebMvcConfigurerAdapter implements
ApplicationContextAware {
private ApplicationContext _appContext;
/*
* (non-Javadoc)
*
* @see
* org.springframework.context.ApplicationContextAware#setApplicationContext
* (org.springframework.context.ApplicationContext)
*/
@Override
public void setApplicationContext(ApplicationContext appContext)
throws BeansException {
_appContext = appContext;
}
@Bean
public ViewResolver getViewResolver() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/views/");
resolver.setSuffix(".jsp");
resolver.getAttributesMap().put("appVersion", appVersion);
return resolver;
}
/**
* Since we don''t have any controller logic, simpler to just define
* controller for page using View Controller. Note: had to extend
* WebMvcConfigurerAdapter to get this functionality
*
* @param registry
*/
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("home");
}
/**
* The application version.
*/
@Value("${app.version:0.0}")
protected String appVersion;
@Bean
public static PropertySourcesPlaceholderConfigurer configurer() {
PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
configurer.setIgnoreResourceNotFound(true);
configurer.setLocations(new Resource[] {
new ClassPathResource("version.properties")});
return configurer;
}
}
Y finalmente, en su /WEB-INF/views/home.jsp puede tener algo como:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Service Status</title>
</head>
<body>
<h1>Service API</h1>
<p>The service is up and running! (v${appVersion})</p>
</body>
</html>
Y esto, por supuesto, se traduciría como:
El servicio está en funcionamiento! (v0.1)
NOTA: Si no usa las clases JavaConfig para configurar Spring Framework, puede hacer lo mismo con la configuración de Spring XML.
Tal vez sea estúpido, pero usaría un archivo .properties como en este ejemplo en lugar de filtrar directamente el JSP.
Yo le daría a .jsp el valor de
String version = getClass().getPackage().getImplementationVersion();
que se vería como 1.0.0-SNAPSHOT por ejemplo.
Si solo está obteniendo nulos , es posible que deba agregar el classpath al Manifiesto de la war con
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>2.5</version>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
</manifest>
</archive>
</configuration>
</plugin>
para que el cargador de clases lo recoja.
Yo uso este plugin,
http://code.google.com/p/maven-substitute-plugin/
Puedes hacer algo como esto en Java,
public final static String projectVersion = "@PROJECT_VERSION@";
y es trivial pasar este valor a JSP.
Utilice el maven-replacer-plugin
Incluya el plugin en su pom.xml de esta manera:
<plugin>
<groupId>com.google.code.maven-replacer-plugin</groupId>
<artifactId>replacer</artifactId>
<version>(version)</version>
<executions>
<execution>
<phase>prepare-package</phase>
<goals>
<goal>replace</goal>
</goals>
</execution>
</executions>
<configuration>
<ignoreMissingFile>true</ignoreMissingFile>
<file>target/someapp/jsp/helloWorld.jsp</file>
<outputFile>
target/someapp/jsp/helloWorld-updated.jsp
</outputFile>
<regex>false</regex>
<token>$BUILD_NUMBER$</token>
<value>${buildNumber}</value>
</configuration>
</plugin>
Ahora, en cualquier lugar del archivo especificado que tenga el token $BUILD_NUMBER$ , se reemplazará el token.