BlogJava-tbwshc-随笔分类-随笔

Java内存管理优化笔记

chen11-1 — Fri, 28 Jun 2013 08:59:00 GMT

1. 垃圾回收
　　JVM运行环境中垃圾对象的定义：
　　一个对象创建后被放置在JVM的堆内存(heap)中，当永远不再引用这个对象时，它将被JVM在堆内存(heap)中回收。被创建的对象不能再生，同时也没法通过程序语句释放它们。
　　不可到达的对象被JVM视为垃圾对象，JVM将给这些对象打上标记，然后清扫回收它们，并将散碎的内存单元收集整合。
　　JVM管理的两种类型的内存：
　　堆内存(heap)，主要存储程序在运行时创建或实例化的对象与变量。
　　栈内存(stack)，主要存储程序代码中声明为静态(static)(或非静态)的方法。
　　堆内存(heap)通常情况下被分为两个区域：新对象(new object)区域与老对象(old object)区域。
　　新对象区域：
　　又可细分为Eden区域、From区域与To区域。
　　Eden区域保存新创建的对象。当该区域中的对象满了后，JVM系统将做可达性测试，主要任务是检测有哪些对象由根集合出发是不可到达的，这些对象就可被JVM回收，且将所有的活动对象从Eden区域拷到To区域，此时有一些对象将发生状态交换，有的对象就从To区域被转移到From区域，此时From区域就有了对象。
　　该过程执行期间，JVM的性能非常低下，会严重影响到正在运行的应用的性能。
　　老对象区域：
　　在老对象区域中的对象仍有一个较长的生命周期。经过一段时间后，被转入tb老对象区域的对象就变成了垃圾对象，此时它们被打上相应的标记，JVM将自动回收它们。
　　建议不要频繁强制系统做垃圾回收，因为JVM会利用有限的系统资源，优先完成垃圾回收工作，致使应用无法快速响应来自用户端的请求，这样会影响系统的整体性能。
　　2. JVM中对象的生命周期
　　对象的整个生命周期大致分为7个阶段：创建(creation)、应用(using)、不可视(invisible)、不可到达(unreachable)、可收集(collected)、终结(finalized)、释放(free)。
　　1) 创建阶段
　　系统通过下面步骤，完成对象的创建：
　　a) 为对象分配存储空间
　　b) 开始构造对象
　　c) 递归调用其超类的构造方法
　　d) 进行对象实例初始化与变量初始化
　　e) 执行构造方法体
　　在创建对象时的几个关键应用规则：
　　避免在循环体中创建对象，即使该对象占用内存空间不大
　　尽量及时使对象符合垃圾回收标准
　　不要采用过深的继承层次
　　访问本地变量优于访问类中的变量

chen11-1 2013-06-28 16:59 发表评论

java 数据库通用操作类

chen11-1 — Mon, 27 May 2013 08:55:00 GMT

package com.hospital.dao.tools;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import org.apache.log4j.Logger;

/**
* 数据库操作管理类
*
* @author Harlyhood
*
*/
public class DBManager {

    // --------------------------------------------------------- Instance
    private static Logger logger = Logger.getLogger(DBManager.class);
    // --------------------------------------------------------- Methods

    // 数据库连接对象
    private Connection con;
    // SQL语句对象
    private Statement stmt;
    // 带参数的Sql语句对象
    private PreparedStatement pstmt;
    // 记录集对象
    private ResultSet rs;
    // 数据连接管理（连接池对象）
    private DBConnectionManager dcm = null;

    /** ***********************手动设置的连接参数********************************* */
    @SuppressWarnings("unused")
    private static String _DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
    @SuppressWarnings("unused")
    private static String _URL = "jdbc:sqlserver://localhost:1433;database=Hospital_AI_DB;characterEncoding=gb2312";
    @SuppressWarnings("unused")
    private static String _USER_NA = "sa";
    @SuppressWarnings("unused")
    private static String _PASSWORD = "";

    /** ********************************************************************** */

    // 默认构造
    public DBManager() {
    }

    /** ****************************************************************************************** */
    /**
     * **************************************** 数据库连接初始化
     * ***********************************
     */
    /** ****************************************************************************************** */

    /**
     * 得到一个默认的数据库连接[从 com.hospital.dao.tools.db.properties文件初始化]
     *
     * @throws Exception
     */
    private void getConnection() {
        logger.info("###############open:::::从默认的配置文件得到一个数据库连接");
        // 获取一个连接tb池管理类的实例
        dcm = DBConnectionManager.getInstance();
        // 得到一个数据库连接
        con = dcm.getConnection("mysql");

        try {
            con.setAutoCommit(false);
        } catch (SQLException e) {

            e.printStackTrace();
        }
    }

    /**
     * 从指定参数得到一个连接对象
     *
     * @param driver
     * @param url
     * @param user_na
     * @param password
     * @throws Exception
     */
    public void getConnection(String driver, String url, String user_na,
            String password) throws Exception {
        try {
            logger.info("###############open:::::从指定配置中得到一个数据库连接");
            Class.forName(driver);
            con = DriverManager.getConnection(url, user_na, password);
        } catch (ClassNotFoundException ex) {
            logger
                    .info("###############Error[com.hospital.dao.tools.DBManager^^^Method:getConnection^^^Line:81]找不到类驱动类: "
                            + driver);
            throw ex;
        } catch (SQLException ex) {
            logger
                    .info("###############Error[com.hospital.dao.tools.DBManager^^^Method:getConnection^^^Line:81]加载类: "
                            + driver + " 时出现 SQLException 异常");
            throw ex;
        }
    }

    /** ****************************************************************************************** */
    /**
     * **************************************** 数据库操作方法
     * ***********************************
     */
    /** ****************************************************************************************** */

    /**
     * 执行SQL语句操作(更新数据无参数)
     *
     * @param strSql
     *            SQL语句
     * @throws Exception
     */
    public boolean executeUpdate(String strSql) throws SQLException {
        getConnection();
        // getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
        boolean flag = false;
        stmt = con.createStatement();
        logger.info("###############::执行SQL语句操作(更新数据无参数):" + strSql);
        try {
            if (0 < stmt.executeUpdate(strSql)) {
                close_DB_Object();
                flag = true;
                con.commit();
            }
        } catch (SQLException ex) {
            logger
                    .info("###############Error DBManager Line126::执行SQL语句操作(更新数据无参数):"
                            + strSql + "失败!");
            flag = false;
            con.rollback();
            throw ex;
        }
        return flag;

    }

    /**
     * 执行SQL语句操作(更新数据有参数)
     *
     * @param strSql
     *            sql指令
     * @param prams
     *            参数列表
     * @return
     * @throws SQLException
     */
    public boolean executeUpdate(String strSql, HashMap prams)
            throws SQLException, ClassNotFoundException {
        getConnection();
        // getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
        boolean flag = false;
        try {
            pstmt = con.prepareStatement(strSql);
            setParamet(pstmt, prams);
            logger.info("###############::执行SQL语句操作(更新数据有参数):" + strSql);

            if (0 < pstmt.executeUpdate()) {
                close_DB_Object();
                flag = true;
                con.commit();
            }
        } catch (SQLException ex) {
            logger
                    .info("###############Error DBManager Line121::执行SQL语句操作(更新数据无参数):"
                            + strSql + "失败!");
            flag = false;
            con.rollback();
            throw ex;
        } catch (ClassNotFoundException ex) {
            logger
                    .info("###############Error DBManager Line152::执行SQL语句操作(更新数据无参数):"
                            + strSql + "失败! 参数设置类型错误!");
            con.rollback();
            throw ex;
        }
        return flag;

    }

    /**
     * 执行SQL语句操作(查询数据无参数)
     *
     * @param strSql
     *            SQL语句
     * @return 数组对象列表
     * @throws Exception
     */
    public ArrayList executeSql(String strSql)
            throws Exception {
        getConnection();
        // getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
        stmt = con.createStatement();
        logger.info("###############::执行SQL语句操作(查询数据):" + strSql);
        rs = stmt.executeQuery(strSql);
        con.commit();
        if (null != rs) {
            return convertResultSetToArrayList(rs);
        }
        close_DB_Object();
        return null;
    }

    /**
     * 执行SQL语句操作(查询数据有参数)
     *
     * @param strSql
     *            SQL语句
     * @param prams
     *            参数列表
     * @return 数组对象列表
     * @throws Exception
     */
    public ArrayList executeSql(String strSql,
            HashMap prams) throws Exception {
        getConnection();
        // getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
        pstmt = con.prepareStatement(strSql);
        setParamet(pstmt, prams);
        logger.info("###############::执行SQL语句操作(查询数据):" + strSql);
        rs = pstmt.executeQuery();
        con.commit();
        if (null != rs) {
            return convertResultSetToArrayList(rs);
        }
        return null;
    }

    /**
     * 执行存储过程(查询数据无参数)
     *
     * @param procName
     *            存储过程名称
     * @return 数组列表对象
     * @throws Exception
     */
    public ArrayList executeProcedureQuery(
            String procName) throws Exception {
        getConnection();// 获取连接
        String callStr = "{call " + procName + "}";// 构造执行存储过程的sql指令
        CallableStatement cs = con.prepareCall(callStr);
        logger.info("###############::执行存储过程(查询数据):" + procName);
        rs = cs.executeQuery();
        con.commit();
        cs.close();
        close_DB_Object();
        return convertResultSetToArrayList(rs);
    }

    /**
     * 执行存储过程(查询数据,带参数)返回结果集合
     *
     * @param procName
     *            存储过程名称
     * @param parameters
     *            参数对象数组
     * @param al
     *            数组列表对象
     * @return 数组列表对象
     * @throws Exception
     */
    public ArrayList executeProcedureQuery(
            String procName, Object[] parameters) throws Exception {
        int parameterPoint = 0;
        // 获取存储过程信息列表集合
        ArrayList procedureInfo = getProcedureInfo(procName);
        // 获取存储过程的完全名称
        String procedureCallName = getProcedureCallName(procName,parameters.length);
        // 获取连接对象
        getConnection();
        // 初始化存储过程执行对象
        CallableStatement cs = con.prepareCall(procedureCallName);
        // 参数下标变量
        int index = 0;
        // 获取存储过程信息列表集合的迭代器对象
        Iterator iter = procedureInfo.iterator();
        // 遍历存储过程信息列表集合
        while (iter.hasNext()) {
            HashMap hm = iter.next();

            parameterPoint++;
            // 如果参数是输入参数 way = 0
            if (hm.get("WAY").equals("0")) {
                // 设置参数到cs
                cs.setObject(parameterPoint, parameters[index]);
                // 参数下标+1
                index++;
            }
        }
        // 释放这个对象,做为第二次使用
        procedureInfo = null;
        logger.info("###############::执行存储过程(查询数据):::::" + procedureCallName);
        rs = cs.executeQuery();
        con.commit();
        procedureInfo = convertResultSetToArrayList(rs);
        cs.close();
        close_DB_Object();
        return procedureInfo;

    }

    /**
     * 执行存储过程(更新，查询数据[简单查询、非纪录集]，返回输出参数[非纪录集])
     *
     * @param procName
     *            存储过程名称
     * @param parameters
     *            参数对象数组
     * @param os
     *            输出参数对象数组
     * @return 输出参数对象数组
     * @throws Exception
     */
    public Object[] executeProcedureUpdate(String procName, Object[] parameters)
            throws Exception {
        logger.info("------------------------------------------------------------------------------------------------------");
        logger.info(" Run --> executeProcedureUpdate ##############   正在执行存储过程: " + procName +"   ##############");
        CallableStatement cs = null;
        Object []returnVal = null;
        try {
        // 获取存储过程调用全名
        String fullPCallName = getProcedureCallName(procName,parameters.length);
        logger.info(" Run --> executeProcedureUpdate #   存储过程命令: " + fullPCallName +"   #");
        //获取存储过程参数信息
        ArrayList p_Call_Info_List = getProcedureInfo(procName);
        //获取连接
        getConnection();
        //创建存储过程执行对象
        cs = con.prepareCall(fullPCallName);
        //数组下标
        int index = 1;
        //输出参数下标纪录
        ArrayList outPutIndexList = new ArrayList();
        logger.info(" Run --> executeProcedureUpdate #   参数个数是: " + parameters.length +"   #");
        for(HashMap tempHash:p_Call_Info_List)
        {
            if("0".equals(tempHash.get("WAY")))
            {
                //设置输入参数
                cs.setObject(index, parameters[index-1]);
                logger.info(" Run --> executeProcedureUpdate #   输入 Input: 编号:" + index +" 值: "+parameters[index-1]+" 类型: "+parameters[index-1].getClass()+"   #");
            }
            else
            {
                //注册输出参数
                cs.registerOutParameter(index, getDataType(tempHash.get("TYPENAME").toString()));
                //纪录输出参数的下标
                outPutIndexList.add(index);
                logger.info(" Run --> executeProcedureUpdate #   输出 OutPut: 编号:" + index +" 值: "+parameters[index-1]+" 类型: "+parameters[index-1].getClass()+"   #");
            }
            index++;
        }
        logger.info(" Run --> executeProcedureUpdate #   参数设置完毕,正在执行中 :   #");

        //-------------------- 执行 -----------------
        if(!cs.execute())
        {
            returnVal = new Object[outPutIndexList.size()];
            logger.info(" Run --> executeProcedureUpdate #   执行成功! :   #");
            //取输出参数的返回值
            for(int i = 0 ;i            {
                returnVal[i] = cs.getObject(outPutIndexList.get(i));
                logger.info(" Run --> executeProcedureUpdate #   返回值 "+(i+1)+" "+returnVal[i]+"   #");
            }
            con.commit();//提交
        }
        } catch (Exception e) {
            logger.info(" Run --> executeProcedureUpdate #   执行失败!事务回滚中 :   #");
            con.rollback();
            throw e;
        }
        logger.info("------------------------------------------------------------------------------------------------------");
        return returnVal;
    }

    /** ****************************************************************************************** */
    /**
     * ********************************* 小工具
     * ************************************************
     */
    /** ****************************************************************************************** */

    /**
     * 关闭数据对象
     */
    public void close_DB_Object() {
        logger.info("###############close:::::关闭连接对象，语句对象，记录集对象");
        if (null != rs) {
            try {
                rs.close();
            } catch (SQLException ex) {
                rs = null;
            }
        }
        if (null != stmt) {
            try {
                stmt.close();
            } catch (SQLException ex) {
                stmt = null;
            }
        }
        if (null != pstmt) {
            try {
                pstmt.close();
            } catch (SQLException ex) {
                pstmt = null;
            }
        }
        if (con != null) {
            dcm.freeConnection("mysql", con);
        }
    }

    /**
     * 设置Sql 指令参数
     *
     * @param p_stmt
     *            PreparedStatement
     * @param pramets
     *            HashMap
     */
    private PreparedStatement setParamet(PreparedStatement p_stmt,
            HashMap pramets) throws ClassNotFoundException,
            SQLException {
        // 如果参数为空
        if (null != pramets) {
            // 如果参数个数为0
            if (0 <= pramets.size()) {
                for (int i = 1; i <= pramets.size(); i++) {
                    try {
                        // 字符类型 String
                        if (pramets.get(i).getClass() == Class
                                .forName("java.lang.String")) {
                            p_stmt.setString(i, pramets.get(i).toString());
                        }
                        // 日期类型 Date
                        if (pramets.get(i).getClass() == Class
                                .forName("java.sql.Date")) {
                            p_stmt.setDate(i, java.sql.Date.valueOf(pramets
                                    .get(i).toString()));
                        }
                        // 布尔类型 Boolean
                        if (pramets.get(i).getClass() == Class
                                .forName("java.lang.Boolean")) {
                            p_stmt.setBoolean(i, (Boolean) (pramets.get(i)));
                        }
                        // 整型 int
                        if (pramets.get(i).getClass() == Class
                                .forName("java.lang.Integer")) {
                            p_stmt.setInt(i, (Integer) pramets.get(i));
                        }
                        // 浮点 float
                        if (pramets.get(i).getClass() == Class
                                .forName("java.lang.Float")) {
                            p_stmt.setFloat(i, (Float) pramets.get(i));
                        }
                        // 双精度型 double
                        if (pramets.get(i).getClass() == Class
                                .forName("java.lang.Double")) {
                            p_stmt.setDouble(i, (Double) pramets.get(i));
                        }

                    } catch (ClassNotFoundException ex) {
                        throw ex;
                    } catch (SQLException ex) {
                        throw ex;
                    }
                }
            }
        }
        return p_stmt;
    }

    /**
     * 转换记录集对象为数组列表对象
     *
     * @param rs
     *            纪录集合对象
     * @return 数组列表对象
     * @throws Exception
     */
    private ArrayList convertResultSetToArrayList(
            ResultSet rs) throws Exception {
        logger.info("###############::转换记录集对象为数组列表对象");
        // 获取rs 集合信息对象
        ResultSetMetaData rsmd = rs.getMetaData();
        // 创建数组列表集合对象
        ArrayList tempList = new ArrayList();
        HashMap tempHash = null;
        // 填充数组列表集合
        while (rs.next()) {
            // 创建键值对集合对象
            tempHash = new HashMap();
            for (int i = 0; i < rsmd.getColumnCount(); i++) {
                // 遍历每列数据，以键值形式存在对象tempHash中
                tempHash.put(rsmd.getColumnName(i + 1).toUpperCase(), rs
                        .getString(rsmd.getColumnName(i + 1)));
            }
            // 第一个键值对，存储在tempList列表集合对象中
            tempList.add(tempHash);
        }
        close_DB_Object();// 关闭相关链接
        return tempList;// 返回填充完毕的数组列表集合对象
    }

    /**
     * 从数据库得到tb存储过程信息
     *
     * @param procName
     *            存储过程名称
     * @return 数组列表对象
     * @throws Exception
     */
    private ArrayList getProcedureInfo(String procName)
            throws Exception {
        return this.executeSql("select Syscolumns.isoutparam as Way,systypes.name as TypeName from sysobjects,syscolumns,systypes where systypes.xtype=syscolumns.xtype and syscolumns.id=sysobjects.id and sysobjects.name='"
                + procName + "' order by Syscolumns.isoutparam");
    }

    /**
     * 从数据库得到存储过程参数个数
     *
     * @param procName
     *            存储过程名称
     * @return 数组列表对象
     * @throws Exception
     */
    @SuppressWarnings("unused")
    private int getParametersCount(String procName) throws Exception {
        int returnVal = 0;
        for (HashMap tempHas : this
                .executeSql("select count(*) as RowsCount from sysobjects,syscolumns,systypes where systypes.xtype=syscolumns.xtype and syscolumns.id=sysobjects.id and sysobjects.name='"
                        + procName + "'")) {
            returnVal = Integer.parseInt(tempHas.get("ROWSCOUNT").toString());
        }
        return returnVal;
    }

    /**
     * 得到调用存储过程的全名
     *
     * @param procName
     *            存储过程名称
     * @return 调用存储过程的全名
     * @throws Exception
     */
    private String getProcedureCallName(String procName, int prametCount)
            throws Exception {
        String procedureCallName = "{call " + procName;
        for (int i = 0; i < prametCount; i++) {
            if (0 == i) {
                procedureCallName = procedureCallName + "(?";
            }
            if (0 != i) {
                procedureCallName = procedureCallName + ",?";
            }
        }
        procedureCallName = procedureCallName + ")}";
        return procedureCallName;
    }

    /**
     * 得到数据类型的整型值
     *
     * @param typeName
     *            类型名称
     * @return 数据类型的整型值
     */
    private int getDataType(String typeName) {
        if (typeName.equals("varchar"))
            return Types.VARCHAR;
        if (typeName.equals("int"))
            return Types.INTEGER;
        if (typeName.equals("bit"))
            return Types.BIT;
        if (typeName.equals("float"))
            return Types.FLOAT;
        return 0;
    }

    // 设置驱动路径
    @SuppressWarnings("static-access")
    public void set_DRIVER(String _DRIVER) {
        this._DRIVER = _DRIVER;
    }

    // 设置数据库密码
    @SuppressWarnings("static-access")
    public void set_PASSWORD(String _PASSWORD) {
        this._PASSWORD = _PASSWORD;
    }

    // 设置数据库连接字符串
    @SuppressWarnings("static-access")
    public void set_URL(String _URL) {
        this._URL = _URL;
    }

    // 设置数据库用户名
    @SuppressWarnings("static-access")
    public void set_USER_NA(String _USER_NA) {
        this._USER_NA = _USER_NA;
    }

}

chen11-1 2013-05-27 16:55 发表评论

Java项目经验——程序员成长的关键

chen11-1 — Thu, 21 Jun 2012 08:23:00 GMT

Java就是用来做项目的！Java的主要应用领域就是企业级的项目开发！要想从事企业级的项目开发，你必须掌握如下要点：
1、掌握项目开发的基本步骤
2、具备极强的面向对象的分析与设计技巧
3、掌握用例驱动、以架构为核心的主流开发方法

没有人愿意自己一辈子就满足于掌握了一些代码实现的技巧，别人告诉你要实现什么，你就用代码堆砌来实现别人的要求！你必须学会从整个项目的角度去思考！你必须学会假如你是项目经理，你该如何思考！你必须学会假如你是架构师，你该如何思考！你必须掌握针对某个特定问题领域的分析方法！

关于基础tb知识：你可以看看这些名词或知识点，看是否能说出个一二三四来。

JavaSE
----基本语法、数据类型、操作符等：int、long、Integer、Long、if、else、for、while
----面向对象：class（类）、Object（对象）、instance（实例）、state（状态）、behavior（行为）、field、method、new、可见性（访问控制）、attribute、property、package、import、static variable、class variable、instance variable、heap、method area、stack、GC（垃圾回收）、override、overload、对象转型(casting)、多态、this、super
----异常处理：理解编译期错误和运行期错误的区别、Exception、RuntimeException、checked exception、unchecked exception、try、catch、finally、throw new XXXException、throws XXXException、异常处理的基本原则
----数组与集合：数组的定义和使用方法、Collection、List、Set、Map、ArrayList、HashSet、HashMap、Iterator、equals、hashCode、Comparable、Comparator
----常用类：String、intern、常量池、StringBuffer、java.util.Date、SimpleDateFormat、Regex（正则表达式）
----反射机制：Class、Method、Field、invoke、newInstance、BeanUtils（apache-commons）、PropertyUtils（apache-commons）
----输入输出流：InputStream、OutputStream、Reader、Writer、Adapter设计模式与原始流类、Decorator设计模式与包装流类、对象序列化和反序列化
----多线程：Thread、Runnable、sleep、wait、notify、synchronized、lock

Servlet和JSP
----HttpServlet、doGet、doPost、HttpServletRequest、HttpServletResponse、request.getParameter()、request.setAttribute()、request.getAttribute()、request.getSession()、ServletContext、Filter、web.xml、tomcat、forward与redirect、http协议的无状态性、cookie、JSP Scope Object、、

HTML与JavaScript
----你需要能够理解常见的网页标签、理解在网页中引入JavaScript的方法、以及JavaScript的基本语法与使用方法

以上，就是你进一步学习Java所必备的基本知识。特别是一些个专业术语和名词，看到这些名词，如果你像看到亲爹一样亲切，那么说明你对Java的基础知识就很熟悉了。

接下来是SSH：
对于初学者来说，这三大框架被赋予了太多神秘的色彩，似乎它们是重中之重的知识！但是对于拥有多年Java开发经验的专业技术人员来说，对于那些Java牛人来说，却对这三大框架不太感冒！难道它们不重要吗？

现在很多企业都在用这三大框架，所以很多企业也把掌握这三大框架作为招聘的必备条件。不可否认的是，也有很多大型企业没有用这三大框架，这些企业经过多年发展，自身已经有一定的技术积累，也形成了自己独特的技术框架体系。这三大框架既可以说很重要，也可以说不重要。

说重要的原因在于：这三大框架对JavaEE开发中所存在的普遍的问题，提供了优美的解决方案，它们蕴含了这个行业中最NB的开发人员的努力和想法，所以，学习这三大框架，你就可以窥探到这些处于技术巅峰的牛人们究竟对一个问题是怎么想的，通过一种什么样的设计思路去解决问题的。所以，对于你来说，你没有太多项目开发的经验，经验是什么？经验就是你知道可能会遇到哪些问题，针对哪个问题可以有哪些解决方法，在某个情景下，哪种解决方法是较好的，哪种方法不太好等等！如果你没做过什么项目，你根本就不会去意识到你可能会遇到哪些问题，而这些问题往往又是非常关键的！解决得不好，会影响到你的程序的稳定性、可扩展性等等！三大框架就给初学者提供了了解你以后可能会遇到哪些问题，以及针对这些问题的解决方案！

当你了解了这三大框架为什么是重要的，那么你也就能理解，为什么这三大框架也可以说是不重要的。如果你曾经开发过很多项目，你碰到了各种各样的问题，凭着你的技术功底，逐个击破了这些问题，在这些人眼里，三大框架（是不是还有N个框架？呵呵）都是浮云！

你属于哪一种人呢？如果你没有太多项目开发经验，那么三大框架对于你来说就是非常重要的！而且，由此你也知道了该怎么去学这三大框架。对于三大框架的学习而言，着力点在于给你展示问题，并触发你自己主动的思考，我们鼓励你提出自己的想法，也许你的想法很白痴，但那毕竟是你自己的想法，如果你不知道牛人的想法，那你怎么知道自己的想法是很白痴的呢？在这种思想的碰撞过程中，你就会逐渐提高自己！所以，三大框架学完之后，你不应该只是看到一大堆配置文件，你不应该只是看到了一些Action，一些Service，一些映射文件，你不应该只知道session.save/update/delete，你不应该只是知道struts2中有一堆interceptor，你不应该只是看到一堆jar包……

如果你只是知道拷贝一堆jar包，定义一系列配置文件之后，SSH三大框架就能够运行起来了，也可以给你干活了，那么，很悲哀的是，你仍然没有掌握三大框架的精粹！请你回答以下问题：

Struts2：
为什么每次请求都要创建一个Action对象？
ModelDriven拦截器的配置中refreshModelBeforeResult解决了什么问题？
为什么在web.xml中配置的StrutsPrepareAndExecuteFilter要过滤所有的请求？
请你给我谈谈ValueStack？
Struts2是如何实现MVC设计模式的？

Spring：
你为什么要用Spring？
请你聊一聊IOC/DI？
什么是声明式的事务管理？为什么要使用声明式的事务管理？Spring如何实现声明式的事务管理？
把spring和hibernate集成，定义事务管理特性的时候，为何要将除了添加、删除、更新操作之外的方法，即主要执行查询任务的方法定义为read-only？

Hibernate：
请你谈谈你对OR映射的理解？
很多人说Hibernate不适合大项目，性能有问题，你是如何理解的？
Hibernate为什么一定要定义一个数据库标识？
为什么Hibernate建议你的实体类实现hashCode和equals方法？
谈谈你对Hibernate实体类中的数据库标识与数据库主键之间关系的认识？
谈谈你对Hibernate关联映射与数据库外键之间关系的认识？
调用session.save()方法，hibernate一定会发出insert语句吗？谈谈你的理解
调用session.update()方法，hibernate一定会发出update语句吗？谈谈你的理解
请你聊一下以下名词、概念或用法：lazy、lazy=”extra”、inverse、fetch、fetch=”join”、fetch=”subselect”、batch-size
配置了lazy=”true”一定会实现懒加载吗？
请你谈谈Hibernate中的“N+1”问题
请你谈谈Hibernate有哪些最佳实践？

以上并非SSH中全部重点的问题，但它们能考察你能否灵活运用SSH框架！如果你能深刻理解这些问题，再配以合适的实战项目训练，你也会逐渐成为牛人！

最后是项目开发能力：
不管你是学Java还是别的技术，你的根本目的在于给客户创造价值！否则，你下大力气学习的东西，随着技术的进步和更新，很快就会过时！所以，技术的核心在于用技术创造有价值的成果！也就是说，客户需要什么，你就要用技术把客户需要的东西给他造出来！一个公司之所以要用各种福利条件极力挽留你，是因为你能够给公司带来极高的利益！那么，你有什么可以给公司利用的呢？公司最看重你的哪方面的能力呢？

做项目需要的能力很多，其中最核心最基础的就是建模能力（现在最主流的就是面向对象建模！）。什么是建模能力呢？

我给大家一个面试题：
一个保险公司的保险卡管理模块：销售人员领取保险卡信息（保险卡数量、卡号、领取日期），然后直接销售给客户，销售完毕后，将保险卡信息录入保险公司系统内部（销售人员信息、购买人信息、购买的保险卡数量、卡号等），客户登录保险公司网站激活保险卡，需要填写（保险卡卡号、激活密码、被保险人信息、受益人信息）

要求就是：如果这个模块交给你来做，你要怎么做？你要解决哪些问题？你可否画个图，给我描述一下你的想法是什么吗？

这只是一个面试题而已，因为只有简单几句话，所以我把它放到这里，让大家感受一下所谓建模要解决什么问题。而业务领域的问题实在是太多了！也许一个几十上百页的需求文档才能把某个业务领域的问题描述清楚，而你的职责就是要把它们实现出来！

某个公司要开发一个考勤管理系统，要求与现有的人力资源系统对接，你是主要的技术负责人，那么，你要做哪些工作呢？

某ERP项目要实现一个排班管理模块，交给你去完成，你如何去完成呢？

不要抱怨项目经理给你的信息太少（只有几句话），不要抱怨客户没有描述清楚他们的需求……你的价值就在于理顺所有的问题tb，用各种手段获得你想要的信息，按照一定的思路汇总，并在特定的时间里逐个解决它！

你应该意识到学Java不是一个坦克大战、一个网络飞车、一个CMS、一个DRP、一个OA那么简单，你不要沉迷于那些技术细节（虽然也是有必要的，但不要转牛角尖），不要满足于实现了CRUD式的项目需求（虽然这是基础中的基础），在你的前方，永远有一个目标在那里，需要你去努力追赶！

今后你将面对更加繁杂的需求，你学习项目的唯一目的，就是：学习如何将需求转化为实现，如何对需求进行分析，如何建立概念模型，如何理顺各种概念之间的关系，如何进行设计，如何选择合适的技术来实现你的设计方案，如何对你的实现进行测试，如何解决你所遇到的形形色色的问题（性能、需求变更等）。当你真正到公司里面从事了几年开发之后，你就会同意我的说法！

利用Java找工作，需要的就是项目经验，项目经验就是理解项目开发的基本过程，理解项目的分析方法，理解项目的设计思路，理解项目的实现技巧，理解项目的测试方法，理解项目中各种问题的解决方案！！！

所以，你该清楚你的目标了！

chen11-1 2012-06-21 16:23 发表评论

IT“茫一代”：35岁成生死线无处安放未来(新浪)----------转

chen11-1 — Sun, 10 Jun 2012 03:31:00 GMT

一年半的时间里，曾小亮两上八宝山。

　　送走的第一位好友，是某著名互联网公司女性频道的主编，突发脑溢血，去世时年仅37岁。新近送走的是《健康与美容》杂志的主编孟玲和，48岁，开会时突发脑溢血，去世前几天曾小亮还曾与其彻夜长聊。

　　从八宝山回来的路上，曾小亮一个人沿着长安街走了好久。这位酒尚出版人助理、情感职场专栏作家、总是为别人调制“心灵鸡汤”的人，在那一刻，竟然抑制不住心生强烈的幻灭感。

　　他忽然间觉得，金钱、地位、名利都不再那么重要，生命、健康与爱，这些我们人生中更具有本源意义，但是长久被忽视的东西，慢慢清晰地浮现出来。

　　这是“压力山大”的一代人。严重透支身体，恨不能每周7*24小时地工作，在跻身上层、功成名就的路上狂奔。他们的不安全感、焦虑感从某种程度上远远超过了父辈。

　　他们几乎完整地经历了中国社会经济快速发展的三十年，从物质财富的极度匮乏到迅速富裕；同时也见证了恢复高考、计划生育、打破大锅饭、企业改制、取消福利分房、中国加入WTO等种种既有秩序的被打破。

　　当秩序被打破时，总会有人为此付出代价。这一代人身上深深烙上了中国社会经济发展代际变迁的印记。

　　35岁老了？

　　提前来临的焦虑、无措、迷茫

　　科锐国际人力资源公司业务总监刘峰前一阵子刚刚接触了一家叫“豆瓣”的互联网公司。让他这个做了十几年人力资源工作的老“猎头”有些意外的是，豆瓣公司员工的平均年龄非常小，大概在25岁左右。

　　大约三年前，刘峰和腾讯的HR有次聊天，让他印象深刻的是腾讯的“特色”之一“很年轻”。

　　近十年里，国内一些新晋大公司的出现，像百度、腾讯、阿里巴巴等互联网巨头的崛起，带动了一个大产业，使很多年轻人年纪轻轻就获得了意想不到的成功。

　　而且，互联网等新产业的勃兴，正加速着社会对人才的需求和优胜劣汰，也正拉低着职场人群的平均年龄。

　　互联网领域里“年轻化”的公司正日益多起来。比如中国第一家女性团购网站“聚美优品”，三个联合创始人都是80后，一些中层管理者甚至是1989年生人，今年29岁的CEO陈欧一直有个想法，在自己30岁以前把聚美优品做上市。他甚至坦言，在事业快速发展的这几年，他暂时不会因为结婚这类“家事”把自己限制住。

　　35岁在某种程度上就意味着职场“生死线”，对许多IT人来说，35岁甚至意味着技术生涯的结束。

　　现在，对越来越多在职场和事业上打拼的80后来说，29岁就已经临近“过期”：青春的有效期29岁截止，一到30岁，就会被打上“Timeout”(过期)的印记。

　　对于那些最早一批进入外资企业“吃螃蟹”的人来说，现在已近人到中年，更是处境尴尬。

　　一方面由于年龄的原因，不少外企白领在公司的发展遭遇瓶颈，“在我这个年龄和职位，继续待在外企的话后面的路已经很清楚，升职上遭遇玻璃天花板，年龄上经不起高强度的工作”。

　　另一方面，不少人由于产业大环境的变化，“金饭碗”的含金量正在加速褪去。

　　科锐国际早期的客户源100%都是外资企业；公司成立五六年时，2000年左右，科锐国际开始与包括华为、李宁等在内的本土企业有初步接触；到2004年、2005年时，公司明确将发展内资企业客户作为重点，彼时内资企业所占科锐国际客户源的比例还很低；从2008年、2009年以后，内资企业的业务能占到科锐国际总业务的百分之二三十。“在高科技、互联网这些行业，外资客户与内资客户的比重甚至是四六开。”

　　刘峰认识很多外资企业的高层或者中层以上的经理，在90年代末或者2000年左右，他们的职业很让人艳羡，而tb现在职业的“含金量”已经大不如以前。“那时候的外企中高层，买两套房子很正常，但是你今天进到外企，即使给你八千、一万块钱月薪，你什么时候才能买个房子呢？同样是薪水，含义已经发生了深刻的变化。”

　　社会经济的快速发展也让职场危机提前而至，在发达国家，焦虑、无措、迷茫等中年职场危机的表现通常发生在45～55岁，但是在中国却提前了近10年。

　　这是“压力山大”的一代人。严重透支身体，恨不能每周7x24小时地工作，在跻身上层、功成名就的路上狂奔。他们的不安全感、焦虑感从某种程度上远远超过了父辈。

退休或重返职场？

　　参数未知的将来

　　“退休”，对当下这个人群来说，几乎是一种奢望。

　　李强是一家私企的老板，早年做生意赚了几百万后觉得足够将来生活了，便结束了生意，开始安享生活。可是不到十年，他发现生活的发展完全脱离了他预设的轨道。“十年前几百万足够一个人安安稳稳过完一辈子，可是我没有想到这几年房价、物价会涨成这样，现在几百万还算个啥。”“安享”计划泡汤的李强不得不重整旗鼓，再次创业。

　　刘峰身边也有朋友有过和李强类似“提前退休”的经历。这位朋友为了移民加拿大，在事业发展最顺风顺水的时候，提前结束在中国国内的工作，在加拿大当地随便找了个工作。待到移民必须的居住时间期满后，这位朋友想再回中国来发展，却发现已经错失了事业发展的最好机会。

　　对于至少还有些“家底儿”的李强等人来说未来虽然艰难，但还不至于毫无保障，对于更多的中年职场工作者而言未来生活的参数一概未知，这种不确定性和不安全感更加重了这一群体的焦虑。到底有多少资产未来才可以安枕无忧？没人可以给出一个确切的答案。

　　20多年前，大学每年的学费只有200元，现在有些专业已经冲上万元，增长了约50倍。中国青年报社会调查中心曾有一项7625人参与的调查统计称，尽管78.8%的人认为和十年前相比收入增加了，但是85.3%的人感觉自己的生活负担比十年前更重了。有人估算了近四十年来中国人结婚的成本：70年代末是600元，80年代是3000元，90年代是3.3万，21世纪达56.6万，越来越贵的中国式婚姻。显而易见的是，中国社会经济获得了前所未有的快速发展，但人们的收入增长速度却远没有跑过物价上涨的速度。

　　“在过去几十年的发展过程中，一个不可回避的问题就是国家对中层人群，其实没有好的政策来扶植他们。”刘峰感慨，中层的赋税很高，高到很吓人的程度，而另一方面，国家给予这一阶层的福利几乎是零。“比如说我每月交那么多钱的税，突然有一天失业了，却发现我什么都没有，真的是什么都没有。”

　　对于这一现状，资深产业经济学家白益民认为，日本企业的员工对于未来的焦虑感要比中国低得多，“日本有约定俗成的终身雇佣制以及与其相配合的年功序列制、企业工会。这是日本的三大神器。”白益民介绍，在日本的企业中，企业不会轻易裁员，年功序列制是指工资待遇按员工的资历慢慢增长，所以一旦进入一个企业，你就可以知道自己未来在这家公司大概享有的工资待遇水准。

　　长期以来，对于中国是否应该采用终身雇佣制的争论一直存在，白益民的看法是一些特定的企业可以尝试这种制度，这对于企业人才的积累、技术的传承以及员工对生活的安全感都将会有很大的帮助。

　　异化的人性

　　“被高速”的一代

　　曾小亮认为，整个社会在追求经济高速发展的时候，同时导致了人性的异化。因为人不可能变成一个经济动物，人有内在的自尊、自我，有对幸福感的追逐，经济并不能满足人们更深的快乐。“很多人在有了基本的物质保证之后，就会发现自己开始寻找新的幸福之道。”

　　“你会发现人们这种心理状态的变化和经济发展有一脉相承的地方，特别是在经济高速发展的时候。”曾小亮注意到，中年阶层的这种集体性焦虑和迷茫，曾经出现在美国的上世纪七八十年代，中国台湾的九十年代。

　　在中国，一方面是高速发展的经济环境让管理人才的职业晋升速度超过了心智成熟度的提升，另一方面是中国长期以来的应试教育过分注重分数，而忽视了心灵的成长，此外对经济发展的过度追求，也让这一群体缺乏对生活的整体观。

　　“升迁官能症”在中层人群中就相当普遍。“或是没有做好准备，或者是能力不够、提拔太快，被提拔上去以后，会发现很多事情自己没有能力驾驭了。”曾小亮认为，因为心智的成熟速度赶不上社会角色的提升速度，很多中层人群在职场角色擢升后就会出现各种问题。“跟同事的关系、家庭的问题，突然就会觉得自己扛不住了。我曾经在专栏中提到过，在这个状态下要学会用一些方法去调试，这就涉及到很多大的课题了。我觉得这跟人才的储备也有关系，经济发展太快，人才储备不够。”

　　这种对周遭事物掌控能力的欠缺也极大地加剧了这一人群的焦虑感。

　　一直以来，中国都推崇GDP增长的神话，认为面临的首要问题是尽快地发展生产力，提高经济水平，解除贫困状态，增强综合国力。在这种背景下，“GDP崇拜”成为一种普遍情结，唯效率主义或独尊经济指数的发展成为主要甚至惟一的取向。片面追求经济增长也导致了诸多不良的后果，国民教育、就业保障、社会福利、医疗卫生、文化建设等与人民生活质量密切相关的社会领域的发展就被不同程度的牺牲掉了，当置身经济发展大潮的主流阶层人士行至中年才发现自己忽略了身体，忽视了家庭，却并没有从过快发展的经济中获得多少幸福感，甚至于找不到自己的未来。

　　近年来，美国、英国等发达国家越来越重视“幸福指数”这一软指标，美国联邦政府和英国内阁甚至拨巨资成立专门的研究机构，聘请诺贝尔经济学奖得主丹尼尔·卡内曼等专家坐镇，设立衡量人们幸福感的指标，使它与GDP一样成为衡量一个国家发展水平的标准。

　　“幸福经济”越来越成为人们热议的话题。曾有人发问，如果GDP的增长不能让人们更幸福，政府为什么还要致力于GDP的增长呢？当下“茫一代”既是推动中国社会经济高速发展的蚂蚁雄兵，也是被经济高速发展“副作用”所中伤的一代，他们是否幸福、如何才能幸福，是中国社会经济代际变迁的注脚。

chen11-1 2012-06-10 11:31 发表评论

网上流传的软件测试工程师级别

chen11-1 — Sun, 10 Jun 2012 03:28:00 GMT

初级测试工程师：年薪约在2-4万左右。他们的工作通常是按照测试方案和流程对产品进行功能测试，检查产品是否有缺陷。具有一些手工测试经验，开发测试脚本并开始熟悉测试生存周期和测试技术；

中级测试工程师：年薪在5-6万左右。他们要能够编写测试文案，测试文档，与项目组一起制定测试阶段的工作计划。能够在项目中合理利用测试工具来完成测试任务。能够独立编写自动测试脚本程序并担任测试编程初期的领导工作，进一步拓展编程语言、操作系统、网络与数据库方面的技能；

高级测试工程师：年薪8-10万左右。他们不但需要掌握测试与开发技术，而且对所测试软件对口的行业非常了解，能够对测试方案可能出现的问题进行分析和评估。帮助开发或维护测试或编程标准与过程，负责同级的评审，并能够指导初级的测试工程师；

Team Leader（测试主管）：年薪8-15w，一般至少具有5年的工作经验，负责管理一个小团队。负责进度安排、工作规模/成本估算、按进度表和预算目标交付产品，负责开发项目的技术方法，能够为用户提供支持和演示；

测试经理：年薪在12-20w，能够担当测试领域内的整个开发生存周期业务，能够为用户提供交互和大量演示，负责项目成本、进度安排、计划和人员分工；

计划经理（或者说测试总监）：年薪20-30w，具有多年纯熟的开发与支持（测试/质量保证）活动方面的经验，管理从事若干项目的人员以及整个开发生存周期，负责把握项目方向和盈亏责任。

----------------------------------------------------------------------------------
0级：
不了解测试方法；
没有测试计划和测试样例，漫无目的测试，靠运气找BUG；
tb提交BUG的时候描述非常不清楚；

1级：
了解一些测试方法；
有一定的逻辑思考能力；
知道测试重点，了解测试覆盖率，会设计测试样例；
提交BUG的时候描述非常清楚，有详细的BUG重现步骤；

2级：
知道常用测试方法和测试技巧；
有较强逻辑思考能力；
会使用一些自动化测试工具；
有明确的测试计划和测试重点，设计的测试样例覆盖率较高。
提交BUG的时候描述非常清楚，有详细的重现步骤，规律性以及解决的建议。

3级：
熟悉常用测试方法和测试技巧；
不定期学习新的测试方法和测试技巧；
有很强逻辑思考能力；
会使用一些自动化测试工具；
经常上一些测试论坛和同行交流；
会一种编程语言（特别是shell，python等脚本语言）；
有明确的测试计划和测试重点，设计的测试样例覆盖率非常高。
提交BUG的时候描述非常清楚，有详细的重现步骤，规律性以及解决的建议。