IntelliJ IDEA搭建SSH框架 maven项目的过程总结

最新推荐文章于 2023-02-23 21:33:28 发布

zyrate

最新推荐文章于 2023-02-23 21:33:28 发布

阅读量505

点赞数 1

分类专栏： SSH 文章标签： SSH IDEA 框架 xml配置非注解

本文链接：https://blog.csdn.net/weixin_41627032/article/details/99059636

版权

SSH 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本人第一个博客
需要了解maven在idea里的使用及作用
本步骤使用spring的XML配置方式搭建，不使用注解

创建maven项目

New Project -> 在 create from archetype 上打勾 -> 选择 maven-archetype-webapp -> Next
创建maven项目
GroupId是包名，一般是com.公司名或姓名，Artificial是项目名
在这里插入图片描述
这里可以用默认的maven仓库，但一般在别的盘自建一个仓库，参考别人的教程

然后 next -> finish

如果是第一次创建，会等待时间稍微长一些，出现BUILD SUCCESS就行了，右下角出现的提示我一般点 Enable Auto-Import.
在这里插入图片描述

配置Tomcat

在这里插入图片描述

在Server面板配置上本地的tomcat服务器，随便命个名，在Deployment面板里点击加号Artifact

选中有exploded的一个，OK，然后下面的Application context可以随意写，这里我写上项目名，也可以不写，只留一个/，这样的话在地址栏只需输入localhost:8080/...。之后OK确定就行了。
在这里插入图片描述

整合与样例代码

配置pom.xml

项目创建好了，接下来开始一系列的配置，我这里用的是Spring4 + Struts2 + Hibernate4,注意有时候版本不同操作也会不同。接下来就是配置相关的依赖：

<!-- spring -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>4.1.1.RELEASE</version>
    </dependency>

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

    <!-- struts2 -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-core</artifactId>
      <version>2.3.1</version>
    </dependency>

    <!--struts与spring的整合-->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-spring-plugin</artifactId>
      <version>2.3.1</version>
    </dependency>

    <!-- mysql数据库 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.44</version>
    </dependency>
   <!-- 连接池 -->
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
    </dependency>

配置web.xml

在web.xml里加入以下代码：

<!--  Spring的核心监听器-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml</param-value>
  </context-param>
  <!--  struts2的核心过滤器-->
  <filter>
    <filter-name>struts</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>struts</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

建立目录结构

在src目录下新建 java 和 resources 目录，分别右键Mark Directory as Sources Root和 Resources Root。此后所有的配置文件最好都建在 resources 目录下面，不然可能识别不到。
在这里插入图片描述
然后在java目录下建好 action、service、dao 和 domain目录，分别是Web层、业务层、持久层和实体。

Spring整合Struts2

所谓的SSH框架搭建不过是Spring、Struts2、Hibernate三个框架的整合，要整合就有个先后顺序，我首先整合Spring和Struts2，然后再整合Spring和Hibernate。我的理解是：Spring在其中就像一个舞台，给了其他框架施展的空间；它也是一个管理者，让我们程序员学会变“懒”，专注重要的事情。 我这里准备用 添加用户 这个操作来做演示，既然先整合Struts，就暂时不管数据库，只去看看这个操作能否按照我们想要的步骤执行。

创建样例类

按照层层递进（持久层、业务层、web层）的顺序，首先要有一个用户实体类，在domain下创建User.java：

package domain;
/**
 * 用户实体
 */
public class User {
    //这里要用包装类型
    private Integer id;
    private String name;
    private Character gender;
	//getter...
	//setter...
}

然后是User的持久层，在dao下创建UserDao.java：

package dao;
import domain.User;
/**
 * 用户持久层
 */
public class UserDao {
    /**
     * 添加用户
     * @param user
     */
    public void addUser(User user){
        System.out.println("UserDao.addUser");
    }
}

接着是User的业务层，在service下创建UserService.java：

package service;
import dao.UserDao;
import domain.User;
/**
 * 用户业务层
 */
public class UserService {
	//用Spring注入
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    /**
     * 添加用户
     * @param user
     */
    public void addUser(User user){
        System.out.println("UserService.addUser");
        userDao.addUser(user);
    }
}

最后是User的action，在action下创建UserAction.java：

package action;

import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import domain.User;
import service.UserService;
/**
 * 用户相关的Action
 */
//struts2的标准代码
public class UserAction extends ActionSupport implements ModelDriven<User> {
    //模型驱动需要用的对象，也就是User对象
    private User user = new User();
    @Override
    public User getModel() {
        return user;
    }
    //Spring注入
    private UserService userService;
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    /**
     * 添加用户方法
     */
    public void addUser(){
        System.out.println("UserAction.addUser");
        userService.addUser(user);
    }
}

我们在jsp页面提交添加用户的表单后，提交到这个action的addUser方法，然后一路调用，在控制台显示出不同方法的信息，就算成功了，但现在还差许多配置，接着往下。

配置spring.xml

在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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
            http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx.xsd">
            
</beans>

在其中管理以下bean：

	<bean id="userDao" class="dao.UserDao"></bean>
    <bean id="userService" class="service.UserService">
        <property name="userDao" ref="userDao"/>
    </bean>
    <bean id="userAction" class="action.UserAction">
        <property name="userService" ref="userService"/>
    </bean>

配置struts.xml

在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>
    <package name="随便" extends="struts-default" namespace="/">
        <action name="user_*" class="userAction" method="{1}"/>
    </package>
</struts>

至此，Spring 和 Struts2的整合就大功告成了，只剩一个jsp页面来验证是否成功了！

编写页面

我们可以修改idea自动生成的index.jsp，用struts的标签写一个添加用户页面：

<%@ taglib prefix="s" uri="/struts-tags" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
<h2>添加用户</h2>
<!-- 注意action的写法 -->
<s:form action="user_addUser" method="POST">
    <table>
        <tr>
            <td>用户ID</td>
            <td><s:textfield name="id"/></td>
        </tr>
        <tr>
            <td>姓名</td>
            <td><s:textfield name="name"/></td>
        </tr>
        <tr>
            <td>性别</td>
            <td><s:textfield name="gender"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="添加"/></td>
        </tr>
    </table>
</s:form>
</body>
</html>

运行测试

我们启动Tomcat，启动好之后，在浏览器地址栏输入localhost:8080/SSH_Demo/index.jsp
输入用户数据后，按添加按钮提交。
这时，地址栏应该变成http://localhost:8080/SSH_Demo/user_addUser
我们回到idea编辑器，看到控制台输出以下信息就成功了：
在这里插入图片描述

Spring整合Hibernate

修改Dao层代码

之前的UserDao继承 HibernateDaoSupport 类，调用getHibernateTemplate方法获取模板，直接save要保存的对象就可以了。

package dao;

import domain.User;
import org.springframework.orm.hibernate4.support.HibernateDaoSupport;
/**
 * 用户持久层
 */
public class UserDao extends HibernateDaoSupport{//继承这个类很方便
    /**
     * 添加用户
     * @param user
     */
    public void addUser(User user) {
        System.out.println("UserDao.addUser");
        this.getHibernateTemplate().save(user);
    }
}

创建数据库和属性文件

我们可以用数据库管理工具新建一个数据库，我这里命名为ssh_demo，不用创建表，hibernate会帮我们创建。
为了方便，jdbc的各种配置放在属性文件里，在resources目录下创建jdbc.properties，用户名密码什么的填自己的。

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssh_demo?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
jdbc.username=root
jdbc.password=2018

创建Hibernate映射文件

在resources下创建user.hbm.xml，有了这个文件Hibernate才能把对象和数据库表对应起来。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="domain.User" table="user">
        <id name="id" column="id">
        	<!-- 自动增长 -->
            <generator class="native"/>
        </id>
        <property name="name" column="name" length="20"/>
        <property name="gender" column="gender"/>
    </class>
</hibernate-mapping>

配置spring.xml

接下来的配置有点繁琐，但都是按部就班的比较固定的步骤，一步步来就行。下面的操作写在spring.xml里面

引入外部的属性文件

<context:property-placeholder location="classpath:jdbc.properties"/>

配置连接池

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
     <property name="driverClass" value="${jdbc.driverClass}"/>
      <property name="jdbcUrl" value="${jdbc.url}"/>
      <property name="user" value="${jdbc.username}"/>
      <property name="password" value="${jdbc.password}"/>
</bean>

配置Hibernate的相关属性（通过注入sessionFactory）

<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
      <!--连接池-->
      <property name="dataSource" ref="dataSource"/>
      <!--Hibernate属性-->
      <property name="hibernateProperties">
          <props>
              <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
              <prop key="hibernate.show_sql">true</prop>
              <prop key="hibernate.format_sql">true</prop>
              <prop key="hibernate.hbm2ddl.auto">update</prop>
          </props>
      </property>
      <!--加载hibernate中的映射文件-->
      <property name="mappingResources">
          <list>
              <value>user.hbm.xml</value>
          </list>
      </property>
</bean>

将sessionFactory注入UserDao

<bean id="productDao" class="com.zyr.ssh.dao.ProductDao">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

配置事务管理器

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

开启事务注解

<tx:annotation-driven transaction-manager="transactionManager"/>

在UserService类上加一个注解@Transactional

大功告成！

运行测试

同样的，运行Tomcat，在浏览器地址栏输入localhost:8080/SSH_Demo/index.jsp，
输入用户ID、姓名、性别后提交。再看看数据库里是不是已经有一个user表，并且插入了一条数据啦。至此SSH框架的初步搭建已完成。

这是我第一次写博客，关于ssh框架也正在学习过程中，有什么不妥或错误的地方还望大家谅解与指教！

zyrate

关注

1
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
IntelliJ IDEA搭建SSH框架 maven项目的过程总结

本人第一个博客需要了解maven在idea里的使用及作用本步骤使用spring的XML配置方式搭建，不使用注解ssh搭建的步骤创建maven项目配置Tomcat配置pom.xml建立目录结构配置spring.xml创建maven项目New Project -> 在 create from archetype 上打勾 -> 选择 maven-archetype-webapp -...
复制链接

扫一扫