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

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/Hemk340200600/article/details/70161863

Eclipse搭建SSH框架搭建教程

 注意:本项目为博主初学Web开发时所写,所使用的方法都比较笨,不符合主流开发方法。例如,包管理应该使用Maven进行管理而不是手动导入,对前端后端代码的架构也并不是很清晰。大家学习思想即可,可以不用浪费时间在将这个项目跑起来。目前主流的技术应当是Spring+SpringMVC+Mybatis的SSM框架,配合Shiro做权限控制,Redis做缓存,也可以学习SpringBoot开发微服务。由于本博主已经保研,较少接触开发,故此项目也不再进行维护。

前期环境准备:

①   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如下:

 

<?xml version="1.0"encoding="UTF-8"?>
   <web-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框架的测试

 

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,内容如下:

 

<?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">//类的目录
                  <resultname="success">/index.jsp</result>
              </action>
       </package>
   </struts>
 

 

 

 

 

 

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

 

<%@ 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-equiv="Content-Type" content="text/html; UTF-8">
<title>Insert titlehere</title>
</head>
<body>
       <ahref="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添加如下内容:

 

<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,内容如下:

 

<?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。

 

<action name="login"class="TestAction">
        <result name="success">/index.jsp</result>
 </action>

⑤   将TestAction改为

 

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框架的配置文件。

 

<context-param> 
   <param-name>contextConfigLocation</param-name> 
   <param-value>classpath:applicationContext.xml</param-value> 
</context-param> 

 

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

 

<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层。

 

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内容如下:

 

<?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 -->
       <propertyname="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 -->
       <propertyname="connection.url">jdbc:mysql://localhost/mankind</property>
       
       <!-- 数据库用户名-->
       <propertyname="connection.username">root</property>
       
       <!-- 数据库密码-->
       <propertyname="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连接那种类型的数据库服务器。-->  
       <propertyname="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>  
       <!--指定映射文件为“hibernate/ch1/UserInfo.hbm.xml”-->         
       <mapping resource="User.hbm.xml"/>  
   </session-factory>
</hibernate-configuration>

User.hbm.xml内容如下:

 

<?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-mappingpackage="com.blog.beans"> 
   <class name="User" table="user"> 
       <id name="id" column="id"> 
            <generatorclass="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内容更改如下:

 

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来实现。

 

   <class name="User" table="user"> 
       <id name="id" column="id"> 
            <generatorclass="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。

 

<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> 
              <beanid="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: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

 

public interface BaseDao { 
    publicvoid saveObject(Object obj) throws HibernateException; 
} 

④   修改UserDao

 

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

 

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

 

<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

展开阅读全文

没有更多推荐了,返回首页