hrtc

动态加载资源文件

hrtc — Wed, 30 Jul 2008 17:10:57 +0800

作者: hrtc 链接：http://hrtc.javaeye.com/blog/221621 发表时间: 2008年07月30日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

问题

对于java应用中的一些配置文件每次都需要重新启动服务才能重新加载，非常麻烦，故做了一个动态加载资源的程序。

可选方案

使用监听线程监听文件变化，当文件变化时通知程序重新加载配置文件，用到了事件委托模型和观察者模式类似，如下

公共部分

1.Listener接口

package com.hrtc.monitor;

/**
 * 监听器接口
 * Jul 30, 2008 3:02:28 PM
 */
public interface IMonitorListener {
	public void update(MonitorEvent event);
}

2.Event监听事件顶层类

package com.hrtc.monitor;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 监听事件
 * Jul 30, 2008 3:03:12 PM
 */
public class MonitorEvent {
	private Object lock = new Object();
	private List monitorListenerList = new ArrayList();

	public void addListener(IMonitorListener listener) {
		synchronized (lock) {
			if (!monitorListenerList.contains(listener)) {
				monitorListenerList.add(listener);
			}
		}
	}

	public void removeListener(IMonitorListener listener) {
		synchronized (lock) {
			if (monitorListenerList.contains(listener)) {
				monitorListenerList.remove(listener);
			}
		}
	}

	public void removeAllListener() {
		synchronized (lock) {
			monitorListenerList.clear();
		}
	}

	/**
	 * 触发事件可由子类重载
	 */
	public void fireEvent() {
		synchronized (lock) {
			for (Iterator it = monitorListenerList.iterator(); it.hasNext();) {
				IMonitorListener listener = (IMonitorListener) it.next();
				listener.update(this);
			}
		}
	}
}

3.主线程监听类

package com.hrtc.monitor;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 监听线程类
 * 
 * Jul 30, 2008 3:03:55 PM
 */
public class MonitorThread extends Thread {
	private List monitorEventList = new ArrayList();
	private long interval;
	private boolean isMonitor = false;
	private Object lock = new Object();
	private static MonitorThread monitor;

	synchronized public static MonitorThread getInstance(long intervalSecond) {
		if (monitor == null) {
			monitor = new MonitorThread(intervalSecond);
		}else{
			monitor.setInterval(intervalSecond);
		}
		return monitor;
	}

	synchronized public static MonitorThread getInstance() {
		if (monitor == null) {
			monitor = new MonitorThread(1);
		}
		return monitor;
	}

	/**
	 * 构造方法
	 * 
	 * @param intervalSecond
	 *            监听间隔时间
	 */
	public MonitorThread(long intervalSecond) {
		this.interval = intervalSecond * 1000;
	}

	public void addEvent(MonitorEvent event) {
		synchronized (lock) {
			if (!monitorEventList.contains(event)) {
				monitorEventList.add(event);
			}
		}
	}

	public void removeEvent(MonitorEvent event) {
		synchronized (lock) {
			if (monitorEventList.contains(event)) {
				monitorEventList.remove(event);
			}
		}
	}

	public void removeAllEvent() {
		synchronized (lock) {
			monitorEventList.clear();
		}
	}

	/**
	 * 监听主方法，每隔一段间隔触发事件列表
	 */
	public void run() {
		if (isMonitor) {
			return;
		}
		isMonitor = true;
		try {
			while (isMonitor) {

				synchronized (lock) {
					for (Iterator it = monitorEventList.iterator(); it
							.hasNext();) {
						MonitorEvent event = (MonitorEvent) it.next();
						event.fireEvent();
					}
				}
				Thread.sleep(interval);

			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			isMonitor = false;
		}
	}

	/**
	 * 结束监听，并不是马上结束只是把标致设为结束
	 */
	public void end() {
		isMonitor = false;
	}

	/**
	 * 是否正在监听
	 * 
	 * @return
	 */
	public boolean isMonitor() {
		return isMonitor;
	}

	public long getInterval() {
		return interval;
	}

	public void setInterval(long interval) {
		this.interval = interval;
	}

}

应用案例1：可自动检查文件变化的Properties

1.首先定义一个“文件改变事件监听类”继承自MonitorEvent

package com.hrtc.monitor.file;

import java.io.File;
import java.io.IOException;

import com.hrtc.monitor.MonitorEvent;

/**
 * 文件改变监听类
 * Jul 30, 2008 3:07:05 PM
 */
public class FileChangeMonitorEvent extends MonitorEvent {
	private File f;
	private long lastModifiedTime;
	private long lastLength;
	private boolean isChanged = false;

	/**
	 * 
	 * @param f 需要监听的文件
	 */
	public FileChangeMonitorEvent(File f) {
		if (!f.exists()) {
			try {
				throw new IllegalArgumentException("Path "
						+ f.getCanonicalPath() + " dose't exist.");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		this.f = f;
		getFileInfo();
	}

	private void getFileInfo(){
		lastModifiedTime = f.lastModified();
		lastLength = f.length();
	}
	
	/**
	 * 如果文件已改变则触发事件
	 */
	@Override
	public void fireEvent() {
		try {
			f = f.getCanonicalFile();
			isChanged = lastModifiedTime != f.lastModified() || lastLength != f.length();
			if (isChanged) {
				super.fireEvent();
				getFileInfo();
				isChanged = false;
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 获得监听的文件
	 * @return
	 */
	public File getF() {
		return f;
	}

}

2.定义PropertiesEx类，以及内部类ReloadPropertiesListener

package com.hrtc.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

import com.hrtc.monitor.IMonitorListener;
import com.hrtc.monitor.MonitorEvent;
import com.hrtc.monitor.MonitorThread;
import com.hrtc.monitor.file.FileChangeMonitorEvent;

/**
 * 可自动加载属性变化的属性类
 * Jul 30, 2008 3:10:32 PM
 */
public class PropertiesEx {
	/**
	 * 
	 */
	private static final long serialVersionUID = -6708397622206255544L;

	private MonitorThread monitor;
	private Properties p;
	
	/**
	 * 
	 * @param intervalSecond 监听变化间隔
	 */
	public PropertiesEx(long intervalSecond) {
		monitor = MonitorThread.getInstance(intervalSecond);
	}
	
	/**
	 * 默认更新间隔为1s
	 */
	public PropertiesEx() {
		this(1);
	}

	/**
	 * 加载配置文件
	 * @param f
	 * @throws FileNotFoundException
	 * @throws IOException
	 */
	public void load(File f) throws FileNotFoundException, IOException {
		p = new Properties();
		p.load(new FileInputStream(f));
		MonitorEvent event = new FileChangeMonitorEvent(f);
		ReloadPropertiesListener listener = new ReloadPropertiesListener();
		event.addListener(listener);
		monitor.addEvent(event);
		if(!monitor.isMonitor()){
			monitor.start();
		}
		
	}

	public String getProperty(String key){
		return p.getProperty(key);
	}

	public Properties getProperties(){
		return p;
	}
	
	/**
	 * 当发生属性文件改变时重新加载属性文件

	 * listener为内部类，为了访问包含类中p成员变量和静止外部访问该类
	 * @author xuwei
	 * Jul 30, 2008 3:11:38 PM
	 */
	private class ReloadPropertiesListener implements IMonitorListener {

		public void update(MonitorEvent event) {
			FileChangeMonitorEvent fcmEvent = (FileChangeMonitorEvent) event;
			try {
				p.load(new FileInputStream(fcmEvent.getF()));
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}

	}

}

3.测试类

package com.hrtc.util;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;

import junit.framework.TestCase;

import com.hrtc.monitor.MonitorThread;

public class PropertiesExTest extends TestCase {

	protected void setUp() throws Exception {
		super.setUp();
	}

       //测试PropertiesEx中的load方法
     	public void testLoad() throws FileNotFoundException, IOException {
		System.out.println("test reload method========");
		PropertiesEx p = new PropertiesEx();
		File f = new File(PropertiesTest.class.getResource("").getPath()
				+ "test.properties");
		p.load(f);
		long t1 = System.currentTimeMillis();
		int count = 10;
		int i = 0;
		try {
                       //循环10秒，在此时间内手动修改配置文件
			while (i < count) {

				String name = p.getProperty("name");
				System.out.println(i + ": name===" + name);
				Thread.sleep(1000);

				i++;
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		long t2 = System.currentTimeMillis();
		System.out.println(t2 - t1);
	}
	
       //测试多个PropertiesEx公用同一MonitorThread
	public void testLoadMultiple() throws FileNotFoundException, IOException {
		System.out.println("test reload multiple========");
		PropertiesEx p1 = new PropertiesEx();
		File f1 = new File(PropertiesTest.class.getResource("").getPath()
				+ "test.properties");
		p1.load(f1);
		PropertiesEx p2 = new PropertiesEx();
		File f2 = new File(PropertiesTest.class.getResource("").getPath()
				+ "test1.properties");
		p2.load(f2);
		long t1 = System.currentTimeMillis();
		int count = 10;
		int i = 0;
		try {
			while (i < count) {

				String name = p1.getProperty("name");
				String value = p2.getProperty("value");
				System.out.println(i + ": " + name + "=" + value);
				Thread.sleep(1000);

				i++;
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		long t2 = System.currentTimeMillis();
		System.out.println(t2 - t1);
               //结束监听，清除监听事件 
		MonitorThread.getInstance().end();
		MonitorThread.getInstance().removeAllEvent();
	}

}

配置文件内容,与PropertiesExTest放在同一文件夹下

test.properties

name=name1

test1.properties

value=value1

总结

上面的同一个MonitorThread甚至可以用到多个不同的事件中，比如除了Properties外还可以定义如xml等其他事件监听，而只用同一个MonitorThread。另一种方案是使用代理每次访问属性时查看文件是否修改，但是效率上比不上这种。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

动态加载java类

hrtc — Mon, 14 Jul 2008 11:14:05 +0800

作者: hrtc 链接：http://hrtc.javaeye.com/blog/214510 发表时间: 2008年07月14日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

目标：

当class重新编译后无需重启JVM就能加载更新过的类

术语：

目标类：指需要动态更新的类

对于目标类的限制：

构造函数不能有参数
必须实现一个接口
只对实例方法有效(因为接口中不能有静态方法)
没有考虑全局变量(可以在重新加载时复制原对象的成员，不过目前没实现)

测试代码：

ClassManager manager = new ClassManager();
String className = "com.hrtc.test.Test";//可换成符合上述约束的类
ITest t = (ITest) manager.getInstanceProxy(className);//当然接口也要随之变化
t.test();//test只是输出一段信息

//等待size秒，在这段时间内你必须重新编译生成你的.class文件,这里是com.hrtc.test.Test.class
int size = 5;
int i = 0;
while (i < size) {
	System.out.println(i);
	i++;
	Thread.currentThread().sleep(1000);
}

t.test();//如果你修改了test输出内容则输出的内容会发生变化,此过程中没有重启jvm,也没有重新创建Test(上述代码中)

//测试动态代理和直接访问的效率，发现代理慢得多
long beginTime1 = System.currentTimeMillis();
int count = 10000;
for(int k = 0;k < count;k++){
	t.test();
}
long endTime1 = System.currentTimeMillis();


ITest t2 = new Test();
long beginTime2 = System.currentTimeMillis();
for(int k = 0;k < count;k++){
	t2.test();
}
long endTime2 = System.currentTimeMillis();

System.out.println("proxy time======="+(endTime1-beginTime1));
System.out.println("no proxy time======="+(endTime2-beginTime2));

要解决的问题及解决方法

如何重新加载类

重新加载class示例代码

/**
 * 加载某个类
 * @param c
 * @return
 * @throws IOException
 */
@SuppressWarnings( { "unchecked" })
public Class loadClass(Class c) throws IOException {
	byte[] bs = loadByteCode(c);
	Class cNew = super.defineClass(c.getCanonicalName(), bs, 0, bs.length);
	return cNew;
}

/**
 * 加载某个类的字节码
 * @param c
 * @return
 * @throws IOException
 */
private byte[] loadByteCode(Class c) throws IOException {
	int iRead = 0;
	String path = c.getResource(c.getSimpleName() + ".class").getPath();

	FileInputStream in = null;
	ByteArrayOutputStream buffer = null;
	try {
		in = new FileInputStream(path);
		buffer = new ByteArrayOutputStream();
		while ((iRead = in.read()) != -1) {
			buffer.write(iRead);
		}
		return buffer.toByteArray();
	} finally {
		FileUtility.safelyCloseInputStream(in);
		FileUtility.safelyCloseOutputStream(buffer);
	}
}

检测类变化的方法

判断类创建的时间如变化则重新加载

/**
* 保存类路径和时间
*/
private static Map mapModify = new HashMap();

private boolean hasChanged(Class c) throws IOException {
	boolean isChanged = false;
	String path = c.getResource(c.getSimpleName() + ".class").getPath();
	File f = new File(path);
	if (f.exists()) {
		Date newDate = new Date(f.lastModified());
		Date oldDate = null;
		String key = f.getCanonicalPath();
		if (mapModify.containsKey(key)) {
			oldDate = (Date) mapModify.get(key);
		} else {
			oldDate = firstDate;
		}
		isChanged = oldDate.compareTo(newDate) < 0;
		if (isChanged) {
			mapModify.put(key, newDate);
		}
	}
	return isChanged;
}

检测类变化的时机

创建类时检查

/**
 * 如果class文件重新生成过会自动加载
 * 
 * @param name
 * @return
 * @throws InstantiationException
 * @throws IllegalAccessException
 * @throws ClassNotFoundException
 * @throws IOException
 */
public Object getInstance(String name) throws InstantiationException,
		IllegalAccessException, ClassNotFoundException, IOException {
	Class c = Class.forName(name);
	Class cNew = reloadClass(c);
	if (cNew == null) {
		cNew = c;
	}
	Object o = cNew.newInstance();
	return o;
}

public synchronized Class reloadClass(Class c) throws IOException {
	Class cNew = null;
	if (hasChanged(c)) {
		cNew = loadClass(c);
	}
	return cNew;
}

调用方法时检查

创建代理对象，自定义方法拦截器，intercept为方法拦截器中的一个方法如下

private Object target;

/**
 * 在调用类时判断该类是否重新编译过，如编译过则调用新类的方法
 */
public Object invoke(Object proxy, Method method, Object[] args)
		throws Throwable {
	Object targetObject = null;
	Class c = target.getClass();
	Class cNew = manager.reloadClass(c);
	if (cNew == null) {
		targetObject = target;
	} else {
		targetObject = cNew.newInstance();
		this.setTarget(targetObject);
	}
	Object returnValue = method.invoke(targetObject, args);
	return returnValue;
}


public void setTarget(Object target) {
	this.target = target;
}

如何更新原来已创建的对象

当class发生改变时可以更新生成新的Class类从而创建新的对象，但是原来已创建的对象怎么办呢，可以用委托实现，代码同上，此处拦截类其实是个委托类，他把方法转给target对象，并在类更新时重新定义target的引用，而从外部调用看是感觉不到这点的。

所有类代码

package com.hrtc.dynamic.hot;

import java.io.File;
import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import net.sf.cglib.proxy.Enhancer;

import com.hrtc.dynamic.proxy.DynamicProxyFactory;
import com.hrtc.test.ITest;
import com.hrtc.test.Test;

/**
 * 创建可以动态更新的java对象

 * 限制:构造函数不能有参数
 * 必须实现一个接口
 * 只能有实例方法(因为接口中不能有静态方法)
 * @author xuwei
 * Jul 9, 2008 12:01:00 PM
 */
public class ClassManager {
	/**
	 * 保存类路径和时间
	 */
	private static Map mapModify = new HashMap();
	/**
	 * 该类被加载时的时间
	 */
	private static Date firstDate = new Date();

	/**
	 * 如果class文件重新生成过会自动加载,只有重新创建才会更新
	 * 
	 * @param name
	 * @return
	 * @throws InstantiationException
	 * @throws IllegalAccessException
	 * @throws ClassNotFoundException
	 * @throws IOException
	 */
	public Object getInstance(String name) throws InstantiationException,
			IllegalAccessException, ClassNotFoundException, IOException {
		Class c = Class.forName(name);
		Class cNew = reloadClass(c);
		if (cNew == null) {
			cNew = c;
		}
		Object o = cNew.newInstance();
		return o;
	}

	/**
	 * 创建代理对象,如果class文件重新生成过会自动加载,调用原先以实例化的方法时也会更新类
	 * 
	 * @param name
	 * @return
	 * @throws InstantiationException
	 * @throws IllegalAccessException
	 * @throws ClassNotFoundException
	 * @throws IOException
	 */
	public Object getInstanceProxy(String name) throws InstantiationException,
			IllegalAccessException, ClassNotFoundException, IOException {
		Object target = getInstance(name);

		DynamicProxyFactory factory = new DynamicProxyFactory(
				new HotInvocationHandler(this));

		return factory.newProxyInstance(target);
	}

	/**
	 * 重新加载类
	 * 
	 * @param c
	 * @return
	 * @throws IOException
	 */
	public synchronized Class reloadClass(Class c) throws IOException {
		Class cNew = null;
		if (hasChanged(c)) {
			cNew = loadClass(c);
		}
		return cNew;
	}

	private boolean hasChanged(Class c) throws IOException {
		boolean isChanged = false;
		String path = c.getResource(c.getSimpleName() + ".class").getPath();
		File f = new File(path);
		if (f.exists()) {
			Date newDate = new Date(f.lastModified());
			Date oldDate = null;
			String key = f.getCanonicalPath();
			if (mapModify.containsKey(key)) {
				oldDate = (Date) mapModify.get(key);
			} else {
				oldDate = firstDate;
			}
			isChanged = oldDate.compareTo(newDate) < 0;
			if (isChanged) {
				mapModify.put(key, newDate);
			}
		}
		return isChanged;
	}

	private Class loadClass(Class c) throws IOException {
		ClassLoaderAdvisor classLoader = new ClassLoaderAdvisor();
		Class cNew = classLoader.loadClass(c);
		return cNew;
	}

	public static void main(String[] args) throws IOException,
			InstantiationException, IllegalAccessException,
			ClassNotFoundException, InterruptedException {
		ClassManager manager = new ClassManager();
		String className = "com.hrtc.test.Test";
		ITest t = (ITest) manager.getInstanceProxyJAVA(className);
		t.test();

		int size = 5;
		int i = 0;
		while (i < size) {
			System.out.println(i);
			i++;
			Thread.currentThread().sleep(1000);
		}

		t.test();

		i = 0;
		while (i < size) {
			System.out.println(i);
			i++;
			Thread.currentThread().sleep(1000);
		}

		t.test();
		
		long beginTime1 = System.currentTimeMillis();
		int count = 10000;
		for(int k = 0;k < count;k++){
			t.test();
		}
		long endTime1 = System.currentTimeMillis();
		
		
		ITest t2 = new Test();
		long beginTime2 = System.currentTimeMillis();
		for(int k = 0;k < count;k++){
			t2.test();
		}
		long endTime2 = System.currentTimeMillis();
		
		System.out.println("proxy time======="+(endTime1-beginTime1));
		System.out.println("no proxy time======="+(endTime2-beginTime2));
		

	}
}

package com.hrtc.dynamic.hot;

import java.lang.reflect.Method;

import com.hrtc.dynamic.proxy.DefaultInvocationHandler;

/**
 * 拦截java方法，更新新的类
 * @author xuwei
 * Jul 9, 2008 12:02:26 PM
 */
public class HotInvocationHandler extends DefaultInvocationHandler {

	private ClassManager manager;

	public HotInvocationHandler(ClassManager manager) {
		this.manager = manager;
	}

	/**
	 * 在调用类时判断该类是否重新编译过，如编译过则调用新类的方法
	 */
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object targetObject = null;
		Class c = target.getClass();
		Class cNew = manager.reloadClass(c);
		if (cNew == null) {
			targetObject = target;
		} else {
			targetObject = cNew.newInstance();
			this.setTarget(targetObject);
		}
		Object returnValue = method.invoke(targetObject, args);
		return returnValue;
	}

}

package com.hrtc.dynamic.hot;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

import com.hrtc.util.FileUtility;

public class ClassLoaderAdvisor extends ClassLoader {
	public ClassLoaderAdvisor() {
	}

	public ClassLoaderAdvisor(ClassLoader parentLoader) {
		super(parentLoader);
	}

	/**
	 * 加载某个类
	 * @param c
	 * @return
	 * @throws IOException
	 */
	@SuppressWarnings( { "unchecked" })
	public Class loadClass(Class c) throws IOException {
		byte[] bs = loadByteCode(c);
		Class cNew = super.defineClass(c.getCanonicalName(), bs, 0, bs.length);
		return cNew;
	}

	/**
	 * 加载某个类的字节码
	 * @param c
	 * @return
	 * @throws IOException
	 */
	private byte[] loadByteCode(Class c) throws IOException {
		int iRead = 0;
		String path = c.getResource(c.getSimpleName() + ".class").getPath();

		FileInputStream in = null;
		ByteArrayOutputStream buffer = null;
		try {
			in = new FileInputStream(path);
			buffer = new ByteArrayOutputStream();
			while ((iRead = in.read()) != -1) {
				buffer.write(iRead);
			}
			return buffer.toByteArray();
		} finally {
			FileUtility.safelyCloseInputStream(in);
			FileUtility.safelyCloseOutputStream(buffer);
		}
	}
}

package com.hrtc.dynamic.proxy;

import java.lang.reflect.Proxy;

/**
 * java代理工厂实现
 * @author xuwei
 * Jul 9, 2008 12:02:48 PM
 */
public class DynamicProxyFactory {
	/*
	 * 方法处理者
	 */
	private DefaultInvocationHandler invocationHandler;

	public DynamicProxyFactory() {
		this(null);
	}

	/**
	 * 
	 * @param invocationHandler
	 */
	public DynamicProxyFactory(DefaultInvocationHandler invocationHandler) {
		if (invocationHandler == null) {
			this.invocationHandler = new DefaultInvocationHandler();
		} else {
			this.invocationHandler = invocationHandler;
		}
	}

	/**
	 * 创建代理对象
	 * @param target
	 * @return
	 */
	public Object newProxyInstance(final Object target) {
		invocationHandler.setTarget(target);
		Object proxy = Proxy.newProxyInstance(target.getClass()
				.getClassLoader(), target.getClass().getInterfaces(),
				invocationHandler);
		return proxy;
	}
}

package com.hrtc.dynamic.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 默认代理处理类
 * @author xuwei
 * Jul 9, 2008 12:03:00 PM
 */
public class DefaultInvocationHandler implements InvocationHandler {

	/**
	 * 目标对象
	 */
	protected Object target;

	public DefaultInvocationHandler() {
	
	}

	/**
	 * 处理方法
	 */
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("before invoke");
		Object returnValue = method.invoke(target, args);
		System.out.println("after invoke");
		return returnValue;
	}

	public Object getTarget() {
		return target;
	}

	public void setTarget(Object target) {
		this.target = target;
	}
}

package com.hrtc.test;

public interface ITest {
	void test();
}

package com.hrtc.test;

public class Test implements ITest {
	public void test() {
		System.out.println("call test method:modify here");
	}
}

目前为止上述讲到的限制没有解决，不知道有没有解决方案？

本文参考了http://www.javaworld.com/javaworld/jw-06-2006/jw-0612-dynamic.html?page=1

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

java servletfilter实现全站动转静

hrtc — Wed, 25 Jun 2008 18:27:06 +0800

作者: hrtc 链接：http://hrtc.javaeye.com/blog/207980 发表时间: 2008年06月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

原理及特点

特点：大小仅9k，没有用额外包，jdk1.4环境开发通用性强，配置简单

原理：利用filter拦截请求的jsp，如已生成静态页面且没到刷新时间则重定向静态页面，否则生成静态页面。

* 生成策略:当前时间与上次修改时间的差值大于间隔时间则重新生成
* 定向策略:如果是拦截的页面并以生成静态页面则重定向的静态页面
* 静态页面文件名生成策略:源文件名+参数的md5码

配置方法

1.引入所需包(见附件dynamictostatic_0.8.jar)

2.web.xml里配置filter，如下



	
		Dynamic2StaticFilter
		com.hrtc.d2s.Dynamic2StaticFilter

		
			刷新频率单位秒
			refresh_time
			600
		
		
			生成静态页面线程池大小
			threadsize
			10
		
		
			输出流缓存大小单位字节
			buffersize
			8192
		
		
			生成的页面存放于相对于应用根路径
			static_folder
			/html
		
		
			静态文件扩展名
			static_extend_name
			.html
		
		
			临时文件扩展名
			temp_extend_name
			.temp
		
		
			http head参数名
			request_head_name
			requesttype
		
		
			http head参数值
			request_head_value
			download
		
	

	
		Dynamic2StaticFilter
		*.jsp
	

	
		index.jsp

配置完毕，随便访问你网站的页面看效果吧。

这是今天自己想到的方法，与大家互相学习一下，希望大家能提出改进意见。

源码见附件，在windows平台上开发

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

java书籍推荐

hrtc — Wed, 04 Jun 2008 17:07:15 +0800

作者: hrtc 链接：http://hrtc.javaeye.com/blog/200166 发表时间: 2008年06月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

基础 L]d@D0.Z
1.java2核心卷抽 L\NZDkd
X5Y `(/V 这本看完，就上手java了
2.java语言规范 4q13xX
这本完全讲java语言规范，可谓内功心法，进国际性外企必看(指没工作经验的人)，外语加这个就ok了。 b$O_L4CP
(YHvGGr
面向对象 zN+*R;Ds
1.java与模式 .3<IOtD=
看完这本你就正真了解了面向对象，但有可能会看不懂，看不懂是因为时机未到，别人告诉我的，不过我觉得蛮有道理的。 `%M-7n9Y
2.gof 设计模式 vM7v�f6
这本书被奉为经典之作，其中的原理讲的非常好，java与模式等模式类书籍都是围绕这个展开的，那为什么要看java与模式呢，因为那本容易看点，这本比较抽象，当你基本掌握了java与模式后就可以从更高的层面开始看这本书。 ]1d,O^S
3.重构 pp]_/46nN
设计模式是最终目标，现在我们有了目标，但是仍不知道这一过程如何实现，为什么这样说呢，有些程序有一定的复杂性，不能一眼就看出用哪个模式可以解决该问题，比如一个素数算法等等，你在写之前能看出用什么模式吗？重构是达到这一目标的手段之一，在重构过程中我们会更加接近目标。不过看这本书要有耐心。
4.UML与模式应用 P:(EU s}0
学习面向对象不学uml是不行的。这本书正在看，看完再写感受。 3`k[!!
)ojx_3j8
全面认识软件工程 - LiPHHX<
1.人月神话 t0e{|du
书老了点，但是讲的还不错。 1iJ0Hut}d
2.人件 RQ^m6)BTo
讲人在软件开发中的重要性，这本还没看，准备买一本。 j9URl$T:
3.敏捷软件开发 7deAr$?Wx
这本书讲的很全，各种思想都讲了，值得推荐。 ]6{(Hjt
=Kc|C~g
规范篇 2J;kD2"!
1.servlet jsr规范 vG�]GQ#
开发网页这个不得不看 lSH ZV Fd
2.http协议 "^;#f+0
想真正了解服务器如何实现的推荐看下 9wL!D3e {Q
3.tcp/ip协议 `6&`wKz
8 AFMn[{ 传世经典，推荐有c基础的看下
A9 U5,mOz
高级篇 5XDgs|8
1.j2ee devleopment without ejb 0HqPyM13Q
这本书非常好，强烈推荐，最好先对ejb有了解 1\/{#c
2.软件架构设计 Nj+a2[
对面向对象的软件架构设计讲的比较清晰，设计师必看。 6 jmrD�
3.j2ee核心模式 j !`B'{cH
准备看 GQb i$kl
4.企业架构模式 "?35C !
把企业应用中的问题分析的很透彻，另外感觉hibernate中的很多思想都是出自该书。
5.分析模式 S#tY@h@XV
非常好，不过比较抽象。 z`4c 4h]I

#AShbl jm+
希望大家把看过的好书也列在下面 KC#/Z2A|<

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

websphere5.1+spring2.0+struts2+hibernate3搭建总结

hrtc — Sun, 25 May 2008 16:43:37 +0800

作者: hrtc 链接：http://hrtc.javaeye.com/blog/196721 发表时间: 2008年05月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

最近搭建了一个websphere5.1+spring2.0+struts2+hibernate3的框架，因为jdk1.4加websphere5.1环境中间碰到一些问题，网上的解决方案也不全，今天搞了一整天总算搞定了，现与大家分享下。

开发工具myeclipse6，先在tomcat4 jdk4上测试，然后部署到websphere5.1上测试通过。

步骤：

1.设置编译环境为jdk1.4

2.把自己代码中所有1.5的特性都改成1.4

3.web.xml改成servlet2.3规范的

4.lib包不要配缺了就行

spring和hibernate的包都是jdk1.4编译的，不需要修改，其中cglib用的是cglib-nodep-2.1_3.jar而不是cglib-2.1_3.jar

struts2由于是jdk1.5编译的需要用retrotranslator转换，工具在struts2目录下的backport目录中，struts2-core-j4-2.0.11.1.jar和xwork-j4-2.0.4.jar已经转好了，再自己转个struts2-spring-plugin-j4-2.0.11.1.jar就可以了，最后把backport-util-concurrent-3.0.jar，retrotranslator-runtime-1.2.2.jar和你转好的包扔到lib目录下，原来的删除。

这方面网上资料还是蛮多的，不明白的可以查找下。

5.websphere5.1兼容性问题

当你成功完成上述步骤后tomcat4已经可以跑了，然后部署到websphere5.1如果没有错误的话可以运行而且后台不报错，但是页面上报XXX.action路径找不到，这个花了我好多时间才搞定，网上也没找到具体解决方案。

原因：

DefaultActionMapper类中的getUri方法：

String getUri(HttpServletRequest request) {
		// handle http dispatcher includes.
		String uri = (String) request
				.getAttribute("javax.servlet.include.servlet_path");
		if (uri != null) {
			return uri;
		}

		uri = RequestUtils.getServletPath(request);
		//System.out.println("url==========="+uri);
		//old:if (uri != null && !"".equals(uri)) {
		if (uri != null && uri.length() > 1) {
			return uri;
		}

		uri = request.getRequestURI();
		return uri.substring(request.getContextPath().length());
	}

发现上面注释掉的那句：

//System.out.println("url==========="+uri);

输出为"/",实际为"/XX/XX.action"看来是uri解析错误，猜想可能是

RequestUtils.getServletPath(request);

这个方法有bug，结果发现源代码没提供，所以只能在外层方法中改下了,重写了个过滤器。改完后成功运行。

解决方案如下，添加2个类

DefaultActionMapperCompaWebsphere51(修改了getUri后的判断)

/*
 * $Id: DefaultActionMapper.java 540141 2007-05-21 13:46:48Z mrdon $
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.struts2.dispatcher.mapper;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts2.RequestUtils;

public class DefaultActionMapperCompaWebsphere51 extends DefaultActionMapper {
	private static ActionMapper actionMapper = new DefaultActionMapperCompaWebsphere51();
	
	public static ActionMapper getActionMapper(){
		return actionMapper;
	}
	
	/**
	 * modify uri compare
	 * @param request
	 * @return
	 */
	String getUri(HttpServletRequest request) {
		// handle http dispatcher includes.
		String uri = (String) request
				.getAttribute("javax.servlet.include.servlet_path");
		if (uri != null) {
			return uri;
		}

		uri = RequestUtils.getServletPath(request);
		//System.out.println("url==========="+uri);
		//old:if (uri != null && !"".equals(uri)) {
		if (uri != null && uri.length() > 1) {
			return uri;
		}

		uri = request.getRequestURI();
		return uri.substring(request.getContextPath().length());
	}

}

FilterDispatcherCompaWebsphere51(调用自己刚才重写的DefaultActionMapperCompaWebsphere51)

/*
 * $Id: FilterDispatcherCompatWeblogic61.java 476075 2006-11-17 08:28:30Z mrdon $
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.struts2.dispatcher;

import java.io.IOException;

import javax.servlet.FilterChain;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts2.RequestUtils;
import org.apache.struts2.dispatcher.mapper.ActionMapper;
import org.apache.struts2.dispatcher.mapper.ActionMapping;
import org.apache.struts2.dispatcher.mapper.DefaultActionMapperCompaWebsphere51;

import com.opensymphony.xwork2.util.profiling.UtilTimerStack;

public class FilterDispatcherCompaWebsphere51 extends FilterDispatcher {
	private static boolean serveStatic;

	public void doFilter(ServletRequest req, ServletResponse res,
			FilterChain chain) throws IOException, ServletException {
		HttpServletRequest request = (HttpServletRequest) req;
		HttpServletResponse response = (HttpServletResponse) res;
		ServletContext servletContext = getServletContext();

		String timerKey = "FilterDispatcher_doFilter: ";
		try {
			UtilTimerStack.push(timerKey);
			request = prepareDispatcherAndWrapRequest(request, response);
			ActionMapping mapping;
			ActionMapper actionMapper = DefaultActionMapperCompaWebsphere51.getActionMapper();
			try {
				mapping = actionMapper.getMapping(request, dispatcher
						.getConfigurationManager());
			} catch (Exception ex) {
				log.error("error getting ActionMapping", ex);
				dispatcher.sendError(request, response, servletContext,
						HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex);
				return;
			}

			if (mapping == null) {
				// there is no action in this request, should we look for a
				// static resource?
				String resourcePath = RequestUtils.getServletPath(request);

				if ("".equals(resourcePath) && null != request.getPathInfo()) {
					resourcePath = request.getPathInfo();
				}

				if (serveStatic && resourcePath.startsWith("/struts")) {
					String name = resourcePath.substring("/struts".length());
					findStaticResource(name, request, response);
				} else {
					// this is a normal request, let it pass through
					chain.doFilter(request, response);
				}
				// The framework did its job here
				return;
			}

			dispatcher
					.serviceAction(request, response, servletContext, mapping);

		} finally {
			try {
				ActionContextCleanUp.cleanUp(req);
			} finally {
				UtilTimerStack.pop(timerKey);
			}
		}
	}

	private static final Log log = LogFactory
			.getLog(FilterDispatcherCompaWebsphere51.class);

}

修改web.xml中原来的struts2的filter类

        struts2

            org.apache.struts2.dispatcher.FilterDispatcherCompaWebsphere51

之后就可以放在tomcat和websphere5.1上运行了。

本文只说明了遇到的一些问题的解决方案，如何配置struts2或spring或hibernate可以参考官方资料。

如有不明白的可以留言。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Better Builds with Maven学习笔记3

hrtc — Thu, 10 Apr 2008 18:55:36 +0800

作者: hrtc 链接：http://hrtc.javaeye.com/blog/181422 发表时间: 2008年04月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

3.10 创建应用程序的Web站点

    既然你已经经过了构建，测试，部署Proficio的过程，是时候让你看一下怎样为应用程序创建web站点。对于像Proficio的应用程序来说，建议在顶层目录创建源代码目录来存储资源以此生成web站点，这是默认的情况。如果你看一下，你将会发现如下的结构：
    proficio
    ----proficio-api
    ----proficio-cli
    ----proficio-core
    ----proficio-model
    ----proficio-stores
    --------proficio-store-memory
    --------proficio-store-xstream
    --------pom.xml
    ----src
    --------site
    ------------apt
    ----------------index.apt
    ------------fml
    ----------------proficio.fml
    ------------resources
    ----------------images
    --------------------flow.png
    ------------site.xml
    ----pom.xml
    生成web站点的所有东西都在src/site目录下。在src/site目录里每一种支持的文档格式都有有一个子目录和站点描述。Maven支持许多文档格式以提供各种各样的需求。
    目前为止，良好的支持如下：
        XDOC，一个简单的被Apache广泛使用的XML格式
        APT(Almost Plain Text)，wiki-like格式，允许你快速输出简单的文档结构
        FML，FAQ格式，一个简单的管理FAQs的xml格式
        简单DocBook格式
    限制支持：
        Twiki格式，一种流行的Wiki标记格式
        汇合(Confluence)格式，另一种流行的Wiki标记格式
        DocBook格式
    在后面的章节我们会看一下几个支持良好的格式，但是你应该熟悉站点描述，使用如下配置
        配置banner外观
        为站点配置皮肤
        配置出版日期
        配置banner下的链接
        配置放置在元素中的额外信息
        配置在导航栏生成的菜单
        配置项目报告外观
    如果你看一下Proficio应用程序的src/site目录和其中的站点描述，你将看到如下：


            Proficio
            http://maven.apache.org/


            Proficio
            http://maven.apache.org/images/apache-maven project.png


            org.apache.maven.skins
            maven-default-skin
            1.0-SNAPSHOT

            ${reports}


    这是一个相当标准的描述，你应该知道站点描述中每个元素的意思，如下：
        站点描述                元素描述
        bannerLeft和bannerRight        这个元素有一个name，href和可选的用于images的src子元素
        skin                和dependency的机制相似，用来配置站点皮肤
        publishDate            用SimpleDateFormat格式化日期
        body/links            定义在banner下的链接，每一项有一个name和href属性
        body/head            允许你在页面的head元素中插入任何东西。你可能会像加入metadata或者用来激活Google统计功能的script片段
        body/menu            控制在导航栏的菜单，你可以有任意多个菜单，每个菜单可以有任意多个连接
        body/${reports}            包含的${reports}引用控制是否显示站点报告。你可能会排除${reports}引用来形成一个干净的站点文档

    Maven的一个受欢迎的特征就是可以轻易的生成标准报告。你只要简单的在你的descriptor中包括${reports}，站点报告就会自动显示。标准的项目信息报告由如下部分组成：
        依赖报告(Dependencies Report)
        邮件列表报告(Mailing Lists Report)
        连续累计报告(Continuous Integration Report)
        源码库报告(Source Repository Report)
        问题跟踪(Issue Tracking Report)
        项目团队报告(Project Team Report)
        许可(License)
    虽然标准报告是有用的，但是你可能想要自定义项目报告。报告创建和展示由POM中的build/reports元素控制。你可能想要关于报告更多的选择，要这样做你需要列出每个你想包括的站点生成部分的报告，你可以像下面这样配置插件：

        [...]

            [...]


                    org.apache.maven.plugins
                    maven-project-info-reports-plugin



                                dependencies
                                project-team
                                mailing-list
                                cim

                                license
                                scm





            [...]

        [...]

    配好了配置文件以后你就可以生成站点了，命令如下：
    mvn site
    究竟效果如何自己看一下生成的目录结构吧
    如果你有想把pdf或图片等资源引入到你的文档中，你可以使用src/site/resources来存储他们，当站点生成时src/site/resources中的内容将被处理。src/site/resources下的任何文件或目录都会被包含在输出中，记住这个规则你可以为你的站点添加任意资源。

未完待续

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Better Builds with Maven学习笔记2

hrtc — Thu, 10 Apr 2008 18:50:28 +0800

作者: hrtc 链接：http://hrtc.javaeye.com/blog/181421 发表时间: 2008年04月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

第三章用Maven创建应用程序

3.1 介绍

现在你将钻研的更深一些，在这部分你将学习通过一个管理FAQ应用程序的真实例子学习Maven的最佳实践和高级应用。这个应用程序名字叫Proficio，该名字来自于拉丁语帮助的意思。

3.2 建立应用程序目录结构

    Proficio的模块组成
        Proficio API
            Proficio的应用程序接口
        Proficio CLI
            提供命令行接口
        Proficio Core
            接口实现
        Proficio Model
            Proficio的数据模型
        Proficio Stores
            存放存储模块，Proficio有一个简单的基于内存(memory-based)的仓库和一个基于流(XStream-based)的仓库
    查看Proficio的顶层POM时，你会在modules元素下看到所有的子模块构成了Proficio应用程序。一个子模块是另一个Maven项目的引用。如下

        4.0.0
        com.devzuz.mvnbook.proficio
        proficio
        pom
        1.0-SNAPSHOT
        Maven Proficio
        http://maven.apache.org
        [...]

            proficio-model
            proficio-api
            proficio-core
            proficio-stores
            proficio-cli

        [...]

    上述pom中的一个特征就是版本属性为1.0-SNAPSHOT。对于一个应用程序来说，通常会一起发布许多子模块，这对于所有模块都有一个公共版本来说是很有意义的。建议你的应用程序的所有子模块都用顶层POM的版本号。
    你应该注意packaging元素，在这个例子中它的值为pom。对于包括子模块的POMs来说，packaging类型必须被设置成pom，这告诉Maven你打算构建一个多模块的结构。目录结构如下
    proficio
    ----proficio-api
    ----proficio-cli
    ----proficio-core
    ----proficio-model
    ----proficio-stores
    --------proficio-store-memory
    --------proficio-store-xstream
    --------pom.xml
    ----pom.xml
    各个模块的打包类型
    Module        Packaging
    proficio-api    jar
    proficio-cli    jar
    proficio-core    jar
    proficio-model    jar
    proficio-stores    pom
    在大多数时候打包类型为默认的jar，但是proficio-stores这个模块类型为pom，下面是这个模块的POM


            com.devzuz.mvnbook.proficio
            proficio
            1.0-SNAPSHOT

        4.0.0
        proficio-stores
        Maven Proficio Stores
        pom

            proficio-store-memory
            proficio-store-xstream


    当你看到packaging类型为pom时，意味着该项目/模块有多个子模块构成

3.3 使用项目继承

    项目继承是Maven的一项重要特征之一。使用项目继承允许你在同一个位置声明你的组织信息，部署信息或者你的通用依赖性。你可能会注意到每个子POMs的头部会像下面这样
    [...]

        com.devzuz.mvnbook.proficio
        proficio
        1.0-SNAPSHOT

    [...]
    这是一个pom片段，让你利用顶层POM的资源，定义了从哪个项目继承。让我们来看一个例子。
    如果你观察一下Proficio的顶层POM，你会发现在依赖部分有一个JUnit3.8.1的声明。在这个例子中假设Junit将被用来测试所有子项目。所以，通过继承顶层POM的依赖，在你的任何子POMs中你将不需要再次声明这个依赖。这个依赖定义如下：

        [...]


                junit
                junit
                3.8.1
                test


        [...]

    让我们来看看每个子POM发生了什么，每个子POM都继承了顶层POM的依赖部分。所以如果你看一下proficio-core模块的POM你会发现如下(注意：没有JUnit的依赖声明)


            com.devzuz.mvnbook.proficio
            proficio
            1.0-SNAPSHOT

        4.0.0
        proficio-core
        jar
        Maven Proficio Core


                com.devzuz.mvnbook.proficio
                proficio-api


                org.codehaus.plexus
                plexus-container-default



    为了让你看见继承的过程，你需要使用快捷工具mvn help:effective-pom命令。这个命令将让你看到最终目标POM的结果。进入proficio-core模块目录运行上述命令，你将会看到JUnit的依赖。

        [...]

            [...]

                junit
                junit
                3.8.1
                test

            [...]

        [...]

    你会发现用mvn help:effective-pom命令输出的pom比预想的大很多，因为这个命令输出了合并后的整个层次结构的pom，当你遇到问题时这个命令是非常有帮助的。

3.4 管理依赖

    当你构建应用程序时，有许多依赖需要管理而且随着时间的增长依赖也不断的增长，使依赖管理变得复杂。Maven管理依赖的策略是通过把项目的继承机制和在POM中定义的依赖管理元素相结合来处理这个问题。
    当你写的应用程序由许多独立的项目组成，很可能其中一些项目共享相同的依赖。当这个发生时，要保证所有的相同版本的依赖被你的所有项目使用，这样才能保证你的应用程序正常工作。为了在跨多个项目管理你的依赖，你使用顶层POM中的依赖管理部分来管理依赖。让我们来看一下如下部分

        [...]



                    com.devzuz.mvnbook.proficio
                    proficio-model
                    ${project.version}


                    com.devzuz.mvnbook.proficio
                    proficio-api
                    ${project.version}


                    com.devzuz.mvnbook.proficio
                    proficio-store-memory
                    ${project.version}


                    com.devzuz.mvnbook.proficio
                    proficio-store-xstream
                    ${project.version}


                    com.devzuz.mvnbook.proficio
                    proficio-core
                    ${project.version}


                    org.codehaus.plexus
                    plexus-container-default
                    1.0-alpha-9



        [...]

    注意：${project.version}是指顶层POM的版本元素，也就是应用程序版本
    就像上面的依赖管理部分看到的，我们有几个Proficio依赖和一个Plexus依赖注入容器的依赖。在包括依赖元素的dependencyManagement元素和在POM顶层dependencies依赖元素有一个重要的区别：dependencyManagement只是用来定义引用的版本号，他自己不会作用于依赖层次图，而顶层dependencies元素会影响层次图。如果你观察一下proficio-api模块里的POM，你会发现依赖声明部分如下:

        [...]


                com.devzuz.mvnbook.proficio
                proficio-model



    这个依赖的版本来源于顶层POM的dependencyManagement元素。只有在子项目的依赖没有声明版本时定义在祖先项目中的dependencyManagement依赖才会生效。

3.5 使用快照(Snapshots)

    当你开发拥有多个模块的应用程序时，在某些情况下每个模块更新都很频繁，需要不断的获取最新子模块(原文：it is usually the case that each of the modules are in flux)。你的APIs会改变，你的实现会改变和更新，你可能还会重构。你的构建系统需要以简单的方式来实时更新（获取最新子模块以构建项目），这就是Maven快照出现的原因。Maven中快照是用来获得最新源代码生成的产品。如果你看一下顶层Proficio的POM，你会发现快照版本定义如下:

            [...]
            1.0-SNAPSHOT



                        com.devzuz.mvnbook.proficio
                        proficio-model
                        ${project.version}


                        com.devzuz.mvnbook.proficio
                        proficio-api
                        ${project.version}


                        org.codehaus.plexus
                        plexus-container-default
                        1.0-alpha-9



            [...]

    定义一个快照版本意味着Maven将寻找最新的依赖。快照假设依赖是被改变的，所以Maven将企图获取他们。默认情况下Maven会按日生成一次快照，但是你可以使用-U命令强迫更新。控制快照如何工作将在第七章介绍。当你定义了一个非快照的依赖，Maven将会下载依赖一次而不会再去获取他。

3.6 解决依赖冲突和使用版本范围

    当使用Maven2.0时，你只要简单的定义依赖，Maven会计算所有的依赖图。然而，当生成依赖图时，有2个或多个产品依赖不同版本号的特定依赖是不可避免的。在这种情况下依赖必须选择提供的版本。
    在Maven中版本选择会以离版本树最近的优先选择，然而这个是有限制的：
    1) 这个版本可能没有其他依赖所需要的特征
    2) 如果选择了多个版本，可能会出现不确定的结果
    要手动解决这些冲突，你可以移除版本树中不正确的版本或者你可以用正确的版本覆盖。移除不正确的版本要求识别出不正确的版本源代码，通过运行-X标记(详情见6.9)，例如：如果你在proficio-core模块中使用mvn -X test，输出将包括如下:
    proficio-core:1.0-SNAPSHOT
        junit:3.8.1 (selected for test)
        plexus-container-default:1.0-alpha-9 (selected for compile)
            plexus-utils:1.0.4 (selected for compile)
            classworlds:1.1-alpha-2 (selected for compile)
            junit:3.8.1 (not setting scope to compile; local scope test wins)
        proficio-api:1.0-SNAPSHOT (selected for compile)
            proficio-model:1.0-SNAPSHOT (selected for compile)
            plexus-utils:1.1 (selected for compile)
    在执行mvn -X test之前必须保证构建已经进行，所以最好先执行mvn install保证项目已经被安装到本地库中。
    一旦版本路径已经识别出来，你可以通过在dependency中增加exclusion来排除对象图中的依赖。在上面的例子中plexus-utils出现了2次，Proficio需要1.1版本的。要保证这个，只需修改在proficio-core/pom.xml中的plexus-container-default依赖如下：

        org.codehaus.plexus
        plexus-container-default
        1.0-alpha-9


            org.codehaus.plexus
            plexus-utils



    这样就保证了Maven会忽略依赖图中1.0.4版本的plexus-utils，而1.1版本的会被使用。
    另一种保证特定版本依赖的方式是直接在POM中指定如下：


            org.codehaus.plexus
            plexus-utils
            1.1
            runtime


    然而这个方式是不建议使用的，除非你制造的产品不需要被其他程序依赖(例如:WAR包)。原因是这样做曲解了依赖图，使得难以被依赖。
    你会注意到这里使用了runtime范围。这是因为这个例子中依赖被用在打包而不是编译。
    上述2个方法都不是理想的，但是它能保证改进你的依赖的质量，降低构建的风险问题。如果你要发布框架的库，发布给许多人是非常重要的，这就要使用版本范围而不是指定一个特定的。
    当版本声明为1.1就像上一个例子中的plexus-utils，这表明首选的版本是1.1，但是其他版本可能也是可接受的。Maven不知道哪些版本能运行，所以为了防止与另一个版本冲突，Maven假设所有的版本都是有效的，使用先前描述的最近依赖技术来决定选择哪个版本。用版本范围的定义方式如下：

        org.codehaus.plexus
        plexus-utils
        [1.1,)

    上述的配置意味着，当使用最近依赖技术防止冲突时，其版本范围必须匹配。如果最近版本不匹配，则用第二近的，以此类推。如果都不匹配，或者没有冲突，则会使用大于1.1的版本。这时库中大于1.1的最新版本将会被使用。
    版本范围的例子：
    Range        Meaning
    (,1.0]        Less than or equal to 1.0
    [1.2,1.3]    Between 1.2 and 1.3 (inclusive)
    [1.0,2.0)    Greater than or equal to 1.0,
    [1.5,)        Greater than or equal to 1.5
    (,1.1),(1.1,)    Any version, except 1.1
    使用更精确的定义可以使依赖机制更可靠和降低异常的数量。然而你不应该定义的太过精确。因为，如果2个版本范围没有交集，构建过程会失败。
    要理解版本范围如何工作，理解版本比较是必须的。如下所示说明了版本如何分割：
    主版本号(Major)    次版本号(Minor)    修订号(Bug fix)    限定符(Qualifier)    构建号(Build Number)
    1.        0.        1-        20060211.131141-    1
    连起来就是1.0.1-20060211.131141-1
    正如你看到的一个版本被拆分成5部分：主版本号，次版本号，修订号以及限定符和最后的构建号。对于当前的版本模式，一个快照(如前文提到的)允许有限定符和构建号。对于正规的版本，你可以只提供限定符或者只提供构建号。限定符的意图是表明一个产品在发布之前的版本(例如：alpha-1,beta-1,rc1)。对于snapshot的限定符，必须为文本"snapshot"或者时间戳。上例中的快照版本生成于2006-11-02 13:11:41。构建号是一个在发布后表明构建补丁的数字。
    关于排序，这些元素被用来顺序决定哪个比较新：首先是主版本号，然后如果主版本号相同则比较次版本号，第三是修订号，第四是限定符(使用字符串比较),最后是构建号。一个带限定符的版本比不带限定符的版本旧。例如1.2-beta比1.2旧。一个带构建号的版本比不带构建号的版本新。例如：1.2-beta-1比1.2-beta新。在某些情况下版本不会匹配这个语法。在那些情况下，2个版本完全用字符串比较。
    对于版本范围比较也一样。如果你使用的版本范围是[1.1,)，版本1.1和1.2-beta-1存在于库中，则1.2-beta-1会被选择。一般这是不希望的，为了避免这种情况，你必须组织你的发布，避免用命名规则导致上述的行为或者使用不同的库来存放你希望的版本产品。
    无论你发布最终版本还是发布里程碑式的测试版本，你应该把它们部署到库中。这能保证测试版本只有在项目明确声明为快照时才使用范围。
    最后一个需要注意的地方是当使用范围时如何决定版本更新。这个机制和快照一样。默认情况下，每天从库中更新一次。然而，可以配置更多的时间间隔才更新或者使用-U选项强制更新。配置间隔的例子如下：

        [...]

            interval:60

3.7 利用构建生命周期

    在第二章里，Maven被描述成为通过良好定义的方式和过程(也就是Maven的默认构建生命周期)与可执行插件交互的框架。Maven的默认构建生命周期满足于大多数项目。但是，有些项目将有不同的需求，需要在默认生命周期基础上再增加一些阶段来满足需求。
    例如，Proficio有一个从模型生成源代码的需求。Maven允许通过插件声明来把它绑定到默认生命周期的标准阶段——generate-sources阶段。
    Maven中的插件根据特定的任务创建，意味着插件被绑定到默认构建生命周期。在Proficio中，Modello插件用来为数据模型生成源代码。如果你观察一下proficio-model的POM你会发现其中有一个plunins元素：


            com.devzuz.mvnbook.proficio
            proficio
            1.0-SNAPSHOT

        4.0.0
        proficio-model
        jar
        Proficio Model



                    org.codehaus.modello
                    modello-maven-plugin
                    1.0-alpha-5



                                java




                        1.0.0
                        false
                        src/main/mdo/proficio.mdo





    这个和你在第二章中看到的声明maven-compiler-plunin非常相似，但是你会看到多出了executions元素。Maven中的插件可以有多个目标，所以你需要通过指定在executions元素中的goal来定义你要运行插件中的哪个目标。

3.8 使用Profiles

    Profiles让你在默认构建生命周期时创建环境变量来完成一些事情，如在不同平台构建，不同虚拟机构建，不同数据库测试或者引用本地文件系统。典型的，你试图尽可能封装POM来保证可移植的构建，但是有时你不得不考虑跨系统的环境变量，这就是Maven提供profiles的原因。
    Profiles在构建时修改POM，意味着可以为目标环境提供意义相同而定义不同的参数(例如，应用程序服务器的开发，测试，产品环境的根路径)。
    你可以在下面三个地方定义Profiles：
        1 Maven配置文件(默认：/.m2/settings.xml)
        2 和POM在同一文件夹下的profiles.xml文件
        3 在POM中
    要确定哪个profile优先，规则是就近原则。所以POM中的最高，然后是profiles.xml，最后是setting.xml。
    setting.xml可以影响到所有构建，所以他是全局的profiles。profiles.xml允许你使用一个单独的项目构建而不需要修改POM。基于POM的profiles是首选的,因为他们是可移植的(他们可以被发布到库中和可以被子构建继承使用)。
    由于可移植性的原因，任何不能被发布到库中的文件都不能改变基本构建。因此，在profile.xml和setting.xml中定义的profiles只允许定义：
        repositories
        pluginRespositories
        properties
    其他的都必须定义在POM的profile中，或者POM自己或者不定义。例如，如果你有一个setting.xml需要注入一个依赖，你的项目运行时确实需要那个依赖，一旦你的工程被部署到库中，这个依赖就不能被解决，因为他的依赖设置在你的本地settings.xml而库中没有。
    注意：repositories,pluginRespositories,properties也可以被定义在POM中。所以能在POM外面定义的profiles只是POM中可定义的profiles的一个子集。
    你可以在POM profile中定义如下元素：
        repositories
        pluginRepositories
        dependencies
        plugins
        properties (not actually available in the main POM, but used behind the scenes)
        modules
        reporting
        dependencyManagement
        distributionManagement
    构建元素自己可以包括如下元素：
        defaultGoal
        resources
        testResources
        finalName
    激活profiles有好几个方式：
        1 -P CLI选项，后面跟以,分割的profiles-ids，例如：
            mvn -Pprofile1,profile2 install
        2 通过Maven设置中的activeProfiles部分。例如：

                [...]


                        profile1
                        [...]



                    profile1

                [...]

        3 Profiles可以根据构建环境的检测状态自动触发。通过activation部分设定。目前这个检测被限制于前缀匹配JDK版本或者系统属性，例如：

                profile1
                [...]

                    1.4


            这个活动在JDK版本为以1.4开头时触发(例如"1.4.0_08","1.4.2_07","1.4")

                profile1
                [...]


                        debug



            这个将在定义了debug属性时触发

                profile1
                [...]


                        environment
                        test



            这个将会在定义了environment属性为test时触发
    既然你熟悉了profiles，你打算使用他们创建定制的装配件：Proficio的装配件使用基于内存的仓库和使用基于XStream的仓库。这些装配件将在proficio-cli模块中创建，profiles用来控制这些装配件的创建。
    下面是proficio-cli模块的profile定义：

        [...]




                memory



                        maven-assembly-plugin


                                src/main/assembly/assembly-store-memory.xml







                        memory





                xstream



                            maven-assembly-plugin


                                    src/main/assembly/assembly-store-xstream.xml







                        xstream





    你可以看到2个profile：一个是基于memory的另一个是xstream。在每一个profiles中你都配置了将会创建装配件的插件描述。你将注意到使用系统属性激活profiles。你应该注意下面的例子依赖的部分应该首先被执行构建，所以应该先使用顶层项目的mvn install以保证所需的组件已经被安装到本地库。
    如果你想创建基于内存的库，你应该执行：
        mvn -Dmemory clean assembly:assembly
    如果你想创建基于XStream库，你应该执行：
        mvn -Dxstream clean assembly:assembly
    上述两个装配件都被创建到目标目录，如果你在结果装配件上使用java tvf命令，你将看到基于内存的装配件只包括proficio-store-memory-1.0-SNAPSHOT.jar。这是一个非常简单的例子，但是这个例子展示了自定义生命周期profiles来适应你的需求。

3.9 部署你的应用程序

既然你有了一个应用程序装配件，你想把它尽可能多的与人分享，所以你决定部署你的应用程序装配件。
现在Maven支持好几种部署方式：包括简单的file-based部署，SSH2部署,SFTP部署，FTP部署和扩展SSH部署。为了部署，你需要配置POM中的distributionManagement元素，它通常在你的顶层POM中，所以所有子POMs可以继承这些信息。下面是通过各种部署机制来配置你的POM的例子。

3.9.1 以文件方式部署

        [...]


                proficio-repository
                Proficio Repository
                file://${basedir}/target/deploy


        [...]

3.9.2 以SSH2方式部署

        [...]


                proficio-repository
                Proficio Repository
                scp://sshserver.yourcompany.com/deploy


        [...]

3.9.3 以SFTP方式部署

    [...]


            proficio-repository
            Proficio Repository
            sftp://ftpserver.yourcompany.com/deploy


    [...]

3.9.4 以扩展SSH方式部署

    目前为止上述3中方式已经被Maven包含，所以只要distributionManagement就可以了，但是使用扩展SSH命令部署的话你不仅需要配置distributionManagement还需要一个build extension，如下

        [...]


                proficio-repository
                Proficio Repository
                scpexe://sshserver.yourcompany.com/deploy





                    org.apache.maven.wagon
                    wagon-ssh-external
                    1.0-alpha-6



        [...]

    The build extension specifies the use of the Wagon external SSH provider, which does the work of moving your files to the remote server. Wagon is the general purpose transport mechanism used throughout Maven.

3.9.5 以FTP方式部署

        [...]


            proficio-repository
            Proficio Repository
            ftp://ftpserver.yourcompany.com/deploy





                org.apache.maven.wagon
                wagon-ftp
                1.0-alpha-6



        [...]

一旦你配置好了相应的POM你可以执行下列命令来开始部署：mvn deploy

一章也显示不下，本章最后一节见下篇：http://hrtc.javaeye.com/admin/blogs/181422

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

hrtc

动态加载资源文件

问题

可选方案

公共部分

应用案例1：可自动检查文件变化的Properties

总结

动态加载java类

目标：

术语：

对于目标类的限制：

测试代码：

要解决的问题及解决方法

如何重新加载类

检测类变化的方法

检测类变化的时机

创建类时检查

调用方法时检查

如何更新原来已创建的对象

所有类代码

java servletfilter实现全站动转静

原理及特点

配置方法

java书籍推荐

websphere5.1+spring2.0+struts2+hibernate3搭建总结

Better Builds with Maven学习笔记3

3.10 创建应用程序的Web站点

Better Builds with Maven学习笔记2

第三章 用Maven创建应用程序

3.1 介绍

3.2 建立应用程序目录结构

3.3 使用项目继承

3.4 管理依赖

3.5 使用快照(Snapshots)

3.6 解决依赖冲突和使用版本范围

3.7 利用构建生命周期

3.8 使用Profiles

3.9 部署你的应用程序

3.9.1 以文件方式部署

3.9.2 以SSH2方式部署

3.9.3 以SFTP方式部署

3.9.4 以扩展SSH方式部署

3.9.5 以FTP方式部署

第三章用Maven创建应用程序