Struts2 中常用的代码

BaseAction

public class BaseAction extends ActionSupport {

	protected String target;

	public Map getRequest(){
		return (Map)ActionContext.getContext().get("request");
	}

	public Map getSession(){
		return ActionContext.getContext().getSession();
	}

	public Map getApplication(){
		return ActionContext.getContext().getApplication();
	}

	public HttpServletResponse getResponse(){
		HttpServletResponse response = ServletActionContext.getResponse();
		response.setContentType("text/html;charset=utf-8");
		return response;
	}

　　DaoFactory

public class DaoFactory<T> {
	private static String fname = "oracle.jdbc.driver.OracleDriver";
	private static String url = "jdbc:oracle:thin:@localhost:1521:orcl";
	private static String user = "scott";
	private static String pwd = "tiger";
	/**
	 * 加载数据库驱动
	 */
	static{
		try {
			Class.forName(fname);
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	/**
	 * 创建登陆对象，获取connection
	 * @return
	 */
	public Connection getConnection(){
		try {
			return DriverManager.getConnection(url,user,pwd);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	/**
	 * 设置preparedStatement对象参数
	 * @param ps
	 * @param params
	 * @throws SQLException
	 */
	public void setParams(PreparedStatement ps,Object[] params) throws SQLException{
		if(params == null)return;
		for(int i = 0; i < params.length; i++){
			ps.setObject(i+1, params[i]);
		}
	}
	/**
	 * 查询方法
	 * @param sql
	 * @param params
	 * @return
	 */
	public List<List> query(String sql,Object[] params) {
		Connection con = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		ArrayList allData = new ArrayList();
		try {
			con = getConnection();
			pstmt = con.prepareStatement(sql);
			setParams(pstmt,params);
			rs = pstmt.executeQuery();
			int colCount = rs.getMetaData().getColumnCount();
			while (rs.next()) {
				ArrayList rowData = new ArrayList();
				for (int i = 1; i <= colCount; i++) {
					rowData.add(rs.getObject(i));
				}
				allData.add(rowData);
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			closeAll(rs,pstmt,con);
		}
		return allData;
	}
	/**
	 *
	 * @param sql 查询语句，要求句中字段名或别名必须和类中的属性名相同
	 * @param params sql语句所需的参数数组
	 * @param clazz 要封装的类的Class对象
	 * @return 返回封装好的对象，装载在集合中
	 * @throws Exception
	 *
	 */
	public List<T> list(String sql,Object[] params,Class clazz){
		List<T> list=new ArrayList<T>();
		Connection con=null;
		PreparedStatement ps=null;
		ResultSet rs=null;
		try {
			con = getConnection();
			ps = con.prepareStatement(sql);
			setParams(ps, params);
			rs = ps.executeQuery();
			ResultSetMetaData md=rs.getMetaData();
			int colCount=md.getColumnCount();
			String fieldName="";
			Field field=null;

			while(rs.next()){
				T obj=(T)clazz.newInstance();//实例化包装实体
				for(int i=1;i<=colCount;i++){
					fieldName=md.getColumnName(i);//获得数据库字段名
					//System.out.println("字段名：====================="+ fieldName+"================" + rs.getString(i));
					try {
						field = clazz.getDeclaredField(fieldName);//获得实体类中和数据库字段名相应的Field对象
						field.setAccessible(true);//设置Field的可访问性为true，否则私有属性不能访问
						//System.out.println("字段类型：===================" + field.getType().getName()+"================");
						field.set(obj, convert(rs.getString(i),field.getType()));
						//调用Field的set方法给属性赋值
					} catch (Exception e) {	//如果没有相应的Field对象则不作任何处理			

					}
				}
				list.add(obj);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (Exception e) {

			e.printStackTrace();
		}finally{
			closeAll(rs, ps, con);
		}
		return list;
	}
	/**
	 * 该方法用于返回多对一关系的集合
	 * @param sql 用于多表联合查询的语句，要求主类对应的字段前缀名必须和类名相同（不区分大小写），
	 * 引用类对应的字段前缀名必须和主类中引用的属性名相同（大小写严格区分）
	 * @param params 查询语句的参数数组
	 * @param clazzs 返回的封装对象，第一个是List中封装的主对象，其余为该对象的引用属性对象
	 * @return
	 * @throws Exception
	 */
	public List<T> list(String sql,Object[] params,Class...clazzs){
		List<T> list=new ArrayList<T>();
		Connection con=null;
		PreparedStatement ps=null;
		ResultSet rs=null;
		try {
			con = getConnection();
			ps = con.prepareStatement(sql);
			setParams(ps, params);
			rs = ps.executeQuery();
			ResultSetMetaData md=rs.getMetaData();
			int colCount=md.getColumnCount();
			System.out.println(colCount);
			String fieldName="";//sql中的字段名或别名
			Field field=null; //要包装的类中的属性对象
			String prefixName="";//数据库字段的前缀名（映射类名）
			Map<String,Object> refMap=new HashMap<String,Object>();//用来存放主类中引用类对象的属性名和对象
			String key="";//用来标记refMap中的键
			while(rs.next()){
				List<T> claObjList=new ArrayList<T>();
				for(Class cla:clazzs){//将要封装的实体类型实例化放入到List中，以便将rs中的值赋值给实例的属性
					claObjList.add((T) cla.newInstance());
				}
				for(int j=0;j<clazzs.length;j++){
					for(int i=1;i<=colCount;i++){
						fieldName=md.getColumnName(i);
						prefixName=fieldName.split("\\.")[0];//获得结果集中字段的前缀名
						fieldName=fieldName.split("\\.")[1];//获得结果集中字段的名称
						//System.out.println(clazzs[j].getSimpleName()+"==="+prefixName+"==="+fieldName+"---");
						if(clazzs[j].getSimpleName().toLowerCase().equals(prefixName.toLowerCase())){
							try {
								//System.out.println(clazzs[j].getSimpleName());
								field=clazzs[j].getDeclaredField(fieldName);//获得当前类中所有的字段对象
								field.setAccessible(true);//设置Field的可访问性为true，否则私有属性不能访问
								field.set(claObjList.get(j), convert(rs.getString(i),field.getType()));
								//给参数数组对映的实例化对象的属性赋值
								if(j>0) refMap.put(prefixName, claObjList.get(j));
								//如果是第二个以后的对象，则放入到引用对象的Map中
							} catch (Exception e) {
								e.printStackTrace();
							}
						}
					}

				}
				Set<String> keySet=refMap.keySet();
				Iterator<String> it=keySet.iterator();
				while(it.hasNext()){
					key=it.next();
					try {
						field=clazzs[0].getDeclaredField(key);//获得主类中外键对象的引用字段对象
						field.setAccessible(true);//设置该字段可访问
						field.set(claObjList.get(0), refMap.get(key));//将Map集合中该键对应的值赋值给该字段
					} catch (Exception e) {					

					}
				}
				list.add(claObjList.get(0));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			closeAll(rs, ps, con);
		}
		return list;
	}
	/**
	 * 将传入的字符串参数转化成制定的数据类型,如果格式不匹配则返回null
	 *
	 * @param <T>
	 * @param param
	 *            要转换的参数字符串
	 * @param clas
	 *            转换的目标CLASS
	 * @return
	 */
	private <T extends Serializable> T convert(String param, Class clas) {
		if (param == null || param == "" || clas == null)
			return null;
		String type = clas.getName();// 获得要转换的数据类型名称
		//System.out.println(type);
		if (type.equals("java.lang.String"))
		{
			//System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
			return (T) param;
		}
		try {// 根据不同类型的属性，返回不同的结果，如果出现异常，则返回null
			if (type.equals("java.util.Date")) {
				return (T) new java.util.Date(java.sql.Timestamp.valueOf(param)
						.getTime());
			}
			if (type.equals("java.sql.Date")) {
				return (T) new java.sql.Date(java.sql.Timestamp.valueOf(param).getTime());
			}
			if (type.equals("java.sql.Timestamp")) {
				return (T) java.sql.Timestamp.valueOf(param);
			}
			if (type.equals("java.lang.Char")) {
				return (T) Character.valueOf(param.charAt(0));
			}
			if (type.equals("java.lang.Integer") || type.equals("int")) {
				return (T) Integer.valueOf(param);
			}
			if (type.equals("java.lang.Double") || type.equals("double")) {
				return (T) Double.valueOf(param);
			}
			if (type.equals("java.lang.Float") || type.equals("float")) {
				return (T) Float.valueOf(param);
			}
			if (type.equals("java.lang.Byte") || type.equals("byte")) {
				return (T) Byte.valueOf(param);
			}
			if (type.equals("java.lang.Short") || type.equals("short")) {
				return (T) Short.valueOf(param);
			}
			if (type.equals("java.lang.Long") || type.equals("long")) {
				return (T) Long.valueOf(param);
			}
			if (type.equals("java.lang.Boolean") || type.equals("boolean")) {
				return (T) Boolean.valueOf(param);
			}
		} catch (Exception e) {
			//e.printStackTrace();
		}
		return null;
	}
	/**
	 * 将sql语句中传入的地段名称转换为相应的set方法名
	 * @param fieldName 传入的sql语句的字段名称
	 * @return 返回set方法名称
	 */
	private String findSetMethodName(String fieldName) {
		Character firstChar = fieldName.charAt(0);
		firstChar = Character.toUpperCase(firstChar);
		String methodName = "set"+firstChar + fieldName.substring(1);// 将首字母小写
		return methodName;
	}
	public boolean updateTrans(String[] sql,List<Object[]> listParam) {
		Connection con = null;
		PreparedStatement pstmt = null;
		try {
			con = getConnection();
			con.setAutoCommit(false);
			for(int i=0;i<sql.length;i++){
				pstmt = con.prepareStatement(sql[i]);
				setParams(pstmt,listParam.get(i));
				pstmt.executeUpdate();
			}
			con.commit();
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			try {
				con.rollback();
			} catch (SQLException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		} finally {
			closeAll(null,pstmt,con);
		}
		return false;
	}
	public int update(String sql,Object[] params) {
		Connection con = null;
		PreparedStatement pstmt = null;
		try {
			con = getConnection();
			pstmt = con.prepareStatement(sql);
			setParams(pstmt,params);
			return pstmt.executeUpdate();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			closeAll(null,pstmt,con);
		}
		return -1;
	}

	public int update(String sql,Object[] params,Connection con) {
		PreparedStatement pstmt = null;
		try {
			con = getConnection();
			pstmt = con.prepareStatement(sql);
			setParams(pstmt,params);
			return pstmt.executeUpdate();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			closeAll(null,pstmt,null);
		}
		return -1;
	}

	/**
	 * 修改数据库信息的通用方法
	 * @param sql
	 * 一个sql语句
	 * @param params
	 * 参数数组
	 * @return
	 * 修改每条信息的主键，为int类型
	 */
	public int getKey(String sql,Object[] params) {
		int id=0;
		Connection conn=null;
		PreparedStatement ps=null;
		ResultSet rs=null;
		try {
			conn =getConnection();
			ps = conn.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);
			setParams(ps, params);
			ps.executeUpdate();
			rs = ps.getGeneratedKeys();
			while(rs.next())
				id=rs.getInt(1);

		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	finally{
		closeAll(rs,ps,conn);
		}
		return id;
	}
	/**
	 * 修改数据库信息的通用方法
	 * @param sql
	 * 一个sql语句
	 * @param params
	 * 参数数组
	 * @param con
	 * 一个Connection对象
	 * @return
	 * 修改每条信息的主键，为int类型
	 */
	public int getKey(String sql,Object[] params,Connection con) {
		int id=0;
		PreparedStatement ps=null;
		ResultSet rs=null;
		try {
			con = getConnection();
			ps = con.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);
			setParams(ps, params);
			ps.executeUpdate();
			rs = ps.getGeneratedKeys();
			while(rs.next()){
				id=rs.getInt(1);
			}

		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	finally{
		closeAll(rs,ps,null);
		}
		return id;
	}

	/**
	 * 关闭连接对象
	 * @param rs
	 * @param ps
	 * @param con
	 */
	public void closeAll(ResultSet rs, Statement ps, Connection con) {
		// TODO Auto-generated method stub
		try {
			if(rs != null){
				rs.close();
				rs = null;
			}
			if(ps != null){
				ps.close();
				ps = null;
			}
			if(con != null){
				con.close();
				con = null;
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
	/**
	 * 测试显示数据
	 * @param args
	 */
	public static void main(String[] args){
		DaoFactory dao = new DaoFactory();
		List li = dao.query("select * from rights", null);
		System.out.println(li);
	}

}