关键字 Hibernate，Struts，MVC，持久层

　　引言

　　随着Java技术的逐渐成熟与完善，作为建立企业级应用的标准平台，J2EE平台得到了长足的发展。借助于J2EE规范中包含的多项技术：Enterprise JavaBean(EJB)、Java Servlets(Servlet)、Java Server Pages(JSP)、Java Message Service(JMS)等，开发出了许多应用系统。但是，在传统J2EE应用的开发过程中也出现了一些问题：1）数据模型和逻辑模型之间的矛盾。目前使用的数据库基本上都是关系型数据库，而Java本质上是一种面向对象的语言，对象在存储和读取时使用SQL和JDBC进行数据库操作，降低了编程的效率以及系统的可维护性；2）传统的J2EE应用多采用基于EJB的重量级框架，这种框架适合于开发大型企业应用，但是使用EJB容器进行开发和调试需要耗费大量时间。为了降低代码的耦合性，提高系统的开发效率，本文提出了一种基于Struts框架和Hibernate框架的J2EE应用开发策略。

　　数据持久层及Hibernate

　　Hibernate是一个数据持久层框架，是一种实现对象和关系之间映射（O/R Mapping）的工具，它对JDBC进行了轻量级的对象封装，使程序员可以使用对象编程思想来操作数据库。它不仅提供了从Java类到数据表的映射，也提供了数据查询和恢复机制。相对于使用JDBC和SQL来操作数据库，使用Hibernate能大大的提高实现的效率。Hibernate框架用配置文件的形式来定义Java对象和数据表之间的映射关系，同时在更深的层面将数据表之间的关系解释为Java对象之间的继承及包含等关系。通过使用HQL语句将复杂的关系算法用对象的方式描述，在很大程度上简化了对数据的查询，加快了开发的效率。在Hibernate中有一个简单而直观的API，用于对数据库所表示的对象执行查询。要创建或修改这些对象，只需在程序中与它们进行交互，然后告诉Hibernate保存即可。这样，大量封装持久化操作的业务逻辑不再需要编写烦琐的JDBC语句，从而使数据持久层得到了极大的简化。

　　用Struts实现MVC架构

　　MVC（Model-View-Controller）由Trygve Reenskaug提出，首先被应用在SmallTalk-80环境中，是许多交互和界面系统的构成基础。根据界面设计可变性的需求，MVC把交互系统的组成分解成模型、视图、控制器三部分。

　　模型（Model）是软件所处理问题逻辑在独立于外在显示内容和形式情况下的内在抽象，封装了问题的核心数据、逻辑和功能的计算关系，独立于具体的界面表达和I/O操作。视图（View）把表示模型数据及逻辑关系和状态的信息及特定形式展示给用户。它从模型获得显示信息，对于相同的信息可以有多个不同的显示形式或视图。控制器（Controller）是处理用户与软件的交互操作的，其职责是控制提供模型中任何变化的传播，确保用户界面于模型间的对应联系；它接受用户的输入，将输入反馈给模型，进而实现对模型的计算控制，是使模型和视图协调工作的部件。通常一个视图对应一个控制器。模型、视图与控制器的分离，使得一个模型可以具有多个显示视图。如果用户通过某个视图的控制器改变了模型的数据，所有其它依赖于这些数据的视图都应反映到这些变化。因此，无论何时发生了何种数据变化，控制器都会将变化通知所有的视图，导致显示的更新。这实际上是一种模型的变化-传播机制。

　　Struts框架最早是作为Apache Jakarta项目的组成部分问世运做，它继承了MVC的各项特性，并根据J2EE的特点，做了相应的变化与扩展。Struts框架很好的结合了Jsp，Java Servlet，Java Bean，Taglib等技术。在Struts中，承担MVC中控制器角色的是ActionServlet。ActionServlet是一个通用的控制组件。这个控制组件提供了处理所有发送到Struts的HTTP请求的入口点。它截取和分发这些请求到相应的动作类（这些动作类都是Action类的子类）。另外控制组件也负责用相应的请求参数填充Action Form（FromBean），并传给动作类（ActionBean）。动作类访问核心商业逻辑，即访问Java Bean或调用EJB。最后动作类把控制权传给后续的JSP文件，由JSP文件生成视图。所有这些控制逻辑利用Struts-config.xml文件来配置。在Struts框架中，视图主要由JSP生成页面完成，Struts提供丰富的JSP标签库，这有利于分开表现逻辑和程序逻辑。模型以一个或多个Java Bean的形式存在。在Struts中，主要存在三种Bean，分别是：Action，ActionForm，EJB或者Java Bean。

    Struts框架没有具体定义模型层的实现，在实际开发中，模型层通常是和业务逻辑紧密相连的，并且要对底层数据进行操作。下面介绍一种开发策略，将Hibernate引入到Struts框架的模型层中，使用它来进行数据封装和映射，提供持久化的支持。

Java Swing中处理各组件事件的一般步骤是：

1. 新建一个组件(如JButton)。

2. 将该组件添加到相应的面板(如JPanel)。

3. 注册监听器以监听事件源产生的事件(如通过ActionListener来响应用户点击按钮)。

4. 定义处理事件的方法(如在ActionListener中的actionPerformed中定义相应方法)。

以上步骤我们可以用多种方法实现。但人们通常用二种方法。第一种方法是只利用一个监听器以及多个if语句来决定是哪个组件产生的事件;第二种方 法是使用多个内部类来响应不同组件产生的各种事件，其具体实现又分两种方式，一种是匿名内部类，一种是一般内部类。

为了说明如何使用上述三种方法实现事件的处理方法，我们建立一个简单的应用程序。该程序界面有两个按钮，当用户点击相应的按钮，就会弹出一个对 话框显示相应的内容。通过这个简单程序，你可以实现自己更多、更复杂的用户界面程序。

首先，我们利用单个监听器来实现该程序。我们定义一个名为Simple1的类来包括所有代码。所有的用户行为(如点击按钮)由一个监听器 SimpleListenner中的actionPerformed方法来处理。

2.引发NullPointerException异常，主要原因是没有对对象的存在性进行验证，在jsp编程中经常出现：if (request.getParameter(“username”).equals(“xxx”))、 out.println(session.getAttribute(“record”))等。解决这个问题的方法是在使用前进行判空比较：

if (request.getParameter(“username”)!=null)

{if if (request.getParameter(“username”).

equals(“xxx”))…}

3.引发NumberFormatException异常：主要原因是将用户提交的内容转换为整数或者浮点数时用户输入了其它非法字符。处理的 主要方式是在需要进行转换的地方使用try/catch块捕获此异常然后提示用户输入合法数据。

4.引发StringIndexOutOfBoundsException异常：主要原因是使用String的substring()、 charAt()等方法，而字符串的长度不够，就会引发此异常;在字符串为null时也会引发NullPointerException。解决的方法是判 空，判断长度或者转换为字节数组。考虑到这些操作很多，可以将之封装到javabean中。

5.引发NoClassDefFoundError错误，主要原因是类路径或者类文件放置错误，类文件的放置要符合服务器的要求。

6.引发java.lang.Error错误，主要原因是对系统所访问外部资源，未执行关闭操作，导致外部资源大量浪费，最终可能导致系统无法 正常运行;对系统所访问的外部资源关闭次数太多，外部系统无法正常处理;所系统访问的外部资源出现异常情况。

解决的方法是：访问外部资源前，首先检查该资源(如数据库)是否可正常连接或操作;访问外部资源时，如果进行了连接，一定进行关闭操作，并仅进 行一次关闭操作;尽量在同一操作中共享外部资源，以减少该操作对资源的消费，提高程序的执行效率。

1. 数据库脚本，数据库采用MySQL 5.0

2. 几个重要的文件

web.xml

applicationContext.xml

struts.xml

3. 本实例仅实现CRUD功能，没有实现其他的处理，如数据校验、国际化、分页等.

（我的IDE： MyEclipse_6.0.1GA_E3.3.1_FullStackInstaller）

1.建立一个Java Project（或者Web Project）
（Hibernate主要是与数据库交互，初学时就新建一个Java Project吧）

2.在数据库中创建数据库和表
e.g. datebase name = test，
test.table name =login
表login的字段可参照 UserInfo.hbm.xml或者POJO类的属性

3.创建持久化类

4.导入hibernate的jar
利用myeclipse自动完成。其间会生成配置文件hibernate.cfg.xml。

5.创建数据库关系映射文件
e.g.UserInfo.hbm.cml

6.建立测试类

这两个方法应该都比较熟悉，把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由Java的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void.

二、关键字Synchronized

这个关键字用于保护共享数据，当然前提是要分清哪些数据是共享数据。每个对象都有一个锁标志，当一个线程访问该对象时，被Synchronized修饰的数据将被“上锁”，阻止其他线程访问。当前线程访问完这部分数据后释放锁标志，其他线程就可以访问了。

以上这段程序中的 i 变量并不是共享数据，也就是这里的Synchronized关键字并未起作用。因为t1，t2两个线程是两个对象(r1，r2)的线程。不同的对象其数据是不同的，所以r1和r2两个对象的i变量是并不是共享数据。

当把代码改成如下：Synchronized关键字才会起作用

三、sleep()

使当前线程(即调用该方法的线程)暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是如果有Synchronized同步块，其他线程仍然不同访问共享数据。注意该方法要捕获异常

比如有两个线程同时执行(没有Synchronized)，一个线程优先级为MAX_PRIORITY，另一个为MIN_PRIORITY，如果没有Sleep()方法，只有高优先级的线程执行完成后，低优先级的线程才能执行;但当高优先级的线程sleep(5000)后，低优先级就有机会执行了。

总之，sleep()可以使低优先级的线程得到执行的机会，当然也可以让同优先级、高优先级的线程有执行的机会。

四、join()

join()方法使调用该方法的线程在此之前执行完毕，也就是等待调用该方法的线程执行完毕后再往下继续执行。注意该方法也要捕获异常。

五、yield()

它与sleep()类似，只是不能由用户指定暂停多长时间，并且yield()方法只能让同优先级的线程有执行的机会。

六、wait()和notify()、notifyAll()

这三个方法用于协调多个线程对共享数据的存取，所以必须在Synchronized语句块内使用这三个方法。前面说过Synchronized 这个关键字用于保护共享数据，阻止其他线程对共享数据的存取。但是这样程序的流程就很不灵活了，如何才能在当前线程还没退出Synchronized数据块时让其他线程也有机会访问共享数据呢?此时就用这三个方法来灵活控制。

wait()方法使当前线程暂停执行并释放对象锁标志，让其他线程可以进入Synchronized数据块，当前线程被放入对象等待池中。当调用 notify()方法后，将从对象的等待池中移走一个任意的线程并放到锁标志等待池中，只有

锁标志等待池中的线程能够获取锁标志;如果锁标志等待池中没有线程，则notify()不起作用。

notifyAll()则从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。

如下代码是一个使用hashmap的实例，它提供了account信息和account balance的对应：

import java.util.*;

public class HashMapDemo {

public static void main( String[] args) {

HashMap hm = new HashMap();
hm.put(“Rohit”, new Double(3434.34));
hm.put(“Mohit”, new Double(123.22));
hm.put(“Ashish”, new Double(1200.34));
hm.put(“Khariwal”, new Double(99.34));
hm.put(“Pankaj”, new Double(-19.34));
Set set = hm.entrySet();

Iterator i = set.iterator();

while(i.hasNext()){
Map.Entry me = (Map.Entry)i.next();
System.out.println(me.getKey() + “ : ” + me.getValue() );
}

//deposit into Rohit’s Account
double balance = ((Double)hm.get(“Rohit”)).doubleValue();
hm.put(“Rohit”, new Double(balance + 1000));

System.out.println(“Rohit new balance : ” + hm.get(“Rohit”));

}
}

运行后的输出如下：

Rohit : 3434.34
Ashish : 1200.34
Pankaj : -19.34
Mohit : 123.22
Khariwal : 99.34
Rohit new balance : 4434.34

一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java   1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

package com.my.time;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Timer;

public class BugXmlTimer  {

public   Timer timer;

public void timerStart(){

timer = new Timer();

Date datetime=new Date();

Date midnightDate=new Date();

SimpleDateFormat sdf1 = new SimpleDateFormat(“yyyy-MM-dd”);

SimpleDateFormat sdf2 = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

try {

midnightDate = sdf2.parse(sdf1.format(datetime)+” 23:00:00″);

} catch (ParseException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

long in=midnightDate.getTime()-datetime.getTime();

System.out.println(“before task”);

//立刻执行，然后每隔30s执行一次

timer.schedule(new BugXmlTimerTask(), 0,30000);

}

public void timerStop(){

if(timer!=null)

timer.cancel();

}

public static void main(String[] args){

BugXmlTimer myTimer=new BugXmlTimer();

// TODO Auto-generated method stub

myTimer.timerStart();

}

}

//这是执行任务的类，即每隔一段时间要做的事情在这里

package com.my.time;

import java.util.TimerTask;

public class BugXmlTimerTask extends TimerTask {

@Override

public void run() {

System.out.print(“run task”);

}

}

//以下是出发定时操作的类，该类实现了ServletContextListener

public class MyTimerListener implements ServletContextListener {

private BugXmlTimer  mytimer = new BugXmlTimer  ();

public void contextInitialized(ServletContextEvent event) {

mytimer.timerStart();

}

public void contextDestroyed(ServletContextEvent event) {

mytimer.timerStop();

}

}

然后在web.xml里部署一下，即可在程序启动后运行定时器了！

<listener>

<listener-class>com.my.time.MyTimerListener </listener-class>

</listener>

比如:
业务逻辑方法

public A bussinessMethod(){

   DaoA   a = new DaoA();
   a.udpate();

   DaoB  b = new DaoB();
   b.update;

}

假设，上面的事务是自动提交的。
那么，我们就可以什么不考虑。但是有一个问题，创建DAO对象的时候两个对象用的是不同的Connection对象。

再假定我们的取得连接的代码是

    public Connection getConnection(String username, String password)
            throws SQLException {
        Connection con = DriverManager
                .getConnection(conStr, username, password);
        return con;
    }

这个方法的一个调用。

那么如果，我们需要自己控制事务的开始和结束。
如何控制呢。
也许又有了新的方法
public A bussinessMethod(){

   DaoA   a = new DaoA();
   a.beginTx();
   a.udpate();
   a.endTx();
   a.close();

   DaoB  b = new DaoB();
   b.beginTx();
   b.update;
   b.endTx();
   b.close();
}

这样我们就控制了事务，并且我们也只有这样才能实现，因为，不同的DAO取得的是不同的Connection对象。

[2]问题
那么怎么才能实现两个或多个DAO用同一个事务来控制呢？

首先就要解决一个根本问题，我们在一个事务中，不同的DAO取得的是同一个Connection,这个要怎么实现呢。我们想到了TheadLocal.
[3]方案
因为当一个业务逻辑要对多个DAO进行处理的时候，此操作属于同一个线程内。所以，我们希望能把此Connection放在线程内，或者和线程有关联。
第一个方案，可以用Map来使现。
就是Map<Thread,Connection>
但是这个map维护起来比较麻烦，如果一直put的话，那么这个map随着系统的运行就会越来越大。
第二个方案，就是用ThreadLocal
在任何一个线程内都可以用ThreadLocal来保存一个变量的copy,这样，如果此对象存在，就可以直接取用。
如果把Connection存在ThreadLocal也一样。
所以，在同一个线程内，就可以保证取得到的是同一个Connection.

[4]实现
代码
    private static ThreadLocal<Connection> localCon = new ThreadLocal<Connection>();

    public final static Connection getConnection() throws SQLException {

        Connection con = localCon.get();
       
        if(con==null||con.isClosed()){

            con = new OracleJdbcDatasource().getConnection();
           
            localCon.set(con);
        }
        return con;
    }
这样就实现了上面的问题。

[5]新的事务管理

public A bussinessMethod(){

   DaoA   a = new DaoA();
   DaoB  b = new DaoB();

   a.beginTx();
   a.udpate();

   b.beginTx();
   b.update;

   a.endTx();
   a.close();

//   b.endTx();
//   b.close();
能实现一样的效果
}
上面的黑体部分，就可以实现对事务的统一管理。

[6]改进
上面的方法给人的感觉有点别扭，但是却能实现事务的统一管理。