或许有不少Java程序猿在写Integer比较的时候出现过一种情况，均为Integer类型的相同值比较，却不是我们想要的结果！刚好在今天在开发中赶进度，也犯了这么一个错，所以来整理分享一下！

刚好今天有这么一个比较：

device.getIdevicetypeid != dbDevice.getIdevicetypeid()

在测试的时候就一直有问题，逼得我来个debug，一只跟踪到这里发现原本类型一致、值也一致的两个属性值比较时，却永远是true，很是诧异，仔细看看才发现"!="这个比较！

在这个时候，作为一个有了几年开发经验的来说，马上会想到几种解决方案！先例举两种：

1、不改比较方式，还是使用"!="，但是将

device.getIdevicetypeid().intValue != dbDevice.getIdevicetypeid().intValue()

这样就会得到你想要的答案

2、改变比较方式，使用"equals()"，代码如下：

!device.getIdevicetypeid().equals(dbDevice.getIdevicetypeid())

这种比较方式一样能比较出来！以上两种比较方式要注意java.lang.NullPointerException异常，至于怎么处理这个异常，我就不多说了！

说说为什么吧，Integer不属于基本数据类型，使用==只能比较值相等，而Integer为对象所以使用==比较时就会出现问题，只要使用equals比较就不会有这种问题出现。再说说为什么用上面的两种方式就能比较出来呢，有使用jdk API习惯的程序猿，会发现Integer对象的intValue()会把Integer对象的值转换为int的基本数据类型值，这样使用==比较就是正常的！而用equals比较在底层的逻辑也就是将它用intValue()转换了！

内容很简单，知识很基础！

转载至:http://blog.csdn.net/luo201227/article/details/22392943

在大部分编程语言中，枚举类型都会是一种常用而又必不可少的数据类型，Java中当然也不会例外。然而，Java中的Enum枚举类型却有着许多你意想不到的用法，下面让我们一起来看看。

1、可以在enum中添加变量和方法

先来看一段代码示例：

public enum State {
        Normal("正常态", 1), Update("已更新", 2), Deleted("已删除", 3), Fired("已屏蔽", 4);
        // 成员变量
        private String name;
        private int index;

        // 构造方法，注意：构造方法不能为public，因为enum并不可以被实例化
        private State(String name, int index) {
            this.name = name;
            this.index = index;
        }

        // 普通方法
        public static String getName(int index) {
            for (State c : State .values()) {
                if (c.getIndex() == index) {
                    return c.name;
                }
            }
            return null;
        }

        // get set 方法
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getIndex() {
            return index;
        }

        public void setIndex(int index) {
            this.index = index;
        }
    }

从上面的代码中我们可以看到，定义完枚举值，然后在其后面加上分号，接着就可以定义其他的变量、方法了。另外需要特别说明的是，enum中的构造方法不可以用public标识，这样做是为了防止用户实例化enum。

2、可以用来定义常量

先来回顾一下Java中如何定义常量吧，看下面一段代码：

public static final int normalState = 1;
private static final int updateState = 2;

下面我们还可以用enum枚举来代替上面的常量定义，代码如下：

public enum State {  
  Normal, Update, Deleted, Fired
}

在Java中用enum来定义常量在语法上没有什么优势，但是enum枚举类型可以提供更多的操作功能。

3、在enum中实现接口

先来看下面一段代码：

public interface ICanReadState {
        void read();

        String getState();
}

    public enum State implements ICanReadState {
        Normal("正常态", 1), Update("已更新", 2), Deleted("已删除", 3), Fired("已屏蔽", 4);

        private String name;
        private int index;

        private State(String name, int index) {
            this.name = name;
            this.index = index;
        }

        // 接口方法1

        @Override
        public String getState() {
            return this.name;
        }

        // 接口方法2
        @Override
        public void read() {
            System.out.println(this.index + ":" + this.name);
        }
    }

和一般的类中使用接口一样，enum枚举中同样可以继承接口，并实现接口中的所有方法，这样做的好处在于可以更方便地对枚举中的值进行排序、比较等操作，封装性更好。

总结

说白了，enum枚举类型是一个不可以被继承的final类，就以上面的State枚举为例，如果你查看enum类型的字节码，其实是State类型的类静态常量。

转载至:http://blog.csdn.net/luo201227/article/details/39177295

在开发过程中，Java程序猿有时候很郁闷，要取计算机的相关信息相当无措！其实了解JNI的猿人应该知道，通过JNI调用C/C++的动态链接库就可以轻松的实现！但是有人又会觉得JNI还是有点复杂，好吧，今天就分享一下JNI的加强版――JNA，它让我们轻松了跨语言的调用，调用其他语言的方法/函数就如调用Java自己定义方法一般！好啦，不多说，直接贴代码，简单的实例，获取计算机的名称：

/**
 * @Description: 
 *
 * @Title: JNATestServlet.java
 * @Package com.joyce.jna
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-2-27 下午04:26:21
 * @version V2.0
 */
package com.joyce.jna;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.sun.jna.Library;
import com.sun.jna.Native;
/**
 * @Description: 
 *
 * @ClassName: JNATestServlet
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-2-27 下午04:26:21
 * @version V2.0
 */
public class JNATestServlet extends HttpServlet {
    
    /**
      * @Fields serialVersionUID : TODO
      */
    private static final long serialVersionUID = -8617706236668864317L;
    public interface GetComputerName extends Library {
        GetComputerName INSTANCE = (GetComputerName) Native.loadLibrary("dll/GetCompName",GetComputerName.class);
        public String GetCopmuterName();
    }
    
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        this.doPost(request, response);
    }
    
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        String computerName = GetComputerName.INSTANCE.GetCopmuterName();
        System.out.println(computerName);
        PrintWriter out = response.getWriter();
        out.print(computerName);
        out.flush();
        out.close();
    }
}

这是后台是的代码，至于怎么展示在前台上就不用我多说了吧！

动态链接库dll、jar包下载地址：http://download.csdn.net/download/luo201227/7133593

转载至:http://blog.csdn.net/luo201227/article/details/22779341

为了庆祝明天和这不成器的好产品，写上这Java生成的二维码！这里生成的二维码所使用的jar是为qrcode！具体资源的下载路径：http://download.csdn.net/download/luo201227/7130951（包含了代码和jar包），好啦。直接上代码：

一、[编码]

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;
import com.swetake.util.Qrcode;
/**
 * @Description: 编码器
 *
 * @ClassName: QRCodeEncoderHandler
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-2-11 下午01:57:47
 * @version V2.0
 */
public class QRCodeEncoderHandler {
    
    /**
     * @Description: 生成二维码(QRCode)图片 
     *
     * @param content 二维码内容
     * @param imgPath 二维码存放路径
     *
     * @Title: QRCodeEncoderHandler.java
     * @Copyright: Copyright (c) 2014
     *
     * @author Comsys-LZP
     * @date 2014-2-11 下午03:54:18
     * @version V1.0
     * @throws Exception 
     */
    public void encoderQRCode(String content, String imgPath) throws Exception {
        // 处理异常
        try { 
            // 实例化对象
            Qrcode qrcodeHandler = new Qrcode(); 
            // 设置
            qrcodeHandler.setQrcodeErrorCorrect('M'); 
            qrcodeHandler.setQrcodeEncodeMode('B'); 
            qrcodeHandler.setQrcodeVersion(7); 
            
            // 二维码内容转换
            byte[] contentBytes = content.getBytes("gb2312"); 
            
            // 实例化对象
            BufferedImage bufImg = new BufferedImage(140, 140, BufferedImage.TYPE_INT_RGB); 
            
            // 创建
            Graphics2D gs = bufImg.createGraphics(); 
            // 设置
            gs.setBackground(Color.WHITE);
            
            gs.clearRect(0, 0, 140, 140);
 
            // 设定图像颜色> BLACK 
            gs.setColor(Color.BLACK); 
 
            // 设置偏移量 不设置可能导致解析出错 
            int pixoff = 2; 
            // 输出内容> 二维码 
            if (contentBytes.length > 0 && contentBytes.length < 120) { 
                boolean[][] codeOut = qrcodeHandler.calQrcode(contentBytes); 
                for (int i = 0; i < codeOut.length; i++) { 
                    for (int j = 0; j < codeOut.length; j++) { 
                        if (codeOut[j][i]) { 
                            gs.fillRect(j * 3 + pixoff, i * 3 + pixoff, 3, 3); 
                        } 
                    } 
                } 
            } else {
                throw new Exception("QRCode content bytes length = " + contentBytes.length + " not in [ 0,120 ]. ");
            } 
            gs.dispose(); 
            bufImg.flush(); 
            
            // 二维码文件对象
            File imgFile = new File(imgPath); 
            
            // 判断是否存在
            if(!imgFile.exists()){
                // 不存在，先进行创建
                imgFile.mkdirs();
            }
            // 生成二维码QRCode图片 
            ImageIO.write(bufImg, "png", imgFile); 
        } catch (Exception e) {
            throw new Exception("Error：" + e.getMessage());
        } 
    }
}

二、[解码]

import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;
import jp.sourceforge.qrcode.QRCodeDecoder;
import jp.sourceforge.qrcode.data.QRCodeImage;
/**
 * @Description: 解码器
 *
 * @ClassName: QRCodeDecoderHandler
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-2-11 下午02:51:55
 * @version V1.0
 */
public class QRCodeDecoderHandler {
    /**
     * @Description: 解码二维码 
     *
     * @param imgPath 二维码图片文件路径
     * @return 解码内容
     *
     * @Title: QRCodeDecoderHandler.java
     * @Copyright: Copyright (c) 2014
     *
     * @author Comsys-LZP
     * @date 2014-2-11 下午03:44:04
     * @version V1.0
     * @throws Exception 
     */
    public String decoderQRCode(String imgPath) throws Exception { 
        // QRCode 二维码图片的文件 
        File imageFile = new File(imgPath); 
        // 声明对象
        BufferedImage bufImg = null; 
        // 声明变量
        String decodedData = null;
        // 处理异常
        try { 
            // 获取对象
            bufImg = ImageIO.read(imageFile); 
            // 实例化对象
            QRCodeDecoder decoder = new QRCodeDecoder();
            // 解码
            decodedData = new String(decoder.decode(new J2SEImage(bufImg))); 
        } catch (Exception e) {
            // 抛出异常
            throw new Exception("Error: " + e.getMessage());
        }
        // 返回
        return decodedData; 
    } 
    
    class J2SEImage implements QRCodeImage { 
        BufferedImage bufImg; 
 
        public J2SEImage(BufferedImage bufImg) { 
            this.bufImg = bufImg; 
        } 
 
        public int getWidth() { 
            return bufImg.getWidth(); 
        } 
 
        public int getHeight() { 
            return bufImg.getHeight(); 
        } 
 
        public int getPixel(int x, int y) { 
            return bufImg.getRGB(x, y); 
        } 
    } 
}

关键代码已贴上！至于怎么调用就不用我说了吧！

想看看效果吗？不好意思，不贴图，如果觉得神奇就拿起扫描的扫起来吧！

转载至:http://blog.csdn.net/luo201227/article/details/22939833

程序猿在一些多语言或者多平台的时候，数据传递绝大部分时候都是采用XML和JSON，以便双方都能识别，目前Java在XML方面有些常用的：dom4j这就不用说了，然后还有就是使用的比较少的，但是很强大很方便的XStream和XBlink！这里就不多介绍这些了；而对于JSON呢，有Java本身解析的包和方法，不过自从使用Google的Gson后，似乎就不再用以前的那种方式了！好啦，来简单的说说Gson对Json的使用吧，其实也真的很简单，所以现在使用的人也越来越多了！

Gson gs = new GsonBuilder().setDateFormat("yyyy-MM-dd").create();
List<T> list= gs.fromJson(jsonStr,new TypeToken<List<T>>() {}.getType());//转换为集合
Object obj = gs.fromJson(jsonStr, Object.class);//转换为对象
gs.toJson(list);//集合转换为json字符串
gs.toJson(obj);//对象转换为json字符串

关键代码就在这里，好好领悟去吧！多动动脑筋哟

Gson的jar包下载地址：http://download.csdn.net/download/luo201227/7176985

Google官网下载地址：https://code.google.com/p/google-gson/downloads/list

转载至:http://blog.csdn.net/luo201227/article/details/23436951

在业务逻辑很复杂的时候，一般都是牵涉到很广，这最直白的表现就是牵连诸多表，然后数据却不是一个对象中的属性或字段，这个时候我们为了方便数据传输一般都会将多个对象中的属性封装到一个VO中，使用Hibernate的人应该知道，查询出来一般都是一个或多个对象，如果依次通过setter方法来赋值的话，效率太低！这时候我们的DozerBeanMapper就体现出来了价值，所以我便将其封装了起来！好啦，直接上代码：

/**
 * @Title: EntityObjectConverter.java
 * @Package com.joyce.util
 * @Copyright: Copyright (c) 2013
 *
 * @author Comsys-LZP
 * @date 2013-11-4 上午09:55:14
 * @version V2.0
 */
package com.joyce.util;

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

import net.sf.dozer.util.mapping.DozerBeanMapper;

/**
 * @Description: 两个对象间，相同属性名之间进行转换
 * 
 * @ClassName: EntityObjectConverter
 * @Copyright: Copyright (c) 2013
 *
 * @author Comsys-LZP
 * @date 2013-11-4 上午09:55:14
 * @version V2.0
 */
public class EntityObjectConverter {
	/*
	 * 实例化对象
	 */
	private static DozerBeanMapper map = new DozerBeanMapper();
	
	/**
	 * @Description: 将目标对象转换为指定对象，相同属性名进行属性值复制
	 * 
	 * @Title: EntityObjectConverter.java
	 * @Copyright: Copyright (c) 2013
	 *
	 * @author Comsys-LZP
	 * @date 2013-11-4 下午02:32:34
	 * @version V2.0
	 */
	@SuppressWarnings("unchecked")
	public static <T> T getObject(Object source,Class<T> cls){
		if (source==null) {
			return null;
		}
		return (T) map.map(source, cls);
	}
	
	/**
	 * @Description: 两个对象之间相同属性名的属性值复制
	 * 
	 * @Title: EntityObjectConverter.java
	 * @Copyright: Copyright (c) 2013
	 *
	 * @author Comsys-LZP
	 * @date 2013-11-4 下午02:33:56
	 * @version V2.0
	 */
	public static void setObject(Object source,Object target){
		map.map(source, target);
	}
	
	/**
	 * @Description: 对象集合中对象相同属性名的属性值复制
	 * 
	 * @Title: EntityObjectConverter.java
	 * 
	 * @Copyright: Copyright (c) 2013
	 * @author Comsys-LZP
	 * @date 2013-11-4 下午02:34:26
	 * @version V2.0
	 */
	@SuppressWarnings("unchecked")
	public static List getList(List source,Class cls){
		List listTarget = new ArrayList();
		if(source != null){
			for (Object object : source) {
				Object objTarget = EntityObjectConverter.getObject(object, cls);
				listTarget.add(objTarget);
			}
		}
		return listTarget;
	}
}

附上jar资源下载地址：http://download.csdn.net/download/luo201227/7213937

欢迎大家关注我的博客！

转载至:http://blog.csdn.net/luo201227/article/details/24021791

所谓无规矩不成方圆，在编程世界中，也自有其一套编写规范。接下来，我们一起了解下Java的命名规范

转载至:http://blog.csdn.net/luo201227/article/details/24300615

随机数在程序的开发中经常使用，最实在的现在好多的网站开始使用随机密码了，好啦，直接上代码，很简单的！

/**
 * @Description: 
 *
 * @Title: RandomUtil.java
 * @Package com.joyce.util
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-4-29 下午03:14:06
 * @version V2.0
 */
package com.joyce.util;

import java.util.Random;

/**
 * @Description: 生成随机数
 * 
 * @ClassName: RandomUtil
 * @Copyright: Copyright (c) 2014
 * 
 * @author Comsys-LZP
 * @date 2014-4-29 下午03:14:06
 * @version V2.0
 */
public class RandomUtil {
	/**
	 * 随机数的最小值
	 */
	private static final Integer rand_min = 0;
	/**
	 * 随机数的最大值
	 */
	private static final Integer rand_max = 100;
	/**
	 * 实例化对象
	 */
	private static final Random RANDOM = new Random();

	/**
	 * @Description: 生成指定范围的随机数[minValue,maxValue]
	 * 
	 * @param minValue
	 *            最小值
	 * @param maxValue
	 *            最大值
	 * @return 指定范围内的随机数
	 * 
	 * @Title: RandomUtil.java
	 * @Copyright: Copyright (c) 2014
	 * 
	 * @author Comsys-LZP
	 * @date 2014-4-29 下午03:23:09
	 * @version V2.0
	 * @throws Exception 
	 */
	public static Integer appointRangeValue(Integer minValue, Integer maxValue) throws Exception {
		if(maxValue <= 0){
			throw new RuntimeException("maxValue must more than zero");
		}
		return RANDOM.nextInt(maxValue) % (maxValue - minValue + 1) + minValue;
	}

	/**
	 * @Description: 生成指定结束值的随机数[startValue,100]
	 * 
	 * @param startValue
	 *            开始值
	 * @return 开始值~100之间的值
	 * 
	 * @Title: RandomUtil.java
	 * @Copyright: Copyright (c) 2014
	 * 
	 * @author Comsys-LZP
	 * @date 2014-4-29 下午03:37:21
	 * @version V2.0
	 * @throws Exception 
	 */
	public static Integer appointStartValue(Integer startValue) throws Exception {
		return appointRangeValue(startValue, rand_max);
	}

	/**
	 * @Description: 生成指定结束值的随机数[0,endValue]
	 * 
	 * @param endValue
	 *            结束值
	 * @return 0~指定结束值之间的值
	 * 
	 * @Title: RandomUtil.java
	 * @Copyright: Copyright (c) 2014
	 * 
	 * @author Comsys-LZP
	 * @date 2014-4-29 下午03:34:35
	 * @version V2.0
	 * @throws Exception 
	 */
	public static Integer appointEndValue(Integer endValue) throws Exception {
		return appointRangeValue(rand_min, endValue);
	}
}

以上就是简单封装了一些产生随机数的方法，至于怎么调用，就不用多说了！

转载至:http://blog.csdn.net/luo201227/article/details/25055167

在要获取计算机的一些基本信息时，让Java开发人员感觉无所适从，总觉得不好做，因为大家的第一反应可能是动态链接库，使用JNI或JNA来实现，但是求人不如求己，所以就简单的写了一个例子，实现的功能也很简单，只是玩玩。。。。

好啦，先写好bean或者说实体类吧

/**
 * @Description: 
 *
 * @Title: MonitorInfoBean.java
 * @Package com.joyce.bean
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-4-24 上午11:07:59
 * @version V2.0
 */
package com.joyce.bean;

/**
 * @Description:
 * 
 * @ClassName: MonitorInfoBean
 * @Copyright: Copyright (c) 2014
 * 
 * @author Comsys-LZP
 * @date 2014-4-24 上午11:07:59
 * @version V2.0
 */
public class MonitorInfoBean {
	/** 可使用内存. */
	private long totalMemory;

	/** 剩余内存. */
	private long freeMemory;

	/** 最大可使用内存. */
	private long maxMemory;

	/** 操作系统. */
	private String osName;

	/** 总的物理内存. */
	private long totalMemorySize;

	/** 剩余的物理内存. */
	private long freePhysicalMemorySize;

	/** 已使用的物理内存. */
	private long usedMemory;

	/** 线程总数. */
	private int totalThread;

	/** cpu使用率. */
	private double cpuRatio;

	/**
	 * @return the totalMemory
	 */
	public long getTotalMemory() {
		return totalMemory;
	}

	/**
	 * @param totalMemory
	 *            the totalMemory to set
	 */
	public void setTotalMemory(long totalMemory) {
		this.totalMemory = totalMemory;
	}

	/**
	 * @return the freeMemory
	 */
	public long getFreeMemory() {
		return freeMemory;
	}

	/**
	 * @param freeMemory
	 *            the freeMemory to set
	 */
	public void setFreeMemory(long freeMemory) {
		this.freeMemory = freeMemory;
	}

	/**
	 * @return the maxMemory
	 */
	public long getMaxMemory() {
		return maxMemory;
	}

	/**
	 * @param maxMemory
	 *            the maxMemory to set
	 */
	public void setMaxMemory(long maxMemory) {
		this.maxMemory = maxMemory;
	}

	/**
	 * @return the osName
	 */
	public String getOsName() {
		return osName;
	}

	/**
	 * @param osName
	 *            the osName to set
	 */
	public void setOsName(String osName) {
		this.osName = osName;
	}

	/**
	 * @return the totalMemorySize
	 */
	public long getTotalMemorySize() {
		return totalMemorySize;
	}

	/**
	 * @param totalMemorySize
	 *            the totalMemorySize to set
	 */
	public void setTotalMemorySize(long totalMemorySize) {
		this.totalMemorySize = totalMemorySize;
	}

	/**
	 * @return the freePhysicalMemorySize
	 */
	public long getFreePhysicalMemorySize() {
		return freePhysicalMemorySize;
	}

	/**
	 * @param freePhysicalMemorySize
	 *            the freePhysicalMemorySize to set
	 */
	public void setFreePhysicalMemorySize(long freePhysicalMemorySize) {
		this.freePhysicalMemorySize = freePhysicalMemorySize;
	}

	/**
	 * @return the usedMemory
	 */
	public long getUsedMemory() {
		return usedMemory;
	}

	/**
	 * @param usedMemory
	 *            the usedMemory to set
	 */
	public void setUsedMemory(long usedMemory) {
		this.usedMemory = usedMemory;
	}

	/**
	 * @return the totalThread
	 */
	public int getTotalThread() {
		return totalThread;
	}

	/**
	 * @param totalThread
	 *            the totalThread to set
	 */
	public void setTotalThread(int totalThread) {
		this.totalThread = totalThread;
	}

	/**
	 * @return the cpuRatio
	 */
	public double getCpuRatio() {
		return cpuRatio;
	}

	/**
	 * @param cpuRatio
	 *            the cpuRatio to set
	 */
	public void setCpuRatio(double cpuRatio) {
		this.cpuRatio = cpuRatio;
	}

	/**
	 * 
	 */
	public MonitorInfoBean() {
		super();
	}

	/**
	 * @param totalMemory
	 * @param freeMemory
	 * @param maxMemory
	 * @param osName
	 * @param totalMemorySize
	 * @param freePhysicalMemorySize
	 * @param usedMemory
	 * @param totalThread
	 * @param cpuRatio
	 */
	public MonitorInfoBean(long totalMemory, long freeMemory, long maxMemory,
			String osName, long totalMemorySize, long freePhysicalMemorySize,
			long usedMemory, int totalThread, double cpuRatio) {
		super();
		this.totalMemory = totalMemory;
		this.freeMemory = freeMemory;
		this.maxMemory = maxMemory;
		this.osName = osName;
		this.totalMemorySize = totalMemorySize;
		this.freePhysicalMemorySize = freePhysicalMemorySize;
		this.usedMemory = usedMemory;
		this.totalThread = totalThread;
		this.cpuRatio = cpuRatio;
	}
}

其实封装实体对象，只是为了后面开发更加方便，习惯问题，这里接着来实现类：

/**
 * @Description: 
 *
 * @Title: MonitorServiceImpl.java
 * @Package com.joyce.service.impl
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-4-24 上午11:14:53
 * @version V2.0
 */
package com.joyce.service.impl;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.util.StringTokenizer;

import sun.management.ManagementFactory;

import com.joyce.bean.MonitorInfoBean;
import com.joyce.service.IMonitorService;
import com.joyce.util.Bytes;
import com.sun.management.OperatingSystemMXBean;

/**
 * @Description:
 * 
 * @ClassName: MonitorServiceImpl
 * @Copyright: Copyright (c) 2014
 * 
 * @author Comsys-LZP
 * @date 2014-4-24 上午11:14:53
 * @version V2.0
 */
public class MonitorServiceImpl implements IMonitorService {
	private static final int CPUTIME = 30;
	private static final int PERCENT = 100;
	private static final int FAULTLENGTH = 10;
	private static String linuxVersion = null;

	@Override
	public MonitorInfoBean getMonitorInfoBean() throws Exception {
		int kb = 1024;

		// 可使用内存
		long totalMemory = Runtime.getRuntime().totalMemory() / kb;
		// 剩余内存
		long freeMemory = Runtime.getRuntime().freeMemory() / kb;
		// 最大可使用内存
		long maxMemory = Runtime.getRuntime().maxMemory() / kb;

		OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();

		// 操作系统
		String osName = System.getProperty("os.name");
		// 总的物理内存
		long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;
		// 剩余的物理内存
		long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb;
		// 已使用的物理内存
		long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb
				.getFreePhysicalMemorySize())
				/ kb;

		// 获得线程总数
		ThreadGroup parentThread;
		for (parentThread = Thread.currentThread().getThreadGroup(); parentThread
				.getParent() != null; parentThread = parentThread.getParent())
			;
		int totalThread = parentThread.activeCount();

		double cpuRatio = 0;
		if (osName.toLowerCase().startsWith("windows")) {
			cpuRatio = this.getCpuRatioForWindows();
		} else {
			cpuRatio = this.getCpuRateForLinux();
		}

		// 构造返回对象
		MonitorInfoBean infoBean = new MonitorInfoBean();
		infoBean.setFreeMemory(freeMemory);
		infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize);
		infoBean.setMaxMemory(maxMemory);
		infoBean.setOsName(osName);
		infoBean.setTotalMemory(totalMemory);
		infoBean.setTotalMemorySize(totalMemorySize);
		infoBean.setTotalThread(totalThread);
		infoBean.setUsedMemory(usedMemory);
		infoBean.setCpuRatio(cpuRatio);
		return infoBean;
	}
	
	/**
	 * @Description:获取Linux下CPU的使用率 
	 *
	 * @return
	 *
	 * @Title: MonitorServiceImpl.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-5-5 下午04:01:41
	 * @version V2.0
	 */
	private double getCpuRateForLinux() {
		InputStream is = null;
		InputStreamReader isr = null;
		BufferedReader brStat = null;
		StringTokenizer tokenStat = null;
		try {
			System.out.println("Get usage rate of CUP , linux version: "
					+ linuxVersion);

			Process process = Runtime.getRuntime().exec("top -b -n 1");
			is = process.getInputStream();
			isr = new InputStreamReader(is);
			brStat = new BufferedReader(isr);

			if (linuxVersion.equals("2.4")) {
				brStat.readLine();
				brStat.readLine();
				brStat.readLine();
				brStat.readLine();

				tokenStat = new StringTokenizer(brStat.readLine());
				tokenStat.nextToken();
				tokenStat.nextToken();
				String user = tokenStat.nextToken();
				tokenStat.nextToken();
				String system = tokenStat.nextToken();
				tokenStat.nextToken();
				String nice = tokenStat.nextToken();

				System.out.println(user + " , " + system + " , " + nice);

				user = user.substring(0, user.indexOf("%"));
				system = system.substring(0, system.indexOf("%"));
				nice = nice.substring(0, nice.indexOf("%"));

				float userUsage = new Float(user).floatValue();
				float systemUsage = new Float(system).floatValue();
				float niceUsage = new Float(nice).floatValue();

				return (userUsage + systemUsage + niceUsage) / 100;
			} else {
				brStat.readLine();
				brStat.readLine();

				tokenStat = new StringTokenizer(brStat.readLine());
				tokenStat.nextToken();
				tokenStat.nextToken();
				tokenStat.nextToken();
				tokenStat.nextToken();
				tokenStat.nextToken();
				tokenStat.nextToken();
				tokenStat.nextToken();
				String cpuUsage = tokenStat.nextToken();

				System.out.println("CPU idle : " + cpuUsage);
				Float usage = new Float(cpuUsage.substring(0, cpuUsage
						.indexOf("%")));

				return (1 - usage.floatValue() / 100);
			}

		} catch (IOException ioe) {
			System.out.println(ioe.getMessage());
			freeResource(is, isr, brStat);
			return 1;
		} finally {
			freeResource(is, isr, brStat);
		}

	}

	private static void freeResource(InputStream is, InputStreamReader isr,
			BufferedReader br) {
		try {
			if (is != null)
				is.close();
			if (isr != null)
				isr.close();
			if (br != null)
				br.close();
		} catch (IOException ioe) {
			System.out.println(ioe.getMessage());
		}
	}

	/**
	 * @Description: 获取Windows下CPU的使用率 
	 *
	 * @return
	 *
	 * @Title: MonitorServiceImpl.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-5-5 下午04:02:12
	 * @version V2.0
	 */
	private double getCpuRatioForWindows() { 
        try { 
            String procCmd = System.getenv("windir") 
                    + "\\system32\\wbem\\wmic.exe process get Caption,CommandLine," 
                    + "KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount"; 
            // 取进程信息 
            long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd)); 
            Thread.sleep(CPUTIME); 
            long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd)); 
            if (c0 != null && c1 != null) { 
                long idletime = c1[0] - c0[0]; 
                long busytime = c1[1] - c0[1]; 
                return Double.valueOf( 
                        PERCENT * (busytime) / (busytime + idletime)) 
                        .doubleValue(); 
            } else { 
                return 0.0; 
            } 
        } catch (Exception ex) { 
            ex.printStackTrace(); 
            return 0.0; 
        } 
    }
	
	/**
	 * @Description: 读取CPU信息
	 *
	 * @param proc
	 * @return
	 *
	 * @Title: MonitorServiceImpl.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-5-5 下午04:02:37
	 * @version V2.0
	 */
	private long[] readCpu(final Process proc) { 
        long[] retn = new long[2]; 
        try { 
            proc.getOutputStream().close(); 
            InputStreamReader ir = new InputStreamReader(proc.getInputStream()); 
            LineNumberReader input = new LineNumberReader(ir); 
            String line = input.readLine(); 
            if (line == null || line.length() < FAULTLENGTH) { 
                return null; 
            } 
            int capidx = line.indexOf("Caption"); 
            int cmdidx = line.indexOf("CommandLine"); 
            int rocidx = line.indexOf("ReadOperationCount"); 
            int umtidx = line.indexOf("UserModeTime"); 
            int kmtidx = line.indexOf("KernelModeTime"); 
            int wocidx = line.indexOf("WriteOperationCount"); 
            long idletime = 0; 
            long kneltime = 0; 
            long usertime = 0; 
            while ((line = input.readLine()) != null) { 
                if (line.length() < wocidx) { 
                    continue; 
                } 
                // 字段出现顺序：Caption,CommandLine,KernelModeTime,ReadOperationCount, 
                // ThreadCount,UserModeTime,WriteOperation 
                String caption = Bytes.substring(line, capidx, cmdidx - 1) 
                        .trim(); 
                String cmd = Bytes.substring(line, cmdidx, kmtidx - 1).trim(); 
                if (cmd.indexOf("wmic.exe") >= 0) { 
                    continue; 
                } 
                // log.info("line="+line); 
                if (caption.equals("System Idle Process") 
                        || caption.equals("System")) { 
                    idletime += Long.valueOf( 
                            Bytes.substring(line, kmtidx, rocidx - 1).trim()) 
                            .longValue(); 
                    idletime += Long.valueOf( 
                            Bytes.substring(line, umtidx, wocidx - 1).trim()) 
                            .longValue(); 
                    continue; 
                } 

                kneltime += Long.valueOf( 
                        Bytes.substring(line, kmtidx, rocidx - 1).trim()) 
                        .longValue(); 
                usertime += Long.valueOf( 
                        Bytes.substring(line, umtidx, wocidx - 1).trim()) 
                        .longValue(); 
            } 
            retn[0] = idletime; 
            retn[1] = kneltime + usertime; 
            return retn; 
        } catch (Exception ex) { 
            ex.printStackTrace(); 
        } finally { 
            try { 
                proc.getInputStream().close(); 
            } catch (Exception e) { 
                e.printStackTrace(); 
            } 
        } 
        return null; 
    }
	
	/**
	 * @Description: 测试
	 *
	 * @param args
	 * @throws Exception
	 *
	 * @Title: MonitorServiceImpl.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-5-5 下午04:02:50
	 * @version V2.0
	 */
	public static void main(String[] args) throws Exception {
		IMonitorService service = new MonitorServiceImpl();
		MonitorInfoBean monitorInfo = service.getMonitorInfoBean();
		System.out.println("cpu占有率=" + monitorInfo.getCpuRatio());

		System.out.println("可使用内存=" + monitorInfo.getTotalMemory());
		System.out.println("剩余内存=" + monitorInfo.getFreeMemory());
		System.out.println("最大可使用内存=" + monitorInfo.getMaxMemory());

		System.out.println("操作系统=" + monitorInfo.getOsName());
		System.out.println("总的物理内存=" + monitorInfo.getTotalMemorySize() + "kb");
		System.out.println("剩余的物理内存=" + monitorInfo.getFreeMemory() + "kb");
		System.out.println("已使用的物理内存=" + monitorInfo.getUsedMemory() + "kb");
		System.out.println("线程总数=" + monitorInfo.getTotalThread() + "kb");
	}
}

大家应该看出来了，怎么还有一个接口类没有呢，真的不想贴的，但是为了那些刚上手的或者很B的人还是贴上吧

/**
 * @Description: 
 *
 * @Title: IMonitorService.java
 * @Package com.joyce.service
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-4-24 上午11:11:17
 * @version V2.0
 */
package com.joyce.service;

import com.joyce.bean.MonitorInfoBean;

/**
 * @Description: 
 *
 * @ClassName: IMonitorService
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-4-24 上午11:11:17
 * @version V2.0
 */
public interface IMonitorService {
	public MonitorInfoBean getMonitorInfoBean() throws Exception;
}

是不是很简单呀，好啦！至于怎么在界面上去展示，我就不在这里说了，有完整的案例，包括了以上看到的部分内容，还有ExtJs4的图表，这里就把测试运行结果就大伙看看啦

cpu占有率=16.0
可使用内存=5056
剩余内存=4794
最大可使用内存=65088
操作系统=Windows Vista
总的物理内存=4148916kb
剩余的物理内存=4794kb
已使用的物理内存=3478464kb
线程总数=5kb

其实Java也可以的吧，别怕，亲们，放手去搞！完整demo已上传，如需请下载：http://download.csdn.net/download/luo201227/7297885

转载至:http://blog.csdn.net/luo201227/article/details/25057311

很多情况下我们需要获取到系统中一些可执行文件的版本号，以便做一些附加动作！其实可以使用jna获取，但是这将依赖人家，所以还是Java自己来吧！好啦，直接上代码吧

/**
 * @Description: 
 *
 * @Title: FileInfoUtil.java
 * @Package com.joyce.util
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-5-12 下午03:46:32
 * @version V2.0
 */
package com.joyce.util;

import java.io.File;
import java.io.RandomAccessFile;

/**
 * @Description:文件操作工具类
 * 
 * @ClassName: FileInfoUtil
 * @Copyright: Copyright (c) 2014
 * 
 * @author Comsys-LZP
 * @date 2014-5-12 下午03:46:32
 * @version V2.0
 */
public class FileInfoUtil {
	
	/**
	 * @Description: 获取文件版本信息 
	 *
	 * @param file
	 * @return
	 *
	 * @Title: FileInfoUtil.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-5-12 下午04:36:17
	 * @version V2.0
	 */
	public static String getVersion(File file) {
		RandomAccessFile raf = null;
		byte[] buffer;
		String str;
		try {
			raf = new RandomAccessFile(file, "r");
			buffer = new byte[64];
			raf.read(buffer);
			str = "" + (char) buffer[0] + (char) buffer[1];
			if (!"MZ".equals(str)) {
				return null;
			}

			int peOffset = unpack(new byte[] { buffer[60], buffer[61],
					buffer[62], buffer[63] });
			if (peOffset < 64) {
				return null;
			}

			raf.seek(peOffset);
			buffer = new byte[24];
			raf.read(buffer);
			str = "" + (char) buffer[0] + (char) buffer[1];
			if (!"PE".equals(str)) {
				return null;
			}
			int machine = unpack(new byte[] { buffer[4], buffer[5] });
			if (machine != 332) {
				return null;
			}

			int noSections = unpack(new byte[] { buffer[6], buffer[7] });
			int optHdrSize = unpack(new byte[] { buffer[20], buffer[21] });
			raf.seek(raf.getFilePointer() + optHdrSize);
			boolean resFound = false;
			for (int i = 0; i < noSections; i++) {
				buffer = new byte[40];
				raf.read(buffer);
				str = "" + (char) buffer[0] + (char) buffer[1]
						+ (char) buffer[2] + (char) buffer[3]
						+ (char) buffer[4];
				if (".rsrc".equals(str)) {
					resFound = true;
					break;
				}
			}
			if (!resFound) {
				return null;
			}

			int infoVirt = unpack(new byte[] { buffer[12], buffer[13],
					buffer[14], buffer[15] });
			int infoSize = unpack(new byte[] { buffer[16], buffer[17],
					buffer[18], buffer[19] });
			int infoOff = unpack(new byte[] { buffer[20], buffer[21],
					buffer[22], buffer[23] });
			raf.seek(infoOff);
			buffer = new byte[infoSize];
			raf.read(buffer);
			int nameEntries = unpack(new byte[] { buffer[12], buffer[13] });
			int idEntries = unpack(new byte[] { buffer[14], buffer[15] });
			boolean infoFound = false;
			int subOff = 0;
			for (int i = 0; i < (nameEntries + idEntries); i++) {
				int type = unpack(new byte[] { buffer[i * 8 + 16],
						buffer[i * 8 + 17], buffer[i * 8 + 18],
						buffer[i * 8 + 19] });
				if (type == 16) { // FILEINFO resource
					infoFound = true;
					subOff = unpack(new byte[] { buffer[i * 8 + 20],
							buffer[i * 8 + 21], buffer[i * 8 + 22],
							buffer[i * 8 + 23] });
					break;
				}
			}
			if (!infoFound) {
				return null;
			}

			subOff = subOff & 0x7fffffff;
			infoOff = unpack(new byte[] { buffer[subOff + 20],
					buffer[subOff + 21], buffer[subOff + 22],
					buffer[subOff + 23] }); // offset of first FILEINFO
			infoOff = infoOff & 0x7fffffff;
			infoOff = unpack(new byte[] { buffer[infoOff + 20],
					buffer[infoOff + 21], buffer[infoOff + 22],
					buffer[infoOff + 23] }); // offset to data
			int dataOff = unpack(new byte[] { buffer[infoOff],
					buffer[infoOff + 1], buffer[infoOff + 2],
					buffer[infoOff + 3] });
			dataOff = dataOff - infoVirt;

			int version1 = unpack(new byte[] { buffer[dataOff + 48],
					buffer[dataOff + 48 + 1] });
			int version2 = unpack(new byte[] { buffer[dataOff + 48 + 2],
					buffer[dataOff + 48 + 3] });
			int version3 = unpack(new byte[] { buffer[dataOff + 48 + 4],
					buffer[dataOff + 48 + 5] });
			int version4 = unpack(new byte[] { buffer[dataOff + 48 + 6],
					buffer[dataOff + 48 + 7] });
			return version2 + "." + version1 + "." + version4 + "." + version3;
		} catch (Exception e) {
			return null;
		} finally {
			if (raf != null) {
				try {
					raf.close();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static int unpack(byte[] b) {
		int num = 0;
		for (int i = 0; i < b.length; i++) {
			num = 256 * num + (b[b.length - 1 - i] & 0xff);
		}
		return num;
	}

	public static void main(String[] args) {
		try {
//			String filePath = "D:\\Program Files (x86)\\Wiz\\Wiz.exe";
			String filePath = "D:\\Program Files (x86)\\360\\360Chrome\\Chrome\\Application\\360chrome.exe";
			File file = new File(filePath);
			System.out.println("软件版本号：" + getVersion(file));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

真的很赞，效果美极了！

附上完整文件资源下载地址：http://download.csdn.net/download/luo201227/7336013

转载至:http://blog.csdn.net/luo201227/article/details/25638735

由于Java在开发网页上占有绝大优势，所以作为web端的领军人物，譬如发送短信和发送邮件这些就成了必然，网络安全一再安全我们需要把账号的安全级别提到更高！因此这些对于开发人员也就成了必须掌握的技能！我一直都觉得作为开发人员，不怕在开发的过程中遇到多少难题，而是有没有去解决它的勇气和决心，这里多学习就成为了关键，成为了一个程序猿发展的重中之重！好啦，闲话就说到这里，来点实际的！

当一个开发人员工作到一定程度后，面向对象的思维就会一直在他的老子里围绕！所以我们先把邮件的常量类、实体类以及工具类等等先该封装的封装，该继承的继承！代码来了，睁大眼睛：

/**
 * @Description: 
 *
 * @Title: SimpleMail.java
 * @Package com.joyce.bean
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-5-28 上午09:06:51
 * @version V2.0
 */
package com.joyce.mail.bean;

/**
 * @Description:邮件信息类
 * 
 * @ClassName: SimpleMail
 * @Copyright: Copyright (c) 2014
 * 
 * @author Comsys-LZP
 * @date 2014-5-28 上午09:06:51
 * @version V2.0
 */
public class Mail {
	/**
	 * 主题
	 */
	private String subject;
	/**
	 * 内容
	 */
	private String content;

	/**
	 * @return the subject
	 */
	public String getSubject() {
		return subject;
	}

	/**
	 * @param subject
	 *            the subject to set
	 */
	public void setSubject(String subject) {
		this.subject = subject;
	}

	/**
	 * @return the content
	 */
	public String getContent() {
		return content;
	}

	/**
	 * @param content
	 *            the content to set
	 */
	public void setContent(String content) {
		this.content = content;
	}
}

上面大家看到的就是发送邮件一般必不可少的邮件标题和邮件内容，作为在邮件使用广泛的那就免不了封装起来了，好啦，接下来咱们看邮箱的登录类：

/**
 * @Description: 
 *
 * @Title: MailAuthenticator.java
 * @Package com.joyce.bean
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-5-28 上午08:59:11
 * @version V2.0
 */
package com.joyce.mail.bean;

import javax.mail.Authenticator;
import javax.mail.PasswordAuthentication;

/**
 * @Description: 邮箱登录类
 *
 * @ClassName: MailAuthenticator
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-5-28 上午08:59:11
 * @version V2.0
 */
public class MailAuthenticator extends Authenticator {
	/**
     * 用户名（登录邮箱）
     */
    private String username;
    
    /**
     * 密码
     */
    private String password;

	/**
	 * @return the username
	 */
	public String getUsername() {
		return username;
	}

	/**
	 * @param username the username to set
	 */
	public void setUsername(String username) {
		this.username = username;
	}

	/**
	 * @return the password
	 */
	public String getPassword() {
		return password;
	}

	/**
	 * @param password the password to set
	 */
	public void setPassword(String password) {
		this.password = password;
	}

	/**
	 * @param username
	 * @param password
	 */
	public MailAuthenticator(String username, String password) {
		this.username = username;
		this.password = password;
	}
	
	@Override
	protected PasswordAuthentication getPasswordAuthentication() {
	    return new PasswordAuthentication(username, password);
    }
}

这时候我们需要的常量类就应该进来了

package com.joyce.mail.bean;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @Description: 邮件发送常量类
 *
 * @ClassName: MailConstant
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-5-28 上午11:01:16
 * @version V2.0
 */
public class MailConstant {
	public static final String MAIL_USER = "luo201227@163.com"; 
	public static final String MAIL_PWD = "*****";
	public static final boolean MAIL_IFDEBUG = true;
	public static final String MAIL_CONTENT_CHARSET = "text/html;charset=utf-8"; 
	public static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E");
	public static final String MAIL_TITLE = "*********账号激活码" + sdf.format(new Date());//邮件标题
	public static String getMailContent(String content){
		StringBuffer sb = new StringBuffer();
		sb.append("<div style='width:1024px;height:auto;margin:0px auto;background-color:#66CCFF;font-size:14px;font-family:微软雅黑;border-radius:5px;padding:5px;'><center><h1>");
		sb.append("</h1></center><div style='margin-left:20px;margin-bottom:10px;'><b>尊敬的用户，您好！</b><br/><br/>");
		sb.append("    <b></b>"+content);		
		sb.append("</div></div>");
		return sb.toString();
	}
}

关键来了，看看发送邮件的关键部分吧

/**
 * @Description: 
 *
 * @Title: MailSender.java
 * @Package com.joyce.service.impl
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-5-28 上午09:03:08
 * @version V2.0
 */
package com.hupu.nac.mail.sender;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Properties;
import java.util.Vector;

import javax.activation.DataHandler;
import javax.activation.FileDataSource;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;

import com.hupu.nac.mail.bean.Mail;
import com.hupu.nac.mail.bean.MailAuthenticator;
import com.hupu.nac.mail.bean.MailConstant;

/**
 * @Description:邮件发送类
 * 
 * @ClassName: MailSender
 * @Copyright: Copyright (c) 2014
 * 
 * @author Comsys-LZP
 * @date 2014-5-28 上午09:03:08
 * @version V2.0
 */
public class MailSender {
	/**
	 * 发送邮件的props文件
	 */
	private final transient Properties props = new Properties();
	/**
	 * 邮件服务器登录验证
	 */
	private transient MailAuthenticator authenticator;

	/**
	 * 邮箱session
	 */
	private transient Session session;

	/**
	 * 初始化邮件发送器
	 * 
	 * @param smtpHostName
	 *            SMTP邮件服务器地址
	 * @param username
	 *            发送邮件的用户名(地址)
	 * @param password
	 *            发送邮件的密码
	 */
	public MailSender(final String smtpHostName, final String username,
			final String password) {
		init(username, password, smtpHostName);
	}

	/**
	 * 初始化邮件发送器
	 * 
	 * @param username
	 *            发送邮件的用户名(地址)，并以此解析SMTP服务器地址
	 * @param password
	 *            发送邮件的密码
	 */
	public MailSender(final String username, final String password) {
		// 通过邮箱地址解析出smtp服务器，对大多数邮箱都管用
		final String smtpHostName = "smtp." + username.split("@")[1];
		init(username, password, smtpHostName);

	}

	/**
	 * @Description: 初始化
	 * 
	 * @param username
	 *            发送邮件的用户名(地址)
	 * @param password
	 *            密码
	 * @param smtpHostName
	 *            SMTP主机地址
	 * 
	 * @Title: MailSender.java
	 * @Copyright: Copyright (c) 2014
	 * 
	 * @author Comsys-LZP
	 * @date 2014-5-28 上午09:18:31
	 * @version V2.0
	 */
	private void init(String username, String password, String smtpHostName) {
		// 初始化props
		props.put("mail.smtp.host", smtpHostName);
		props.put("mail.smtp.auth", "true");
		// 验证
		authenticator = new MailAuthenticator(username, password);
		// 创建session
		session = Session.getInstance(props, authenticator);
		// 打印一些调试信息
		session.setDebug(MailConstant.MAIL_IFDEBUG);
	}

	/**
	 * @Description: 发送邮件
	 * 
	 * @param recipient
	 *            收件人邮箱地址
	 * @param subject
	 *            邮件主题
	 * @param content
	 *            邮件内容
	 * @throws AddressException
	 * @throws MessagingException
	 * 
	 * @Title: MailSender.java
	 * @Copyright: Copyright (c) 2014
	 * 
	 * @author Comsys-LZP
	 * @date 2014-5-28 上午09:19:16
	 * @version V2.0
	 */
	public void send(String recipient, String subject, Object content) throws Exception {
		send(recipient, subject, content, null);
	}

	/**
	 * 发送邮件
	 * 
	 * @param recipient
	 *            收件人邮箱地址
	 * @param subject
	 *            邮件主题
	 * @param content
	 *            邮件内容
	 * @param files
	 *            附件
	 * @throws Exception
	 * @author Joyce.Luo
	 * @date 2014-10-15 上午10:23:09
	 * @version V3.0
	 * @since Tomcat6.0,Jdk1.6
	 * @copyright: Copyright (c) 2014
	 */
	public void send(String recipient, String subject, Object content, Vector<File> files) throws Exception {
		// 创建mime类型邮件
		final MimeMessage message = new MimeMessage(session);
		// 设置发信人
		message.setFrom(new InternetAddress(authenticator.getUsername()));
		// 设置收件人
		message.setRecipient(Message.RecipientType.TO, new InternetAddress(
				recipient));
		// 设置主题
		message.setSubject(subject);
		// 设置邮件内容
		if (null == files || files.size() == 0) {
			message.setContent(content.toString(), MailConstant.MAIL_CONTENT_CHARSET);
		} else {
			//创建 Mimemultipart添加内容(可包含多个附件)
			MimeMultipart multipart = new MimeMultipart();
			//MimeBodyPart(用于信件内容/附件)
			BodyPart bodyPart = new MimeBodyPart();
			bodyPart.setContent(content.toString(), MailConstant.MAIL_CONTENT_CHARSET);
			//添加到MimeMultipart对象中
			multipart.addBodyPart(bodyPart);
			for (int i = 0; i < files.size(); i++) {
				File file = (File) files.elementAt(i);
				String fname = file.getName();
				//创建FileDAtaSource(用于添加附件)
				FileDataSource fds = new FileDataSource(file);
				BodyPart fileBodyPart = new MimeBodyPart();
				// 字符流形式装入文件
				fileBodyPart.setDataHandler(new DataHandler(fds));
				// 设置附件文件名
				fileBodyPart.setFileName(fname);
				multipart.addBodyPart(fileBodyPart);
				message.setContent(multipart);
			}
		}
		// 设置发信时间
		message.setSentDate(new Date());
		// 存储邮件信息
		message.saveChanges();
//		message.setFileName(filename)
		// 发送邮件
		Transport.send(message);
	}

	/**
	 * @Description: 群发邮件
	 * 
	 * @param recipients
	 *            收件人们
	 * @param subject
	 *            主题
	 * @param content
	 *            内容
	 * @throws AddressException
	 * @throws MessagingException
	 * 
	 * @Title: MailSender.java
	 * @Copyright: Copyright (c) 2014
	 * 
	 * @author Comsys-LZP
	 * @date 2014-5-28 上午09:20:24
	 * @version V2.0
	 */
	public void send(List<String> recipients, String subject, Object content) throws Exception {
		send(recipients, subject, content, null);
	}

	/**
	 * 群发邮件
	 * 
	 * @param recipients
	 *            收件人们
	 * @param subject
	 *            主题
	 * @param content
	 *            内容
	 * @param files
	 *            附件
	 * @throws Exception
	 * @author Joyce.Luo
	 * @date 2014-10-15 上午10:26:35
	 * @version V3.0
	 * @since Tomcat6.0,Jdk1.6
	 * @copyright: Copyright (c) 2014
	 */
	public void send(List<String> recipients, String subject, Object content, Vector<File> files) throws Exception {
		// 创建mime类型邮件
		final MimeMessage message = new MimeMessage(session);
		// 设置发信人
		message.setFrom(new InternetAddress(authenticator.getUsername()));
		// 设置收件人们
		final int num = recipients.size();
		InternetAddress[] addresses = new InternetAddress[num];
		for (int i = 0; i < num; i++) {
			addresses[i] = new InternetAddress(recipients.get(i));
		}
		message.setRecipients(Message.RecipientType.TO, addresses);
		// 设置主题
		message.setSubject(subject);
		// 设置邮件内容
		if (null == files || files.size() == 0) {
			message.setContent(content.toString(), MailConstant.MAIL_CONTENT_CHARSET);
		} else {
			 //创建 Mimemultipart添加内容(可包含多个附件)
			MimeMultipart multipart = new MimeMultipart();
			  //MimeBodyPart(用于信件内容/附件)
			BodyPart bodyPart = new MimeBodyPart();
			bodyPart.setContent(content.toString(), MailConstant.MAIL_CONTENT_CHARSET);
			 //添加到MimeMultipart对象中
			multipart.addBodyPart(bodyPart);
			for (int i = 0; i < files.size(); i++) {
				File file = (File) files.elementAt(i);
				String fname = file.getName();
				//创建FileDAtaSource(用于添加附件)
				FileDataSource fds = new FileDataSource(file);
				BodyPart fileBodyPart = new MimeBodyPart();
				// 字符流形式装入文件
				fileBodyPart.setDataHandler(new DataHandler(fds));
				// 设置附件文件名
				fname = new String(fname.getBytes("UTF-8"), "ISO-8859-1");
				fileBodyPart.setFileName(fname);
				multipart.addBodyPart(fileBodyPart);
				message.setContent(multipart);
			}
		}
		// 设置发信时间
		message.setSentDate(new Date());
		// 存储邮件信息
		message.saveChanges();
		// 发送邮件
		Transport.send(message);
	}

	/**
	 * @Description: 发送邮件
	 * 
	 * @param recipient
	 *            收件人邮箱地址
	 * @param mail
	 *            邮件对象
	 * @throws Exception
	 * 
	 * @Title: MailSender.java
	 * @Copyright: Copyright (c) 2014
	 * 
	 * @author Comsys-LZP
	 * @date 2014-5-28 上午09:20:54
	 * @version V2.0
	 */
	public void send(String recipient, Mail mail) throws Exception {
		send(recipient, mail.getSubject(), mail.getContent());
	}

	/**
	 * @Description: 群发邮件
	 * 
	 * @param recipients
	 *            收件人们
	 * @param mail
	 *            邮件对象
	 * @throws Exception
	 * 
	 * @Title: MailSender.java
	 * @Copyright: Copyright (c) 2014
	 * 
	 * @author Comsys-LZP
	 * @date 2014-5-28 上午09:21:19
	 * @version V2.0
	 */
	public void send(List<String> recipients, Mail mail) throws Exception {
		send(recipients, mail.getSubject(), mail.getContent());
	}

	/**
	 * 群发邮件
	 * 
	 * @param recipients
	 *            收件人们
	 * @param mail
	 *            邮件对象
	 * @param files
	 *            附件
	 * @throws Exception
	 * @author Joyce.Luo
	 * @date 2014-10-15 上午10:28:38
	 * @version V3.0
	 * @since Tomcat6.0,Jdk1.6
	 * @copyright: Copyright (c) 2014
	 */
	public void send(List<String> recipients, Mail mail, Vector<File> files) throws Exception {
		send(recipients, mail.getSubject(), mail.getContent(), files);
	}
}

在网页上的激活码或者验证码这类的就不用多说了吧

/**
 * @Description: 
 *
 * @Title: RandomCodeUtil.java
 * @Package com.joyce.mail.util
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-5-28 上午11:07:34
 * @version V2.0
 */
package com.joyce.mail.util;


/**
 * @Description: 随机码工具类
 * 
 * @ClassName: RandomCodeUtil
 * @Copyright: Copyright (c) 2014
 * 
 * @author Comsys-LZP
 * @date 2014-5-28 上午11:07:34
 * @version V2.0
 */
public class RandomCodeUtil {
	/**
	 * 随机码集合
	 */
	private static final String[] randCode = { "0", "1", "2", "3", "4", "5", "6",
			"7", "8", "9", "q", "w", "e", "r", "t", "y", "u", "i", "o", "p",
			"a", "s", "d", "f", "g", "h", "j", "k", "l", "z", "x", "c", "v",
			"b", "n", "m" };
	
	/**
	 * @Description: 产生指定长度的随机码
	 *
	 * @param codeLength
	 * @return
	 *
	 * @Title: RandomCodeUtil.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-5-28 上午11:11:55
	 * @version V2.0
	 */
	public static String randomCode(Integer codeLength) throws Exception {
		try {
			StringBuffer code = new StringBuffer();
			if(null == codeLength || 0 == codeLength){
				codeLength = 4;
			}
			for (int i = 0; i < codeLength; i++) {
				code.append(randCode[(int)Math.floor(Math.random() * 36)]);
			}
			return code.toString();
		} catch (Exception e) {
			throw new RuntimeException("Random Code Error");
		}
	}
	
	/**
	 * @Description: 生成长度为4的随机码
	 *
	 * @return
	 * @throws Exception
	 *
	 * @Title: RandomCodeUtil.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-5-28 下午01:19:33
	 * @version V2.0
	 */
	public static String randomCode() throws Exception{
		return randomCode(null);
	}
}

Ok，利用javax.mail.jar发送邮件就大功告成了！是不是很easy呢！完整的demo资源;下载地址：http://download.csdn.net/download/luo201227/7446279

有段时间了，来更新一下，其实也没有什么很多要说的，只是跟大家提一下，如果有兴趣的，可以去了解一下James邮件服务器的搭建！

转载至:http://blog.csdn.net/luo201227/article/details/28425283

jQuery是一款非常流行的Javascript框架，如果你想要从事Web前端开发这个岗位，那么jQuery是你必须掌握而且能够熟练应用的一门技术。本文整理了一些关于jQuery的经典面试题及答案，分享给正要面试Web开发岗位的同学。

问题：jQuery的美元符号$有什么作用？

回答：其实美元符号$只是”jQuery”的别名，它是jQuery的选择器，如下代码：

$(document).ready(function(){

});

当然你也可以用jQuery来代替$，如下代码：

jQuery(document).ready(function(){

});

jQuery中就是通过这个美元符号来实现各种灵活的DOM元素选择的，例如$(“#main”)即选中id为main的元素。

问题：body中的onload()函数和jQuery中的document.ready()有什么区别？

回答：onload()和document.ready()的区别有以下两点：

1、我们可以在页面中使用多个document.ready()，但只能使用一次onload()。

2、document.ready()函数在页面DOM元素加载完以后就会被调用，而onload()函数则要在所有的关联资源（包括图像、音频）加载完毕后才会调用。

问题：jQuery中有哪几种类型的选择器？

回答：从我自己的角度来讲，可以有3种类型的选择器，如下：

1、基本选择器：直接根据id、css类名、元素名返回匹配的dom元素。

2、层次选择器：也叫做路径选择器，可以根据路径层次来选择相应的DOM元素。

3、过滤选择器：在前面的基础上过滤相关条件，得到匹配的dom元素。

问题：请使用jQuery将页面上的所有元素边框设置为2px宽的虚线？

回答：这正是jQuery选择器上场的时候了，代码如下：

<script language="javascript" type="text/javascript">

         $("*").css("border", "2px dotted red"); 

</script>

问题：当CDN上的jQuery文件不可用时，该怎么办？

回答：为了节省带宽和脚本引用的稳定性，我们会使用CDN上的jQuery文件，例如google的jquery cdn服务。但是如果这些CDN上的jQuery服务不可用，我们还可以通过以下代码来切换到本地服务器的jQuery版本：

<script type="text/javascript" language="Javascript" src="http://ajax.aspnetcdn.com/ajax/jquery/jquery-1.4.1.min.js "></script>

<script type='text/javascript'>//<![CDATA[

if (typeof jQuery == 'undefined') {

document.write(unescape("%3Cscript src='/Script/jquery-1.4.1.min.js' type='text/javascript' %3E%3C/script%3E"));

}//]]>

</script>

问题：如何使用jQuery实现点击按钮弹出一个对话框？

回答：代码如下：

HTML：

<input id="inputField" type="text" size="12"/>

jQuery：

<script type="text/javascript"> 
$(document).ready(function () {
 $('#Button1').click(function () { 
alert($('#inputField').attr("value")); 
}); 
});
 </script>

问题：jQuery中的Delegate()函数有什么作用？

回答：delegate()会在以下两个情况下使用到：

1、如果你有一个父元素，需要给其下的子元素添加事件，这时你可以使用delegate()了，代码如下：

$("ul").delegate("li", "click", function(){

$(this).hide();

});

2、当元素在当前页面中不可用时，可以使用delegate()

问题：怎样用jQuery编码和解码URL？

回答：在jQuery中，我们可以使用以下方法实现URL的编码和解码。

encodeURIComponent(url) and decodeURIComponent(url)

问题：如何用jQuery禁用浏览器的前进后退按钮？

回答：实现代码如下：

<script type="text/javascript" language="javascript">

$(document).ready(function() {

     window.history.forward(1);
     //OR
     window.history.forward(-1);

});

</script>

转载至:http://blog.csdn.net/luo201227/article/details/39177195

至于MINA2是什么，这里就不介绍了，有兴趣的可以自己去问一下度娘！

首先使用MINA2的时候，你最起码的知道怎么下载jar包和在工程中引入哪些jar包。

附上下载地址：http://mirrors.cnnic.cn/apache/mina/mina/2.0.7/dist/apache-mina-2.0.7-bin.zip 和必须引入工程的jar包：mina-core-2.0.7.jar;slf4j-api-1.6.6.jar;slf4j-log4j12-1.7.5.jar，不多说直接上代码：

第一步：编写通信要用的编码器类、解码器类和编解码工厂类

1、字符编码：

/**
 * @Description: 
 *
 * @Title: CharsetEncoder.java
 * @Package com.joyce.mina.code
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-3-19 上午11:48:53
 * @version V2.0
 */
package com.joyce.mina.code;

import java.nio.ByteOrder;
import java.nio.charset.Charset;

import org.apache.log4j.Logger;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolEncoder;
import org.apache.mina.filter.codec.ProtocolEncoderOutput;

/**
 * @Description: 字符编码
 *
 * @ClassName: CharsetEncoder
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-3-19 上午11:48:53
 * @version V2.0
 */
public class CharsetEncoder implements ProtocolEncoder {
	
	/**
	 * Log4j日志
	 */
	private static final Logger logger = Logger.getLogger(CharsetEncoder.class);
	
	private static final Charset charset = Charset.forName("UTF-8");

	@Override
	public void dispose(IoSession session) throws Exception {
		logger.info("#####################dispose#########################");
	}

	@Override
	public void encode(IoSession session, Object message, ProtocolEncoderOutput out) throws Exception {
		logger.debug("#####################encode#########################");
		IoBuffer buff = IoBuffer.allocate(100).setAutoExpand(true);
		buff.order(ByteOrder.LITTLE_ENDIAN);
		String smsgbody = message.toString();
		byte[] bytearr = smsgbody.getBytes(charset);
		buff.put(bytearr);
		// 为下一次读取数据做准备
		buff.flip();
		out.write(buff);
	}
}

2、字符解码：

/**
 * @Description: 
 *
 * @Title: CharsetDecoder.java
 * @Package com.joyce.mina.code
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-3-19 上午11:35:49
 * @version V2.0
 */
package com.joyce.mina.code;

import java.nio.charset.Charset;

import org.apache.log4j.Logger;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolDecoder;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;

/**
 * @Description:  字符解码
 *
 * @ClassName: CharsetDecoder
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-3-19 上午11:35:49
 * @version V2.0
 */
public class CharsetDecoder implements ProtocolDecoder {
	
	/**
	 * Log4j日志
	 */
	private final static Logger logger = Logger.getLogger(CharsetDecoder.class);
	
	private static final Charset charset = Charset.forName("UTF-8");
	// 可变的IoBuffer数据缓冲区
	private IoBuffer buff = IoBuffer.allocate(100).setAutoExpand(true);

	@Override
	public void decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {
		logger.debug("#####################decode#########################");
		// 如果有信息
		if (in.hasRemaining()) {
			// 判断消息是否是结束符，不同平台的结束符也不一样；
                        // windows换行符（\r\n）就认为是一个完整消息的结束符了； UNIX 是\n；MAC 是\r
			byte b = in.get();
			if (b == '\n') {
				buff.flip();
				byte[] bytes = new byte[buff.limit()];
				buff.get(bytes);
				String message = new String(bytes, charset);
				buff = IoBuffer.allocate(100).setAutoExpand(true);
				// 如果结束了，就写入转码后的数据
				out.write(message);
			} else {
				buff.put(b);
			}
		}
	}

	@Override
	public void dispose(IoSession session) throws Exception {
		logger.info("#####################dispose#########################");
		logger.info(session.getCurrentWriteMessage());
		
	}

	@Override
	public void finishDecode(IoSession session, ProtocolDecoderOutput out) throws Exception {
		logger.info("#####################完成解码#########################");
	}
}

上面的decode方法是解码方法，它主要是把读取到数据中的换行符去掉。因为在mina通信协议中以换行符为结束符，如果不定义结束符那么程序会在那里一直等待下一条发送的数据。

这里用到了IoBuffer，MiNa中传输的所有二进制信息都存放在IoBuffer中，IoBuffer是对Java NIO中ByteBuffer的封装（Mina2.0以前版本这个接口也是ByteBuffer），提供了更多操作二进制数据，对象的方法，并且存储空间可以自增长，用起来非常方便；简单理解，它就是个可变长度的byte字节数组！

1). static IoBuffer allocate(int capacity,boolean useDirectBuffer)

创建IoBuffer实例，第一个参数指定初始化容量，第二个参数指定使用直接缓冲区还是JAVA 内存堆的缓存区，默认为false。

2)．IoBuffer setAutoExpand(boolean autoExpand)

这个方法设置IoBuffer 为自动扩展容量，也就是前面所说的长度可变，那么可以看出长度可变这个特性默认是不开启的。

3). IoBuffer flip()

limit=position, position=0,重置mask，为了读取做好准备，一般是结束buffer操作，将buffer写入输出流时调用；这个必须要调用，否则极有可能position!=limit，导致position后面没有数据；每次写入数据到输出流时，必须确保position=limit。

4). IoBuffer clear()与IoBuffer reset()

clear：limit=capacity , position=0,重置mark；它是不清空数据，但从头开始存放数据做准备—相当于覆盖老数据。

reset就是清空数据

5). int remaining()与boolean hasRemaining()

这两个方法一般是在调用了flip方法后使用的，remaining()是返回limt-position的值！hasRemaining()则是判断当前是否有数据，返回position < limit的boolean值！

3、编解码过滤工厂：

/**
 * @Description: 
 *
 * @Title: CharsetCodecFactory.java
 * @Package com.joyce.mina.code.factory
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-3-19 上午11:34:14
 * @version V2.0
 */
package com.joyce.mina.code.factory;

import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFactory;
import org.apache.mina.filter.codec.ProtocolDecoder;
import org.apache.mina.filter.codec.ProtocolEncoder;

import com.joyce.mina.code.CharsetDecoder;
import com.joyce.mina.code.CharsetEncoder;

/**
 * @Description: 字符编码、解码工厂类，编码过滤工厂
 *
 * @ClassName: CharsetCodecFactory
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-3-19 上午11:34:14
 * @version V2.0
 */
public class CharsetCodecFactory implements ProtocolCodecFactory {

	@Override
	public ProtocolDecoder getDecoder(IoSession session) throws Exception {
		return new CharsetDecoder();
	}

	@Override
	public ProtocolEncoder getEncoder(IoSession session) throws Exception {
		return new CharsetEncoder();
	}
}

第二步：编写IoHandler实现类代码

IoHander是Io读写的事件驱动类，这里的Io操作都会触发里面的事件。所有的业务逻辑都应当在这个类中完成，个人建议如果能封装出来的尽量封装出来，否则业务代码会很多很大！我这里就实现了封装

/**
 * @Description: 
 *
 * @Title: ServerMessageReceived.java
 * @Package com.joyce.mina.message
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-3-21 上午08:54:13
 * @version V2.0
 */
package com.joyce.mina.message;

import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;

import org.apache.log4j.Logger;
import org.apache.mina.core.session.IoSession;

/**
 * @Description: 消息处理
 *
 * @ClassName: ServerMessageReceived
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-3-21 上午08:54:13
 * @version V2.0
 */
public class ServerMessageUtil {
	
	/**
	 * Log4j日志对象
	 */
	private static final Logger logger = Logger.getLogger(ServerMessageUtil.class);
	
	/**
	 * @Description: 服务器接收信息处理
	 *
	 * @param session
	 * @param message
	 *
	 * @Title: ServerMessageReceived.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-3-21 上午08:55:53
	 * @version V2.0
	 */
	public static void messageReceived(IoSession session, Object message){
		String content = message.toString();
		String datetime = ServerMessageUtil.getNowDate();
		// 拿到所有的客户端Session
		Collection<IoSession> sessions = ServerMessageUtil.getAllClient(session);
		// 向所有客户端发送数据
		if(content.trim().equals("1")){
			logger.info("在线用户列表：");
			session.write("在线用户列表：\r\n");
			for (IoSession sess : sessions) {
				logger.info("Client" + sess.getId() + "：\t" + sess.getRemoteAddress());
				session.write("Client" + sess.getId() + "：\t" + sess.getRemoteAddress() + "\r\n");
			}
		} else if("2".equals(content.trim())){
			logger.info("说明：");
			StringBuffer sb = new StringBuffer();
			sb.append("说明：");
			sb.append("\r\n");
			sb.append("1、使用@符号进行私聊（@127.0.0.1#你好！-- @ip#你好！）");
			sb.append("\r\n");
			sb.append("2、无@符号属于群聊");
			sb.append("\r\n");
			sb.append("3、新增quit和exit命令退出");
			sb.append("\r\n");
			session.write(sb);
		} else if("quit".equalsIgnoreCase(content.trim()) || "exit".equalsIgnoreCase(content.trim())){
			session.close(true);
		} else if(content.trim().indexOf("@") != -1 && content.trim().indexOf("#") != -1){
			String ip = content.substring(content.indexOf("@") + 1,content.indexOf("#"));
			for (IoSession sess : sessions) {
				logger.info(sess.getRemoteAddress() + "-->IP:" + ip);
				if(sess.getRemoteAddress().toString().indexOf(ip) != -1){
					logger.info("Clinet：" + session.getRemoteAddress() + "即将对" + sess.getRemoteAddress() + "私聊");
					session.write("您对客户端：" + sess.getRemoteAddress() + "说：" + content.substring(content.indexOf("#")+1) + "\n");
					sess.write("客户端：" + session.getRemoteAddress() + "对您说：" + content.substring(content.indexOf("#")+1) + "\n");
				}
			}
		} else if(!"\r".equals(content)) {
			for (IoSession sess : sessions) {
				logger.info("转发给：" + session.getRemoteAddress() + "客户端   messageReceived: " + datetime + "\t" + content);
				sess.write("客户端：" + session.getRemoteAddress() + "在" + datetime + "对所有人说：\t" + content + "\n");
			}
		} else {
			session.write("\r");
		}
	}
	
	/**
	 * @Description: 获取连接所有客户端 
	 *
	 * @param session
	 * @return
	 *
	 * @Title: ServerMessageUtil.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-3-21 上午11:26:47
	 * @version V2.0
	 */
	public static Collection<IoSession> getAllClient(IoSession session){
		// 拿到所有的客户端Session
        	return session.getService().getManagedSessions().values();
	}
	
	/**
	 * @Description: 获取现在时间，并且格式为yyyy-MM-dd hh:mm:ss
	 *
	 * @return
	 *
	 * @Title: ServerMessageUtil.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-3-21 上午11:34:09
	 * @version V2.0
	 */
	public static String getNowDate(){
		 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		 return sdf.format(new Date());
	}
}

上面的就是封装的一些常用的方法和业务处理等。接下来就是IoHandler实现类了

/**
 * @Description: 
 *
 * @Title: ServerMessageHandler.java
 * @Package com.joyce.mina.server.message
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-3-19 上午11:54:31
 * @version V2.0
 */
package com.joyce.mina.server.message;

import java.util.Collection;

import org.apache.log4j.Logger;
import org.apache.mina.core.future.CloseFuture;
import org.apache.mina.core.future.IoFuture;
import org.apache.mina.core.future.IoFutureListener;
import org.apache.mina.core.service.IoHandler;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import com.joyce.mina.message.ServerMessageUtil;

/**
 * @Description: 处理服务器端消息
 *
 * @ClassName: ServerMessageHandler
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-3-19 上午11:54:31
 * @version V2.0
 */
public class ServerMessageHandler implements IoHandler {
	
	private static final Logger logger = Logger.getLogger(ServerMessageHandler.class);

	@Override
	public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
		logger.info("服务器发生异常：" + cause.getMessage());
	}

	@Override
	public void messageReceived(IoSession session, Object message) throws Exception {
		logger.info("服务器接收到数据： " + message);
		ServerMessageUtil.messageReceived(session, message);
	}

	@Override
	public void messageSent(IoSession session, Object message) throws Exception {
		logger.info("服务器发送消息：" + message);
	}

	@Override
	public void sessionClosed(IoSession session) throws Exception {
		logger.info("关闭当前session：" + session.getId() + "#" + session.getRemoteAddress());
        	CloseFuture closeFuture = session.close(true);
        	closeFuture.addListener(new IoFutureListener<IoFuture>() {
			@Override
			public void operationComplete(IoFuture future) {
				if (future instanceof CloseFuture) {
					((CloseFuture) future).setClosed();
					logger.info("sessionClosed CloseFuture setClosed--> " + future.getSession().getId());
				}
			}
		});
        
        	// 获取所有客户端
        	Collection<IoSession> sessions = ServerMessageUtil.getAllClient(session);
        	// 给每个客户端发送离开信息
        	for (IoSession sess : sessions) {
			sess.write("客户端：" + session.getRemoteAddress() + "在" + ServerMessageUtil.getNowDate() + "离开");
		}
	}

	@Override
	public void sessionCreated(IoSession session) throws Exception {
		logger.info("创建一个新连接：" + session.getRemoteAddress());
		StringBuffer info = new StringBuffer();
		info.append("welcome to the joyce chat room !");
		info.append("\r\n\r\n");
		session.write(info);
		
		// 获取所有在线客户端
		Collection<IoSession> sessions = ServerMessageUtil.getAllClient(session);
		for (IoSession sess : sessions) {
			StringBuffer welcome = new StringBuffer();
			welcome.append("客户端：" + session.getRemoteAddress() + "在" + ServerMessageUtil.getNowDate() + "加入!");
			welcome.append("\r\n\r\n");
			sess.write(welcome);
		}
	}

	@Override
	public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
		logger.info("当前连接" + session.getRemoteAddress() + "处于空闲状态：" + status);
	}

	@Override
	public void sessionOpened(IoSession session) throws Exception {
		logger.info("打开一个session：" + session.getId() + "#" + session.getBothIdleCount());
		StringBuffer info = new StringBuffer();
		info.append("1：获取所有在线用户\t2：说明");
		info.append("\r\n");
		session.write(info);
	}
}

sessionCreated：当一个新的连接建立时，由I/O processor thread调用；

sessionOpened：当连接打开是调用；

messageReceived： 当接收了一个消息时调用；

messageSent：当一个消息被(IoSession#write)发送出去后调用；

sessionIdle：当连接进入空闲状态时调用；

sessionClosed：当连接关闭时调用；

exceptionCaught：实现IoHandler的类抛出异常时调用；

一般情况下，我们最关心的只有messageReceived方法，接收消息并处理，然后调用IoSession的write方法发送出消息！（注意：这里接收到的消息都是Java对象，在IoFilter中所有二进制数据都被解码）一般情况下很少有人实现IoHandler接口，而是继承它的一个实现类IoHandlerAdapter，这样不用覆盖它的7个方法，只需要根据具体需求覆盖其中的几个方法就可以！

Iohandler的7个方法其实是根据session的4个状态值间变化来调用的：

 Connected：会话被创建并使用；

 Idle：会话在一段时间(可配置)内没有任何请求到达，进入空闲状态；

 Closing：会话将被关闭（剩余message将被强制flush）；

 Closed：会话被关闭；

第三步：编写Server启动类，bind端口，设置编码过程和核心业务处理器

/**
 * @Description: 
 *
 * @Title: MinaServer.java
 * @Package com.joyce.mina.server
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-3-19 下午12:35:48
 * @version V2.0
 */
package com.joyce.mina.server;

import java.io.IOException;
import java.net.InetSocketAddress;

import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.logging.LogLevel;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.SocketAcceptor;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;

import com.joyce.mina.code.factory.CharsetCodecFactory;
import com.joyce.mina.server.message.ServerMessageHandler;

/**
 * @Description: 服务器启动类 
 *
 * @ClassName: MinaServer
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-3-19 下午12:35:48
 * @version V2.0
 */
public class MinaServer {
	
	private SocketAcceptor acceptor;

	/**
	 * 
	 */
	public MinaServer() {
		// 创建非阻塞的server端的Socket连接
        acceptor = new NioSocketAcceptor();
	}
	
	public boolean start(){
		// 获取过滤器链
		DefaultIoFilterChainBuilder filterChain = acceptor.getFilterChain();
		// 添加编码过滤器 处理乱码、编码问题
		filterChain.addLast("codec", new ProtocolCodecFilter(new CharsetCodecFactory()));
		
		// 添加日志过滤器
		LoggingFilter loggingFilter = new LoggingFilter();
        	loggingFilter.setMessageReceivedLogLevel(LogLevel.INFO);
        	loggingFilter.setMessageSentLogLevel(LogLevel.INFO);
        	filterChain.addLast("logger", loggingFilter);
        
		// 设置核心消息业务处理器
        	acceptor.setHandler(new ServerMessageHandler());
		// 设置session配置，30秒内无操作进入空闲状态
		acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 30);
		try {
			// 绑定端口3456
            		acceptor.bind(new InetSocketAddress(3456));
        	} catch (IOException e) {
            		return false;
        	}
		return true;
	}
	
	public static void main(String[] args) {
		MinaServer server = new MinaServer();
        	server.start();
	}
}

这里只是一个简单的MINA2服务器的启动，框架很成熟很强大，可以通过Spring配置！这方面的先不扯开，有机会再分享！

此时就可以通过输入http://localhost:3456 来访问了，在控制台会有大量数据输出，绝大部分是浏览器的相关信息和服务器发出去的信息！如果懂telnet的程序猿可以去通过telnet连接上去，效果会更佳！

就说到这里了！

来附上完整项目的地址：http://download.csdn.net/download/luo201227/7101013

转载至:http://blog.csdn.net/luo201227/article/details/22150043