IDEA 2021+ Maven进行SSH框架整合

Floating*Star

已于 2022-11-28 15:47:34 修改

阅读量1.5k

点赞数 6

分类专栏：经验文章标签： intellij-idea java maven ssh

于 2022-05-26 17:22:44 首次发布

本文链接：https://blog.youkuaiyun.com/Ying_Lan/article/details/124986308

版权

经验专栏收录该内容

15 篇文章

订阅专栏

鉴于SSH已经…[doge]，之所以做这个SSH框架整合，一方面是课程要求，另一方面也算锻炼，辛苦上学人罢了[doge]。(狗头保命)
那就话不多说，直接来吧！

工具：
IDEA 2021
MySQL 8.0
Navicat
Maven

第一步，创建工程

在这里插入图片描述

点Next

好的，工程就建好了哈。

第二步，搭建SSH框架

准备工作

引入依赖pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<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>com.ssh</groupId>
  <artifactId>SSH_Demo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>SSH_Demo Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
  <!-- junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!-- log4j日志依赖 -->
      <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.2</version>
      </dependency>
      <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.2</version>
      </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.12</version>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-api</artifactId>
      <version>2.9.1</version>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>2.9.1</version>
    </dependency>
    
	<!-- 此处lombok引入不引入都可 -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>0.9.3</version>
    </dependency>

    <!-- Spring依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.3.1</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.1</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.3.1</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.3.1</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>5.3.1</version>
    </dependency>
    
    <!-- aop面向切面的依赖 -->
    <!-- aspectjrt -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.9.5</version>
    </dependency>
    <!-- aspectjweaver -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.5</version>
    </dependency>

    <!-- hibernate核心依赖 -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>5.5.5.Final</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.20</version>
    </dependency>

    <!-- c3p0连接池 -->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.5</version>
    </dependency>

    <!-- struts2依赖 -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-core</artifactId>
      <version>2.5.25</version>
    </dependency>
    <!-- struts2-spring-plugin整合spring和struts2 -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-spring-plugin</artifactId>
      <version>2.5.25</version>
    </dependency>

    <!-- json数据处理，struts插件 -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-json-plugin</artifactId>
      <version>2.5.25</version>
    </dependency>

    <!-- 配置Java EE坐标依赖 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.3.3</version>
      <scope>provided</scope>
    </dependency>

    <!-- jstl -->
    <dependency>
      <groupId>javax.servlet.jsp.jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>1.1.2</version>
    </dependency>
  </dependencies>

  <build>
      <resources>
        <resource>
          <directory>src/main/java</directory>
          <includes>
            <include>**/*.xml</include>
            <include>**/*.*</include>
          </includes>
          <excludes>
            <exclude>**/*.java</exclude>
          </excludes>
        </resource>
        <resource>
          <directory>src/main/resources</directory>
          <includes>
            <include>*</include>
            <include>*/*</include>
          </includes>
          <filtering>false</filtering>
        </resource>
      </resources>
    <finalName>SSH_Demo</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

依赖真的好多呀，要看清楚哈，或者直接复制就可，要记得改工程名哦
添加Source Root和Resources Root
在这里插入图片描述
顺便把package整了

action包就是控制层，接受前端请求，并调用业务逻辑层处理，将处理结果通过视图返回给前端
dao包即持久层，与数据库打交道，执行增删查改功能
pojo包，放实体类。
service包即业务逻辑层，调用DAO层，实现常用功能

添加以后，工程的结构是这样的。
在这里插入图片描述

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>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:applicationContext.xml</param-value>
  </context-param>

  <context-param>
    <param-name>log4jConfigLocation</param-name>
    <param-value>classpath*:log4j.properties</param-value>
  </context-param>
  <context-param>
    <param-name>log4jRefreshInterval</param-name>
    <param-value>60000</param-value>
  </context-param>


  <!-- struts2核心过滤器 -->
  <filter>
    <filter-name>StrutsPrepareAndExecuteFilter</filter-name>
    <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>StrutsPrepareAndExecuteFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- 上下文监听器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

下面在resources文件夹中，放一些配置

jdbc.properties

随便用个图形化界面，在MySQL里边建个数据库，我这里用的是Navicat，命名为了hibernate，建立表t_user，只有三个字段。
在这里插入图片描述

然后连接数据库的配置：
这里有两个注意点：

我这里用的是MySQL 8.0，所以驱动是有 cj 这个包的
MySQL 8.0要增加时区配置，不然等等建立连接的时候不会很顺利

jdbc.driverClass = com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/hibernate?characterEncoding=UTF-8&userSSL=false&serverTimezone=UTC
jdbc.username=root
jdbc.password=root
jdbc.minPoolSize=1
jdbc.maxPoolSize=20

log4j.properties

log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %d{ABSOLUTE} %5p %c{1}:%L - %m%n

log4j.appender.file = org.apache.log4j.FileAppender
log4j.appender.file.File = d:/mylog.log
log4j.appender.file.layout = org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern = %d{ABSOLUTE} %5p %c{1}:%L - %m%n

log4j.rootLogger = info, stdout

Spring的配置文件

在Resources文件夹下
在这里插入图片描述
applicationContext.xml
已经整合了Hibernate。

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="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/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 引入资源文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!-- 自动扫描与装配bean-->
    <context:component-scan base-package="com.ssh.dao"/>
    <context:component-scan base-package="com.ssh.service" />
    <context:component-scan base-package="com.ssh.action" />
    <!--引入注解解析器-->
    <context:annotation-config/>
    <!-- 数据源连接池 -->
    <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}"/>
        <property name="minPoolSize" value="${jdbc.minPoolSize}"/>
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"/>
    </bean>
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="hibernateProperties">
            <props>
                <!--配置Hibernate的方言-->
                <prop key="hibernate.dialect">
                    org.hibernate.dialect.MySQLDialect
                </prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <prop key="hibernate.connection.autocommit">true</prop>
                <!--格式化输出sql语句-->
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.use_sql_comments">false</prop>
            </props>
        </property>
        <!-- 自动扫描实体 -->
        <property name="packagesToScan" value="com.ssh.pojo" />
        <property name="mappingLocations" value="classpath:com/ssh/pojo/TUserEntity.hbm.xml" />
    </bean>
    <!-- 配置 HibernateTemplate 对象 -->

    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <!-- 注入 SessionFactory 对象 -->
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <!-- 用注解来实现事务管理 -->
    <bean id="txManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <tx:annotation-driven transaction-manager="txManager"/>
    
    <!-- 事务增强 -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="save*" />
            <tx:method name="update*"/>
            <tx:method name="delete*"/>
            <tx:method name="select*" read-only="true" />
        </tx:attributes>
    </tx:advice>
<!-- aop配置 -->
    <aop:config>
        <aop:advisor advice-ref="txAdvice"
                     pointcut="execution(public * com.ssh.service..*.*(..))" />
    </aop:config>
</beans>

上述如果报红，建议看一个xsi和xsi:schemaLocation跟我的是否一样，有的时候，IDEA会引入错误的路径，让人有点头疼。

Struts2配置文件

struts.xml
如果extends="struts-default"报红，就要添加struts的jar包中默认的配置文件，戳https://blog.youkuaiyun.com/Ying_Lan/article/details/124989029?spm=1001.2014.3001.5501

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
        "http://struts.apache.org/dtds/struts-2.5.dtd">

<struts>
    <!-- <constant name="struts.objectFactory" value="spring" /> -->
    <constant name="struts.devMode" value="true" />

    <package name="ssh" namespace="/" extends="struts-default">
        <action name="userAction_*" class="userAction" method="{1}">
            <result name="success">/success.jsp</result>
        </action>
    </package>
</struts>

业务处理

结束上述，整个框架已经搭建好啦。
那就进入实际处理业务的环节吧！

连接数据库

右中侧的Database，连接建好的数据库。
我已经连过了，就不具体说啦，劳烦大家自行搜索一下哦。

生成实体类和对应的hbm.xml文件

左下角的Persistence
或者左上角的view->Tool Windows->Persistence
在这里插入图片描述
选好对应的表，其余配置选默认的就可以。
大概这个样

package com.ssh.pojo;

import javax.persistence.*;
import java.util.Objects;

@Entity
@Table(name = "t_user", schema = "hibernate")
public class TUserEntity {
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Id
    @Column(name = "id", nullable = false)
    private int id;
    @Basic
    @Column(name = "username", nullable = true, length = 30)
    private String username;
    @Basic
    @Column(name = "password", nullable = true, length = 30)
    private String password;

    public int getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {return true;}
        if (o == null || getClass() != o.getClass()) {return false;}
        TUserEntity that = (TUserEntity) o;
        return id == that.id && Objects.equals(username, that.username) && Objects.equals(password, that.password);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, username, password);
    }

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

    @Override
    public String toString() {
        return "TUserEntity{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}


```xml
<?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="com.ssh.pojo.TUserEntity" table="t_user" schema="hibernate">
        <id name="id" column="id" type="java.lang.Integer" />
        <property name="username" column="username"  type="java.lang.String"/>
        <property name="password" column="password" type="java.lang.String" />

    </class>
</hibernate-mapping>

细节不一样也无所谓，大体一致差不多就行。

DAO层

UserDao接口

package com.ssh.dao;

import com.ssh.pojo.TUserEntity;

import java.util.List;

public interface UserDao {
    /**
     * Desc: 通过id获取用户信息
     * @param id
     * @return {@link TUserEntity}
     * @author LISHANSHAN
     * @date 2022/5/26 17:02
     */
    TUserEntity getUserById(Integer id);
    
    /**
     * Desc: 更新或新增用户
     * @param user
     * @return 
     * @author LISHANSHAN
     * @date 2022/5/26 17:02
     */
    void saveOrUpdateUser(TUserEntity user);

    /**
     * Desc: 查找所有的用户信息
     * @param 
     * @return {@link List< TUserEntity>}
     * @author LISHANSHAN
     * @date 2022/5/26 17:02
     */
    List<TUserEntity> findAll();

    /**
     * Desc: 删除用户
     * @param user
     * @return 
     * @author LISHANSHAN
     * @date 2022/5/26 17:02
     */
    void deleteUser(TUserEntity user);
}

UserDaoImpl实现类

package com.ssh.dao;

import com.ssh.pojo.TUserEntity;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.query.Query;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.util.List;

@Repository
public class UserDaoImpl implements UserDao {

    @Autowired
    @Resource
    private HibernateTemplate hibernateTemplate;

    @Resource
    private SessionFactory sessionFactory;

    @Override
    public TUserEntity getUserById(Integer id) {
        return hibernateTemplate.get(TUserEntity.class, id);
    }

    @Override
    public void saveOrUpdateUser(TUserEntity user) {
        hibernateTemplate.saveOrUpdate(user);
    }

    @Override
    public void deleteUser(TUserEntity user) {
        hibernateTemplate.delete(user);
    }

    @Override
    public List<TUserEntity> findAll() {
        Session session = hibernateTemplate.getSessionFactory().openSession();
        Query query = session.createQuery("from TUserEntity");
        List<TUserEntity> userList;
        userList = query.list();
        return userList;
    }
}

service层

UserService接口

package com.ssh.service;

import com.ssh.pojo.TUserEntity;
import org.springframework.stereotype.Service;

import java.util.List;

public interface UserService {

    TUserEntity getUserById(Integer id);

    void saveOrUpdateUser(TUserEntity user);

    void deleteUser(TUserEntity user);

    List<TUserEntity> findAllUser();
}

UserServiceImpl实现类

package com.ssh.service;

import com.ssh.dao.UserDao;
import com.ssh.pojo.TUserEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author LISHANSHAN
 * @ClassName UserServiceImpl
 * @Description TODO
 * @date 2022/05/2022/5/19 17:52
 */
@Service("userService")
public class UserServiceImpl implements UserService {

    @Autowired
    UserDao userDao;

    @Override
    public TUserEntity getUserById(Integer id) {
        return userDao.getUserById(id);
    }

    @Override
    public void saveOrUpdateUser(TUserEntity user) {
        userDao.saveOrUpdateUser(user);
    }

    @Override
    public void deleteUser(TUserEntity user) {
        userDao.deleteUser(user);
    }

    @Override
    public List<TUserEntity> findAllUser() {
        return userDao.findAll();
    }
}

控制层

UserAction类

package com.ssh.action;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.ssh.pojo.TUserEntity;
import com.ssh.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import javax.persistence.Tuple;
import java.io.PushbackReader;
import java.util.Map;

/**
 * @author LISHANSHAN
 * @ClassName UserAction
 * @Description TODO
 * @date 2022/05/2022/5/21 01:10
 */

@Controller("userAction")
public class UserAction extends ActionSupport implements ModelDriven<TUserEntity> {

    private TUserEntity user = new TUserEntity();

    @Autowired
    private UserService userService;

    @Override
    public TUserEntity getModel() {
        return this.user;
    }

    public String add() {
        userService.saveOrUpdateUser(user);
        System.out.println("ok!");
        return "success";
    }
    
}

index.jsp

<%@ page contentType="text/html;charset=UTF-8"%>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/userAction_add.action" method="post">
    <label for="username">账户</label>
    <input type="text" name="username" id="username"><br/>
    <label for="password">密码</label>
    <input type="password" name="password" id="password"><br/>
    <input type="submit" value="添加">
</form>

</body>
</html>

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
添加成功
</body>
</html>

配置一下tomcat，就可以成功运行啦！
在这里插入图片描述
如果IDEA的窗口里报了有关log4j的错，那是因为我这里缺少了log4j.xml这个配置文件，大家在网上一搜，加上就行啦(不加其实也问题不大，反正不影响运行，hhh)

如果最后是404错误，emmm，访问我的下一篇文章，专门说的是我在SSH整合过程中遇到的问题，都是血和泪的教训啊
SSH中的404报错