【基于SSH框架的个人博客系统01】Eclipse搭建SSH框架详细流程

最新推荐文章于 2022-06-26 15:02:02 发布

du_xian_sheng

最新推荐文章于 2022-06-26 15:02:02 发布

阅读量1.5k

点赞数 1

分类专栏： SSH

SSH 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Eclipse搭建SSH框架搭建教程

前期环境准备：

① Java环镜

② Eclipse4.6.2

③ Tomcat8.5

④ Struts2.3.41

⑤ Spring4.2.4

⑥ Hibernate4.3.11

⑦ mysql-5.6.35-winx64

⑧ Mysql-connector-java-5.1.26

⑨ Navicat for MySQL

其中①②③可以参照http://www.cnblogs.com/oucbl/p/5928511.html。

对于SSH框架的搭建，本人主要是参照http://blog.csdn.net/eson_15/article/details/51277324这篇博客来搭建的框架，其中的④⑤⑥⑦可以在里面下载到。

SSH框架各自的作用：

在开始搭建框架之前，先整体讲一下SSH框架各自的用途。首先是Struts框架，众所周知，一个网页有着各种各样的请求，比如注册账号，登录账号等请求，通过配置Struts框架，这些请求都会被拦截，由我们分配的Action进行处理，然后再根据我们的配置文件来进行转发。其次是Hibernate框架，它实现了数据库表与javabean的一一对应，使我们能够通过操纵类来操纵数据库。最后是Spring框架，它实现了SSH框架之间的解耦，通过配置文件，我们可以实现依赖注入。比如我有一个类A，其中有一个成员是类B，那么使用之前我们都需要先得到这个类的一个实例，正常情况下我们是通过new来实现。但是，使用了Spring框架之后，我们就可以通过配置文件将B依赖注入进A，在使用时不用管这个类的创建，只负责使用，大大方便了开发。可以说Spring框架就是SSH框架中的粘合剂，掌管着里面各个类。

开始搭建

首先附上项目目录结构图

第一步：新建项目

新建一个Dynamic Web Project项目。然后右键点击项目-Properties-Java Build Path，将默认输出路径调整到项目目录下的WEB-INF/classes。（之后会解释）

第二步：搭建Struts框架

① 进入WEB-INF中的lib，把struts所需jar包复制进来，之后右键项目刷新。（之后每次在eclipse之外的操作都要刷新项目，不再重复）

② 修改WEB-INF目录下的web.xml如下：

[html]view plain copy 
   
 <?xml version="1.0"encoding="UTF-8"?>  
    <web-appxmlns:xsiweb-appxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xmlns="http://java.sun.com/xml/ns/javaee"  
        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>S2SH</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>  
    <welcome-file-list>  
            <welcome-file>index.jsp</welcome-file>  
    </welcome-file-list>  
    <listener>   
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>   
     </listener>  
 </web-app>  

③ 新建一个TestAction类进行Struts框架的测试

[java]view plain copy 
   
 package com.blog.action;  
 importcom.opensymphony.xwork2.ActionSupport;  
    
 public class TestAction extendsActionSupport{  
        publicString execute() throws Exception{  
               System.out.println("Struts2测试成功！！");  
               return"success";  
        }  
 }  

④ 在src目录下，新建struts.xml,内容如下：

[html]view plain copy 
   
 <?xml version="1.0"encoding="UTF-8" ?>  
    <!DOCTYPE struts PUBLIC  
            "-//Apache Software Foundation//DTD Struts Configuration2.0//EN"  
            "http://struts.apache.org/dtds/struts-2.0.dtd">  
    
    <struts>  
        <package name="default"extends="struts-default">  
            <action name="login" class="com.blog.action.TestAction">//类的目录  
                   <resultnameresultname="success">/index.jsp</result>  
               </action>  
        </package>  
    </struts>  
    

⑤ 在WebContent下新建index.jsp,之后都利用这个页面来检测。

[html]view plain copy 
   
 <%@ page language="java"contentType="text/html; charset=UTF-8"  
    pageEncoding="UTF-8"%>  
 <!DOCTYPE html PUBLIC "-//W3C//DTDHTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">  
 <html>  
 <head>  
 <metahttp-equivmetahttp-equiv="Content-Type" content="text/html; UTF-8">  
 <title>Insert titlehere</title>  
 </head>  
 <body>  
        <ahrefahref="login.action">访问save</a>  
 </body>  
 </html>  

总结：

解释一下在这里struts框架的作用。在Web.xml配置了之后，所有符合/*的链接都会被Struts框架中的org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter拦截链接，根据struts.xml的配置来进行转发，这里我们是转发到com.blog.action.TestAction这个类的public String execute()来处理，根据返回的String来转发网页。在struts中的配置有一个<resultname="success">/index.jsp</result>，即如果返回了success，就跳到/index.jsp这个网页。这是struts的一个用途。

第三步：搭建Spring框架并且组合Struts框架

① 将Spring所需jar包拉进lib中。

② 在web.xml添加如下内容：

[html]view plain copy 
   
 <listener>   
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>   
     </listener>   
      
    <context-param>   
    <param-name>contextConfigLocation</param-name>   
    <param-value>classpath:applicationContext.xml</param-value>   
 </context-param>   

③ 在src目录下新建一个applicationContext.xml，内容如下：

[html]view plain copy 
   
 <?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:aop="http://www.springframework.org/schema/aop"  
        xmlns:tx="http://www.springframework.org/schema/tx"  
        xmlns:context="http://www.springframework.org/schema/context"  
        xsi:schemaLocation="  
       http://www.springframework.org/schema/beans  
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
       http://www.springframework.org/schema/tx  
       http://www.springframework.org/schema/tx/spring-tx-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" >  
        <bean id="date" class="java.util.Date" />  
        <bean id="TestAction"class="com.blog.action.TestAction"scope="prototype">   
        <property name="date" ref="date" />  
        </bean>  
 </beans>   

④ 将struts中对应的class交给spring来管理，class后面的内容改为applicationContext.xml对应bean的id。

[html]view plain copy 
   
 <action name="login"class="TestAction">  
         <result name="success">/index.jsp</result>  
  </action>  

⑤ 将TestAction改为

[java]view plain copy 
   
 package com.blog.action;  
 import java.util.Date;  
 import org.hibernate.HibernateException;  
 import org.hibernate.Session;  
 import org.hibernate.SessionFactory;  
 import org.hibernate.Transaction;  
 importorg.hibernate.boot.registry.StandardServiceRegistryBuilder;  
 importorg.hibernate.boot.registry.internal.StandardServiceRegistryImpl;  
 import org.hibernate.cfg.Configuration;  
 importorg.hibernate.service.ServiceRegistry;  
 importcom.opensymphony.xwork2.ActionSupport;  
 public class TestAction extendsActionSupport{  
        privateDate date;  
        publicvoid setDate(Date date){  
               this.date=date;  
        }  
        publicDate getDate(){  
               returndate;  
        }  
        publicString execute() throws Exception{  
               System.out.println("Struts2测试成功！！");  
               System.out.println("Spring测试：目前时间是:"+date);  
               return"success";  
        }  
 }  

总结：

解释一下Spring框架在这里的作用。Spring框架利用IOC的思想，减少了框架之间的耦合程度。比如，在TestAction中，我并没有对date进行new操作就直接使用，而是利用配置文件，在“无形之中”完成了date的创建。首先我们在web.xml配置spring框架的监听器，并且让程序一开始就读取spirng框架的配置文件。

[html]view plain copy 
   
 <context-param>   
    <param-name>contextConfigLocation</param-name>   
    <param-value>classpath:applicationContext.xml</param-value>   
 </context-param>   

这一段中的classpath:指的就是WEB-INF-classes这个路径。它会到这个路径下寻找applicationContext.xml并读取。在配置文件中

[html]view plain copy 
   
 <bean id="date"class="java.util.Date" />  
 <bean id="TestAction"class="com.blog.action.TestAction"scope="prototype">   
 <property name="date"ref="date" />  
 </bean>  

其实就完成了对date的创建，这个仔细琢磨一下应该能看懂。

由于我们使用spring来管理类的创建，所以struts 中action的class也改为ApplicationContext.xml中对应bean的id。

第四步，搭建Hibernate环境

① 将hibernate框架及数据库连接所需要用的jar包拉进lib中。

② 这里我们先使用到Navicat来完成对数据库的创建。

③ 接下来创建Dao层，DaoImpl层，以及bean层。

[java]view plain copy 
   
 package com.blog.dao;  
 import org.hibernate.HibernateException;  
 import org.hibernate.Session;  
 public interface BaseDao {   
    public void saveObject(Object obj) throws HibernateException;   
    public Session getSession();   
    public void setSession(Session session);   
 }   
    
 package com.blog.daoImpl;  
 import org.hibernate.HibernateException;  
 import org.hibernate.Session;  
 import com.blog.dao.BaseDao;  
 public class UserDao implements BaseDao{   
    private Session session;   
    @Override   
    public Session getSession() {   
         return session;   
    }   
    @Override   
    public void setSession(Session session) {   
        this.session = session;   
    }   
    @Override   
    public void saveObject(Object obj) throws HibernateException {   
        session.save(obj);   
     }   
 }   
 public class User {  
        privateString username;  
        privateString password;  
        privateInteger id;  
        publicString getUsername() {  
               returnusername;  
        }  
        publicvoid setUsername(String username) {  
               this.username= username;  
        }  
    
        publicString getPassword() {  
               returnpassword;  
        }  
    
        publicvoid setPassword(String password) {  
               this.password= password;  
        }  
        publicvoid setId(Integer id){  
               this.id=id;  
        }  
        publicInteger getId(){  
               returnid;  
        }  
 }  

③ 在src目录下新建hibernate.cfg.xml和User.hbm.xml。

Hibernate.cfg.xml内容如下：

[html]view plain copy 
   
 <?xml version="1.0"encoding="UTF-8"?>  
 <!DOCTYPE hibernate-configuration PUBLIC  
 "-//Hibernate/Hibernate ConfigurationDTD 3.0//EN"  
 "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
 <hibernate-configuration>  
    <session-factory>  
         <!-- 各属性的配置-->  
        <!-- 为true表示将Hibernate发送给数据库的sql显示出来 -->  
        <property name="show_sql">true</property>  
        <!-- SQL方言，这边设定的是MySQL -->  
        <propertynamepropertyname="dialect">org.hibernate.dialect.MySQLDialect</property>  
          
        <!-- 一次读的数据库记录数 -->  
        <property name="jdbc.fetch_size">50</property>  
          
        <!-- 设定对数据库进行批量删除 -->  
        <property name="jdbc.batch_size">23</property>  
          
        <!--驱动程序-->  
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>  
          
        <!-- JDBC URL -->  
        <propertynamepropertyname="connection.url">jdbc:mysql://localhost/mankind</property>  
          
        <!-- 数据库用户名-->  
        <propertynamepropertyname="connection.username">root</property>  
          
        <!-- 数据库密码-->  
        <propertynamepropertyname="connection.password">123456</property>  
         <!--数据库连接池的大小-->    
        <property name="hibernate.connection.pool.size">20</property>   
        <!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于差错，程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。项目部署后可以设置为false，提高运行效率-->    
        <property name="hibernate.show_sql">true</property>    
        <!--jdbc.use_scrollable_resultset是否允许Hibernate用JDBC的可滚动的结果集。对分页的结果集。对分页时的设置非常有帮助-->    
        <property name="jdbc.use_scrollable_resultset">false</property>    
        <!--connection.useUnicode连接数据库时是否使用Unicode编码-->    
        <property name="Connection.useUnicode">true</property>   
        <!--connection.characterEncoding连接数据库时数据的传输字符集编码方式，最好设置为gbk，用gb2312有的字符不全-->  
        <property name="connection.characterEncoding">gbk</property>   
        <!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。-->    
        <propertynamepropertyname="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>    
        <!--指定映射文件为“hibernate/ch1/UserInfo.hbm.xml”-->           
        <mapping resource="User.hbm.xml"/>    
    </session-factory>  
 </hibernate-configuration>  

User.hbm.xml内容如下：

[html]view plain copy 
   
 <?xml version="1.0"encoding='UTF-8'?>   
 <!DOCTYPE hibernate-mapping PUBLIC   
                             "-//Hibernate/HibernateMapping DTD 3.0//EN"   
                            "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">   
    
 <hibernate-mappingpackagehibernate-mappingpackage="com.blog.beans">   
    <class name="User" table="user">   
        <id name="id" column="id">   
             <generatorclassgeneratorclass="native"></generator>   
        </id>   
        <property name="username" column="username"type="java.lang.String"  />  
        <property name="password" column="password"type="java.lang.String"  />  
    </class>   
 </hibernate-mapping>   
    

④ TestAction内容更改如下：

[java]view plain copy 
   
 package com.blog.action;  
 import java.util.Date;  
 import org.hibernate.HibernateException;  
 import org.hibernate.Session;  
 import org.hibernate.SessionFactory;  
 import org.hibernate.Transaction;  
 import org.hibernate.boot.registry.StandardServiceRegistryBuilder;  
 importorg.hibernate.boot.registry.internal.StandardServiceRegistryImpl;  
 import org.hibernate.cfg.Configuration;  
 importorg.hibernate.service.ServiceRegistry;  
 import com.blog.beans.User;  
 import com.blog.dao.BaseDao;  
 import com.blog.daoImpl.UserDao;  
 importcom.opensymphony.xwork2.ActionSupport;  
 import sun.security.timestamp.TSRequest;  
 public class TestAction extendsActionSupport{  
        privateDate date;  
        privatestatic Configuration configuration = null;  
        privatestatic SessionFactory sessionFactory = null;  
        privatestatic ServiceRegistry serviceRegistry = null;  
        publicvoid setDate(Date date){  
               this.date=date;  
        }  
        publicDate getDate(){  
               returndate;  
        }  
        publicString execute() throws Exception{  
               System.out.println("Struts2测试成功！！");  
               System.out.println("Spring测试：目前时间是:"+date);  
                try {  
                       Configuration configuration = newConfiguration().configure();  
                      //以下这两句是4.3的新用法  
                      StandardServiceRegistryBuilderbuilder = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties());  
                      StandardServiceRegistryImplregistry = (StandardServiceRegistryImpl) builder.build();  
                      SessionFactorysessionFactory = configuration.buildSessionFactory(registry);  
                      Sessionsession = sessionFactory.openSession();  
                      Transactiontx = session.beginTransaction();  
                      Useruser=new User();  
                      //user.setId(1);  
                      user.setUsername("MK");  
                      user.setPassword("123456");  
                      BaseDaodao=new UserDao();  
                      dao.setSession(session);  
                      dao.saveObject(user);  
                      tx.commit();  
                      session.close();  
                       } catch (HibernateException e) {  
                        e.printStackTrace();  
                       }  
               return"success";  
        }  
 }  

总结：

到这里已经完成了Hibernate框架的搭建。Hibernate的思路如下，使用一个bean类，将java的基本数据与数据库中表的数据一一对应起来，比如这里的User类，属性中有id，username，password，分别对应数据表中的id，username和password，他们是一一对应的关系。并且在这里所有的属性都要设置set和get方法。那么hibernate框架通过什么来完成这种转换呢？在这里便是通过user.hbm.xml来实现。

[html]view plain copy 
   
 <class name="User" table="user">   
     <id name="id" column="id">   
          <generatorclassgeneratorclass="native"></generator>   
     </id>   
     <property name="username" column="username"type="java.lang.String"  />  
     <property name="password" column="password"type="java.lang.String"  />  
 </class>   

name对应java中的字段，column对应数据库中的字段，通过这样的配置。Hibernate配置文件hibernate.cfg.xml中配置了账号，密码，数据库方言之类的数据库基本信息，同时通过<mapping resource="User.hbm.xml"/>来指定映射文件，即我们前面说的user与数据库中user表之间的映射关系通过User.hbm.xml就可以找到。

第五步：完成Hibernate与Spring框架的整合。

① 在applicationContext.xml中配置dataSource、sessionFactory、transactionManager。

[html]view plain copy 
   
 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">   
            <property name="driverClass" value="com.mysql.jdbc.Driver"/>   
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mankind"/>   
            <property name="user" value="root"/>   
            <property name="password" value="123456"/>   
               </bean>   
               <beanidbeanid="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">   
                    <property name="dataSource" ref="dataSource"/>   
                    <property name="configLocation"value="classpath:hibernate.cfg.xml" /> <!-- 加载hibernate配置文件 -->   
               </bean>   
         <bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager">   
                  <property name="sessionFactory"ref="sessionFactory" />   
               </bean>   
               <tx:adviceidtx:adviceid="advice" transaction-manager="transactionManager">   
                   <tx:attributes>   
                       <tx:method name="save*" propagation="REQUIRED"/>   
                       <tx:method name="update*" propagation="REQUIRED"/>   
                       <tx:method name="delete*" propagation="REQUIRED"/>   
                       <tx:method name="*" propagation="SUPPORTS"/>   
                   </tx:attributes>   
               </tx:advice>   
               <aop:config>   
            <!-- 配置哪些包的类要切入事务 -->   
            <aop:pointcut id="pointcut" expression="execution(*com.blog.daoImpl.*.*(..))" />   
            <aop:advisor advice-ref="advice"pointcut-ref="pointcut"/><!-- 连接了上面的advice和上面的pointcut -->   
            <!-- aop:pointcut要写在aop:advisor上面，否则会报错 -->   
         </aop:config>  

② 由于在applicationContext.xml中配置了DataSource，可以删除hibernate.cfg.xml中相对应的四项（driverClass，jdbcURL,user,password）。其余的不用删，因为我们在spring中引用了hibernate.cfg.xml。

③ 修改BaseDao

[java]view plain copy 
   
 public interface BaseDao {   
     publicvoid saveObject(Object obj) throws HibernateException;   
 }   

④ 修改UserDao

[java]view plain copy 
   
 public class UserDao implements BaseDao {  
        privateSessionFactory sessionFactory;  
         //当需要使用sessoinFactory的时候，Spring会将sessionFactory注入进来   
     publicvoid setSessionFactory(SessionFactory sessionFactory) {   
        this.sessionFactory = sessionFactory;   
     }     
     protectedSession getSession() {   
        //从当前线程获取session，如果没有则创建一个新的session   
        return sessionFactory.getCurrentSession();   
     }   
     publicvoid saveObject(Object obj) throws HibernateException {   
        getSession().save(obj);  
     }  
 }  

⑤ 修改TestAction

[java]view plain copy 
   
 public class TestAction extends ActionSupport{  
        privateDate date;  
        privateBaseDao userDao;  
        publicvoid setDate(Date date){  
               this.date=date;  
        }  
        publicDate getDate(){  
               returndate;  
        }  
        publicvoid setUserDao(BaseDao userDao){  
               this.userDao=userDao;  
        }  
        publicBaseDao getUserDao(){  
               returnuserDao;  
        }  
        publicString execute() throws Exception{  
               System.out.println("Struts2测试成功！！");  
               System.out.println("Spring测试：目前时间是:"+date);  
                try {  
                      Useruser=new User();  
                      user.setUsername("MK");  
                      user.setPassword("123456");  
                      userDao.saveObject(user);  
                       } catch (HibernateException e) {  
                        e.printStackTrace();  
                       }  
               return"success";  
        }  

⑥ 修改applicationContext.xml，依赖注入TestAction和UserDao

[html]view plain copy 
   
 <bean id="userDao" class="com.blog.daoImpl.UserDao">   
            <property name="sessionFactory"ref="sessionFactory" />   
 </bean>   
 <bean id="date" class="java.util.Date"/>  
 <bean id="TestAction" class="com.blog.action.TestAction"scope="prototype">   
          <property name="date" ref="date"/>  
          <property name="userDao" ref="userDao"/>  
 </bean>  

总结：

很明显，在Hibernate和Spring整合之前，我们在TestAction中需要写很长很长的代码来获得Session，整合之后，代码量大大减少。需要注意的地方是，Spring是针对接口来编程的，在TestAactoin中，userDao不能声明为userDao类型，而是应该声明为它的接口BaseDao，否则会报错。这个坑了我几个小时的时间..

框架到这里就差不多都打通了，剩下的地方再根据需要改一改就可以开始开发了。

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

本项目下载地址：

github：https://github.com/SCAUMankind/SSHBlogSystem

du_xian_sheng

关注

1
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
【基于SSH框架的个人博客系统01】Eclipse搭建SSH框架详细流程

Eclipse搭建SSH框架搭建教程前期环境准备：① Java环镜② Eclipse4.6.2③ Tomcat8.5④ Struts2.3.41⑤ Spring4.2.4⑥ Hibernate4.3.11⑦ mysql-5.6.35-winx64⑧ Mysql-connector-ja
复制链接

扫一扫