InetAddress ia=null;
try {
ia=ia.getLocalHost();

String localname=ia.getHostName();
String localip=ia.getHostAddress();
System.out.println("本机名称是："+ localname);
System.out.println("本机的ip是 ："+localip);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

/**
 * 正则表达式规则：-号出现0或者1次，0-9出现多次，小数点出现0或者1次，0-9出现多次
 * @param str
 * @return
 */
public static boolean isNumeric(String str) {
	if (str != null && !str.isEmpty()) {
		Pattern pattern = Pattern.compile("-?[0-9]*.?[0-9]*");
		Matcher isNum = pattern.matcher(str);
		if (isNum.matches()) {
			return true;
		}
	}
	return false;
}

String countQuery = "select count(*) from (select o.id as id, o.name as orgName, count(t.id) as orgCount from SignUp t, Student s, Org o where t.studentId = s.id and s.orgId=o.id group by o.name) as result"

String countQuery = "select count(distinct o.id) from SignUp t, Student s, Org o where t.studentId = s.id and s.orgId=o.id";

   /**
     * 过滤html标签
     * @param htmlStr
     * @return
     */
    public synchronized static String delHTMLTag(String htmlStr){ 
        String regEx_script="<script[^>]*?>[\\s\\S]*?<\\/script>"; //定义script的正则表达式 
        String regEx_style="<style[^>]*?>[\\s\\S]*?<\\/style>"; //定义style的正则表达式 
        String regEx_html="<[^>]+>"; //定义HTML标签的正则表达式 

        Pattern p_script=Pattern.compile(regEx_script,Pattern.CASE_INSENSITIVE); 
        Matcher m_script=p_script.matcher(htmlStr); 
        htmlStr=m_script.replaceAll(""); //过滤script标签 

        Pattern p_style=Pattern.compile(regEx_style,Pattern.CASE_INSENSITIVE); 
        Matcher m_style=p_style.matcher(htmlStr); 
        htmlStr=m_style.replaceAll(""); //过滤style标签 

        Pattern p_html=Pattern.compile(regEx_html,Pattern.CASE_INSENSITIVE); 
        Matcher m_html=p_html.matcher(htmlStr); 
        htmlStr=m_html.replaceAll(""); //过滤html标签 

        return htmlStr.trim(); //返回文本字符串 
    } 

Calendar calendar = Calendar.getInstance();
	    calendar.setTime(new Date());
	    calendar.set(Calendar.HOUR_OF_DAY, 24);
	    calendar.set(Calendar.MINUTE, 0);
	    calendar.set(Calendar.SECOND, 0);
 Date start = calendar.getTime();

/**
     * 计算指定日期之前或者之后的多少分钟
     * @param date
     * @param minute
     * @return
     */
    public static String getTimeByMinute(Date date, int minute) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MINUTE, minute);
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(calendar.getTime());

    }

try {
	address = new String(address.getBytes("ISO-8859-1"),"UTF-8");
} catch (UnsupportedEncodingException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

// 取得消息类型  
String msgType = inputMsg.getMsgType();
WXEventType.MsgType key = WXEventType.MsgType.valueOf(msgType);
switch (key) {
case WXEventType.MsgType.event:

	break;

default:
	break;
}

// / <summary>
	// / 消息类型枚举
	// / </summary>
	public enum MsgType {
		// / <summary>
		// /文本类型
		// / </summary>
		text,
		// / <summary>
		// / 图片类型
		// / </summary>
		IMAGE,
		// / <summary>
		// / 语音类型
		// / </summary>
		VOICE,
		// / <summary>
		// / 视频类型
		// / </summary>
		VIDEO,
		// / <summary>
		// / 地理位置类型
		// / </summary>
		location,
		// / <summary>
		// / 链接类型
		// / </summary>
		LINK,
		// / <summary>
		// / 事件类型
		// / </summary>
		event,
		// / <summary>
		// / 小视频
		// / </summary>
		SHORTVIDEO
	}
...
}

// 取得消息类型  
String msgType = inputMsg.getMsgType();
WXEventType.MsgType key = WXEventType.MsgType.valueOf(msgType);
switch (key) {
case event:

	break;

default:
	break;
}

private void test(AtomicInteger index) {
  signUpStudentNum.getAndIncrement();
}

Map<String, Object> responseInfoMap = new HashMap<String, Object>();
responseInfoMap.put("testInfo", testInfo);

setAttr("commentListInfo", responseInfoMap);
renderJsp("/WEB-INF/jsp/helloworld/hello.jsp");

package com.yyxz.main;

import java.util.regex.Pattern;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.jfinal.handler.Handler;
import com.jfinal.kit.StrKit;

public class ZhiWebSocketHandler extends Handler {

	private Pattern filterUrlRegxPattern;
	
	public ZhiWebSocketHandler(String filterUrlRegx) {
		if (StrKit.isBlank(filterUrlRegx))
			throw new IllegalArgumentException("The para filterUrlRegx can not be blank.");
		filterUrlRegxPattern = Pattern.compile(filterUrlRegx);
	}
	@Override
	public void handle(String target, HttpServletRequest request, HttpServletResponse response, boolean[] isHandled) {
		// TODO Auto-generated method stub
		if (filterUrlRegxPattern.matcher(target).find())
			return ;
		else {
			next.handle(target, request, response, isHandled);
		}
	}

}

public class DemoConfig extends JFinalConfig {
//...
	public void configHandler(Handlers me) {
		me.add(new ContextPathHandler("ctx"));
		me.add(new ZhiWebSocketHandler("^/websocket"));
// 也可以使用UrlSkipHandler，就不用编写Handler处理类了
//		me.add(new UrlSkipHandler("^/websocket", false));
	}
//...
}

package com.yyxz.controller;

import java.io.IOException;

import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint("/websocket")
public class WebSocketController {
	public WebSocketController() {
		System.out.println(" WebSocket init~~~");
	}

	@OnOpen
	public void onOpen(Session session) {
		System.out.println("onOpen");
	}

	@OnClose

	public void onClose(Session session) {
		System.out.println("onClose");
	}
	
//	@OnError
//	public void onError(Session session) {
//		System.out.println("onError");
//	}

	@OnMessage
	public void onMessage(String requestJson, Session session)
			throws IOException {
		requestJson = "一一小知回复：" + requestJson; 
		System.out.println(requestJson);
		session.getBasicRemote().sendText(requestJson);
	}
}

forwardAction("/api/test/toPage?openId=1");

		String address = getPara("address");
		try {
			address = new String(address.getBytes("ISO-8859-1"),"UTF-8");
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

HttpServletRequest request = this.getRequest();
HttpServletResponse response = this.getResponse();
try {
	request.setCharacterEncoding("UTF-8");
	response.setCharacterEncoding("UTF-8");
} catch (UnsupportedEncodingException e1) {
	// TODO Auto-generated catch block
	e1.printStackTrace();
}

// 分割符是 "-" 或 空格" " 或冒号 ":"
String time = "2017-08-17 10:55:00";
String[] times = time.split("[\\-:\\s]{1,}");

String time = "2017-08-17 10:55:00";
// 分割符是 "-" 或 空格" " 或冒号 ":"
String[] times = time.split("[\\-:\\s]{1,}");
List<String> timesList = Arrays.asList(times);
List<String> flexibleTimesList = new ArrayList<String>();
flexibleTimesList.addAll(timesList);
flexibleTimesList.add(1,"?");
Collections.reverse(flexibleTimesList);
String[] resultTimes = new String[flexibleTimesList.size()];
for (String str : flexibleTimesList) {
	System.out.println(str);
}
resultTimes =  (String[]) flexibleTimesList.toArray();

flexibleTimesList.toArray(resultTimes);

StringBuffer sb = new StringBuffer();
for(String str : resultTimes) {
	sb.append(str + " ");
}
// 干掉最后一个空格
time = sb.toString().substring(0, sb.length() - 1);
System.out.println("{" + time + "}");

String jobName = "GetWeixinAccessToken";
String triggerName = jobName;
// 每个整点执行一次
quartzManager.addJob(jobName, triggerName, WeixinAccessTokenJob.class, "0 0 */1 * * ?", wxAccesstokenManager);

import java.util.Date;
import java.util.List;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.stereotype.Service;

@Service
public class QuartzManager {
	public static SchedulerFactory schedulerFactory = new StdSchedulerFactory();  

	public void addJob(String jobName, String triggerName,
			Class jobClass, String cron, Object obj) {
		try {
			Scheduler sched = schedulerFactory.getScheduler();
			// 任务名，任务组，任务执行类
			JobDetail jobDetail = JobBuilder.newJob(jobClass)
					.withIdentity(jobName).build();
			jobDetail.getJobDataMap().put("obj", obj);
			// 触发器
			TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder
					.newTrigger();
			// 触发器名
			triggerBuilder.withIdentity(triggerName);
			triggerBuilder.startNow();
			// 触发器时间设定
			triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
			// 创建Trigger对象
			CronTrigger trigger = (CronTrigger) triggerBuilder.build();

			// 调度容器设置JobDetail和Trigger
			sched.scheduleJob(jobDetail, trigger);

			// 启动
			if (!sched.isShutdown()) {
				sched.start();
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	    /** 
	     * @Description: 添加一个定时任务 
	     *  
	     * @param jobName 任务名 
	     * @param jobGroupName  任务组名 
	     * @param triggerName 触发器名 
	     * @param triggerGroupName 触发器组名 
	     * @param jobClass  任务 
	     * @param cron   时间设置，参考quartz说明文档  
	     */  
	    @SuppressWarnings({ "unchecked", "rawtypes" })  
	    public void addJob(String jobName, String jobGroupName, 
	            String triggerName, String triggerGroupName, Class jobClass, String cron) {  
	        try {  
	            Scheduler sched = schedulerFactory.getScheduler();  
	            // 任务名，任务组，任务执行类
	            JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();

	            // 触发器  
	            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
	            // 触发器名,触发器组  
	            triggerBuilder.withIdentity(triggerName, triggerGroupName);
	            triggerBuilder.startNow();
	            // 触发器时间设定  
	            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
	            // 创建Trigger对象
	            CronTrigger trigger = (CronTrigger) triggerBuilder.build();

	            // 调度容器设置JobDetail和Trigger
	            sched.scheduleJob(jobDetail, trigger);  

	            // 启动  
	            if (!sched.isShutdown()) {  
	                sched.start();  
	            }  
	        } catch (Exception e) {  
	            throw new RuntimeException(e);  
	        }  
	    }  

	/**
	 * 修改任务的触发时间
	 * @param jobName
	 * @param triggerName
	 * @param cron
	 */
	public void modifyJobTime(String jobName, String triggerName,
			String cron) {
		try {
			Scheduler sched = schedulerFactory.getScheduler();
			TriggerKey triggerKey = TriggerKey.triggerKey(triggerName);
			CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
			if (trigger == null) {
				return;
			}

			String oldTime = trigger.getCronExpression();
			if (!oldTime.equalsIgnoreCase(cron)) {
				/** 方式一 ：调用 rescheduleJob 开始 */
				// 触发器
				TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder
						.newTrigger();
				// 触发器名,触发器组
				triggerBuilder.withIdentity(triggerName);
				triggerBuilder.startNow();
				// 触发器时间设定
				triggerBuilder.withSchedule(CronScheduleBuilder
						.cronSchedule(cron));
				// 创建Trigger对象
				trigger = (CronTrigger) triggerBuilder.build();
				// 方式一 ：修改一个任务的触发时间
				sched.rescheduleJob(triggerKey, trigger);
				/** 方式一 ：调用 rescheduleJob 结束 */

				/** 方式二：先删除，然后在创建一个新的Job */
				// JobDetail jobDetail =
				// sched.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
				// Class<? extends Job> jobClass = jobDetail.getJobClass();
				// removeJob(jobName, jobGroupName, triggerName,
				// triggerGroupName);
				// addJob(jobName, jobGroupName, triggerName, triggerGroupName,
				// jobClass, cron);
				/** 方式二 ：先删除，然后在创建一个新的Job */
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	    /** 
	     * @Description: 修改一个任务的触发时间
	     *  
	     * @param jobName 
	     * @param jobGroupName
	     * @param triggerName 触发器名
	     * @param triggerGroupName 触发器组名 
	     * @param cron   时间设置，参考quartz说明文档   
	     */  
	    public void modifyJobTime(String jobName, 
	            String jobGroupName, String triggerName, String triggerGroupName, String cron) {  
	        try {  
	            Scheduler sched = schedulerFactory.getScheduler();  
	            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
	            CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);  
	            if (trigger == null) {  
	                return;  
	            }  

	            String oldTime = trigger.getCronExpression();  
	            if (!oldTime.equalsIgnoreCase(cron)) { 
	                /** 方式一 ：调用 rescheduleJob 开始 */
	                // 触发器  
	                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
	                // 触发器名,触发器组  
	                triggerBuilder.withIdentity(triggerName, triggerGroupName);
	                triggerBuilder.startNow();
	                // 触发器时间设定  
	                triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
	                // 创建Trigger对象
	                trigger = (CronTrigger) triggerBuilder.build();
	                // 方式一 ：修改一个任务的触发时间
	                sched.rescheduleJob(triggerKey, trigger);
	                /** 方式一 ：调用 rescheduleJob 结束 */

	                /** 方式二：先删除，然后在创建一个新的Job  */
	                //JobDetail jobDetail = sched.getJobDetail(JobKey.jobKey(jobName, jobGroupName));  
	                //Class<? extends Job> jobClass = jobDetail.getJobClass();  
	                //removeJob(jobName, jobGroupName, triggerName, triggerGroupName);  
	                //addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cron); 
	                /** 方式二 ：先删除，然后在创建一个新的Job */
	            }  
	        } catch (Exception e) {  
	            throw new RuntimeException(e);  
	        }  
	    }  

	/**
	 * @Description: 移除一个任务
	 * 
	 * @param jobName
	 * @param triggerName
	 */
	public void removeJob(String jobName, String triggerName) {
		try {
			Scheduler sched = schedulerFactory.getScheduler();
			TriggerKey triggerKey = TriggerKey.triggerKey(triggerName);
			sched.pauseTrigger(triggerKey);// 停止触发器
			sched.unscheduleJob(triggerKey);// 移除触发器
			sched.deleteJob(JobKey.jobKey(jobName));// 删除任务
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
 
	    /** 
	     * @Description: 移除一个任务 
	     *  
	     * @param jobName 
	     * @param jobGroupName 
	     * @param triggerName 
	     * @param triggerGroupName 
	     */  
	    public void removeJob(String jobName, String jobGroupName,  
	            String triggerName, String triggerGroupName) {  
	        try {  
	            Scheduler sched = schedulerFactory.getScheduler();  

	            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);

	            sched.pauseTrigger(triggerKey);// 停止触发器  
	            sched.unscheduleJob(triggerKey);// 移除触发器  
	            sched.deleteJob(JobKey.jobKey(jobName, jobGroupName));// 删除任务  
	        } catch (Exception e) {  
	            throw new RuntimeException(e);  
	        }  
	    }  

	    /** 
	     * @Description:启动所有定时任务 
	     */  
	    public static void startJobs() {  
	        try {  
	            Scheduler sched = schedulerFactory.getScheduler();  
	            sched.start();  
	        } catch (Exception e) {  
	            throw new RuntimeException(e);  
	        }  
	    }  

	    /** 
	     * @Description:关闭所有定时任务 
	     */  
	    public static void shutdownJobs() {  
	        try {  
	            Scheduler sched = schedulerFactory.getScheduler();  
	            if (!sched.isShutdown()) {  
	                sched.shutdown();  
	            }  
	        } catch (Exception e) {  
	            throw new RuntimeException(e);  
	        }  
	    }
	    
	    /**
	     * 判断JobName是否在执行队列中
	     * @param jobName
	     * @return
	     */
	    public synchronized static boolean isJobExist(String jobName) throws SchedulerException {
	    	boolean isExistJob = false;
	    	Scheduler scheduler = schedulerFactory.getScheduler();
	    	for (String groupName : scheduler.getJobGroupNames()) {
	    		for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher
	    				.jobGroupEquals(groupName))) {
	    			String tmpJobName = jobKey.getName();
	    			String jobGroup = jobKey.getGroup();
	    			// get job's trigger
	    			@SuppressWarnings("unchecked")
	    			List<Trigger> triggers = (List<Trigger>) scheduler
	    			.getTriggersOfJob(jobKey);
	    			Date nextFireTime = triggers.get(0).getNextFireTime();
	    			System.out.println("[jobName] : " + tmpJobName
	    					+ " [groupName] : " + jobGroup + " - "
	    					+ nextFireTime);
	    			if (tmpJobName.equals(jobName)) {
	    				return true;
	    			}
	    		}
	    	}
			return isExistJob;
	    }
}

public class ContextLoaderListenerOverWrite extends ContextLoaderListener {

	@Override
	public void contextInitialized(ServletContextEvent event) {
		// TODO Auto-generated method stub
		super.contextInitialized(event);
		ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(event.getServletContext());  
      		startGetWeixinAccessTokenJobs(applicationContext);
	}
	/**
	 * 开启整点定时任务
	 */
	public void startGetWeixinAccessTokenJobs(ApplicationContext ctx) {
		WxBean currentBean = Utility.getAccessToken();
		WxAccesstoken currentToken = new WxAccesstoken();
		currentToken.setAccesstoken(currentBean.getAccess_token());
		currentToken.setExpiresIn(Integer.valueOf(currentBean.getExpires_in()));
		currentToken.setLastRequestTime(new Date());
		
		QuartzManager quartzManager = (QuartzManager)ctx.getBean("quartzManager");
		WxAccesstokenManager wxAccesstokenManager = (WxAccesstokenManager)ctx.getBean("wxAccesstokenManager");
		WxAccesstoken dbWxToken = wxAccesstokenManager.findFirst();
		if (dbWxToken == null) {	// 新增Token
			wxAccesstokenManager.save(currentToken);
			System.out.println("新增Token：" + currentToken);
		} else {	// 更新Token
			currentToken.setId(dbWxToken.getId());
			wxAccesstokenManager.update(currentToken);
			System.out.println("更新Token：" + currentToken);
		}
		String jobName = "GetWeixinAccessToken";
		String triggerName = jobName;
		// 每个整点执行一次
		quartzManager.addJob(jobName, triggerName, WeixinAccessTokenJob.class, "0 0 */1 * * ?", wxAccesstokenManager);
	}
}

/**
 * 获取微信的AccessToken
 * @return
 */
public static WxBean getAccessToken() {
	WxBean bean = null;
	Map<String, String> params = new HashMap<String, String>();
	params.put("grant_type", "client_credential");
	params.put("appid", Constants.WEIXIN_APPID);
	params.put("secret", Constants.WEIXIN_APPSECRET);
	try {
		String jstoken = HttpUtils.sendGet(
				"https://api.weixin.qq.com/cgi-bin/token", params);
		// String access_token = JSONObject.fromObject(jstoken).getString(
		// "access_token"); // 获取到token并赋值保存
		ObjectMapper objectMapper = JsonUtils.createObjectMapper();
		try {
			bean = objectMapper.readValue(jstoken, WxBean.class);
		} catch (JsonParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (JsonMappingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	return bean;
}

public class WeixinAccessTokenJob implements Job{
	
	public WeixinAccessTokenJob() {
	}
	
	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		//打印任务详情  
        System.out.println( "WeixinTokenJob:" + "-" +
                context.getJobDetail().getKey().getGroup() 
                +"——"+context.getJobDetail().getKey().getName()  
                +"——"+context.getTrigger().getKey().getName()  
                +"——"+context.getTrigger().getKey().getGroup() + new Date());
                JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
                WxAccesstokenManager wxAccesstokenManager = (WxAccesstokenManager)jobDataMap.get("obj");
		// Todo 使用wxAccesstokenManager来管理数据库存放的AccessToken
	}
}