紫薇星上的SSM——整合SSM框架

最新推荐文章于 2024-05-19 14:26:23 发布
最新推荐文章于 2024-05-19 14:26:23 发布
阅读量218 收藏
点赞数
分类专栏： 紫薇星上的流行技术 文章标签： spring mybatis java SSM SpringMVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39732867/article/details/107076931
版权

SSM框架分为Spring、Spring MVC、Mybatis，去前面我们分别学习了这三个部分，现在我们来整理一下如何成功的整合这三部分以达到完整的SSM框架。

 0.环境

首先来配一下环境，IDEA2020，Maven项目，这些就不说了，主要看一下依赖：

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.34</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.4</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>3.0-alpha-1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.7.0-M1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2.1-b03</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</version>
        </dependency>
    </dependencies>

1.前期配置

配置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"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

这里我们先什么都不配，来看下一步，在src下建立controller、mapper、pojo、service四个包，分别对应Servlet、Dao、DoMain、Service这四个部分。

简单的Demo

因为处理事务的原因，所以简单的写一个Demo用来说明，我们需要一个数据库，Demo用来实现图书数据的增删改查。

数据库准备

首先建立一个数据库，以及数据：

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for books
-- ----------------------------
DROP TABLE IF EXISTS `books`;
CREATE TABLE `books`  (
  `bookID` int(10) NOT NULL AUTO_INCREMENT,
  `bookName` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `bookCounts` int(11) NOT NULL,
  `detail` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`bookID`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of books
-- ----------------------------
INSERT INTO `books` VALUES (1, 'Java', 1, '从入门到放弃');
INSERT INTO `books` VALUES (2, 'Mysql', 10, '从入门到放弃');
INSERT INTO `books` VALUES (3, 'Linux', 5, '从入门到放弃');

SET FOREIGN_KEY_CHECKS = 1;

pojo准备

接下来在pojo包中建立Books类：

package com.test.pojo;

public class Books {
    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;

    public Books() {
    }

    public Books(int bookID, String bookName, int bookCounts, String detail) {
        this.bookID = bookID;
        this.bookName = bookName;
        this.bookCounts = bookCounts;
        this.detail = detail;
    }

    public int getBookID() {
        return bookID;
    }

    public void setBookID(int bookID) {
        this.bookID = bookID;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public int getBookCounts() {
        return bookCounts;
    }

    public void setBookCounts(int bookCounts) {
        this.bookCounts = bookCounts;
    }

    public String getDetail() {
        return detail;
    }

    public void setDetail(String detail) {
        this.detail = detail;
    }

    @Override
    public String toString() {
        return "Books{" +
                "bookID=" + bookID +
                ", bookName='" + bookName + '\'' +
                ", bookCounts=" + bookCounts +
                ", detail='" + detail + '\'' +
                '}';
    }
}

 前期准备就绪，现在我们可以开始整合了。

2.整合Mybatis

Mapper接口

有了pojo实体类后就应该编写接口来定义方法：

package com.test.mapper;

import com.test.pojo.Books;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface BookMapper {
    public int addBook(Books books);

    public int deleteBookById(@Param("bookID") int id);

    public int updateBook(Books books);

    public List<Books> queryBooks();

    public Books queryBooksById(@Param("bookID")int id);
}

我们简简单单的编写五个方法，实现增删改查的功能。 

mybatis-config.xml

有了接口接下来我们需要建立mybatis-config.xml注册接口，因为使用Spring，所以mybatis-config的大部分工作交给Spring去做，mybatis-config中只需要注册mapper接口和实现别名就可以：

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

    <typeAliases>
        <package name="com.test.pojo"/>
    </typeAliases>

    <mappers>
        <mapper class="com.test.mapper.BookMapper"/>
    </mappers>

</configuration>

数据库配置文件

编写database.properties文件： 

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=true&useUnicode=true&charsetEncoding=utf8
jdbc.username=#你的账号#
jdbc.password=#你的密码#

Spring接管mybatis

使用Spring接管Mybatis的大部分工作，建立spring-mapper.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 
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!--关联数据库文件-->
    <context:property-placeholder location="classpath:database.properties"/>

    <!--<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource"></bean>-->
    <!--数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

        <!--c3p0私有属性-->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!--关闭连接后不自动commit-->
        <property name="autoCommitOnClose" value="false"/>
        <!--获取连接超时时间-->
        <property name="checkoutTimeout" value="10000"/>
        <!--连接失败重试次数-->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>

    <!--SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定Mybatis的配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <!--配置dao接口扫描包，动态实现dao接口注入到Spring中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--注入sqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--要扫描的dao包-->
        <property name="basePackage" value="com.test.mapper"/>
    </bean>

</beans>

我们并没有使用Spring自带的DriverManagerDataSource来做连接池，而是使用了c3p0，这是因为c3p0比较方便。

BookMapper.xml文件

接下来就可以编写sql语句了：

<?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.test.mapper.BookMapper">
    <insert id="addBook" parameterType="Books">
        insert into ssmbuild.books (bookID, bookName, bookCounts, detail)
        values (#{bookID}, #{bookName}, #{bookCounts}, #{detail});
    </insert>

    <delete id="deleteBookById" parameterType="int">
        delete from ssmbuild.books where bookID = #{id};
    </delete>

    <update id="updateBook" parameterType="Books">
        update ssmbuild.books
        set bookName = #{bookName}, bookCounts = #{bookCounts}, detail = #{detail}
        where bookID = #{bookID};
    </update>

    <select id="queryBooks" resultType="Books">
        select * from ssmbuild.books;
    </select>

    <select id="queryBookById" parameterType="int" resultType="Books">
        select * from ssmbuild.books where bookID = #{bookID};
    </select>
</mapper>

3.整合service

service接口

有了DAO层，接下来就是Service层，同样的，建立接口：

package com.test.service;

import com.test.pojo.Books;

import java.util.List;

public interface BookService {
    public int addBook(Books books);

    public int deleteBookById(int id);

    public int updateBook(Books books);

    public List<Books> queryBooks();

    public Books queryBooksById(int id);
}

接口实现类

有了接口就要建立实现类：

package com.test.service;

import com.test.mapper.BookMapper;
import com.test.pojo.Books;

import java.util.List;

public class BookServiceImpl implements BookService {

    //service层调DAO层
    private BookMapper mapper;

    public BookServiceImpl() {
    }

    public BookServiceImpl(BookMapper mapper) {
        this.mapper = mapper;
    }

    public BookMapper getMapper() {
        return mapper;
    }

    public void setMapper(BookMapper mapper) {
        this.mapper = mapper;
    }

    @Override
    public String toString() {
        return "BookServiceImpl{" +
                "mapper=" + mapper +
                '}';
    }

    

    public int addBook(Books books) {
        return mapper.addBook(books);
    }

    public int deleteBookById(int id) {
        return mapper.deleteBookById(id);
    }

    public int updateBook(Books books) {
        return mapper.updateBook(books);
    }

    public List<Books> queryBooks() {
        return mapper.queryBooks();
    }

    public Books queryBooksById(int id) {
        return mapper.queryBooksById(id);
    }
}

Spring注入Service

有了Service就可以使用Spring来做注入：

<?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 
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!--扫描Service下的包-->
    <context:component-scan base-package="com.test.service"/>
    <!--将业务类注入到Spring,通过注解或者配置-->
    <bean id="BookServiceImpl" class="com.test.service.BookServiceImpl">
        <property name="mapper" ref="bookMapper"/>
    </bean>
    <!--声明式事务配置-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

配置applicationContext.xml

不要忘记applicationContext.xml需要修改，不然dataSource注入不了：

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="classpath:spring-mapper.xml"/>
    <import resource="classpath:spring-service.xml"/>

</beans>

4.整合SpringMVC

配置web.xml

首先将普通的Maven项目变成一个Web项目，添加Web Framework support，变为web项目后来配置web.xml：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

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

    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>
</web-app>

配置spring-mvc.xml

在web.xml中配置DispatcherServlet，filter，session，接下来配置mvc：

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

    <!--扫描包-->
    <context:component-scan base-package="com.test.controller"/>
    <!--注解驱动-->
    <mvc:annotation-driven/>
    <!--静态资源过滤-->
    <mvc:default-servlet-handler/>
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

配置applicationContext.xml

当然配置后就要修改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"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="classpath:spring-mapper.xml"/>
    <import resource="classpath:spring-service.xml"/>
    <import resource="classpath:spring-mvc.xml"/>

</beans>

BookController

最后就到了Controller层：

package com.test.controller;

import com.test.pojo.Books;
import com.test.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@Controller
@RequestMapping("/book")
public class BookController {
    //controller层调service层
    @Autowired
    @Qualifier("BookServiceImpl")
    private BookService bookService;

    @RequestMapping("/allBook")
    public String list(Model model){
        List<Books> books = bookService.queryBooks();
        model.addAttribute("list", books);
        return "allBook";
    }

}

直接使用@Qualifier注入Service，接下来该写页面了。

jsp页面

因为Demo主要是为了整合SSM框架，所以页面功能就不做细节，简单实现就可，首先是allBook.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>书籍展示</title>
</head>
<body>
    <h1>书籍展示</h1>
    ${list}
</body>
</html>

接下来是index.jsp入口页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>首页</title>
  </head>
  <body>
  <h3>
    <a href="${pageContext.request.contextPath}/book/allBook">进入书籍页面</a>
  </h3>
  </body>
</html>

5.细节

这里有几个小细节，我们要注意一下：

Not used ‘webapp’

 我们使用的是普通Maven项目+web framework support，这样做的好处是基本不会出错，一切都可以根据我们自己来选，但是这样也会有问题，就是artifacts目录下的WEB-INF目录中没有lib目录，所以我们要手动添加：

然后将所有的jar全部添加，apply，ok，就可以了。

配置Tomcat

 最后就是配置Tomcat：

6.总结

结构

这是最后的文件结构，大家可以核对一下自己的：

效果

以及最终的效果：

SSM整合就这么多东西，其余的如拦截器，功能实现，前端页面等，都可以直接把这个框架拿过去修改，完全没有问题，接下来就该找时间将上次给我爸做的那个商品管理系统使用SSM重构一下，我们下次见👋

紫郡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSM框架——详细整合教程（Spring+SpringMVC+MyBatis）
在路上
07-19 63万+
使用SSM（Spring、SpringMVC和Mybatis）已经有三个多月了，项目在技术上已经没有什么难点了，基于现有的技术就可以实现想要的功能，当然肯定有很多可以改进的地方。之前没有记录SSM整合的过程，这次刚刚好基于自己的一个小项目重新搭建了一次，而且比项目搭建的要更好一些。以前解决问题的过程和方法并没有及时记录，以后在自己的小项目中遇到我再整理分享一下。这次，先说说三大框架整合过程。个人认
ssm框架整合redis源码
05-15
在本项目中，"ssm框架整合redis源码"意味着开发者将SSM框架与Redis缓存系统进行了集成，主要目的是实现session共享。Session共享是Web应用中解决用户会话跨服务器问题的关键技术，尤其是在分布式环境下，确保用户...
紫薇星上的数据结构（6）
紫郡的博客
02-25 262
昨天整理了串的顺序存储结构的知识点，今天我们简单地说一下串的链式存储结构—链串，以及两个模式匹配算法，最后再用一个小实例实践一下这两种算法。
整合SSM项目（图书管理项目）
caicai1hao的博客
09-09 244
项目支持 Maven、mybatis、Spring、数据库知识、前端知识 数据库环境 创建数据库表 基本环境搭建 1.新建一个Maven项目！添加web支持 2.导入相关的pom依赖 <!--依赖-:junit,数据库驱动，连接池，servlet,jsp,mybatis,mybatis-spring,spring--> <dependencies> <dependency> <groupId>j
SSM框架整合详细教程
weixin_44362089的博客
11-11 2557
SSM框架整合，SSM框架整合步骤，Spring框架，SpringMVC框架，Mybatis框架
SSM框架讲解（史上最详细的文章）
热门推荐
代码贩子、的博客
11-30 34万+
SSM框架（白痴都看完都会） 文章目录SSM框架（白痴都看完都会）介绍SSM框架<原理>一、什么是SSM框架？1.Spring2.Spring MVC3.Mybatis （核心是SqlSession）二、代码实战1.创建配置工程2.代码书写 介绍SSM框架<原理> 一、什么是SSM框架？ SSM框架是spring、spring MVC 、和mybatis框架的整合，是标准的MVC模式。标准的SSM框架有四层，分别是dao层（mapper），service层，controller层
SSM项目————整合微信支付
weixin_42858422的博客
02-22 5122
一、准备页面1、第一个页面，购票页面2、第二个页面，详情支付页面3、第三个页面，支付成功跳转页面二、准备二维码（测试一下）三、准备微信参数、环境、HttpClient工具类、雪花算法工具类。四、开始支付功能编码（下单）五、开始支付功能编码（查询订单状态）————————创作不易，如觉不错，随手点赞，关注，收藏(*￣︶￣)，谢谢~~ 我们这里只看支付，其他跟支付无关的东西不看 一、准备页面 主要有三个页面 1、第一个页面，购票页面 2、第二个页面，详情支付页面 紫色的三个是跟我们支付有关的 3、第三个页.
史上最详细的IDEA优雅整合Maven+SSM框架（详细思路+附带源码）
宜春
10-29 24万+
网上很多整合SSM博客文章并不能让初探ssm的同学思路完全的清晰，可以试着关掉整合教程，摇两下头骨，哈一大口气，就在万事具备的时候，开整，这个时候你可能思路全无 ~中招了咩~ ，还有一些同学依旧在使用eclipse或者Myeclipse开发，我想对这些朋友说IDEA 的编译速度很快，人生苦短，来不及解释了，直接上手idea吧。这篇文章每一步搭建过程都测试过了，应该不会有什么差错。本文章还有个比较优秀的特点，就是idea的使用，基本上关于idea的操作都算是比较详细的，所以不用太担心不会撸idea！最后，本文
【SSM进阶学习】详解SSM框架中的整合与分页
最新发布
陈橘又青的博客
05-19 2万+
定义db.properties数据库配置文件针对分页，使用的是PageHelper分页插件，版本使用的是5.1.8。参考文档PageHelper是适用于MyBatis框架的一个分页插件，它支持基本主流与常用的数据库，如MySQL、Oracle、MariaDB、SQLite、Hsqldb等。特性简单易用: PageHelper 提供了简单的配置方式，可以轻松地在 MyBatis 中启用分页功能。
2022新版图文详解IDEA整合SSM框架(附源码)
谷哥的小弟
04-13 1万+
本教程以图文形式详细讲解IDEA整合SSM框架的流程以及具体步骤及其注意事项。总体而言，利用IDEA搭建Maven工程并整合SSM框架的技术难度不大；但是需要注意的细节之处较多。所以，在整合过程中务必细致周到，考虑周全，富有耐心。
SSM项目————整合文件上传
weixin_42858422的博客
02-22 593
SSM项目————整合文件上传 一、首先页面二、编码————————创作不易，如觉不错，随手点赞，关注，收藏(*￣︶￣)，谢谢~~ 我们这里只看文件上传，其他的不看 一、首先页面 二、编码 1、设一个id 2、点击的时候，异步上传 3、Controller编写 4、启动项目演示一下 OK，照片回显没有问题 看一下后台，没有问题，已经上传进来了 ———————— 创作不易，如觉不错，随手点赞，关注，收藏(*￣︶￣)，谢谢~~ ...
SSM框架——详细整合教程.pdf
06-12
SSM框架，全称为Spring、SpringMVC和MyBatis的整合框架，是Java开发中常用的Web应用程序开发架构。SSM框架的整合旨在提供一种高效、灵活且易于维护的开发方式，尤其适用于大型的企业级应用。 1. **Spring框架**： ...
SSM框架整合Java项目源码 - SpringMvc-05示例
03-25
项目概述：本项目命名为 SpringMvc-05 示例，主要采用 Java 语言开发，整合了 SSM（Spring、SpringMVC、MyBatis）框架。项目包含前端和后端两部分，前端使用了 JavaScript、CSS 和 HTML，后端则完全是 Java 实现。...
SSM框架——详细整合源码
05-28
8. **测试与运行**：编写JUnit测试用例，验证SSM框架的整合是否成功，然后部署到Tomcat服务器上运行。 以上就是SSM框架的基本整合流程和关键知识点。在实际开发中，我们还需要关注如异常处理、安全性、性能优化等...
基于Java实现的SSM框架整合实战案例
12-10
基于Java实现的SSM框架整合实战案例 基于Java实现的SSM框架整合实战案例 基于Java实现的SSM框架整合实战案例 基于Java实现的SSM框架整合实战案例 基于Java实现的SSM框架整合实战案例 基于Java实现的SSM框架整合实战...
前后端分离：实战——“全栈”路上的一大步
紫郡的博客
07-08 2765
今天通过一个小Demo实现了前后端分离，这是“全栈”路上的一小步，却是我个人的一大步，冲!
前后端分离：前导——后端程序员能看懂的VUE
紫郡的博客
07-06 2327
说起前后端分离就不得不提VUE，这篇文章来整理一下VUE的知识点
紫薇星上的SSM——SSM框架的一些补充
紫郡的博客
07-04 1495
既然已经学到了这里，那就顺便补充一些知识点，包括：json、Ajax、拦截器、文件的上传与下载
前后端分离：必备——你不得不知道的那些事儿
紫郡的博客
07-07 594
这篇文章主要整理一下WebPack、Vue-CLI、ElementUI、Axios这些前后端分离中一定会用到的知识点
SSM框架整合详解：Spring+SpringMVC+MyBatis
- **部署和测试**：在Tomcat或其他Web服务器上部署应用，进行功能测试以确保SSM框架的正确整合和运行。 通过这种方式整合SSM框架，开发者能够构建出高效、灵活且易于维护的Java Web应用。在实际开发中，根据项目...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值