maven搭建ssm框架（struts2、spring、mybatis ）

最新推荐文章于 2024-11-03 16:28:06 发布
原创 最新推荐文章于 2024-11-03 16:28:06 发布 · 738 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#struts #struts2.0 #spring #mybatis #框架

本文介绍如何使用Maven搭建Struts2+Spring+MyBatis框架，包括依赖配置、实体类定义、DAO层、Service层、Action层等关键组件的设计与实现。

1：maven依赖

<!-- 注解@Resource -->
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>jsr250-api</artifactId>
            <version>1.0</version>
        </dependency>

        <!-- json start -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.1</version>
        </dependency>
        <!-- json end -->

        <!-- servlet start -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <!-- servlet end -->

        <!-- logback start -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.21</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.1.7</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.1.7</version>
        </dependency>
        <!-- logback end -->


        <!-- struts2 start -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-convention-plugin</artifactId>
            <version>2.3.14</version>
        </dependency>
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.3.14</version>
        </dependency>
        <dependency>
            <groupId>org.apache.struts.xwork</groupId>
            <artifactId>xwork-core</artifactId>
            <version>2.3.14</version>
        </dependency>
        <!-- struts2 end -->

        <!-- spring start-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>3.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>3.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>3.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>3.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>2.3.14</version>
        </dependency>
        <!-- spring end -->

        <!-- oracle start -->
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc14</artifactId>
            <version>10.2.0.1.0</version>
        </dependency>
        <!-- oracle end -->

        <!-- mybatis start -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.6</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>3.2.2.RELEASE</version>
        </dependency>
        <!-- mybatis end -->

2：model层（存放实体类）

package com.szmsd.wechat.entity;

public class User {
    private String userno;
    private String username;
    public String getUserno() {
        return userno;
    }
    public void setUserno(String userno) {
        this.userno = userno;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    @Override
    public String toString() {
        return "User [userno=" + userno + ", username=" + username + "]";
    }
}

3：dao层（数据库操作）

package com.szmsd.wechat.dao;

import java.util.List;
import java.util.Map;

import com.szmsd.wechat.entity.User;


public interface UserDao {

    public List<User> findUserList(Map<String, Object> params);

}

dao实现类

package com.szmsd.wechat.dao.impl;

import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.stereotype.Repository;

import com.szmsd.wechat.dao.UserDao;
import com.szmsd.wechat.entity.User;

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

    private @Resource SqlSessionTemplate a;

    public List<User> findUserList(Map<String, Object> params) {
        return a.selectList(getClassPath()+"findUserList", params);
    }

    public String getClassPath(){
        return "com.szmsd.wechat.dao.UserDao.";
    }

}

4：service层（业务逻辑）

package com.szmsd.wechat.service;

import java.util.List;
import java.util.Map;

import com.szmsd.wechat.entity.User;

public interface UserService {

    public List<User> findUserList(Map<String, Object> params);

}

service实现类

package com.szmsd.wechat.service.impl;

import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.szmsd.wechat.dao.UserDao;
import com.szmsd.wechat.entity.User;
import com.szmsd.wechat.service.UserService;


@Service("UserService")
public class UserServiceImpl implements UserService {

    private @Resource UserDao userDao;

    public List<User> findUserList(Map<String, Object> params) {
        return this.userDao.findUserList(params);
    }

}

5：action处理类

package com.szmsd.wechat.action;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Scope;

import com.google.gson.Gson;
import com.szmsd.wechat.base.BaseAction;
import com.szmsd.wechat.entity.User;
import com.szmsd.wechat.service.UserService;

@Namespace("/user")
@Scope("prototype")
@Action(value = "userAction")
public class UserAction extends BaseAction {
    private static final long serialVersionUID = 1L;
    private static Logger logger = LoggerFactory.getLogger(UserAction.class);
    private @Resource UserService userService;
    private Gson gson = new Gson();

    public void findUserList(){
        try {
            Map<String, Object> params = new HashMap<String, Object>();

            List<User> list = this.userService.findUserList(params);

            if(list != null && list.size() > 0) {
                resJson.setSuccess(true);
                resJson.setData(list);
                resJson.setDesc("请求成功");
            } else {
                resJson.setSuccess(false);
                resJson.setDesc("请求失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        String result = gson.toJson(resJson);
        logger.info("[查询员工信息]请求结果："+result);
        out().print(result);
    }

}

用到的工具类BaseAction、ResJson、ResponseJson

package com.szmsd.wechat.base;

import java.io.IOException;
import java.io.PrintWriter;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.commons.lang3.StringUtils;
import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionSupport;

public class BaseAction extends ActionSupport {
    private static final long serialVersionUID = 1L;

    /***************外部工具类*************************/
    protected ResponseJson resJson = new ResponseJson();
    protected ResJson rjson = new ResJson();
    /**
     * 两个参数 是否为空,有一个为空都返回true
     * 
     * @return
     */
    protected boolean isEmpty(String... str) {
        for (String s : str) {
            if (StringUtils.isEmpty(s)) {
                return true;
            }
        }
        return false;
    }

    public static String format(Date date, String format) {
        String result = "";
        try {
            if (date != null) {
                DateFormat df = new SimpleDateFormat(format);
                result = df.format(date);
            }
        } catch (Exception e) {
        }
        return result;
    }
    /**
     * 获取request的ip地址
     * 
     * @param request
     * @return
     */
    public String getIpAddr() {
        String ip = req().getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = req().getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = req().getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = req().getRemoteAddr();
        }
        return ip;
    }

    /**
     * 获取HttpServletRequest对象
     * 
     * @return
     */
    protected HttpServletRequest req() {
        return ServletActionContext.getRequest();
    }

    /**
     * 获取HttpServletResponse对象
     * 
     * @return
     */
    protected HttpServletResponse res() {
        HttpServletResponse response = ServletActionContext.getResponse();
        // 解决乱码问题
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        return response;
    }

    /**
     * 获取HttpSession对象
     * 
     * @return
     */
    protected HttpSession session() {
        HttpSession session = req().getSession();
        session.setMaxInactiveInterval(10 * 60 * 60);// 有效会话时间10小时
        return session;
    }

    /**
     * 获取ServletContext对象
     * 
     * @return
     */
    protected ServletContext application() {
        return session().getServletContext();
    }

    /**
     * 获取PrintWriter对象
     * 
     * @return
     */
    protected PrintWriter out() {
        try {
            return res().getWriter();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取参数
     * 
     * @param paramName
     * @return
     */
    protected String getParam(String paramName) {
        return req().getParameter(paramName) != null ? req().getParameter(paramName) : "";
    }

    /**
     * 随机生成6位数验证码
     * @return
     */
    public int accessCode(){
        return (int) ((Math.random() * 9 + 1) * 100000);
    }

}

package com.szmsd.wechat.base;

public class ResJson {

    private String success= "false";    //响应状态(成功/失败)
    private String  desc;           //说明
    private Object  data;           //内容
    private String  code;           //响应编码
    public String getSuccess() {
        return success;
    }
    public void setSuccess(String success) {
        this.success = success;
    }
    public String getDesc() {
        return desc;
    }
    public void setDesc(String desc) {
        this.desc = desc;
    }
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    @Override
    public String toString() {
        return "ResJson [success=" + success + ", desc=" + desc + ", data=" + data + ", code=" + code + "]";
    }
}

package com.szmsd.wechat.base;

public class ResponseJson  {
    private boolean success= false; //成功、失败
    private String  desc;           //说明
    private Object  data;           //内容

    public boolean isSuccess() {
        return success;
    }
    public void setSuccess(boolean success) {
        this.success = success;
    }
    public String getDesc() {
        return desc;
    }
    public void setDesc(String desc) {
        this.desc = desc;
    }
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    @Override
    public String toString() {
        return "ResponseJson [success=" + success + ", desc=" + desc
                + ", data=" + data + "]";
    }

}

6：struts2配置文件 （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="false" />
    <!-- struts配置文件改动后，是否重新加载 -->
    <constant name="struts.configuration.xml.reload" value="false" />
    <!-- 设置浏览器是否缓存静态内容 -->
    <constant name="struts.serve.static.browserCache" value="true" />
    <!-- 请求参数的编码方式 -->
    <constant name="struts.i18n.encoding" value="utf-8" />
    <!-- 每次HTTP请求系统都重新加载资源文件，有助于开发 -->
    <constant name="struts.i18n.reload" value="false" />
    <!-- 文件上传最大值 -->
    <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" />
    <!-- 设置Convention插件是否从jar包中搜索Action类 [可选] 默认值为true -->
    <constant name="struts.convention.action.disableJarScanning"
        value="true" />
    <!-- 设置Convention插件文件协议类型 -->
    <constant name="struts.convention.action.fileProtocols" value="jar" />
    <!-- 设置Convention插件需要搜索的jar包 -->
    <constant name="struts.convention.action.includeJars" value=".*?/msd-*.*?jar(!/)?" />

    <!-- 该常量指定包作为根包来搜索Action类。 Convention插件除了扫描默认的action,actions,struts,struts2 
        ，还会扫描该常量指定的一个或多个包， Convention会试图从指定包中发现Action类。 -->
    <constant name="struts.convention.action.packages" value="com.szmsd.web" />

    <!-- 默认包路径包含action,actions,struts,struts2的所有包都会被struts作为含有Action类的路径来搜索 -->
    <constant name="struts.convention.package.locators" value="web,action" />

    <constant name="struts.convention.result.path" value="/template" />

    <package name="default" extends="struts-default">
        <global-results>
            <result name="strutsException">/error/strutsException.jsp</result>
        </global-results>

        <global-exception-mappings>
            <exception-mapping result="strutsException"
                exception="java.lang.Exception"></exception-mapping>
        </global-exception-mappings>
    </package>

</struts>

7：spring配置文件(applicationContext.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context" 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.1.xsd 
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-3.1.xsd 
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.1.xsd"
    default-autowire="byName">

    <!-- 开启spring注解 -->
    <context:annotation-config />
    <context:component-scan base-package="com.szmsd" />

    <!-- 加载数据库连接文件 -->
    <context:property-placeholder location="classpath:dbSource.properties" />

    <!-- 数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="${driver}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${user}"></property>
        <property name="password" value="${password}"></property>
        <property name="maxActive" value="40" />
        <property name="initialSize" value="5" />
        <property name="maxWait" value="60000" />
        <property name="maxIdle" value="15" />
        <property name="minIdle" value="5" />
        <property name="defaultAutoCommit" value="true" />
    </bean>

    <!-- 配置myBatis SqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis_config.xml"></property>
        <property name="mapperLocations">
            <list>
                <value>classpath*:mapperconfig/*.xml</value>
            </list>
        </property>
    </bean>

    <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg ref="sqlSessionFactory" />
    </bean>

    <!-- 配置事务 -->  
    <bean id="txAttributes" class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">
        <property name="properties">
            <props>
                <prop key="add*">PROPAGATION_REQUIRED,-Exception</prop>
                <prop key="save*">PROPAGATION_REQUIRED,-Exception</prop>
                <prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>
                <prop key="del*">PROPAGATION_REQUIRED,-Exception</prop>
                <prop key="remove*">PROPAGATION_REQUIRED,-Exception</prop>
                <prop key="read*">PROPAGATION_REQUIRED,readOnly</prop>
                <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
                <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
                <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
            </props>
        </property>
    </bean>

    <bean id="autoProxyCreatorGdasn" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator" depends-on="interceptor">
        <property name="interceptorNames">
            <list>
                <value>interceptor</value>
            </list>
        </property>
        <property name="beanNames">
            <list>
                <value>*Service*</value>
            </list>
        </property>
    </bean>

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" depends-on="dataSource">  
        <property name="dataSource" ref="dataSource" />  
    </bean>  
    <tx:annotation-driven transaction-manager="transactionManager" />

    <bean id="interceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor" depends-on="transactionManager,txAttributes">
        <property name="transactionManager">
            <ref bean="transactionManager" />
        </property>
        <property name="transactionAttributeSource">
            <ref bean="txAttributes" />
        </property>
    </bean>

</beans>

8：mybatis配置文件和mapper文件

myBatisConfig.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD SQL Map Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>

        <package name="com.szmsd.wechat.entity"/>

    </typeAliases>

</configuration>

user.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.szmsd.wechat.dao.UserDao">

    <!-- 查询所有用户信息 -->
    <select id="findUserList" resultType="User" parameterType="map">
        <![CDATA[
            select t.员工编号 as userno, t.姓名 as username
              from tab_公司员工表 t
        ]]>
    </select>

</mapper>

9：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>

    <!-- 初始化spring配置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springconfig/applicationContext*.xml</param-value>
    </context-param>

    <!-- 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>/*</url-pattern>
    </filter-mapping>

    <!-- spring 监听器 -->
    <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>

10：运行结果
这里写图片描述

11：框架结构图
这里写图片描述

SSM框架——Spring+SpringMVC+Mybatis的搭建教程
m0_68850571的博客
06-05 548
一：概述 SSM框架在项目开发中经常使用到，相比于SSH框架，它在仅几年的开发中运用的更加广泛。根据上面的描述，学习SSM框架就非常的重要了！二：搭建一个SSM的过程 使用命令要注意，系统安装了Maven，并配置好了环境变量！[Maven的安装和环境变量配置] 创建数据库和表，生成代码 创建数据库我参考别人的博客数据库设计，这块没有自己去书写，直接添上代码 生成代码请查看：[Mybatis自动生成代码]生成的代码导入图片解释：主要有 applicationContent.xml ：S
Spring笔记 整合SSM[Struts2框架] 万神小栈
万神小栈
10-30 548
在servlet中需要调用中的方法，则需要在servlet类中通过new关键字创建service 的实例 在service实现类中需要调用DAO中的方法，也需要在service实现类通过new关键字创建DAO实现类对象如果在使用new关键字创建对象 则会导致以下问题：： 在servlet中定义service接口的对象变了，不使用new关键字创建实现类对象，在servlet的实例化的时候，通过反射动态的给service对象变量赋值。 spring可以做到​ spring–>没有具体实质性
ssm框架学习之（一） --struts2 注解
04-13
NULL 博文链接：https://hackpro.iteye.com/blog/1726120
SSM(Struts2+Spring+Mybatis)
07-12
SSM(Struts2+Spring+Mybatis)三大框架
SSM整合过程(配置文件版) Struts2+Spring+Mybatis
weixin_44972575的博客
12-19 642
@[TOC](SSM整合过程(配置文件版) Struts2+Spring+Mybatis) 一、SSM整合过程(配置文件版) Struts2+Spring+Mybatis 1.创建web项目 2.补全开发环境
ssm之Struts（拦截器）
qq_35328937的博客
08-08 344
一、Struts2拦截器原理： Struts2拦截器的实现原理相对简单，当请求struts2的action时，Struts 2会查找配置文件，并根据其配置实例化相对的    拦截器对象，然后串成一个列表，最后一个一个地调用列表中的拦截器。 比如：应用要求用户登陆，且必须为指定用户名才可以查看系统中某个视图资源；否则，系统直接转入登陆页面。对于上面的需求，可以在每个Action的执行实际
Struts2+maven+spring+mybatis整合实现注册功能实例
12-12
Struts2、Maven、Spring和MyBatis是Java Web开发中的四大框架，它们的整合应用可以构建出高效、模块化的应用程序。这个实例是关于如何将这些技术融合在一起，实现一个用户注册的功能。 首先，Struts2是一个基于MVC...
ssm jar spring struts mybatis 所需jar
04-12
SSM（Spring、Struts、MyBatis）是Java Web开发中常见的三层架构组合，用于构建高效、灵活的Web应用程序。这个压缩包包含了这三个框架所需的JAR文件，为开发者提供了一个快速搭建SSM整合环境的基础。 **Spring框架*...
SSM框架搭建基础：Spring+Struts2+Mybatis
在目前流行的Java EE开发框架中，Spring、Struts2和MyBatis组合在一起，通常被简称为SSM框架，即Spring + Struts2 + MyBatis框架。这个组合广泛应用于企业级Web应用程序的开发中，因为它们各自提供独特而强大的功能...
SSM框架搭建：struts2+Spring+mybatis整合教程
在当前的软件开发领域，SSM（Struts2 + Spring + MyBatis）框架的组合是一个非常流行的选择，用于开发Java Web应用程序。这个框架的组合充分利用了三个开源框架的优势，为开发者提供了一个高效、灵活且易于维护的...
SSM（Spring+Struts2+Mybatis）整合步骤
08-29
SSM（Spring+Struts2+Mybatis）整合步骤 纯手写
SSM( Spring+Struts2+Mybatis)
qq_44804494的博客
12-26 667
SSM( Spring+Struts2+Mybatis )
struts2入门框架搭建
qq_27933251的博客
07-29 494
1.新建web项目 配置web.xml文件，添加filter拦截器 &amp;lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&amp;gt; &amp;lt;web-app version=&quot;2.5&quot; xmlns=&quot;http://java.sun.com/xml/ns/javaee&quot; x
ssm框架之struts2_day01
github_37217206的博客
02-27 588
一： struts2概述： JavaEE三大框架之一的web层框架，每次访问action的时候，都会创建一次，是线程安全的，内置拦截器，数据操作，值栈等 二： struts2解决问题：   三： 创建一个HellowWord程序： 1 ：导入jar包： 2  创建action： package cn.hr.action.demo; import com.opensymp...
ssm 之 Struts 基础
qq_35328937的博客
08-01 334
第一步：导入Struts的支持包： 至少有十二个： 第二步：web.xml 主配置文件中的配置Struts 第三步：写一个action来接收页面提交的参数  和 发送到页面的参数  必须要有set和get方法（set获取值，get 传值） （获取值得名字必须与页面提交时的name一致不然获取不到值） 第四步：写Struts.xml文件： （act
关于SSM（Spring、Struts2、Mybatis）框架整合的思考
墨小飞的小站
07-20 641
起因：因为很久已经没有自己动手进行过框架整合的配置了，也都遗忘的差不多了；然后最近就在配置SSM（Spring、Struts2、Mybatis）框架的整合，在此出现了不少问题，故在此记录。 首先，你的整体的目录结构应该类似于下面这样： POM.xml的相关配置： 项目是在Maven下进行配置的，一定要注意版本匹配的问题，建议在pom.xml中锁定版本； 在使用jdk1.8的时候Tomc...
SSM框架实战：Struts2+Spring3+Mybatis应用开发
最新发布
weixin_32099703的博客
11-03 803
本文还有配套的精品资源，点击获取 简介：Struts2、Spring3和MyBatis是构建Java企业级Web应用的三大主流框架，即SSM框架。本简介介绍这些框架的基础概念、核心功能和在SSM整合中的应用。同时提供了一个实用的学习路线图，以实现从基础到实战的过渡，包括用户注册、登录功能的开发等。 1. SSM框架组合简介 1.1 SSM框架的定义与组成 ...
ssm(struts2、spring、ibatis)框架使用注意事项
小五的博客
12-05 355
一、大佬绕道，嘿嘿，这部分对刚时候这个框架没多久的小白，比如我是有些用的，因为我在写代码的时候就因为这些问题不能较顺利的完成开发。 二、注意事项： 在控制层写好action方法后，最好马上到struts2的xml文件里配置好相应的action，如果你忘了写也没有关系，项目启动的时候是不会报错的，但是当调用到这个action的时候后台就会报错，提示There is no Action map
SSM_struct2整合步骤
Pluto.的博客
09-05 244
SSM整合步骤 1.引入依赖 ​ spring相关：mybatis mybatis-spring mysql druid ​ struts2相关：struts2-spring-plugin servlet-api ​ 其它：jstl log4j fastjson 2.spring + mybatis ​ 1.建表 ​ 2.实体类 ​ 3.DAO接口 ​ 4.Mapper配置文件 ​ 5.Service接口 ​ 6.Service实现类 ​ 7.编写spring.xml ​ a.创建数据源对象 DruidD
SSM框架整合教程：Spring、Struts2与Mybatis
在IT开发领域中，SSM整合指的是将Spring、Struts2和Mybatis这三大流行的Java框架结合起来进行Web应用开发。下面我将根据提供的文件信息，详细解读与SSM整合相关的核心知识点。 ### SSM整合的背景与优势 SSM整合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值