重温整合Maven+SSM框架（详细思路）

最新推荐文章于 2021-03-10 10:19:10 发布
最新推荐文章于 2021-03-10 10:19:10 发布
阅读量316 收藏 2
点赞数
分类专栏： java 文章标签： mybatis spring jsp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41726650/article/details/105748983
版权

一、搭建整合环境

1、整合说明

SSM整合可以使用多种方式，咱们选择的是XML + 注解的方式，这样可以更加的便捷。

2、整合的思路

  1. 搭建整合的环境
  2. Spring的配置搭建完成
  3. Spring整合SpringMVC框架
  4. Spring整合MyBatis框架
  5. Spring整合MyBatis框架配置事务（Spring的声明式事务管理）

3、创建数据库和表结构的语句

！使用的数据库名为：test

创建表：

create table library (
id int primary key auto_increment,
bookName varchar(255),
price int
);
添加数据：

insert into library (id,bookName,price) values(1,"西游记",520);
insert into library (id,bookName,price) values(2,"三国演义",521);
insert into library (id,bookName,price) values(3,"水浒传",522);
insert into library (id,bookName,price) values(4,"红楼梦",523);

4、创建Maven的工程

！使用IDEA创建Maven工程，可以去网上查询一下有很多的。（也可以参考这个博客）

创建项目的结构如下：（web依赖于service，service依赖于dao，dao依赖于pojo）

在Libraryproject的pom.xml文件中引入坐标依赖如下：

<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>5.0.2.RELEASE</spring.version>
    <slf4j.version>1.6.6</slf4j.version>
    <log4j.version>1.2.12</log4j.version>
    <mysql.version>5.1.6</mysql.version>
    <mybatis.version>3.4.5</mybatis.version>
  </properties>


<dependencies>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.6.8</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</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-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</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-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency> <!-- log start -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency> <!-- log end -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
  </dependencies>

5、编写实体类，在com.jm.pojo包下创建

创建实体类如下：

package com.jm.pojo;

import java.io.Serializable;

/**
 * @author jm
 * @date 2020/4/25
 **/
public class Library implements Serializable {

    private Integer id;
    private String bookName;
    private Integer price;
    
    public Integer getId() {
        return id;
    }

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

    public String getBookName() {
        return bookName;
    }

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

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Library{" +
                "id=" + id +
                ", bookName='" + bookName + '\'' +
                ", price=" + price +
                '}';
    }
}

6、创建dao持久层接口

在com.jm.dao包下创建LibraryDao接口如下：

package com.jm.dao;

import com.jm.pojo.Library;

import java.util.List;


/**
 * @author jm
 * @date 2020/4/25
 **/
public interface LibraryDao {
    //查询所有图书信息
    public List<Library> findAll();
    //保存图书信息
    public void saveLibrary(Library library);
}

7、创建service接口与实现类

在com.jm.service包下创建LibraryService接口如下：

package com.jm.service;

import com.jm.pojo.Library;

import java.util.List;

/**
 * @author jm
 * @date 2020/4/25
 **/
public interface LibraryService {

    //查询所有图书信息
    public List<Library> findAll();
    //保存图书信息
    public void saveLibrary(Library library);
}

创建com.jm.service.impl包下的service接口实现类LibraryServiceImpl如下：

package com.jm.service.impl;

import com.jm.pojo.Library;
import com.jm.service.LibraryService;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author jm
 * @date 2020/4/25
 **/
@Service("libraryService")
public class LibraryServiceImpl implements LibraryService {
    @Override
    public List<Library> findAll() {
        System.out.println("Service业务层：查询所有图书信息.....");
        return null;
    }

    @Override
    public void saveLibrary(Library library) {
        System.out.println("Service业务层：保存图书信息.....");
    }
}

！以上就是整合环境搭建，接下来就搭建Spring配置。

二、Spring框架代码的编写

开始搭建和测试Spring的开发环境

1、创建resources的资源文件目录管理XML配置文件

创建资源文件为：resources，用来管理放置XML配置文件

 创建完resources资源文件，然后将其资源文件权限修改为：Resources Boot 如下：

2、编写applicationContext.xml的配置文件

在resources资源文件中创建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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx.xsd">

<!--开启注解的扫描，处理service和dao、controller不需要Spring框架去处理-->
<context:component-scan base-package="com.jm" >
    <!--配置哪些注解不扫描-->
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
</context:component-scan>

</beans>

3、在项目中编写测试方法，进行Spring测试

在com.jm.test包下创建TestSpring类，如下：

package com.jm.test;

import com.jm.service.LibraryService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author jm
 * @date 2020/4/25
 **/
public class TestSpring {

    @Test
    public void TestRun(){
        ClassPathXmlApplicationContext cs = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        LibraryService ls = (LibraryService) cs.getBean("libraryService");
        ls.findAll();
    }
}

测试出如下结果，说明搭建Spring的开发环境成功！

三、SpringMVC框架代码的编写

主要内容：搭建和测试SpringMVC的开发环境

1、在web.xml中配置DispatcherServlet前端控制器和过滤器解决中文乱码

<!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 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">
  <display-name>Archetype Created Web Application</display-name>

  <!--配置前端控制器-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--加载springmvc.xml配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!--启动服务器，创建该servlet-->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!--解决中文乱码的过滤器-->
  <filter>
    <filter-name>characterEncodingFilter</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>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

2、创建springmvc.xml的配置文件

在resources资源文件中创建springmvc.xml配置文件如下：

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启注解扫描，只扫描Controller注解-->
    <context:component-scan base-package="com.jm">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--配置的视图解析器对象-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--过滤静态资源-->
    <mvc:resources location="/css" mapping="/css/**"/>
    <mvc:resources location="/images/" mapping="/images/**"/>
    <mvc:resources location="/js/" mapping="/js/**"/>
    <!--开启SpringMVC注解的支持-->
    <mvc:annotation-driven/>
</beans>

3、创建jsp页面，并编写controller层

编写index.jsp页面如下：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
<a href="library/findAll">测试SpringMVC查询</a>
</body>
</html>

在controller层中创建LibraryController类并编写查询方法如下：

package com.jm.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @author jm
 * @date 2020/4/25
 **/
@Controller
public class LibraryController {

    @RequestMapping("/library/findAll")
    public String findAll(){
        System.out.println("进入contr层：进行查询图书信息......");
        return  "list";
    }
}

创建controller层跳转的list.jsp页面如下：

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

<html>
<head>
    <title>Title</title>
</head>
<body>
    <h2>跳转成功，展示所有图书信息！</h2>
</body>
</html>

4、给项目部署Tomcat进行页面测试

配置Tomcat如下：

5、启动项目，进入页面测试接口

在页面输入http://localhost:8080/Libraryproject_war_exploded/ 

点击进入跳转到展示所有图书信息，则测试成功！如下：

以上就是Spring、SpringMVC的开发环境就搭建完成了，接下来就开始整合Spring和SpringMVC了！

四、Spring整合SpringMVC的框架

1、在web.xml中配置ContextLoaderListener监听器

在项目启动的时候，就去加载applicationContext.xml的配置文件，在web.xml中配置ContextLoadListener监听器（该监听器只能加载WEN-INF母驴下的applicationContext.xml的配置文件）。想要加载applicationContext.xml的配置文件有两种方法，第一种（不建议使用）；推荐使用第二种如下：

在web.xml中配置加载路径：

 <!--配置Spring的监听器，默认只加载WEB-INF目录下的applicationContext.xml配置文件-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
 <!--设置配置文件的路径-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

2、controller中注入service对象，调用service对象方法并测试

现在启动服务器时会加载spring配置文件，那么，我们可以在controller层注入service的方法，如下：

package com.jm.controller;

import com.jm.service.LibraryService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @author jm
 * @date 2020/4/25
 **/
@Controller
public class LibraryController {

    @Autowired
    private LibraryService libraryService;

    @RequestMapping("/library/findAll")
    public String findAll(){
        System.out.println("进入contr层：进行查询图书信息......");
        libraryService.findAll();
        return  "list";
    }
}

测试Spring和SpringMVC整合是否成功，看如下效果：

五、MyBatis框架代码的编写

提到MyBatis，就要想到dao持久层；MyBatis环境搭建首先是dao，再搭建MyBatis，在此之前还要编写mapper映射的配置文件，这里我们选择使用注解的方式如下：

1、在LibraryDao接口方法是添加注解，编写SQL语句

package com.jm.dao;

import com.jm.pojo.Library;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

import java.util.List;


/**
 * @author jm
 * @date 2020/4/25
 **/
@Repository//此注解表示为持久层
public interface LibraryDao {
    //查询所有图书信息
    @Select("select * from library")
    public List<Library> findAll();
    //保存图书信息
    @Insert("insert into library (bookName,price) value(#{bookName},#{price})")
    public void saveLibrary(Library library);
}

2、创建SqlMapConfig.xml的配置文件并编写

在resources文件下创建SqlMapConfig.xml的配置文件如下：

<?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>
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///claire"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 使用的是注解 -->
    <mappers>
        <!-- <mapper class="com.jm.dao.LibraryDao"/> --> <!-- 该包下所有的dao接口都可以使用 -->
        <package name="com.jm.dao"/>
    </mappers>
</configuration>

3、创建并编写MyBatis测试方法

在com.jm.test包下创建TestMyBatis测试类如下：

package com.jm.test;

import com.jm.dao.LibraryDao;
import com.jm.pojo.Library;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * @author jm
 * @date 2020/4/26
 **/
public class TestMyBatis {

    @Test
    public void myRunOne() throws IOException {
        Library library = new Library();
        library.setBookName("金瓶梅");
        library.setPrice(998);
        //加载配置文件
        InputStream rst = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(rst);
        //创建SqlSession对象
        SqlSession session = factory.openSession();
        //获取到代理对象
        LibraryDao dao = session.getMapper(LibraryDao.class);
        dao.saveLibrary(library);
        session.commit();
        session.close();
        rst.close();
    }

    @Test
    public void myRunTwo() throws IOException {
        InputStream rst = Resources.getResourceAsStream("SqlMapConfig.xml");

        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(rst);

        SqlSession session = factory.openSession();

        LibraryDao dao = session.getMapper(LibraryDao.class);

        List<Library> list = dao.findAll();
        for (Library library: list ) {
            System.out.println(library);
        }
        session.close();
        rst.close();
    }

}

测试效果如下：

六、Spring整合MyBatis框架

整合思路：需要Service层能够调用Dao层的对象，进行数据库的操作；现在Spring已经是在IOC容器中，Dao是个接口，可通过程序把这个接口生成代理对象，我们把这个代理对象放到IOC容器，那么service就可以拿到这个对象在service中做个注入，调用dao代理对象的方法。

把SqlMapConfig.xml配置文件中的内容配置到applicationContext.xml配置文件中如下：

 <!--Spring整合MyBatis框架-->
    <!--配置连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///claire"/>
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
    </bean>

1、在applicationContext.xml中配置SqlSessionFactory工厂

在applicationContext.xml中配置SqlSessionFactory工厂，这就相当于IOC容器中有工厂，就可以去创建SqlSession，进而

通过Sqlsession拿到代理对象，没必要每次测试都去创建工厂，配置如下：

 <!--配置SqlSessionFactory工厂-->
<bean id="sqlSessonFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
 </bean>

2、在applicationContext.xml中配置LibraryDao接口在包

现在工厂、SqlSession都有了，那代理谁？所以我们要配置Library接口所在包，告诉SqlSession去代理接口所在包中的代理，从而存到IOC容器中，如下：

 <!--配置LibraryDao接口所在包-->
    <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.jm.dao"/>
    </bean>

以上就是把MyBatis中配置（SqlMaoConfig.xml）转移到spring中去，让他产生代理并存到IOC容器中。

3、完善Service层代码

package com.jm.service.impl;

import com.jm.dao.LibraryDao;
import com.jm.pojo.Library;
import com.jm.service.LibraryService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author jm
 * @date 2020/4/25
 **/
@Service("libraryService")
public class LibraryServiceImpl implements LibraryService {

    @Autowired
    private LibraryDao libraryDao;

    @Override
    public List<Library> findAll() {
        System.out.println("Service业务层：查询所有图书信息.....");
        return libraryDao.findAll();
    }

    @Override
    public void saveLibrary(Library library) {
        System.out.println("Service业务层：保存图书信息.....");
        libraryDao.saveLibrary(library);
    }
}

4、完善Controller层代码

package com.jm.controller;

import com.jm.pojo.Library;
import com.jm.service.LibraryService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

/**
 * @author jm
 * @date 2020/4/25
 **/
@Controller
public class LibraryController {

    @Autowired
    private LibraryService libraryService;

    @RequestMapping("/library/findAll")
    public String findAll(Model model){
        System.out.println("进入contr层：进行查询图书信息......");
        List<Library> list = libraryService.findAll();
        model.addAttribute("list",list);
        return  "list";
    }
}

5、创建list.jsp页面并展示数据

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

<html>
<head>
    <title>Title</title>
</head>
<body>
    <h2>查询所有图书信息</h2>
    <c:forEach items="${list}" var="liy">
        ${liy.bookName}
    </c:forEach>
</body>
</html>

6、启动项目并测试

七、Spring整合MyBatis框架配置事务（Spring的声明式事务管理）

1、在applicationContext.xml中配置Spring框架声明式事务管理

<!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" isolation="DEFAULT"/>
        </tx:attributes>
    </tx:advice>

    <!--配置AOP增强-->
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.jm.service.impl.*ServiceImpl.*(..))"/>
    </aop:config>

2、完善index.jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <a href="library/findAll">测试</a>
    <h3>测试页面</h3>
    <form action="library/saveData" method="post">
        图书名称：<input type="text" name="bookName" /><br/>
        价格：<input type="text" name="price" /><br/>
        <input type="submit" value="保存"/><br/>
    </form>
</body>
</html>

3、完善Service层、Controller层代码

 @Override
    public void saveLibrary(Library library) {
        System.out.println("Service业务层：保存图书信息.....");
        libraryDao.saveLibrary(library);
    }
@RequestMapping("/library/saveData")
    public void saveData(Library library, HttpServletRequest request, HttpServletResponse response) throws IOException {
        libraryService.saveLibrary(library);
        response.sendRedirect(request.getContextPath() + "/library/findAll");
        return ;
    }

4、启动项目并测试运行

结束语：以上就是SSM框架的整合，此篇只是自己作为练习发布的，如果有大神看到了可以请绕过，谢谢！

 

 

 

 

 

 

 

 

 

 

 

 

IT_子龙
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Maven+SSM框架模板
02-28
Maven项目下，搭建Spring，SpringMVC，Mybatis框架。下载直接可用。需要下载zookeeper
千辛万苦弄出来 Maven+SSM框架整合项目
07-07
在这个"千辛万苦弄出来 Maven+SSM框架整合项目"中，我们可以深入探讨这些关键知识点。 首先，**Maven** 是Apache软件基金会开发的一款项目管理和集成工具。它通过一个项目对象模型（Project Object Model, POM）来...
[JSP]Maven+SSM框架(Spring+SpringMVC+MyBatis) - Hello World
weixin_30673611的博客
04-16 230
来源：http://blog.csdn.net/zhshulin/article/details/37956105?utm_source=tuicool&utm_medium=referral（以下博文对原博文有改动和补充） 博文里红底白字的，为注意修改的地方，在这里先声明 源码：Maven&SSM框架 - Hello World 开发环境： Eclipse J...
maven下整合SSM框架
老狼的博客
01-18 517
工具:配置好maven的eclipse, jdk1.8, tomcat7.0, MySQL 5.6.24一. 创建一个maven项目,下载所需要jar包1.maven项目创建后目录,启动成功. 2.打开项目下的pom.xml 添加依赖jar包 (如果是第一次用maven下载,可能会有些慢,需要耐心等待) <project xmlns="http://maven.apache.org/POM/4
使用maven搭建一个简单的SSM框架
boy_chen93的博客
08-11 2200
       学习了ssm框架后，一直想要自己亲自搭建一个，最近尝试了一下，效果还行，算是一个微型的ssm框架吧。介绍一下，我使用的IDE是idea。        首先，创建一个maven的web工程，如下：         然后点击next,添加groupId,artifactId和version,这个随便起不过groupId表示你的包名，artifactId表示你的项目名，如下： ...
maven+SSM框架整合
lf1213520的博客
05-02 2673
idea 构建maven+ssm项目
整合IDEA+Maven+SSM框架商品秒杀项目
12-27
【标题】"整合IDEA+Maven+SSM框架商品秒杀项目"是一个基于Java的电商项目，旨在演示如何在IntelliJ IDEA（IDEA）集成开发环境中，使用Maven构建工具以及Spring、SpringMVC和MyBatis（SSM）经典企业级开发框架来实现...
maven+ssm整合
12-15
SSM（Spring、SpringMVC、MyBatis）是一个经典的Java web开发框架组合，而Maven则是一个项目管理和构建工具。在Java开发中，Maven能够帮助开发者管理项目的依赖关系，构建过程，以及标准化项目结构。SSM整合则是将这...
IDEA整合Maven+SSM框架.zip
08-13
以上就是关于"IDEA整合Maven+SSM框架"的相关知识点。在实际开发中，理解这些概念并熟练掌握SSM整合对于提高开发效率和代码质量至关重要。通过不断实践和优化，开发者可以更加高效地利用这个框架组合来构建复杂的企业...
maven+ssm框架demo
05-13
这个“maven+ssm框架demo”项目是一个适合初学者实践的示例，它演示了如何将这三大框架整合在一起，并引入Log4j作为日志处理工具。以下将详细介绍SSM框架的核心概念和集成过程，以及Maven在项目构建中的作用。 1. *...
Maven+Spring+Spring MVC+MyBatis+MySQL整合SSM框架Demo
07-11
Maven+Spring+Spring MVC+MyBatis+MySQL整合SSM框架Demo，对应的有博文，欢迎对照下载学习
ssm框架的依赖文件--maven方式
05-10
SSM框架的依赖文件，可以让javaweb解决同一个项目不同jar包版本引起的问题
maven配置ssm框架
02-27
spring+spring mvc +mybatis 整合maven工程
maven+SSM框架工程搭建
qq_19688207的博客
03-10 452
1、自行下载 maven 和 tomcat 安装 配置环境变量（网上查找资料即可） 2、使用eclipse 集成maven Window --- Preferences --- Maven(可搜索) --- Installations 配置User Settings(下载的依赖文件所在位置) 设置 maven conf文件夹下的settings.xml文件配置存放maven仓库的位置，C:/Java_Web/apache-maven-3.5.3/repository 为存放路..
使用Maven搭建SSM框架 IDEA
weixin_44215175的博客
09-17 1505
使用Maven搭建SSM框架，并测试使用 使用Maven搭建SSM框架（IDEA） 1. 创建Maven工程 2. 使用自己安装的Maven 3. 加入Maven依赖jar <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>1.7</maven.compiler.source&gt
Maven+SSM框架搭建前（一）
hans的博客
03-23 476
主体: 配置框架之前首先确保自己的开发环境，本章主要介绍maven环境的搭建。        1.1.1 搭建maven环境      具体参照https://jingyan.baidu.com/article/3052f5a1e8f86397f21f8671.html  点击打开链接        一步步照着上面做，基本上不会有什么问题。        2.1  Maven环境搭建配置成功，然后...
SSM框架的Maven依赖
LBH19960601的博客
09-27 97
SSM框架的Maven依赖 <?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.apac
ssm框架MAVEN依赖
xiaopeng_thriller的博客
08-05 104
<?xml version="1.0" encoding="UTF-8"?> 4.0.0 <groupId>com.itheima.ssm_test</groupId> <artifactId>ssm_test</artifactId> <packaging>pom</packaging> <version...
ssm框架常用maven依赖
有人的地方，就是江湖
04-09 374
1、导入相关jar包 junit mysql-connector-java mybatis spring-webmvc spring-jdbc aspectjweaver mybatis-spring <dependencies> <!-- https://mvnrepository.com/artifact/junit/junit --> <d...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值