ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

Idea 搭建 SSH 项目框架

2019-08-01 14:05:05  阅读：139  来源： 互联网

标签：spring Idea springframework SSH org import com public 搭建


引言

　　在平时的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>
View Code

编写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>
View Code

　　在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>
View Code

在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();
    }
}
View Code

　　这里主要使用注解将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://103.40.29.133:3306/javadb?useUnicode=true
jdbc_username=jaminhuang
jdbc_password=opN9d1t3AUQ#Kzyy

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;
    }
}
View Code

　　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

 

标签：spring,Idea,springframework,SSH,org,import,com,public,搭建
来源： https://www.cnblogs.com/huanghzm/p/11271935.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有