deploy.path=/data/jsp/xxxxxxxx.com

<?xml version="1.0"?>
<project name="xxxx" basedir="." default="usage">
	<property file="build.properties"/>
	<property name="src.dir" value="src"/>
	<property name="web.dir" value="WebRoot"/>
	<property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
	<property name="name" value="webapps"/>
	<path id="master-classpath">
		<fileset dir="${web.dir}/WEB-INF/lib">
			<include name="*.jar"/>

		</fileset>
		<pathelement path="${build.dir}"/>

	</path>
	<target name="usage">
		<echo message=""/>
		<echo message="${name} build file"/>
		<echo message="-----------------------------------"/>
		<echo message=""/>
		<echo message="Available targets are:"/>
		<echo message=""/>
		<echo message="build --> Build the application"/>
		<echo message="deploy --> Deploy application as directory"/>
		<echo message="deploywar --> Deploy application as a WAR file"/>
		<echo message=""/>
	</target>
	<target name="build" description="Compile main source tree java files">
		<mkdir dir="${build.dir}"/>
		<javac destdir="${build.dir}" source="1.5" target="1.5" debug="true" deprecation="false" optimize="false"
			   failonerror="true" includeantruntime="false" encoding="GBK">
			<src path="${src.dir}"/>
			<classpath refid="master-classpath"/>
		</javac>
		<copy todir="${build.dir}" preservelastmodified="true">
		<fileset dir="${src.dir}">

				<!--<include  name="**/*.*"/>-->
				<exclude name="**/*.java"/>
			</fileset>
		</copy>
	</target>
	<target name="deploy" depends="build" description="Deploy application">

		<mkdir dir="${deploy.path}/${name}"/>

		<copy todir="${deploy.path}/${name}" preservelastmodified="true">

			<fileset dir="${web.dir}">

				<include name="**/*.*"/>

			</fileset>
		</copy>
	</target>
	<target name="deploywar" depends="build" description="Deploy application as a WAR file">
		<war destfile="${name}.war" webxml="${web.dir}/WEB-INF/web.xml">
			<fileset dir="${web.dir}">
			<include name="**/*.*"/>
			</fileset>
		</war>
		<copy todir="${deploy.path}" preservelastmodified="true">
			<fileset dir=".">
				<include name="*.war"/>
			</fileset>
		</copy>
	</target>
	<target name="clean" description="Clean output directories">
		<delete>
			<fileset dir="${build.dir}">
				<include name="**/*.*"/>
			</fileset>
		</delete>
	</target>
	<target name="undeploy" description="Un-Deploy application">
		<delete>
			<fileset dir="${deploy.path}/${name}">
				<include name="**/*.*"/>
			</fileset>
		</delete>
	</target>
</project> 

主要功能：

1、自动将表单封装成对象（类似Struts2）

2、自动根据对象产生增删改查sql语句（类似hibernate）

3、支持Spring动态注入，可以把自定义的Action 交给Spring去进行管理

4、自定义的tab标签库 

5、支持伪静态功能

伪静态实现，可以用正则表达式！~

这个框架，差不多就是一个SSH最精简的实现。

配置非常灵活简单，比起三大框架来说，容易多了，而且包就一个而已，非常的小！

包和类：

org.pan.code 这是核心类的包

主要的类：

过滤器-转发控制器-Action管理器-字段类型转换器-Spring支持类-JDBC支持类-SQL创建类

主要的配置文件是：request.xml

百度网盘下载地址：http://pan.baidu.com/share/link?shareid=467157&uk=470382596

Q:599194993

有兴趣的联系我，一起完善！~

附上部分源代码：

最核心的代码，Action管理器：

package org.pan.code;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

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

import org.pan.convetor.FieldConvertor;
import org.pan.exception.InitializeActionException;
import org.pan.support.ServletActionContent;
import org.pan.util.MethodsUitl;
import org.pan.util.StringUitl;

/**
 * 请求request请求数据 调用对应的类去进行处理
 * @author Pan
 *
 */
public class ActionManage {

	private HttpServletRequest request;		//请求对象
	private HttpServletResponse response;	//响应对象
	private Map<String, Object> map=new HashMap<String, Object>();		//map对象
	private String result;		//返回类型
	private String classPath;	//类的路径
	private String methodName;		//需要操作的方法
	private Object bean;			//对象的实例 可以是从Spring中获取到的
	
	public void setMethodName(String methodName) {
		this.methodName = methodName;
	}
	public String getMethodName() {
		return methodName;
	}
	public String getResult() {
		return result;
	}
	private Map<String, Object> getMap() {
		return map;
	}

	public ActionManage(Object bean,HttpServletRequest request,HttpServletResponse response,String classPath,String methodName){
		
		this.request=request;
		this.response=response;
		this.classPath=classPath;
		this.methodName=methodName;
		this.bean=bean;
		invokeMap();	//将请求的值放入map
		
		try {
			init();	//初始化
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}
	/**
	 * 将请求的值放入map
	 */
	private void invokeMap(){
		Iterator it=request.getParameterMap().entrySet().iterator();
		while (it.hasNext()) {
			Map.Entry entry=(Map.Entry)it.next();
			String key=entry.getKey().toString();
			String value=StringUitl.getStringArray((String[])entry.getValue());
			map.put(key, value);
		}
	}
	
	/**
	 * 将相关对象设置到用户的Action中
	 * @throws InitializeActionException 
	 * @throws NoSuchMethodException 
	 * @throws SecurityException 
	 * @throws InvocationTargetException 
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 */
	private void init() throws Exception{
		
		
		//获取类对象
		Class class1=null;
		Object object=null;
		try{
//			
			if(this.bean!=null){
				object=bean;
				class1=bean.getClass();
			}else{
				class1=Class.forName(classPath);
				//初始化对象
				object=class1.newInstance();
				System.out.println("初始化对象");
			}
			
		}catch (Exception e) {
			System.err.println(e);
			throw new InitializeActionException();
		}
		
		//给对象设置字段参数
		initField(class1,object);
		
		//调用方法
		this.result=invokeMethod(class1, object);
		
		
	}

	/**
	 * 初始化字段
	 */
	private void initField(Class class1,Object object) throws Exception{
		
		//获取字段集合
		Field[] fields=class1.getDeclaredFields();
		
		//获取方法集合
		Method [] methods=class1.getDeclaredMethods();
		
		for (Field field : fields) {
			String name=(String)map.get(field.getName());
				//给指定赋值
				String MethodName="set"+StringUitl.capitalize(field.getName());
				if(MethodsUitl.exist(methods,MethodName)){

					field.setAccessible(true);
					//field.set(object, map.get(field.getName()));
					Object value=map.get(field.getName());
					if(value!=null){
						FieldConvertor.convertor(object, field, value.toString());
					}
	
				}
			}
		}
		
	/**
	 * 调用方法
	 */
	private String invokeMethod(Class class1,Object object) throws Exception{
		
		//创建ServletActionContent实例对象
				ServletActionContent servlet=new ServletActionContent();
				servlet.setRequest(request);
				servlet.setResponse(response);
				servlet.setSession(request.getSession());
				
				//创建参数类型
				Class parameter[]=new Class[]{ServletActionContent.class};
				Method method=class1.getMethod("setServletActionContent", parameter);
				
				//参数值
				Object obj[]=new Object[]{servlet};
				method.invoke(object, obj);	//操作方法
				//调用execute 方法
				//Method execute=class1.getMethod("execute", new Class[0]);
				Method execute=class1.getMethod(this.methodName, new Class[0]);
				Object type=execute.invoke(object, new Class[0]);
				
				return type.toString();	//设置返回类型
		
	}
		
	
}

请求管理器：

package org.pan.controller;

import java.util.List;

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

import org.pan.bean.Request;
import org.pan.bean.Result;
import org.pan.bean.SpringBean;
import org.pan.code.ActionManage;
import org.pan.code.Configuration;
import org.pan.spring.SpringBeanFactory;
import org.pan.support.ActionSupport;
import org.pan.util.ResultUitl;

/**
 * 请求控制器
 * @author Pan
 *
 */
public class RequestController {

	private HttpServletRequest request;
	private HttpServletResponse response;
	private FilterChain chain;
	
	public RequestController(ServletRequest request,ServletResponse response,FilterChain chain){
		
		this.request=(HttpServletRequest)request;
		this.response=(HttpServletResponse)response;
		this.chain=chain;
	}
	
	/**
	 * 处理请求
	 */
	public void doFilter() throws Exception{
		
		String filepath=request.getServletPath().substring(1);	//当前这个文件的名称
			//通过配置文件得到跳转对象和一些操作的方法
			Configuration configuration=new Configuration(request);
			System.out.println("filepath:"+filepath);
			//伪静态
			Request rt=configuration.findByLike(filepath);
			if(rt==null){
				System.out.println(rt);
				System.out.println("error:"+configuration.find(filepath));
				rt=configuration.find(filepath);			
			}
			
			//如果rt还是null 就直接跳过不处理
			if(rt==null){
				chain.doFilter(request, response);
				return ;
			}
			//如果没有配置类路径，就当作转发器使用直接转发到结果页
			if(rt.getClassPath()==null||rt.getClassPath()==""){
				Result rs=ResultUitl.findResult(rt.getResults(), ActionSupport.SUCCESS);
				if(rs==null){
					chain.doFilter(request, response);
				}else{
					request.getRequestDispatcher(rs.getPath()).forward(request, response);
				}
				return;
			}
			
			
			//Spring support
			
			SpringBeanFactory factory=new SpringBeanFactory(request);
			Object object=null;
			if(rt.getId()!=null||rt.getId()!=""){
				//xml配置中需要开启支持
				if(SpringBean.getSupport()){
					object=factory.getBean(rt.getId());
				}
			}
			//用户Action管理器
			ActionManage actionManage=new ActionManage(object,request,response,rt.getClassPath(),rt.getMethod());
			String result=actionManage.getResult();
			
			
			//寻找放返回值对应的页面
			List<Result> results= rt.getResults();
			String path="";
			for (Result result2 : results) {
				if(result2.getName().equals(result)){
					//得到对应的路径
					path=result2.getPath();
				}
			}
			
			//转发到对应的页面
			if(!path.equals("")){
				
				request.getRequestDispatcher(path).forward(request, response);
				
			}
			//上面没有进行处理那就是配置不争取或者面页不存在
			else{
				chain.doFilter(request, response);
			}
			
			
		}
	}
		

package org.pan.code;

import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.pan.bean.Request;
import org.pan.bean.Result;
import org.pan.exception.ReadRequestXmlException;

/**
 * 配置管理器
 * @author Pan
 *
 */
public class Configuration {

	private List<Request> requests;
	public Configuration(HttpServletRequest request){
		
		XmlRead xmlRead=new XmlRead(request);
		try {
			
			requests=xmlRead.read();
			
		} catch (ReadRequestXmlException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 寻找配置文件中的request节点对象
	 * @param name
	 * @return
	 */
	public Request find(String name){
		for (Request request : requests) {
			System.out.println("name:"+name+" - "+request.getPag