学习SSH框架

2019独角兽企业重金招聘Python工程师标准>>>

1.SSH框架的认知

　　在做相关的java的网页的开发制作时，良好的层次分解是十分有比要的，所以我们在云涌第三方的框架之下来简化还有名了我们相关的网站的开发。

　　SSH框架实则为Struct + spring + hibernate 的三个组成的，其中struct，专注与前台的相关的请求的所对应的ActionForm还有其相关跳转的Action来处理得到相关的JSP页面，从而来更新或是条状到相关用户的请求的服务页面，或是信息页面。而Hibernate的作用是体现在数据的持久化的层次中，我们对于页面，通过其特定的方式来对相关程序的数据惊醒I/O的持久化操作。在其次是相关spring的应用，是对与中间层次的相关的控制，处理相关业务的数据的依赖注入问题，还有就是融合其他的联大框架来实现相关程序的层次化的结构。

　　2.struct框架的使用

1. 在web.xml中进行配置，相关配置如下：
   1. <filter>
   2. <filter-name>SSH</filter-name>
   3. <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
   4. </filter>
   5.  
   6. <filter-mapping>
   7. <filter-name>SSH</filter-name>
   8. <url-pattern>/*</url-pattern>
   9. </filter-mapping>
2. Struct.xml的相关配置如下
   1. <?xmlversion="1.0"encoding="UTF-8"?>
   2. <!DOCTYPE struts PUBLIC
   3. "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   4. "http://struts.apache.org/dtds/struts-2.0.dtd">
   5.  
   6. <struts>
   7.  
   8. <includefile="struts-default.xml"/>
   9. <packagename="ynwi"extends="struts-default">
   10. <actionname="register"class="com.ynwi.ssh.action.RegisterAction">
   11. <resultname="input">/Register.jsp</result>
   12. <resultname="success">/Success.jsp</result>
   13. <resultname="error">/Fail.jsp</result>
   14. </action>
   15. </package>
   16.  
   17. </struts>
3. 其上两处的配置的做用时。当在browser中发出相关的请求时候，Struct会把相关的请求转到Struct的特定的filter中去，然后把数据映射到在struct.xml中所示的ActionForm中去，然后在更具配置吧，数据还有其他的相关的参数转交给相关的Action来做业务的处理，软后在更具结果进行跳转的。所以我们在Struct.xml中的相关的配置，实际上就是相关的请求所对应要使用到的ActionForm还有就是Action和相关跳转页面的配置。
4. 程序的书写代码如下：
   1. packagecom.ynwi.ssh.beans;
   2.  
   3. publicclassUserForm {
   4.  
   5. privateString username;
   6. privateString password;
   7. privateintgender;
   8.  
   9. publicString getUsername() {
   10. returnusername;
   11. }
   12.  
   13. publicvoidsetUsername(String username) {
   14. this.username = username;
   15. }
   16.  
   17. publicString getPassword() {
   18. returnpassword;
   19. }
   20.  
   21. publicvoidsetPassword(String password) {
   22. this.password = password;
   23. }
   24.  
   25. publicintgetGender() {
   26. returngender;
   27. }
   28.  
   29. publicvoidsetGender(intgender) {
   30. this.gender = gender;
   31. }
   32.  
   33. } //相关的ActionForm类的书写范例。
5. 处理业务的书写如下：
   1. packagecom.ynwi.ssh.action;
   2.  
   3. importcom.opensymphony.xwork2.ActionSupport;
   4. importcom.ynwi.ssh.beans.UserForm;
   5. importcom.ynwi.ssh.service.UserManager;
   6. importcom.ynwi.ssh.serviceImpl.UserManagerImpl;
   7.  
   8. publicclassRegisterAction extendsActionSupport {
   9.  
   10. privatestaticfinallongserialVersionUID = 1L;
   11.  
   12. privateUserForm user;
   13.  
   14. privateUserManager userManager;
   15.  
   16. publicUserForm getUser() {
   17. returnuser;
   18. }
   19.  
   20. publicvoidsetUser(UserForm user) {
   21. this.user = user;
   22. }
   23.  
   24. publicUserManager getUserManager() {
   25. returnuserManager;
   26. }
   27.  
   28. publicvoidsetUserManager(UserManager userManager) {
   29. this.userManager = userManager;
   30. }
   31.  
   32. publicString execute() {
   33. try{
   34. this.setUserManager(newUserManagerImpl());
   35. userManager.regUser(user);
   36. returnSUCCESS;
   37.  
   38. } catch(Exception e) {
   39. e.printStackTrace();
   40. returnERROR;
   41. }
   42. }
   43.  
   44. } //相关的Action的书写范例。
6. 以上便是struct的书写的范例。Struct的其原理可查询struct的官网站，或者是相关的文档。

　　3.Hibernate的使用

1. hibernate的相关的配置如下：
   1. <?xmlversion='1.0'encoding='utf-8'?>
   2. <!DOCTYPE hibernate-configuration PUBLIC
   3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
   4. "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
   5.  
   6. <hibernate-configuration>
   7. <session-factory>
   8. <!-- Database connection settings -->
   9. <propertyname="connection.driver_class">com.mysql.jdbc.Driver</property>
   10. <propertyname="connection.url">jdbc:mysql://localhost:3306/project</property>
   11. <propertyname="connection.username">root</property>
   12. <propertyname="connection.password">root</property>
   13.  
   14. <!-- JDBC connection pool (use the built-in) -->
   15. <!-- <property name="connection.pool_size">1</property> -->
   16.  
   17. <!-- SQL dialect -->
   18. <propertyname="dialect">org.hibernate.dialect.MySQLDialect</property>
   19.  
   20. <!-- Enable Hibernate's automatic session context management -->
   21. <!-- <property name="current_session_context_class">thread</property> -->
   22.  
   23. <!-- Disable the second-level cache -->
   24. <!-- <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property> -->
   25.  
   26. <!-- Echo all executed SQL to stdout -->
   27. <propertyname="show_sql">true</property>
   28.  
   29. <!-- Drop and re-create the database schema on startup -->
   30. <!-- <property name="hbm2ddl.auto">update</property> -->
   31. <mappingresource="com/ynwi/ssh/beans/User.hbm.xml"/>
   32. </session-factory>
   33. </hibernate-configuration>
   34. //hibernate-configuration的相关的配置实际上就是配置县官的Hibernate的相关数据库ide链接用户名还有密码。同时还有一些相关的设置的问题。还有就是Mapping的配置（对象性的数据到关系型数据映射，例子见2）
2. mapping的配置：
   1. <?xmlversion="1.0"encoding='UTF-8'?>
   2. <!DOCTYPE hibernate-mapping PUBLIC
   3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
   4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
   5.  
   6. <hibernate-mappingpackage="com.ynwi.ssh.beans">
   7. <classname="User"table="user">
   8. <idname="userId"column="userId">
   9. <generatorclass="native"></generator>
   10. </id>
   11. <propertyname="username"column="userName"type="java.lang.String"
   12. not-null="true"length="16"></property>
   13. <propertyname="password"column="password"type="java.lang.String"
   14. not-null="true"length="16"/>
   15. <propertyname="gender"column="gender"type="java.lang.Integer"length="1"/>
   16. </class>
   17. </hibernate-mapping>
   18. //其中ID是变种对应的主键，而其他的为元素的应用。
   19. //代码<generator class="native"></generator>说明将根据本地数据库的设置来创建userId，如MySQL中将表user的userId设置为自动增长，则在保存记录是，userId将自动增长。对于需要在程序中指定主键的值，则将generator的class属性设置为assigned。
3. 相关的代码书写如下：
   1. packagecom.ynwi.ssh.dao;
   2.  
   3. importorg.hibernate.HibernateException;
   4. importorg.hibernate.Session;
   5.  
   6. publicinterfaceBaseDao {
   7.  
   8. publicvoidsaveObject(Object obj) throwsHibernateException;
   9.  
   10. publicSession getSession();
   11.  
   12. publicvoidsetSession(Session session);
   13. }
   14. //数据持久化曾的相关的接口。

1. 1. packagecom.ynwi.ssh.daoImpl;
   2.  
   3. importorg.hibernate.HibernateException;
   4. importorg.hibernate.Session;
   5.  
   6. importcom.ynwi.ssh.dao.BaseDao;
   7.  
   8. publicclassUserDao implementsBaseDao {
   9.  
   10. privateSession session;
   11.  
   12. @Override
   13. publicSession getSession() {
   14. returnsession;
   15. }
   16.  
   17. @Override
   18. publicvoidsetSession(Session session) {
   19. this.session = session;
   20. }
   21.  
   22. @Override
   23. publicvoidsaveObject(Object obj) throwsHibernateException {
   24. session.save(obj);
   25. }
   26.  
   27. }
   28. //数据持久层的相关的实现。

1. packagecom.ynwi.ssh.daoImpl;
2.  
3. importorg.hibernate.HibernateException;
4. importorg.hibernate.Session;
5. importorg.hibernate.SessionFactory;
6. importorg.hibernate.cfg.Configuration;
7. importorg.hibernate.service.ServiceRegistry;
8. importorg.hibernate.service.ServiceRegistryBuilder;
9.  
10. publicclassHibernateSessionFactory {
11.  
12. privatestaticfinalString CFG_FILE_LOCATION = "/Hibernate.cfg.xml";
13.  
14. privatestaticfinalThreadLocal<Session> threadLocal = newThreadLocal<Session>();
15.  
16. privatestaticfinalConfiguration cfg = newConfiguration()
17. .configure(CFG_FILE_LOCATION);
18.  
19. privatestaticServiceRegistryBuilder builder = newServiceRegistryBuilder()
20. .applySettings(cfg.getProperties());
21.  
22. privatestaticServiceRegistry registry;
23.  
24. privatestaticSessionFactory sessionFactory;
25.  
26. publicstaticSession currentSession() throwsHibernateException {
27. Session session = threadLocal.get();
28.  
29. if(session == null|| session.isOpen() == false) {
30.  
31. if(sessionFactory == null) {
32. try{
33. registry = builder.buildServiceRegistry();
34. sessionFactory = cfg.buildSessionFactory(registry);
35. } catch(Exception e) {
36. e.printStackTrace();
37. }
38. }
39.  
40. session = sessionFactory.openSession();
41. threadLocal.set(session);
42.  
43. }
44.  
45. returnsession;
46. }
47.  
48. publicstaticvoidcloseSession() throwsHibernateException {
49. Session session = threadLocal.get();
50. threadLocal.set(null);
51. if(session != null) {
52. session.close();
53. }
54. }
55.  
56. }
57. //工厂类SessionFactory的内容。（这是使用Hibernate4时候的SessionFactory，Hibernate3时候sessionFactory的创建估计会不一样，请自行查阅。）

1. packagecom.ynwi.ssh.serviceImpl;
2.  
3. importorg.hibernate.HibernateException;
4. importorg.hibernate.Session;
5. importorg.hibernate.Transaction;
6.  
7. importcom.ynwi.ssh.beans.User;
8. importcom.ynwi.ssh.dao.BaseDao;
9. importcom.ynwi.ssh.daoImpl.HibernateSessionFactory;
10. importcom.ynwi.ssh.daoImpl.UserDao;
11. importcom.ynwi.ssh.forms.UserForm;
12. importcom.ynwi.ssh.service.UserManager;
13.  
14. publicclassUserManagerImpl implementsUserManager {
15.  
16. privateBaseDao dao;
17.  
18. privateSession session;
19.  
20. publicUserManagerImpl() {
21. dao = newUserDao();
22. }
23.  
24. @Override
25. publicvoidregUser(UserForm userForm) throwsHibernateException {
26. session = HibernateSessionFactory.currentSession();
27. dao.setSession(session);
28. // 获取事务
29. Transaction ts = session.beginTransaction();
30. // 构造User对象
31. User user = newUser();
32. user.setUsername(userForm.getUsername());
33. user.setPassword(userForm.getPassword());
34. user.setGender(userForm.getGender());
35. // 保存User对象
36. dao.saveObject(user);
37. // 提交事务
38. ts.commit();
39. // 关闭Session
40. HibernateSessionFactory.closeSession();
41. }
42.  
43. }
44. //相关的业务逻辑。

　　4.Hibernate的总结：

　　Hibernate实际上是在configuration方法的读取之下，得到相关的变量然后在通过此变量得到相关的sessionfactory类，通过SessionFactory类来读到会话类（Session）然后Session中的系列方法类进行数据库中的对应增，删，改，查的操作。当然session还可以开启事物的相关的操作。

　　4.Spring整合：

1. ApplicationContext.xml相关配置：
   1. <?xmlversion="1.0"encoding="UTF-8"?>
   2. <beansxmlns="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
   5. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   6.  
   7. <!-- 定义数据源的信息 -->
   8. <beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource"
   9. destroy-method="close">
   10. <propertyname="driverClass">
   11. <value>com.mysql.jdbc.Driver</value>
   12. </property>
   13. <propertyname="jdbcUrl">
   14. <value>jdbc:mysql://localhost/project</value>
   15. </property>
   16. <propertyname="user">
   17. <value>root</value>
   18. </property>
   19. <propertyname="password">
   20. <value>root</value>
   21. </property>
   22. <propertyname="maxPoolSize">
   23. <value>80</value>
   24. </property>
   25. <propertyname="minPoolSize">
   26. <value>1</value>
   27. </property>
   28. <propertyname="initialPoolSize">
   29. <value>1</value>
   30. </property>
   31. <propertyname="maxIdleTime">
   32. <value>20</value>
   33. </property>
   34. </bean>
   35.  
   36. <!--定义Hibernate的SessionFactory -->
   37. <!-- SessionFactory使用的数据源为上面的数据源 -->
   38. <!-- 指定了Hibernate的映射文件和配置信息 -->
   39. <beanid="sessionFactory"
   40. class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
   41. <propertyname="dataSource">
   42. <reflocal="dataSource"/>
   43. </property>
   44. <propertyname="mappingResources">
   45. <list>
   46. <value>com/ynwi/ssh/beans/User.hbm.xml</value>
   47. </list>
   48. </property>
   49. <propertyname="hibernateProperties">
   50. <props>
   51. <propkey="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
   52. <propkey="show_sql">true</prop>
   53. <propkey="hibernate.jdbc.batch_size">20</prop>
   54. </props>
   55. </property>
   56. </bean>
   57.  
   58. <beanid="transactionManager"
   59. class="org.springframework.orm.hibernate3.HibernateTransactionManager">
   60. <propertyname="sessionFactory"ref="sessionFactory"/>
   61. </bean>
   62.  
   63. <beanid="baseDao"class="com.ynwi.ssh.daoImpl.UserDao">
   64. <propertyname="sessionFactory">
   65. <refbean="sessionFactory"/>
   66. </property>
   67. </bean>
   68.  
   69. <!--用户注册业务逻辑类 -->
   70. <beanid="userManager"class="com.ynwi.ssh.serviceImpl.UserManagerImpl">
   71. <propertyname="dao">
   72. <refbean="baseDao"/>
   73. </property>
   74. </bean>
   75.  
   76. <!-- 用户注册的Action -->
   77. <beanid="regAction"class="com.ynwi.ssh.action.RegisterAction">
   78. <propertyname="userManager">
   79. <refbean="userManager"/>
   80. </property>
   81. </bean>
   82.  
   83. <!-- more bean definitions go here -->
   84.  
   85. </beans>
   86. //对于用户中的业务逻辑还有持久化操作的逻辑的相关类，我们放到spring的相关的容器中进行统一的管理。

2. 以上相关的修改结果如下（相对于之前的类来说）：BaseDao.java

   　　[java]view plain copy print ?

   　　UserDao.java

   　　[java]view plain copy print ?

   　　//getHibernateTemplate（）：HibernateTemplate 提供非常多的常用方法来完成基本的操作，比如通常的增加、删除、修改、查询等操作，Spring 2.0更增加对命名SQL查询的支持，也增加对分页的支持。大部分情况下，使用Hibernate的常规用法，就可完成大多数DAO对象的CRUD操作。 下面是HibernateTemplate的常用方法简介：

   　　q void delete(Object entity)：删除指定持久化实例

   1. packagecom.ynwi.ssh.dao;
   2.  
   3. importorg.hibernate.HibernateException;
   4.  
   5. publicinterfaceBaseDao {
   6.  
   7. publicvoidsaveObject(Object obj) throwsHibernateException;
   8.  
   9. }
   10. packagecom.ynwi.ssh.daoImpl;
   11.  
   12. importorg.hibernate.HibernateException;
   13. importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;
   14.  
   15. importcom.ynwi.ssh.dao.BaseDao;
   16.  
   17. publicclassUserDao extendsHibernateDaoSupport implementsBaseDao {
   18.  
   19. @Override
   20. publicvoidsaveObject(Object obj) throwsHibernateException {
   21. getHibernateTemplate().save(obj);
   22. }
   23.  
   24. }

3. q deleteAll(Collection entities)：删除集合内全部持久化类实例

4. q find(String queryString)：根据HQL查询字符串来返回实例集合

5. q findByNamedQuery(String queryName)：根据命名查询返回实例集合

6. q get(Class entityClass, Serializable id)：根据主键加载特定持久化类的实例

7. q save(Object entity)：保存新的实例

8. q saveOrUpdate(Object entity)：根据实例状态，选择保存或者更新

9. q update(Object entity)：更新实例的状态，要求entity是持久状态

10. q setMaxResults(int maxResults)：设置分页的大小·····························································································································································在dao层用到getSession()方法来操作数据库记录，但是他还有个方法getHibernateTemplate()，这两个方法究竟有什么区别呢？

    　　1.使用getSession()方法你只要继承 sessionFactory，而使用getHibernateTemplate()方法必须继承HibernateDaoSupport当然包括 sessionFactory，这点区别都不是特别重要的，下面这些区别就很重要了

    　　2.getSession()方法是没有经过spring包装 的，spring会把最原始的session给你，在使用完之后必须自己调用相应的close方法，而且也不会对声明式事务进行相应的管理，一旦没有及时 关闭连接，就会导致数据库连接池的连接数溢出，getHibernateTemplate()方法是经过spring封装的，例如添加相应的声明式事务管 理，由spring管理相应的连接。

    　　在实际的使用过程中发现的确getHibernateTemplate()比getSession()方法要好很多，但是有些方法在getHibernateTemplate()并没有提供，这时我们用HibernateCallback 回调的方法管理数据库.

    　　例如如下代码：

    　　/** * 使用 hql 语句进行操作

11. * @param hql HSQL 查询语句（使用回调函数访问外部变量，必须是final的）

12. * @param offset 开始取数据的下标

13. * @param length 读取数据记录数

14. * @return List 结果集

15. */

16. public List getListForPage ( final String hql , final int offset , final int length ) {

    　　List list = getHibernateTemplate().executeFind ( new HibernateCallback ( ) {

17. public Object doInHibernate ( Session session ) throws HibernateException, SQLException {

18. Query query = session.createQuery ( hql ) ; query.setFirstResult ( offset ) ; query.setMaxResults ( length ) ; List list = query.list ( ) ; return list ;

19. }

20. }) ;

21. return list ;}

    　　[java]view plain copy print ?

    　　[java]view plain copy print ?

    　　[html]view plain copy print ?

    　　[html]view plain copy print ?

    • 修改后的业务逻辑实现类UserManagerImpl的内容。
    1. packagecom.ynwi.ssh.serviceImpl;
    2.  
    3. importorg.hibernate.HibernateException;
    4. importorg.springframework.beans.BeanUtils;
    5.  
    6. importcom.ynwi.ssh.beans.User;
    7. importcom.ynwi.ssh.dao.BaseDao;
    8. importcom.ynwi.ssh.forms.UserForm;
    9. importcom.ynwi.ssh.service.UserManager;
    10.  
    11. publicclassUserManagerImpl implementsUserManager {
    12.  
    13. privateBaseDao dao;
    14.  
    15. publicvoidsetDao(BaseDao dao) {
    16. this.dao = dao;
    17. }
    18.  
    19. @Override
    20. publicvoidregUser(UserForm userForm) throwsHibernateException {
    21. User user = newUser();
    22. BeanUtils.copyProperties(userForm, user);
    23. dao.saveObject(user);
    24. }
    25.  
    26. }
    • 修改后的用户注册Action类RegisterAction的内容。
    1. packagecom.ynwi.ssh.action;
    2.  
    3. importcom.opensymphony.xwork2.ActionSupport;
    4. importcom.ynwi.ssh.forms.UserForm;
    5. importcom.ynwi.ssh.service.UserManager;
    6.  
    7. publicclassRegisterAction extendsActionSupport {
    8.  
    9. privatestaticfinallongserialVersionUID = 1L;
    10.  
    11. privateUserForm user;
    12.  
    13. privateUserManager userManager;
    14.  
    15. publicUserForm getUser() {
    16. returnuser;
    17. }
    18.  
    19. publicvoidsetUser(UserForm user) {
    20. this.user = user;
    21. }
    22.  
    23. publicvoidsetUserManager(UserManager userManager) {
    24. this.userManager = userManager;
    25. }
    26.  
    27. publicString execute() {
    28. try{
    29. userManager.regUser(user);
    30. returnSUCCESS;
    31.  
    32. } catch(Exception e) {
    33. e.printStackTrace();
    34. returnERROR;
    35. }
    36. }
    37.  
    38. }
    • 修改后的web.xml的内容。
    1. <?xmlversion="1.0"encoding="UTF-8"?>
    2. <web-appid="WebApp_9"version="2.4"xmlns="http://java.sun.com/xml/ns/j2ee"
    3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4. xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    5.  
    6. <display-name>SSH Project</display-name>
    7.  
    8. <filter>
    9. <filter-name>SSH</filter-name>
    10. <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    11. </filter>
    12.  
    13. <filter-mapping>
    14. <filter-name>SSH</filter-name>
    15. <url-pattern>/*</url-pattern>
    16. </filter-mapping>
    17.  
    18. <listener>
    19. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    20. </listener>
    21.  
    22. <welcome-file-list>
    23. <welcome-file>index.html</welcome-file>
    24. </welcome-file-list>
    25.  
    26. </web-app>
    • 修改后的Struts配置文件struts.xml的内容。
    1. <?xmlversion="1.0"encoding="UTF-8"?>
    2. <!DOCTYPE struts PUBLIC
    3. "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    • "http://struts.apache.org/dtds/struts-2.0.dtd">
    1.  
    2. <struts>
    3.  
    4. <includefile="struts-default.xml"/>
    5. <packagename="ynwi"extends="struts-default">
    6. <actionname="register"class="regAction">
    7. <resultname="input">/Register.jsp</result>
    8. <resultname="success">/Success.jsp</result>
    9. <resultname="error">/Fail.jsp</result>
    10. </action>
    11. </package>
    12.  
    13. </struts>

　　5.总结

　　有待改善。

                                                                                                                                    技术分享：www.kaige123.com

转载于:https://my.oschina.net/kaige123/blog/752940