SSH框架手动整合——Struts2+Hibernate4+Spring4

最近遇到过一些框架方面的问题，其中有MyBatis、SSH、SpringMVC，其中SSH的一些配置有些忘的差不多了，也有一些同事问了这些问题，前几个月也整合过SSH框架，那个时候是直接拿别人的Jar包直接整合框架，好像是Struts2+Hibernate3+Spring4，这次是相关的Jar从相关的官网下的。

我整合的环境：

——Win 7 64

——MySQL 5.6

——MyEclipse 2014

——Jar包：struts-2.3.28、spring-framework-4.0.4.RELEASE-dist、hibernate-release-4.3.5.Final

接下来整合的主要步骤是：

1.本文提纲：本文通过一个用户注册的实例讲解SSH的整合。创建Struts项目，整合Hibernate，整合Spring。最后总结如何熟练创建SSH项目。

2.本整合SSH项目，可以进一步扩展例如Struts的国际化，Hibernate的缓存优化，Spring的AOP等，本次博文暂时没有。

3.本次使用的是Tomcat 8.0，MySQL 5.6下的test数据库。

4.创建user表的sql。

create table user(
userId int auto_increment,
userName varchar(16) not null,
password varchar(16) not null,
gender int not null,
primary key(userId)
);

5.本次项目是根据另外一博主参考的。在此博主的基础上解决了所遇到的问题。

接下来开始整合框架：

——创建Struts项目

——创建工程

1.在MyEclipse中创建一个Dynamic Web Project，本文项目名称为SSHShop。

2.把Struts内apps文件夹下的struts2-blank war包用压缩工具解压，然后把WEB-INF/lib内的jar包和WEB-INF下的web.xml文件分别复制到SSHShop项目下的WEB-INF/lib内和WEB-INF下。

3.在src目录下创建相应package。

4.在WebContent下创建Register.jsp文件，并分别创建注册成功和注册失败的Success.jsp和Fail.jsp。

建完后Struts2的目录请见我参考博主的目录图。

接下来整合Struts2和参考博主一样；

  • web.xml 代码：
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  

    <display-name>SSH Project</display-name>  

    <filter>
        <filter-name>SSH</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
  <init-param>
        <param-name>config</param-name>
        <param-value>struts-default.xml,struts-plugin.xml,struts.xml</param-value>
    </init-param>
    <filter-mapping>
        <filter-name>SSH</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>  

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

</web-app>
  • Register.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>User Register Page</title>
</head>
<body>  

    <s:form action="register" method="post" namespace="/">
        <s:textfield name="user.username" label="用户名"></s:textfield>
        <s:password name="user.password" label="密码"></s:password>
        <s:select list="#{‘1‘:‘男‘,‘0‘:‘女‘}" listKey="key" listValue="value"
            name="user.gender" label="性别" value="1"></s:select>
        <s:submit value="注册"></s:submit>
    </s:form>  

</body>
</html>
  • UserForm.java
package com.zeb.ssh.beans;  

public class UserForm {  

    private String username;
    private String password;
    private int gender;  

    public String getUsername() {
        return username;
    }  

    public void setUsername(String username) {
        this.username = username;
    }  

    public String getPassword() {
        return password;
    }  

    public void setPassword(String password) {
        this.password = password;
    }  

    public int getGender() {
        return gender;
    }  

    public void setGender(int gender) {
        this.gender = gender;
    }  

}  
<?xml version="1.0" encoding="GBK"?>
<!-- 版本不一致 选择下面两个的一个 -->
<!--
<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.3//EN"
    "http://www.opensymphony.com/xwork/xwork-validator-1.0.3.dtd"> -->

<!DOCTYPE validators PUBLIC
 "-//Apache Struts//XWork Validator 1.0.2//EN"
 "http://struts.apache.org/dtds/xwork-validator-1.0.2.dtd">

<validators>
    <!-- 添加对用户名的校验 -->
    <field name="user.username">
        <field-validator type="requiredstring">
            <param name="trim">true</param>
            <message>用户名不能为空</message>
        </field-validator>
        <field-validator type="regex">
            <param name="regex"><![CDATA[(\w{6,16})]]></param>
            <message>用户名输入不合法，必须为长度在6~16中间的数字或字母</message>
        </field-validator>
    </field>

    <!-- 添加对密码的校验 -->
    <field name="user.password">
        <field-validator type="requiredstring">
            <param name="trim">true</param>
            <message>密码不能为空</message>
        </field-validator>
        <field-validator type="regex">
            <param name="regex"><![CDATA[(\w{6,16})]]></param>
            <message>密码输入不合法，必须为长度在6~16之间的数字或者字母</message>
        </field-validator>
    </field>
</validators>

注意：如果使用validator1.0.3的话，在接下来的整合会报错说是validator 已经转到Struts2那了，先试试1.0.3吧，增加下印象

  • struts.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd"> 

<struts>  

    <include file="struts-default.xml" />
    <package name="zeb" extends="struts-default" namespace="/">
        <action name="register" class="com.zeb.ssh.action.RegisterAction">
            <result name="input">/Register.jsp</result>
            <result name="success">/Success.jsp</result>
            <result name="error">/Fail.jsp</result>
        </action>
    </package>  

</struts>

<include file="struts-default.xml" /> 个人觉得这个可以去掉，有兴趣的可以去试试

相关整合Struts2后的截图与我参考博主的效果一致


接下来整合Hibernate4：

  1. 将Hibernate内的lib/required下的jar包和lib/jpa下的jar包复制到SSHProject项目的lib目录下。
  2. 在上面Struts项目的基础上添加com.zeb.ssh.dao和com.zeb.ssh.daoImpl包。分别创建BaseDao接口和UserDao类。
  3. 在数据库test中创建对应的表user,sql 在上边。
  4. 创建user表的Hibernate映射文件。因为这里要创建user表对应的POJO类，所以我这里把之前com.ynwi.ssh.beans包改成com.ynwi.ssh.forms包，用来存放页面传过来的表单数据，新创建com.ynwi.ssh.beans包，用来创建POJO对象来对应数据库中的表。路径：POJO类同目录。
  5. 建立Hibernate配置文件。路径：src目录下。
  6. 编写Session工厂类。整合Spring后，数据源的创建和SessionFactory的创建都交给Spring去管理，就无需这个工厂类了，所以这里我临时创建在daoImpl包里面。
  7. 修改业务逻辑实现类。

注：整合Hibernate4的步骤与参考博主一致

  • 整合Hibernate4结构图见：

    参考博主整合第二步

  • 接口类BaseDao.java的内容。注意：接口里的两个get/set方法是为了让实现类覆盖。这样使用BaseDao dao = new UserDao()的时候，dao实体中有这两个方法。
package com.zeb.ssh.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);
}
  • 实现类UserDao.java的内容
package com.zeb.ssh.daoImpl;  

import org.hibernate.HibernateException;
import org.hibernate.Session;  

import com.zeb.ssh.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);
    }  

}
  • 表user的POJO类User.java的内容，因为跟UserForm.java内容差不多，所以不再列出。这个比UserForm.java多一个userId属性，因为在表user里面有userId的column。在POJO类里需要跟这个column有映射。
  • POJO类User.java的Hibernate映射文件User.hbm.xml的内容。代码<generator class="native"></generator>说明将根据本地数据库的设置来创建userId，如MySQL中将表user的userId设置为自动增长，则在保存记录是，userId将自动增长。对于需要在程序中指定主键的值，则将generator的class属性设置为assigned。
  • User.hbm.xml
<?xml version="1.0" encoding=‘UTF-8‘?>
<!DOCTYPE hibernate-mapping PUBLIC
                            "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                            "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >  

<hibernate-mapping package="com.zeb.ssh.beans">
    <class name="User" table="user">
        <id name="userId" column="userId">
            <generator class="native"></generator>
        </id>
        <property name="username" column="userName" type="java.lang.String"
            not-null="true" length="16"></property>
        <property name="password" column="password" type="java.lang.String"
            not-null="true" length="16" />
        <property name="gender" column="gender" type="java.lang.Integer" length="1" />
    </class>
</hibernate-mapping>
  • Hibernate.cfg.xml
<?xml version=‘1.0‘ encoding=‘utf-8‘?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">  

<hibernate-configuration>
  <session-factory>
    <!-- Database connection settings -->
    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="connection.url">jdbc:mysql://localhost:3306/project</property>
    <property name="connection.username">root</property>
    <property name="connection.password">root</property>  

    <!-- JDBC connection pool (use the built-in) -->
    <!-- <property name="connection.pool_size">1</property> -->  

    <!-- SQL dialect -->
    <property name="dialect">org.hibernate.dialect.MySQLDialect</property>  

    <!-- Enable Hibernate‘s automatic session context management -->
    <!-- <property name="current_session_context_class">thread</property> -->  

    <!-- Disable the second-level cache  -->
    <!-- <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property> -->  

    <!-- Echo all executed SQL to stdout -->
    <property name="show_sql">true</property>  

    <!-- Drop and re-create the database schema on startup -->
    <!-- <property name="hbm2ddl.auto">update</property> -->
    <mapping resource="com/zeb/ssh/beans/User.hbm.xml"/>
  </session-factory>
</hibernate-configuration>
  • SessionFactory.java
package com.zeb.ssh.daoImpl;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

public class HibernateSessionFactory {

    private static final String CFG_FILE_LOCATION = "/Hibernate.cfg.xml";

    private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();

    private static final Configuration cfg = new Configuration()
            .configure(CFG_FILE_LOCATION);

    private static ServiceRegistryBuilder builder = new ServiceRegistryBuilder()
            .applySettings(cfg.getProperties());

    private static ServiceRegistry registry;

    private static SessionFactory sessionFactory;

    public static Session currentSession() throws HibernateException {
        Session session = threadLocal.get();

        if (session == null || session.isOpen() == false) {

            if (sessionFactory == null) {
                try {
                    registry = builder.buildServiceRegistry();
                    sessionFactory = cfg.buildSessionFactory(registry);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            session = sessionFactory.openSession();
            threadLocal.set(session);

        }

        return session;
    }

    public static void closeSession() throws HibernateException {
        Session session = threadLocal.get();
        threadLocal.set(null);
        if (session != null) {
            session.close();
        }
    }

}
  • UserManagerImpl.java:
package com.zeb.ssh.serviceImp;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.zeb.ssh.beans.User;
import com.zeb.ssh.dao.BaseDao;
import com.zeb.ssh.daoImpl.HibernateSessionFactory;
import com.zeb.ssh.daoImpl.UserDao;
import com.zeb.ssh.forms.UserForm;
import com.zeb.ssh.service.UserManager;

public class UserManagerImpl implements UserManager {

    private BaseDao dao;

    private Session session;

    public UserManagerImpl() {
        dao = new UserDao();
    }

    @Override
    public void regUser(UserForm userForm) throws HibernateException {
        session = HibernateSessionFactory.currentSession();
        dao.setSession(session);
        // 获取事务
        Transaction ts = session.beginTransaction();
        // 构造User对象
        User user = new User();
        user.setUsername(userForm.getUsername());
        user.setPassword(userForm.getPassword());
        user.setGender(userForm.getGender());
        // 保存User对象
        dao.saveObject(user);
        // 提交事务
        ts.commit();
        // 关闭Session
        HibernateSessionFactory.closeSession();
    }

}

整合后的系统截图：

请参考

运行截图、数据库插入数据截图、Hibernate-show_sql


接下来到了最为关键的一点——整合Spring4，其中有Spring与Struts2的整合、Spring4和Hibernate4的整合，相关的Jar包请看本人上传的52个Jar包，其中有jdbc-jar包，但不保证个个用到了。

  • 接下来【参考博主】整合Spring的步骤：
  • 1.将Spring内libs目录下包含所有的jar包（不需要复制结尾为sources和javadoc的jar包）到SSHProject项目的lib目录下。
  • 2.编写Spring的配置文件applicationContext.xml。路径：src目录下，需要在web.xml配置context-param指定路径，或者把该文件放在WEB-INF下，跟web.xml同目录。这里由于Spring配置数据源的需要，需要把Hibernate内lib/optional/c3p0下的c3p0-0.9.1.jar复制到lib下。
  • 3.修改BaseDao和UserDao。在引入Spring后，需要用Spring进行统一的事务管理，数据源和sessionFactory都交给Spring去生成，因此接口类和实现类BaseDao和UserDao都需要做相应的修改。Spring提供了HibernateDaoSupport类来完成对数据的操作，因此UserDao在实现BaseDao的同时还需要继承HibernateDaoSupport;类。并将先前获取session的操作修改为getSessionFactory().openSession()方法。（这个好像没有关系到Spring事务管理）
  • 4，修改业务逻辑实现类。在没有加入Spring之前，业务逻辑实现类的Session的获得，dao的实例化，以及事务的管理都是该类执行管理的。加入Spring后，这些都交给Spring去管理。该类的dao的实例化由Spring注入。
  • 5.修改用户注册的RegisterAction类。同样，RegisterAction类中的userManager的实例化也由Spring注入。
  • 6.删除Hibernate的配置文件Hibernate.cfg.xml和工厂类HibernateSesseionFactory类。他们的工作已经交给Spring去做，已经不再有用。（整合Spring、Hibernate）
  • 7.修改web.xml，加载Spring。要想启动时加载Spring的配置文件，需要在web.xml中配置对应的监听器（listenser），并制定Spring的配置文件。
  • 8.修改Struts的配置文件struts.xml。把原来指定的名为register的action的class由原来的路径变为applicationContext.xml文件中该Action的id。
  • 本人整合后的结果图：
  1. 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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  

    <!-- 定义数据源的信息 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
        destroy-method="close">
        <property name="driverClass">
            <value>com.mysql.jdbc.Driver</value>
        </property>
        <property name="jdbcUrl">
            <value>jdbc:mysql://localhost/test</value>
        </property>
        <property name="user">
            <value>root</value>
        </property>
        <property name="password">
            <value>123456</value>
        </property>
        <property name="maxPoolSize">
            <value>80</value>
        </property>
        <property name="minPoolSize">
            <value>1</value>
        </property>
        <property name="initialPoolSize">
            <value>1</value>
        </property>
        <property name="maxIdleTime">
            <value>20</value>
        </property>
    </bean>  

    <!--定义Hibernate的SessionFactory -->
    <!-- SessionFactory使用的数据源为上面的数据源 -->
    <!-- 指定了Hibernate的映射文件和配置信息 -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource">
            <ref local="dataSource" />
        </property>
        <property name="mappingResources">
            <list>
                <value>com/zeb/ssh/beans/User.hbm.xml</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hiberante.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">false</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>  

    <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <bean id="baseDao" class="com.zeb.ssh.daoImpl.UserDao">
        <property name="sessionFactory">
            <ref bean="sessionFactory" />
        </property>
    </bean>  

    <!--用户注册业务逻辑类 -->
    <bean id="userManager" class="com.zeb.ssh.serviceImpl.UserManagerImpl">
        <property name="dao">
            <ref bean="baseDao" />
        </property>
    </bean>  

    <!-- 用户注册的Action -->
    <bean id="registerAction" class="com.zeb.ssh.action.RegisterAction">
        <property name="userManager">
            <ref bean="userManager" />
        </property>
    </bean>  

    <!-- more bean definitions go here -->  

</beans>
  1. 修改后的接口类Dao和实现类UserDao的内容。

    BaseDao.java

package com.zeb.ssh.dao;

import org.hibernate.HibernateException;

public interface BaseDao {

    public void saveObject(Object obj) throws HibernateException;

}
  1. UserDao.java
package com.zeb.ssh.daoImpl;

import org.hibernate.HibernateException;
import org.springframework.orm.hibernate4.support.HibernateDaoSupport;

import com.zeb.ssh.dao.BaseDao;

public class UserDao extends HibernateDaoSupport implements BaseDao {

    @Override
    public void saveObject(Object obj) throws HibernateException {
        getSessionFactory().openSession().save(obj);
    }

}

4.修改后的业务逻辑实现类UserManagerImpl的内容。

package com.zeb.ssh.serviceImpl;

import org.hibernate.HibernateException;
import org.springframework.beans.BeanUtils;

import com.zeb.ssh.beans.User;
import com.zeb.ssh.dao.BaseDao;
import com.zeb.ssh.forms.UserForm;
import com.zeb.ssh.service.UserManager;

public class UserManagerImpl implements UserManager {

    private BaseDao dao;

    public void setDao(BaseDao dao) {
        this.dao = dao;
    }

    @Override
    public void regUser(UserForm userForm) throws HibernateException {
        User user = new User();
        BeanUtils.copyProperties(userForm, user);
        dao.saveObject(user);
    }

}

5.修改后的用户注册Action类RegisterAction的内容。

package com.zeb.ssh.action;

import com.opensymphony.xwork2.ActionSupport;
import com.zeb.ssh.forms.UserForm;
import com.zeb.ssh.service.UserManager;

public class RegisterAction extends ActionSupport {

    private static final long serialVersionUID = 1L;

    private UserForm user;

    private UserManager userManager;

    public UserForm getUser() {
        return user;
    }

    public void setUser(UserForm user) {
        this.user = user;
    }

    public void setUserManager(UserManager userManager) {
        this.userManager = userManager;
    }

    public String execute() {
        try {
            userManager.regUser(user);
            return SUCCESS;

        } catch (Exception e) {
            e.printStackTrace();
            return ERROR;
        }
    }

}
  • 修改后的web.xml的内容
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  

    <display-name>SSH Project</display-name>  

    <filter>
        <filter-name>SSH</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
  <init-param>
        <param-name>config</param-name>
        <param-value>struts-default.xml,struts-plugin.xml,struts.xml</param-value>
    </init-param>
    <filter-mapping>
        <filter-name>SSH</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>  

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

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

</web-app>
  • 修改后的Struts配置文件struts.xml的内容
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">

<struts>
    <constant name="struts.objectFactory" value="spring" />

    <package name="zeb" extends="struts-default" namespace="/">
        <action name="register" class="registerAction">
            <result name="input">/Register.jsp</result>
            <result name="success">/Success.jsp</result>
            <result name="error">/Fail.jsp</result>
        </action>
    </package>  

</struts>

运行结果：

数据库截图：

总结

  • 一开始遇到过整合时Jar缺少，在遇到错误时，直接搜问题，补充Jar包。
  • Hibernate3与Hibernate4之间的区别，Hibernate3是getHibernateTemplate()来获取Session，Hibernate4用getSessionFactory().openSession()
  • 检验，RegisterAction-validation.xml validator-1.0.2-dtd 的改变
  • 定义Bean-sessionFactory，Bean-transactionManager所调用的class
  • <constant name="struts.objectFactory" value="spring" /> struts.xml试试这句话的效果，有可能导致Spring无法管理Struts（I Guess）.
  • Spring整合Hibernate时：有可能找不到cfg文件

    <context-param>

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

    <param-value>classpath:applicationContext.xml</param-value>

    </context-param>

  • Spring整合Struts时，有可能没找到Struts-default.xml：

    <init-param>

    <param-name>config</param-name>

    <param-value>struts-default.xml,struts-plugin.xml,struts.xml</param-value>

    </init-param>

最后：

框架玩的就是Jar包、配置，对初学者可能会有挑战性。希望本人的项目SSHShop对有需要的人有所帮助。


May-The-Good-Luck-Be-With-You

时间： 2024-11-03 16:50:18

SSH框架手动整合——Struts2+Hibernate4+Spring4的相关文章

SSH框架的简化(struts2、spring4、hibernate5)

目的: 在上次的基础下,对ssh框架进行简化. 1.本文提纲:本文通过一个新闻管理系统的实例来简化ssh框架的代码编写,功能包括查询数据库中所有新闻信息,删除某条新闻信息.     2.本项目的搭建环境:Windows 8-64位,Eclipse(开发工具),jdk1.8.0_91,Tomcat 8.0 ,mysql数据库. 第一步:在eclipse里创建web项目 (news) 第二步:导入本次项目要使用到的jar包 第三步:在配置文件web.xml配置一个struts2的过滤器和spring

SSH框架的整合详解

"-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> SSH框架的整合详解 - super_YC的博客 - 博客频道 - CSDN.NET super_YC的博客 记录我生活的一点一滴!我很开心拥有这样一个自己心事的笔记本 目录视图 摘要视图 订阅 [活动]2017 CSDN博客专栏评选 &nbsp [5月书讯]流畅的P

【SSH框架】之Struts2系列（二）

微信公众号:compassblog 欢迎关注.转发,互相学习,共同进步! 有任何问题,请后台留言联 1.Struts2常量配置 (1).Struts2默认常量配置文件路径,如下图: (2).Struts2常量配置方式:以配置国际化字节编码UTF-8为例 方式1:在struts.xml文件中配置 <constant name="struts.i18n.encoding" value="UTF-8"></constant> 方式2:在src下创建

maven项目ssh框架的整合

1.环境 eclipse版本:Eclipse Mars2 4.5jdk版本:1.8maven版本:apache-maven 3.3.9zhnegs这是主要的开发工具版本,ssh的各种jar包版本就不列举了. 2.依赖传递与依赖冲突的解决 在整合开始前需要先介绍依赖传递与依赖冲突的问题:依赖传递: 如图.可以看到在pom文件中只是导入了struts的核心包,在项目中去将核心包依赖的jar包全部都导入进来,这种依赖关系就会产生依赖传递. 依赖冲突:那如何会冲突呢,在整合ssh框架中,项目采用的包会有

SSH框架简化（struts2+spring+hibernate）

目的: 通过对ssh框架有了基础性的学习,本文主要是使用注解的方式来简化ssh框架的代码编写. 注意事项: .运行环境:Windows 8-64位,Eclipse(开发工具),jdk1.8.0_91,Tomcat 8.0,struts-2.3.30-apps,spring-framework-4.2.2.RELEASE,hibernate-release-5.2.2.Final,mysql数据库 一.  在eclipse右键新建一个项目并勾上生成web.xml文件 二.导入struts.spri

[SSH] Eclipse+Struts2+Hibernate4+Spring4的整合

在前面Struts2和Hibernate4的整合基础上,对Spring4进行整合,网上参考的大概都是Spring4+Hibernate3或者基于MyEclispe的,这里把自己研究后的配置和大家分享一下. 本次相关的版本如下: Spring : spring-framework-4.0.1.RELEASE 1.将相关的jar包导入: 1.1libs目录下包含所有的jar包(不需要复制结尾为sources和javadoc的jar包)到SSHProject项目的lib目录 1.2 Hibernate

[SSH] Eclipse+Struts2+Hibernate4+Spring4的手动入门配置流程

整合一下自己在配置环境时候的方法,因为网上大部分都是MyEclipse自动配置或者低版本的,这里自己研究了一下新版本不同的地方,用的基本都是最新的,将配置方法跟大家分享一下,下面是所有的环境版本信息: 操作系统:Win7 64bit JDK:1.7.0_67 for 64bit Tomcat: apache-tomcat-8.0.24-windows-x64 Eclipse: eclipse-jee-mars-R-win32-x86_64.zip MySql : MySQL Server 5.5

【SSH框架】之Struts2系列（一）

微信公众号:compassblog 欢迎关注.转发,互相学习,共同进步! 有任何问题,请后台留言联系 1.Struts2框架概述 (1).什么是Struts2 Struts2是一种基于MVC模式的轻量级web框架,本质上相当于一个servlet.在MVC设计模式中,Struts2作为控制器来建立模型与视图的数据交互,以WebWork为核心,采用拦截器机制来处理用户的请求,使得业务逻辑控制器能够与ServletAPI完全脱离,是致力于组件化和代码重用的J2EE Web框架. (2).Struts2

SSH之Spring整合struts2

Struts2+spring整合/result常用类型/拦截器 为什么?通过spring管理Struts2的组件,实现注入 怎么整合? 1.创建项目 2.导包:struts2-spring-plugin struts2-core 3.配置文件:web.xml spring-context.xml web.xml:配置struts2的filert,配置spring的启动加载配置文件,配置spring的监听器 <!-- 配置spring监听,用于初始化spring容器 --> <listen