Struts2SpringHibernate框架的简单整合1

最新推荐文章于 2025-09-05 16:34:31 发布

梦道愚

最新推荐文章于 2025-09-05 16:34:31 发布

阅读量303

点赞数

CC 4.0 BY-SA版权

分类专栏： java 文章标签： java

本文链接：https://blog.youkuaiyun.com/qq_36399629/article/details/78065184

java 专栏收录该内容

9 篇文章

订阅专栏

本文详细介绍了一个简单的SSH(Struts2 + Spring + Hibernate)框架整合过程，包括Maven项目的搭建、依赖配置、Spring与Hibernate的整合及测试。

之前学ssh框架整合的时候，没看视频，直接去网络上找那些整合好的东西，结果，很痛苦，要问为什么，因为那些看上去整合好的，不是要积分的不知道能不能运行的，就是根本不能运行的，只有零零散散的是能运行的，自己本来以为看了那些，在加上自己之前零零散散的看的关于struts2，hibernate，spring的知识就可以完成整合。
不过还是不行，可能和个人天资有关吧
现在终于在视频的指导下，将框架基本整合好了，下面我详说一下整合的步骤吧：
我之前是使用eclipse＋maven进行操作的，现在使用sts+maven，sts是eclipse的一个插件，刚开始用，操作方法和eclipse一样，感觉除了上面安装的插件版本可以更高一点之外，并没有什么更加好用之类的，里面的sql文件竟然没有建立打开方式，format的快捷键也只有在java文件之中才比较灵敏一些。
开始的第一步是建项目：
然后在pom.xml添加相关联的jar包，对于这个，我是将学习好的成品jar包直接复制过来的

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>study.intergration</groupId>
  <artifactId>StrutsSpringHibernate</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <description>SSH框架整合简单项目</description>
    <properties>  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <struts.version>2.5.12</struts.version>
        <spring.version>4.3.10.RELEASE</spring.version>
<hibernate.version>5.2.2.Final</hibernate.version>
        <mysql.version>5.1.34</mysql.version>
    </properties>
    <dependencies>
        <!-- Junit依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- Spring 核心依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring web依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Struts2 核心依赖 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>${struts.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.javassist</groupId>
                    <artifactId>javassit</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- Struts2和Spring整合依赖 -->
        <!-- 将struts2中action的类在web容器启动的时后加入spring上下文中 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>${struts.version}</version>
        </dependency>
        <!-- strtus2注解用包 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-convention-plugin</artifactId>
            <version>${struts.version}</version>
        </dependency>
        <!-- Spring整合ORM框架依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Hibernate 核心依赖 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!-- MySQL 依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!-- druid依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.38</version>
        </dependency>
        <!-- AspectJ依赖 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.10</version>
        </dependency>
    </dependencies>
</project>

首先进行对Spring是否成功配置进行检查
spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    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:p="http://www.springframework.org/schema/p"
    xmlns:util="http://www.springframework.org/schema/util" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xsi:schemaLocation="
    http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/jdbc
    http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
    http://www.springframework.org/schema/cache
    http://www.springframework.org/schema/cache/spring-cache-3.1.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd  http://www.springframework.org/schema/util
    http://www.springframework.org/schema/util/spring-util.xsd">
    <!-- 开启包扫描，并注册注解,我的命名为ssh1.* -->
    <context:component-scan base-package="ssh1.service" />
    <!-- 属性文件的配置是为了之后hibernate框架的使用而放入的 -->
    <context:property-placeholder location="classpath:jdbc.properties" />
</beans>

下面是进行测试需要在service包中建立相关类

package ssh1.service;
public interface UserServiceI {
    public void test();
}

package ssh1.service.impl;

import org.springframework.stereotype.Service;

import ssh1.service.UserServiceI;

@Service("userService")

public class UserServiceImpl implements UserServiceI{

    @Override
    public void test() {
        System.out.println("进行测试");
    }
}

下面的测试类，放在test下面新建的test.ModelTest下
测试类下面我只写方法！

    @Test
    public void testSpring() {
        ApplicationContext ac=new ClassPathXmlApplicationContext(new String[] {"classpath:spring.xml"});
        UserServiceI userService=(UserServiceI)ac.getBean("userService");
        userService.test();
    }

使用junit插件运行之后，console中打印出进行测试的字样，并且在junit上面没有报错就代表spring配置好了
这里写图片描述

下面开始配置hibernate，首先需要建立好model下面的包，另外配置好配置文件
首先是jdbc.properties

jdbc.url=jdbc:mysql:///你使用的数据库?useSSL=true&characterEncoding=UTF-8
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.username=你的数据库账号
jdbc.password=你的数据库密码
hibernate.hbm2ddl.auto=update
hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
hibernate.show_sql=true
hibernate.format_sql=false
sessionInfoName=sessionInfo
uploadFieldName=filedate

然后是spring-hibernate.xml，spring-hibernate整合的文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    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:p="http://www.springframework.org/schema/p"
    xmlns:util="http://www.springframework.org/schema/util" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xsi:schemaLocation="
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/jdbc
    http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
    http://www.springframework.org/schema/cache
    http://www.springframework.org/schema/cache/spring-cache-3.1.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/util
    http://www.springframework.org/schema/util/spring-util.xsd">
    <!-- 这里使用druid，看视频里面是使用这个的，另外也听说比较好用，可以在web.xml里面进行配置然后直接查看数据库的连接情况 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
        init-method="init">
        <!-- 数据库连接相关信息 -->
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    <!-- 配置Hibernate的SessionFactory -->
    <bean id="sessionFactory"
    class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 注入连接池 -->
        <property name="dataSource" ref="dataSource" />
        <!-- 配置Hibernate属性 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop><!-- 是否自动创建表结构 -->
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop><!-- 是否展示SQL -->
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
            </props>
        </property>
        <!-- 扫描并加载注解过的实体类 -->
        <property name="packagesToScan">
            <list>
                <value>ssh1.model</value>
            </list>
        </property>
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="transactionManager"
    class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <!-- 注入SessionFactory -->
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
        <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
         <property name="sessionFactory">
            <ref bean="sessionFactory"/>
        </property>
    </bean> 
    <!-- 拦截器方式配置事务 -->
    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 配置需要这里使用最简配置-->
            <tx:method name="*" />
        </tx:attributes>
    </tx:advice>
    <!-- 配置切面 -->
    <aop:config>
        <!-- 配置切入点 * ssh1.service.*+.*(..) *：表示方法的作用域，*表示所有 ssh1.service.*：表示ssh1.service下的任何包 
            ssh1.service.*+：表示ssh1.service下的任何包及其子包 *(..)：*表示任何方法，(..)表示方法的任何参数 -->
        <aop:pointcut id="transactionPointcut" expression="execution(* ssh1.service..*Impl.*(..))" />
        <!-- 适配切入点和事务增强 -->
        <aop:advisor advice-ref="transactionAdvice" pointcut-ref="transactionPointcut" />
    </aop:config>
</beans>

下面是在model包下面建立与table类
这里是使用注解配置


@Entity(name = "tuser")
public class Tuser {
    private String id;
    private String name;
    private String pwd;
    private Set<Trole> roles=new HashSet<Trole>();

    public Tuser() {
        super();
    }

    public Tuser(String id) {
        super();
        this.id = id;
    }

    public Tuser(String id, String name, String pwd) {
        super();
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    @Id
    @Column(name = "id", unique = true, nullable = false, length = 36)
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Column(name = "name", nullable = false, length = 50)
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Column(name = "pwd", nullable = false, length = 36)
    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @ManyToMany
    public Set<Trole> getRoles() {
        return roles;
    }

    public void setRoles(Set<Trole> roles) {
        this.roles = roles;
    }


}

同时开始进行测试，在dao下面的包建立接口UserDaoI
接口中建立一个用来测试的方法save();

public interface UserDaoI {
    public Serializable save(Tuser t);

    public void query(String hql);

    public List<Tuser> findAll();

    public List<Tuser> login(Tuser user);
}

在Impl中实现该方法

@Repository("userDao")
public class UserDaoImpl implements UserDaoI {
    private HibernateTemplate hibernateTemplate;

    public HibernateTemplate getHibernateTemplate() {
        return hibernateTemplate;
    }

    @Resource(name = "hibernateTemplate")
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }

    @Override
    public Serializable save(Tuser t) {
        return this.getHibernateTemplate().save(t);
    }

然后在service下的UserServiceI中同样添加一个方法

public Serializable save(Tuser t);

在UserServiceImpl中进行实现

    @Override
    public Serializable save(Tuser t) {
        return userDao.save(t);
    }

然后开始测试

    @Test
    public void testSpring2() {
        ApplicationContext ac=new ClassPathXmlApplicationContext(new String[] {"classpath:spring.xml","classpath:spring-hibernate.xml"});
        UserServiceI userService=(UserServiceI)ac.getBean("userService");
        Tuser t=new Tuser();
        t.setId(UUID.randomUUID().toString());
        t.setName("admin");
        t.setPwd("admin");
        userService.save(t);
    }