dwr2.0+spring2.5+hibernate3.2整合

dwr越来越强大和spring的结合也很方便

 用dwr直接调用spring和hibernate整合后的service层 这样可以绕开使用struts jsf 这样的mvc框架

 然后页面全部换成静态的结合jquery ext dojo yui这样的库效果

 在用spring把acegi整合进来控制权限 我觉得是个不错的选择

以后如果osgi和spring hibernate的整合成熟了可以直接转成osgi的形式。

需要的包如下不能少了,最好不要有重复的可能会冲突：

           

web.xml如下：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
5.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
7.     <!-- Spring ApplicationContext配置文件的路径,可使用通配符，多个路径用,号分隔,此参数用于后面的Spring-Context loader -->
8.     <context-param>
9.         <param-name>contextConfigLocation</param-name>
10.         <param-value>
11.         classpath:applicationContext.xml,
12.         classpath:com/demonstration/entityclass/applicationContext-dao.xml
13.         </param-value>
14.     </context-param>
16.     <!--log4j配置文件路径配置  -->
17.     <context-param>
18.         <param-name>log4jConfigLocation</param-name>
19.         <param-value>classpath:log4j.properties</param-value>
20.     </context-param>
22.     <!-- 著名 Character Encoding filter -->
23.     <filter>
24.         <filter-name>encodingFilter</filter-name>
25.         <filter-class>
26.             org.springframework.web.filter.CharacterEncodingFilter
27.         </filter-class>
28.         <init-param>
29.             <param-name>encoding</param-name>
30.             <param-value>UTF-8</param-value>
31.         </init-param>
32.     </filter>
35.     <!--Hibernate Open Session in View Filter-->
36.     <!-- 假设在你的应用中Hibernate是通过spring 来管理它的session.如果在你的应用中没有使用OpenSessionInViewFilter
37.         或者OpenSessionInViewInterceptor。session会在transaction结束后关闭，此时会抛出session is close 的异常-->
38.     <filter>
39.         <filter-name>hibernateFilter</filter-name>
40.         <filter-class>
41.             org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
42.         </filter-class>
43.     </filter>
45.     <!-- 过滤器映射 -->
46.     <filter-mapping>
47.         <filter-name>encodingFilter</filter-name>
48.         <url-pattern>/*</url-pattern>
49.     </filter-mapping>
51.     <filter-mapping>
52.         <filter-name>hibernateFilter</filter-name>
53.         <url-pattern>/*</url-pattern>
54.     </filter-mapping>
56.     <!--Spring ApplicationContext 载入    -->
57.     <listener>
58.         <listener-class>
59.             org.springframework.web.context.ContextLoaderListener
60.         </listener-class>
61.     </listener>
63.     <!-- 扩展spring bean的作用域有request,session,global session等-->
64.     <listener>
65.         <listener-class>
66.             org.springframework.web.context.request.RequestContextListener
67.         </listener-class>
68.     </listener>
70.     <!-- log4j监听器载入 -->
71.     <listener>
72.         <listener-class>
73.             org.springframework.web.util.Log4jConfigListener
74.         </listener-class>
75.     </listener>
77.     <!-- session超时定义,单位为分钟 -->
78.     <session-config>
79.         <session-timeout>30</session-timeout>
80.     </session-config>
81.     
82.     <!-- dwr配置 -->
83.     <servlet>
84.         <servlet-name>dwr</servlet-name>
85.         <servlet-class>
86.             org.directwebremoting.spring.DwrSpringServlet
87.         </servlet-class>
88.         <init-param>
89.             <param-name>debug</param-name>
90.             <param-value>true</param-value>
91.         </init-param>
92.     </servlet>
93.     <servlet-mapping>
94.         <servlet-name>dwr</servlet-name>
95.         <url-pattern>/dwr/*</url-pattern>
96.     </servlet-mapping>
98.     <!--  -->
99.     <welcome-file-list>
100.         <welcome-file>index.jsp</welcome-file>
101.     </welcome-file-list>
102. </web-app>

log4j.properties

1. log4j.rootLogger=INFO, stdout, logfile
2. log4j.logger.org.springframework=WARN //控制spring的日志输出
3. log4j.logger.org.hibernate=WARN       //控制hibernate的日志输出
5. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
6. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
7. log4j.appender.stdout.layout.ConversionPattern=%p [%c] - %m%n
9. log4j.appender.logfile=org.apache.log4j.RollingFileAppender
10. log4j.appender.logfile.File=../logs/demonstration.log
11. log4j.appender.logfile.MaxFileSize=512KB
12. # Keep three backup files.
13. log4j.appender.logfile.MaxBackupIndex=3
14. # Pattern to output: date priority [category] - message
15. log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
16. log4j.appender.logfile.layout.ConversionPattern=%p [%c] - %m%n

applicationContext.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
6.     <!-- 使用外部文件配置数据源的属性 -->
7.     <bean
8.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
9.         <property name="locations">
10.             <list>
11.                 <!-- 外部文件地址 -->
12.                 <value>classpath:database_conn.properties</value>
13.             </list>
14.         </property>
15.         <property name="fileEncoding" value="utf-8" />
16.     </bean>
18.     <!-- 配置数据源 -->
19.     <bean id="dataSource"
20.           class="com.mchange.v2.c3p0.ComboPooledDataSource" 
21.           destroy-method="close">
22.        <property name="driverClass" value="${driverClassName}" />
23.        <property name="jdbcUrl" value="${url}"/>
24.        <property name="user" value="${username}"/>
25.        <property name="password" value="${password}"/>
26.        
27.        <!--连接池中保留的最小连接数。-->
28.        <property name="minPoolSize" value="5" />
29.             
30.        <!--连接池中保留的最大连接数。Default: 15 -->
31.        <property name="maxPoolSize" value="20" />
32.        
33.        <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
34.         <property name="initialPoolSize" value="10" />
35.       
36.        <!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
37.         <property name="maxIdleTime" value="60" />
38.        
39.        <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
40.         <property name="acquireIncrement" value="5" />
41.        
42.        <!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements
43.           属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
44.           如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0-->
45.         <property name="maxStatements" value="0"/>
47.        <!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
48.         <property name="idleConnectionTestPeriod" value="60"/>
49.       
50.        <!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
51.         <property name="acquireRetryAttempts" value="5" />
53.        <!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效
54.           保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试
55.           获取连接失败后该数据源将申明已断开并永久关闭。Default: false-->
56.         <property name="breakAfterAcquireFailure" value="true" />
57.   
58.         <!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的
59.           时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
60.           等方法来提升连接测试的性能。Default: false -->
61.         <property name="testConnectionOnCheckout" value="false" />
62.     </bean>
64.     <!-- hibernate3 sessionfactory配置 
65.         使用AnnotationSessionFactoryBean创建基于JPA注解的SessionFactory-->
66.     <bean id="sessionFactory"
67.         class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
68.         <!-- 引用数据源 -->
69.         <property name="dataSource">
70.             <ref bean="dataSource" />
71.         </property>
72.         <!-- hibernate的属性具体见hibernate文档 -->
73.         <property name="hibernateProperties">
74.             <props>
75.                 <prop key="hibernate.dialect">
76.                     org.hibernate.dialect.MySQLDialect
77.                 </prop>
78.                 <prop key="hibernate.show_sql">true</prop>
79.                 <prop key="hibernate.generate_statistics">true</prop>
80.                 <prop key="hibernate.connection.release_mode">auto</prop>
81.                 <prop key="hibernate.autoReconnect">true</prop>
82.                 <prop key="hibernate.cache.use_query_cache">true</prop>
83.                 <prop key="hibernate.cache.provider_class">
84.                     org.hibernate.cache.EhCacheProvider
85.                 </prop>      
86.             </props>
87.         </property>
88.         <!-- annotatedClasses属性指定使用JPA注解实体类名 可以通过annotatedPackages指定实体类包名 -->
89.         <property name="annotatedClasses">
90.             <list>
91.                 <!-- 指定注解的实体类 -->
92.                 <value>com.demonstration.entityclass.Demodata</value>
93.             </list>
94.         </property>
95.         <!-- 通过相对于类路径指定映射文件 可以内嵌多个<value>的<list>元素 也可以通过逗号分隔 属性类型String[] 
96.             这种配置为映射文件配置-->
97.         <property name="mappingResources">
98.             <list>
99.                 <!-- 指定xml配置文件 -->
100.             </list>
101.         </property>
102.     </bean>
103.     
104.     <!-- 导入spring aop配置文件 -->
105.     <import resource="applicationContext-tx.xml" />
106.     <!-- 导入spring 注解配置文件 -->
107.     <import resource="applicationContext-annotation.xml" />
108. </beans>

database_conn.properties

2. driverClassName=你的数据库驱动
3. url=你的数据库地址
4. username=数据库用户名
5. password=数据库密码

applicationContext-tx.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!-- 使用aop/tx命名空间 -->
3. <beans xmlns="http://www.springframework.org/schema/beans"
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5.     xmlns:aop="http://www.springframework.org/schema/aop"
6.     xmlns:tx="http://www.springframework.org/schema/tx"
7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
8.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
9.         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
11.     <!-- 配置事务管理器bean,使用HibernateTransactionManager事务管理器 -->
12.     <bean id="txManager"
13.         class="org.springframework.orm.hibernate3.HibernateTransactionManager">
14.         <!-- 为事务管理器注入sessionFactory" -->
15.         <property name="sessionFactory">
16.             <ref bean="sessionFactory" />
17.         </property>
18.     </bean>
20.     <!-- 通过aop定义事务增强切面 --> 
21.     <aop:config>
22.         <!-- 使用强大的切点表达式语言轻松定义目标方法 -->
23.         <aop:pointcut id="serviceMethod"
24.             expression="execution(* com.demonstration.hibernate.basedao.BaseDao.*(..))" />
25.         <!-- 引用事务增强 -->
26.         <aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice" />
27.     </aop:config>
29.     <!-- 事务增强 -->
30.     <tx:advice id="txAdvice" transaction-manager="txManager">
31.         <!-- 属性事务定义 -->
32.         <tx:attributes>
33.             <!--OpenSessionInViewFilter在getSession的时候,会把获取回来的session的flush mode 设为FlushMode.NEVER。
34.             然后把该sessionFactory绑定到TransactionSynchronizationManager，使request的整个过程都使用同一个session，
35.             在请求过后再接除该sessionFactory的绑定，最后closeSessionIfNecessary根据该session是否已和transaction绑定来决定是否关闭session。
36.             在这个过程中，若HibernateTemplate 发现自当前session有不是readOnly的transaction，就会获取到FlushMode.AUTO Session，使方法拥有写权限。 
37.             也即是，如果有不是readOnly的transaction就可以由Flush.NEVER转为Flush.AUTO,拥有insert,update,delete操作权限，如果没有transaction，
38.             并且没有另外人为地设flush model的话，则doFilter的整个过程都是Flush.NEVER。所以受transaction保护的方法有写权限，没受保护的则没有  -->
39.             <tx:method name="get*" />
40.             <tx:method name="save*" />
41.             <tx:method name="create*" />
42.             <tx:method name="remove*"/>
43.         </tx:attributes>
44.     </tx:advice>
45.     
46. </beans>

applicationContext-annotation.xml这个是dwr配置的关键，尤其是命名空间TMD超多容易搞错

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.     xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
5.     xmlns:context="http://www.springframework.org/schema/context"
6.     xmlns:aop="http://www.springframework.org/schema/aop"
7.     xsi:schemaLocation="http://www.springframework.org/schema/beans      
8.     http://www.springframework.org/schema/beans/spring-beans-2.5.xsd     
9.     http://www.springframework.org/schema/context      
10.     http://www.springframework.org/schema/context/spring-context-2.5.xsd
11.     http://www.directwebremoting.org/schema/spring-dwr
12.     http://www.directwebremoting.org/schema/spring-dwr-2.0.xsd
13.     http://www.springframework.org/schema/aop 
14.     http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
15.     
16.     <!-- 隐式注册了AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor -->
17.     <context:component-scan base-package="com.demonstration.service" />
18.     
19.     <!-- dwr初始化配置参看官方文档 -->
20.     <dwr:configuration></dwr:configuration>
21.         
22.     <bean class="com.demonstration.dwrinvoke.DemoTest" scope="session">
23.        <dwr:remote javascript="DemoTest">
24.            <dwr:include method="getDemodata"/>
25.            <dwr:convert type="bean" class="com.demonstration.entityclass.Demodata" />
26.        </dwr:remote>
27.        <!-- 如果想要scope='session'起作用的话就加上下面这句
28.             并且保证这个bean实现了接口 这个接口有上面dwr声明要
29.             调用的方法 -->
30.        <aop:scoped-proxy proxy-target-class="false"/>
31.     </bean>
32. </beans>

配置文件就暂时就这些.关于dao的配置在这里：http://blog.csdn.net/tom_221x/archive/2008/12/05/3453312.aspx

1.     <!-- 隐式注册了AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor -->
2.     <context:component-scan base-package="com.demonstration.service" />
3. 
   

  

   说明了在com.demonstration.service这个包下面的类是spring注解的并且有spring自动加载

1. package com.demonstration.service;
2. import java.util.List;
3. import javax.annotation.PostConstruct;
4. import javax.annotation.Resource;
5. import org.springframework.stereotype.Service;
6. import com.demonstration.base.BaseService;
7. import com.demonstration.entityclass.Demodata;
8. import com.demonstration.hibernate.basedao.IBaseDao;
9. import com.demonstration.service.interfaces.ITest;
10. @Service("testServiceImp") //表示这个类注解为spring的bean 引号里的是bean的id
11. public class TestServiceImp extends BaseService implements ITest{
12.   
13.     @Resource(name="demoDao") //把spring容器中id为demoDao的dao注入到这里(不需要setter方法了)
14.     private IBaseDao<Demodata> demoDao;
15.   
16.     @PostConstruct   //会在这个bean加载前调用这个方法 纯属测试用的
17.     public void postConstruct() {
18.         log.info("测试service bean初始化成功");
19.     }
20.     public List<Demodata> getDemodata() { //dao的数据库操作
21.         
22.         return demoDao.getAll();
23.     }     
24.     
25. }    

 

接口一个：

1. package com.demonstration.service.interfaces;
3. import java.util.List;
5. import com.demonstration.entityclass.Demodata;
7. public interface ITest {
8.   public List<Demodata> getDemodata();
9. }

1.  <bean class="com.demonstration.dwrinvoke.DemoTest" scope="session">
2.        <dwr:remote javascript="DemoTest">
3.            <dwr:include method="getDemodata"/>
4.            <dwr:convert type="bean" class="com.demonstration.entityclass.Demodata" />
5.        </dwr:remote>
6.        <!-- 如果想要scope='session'起作用的话就加上下面这句
7.             并且保证这个bean实现了接口 这个接口有上面dwr声明要
8.             调用的方法 -->
9.        <aop:scoped-proxy proxy-target-class="false"/>
10.     </bean>
11. </beans>

这个配置中的com.demostration.dwrinvoke.DemoTest如下：

1. package com.demonstration.dwrinvoke;
3. import java.util.List;
5. import javax.annotation.Resource;
7. import com.demonstration.service.interfaces.ITest;
8. import com.demonstration.base.BaseDwrInvoke;
9. import com.demonstration.entityclass.Demodata;
12. public class DemoTest extends BaseDwrInvoke implements ITest {
13.   
14.   @Resource(name="testServiceImp") //植入的服务类有spring注解注入
15.   private ITest testService;
16.   
17.   public List<Demodata> getDemodata(){ //这个方法就是公开给dwr在页面上调用的方法 配置文件有描述
18.       log.info("dwr调用成功");
19.       return testService.getDemodata();
20.   }
21.   
22. }

等到dwr3.0的时候用<dwr:component-scan/>和<dwr:annotation-config/>就可以实现零xml配置了,全部用注解实现。

现在在页面上导入正确的包之后就可以用：

1.       function test(){
2.         DemoTest.getDemodata(function(data){ //调用spring的sevice bean
3.             dwr.util.setValue("d", data);
4.         });
5.       }