176142998

  BlogJava :: 首页 :: 联系 :: 聚合  :: 管理
  116 Posts :: 0 Stories :: 45 Comments :: 0 Trackbacks

#

为你的数据库属性hibernate.dialect设置正确的 org.hibernate.dialect.Dialect子类. 如果你指定一种方言, Hibernate将为上面列出的一些属性使用合理的默认值, 为你省去了手工指定它们的功夫.

表 4.8.  Hibernate SQL方言 (hibernate.dialect)
RDBMS 方言
DB2 org.hibernate.dialect.DB2Dialect
DB2 AS/400 org.hibernate.dialect.DB2400Dialect
DB2 OS390 org.hibernate.dialect.DB2390Dialect
PostgreSQL org.hibernate.dialect.PostgreSQLDialect
MySQL org.hibernate.dialect.MySQLDialect
MySQL with InnoDB org.hibernate.dialect.MySQLInnoDBDialect
MySQL with MyISAM org.hibernate.dialect.MySQLMyISAMDialect
Oracle (any version) org.hibernate.dialect.OracleDialect
Oracle 9i/10g org.hibernate.dialect.Oracle9Dialect
Sybase org.hibernate.dialect.SybaseDialect
Sybase Anywhere org.hibernate.dialect.SybaseAnywhereDialect
Microsoft SQL Server org.hibernate.dialect.SQLServerDialect
SAP DB org.hibernate.dialect.SAPDBDialect
Informix org.hibernate.dialect.InformixDialect
HypersonicSQL org.hibernate.dialect.HSQLDialect
Ingres org.hibernate.dialect.IngresDialect
Progress org.hibernate.dialect.ProgressDialect
Mckoi SQL org.hibernate.dialect.MckoiDialect
Interbase org.hibernate.dialect.InterbaseDialect
Pointbase org.hibernate.dialect.PointbaseDialect
FrontBase org.hibernate.dialect.FrontbaseDialect
Firebird org.hibernate.dialect.FirebirdDialect

posted @ 2008-06-19 23:33 飞飞 阅读(178) | 评论 (0)编辑 收藏

Oracle导入excel数据方法汇总
摘要:在程序编制过程和数据汇总交换过程中,经常会碰到需要将其他人员在office办公环境下编制的文件数据内容导入oracle中的情况。目前程序开发者经常使用的方法有如下几种:1,使用oracle提供的导入工具sql*loader;2,使用plsql developer工具;3使用其他数据转移工具做中转站。下面我们采用实例的方式分别描述几种导入方式的优缺点及其操作步骤。假设‘e:\test.xls’文件中存在三列数据分别代表客户编号,客户名称和联系电话。其内容如下:
10001
zjaxi01
13562485246
10002
zjaxi02
13562485247
10003
zjaxi03
13562485248
10004
zjaxi04
13562485249
10005
zjaxi05
13562485250
10006
zjaxi06
13562485251
10007
zjaxi07
13562485252
10008
zjaxi08
13562485253
10009
zjaxi09
13562485254
10010
zjaxi10
13562485255
10011
zjaxi11
13562485256
10012
zjaxi12
13562485257
10013
zjaxi13
13562485258
10014
zjaxi14
13562485259
使用sql *loader
SQL*LOADER是oracle的数据加载工具,在NT下sql*loader的命令为SQLLDR,在UNIX下一般为SQLLDR/SQLLOAD。通常用来将操作系统文件迁移到oracle数据库中。它是大型数据仓库选择使用的加载方法,因为它提供了最快速的途径(direct,parallel)。但这种方法要求存储数据的oracle表是已经存在的。
使用这种方法导入excel内容到oracle时,首先需要将excel文件另存为文本格式,文件类型选文本类型或者csv类型即将e:\test.xls另存为e:\test.csv。
如果oracle没有对应存储数据的表结构,则需要创建表test(id,name,telphone)。
用记事本创建sql*loader控制文件test.ctl(ctl后缀是企图证明这是一个控制文件,但实际上这个文件后缀不重要,用户可以自由选择,但文件格式一定要是文本格式),内容如下:
Load data
Infile ‘e:\test.csv’          --数据源文件名称
Append|insert|replace       --append在表后追加,insert插入空表,replace替代原有内容
Into table test            --要导入的数据库表名称
[when id = id_memo]     --过滤条件
Fields terminated by X’09’ --字段分隔符
(id,name,telphone)        --字段名称列表
最后在命令窗口输入sqlldr命令行执行导入操作Sqlldr userid = system/manager control=’e:\test.ctl’
Sqlldr的函数关键字说明:
Userid   --oracle用户名 userid = username/password
Control --控制文件名称 control = ‘e:\insert.ctl’
Log     –-日志文件名称 log = ‘e:\insert.log’
Bad     --损坏文件名称
Data     --data file name
Discard    --discard file name
Discardmax --number of discards to allow(默认全部)
Skip       --导入时跳过的记录行数(默认0)
Load       --导入时导入的记录行数(默认全部)
Errors    --允许错误的记录行数(默认50)
使用plsql developer
PL/SQL Developer是一种专门用于开发、测试、调试和优化oracle PL/SQL存储程序单元,比如触发器,存储过程,函数和程序包等集成开发环境。
在单个文件数据不多(小于10w行),并且目的表结构已经存在的情况下可以使用plsql developer工具将excel内容直接通过简单的copy,paste操作导入oracle数据库。具体操作方式如下:
l         在plsql developer的sql window里输入select * from test for update,其中test是要导入的oracle数据表名称;
l         执行查询(通过点击按钮或者快捷键F8可以实现);
l         点击查询结果上面的锁状按钮,使得查询到的内容处于编辑状态。
l         从excel数据表中copy(ctrl +C)要导入oracle中的数据,如果是单列数据导入,可以先按plsql developer中查询结果上面的“添加(+)”按钮,使得数据表处于添加数据状态,然后将鼠标在plsql developer的列名称上单击,最后使用快捷键ctrl + v 完成数据导入操作,并单击plsql developer中的“提交(对号)”按钮提交所做的修改。
l         如果是同时导入所有列,首先选择copy所有数据,然后点增加(+)并点击编辑那一行最前面的星号使得整行数据都处于被选择状态,最后paste即可将数据导入。
l         如果分列导入数据,则需要逐列完成,首先选择copy要导入的数据,然后然后点增加(+)并点击编辑那一列的名称,使得整列数据都处于被选择状态,最后paste即可将数据导入。
使用PLSQL developer执行数据的导入和导出操作主要存在的问题是在大数据量情况下对中文数据可能出错,估计将接收数据表的类型定义为nvarchar2的类型会比较好一点。另外,就是这种方法需要人工更多的参与,不能达到自动导入的效果。
使用sql server中转
    这部操作执行时,需要先用sqlserver的导入导出工具将excel内容导入sqlserver数据库中,然后使用同样的工具将sqlserver中转内容导入oracle数据库,这里需要两次的数据复制与IO操作,效率相对是比较低的。并且根据csdn网友jkflyfox的描述,这种方式下需要将oracle文件的名称全部大写,否则会出错。
 
posted @ 2008-06-16 15:17 飞飞 阅读(545) | 评论 (0)编辑 收藏

实现的功能:

每隔一分钟自动向getSysDate表中插入当前的系统时间。

一、创测试表

create table getSysDate(test date);

二、创要定时执行的存储过程

create or replace procedure insertSysDate as

begin

insert into getSysDate values (sysdate);

end ;

三、创建JOB,即创建待执行的定时任务过程

variable job1 number;

begin

dbms_job.submit(:job1,'insertSysdate;',sysdate,'sysdate+1/1440');

end;

四、启动JOB,即启动并运行定时任务过程

begin

dbms_job.run(:job1);

end;

五、查看运行效果

select to_char(test,'yyyy/mm/dd hh24:mi:ss') from getSysDate;

结果如下:

2007/08/03 10:53:11

2007/08/03 11:05:51

部分重点参数补充说明:

DBMS_JOB.SUBMIT(:jobno,//job号

'your_procedure;',//要执行的过程

trunc(sysdate)+1/24,//下次执行时间

'trunc(sysdate)+1/24+1'//每次间隔时间

);

删除job:dbms_job.remove(jobno);

修改要执行的操作:job:dbms_job.what(jobno,what);

修改下次执行时间:dbms_job.next_date(job,next_date);

修改间隔时间:dbms_job.interval(job,interval);

停止job:dbms.broken(job,broken,nextdate);

启动job:dbms_job.run(jobno);

修改job_queue_processes的值:(保证其不为0否则JOB不自动运行)

可通过select * from v$parameter;查看其值;

或者直接用show parameter job_queue_processes;查看如下:

NAME TYPE VALUE

--------------- ----------- ------------

job_queue_processes integer 10

方法1.startup pfile='C:oracleora90databaseinitorcl.ora';

//这个方法用来修改initorcl.ora文件的job_queue_processes参数,然后重新启动数据库

方法2.alter system set job_queue_processes=10

//这个方法不用重启数据库就可以生效,系统自动修改init.ora文件以后即可生效 。

posted @ 2008-06-16 12:07 飞飞 阅读(393) | 评论 (0)编辑 收藏

在网上漫无边际地搜索了一天,绝大部分都是垃圾信息,只好自己做一遍

    好了,下面我就将我所完成的例子程序完整的叙述,希望对读者有所帮助。

一、开发环境

   myeclipse6.01GA,mysql。

二、表结构

   CREATE TABLE `user` (
  `id` int(10) unsigned NOT NULL auto_increment,
  `username` varchar(64) NOT NULL,
  `password` varchar(64) NOT NULL,
  `first_name` varchar(128) NOT NULL,
  `last_name` varchar(128) NOT NULL,
  `date_created` bigint(20) unsigned NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

三、具体步骤:

1、在myeclipse中建立一个“java project”,工程名为:HibernateSpringProject,这个程序用java应用程序就可以实现。

 

2、右键点击工程文件,然后选择MyEclipse->Add Spring Capabilities...

第一步选择需要加载的包,如下图所示:



其余的选项默认,点击 “下一步”,提示是否建立spring配置文件,选择默认,然后直接点击“finish”。

3、右键点击工程文件,然后选择MyEclipse->Add Hibernate Capabilities...

第一步选择默认,点击“下一步”。

第二步提示你是用hibernate的配置文件还是用spring的配置文件进行SessionFactory的配置,选择使用spring来对hibernate进行管理,这样最后生成的工程里就不包含hibernate.cfg.xml了,好处是在一个地方就可以对hibernate进行管理了。

 

第三步提示你是创建一个新的hibernate配置文件还是使用已有的配置文件,由于我们刚才已经生成了spring配置文件,并且要在其中进行hibernate的配置,所以选择复选框“Existing Spring configuration file”,选择该项后,下方的“Spring Config:”后的下拉列表框自动填入了刚才生成的spring配置文件路径。这时候有个错误,要求你填写SessionFactory ID,这个id就是我们要为hibernate注入的一个类的ID,随便取一个名字,例如“sessionFactory”。点击“下一步”。

 

第四步要求选择数据库连接信息,这个步骤可以参照网上的信息进行配置,很简单。这里需要注意一点,“bean id”处填写一个数据源的名称,例如“datasource”,下面的单选按钮选择“Use Jdbc Driver”就行了,此处没有用jndi。在“DB Driver”处选择配置好的数据库连接信息,其他信息自动填入余下的输入框中,点击下一步。

 

第四步提示是否创建“SessionFactory”类,由于本程序用spring替我们注入sessionfactory,此处可以不用创建,勾掉复选框。然后直接点击“finish”。

 

4、建立三个包,分别是com.simon.dao,com.simon.model,com.simon.service。

在用ssh开发web应用时,需要对生成的各个类文件进行组织,下面就对一个可行的目录方案进行介绍:

譬如应用中有一个用户管理模块,则在公共包下建立一个user包,如该公共包可以为com.simon.oa,

在user包下包括如下子包

1、controler包

该包放置各种struts的action。

 

2、dao包

该包放置各类dao(data access object),也就是放置对数据库访问的实现类,在用myeclipse中的“Hibernate Reverse Engineering”进行反向操作时在某一个目录中就会生成对应某个表的DAO,生成后可将该DAO拖到dao包中。在某些应用中将DAO作为接口,在该接口中包括所有对数据库的操作方法,然后在dao包建立一个hibernate包,在hibernate包中放置对DAO接口的实现,譬如:UserDAO接口有一个实现类为UserDaoImpl,将该类放置到hibernate包中,实际的开发倾向于后一种方式,因为对这个DAO接口可以实现spring的IoC操作。(不知道myeclipse对此是怎么考虑的,这个问题让我纠缠了很久,误将DAO理解成一个能够进行实际操作的类,而不是一个接口,以后开发要注意)

 

3、model包

该包中放置hibernate反向工程生成的bean和该bean对应的.hbm.xml文件。

 

4、service包

该包放置业务操作类,譬如用户服务类,一般情况将该用户操作类提取一个接口,然后在service包下生成一个impl包,在impl包中才放置用户操作接口的实现类。该用户接口实现类中调用DAO接口对数据库进行操作,而调用该实现类的方法在struts的action中。

 

5、vo包(value object)

vo包中的中包括struts中使用的POJO及actionform等信息。

VO:  Value Object
DTO: Data Transfer Object
个人理解VO和DTO是类似的东西,原则上VO和DTO只有Public Fields,主要用于进程之间数据传递的问题,VO和DTO不会传递到表示层,在业务层就会被吸收。但看到很多人在建立VO和DTO时,也含有Setter,Getter属性和一些其它的辅助方法,这也无可厚非,我自己也不能确定这对不对。

实际的结构如下:


 

5、打开myeclipse的database exployer perspective,右键选择user表,选择Hibernate reverse engineering

按照下图所示进行设置


点击下一步,在“ID generator”中选择native,如果愿意可以直接点击finish

这时再观察applicationContext.xml文件,发现在sessionFactory定义中增加了如下代码:

  <property name="mappingResources">
   <list>
    <value>com/simon/model/User.hbm.xml</value>
    </list>
  </property>

此时在观察类结构:


在model包下生成了三个类和一个映射文件。AbstractUser是User的抽象类,在此需要说明一点的是,在标准的spring应用中UserDAO应该是一个接口,而不是一个具体的类,而myeclipse将数据库操作方法直接写到了UserDAO中,另外,按照标准写法,DAO实现类要实现DAO接口,并且要包括SessionFactory的变量声明,但是生成的代码中UserDAO直接实现了HibernateDaoSupport类,需要特别注意。所以,如果你需要标准写法,可以将UserDAO中的方法提取出来,只保留方法声明,然后再间一个impl目录,将该DAO的实现类放在该impl中,按照管理将该类命名为UserDAOImpl,另外一点最好将DAO和它的实现类移到dao包中,结构和model包中的相同

在这个例子中暂且将生成的文件都放到model中。

此时我们可以写一个测试程序将一条记录插入到user表中,当然这个测试程序并没有用事务控制,后面我们还会介绍,测试程序如下:

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.simon.model.UserDAO;
import com.simon.model.User;
public class TestWithoutTx {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
        User user=new User();
        user.setFirstName("first name");
        user.setLastName("last name");
        user.setUsername("user name");
        user.setPassword("password");
        user.setDateCreated(new Long(111111));
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDAO userdao=(UserDAO)context.getBean("UserDAO");
        userdao.save(user);       
 }
}

现在的问题是增加事务处理功能,跟我继续,这时候源程序不需要修改,只需要修改applicationContext.xml配置文件,首先增加事务管理器,因为事务管理器也需要使用数据库,所以需要引入sessionFactory

如下:

 <bean id="myTransactionManager"  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
 <property name="sessionFactory">
 <ref bean="sessionFactory" />
 </property>
 </bean> 

继续增加如下配置信息:

<bean id="userDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="proxyTargetClass">
   <value>true</value>
  </property>

  <property name="transactionManager">
   <ref bean="myTransactionManager" />
  </property>
  <property name="target">
   <ref local="UserDAO" />
  </property>
  <property name="transactionAttributes">
   <props>
    <!-- 这里的方法签名可以精确到方法, 先懒惰一下全配置上 -->
    <prop key="*">PROPAGATION_REQUIRED</prop>
   </props>
  </property>
 </bean>

 

注意以上红色部分:  注意这个属性,必须为 true, 使用CGLIB时才不用强制编写DAO接口,也就是由于myeclipse并没有为我们生成DAO接口,而是生成了一个数据库实现类,为了使spring不强迫我们必须定义一个DAO接口,只需要将这个proxyTargetClass属性定义为true,这点非常重要,程序出错很有可能和这个属性设置错误有关。

下面再写一个测试程序,和上面的测试程序基本相同,唯一不同是将上面的

UserDAO userdao=(UserDAO)context.getBean("userDAO");

换成

UserDAO userdao=(UserDAO)context.getBean("userDAOProxy");

执行,一切ok,数据正确的插入到数据库中。

posted @ 2008-06-13 16:40 飞飞 阅读(308) | 评论 (0)编辑 收藏

一说起传说中的SSH(Struts+Spring+Hibernate)架构,许多人的心里面就没有底。

依照本人来看,所谓的整合没有什么神秘的,只不过就是让三个框架在一起协同的工作,我们做的主要工作就是让其知道彼此的存在,打成“统一战线联盟”以后,再各自为战,互不干扰。

下面就本人知道的一些整合方法一一叙述。

1 Struts+Spring

主要就是让Struts知道Spring的存在,我们可以采用两种办法。

(1) 运用Struts的插件方法,添加struts-congif.xml的<plug-in>节点。

示例代码如下:

xml 代码
  1. <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">  
  2.         <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />  
  3.     </plug-in>   

上段代码意图很简单:把Struts的配置文件和Spring的配置文件联系起来,这样Struts就知道了Spring的存在。

另外,在web.xml里面需要配置一个Spring的监听器,示例代码如下:

xml 代码
  1. <listener>  
  2.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  3.     </listener>   

第一种方法完毕。

(2) 直接在web.xml里面进行加载。

这种方法与上种方法的不同之处在于Spring的配置文件加载的位置不同,上种方法是在struts-cong.xml中声明,而这种方法是在web.xml里面进行声明,示例代码如下:

xml 代码
  1. <context-param>  
  2.         <param-name>contextConfigLocation</param-name>  
  3.         <param-value>  
  4.              /WEB-INF/applicationContext-module1.xml,   
  5.              /WEB-INF/applicationContext-module2.xml  
  6.         </param-value>  
  7.     </context-param>  

这样我们就实现了第二种方法的SS整合。

问题至于我们还要遇到一个小问题,那就是Struts如何实用Spring的特性?Struts怎么就知道Spring注入的Bean呢?当然,这需要我们进行编程式的声明,众所周知,在Strus的Action里面有一个setServlet方法,我们此时就需要覆盖这个方法,当ActionServlet把请求转发到此Action时,Action就可以实用Spring的特性。

示例代码如下:

 

java 代码
  1. import org.springframework.context.ApplicationContext;   
  2. import org.springframework.web.context.support.WebApplicationContextUtils;   
  3.   
  4. public void setServlet(ActionServlet actionServlet) {   
  5.         try {   
  6.             super.setServlet(actionServlet);   
  7.              ServletContext servletContext = actionServlet.getServletContext();   
  8.              context = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);   
  9.          } catch(Exception e) {   
  10.              e.printStackTrace();   
  11.          }   
  12.      }  

 

其中context是ApplicationContext的实例,有了上串代码以后我们就可以以下面的方式进行Spring的特性利用了!

java 代码
  1. protected IXjdjService getXjdjServiceImp(){   
  2.         return (IXjdjService) context.getBean("xjdj");   
  3.      }  

到此OK,Struts与Spring的整合成功。

2 Spring+Hibernate

可以说Spring与Hibernate的整合是非常完善的,具体要素如下:

在Hibernate中,最重要的无非就是两点,一是配置数据库连接池,二是配置实体类的映射文件。现在我贴出上述两点在Spring里面是怎么配的,配置完毕以后,我们完全可以删除hibernate.cfg.xml文件。示例代码如下:

xml 代码
  1. <bean id="dataSource"     
  2.         class="org.springframework.jdbc.datasource.DriverManagerDataSource">     
  3.         <property name="driverClassName">     
  4.             <value>com.microsoft.jdbc.sqlserver.SQLServerDriver</value>     
  5.         </property>     
  6.         <property name="url">     
  7.             <value>jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=EXAM</value>     
  8.         </property>     
  9.         <property name="username">     
  10.             <value>sa</value>     
  11.         </property>     
  12.         <property name="password">     
  13.             <value>135780</value>     
  14.         </property>     
  15.     </bean>     
  16.     <!-- 配置Hibernate会话工厂 -->     
  17.     <bean id="sessionFactory"     
  18.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">     
  19.         <property name="dataSource">     
  20.             <ref bean="dataSource" />     
  21.         </property>     
  22.         <!-- 在此可以配置Hibernate会话工厂的属性 -->     
  23.         <property name="hibernateProperties">     
  24.             <props>     
  25.                 <prop key="hibernate.dialect">     
  26.                      org.hibernate.dialect.SQLServerDialect      
  27.                 </prop>     
  28.                 <prop key="hibernate.show_sql">true</prop>     
  29.                      
  30.              </props>     
  31.         </property>     
  32.         <!-- 在此可以匹配*.hbm.xml映射文件 -->     
  33.         <property name="mappingDirectoryLocations">     
  34.             <list>     
  35.                 <value>     
  36.                      classpath:/com/wjh/comm/framework/bean      
  37.                 </value>     
  38.                    
  39.             </list>     
  40.         </property>     
  41.         <property name="mappingResources">  
  42.            <list>  
  43.                 <value>com/wjh/example/User.hbm.xml</value>  
  44.           </list>  
  45. </property>  
  46. </bean>   

OK,到此就完成了Spring+Hibernate的整合,纵观整个过程,我们可以发现一点,那就是所谓的整合就是他们配置文件的融合,只要抓住这一点,再复杂的程序也会变的简单。

网友经常说,我也是这么做的,但是总是不成功。说实在的这个东西理论很简单,但是实际操作起来确实要费一番周折,大家在整合过程中出现了什么问题,不妨贴出来,我们一起讨论讨论!

http://hi.baidu.com/ziheng65/blog/item/0546d01609bedb4f21a4e904.html

posted @ 2008-06-13 13:45 飞飞 阅读(258) | 评论 (0)编辑 收藏

最近,在 bartsandbox 上,有人问我在 WebLogic 上配置 Hibernate 的具体步骤。您可能知道, Hibernate 是一个非常流行的开源对象关系映射 (Object Relational Mapping , ORM) 工具。下面是在 WebLogic 8.1 上配置 Hibernate 的具体步骤:
  
  首先要创建一个域。我创建了一个 WebLogic Workshop (WLW) 域,因为我打算使用 WLW 来创建和实现应用程序。
  
  将 hibernate...\lib\antlr-2.7.5H3.jar 添加到 PRE_CLASSPATH ,或者在 hibernate.cfg.XML 文件中将 query.factory_class 属性设为 user 2.x's query factory 。
  
  WLW 域还启动了一个 PointBase 数据库实例。我将使用这个内置实例。我创建了一个新的用户和模式。并为该模式填充了一些示例数据。
  
  在服务器实例中配置连接池和数据源。
  
  创建应用程序。我打算使用 WebLogic Workshop 创建。
  
  应该将库( jar 文件)(它们是成功运行 Hibernate 所必需的)放在哪里呢?放在应用程序的 APP-INF/lib 文件夹中。库包括 hibernate.jar 和附加的第三方库。引用 Hibernate Reference 的表格 3-1 。
  
  在 WLW 中创建一个 Java 项目。该 Java 项目包括映射到数据库的域类。 WLW 编译该项目,并将生成的 jar 文件放到 APP-INF/lib 目录下。在 Java 项目中编码域类。创建 Hibernate 映射文件和 Hibernate 配置文件。此外,从 Hibernate Reference 复制实现,创建 HibenateUtil 类。 Hibernate 配置文件包括数据源的 JNDI 名。
  
  创建一个 EJB 对象(例如,一个模块)。该项目包含了会话 bean 。编写一个操纵域类的会话 bean 。
  
  创建一个 Web 或 Web Service 项目(例如,一个模块)。该项目包含了可互操作性地测试会话 bean 的组件。
  
  完整、有效、自包含的示例应用程序 在此 。其中包括了模式和所有的 Hibernate 配置文件。(注:需要有 bartsandbox 的免费会员资格。)

http://www.knowsky.com/365592.html
posted @ 2008-06-13 09:17 飞飞 阅读(206) | 评论 (0)编辑 收藏

Spring MVC 框架。用银行示例介绍如何建模和构建简单的应用程序。示例应用程序包含了已经学过的一些技术(例如依赖注入),但是主要演示 Spring MVC 的特性。
  
  在开始之前,请 下载这篇文章的源代码。请参阅 参考资料 访问 Spring 框架和 Tomcat 5.0,运行示例需要它们。
  
  Spring MVC 框架
  
  Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构,可以选择是使用内置的 Spring Web 框架还是 Struts 这样的 Web 框架。通过策略接口,Spring 框架是高度可配置的,而且包含多种视图技术,例如 JavaServer Pages(JSP)技术、Velocity、Tiles、iText 和 POI。Spring MVC 框架并不知道使用的视图,所以不会强迫您只使用 JSP 技术。Spring MVC 分离了控制器、模型对象、分派器以及处理程序对象的角色,这种分离让它们更容易进行定制。
  
  Spring 的 Web MVC 框架是围绕 DispatcherServlet 设计的,它把请求分派给处理程序,同时带有可配置的处理程序映射、视图解析、本地语言、主题解析以及上载文件支持。默认的处理程序是非常简单的 Controller 接口,只有一个方法 ModelAndView handleRequest(request, response)。Spring 提供了一个控制器层次结构,可以派生子类。如果应用程序需要处理用户输入表单,那么可以继承 AbstractFormController。如果需要把多页输入处理到一个表单,那么可以继承 AbstractWizardFormController。
  
  示例应用程序有助于直观地学习这些特性。银行应用程序允许用户检索他们的帐户信息。在构建银行应用程序的过程中,可以学到如何配置 Spring MVC 框架和实现框架的视图层,视图层包括 JSTL 标记(用于显示输出的数据)和JavaServer Pages 技术。
  
  配置 Spring MVC
  
  要开始构建示例应用程序,请配置 Spring MVC 的 DispatcherServlet。请在 web.xml 文件中注册所有配置。清单 1 显示了如何配置 sampleBankingServlet。
  
  清单 1. 配置 Spring MVC DispatcherServlet
  
  <servlet>
  <servlet-name>sampleBankingServlet</servlet-name>
  <servlet-class>
  org.springframework.we.servlet.DispatcherServlet
  <servlet-class>
  <load-on-startup>1<load-on-startup>
  <servlet>
  
  DispatcherServlet 从一个 XML 文件装入 Spring 应用程序上下文,XML 文件的名称是 servlet 的名称后面加上 -servlet 。在这个示例中,DispatcherServlet 会从 sampleBankingServlet-servlet.xml 文件装入应用程序上下文。
  
  配置应用程序的 URL
  
  下一步是配置想让 sampleBankingServlet 处理的 URL。同样,还是要在 web.xml 中注册所有这些信息。
  
  清单 2. 配置想要处理的 URL
  
  <servlet-mapping>
  <servlet-name> sampleBankingServlet<servlet-name>
  <url-pattern>*.jsp</url-pattern>
  </servlet-mapping>
  
  装入配置文件
  
  下面,装入配置文件。为了做到这点,请为 Servlet 2.3 规范注册 ContextLoaderListener 或为 Servlet 2.2 及以下的容器注册 ContextLoaderServlet。为了保障后向兼容性,请用 ContextLoaderServlet。在启动 Web 应用程序时,ContextLoaderServlet 会装入 Spring 配置文件。清单 3 注册了 ContextLoaderServlet。
  
  清单 3. 注册 ContextLoaderServlet
  
  <servlet>
  <servlet-name>context>servlet-name>
  <servlet-class>
  org.springframework.web.context.ContextLoaderServlet
  </servlet-class>
  <load-on-startup>1</load-on-startup>
  </servlet>
  
  contextConfigLocation 参数定义了要装入的 Spring 配置文件,如下面的 servlet 上下文所示。
  
  <context-param>
  <param-value>contextConfigLocation</param-value>
  <param-value>/WEB-INF/sampleBanking-services.xml</param-value>
  </context-param>
  
  sampleBanking-services.xml 文件代表示例银行应用程序服务的配置和 bean 配置。如果想装入多个配置文件,可以在 <param-value> 标记中用逗号作分隔符。
  
  Spring MVC 示例
  
  示例银行应用程序允许用户根据惟一的 ID 和口令查看帐户信息。虽然 Spring MVC 提供了其他选项,但是我将采用 JSP 技术作为视图页面。这个简单的应用程序包含一个视图页用于用户输入(ID 和口令),另一页显示用户的帐户信息。
  
  我从 LoginBankController 开始,它扩展了 Spring MVC 的 SimpleFormController。SimpleFormContoller 提供了显示从 HTTP GET 请求接收到的表单的功能,以及处理从 HTTP POST 接收到的相同表单数据的功能。LoginBankController 用 AuthenticationService 和 AccountServices 服务进行验证,并执行帐户活动。“ 配置视图属性 ”一节中的 清单 5 描述了如何把 AuthenticationService 和 AccountServices 连接到 LoginBankController。 清单 4 显示了 LoginBankController 的代码。
 

清单 4. LoginBankController 扩展 SimpleFormController

public class LoginBankController extends SimpleFormController {

   public LoginBankController(){

   }

   protected ModelAndView onSubmit(Object command) throws Exception{

      LoginCommand loginCommand = (LoginCommand) command;
      authenticationService.authenticate(loginCommand);
      AccountDetail accountdetail = accountServices.getAccountSummary(loginCommand.getUserId());
      return new ModelAndView(getSuccessView(),"accountdetail",accountdetail);
   }

   private AuthenticationService authenticationService;

   private AccountServices accountServices;

   public AccountServices getAccountServices() {
      return accountServices;
   }

   public void setAccountServices(AccountServices accountServices) {
      this.accountServices = accountServices;
   }

   public AuthenticationService getAuthenticationService() {
      return authenticationService;
   }

   public void setAuthenticationService(
         AuthenticationService authenticationService) {
      this.authenticationService = authenticationService;
   }
}

 
  配置视图属性
  
  下面,我必须注册在接收到 HTTP GET 请求时显示的页面。我在 Spring 配置中用 formView 属性注册这个页面,如清单 5 所示。sucessView 属性代表表单数据提交而且 doSubmitAction() 方法中的逻辑成功执行之后显示的页面。formView 和 sucessView 属性都代表被定义的视图的逻辑名称,逻辑名称映射到实际的视图页面。
  
  清单 5. 注册 LoginBankController
  
  <bean id="loginBankController"
  class="springexample.controller.LoginBankController">
  <property name="sessionForm"><value>true</value></property>
  <property name="commandName"><value>loginCommand</value></property>
  <property name="commandClass">
  <value>springexample.commands.LoginCommand</value>
  </property>
  
  <property name="authenticationService">
  <ref bean="authenticationService" />
  </property>
  <property name="accountServices">
  <ref bean="accountServices" />
  </property>
  <property name="formView">
  <value>login</value>
  </property>
  <property name="successView">
  <value>accountdetail</value>
  </property>
  
  </bean>
  
  commandClass 和 commandName 标记决定将在视图页面中活动的 bean。例如,可以通过 login.jsp 页面访问 loginCommand bean,这个页面是应用程序的登录页面。一旦用户提交了登录页面,应用程序就可以从 LoginBankController 的 onSubmit() 方法中的命令对象检索出表单数据。
  
  视图解析器
  
  Spring MVC 的 视图解析器 把每个逻辑名称解析成实际的资源,即包含帐户信息的 JSP 文件。我用的是 Spring 的 InternalResourceViewResolver,如 清单 6 所示。

清单 6. InternalResourceViewResolver

<bean id="view-Resolver"
      class="org.springframework.web.servlet.view.InternalResourceViewResolver">
   <property name="viewClass">
      <value>org.springframework.web.servlet.view.JstlView</value>
   </property>
   <property name="prefix"><value>/jsp/</value></property>
   <property name="suffix"><value>.jsp</value></property>
</bean>


  因为我在 JSP 页面中使用了 JSTL 标记,所以用户的登录名称解析成资源 /jsp/login.jsp,而 viewClass 成为 JstlView。
  
  验证和帐户服务
  
  就像前面提到的,LoginBankController 内部连接了 Spring 的 AccountServices 和 AuthenticationService。AuthenticationService 类处理银行应用程序的验证。AccountServices 类处理典型的银行服务,例如查找交易和电汇。清单 7 显示了银行应用程序的验证和帐户服务的配置。
  
  清单 7. 配置验证和帐户服务
  
  <beans>
  
  <bean id="accountServices"
  class="springexample.services.AccountServices">
  
  </bean>
  
  <bean id="authenticationService"
  class="springexample.services.AuthenticationService">
  
  </bean>
  
  </beans>
  
  以上服务在 sampleBanking-services.xml 中注册,然后装入 web.xml 文件中,就像 前面讨论的那样。控制器和服务配置好后,这个简单的应用程序就完成了。现在我们来看看部署和测试它时会发生什么!
  
  部署应用程序
  
  我把示例应用程序部署在 Tomcat servlet 容器中。Tomcat 是 Java Servlet 和 Java ServerPagest 技术的官方参考实现中使用的 servlet 容器。如果以前没这么做过,请 下载 jakarta-tomcat-5.0.28.exe 并运行它把 Tomcat 安装到自己喜欢的任何位置,例如 c:\tomcat5.0。
  
  接下来,下载示例代码 并释放到驱动器(例如 c:\ )上。创建了 Spring 项目的文件夹之后,打开它并把 spring-banking 子文件夹拷贝到 c:\tomvat5.0\webapps。spring-banking 文件夹是一个 Web 档案,里面包含 Spring MVC 示例应用程序。lib 文件夹包含应用程序需要的 Spring 框架、与Spring 相关的 MVC 库以及 JSTL 标记库和 jar 文件。
  
  要启动 Tomcat 服务器,请使用以下命令:
  
  cd bin C:\Tomcat 5.0\bin> catalina.bat start
  Tomcat 应当启动并部署 Spring MVC 示例应用程序。
  
  测试应用程序
  
  要测试应用程序,请打开 Web 浏览器,指向 http://localhost:tomcatport/springbanking 并用 Tomcat 服务器实际运行的端口替换 tomcatport。应当看到图 1 所示的登录屏幕。输入用户 ID “admin”和口令“password”,并按下登录按钮。其他用户 ID 或口令会造成来自验证服务的错误。
  
  图 1. Spring MVC 示例登录屏幕


登录成功之后,会看到图 2 所示的帐户细节页面。
  
  图 2. Spring MVC 示例帐户细节页面
  


  结束语
  
  在三部分的 Spring 系列 的第三篇文章中,我介绍了 Spring MVC 框架的特性。我演示了如何配置和开发 Spring MVC 应用程序、如何配置 Spring MVC 控制器和向其中插入依赖项、如何用 JavaServer Pages 技术开发应用程序视图,以及如何把自己的页面与 Spring MVC 的视图层集成。总结这篇文章时,我演示了如何在 Tomcat servlet 容器中部署应用程序以及如何在浏览器中测试它。

posted @ 2008-06-12 23:48 飞飞 阅读(324) | 评论 (0)编辑 收藏

本文是开发基于spring的web应用的入门文章,前端采用Struts MVC框架,中间层采用spring,后台采用Hibernate。

  本文包含以下内容:

   ·配置Hibernate和事务

   ·装载Spring的applicationContext.xml文件

   ·建立业务层和DAO之间的依赖关系

   ·将Spring应用到Struts中

  简介

  这个例子是建立一个简单的web应用,叫MyUsers,完成用户管理操作,包含简单的数据库增,删,查,该即CRUD(新建,访问,更新,删除)操作。这是一个三层的web应用,通过Action(Struts)访问业务层,业务层访问DAO。图一简要说明了该应用的总体结构。图上的数字说明了流程顺序-从web(UserAction)到中间层(UserManager),再到数据访问层(UserDAO),然后将结果返回。

  Spring层的真正强大在于它的声明型事务处理,帮定和对持久层支持(例如Hiberate和iBATIS)

  以下下是完成这个例子的步骤:

  1. 安装Eclipse插件

  2. 数据库建表

  3. 配置Hibernate和Spring

  4. 建立Hibernate DAO接口的实现类

  5. 运行测试类,测试DAO的CRUD操作

  6. 创建一个处理类,声明事务

  7. 创建web层的Action和model

  8. 运行Action的测试类测试CRUD操作

  9. 创建jsp文件通过浏览器进行CRUD操作

  10. 通过浏览器校验jsp

  安装eclipse插件

  1. Hibernate插件http://www.binamics.com/hibernatesync

  2. Spring插件http://springframework.sourceforge.net/spring-ide/eclipse/updatesite/

  3. MyEclipse插件(破解版)

  4. Tomcat插件. tanghan

  5. 其他插件包括xml,jsp,

  数据库建表


create table app_user(id number not null primary,firstname vchar(32),lastname vchar(32));

  新建项目

  新建一个web project,新建后的目录结构同时包含了新建文件夹page用于放jsp文件,和源文件夹test用于放junit测试文件。同时将用到的包,包括struts,hibernate,spring都导入到lib目录下。

  创建持久层O/R mapping

  1. 在src/com.jandar.model下用hibernate插件从数据库导出app_user的.hbm.xml文件改名为User.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
   "-//Hibernate/Hibernate Mapping DTD//EN"
   "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
<hibernate-mapping package="com.jandar.model">
<class name="User" table="APP_USER">
 <id
  column="ID"
  name="id"
  type="integer"
 >

  <generator class="assigned" />

 </id>

 <property
   column="LASTNAME"
   length="10"
   name="lastname"
   not-null="false"
   type="string"
 />

 <property
   column="FIRSTNAME"
   length="10"
   name="firstname"
   not-null="true"
   type="string"
 />

</class>
</hibernate-mapping>

  2. 通过hibernate synchronizer->synchronizer file生成User.java文件,User对象对应于数据库中的app_user表

  注:在eclipse下自动生成的对象文件不完全相同,相同的是每个对象文件必须实现Serializable接口,必需又toString和hashCode方法;

import java.io.Serializable;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;

public class BaseObject implements Serializable {
 public String toString() {
  return ToStringBuilder.reflectionToString(this,
  ToStringStyle.MULTI_LINE_STYLE);
 }

 public boolean equals(Object o) {
  return EqualsBuilder.reflectionEquals(this, o);
 }

 public int hashCode() {
  return HashCodeBuilder.reflectionHashCode(this);
 }
}

public class User extends BaseObject {
 private Long id;
 private String firstName;
 private String lastName;

 /**
 * @return Returns the id.
 */

 public Long getId() {
  return id;
 }

 /**
  * @param id The id to set.
 */

 public void setId(Long id) {
  this.id = id;
 }

 /**
 * @return Returns the firstName.
 */

 public String getFirstName() {
  return firstName;
 }

 /**
  * @param firstName The firstName to set.
 */

 public void setFirstName(String firstName) {
  this.firstName = firstName;
 }

 /**
 * @return Returns the lastName.
 */

 public String getLastName() {
  return lastName;
 }

 /**
 * @param lastName The lastName to set.
 */

 public void setLastName(String lastName) {
  this.lastName = lastName;
 }
}

创建DAO访问对象

  1. 在src/com.jandar.service.dao新建IDAO.java接口,所有的DAO都继承该接口

package com.jandar.services.dao;

public interface IDAO {

}

  2. 在src/com.jandar.service.dao下新建IUserDAO.java接口

public interface IUserDAO extends DAO {
 List getUsers();
 User getUser(Integer userid);
 void saveUser(User user);
 void removeUser(Integer id);
}

  该接口提供了访问对象的方法,

  3. 在src/com.jandar.service.dao.hibernate下新建UserDAOHiberante.java

import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.orm.hibernate.support.HibernateDaoSupport;
import com.jandar.model.User;
import com.jandar.service.dao.IUserDAO;

public class UserDaoHibernate extends HibernateDaoSupport implements IUserDAO {

 private Log log=LogFactory.getLog(UserDaoHibernate.class);
 /* (非 Javadoc)
 * @see com.jandar.dao.IUserDAO#getUsers()
 */

 public List getUsers() {
  return getHibernateTemplate().find("from User");
 }

 /* (非 Javadoc)
 * @see com.jandar.dao.IUserDAO#getUser(java.lang.Long)
 */

 public User getUser(Integer id) {
  // TODO 自动生成方法存根
  return (User) getHibernateTemplate().get(User.class,id);
 }

 /* (非 Javadoc)
 * @see com.jandar.dao.IUserDAO#saveUser(com.jandar.model.User)
 */

 public void saveUser(User user) {
  log.debug("xxxxxxx");
  System.out.println("yyyy");
  getHibernateTemplate().saveOrUpdate(user);
  if(log.isDebugEnabled())
  {
   log.debug("userId set to "+user.getId());
  }
 }

 /* (非 Javadoc)
 * @see com.jandar.dao.IUserDAO#removeUser(java.lang.Long)
 */

 public void removeUser(Integer id) {
  Object user=getHibernateTemplate().load(User.class,id);
  getHibernateTemplate().delete(user);
  if(log.isDebugEnabled()){
   log.debug("del user "+id);
  }
 }
}

  在这个类中实现了IUserDAO接口的方法,并且继承了HibernateDAOSupport类。这个类的作用是通过hibernate访问、操作对象,进而实现对数据库的操作。
posted @ 2008-06-12 23:17 飞飞 阅读(484) | 评论 (0)编辑 收藏

这里主要讲在Eclipse下如何搭配Spring MVC + Hibernate框架进行Web开发,至于Eclipse以及JDK以及MyEclipse等的安装不在此列,也不使用MyEclipse来搭建,只是手工搭建的方式。

1.版本

JDK1.50;Eclipse3.2;MyEclipse 5.0;Tomcat 5.0;Spring2.0;Hibernate3.2。

2.准备

安装好Eclipse和JDK环境,由于不使用MyEclipse,需要自行准备两个主要的包:Spring.jar包、Hibernate3.jar,还有commons-dbcp.jar,commons-pool.jar,spring-orm.jar等这些包;这些表都可以在相应的项目网站中下载到,或者网上搜索。

安装好后Lib下包会有:

activation.jar

antlr-2.7.6.jar

asm.jar

cglib-2.1.3.jar

commons-beanutils.jar

commons-collections.jar

commons-collections-2.1.1.jar

commons-digester.jar

commons-fileupload.jar

commons-logging.jar

commons-logging-1.0.4.jar

commons-validator.jar

dom4j-1.6.1.jar

ehcache-1.2.jar

jakarta-oro.jar

jstl.jar

jta.jar

log4j-1.2.11.jar

mail.jar

ojdbc14.jar

standard.jar

以下几个是比较重要的:

commons-dbcp.jar

commons-pool.jar

hibernate3.jar

spring.jar

spring-orm.jar

如果要用到Struts,会有一个struts.jar包。

3.搭建:

首先在"File"菜单下"new" 一个"Project",选择"Other"下的MyEclipse下的"Web Project",把上面的包放到WebRoot/WEB-INF/lib下;

建立好工程后,我们在项目下的WebRoot/WEB-INF/下新建两个.xml文件,名字可以随便起(也可新建一个,内容和两个文件里面的内容一样即可),在这里命名为web-config.xml和model-config.xml,顾名思义,web-config.xml下配置和servlet以及控制逻辑等与WEB相关的bean,model-config.xml下配置与数据模型层相关的Bean,如数据访问的bean。

以下是model-config.xml内容:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

    <!-- 设定数据库连接池相关参数,这里使用的是Oracel的数据库 -->
    <bean id="dataSource"
    class="org.apache.commons.dbcp.BasicDataSource"
    destroy-method="close">
   <property name="driverClassName">
    <value>oracle.jdbc.driver.OracleDriver</value>
   </property>
   <property name="url">
    <value>jdbc:oracle:thin:@192.168.6.4:1521:database</value>
   </property>
   <property name="username">
    <value>username</value>
   </property>
   <property name="password">
    <value>password</value>
   </property>
</bean>
   
    <!-- 定义Hibernate sessionFactory 和Hibernate映射文件,所有的Hibernate映射文件统一在这里定义 -->
    <bean id="sessionFactory"
          class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"
          destroy-method="destroy">
        <property name="dataSource" ref="dataSource"/>
        <property name="mappingResources">
            <list>
<!-- Hibernate映射文件 把Hibernate的配置文件在这里映射,这里定义了一个UUser类的持久化类映射文件 -->
                <value>com/yondor/yuejiao/orm/UUser.hbm.xml</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">
                    org.hibernate.dialect.Oracle9Dialect
                </prop>
            </props>
        </property>
    </bean>
   
    <!-- Spring hibernateTemplate 模板定义 -->
    <bean id="hibernateTemplate"
          class="org.springframework.orm.hibernate3.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
      

<!-- Hibernate数据模型Bean定义 -->        
    <bean id="dbDAO"
           class="com.yondor.yuejiao.model.common.DbDAO">
        <property name="hibernateTemplate" ref="hibernateTemplate"/>
    </bean>


<!-- 以下是业务逻辑Bean的定义 -->

<!-- User模块开始 定义的bean可以在web-config.xml配置文件中使用-->
    <bean id="userDAO"
           class="com.yondor.yuejiao.model.example.UserDAO">
        <property name="dbDAO" ref="dbDAO"/>
     </bean>  
    <!-- User模块结束 -->

</beans>

 

以下是web-config.xml的内容:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
  
   <!-- Controller方法调用规则定义 -->
    <bean id="paraMethodResolver"
        class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
        <property name="paramName" value="action"/>
        <property name="defaultMethodName" value="list"/>
    </bean>
  
   <!-- 页面View层基本信息设定 -->
    <bean id="viewResolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass"
            value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/yuejiao/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

 

<!-- servlet映射列表,所有控制层Controller的servlet在这里定义 -->
    <bean id="urlMapping"
          class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
                <prop key="example.do">userController</prop>
            </props>
        </property>
    </bean>


<!-- 以下控制层Controller Bean定义开始 -->

<!-- User模块开始 -->
<!-- 一共注入了7个属性(Bean),其中userDAO为业务逻辑Bean,该Bean定义在model-config.xml相应的模块中 -->
    <bean id="userController"
                class="com.yondor.yuejiao.controller.example.UserController">
        <property name="methodNameResolver" ref="paraMethodResolver"/>

       <!-- 使用了在model-config.xml文件里定义userDAO-->
        <property name="userDAO" ref="userDAO"/>
        <!-- 以下的属性与处理后的跳转有有关 -->
        <property name="login_success" value="example/login_success"/>
        <property name="login_failure" value="example/login"/>
        <property name="register_success" value="example/register_success"/>
        <property name="register_failure" value="example/register"/>
        <property name="userInfoList" value="example/list"/>
    </bean>
    <!-- User模块结束 -->
   
   
    
</beans>

 

最后,还需要配置一下web.xml文件,内容如下:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
version="2.4">

    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>

    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/model-config.xml,/WEB-INF/web-config.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

 

到此,基本上已完成开发环境的搭建,最后,

右键单击项目名称——properties——java bulid path ——libraries,Add Jars把刚才加入的包引入到工程里面去即可。

 

资料来源:http://hi.baidu.com/lhx222/blog/item/3fc769cb4b4ae01bbe09e67a.html

posted @ 2008-06-12 16:34 飞飞 阅读(5087) | 评论 (0)编辑 收藏

Struts+Spring+Hibernate
  本次配置环境:Myeclipse5.5、MySQL5.0、Struts1.2、Spring2.0、Hibernate3.1
  一、建工程
  略。。。。。。
  二、要使用Struts、Spring、Hibernate必须导入必需的包
  1、Struts(和之前没区别)
  2、Spring
     分别导入Spring 2.0 Core Libraries、Spring 2.0 Web Libraries
     选择把*.jar Copy到工程/WebRoot/WEB-INF/lib下; 点击NEXT
     选择applicationContext.xml的目录,/WebRoot/WEB-INF;点击finish
  3、Hibernate
     在导入Hibernate时,当然先要配置DataSource咯,这里就不再说了
     选择导入Hibernate全选上
     选上复选框:Hibernate 3.1 Core......、Hibernate 3.1 Advanced......、Spring 2.0 ORM/DAO.......
     同样选择把*.jar Copy到工程/WebRoot/WEB-INF/lib下; 点击NEXT
     这里我们选择把hibernate交给spring去管理
  选中单选按钮 Spring configuration file...... 点击NEXT
     选择已存在的applicationContext.xml文件,
     填写SessionFactory ID :sessionFactory 点击NEXT
     这里我们需要填写Bean Id :dataSource
     选择 DB Driver :选择刚才配置的DataSource 点击NEXT
     这里不需要创建 SessionFactory Class 点击Finish
     注意:查看applicationContext.xml的变化
  三、映射VO、数据操作
  首先工程的结构建好,比较简单的结构:
  org.chenwj.dao
  org.chenwj.struts
  org.chenwj.struts.action
  org.chenwj.struts.form
  org.chenwj.vo
  映射表userinfo创建持久类到org.chenwj.vo目录
  在dao下创建数据库操作类 UserDAO 这里只是对数据库进去插入,代码如下:
  private SessionFactory sessionFactory;

      public SessionFactory getSessionFactory() ...{
         return sessionFactory;
      }
      public void setSessionFactory(SessionFactory sessionFactory) ...{
         this.sessionFactory = sessionFactory;
      }
      /**//* 用户注册 */
      public boolean regist(Userinfo user) ...{
         try ...{
             Session session = sessionFactory.openSession();
             Transaction tx = session.beginTransaction();
             session.save(user);
             tx.commit();
             session.close();
             return true;
         } catch (Exception ex) ...{
             ex.printStackTrace();
             return false;
                }
         }
      使用依赖注入,setter设值 sessionFactory
      到此数据层已经完成

  四、配置struts-config.xml
      添加action、form、jsp 略……
      首先在struts-config.xml添加一个插件
      <plug-in
      className="org.springframework.web.struts.ContextLoaderPlugIn">
         <set-property property="contextConfigLocation"
             value="/WEB-INF/applicationContext.xml" />
      </plug-in>
      为什么要添回这个插件呢?
      因为在后面会在applicationContext.xml下配置action,让action交给spring
      去管理,实现了struts的依赖注入机制
      接下来添加cuntroller,这里你可以使用DelegatingActionProxy代理
      <controller processorClass=
      "org.springframework.web.struts.DelegatingRequestProcessor"/>
      Controller取代了struts的RequestProcessor,在定义action里,我们可以省略
  type属性。(我个人比较喜欢用这个)下面让我们看配置好的struts-config.xml:
  <struts-config>
          <data-sources />
          <form-beans>
             <form-bean name="userForm"
             type="org.chenwj.struts.form.UserForm" />
          </form-beans>
      <global-exceptions />
      <global-forwards />
      <action-mappings>
         <action attribute="userForm" input="/index.jsp" name="userForm"
             path="/user" scope="request">
             <forward name="success" path="/success.jsp" />
             <forward name="error" path="/index.jsp" />
         </action><!--type属性可不写-->
      </action-mappings>

      <controller processorClass=
  "org.springframework.web.struts.DelegatingRequestProcessor"/>

       <message-resources
         parameter="org.chenwj.struts.ApplicationResources" />
       <plug-in
      className="org.springframework.web.struts.ContextLoaderPlugIn">
         <set-property property="contextConfigLocation"
             value="/WEB-INF/applicationContext.xml" />
       </plug-in>
  </struts-config>

五、在applicationContext.xml配置action
      这里我们先在 action类里添加一些业务逻辑,代码如下:
      public class UserAction extends Action ...{

 

      private UserDAO userDao;
      private Userinfo user;

      public ActionForward execute(ActionMapping mapping, ActionForm form,
         HttpServletRequest request, HttpServletResponse response) ...{
     UserForm userForm = (UserForm) form;
     //封装数据
     user.setName(userForm.getName());
         user.setPassword(userForm.getPassword());
         if(userDao.regist(user))...{
             return mapping.findForward("success");
         }
         return mapping.findForward("error");
      }

      public Userinfo getUser() ...{
         return user;
      }
      public void setUser(Userinfo user) ...{
         this.user = user;
      }
      public UserDAO getUserDao() ...{
         return userDao;
      }
      public void setUserDao(UserDAO userDao) ...{
         this.userDao = userDao;
      }}
      这里使用setter实现依赖注入了两个bean,接下来配置applicationContext.xml
      <beans xmlns="略……">
      <!—- 数据源 -->
      <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/demo"></property>
         <property name="username" value="root"></property>
         <property name="password" value="root"></property>
      </bean>
      <!--  sessionFactory -->
      <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/chenwj/vo/Userinfo.hbm.xml</value>
             </list>
         </property>
      </bean>
      <!--  数据库操作类  -->
      <bean id="userDao" class="org.chenwj.dao.UserDAO">
         <property name="sessionFactory">
             <ref local="sessionFactory" />
         </property>
      </bean>
      <!--  action需要注意:这里是name属性不是ID,同时要和struts-config.xml
        对应的 action path属性值相同,斜线也是必需的,通过这个属性scope=
        "prototype" 每次获取bean实例时都会产生新的实例,默认是单例-->
      <bean name="/user" class="org.chenwj.struts.action.UserAction"
         abstract="false" lazy-init="default" autowire="default"
         scope="prototype" dependency-check="default">
         <property name="userDao" ref="userDao" />
         <property name="user" ref="user" />
      </bean>
      <bean id="user" class="org.chenwj.vo.Userinfo" abstract="false"
         lazy-init="default" autowire="default"
           dependency-check="default">
      </bean>
  </beans>
      到此所有的配置已经完成,测试:
      HTTP Status 404 - Servlet action is not available
  The requested resource (Servlet action is not available) is not available
  这个错误是大部初学者整合 SSH 时都会遇到的问题

      首先建议你使用测试类进行测试,这样我们可以很快找到错误所在的地方
  public static void main(String[] args) ...{
      ApplicationContext context = new FileSystemXmlApplicationContext(
                "/WebRoot/WEB-INF/applicationContext.xml");
          UserDAO dao = (UserDAO)context.getBean("userDao");
         Userinfo user = new Userinfo();
         user.setName("aaa");
         user.setPassword("bbb");
         boolean a = dao.regist(user);
         if(a)...{
             System.out.println("OK");
         }
     }
  如果这里没出错,那么请你好好检查你的配置文件,是否写错或少了些什么东东了
      这里出的错误也跟使用的版本有关系,这里报的错一般都是说找不到XX类所报的异常
  那么请检查lib下有没commons-pool-1.2.jar包,如没请导入,这个问题也有可能是包
  之间的****,删除这个包hibernate-annotations.jar

  六、.sql文件、.jsp文件
  create table userinfo(
         id int(10) not null auto_increment,
 name varchar(20),
 password varchar(20),
 PRIMARY KEY  (id))
     <body>
        <html:form action="/user">
            name : <html:text property="name"/><br/>
            password : <html:password property="password"/><br/>
            <html:submit/><html:cancel/>
        </html:form>
     </body>

posted @ 2008-06-12 15:56 飞飞 阅读(557) | 评论 (0)编辑 收藏

仅列出标题
共12页: First 上一页 4 5 6 7 8 9 10 11 12 下一页