Ssh整合

 

   Ssh整合

 

 

Spring整合Struts2的步骤

1、先配置运行一个Struts2工程。

       * 拷贝相关jar包到lib目录下

       * 拷贝struts.xml到src目录下

       * 在web.xml中加入Struts2的拦截器

              <filter>

               <filter-name>struts2</filter-name>

               <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>

           </filter>

      

           <filter-mapping>

               <filter-name>struts2</filter-name>

               <url-pattern>/*</url-pattern>

           </filter-mapping>

2、配置Spring：

       * 相关jar包拷贝到lib目录下。

       * 在src目录下创建Spring的配置文件：bean.xml

       * 在web.xml文件中加入ContextLoaderListener，用来创建Spring容器：

              <context-param>

                  <param-name>contextConfigLocation</param-name>

                  <param-value>classpath*:bean.xml</param-value>

           </context-param>

          

           <!-- 使用ContextLoaderListener初始化Spring容器 -->

              <listener>

                     <listener-class>org.springframework.web.context.ContextLoaderListener

                     </listener-class>

              </listener>

3、Struts2和Spring的整合

       * 把struts2-spring-plugin-2.2.3.1.jar拷贝到lib路径下

       * 把Struts2的Action的创建交给Spring

       * 在Struts2的配置文件中配置Action时，class属性指定为Spring中生成的Action的bean ID。

       注意：必须配置Struts2的Action的scope为prototype  

      

===========================================================

 

整合Hibernate

 

1、添加Jar包：

       * hibernate相关jar包

       * aop及数据库连接等相关jar包，具体参考工程中的jar包

2、在Spring的配置文件中添加数据源和Hibernate的相关配置

  * 数据源

         <!-- 定义数据源Bean，使用C3P0数据源实现 -->

              <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

                     destroy-method="close">

                     <!-- 指定连接数据库的驱动 -->

                     <property name="driverClass" value="com.mysql.jdbc.Driver"/>

                     <!-- 指定连接数据库的URL -->

                     <property name="jdbcUrl" value="jdbc:mysql://localhost/ssh"/>

                     <!-- 指定连接数据库的用户名 -->

                     <property name="user" value="root"/>

                     <!-- 指定连接数据库的密码 -->

                     <property name="password" value="123456"/>

                     <!-- 指定连接数据库连接池的最大连接数 -->

                     <property name="maxPoolSize" value="40"/>

                     <!-- 指定连接数据库连接池的最小连接数 -->

                     <property name="minPoolSize" value="1"/>

                     <!-- 指定连接数据库连接池的初始化连接数 -->

                     <property name="initialPoolSize" value="1"/>

                     <!-- 指定连接数据库连接池的连接的最大空闲时间 -->

                     <property name="maxIdleTime" value="20"/>

              </bean>

       * Hibernate的SessionFactory相关配置：

              <!-- 定义Hibernate的SessionFactory -->

              <bean id="sessionFactory"

                     class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

                     <!-- 依赖注入数据源，注入正是上面定义的dataSource -->

                     <property name="dataSource" ref="dataSource"/>

                     <!-- mappingResouces属性用来列出全部映射文件 -->

                     <property name="mappingResources">

                            <list>

                                   <!-- 以下用来列出Hibernate映射文件 -->

                                   <value>cn/hnpi/lis/entity/User.hbm.xml</value>

                            </list>

                     </property>

                     <!-- 定义Hibernate的SessionFactory的属性 -->

                     <property name="hibernateProperties">

                            <!-- 配置Hibernate属性  -->

                            <value>

                            hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect

                            hibernate.hbm2ddl.auto=update

                            hibernate.show_sql=true

                            hibernate.format_sql=true;

                           

                            </value>

                     </property>

              </bean>  

3、配置声明式事务

       <!-- 配置Hibernate的局部事务管理器，使用HibernateTransactionManager类 -->

       <!-- 该类实现PlatformTransactionManager接口，是针对Hibernate的特定实现-->

       <bean id="transactionManager"

              class="org.springframework.orm.hibernate3.HibernateTransactionManager">

              <!-- 配置HibernateTransactionManager时需要依注入SessionFactory的引用 -->

              <property name="sessionFactory" ref="sessionFactory"/>

       </bean>

       <!-- 配置事务增强处理,指定事务管理器 -->

       <tx:advice id="txAdvice" transaction-manager="transactionManager">

              <!-- 用于配置详细的事务语义 -->

              <tx:attributes>

                     <!-- 所有以'get'开头的方法是read-only的 -->

                     <tx:method name="find*" read-only="true"/>

                     <!-- 其他方法使用默认的事务设置 -->

                     <tx:method name="*"/>

              </tx:attributes>

       </tx:advice>

       <aop:config>

              <!-- 配置一个切入点 -->

              <aop:pointcut id="myPointcut"

                     expression="execution(* cn.hnpi.lis.service.impl.*.*(..))"/>

              <!-- 指定在myPointcut切入点应用txAdvice事务增强处理 -->

              <aop:advisor advice-ref="txAdvice"

                     pointcut-ref="myPointcut"/>

       </aop:config>

 

4、具体代码编写，演示系统工作：

  * 编写实体类和映射文件，并将配置文件加入到mappingResources属性中

  * 编写Dao：Dao接口和相应的实现，并在实现中声明SessionFactory，然后再Spring的配置文件中进行配置，并注入SessionFactory。

  * 编写Service：Service接口及相应的实现类，在Service中声明Dao，实现相关业务操作；然后再Spring的配置文件中进行配置，并注入相应的Dao实现。

  * 编写Action：在Action中声明用到的Service，使用Spring中注入Service的实现。

  * 编写jsp，测试。

      

 

 

具体的实例如下：

 

 

Bean.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"

  xmlns:context="http://www.springframework.org/schema/context"

  xmlns:aop="http://www.springframework.org/schema/aop"

  xmlns:tx="http://www.springframework.org/schema/tx"

  xsi:schemaLocation="

    http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

   

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-3.0.xsd

   

    http://www.springframework.org/schema/aop

    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

   

    http://www.springframework.org/schema/tx

    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

">

 

  <!-- 定义数据源Bean，使用C3P0数据源实现 -->

  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

    destroy-method="close">

    <!-- 指定连接数据库的驱动 -->

    <property name="driverClass" value="com.mysql.jdbc.Driver"/>

    <!-- 指定连接数据库的URL -->

    <property name="jdbcUrl" value="jdbc:mysql://localhost/ssh"/>

    <!-- 指定连接数据库的用户名 -->

    <property name="user" value="root"/>

    <!-- 指定连接数据库的密码 -->

    <property name="password" value="123456"/>

    <!-- 指定连接数据库连接池的最大连接数 -->

    <property name="maxPoolSize" value="40"/>

    <!-- 指定连接数据库连接池的最小连接数 -->

    <property name="minPoolSize" value="1"/>

    <!-- 指定连接数据库连接池的初始化连接数 -->

    <property name="initialPoolSize" value="1"/>

    <!-- 指定连接数据库连接池的连接的最大空闲时间 -->

    <property name="maxIdleTime" value="20"/>

  </bean>

 

  <!-- 定义Hibernate的SessionFactory -->

  <bean id="sessionFactory"

    class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

    <!-- 依赖注入数据源，注入正是上面定义的dataSource -->

    <property name="dataSource" ref="dataSource"/>

    <!-- mappingResouces属性用来列出全部映射文件 -->

    <property name="mappingResources">

      <list>

        <!-- 以下用来列出Hibernate映射文件 -->

        <value>cn/hnpi/lis/entity/User.hbm.xml</value>

      </list>

    </property>

    <!-- 定义Hibernate的SessionFactory的属性 -->

    <property name="hibernateProperties">

      <!-- 配置Hibernate属性  -->

      <value>

      hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect

      hibernate.hbm2ddl.auto=update

      hibernate.show_sql=true

      hibernate.format_sql=true;

     

      </value>

    </property>

  </bean>

 

 

  <!-- 配置Hibernate的局部事务管理器，使用HibernateTransactionManager类 -->

  <!-- 该类实现PlatformTransactionManager接口，是针对Hibernate的特定实现-->

  <bean id="transactionManager"

    class="org.springframework.orm.hibernate3.HibernateTransactionManager">

    <!-- 配置HibernateTransactionManager时需要依注入SessionFactory的引用 -->

    <property name="sessionFactory" ref="sessionFactory"/>

  </bean>

  <!-- 配置事务增强处理,指定事务管理器 -->

  <tx:advice id="txAdvice" transaction-manager="transactionManager">

    <!-- 用于配置详细的事务语义 -->

    <tx:attributes>

      <!-- 所有以'get'开头的方法是read-only的 -->

      <tx:method name="find*" read-only="true"/>

      <!-- 其他方法使用默认的事务设置 -->

      <tx:method name="*"/>

    </tx:attributes>

  </tx:advice>

  <aop:config>

    <!-- 配置一个切入点 -->

    <aop:pointcut id="myPointcut"

      expression="execution(* cn.hnpi.lis.service.impl.*.*(..))"/>

    <!-- 指定在leePointcut切入点应用txAdvice事务增强处理 -->

    <aop:advisor advice-ref="txAdvice"

      pointcut-ref="myPointcut"/>

  </aop:config>

 

 

 

  <!-- 由Spring生成Struts2的Action，注意：必须配置Struts2的Action的scope为prototype -->

  <bean id="loginAction" class="cn.hnpi.lis.action.LoginAction" scope="prototype">

    <property name="userService" ref="userService"></property>

  </bean>

 

  <bean id="userAction" class="cn.hnpi.lis.action.UserAction" scope="prototype">

    <property name="userService" ref="userService"></property>

  </bean>

 

  <bean id="userService" class="cn.hnpi.lis.service.impl.UserServiceImpl">

    <property name="userDao" ref="userDao"></property>

  </bean>

 

  <bean id="userDao" class="cn.hnpi.lis.dao.impl.UserDaoImpl">

    <property name="sf" ref="sessionFactory"></property>

  </bean>

 

</beans>

 

 

Web.xml

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

  id="WebApp_ID" version="2.5">

  <display-name>ss</display-name>

 

 

 

  <filter>

    <filter-name>struts2</filter-name>

    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>

  </filter>

 

  <filter-mapping>

    <filter-name>struts2</filter-name>

    <url-pattern>/*</url-pattern>

  </filter-mapping>

 

  <context-param>

    <param-name>contextConfigLocation</param-name>

    <param-value>classpath*:bean.xml</param-value>

  </context-param>

 

  <!-- 使用ContextLoaderListener初始化Spring容器 -->

  <listener>

    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

  </listener>

 

 

 

 

  <welcome-file-list>

    <welcome-file>index.html</welcome-file>

    <welcome-file>index.htm</welcome-file>

    <welcome-file>index.jsp</welcome-file>

    <welcome-file>default.html</welcome-file>

    <welcome-file>default.htm</welcome-file>

    <welcome-file>default.jsp</welcome-file>

  </welcome-file-list>

</web-app>

 

Struts.xml

 

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts PUBLIC

    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"

    "http://struts.apache.org/dtds/struts-2.0.dtd">

 

<struts>

 

    <constant name="struts.devMode" value="false" />

 

    <package name="default" namespace="/" extends="struts-default">

    <!--  没有Spring时的配置方式

    <action name="login" class="cn.hnpi.lis.action.LoginAction" method="login">

      <result name="success">login_success.jsp</result>

      <result name="login">login.jsp</result>

    </action>

        -->

       

        <!-- 由Spring创建Action -->

        <action name="login" class="loginAction" method="login">

      <result name="success">login_success.jsp</result>

      <result name="login">login.jsp</result>

    </action>

   

    <action name="add" class="userAction" method="add">

      <result>add_success.jsp</result>

    </action>

   

   

    </package>

 

 

</struts>

 

 

1、Hibernate

要求：

  * 编写一个Student类，包含id,name,age属性。

  * 编写Student的映射文件和Hibernate相应的配置文件，应用Hibernate技术生成数据库表“t_stu"，

        数据库主键采用自增长方式。

  * 编写HibernateUtil类，用来生成SessionFactory，并获取Session。

  * 编写测试类，完成以下操作：

      △  生成两个Student对象，通过Hibernate持久化到数据库中。

      △  查询所有的Student，并输出每个Student的id,name,age的值。

      △  查询age>20的学生， 并输出这些Student的id,name,age的值。

     

2、Spring

要求：

  * 定义一个接口Axe和相应的实现类SteelAxe，接口Axe中有一个chop()方法.

  * 定义一个Peron接口和相应的实现类Chinese，接口Peron中有一个useAxe()方法。

  * 在Chinese中有一个Axe类型的属性，类Chinese中的方法useAxe()调用Axe中的chop()方法。

  * 利用Spring的依赖注入功能，在配置文件中配置Chinese的Axe属性的值。

  * 编写测试程序，生成Spring容器，调用Person的useAxe()方法。

 

3、简答题

  * 什么是ORM？

  * ORM的基本映射关系有哪些？(

  数据表映射类

  数据表的行映射对象（实例）

  数据表的字段（列）映射对象的属性

)

  * Hibernate与其他ORM相比优势有哪些？（

       Hibernate是目前最流行的ORM框架，其作者Gavin King采用非常优雅的方式将SQL操作完全包装成对象的操作。

?目前Hibernate在国内的开发人员相当多，Hibernate的文档也非常丰富。

Hibernate是一个面向Java环境的对象/关系数据库映射工具。

?Hibernate的目标是：释放开发者通常的数据持久化相关的编程任务的95%。

 

）

  * Hibernate中的关联映射有哪几种。（

        双向1-N关联

      ?双向N-N关联

      ?双向1-1关联

      单向1-1

?单向1-N

?单向N-1

?单向N-N

?双向1-1

?双向1-N

?双向N-N双向1-1

 

常用的双向关联：

–基于外键的双向1-N关联

–基于连接表的双向N-N关联

–基于外键的双向1-1关联

 

）

  * Spring有哪些优点？

 

低侵入式设计，代码污染率极低

?不依赖于容器，再各种容器内都可以轻松使用

?Spring的依赖注入为程序提供了高层次的解耦，降低了业务对象替换的复杂性

?Spring的高度开放性，用户可以根据需要选择使用Spring框架的部分或全部。

 

  * 简述依赖注入。

Spring 能有效地组织J2EE应用各层的对象。不管是控制层的Action对象，还是业务层的Service对象，还是持久层的DAO对象，都可在Spring的 管理下有机地协调、运行。Spring将各层的对象以松耦合的方式组织在一起，Action对象无须关心Service对象的具体实现，Service对 象无须关心持久层对象的具体实现，各层对象的调用完全面向接口。当系统需要重构时，代码的改写量将大大减少。

 

　　上面所说的一切都得宜于Spring的核心机制，依赖注入。依赖注入让bean与bean之间以配置文件组织在一起，而不是以硬编码的方式耦合在一起。理解依赖注入

 

　　依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在 传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。

 

　　不管是依赖注入，还是控制反转，都说明Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现互相透明。在理解依赖注入之前，看如下这个问题在各种社会形态里如何解决:一个人(Java实例，调用者)需要一把斧子(Java实例，被调用者)。

 

　　(1)原始社会里，几乎没有社会分工。需要斧子的人(调用者)只能自己去磨一把斧子(被调用者)。对应的情形为:Java程序里的调用者自己创建被调用者。

 

　　(2)进入工业社会，工厂出现。斧子不再由普通人完成，而在工厂里被生产出来，此时需要斧子的人(调用者)找到工厂，购买斧子，无须关心斧子的制造过程。对应Java程序的简单工厂的设计模式。

 

　　(3)进入“按需分配”社会，需要斧子的人不需要找到工厂，坐在家里发出一个简单指令:需要斧子。斧子就自然出现在他面前。对应Spring的依赖注入。

 

　　第一种情况下，Java实例的调用者创建被调用的Java实例，必然要求被调用的Java类出现在调用者的代码里。无法实现二者之间的松耦合。

 

　　第二种情况下，调用者无须关心被调用者具体实现过程，只需要找到符合某种标准(接口)的实例，即可使用。此时调用的代码面向接口编程，可以让调用者和被调用者解耦，这也是工厂模式大量使用的原因。但调用者需要自己定位工厂，调用者与特定工厂耦合在一起。

 

　　第三种情况下，调用者无须自己定位工厂，程序运行到需要被调用者时，系统自动提供被调用者实例。事实上，调用者和被调用者都处于Spring的管理下，二者之间的依赖关系由Spring提供。

 

　　所谓依赖注入，是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部的注入。Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。依赖注入通常有两种:

 

　　·设值注入。

 

　　·构造注入。

 

      

  

 

  * 简述Spring整合Struts2的步骤。

 

 

  * 简述Spring整合Hibernate的步骤。

 

 

答案：?ORM的全称是Object/Relation Mapping，对象/关系映射。

?ORM可以理解是一种规范，具体的ORM框架可作为应用程序和数据库的桥梁。

 

ORM的优点：

?基于ORM框架完成映射后，既可利用面向对象程序设计语言的简单易用性，又可利用关系数据库的技术优势。

?ORM框架是面向对象程序设计语言与关系数据库发展不同步时的中间解决方案。随着面向对象数据库的发展，其理论逐步完善，最终会取代关系数据库。