向url添加参数
<c:redirect url="http://www.baidu.com/s">
	<c:param name="wd" value="音乐" ></c:param>
	<c:param name="cl" value="3"></c:param>
</c:redirect>

结果 ： http://www.baidu.com/s?wd=音乐&cl=3
----------------------------------------------------
xml 解析：

<%@ taglib uri="http://java.sun.com/jsp/jstl/xml" prefix="x"%>
<x:parse var="doc" doc="${ file }"></x:parse>

新浪 RSS <br/>
版本：<x:out select="$doc/rss/@version" /> <br/>
标题：<x:out select="$doc/rss/channel/title" /> <br/>
来源：<x:out select="$doc/rss/channel/generator" /> <br/>
版权：<x:out select="$doc/rss/channel/copyright" /> <br/>
出版时间：<x:out select="$doc/rss/channel/pubDate" /> <br/>
链接地址：<x:out select="$doc/rss/channel/link"/> <br/>

----------------------------------------------------

<%
	request.setAttribute("somemap", new HashMap());
%>

<c:remove var="somemap" />

${ somemap == null ? 'somemap 已经被删除' : 'somemap 没有被删除' }
----------------------------------------------------------

<fmt:requestEncoding value="UTF-8"/>

<form action="${ pageContext.request.requestURI }" method="post">
	关键字：<input name="key" /> <c:out value="${ param.key }" default="请输入关键字"></c:out> 
	<br/><br/>
	<input type="submit">
</form>
-----------------------------------------------------------
<c:set var="totalCount" value="${ totalCount + 1 }" scope="application"></c:set>
<c:set var="count" value="${ count + 1 }" scope="session"></c:set>
本网站总访问人次：${ totalCount } <br/>
其中您的访问次数：${ count } <br/>
------------------------------------------
<c:set var="email">liujhua@cn.ibm.com</c:set>
${ fn:substring(email, 0, fn:indexOf(email, '@') ) }

${ fn:substringBefore(email, '@') }

${ fn:substringAfter(email, '@') }
--------------------------------------------------

<c:url value="/images/bg.gif">
</c:url>

JSTL 使用表达式来简化页面的代码，这对一些标准的方法，例如bean的getter/setter方法，请求参数或者context以及 session中的数据的访问非常方便，但是我们在实际应用中经常需要在页面调用对象的某些方法，例如我需要调用字符串的length方法来获取字符串的 长度时，在以往的开发过程中我们必须把对象先转为String类，然后在调用其length方法，这样的代码繁琐而且容易出错。
       因此JSTL内置了几个用于字符串操作的方法，可以直接在表达式中使用，大大的简化了代码，提供代码的可读性。在JSTL的表达是中要使用一个函数，其格式如下
      ${ns:methodName(args....)}
      在使用这些函数之前必须在JSP中引入标准函数的声明
      <%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
      下面是JSTL中自带的方法列表以及其描述
函数名	函数说明	使用举例
fn:contains	判断字符串是否包含另外一个字符串	<c:if test="${fn:contains(name, searchString)}">
fn:containsIgnoreCase	判断字符串是否包含另外一个字符串(大小写无关)	<c:if test="${fn:containsIgnoreCase(name, searchString)}">
fn:endsWith	判断字符串是否以另外字符串结束	<c:if test="${fn:endsWith(filename, ".txt")}">
fn:escapeXml	把一些字符转成XML表示，例如<字符应该转为<	${fn:escapeXml(param:info)}
fn:indexOf	子字符串在母字符串中出现的位置	${fn:indexOf(name, "-")}
fn:join	将数组中的数据联合成一个新字符串，并使用指定字符格开	${fn:join(array, ";")}
fn:length	获取字符串的长度，或者数组的大小	${fn:length(shoppingCart.products)}
fn:replace	替换字符串中指定的字符	${fn:replace(text, "-", "•")}
fn:split	把字符串按照指定字符切分	${fn:split(customerNames, ";")}
fn:startsWith	判断字符串是否以某个子串开始	<c:if test="${fn:startsWith(product.id, "100-")}">
fn:substring	获取子串	${fn:substring(zip, 6, -1)}
fn:substringAfter	
获取从某个字符所在位置开始的子串
${fn:substringAfter(zip, "-")}
fn:substringBefore	获取从开始到某个字符所在位置的子串	${fn:substringBefore(zip, "-")}
fn:toLowerCase	转为小写	${fn.toLowerCase(product.name)}
fn:toUpperCase	转为大写字符	${fn.UpperCase(product.name)}
fn:trim	去除字符串前后的空格	${fn.trim(name)}
函数
描述
fn:contains(string, substring)
如果参数string中包含参数substring，返回true
fn:containsIgnoreCase(string, substring)
如果参数string中包含参数substring（忽略大小写），返回true
fn:endsWith(string, suffix)
如果参数 string 以参数suffix结尾，返回true
fn:escapeXml(string)
将有特殊意义的XML (和HTML)转换为对应的XML character entity code，并返回
fn:indexOf(string, substring)
返回参数substring在参数string中第一次出现的位置
fn:join(array, separator)
将一个给定的数组array用给定的间隔符separator串在一起，组成一个新的字符串并返回。
fn:length(item)
返回参数item中包含元素的数量。参数Item类型是数组、collection或者String。如果是String类型,返回值是String中的字符数。
fn:replace(string, before, after)
返回一个String对象。用参数after字符串替换参数string中所有出现参数before字符串的地方，并返回替换后的结果
fn:split(string, separator)
返回一个数组，以参数separator 为分割符分割参数string，分割后的每一部分就是数组的一个元素
fn:startsWith(string, prefix)
如果参数string以参数prefix开头，返回true
fn:substring(string, begin, end)
返回参数string部分字符串, 从参数begin开始到参数end位置，包括end位置的字符
fn:substringAfter(string, substring)
返回参数substring在参数string中后面的那一部分字符串
fn:substringBefore(string, substring)
返回参数substring在参数string中前面的那一部分字符串
fn:toLowerCase(string)
将参数string所有的字符变为小写，并将其返回
fn:toUpperCase(string)
将参数string所有的字符变为大写，并将其返回
fn:trim(string)
去除参数string 首尾的空格，并将其返回



http://blog.csdn.net/qingwangyoucao/article/details/6218069
EL表达式中fn函数的使用及截取字符串
文章分类:Java编程 关键字: el表达式中fn函数的使用及截取字符串
做了一个月的项目,下面把我经常用到的,在今天写了几篇文章,方便以后的查阅.
fn函数：
使用前在Jsp页面的首部加上以下代码:   
  
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>    
  
下面是JSTL中自带的方法列表以及其描述    
  
函数名 函数说明 使用举例    
fn:contains 判断字符串是否包含另外一个字符串 <c:if test="${fn:contains(name, searchString)}">    
fn:containsIgnoreCase 判断字符串是否包含另外一个字符串(大小写无关) <c:if test="${fn:containsIgnoreCase(name, searchString)}">    
fn:endsWith 判断字符串是否以另外字符串结束 <c:if test="${fn:endsWith(filename, ".txt")}">    
fn:escapeXml 把一些字符转成XML表示，例如 <字符应该转为< ${fn:escapeXml(param:info)}    
fn:indexOf 子字符串在母字符串中出现的位置 ${fn:indexOf(name, "-")}    
fn:join 将数组中的数据联合成一个新字符串，并使用指定字符格开 ${fn:join(array, ";")}    
fn:length 获取字符串的长度，或者数组的大小 ${fn:length(shoppingCart.products)}    
fn:replace 替换字符串中指定的字符 ${fn:replace(text, "-", "•")}    
fn:split 把字符串按照指定字符切分 ${fn:split(customerNames, ";")}    
fn:startsWith 判断字符串是否以某个子串开始 <c:if test="${fn:startsWith(product.id, "100-")}">    
fn:substring 获取子串 ${fn:substring(zip, 6, -1)}    
fn:substringAfter 获取从某个字符所在位置开始的子串    
${fn:substringAfter(zip, "-")}    
fn:substringBefore 获取从开始到某个字符所在位置的子串 ${fn:substringBefore(zip, "-")}    
fn:toLowerCase 转为小写 ${fn.toLowerCase(product.name)}    
fn:toUpperCase 转为大写字符 ${fn.UpperCase(product.name)}    
fn:trim 去除字符串前后的空格 ${fn.trim(name)}   
[java] view plaincopy
使用前在Jsp页面的首部加上以下代码:  
  
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>   
  
下面是JSTL中自带的方法列表以及其描述   
  
函数名 函数说明 使用举例   
fn:contains 判断字符串是否包含另外一个字符串 <c:if test="${fn:contains(name, searchString)}">   
fn:containsIgnoreCase 判断字符串是否包含另外一个字符串(大小写无关) <c:if test="${fn:containsIgnoreCase(name, searchString)}">   
fn:endsWith 判断字符串是否以另外字符串结束 <c:if test="${fn:endsWith(filename, ".txt")}">   
fn:escapeXml 把一些字符转成XML表示，例如 <字符应该转为< ${fn:escapeXml(param:info)}   
fn:indexOf 子字符串在母字符串中出现的位置 ${fn:indexOf(name, "-")}   
fn:join 将数组中的数据联合成一个新字符串，并使用指定字符格开 ${fn:join(array, ";")}   
fn:length 获取字符串的长度，或者数组的大小 ${fn:length(shoppingCart.products)}   
fn:replace 替换字符串中指定的字符 ${fn:replace(text, "-", "•")}   
fn:split 把字符串按照指定字符切分 ${fn:split(customerNames, ";")}   
fn:startsWith 判断字符串是否以某个子串开始 <c:if test="${fn:startsWith(product.id, "100-")}">   
fn:substring 获取子串 ${fn:substring(zip, 6, -1)}   
fn:substringAfter 获取从某个字符所在位置开始的子串   
${fn:substringAfter(zip, "-")}   
fn:substringBefore 获取从开始到某个字符所在位置的子串 ${fn:substringBefore(zip, "-")}   
fn:toLowerCase 转为小写 ${fn.toLowerCase(product.name)}   
fn:toUpperCase 转为大写字符 ${fn.UpperCase(product.name)}   
fn:trim 去除字符串前后的空格 ${fn.trim(name)}   



函数 描述

fn:contains(string, substring)
如果参数string中包含参数substring，返回true

fn:containsIgnoreCase(string, substring)
如果参数string中包含参数substring（忽略大小写），返回true

fn:endsWith(string, suffix)
如果参数 string 以参数suffix结尾，返回true

fn:escapeXml(string)
将有特殊意义的XML (和HTML)转换为对应的XML character entity code，并返回

fn:indexOf(string, substring)
返回参数substring在参数string中第一次出现的位置

fn:join(array, separator)
将一个给定的数组array用给定的间隔符separator串在一起，组成一个新的字符串并返回。

fn:length(item)
返回参数item中包含元素的数量。参数Item类型是数组、collection或者String。如果是String类型,返回值是String中的字符数。

fn:replace(string, before, after)
返回一个String对象。用参数after字符串替换参数string中所有出现参数before字符串的地方，并返回替换后的结果

fn:split(string, separator)
返回一个数组，以参数separator 为分割符分割参数string，分割后的每一部分就是数组的一个元素

fn:startsWith(string, prefix)
如果参数string以参数prefix开头，返回true

fn:substring(string, begin, end)
返回参数string部分字符串, 从参数begin开始到参数end位置，包括end位置的字符

fn:substringAfter(string, substring)
返回参数substring在参数string中后面的那一部分字符串

fn:substringBefore(string, substring)
返回参数substring在参数string中前面的那一部分字符串

fn:toLowerCase(string)
将参数string所有的字符变为小写，并将其返回

fn:toUpperCase(string)
将参数string所有的字符变为大写，并将其返回

fn:trim(string)
去除参数string 首尾的空格，并将其返回

<c:if test="${ param.action == 'add' }">
		<legend>添加操作</legend>
		<table>
			<tr>
				<td>帐号</td>
				<td><input type="text" name="login" /></td>
			</tr>
			<tr>
				<td>真实姓名</td>
				<td><input type="text" name="name" /></td>
			</tr>
		</table>
	</c:if>
	<c:if test="${ param.action == 'edit' }">
		<legend>修改操作</legend>
		<table>
			<tr>
				<td>帐号</td>
				<td><c:out value="${ param.login }" default="Param login required. " /></td>
			</tr>
			<tr>
				<td>真实姓名</td>
				<td><input type="text" name="name" /></td>
			</tr>
		</table>
	</c:if>
	
	<table><tr><td><input type="submit" /></td></tr></table>

<c:forTokens>：这个标签专门用于处理TokenString的迭代，可以指定一个或者多个分隔符(delimiters)
语法：
    <c:forTokens 
items=”stringOfTokens” 
delims=”delimiters” 
[var=”varName”] 
[varStatus=”varStatusName”] 
[begin=”begin”] [end=”end”] [step=”step”]>
Body content
     </c:forTokens>
属性：
var：String，迭代参数的名字
items：String，将要迭代的String
varStatus：String，表示迭代的状态，可以访问迭代自身的信息
delims：String，分隔符
begin：int，如果指定items，那么就从items的index[begin]开始迭代；如果没有指定items，那么就从指定的index开始迭代，相当于for(int i=begin;;)语句。
end：int，如果指定items，那么就在items的index[end]结束迭代；如果没有指定items，那么就在指定的index结束，相当于for(;i<end;)语句。
step：int，迭代的步长
说明：<c:forEach>也可以迭代TokenString，但是<c:forTokens>在迭代处理TokenSting时功能更强大。

fn:escapeXml:


<c:import var="source" url="http://www.baidu.com" charEncoding="gbk"></c:import>

<c:out value="${source}" escapeXml="false"></c:out>
<hr/>
${ fn:escapeXml(source) }
<hr>
如果escapeXml为false，则将其中的html、xml解析出来。
如<font size=16>java</font>,会显示为大小为16的”java“
如果为true，则显示<font size=16>java</font> 

-----------------------------------------------------
forEach:
<table>
	<tr>
		<td class="header">Header Name</td>
		<td class="header">Header Value</td>
	</tr>
	<c:forEach var="headerName" items="${ pageContext.request.headerNames }">
		<tr>
			<td>${ headerName }</td>
			<td>${ header[headerName] }</td>
		</tr>
	</c:forEach>
</table>
<table>
	<tr>
		<td class="header">Header Name</td>
		<td class="header">Header Value</td>
	</tr>
	<c:forEach var="item" items="${ header }">
		<tr>
			<td>${ item.key }</td>
			<td>${ item.value }</td>
		</tr>
	</c:forEach>
</table>
----------------------------------------------
<c:forEach items="${ personList }" var="person" varStatus="varStatus">
	       
		<tr bgcolor="${ varStatus.index % 2 == 1 ? '#EFEFEF' : '#FFFFFF' }">
			<td>${ varStatus.current.id }</td>
			<td>${ varStatus.current.name }</td>
			<td>${ varStatus.current.age }</td>
			<td>${ varStatus.current.sex }</td>
			<td>${ varStatus.current.city }</td>
			<td>${ varStatus.current.address }</td>
			<td>${ varStatus.current.birthday }</td>
			<td>${ varStatus.current.mobile }</td>
			<td>${ varStatus.current.telephone }</td>
		</tr>
		
</c:forEach>
----------------------------------------------
<jsp:useBean id="date" class="java.util.Date"></jsp:useBean>
	
	<c:forEach var="locale" items="${ localeList }">
		<fmt:setLocale value="${ locale }"/>
		<tr>
			<td>${ locale }</td>
			<td><fmt:formatDate value="${ date }" type="both"/></td>
			<td><fmt:formatNumber value="10000.5" /></td>
			<td><fmt:formatNumber value="10000.5" type="currency" /> </td>
		</tr>	
	</c:forEach>
-------------------------------------------------

<%
        	Field[] field = Locale.class.getFields();

        	List<Locale> localeList = new ArrayList<Locale>();

        	for(int i=0; i<field.length; i++){
        	    if(field[i].getType().equals(Locale.class)){
        	        localeList.add((Locale)field[i].get(null));
        	    }
        	}

        	request.setAttribute("localeList", localeList);

            double[] numbers = { 0, 10000, 55.0, -123.2568 };
            request.setAttribute("numbers", numbers);
%>

<fmt:setLocale value="${ param.locale }"/>

当前格式：<c:out value="${ param.locale }" default="${ pageContext.request.locale } "></c:out>

 

<c:forEach items="${ localeList }" var="locale">
	<a href="${ pageContext.request.requestURI }?locale=${ locale }">${ locale }</a> 
</c:forEach>

<table>
	<tr class="title">
		<td>数字原值</td>
		<td>数字格式</td>
		<td>货币格式</td>
		<td>百分数格式</td>
	</tr>

	<c:forEach items="${ numbers }" var="number">
		<tr>
			<td>${ number }</td>
			<td><fmt:formatNumber value="${ number }" type="number"
				maxFractionDigits="4" minIntegerDigits="3" maxIntegerDigits="3"
				minFractionDigits="2" /></td>
			<td><fmt:formatNumber value="${ number }" type="currency"/></td>
			<td><fmt:formatNumber value="${ number }" type="percent" /></td>
		</tr>
	</c:forEach>

</table>

   jstl 
   在使用jstl的时候项目导入jstl-1.2.jar 和 standard-1.1.2.jar 两个包.
   
   1. <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
   
      在jsp页面引入国际化消息
      例 ： 创建messages_zh_CN.properties文件,bundle.jsp文件.
      messages_zh_CN.properties :
       prompt.hello = \u4F60\u597D, "{0}". //{0} 参数
       prompt.greeting =\u5F88\u9AD8\u5174\u89C1\u5230\u4F60.
      bundle.jsp:
         <fmt:bundle basename="messages">
	    <fmt:message key="prompt.hello">
		<fmt:param value="Helloween"></fmt:param>  -->参数
	    </fmt:message> <br/>
	    <fmt:message key="prompt.greeting"></fmt:message>
         </fmt:bundle>
      结果是：你好, Helloween. 很高兴见到你.
   2. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
      <c:import var="file" url="/WEB-INF/web.xml" /> -->导入文件
      
      jsp页面抛出异常：
      <c:catch var="e">
	<c:set target="someBean" property="someProperty" value="Some Value"></c:set>
      </c:catch>

      <c:if test="${ e != null }">
	    程序抛出了异常 ${ e.class.name }，原因: ${ e.message }
      </c:if>
      -------------------------------------
      
      <c:choose>
	   <c:when test="${ param.action }">
		when 标签的输出
	   </c:when>
	   <c:otherwise>
		otherwise 标签的输出
	   </c:otherwise>
      </c:choose>
      -------------------------------------
      包含：
      header['User-Agent'] = "${ header['User-Agent'] }"; <br/><br/>

     您使用 
      <c:if test="${ fn:contains(header['User-Agent'], 'MSIE') }">IE 浏览器</c:if>
      <c:if test="${ fn:contains(header['User-Agent'], 'Firefox') }">Firefox 浏览器</c:if>
      <c:if test="${ fn:contains(header['User-Agent'], 'Maxthon') }">Maxth 浏览器</c:if>
      <c:if test="${ fn:contains(header['User-Agent'], 'MyIE2') }">MyIE2 浏览器</c:if>
      <c:if test="${ fn:contains(header['User-Agent'], 'Opera') }">Opera 浏览器</c:if>
      <c:if test="${ fn:contains(header['User-Agent'], 'TencentTraveler ') }">腾讯 Traveler 浏览器        </c:if>
      <c:if test="${ fn:contains(header['User-Agent'], 'TheWorld ') }">世界之窗 浏览器</c:if>
      <c:if test="${ fn:contains(header['User-Agent'], 'Kubuntu') }">Kubuntu 浏览器</c:if>
，
      <c:if test="${ fn:contains(header['User-Agent'], 'Windows') }">Windows 操作系统</c:if>
      <c:if test="${ fn:contains(header['User-Agent'], 'windows') }">Windows 操作系统</c:if>
      <c:if test="${ fn:contains(header['User-Agent'], 'Linux') }">Linux 操作系统</c:if>
      <c:if test="${ fn:contains(header['User-Agent'], 'linux') }">Linux 操作系统</c:if>
      <c:if test="${ fn:contains(header['User-Agent'], 'SunOS') }">Sun 操作系统</c:if>
      <c:if test="${ fn:contains(header['User-Agent'], 'Mac') }">Mac 操作系统</c:if>
    -------------------------------------
    

   3 .
     <jsp:include flush="true" page="/head.jsp"></jsp:include> 导入文件
     <%-- 定义一个 session 范围内的计数器 记录个人访问信息 --%>
     <jsp:useBean id="personCount" class="com.helloweenvsfei.jspweb.bean.Counter" scope="session" />
     <%-- 定义一个 application 范围内的计数器 记录所有人的访问信息 --%>
     <jsp:useBean id="totalCount" class="com.helloweenvsfei.jspweb.bean.Counter" scope="application" />
    <%-- 获取个人的 访问次数 --%>
    <jsp:getProperty name="personCount" property="count" /> 次
    <%-- 获取所有人的 访问次数 --%>
    <jsp:getProperty name="totalCount" property="count" /> 次

   4. <%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql"%>
    
<jsp:useBean id="date" class="java.util.Date"></jsp:useBean>

<sql:setDataSource driver="com.mysql.jdbc.Driver" user="root"
	password="admin"
	url="jdbc:mysql://localhost:3306/jstl?charachterEncoding=UTF-8"
	var="dataSource" scope="page" />

<sql:update dataSource="${ dataSource }">
	create table if not exists tb_person 
	( id integer auto_increment, 
	  name varchar(255), 
	  birthday timestamp null, 
	  primary key (id) 
	 )
</sql:update>

<sql:update dataSource="${ dataSource }">
	insert into tb_person ( name, birthday ) values ( ?, ? ) 
	<sql:param value="Helloween"></sql:param>
	<sql:dateParam value="${ date }" type="timestamp"/>
</sql:update>

<sql:query var="rs" dataSource="${ dataSource }">
	select * from tb_person where birthday > ( ? - 1 )
	<sql:param value="${ date }"></sql:param>
</sql:query>

<table>
	<tr class="title">
		<c:forEach var="columnName" items="${ rs.columnNames }">
			<td>${ columnName }</td>
		</c:forEach>
	</tr>

	<c:forEach var="row" items="${ rs.rows }">
		<tr>
			<c:forEach var="columnName" items="${ rs.columnNames }">
				<td>${ row[columnName] }</td>
			</c:forEach>
		</tr>
	</c:forEach>

</table>

-----------------------------------------------------------------------------------

<%
	request.setAttribute("files", new File("e:\\").listFiles());
%>

<table>
	<tr class="title">
		<td>File Name</td>
		<td>Type</td>
	</tr>
	
	<c:forEach var="file" items="${ files }">
		<tr>
			<td>${ file.name }</td>
			<td>
			
				<c:choose>
					<c:when test="${ file.directory }">文件夹</c:when>
					<c:otherwise>
						<c:if test="${ fn:endsWith(file.name, '.jpg') }">JPG 图片</c:if>
						<c:if test="${ fn:endsWith(file.name, '.exe') }">EXE 应用程序</c:if>
						<c:if test="${ fn:endsWith(file.name, '.gif') }">GIF 图片</c:if>
						<c:if test="${ fn:endsWith(file.name, '.txt') }">TXT 文本文件</c:if>
						<c:if test="${ fn:endsWith(file.name, '.doc') }">WORD 文件</c:if>
						<c:if test="${ fn:endsWith(file.name, '.xls') }">Excel 文件</c:if>
						<c:if test="${ fn:endsWith(file.name, '.log') }">LOG 日志文件</c:if>
						<c:if test="${ fn:endsWith(file.name, '.sql') }">SQL 数据库脚本文件</c:if>
					</c:otherwise>
				</c:choose>
			
			</td>
		</tr>
	</c:forEach>
	
</table>

package cn.javass.commons.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用户描述方法参数，包括参数类型、参数来源
 * 
 * @author 牛
 **/

// 运行时保留
@Retention(RetentionPolicy.RUNTIME)
// 注解对象为方法
@Target(ElementType.METHOD)
public @interface RenderParameter {
	// 参数类型
	public enum ParameterType {
		STRING, SHORT, INT, LONG, OBJECT
	};

	// 参数来源
	public enum ScopeType {
		NORMAL, SESSION, COOKIE,ATTRIBUTE, CUSTOM
	};

	// 参数名
	public String name();

	// 匹配时是否忽略大小写
	public boolean ignoreCase() default false;

	// 参数类型
	public ParameterType type() default ParameterType.STRING;

	// 参数来源
	public ScopeType scope() default ScopeType.NORMAL;

}


package cn.javass.commons.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RenderMethod {
	public enum MethodType {
		INQUIRE
	};

	public MethodType method() default MethodType.INQUIRE;

	// 参数列表
	public RenderParameter[] parameters();
}




package cn.javass.commons.annotation;

import java.lang.reflect.Method;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;

import cn.javass.commons.annotation.RenderParameter.ScopeType;
/**
 * 注解处理器
 **/
public class Processor {
	public static void main(String[] args) {
		AnnotationTest render = new AnnotationTest();
		HttpServletRequest request = null;
		for (Method method : render.getClass().getDeclaredMethods()) {
			RenderMethod rm = method.getAnnotation(RenderMethod.class);
			if (rm != null) {
				int length = rm.parameters().length;
				Object[] parameters = length > 0 ? buildParameters(request,rm
						.parameters()) : null;
				try {
					method.invoke(render, parameters);
				} catch (Exception e) {
					e.printStackTrace();
				}
				break;
			}
		}
	}

	private static Object[] buildParameters(HttpServletRequest request,RenderParameter[] parameters) {
		Object[] objs = new Object[parameters.length];
		int i = 0;
		for (RenderParameter parameter : parameters) {
			ScopeType scope = parameter.scope();
			// 参数值来自request.getParameter
			if (scope == ScopeType.NORMAL) {
				String temp = request.getParameter(parameter.name());
				String value=null;
				if(temp!=null && !"".equals(temp)){
					try{
						byte[] bytes=temp.getBytes("ios-8859-1");
						value=new String(bytes,"utf-8");
					}catch(Exception e){
						e.printStackTrace();
					}
				}
				objs[i++]=value;
			//参数值来自Session
			}else if(scope==ScopeType.SESSION){
				objs[i++]=request.getSession().getAttribute(parameter.name());

			//参数值来自Cookie
			}else if(scope==ScopeType.COOKIE){
				for(Cookie cookie:request.getCookies()){
					if(cookie.getName().equals(parameter.name())){
						objs[i++]=cookie.getValue();
						break;
					}
				}
			//参数来自于request.getAttribute
			}else if(scope==ScopeType.ATTRIBUTE){
				objs[i++]=request.getAttribute(parameter.name());
			}
		}
		return objs;
	}

}



package cn.javass.commons.annotation;


import cn.javass.commons.annotation.RenderParameter.ScopeType;

public class AnnotationTest {
	
	@RenderMethod(parameters = {
			@RenderParameter(name = "logined", scope = ScopeType.SESSION),
			@RenderParameter(name = "loginedUser", scope = ScopeType.SESSION) })
	public void inquire(String logined, String loginedUser) {
		if ("true".equals(logined)) {
			System.out.println(loginedUser + "is logined");
		} else {
			System.out.println("not user logined");
		}
	}
}

package org.sharpcode.util;   
  
import java.beans.IntrospectionException;   
import java.beans.Introspector;   
import java.beans.MethodDescriptor;   
import java.beans.ParameterDescriptor;   
import java.beans.PropertyDescriptor;   
import java.lang.reflect.InvocationTargetException;   
import java.lang.reflect.Method;   
import java.util.HashMap;   
import java.util.Map;   
import java.util.Set;   
  
import org.sharpcode.po.Account;   
  
/**  
 * java bean 工具类  
 *   
 * @author kingschan  
 *   
 */  
public class JavaBeanUtil {   
    /**  
     * 得到一个bean的方法列表  
     *   
     * @param clazz  
     * @throws IntrospectionException  
     */  
    public static void getBeansMethods(Class<?> clazz)   
            throws IntrospectionException {   
        // 方法列表   
        MethodDescriptor[] methods;   
        // 参数列表   
        ParameterDescriptor[] parameters;   
        methods = Introspector.getBeanInfo(clazz).getMethodDescriptors();   
        System.out.println(String.format("%s:共有%s个方法", clazz.getName(),   
                methods.length));   
        for (MethodDescriptor m : methods) {   
            System.out.println(m.getName());   
            parameters = m.getParameterDescriptors();   
            if (null != parameters) {   
                for (ParameterDescriptor p : parameters) {   
                    System.out.println("parametes:" + p.getName());   
                }   
            }   
  
        }   
    }   
  
    /**  
     * 得到bean的属性名字  
     *   
     * @param clazz  
     * @throws IntrospectionException  
     * @throws InvocationTargetException  
     * @throws IllegalAccessException  
     * @throws IllegalArgumentException  
     */  
    public static void getProperty(Object obj) throws IntrospectionException,   
            IllegalArgumentException, IllegalAccessException,   
            InvocationTargetException {   
        // 属性列表   
        PropertyDescriptor[] propertys;   
        Method method;   
        propertys = Introspector.getBeanInfo(obj.getClass())   
                .getPropertyDescriptors();   
        for (PropertyDescriptor p : propertys) {   
            System.out.println(p.getName());   
            method = p.getReadMethod();   
            // Set<String> set = new HashSet<String>();   
            // set.add("accountUsername");   
            // getPropertyValue(p,obj,set);   
            getPropertyValue(p, obj);   
  
        }   
    }   
  
    /**  
     * 得到bean 属性的值  
     *   
     * @param p  
     * @param obj  
     * @throws InvocationTargetException  
     * @throws IllegalAccessException  
     * @throws IllegalArgumentException  
     */  
    public static void getPropertyValue(PropertyDescriptor p, Object obj)   
            throws IllegalArgumentException, IllegalAccessException,   
            InvocationTargetException {   
        System.out.println(String.format("key:%s value:%s", p.getName(), p   
                .getReadMethod().invoke(obj)));   
    }   
  
    /**  
     * 只打出指定属性名  
     *   
     * @param p  
     * @param obj  
     * @param pname  
     * @throws IllegalArgumentException  
     * @throws IllegalAccessException  
     * @throws InvocationTargetException  
     */  
    public static void getPropertyValue(PropertyDescriptor p, Object obj,   
            Set<String> pname) throws IllegalArgumentException,   
            IllegalAccessException, InvocationTargetException {   
        if (pname.contains(p.getName())) {   
            System.out.println(String.format("key:%s value:%s", p.getName(), p   
                    .getReadMethod().invoke(obj)));   
        }   
  
    }   
  
    /**  
     * 构建指定的对象 并初始化  
     *   
     * @param obj  
     *            对象类型  
     * @param map  
     *            key 属性名 value 要初始化的值  
     * @return  
     * @throws IntrospectionException  
     * @throws InvocationTargetException  
     * @throws IllegalAccessException  
     * @throws IllegalArgumentException  
     * @throws ClassNotFoundException  
     * @throws InstantiationException  
     */  
    public static Object buildObject(Object obj, Map<String, Object> map)   
            throws IntrospectionException, IllegalArgumentException,   
            IllegalAccessException, InvocationTargetException,   
            ClassNotFoundException, InstantiationException {   
        //实例化一个对象   
        Object objclass = ((Class<?>) obj).newInstance();   
        // 属性列表   
        PropertyDescriptor[] propertys;   
        Method method;   
        Class<?> ptype;// 参数列类   
        propertys = Introspector.getBeanInfo(objclass.getClass())   
                .getPropertyDescriptors();   
        for (PropertyDescriptor p : propertys) {   
            //对属性赋值   
            if (map.keySet().contains(p.getName())) {   
                method = p.getWriteMethod();   
                ptype = method.getParameterTypes()[0];   
                method.invoke(objclass, map.get(p.getName()));   
            }   
  
        }   
        return objclass;   
    }   
  
    public static void main(String[] args) throws IntrospectionException,   
            IllegalArgumentException, IllegalAccessException,   
            InvocationTargetException, ClassNotFoundException,   
            InstantiationException {           
        HashMap<String, Object> map = new HashMap<String, Object>();   
        map.put("accountUsername", "admin");   
        map.put("accountId", 100);   
        map.put("accountEnable", true);   
        Account a = (Account) JavaBeanUtil.buildObject(Account.class, map);   
        JavaBeanUtil.getProperty(a);   
    }   
}  

package cn.javass.commons.cache;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

/**
 * *
 * <p>
 * Title:
 * </p>
 * <p>
 * Description: 管理缓存
 * </p>
 * * Deep blue 2008-11-28 think *
 * 可扩展的功能：当chche到内存溢出时必须清除掉最早期的一些缓存对象，这就要求对每个缓存对象保存创建时间 *
 * <p>
 * Copyright: Copyright (c) 2008
 * </p>
 * * *
 * <p>
 * Company:
 * </p>
 * * *
 */
public class CacheManager {
	@SuppressWarnings("unchecked")
	private static HashMap cacheMap = new HashMap();

	private CacheManager() {
		super();
	}

	// 获取布尔值的缓存
	public static boolean getSimpleFlag(String key) {
		try {
			return (Boolean) cacheMap.get(key);
		} catch (NullPointerException e) {
			return false;
		}
	}

	public static long getServerStartdt(String key) {
		try {
			return (Long) cacheMap.get(key);
		} catch (Exception e) {
			return 0;
		}
	}

	// 设置布尔值的缓存
	@SuppressWarnings("unchecked")
	public synchronized static boolean setSimpleFlag(String key, boolean flag) {
		if (flag && getSimpleFlag(key)) {
			return false;
		} else {
			cacheMap.put(key, flag);
			return true;
		}
	}

	@SuppressWarnings("unchecked")
	public synchronized static boolean setSimpleFlag(String key,
			long serverbegrundt) {
		if (cacheMap.get(key) == null) {
			cacheMap.put(key, serverbegrundt);
			return true;
		} else {
			return false;
		}
	}

	// 得到缓存，同步静态方法
	private synchronized static Cache getCache(String key) {
		return (Cache) cacheMap.get(key);
	}

	// 判断是否存在一个缓存
	private synchronized static boolean hasCache(String key) {
		return cacheMap.containsKey(key);
	}

	// 清楚所有缓存
	public synchronized static void clearAll() {
		cacheMap.clear();
	}

	// 删除某一类特定缓存，通过遍历HashMap下的所有对象，来判断它传入的Type是否匹配
	public synchronized static void clearAll(String type) {
		Iterator i = cacheMap.entrySet().iterator();
		String key;
		ArrayList<String> arr = new ArrayList<String>();
		try {
			while (i.hasNext()) {
				java.util.Map.Entry entity = (java.util.Map.Entry) i.next();
				key = (String) entity.getKey();
				if (key.startsWith(type)) {
					arr.add(key);
				}
			}
			for (int k = 0; k < arr.size(); k++) {
				clearOnly(arr.get(k));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 清除指定缓存
	public synchronized static void clearOnly(String key) {
		cacheMap.remove(key);
	}

	// 载入缓存
	public synchronized static void putCache(String key, Cache obj) {
		cacheMap.put(key, obj);
	}

	// 获取缓存信息
	public static Cache getCacheInfo(String key) {
		if (hasCache(key)) {
			Cache cache = getCache(key);
			if (cacheExpired(cache)) {
				cache.setExpired(true);
			}
			return cache;
		} else {
			return null;
		}
	}

	// 載入緩存信息
	public static void putCacheInfo(String key, Cache obj, long dt,
			boolean expired) {
		Cache cache = new Cache();
		cache.setKey(key);
		cache.setTimeOut(dt + System.currentTimeMillis());// 设置多久后跟新缓存
		cache.setValue(obj);
		cache.setExpired(expired);// 缓存默认载入时，终止状态为false
		cacheMap.put(key, obj);
	}

	// 重写载入缓存信息方法
	public static void putCacheInfo(String key, Cache obj, long dt) {
		Cache cache = new Cache();
		cache.setKey(key);
		cache.setExpired(false);
		cache.setTimeOut(dt + System.currentTimeMillis());
		cache.setValue(obj);
		cacheMap.put(key, cache);
	}

	// 判断缓存是否终止
	public static boolean cacheExpired(Cache cache) {
		if (null == cache) {
			return false; // 传入的缓存不存在
		}
		long nowDt = System.currentTimeMillis();// 系统当前的毫秒数
		long cacheDt = cache.getTimeOut();// 缓存内过期毫秒数
		if (cacheDt <= 0 || cacheDt > nowDt) {// 过期时间小于等于零时,或者过期时间大于当前时间时，则为FALSE
			return false;
		} else {
			return true;// //大于过期时间 即过期
		}
	}

	// 获取缓存中的大小
	public static int getCacheSize() {
		return cacheMap.size();
	}

	// 获取指定类型的大小
	@SuppressWarnings("unchecked")
	public static int getCacheSize(String type) {
		int k = 0;
		Iterator i = cacheMap.entrySet().iterator();
		String key;
		try {
			while (i.hasNext()) {
				java.util.Map.Entry entity = (java.util.Map.Entry) i.next();
				key = (String) entity.getKey();
				if (key.indexOf(type) == -1) {
					k++;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return k;
	}

	// 获取缓存对象中的所有键值名称
	@SuppressWarnings( { "unchecked", "finally" })
	public static ArrayList<String> getCacheAllkey() {
		ArrayList a = new ArrayList();
		try {
			Iterator i = cacheMap.entrySet().iterator();
			while (i.hasNext()) {
				java.util.Map.Entry entity = (java.util.Map.Entry) i.next();
				a.add((String) entity.getKey());
			}
		} catch (Exception e) {
		} finally {
			return a;
		}
	}

	// 获取缓存对象中指定类型 的键值名称
	@SuppressWarnings( { "unchecked", "finally" })
	public static ArrayList<String> getCacheListkey(String type) {
		ArrayList a = new ArrayList();
		String key;
		try {
			Iterator i = cacheMap.entrySet().iterator();
			while (i.hasNext()) {
				java.util.Map.Entry entry = (java.util.Map.Entry) i.next();
				key = (String) entry.getKey();
				if (key.indexOf(type) != -1) {
					a.add(key);
				}
			}
		} catch (Exception ex) {
		} finally {
			return a;
		}
	}
}




package cn.javass.commons.cache;

/**
 * *
 * <p>
 * Title:
 * </p>
 * * *
 * <p>
 * Description: 缓存DTO(数据传输对象)
 * </p>
 * * *
 * <p>
 * Copyright: Copyright (c) 2008
 * </p>
 * * *
 * <p>
 * Company:
 * </p>
 * * * @author Deepblue 2008-11-11 * @version 1.0
 */
public class Cache {
	private String key;// 缓存ID
	private Object value;// 缓存数据
	private long timeOut;// 更新时间
	private boolean expired; // 是否终止

	public Cache() {
		super();
	}

	public Cache(String key, Object value, long timeOut, boolean expired) {
		this.key = key;
		this.value = value;
		this.timeOut = timeOut;
		this.expired = expired;
	}

	public String getKey() {
		return key;
	}

	public void setKey(String key) {
		this.key = key;
	}

	public Object getValue() {
		return value;
	}

	public void setValue(Object value) {
		this.value = value;
	}

	public long getTimeOut() {
		return timeOut;
	}

	public void setTimeOut(long timeOut) {
		this.timeOut = timeOut;
	}

	public boolean isExpired() {
		return expired;
	}

	public void setExpired(boolean expired) {
		this.expired = expired;
	}
    
}

package com.javass.spring.helloword;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;

import junit.framework.Assert;

import org.junit.Test;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.InputStreamResource;
import org.springframework.core.io.Resource;

public class ResourceTest4 {
	@Test
	public void testBtyeArrayResource() {
		Resource resource = new ByteArrayResource("hello Word!".getBytes());
		if (resource.exists()) {
			dumpStream(resource);
		}
	}

	@Test
	public void testInputStreamResource() {
		ByteArrayInputStream bis = new ByteArrayInputStream("hello word!"
				.getBytes());
		Resource resource = new InputStreamResource(bis);
		if (resource.exists()) {
			dumpStream(resource);
		}
		Assert.assertEquals(true, resource.isOpen());
	}

	@Test
	public void testFileResource() {
		File file = new File("d:/test.txt");
		Resource resource = new FileSystemResource(file);
		if (resource.exists()) {
			dumpStream(resource);
		}
		Assert.assertEquals(false, resource.isOpen());
	}

	/**
	 * 默认的加载器加载资源
	 **/
	@Test
	public void testClasspathResourceByDefaultClassLoader() throws IOException {
		Resource resource = new ClassPathResource(
				"com/javass/spring/helloword/test.properties");
		if (resource.exists()) {
			dumpStream(resource);
		}
		System.out.println("path:" + resource.getFile().getAbsolutePath());
		Assert.assertEquals(false, resource.isOpen());
	}

	/**
	 * 使用指定的ClassLoader进行加载资源
	 * 
	 * @throws IOException
	 **/
	@Test
	public void testClasspathResourceByClassLoader() throws IOException {
		ClassLoader cl = this.getClass().getClassLoader();
		Resource resource = new ClassPathResource(
				"com/javass/spring/helloword/test.properties", cl);
		if (resource.exists()) {
			dumpStream(resource);
		}
		System.out.println("path:" + resource.getFile().getAbsolutePath());
		Assert.assertEquals(false, resource.isOpen());
	}

	/**
	 * 使用指定的类进行加载资源
	 **/
	@SuppressWarnings("unchecked")
	@Test
	public void testClasspathResourceByClass() throws IOException {
		Class clazz = this.getClass();
		Resource resource1 = new ClassPathResource(
				"com/javass/spring/helloword/test.properties", clazz);
		if (resource1.exists()) {
			dumpStream(resource1);
		}
		System.out.println("path:" + resource1.getFile().getAbsolutePath());
		Assert.assertEquals(false, resource1.isOpen());
		Resource resource2 = new ClassPathResource("test.properties", this
				.getClass());
		if (resource2.exists()) {
			dumpStream(resource2);
		}
		System.out.println("path:" + resource2.getFile().getAbsolutePath());
		Assert.assertEquals(false, resource2.isOpen());
	}

	/**
	 * 加载Jar包里的资源(不能使用“resource.getFile()”，应该使用“resource.getURL()”，
	 * 因为资源不存在于文件系统而是存在于jar包里)
	 **/
	@Test
	public void classpathResourceTestFromJar() throws IOException {
		Resource resource = new ClassPathResource("overview.html");
		if (resource.exists()) {
			dumpStream(resource);
		}
		System.out.println("path:" + resource.getURL().getPath());
		Assert.assertEquals(false, resource.isOpen());
	}

	/**
	 * UrlResource一般支持如下资源访问： http：通过标准的http协议访问web资源，如new
	 * UrlResource(“http://地址”)； ftp：通过ftp协议访问资源，如new UrlResource(“ftp://地址”)；
	 * file：通过file协议访问本地文件系统资源，如new UrlResource(“file:d:/test.txt”)；
	 **/
	public void testUrlResource() {
      
	}

	private void dumpStream(Resource resource) {
		InputStream is = null;
		try {
			// 获取文件资源
			is = resource.getInputStream();
			// 读取资源
			byte[] descBytes = new byte[is.available()];
			is.read(descBytes);
			System.out.println(new String(descBytes));
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				is.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

package com.fengsheng.jpks.util;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;

/**
 * 工具类
 * 
 * @author 
 * 
 */
public abstract class Utils {

	/**
	 * 是否是null或空字符串
	 * 
	 * @param str
	 * @return
	 */
	public final static boolean isNull(String str) {
		return str == null || str.trim().length() == 0 || "null".equals(str);
	}

	/**
	 * 返回非null字符串，如果str=null则返回空字符串
	 * 
	 * @param str
	 * @return
	 */
	public final static String getString(String str) {
		return str == null ? "" : str;
	}

	/**
	 * 将前台出来的id加''号
	 * 
	 * @param str
	 * @return
	 * @author 牛文吉
	 */
	public static String getNewString(String str) {
		if (str == null || str.length() == 0) {
			return "";
		}
		String[] st = str.split(",");
		return "'" + arrayToString(st, "','") + "'";
	}

	/**
	 * array以separator=“,”做为分割格式化成字符串如：“a,b,c”<br>
	 * array以separator=“','”做为分割格式化成字符串如：“a','b','c”
	 * 
	 * @param arr
	 * @param separator
	 *            分割符
	 * @return
	 */
	public static String arrayToString(String[] arr, String separator) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < arr.length; i++) {
			sb.append(arr[i]);
			if (i != arr.length - 1) {
				sb.append(separator);
			}
		}
		return sb.toString();
	}

	/**
	 * array以“,”做为分割格式化成字符串如：“a,b,c”
	 * 
	 * @param arr
	 * @return
	 */
	public static String arrayToString(String[] arr) {
		return arrayToString(arr, ",");
	}

	public static String ascIIToHtml(String s) {
		// System.out.println(s);
		s = s.replaceAll("\"", """);
		// System.out.println(s);
		return s;
	}

	/**
	 * 字符形如：“,a,b,,c,”格式化成“a,b,c”
	 * 
	 * @param s
	 * @return
	 */
	public final static String formatString(String s) {
		s = s.replaceAll(",,", ",");
		s = s.replaceAll("^,", "");
		s = s.replaceAll(",$", "");
		return s;
	}

	/**
	 * 如果separator为“|”，字符形如：“|a|b||c|”格式化成“a|b|c”
	 * 
	 * @param s
	 * @param separator
	 *            分割符，不支持“\”
	 * @return
	 */
	public final static String formatString(String s, String separator) {
		s = s.replaceAll("\\" + separator + "\\" + separator, separator);
		s = s.replaceAll("^" + separator, "");
		s = s.replaceAll(separator + "$", "");
		return s;
	}

	/**
	 * 尝试把String s转换成int，如果转换异常则返回0;
	 * 
	 * @param s
	 * @return
	 */
	public final static int parseInt(String s) {
		try {
			int i = Integer.parseInt(s);
			return i;
		} catch (Exception e) {
			// System.out.println(">>>Util.parseInt()");
			// e.printStackTrace();
		}
		return 0;
	}

	/**
	 * 自动把request里的参数组装成形如：a1=vvv1&a2=vvv2...
	 * 
	 * @param request
	 * @param noAppendUrlParameterNames
	 *            不组装在字符串中的参数名列表
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public final static String readRequestCreateUrl(HttpServletRequest request,
			Set<String> noAppendUrlParameterNames) {
		StringBuffer sb = new StringBuffer();
		Enumeration<String> req = request.getParameterNames();
		int i = 0;
		while (req.hasMoreElements()) {
			String n = req.nextElement();
			if (noAppendUrlParameterNames != null) {
				if (!noAppendUrlParameterNames.contains(n)) {
					if (i != 0) {
						sb.append("&");
					}
					sb.append(n + "=" + request.getParameter(n));
					i++;
				}
			}
		}
		return sb.toString();
	}

	/**
	 * 自动把request里的参数组装成形如：a1=vvv1&a2=vvv2...
	 * 
	 * @param request
	 * @param noAppendUrlParameterName
	 *            不组装在字符串中的参数名
	 * @return
	 */
	public final static String readRequestCreateUrl(HttpServletRequest request,
			String noAppendUrlParameterName) {
		Set<String> set = new HashSet<String>();
		set.add(noAppendUrlParameterName);
		return readRequestCreateUrl(request, set);
	}

	/**
	 * @param date
	 * @return yyyy-MM-dd
	 */
	public final static String format1(Date date) {
		if (date != null) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			return sdf.format(date);
		}
		return "";
	}

	/**
	 * @param date
	 * @return yyyy年M月d日
	 */
	public final static String format2(Date date) {
		if (date != null) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy年M月d日");
			return sdf.format(date);
		}
		return "";
	}

	/**
	 * @param strDate
	 *            yyyy-MM-dd
	 * @return
	 */
	public final static Date toDate(String strDate) {
		if (strDate != null) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			try {
				return sdf.parse(strDate);
			} catch (ParseException e) {
			}
		}
		return null;
	}

	/**
	 * 检测str是否在array里。
	 * 
	 * @param array
	 * @param str
	 * @return true：在，false：不在
	 */
	public static boolean inArray(String[] array, String str) {
		for (String s : array) {
			if (s.equals(str)) {
				return true;
			}
		}
		return false;
	}
}

成员变量、类变量和实例变量：
类中定义的变量称为类的成员变量：
public class Myclass{
     private static String classVar="这是一个类变量";
     private String instanVal="这是一个实例变量";
}
类变量和实例变量的不同：
1.类变量被同一个类的所有实例共享，不同的对象只要所属的类相同，类变量的值就相同；实例对象不能在对象之间共享。
2.访问实例变量必须先获得对象的实例；访问类变量只需要制定类名。
3.实例变量在对象被创建时被初始化，在对象销毁的时候被销毁。类变量一旦创建就永驻内存。
例：
public class Count{
     private int serialNumber;
     private static  int counter=0;
     public Count(){
        counter++;
        serialNumber=counter;
     }
}

静态方法和非静态方法的比较：
1.静态方法只需制定类名，非静态方法需要获取对象实例。
2.非静态方法中可以使用类变量、实例变量，静态方法只能使用类变量。
3.静态方法中不能使用this关键字。
4.静态方法不能被覆盖。
public class Wrong{
    int a=9;
    public static int add(int s){
        return  a+s; // 错误
    }
}
用static修饰的初始化程序块即就是静态初始化块。
static {
   ....
}
静态初始化块在类加载的时候被执行一次，并且只执行一次。普通的初始化程序在每次创建对象时都会执行。


自动装箱和拆箱：
Integer param=13;
自动拆箱：
System.out.println(param+12);

javaBean 的讲解
  内省：
       操作JavaBean时,如Person类中id,name.
  Person person=new Person(1,"niuwenji");
  String property="name";
  PropertyDescriptor pd=new PropertyDescriptor(property,person.getClass());
  Method  method=pd.getReadMethod();
  method.invoke(person);
  PropertyDescriptor类在java.beans包中

  还有BeanInfo类 表示javaBean的信息
  BeanInfo beanInfo = Instrospector.getBeanInfo(pt.getClass());
  beanInfo.getPropertyDescriptors();//得到所有属性的描述
  
  commons-beanUtils.jar
  BeanUtils工具包操作javaBean 
  BeanUtils.setProperty(person,"name","niuwenji");
  BeanUtils.getProperty(person,"name");
  如果设置id（int型的）那么 setProperty(person,”id” , “1”)  1用的还是String类型
  Set和get方法都用的是String，set时传入的是String，get返回的是String因为web中用的传过来的是 String
  如果用的Date对象，如Person中有 birthday属性
  可以用 因为Birthday有一个setTime()方法，所以有一个time属性，设置time,time为long int型的
  BeanUtil.setProperty(person,”birthday.time”,”111”);
  这样是可以的，这跟EL表达式一样



  了解和入门注解的应用：
  注解的应用结构图->
  @interface A{}  //注解类
  
  @A
  class B{}      //应用了注解的类

  class C{
         B.class.isAnnotionPresernt(A.class);
         A a=B.class.getAnnotion(A.class);
  }      //对“应用了注解类的类”进行反射操作的类；

   
  
  @Target设置注解的使用区域Class 和 Interface，的父类Interface Type
  实现了Type的有Class，interface，enum，@interface注解

  所以一个注解类，的target属性，要在类上可以用在类上
  @Target（Element.TYPE）表示注解用在类上
  可以用 Element.FIELD用在字段上
  Element.METHOD用在方法上

  泛型的应用：泛型中的 ？ 通配符
  ?表示全部都可以用
  ArrayList<?>  list=new ArrayList<String>();
  list.add(new String()); //出错
  list.size();  //正确
  因为对于ArrayList<?>来接收对象后，就不能调用与类型有关的方法，如这里的add，因为不知道是什么类型的。
因为Add（E e） 是与类型有关系的。而size方法是与类型没有关系的。
 
  泛型中的？ 通配符的扩展：
  限定通配符的上边界，
  ArrayList<? extends Number>
  限制只能是Number或Number的子类
  正确：Vector<? Extends Number> x = new Vector<Integer>();
  错误：Vector<? Extends Number> x = new Vector<String>();
  限定通配符的下边界：
  Vector<? super Integer> y=new Vector<Number>();
  Vector<? super Integer> y=new Vector<Bype>();
  只能是Integer或它的父类;

<script language="javascript" type="text/javascript" src="/view/common/jquery.dialog.js"></script>

---------------------------------------------------
$(function(){
	$.extend({
		dialogInit : function(josn){
			var h='<div id="dialog">';
			h+='<div class="dialogBox">';
			h+='<div class="handler">';
			h+='<div class="title">标题</div>';
			h+='<div class="close">关闭</div>';
			h+='</div>';
			h+='<div class="content"><iframe id="contentBody" src="/view/common/jqueryDialogBlank.html" frameborder="0" scrolling="auto"></iframe></div>';
			h+='<div id="dialogLoading"></div>';
			h+='</div>';
			h+='<iframe id="dialogContentBgIframe" src="/view/common/jqueryDialogBlank.html" scrolling="no" frameborder="0"></iframe>';
			h+='</div>';
			//h+='<div id="dialogBg"><iframe id="dialogBgIframe" src="_blank" scrolling="no" frameborder="0"></iframe></div>';
			$('body').append(h);
			//system/view/dialogBlank.html
			
			var autoClose = true;
			var autoResize = true;
			if(josn!=null){
				if(josn.autoClose!=null) autoClose = josn.autoClose;
				if(josn.autoResize!=null) autoResize = josn.autoResize;
			}
			$('#dialog').data('autoClose',autoClose).data('autoResize',autoResize);
			
			$('#dialog #dialogLoading').hide();
			var w = $(window).width();
			var h = $(document).height();
			$('#dialogBg').hide().width(w).height(h);
//			var left = ($(window).width()-$('#dialog').width())/2;
//			var top = ($(window).height()-$('#dialog').height())/2;
//			$('#dialog').css({ 'left':left,'top':top });
			
			$('#dialog .close').click(function(){
				$('#dialog #contentBody').empty().attr('src' , '');
				$('#dialogBg').hide();
				$('#dialog').hide();
			});
			$('#dialog .close').hover(
				function(){ $(this).addClass('closeHover'); },
				function(){ $(this).removeClass('closeHover'); }
			);
			
			$('#dialogBgIframe').attr('src' , 'javascript:parent.$.dialogBgIFrameHtml();');
//			$(document).scroll(function(){
//				var top = ($(window).height()-$('#dialog').height())/2;
//				top+=$(window).scrollTop();
//				$('#dialog').animate({'top':top},{duration:'fast'});;
//			});
		},
		dialogShow : function(josn){
			var url = '';
			var title = '标题';
			var height = '500';
			var width = '90%';
			var autoResize = true;
			var onCloseDoRefresh = false;
			var onComplate = function(){};
			if(josn!=null){
				if (josn.url!=null) url = josn.url;
				if (josn.title!=null) title = josn.title;
				if (josn.height!=null) height = josn.height;
				if (josn.width!=null) width = josn.width;
				if (josn.autoResize!=null) autoResize = josn.autoResize;
				if (josn.onCloseDoRefresh!=null) onCloseDoRefresh = josn.onCloseDoRefresh;
				if (josn.onComplate!=null) onComplate = josn.onComplate;
			}
			
			$('#dialog .content').height(height);
			$('#dialog').width(width).height(height);
			$('#dialog #dialogLoading').height(height).show();
			
			var left = ($(window).width()-$('#dialog').width())/2;
			var top = ($(window).height()-$('#dialog').height())/2;
			$('#dialog').css({ 'left':left,'top':top });
			
			$('#dialog .title').text(title);
			$('#dialogBg').stop().fadeTo('fast', 0.3);
			
			
			
			$('#dialog').stop().slideDown('fast',function(){
				var iframe = document.getElementById("contentBody");
				iframe.src=url;
				if (!$.browser.msie) { //if not IE 
					iframe.onload = function(){ 
						var h = changeIFrameSize(iframe.contentWindow.document.body);
						$(iframe.contentWindow.document).change(function(e){
							if ($(iframe.contentWindow.document.body).find('fieldset').height() != (h-40) ){
								h = changeIFrameSize(iframe.contentWindow.document.body);
							}
						});
					}; 
				} else { 
					iframe.onreadystatechange = function(){
						if (iframe.readyState == "complete"){ 
							var h = changeIFrameSize(iframe.contentWindow.document.body);
							$(iframe.contentWindow.document).change(function(e){
								if ($(iframe.contentWindow.document.body).find('fieldset').height() != (h-40) ){
									h = changeIFrameSize(iframe.contentWindow.document.body);
								}
							});
						}
					}; 
				}
			});
			
			if(onCloseDoRefresh){
				$('#dialog .close').click(function(){
					$('#dialog #contentBody').empty().attr('src' , '');
					$('#dialogBg').hide();
					$('#dialog').hide();
					window.location.reload(true);
				});
			}
			
			
			function changeIFrameSize(o){
				if(autoResize){
					var bodyHeight = $(o).find('fieldset').height()+40;
					var wH = $(window).height();
					//alert(wH+","+bodyHeight);
					
					//$('#dialog').width($(o).find('fieldset').width()+70);
					if (bodyHeight>=40){
						if(bodyHeight>wH || bodyHeight=='auto'){
							bodyHeight = wH-80;
						}
						if(bodyHeight<200){
							bodyHeight=200;
						}
						//alert(wH+","+bodyHeight);
						$('#dialog .content').stop().animate({'height':bodyHeight},'fast',function(){
							$('#dialog').height(bodyHeight+40);
							var top = (wH-$('#dialog').height())/2;
							$('#dialog').stop().animate({ 'top':top },'fast',function(){
								//$('#dialog #contentBody').attr('scrolling','auto');
								onComplate($('#dialog'));
							});
						});
					}
				}
				//$('#dialog #contentBody').attr('scrolling','auto');
				$('#dialog #dialogLoading').hide();
				return bodyHeight;
			}
		},
		dialogClose : function(refreshPage,target){
			var pDoc = $(window.parent.document);
			
			pDoc.find('#dialog #contentBody').empty().attr('src' , '');
			pDoc.find('#dialogBg').hide();
			pDoc.find('#dialog').hide();
			pDoc.find('#dialog #dialogLoading').hide();
			var hrefTarget=window.parent;
			if(target!=null && target!=""){
				hrefTarget=target;
			}
			
			if(refreshPage==true){
				//window.parent.location.reload(true);
				hrefTarget.location.href = refreshPage;
			}else if(refreshPage==false){
				
			}else{
				hrefTarget.location.href = refreshPage;
			}
		},
		dialogBgIFrameHtml : function(){
			return '<html><body style="background:#000;"></body></html>';
		}
	});
});
$(function(){
//(function($) {
	$.fn.drags = function(opts) {
		var obj = $(this);
		var opt = $.extend({
			zIndex : 99999999,
			handler : obj,
			opacity : 1,
			onMove : function() {
			},
			onDown : function() {
			},
			onUp : function() {
			}
		},opts);
		var x1, y1;
		var oldCss = {};
		oldCss.opacity = obj.css('opacity') || 1;
		oldCss.zIndex = obj.css('z-index');
		
		function doMousedown(event) {
			var offset = obj.offset();
			x1 = event.clientX - offset.left;
			y1 = event.clientY - offset.top;
			var witchButton = false;
			if (document.all && event.button == 1) {
				witchButton = true;
			} else {
				if (event.button == 0)
					witchButton = true;
			}
			if (witchButton) {// FF0 , IE1
				obj.css('opacity', opt.opacity);
				obj.css('z-index', opt.zIndex);
				if (obj.css('position') != 'absolute') {
					obj.css('position', 'absolute');
				}
				opt.onDown(event);
				$(document).mousemove(function(event) {
					opt.onMove(event);
					obj.css("left", (event.clientX - x1) + "px");
					obj.css("top", (event.clientY - y1) + "px");
				})
			}
		}
		function doMouseup(event) {
			opt.onUp(event);
			obj.css('opacity', oldCss.opacity);
			obj.css('z-index', oldCss.zIndex);
			$(document).unbind("mousemove");
		}
		
		opt.handler.mousedown(doMousedown);
		opt.handler.mouseup(doMouseup);
		//opt.handler.mouseout(doMouseup);
	}
//})(jQuery);
});

1. 在jsp页面中代码

 <span class="spans" pid="${person.ID }" style="cursor:hand;"  >${person.TITLE }</span>

2.在 js 

 $(document).ready(function(){
	   $('.spans').click(function(){
	        var personId=$(this).attr('pid');
	        showDetail(personId);
	    });
 });

  /*
   * 查看用户详细资料
    * @param {} userId 用户ID
   */
   function showDetail(personId) {
	$.ajax({  
		type: "POST",  
		url: "/personInformation.xhtml",  
		data:"id="+personId+ "&time=" + new Date().getTime(),
		async: true, 
		beforeSend: function(){
			$("#load").text("正在提交数据请稍候......").show(); 
			},  
		success: function(text){ 
		   alert(text);
		   var  person=text;
		   //将json格式的Text转化成JSON对象：用eval('('+response+')')   
	            var resultJson = eval('('+text+')');   
		   alert(resultJson.ID);
		   alert(resultJson.TITLE);
		 }  
	   }); 
     }

3.  personInformation.xhtml中代码

		response.setCharacterEncoding("UTF-8");
		String id = request.getParameter("id");
		SYS_PERSON person = sys_personService.FindById(Integer.parseInt(id));
		JSONObject jsonObject = JSONObject.fromObject(person);
		System.out.println(jsonObject);
		response.getWriter().print(jsonObject);

JSON实例：根据前台传入的Id查出所需的对象在利用JSON变成有规律格式的字符串传到客户端在转化成JS对象

style="cursor:hand;"   变小手;

1.在HibernateBaseDao中

        /**
	 * <strong>得到分页数据</strong>
	 * @参数 pagesize 页面总条数
	 * @参数 currow   当前页
	 * @参数 hql      要执行的hql
	 * */
	List<T> getFenYeList(String hql);

       /**
	 * <strong>返回表中的记录总数</strong>
	 * @参数 String hql
	 * */
	Integer getTotalCount();
   
        /**
	 * <strong>获取分页page对象</strong>
	 * */
	Page getPage(HttpServletRequest request);

2.HibernateBaseDaoImpl中
        private Page p;
 

        public List<T> getFenYeList(final String hql) {
		return (List<T>) this.getHibernateTemplate().execute(
				new HibernateCallback<T>() {
					public T doInHibernate(org.hibernate.Session session)
							throws org.hibernate.HibernateException {
						Query query = session.createQuery(hql);
						query.setCacheable(true);
						query.setFirstResult(p.getStartRow());
						query.setMaxResults(p.getPageSize());
						List<T> rows = query.list();
						return (T) rows;
					}
				});
	 }



        public Integer getTotalCount() {
		String hql = "select count(*) from " + entityClass.getName();
		Long count = (Long) getSession().createQuery(hql).uniqueResult();
		return Integer.parseInt(count.toString());
	}


       	public Page getPage(HttpServletRequest request, String queryString) {
		this.setP(FenyeUtil.getPager(request, this.getTotalCount(queryString)));
		return this.getP();
	}

	public Page getP() {
		return p;
	}

	public void setP(Page p) {

		this.p = p;
	}

Jsp 页面调用



<div class="turnPage"> 共有${page.totalRows}条记录
  共${page.totalPages}页
  <html:link action="${pageUrl}pageMethod=first" paramName="page" paramProperty="currentPage" paramId="currentPage">首页</html:link>
  <html:link action="${pageUrl}pageMethod=previous" paramName="page" paramProperty="currentPage" paramId="currentPage">上一页</html:link>
  <bean:write name="page" property="currentPage" />
  /
  <bean:write name="page" property="totalPages" />
  <html:link action="${pageUrl}pageMethod=next" paramName="page" paramProperty="currentPage" paramId="currentPage">下一页</html:link>
  <html:link action="${pageUrl}pageMethod=last" paramName="page" paramProperty="currentPage" paramId="currentPage">尾页</html:link>
  转至：
  <select id="tpGo" url="${pageUrl}">
    
    
    ${page.goOption}
  
  
  </select>
</div>


Controller 中调用



        mav.addObject("page", sys_personService.getPage(request, user.getGROUPID()));
       mav.addObject("personList", sys_personService.getPageList(user.getGROUPID()));
       mav.addObject("pageUrl", "personList.xhtml?");
        

package com.springmvchibernate.ContinuingEducation.util;

import javax.servlet.http.HttpServletRequest;
import com.springmvchibernate.ContinuingEducation.util.Page;
/**
 * 这个类主要用于分页
 * @auther 牛文吉
 * */
public final class FenyeUtil {
	public static Page getPager(HttpServletRequest request, // 定义pager对象，用于传到页面
			int totalRows) {
		Page pager = new Page(totalRows);        // 从Request对象中获取当前页号
		String currentPage = request.getParameter("currentPage");     
                  // 如果当前页号为空，表示为首次查询该页
		  										                                
		if (currentPage != null) {	// //如果不为空，则刷新page对象，输入当前页号等信息
			Integer cp=Integer.parseInt(currentPage);
			pager.refresh(cp);
			pager.setCurrentPage(cp);
		}             // 获取当前执行的方法，首页，前一页，后一页，尾页。
		String pagerMethod = request.getParameter("pageMethod");
		if (pagerMethod != null) {
			if (pagerMethod.equals("first")) {
				pager.first();
			} else if (pagerMethod.equals("previous")) {
				pager.previous();
			} else if (pagerMethod.equals("next")) {
				pager.next();
			} else if (pagerMethod.equals("last")) {
				pager.last();
			}
		}
		pager.setRownumber((pager.getCurrentPage()-1)*pager.getPageSize()+1);  //设置序号
		return pager;
	}
}

package com.springmvchibernate.ContinuingEducation.util;

/**
 * 分页类Page 设定与分页页面有关的元素
 * 
 * @totalRows 总行数
 * @pageSize 每页显示的行数
 * @currentPage 当前页号
 * @totalPages 总页数
 * @startRow 当前页在数据库中的起始行
 * @rownumber 序号
 * @auther 牛文吉
 * */

public class Page {

	private int totalRows; // 总行数
	private int pageSize = 15; // 每页显示的行数
	private int currentPage; // 当前页号
	private int totalPages = 1; // 总页数
	private int startRow; // 当前页在数据库中的起始行
	private int rownumber = 1;
	private String goOption;

	public Page(int _totalRows) {
		totalRows = _totalRows;
		totalPages = totalRows / pageSize;// 总页数
		int mod = totalRows % pageSize;
		if (mod > 0) {
			totalPages++;
		}
		if (totalPages <= 0) {
			totalPages = 1;
		}
		currentPage = 1;
		startRow = 0;
	}

	public int getStartRow() {
		return startRow;
	}

	public int getTotalPages() {
		return totalPages;
	}

	public int getCurrentPage() {
		return currentPage;
	}

	public int getPageSize() {
		return pageSize;
	}

	public void setTotalRows(int totalRows) {
		this.totalRows = totalRows;
	}

	public void setStartRow(int startRow) {
		this.startRow = startRow;
	}

	public void setTotalPages(int totalPages) {
		this.totalPages = totalPages;
	}

	public void setCurrentPage(int currentPage) {
		this.currentPage = currentPage;
		startRow = (currentPage - 1) * pageSize;
	}

	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

	public int getTotalRows() {
		return totalRows;
	}

	public void first() {
		currentPage = 1;
		startRow = 0;
	}

	public void previous() {
		if (currentPage == 1) {
			return;
		}
		currentPage--;
		startRow = (currentPage - 1) * pageSize;
	}

	public void next() {
		if (currentPage < totalPages) {
			currentPage++;
		}
		startRow = (currentPage - 1) * pageSize;
	}

	public void last() {
		currentPage = totalPages;
		startRow = (currentPage - 1) * pageSize;
	}

	public void refresh(int _currentPage) {
		currentPage = _currentPage;
		if (currentPage > totalPages) {
			last();
		}
	}

	public int getRownumber() {
		// if(this.rownumber>this.pageSize){
		// rownumber=1;
		// }
		return rownumber++;
	}

	public void setRownumber(int rownumber) {
		this.rownumber = rownumber;
	}

	public String getGoOption() {
		StringBuffer sb = new StringBuffer();
		String strSel = "";
		for (int i = 1; i <= this.totalPages; i++) {
			if (i == this.currentPage) {
				strSel = " selected=\"selected\"";
			} else {
				strSel = "";
			}
			sb.append("<option value=\"" + i + "\"" + strSel + ">" + i
					+ "</option>");
		}
		this.goOption = sb.toString();
		return this.goOption;
	}

	public void setGoOption(String goOption) {
		this.goOption = goOption;
	}
}

package com.springmvchibernate.ContinuingEducation.controller;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import com.springmvchibernate.ContinuingEducation.log.Logger;
import com.springmvchibernate.ContinuingEducation.model.SYS_PERSON;
import com.springmvchibernate.ContinuingEducation.model.SYS_USER;
import com.springmvchibernate.ContinuingEducation.service.Sys_personService;
import com.springmvchibernate.ContinuingEducation.util.Utils;

/**
 * 
 *@see 企业人员控制层
 * 
 * @author 牛文吉
 * 
 */
@Controller
public class PersonController {
	@Autowired
	Sys_personService sys_personService;

	/**
	 * 控制面板-人员列表
	 * 
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping(value = "personList", method = RequestMethod.GET)
	public ModelAndView personList(HttpServletRequest request,
			HttpServletResponse response) {
		Logger.audit("进入->企业人员方法[personList.xhtml]");
		ModelAndView mav = new ModelAndView();
		try {
			SYS_USER user = (SYS_USER) request.getSession()
					.getAttribute("user");
			mav.addObject("page", sys_personService.getPage(request, user
					.getGROUPID()));
			mav.addObject("personList", sys_personService.getPageList(user
					.getGROUPID()));
			mav.addObject("pageUrl", "personList.xhtml?");
			mav
					.setViewName("ContinuingEducationWeb/success/personPage/personList");
		} catch (DataAccessException e) {
			Logger.error("DataAccessException->:访问数据异常，查询企业人员异常！" + e);
		} catch (Exception e) {
			Logger.error("Exception->:系统异常", e);
		} finally {
			response.reset();
			response.setCharacterEncoding("UTF-8");
			response.setContentType("text/html; charset=UTF-8");
			Logger.audit("finally->:重新初始化response");
		}
		Logger.audit("退出->:查询企业人员方法[personList.xhtml]");
		return mav;
	}

	/**
	 * 控制面板-人员添加初始化
	 * 
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping(value = "personAddInit", method = RequestMethod.GET)
	public ModelAndView personAddInit(HttpServletRequest request,
			HttpServletResponse response) {
		Logger.audit("进入->企业人员添加初始方法[personAdd.xhtml]");
		ModelAndView mav = new ModelAndView();
		try {
			mav
					.setViewName("ContinuingEducationWeb/success/personPage/personAdd");
		} catch (DataAccessException e) {
			Logger.error("DataAccessException->:访问数据异常，企业人员初始异常！" + e);
		} catch (Exception e) {
			Logger.error("Exception->:系统异常", e);
		} finally {
			response.reset();
			response.setCharacterEncoding("UTF-8");
			response.setContentType("text/html; charset=UTF-8");
			Logger.audit("finally->:重新初始化response");
		}
		Logger.audit("退出->:查询企业人员添加初始方法[personAdd.xhtml]");
		return mav;
	}

	/**
	 * 控制面板-人员添加
	 * 
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping(value = "personAdd", method = RequestMethod.POST)
	public ModelAndView personAdd(HttpServletRequest request,
			HttpServletResponse response) {
		Logger.audit("进入->企业人员添加方法[personAdd.xhtml]");
		ModelAndView mav = new ModelAndView();
		try {
			SYS_USER user = (SYS_USER) request.getSession()
					.getAttribute("user");
			SYS_PERSON person = new SYS_PERSON();
			person.setGROUPID(user.getGROUPID());
			person.setGROUPTITLE(user.getUNITSNAME());
			person.setTITLE(request.getParameter("TITLE").trim());
			person.setDRIVINGCODE(request.getParameter("DRIVINGCODE"));
			person.setOBTAINTIME(Utils.toDate(request
					.getParameter("OBTAINTIME")));
			person.setBIRTHDAY(Utils.toDate(request.getParameter("BIRTHDAY")));
			person.setCERTCODE(request.getParameter("CERTCODE"));
			person.setTEL(request.getParameter("TEL"));
			person.setEMAIL(request.getParameter("EMAIL"));
			person.setAREA(user.getAREA());
			person.setTAREA(user.getTAREA());
			person.setSEX(request.getParameter("SEX"));
			person.setPAPERS(request.getParameter("PAPERS"));
			person.setPAPERSCODE(request.getParameter("PAPERSCODE"));
			person.setDEGREE(request.getParameter("DEGREE"));
			person.setCERTTYPE(request.getParameter("personTypeCode"));
			person.setTCERTTYPE(request.getParameter("personTypeTitle"));
			sys_personService.save(person);
			mav.addObject("message", "添加成功！");
			mav.addObject("backUrl", "/personList.xhtml");
			mav.setViewName("ContinuingEducationWeb/DialogMessage");
		} catch (DataAccessException e) {
			Logger.error("DataAccessException->:访问数据异常，查询企业人员异常！" + e);
		} catch (Exception e) {
			Logger.error("Exception->:系统异常", e);
		}
		Logger.audit("退出->:查询企业人员添加方法[personAdd.xhtml]");
		return mav;
	}

	/**
	 * 控制面板-人员修改初始
	 * 
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping(value = "personUpInit", method = RequestMethod.GET)
	public ModelAndView personUpInit(HttpServletRequest request,
			HttpServletResponse response) {
		Logger.audit("进入->企业人员修改方法[personUpInit.xhtml]");
		ModelAndView mav = new ModelAndView();
		String id = request.getParameter("id");
		try {
			SYS_PERSON person = sys_personService
					.FindById(Integer.parseInt(id));
			if (!Utils.isNull(person.getCERTTYPE())) {
				String bigclass = person.getCERTTYPE().substring(0, 2);
				String code1 = person.getCERTTYPE().substring(2, 4);
				String code2 = person.getCERTTYPE().substring(4, 6);
				String code3 = person.getCERTTYPE().substring(6, 8);
				System.out.println(bigclass);
				System.out.println(code1);
				System.out.println(code2);
				System.out.println(code3);
				mav.addObject("bigclass", bigclass);
				mav.addObject("code1", code1);
				mav.addObject("code2", code2);
				mav.addObject("code3", code3);
			}
			mav.addObject("person", person);
			mav
					.setViewName("ContinuingEducationWeb/success/personPage/personUp");
		} catch (DataAccessException e) {
			Logger.error("DataAccessException->:访问数据异常，查询企业人员异常！" + e);
		} catch (Exception e) {
			Logger.error("Exception->:系统异常", e);
		}
		Logger.audit("退出->:查询企业人员添加方法[personUpInit.xhtml]");
		return mav;
	}

	/**
	 * 控制面板-人员修改
	 * 
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping(value = "personUp", method = RequestMethod.POST)
	public ModelAndView personUp(HttpServletRequest request,
			HttpServletResponse response) {
		Logger.audit("进入->企业人员修改方法[personUp.xhtml]");
		ModelAndView mav = new ModelAndView();
		String id = request.getParameter("id");
		try {
			SYS_PERSON person = sys_personService
					.FindById(Integer.parseInt(id));
			person.setTITLE(request.getParameter("TITLE").trim());
			person.setDRIVINGCODE(request.getParameter("DRIVINGCODE"));
			person.setOBTAINTIME(Utils.toDate(request
					.getParameter("OBTAINTIME")));
			person.setBIRTHDAY(Utils.toDate(request.getParameter("BIRTHDAY")));
			person.setCERTCODE(request.getParameter("CERTCODE"));
			person.setTEL(request.getParameter("TEL"));
			person.setEMAIL(request.getParameter("EMAIL"));
			person.setSEX(request.getParameter("SEX"));
			person.setPAPERS(request.getParameter("PAPERS"));
			person.setPAPERSCODE(request.getParameter("PAPERSCODE"));
			person.setDEGREE(request.getParameter("DEGREE"));
			person.setCERTTYPE(request.getParameter("personTypeCode"));
			person.setTCERTTYPE(request.getParameter("personTypeTitle"));
			sys_personService.updatePerson(person);
			mav.addObject("message", "修改成功！");
			mav.addObject("backUrl", "/personList.xhtml");
			mav.setViewName("ContinuingEducationWeb/DialogMessage");
		} catch (DataAccessException e) {
			Logger.error("DataAccessException->:访问数据异常，查询企业人员异常！" + e);
		} catch (Exception e) {
			Logger.error("Exception->:系统异常", e);
		}
		Logger.audit("退出->:查询企业人员添加方法[personUp.xhtml]");
		return mav;
	}

	/**
	 * 控制面板-人员删除
	 * 
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping(value = "personDe", method = RequestMethod.GET)
	public ModelAndView personDe(HttpServletRequest request,
			HttpServletResponse response) {
		Logger.audit("进入->企业人员删除方法[personDe.xhtml]");
		ModelAndView mav = new ModelAndView();
		String id = request.getParameter("id");
		try {
			SYS_PERSON person = sys_personService
					.FindById(Integer.parseInt(id));
			sys_personService.delete(person);
			mav.addObject("message", "删除成功！");
			mav.addObject("backUrl", "/personList.xhtml");
			mav.setViewName("ContinuingEducationWeb/DialogMessage");
		} catch (DataAccessException e) {
			Logger.error("DataAccessException->:访问数据异常，查询企业人员异常！" + e);
		} catch (Exception e) {
			Logger.error("Exception->:系统异常", e);
		}
		Logger.audit("退出->:查询企业人员删除方法[personDe.xhtml]");
		return mav;
	}
}

package com.springmvchibernate.ContinuingEducation.service.impl;

import java.io.Serializable;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.springmvchibernate.ContinuingEducation.dao.Sys_personDao;
import com.springmvchibernate.ContinuingEducation.model.SYS_PERSON;
import com.springmvchibernate.ContinuingEducation.service.Sys_personService;
import com.springmvchibernate.ContinuingEducation.util.Page;
import com.springmvchibernate.ContinuingEducation.util.Utils;

@Service("sys_personService")
@SuppressWarnings("unchecked")
/**
 * @说明  人员业务实现类
 * @作者 牛文吉
 * */
public class Sys_personServiceImpl implements Sys_personService {
	@Autowired
	Sys_personDao sys_personDao;

	public SYS_PERSON FindById(int id) {
		return (SYS_PERSON) sys_personDao.FindById(id);
	}

	public SYS_PERSON FindByProperty(String property, String value) {
		return (SYS_PERSON) sys_personDao.FindByProperty(property, value);
	}

	public void delete(SYS_PERSON entity) {
		sys_personDao.delete(entity);
	}

	public List<SYS_PERSON> getAllUser() {
		return sys_personDao.getAllUser();
	}

	public Page getPage(HttpServletRequest request, String groupId) {
		return sys_personDao.getPage(request, " p where p.GROUPID='" + groupId
				+ "' order by p.ID desc ");
	}

	public List<SYS_PERSON> getPageList(String groupId) {
		return sys_personDao.getPageList("from SYS_PERSON p where p.GROUPID='"
				+ groupId + "' order by p.ID desc ");
	}

	public SYS_PERSON save(SYS_PERSON entity) {
		return (SYS_PERSON) sys_personDao.savePerson(entity);
	}

	public SYS_PERSON updatePerson(SYS_PERSON entity) {
		return (SYS_PERSON) sys_personDao.updatePerson(entity);
	}

	public List<SYS_PERSON> getPersonByGroupId(String groupId) {
		return sys_personDao
				.getPersonByHql("from SYS_PERSON p where p.GROUPID='" + groupId
						+ "' order by p.ID desc");
	}

	public List<SYS_PERSON> getPersonByIds(Serializable[] ids) {
		return sys_personDao.getPersonByIds(ids);
	}

	public Page getSearchPage(HttpServletRequest request, String area,
			String name,String cardno) {
		StringBuffer hql = new StringBuffer();
		hql.append(" person where person.AREA like '");
		hql.append(area).append("%'");
		if (!Utils.isNull(name)) {
			hql.append(" and person.TITLE like '");
			hql.append(name).append("'");
		}
		if(!Utils.isNull(cardno)){
			hql.append(" and person.PAPERSCODE='");
			hql.append(cardno).append("'");
		}
		hql.append(" order by person.GROUPID desc ");
		return sys_personDao.getPage(request, hql.toString());
	}

	public List<SYS_PERSON> getSearchPageList(String area,String name,String cardno) {
		StringBuffer hql = new StringBuffer();
		hql.append("from SYS_PERSON person where person.AREA like '");
		hql.append(area).append("%'");
		if (!Utils.isNull(name)) {
			hql.append(" and person.TITLE like '");
			hql.append(name).append("'");
		}
		if(!Utils.isNull(cardno)){
			hql.append(" and person.PAPERSCODE='");
			hql.append(cardno).append("'");
		}
		hql.append(" order by person.GROUPID desc ");
		return sys_personDao.getPageList(hql.toString());
	}

}

package com.springmvchibernate.ContinuingEducation.service;

import java.io.Serializable;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import com.springmvchibernate.ContinuingEducation.model.SYS_PERSON;
import com.springmvchibernate.ContinuingEducation.util.Page;

/**
 * @说明 人员service
 * @作者 牛文吉
 * */
public interface Sys_personService {

	/**
	 * <strong>获取所有人员</strong>
	 * */
	List<SYS_PERSON> getAllUser();

	/**
	 * <strong>获取企业人员根据企业ID</strong>
	 * 
	 * @param groupIds
	 * @return
	 */
	List<SYS_PERSON> getPersonByGroupId(String groupId);

	/**
	 * <strong>获取企业人员根据IDS</strong>
	 * 
	 * @param ids
	 * @return
	 */
	List<SYS_PERSON> getPersonByIds(Serializable[] ids);

	/**
	 * <strong>根据id获取person</strong>
	 * */
	SYS_PERSON FindById(int id);

	/**
	 * <strong>根据property获取person</strong>
	 * */
	SYS_PERSON FindByProperty(String property, String value);

	/**
	 * <strong>更新user</strong>
	 * */
	SYS_PERSON updatePerson(SYS_PERSON entity);

	/**
	 * <strong>增加user</strong>
	 * */
	SYS_PERSON save(SYS_PERSON entity);

	/**
	 * <strong>删除user</strong>
	 * */
	void delete(SYS_PERSON entity);

	/**
	 * 页面page对象
	 * 
	 * @return page
	 * */
	Page getPage(HttpServletRequest request, String groupId);

	/**
	 * 页面分页数据
	 * 
	 * @return List<SYS_PERSON>
	 * */
	List<SYS_PERSON> getPageList(String groupId);

	/**
	 * 政府用户人员查询
	 * 
	 * @param request
	 * @param area
	 * @return
	 */
	Page getSearchPage(HttpServletRequest request, String area,String name,String cardno);

	/**
	 * 政府用户人员查询
	 * 
	 * @param request
	 * @param area
	 * @return
	 */
	List<SYS_PERSON> getSearchPageList(String area,String name,String cardno);

}

package com.springmvchibernate.ContinuingEducation.dao.impl;

import java.io.Serializable;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.springframework.stereotype.Repository;

import com.springmvchibernate.ContinuingEducation.base.dao.impl.HibernateBaseDaoImpl;
import com.springmvchibernate.ContinuingEducation.dao.Sys_personDao;
import com.springmvchibernate.ContinuingEducation.model.SYS_PERSON;
import com.springmvchibernate.ContinuingEducation.util.Page;

@SuppressWarnings("unchecked")
@Repository(value = "sys_personDao")
public class Sys_personDaoImpl extends HibernateBaseDaoImpl<SYS_PERSON, Long>
		implements Sys_personDao {

	public SYS_PERSON FindById(int id) {
		return super.get(id);
	}

	public SYS_PERSON FindByProperty(String property, String value) {
		return super.getByProperty(property, value);
	}

	public List<SYS_PERSON> getAllUser() {
		return super.findAll();
	}

	public List<SYS_PERSON> getPageList(String hql) {
		return super.getFenYeList(hql);
	}

	public List<SYS_PERSON> getPersonByHql(String hql) {
		return super.createQuery(hql);
	}

	public SYS_PERSON updatePerson(Object entity) {
		return super.update(entity);
	}

	public Page getPage(HttpServletRequest request, String queryString) {
		return super.getPage(request, queryString);

	}

	public SYS_PERSON savePerson(Object entity) {
		return super.save(entity);
	}

	public List getPersonByIds(Serializable[] ids) {
		return super.getByIds(ids);
	}
	
	public Integer getTotalCount(String queryString){
		return super.getTotalCount(queryString);
	}

}

package com.springmvchibernate.ContinuingEducation.dao;

import java.io.Serializable;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import com.springmvchibernate.ContinuingEducation.base.dao.HibernateBaseDao;
import com.springmvchibernate.ContinuingEducation.util.Page;

/**
 * @说明 个人用户DAO
 * @作者 牛文吉
 * */
@SuppressWarnings( { "hiding", "unchecked" })
public interface Sys_personDao<SYS_PERSON, Long> extends HibernateBaseDao {
	/**
	 * <strong>获取所有人员</strong>
	 * */
	List<SYS_PERSON> getAllUser();

	/**
	 * <strong>获取企业人员根据Hql</strong>
	 * 
	 * @param groupIds
	 * @return
	 */
	List<SYS_PERSON> getPersonByHql(String hql);

	/**
	 * <strong>获取企业人员根据IDS</strong>
	 * 
	 * @param ids
	 * @return
	 */
	List<SYS_PERSON> getPersonByIds(Serializable[] ids);

	/**
	 * <strong>根据id获取person</strong>
	 * */
	SYS_PERSON FindById(int id);

	/**
	 * <strong>根据property获取person</strong>
	 * */
	SYS_PERSON FindByProperty(String property, String value);

	/**
	 * <strong>更新user</strong>
	 * */
	SYS_PERSON updatePerson(SYS_PERSON entity);

	/**
	 * <strong>增加user</strong>
	 * */
	SYS_PERSON savePerson(SYS_PERSON entity);

	/**
	 * <strong>删除user</strong>
	 * */
	void delete(SYS_PERSON entity);

	/**
	 * 页面page对象
	 * 
	 * @return page
	 * */
	Page getPage(HttpServletRequest request);

	/**
	 * 页面page对象
	 * 
	 * @return page
	 * */
	Page getPage(HttpServletRequest request, String queryString);

	/**
	 * 页面分页数据
	 * 
	 * @return List<SYS_PERSON>
	 * */
	List<SYS_PERSON> getPageList(String hql);

	/**
	 * 根据Hql获取人员数量
	 * 
	 * @param queryString
	 * @return
	 */
	Integer getTotalCount(String queryString);

}

package com.springmvchibernate.ContinuingEducation.base.dao.impl;
 
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.hibernate.Query;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.util.Assert;
import com.springmvchibernate.ContinuingEducation.base.dao.HibernateBaseDao;
import com.springmvchibernate.ContinuingEducation.util.Page;
import com.springmvchibernate.ContinuingEducation.util.FenyeUtil;

@SuppressWarnings("unchecked")
/**
 * <strong>
 * 实现于采用泛型模式设计的
 * HibernateBaseDao extends HibernateDaoSupport
 * </strong> 
 * @参数 <T>
 * @参数 ID extends Serializable
 * @版本 v1.0 2011-9-26
 * @作者 牛文吉
 * */
public class HibernateBaseDaoImpl<T, ID extends Serializable> extends
		HibernateDaoSupport implements HibernateBaseDao {
	private Class<T> entityClass = null;
	private Page p;

	public HibernateBaseDaoImpl() {
		entityClass = (Class<T>) ((ParameterizedType) getClass()
				.getGenericSuperclass()).getActualTypeArguments()[0];
	}

	/**
	 * 继承HibernateDaoSupport注入sessionfactory的2种方式一种是下面
	 * 一种是在spring-servlet.xml中的default-autowire="byName"
	 * 
	 * */
	public List<T> createQuery(final String queryString) {
		Assert.notNull(queryString, "queryString is required");
		return (List<T>) this.getHibernateTemplate().execute(
				new HibernateCallback<T>() {
					public T doInHibernate(org.hibernate.Session session)
							throws org.hibernate.HibernateException {
						Query query = session.createQuery(queryString);
						query.setCacheable(true);
						List<T> rows = query.list();
						return (T) rows;
					}
				});
	}

	public void delete(final Object entity) {
		Assert.notNull(entity, "entity is required");
		this.getHibernateTemplate().execute(new HibernateCallback<Object>() {
			public Object doInHibernate(org.hibernate.Session session)
					throws org.hibernate.HibernateException {
				session.delete(entity);
				return null;
			}
		});
	}

	public List findAll() {
		getHibernateTemplate().setCacheQueries(true);
		List list = getHibernateTemplate().loadAll(entityClass);
		org.hibernate.Hibernate.initialize(list);
		getHibernateTemplate().setCacheQueries(false);
		return list;
	}

	public List<T> getFenYeList(final String hql) {
		return (List<T>) this.getHibernateTemplate().execute(
				new HibernateCallback<T>() {
					public T doInHibernate(org.hibernate.Session session)
							throws org.hibernate.HibernateException {
						Query query = session.createQuery(hql);
						query.setCacheable(true);
						query.setFirstResult(p.getStartRow());
						query.setMaxResults(p.getPageSize());
						List<T> rows = query.list();
						return (T) rows;
					}
				});
	}

	public T get(Serializable id) {
		Assert.notNull(id, "id is required");
		return getHibernateTemplate().get(entityClass, id);
	}

	public T save(final Object entity) {
		Assert.notNull(entity, "entity is required");
		return (T) this.getHibernateTemplate().execute(
				new HibernateCallback<T>() {
					public T doInHibernate(org.hibernate.Session session)
							throws org.hibernate.HibernateException {
						session.save(entity);
						return (T) entity;
					}
				});
	}

	public T saveOrUpdate(final Object entity) {
		Assert.notNull(entity, "entity is required");
		return (T) this.getHibernateTemplate().execute(
				new HibernateCallback<T>() {
					public T doInHibernate(org.hibernate.Session session)
							throws org.hibernate.HibernateException {
						session.saveOrUpdate(entity);
						return (T) entity;
					}
				});
	}

	public T update(final Object entity) {
		Assert.notNull(entity, "entity is required");
		return (T) this.getHibernateTemplate().execute(
				new HibernateCallback<T>() {
					public T doInHibernate(org.hibernate.Session session)
							throws org.hibernate.HibernateException {
						session.update(entity);
						return (T) entity;
					}
				});
	}

	public List<T> getByIds(Serializable[] ids) {
		Assert.notEmpty(ids, "ids must not be empty");
		String hql = "from " + entityClass.getName()
				+ " as model where model.id in(:ids)";
		List<T> list = getSession().createQuery(hql).setCacheable(true)
				.setParameterList("ids", ids).list();
		return list;
	}

	public List<String> getString(String hql) {
		List<String> list = getSession().createQuery(hql).list();
		return list;
	}

	public T getByProperty(String propertyName, Object value) {
		Assert.hasText(propertyName, "propertyName must not be empty");
		Assert.notNull(value, "value is required");
		String hql = "from " + entityClass.getName() + " as model where model."
				+ propertyName + " = ?";
		T T = (T) getSession().createQuery(hql).setCacheable(true)
				.setParameter(0, value).uniqueResult();
		return T;
	}

	public Integer getTotalCount() {
		String hql = "select count(*) from " + entityClass.getName();
		Long count = (Long) getSession().createQuery(hql).uniqueResult();
		return Integer.parseInt(count.toString());
	}

	public Integer getTotalCount(String queryString) {
		String hql = "select count(*) from " + entityClass.getName()
				+ queryString;
		Long count = (Long) getSession().createQuery(hql).uniqueResult();
		return Integer.parseInt(count.toString());
	}

	public void delete(Serializable[] ids) {
		Assert.notEmpty(ids, "ids must not be empty");
		for (Serializable id : ids) {
			T entity = get(id);
			getSession().delete(entity);
		}
	}

	public void evict(Object object) {
		Assert.notNull(object, "object is required");
		getSession().evict(object);
	}

	public boolean isExist(String propertyName, Object value) {
		Assert.hasText(propertyName, "propertyName must not be empty");
		Assert.notNull(value, "value is required");
		T object = getByProperty(propertyName, value);
		return (object != null);
	}

	public Page getPage(HttpServletRequest request) {
		this.setP(FenyeUtil.getPager(request, this.getTotalCount()));
		return this.getP();
	}

	public Page getPage(HttpServletRequest request, String queryString) {
		this.setP(FenyeUtil.getPager(request, this.getTotalCount(queryString)));
		return this.getP();
	}

	public Page getP() {
		return p;
	}

	public void setP(Page p) {

		this.p = p;
	}

	public List<T> findByMap(Map map) {

		return null;
	}

}

package com.springmvchibernate.ContinuingEducation.base.dao;
import java.io.Serializable;
import java.util.*;
import javax.servlet.http.HttpServletRequest;
import com.springmvchibernate.ContinuingEducation.util.Page;
/** 
 * <strong>采用泛型模式设计的
 * HibernateBaseDao 
 * O(∩_∩)O哈哈~
 * </strong>
 * @参数  T
 * @参数  ID extends Serializable
 * @版本 v1.0 2011-9-26
 * @作者 牛文吉
 * */
public interface HibernateBaseDao<T,ID extends Serializable> {
	/**
	 * <strong>根据对象id获得一个对象</strong>
	 * @参数 id 对象主键id
	 * @返回 返回一个对象类型
	 */
	T get(ID id);
	/**
	 * <strong>保存一条记录</strong>
	 * @参数 entity 一个对象实体
	 * @返回 返回保存的对象实体
	 */
	T save(T entity);
	/**
	 * <strong>保存一条新的记录或者跟新一条新的记录</strong>
	 * @参数 entity 一个对象实体
	 * @返回 返回保存/更新的对象实体
	 */
	T saveOrUpdate(T entity);
	/**
	 * <strong>更新一条记录</strong>
	 * @参数 entity 一个对象实体
	 * @返回 返回更新的对象实体
	 */
	T update(T entity);
	/**
	 * <strong>执行del 或者 update语句 </strong>
	 * <li> delete from 实体名 us  where us.id>0
	 * <li> update 实体名 us set us.ucode = 'admin' where id in (0,1,2,3,4)
	 * @参数 hql
	 */
	void delete(T entity);
	/**
	 * <strong>查询出所有的对象集合</strong>
	 * @返回 返回一个对象实体的集合
	 */
	List<T> findAll();
	/**
	 * <strong>得到分页数据</strong>
	 * @参数 pagesize 页面总条数
	 * @参数 currow   当前页
	 * @参数 hql      要执行的hql
	 * */
	List<T> getFenYeList(String hql);
	/**
	 * <strong>返回表中的记录总数</strong>
	 * @参数 String hql
	 * */
	Integer getTotalCount();
	/**
	 * <strong>根据HQL语句返回List</strong>
	 * @参数 String hql
	 * */
	List<T> createQuery(final String hql);
	/**
	 * <strong>根据ID数组获取实体对象集合.</strong>
	 * 
	 * @参数 ids
	 *            - id数组
	 * @返回 List - 实体集合
	 */
	public List<T> getByIds(ID[] ids) ;
	/**
	 * <strong>根据属性名和属性值获取实体对象</strong>
	 * 
	 * @参数 propertyName
	 *            - 属性名
	 * @参数 value
	 *            - 属性值
	 * @返回 T - 对象
	 */
	public T getByProperty(String propertyName, Object value);
	/**
	 * <strong>根据ID数组删除实体对象</strong>
	 * 
	 * @参数 ids
	 *            - id数组
	 */
	public void delete(ID[] ids) ;
	/**
	 * <strong>清除某一对象</strong>.
	 */
	public void evict(Object object);
	/**
	 * <strong>根据属性名判断数据是否已存在.</strong>
	 * 
	 * @参数 propertyName
	 *            属性名称
	 * @参数 value
	 *            值
	 * @返回 boolean
	 */
	public boolean isExist(String propertyName, Object value);
	/**
	 * <strong>根据map组合参数查询</strong>
	 * @参数 map
	 * @返回 List<T>
	 * */
	List<T> findByMap(final Map<?,?> map);
	/**
	 * <strong>获取分页page对象</strong>
	 * */
	Page getPage(HttpServletRequest request);

}

1、关于JSP标签的好处就不再罗嗦

数据字典就是使用的下拉框，只要定义使用那个字典就会将这个字典可用的内容显示出来

显示字典时只要定义那个字典和属性值就可以显示出字典的显示值


2、首先在web.xml中定义自定义标签加载的引用，两个属性分别是引用的URI和加载路径
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee           
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
	<jsp-config>
		<taglib>
			<taglib-uri>/tld/web-html</taglib-uri>
			<taglib-location>/WEB-INF/tlds/web-html.tld</taglib-location>
		</taglib>
	</jsp-config>
</web-app>  

3、在web-html.tld中定义自己的标签，数据字典应用的话我们需要一个标签库，三个标签。分别是，select标签，options标签，和现实数据字典的标签，每个标签都对应不同的实现类

<?xml version="1.0" encoding="UTF-8"?>  
 <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"       
    "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
	<tlib-version>1.0</tlib-version><!-- 标签库版本 -->
	<jsp-version>1.2</jsp-version>  <!-- 标签库要求的JSP规范版本 -->
	<short-name>html</short-name>   <!-- JSP页面编写工具可以用来创建助记名的可选名字 -->
	<tag>
		<name>select</name>
		<tag-class>com.SelectTag</tag-class>
		<body-content>JSP</body-content>
		<attribute>
			<name>name</name>
			<rtexprvalue>true</rtexprvalue>
		</attribute>
		<attribute>
			<name>style</name>
			<rtexprvalue>true</rtexprvalue>
		</attribute>
	</tag>
	<tag>
		<name>options</name>
		<tag-class>com.OptionsTag</tag-class>
		<body-content>JSP</body-content>
		<attribute>
			<name>collection</name>
			<rtexprvalue>true</rtexprvalue>
		</attribute>
	</tag>
	<tag>
		<name>selectDisplay</name>
		<tag-class>com.SelectDisplay</tag-class>
		<body-content>JSP</body-content>
		<attribute>
			<name>collection</name>
			<rtexprvalue>true</rtexprvalue>
		</attribute>
		<attribute>
			<name>name</name>
			<rtexprvalue>true</rtexprvalue>
		</attribute>
		<attribute>
			<name>value</name>
			<rtexprvalue>true</rtexprvalue>
		</attribute>
	</tag>
</taglib>   



4、实现类

实现类的作用就是在后台拼接所需HTML标签内容，然后由JSP进行输出

实现类最主要的两个方法，一个遇到这个标签开始时输出，一个是结束时输出

如果需要定义属性，可以参考实现类定义属性，并在TLD中定义，在JSP中使用标签时快捷键就可以出来这个属性

首先是select标签的代码：





package com.springmvchibernate.ContinuingEducation.base.dao;

import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.tagext.BodyTagSupport;

/**
 * 
 * * TagSupport与BodyTagSupport的区别: *
 * 主要看标签处理类是否要读取标签体的内容和改变标签体返回的内容，如果不需要就用TagSupport， 否则就用BodyTagSupport *
 * 用TagSupport实现的标签， 都可以用BodyTagSupport来实现，因为BodyTagSupport继承了TagSupport
 */
@SuppressWarnings("serial")
public class SelectTag extends BodyTagSupport {
	@Override
	public int doStartTag() throws JspException {
		try {
			StringBuffer results = new StringBuffer("<select");
			if (name != null) {
				results.append(" name=\"");
				results.append(name);
				results.append("\"");
			}
			if (style != null) {
				results.append(" style=\"");
				results.append(style);
				results.append("\"");
			}
			results.append(">");
			pageContext.getOut().write(results.toString());
		} catch (IOException ex) {
			throw new JspTagException("错误");
		}
		return EVAL_BODY_INCLUDE;
	}

	@Override
	public int doEndTag() throws JspException {
		try {
			StringBuffer results = new StringBuffer("");
			// 因为下拉中包含下拉内容，所以只能在遇到结束标签时才能写select结束
			results.append("</select>");
			pageContext.getOut().write(results.toString());
		} catch (IOException ex) {
			throw new JspTagException("错误");
		}
		return EVAL_PAGE;
	}

	// 样式
	protected String style;
	// 名字
	protected String name;

	public String getStyle() {
		return style;
	}

	public void setStyle(String style) {
		this.style = style;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	/**
	 * doStartTag()方法是遇到标签开始时会呼叫的方法， 其合法的返回值是EVAL_BODY_INCLUDE与SKIP_BODY,
	 * 前者表示将显示标签间的文字，后者表示不显示标签间的文字
	 * doEndTag()方法是在遇到标签结束时呼叫的方法，其合法的返回值是EVAL_PAGE与SKIP_PAGE
	 * ，前者表示处理完标签后继续执行以下的JSP网页，后者是表示不处理接下来的JSP网页
	 * doAfterBody(),这个方法是在显示完标签间文字之后呼叫的
	 * ，其返回值有EVAL_BODY_AGAIN与SKIP_BODY，前者会再显示一次标签间的文字，后者则继续执行标签处理的下一步
	 * EVAL_BODY_INCLUDE：把Body读入存在的输出流中，doStartTag()函数可用
	 * EVAL_PAGE：继续处理页面，doEndTag()函数可用
	 * SKIP_BODY：忽略对Body的处理，doStartTag()和doAfterBody()函数可用
	 * SKIP_PAGE：忽略对余下页面的处理，doEndTag()函数可用
	 * EVAL_BODY_BUFFERED：申请缓冲区，由setBodyContent
	 * ()函数得到的BodyContent对象来处理tag的body，如果类实现了BodyTag，那么doStartTag()可用，否则非法
	 * EVAL_BODY_AGAIN：请求继续处理body，返回自doAfterBody()，这个返回值在你制作循环tag的时候是很有用的
	 * 预定的处理顺序是：doStartTag()返回SKIP_BODY,doAfterBodyTag()
	 * 返回SKIP_BODY,doEndTag()返回EVAL_PAGE 如果继承了TagSupport之后，
	 * 如果没有改写任何的方法，标签处理的执行顺序是：doStartTag() ->不显示文字 ->doEndTag()->执行接下来的网页
	 * 如果您改写了doStartTag(),则必须指定返回值,
	 * 如果指定了EVAL_BODY_INCLUDE,则执行顺序是：doStartTag()->显示文字
	 * ->doAfterBodyTag()->doEndTag()-> 执行下面的网页
	 */

}




关于返回参数，返回具体数字也可以，不用过于纠结

然后是下拉内容实现类

import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.tagext.BodyTagSupport;

@SuppressWarnings("serial")
public class OptionsTag extends BodyTagSupport {
	@Override
	public int doStartTag() throws JspException {
		return EVAL_BODY_INCLUDE;
	}

	@Override
	public int doEndTag() throws JspException {
		try {
			StringBuffer results = new StringBuffer("");
			if ("SEX".equals(collection)) {
				results
						.append("<option value=\"0\"  selected=\"selected\">请选择</option>");
				results.append("<option value=\"1\">男</option>");
				results.append("<option value=\"2\">女</option>");
			}
			pageContext.getOut().write(results.toString());
		} catch (IOException ex) {
			throw new JspTagException("错误");
		}
		return EVAL_PAGE;
	}

	// collection只是传递一个标识，具体下拉值内容是从数据库取还是从请求中得到为不同具体实现
	protected String collection;

	public String getCollection() {
		return collection;
	}

	public void setCollection(String collection) {
		this.collection = collection;
	}
}


具体你的字典数据从数据库中如何存储如何查询，可以自定义实现

显示的标签实现，为了将来可以在页面取到标签内容值，我们定义隐藏域来保存属性值，然后在显示显示内容

import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.tagext.BodyTagSupport;

@SuppressWarnings("serial")
public class SelectDisplay extends BodyTagSupport {
	@Override
	public int doStartTag() throws JspException {
		try {
			StringBuffer results = new StringBuffer("");
			pageContext.getOut().write(results.toString());
		} catch (IOException ex) {
			throw new JspTagException("错误");
		}
		return EVAL_BODY_INCLUDE;
	}

	@Override
	public int doEndTag() throws JspException {
		try {
			StringBuffer results = new StringBuffer("");
			if ("SEX".equals(collection)) {
				results.append("<span>");
				results.append("<input type=\"");
				results.append("hidden\" name=\"");
				results.append(getName());
				results.append("\"");
				results.append(" value=\"");
				results.append(getValue());
				results.append("\">");
				if ("1".equals(getValue())) {
					results.append("男");
				} else if ("2".equals(getValue())) {
					results.append("女");
				} else {
					results.append("请选择");
				}
				results.append("</span>");
			}
			pageContext.getOut().write(results.toString());
		} catch (IOException ex) {
			throw new JspTagException("错误");
		}
		return EVAL_PAGE;
	}

	// collection只是传递一个标识，具体下拉值内容是从数据库取还是从请求中得到为不同具体实现
	protected String collection; // 传递的值
	protected String value; // 该属性的名称
	protected String name;

	public String getCollection() {
		return collection;
	}

	public void setCollection(String collection) {
		this.collection = collection;
	}

	public String getName() {
		return name;
	}

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

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}
}

5、JSP中引用，直接在index.jsp中引用

需要引入相应的标签内容，引入的方式在JSP头部引用

标签的属性可以设置也可以不设置，标签的使用和HTML标签的使用是一样的，定义属性即可

<%@ page language="java" pageEncoding="UTF-8"%> <%@ taglib
uri="/tld/web-html" prefix="html"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
	<head>
		<title>JSP 自定义标签的实现</title>
	</head>
	<body>
		请选择：
		<html:select name="sex" style="width:100px">
			<html:options collection="SEX"></html:options>
		</html:select>
		显示性别：
		<html:selectDisplay collection="SEX" value="1" name="sex"></html:selectDisplay>
	</body>
</html>



6、后话

访问项目就可以看到效果，附件是这个项目的源代码，导入到MyEclipse中可以查看

如果想要自己设计一个大的标签库，可以设计一个父类，包含一些主要的属性，例如name，id，style等属性。然后在子类中定义自己的特有属性

这个实现只是学习一下JSP自定义标签使用的HelloWorld程序，然后包含了字典应用的实际例子，程序简单，仅供参考。

loop:

while(it.hasNext()){
    
    while(it1.hasNext()){
        continue loop;  //标记  程序执行到这后 跳到上面那个loop位置继续执行.
    }
}

group by  语法：
  select substr(v.stattime,6,8),v.personid
  from sys_edu_view  v group by substr(v.stattime,6,8),v.personid

日期时间间隔操作

当前时间减去七分钟的时间：
1.select sysdate,sysdate - interval '7' minute from dual ;
当前时间减去七小时的时间：
2.select sysdate,sysdate - interval '7' hour from dual;
当前时间减去七天的时间：
3.select sysdate,sysdate - interval '7' day from dual ;
当前时间减去七个月的时间：
4.select sysdate,sysdate - interval '7' month  from dual;
时间间隔乘以一个数：
5.select sysdate,sysdtate - 8*interval '2' year from dual ;

日期到字符串的操作：
select sysdate ,to_char(sysdate,'yyyy-mm iw-d hh:mi:ss') from dual;




trunk/round  函数的使用

select trunc(sysdate,'year') from dual;  --2012-1-1
select round(sysdate) from dual;         --2012-3-23


创建视图：
create or  replace view view_test as 
select * from  sys_person

连接字符串：
code1||code2||code3   --

截取字符串：
substr("ABCDEFG",0) --ABCDEFG 截取所有字符
substr("ABCDEFG",2)  --CDEF  
substr("ABCDEFG",0,2) -- AB
substr("ABCDEFG",0,-3) --DEF 注意参数-3，为负值时表示从尾部开始算起，字符串排列位置不变。

--两个Date类型字段：START_DATE，END_DATE，计算这两个日期的时间差（分别以天，小时，分钟，秒，毫秒）：
--天：
ROUND(TO_NUMBER(END_DATE - START_DATE))
--小时：
ROUND(TO_NUMBER(END_DATE - START_DATE) * 24)
--分钟：
ROUND(TO_NUMBER(END_DATE - START_DATE) * 24 * 60)
--秒：
ROUND(TO_NUMBER(END_DATE - START_DATE) * 24 * 60 * 60)
--毫秒：
ROUND(TO_NUMBER(END_DATE - START_DATE) * 24 * 60 * 60 * 1000)


Oracle内连接、左外连接、右外连接、全外连接小总结 :

1.内连接
内连接即最常见的等值连接例：

select *  from TableA ,TableB where TableA.A=TableB.A;

2.外连接
外连接分为左外连接和右外连接和全外连接。

(1).左外连接 left outer join 或者 left join 
左外连接就是在等值的基础上加上主表中的未匹配数例：
select * from TableA left outer join TableB where TableA.A=TableB.A;

oracle 支持另一种写法：
select * from TableA ,TableB where TableA.A=TableB.A(+);
三个表做做外连接：
select * from TableA left outer join TableB on TableA.A=TableB.A left outer join TableC on 
TableA.A=TableC.A;

Oracle 支持的另外一种写法 
select * from TableA,TableB,TableC  where TableA.A=TableB.A(+) and TableA.A=TableC.A(+) 

(2).右外连接 right outer join 或 right join 
右外连接是在等值的基础上加上被连接表的不匹配数据:
select * from TableA right outer join TableB on TableA.A=TableB.A;
Oracle支持的另一种写法 :
select * from TableA ,TableB where TableA.A(+)=TableB.A;

(3).全外连接 full outer join 或者 full join 
select * from TableA full outer join TableB on TableA.A=TableB.A;

nvl()函数：
nvl(a,b) 如果a不为null 则返回a,如果a为null则返回b;
nvl2(a,b,c) ,如果a不为null 则返回b,如果a为null则返回c;

如果oracle 表中有大字段如(Long) 导出sql文件时出错，则可以导成dmp格式的文件

-------------------------------------------------------------------
1.按年份分组
　　select to_char(exportDate,'yyyy'),sum(amount) from table1 group by to_char(exportDate,'yyyy');
　　年份      数量
　　-----------------------------
　　2009    68
　　2010    137
　　2008    103
　　2.按月份分组
　　select to_char(exportDate,'yyyy-mm'),sum(amount) from table1 group by to_char(exportDate,'yyyy-mm')
　　order by to_char(exportDate,'yyyy-mm');
　　月份           数量
　　-----------------------------
　　2008-02    20
　　2008-03    2
　　2008-04    6
　　2008-06    75
　　2009-10    23
　　2009-11    45
　　2010-08    5
　　2010-09    44
　　2010-10    88
　　3.按季度分组
　　select to_char(exportDate,'yyyy-Q'),sum(amount) from table1 group by to_char(exportDate,'yyyy-Q')
　　order by to_char(exportDate,'yyyy-Q');
　　季度          数量
　　------------------------------
　　2008-1    22
　　2008-2    81
　　2009-4    68
　　2010-3    49
　　2010-4    88
　　4.按周分组
　　select to_char(exportDate,'yyyy-IW'),sum(amount) from table1 group by to_char(exportDate,'yyyy-IW')
　　order by to_char(exportDate,'yyyy-IW');
　　周             数量
　　------------------------------
　　2008-07    20
　　2008-11    2
　　2008-16    6
　　2008-24    75
　　2009-43    23
　　2009-46    45
　　2010-31    5
　　2010-35    44
　　2010-40    88
　　补充：
　　按季度分组还有个比较笨的方法（参考网络资源）
　　select  to_char(exportDate,'yyyy'),
　　sum(decode(to_char(exportDate,'mm'),'01',amount,'02',amount,'03',amount,0)) as 第一季,
　　sum(decode(to_char(exportDate,'mm'),'04',amount,'05',amount,'06',amount,0)) as 第二季,
　　sum(decode(to_char(exportDate,'mm'),'07',amount,'08',amount,'09',amount,0)) as 第三季,
　　sum(decode(to_char(exportDate,'mm'),'10',amount,'11',amount,'12',amount,0)) as 第四季
　　from table1
　　group by to_char(exportDate,'yyyy');
　　年份        第一季     第二季     第三季     第四季　　--------------------------------------------------
　　2009         0            0            0          68
　　2010         0            0            49         88
　　2008         22           81           0          0
-------------------------------------------------------------
select t.grouptitle 企业名称,t.purpose  用途,t.used 使用金额,(case t.type when '1' then '教育' when '2' then '生产' else '无' end)经费类别,t.usedperson 使用人 from sys_funds_used t where t.groupid=345 and to_char(t.dates,'yyyy')='2011'
------------------------------------------------------------------

Oracle模糊查询的实现


Oracle模糊查询应该如何实现呢？下面就教您一个实现Oracle模糊查询的方法，如果您在Oracle模糊查询方面遇到问题，不妨一看。

在Where子句中，可以对datetime、char、varchar字段类型的列用Like子句配合通配符选取那些“很像...”的数据记录，以下是可使用的通配符：
%   零或者多个字符
_    单一任何字符（下划线）
\     特殊字符
[]     在某一范围内的字符，如[0-9]或者[aeth]
[^]    不在某范围内的字符，如[^0-9]或者[^aeth]

其中关于条件，SQL提供了四种匹配模式：

1，%：表示任意0个或多个字符。可匹配任意类型和长度的字符，有些情况下若是中文，请使用两个百分号（%%）表示。

比如 SELECT * FROM [user] WHERE u_name LIKE '%三%'

将会把u_name为“张三”，“张猫三”、“三脚猫”，“唐三藏”等等有“三”的记录全找出来。

另外，如果需要找出u_name中既有“三”又有“猫”的记录，请使用and条件
SELECT * FROM [user] WHERE u_name LIKE '%三%' AND u_name LIKE '%猫%'

若使用 SELECT * FROM [user] WHERE u_name LIKE '%三%猫%' 
虽然能搜索出“三脚猫”，但不能搜索出符合条件的“张猫三”。

2，_： 表示任意单个字符。匹配单个任意字符，它常用来限制表达式的字符长度语句：

比如 SELECT * FROM [user] WHERE u_name LIKE '_三_'
只找出“唐三藏”这样u_name为三个字且中间一个字是“三”的；

再比如 SELECT * FROM [user] WHERE u_name LIKE '三__';
只找出“三脚猫”这样name为三个字且第一个字是“三”的；

3，[ ]：表示括号内所列字符中的一个（类似正则表达式）。指定一个字符、字符串或范围，要求所匹配对象为它们中的任一个。

比如 SELECT * FROM [user] WHERE u_name LIKE '[张李王]三'
将找出“张三”、“李三”、“王三”（而不是“张李王三”）；

如 [ ] 内有一系列字符（01234、abcde之类的）则可略写为“0-4”、“a-e”
SELECT * FROM [user] WHERE u_name LIKE '老[1-9]'
将找出“老1”、“老2”、……、“老9”；

4，[^ ] ：表示不在括号所列之内的单个字符。其取值和 [] 相同，但它要求所匹配对象为指定字符以外的任一个字符。

比如 SELECT * FROM [user] WHERE u_name LIKE '[^张李王]三'
将找出不姓“张”、“李”、“王”的“赵三”、“孙三”等；

SELECT * FROM [user] WHERE u_name LIKE '老[^1-4]';
将排除“老1”到“老4”，寻找“老5”、“老6”、……

5，查询内容包含通配符时

由于通配符的缘故，导致我们查询特殊字符“%”、“_”、“[”的语句无法正常实现，而把特殊字符用“[ ]”括起便可正常查询。据此我们写出以下函数：

function sqlencode(str)  str=replace(str,"[","[[]") '此句一定要在最前  str=replace(str,"_","[_]")  str=replace(str,"%","[%]")  sqlencode=str end function 在查询前将待查字符串先经该函数处理即可。
-------------------------------------------------