Maven集成SSH

最新推荐文章于 2025-06-04 12:41:28 发布
最新推荐文章于 2025-06-04 12:41:28 发布
阅读量296 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： ----------Java---------- 文章标签： maven ssh
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u010148687/article/details/80043875

最近段时间在进行各种框架的搭建，这篇博客主要介绍maven集成ssh框架，借助了下网上资料。
1.首先创建maven项目
这里写图片描述

2.导入jar包依赖。
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.maven</groupId>
    <artifactId>maven-SSH</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>maven-SSH 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>
        <spring.version>4.3.0.RELEASE</spring.version>
        <hibernate.version>5.2.0.Final</hibernate.version>
        <struts2.version>2.5.1</struts2.version>
        <jackson.version>2.7.5</jackson.version>
        <log4j.version>2.5</log4j.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.5.1</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.servlet</groupId>
                    <artifactId>servlet-api</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</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-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</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-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate.javax.persistence</groupId>
            <artifactId>hibernate-jpa-2.0-api</artifactId>
            <version>1.0.1.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>${struts2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-convention-plugin</artifactId>
            <version>${struts2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.mortbay.jetty</groupId>
            <artifactId>servlet-api</artifactId>
            <version>3.0.20100224</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-web</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <!--<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.3</version>
        </dependency>-->

        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.31</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.13</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.21</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.9</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>maven-SSH</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.0.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.7.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.20.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.0</version>
                    <configuration>
                        <webXml>src/main/webapp/WEB-INF/web.xml</webXml>
                    </configuration>
                </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>

                <plugin>
                    <groupId>org.codehaus.cargo</groupId>
                    <artifactId>cargo-maven2-plugin</artifactId>
                    <version>1.5.0</version>
                    <configuration>
                        <container>
                            <containerId>tomcat7x</containerId>
                            <home>D:\work\tomcat8\apache-tomcat-8.0.28</home><!--Tomcat安装目录-->
                        </container>
                        <configuration>
                            <type>existing</type>
                            <home>D:\work\tomcat8\apache-tomcat-8.0.28</home><!--Tomcat安装目录-->
                        </configuration>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

3.构建项目结构，添加action、bean、dao、service包
这里写图片描述

4.各种资源文件如下
config.properties

#application configs
#jdbc druid config
validationQuery = SELECT 1
#mysql connect 6.x 使用com.mysql.cj.jdbc.Driver
jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/databases?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
jdbc.username = root
jdbc.password = *******

#hibernate config
hibernate.dialect = org.hibernate.dialect.MySQLDialect
hibernate.show_sql = true
hibernate.format_sql = false
hibernate.hbm2ddl.auto = update

log4j.properties

### set log levels ###
log4j.rootLogger = INFO , C , D , E 

### console ###
log4j.appender.C = org.apache.log4j.ConsoleAppender
log4j.appender.C.Target = System.out
log4j.appender.C.layout = org.apache.log4j.PatternLayout
log4j.appender.C.layout.ConversionPattern = [mavenSSH][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n

### log file ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = ../logs/ssh_mavenSSH.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = INFO 
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = [mavenSSH][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n

### exception ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File = ../logs/ssh_mavenSSH_error.log 
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR 
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = [mavenSSH][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n

log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="info">
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
        </Console>
    </Appenders>
    <Loggers>
        <Root level="info">
            <AppenderRef ref="Console" />
        </Root>
    </Loggers>
</Configuration>

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-4.3.xsd">
    <!-- 扫描service自动注入为bean -->
    <context:component-scan base-package="action,dao,service"/>
</beans>

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

    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:config.properties"/>

    <!-- 配置数据源 使用的是Druid数据源 -->
    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <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="minIdle" value="0" />
        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="60000" />
        <property name="poolPreparedStatements" value="true" />
        <property name="maxPoolPreparedStatementPerConnectionSize" value="33" />
        <!-- 用来检测有效sql -->
        <property name="validationQuery" value="${validationQuery}" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />
        <property name="testWhileIdle" value="true" />
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000" />
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="25200000" />
        <!-- 打开removeAbandoned功能 -->
        <property name="removeAbandoned" value="true" />
        <!-- 1800秒，也就是30分钟 -->
        <property name="removeAbandonedTimeout" value="1800" />
        <!-- 关闭abanded连接时输出错误日志 -->
        <property name="logAbandoned" value="true" />
        <!-- 监控数据库 -->
        <property name="filters" value="mergeStat" />
    </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.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
            </props>
        </property>
        <!-- 扫描hibernate注解配置的entity -->
        <property name="packagesToScan" value="bean" />
    </bean>

    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

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

    <!-- 配置事务增强处理Bean，指定事务管理器 -->
    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
        <!-- 配置详细事务处理语义 -->
        <tx:attributes>
            <tx:method name="insert*" propagation="REQUIRED" />
            <tx:method name="update*" propagation="REQUIRED" />
            <tx:method name="delete*" propagation="REQUIRED" />

            <tx:method name="get*" propagation="SUPPORTS" read-only="true" />
            <tx:method name="find*" propagation="SUPPORTS" read-only="true" />
            <tx:method name="select*" propagation="SUPPORTS" read-only="true" />
            <tx:method name="load*" propagation="SUPPORTS" read-only="true" />
            <tx:method name="save*" propagation="SUPPORTS" read-only="true" />

            <tx:method name="list*" propagation="SUPPORTS" read-only="true" />
            <!-- 其他采用默认事务方式 -->
            <tx:method name="*" />

        </tx:attributes>
    </tx:advice>

    <!-- Spring aop事务管理 -->
    <aop:config>
        <!-- 配置切入点 -->
        <aop:pointcut id="transactionPointcut" expression="execution(* service..serviceImpl.*.*(..))" />
        <!-- 指定在txAdvice切入点应用txAdvice事务增强处理 -->
        <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice" />
    </aop:config>

</beans>

struts.xml

<?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>
    <!-- 指定由spring负责action对象的创建 -->
    <constant name="struts.objectFactory" value="spring" />
    <!-- 所有匹配*.action的请求都由struts2处理 -->
    <constant name="struts.action.extension" value="action" />
    <!-- 是否启用开发模式 -->
    <constant name="struts.devMode" value="true" />
    <!-- struts配置文件改动后，是aa否重新加载 -->
    <constant name="struts.configuration.xml.reload" value="true" />
    <!-- 设置浏览器是否缓存静态内容 -->
    <constant name="struts.serve.static.browserCache" value="false" />
    <!-- 请求参数的编码方式 -->
    <constant name="struts.i18n.encoding" value="utf-8" />
    <!-- 每次HTTP请求系统都重新加载资源文件，有助于开发 -->
    <constant name="struts.i18n.reload" value="true" />
    <!-- 文件上传最大值 -->
    <constant name="struts.multipart.maxSize" value="104857600" />
    <!-- 让struts2支持动态方法调用 -->
    <constant name="struts.enable.DynamicMethodInvocation" value="true" />
    <!-- Action名称中是否还是用斜线 -->
    <constant name="struts.enable.SlashesInActionNames" value="false" />
    <!-- 允许标签中使用表达式语法 -->
    <constant name="struts.tag.altSyntax" value="true" />
    <!-- 对于WebLogic,Orion,OC4J此属性应该设置成true -->
    <constant name="struts.dispatcher.parametersWorkaround" value="false" />

    <!-- 用于CRUD Action的parent package -->
    <package name="crud-default" extends="convention-default">
        <!-- 基于paramsPrepareParamsStack, 增加store interceptor保证actionMessage在redirect后不会丢失 -->
        <interceptors>
            <interceptor-stack name="crudStack">
                <interceptor-ref name="store">
                    <param name="operationMode">AUTOMATIC</param>
                </interceptor-ref>
                <interceptor-ref name="paramsPrepareParamsStack" />
            </interceptor-stack>
        </interceptors>
        <default-interceptor-ref name="crudStack" />
    </package>

    <!-- 使用Convention插件,实现约定大于配置的零配置文件风格. 特殊的Result路径在Action类中使用@Result设定. -->

</struts>

7.实体类User
User.java

package bean;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import java.io.Serializable;

@Entity(name = "user")
public class User implements Serializable {
    private static final long serialVersionUID = 3834833794454172304L;
    private int id;
    private String userName;
    private String password;
    private int gender;

    @Id
    @Column(name = "id", unique = true,  nullable = false, insertable = false, updatable = false)
    public int getId() {
        return id;
    }

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

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

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @Column(name = "password", nullable = false)
    public String getPassword() {
        return password;
    }

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

    @Column(name = "gender", nullable = false)
    public int getGender() {
        return gender;
    }

    public void setGender(int gender) {
        this.gender = gender;
    }
}

BaseDao.java

package dao;

import java.io.Serializable;
import java.util.List;

public interface BaseDao <T, PK extends Serializable> {
    T load(PK id);
    T get(PK id);
    List<T> findAll();
    void persist(T entity);
    PK save(T entity);
    void saveOrUpdate(T entity);
    void delete(PK id);
    void flush();
}

UserDao.java

package dao;

import bean.User;

public interface UserDao extends BaseDao<User, Integer> {
}

UserDaoImpl.java

package dao;

import bean.User;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Repository("UserDao")
@Transactional
public class UserDaoImpl implements UserDao {

    @Autowired
    private SessionFactory sessionFactory;

    private Session getCurrentSession() {
        return sessionFactory.getCurrentSession();
    }

    @Override
    public User load(Integer id) {
        return getCurrentSession().load(User.class, id);
    }

    @Override
    public User get(Integer id) {
        return getCurrentSession().get(User.class, id);
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<User> findAll() {
        return getCurrentSession().createQuery("from user").getResultList();
    }

    @Override
    public void persist(User entity) {
        getCurrentSession().persist(entity);
    }

    @Override
    public Integer save(User entity) throws RuntimeException{
        Integer num = (Integer) this.getCurrentSession().save(entity);
        return num;
    }

    @Override
    public void saveOrUpdate(User entity) {
        getCurrentSession().saveOrUpdate(entity);
    }

    @Override
    public void delete(Integer id) {
        getCurrentSession().delete(this.get(id));
    }

    @Override
    public void flush() {
        getCurrentSession().flush();
    }

}

UserAction.java

package action;

import bean.User;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.opensymphony.xwork2.Preparable;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.convention.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import service.UserManager;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import java.util.logging.Logger;

@ParentPackage("struts-default")
@Namespace("/user")
@AllowedMethods("detail")
@Results({
        @Result(name = "success", location = "/user/user.jsp")
})
public class UserAction extends ActionSupport implements ModelDriven<User>, Preparable {
    private static final long serialVersionUID = -4611010990125262639L;
    private static final Logger LOGGER = Logger.getLogger(String.valueOf(UserAction.class));
    private Integer id;
    User user;
    List<User> userList;

    @Autowired
    private UserManager userManager;

    public Integer getId() {
        return id;
    }

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

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public List<User> getUserList() {
        return userList;
    }

    public void setUserList(List<User> userList) {
        this.userList = userList;
    }

    @Override
    public void prepare() throws Exception {

    }

    @Override
    public User getModel() {
        if (null != id) {
            user = userManager.get(id);
        } else {
            user = new User();
        }
        return user;
    }

    @Override
    public String execute() throws Exception {
        LOGGER.info("查询所有用户");
        userList = userManager.findAll();
        return SUCCESS;
    }

    public void detail() throws IOException {
        String id = ServletActionContext.getRequest().getParameter("id");
        LOGGER.info("查询用户详情：" + id);
        user = userManager.get(Integer.valueOf(id));
        //AjaxUtil.ajaxJSONResponse(user);
        HttpServletResponse response = ServletActionContext.getResponse();
        PrintWriter out = response.getWriter();
        out.println("Hello " + user.getUserName());
    }

}

user.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>

<%
    String path = request.getContextPath();
    String basePath = request.getScheme() + "://"
            + request.getServerName() + ":" + request.getServerPort()
            + path + "/";
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <base href="<%=basePath%>" />
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <script type="text/javascript" src="js/jquery-1.9.1.min.js"></script>
    <title>userInfo</title>
</head>
<body>
全部用户信息：
<c:forEach items="${userList}" var="user">
    <div>姓名：${user.userName } 性别：${user.gender } <a target="_blank" href="user/user!detail.action?id=${user.id}">用户详情</a></div>
</c:forEach>

</body>
</html>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         id="mavenSSH" version="3.0">

  <display-name>mavenSSH</display-name>

  <!-- spring 和  Hibernate的配置文件 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
      classpath:spring.xml
      classpath:spring-hibernate.xml
    </param-value>
  </context-param>

  <!-- 编码设置 -->
  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>utf-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- openSessionInView配置 作用是延迟session关闭到view层 -->
  <filter>
    <filter-name>openSessionInViewFilter</filter-name>
    <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
    <init-param>
      <param-name>singleSession</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>

  <!-- 监听servletContext，启动contextConfigLocation中的spring配置信息 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

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

  <!-- Struts2 filter -->
  <filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>

  <filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>


  <filter-mapping>
    <filter-name>openSessionInViewFilter</filter-name>
    <url-pattern>*.action</url-pattern>
  </filter-mapping>

  <!-- 配置session超时时间，单位分钟 -->
  <session-config>
    <session-timeout>30</session-timeout>
  </session-config>

  <welcome-file-list>
    <welcome-file>/index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

编写测试类如下:

import bean.User;
import com.alibaba.fastjson.JSON;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import service.UserManager;

import java.util.logging.Logger;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
        "classpath:spring.xml",
        "classpath:spring-hibernate.xml"
})
public class TestUserManager {
    private static final Logger LOGGER = Logger.getLogger(String.valueOf(TestUserManager.class));
    @Autowired
    UserManager userManager;

    @Test
    public void save() {
        User user = new User();
        user.setId(59);
        user.setUserName("jiul");
        user.setPassword("123456");
        user.setGender(33);
        Integer id = userManager.save(user);
        JSON.toJSONString(id);
        System.out.println(id);
    }
}

测试结果如下
这里写图片描述

SSH之maven
Cat_Jay_Fish的博客
10-13 344
总结以下自定义mvc框架 自定义mvc框架（框架制作包括xml，反射，自定义标签，通用分页，自定义mvc，easyui） SSH框架 学习目标：①，体验开源的优秀的框架，带给我们便利 ②，与自定义mvc框架的知识验证 ③，开发模式的转变 一.Maven 1.maven是什么 ①、 Apache Maven是个项目管理和自动构建工具，基于项目对象模型（POM）的概念。 ②、作用：完成项目的相关操作，如：编译，构建，单元测试，安装，网站生成和基于Maven部署目。 ③、什么是POM Pr.
Idea + maven 搭建 SSH （struts2 +hibernate5 + spring5） 环境
2401_84093780的博客
05-02 893
面试前一定少不了刷题，为了方便大家复习，我分享一波个人整理的面试大全宝典Java核心知识整理Java核心知识Spring全家桶（实战系列）其他电子书资料Step3：刷题既然是要面试，那么就少不了刷题，实际上春节回家后，哪儿也去不了，我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。以下是我私藏的面试题库：《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》
Maven搭建SSH环境
weixin_30700977的博客
05-09 162
一、新建maven项目 选中maven-aechetype-webapp group Id一般为公司域 ；Artifact Id相当于项目名称 ；version不需要更改；Package不使用默认，手动清空 Finish 项目结构如图 报错是因为没有加入servlet API 暂时不用管。 二、配置pom.xml 1　　　　<properties&...
SshClient应用指南：使用org.apache.sshd库在服务器中执行命令
最新发布
xx155802862xx的博客
06-04 165
Apache SSHD库是一个用Java编写的、授权给Apache的100%纯SSH服务器，你可以通过它来完成在服务器中执行命令的需求。下面我将以一个简单的应用指南来介绍如何使用org.apache.sshd库在服务器中执行命令。
Maven环境下搭建SSH框架
zqq_2016的博客
05-30 1239
1.搭建环境　　Maven：3.3.9　　Struts2：2.5.10　　Spring：4.3.8.RELEASE　　Hibernate：5.1.7.Final　　MySQL：5.7.172.说明　　本文只有完整代码。具体搭建步骤请参考《Maven环境下搭建SSH框架之Spring整合Struts2》和《Maven环境下搭建SSH框架之Spring整合Hibernate》　　此代码只新增了简单的日...
使用Maven管理项目-----创建Struts2,Spring,Hibernate项目
Java开发与学习
05-25 174
Maven应该都听说过吧！一个构建工具！与Ant相比，它更粗粒化！不需要编写build.xml文件，来操作项目的编译，运行，打包！只要你创建了一个Maven项目，编译，只需要mvn compile！Maven会自动的帮你完成编译！关于Maven2的知识请看这里！ http://books.sonatype.com/maven-book/reference_zh...
SSH框架之Maven工程
m0_53151031的博客
10-12 385
前言：在之前与大家分享了使用MVC框架写的网上书城项目，在其中最重要的是MVC框架的制作（xml、反射、自定义标签、通用分页、自定义mvc、easyui）。今天将于大家分享全新的东西，叫做maven整合ssh框架，主要是介绍Maven。 一、Maven学习目标： 1、体验开元的优秀的框架带给的便利 2、对与自定义MVC框架的知识验证 3、开发模式的模式转变 二、Maven定义： 1、定义：Maven是专门用于构建和管理java相关项目...
Maven集成SSH与EasyUI的演示项目
从给定文件信息中，我们可以提取到关键词"Maven"、"SSH"、"EasyUI"以及项目名称"sshmaven"。在此基础上，我们可以推断该文档涉及到的技术知识点主要包括Maven项目管理工具、SSH框架和EasyUI前端框架。下面将对这些...
Maven集成SSH框架：深度整合与配置解析
### Maven整合SSH2知识点详解 #### Maven基础介绍 Maven 是一个项目管理工具，它主要服务于Java平台的项目构建、依赖管理和项目信息管理。Maven采用了项目对象模型（POM，Project Object Model）的概念来管理项目...
构建基于Maven的SSH原型项目
08-21
在IT行业中，SSH（Struts2、Spring、Hibernate）是一个常见的Java Web开发框架组合，而Maven则是一个项目管理和综合工具。"构建基于Maven的SSH原型项目"这个主题，旨在帮助初学者理解和掌握如何使用这些技术搭建一个...
idea基于maven的SSH模板
04-01
SSH是JavaEE中三种框架(Struts+Spring+Hibernate)的集成框架，是目前比较流行的一种Java Web开源框架。 SSH主要用于Java Web的开发。现在SSH有SSH1和SSH2两种，区别在于Struts的版本是struts1.x还是2.x。
maven搭建SSH工程
08-04
NULL 博文链接：https://09094224.iteye.com/blog/2017812
采用Maven整合SSH
03-13
利用Maven整合SSH，包括整合说明以及实例代码，导入Eclipse可直接运行，适合初学SSH开发框架的同学
maven ---> ssh搭建
12-09
ssh所需要的核心文件 ssh所需要的核心文件 ssh所需要的核心文件
Maven搭建SSH框架Demo
09-17
Maven搭建SSH框架Demo,Maven是可以解决包依赖问题，在搭建SSH(struts2,spring3,hibernate)框架时不用考虑包的依赖问题，提高了开发效率，该demo已经完成框架的搭建，可以直接拿来使用
java树形数据结构递归求上级，附答案
m0_57081368的博客
06-27 1240
Part 1微服务架构设计概述 1.1 传统应用架构的问题 1.2 微服务架构是什么 1.3 微服务架构有哪些特点和挑战 1.4 如何搭建微服务架构 Part 2微服务开发框架 2.1 Spring Boot 是什么 2.2 如何使用Spring Boot框架 2.3 Spring Boot生产级特性 Part 3微服务网关 3.1 Node.js 是什么 3.2 如何使用 Node.js 3.3 使用Node.js搭建微服务网关 Part 4微服务注册与发现. 4.1 ZooKeepe
SSH之Maven
m0_60375302的博客
10-12 216
一、为什么要学习SSH框架 ①、 体验开源的优秀的框架（稳定），带来的便利 ； ②、与自定义mvc框架的知识相互验证； ③、开发模式的转变，前后端分离； 二、Maven 1、Maven的简单介绍 Apache Maven 是个项目管理和自动构建工具，基于项目对象模型（POM（Project Object Model，项目对象模型））的概念。 作用：完成项目的相关操作，如：编译，构建，单元测试，安装，网站生成和基于Maven部署项目。 2、Maven的配置 ①、下载maven安装包，解...
Maven搭建SSH框架
zqh994828的博客
11-01 1231
SSH框架搭建
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值