首页 > 代码库 > Maven学习（五）：maven的灵活构建
Maven学习（五）：maven的灵活构建
一、实现资源过滤
（一）maven-resources-plugin 插件
1、Maven 区别对待Java代码文件和资源文件，maven-compiler-plugin用来编译Java代码，maven-resources-plugin则用来处理资源文件。默认的主资源文件目录是 src/main/resources。
2、很多用户会需要添加额外的资源文件目录，这个时候就可以通过配置maven-resources-plugin来实现。实现资源的过滤只需要添加 <filtering>true</filtering> 标签。
<!-- 资源过滤过滤 src/main/resources --> <resources> <resource> <directory>src/main/resources</directory> <filtering>true</filtering> </resource> <resource> <directory>config</directory> </resource> </resources>
（二）资源过滤
1、两个资源文件夹：src/main/resources 和 config 。定义了同样的数据库配置。
jdbc.driverClassName = ${db.driver}
jdbc.url = ${db.url}
jdbc.username = ${db.username}
jdbc.password = ${db.password}2、定义资源文件及制定需要过滤的资源文件。（在<build> 标签）
<!-- 资源过滤过滤 src/main/resources --> <resources> <resource> <directory>src/main/resources</directory> <filtering>true</filtering> </resource> <resource> <directory>config</directory> </resource> </resources>
两个文件都被指定为资源文件，并且对src/main/resources 下文件是实现过滤。
3、利用 <profiles> 定义灵活构建的属性。
<!-- 定义灵活构建的属性 --> <profiles> <!-- DEV开发环境属性 --> <profile> <id>DEV</id> <properties> <db.driver>com.mysql.jdbc.Driver</db.driver> <db.url>jdbc:mysql://localhost:3306/dev_oa_0303</db.url> <db.username>dev-name</db.username> <db.password>dev-password</db.password> </properties> <!-- 激活方式： 1、命令行：mvn clean install -PDEV,UAT 2、setting中配置： <activeProfiles><activeProfile>dev</activeProfile></activeProfiles> 3、存在属性激活：<activation><property><name>a</name></property></activation>存在属性a 4、存在属性值：<activation><property><name>test</name><value>1</value></property></activation> 存在属性test=1,即激活。可以命令行：mvn clean install -Dtest=1; 5、默认激活：<activeByDefault>true</activeByDefault>. --> <activation> <activeByDefault>true</activeByDefault> </activation> </profile> <!--UAT测试环境属性 --> <profile> <id>UAT</id> <properties> <db.driver>com.mysql.jdbc.Driver</db.driver> <db.url>jdbc:mysql://localhost:3306/uat_oa_0505</db.url> <db.username>uat-name</db.username> <db.password>uat-password</db.password> </properties> </profile> </profiles>
1）一个 profile 代表一个动态项，使用不同的Id 区分。这个Id 作为 -P 的参数使用。
2）使用properties 标签定义属性，这边属性的标签名需要与配置文件中${key}一致。
3）激活方式：
①、命令行激活：mvn clean install -PDEV,UAT
②、setting中配置激活： 使用<activeProfiles><activeProfile>dev</activeProfile></activeProfiles>标签。
③、存在属性激活：<activation><property><name>a</name></property></activation>存在属性激活
④、存在属性值：<activation><property><name>test</name><value>1</value></property></activation> ，存在属性test=1,即激活。可以在命令行：mvn clean install -Dtest=1;
⑤、默认激活：<activeByDefault>true</activeByDefault>
4、动态构建： 运行时输入 clean install ，使用默认激活的 profile 配置。
1）两个文件都被作为配置文件处理。
2）其中 jdbc.properties 中的属性引用被动态替换了。并且是被默认的 id = DEV 的profile 替换。
5、运行时输入 clean install -PUAT，激活使用 id=UAT 的profile 配置。
二、创建web项目
1、Maven学习 (三) 使用m2eclipse创建web项目
三、一个成功的灵活构建项目实例
（一）简介
1、三类配置文件：都放在src/main/resources 下
1）配置文件总类：
application-file.properties，定义了需要的配置文件，其中A、B为通用的配置，而C则动态构建。
2）新建local 和 product两个环境的私有配置文件：application.local.properties 和 application.product.properties
3）所有的配置文件如下：
2、pom配置：
1）profiles 动态构建如下：默认激活 dev 。
<profiles>
<profile>
<id>dev</id>
<properties>
<dev.mode>true</dev.mode>
<env.prop.application.file>
application.local.properties
</env.prop.application.file>
</properties>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
</profile>
<profile>
<id>product</id>
<properties>
<dev.mode>true</dev.mode>
<env.prop.application.file>
application.product.properties
</env.prop.application.file>
</properties>
</profile>
</profiles>2）对资源文件进行过滤
<!-- 资源过滤过滤 src/main/resources -->
<resources>
<resource>
<directory>${basedir}/src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
3）配置Tomcat 插件。
<!-- tomcat的插件 -->
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>tomcat-maven-plugin</artifactId>
<version>1.1</version>
<configuration>
<path>/${project.build.target.file.name}</path>
</configuration>
</plugin>
4）如运行命令：clean install -Pproduct ，那么会动态替换application-file.properties 配置文件中的各环境的私有配置。如：
（二）配置文件读取类
1、需要定义一个配置文件的读取类，业务需求为，先读取application-file.properties ，然后按照顺序，依次读取其中配置的三个配置文件。这样配合Maven的动态构建，就实现了不同环境读取不同的配置文件。
2、默认的 Properties 类时无序的，我们需要实现一个有序的Properties 类。
package util;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import org.apache.commons.lang3.ArrayUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.util.DefaultPropertiesPersister;
import org.springframework.util.PropertiesPersister;
/**
* 系统属性工具类
* PropertyUtil
* @title
* @desc
* @author SAM-SHO
* @Jan 15, 2015
*/
public class PropertyUtil {
private static Logger logger = LoggerFactory.getLogger(PropertyUtil.class);
private static Properties properties;
private static PropertiesPersister propertiesPersister = new DefaultPropertiesPersister();
private static ResourceLoader resourceLoader = new DefaultResourceLoader();
private static final String DEFAULT_ENCODING = "UTF-8";
/**
* 初始化读取配置文件，读取的文件列表位于classpath下面的application-files.properties
*
*
* 多个配置文件会用最后面的覆盖相同属性值
*
* @throws IOException
* 读取属性文件时
*/
public static void init() throws IOException {
String fileNames = "application-file.properties";
innerInit(fileNames);
}
/**
* 初始化读取配置文件，读取的文件列表位于classpath下面的application-[type]-files.properties
*
*
* 多个配置文件会用最后面的覆盖相同属性值
*
* @param type
* 配置文件类型，application-[type]-files.properties
*
* @throws IOException
* 读取属性文件时
*/
public static void init(String type) throws IOException {
String fileNames = "application-" + type + "-files.properties";
innerInit(fileNames);
}
/**
* 内部处理
*
* @param fileNames
* @throws IOException
*/
private static void innerInit(String fileNames) throws IOException {
ClassLoader loader = Thread.currentThread().getContextClassLoader();
InputStream resourceAsStream = loader.getResourceAsStream(fileNames);
// 默认的Properties实现使用HashMap算法，为了保持原有顺序使用有序Map
Properties files = new LinkedProperties();
files.load(resourceAsStream);
Set<Object> fileKeySet = files.keySet();
String[] propFiles = new String[fileKeySet.size()];
List<Object> fileList = new ArrayList<Object>();
fileList.addAll(files.keySet());
for (int i = 0; i < propFiles.length; i++) {
String fileKey = fileList.get(i).toString();
propFiles[i] = files.getProperty(fileKey);
}
logger.debug("读取属性文件：{}", ArrayUtils.toString(propFiles));
;
properties = loadProperties(propFiles);
Set<Object> keySet = properties.keySet();
for (Object key : keySet) {
logger.debug("property: {}, value: {}", key, properties.getProperty(key.toString()));
}
}
/**
* 载入多个properties文件, 相同的属性在最后载入的文件中的值将会覆盖之前的载入. 文件路径使用Spring Resource格式,
* 文件编码使用UTF-8.
*
* @see org.springframework.beans.factory.config.PropertyPlaceholderConfigurer
*/
public static Properties loadProperties(String... resourcesPaths) throws IOException {
Properties props = new Properties();
for (String location : resourcesPaths) {
logger.debug("Loading properties file from:" + location);
InputStream is = null;
try {
Resource resource = resourceLoader.getResource(location);
is = resource.getInputStream();
propertiesPersister.load(props, new InputStreamReader(is, DEFAULT_ENCODING));
} catch (IOException ex) {
logger.info("Could not load properties from classpath:" + location + ": " + ex.getMessage());
} finally {
if (is != null) {
is.close();
}
}
}
return props;
}
/**
* 获取键值对Map
*
* @return
*/
public static Map<String, String> getKeyValueMap() {
Set<String> keys = getKeys();
Map<String, String> values = new HashMap<String, String>();
for (String key : keys) {
values.put(key, get(key));
}
return values;
}
/**
* 获取所有的key
*
* @return
*/
public static Set<String> getKeys() {
return properties.stringPropertyNames();
}
/**
* 获取属性值
*
* @param key
* 键
* @return 值
*/
public static String get(String key) {
String propertyValue = http://www.mamicode.com/properties.getProperty(key);>
package util;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
/**
* 有序Properties
*/
public class LinkedProperties extends Properties {
private static final long serialVersionUID = 1L;
private Map<Object, Object> linkMap = new LinkedHashMap<Object, Object>();
public void clear() {
linkMap.clear();
}
public boolean contains(Object value) {
return linkMap.containsValue(value);
}
public boolean containsKey(Object key) {
return linkMap.containsKey(key);
}
public boolean containsValue(Object value) {
return linkMap.containsValue(value);
}
public Enumeration elements() {
throw new RuntimeException("Method elements is not supported in LinkedProperties class");
}
public Set entrySet() {
return linkMap.entrySet();
}
public boolean equals(Object o) {
return linkMap.equals(o);
}
public Object get(Object key) {
return linkMap.get(key);
}
public String getProperty(String key) {
Object oval = get(key); //here the class Properties uses super.get()
if (oval == null) return null;
return (oval instanceof String) ? (String) oval : null; //behavior of standard properties
}
public boolean isEmpty() {
return linkMap.isEmpty();
}
public Enumeration keys() {
Set keys = linkMap.keySet();
return Collections.enumeration(keys);
}
public Set keySet() {
return linkMap.keySet();
}
public void list(PrintStream out) {
this.list(new PrintWriter(out, true));
}
public void list(PrintWriter out) {
out.println("-- listing properties --");
for (Map.Entry e : (Set<Map.Entry>) this.entrySet()) {
String key = (String) e.getKey();
String val = (String) e.getValue();
if (val.length() > 40) {
val = val.substring(0, 37) + "...";
}
out.println(key + "=" + val);
}
}
public Object put(Object key, Object value) {
return linkMap.put(key, value);
}
public int size() {
return linkMap.size();
}
public Collection values() {
return linkMap.values();
}
}
（三）项目启动时，读取配置的Servlet。
1、PropertiesServlet 的代码如下：
package servlet;
import java.io.IOException;
import java.util.Set;
import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import util.PropertyUtil;
/**
* classpath下面的属性配置文件读取初始化类
* PropertiesServlet
* @title
* @desc
* @author SAM-SHO
* @Jan 15, 2015
*/
public class PropertiesServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected Logger logger = LoggerFactory.getLogger(getClass());
/**
* @see Servlet#init(ServletConfig)
*/
public void init(ServletConfig config) throws ServletException {
try {
PropertyUtil.init();
ServletContext servletContext = config.getServletContext();
setParameterToServerContext(servletContext);;
logger.info("++++ 初始化[classpath下面的属性配置文件]完成 ++++");
} catch (IOException e) {
logger.error("初始化classpath下的属性文件失败", e);
}
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String action = StringUtils.defaultString(req.getParameter("action"));
resp.setContentType("text/plain;charset=UTF-8");
if ("reload".equals(action)) { // 重载
try {
PropertyUtil.init();
setParameterToServerContext(req.getSession().getServletContext());
logger.info("++++ 重新初始化[classpath下面的属性配置文件]完成 ++++，{IP={}}", req.getRemoteAddr());
resp.getWriter().print("<b>属性文件重载成功！</b>");
// writeProperties(resp);
} catch (IOException e) {
logger.error("重新初始化classpath下的属性文件失败", e);
}
} else if ("getprop".equals(action)) { // 获取属性
String key = StringUtils.defaultString(req.getParameter("key"));
resp.getWriter().print(key + "=" + PropertyUtil.get(key));
} else if ("list".equals(action)) { // 获取属性列表
// writeProperties(resp);
}
}
private void setParameterToServerContext(ServletContext servletContext) {
servletContext.setAttribute("prop", PropertyUtil.getKeyValueMap());
}
}
2、PropertiesServlet 配置：
<!-- 配置文件 -->
<servlet>
<servlet-name>PropertiesServlet</servlet-name>
<servlet-class>servlet.PropertiesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>PropertiesServlet</servlet-name>
<url-pattern>/servlet/properties</url-pattern>
</servlet-mapping>
（四）启动项目，使用tomcat-maven-plugin插件
1、启动方式：tomcat:run 和 tomcat:run -Dmaven.tomcat.port=8880(指定端口)
2、项目启动：
1）tomcat:run 默认运行dev环境的配置。
2）tomcat:run -Pproduct ，指定移动 product 的profile（运行product 的环境）。（这边的-P，即指的就是profile）。
Maven学习（五）：maven的灵活构建
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。