本文分析了Hibernate和Struts的机制，提出了一种基于Hibernate和Struts的J2EE应用开发策略。在这种策略中，模型层用Hibernate实现，视图和控制器则用Struts框架实现。这样可大大降低代码的耦合性以及提高系统的开发效率。
关键字 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框架的模型层中，使用它来进行数据封装和映射，提供持久化的支持。
Swing是目前Java中不可缺少的窗口工具组，是用户建立图形化用户界面(GUI)程序的强大工具。Java Swing组件自动产生各种事件来响应用户行为。如当用户点击按钮或选择菜单项目时，Swing组件会产生一个ActionEvent。Swing组件会 产生许多事件，如ActionEvents,ChangeEvents,ItemEvents等，来响应用户的鼠标点击行为，列表框中值的改变，计时器的 开始计时等行为。在Java Swing编程中，通过注册监听器，我们可以监听事件源产生的事件，从而在事件处理程序中处理我们所需要处理的用户行为。
Java Swing中处理各组件事件的一般步骤是：
1. 新建一个组件(如JButton)。
2. 将该组件添加到相应的面板(如JPanel)。
3. 注册监听器以监听事件源产生的事件(如通过ActionListener来响应用户点击按钮)。
4. 定义处理事件的方法(如在ActionListener中的actionPerformed中定义相应方法)。
以上步骤我们可以用多种方法实现。但人们通常用二种方法。第一种方法是只利用一个监听器以及多个if语句来决定是哪个组件产生的事件;第二种方 法是使用多个内部类来响应不同组件产生的各种事件，其具体实现又分两种方式，一种是匿名内部类，一种是一般内部类。
为了说明如何使用上述三种方法实现事件的处理方法，我们建立一个简单的应用程序。该程序界面有两个按钮，当用户点击相应的按钮，就会弹出一个对 话框显示相应的内容。通过这个简单程序，你可以实现自己更多、更复杂的用户界面程序。
首先，我们利用单个监听器来实现该程序。我们定义一个名为Simple1的类来包括所有代码。所有的用户行为(如点击按钮)由一个监听器 SimpleListenner中的actionPerformed方法来处理。
1.对应String类型的对象使用println()方法时，如果对象为null，将打印null而不是引发 NullPointerException，由此引用的问题是容易造成错觉，对于以后对字符串的操作容易引起问题。
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错误，主要原因是对系统所访问外部资源，未执行关闭操作，导致外部资源大量浪费，最终可能导致系统无法 正常运行;对系统所访问的外部资源关闭次数太多，外部系统无法正常处理;所系统访问的外部资源出现异常情况。
解决的方法是：访问外部资源前，首先检查该资源(如数据库)是否可正常连接或操作;访问外部资源时，如果进行了连接，一定进行关闭操作，并仅进 行一次关闭操作;尽量在同一操作中共享外部资源，以减少该操作对资源的消费，提高程序的执行效率。
本文提供Struts2整合Spring Hibernate的CRUD的实例的源代码
1. 数据库脚本，数据库采用MySQL 5.0
CREATE TABLE `user` (
`id` int(11) NOT NULL auto_increment,
`username` varchar(32) NOT NULL,
`password` varchar(32) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
2. 几个重要的文件
web.xml
<?xml version=”1.0″ encoding=”UTF-8″?>
<web-app version=”2.5″ xmlns=”[url=http://java.sun.com/xml/ns/javaee]http://java.sun.com/xml/ns/javaee[/url]”
xmlns:xsi=”[url=http://www.w3.org/2001/XMLSchema-instance]http://www.w3.org/2001/XMLSchema-instance[/url]”
xsi:schemaLocation=”[url=http://java.sun.com/xml/ns/javaee]http://java.sun.com/xml/ns/javaee[/url]
[url=http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd]http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd[/url]“>
<!– spring的应用上下文 –>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext*.xml</param-value>
</context-param>
<!– struts2 过滤器 –>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!– spring的监听器，以便在启动时就自动加载spring的配置 –>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<!– OpenSessionInViewFilter过滤器 –>
<filter>
<filter-name>lazyLoadingFilter</filter-name>
<filter-class>
org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>lazyLoadingFilter</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>/user/userAdd.jsp</welcome-file>
</welcome-file-list>
</web-app>
applicationContext.xml
<?xml version=”1.0″ encoding=”UTF-8″?>
<beans xmlns=”[url=http://www.springframework.org/schema/beans]http://www.springframework.org/schema/beans[/url]”
xmlns:xsi=”[url=http://www.w3.org/2001/XMLSchema-instance]http://www.w3.org/2001/XMLSchema-instance[/url]”
xsi:schemaLocation=”[url=http://www.springframework.org/schema/beans]http://www.springframework.org/schema/beans[/url] [url=http://www.springframework.org/schema/beans/spring-beans-2.0.xsd]http://www.springframework.org/schema/beans/spring-beans-2.0.xsd[/url]“>
<bean id=”dataSource”
class=”org.apache.commons.dbcp.BasicDataSource”>
<property name=”driverClassName”
value=”com.mysql.jdbc.Driver”>
</property>
<property name=”url”
value=”jdbc:mysql://localhost:3306/catalog”>
</property>
<property name=”username” value=”root”></property>
<property name=”password” value=”ethip”></property>
</bean>
<bean id=”sessionFactory”
class=”org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
<property name=”dataSource”>
<ref bean=”dataSource” />
</property>
<property name=”hibernateProperties”>
<props>
<prop key=”hibernate.dialect”>
org.hibernate.dialect.MySQLDialect
</prop>
</props>
</property>
<property name=”mappingResources”>
<list>
<value>org/ethip/catalog/model/User.hbm.xml</value>
</list>
</property>
</bean>
<bean id=”UserDAO”>
<property name=”sessionFactory”>
<ref [...]
Hibernate入门篇三：建立hibernate应用程序的步骤
（我的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()方法中，start()方法启动线程将自动调用 run()方法，这是由Java的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void.
二、关键字Synchronized
这个关键字用于保护共享数据，当然前提是要分清哪些数据是共享数据。每个对象都有一个锁标志，当一个线程访问该对象时，被Synchronized修饰的数据将被“上锁”，阻止其他线程访问。当前线程访问完这部分数据后释放锁标志，其他线程就可以访问了。
以下是引用片段：
public ThreadTest implements Runnable
{
public synchronized void run(){
for(int i=0;i<10;i++)
{
System.out.println(“ ” + i);
}
}
public static void main(String[] args)
{
Runnable r1 = new ThreadTest();
Runnable r2 = new ThreadTest();
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
}
以上这段程序中的 i 变量并不是共享数据，也就是这里的Synchronized关键字并未起作用。因为t1，t2两个线程是两个对象(r1，r2)的线程。不同的对象其数据是不同的，所以r1和r2两个对象的i变量是并不是共享数据。
当把代码改成如下：Synchronized关键字才会起作用
以下是引用片段：
Runnable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
三、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()则从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。
Map是一个保存键值对的对象，根据键值可以找到它对应的值。键必须是唯一的，但是值可以重复。HashMap类提供了map接口的主要实现，它使用hash table来实现map接口。这就使得一些常见的操作如get()和put()所用的时间基本不变。
如下代码是一个使用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
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
就HashMap与HashTable主要从三方面来说:
一.历史原因: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 [...]
通常我们会把事务处理放在业务层。
[1]引子
比如:
业务逻辑方法
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 = [...]