winter framework 源码 SSH最精简的实现

前些天一直在写这个框架，现在放出源码！

主要功能：

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);
			}
			
			
		}
	}
		

配置管理器和xml读取：

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.getPage());
			if(request.getPage().equals(name)){
				return request;
			}
		}
		return null;
	}
	/**
	 * 模糊检索
	 * @param name
	 * @return
	 */
	public Request findByLike(String name){
		//用正则表达式进行验证
		for (Request request:requests) {
			System.out.println("findByLike:"+request.getPage()+" - "+name);
			String reg=request.getPage();
			String page=name;
			if(page.matches(reg)){
				return request;
			}
		}
		return null;
	}
	
	/**
	 * 通过id寻找对象，主要用于url伪静态
	 * @param id
	 * @return
	 */
	public Request findById(String id){
		for (Request request:requests) {
			System.out.println(request.getPage()+" - "+id);
			if(request.getId().equals(id)){
				return request;
			}
		}
		
		return null;
	}
}

xml读取：

package org.pan.code;

import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.pan.bean.JdbcConnectConfig;
import org.pan.bean.Request;
import org.pan.bean.Result;
import org.pan.bean.SpringBean;
import org.pan.exception.ReadRequestXmlException;
import org.pan.util.ServerUrl;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;


/**
 * 读取xml
 * @author Pan
 *
 */
public class XmlRead {

	private HttpServletRequest request;
	
	//从xml读取出来的请求对象
	private List<Request> requests=new ArrayList<Request>();
	
	public XmlRead(HttpServletRequest request){
		this.request=request;
	}
	
	public List<Request> read() throws ReadRequestXmlException{
		
		//判断文件是否存在
		String strpath=ServerUrl.getDiskPath(request)+"WEB-INF/request.xml";
		File file=new File(strpath);
		if(!file.exists()){
			throw new ReadRequestXmlException();
		}
			
		   DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
		    try {  
		        DocumentBuilder db = dbf.newDocumentBuilder();  
		        Document doc = db.parse(new FileInputStream(strpath));  
		        Element root = doc.getDocumentElement();  
		        
		        //Action是否由Spring去管理
		       
		        String spring="false";
		        try{
		        	spring=doc.getElementsByTagName("spring").item(0).getTextContent();
		        	if(spring==null){
		        		spring="false";
		        	}
		        }catch (Exception e) {
		    	   spring="false";
		        }finally{
		        	SpringBean.setSupport(Boolean.parseBoolean(spring));
		        }
		        
		        //jdbc配置
		        String url="";
		        String driverClass="";
		        String userName="";
		        String password="";

		        
		        NodeList serverslist = doc.getElementsByTagName("request"); 
		        for(int i=0;i<serverslist.getLength();i++){
		        	
		        	Node node=serverslist.item(i);
		        	System.out.println(serverslist.getLength());
			        String page=null;
			        try{
			        	page=node.getAttributes().getNamedItem("page").getNodeValue();
			        }catch (Exception e) {
			        	page="";
					}
			        
			        //id
			        String id="";
			        try{
			        	id=node.getAttributes().getNamedItem("id").getNodeValue();
			        	id=id==null?"":id;
			        }catch (Exception e) {
			        	id="";
					}
			        
			        String classPath=null;
			        try{	
			        	classPath=node.getAttributes().getNamedItem("class").getNodeValue();
			        	if(classPath==null){
			        		classPath="";
			        	}
			        }catch (Exception e) {
			        	classPath="";
					}
			        
			        String method = null;
			        try{
			        	method=node.getAttributes().getNamedItem("method").getNodeValue();
			        	if(method==null||method=="null"){
			        		method="execute";
			        	}
			        }catch (Exception e) {
						method="execute";
					}
			        
			        String pretend=null;
			        try{
			        	pretend=node.getAttributes().getNamedItem("pretend").getNodeValue();
			        }catch (Exception e) {
			        	pretend="false";
					}
			        Request request=new Request();
			        request.setId(id);
			        request.setPage(page);
			        request.setClassPath(classPath);
			        request.setMethod(method);	//方法名称
			        request.setPretend(Boolean.parseBoolean(pretend));	//伪静态
			        
			        for (int j = 0; j < node.getChildNodes().getLength(); j++) {
                        Node book1 = node.getChildNodes().item(j);
                        if(book1.getNodeType()==Node.ELEMENT_NODE){
                        	Result result=new Result();
                        	
                        	String name=book1.getAttributes().getNamedItem("name").getNodeValue();
                        	String path=book1.getTextContent();
                        	result.setName(name);
                        	result.setPath(path);
                        	request.add(result);
                        }
			        }
			        requests.add(request);
		        }
		        
		    } catch (Exception e) {  
		    	System.err.println(e);
		      //throw new ReadRequestXmlException();
		    }  
		    
		    return this.requests;
		
	}
	
}

Spring 支持模块：

package org.pan.spring;

import javax.servlet.http.HttpServletRequest;

import org.pan.util.ServerUrl;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ApplicationObjectSupport;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
 * Spring 框架支持类
 * 
 * @author Pan
 * 
 */
public class SpringSupport extends ApplicationObjectSupport {

	private AbstractApplicationContext aac;

	public SpringSupport(HttpServletRequest request) { // 可以将ApplicationContent.xml文件放在src或者WEB-INF中
		try {
			aac = new ClassPathXmlApplicationContext("applicationContext.xml");
		} catch (Exception e) {

		}
		if (aac == null) {

			aac = new FileSystemXmlApplicationContext(
					ServerUrl.getDiskPath(request)
							+ "/WEB-INF/applicationContext.xml");
		}
	}

	public Object getBean(String bean) {
		try {
			return aac.getBean(bean);
		} catch (Exception e) {
			System.err.println(e);
			return null;
		}
	}

}

Spring bean 工厂：

package org.pan.spring;

import javax.servlet.http.HttpServletRequest;

/**
 * Spring Bean Factory
 * 
 * @author Pan
 * 
 */
public class SpringBeanFactory extends SpringSupport {

	public SpringBeanFactory(HttpServletRequest request) {
		super(request);
		// TODO Auto-generated constructor stub
	}

	public Object findBean(String id) {

		Object object = null;
		try {
			object = getBean(id);
		} catch (Exception e) {
			//Do not display error
		}
		return object;
	}

}

SQL语句创建：

package org.pan.sql.create;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

import org.pan.exception.FieldNullException;
import org.pan.util.StringUitl;
/**
 * this the create sql code util
 * @author Pan
 *
 */
public class SqlCodeCreate {

	private Object object;

	public SqlCodeCreate(Object object) {
		this.object = object;
	}

	/**
	 * create update sql code
	 * 
	 * @return
	 * @throws Exception
	 */
	public String updateSql() throws Exception {

		Class cl = object.getClass();
		String table = cl.getSimpleName(); // 类名=表名
		String sql = "update [" + table + "] set ";
		// 获得字段名

		// 生成字段
		Field[] fields = cl.getDeclaredFields();
		Field id = cl.getDeclaredField("id");
		Method idMethod = cl.getMethod("getId", new Class[0]);
		Object ivalue = idMethod.invoke(object, new Class[0]);
		if (ivalue == null) {
			throw new FieldNullException("Field :id ,not null!");
		}

		for (Field field : fields) {
			if (field.getName().equals("id"))
				continue;
			String m = "get" + StringUitl.capitalize(field.getName());
			Method method = cl.getMethod(m, new Class[0]);
			Object o = method.invoke(object, new Class[0]);
			if (o != null)
				sql += "[" + field.getName() + "] = '" + o + "',";
		}
		sql = StringUitl.removeEndChar(sql);
		Method method = cl.getMethod("getId", new Class[0]);
		sql += " where id = '" + method.invoke(object, new Class[0]) + "'";
		return sql;
	}

	/**
	 * 创建sql语句
	 * 
	 * @return
	 * @throws NoSuchMethodException
	 * @throws SecurityException
	 */
	public String insertSql(boolean sign) throws Exception {

		Class cl = object.getClass();
		String table = cl.getSimpleName(); // 类名=表名
		String sql = "insert into [" + table + "] ";
		// 获得字段名

		String strFileds = "("; // 字段
		String strValues = ")values("; // 值
		// 生成字段
		Field[] fields = cl.getDeclaredFields();
		// 输出值
		for (Field field : fields) {
			String m = "get" + StringUitl.capitalize(field.getName());
			Method method = cl.getMethod(m, new Class[0]);
			Object value = method.invoke(object, new Class[0]);
			// 插入id
			if (field.getName().equals("id"))
				continue;
			if (sign) {
				if (value == null) {
					continue;
				}
			}
			strFileds += "[" + field.getName() + "],";
			strValues += "'" + value + "',";

		}
		strFileds = StringUitl.removeEndChar(strFileds);
		strValues = StringUitl.removeEndChar(strValues) + ");";
		sql += strFileds + strValues;
		return sql;
	}

	/**
	 * 创建查询语句
	 * 
	 * @return
	 * @throws Exception
	 */
	public String selectSql() throws Exception {
		Class cl = object.getClass();
		String table = cl.getSimpleName();
		String sql = "select * from [" + table+"]";
		return sql;
	}

	/**
	 * 按条件查询字段，查询所有不为null的字段 传入bool 参数，指定是否用like进行查询
	 * 
	 * @return
	 * @throws NoSuchMethodException
	 * @throws SecurityException
	 */
	public String seleteFieldSql(boolean like) throws Exception {
		Class cl = object.getClass();
		String table = cl.getSimpleName();
		String sql = "select * from [" + table + "] where 1=1 ";
		Field[] fields = cl.getDeclaredFields();
		for (Field field : fields) {
			String fname = field.getName();
			Method method = cl.getMethod("get" + StringUitl.capitalize(fname),
					new Class[0]);
			Object o = method.invoke(object, new Class[0]);
			if (o != null) {
				if (!like) {
					sql += "and [" + fname + "] = '" + o + "' ";
				} else {
					sql += "and [" + fname + "] like '%" + o + "%' ";
				}
			}
		}

		return sql;
	}
	
	/**
	 * 创建删除语句
	 * @return
	 * @throws Exception
	 */
	public String deleteSql() throws Exception{
		Class cl=object.getClass();
		String table=cl.getSimpleName();
		Method method=cl.getMethod("getId", new Class[0]);
		Object ob=method.invoke(object,new Class[0]);
		
		if(ob==null){
			throw new FieldNullException("Field is null from:id");
		}
		
		String sql="delete ["+table+"] where id='"+ob+"'";
		
		return sql;
	}

}