#include <windows.h>
#include <jni.h>
#include <string>
using namespace std;
 
void vShowError(string sErrorMessage);
void vShowLastError(string sErrorMessage);
void vDestroyVM(JNIEnv *env, JavaVM *jvm);
void vAddOption(string& sName);
 
JavaVMOption* vm_options;
int mctOptions = 0;
int mctOptionCapacity = 0;
boolean GetApplicationHome(char *buf, jint sz);
typedef jint (CALLBACK *CreateJavaVM)(JavaVM **pvm, JNIEnv **penv, void *args);
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow){
    JNIEnv *env;
    JavaVM *jvm;
    jint jintVMStartupReturnValue;
    jclass jclassStartup;
    jmethodID midStartup;
 
    // 确定各种文件所在的路径
    // -应用的主目录
    char home[2000];
    if (!GetApplicationHome(home, sizeof(home))) {
        vShowError("不能确定应用的主目录。");
        return 0;
    }
    string sAppHome(home);
    string sOption_AppHome = "-Ddodo.home=" + sAppHome;
    string sJREPath = sAppHome + "\\jre";
    // -VM路径
    string sRuntimePath = sJREPath + "\\bin\\client";
    string sJVMpath = sRuntimePath + "\\jvm.dll";
    // -启动路径
    string sBootPath = sJREPath + "\\lib";
    string sOption_BootPath = "-Dsun.boot.class.path=" + sBootPath;
    // -CLASSPATH
	string sClassPath = sAppHome + "\\main\\startup.jar";
 
    string sOption_ClassPath = "-Djava.class.path=" + sClassPath;
 
    // 设置VM参数
    // vAddOption(string("-verbose"));
    vAddOption(sOption_ClassPath);
    vAddOption(sOption_AppHome);
    // VM初始化参数
    JavaVMInitArgs vm_args;
    vm_args.version = 0x00010002;
    vm_args.options = vm_options;
    vm_args.nOptions = mctOptions;
    vm_args.ignoreUnrecognized = JNI_TRUE;
    // 装入JVM库
    HINSTANCE hJVM = LoadLibrary(sJVMpath.c_str());
    if( hJVM == NULL ){
        vShowLastError("不能从下面的路径装入JVM：" + sJVMpath);
        return 0;
    }
    // 启动1.2/3/4 VM
    CreateJavaVM lpfnCreateJavaVM = (CreateJavaVM) GetProcAddress(hJVM, "JNI_CreateJavaVM");
    jintVMStartupReturnValue = (*lpfnCreateJavaVM) (&jvm, &env, &vm_args);
    // 是否成功？
    if (jintVMStartupReturnValue < 0) {
        string sErrorMessage = "创建VM失败。";
        vShowError(sErrorMessage);
        vDestroyVM(env, jvm);
        return 0;
    }
    // 要启动的类
    string sStartupClass = "DodoStartup";
    // 注意句点符号已经被转换成斜杠
    jclassStartup = env->FindClass(sStartupClass.c_str());
    if (jclassStartup == NULL) {
        string sErrorMessage ="找不到启动类[" +sStartupClass + "]";
        vShowError(sErrorMessage);
        vDestroyVM(env, jvm);
        return 0;
    }
    // 要启动的方法
    string sStartupMethod_Identifier = "main";
    string sStartupMethod_TypeDescriptor ="([Ljava/lang/String;)V";
    midStartup = env->GetStaticMethodID(jclassStartup,
    sStartupMethod_Identifier.c_str(),
    sStartupMethod_TypeDescriptor.c_str());
    if (midStartup == NULL) {
        string sErrorMessage = "找不到启动方法["+ sStartupClass + "."+ sStartupMethod_Identifier
        + "]，类型描述符是[" + sStartupMethod_TypeDescriptor + "]";
        vShowError(sErrorMessage);
        vDestroyVM(env, jvm);
        return 0;
    }
    // 构造启动方法的参数
    jstring jstringExampleArg;
    jclass jclassString;
    jobjectArray jobjectArray_args;
    jstringExampleArg = env->NewStringUTF("string1");
    if (jstringExampleArg == NULL){
        vDestroyVM(env, jvm);
        return 0;
    }
    jclassString = env->FindClass("java/lang/String");
    jobjectArray_args = env->NewObjectArray(1, jclassString, jstringExampleArg);
    if (jobjectArray_args == NULL){
        vDestroyVM(env, jvm);
        return 0;
    }
    // 调用启动方法启动Java程序
    env->CallStaticVoidMethod(jclassStartup, midStartup, jobjectArray_args);
    // 在退出之前尝试分离主线程
    if (jvm->DetachCurrentThread() != 0) {
        vShowError("分离主线程失败。\n");
    }
    // 只要还有非守护线程，下面的调用将一直被挂起
    jvm->DestroyJavaVM();
    return 0;
}
void vDestroyVM(JNIEnv *env, JavaVM *jvm){
    if (env->ExceptionOccurred()) {
        env->ExceptionDescribe();
    }
    jvm->DestroyJavaVM();
}
 
void vShowError(string sError) {
    MessageBox(NULL, sError.c_str(), "错误", MB_OK);
}
 
/* 在对话框中显示错误信息，括号内包含
的GetLastError错误信息 */
void vShowLastError(string sLocalError) {
    LPVOID lpSystemMsgBuf;
    FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER |
    FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
    NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
    (LPTSTR) &lpSystemMsgBuf, 0, NULL );
    string sSystemError = string((LPTSTR)lpSystemMsgBuf);
    vShowError(sLocalError + " [" + sSystemError + "]");
}
 
void vAddOption(string& sValue) {
    mctOptions++;
    if (mctOptions >= mctOptionCapacity) {
        if (mctOptionCapacity == 0) {
            mctOptionCapacity = 3;
            vm_options = (JavaVMOption*)malloc(mctOptionCapacity * sizeof(JavaVMOption));
        } else {
            JavaVMOption *tmp;
            mctOptionCapacity *= 2;
            tmp = (JavaVMOption*)malloc(mctOptionCapacity * sizeof(JavaVMOption));
            memcpy(tmp, vm_options, (mctOptions-1) * sizeof(JavaVMOption));
            free(vm_options);
            vm_options = tmp;
        }
    }
    vm_options[mctOptions-1].optionString = (char*)sValue.c_str();
}
 
/* 如果缓冲区是"c:\app\bin\java"，则把"c:\app"放入buf。*/
jboolean GetApplicationHome(char *buf, jint sz) {
    char *cp;
    GetModuleFileName(0, buf, sz);
    *strrchr(buf, '\\') = '\0';
    if ((cp = strrchr(buf, '\\')) == 0) {
        // 如果应用程序放在驱动器的根目录下，且不存在bin目录
        // 会出现这种情形
        buf[0] = '\0';
        return JNI_FALSE;
    }
    return JNI_TRUE;
}

    FolderPane fp=new FolderPane();//设置是否有动画效果，缺省没有
    fp.setAnimated(true);//添加子面板      
    fp.addFolder("文件和文件夹任务", getFileFolderPane());      
    fp.addFolder("其他位置", getOtherPlacePane());      
    fp.addFolder("详细信息", getDetailsPane());      
    add(fp, BorderLayout.CENTER);

    //设置是否要动画效果      
    public void setAnimated(boolean b)
    //添加面板，title是面板标题文字，content是应用程序组件
    public void addFolder(String title, JComponent content)

 public Insets getInsets() {
        Insets insets = (Insets)super.getInsets().clone();
        insets.left += imageIcon.getIconWidth();
        return insets;
    }

    public void paint(Graphics g) {
        super.paint(g);
        if (imageIcon != null) {
            Insets insets = getInsets();
            // 每一副图像的位置坐标
    		int x = insets.left - imageIcon.getIconWidth();
    		int y = insets.top-2;
 
    		Image image = imageIcon.getImage();
    		// 平铺背景图片
    		while (true) {
    			// 绘制图片
    			g.drawImage(image, x, y, this);
    			// 如果绘制完毕，退出循环
    			if ( y > getSize().height)
    				break;
    			y += imageIcon.getIconHeight();
    		}
        }
    }

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Insets;
import java.awt.Toolkit;
import java.awt.event.MouseEvent;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
 
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
 
public class JImagedPopupMenu extends JPopupMenu {
    private Font font = new Font("Dialog", Font.BOLD, 13);
    private ImageIcon imageIcon = null;
 
    public JImagedPopupMenu(ImageIcon imageIcon) {
        this.imageIcon = imageIcon;
    }
 
    public JImagedPopupMenu(String text) {
        this.imageIcon = createImage(text);
    }
 
    private ImageIcon createImage(String text) {
    	FontMetrics fm = Toolkit.getDefaultToolkit().getFontMetrics(font);
    	int height = fm.stringWidth(text)+20;
        BufferedImage bi = new BufferedImage(30, height, BufferedImage.TYPE_INT_ARGB);
        ImageIcon image = new ImageIcon(bi);
        Graphics2D g2d = bi.createGraphics();
 
        GradientPaint paint = new GradientPaint(0, 0, Color.YELLOW, 30, 0, Color.RED, true);
        g2d.setPaint(paint);
 
        g2d.fillRect(0, 0, bi.getWidth(), bi.getHeight());
 
        AffineTransform at = new AffineTransform();
        at.rotate( -Math.PI / 2);
 
        g2d.setTransform(at);
        g2d.setColor(Color.white);
        g2d.setFont(font);
        g2d.drawString(text, -height+10, bi.getWidth() / 2);
 
        return image;
    }
 
    public Insets getInsets() {
        Insets insets = (Insets)super.getInsets().clone();
        insets.left += imageIcon.getIconWidth();
        return insets;
    }
 
    public void paint(Graphics g) {
        super.paint(g);
        if (imageIcon != null) {
            Insets insets = getInsets();
            // 每一副图像的位置坐标
    		int x = insets.left - imageIcon.getIconWidth();
    		int y = insets.top-2;
 
    		Image image = imageIcon.getImage();
    		// 平铺背景图片
    		while (true) {
    			// 绘制图片
    			g.drawImage(image, x, y, this);
    			// 如果绘制完毕，退出循环
    			if ( y > getSize().height)
    				break;
    			y += imageIcon.getIconHeight();
    		}
        }
    }
 
    public static void main(String[] args) {
        final JFrame frame = new JFrame();
        frame.setSize(600, 500);
        frame.setTitle("ImageMenu");
        final JImagedPopupMenu menu = new JImagedPopupMenu("www.voland.com.cn");
        menu.add(new JMenuItem("Winzip 8.0"));
        menu.addSeparator();
        menu.add(new JMenuItem("Programs"));
        menu.add(new JMenuItem("Document"));
        menu.add(new JMenuItem("Settings"));
        menu.add(new JMenuItem("Search"));
        menu.add(new JMenuItem("Help and Support"));
        menu.add(new JMenuItem("Run..."));
 
        JLabel label = new JLabel("Right click me to show image popup menu.");
        label.addMouseListener(new java.awt.event.MouseAdapter() {
            public void mouseReleased(MouseEvent e) {
                if (e.isPopupTrigger()) {
                    menu.show(frame, e.getPoint().x, e.getPoint().y);
                }
            }
        });
        frame.getContentPane().add(label, BorderLayout.CENTER);
        frame.show();
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collection;
import java.util.Hashtable;
 
public class JavaWindowsTaskManager {
 
	/**
	 * 杀死一个进程
	 * @param task 进程号
	 *            
	 */
	public static void killTask(Integer pid) {
		try {
			// 取得任务列表
			Hashtable<Integer, WindowsTask> tasks = getTaskList();
			WindowsTask task = tasks.get(pid);
			if(task != null){
				Runtime.getRuntime().exec("tskill " + pid);
			}			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
 
	/**
	 * 杀死指定名称的所有进程
	 * @param taskName
	 */
	public static void killTask(String taskName){
		try{
			Hashtable<Integer, WindowsTask> tasks = getTaskList();
			Collection<WindowsTask> allTasks = tasks.values();
			for(WindowsTask task: allTasks){
				if(task.getName().equals(taskName)){
					killTask(task.getPid());
				}
			}
 
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
 
	/**
	 * 返回当前机器的所有进程
	 * 
	 * @return
	 */
	public static Hashtable<Integer, WindowsTask> getTaskList() {
		Hashtable<Integer, WindowsTask> tasks = new Hashtable<Integer, WindowsTask>();
		try {
			Process process = Runtime.getRuntime().exec("taskList");
			InputStreamReader in = new InputStreamReader(process
					.getInputStream(), "GBK");
			BufferedReader reader = new BufferedReader(in);
			String taskInfo = null;
			WindowsTask task = null;
			String tmp = null;
			while ((taskInfo = reader.readLine()) != null) {
				if (taskInfo.trim().length() > 0
						&& (taskInfo.contains("Services") || taskInfo
								.contains("Console"))) {
					System.out.println(taskInfo);
					task = new WindowsTask();
					tmp = taskInfo.substring(0, 26);
					task.setName(tmp.trim());
					tmp = taskInfo.substring(26, 35);
					task.setPid(Integer.valueOf(tmp.trim()));
 
					tmp = taskInfo.substring(35, 52);
					task.setSessionName(tmp.trim());
					tmp = taskInfo.substring(52, 64);
					task.setSessionId(Integer.valueOf(tmp.trim()));
					tmp = taskInfo.substring(64, taskInfo.lastIndexOf("K"));
					tmp = tmp.replaceAll(",", "");
					task.setMem(Long.valueOf(tmp.trim()));
 
					tasks.put(task.getPid(), task);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return tasks;
	}
 
	/**
	 * 启动一个进程,传入的值可以是服务名,也可以是可执行文件的全路径名
	 * 
	 * @param task
	 */
	public static void startTask(String task) {
		try {
			Runtime.getRuntime().exec(task);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
 
}
 
class WindowsTask {
	// 映像名称
	private String name;
	// PID
	private Integer pid;
	// 会话名
	private String sessionName;
	// 会话编号
	private Integer sessionId;
	// 内存使用
	private long mem;
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	public Integer getPid() {
		return pid;
	}
 
	public void setPid(Integer pid) {
		this.pid = pid;
	}
 
	public String getSessionName() {
		return sessionName;
	}
 
	public void setSessionName(String sessionName) {
		this.sessionName = sessionName;
	}
 
	public Integer getSessionId() {
		return sessionId;
	}
 
	public void setSessionId(Integer sessionId) {
		this.sessionId = sessionId;
	}
 
	public long getMem() {
		return mem;
	}
 
	public void setMem(long mem) {
		this.mem = mem;
	}
}

public class BeanUtils {
	@SuppressWarnings("unchecked")
	public static <T> T copyProperties(Class<T> beanClass,Object fromBean){
 
		Class[] classes = new Class[0];
		Object[] objects = new Object[0];
		try {			
			T bean = beanClass.newInstance();
			Class formBeanClass = fromBean.getClass();			
			Method[] beanMethods = beanClass.getMethods();			
 
			String methodName  = null;
			String getMethodName = null;
			Class[] paramsType = null;
			Class paramType = null;
			//这里为什么用method去循环,而不用fields去循环?呵呵,这个就是提升性能的一个点
			for(Method method: beanMethods){
				methodName = method.getName();				
				if(methodName.startsWith("set")){
					paramsType = method.getParameterTypes();
					if(paramsType.length != 1)
						continue;
 
					paramType = paramsType[0];
					if(paramType.isInstance(boolean.class) ){
						getMethodName = "is"+methodName.substring(3);
					}else{
						getMethodName = "get"+methodName.substring(3);
					}
 
					try{
						Method formBeanGetMethod = formBeanClass.getMethod(getMethodName, classes);
						if( paramType.equals( formBeanGetMethod.getReturnType() )){
							Object value = formBeanGetMethod.invoke(fromBean,objects);
							if (value != null){
								method.invoke(bean,new Object[]{value});
							}
						}
					}catch (NoSuchMethodException e) {}
				}				
			}		
			return bean;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}		
}

Method[] beanMethods = beanClass.getMethods();
paramsType = method.getParameterTypes();
Method formBeanGetMethod = formBeanClass.getMethod(getMethodName, classes);

 
import java.lang.reflect.Method;
import java.util.HashMap;
 
public class BeanUtils {
 
	private static HashMap<Class, Method[]> beanMethodCache = new HashMap<Class, Method[]>();
	private static HashMap<Class,HashMap<String, Method>> fromBeanMethodCache = new HashMap<Class, HashMap<String,Method>>();
 
	@SuppressWarnings("unchecked")
	public static <T> T copyProperties(Class<T> beanClass,Object fromBean){
 
		Class[] classes = new Class[0];
		Object[] objects = new Object[0];
		try {			
			T bean = beanClass.newInstance();
			Class formBeanClass = fromBean.getClass();
 
			Method[] beanMethods = beanMethodCache.get(beanClass);
			if(beanMethods == null){
				beanMethods = beanClass.getMethods();
				beanMethodCache.put(beanClass, beanMethods);
			}
 
			HashMap<String, Method> fromBeanMethods = fromBeanMethodCache.get(formBeanClass);
			if(fromBeanMethods == null){
				fromBeanMethods = new HashMap<String, Method>();
				Method[] methods = formBeanClass.getMethods();
				String getMethodName = null;
				for(Method method: methods){
					getMethodName = method.getName();
					if( getMethodName.startsWith("get") || getMethodName.startsWith("is") )
						fromBeanMethods.put(getMethodName, method);
				}
				fromBeanMethodCache.put(formBeanClass, fromBeanMethods);
			}
 
			String methodName  = null;
			String getMethodName = null;
			Class[] paramsType = null;
			Class paramType = null;
			for(Method method: beanMethods){
				methodName = method.getName();				
				if(methodName.startsWith("set")){
					paramsType = method.getParameterTypes();
					if(paramsType.length != 1)
						continue;
 
					paramType = paramsType[0];
					if(paramType.isInstance(boolean.class) ){
						getMethodName = "is"+methodName.substring(3);
					}else{
						getMethodName = "get"+methodName.substring(3);
					}
					Method formBeanGetMethod = fromBeanMethods.get(getMethodName);
					if(formBeanGetMethod !=null ){
						if( paramType.equals( formBeanGetMethod.getReturnType() )){
							Object value = formBeanGetMethod.invoke(fromBean,objects);
							if (value != null){
								method.invoke(bean,new Object[]{value});
							}
						}
					}
				}				
			}		
			return bean;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}	
}

Method[] beanMethods = beanClass.getMethods();
Method formBeanGetMethod = formBeanClass.getMethod(getMethodName, classes);

package com.voland.utils;
 
import java.util.Date;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
 
/**
 * 任务引擎，在指定是时间或者立即执行特定的任务，所有执行的任务都在指定的线程池中。
 * 如果在指定的时间执行特定任务时，线程池中没有空闲的线程，那么这个任务也将排队等待有空闲的线程。
 * 这个任务引擎你可以看成是有线程管理的{@link Thread} 或者是{@line TimerTask}.
 * @author nortan
 *
 */
public class TaskEngine {
 
    private static TaskEngine instance = new TaskEngine();
 
    /**
     * 返回一个任务引擎实例
     * @return
     */
    public static TaskEngine getInstance() {
        return instance;
    }
 
    private Timer timer;	//定时器
    private ExecutorService executor; //执行管理服务
    private Map<TimerTask, TimerTaskWrapper> wrappedTasks = new ConcurrentHashMap<TimerTask, TimerTaskWrapper>();
    private boolean daemon = true;
 
    /**
     * 构造一个新的引擎
     */
    private TaskEngine() {
        timer = new Timer("timer-openfire", daemon);
        executor = Executors.newCachedThreadPool(new ThreadFactory() {
            final AtomicInteger threadNumber = new AtomicInteger(1);
            public Thread newThread(Runnable runnable) {
                // 使用我们自己的线程命名方式
                Thread thread = new Thread(Thread.currentThread().getThreadGroup(), runnable,
                                      "pool-netmachine" + threadNumber.getAndIncrement(), 0);
                // 设置任务为守护进程
                thread.setDaemon(daemon);
                if (thread.getPriority() != Thread.NORM_PRIORITY) {
                    thread.setPriority(Thread.NORM_PRIORITY);
                }
                return thread;
            }
        });
    }
 
    /**
     * 提交一个实时执行的任务也是需要排队的
     * @param task
     * @return
     */
    public Future<?> submit(Runnable task) {
        return executor.submit(task);
    }
 
    /**
     * 延迟时间来执行特定的task
     * @param task
     * @param delay 延迟的时间,单位：毫秒
     */
    public void schedule(TimerTask task, long delay) {
        timer.schedule(new TimerTaskWrapper(task), delay);
    }
 
    /**
     * 在指定时间执行任务
     * @param task
     * @param time
     */
    public void schedule(TimerTask task, Date time) {
        timer.schedule(new TimerTaskWrapper(task), time);
    }
 
    /**
     * 延迟一定时间后，固定延时执行循环执行任务，可以参看{@link Timer#schedule()}
     * @param task
     * @param delay
     * @param period，循环任务间的间隔时间，以毫秒为单位
     */
    public void schedule(TimerTask task, long delay, long period) {
        TimerTaskWrapper taskWrapper = new TimerTaskWrapper(task);
        wrappedTasks.put(task, taskWrapper);
        timer.schedule(taskWrapper, delay, period);
    }
 
    /**
     * 在指定的时间执行第一次任务，以后循环执行
     * @param task
     * @param firstTime
     * @param period
     */
    public void schedule(TimerTask task, Date firstTime, long period) {
        TimerTaskWrapper taskWrapper = new TimerTaskWrapper(task);
        wrappedTasks.put(task, taskWrapper);
        timer.schedule(taskWrapper, firstTime, period);
    }
 
   /***
    * 延迟一定时间后，以固定速率执行循环执行任务，用来执行绝对 时间敏感的重复执行活动，如每小时准点打钟报时等等。
    * @param task
    * @param delay
    * @param period
    */
    public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
        TimerTaskWrapper taskWrapper = new TimerTaskWrapper(task);
        wrappedTasks.put(task, taskWrapper);
        timer.scheduleAtFixedRate(taskWrapper, delay, period);
    }
 
    /**
     * 
     * @param task
     * @param firstTime 第一次执行时间
     * @param period 固定速率间隔时间
     */
    public void scheduleAtFixedRate(TimerTask task, Date firstTime, long period) {
        TimerTaskWrapper taskWrapper = new TimerTaskWrapper(task);
        wrappedTasks.put(task, taskWrapper);
        timer.scheduleAtFixedRate(taskWrapper, firstTime, period);
    }
 
    /**
     * 取消任务执行 {@link java.util.TimerTask#cancel()}
     *
     * @param task 需要取消的任务.
     */
    public void cancelScheduledTask(TimerTask task) {
        TaskEngine.TimerTaskWrapper taskWrapper = wrappedTasks.remove(task);
        if (taskWrapper != null) {
            taskWrapper.cancel();
        }
    }
 
    /**
     * 关闭任务服务
     */
    public void shutdown() {
        if (executor != null) {
            executor.shutdownNow();
            executor = null;
        }
 
        if (timer != null) {
            timer.cancel();
            timer = null;
        }
    }
 
    private class TimerTaskWrapper extends TimerTask {
 
        private TimerTask task;
 
        public TimerTaskWrapper(TimerTask task) {
            this.task = task;
        }
        public void run() {
            executor.submit(task);
        }
    }
}

final static BlockingQueue<Message> queue = new LinkedBlockingQueue<Message>();

// 本方法由生产者调用，将生产的数据放入队列
	public static void add(Message m) {
		try {
			queue.put(m);
		} catch (InterruptedException e) {			
			e.printStackTrace();
		}
	}

        @Override
	public void run() {
		try {
			while (true) {
				consume(queue.take());
			}
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
	}
 
	/**
	 * 消费数据，把数据放在list中，便于对数据的批量写入数据库
	 * @param message
	 */
	void consume(Message message) {
		synchronized(list) {			
			list.add(message);
			if(list.size() == 100){
				insert("满足100");
			}
		}		
	}

	/**
	 * 因为list可能同时被消费者、定时器操作，所以这里使用对list同步
	 * @param type
	 */
	void insert(String type){
		synchronized(list) {
			if(list.size() < 1)
				return ;
 
			System.out.println(type);
			String name = Thread.currentThread().getName();
			for(Message message : list){
				log.debug("消费者："+message.toString()+" ---"+name+" "+type);
			}
			list.clear();
		}
	}
}

class TimerInsert extends TimerTask{
	Consumer consumer;
	TimerInsert(Consumer consumer){
		this.consumer = consumer;
	}
 
	@Override
	public void run() {
		consumer.insert("满足时间");		
	}	
}

import java.net.URL;
import java.util.HashMap;
import java.util.Map;
 
import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
 
public class Test {
	public static void post(String title, String content)  {
		try{
			// Set up XML-RPC connection to server
                        String domain = "www.extbi.com";//你网站的域名
			XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
			config.setServerURL(new URL("http://"+domain+"/xmlrpc.php"));
			XmlRpcClient client = new XmlRpcClient();
			client.setConfig(config);
 
			// Set up parameters required by newPost method
			Map post = new HashMap();
			post.put("title", title);//标题
			post.put("mt_keywords", "标签,标签2,标签3");//标签
			Object[] categories = new Object[] { "服饰","数码" };//分类
			post.put("categories", categories);
			post.put("description", content);//内容
			Object[] params = new Object[] { "1", "用户名", "密码", post,
					Boolean.TRUE };
 
			// Call newPost
			String result = (String) client.execute("metaWeblog.newPost", params);
			System.out.println(" Created with blogid " + result);
		}catch (Exception e) {
			// TODO: handle exception
                       System.out.println(" UnCreated ");
		}
	}
}

/**
	 * 给定一个列表url，得到本url对象的html,然后其它操作在这个基础上做
	 * @param url 
	 * @param encoding   返回html的编码方式，如GBK，UTF─8
	 * @return
	 * @throws Exception
	 */
	public String getHtml(String url, String encoding) throws Exception {
		String value = null;
		HttpClient httpclient = new DefaultHttpClient();        
        HttpGet httpget = new HttpGet(url);
 
        // 以下这条如果不加会发现无论你设置Accept-Charset为gbk还是utf-8，他都会默认返回gb2312（本例针对google.cn来说）
        httpget.setHeader("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.1.2)");
        // 用逗号分隔显示可以同时接受多种编码
        httpget.setHeader("Accept-Language", "zh-cn,zh;q=0.5");
        httpget.setHeader("Accept-Charset", "GB2312,utf-8;q=0.7,*;q=0.7");        
        HttpResponse response = httpclient.execute(httpget);     
 
        // 判断页面返回状态判断是否进行转向抓取新链接
        int statusCode = response.getStatusLine().getStatusCode();
        if ((statusCode == HttpStatus.SC_MOVED_PERMANENTLY) ||
                (statusCode == HttpStatus.SC_MOVED_TEMPORARILY) ||
                (statusCode == HttpStatus.SC_SEE_OTHER) ||
                (statusCode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
            // 此处重定向处理  此处还未验证
            String newUri = response.getLastHeader("Location").getValue();
            httpclient = new DefaultHttpClient();
            httpget = new HttpGet(newUri);
            response = httpclient.execute(httpget);
        }
 
        // Get hold of the response entity
        HttpEntity entity = response.getEntity();        
        // If the response does not enclose an entity, there is no need
        // to bother about connection release
        if (entity != null) {
            // 将源码流保存在一个byte数组当中，因为可能需要两次用到该流，
            byte[] bytes = EntityUtils.toByteArray(entity);
            // 如果头部Content-Type中包含了编码信息，那么我们可以直接在此处获取
 
            if(encoding != null && !"".equals(encoding.trim())){
            	value = new String(bytes, encoding);
            }else{
            	String charSet = EntityUtils.getContentCharSet(entity);
            	// 如果头部中没有，那么我们需要 查看页面源码，这个方法虽然不能说完全正确，因为有些粗糙的网页编码者没有在页面中写头部编码信息
	            if (charSet == null || "".equals(charSet.trim())) {
	                String regEx="(?=<meta).*?(?<=charset=[\\'|\\\"]?)([[a-z]|[A-Z]|[0-9]|-]*)";
	                Pattern p=Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);
	                Matcher m=p.matcher(new String(bytes));  // 默认编码转成字符串，因为我们的匹配中无中文，所以串中可能的乱码对我们没有影响
	                boolean result=m.find();
	                if (m.groupCount() == 1) {
	                    charSet = m.group(1);
	                }
	            }
	            value = new String(bytes, charSet);
            }       
        }
 
        httpclient.getConnectionManager().shutdown();   
        return value;
    }

/**
	 * 列表区域识别规则
	 * @param html 原始的html
	 * @param areaRegex 所提取区域的正则表达式
	 * @param area 正则表达式中需要提取的区域，取值是：AREA_LIST，AREA_TITLE等等
	 * @return
	 */
	public String getArea(String html, String areaRegex ,String area) {
		String valueHtml=null;
		String regex = areaRegex.replaceFirst(area, "([\\\\s\\\\S]*?)");
//		System.out.println(regex);
		Pattern pattern = Pattern.compile(regex,Pattern.MULTILINE); 
		Matcher matcher = pattern.matcher(html); 
		while(matcher.find()) {
			valueHtml = matcher.group(1).trim();
			break;
		} 
		return valueHtml;
	}

       //提取给定区域的文章列表地址,
       public List<String> getListUrl(String areaHtml,String regex,String withPrefix){
		return this.getListUrl(areaHtml, regex, withPrefix, false, null);
	}
 
	/**
	 * 提取给定区域的文章列表地址，主要用来提取文章内的分页用的
	 * @param areaHtml 
	 * @param regex 
	 * @param withPrefix 返回的地址是否需要加一个前缀，如21cn的新闻，提取到后是没有前缀的，得加一个
	 * @param hasOmit  提取文章内分页时，是否有分页是否有省略号，如淘宝的就有。
	 * @param pageNumRegex  提取文章内的分页正则表达式
	 * @return
	 */
	public List<String> getListUrl(String areaHtml,String regex,String withPrefix,boolean hasOmit,String pageNumRegex){
		List<String> list = new ArrayList<String>();
		regex = regex.replaceFirst(WebContent.AREA_URL, "(.*?)");
		Pattern pa = Pattern.compile(regex, Pattern.MULTILINE);
		Matcher ma = pa.matcher(areaHtml);
		while (ma.find()) {
			if(withPrefix !=null && !"".equals(withPrefix.trim())){
				list.add(withPrefix+ma.group(1).trim());
			}else{
				list.add(ma.group(1).trim());
			}
		}
 
		if(hasOmit && list.size()>1){
			String lasturl = list.get(list.size()-1);
			list.clear(); 
			regex = "(.*?)"+pageNumRegex.replaceFirst(WebContent.PAGE_URL_NUM, "(-?\\\\d+)");			
			pa = Pattern.compile(regex);
			ma = pa.matcher(lasturl);
			if(ma.find()){
				int num = Integer.parseInt(ma.group(2));
				String prefix = ma.group(1).trim();
				String baseurl = prefix+pageNumRegex;
 
				for(int i = 2; i <= num; i ++)
				list.add(baseurl.replaceFirst(WebContent.PAGE_URL_NUM, i+""));
			}			
		}
 
		return list;
	}