Idea 搭建 SSH 项目框架

引言

　　在平时的JavaEE开发中，为了能够用最快的速度开发项目，一般会选择使用Struts2、SpringMVC、Spring、Hibernate、MyBatis这些开源框架来开发项目。

　　本文来总结一下如何使用Maven搭建Struts2+Spring3+Hibernate4的整合开发环境。

建立Maven工程

　　根据下图，一步步操作设定，填写GroupId、ArtifactId；创建完成后，Maven install 进行编译发布。

　　完成的项目结构，如下图所示

搭建Spring3开发环境

加载Spring依赖包

<!-- spring -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>${spring.version}</version>
    </dependency>

编写Spring配置文件

　　在src/main/resources目录下创建一个spring.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd" >

    <!--  引入属性文件  -->
    <context:property-placeholder location="classpath:/config.properties" />
    <!--  自动扫描dao和service包  -->
    <context:component-scan base-package="com.service" />
</beans>

　　在src/main/resources目录下创建一个config.properties文件，文件中的内容暂时先不编写，等整合Hibernate时再编写具体数据库链接信息。

编写单元测试

　　在src/main/java中创建com.servier包，编写IUserService接口

package com.service;

public interface IUserService {
    /**
     * 测试方法
     */
    void test();
}

　　在src/main/java中创建com.service.impl包，在包中编写UserServiceImpl实现类

package com.service.impl;

import com.service.IUserService;
import org.springframework.stereotype.Service;

@Service("userService")
public class UserServiceImpl implements IUserService {

    @Override
    public void test() {
        System.out.println("Hello World");
    }
}

　　进行单元测试时，需要用到Junit，所以在pom.xml中添加Junit的jar包描述

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

　　最后，在src/main/test中创建com.test包，在包中编写TestSpring类

package com.test;

import com.service.IUserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {

    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring.xml");
        IUserService userService = (IUserService) applicationContext.getBean("userService");
        userService.test();
    }
}

在web.xml中配置Spring监听器

 <!-- Spring 监听器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
    <!-- Spring 配置文件位置 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml</param-value>
  </context-param>

测试

搭建Struts2开发环境并整合Spring3

加载Struts2依赖包

<!-- Struts2的核心包 -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-core</artifactId>
      <version>2.3.16</version>
    </dependency>
    <!-- 注解方式 -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-convention-plugin</artifactId>
      <version>2.3.20</version>
    </dependency>
    <!-- action映射 -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-config-browser-plugin</artifactId>
      <version>2.3.20</version>
    </dependency>
    <!-- Struts2和Spring整合插件 -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-spring-plugin</artifactId>
      <version>2.3.4.1</version>
    </dependency>

编写Struts.xml配置文件

　　在src/main/resources目录下创建一个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>
    <!--  指定spring负责action创建  -->
    <constant name="struts.objectFactory" value="spring" />
    <!--  所有匹配*.action的请求都有Struts2处理  -->
    <constant name="struts.action.extension" value="action" />
    <!--  是否启用开发者模式  -->
    <constant name="struts.devMode" value="true" />
    <!--  是否重新加载  -->
    <constant name="struts.configuration.xml.reload" value="true" />
    <!--  设置浏览器缓存静态内容  -->
    <constant name="struts.serve.static.browserCache" value="true" />
    <!--  请求参数的编码方式  -->
    <constant name="struts.i18n.encoding" value="utf-8" />
    <!--  文件上传最大值  -->
    <constant name="struts.multipart.maxSize" value="104857600" />
    <!--  动态调用方式，使用叹号访问方法  -->
    <constant name="struts.enable.DynamicMethodInvocation" value="true" />
    <!--  Action名称中是否使用斜线  -->
    <constant name="struts.enable.SlashesInActionNames" value="false" />
    <!--  允许标签中使用表达式语法  -->
    <constant name="struts.tag.altSyntax" value="true" />
    <!--  对于WebLogic，Orion属性设置为ture  -->
    <constant name="struts.dispatcher.parametersWorkaround" value="true" />

    <package name="basePackage" extends="struts-default" >

    </package>
</struts>

在web.xml中配置Struts2的过滤器

    <!--  Struts2的核心过滤器配置  -->
    <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>*.action</url-pattern>
    </filter-mapping>

编写测试

　　首先，在src/main/java中创建com.action包，在包中编写一个Action类

package com.action;

import com.service.IUserService;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.springframework.beans.factory.annotation.Autowired;

@ParentPackage("basePackage")
@Action(value = "strust2Test")
@Namespace("/")
public class TestAction {

    @Autowired
    private IUserService userService;

    public void  test() {
        System.out.println("进入TestAction");
        userService.test();
    }
}

　　这里主要使用注解将userService注入到UserAction中，输入访问地址：http://localhost:8080/strust2Test!test.action

搭建Hibernate4开发环境并整合Spring3

加载Hibernate依赖包

    <!--  Hibernate4  -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>4.1.7.Final</version>
    </dependency>

添加数据库和连接池驱动包

　　Hibernate是用于和数据库交互的，应用系统所有的CRUD操作都要通过Hibernate来完成。

　　在平时开发中，我们一般都会使用数据库连接池，应用系统初始化时，由数据库连接池想数据库申请一定数量的数据库链接，以下采用Druid的jar包。

    <!--  MySQL驱动包  -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.34</version>
    </dependency>
    <!--  Druid连接池包  -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.0.12</version>
    </dependency>

添加aspectjweaver包

　　使用Spring的AOP时需要使用aspectjweaver包，如下所示：

    <!--  aspectjweaver包  -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.5</version>
    </dependency>

编写链接数据库的配置信息

　　在src/main/resources目录下的config.properties文件中，编写连接数据库需要使用到的相关信息，如下所示：

hibernate.dialect=org.hibernate.dialect.MySQLDialect
driverClassName=com.mysql.jdbc.Driver
validationQuery=SELECT 1
jdbc_url=jdbc:mysql://*******:3306/javadb?useUnicode=true
jdbc_username=******
jdbc_password=*****

hibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.format_sql=true

编写Hibernate与Spring整合的配置文件

　　在src/main/resources目录下新建一个spring-hibernate.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:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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/aop
                           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd" >
    <!--  配置数据源  -->
    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc_url}" />
        <property name="username" value="${jdbc_username}" />
        <property name="password" value="${jdbc_password}" />

        <!--    初始连接池大小    -->
        <property name="initialSize" value="0"/>
        <!--    连接池最大使用链接数量    -->
        <property name="maxActive" value="20" />
        <!--    连接池最大空闲    -->
        <property name="maxIdle" value="20" />
        <!--    连接池最小空闲    -->
        <property name="minIdle" value="0" />
        <!--    连接池最大等待时间    -->
        <property name="maxWait" value="60000" />

        <property name="validationQuery" value="${validationQuery}" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />
        <property name="testWhileIdle" value="true" />

        <property name="timeBetweenConnectErrorMillis" value="60000" />
        <property name="minEvictableIdleTimeMillis" value="25200000" />

        <property name="removeAbandoned" value="true" />
        <property name="removeAbandonedTimeout" value="1800" />
        <property name="logAbandoned" value="true" />
        <!--    监控数据库    -->
        <property name="filters" value="mergeStat" />
    </bean>

    <bean name="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean" >
        <property name="dataSource" ref="dataSource" />
        <property name="hibernateProperties">
            <props>
                <!--   web项目启动时是否更新表结构 -->
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <!--   系统使用数据库方言 -->
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <!--   是否打印sql到控制台 -->
                <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>com.model</value>
            </list>
        </property>
    </bean>
    
    <!--  配置事务管理器  -->
    <bean name="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    <!--  拦截器方式配置事务  -->
    <tx:advice id="transactionAdvice" transaction-manager="transactionManager" >
        <tx:attributes>
            <!--  以下关键字开头使用事务  -->
            <tx:method name="add*" />
            <tx:method name="save*" />
            <tx:method name="update*" />
            <tx:method name="edit*" />
            <tx:method name="delete*" />
            <tx:method name="remove*" />
            <!--  以下关键字开头不使用事务  -->
            <tx:method name="get*" propagation="SUPPORTS" />
            <tx:method name="find*" propagation="SUPPORTS" />
            <tx:method name="load*" propagation="SUPPORTS" />
            <tx:method name="search*" propagation="SUPPORTS" />
            <!--  其他方法不使用事务  -->
            <tx:method name="*" propagation="SUPPORTS" />
        </tx:attributes>
    </tx:advice>
    <!--  AOP切面  -->
    <aop:config>
        <aop:pointcut id="transactionPointcut" expression="execution(* com.service..*Impl.*(..))"/>
        <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice" />
    </aop:config>
</beans>

编写单元测试代码

　　1. 在MySQL中创建数据库javadb

　　2. 在src/main/java中创建com.model包，在包中创建UserInfo类，如下图所示：

package com.model;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;

@Entity
@Table(name = "UserInfo", schema = "javadb")
public class UserInfo implements Serializable {

    private String UserId;
    private String UserName;
    private int Age;
    private Date UpdateTime;

    public UserInfo() {

    }

    public UserInfo(String userId, String userName, int age, Date updateTime) {
        this.UserId = userId;
        this.UserName = userName;
        this.Age = age;
        this.UpdateTime = updateTime;
    }

    @Id
    @Column(name = "UserId", unique = true, nullable = false, length = 20)
    public String getUserId() {
        return UserId;
    }

    public void setUserId(String userId) {
        UserId = userId;
    }

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

    public void setUserName(String userName) {
        UserName = userName;
    }

    @Column(name = "Age", nullable = false, length = 4)
    public int getAge() {
        return Age;
    }

    public void setAge(int age) {
        Age = age;
    }

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "UpdateTime", length = 7)
    public Date getUpdateTime() {
        return UpdateTime;
    }

    public void setUpdateTime(Date updateTime) {
        UpdateTime = updateTime;
    }
}

　　3. 在src/main/java中创建com.dao包，在包中创建UserInfoDao接口，如下图所示：

package com.dao;

import com.model.UserInfo;

import java.io.Serializable;

public interface IUserInfoDao {

    /**
     * 保存用户
     * @param model 用户对象
     * @return
     */
    Serializable save(UserInfo model);
}

　　4. 在src/main/java中创建com.dao.impl包，在包中创建UserInfoDaoImpl实现类，如下图所示：

package com.dao.impl;

import com.dao.IUserInfoDao;
import com.model.UserInfo;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.io.Serializable;

@Repository("userInfoDao")
public class UserInfoDaoImpl implements IUserInfoDao {

    /**
     * 注入Session工厂
     */
    @Autowired
    private SessionFactory sessionFactory;

    @Override
    public Serializable save(UserInfo model) {
        return sessionFactory.getCurrentSession().save(model);
    }
}

　　5. 在之前的IUserInfoService接口中添加save方法，如下图所示：

package com.service;

import com.model.UserInfo;

import java.io.Serializable;

public interface IUserService {
    /**
     * 测试方法
     */
    void test();

    /**
     * 保存用户
     * @param model 用户对象
     * @return
     */
    Serializable save(UserInfo model);
}

　　6. 同时在UserInfoServiceImpl实现类中实现方法，如下图所示：

package com.service.impl;

import com.dao.IUserInfoDao;
import com.model.UserInfo;
import com.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.Serializable;

@Service("userService")
public class UserServiceImpl implements IUserService {

    @Autowired
    private IUserInfoDao userInfoDao;

    @Override
    public void test() {
        System.out.println("Hello World");
    }

    @Override
    public Serializable save(UserInfo model) {
        return userInfoDao.save(model);
    }
}

　　7. 编写测试类，进行单元测试

package com.test;

import com.model.UserInfo;
import com.service.IUserService;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Date;

public class TestHibernate {

    private IUserService userService;

    /**
     * 在所有测试方法之前执行，且只执行一次
     */
    @Before
    public void before() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(new String[] {"spring.xml", "spring-hibernate.xml"});
        userService = (IUserService) applicationContext.getBean("userService");
    }

    @Test
    public void testSave() {
        UserInfo userInfo = new UserInfo();
        userInfo.setUserId("userId");
        userInfo.setUserName("小明");
        userInfo.setAge(25);
        userInfo.setUpdateTime(new Date());
        userService.save(userInfo);
    }
}

　　运行单元测试，获得输出信息；同时javadb数据库当中创建了userinfo表

错误说明

　　在对当前测试的同时，由于添加了spring-hibernate.xml文件，则在上文之前配置的TestSpring测试类中，需要调整相关测试代码，如下图所示

package com.test;

import com.service.IUserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

@RunWith(BlockJUnit4ClassRunner.class)
public class TestSpring {

    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(new String[] {"spring.xml", "spring-hibernate.xml"});
        IUserService userService = (IUserService) applicationContext.getBean("userService");
        userService.test();
    }
}

三大框架综合测试

完善web.xml文件中的配置

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>

  <!-- Spring 监听器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- Spring 配置文件位置 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml,classpath:spring-hibernate.xml</param-value>
  </context-param>

  <!-- 防止spring内存溢出监听器 -->
  <listener>
    <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
  </listener>

  <!-- openSessionInViewFilter配置 -->
  <filter>
    <filter-name>openSessionInViewFilter</filter-name>
    <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
    <init-param>
      <param-name>singleSession</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>openSessionInViewFilter</filter-name>
    <url-pattern>*.action</url-pattern>
  </filter-mapping>

  <!--  Struts2的核心过滤器配置  -->
  <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>*.action</url-pattern>
  </filter-mapping>

  <!-- druid监控页面，使用${pageContext.request.contextPath}/druid/index.heml访问 -->
  <servlet>
    <servlet-name>druidStatView</servlet-name>
    <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>druidStatView</servlet-name>
    <url-pattern>/druid/*</url-pattern>
  </servlet-mapping>
</web-app>

编写测试代码

　　在TestAction类中添加一个saveUser方法。

package com.action;

import com.model.UserInfo;
import com.service.IUserService;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Date;

@ParentPackage("basePackage")
@Action(value = "strust2Test")
@Namespace("/")
public class TestAction {

    /**
     * 注入userService
     */
    @Autowired
    private IUserService userService;

    /**
     * 测试地址：http://localhost:8080/strust2Test!test.action
     */
    public void  test() {
        System.out.println("进入TestAction");
        userService.test();
    }

    /**
     * 测试地址：http://localhost:8080/strust2Test!saveUser.action
     */
    public void saveUser() {
        UserInfo userInfo = new UserInfo();
        userInfo.setUserId("abc");
        userInfo.setUserName("abc");
        userInfo.setAge(23);
        userInfo.setUpdateTime(new Date());
        userService.save(userInfo);
    }
}

　　运行，在浏览器输入地址 http://localhost:8080/strust2Test!saveUser.action