prototype.js是一个很强大的Javascript函数库,它可以让你很轻松的使用一些特效,实现AJAX的功能.虽然prototype.js是为了Ruby On Rails开发的,它的纯Javascript的性质也使得它很容易用在其他的网络程序中.可惜的是,Prototype.js还没有强大的文档解释,尽管它的代码非常有条理,但是也给初学者造成了一定的麻烦.作者在README里说:

Prototype is embarrassingly lacking in documentation. (The source code should be fairly easy to comprehend; I’m committed to using a clean style with meaningful identifiers. But I know that only goes so far.)

基本用法:以Element Class为例,prototype给每个主要的分类都分成了一个Class,使用起来很方便,要产生特定的效果的话只要用new Class.function(<argument>)就可以了.比如:

<DIV id="div1"><a href="#" onclick="new Element.toggle(''div2'')">Click Me</a></DIV>

<DIV id="div2">Hello!</DIV>

当点击Click Me的时候,div2就会交替隐藏或显示.注意,你可以给toggle加上无限个parameter,比如Element.toggle(''div2'',''div3'',''div4'')...

下面是每个重要的类和函数的解释:

Ajax的函数实际上还有一个可选参数,就是options.在未指明的情况下,Ajax使用的是''POST''发送请求,而且是异步执行,如果想要改用''GET''和同步,就可以用Ajax.Request(''http://server/s.php'',''get'','''',''a=1&b=2'')来执行.

在Rails中Ajax的函数被封装成Ruby的函数,所以不必直接采用Ajax.Request,Ajax.Updater.但是知道它是怎么工作的也很有用.

运行截图如下：

3、从借贷记帐法的记帐规则看
借贷记帐法的记帐规则是“有借必有贷，借贷必相等”。

4、从借贷记帐法的试算平衡看
根据这一原理和记帐规则的要求，每一笔经济业务的会计分录都是借贷相等，因而当全部经济都记入帐户后，所有帐户的本期借方发生额合计与本期贷方发生额合计，必定相等；所有帐户的期末借方余额合计与期末贷方合计也必定相等。

Hibernate 完全以面向对象的方式来操作数据库，当程序里以面向对象的方式操作持久化对象时，将被自动转换为对数据库的操作。例如调用Session的 delete()方法来删除持久化对象，Hibernate将负责删除对应的数据记录；当执行持久化对象的set方法时，Hibernate将自动转换为对应的update方法，修改数据库的对应记录。

问题是如果需要同时更新100 000条记录，是不是要逐一加载100 000条记录，然后依次调用set方法——这样不仅繁琐，数据访问的性能也十分糟糕。对这种批量处理的场景，Hibernate提供了批量处理的解决方案，下面分别从批量插入、批量更新和批量删除3个方面介绍如何面对这种批量处理的情形。

4.2.1 批量插入

如果需要将100 000条记录插入数据库，通常Hibernate可能会采用如下做法：

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
for ( int i=0; i<100000; i++ ) {
User u = new User (.....);
session.save(customer);
}
tx.commit();
session.close();

但随着这个程序的运行，总会在某个时候运行失败，并且抛出OutOfMemoryException（内存溢出异常）。这是因为Hibernate的Session持有一个必选的一级缓存，所有的User实例都将在Session级别的缓存区进行了缓存的缘故。

为了解决这个问题，有个非常简单的思路：定时将Session缓存的数据刷新入数据库，而不是一直在Session级别缓存。可以考虑设计一个累加器，每保存一个User实例，累加器增加1。根据累加器的值决定是否需要将Session缓存中的数据刷入数据库。

下面是增加100 000个User实例的代码片段：

private void testUser()throws Exception
{
//打开Session
Session session = HibernateUtil.currentSession();
//开始事务
Transaction tx = session.beginTransaction();
//循环100 000次，插入100 000条记录
for (int i = 0 ; i < 1000000 ; i++ )
{
//创建User实例
User u1 = new User();
u1.setName("xxxxx" + i);
u1.setAge(i);
u1.setNationality("china");
//在Session级别缓存User实例
session.save(u1);
//每当累加器是20的倍数时，将Session中的数据刷入数据库，并清空Session缓存
if (i % 20 == 0)
{
session.flush();
session.clear();
tx.commit();
tx = session.beginTransaction();
}
}
//提交事务
tx.commit();
//关闭事务
HibernateUtil.closeSession();
}

上面代码中，当i%20 == 0时，手动将Session处的缓存数据写入数据库，并手动提交事务。如果不提交事务，数据将依然缓存在事务处——未进入数据库，也将引起内存溢出的异常。

这是对Session级别缓存的处理，还应该通过如下配置来关闭SessionFactory的二级      缓存。

hibernate.cache.use_second_level_cache false

注意：除了要手动清空Session级别的缓存外，最好关闭SessionFactory级别的二级缓存。否则，即使手动清空Session级别的缓存，但因为在SessionFactory级别还有缓存，也可能引发异常。

4.2.2 批量更新

上面介绍的方法同样适用于批量更新数据，如果需要返回多行数据，可以使用scroll()方法，从而可充分利用服务器端游标所带来的性能优势。下面是进行批量更新的代码片段：

private void testUser()throws Exception
{
//打开Session
Session session = HibernateUtil.currentSession();
//开始事务
Transaction tx = session.beginTransaction();
//查询出User表中的所有记录
ScrollableResults users = session.createQuery("from User")
.setCacheMode(CacheMode.IGNORE)
.scroll(ScrollMode.FORWARD_ONLY);
int count=0;
//遍历User表中的全部记录
while ( users.next() )
{
User u = (User) users.get(0);
u.setName("新用户名" + count);
//当count为20的倍数时，将更新的结果从Session中flush到数据库
if ( ++count % 20 == 0 )
{
session.flush();
session.clear();
}
}
tx.commit();
HibernateUtil.closeSession();
}

通过这种方式，虽然可以执行批量更新，但效果非常不好。执行效率不高，而且需要先执行数据查询，然后再执行数据更新，并且这种更新将是逐行更新，即每更新一行记录，都需要执行一条update语句，性能非常低下。

为了避免这种情况，Hibernate提供了一种类似于SQL的批量更新和批量删除的HQL语法。

4.2.3 SQL风格的批量更新/删除

Hibernate提供的HQL语句也支持批量的UPDATE和DELETE语法。

批量UPDATE和DELETE语句的语法格式如下：

UPDATE | DELETE FROM? ClassName [WHERE WHERE_CONDITIONS]

关于上面的语法格式有以下四点值得注意：

   ● 在FROM子句中，FROM关键字是可选的。即完全可以不写FROM关键字。

   ● 在FROM子句中只能有一个类名，该类名不能有别名。

   ● 不能在批量HQL语句中使用连接，显式的或隐式的都不行。但可以在WHERE子句中使用子查询。

   ● 整个WHERE子句是可选的。

假设，需要批量更改User类实例的name属性，可以采用如下代码片段完成：

private void testUser()throws Exception
{
//打开Session
Session session = HibernateUtil.currentSession();
//开始事务
Transaction tx = session.beginTransaction();
//定义批量更新的HQL语句
String hqlUpdate = "update User set name = :newName";
//执行更新
int updatedEntities = session.createQuery( hqlUpdate )
.setString( "newName", "新名字" )
.executeUpdate();
//提交事务
tx.commit();
HibernateUtil.closeSession();
}

从上面代码中可以看出，这种语法非常类似于PreparedStatement的executeUpdate语法。实际上，HQL的这种批量更新就是直接借鉴了SQL语法的UPDATE语句。

注意：使用这种批量更新语法时，通常只需要执行一次SQL的UPDATE语句，就可以完成所有满足条件记录的更新。但也可能需要执行多条UPDATE语句，这是因为有继承映射等特殊情况，例如有一个Person实例，它有Customer的子类实例。当批量更新Person实例时，也需要更新Customer实例。如果采用joined-subclass或union-subclass映射策略，Person和Customer实例保存在不同的表中，因此可能需要多条UPDATE语句。

执行一个HQL DELETE，同样使用 Query.executeUpdate() 方法，下面是一次删除上面全部记录的代码片段：

private void testUser()throws Exception
{
//打开Session实例
Session session = HibernateUtil.currentSession();
//开始事务
Transaction tx = session.beginTransaction();
//定义批量删除的HQL语句
String hqlUpdate = "delete User";
//执行批量删除
int updatedEntities = session.createQuery( hqlUpdate )
.executeUpdate();
//提交事务
tx.commit();
//关闭Session
HibernateUtil.closeSession();
}

由 Query.executeUpdate()方法返回一个整型值，该值是受此操作影响的记录数量。实际上，Hibernate的底层操作是通过JDBC完成的。因此，如果有批量的UPDATE或DELETE操作被转换成多条UPDATE或DELETE语句，该方法返回的是最后一条SQL语句影响的记录行数。

　　一、linux的基本命令

　　1、用户管理

　　userdel 删除用户帐号

　　useradd 增加用户账号

　　su 改变当前用户的ID

　　2、文件目录管理

　　ls 浏览目录，查看当前目录下的文件和文件名

　　chmod 修改文件权限

　　chown 改变文件所有者

　　cp 复制文件

　　cd 改变当前目录

　　mv 重命名文件或移动文件

　　rm 删除文件或者目录

　　pwd 当前目录

　　scp 远程拷贝

　　alias 别名

　　3、其他命令

　　ln 在文件之间建立链接

　　tail 输出文件内容后面的部分，一般我们会通过tail -f 实时查看当前程序打印的日志。

　　type 查看一个命令所在路径

　　wc 查看行数

　　grep 在文件内容中查找

　　find 查找文件

　　date 查看日期

　　crontab 制定计划任务，通常用于系统监控。

　　df 查看磁盘剩余空间，你最好在crontab中写个脚本监控磁盘的空间。超过90％就给相关的人员发email。

　　ps 查看进程状态

　　top 查看CPU的使用率

　　kill 终止进程

　　killall java程序员最喜欢用killall -9 java吧

　　w 查看登录用户和他们正在做什么，也可以看看系统的load。load太高，就该找找原因了。

　　who 查看当前用户的便当情况

　　tar 解压或压缩文件

　　echo 控制台输出

　　wget http访问

　　rpm rpm包管理

　　4、重定向、管道

　　5、标准输出、标准错误

　　6、使用屏蔽一个特殊字符的含义

　　7、正则表达式

　　二、熟练掌握vim编辑器

　　三、liunx环境下shell脚本、perl脚本的编写

　　为了对网上服务器应用进行管理，通常需要编写一些脚本。

　　脚本的编写重点掌握下面几点：

　　1、理解双引号、单引号、反引号的含义。

　　2、反斜线的使用。

　　3、shell脚本赋值语句左边的变量名不要加上$，常写perl脚本的常犯此错误。

　　4、字符串比较长，含有空格的时候，作为一个参数时脚本出错，用双引号把字符串括起来。

　　5、掌握好awk和sed的用法。

　　四、基本软件包的安装

　　apache、resin、mysql

　　一般的步骤就是：

　　configure

　　make

　　make install

首先是模块化特性：如果您安装和使用过NetBeans6.7的话，是不是会有一个很大的感觉，就是NetBeans6.7的启动速度比以前快了很多，当然并不是NetBeans已经使用了Java7，而是NetBeans将以前一启动就加载的功能划分成了很多的模块，第一次安装启动的时候，很多模块都没有加载，只是加载了一些最基本的功能模块，在随后的使用过程中，如果用到了某一种功能，就启用相应的模块，这样形成了一个按需加载的特点，当然随着加载的模块数量增加，启动的速度也会随之变慢。不过除非你要用其中的所有模块，否则总是比之前的版本速度要快。现在的 Java7也是采用了模块的划分方式来提速，一些不是必须的模块并没有下载和安装，因此在使用全新的Java7的虚拟机的时候会发现真的很快，当虚拟机需要用到某些功能的时候，再下载和启用相应的模块，这样使得最初需要下载的虚拟机大小得到了有效的控制。同时对启动速度也有了很大的改善。如果你对 OpenJDK的架构比较熟悉，你甚至可以定制JDK的模块。

其次是多语言支持：这里的多语言不是指中文英文之类的语言，而是说Java7的虚拟机对多种动态程序语言增加了支持，比如：Rubby、 Python等等。对这些动态语言的支持极大地扩展了Java虚拟机的能力。对于那些熟悉这些动态语言的程序员而言，在使用Java虚拟机的过程中同样可以使用它们熟悉的语言进行功能的编写，而这些语言是跑在功能强大的JVM之上的。

再有是开发者的开发效率得到了改善：Java7通过多种特性来增强开发效率。比如对语言本身做了一些细小的改变来简化程序的编写，在多线程并发与控制方面：轻量级的分离与合并框架，一个支持并发访问的HashMap等等。通过注解增强程序的静态检查。提供了一些新的API用于文件系统的访问、异步的输入输出操作、Socket通道的配置与绑定、多点数据包的传送等等。

最后是执行效率的提高，也是给人感觉最真切体验的特性：压缩了64位的对象指针，Java7通过对对象指针由64位压缩到与32位指针相匹配的技术使得内存和内存带块的消耗得到了很大的降低因而提高了执行效率。此外还提供了新的垃圾回收机制（G1）来降低垃圾回收的负载和增强垃圾回收的效果。G1垃圾回收机制拥有更低的暂停率和更好的可预测性。

其实如上的这些特性是在告诉我们，Java7改善了什么，速度为什么快了，当然这些特性将随着Java7的正式版发布而继续凸显其优势。

1. Set up the installed JRE in eclipse (Windows -> Preferences -> Java -> Installed JREs)

2. Set up the installed runtime for server in eclipse (Windows -> Preferences -> Server -> Installed Runtimes)

3. Set up the Server view in eclipse (Windows -> Show View -> Other)

4. Set up the Tomcat Server by right clicking and selecting New -> Server option from the Server view in eclipse

?span style="font:7.0pt "Times New Roman"">         Creating a Web service

1. Create a new Dynamic Web Project in eclipse (File -> New -> Other)

2. Enter name as 揥ebServiceTutorial? select project location as 揈:"Test? and select Apache Tomcat v5.5 as the Target server.

3. Now create a new Java class from the Project Explorer (Dynamic Web Projects -> Java Source -> New -> Class)

4. Enter name as 揌ello?and package as 揷om.tutorial?

5. Add a simple method in the 揌ello?class as below.

            public String sayHello(String name){

                        return "Hello " + name;

            }            

6. Save and build the project.
7. Create a new Web service in eclipse (File -> New -> Other)

8. Select Generate a proxy.
9. Select Test the Web service.
10. Select Overwrite files without warning.

11. Select or enter the Bean name as 揷om.tutorial.Hello? This is the java class that we just now created.

12. Continue the wizard by clicking Next and finish.
13. On Finish, the Tomcat server starts up and launches the Test client.
14. Verify the generated contents. Look for Hello.class and the generated JSPs as below.

15. Verify the Tomcat folder and ensure the newly created web applications ? WebServiceTutorial, WebServiceTutorialClient.

16. We can also run the following url from the browser to access/test the Web service.

http://localhost:8080/WebServiceTutorialClient/sampleHelloProxy/TestClient.jsp

17. If servlet error 搊rg.eclipse.jst.ws.util.JspUtils cannot be resolved or is not a type?is thrown on the browser, then copy the webserviceutils.jar file from the E:"Eclipse3.1"eclipse"plugins"org.eclipse.jst.ws.consumption_0.7.0 into the WEB-INF"lib folder of the WebServiceTutorialClient application and restart the Tomcat server.

18. The browser displays the methods available in the web service.

19. Click on the sayHello(..) method, enter your name (for e.g. 揓eeva? in the inputs section and click 揑nvoke?

20. The browser greets using the web service.

21. The WSDL for the Hello Web service can be found in E:"Test"WebServiceTutorial"WebContent"wsdl"Hello.wsdl. On double-click, the WSDL opens in a graphical editor.

22. Right-click on the WSDL file and explore the options to test the web service / publish the WSDL file / generate client / etc.

1.       功能测试

2.       性能测试（包括负载/压力测试）

3.       用户界面测试

4.       兼容性测试

5.       安全测试

6.       接口测试

本文的目的是覆盖 web 测试的各个方面，未就某一主题进行深入说明。

1 功能测试

1.1 链接测试

链接是Web应用系统的一个主要特征，它是在页面之间切换和指导用户去一些不知道地址的页面的主要手段。链接测试可分为三个方面。首先，测试所有链接是否按指示的那样确实链接到了该链接的页面；其次，测试所链接的页面是否存在；最后，保证Web应用系统上没有孤立的页面，所谓孤立页面是指没有链接指向该页面，只有知道正确的URL地址才能访问。

链接测试可以自动进行，现在已经有许多工具可以采用。链接测试必须在集成测试阶段完成，也就是说，在整个Web应用系统的所有页面开发完成之后进行链接测试。

采取措施：采用自动检测网站链接的软件来进行。

推荐软件：

Xenu Link Sleuth 免费 绿色免安装软件

HTML Link Validator 共享（30天试用）

1.2 表单测试

当用户通过表单提交信息的时候，都希望表单能正常工作。

如果使用表单来进行在线注册，要确保提交按钮能正常工作，当注册完成后应返回注册成功的消息。如果使用表单收集配送信息，应确保程序能够正确处理这些数据，最后能让顾客能让客户收到包裹。要测试这些程序，需要验证服务器能正确保存这些数据，而且后台运行的程序能正确解释和使用这些信息。

当用户使用表单进行用户注册、登陆、信息提交等操作时，我们必须测试提交操作的完整性，以校验提交给服务器的信息的正确性。例如：用户填写的出生日期与职业是否恰当，填写的所属省份与所在城市是否匹配等。如果使用了默认值，还要检验默认值的正确性。如果表单只能接受指定的某些值，则也要进行测试。例如：只能接受某些字符，测试时可以跳过这些字符，看系统是否会报错。

1.3 数据校验

如果系根据业务规则需要对用户输入进行校验，需要保证这些校验功能正常工作。例如，省份的字段可以用一个有效列表进行校验。在这种情况下，需要验证列表完整而且程序正确调用了该列表(例如在列表中添加一个测试值，确定系统能够接受这个测试值)。

在测试表单时，该项测试和表单测试可能会有一些重复。

1.2和1.3的采取措施：第一个完整的版本采用手动检查，同时形成WinRunner（QTP）脚本；回归测试以及升级版本主要靠WinRunner（QTP）自动回放测试。

1.4 cookies测试

Cookies通常用来存储用户信息和用户在某应用系统的操作，当一个用户使用Cookies访问了某一个应用系统时，Web服务器将发送关于用户的信息，把该信息以Cookies的形式存储在客户端计算机上，这可用来创建动态和自定义页面或者存储登陆等信息。
如果Web应用系统使用了Cookies，就必须检查Cookies是否能正常工作。测试的内容可包括Cookies是否起作用，是否按预定的时间进行保存，刷新对Cookies有什么影响等。如果在 cookies 中保存了注册信息，请确认该 cookie能够正常工作而且已对这些信息已经加密。如果使用 cookie 来统计次数，需要验证次数累计正确。

采取措施：

     1 采用黑盒测试：采用上面提到的方法进行测试

2 采用查看cookies的软件进行（初步的想法）

可以选择采用的软件

IECookiesView v1.50

Cookies Manager v1.1

1.5 数据库测试

在Web应用技术中，数据库起着重要的作用，数据库为Web应用系统的管理、运行、查询和实现用户对数据存储的请求等提供空间。在Web应用中，最常用的数据库类型是关系型数据库，可以使用SQL对信息进行处理。

在使用了数据库的Web应用系统中，一般情况下，可能发生两种错误，分别是数据一致性错误和输出错误。数据一致性错误主要是由于用户提交的表单信息不正确而造成的，而输出错误主要是由于网络速度或程序设计问题等引起的，针对这两种情况，可分别进行测试。

采取措施：暂时没有更好的测试方法

     考虑结合到1.2和1.3的测试中

1.6 应用程序特定的功能需求

最重要的是，测试人员需要对应用程序特定的功能需求进行验证。尝试用户可能进行的所有操作：下订单、更改订单、取消订单、核对订单状态、在货物发送之前更改送货信息、在线支付等等。这是用户之所以使用网站的原因，一定要确认网站能像广告宣传的那样神奇。

采取措施：深刻理解需求说明文档

1.7 设计语言测试

Web设计语言版本的差异可以引起客户端或服务器端严重的问题，例如使用哪种版本的HTML等。当在分布式环境中开发时，开发人员都不在一起，这个问题就显得尤为重要。除了HTML的版本问题外，不同的脚本语言，例如Java、JavaScript、 ActiveX、VBScript或Perl等也要进行验证。

暂时没有方法测试，可以多参考一点讨论组内的更新信息

　  无论你在测试 internet、intranet 或者是 extranet 应用程序，web 测试相对于非 web 测试来说都是更具挑战性的工作。用户对 web 页面质量有很高的期望。在很多情况下，就像业务功能一样，页面用于维护和发展公共关系，所以第一印象非常重要。

usr/home/zk1007874/htdocs/upload_files/images

 
方案二： 
使用一个能操作两个数据库的账号，在?.hbm.xml映射文件中的class标签中指定catalog为数据库名

使用例子：
  1.web.xml配置
  <filter>
        <filter-name>Filter_name</filter-name>
        <filter-class>Filter_class_name</filter-class>
        <init-param>
            <description>set 'true' to enable the filter</description>
            <param-name>enabled</param-name>
            <param-value>true</param-value>
        </init-param>
  <init-param>
         <param-name>excepts</param-name>
   <param-value>Excepts_Path</param-value>
        </init-param>
    </filter>
 <filter-mapping>
     <filter-name>Filter_name</filter-name>
     <url-pattern>filter_path</url-pattern>
    </filter-mapping>
    <filter-mapping>
        <filter-name>Filter_name</filter-name>
        <url-pattern>filter_path</url-pattern>
    </filter-mapping>

   2、java代码
 
 2.1 init 函数
 public void init(FilterConfig filterConfig) throws ServletException {

        //检查是否打开SSOFilter功能
        String _enable = filterConfig.getInitParameter("enabled");
        if (_enable != null && "true".equalsIgnoreCase(_enable)) {
            enabled = true;
        }

        //初始化例外列表，即不经过SSOFilter的请求地址
        String _exceptStr = filterConfig.getInitParameter("excepts");
        if (_exceptStr != null) {
            String[] _excepts = _exceptStr.split(",");
            for (int i = 0; i < _excepts.length; i ++) {
                excepts.add(_excepts[i]);
            }
        }
      }
 
 2.2 doFilter函数
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
                         FilterChain chain) throws IOException, ServletException {

        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        String path = request.getServletPath();

        /**
         * 当WEB程序启了SSOFilter，并且请求的路径没被配置为例外时，
         * 检查用户是否已通过统一用户平台登录，已登录的话创建会话，否则转到统一登录页面。
         */
        if (enabled && !excepts.contains(path)) {

            if (logger.isDebugEnabled()) {
                logger.debug("check member has signoned ...");
            }

            boolean signOned = SSOHelper.hasSignOned(request, response);

            if (logger.isDebugEnabled()) {
                logger.debug("Signoned? " + signOned);
            }

            if (!signOned) {
                String SSOContextUri = SysParamHelper.getSysParam(SysParamConstants.CONTEXT_URI_SSO);
                StringBuffer url = new StringBuffer(SSOContextUri);
                url.append("/Login");
                //记住入口地址
                url.append("?entrance=");
                url.append(request.getRequestURL());
                if (request.getQueryString() != null) {
                    url.append("|");
                    url.append(request.getQueryString());
                }
                response.sendRedirect(url.toString());
                return;
            }
        }
         chain.doFilter(servletRequest, servletResponse);
       }

获取web服务器所在的真实路径
request.getContextPath();

1.熟悉SAAS产品

IT人员配备和随需应变的咨询公司Bluewolf的共同创始人和负责人Michael Kirven说，SAAS（软件服务）知识在用人要求条件中的比例已经从三年前的5%提高到了35%。拥有这方面知识的人可能很快提高自己的薪酬，无论他们是否知道alesforce、Google Apps或者WorkDay。每一个人都需要知道这些产品如何适合当前的IT架构。

2.获得SAP知识或者经验

位于费城的人才和外包服务公司Yoh Services复杂战略和营销的副总裁Jim Lanzalotto称，他支持拥有SAP技术的人，因为SAP技术顾问的需求量和现有人员之间的缺口有3至4万。

3.获得一个行业的垂直的技术专长

Kirven说，做一个Java程序员或者一个熟练的.Net开发人员就是一件很好的事情。但是，随着系统越来越复杂，企业不仅需要这些人学些这些编程语言，而且还要了解具体的垂直市场知识，如金融、零售或者媒体，并且了解所有这些知识。

4.获得一个虚拟化项目

IT job board Dice网站称，它看到招聘列表中对虚拟化知识人才的需求在过去的六个月里提高了40%，特别是需要了解VMware技术的人。

5.提高你的商务技能

Lanzalotto认为，商务经验对于提高IT专业人员的薪金水平是非常重要的。他说，最好的首席信息官不仅仅是一个技术人员，而且应该是能够在技术和业务两个方面都能够工作的业务人员。

6.获得开源软件产品开发经验

Kirven说，由于时代已经发生了变化，首席信息官采用MySQL和其它开源软件技术不会有失去工作的风险。事实上，业务人员经常会喜欢开源软件，因为它可能为公司省钱。

7.更近一步了解能够让你的公司赚钱的技术

在大型银行或者金融机构工作的人都知道你越接近能够让你的公司赚钱的技术，你的工作岗位对于你的公司就越重要。IT人员也是如此。参与让你的公司增加收入或者节省金钱的项目的IT人员很少会被人忽略。

8.首席信息官需要架构技能

Kirven称，IT架构是一个极好的职场道路，不仅因为这是一个高级的职位，而且还因为这些职位几乎完全是不会外包出去的。

9.付费参加项目管理认证学习的人

许多研究报名，虽然并非所有的证书都比印刷证书的成本值钱，但是，企业继续付出高价的费用聘用拥有关键证书的人才。其中最最主要的两个项目管理证书是PMP（项目管理专业人员）和PMO（项目管理办公室）。

10.跳槽

IT专业人员从一个地方搬迁的另一个地方的比例提高了20%。当你在你的技术专长领域寻求进一步发展时，换一个地理环境也许会有帮助。不同地区对于IT专业人员的技术需求是不同的

public class MysqlJdbc {
  public static void main(String args[]) {
    try {
      Class.forName("org.gjt.mm.mysql.Driver");     //加载MYSQL JDBC驱动程序  
      System.out.println("Success loading Mysql Driver!");
    }
    catch (Exception e) {
      System.out.print("Error loading Mysql Driver!");
      e.printStackTrace();
    }

    try {
      Connection connect = DriverManager.getConnection(
          "jdbc:mysql://localhost/catmiw", "root", "");
//连接URL为   jdbc:mysql//服务器地址/数据库名
//后面的2个参数分别是登陆用户名和密码
      System.out.println("Success connect Mysql server!");

      Statement stmt = connect.createStatement();
      ResultSet rs = stmt.executeQuery("select * from pet");
      while (rs.next()) {
        System.out.println(rs.getString("name"));

      }
    }
    catch (Exception e) {
      System.out.print("get data error!");
      e.printStackTrace();
    }
  }
}

程序运行结果如下：
Success loading Mysql Driver!
Success connect Mysql server!
a dog

Hibernate提供了异常强大的查询体系，使用Hibernate有多种查询方式。可以选择使用Hibernate的HQL查询，或者使用条件查询，甚至可以使用原生的SQL查询语句，此外还提供了一种数据过滤功能，这些都可用于筛选目标数据。

下面分别介绍Hibernate的4种数据筛选方法：

4.3.1 HQL查询

HQL是Hibernate Query Language的缩写，HQL的语法很像SQL的语法，但HQL是一种面向对象的查询语言。因此，SQL的操作对象是数据表和列等数据对象，而HQL的操作对象是类、实例、属性等。

HQL是完全面向对象的查询语言，因此可以支持继承和多态等特征。

HQL查询依赖于Query类，每个Query实例对应一个查询对象。使用HQL查询可按如下步骤进行：

（1）获取Hibernate Session对象；

（2）编写HQL语句；

（3）以HQL语句作为参数，调用Session的createQuery方法创建查询对象；

（4）如果HQL语句包含参数，调用Query的setXxx方法为参数赋值；

（5）调用Query对象的list等方法遍历查询结果。

看下面的查询示例：

public class HqlQuery

{

    public static void main(String[] args)throws Exception

    {

        HqlQuery mgr = new HqlQuery();

        //调用查询方法

        mgr.findPersons();

        //调用第二个查询方法

        mgr.findPersonsByHappenDate();

        HibernateUtil.sessionFactory.close();

    }

    //第一个查询方法

    private void findPersons()

    {

        //获得Hibernate Session

        Session sess = HibernateUtil.currentSession();

        //开始事务

        Transaction tx = sess.beginTransaction();

        //以HQL语句创建Query对象.

        //执行setString方法为HQL语句的参数赋值

        //Query调用list方法访问查询的全部实例

        List pl = sess.createQuery("from Person p where p.myEvents.title

        = :eventTitle")

                        .setString("eventTitle","很普通事情")

                        .list();

        //遍历查询的全部结果

        for (Iterator pit = pl.iterator() ; pit.hasNext(); )

        {

            Person p = ( Person )pit.next();

            System.out.println(p.getName());

        }

        //提交事务

        tx.commit();

        HibernateUtil.closeSession();

    }

    //第二个查询方法

    private void findPersonsByHappenDate()throws Exception

    {

        //获得Hibernate Session对象

        Session sess = HibernateUtil.currentSession();

        Transaction tx = sess.beginTransaction();

        //解析出Date对象

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        Date start = sdf.parse("2005-01-01");

        System.out.println("系统开始通过日期查找人" + start);

        //通过Session的createQuery方法创建Query对象

        //设置参数

        //返回结果集

        List pl = sess.createQuery(

            "from Person p where p.myEvents.happenDate between :firstDate

            and :endDate")

                        .setDate("firstDate",start)

                        .setDate("endDate",new Date())

                        .list();

        //遍历结果集

        for (Iterator pit = pl.iterator() ; pit.hasNext(); )

        {

            Person p = ( Person )pit.next();

            System.out.println(p.getName());

        }

        tx.commit();

        HibernateUtil.closeSession();

    }

}

通过上面的示例程序，可看出查询步骤基本相似。Query对象可以连续多次设置参数，这得益于Hibernate Query的设计。

通常，setXxx方法的返回值都是void，但Hibernate Query的setXxx方法返回值是Query本身。因此，程序通过Session创建Query后，直接多次调用setXxx方法为HQL语句的参数赋值，再直接调用list方法返回查询到的全部结果即可。

Query还包含两个方法：

   ● setFirstResult（int firstResult），设置返回的结果集从第几条记录开始。

   ● setMaxResults（int maxResults），设置本次查询返回的结果数。

这两个方法用于实现Hibernate分页。

下面简单介绍HQL语句的语法。

HQL语句本身是不区分大小写的。也就是说，HQL语句的关键字和函数都是不区分大小写的。但HQL语句中所使用的包名、类名、实例名和属性名都区分大小写。

4.3.2 HQL查询的from子句

from子句是最简单的HQL语句，也是最基本的HQL语句。from关键字后紧跟持久化类的类名。例如：

from Person

表明从Person持久化类中选出全部的实例。

大部分时候，推荐为该Person的每个实例起别名。例如：

from Person as p

在上面的HQL语句中，Person持久化类中的实例的别名为p，既然 p是实例名，因此也应该遵守Java的命名规则：第一个单词的首字母小写，后面每个单词的首字母大写。

命名别名时，as关键字是可选的，但为了增加可读性，建议保留。

from后还可同时出现多个持久化类，此时将产生一个笛卡儿积或跨表的连接。

4.3.3 HQL查询的select子句

select子句用于确定选择出的属性，当然select选择的属性必须是from后持久化类包含的属性。例如：

select p.name from Person as p

select可以选择任意属性，不仅可以选择持久化类的直接属性，还可以选择组件属性包含的属性，例如：

select p.name.firstName from Person as p

select也支持将选择出的属性存入一个List对象中，例如：

select new list(p.name , p.address) from Person as p

甚至可以将选择出的属性直接封装成对象，例如：

select new ClassTest(p.name , p.address) from Person as p

前提是ClassTest支持p.name和p.address的构造器，假如p.name的数据类型是           String，p.address的数据类型是String，则ClassTest必须有如下的构造器：

ClassTest(String s1, String s2)

select还支持给选中的表达式命名别名，例如：

select p.name as personName from Person as p

这种用法与new map结合使用更普遍。如：

select new map(p.name as personName) from Person as p

在这种情形下，选择出的是Map结构，以personName为key，实际选出的值作为value。

4.3.4 HQL查询的聚集函数

HQL也支持在选出的属性上，使用聚集函数。HQL支持的聚集函数与SQL完全相同，有如下5个：

   ● avg，计算属性平均值。

   ● count，统计选择对象的数量。

   ● max，统计属性值的最大值

   ● min，统计属性值的最小值。

   ● sum，计算属性值的总和。

例如：

select count(_*) from Person

select max(p.age) from Person as p

select子句还支持字符串连接符、算术运算符以及SQL函数。如：

select p.name || "" || p.address from Person as p

select子句也支持使用distinct和all关键字，此时的效果与SQL中的效果完全相同。

4.3.5 多态查询

HQL语句被设计成能理解多态查询，from后跟的持久化类名，不仅会查询出该持久化类的全部实例，还会查询出该类的子类的全部实例。

如下面的查询语句：

from Person as p

该查询语句不仅会查询出Person的全部实例，还会查询出Person的子类，如Teacher的全部实例，前提是Person和Teacher完成了正确的继承映射。

HQL支持在from子句中指定任何Java类或接口，查询会返回继承了该类的持久化子类的实例或返回实现该接口的持久化类的实例。下面的查询语句返回所有被持久化的对象：

from java.lang.Object o

如果Named接口有多个持久化类，下面的语句将返回这些持久化类的全部实例：

from Named as n

注意：后面的两个查询将需要多个SQL SELECT语句，因此无法使用order by子句对结果集进行排序，从而，不允许对这些查询结果使用Query.scroll()方法。

4.3.6 HQL查询的where子句

where子句用于筛选选中的结果，缩小选择的范围。如果没有为持久化实例命名别名，可以直接使用属性名引用属性。

如下面的HQL语句：

from Person where name like 'tom%'

上面HQL语句与下面的语句效果相同：

from Person as p where p.name like "tom%"

在后面的HQL语句中，如果为持久化实例命名了别名，则应该使用完整的属性名。两个HQL语句都可返回name属性以tom开头的实例。

复合属性表达式加强了where子句的功能，例如如下HQL语句：

from Cat cat where cat.mate.name like "kit%"

该查询将被翻译成为一个含有内连接的SQL查询，翻译后的SQL语句如下：

select _* from cat_table as table1 cat_table as table2 where table1.mate =

table2.id and table1.name like "kit%"

再看下面的HQL查询语句：

from Foo foo where foo.bar.baz.customer.address.city like"guangzhou%"

翻译成SQL查询语句，将变成一个四表连接的查询。

=运算符不仅可以被用来比较属性的值，也可以用来比较实例：

from Cat cat, Cat rival where cat.mate = rival.mate

select cat, mate

from Cat cat, Cat mate

where cat.mate = mate

特殊属性（小写）id可以用来表示一个对象的标识符。（也可以使用该对象的属性名。）

from Cat as cat where cat.id = 123

from Cat as cat where cat.mate.id = 69

第二个查询是一个内连接查询，但在HQL查询语句下，无须体会多表连接，而完全使用面向对象方式的查询。

id也可代表引用标识符。例如，Person类有一个引用标识符，它由country属性 与medicareNumber两个属性组成。

下面的HQL语句有效：

from Person as person

where person.id.country = 'AU'

    and person.id.medicareNumber = 123456

from Account as account

where account.owner.id.country = 'AU'

    and account.owner.id.medicareNumber = 123456

第二个查询跨越两个表Person和Account。是一个多表连接查询，但此处感受不到多表连接查询的效果。

在进行多态持久化的情况下，class关键字用来存取一个实例的鉴别值（discriminator value）。嵌入where子句中的Java类名，将被作为该类的鉴别值。例如：

from Cat cat where cat.class = DomesticCat

where子句中的属性表达式必须以基本类型或java.lang.String结尾，不要使用组件类型属性结尾，例如Account有Person属性，而Person有Name属性，Name有firstName属性。

看下面的情形：

from Account as a where a.person.name.firstName like "dd%" //正确

from Account as a where a.person.name like "dd%" //错误

4.3.7 表达式

HQL的功能非常丰富，where子句后支持的运算符异常丰富，不仅包括SQL的运算符，还包括EJB-QL的运算符等。

where子句中允许使用大部分SQL支持的表达式：

   ● 数学运算符+、–、_*、/ 等。

   ● 二进制比较运算符=、>=、<=、<>、!=、like等。

   ● 逻辑运算符and、or、not等。

   ● in、not in、between、is null、is not null、is empty、is not empty、member of和not member of等。

   ● 简单的case、case ... when ... then ... else ... end和case、case when ... then ... else ...       end等。

   ● 字符串连接符value1 || value2或使用字符串连接函数concat(value1 , value2)。

   ● 时间操作函数current_date()、current_time()、current_timestamp()、second()、minute()、hour()、day()、month()、year()等。

   ● HQL还支持EJB-QL 3.0所支持的函数或操作substring()、trim()、lower()、upper()、length()、locate()、abs()、sqrt()、bit_length()、coalesce()和nullif()等。

   ● 还支持数据库的类型转换函数，如cast(... as ...)，第二个参数是Hibernate的类型名，或者extract(... from ...)，前提是底层数据库支持ANSI cast() 和extract()。

   ● 如果底层数据库支持如下单行函数sign()、trunc()、rtrim()、sin()。则HQL语句也完全可以支持。

   ● HQL语句支持使用？作为参数占位符，这与JDBC的参数占位符一致，也可使用命名参数占位符号，方法是在参数名前加冒号 :，例如 :start_date和:x1等。

   ● 当然，也可在where子句中使用SQL常量，例如'foo'、69、'1970-01-01 10:00:         01.0'等。

   ● 还可以在HQL语句中使用Java public static final 类型的常量，例如eg.Color.TABBY。

除此之外，where子句还支持如下的特殊关键字用法。

   ● in与between...and可按如下方法使用：

from DomesticCat cat where cat.name between 'A' and 'B'

from DomesticCat cat where cat.name in ( 'Foo','Bar','Baz')

   ● 当然，也支持not in和not between...and的使用，例如：

from DomesticCat cat where cat.name not between 'A' and 'B'

from DomesticCat cat where cat.name not in ( 'Foo','Bar','Baz' )

   ● 子句is null与is not null可以被用来测试空值，例如：

from DomesticCat cat where cat.name is null;

from Person as p where p.address is not null;

如果在Hibernate配置文件中进行如下声明：

<property name="hibernate.query.substitutions">true 1, false 0</property>

上面的声明表明，HQL转换SQL语句时，将使用字符1和0来取代关键字true和false。然后将可以在表达式中使用布尔表达式，例如：

from Cat cat where cat.alive = true

   ● size关键字用于返回一个集合的大小，例如：

from Cat cat where cat.kittens.size > 0

from Cat cat where size(cat.kittens) > 0

   ● 对于有序集合，还可使用minindex与maxindex函数代表最小与最大的索引序数。同理，可以使用minelement与maxelement函数代表集合中最小与最大的元素。         例如：

from Calendar cal where maxelement(cal.holidays) > current date

from Order order where maxindex(order.items) > 100

from Order order where minelement(order.items) > 10000

   ● 可以使用SQL函数any、some、all、exists、in操作集合里的元素，例如：

//操作集合元素

select mother from Cat as mother, Cat as kit

where kit in elements(foo.kittens)

//p的name属性等于集合中某个元素的name属性

select p from NameList list, Person p

where p.name = some elements(list.names)

//操作集合元素

from Cat cat where exists elements(cat.kittens)

from Player p where 3 > all elements(p.scores)

from Show show where 'fizard' in indices(show.acts)

注意这些结构变量size、elements、indices、minindex、maxindex、minelement、maxelement 等，只能在where子句中使用。

   ● where子句中，有序集合的元素（arrays, lists, maps）可以通过[ ]运算符访问。例如：

//items是有序集合属性，items[0]代表第一个元素

from Order order where order.items[0].id = 1234

//holidays是map集合属性，holidays[national day]代表其中一个元素

select person from Person person, Calendar calendar

where calendar.holidays['national day'] = person.birthDay

and person.nationality.calendar = calendar

//下面同时使用list 集合和map集合属性

select item from Item item, Order order

where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11

select item from Item item, Order order

where order.items[ maxindex(order.items) ] = item and order.id = 11

在[]中的表达式甚至可以是一个算术表达式，例如：

select item from Item item, Order order

where order.items[ size(order.items) - 1 ] = item

借助于HQL，可以大大简化选择语句的书写，提高查询语句的可读性，看下面的HQL语句：

select cust

from Product prod,

    Store store

    inner join store.customers cust

where prod.name = 'widget'

    and store.location.name in ( 'Melbourne', 'Sydney' )

    and prod = all elements(cust.currentOrder.lineItems)

如果翻译成SQL语句，将变成如下形式：

SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order

FROM customers cust,

    stores store,

    locations loc,

    store_customers sc,

    product prod

WHERE prod.name = 'widget'

    AND store.loc_id = loc.id

    AND loc.name IN ( 'Melbourne', 'Sydney' )

    AND sc.store_id = store.id

    AND sc.cust_id = cust.id

    AND prod.id = ALL(

        SELECT item.prod_id

        FROM line_items item, orders o

        WHERE item.order_id = o.id

            AND cust.current_order = o.id

    )

4.3.8 order by子句

查询返回的列表(list)可以根据类或组件属性的任何属性进行排序，例如：

from Person as p

order by p.name, p.age

还可使用asc或desc关键字指定升序或降序的排序规则，例如：

from Person as p

order by p.name asc , p.age desc

如果没有指定排序规则，默认采用升序规则。即是否使用asc关键字是没有区别的，加asc是升序排序，不加asc也是升序排序。

4.3.9 group by子句

返回聚集值的查询可以对持久化类或组件属性的属性进行分组，分组所使用的group by子句。看下面的HQL查询语句：

select cat.color, sum(cat.weight), count(cat)

from Cat cat

group by cat.color

类似于SQL的规则，出现在select后的属性，要么出现在聚集函数中，要么出现在group by的属性列表中。看下面示例：

//select后出现的id出现在group by之后，而name属性则出现在聚集函数中

select foo.id, avg(name), max(name)

from Foo foo join foo.names name

group by foo.id

having子句用于对分组进行过滤，如下：

select cat.color, sum(cat.weight), count(cat)

from Cat cat

group by cat.color

having cat.color in (eg.Color.TABBY, eg.Color.BLACK)

注意：having子句用于对分组进行过滤，因此having子句只能在有group by子句时才可以使用，没有group by子句，不能使用having子句。

Hibernate的HQL语句会直接翻译成数据库SQL语句。因此，如果底层数据库支持的having子句和group by子句中出现一般函数或聚集函数，HQL语句的having子句和order by 子句中也可以出现一般函数和聚集函数。

例如：

select cat

from Cat cat

join cat.kittens kitten

group by cat

having avg(kitten.weight) > 100

order by count(kitten) asc, sum(kitten.weight) desc

注意：group by子句与 order by子句中都不能包含算术表达式。

4.3.10 子查询

如果底层数据库支持子查询，则可以在HQL语句中使用子查询。与SQL中子查询相似的是，HQL中的子查询也需要使用()括起来。如：

from Cat as fatcat

where fatcat.weight > ( select avg(cat.weight) from DomesticCat cat )

如果select中包含多个属性，则应该使用元组构造符：

from Cat as cat

where not ( cat.name, cat.color ) in (

    select cat.name, cat.color from DomesticCat cat

)

4.3.11 fetch关键字

对于集合属性，Hibernate默认采用延迟加载策略。例如，对于持久化类Person，有集合属性scores。加载Person实例时，默认不加载scores属性。如果Session被关闭，Person实例将无法访问关联的scores属性。

为了解决该问题，可以在Hibernate映射文件中取消延迟加载或使用fetch join，例如：

from Person as p join p.scores

上面的fetch语句将会初始化person的scores集合属性。

如果使用了属性级别的延迟获取，可以使用fetch all properties来强制Hibernate立即抓取那些原本需要延迟加载的属性，例如：

from Document fetch all properties order by name

from Document doc fetch all properties where lower(doc.name) like '%cats%'

4.3.12 命名查询

HQL查询还支持将查询所用的HQL语句放入配置文件中，而不是代码中。通过这种方式，可以大大提供程序的解耦。

使用query元素定义命名查询，下面是定义命名查询的配置文件片段：

<!-- 定义命名查询 -->

<query name="myNamedQuery">

    <!-- 此处确定命名查询的HQL语句 -->

    from Person as p where p.age > ?

</query>

该命名的HQL查询可以直接通过Session访问，调用命名查询的示例代码如下：

private void findByNamedQuery()throws Exception

{

    //获得Hibernate Session对象

    Session sess = HibernateUtil.currentSession();

    //开始事务

    Transaction tx = sess.beginTransaction();

    System.out.println("执行命名查询");

    //调用命名查询

    List pl = sess.getNamedQuery("myNamedQuery")

                        //为参数赋值

                       .setInteger(0 , 20)

                        //返回全部结果

                       .list();

    //遍历结果集

    for (Iterator pit = pl.iterator() ; pit.hasNext(); )

    {

        Person p = ( Person )pit.next();

        System.out.println(p.getName());

    }

    //提交事务

    tx.commit();

    HibernateUtil.closeSession();

}

　　可以说，一个框架是一个可复用的设计构件，它规定了应用的体系结构，阐明了整个设计、协作构件之间的依赖关系、责任分配和控制流程，表现为一组抽象类以及其实例之间协作的方法，它为构件复用提供了上下文(Context)关系。因此构件库的大规模重用也需要框架。

　　构件领域框架方法在很大程度上借鉴了硬件技术发展的成就，它是构件技术、软件体系结构研究和应用软件开发三者发展结合的产物。在很多情况下，框架通常以构件库的形式出现，但构件库只是框架的一个重要部分。框架的关键还在于框架内对象间的交互模式和控制流模式。

　　框架比构件可定制性强。在某种程度上，将构件和框架看成两个不同但彼此协作的技术或许更好。框架为构件提供重用的环境，为构件处理错误、交换数据及激活操作提供了标准的方法。

　　应用框架的概念也很简单。它并不是包含构件应用程序的 小片程序，而是实现了某应用领域通用完备功能(除去特殊应用的部分)的底层服务。使用这种框架的编程人员可以在一个通用功能已经实现的基础上开始具体的系 统开发。框架提供了所有应用期望的默认行为的类集合。具体的应用通过重写子类(该子类属于框架的默认行为)或组装对象来支持应用专用的行为。

　　应用框架强调的是软件的设计重用性和系统的可扩充性，以缩短大型应用软件系统的开发周期，提高开发质量。与传统的基于类库的面向对象重用技术比较，应用框架更注重于面向专业领域的软件重用。应用框架具有领域相关性，构件根据框架进行复合而生成可运行的系统。框架的粒度越大，其中包含的领域知识就更加完整。

　　框架，即framework.其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。

　　框架的概念最早起源于Smalltalk环境，其中最著名的框架是Smalltalk 80的用户界面框架MVC(Model -View-Controller)。随着用户界面框架Interviews [Linton 89]和ET++ [Weinand 89] 的开发和发布，框架研究越来越受到研究人员的重视。虽然框架研究最初起源于用户界面领域，但它还被成功地应用到其他领域中，如操作系统[Russo 90]、火警系统 [Molin 96a，Molin 96b] 等。Taligent公司于1992年成立后，框架研究受到了广泛的重视。该公司计划基于框架来开发一个完整的面向对象操作系统。另外，该公司还发布了一 套支持快速应用开发的工具集CommonPoint，其中包括了上百个面向对象框架 [Andert 94，Cotter 95].框架目前还没有统一的定义，其中Ralph Johnson所给出的定义基本上为大多数研究人员所接受：一个框架是一个可复用设计，它是由一组抽象类及其实例间协作关系来表达的 [Johnson 98].这个定义是从框架内涵的角度来定义框架的，当然也可以从框架用途的角度来给出框架的定义：一个框架是在一个给定的问题领域内，一个应用程序的一部分设计与实现[Bosch 97].从以上两个定义可以看出，框架是对特定应用领域中的应用系统的部分设计和实现，它定义了一类应用系统(或子系统)的整体结构。框架将应用系统划分为类和对象，定义类和对象的责任，类和对象如何互相协作，以及对象之间的控制线程。这些共有的设计因素由框架预先定义，应用开发人员只须关注于特定的应用系统特有部分。框架刻画了其应用领域所共有的设计决策，所以说框架着重于设计复用，尽管框架中可能包含用某种程序设计语言实现的具体类。

　　一个基于框架开发的应用系统包含一个或多个框架，与框架相关的构件类，以及与应用系统相关的功能扩展。与应用系统相关的扩展包括与应用系统相关的类和对象。应用系统可能仅仅复用了面向对象框架的一部分，或者说，它可能需要对框架进行一些适应性修改，以满足系统需求。

　　面向对象的框架作为一种可复用的软件，在基于框架的软件开发过程中会涉及到框架的开发和利用两个方面的工作。框架的开发阶段在于产生领域中可复用的设计。 该阶段的主要结果是框架以及与框架相关的构件类。该阶段的一个重要活动是框架的演变和维护。象所有软件一样，框架也易于变化。产生变化的原因很多，如应用 出错，业务领域变化，等等。

　　不论是哪一种技术，最终都是为业务发展而服务的。从业务的角度来讲。首先，框架的是为了企业的业务发展和战略规划而服务的，他服从于企业的愿景 (vision);其次，框架最重要的目标是提高企业的竞争能力，包括降低成本、提高质量、改善客户满意程度，控制进度等方面。最后，框架实现这一目标的 方式是进行有效的知识积累。软件开发是一种知识活动，因此知识的聚集和积累是至关重要的。框架能够采用一种结构化的方式对某个特定的业务领域进行描述，也 就是将这个领域相关的技术以代码、文档、模型等方式固化下来。

　　一、框架要解决的问题框架要解决的最重要的一个问题是技术整合的问题，在J2EE的 框架中，有着各种各样的技术，不同的软件企业需要从J2EE中选择不同的技术，这就使得软件企业最终的应用依赖于这些技术，技术自身的复杂性和技术的风险 性将会直接对应用造成冲击。而应用是软件企业的核心，是竞争力的关键所在，因此应该将应用自身的设计和具体的实现技术解耦。这样，软件企业的研发将集中在 应用的设计上，而不是具体的技术实现，技术实现是应用的底层支撑，它不应该直接对应用产生影响。

　　要理解这一点，我们来举一些例子：一个做视频流应用的软件企业，他为电广行业提供整体的解决方案。他的优势在于将各种各样的视频硬件、服务器、和管理结合起来，因此他扮演的是一个集成商的 角色。因此他的核心价值在于使用软件技术将不同的硬件整合起来，并在硬件的整合层面上提供一个统一的管理平台。所以他的精力应该放在解决两个问题：如何找到一种方法，将不同的硬件整合起来，注意，这里的整合并不是技术整合，而是一种思路上的整合。首先要考虑的绝对不是要使用什么技术，而是这些硬件需 要提供哪些服务，需要以什么样的方式进行管理。因此，这时候做的事情实际上是对领域进行建模。例如，我们定义任何一种硬件都需要提供两种能力，一种是统一 的管理接口，用于对所有硬件统一管理;另一种是服务接口，系统平台可以查询硬件所能够提供的服务，并调用这些服务。所以，设计的规范将会针对两种能力进 行。

　　另一个问题是如何描述这个管理系统的规范。你需要描述各种管理活动，以及管理中所涉及的不同实体。因为管理系统是针对硬件的管理，所以它是构架在硬件整合平台之上的。

　　在完成业务层面的设计之后，我们再来看看具体的技术实现。光有规范和设计是不够的，我们还需要选择一个优秀的技术。由于是对不同硬件的整合，我们想到采用Java提供的JMX技术。JMX技术适合用来进行系统整合，它定义了一个通用的规范，并给出了远程管理端口的一些默认实现。JMX已经经过了实践的检验，不少的应用服务器都采用了以JMX为基础的结构，例如有名的JBoss.JMX已经是一个很好的开始了，但是我们还需要在JMX的基础上再做一些工作。

　　二、什么要用框架?

　　因为软件系统发展到今天已经很复杂了，特别是服务器端软件，设计到的知识，内容，问题太多。在某些方面使用别人成熟的框架，就相当于让别人帮你完成一些基 础工作，你只需要集中精力完成系统的业务逻辑设计。而且框架一般是成熟，稳健的，他可以处理系统很多细节问题，比如，事物处理，安全性，数据流控制等问 题。还有框架一般都经过很多人使用，所以结构很好，所以扩展性也很好，而且它是不断升级的，你可以直接享受别人升级代码带来的好处。

　　框架一般处在低层应用平台(如J2EE)和高层业务逻辑之间的中间层。

　　软件为什么要分层?

　　为了实现“高内聚、低耦合”。把问题划分开来各个解决，易于控制，易于延展，易于分配资源…总之好处很多啦：)。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/whhpaccp2008/archive/2009/09/21/4576616.aspx

  所以 对于组件和服务的管理其实也有不同那个的策略，组件要管理的是软件实体，服务管理的是服务的接口和协议信息，并且服务有一系列的特征，这个网上也有很多描述，可以根据不同需求调整服务的实现。当前服务的协议通常有WebService、HTTP、EJB等，对应其组件的实现可以采用不同的技术，比如Java、C/C++等等。

从业人员篇

IT工作、特别是开发工作，是年轻人的天下。在本次调查中，19-25 岁以下受访者占47.84%，如果加上26-30岁的受访者，占到总比例的87.26%。这反映了我国IT尚未进入成熟阶段的现状。把年龄层比例数据与岗位比例数据作对比，可以更明确地看到这一点。有趣的是，据研究机构统计，越南等IT业处于起步阶段的国家，年轻开发者所占比例更大。

受访者年龄分布

开发者群体中，“阳盛阴衰”的现象很明显。此次调查的受访者有9 成是男性。受访者集中在北京、广东、上海和江浙地区。今年的数据显示，江苏、浙江两省受访者之和占到总额的13.26%，俨然已和北、上、广形成鼎立之势。但其他地区受访者愿意前往江苏、浙江发展的，所占比例却微不足道。在人才方面，江、浙尚缺乏足以与人抗衡的整体竞争力。

五地受访者比例分布

以对人才的吸引力而论，大型外企和创业公司最有人才竞争力。前者的薪酬、福利、管理、职业生涯等体系较为成熟可靠，后者凭借的是“许你一个未来”、“体现自我价值”的前景。调查显示，三成受访者有自我创业的意图。但金融危机引发的经济低潮，势必影响到创投形势，今年大家是否还想创业就很难说了。

受访者理想中的工作单位

对于从业人员来说，就业市场形势越来越严峻。而在数百万尚未解决就业的应届和往届毕业生看来，简直就是冰海沉船一般的死局。在这种情况下，计算机相关专业教育与单位需求脱节的现象越发显得突出和严重。学生受访者中，有六成对高校计算机教材表示不满意。学历教育解决不了就业问题，学生只能转向培训机构寻求帮助。有77.1%的学生受访者，愿意参加专业课程之外的软件技术培训。相较去年的60%，比例有了极大的增加。入行不容易，入行后也得跟上日新月异的技术发展，培训市场的火暴不是没有理由的。

07/08两年愿意参加课程外培训的学生比例

积累二三年的工作经验后，通常都会成为骨干开发人员。此时，薪资方面可能得到第一次大幅度提升，部分开发者甚至得到提升机会。此时，他们对单位购买IT软、硬件设备的决策影响力也大幅增加。以购买开发工具为例，参与提出建议和选型评估的受访者，占总额的55.2%；有决策购买能力的，占10.%。厂商应更为重视开发者的购买决策影响力。

受访者在机构购买开发工具时的参与情况

编程语言和平台篇

Java、.NET和C++ 无疑仍是编程语言中的王者，各自占据擅长的市场。Java 在大规模企业级应用中翻手为云，.NET在中小企业信息化市场上呼风唤雨，C++宝刀不老、在内核级开发和嵌入式软件应用上独擅胜场。PHP等Web专用的脚本语言，没有想象中那么风光。毕竟面向公众的Web应用，在整个IT市场中未见得占到多大的份额。企事业单位信息化进程日渐深入，IT正在成为基础设施，更“架构化”的Java和.NET，以及更“底层化”的C++，一占企业市场，一占移动市场，不算出奇。

受访者工作涉及开发平台及语言

在.NET阵营中，.NET Framework 2.0 的占有率高达63.7%，是当今.NET应用的主流平台版本。从2005 年的11.0%到今天的超过六成，.NET Framework 2.0确已修成正果。.NET Framework 3.0和3.5版本的占有率之和超过17%；随着Visual Studio 2008的推广（目前是VS2005占优，但有30%的.NET开发者打算迁移至VS 2008），3.0和3.5版本会越来越强势。无论在哪个版本的.NET Framework上，C#语言都独占鳌头，其他语言完全不能与之抗衡。

相对于.NET/C#不断升级的“折腾”劲，传统C++显得较为保守。根据调查显示，使用C++ 的受访者，以做系统开发（22.9%）和网络开发（22.6%）为主，他们的项目主要是企业应用（42.3%）和研究性项目（22.7%）。C++开发者似乎并不太买新版本Visual Studio的账，目前仍有35.5%的受访者使用Visual Studio 6。

受访者主要使用的C++ IDE环境

在Java方面，JDK的部署版本也逐年变化。到2008年，JDK 5.0 市占率接近50%，远远超过其他版本。不可忽视的是，JDK 6.0从2007年的10%急速上升至25%，未来属于谁，不问可知。

调查显示，Eclipse 市占率持续提升，2008 年首次超过5 成受访者首选Eclipse。Netbeans市占率从2007年的27%下降到2008 年的不到20%，主要原因是Sun公司推广重点转移到了Open Solaris和MySQL上，Netbeans成了爹不疼娘不爱的孩子，未来一段时间内，预计市占率会继续走低。

Ruby、ErLang等“热词”，在2008年貌似风光无限，但实际采用率并不算高。前者的成熟度有待验证，后者应用领域较窄，但这并不说明它们缺乏重要性。尤其是RoR为代表的快速Web 开发框架，给老牌平台/ 语言带来的冲击不可忽视。

Web应用开发篇

反过来看，Java、.NET 两大平台所涉应用， 也反映出B/S 体系成为信息化应用主流的状况。其中，54.8%的.NET 使用者工作主要是开发Web 应用，而在Java 人群这个比例更是高达69.2%。网页为王，已是不争的事实。

由于Web 应用的特殊性，导致调查数据呈现出一种有趣的现象：无论你使用任何一种后台编程语言，绝大多数时候，前端总得与HTML 和JavaScript 打交道。在RIA深入人心的今天，作为一种成熟的RIA表现形式（至少是RIA 过渡形式）的AJAX，其关注度也无人能匹敌。有近5 成开发Web 应用的受访者采用了AJAX作为客户端表现技术。

近5成受访者采用AJAX技术

在目前采用纯HTML的受访者中，64%的人打算转向AJAX。打算采用Flex/AIR或Silverlight 的受访者比例大致相当，都不超过15%。Adobe和微软推广自家RIA技术仍然任重道远，倒是Google 看准AJAX、以Chrome 奇袭，没准真能把水彻底搅浑。

受访者以后考虑采用的客户端表现技术

数据库篇

在主流企业应用市场，Oracle和SQL Server 比其他厂商产品有优势，而DB2在凭借IBM的整合服务，占据了8%的市场。MySQL以其低廉的成本也获取了相当份额。比较有意思的是，Access 的表现相当优异，三成信息化应用是用它做的。

厂商近年来不遗余力宣传的“BI”、“XML”等特性，目前并未成为主流，但开发者非常关注这方面趋势。事实上，40%的受访者数据库应用规模小于10万条记录，36%的受访者数据库应用规模在10万到100万条记录之间，达到千万级记录数的只有16.8%，这样的规模，还谈不上做商业智能级的数据挖掘。对此，数据库专家王翔表示，“相对其他数据而言，这组调查数据非常有趣。它提醒我们数据库、数据库应用设计要‘适度’而不是‘过度’，虽然在各大厂商在技术网站上都提供了为数很多的数据库部署方案，但作为应用的设计者要谨慎对待，要实事求是，设计时要对很多高可用性、高扩展性方案持谨慎态度，虽然对于计算机系统而言故障在所难免, 但总要算个风险成本。”

数据库应用规模比例

本次调查发现，工作中涉及数据库技术的开发者感兴趣的新数据库技术领域以全文搜索比例相对最高（51.4%），其次为基于Web 的管理控制台（44.9%）， 第三为原生XML（Native XML）支持，比例为44.3%。搜索的重要性毋庸置疑，但即便采用数据库提供的全文检索，也未必能实现良好的搜索功能。总的来说，数据库应用水平取决于信息化发展水平。预计未来对检索、数据挖掘、BI 等的需求会更加迫切。

开发者感兴趣的新数据库技术领域

软件工程篇

调查发现，受访者所在公司的认证评估体系以ISO-9000 系列比例最高，其次为CMM/CMMI 系列。但表面上的“正规化”背后却是作坊化的生产方式。20人以下的小团队，占受访者所在团队的80%以上，这样的规模，要真照CMMI 那套干起来，还不得淹没在文档的大海中。

团队规模比例

软件工程专家青润认为，从国际上认可的软件工程实施较为完善的企业要求来看，开发人员和测试人员的比例应该为1：1，排除掉团队内特定的管理、需求、配置管理、文档、美工、质量保证等人员外，开发团队中测试人员的比例应该在1/2到1/3之间比较合理。而此次调查显示，受访者所在团队中，测试人员占团队总人数1/5 以下的，竟有41.7%之多。对测试的忽视必然造成软件质量不过关，这也是信息化程度较低的一种体现。

相对于其他软件生命周期工具，需求管理工具采用率较低。不使用需求管理工具的受访者团队占到三成以上。由此可见，需求管理仍然是大量开发团队较为忽视的环节。缺乏有效的需求管理，导致信息化项目延期或失败，这样的例子比比皆是。

受访者团队采用需求管理工具情况

34.8%的受访者团队采用Visio作为设计建模工具。严格来说Visio 只是一种绘图工具，但相对于Rose 的庞大，似乎更受小型开发团队欢迎。从2007年的调查结果开始，CVS就超过了VSS，成为第一大源代码管理工具。在今年的调查中，CVS继续保持微弱优势。

受访者团队采用源代码管理工具情况

不要求进行集成的比例逐年下降，说明国内软件项目的可控性在不断提高，但精细化仍然是不可触及的梦想。今年的调查结果显示，仅30%的受访者团队做每日集成，而对集成粒度没有要求的受访者团队比例高达20%。这类项目，只可以用“混乱”来形容，失败可能性极大。

开发者经常采用的管理需求工具情况

结语

信息化搞了这么多年，硬件、软件该上的都上了，但应用水平却有待提高。如果说软硬件设备是“形”，那么应用水平就是“神”。反求诸己，软件业也是形稍俱而神不足。如同道家修行，此事急不得。唯有踏踏实实、去除浮躁，才有成功的基础。经济不景气，或许正是韬光隐晦、苦练内功的时候呢