SSM框架简单整合

最新推荐文章于 2022-03-12 00:23:10 发布

Jcduhdt

最新推荐文章于 2022-03-12 00:23:10 发布

阅读量175

点赞数 1

分类专栏： Java 文章标签： java spring

本文链接：https://blog.csdn.net/Jcduhdt/article/details/104933048

版权

Java 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

简单说明

对黑马视频讲的简单的SSM框架的整合的整理，很简单，主要是理解三大框架如何结合在一起，jsp就是简单标签，数据库也只有单表。对黑马所讲解的基本没改变，就是添加了一些备注，自己记录一下。

使用环境

1.JDK：12.0.1
2.IDEA：2019.1.1
3.MySql：8.0.16
4.Tomcat：9.0.31
5.maven：3.5.2# 创建工程

项目结构准备

创建Maven工程，直接选取webapp骨架，然后设置自己的GroupId和项目名一路next就行了
注意图中有两个webapp，使用第二个
得到项目初始结构是这样的
在这里插入图片描述
然后需要将项目文件扩大为

注意java和resources文件夹与其他文件夹不同，需要将java变成Sources Root文件夹，将resources变成Resources Root文件夹。操作过程为右击文件夹找到下图所示位置，选择即可

然后controller是存放SpringMVC的控制类相关，与页面交互的类
dao即持久层，MyBatis相关的类，读写数据库
domain主控制层，是用户与数据库交互的核心中转站，控制用户数据收集，控制请求转向
service是业务逻辑层，处理数据逻辑，验证数据，Spring相关类
test即编写代码的时候需要依次测试模块是否写正确，再进行下一步
resources存放的是配置文件
WEB-INF存放的即为前端文件
pom.xml即编写我们使用maven，需要导入的依赖

项目代码

数据库创建

创建数据库ssm->使用ssm->创建account表，有id、name、money三个域，id为主键，自增

create database ssm;
use ssm;
create table account(
id int primary key auto_increment,
name varchar(100),
money double(7,2)
);

编写log4j.properties文件

将该文件存放在resources文件夹下，用于日志输出，因为导了该依赖，若没添加这个文件，运行程序时会弹出警告，日志还是很重要，有助于排错
在这里插入图片描述
具体代码如下，直接拷贝就ok

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=info, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=E:/axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

导入依赖

编写pom.xml，导入需要的依赖，build那里是建项目的时候，自动创建的，并不知道有什么用。

<?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.zx</groupId>
    <artifactId>SSM</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>SSM 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.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <!--设置属性，用于版本控制，便于后期修改-->
        <spring.version>5.2.0.RELEASE</spring.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <shiro.version>1.2.3</shiro.version>
        <mysql.version>8.0.16</mysql.version>
        <mybatis.version>3.4.5</mybatis.version>
    </properties>

    <dependencies>
        <!-- spring -->
        <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-context-support</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-orm</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-core</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-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</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>
        <!-- el表达式 -->
        <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>

    <build>
        <finalName>SSM</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

编写实体类

在domain文件夹下面创建Account.java文件，该类是一个实体类，实现Serializable接口，对应数据库中的account表，id、name、money三个域，生成对应的get、set和toString方法

package com.zx.domain;

import java.io.Serializable;

/**
 * @author ZhangXiong
 * @version v12.0.1
 * @date 2020-03-17
 * 账户
 */
public class Account implements Serializable {
    private Integer id;
    private String name;
    private Double money;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

编写业务层接口

Spring框架下要使用的业务

package com.zx.service;

import com.zx.domain.Account;

import java.util.List;

/**
 * @author ZhangXiong
 * @version v12.0.1
 * @date 2020-03-17
 * 账户的业务层接口
 */
public interface AccountService {
    //查询所有账户信息
    public List<Account> findAll();

    //保存账户信息
    public void saveAccount(Account account);
}

编写持久层接口

package com.zx.dao;

import com.zx.domain.Account;

import java.util.List;

/**
 * @author ZhangXiong
 * @version v12.0.1
 * @date 2020-03-17
 * 账户dao接口
 */
public interface AccountDao {
    //查询所有账户信息
    public List<Account> findAll();

    //保存账户信息
    public void saveAccount(Account account);
}

整合

因为ssm框架中是以Spring框架为主体，连接SpringMVC和MyBatis的，所以应当先配置Spring。

编写Spring文件并导入约束

在resources文件夹下创建applicationConfig.xml文件，导入约束，用到了IOC容器beans、切片aop、事务管理tx，还有context这些约束。目前而言只需要配置创建容器要扫描的包，即context 这个标签。

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

    <!--开启注解扫描  只扫描业务层和持久层  即service和dao 不处理controller-->
    <context:component-scan base-package="com.zx">
        <!--配置哪些注解不扫描  完整路径-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
</beans>

注解配置业务层实现类

输出业务层：查询所有账户这种是为了在控制台区分各层的操作。

package com.zx.service.impl;

import com.zx.domain.Account;
import com.zx.service.AccountService;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author ZhangXiong
 * @version v12.0.1
 * @date 2020-03-17
 */
@Service("accountService")
public class AccountServiceImpl implements AccountService {


    @Override
    public List<Account> findAll() {
        System.out.println("业务层：查询所有账户");
        return null;
    }

    @Override
    public void saveAccount(Account account) {
        System.out.println("业务层，保存账户");
    }
}

编写测试类测试Spring框架

package com.zx.test;

import com.zx.service.AccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author ZhangXiong
 * @version v12.0.1
 * @date 2020-03-17
 * 测试类
 */
public class TestSpring {
    @Test
    public void run1(){
        //加载配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        //获取对象
        AccountService as = (AccountService)ac.getBean("accountService");
        //调用方法
        as.findAll();

    }
}

然后在控制台得到输出结果，即Spring基本成功
在这里插入图片描述

保证SpringMVC在程序中能独立运行

配置web.xml文件

SpringMVC属于表现层，所以需要在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>
    <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>

配置springmvc.xml文件

配置在web.xml中缺失的springmvc.xml文件，该文件在resources文件夹下，其中过滤静态资源那里，IDEA会标红，因为我们并没有创建对应文件夹，但是不影响使用

<?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">

    <!--开启注解扫描,只是扫描cotroller-->
    <context:component-scan base-package="com.zx">
        <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></mvc:annotation-driven>
</beans>

编写Controller类和jsp文件

配置文件编写好了就要开始写对应的类了
首先是Controller类

package com.zx.controller;

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

/**
 * @author ZhangXiong
 * @version v12.0.1
 * @date 2020-03-17
 * 账户web
 */
@Controller
@RequestMapping("/account")
public class AccountController {

    @RequestMapping("/findAll")
    public String findAll(Model model){
        System.out.println("表现层：查询所有的账户信息");
        return "list";
    }
}

然后是jsp文件，先是index.jsp

<%--
  Created by IntelliJ IDEA.
  User: Zhang
  Date: 2020/3/17
  Time: 13:55
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <a href="account/findAll">测试查询</a>
</body>
</html>

然后是表现层执行后要返回的list.jsp界面

<%--
  Created by IntelliJ IDEA.
  User: Zhang
  Date: 2020/3/17
  Time: 13:57
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>执行成功</h3>
</body>
</html>

然后就需要配置tomcat服务器了，运行tomcat得到如下结果，点击测试查询，就会在控制台输出表现层：查询所有的账户信息的信息，并且在浏览器跳转到list页面，出现执行成功的字样，SpringMVC就成功了。
在这里插入图片描述

在这里插入图片描述

整合Spring与SpringMVC

添加监听

Spring整合SpringMVC：启动Tomcat服务器的时候，需要加载Spring的配置文件
项目部署的时候会创建一个ServletContext域对象，且这ServletContext只会创建一次，随着项目创建而创建，结束而结束。所以可以创建一个监听器，一旦tomcat启动了，就加载Spring配置文件。所以需要在web.xml文件中添加监听器，完整的web.xml内容如下。

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
    <display-name>Archetype Created Web Application</display-name>
    <!--配置前端控制器,默认只加载WEB-INF目录下的applicationContext.xml配置文件-->
    <!--为了整合SpringMVC和Spring，使用监听器是为了在servletContext创建的时候加载Spring的配置文件-->
    <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>
    <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>

细心的同学可以注意到，我把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" >

改写成了<?xml version="1.0" encoding="UTF-8"?>，是因为IDEA会把web-app这个标签标红，强迫症看着很不爽啊，但是建议把web.xml文件配置完在将头部改写，因为改写后再添加新元素，根本不会有提示，写起来超不方便。

改写AccountController类，进行测试

在该controller类中添加一个成员变量accountService，对其使用自动注入，然后调用findAll方法

package com.zx.controller;

import com.zx.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @author ZhangXiong
 * @version v12.0.1
 * @date 2020-03-17
 * 账户web
 */
@Controller
@RequestMapping("/account")
public class AccountController {
    @Autowired
    private AccountService accountService;

    @RequestMapping("/findAll")
    public String findAll(Model model){
        System.out.println("表现层：查询所有的账户信息");
        accountService.findAll();
        return "list";
    }
}

运行tomcat，点击测试，在控制台出现表现层、业务层查询账户信息的字样即整合成功
在这里插入图片描述

Mybatis的独立运行

编写SqlMapConfig.xml映射配置文件

因为我使用的是mysql8.0.16版本，所以需要在url中添加?serverTimezone=UTC参数，保证可以连接数据库。

<?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"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///ssm?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--使用的是注解-->
    <mappers>
        <!--使用mapper只能对一个类产生作用-->
        <!--<mapper class="com.zx.dao.AccountDao"/>-->
        <!--该包下的所有dao接口都可以使用-->
        <package name="com.zx.dao"/>
    </mappers>
</configuration>

将AccountDao类改为

package com.zx.dao;

import com.zx.domain.Account;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @author ZhangXiong
 * @version v12.0.1
 * @date 2020-03-17
 * 账户dao接口
 */
@Repository
public interface AccountDao {
    //查询所有账户信息
    @Select("select * from account")
    public List<Account> findAll();

    //保存账户信息
    @Insert("insert into account (name,money) values(#{name},#{money})")
    public void saveAccount(Account account);
}

在test文件夹下创建一个测试文件，当然在测试之前需要在数据库的表中添加记录。比如
在这里插入图片描述

package com.zx.test;


import com.zx.dao.AccountDao;
import com.zx.domain.Account;
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.InputStream;
import java.util.List;

/**
 * @author ZhangXiong
 * @version v12.0.1
 * @date 2020-03-17
 */
public class TestMybatis {

    //测试查询
    @Test
    public void run1() throws Exception {
        //反射的时候出现警告，因为JDK版本过高
        //加载配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession对象
        SqlSession session = factory.openSession();
        //获取代理对象
        AccountDao dao = session.getMapper(AccountDao.class);
        //查询所有账户信息
        List<Account> list = dao.findAll();
        for (Account account : list) {
            System.out.println(account);
        }
        //关闭资源
        session.close();
        in.close();
    }
    //测试保存
    @Test
    public void run2() throws Exception {
        Account account = new Account();
        account.setName("雄");
        account.setMoney(400d);
        //反射的时候出现警告，因为JDK版本过高，至于是什么原因不太清楚
        //加载配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession对象
        SqlSession session = factory.openSession();
        //获取代理对象
        AccountDao dao = session.getMapper(AccountDao.class);
        //保存
        dao.saveAccount(account);
        //提交事务
        session.commit();
        //关闭资源
        session.close();
        in.close();
    }
}

执行测试，成功从数据库读取数据，这里出现了些警告据我所知是因为JDK版本高了，降到1.8就行，不影响。当然还有个保存账户也可以测试，这里就不写了
在这里插入图片描述

整合Spring和Mybatis

整合思路：把 mybatis 配置文件（SqlMapConfig.xml）中内容配置到 spring 配置文件中同时，把 mybatis 配置文件SqlMapConfig.xml删掉。

三步

1.Spring 接管 MyBatis 的 Session 工厂 sqlSessionFactory dataSource
2.配置自动扫描所有 Mapper 接口和文件
3.配置 spring 的事务 tx相关 aop 切入点表达式
完整applicationConfig.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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启注解扫描  只扫描业务层和持久层  即service和dao 不处理controller-->
    <context:component-scan base-package="com.zx">
        <!--配置哪些注解不扫描  完整路径-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--Spring整合MyBatis框架-->
    <!--配置连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///ssm?serverTimezone=UTC"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!--配置SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--配置AccountDao接口所在包-->
    <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.zx.dao"/>
    </bean>
    <!--配置Spring框架声明式事务管理-->
    <!--配置事务管理器 事务需要连接的数据源-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--配置事务通知-->
    <!--对哪些事务进行管理-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!--find*表示以find开头的所有方法，设置只读-->
            <tx:method name="find*" read-only="true"/>
            <!--*表示所有方法，isolation表示隔离级别-->
            <tx:method name="*" isolation="DEFAULT"/>
        </tx:attributes>
    </tx:advice>
    <!--配置AOP增强-->
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.zx.service.impl.*ServiceImpl.*(..))"/>
    </aop:config>

</beans>

测试整合

改写AccountServiceImpl类、增加accountDao成员变量，自动注入，

package com.zx.service.impl;

import com.zx.dao.AccountDao;
import com.zx.domain.Account;
import com.zx.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author ZhangXiong
 * @version v12.0.1
 * @date 2020-03-17
 */
@Service("accountService")
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    @Override
    public List<Account> findAll() {
        System.out.println("业务层：查询所有账户");
        return accountDao.findAll();
    }

    @Override
    public void saveAccount(Account account) {
        System.out.println("业务层，保存账户");
        accountDao.saveAccount(account);
    }
}

改写AccountController类，因为service层真的返回了值，所以需要一个list接收，又要返回给前端页面所以，传入一个Model，添加键值对

package com.zx.controller;

import com.zx.domain.Account;
import com.zx.service.AccountService;
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 ZhangXiong
 * @version v12.0.1
 * @date 2020-03-17
 * 账户web
 */
@Controller
@RequestMapping("/account")
public class AccountController {
    @Autowired
    private AccountService accountService;

    @RequestMapping("/findAll")
    public String findAll(Model model){
        System.out.println("表现层：查询所有的账户信息");
        List<Account> list = accountService.findAll();
        model.addAttribute("list",list);
        return "list";
    }
}

要在浏览器看到返回结果,改写list.jsp

<%--
  Created by IntelliJ IDEA.
  User: Zhang
  Date: 2020/3/17
  Time: 13:57
  To change this template use File | Settings | File Templates.
--%>
<%@ 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>
<h3>查询所有账户信息</h3>
<c:forEach items="${list}" var="account">
    ${account.name}
</c:forEach>
</body>
</html>

随后启动tomcat，点击测试按钮，得到页面返回结果，即整合成功
在这里插入图片描述

SSM整合

将index.jsp改写，添加一个表单，用于测试保存账户

<%--
  Created by IntelliJ IDEA.
  User: Zhang
  Date: 2020/3/17
  Time: 13:55
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <a href="account/findAll">测试查询</a>
    <h3>测试保存</h3>
    <form action="account/save" method="post">
        姓名：<input type="text" name="name"><br/>
        金额：<input type="text" name="money"><br/>
        <input type="submit" value="保存"><br/>
    </form>
</body>
</html>

在AccountController 添加保存方法

package com.zx.controller;

import com.zx.domain.Account;
import com.zx.service.AccountService;
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 javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

/**
 * @author ZhangXiong
 * @version v12.0.1
 * @date 2020-03-17
 * 账户web
 */
@Controller
@RequestMapping("/account")
public class AccountController {
    @Autowired
    private AccountService accountService;

    @RequestMapping("/findAll")
    public String findAll(Model model){
        System.out.println("表现层：查询所有的账户信息");
        List<Account> list = accountService.findAll();
        model.addAttribute("list",list);
        return "list";
    }

    @RequestMapping("/save")
    public void save(Account account, HttpServletRequest request, HttpServletResponse response) throws IOException {
        System.out.println("表现层：保存账户信息");
        accountService.saveAccount(account);
        //重定向，到findAll的方法
        response.sendRedirect(request.getContextPath() + "/account/findAll");
        return;
    }
}

启动Tomcat，在表单填写账户姓名和金额
在这里插入图片描述
点击保存，得到返回结果，至此简单的SSM框架整合完毕

完整结构

在这里插入图片描述

Jcduhdt

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SSM框架简单整合

简单说明对黑马视频讲的简单的SSM框架的整合的整理，很简单，主要是理解三大框架如何结合在一起，jsp就是简单标签，数据库也只有单表。对黑马所讲解的基本没改变，就是添加了一些备注，自己记录一下。使用环境1.JDK：12.0.12.IDEA：2019.1.13.MySql：8.0.164.Tomcat：9.0.315.maven：3.5.2# 创建工程项目结构准备创建Maven工程，...
复制链接

扫一扫

专栏目录