SSM框架下各层的示例分析（详细版）

前言

SSM框架是Spring MVC，Spring和Mybatis框架的整合，是标准的MVC模式。标准的SSM框架有四层，分别是dao层（mapper），service层，controller层和View层。
Spring实现业务对象管理、spring MVC负责请求的转发和视图管理、Mybatis作为数据对象的持久化引擎。
Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。
使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的Spring MVC框架或集成其他MVC开发框架。

框架

通过策略接口，Spring 框架是高度可配置的，而且包含多种视图技术，例如 JavaServer Pages（JSP）技术、Velocity、Tiles、iText和POI。Spring MVC 框架并不知道使用的视图，所以不会强迫开发者只使用 JSP 技术。
Spring MVC 分离了控制器、模型对象、过滤器以及处理程序对象的角色，这种分离让它们更容易进行定制。

优点

Lifecycle for overriding binding, validation, etc，易于同其它View框架（Tiles等）无缝集成，采用IOC便于测试。
它是一个典型的教科书式的MVC构架，而不像struts等都是变种或者不是完全基于MVC系统的框架，对于初学者或者想了解MVC的人来说我觉得Spring是最好的，它的实现就是教科书！它和tapestry一样是一个纯正的Servlet系统，这也是它和Tapestry相比Struts所具有的优势。而且框架本身有代码，看起来容易理解。

单元测试

关于Spring MVC Controller 层的单元测试
测试准备工作：

1、搭建测试Web环境

@RunWith(UnitilsJUnit4TestClassRunner.class)
@SpringApplicationContext({
"classpath:*.xml","file:src/main/webapp/WEB-INF/spring-configuration/*.xml",
"file:src/main/webapp/WEB-INF/*.xml"
})

2、注入Controller 类

@Controller
BeanController controller;

3、编写测试数据

测试数据的文件名一定要与测试类的文件名相同
比如测试数据BeanControllerTest.xml ，测试类 BeanControllerTest。

4、注入测试数据

@Test
@DataSet
public void testBean(){}

一、各层解释说明

用IDEA创建一个maven项目结构,在该项目中,有五个包,分别是controller、dao、entity、service和serviceimpl：

二、SSM中各层作用及关系

SSM框架全称为Spring+SpringMVC+MyBatis，目前比较主流的Java EE企业级框架，适用于搭建各种大型的企业级应用系统
由Spring、MyBatis两个开源框架整合而成（SpringMVC是Spring中的部分内容）。常作为数据源较简单的web项目的框架
SSM = Spring + SpringMVC + Mybatis = (Spring + Mybatis) + SpringMVC
整合说明：SSM整合可以使用多种方式，选择XML+注解的方式

1、整合思路

先搭建整合的环境
先把Spring的配置搭建完成
搭建SpringMVC框架，通过测试搭建无误
再使用Spring整合SpringMVC框架
搭建MyBatis框架，单元测试通过
最后使用Spring整合MyBatis框架

2、SSM框架实现一个web程序主要使用到如下三个技术：

Spring：用到注解和自动装配，就是Spring的两个精髓IOC(反向控制)和 AOP(面向切面编程)。

IOC（控制反转）

它可以装载bean，也是一种降低对象之间耦合关系的设计思想。（比如租房子。以前租房子需要一个房子一个房子找，费时费力，然后现在加入一个房屋中介，把你需要的房型告诉中介，就可以直接选到需要的房子，中介就相当于spring容器。

AOP（面向切面）

是面向对象开发的一种补充，它允许开发人员在不改变原来模型的基础上动态的修改模型以满足新的需求，如：动态的增加日志、安全或异常处理等。AOP使业务逻辑各部分间的耦合度降低，提高程序可重用性，提高开发效率。

横切关注点：从每个方法中抽取出来的同一类非核心业务代码。
切面：封装横切信息点的类，每个关注点体现为一个通知方法。
通知：切面必须要完成的各个具体工作，也就是切面里的一个个方法。
目标：被通知的对象，也就是被通知方法所作用的对象。
代理：像目标对象应用通知之后所创建的代理对象。
连接点：横切关注点在程序代码中的具体体现，对应用程序执行的某个特定位置。（通俗来讲就是一个个的方法）
切入点：切入点就是定位连接点的方式。每个通知上的切入点表达式找到对应的连接点，执行通知之后连接点也就变成了切入点。

SpringMVC：用到了MVC模型，将流程控制代码放到Controller层处理，将业务逻辑代码放到Service层处理。

SpringMVC是一个基于mvc的web框架，它是Spring框架的一个模块，两者无需通过中间整合进行整合。

3、SpringMVC框架的执行步骤

复杂版

1. 用户发送请求至前端控制器DispatcherServlet。
2. 前端控制器DispatcherServlet收到请求调用HandlerMapping处理器映射器。 前端控制器请求处理器映射器查找Handler
3. 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。 处理器映射器向前端控制器返回Handler
4. 前端控制器DispatcherServlet调用处理器适配器去执行HandlerAdapter
5. HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器) 处理器适配器去执行Handler
6. Controller执行完成返回ModelAndView Handler执行完成给适配器返回ModelAndView
7. HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet 处理器适配器向前端控制器返回ModelAndView
   ModelAndView是springmvc框架的一个底层对象，包括Model和View
8. 前端控制器DispatcherServlet将ModelAndView传给ViewReslover视图解析器
   前端控制器请求视图解析器去进行视图解析，根据逻辑图名解析成真正的视图（jsp）
9. 视图解析器ViewReslover解析后向前端控制器返回具体View
10. 前端控制器DispatcherServlet根据View进行视图渲染，视图渲染将模型数据（在ModelAndView对象中）填充到request域
11. 前端控制器DispatcherServlet向用户响应结果

简单版

1. 客户端发送请求到DispacherServlet（分发器）
2. 由DispacherServlet控制器查询HanderMapping，找到处理请求的Controller
3. Controller调用业务逻辑处理后，返回ModelAndView
4. DispacherSerclet查询视图解析器，找到ModelAndView指定的视图
5. 视图负责将结果显示到客户端

Mybatis是对JDBC的封装，它让数据库底层操作变的透明。Mybatis的操作都是围绕一个sqlSessionFactory实例展开的。Mybatis通过配置文件关联到各实体类的Mapper文件，Mapper文件中配置了每个类对数据库所需进行的Sql语句映射。在每次与数据库交互时，通过SqlSessionFactory拿到一个SqlSession，再执行Sql命令。

4、实体层：pojo层/entity层（Model层）（属于SpringMVC模块）

模型层，bean类，逻辑显示方法，查询数据库，即Plain Ordinary Java Object，model是模型的意思。
pojo层是对应的数据库表的实体类，与entity、domain、pojo、bean类似，实体层用于存放我们的实体类，类中定义了多个类属性，并与数据库表的属性值和字段基本保持一致，一张表对应一个model类。
数据库在项目中的类，主要用于定义与数据库对象应的属性，实现set/get方法,tostring方法,有参无参构造函数。

导入lombok驱动依赖,用来生成get/set方法依赖，代码如下（示例）：

package com.dvms.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import lombok.experimental.Accessors;
import java.util.Date;
@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true) //链式调用
public class Emp {
    private String id;
    private String name;
    private Double salary;
    private Integer age;
    private Date bir;
}

传统方式，代码如下（示例）：

package com.umf.entity;
import java.io.Serializable;
public class UpdataSettingEntity implements Serializable {
	private static final long serialVersionUID = 1L;
	//
	private Integer id = 1;
	//
	private int updataflag;
	/**
	 * 设置：
	 */
	public void setId(Integer id) {
		this.id = id;
	}
	/**
	 * 获取：
	 */
	public Integer getId() {
		return id;
	}
	/**
	 * 设置：
	 */
	public void setUpdataflag(int updataflag) {
		this.updataflag = updataflag;
	}
	/**
	 * 获取：
	 */
	public int getUpdataflag() {
		return updataflag;
	}
}

5、持久层：DAO层（mapper层）（属于mybatis模块）

MyBatis是是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架，其主要就完成3件事情：

1. 更加完善的封装JDBC操作
2. 利用反射打通Java类与SQL语句之间的相互转换
3. 采用ORM思想解决实体与数据映射的问题

Dao（Data access object）层，称为数据访问层。具体到对于某个表、某个实体的增删改查。方法名与mapper中id名相同、impl查询数据库又被称为mapper层，叫数据持久层。
数据持久化操作就是指，把数据放到持久化的介质中，同时提供增删改查操作，比如数据通过hibernate插入到数据库中。

DAO层作用

DAO层作用：访问数据库，向数据库发送sql语句，直接操作数据库完成数据的CRUD操作。主要负责与数据库进行交互设计，做数据持久层的工作，用来处理数据的持久化工作，负责与数据库进行联络的一些任务在此封装。

DAO层（接口类）

DAO层（接口类）对数据库进行数据持久化操作，他的方法语句是直接针对数据库操作的，主要实现一些增删改查操作。
在Mybatis中方法主要与xxxDao（Mapper）.xml内相互一一映射。
Mybatis可以用.xml进行数据操作，也可以在dao层用注解的方式，也可以采取xml和dao层接口组合使用的方法（常用）。

1.DAO层的设计首先是设计DAO的接口，配置数据源，也就是项目中你看到的Dao包
2. 在Spring的xml配置文件中定义接口的实现类。进行配置其实现的关联
3. 就可在其他模块中进行接口的调用来进行数据业务的处理(不用关心接口的具体实现类是哪个类)，这里往往用到的就是反射机制，显得结构非常清晰

DAO层的jdbc.properties数据源配置，以及有关数据库连接的参数都在Spring的配置文件中进行配置。

ps:有的项目里面Dao层，写成mapper，当成一个意思理解

代码如下（示例）：

package com.dvms.dao;
import com.dvms.entity.User;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface UserDao {
    //登录
    User login(@Param("username") String username, @Param("password") String password);// 在mybatis中传递多个参数要做参数的绑定
    //新增用户(注册)
    void save(User user);
    //查询所有用户
    List<User> findAlluser();
    //删除用户
    void delete(String id);
    //修改用户信息（先查再改）
    User update(String id);
    void add(User user);
}

xxxDao（Mapper）.xml：
关键：< mapper namespace=“com.dvms.dao.UserDao”>
前提：基本数据库语法

<?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.dvms.dao.UserDao">
<!--注册/新增用户-->
    <insert id="save" parameterType="User">
        insert into user (id,username,password,sex,phone,email,role) values (#{id},#{username},#{password},#{sex},#{phone},#{email},#{role})
    </insert>
<!--登录验证-->
    <select id="login" resultType="User">
        select id,username,password,sex,phone,email,role from user
        where username =#{username} and password =#{password}
    </select>
<!--查询所有用户-->
    <select id="findAlluser" resultType="User">
        select id,username,password,sex,phone,email,role from user
    </select>
<!--删除用户-->
    <delete id="delete" parameterType="String">
        delete from user where id=#{id}
    </delete>
<!--修改用户信息-->
    <!--查到要修改的用户信息-->
    <select id="update" parameterType="String" resultType="User">
        select id,username,password,sex,phone,email,role from user where id=#{id}
    </select>
    <!--修改用户信息-->
    <update id="add" parameterType="User">
        update user set username=#{username},password=#{password},sex=#{sex},phone=#{phone},email=#{email},role=#{role} where id=#{id}
    </update>
</mapper>
在dao层用注解的方式：
public interface StudentDao {
    
    @Select("select * from student where stu_id=#{stuId}")
    public Student queryById(int stuId);
}

6、业务层/服务层：Service层（属于SpringMVC模块）

定义接口、impl–函数进行实现。控制业务,业务模块的逻辑应用设计。针对具体问题的操作，也可以说是对数据层的操作，对数据业务逻辑处理。

1. 封装Service层的业务逻辑有利于通用的业务逻辑的独立性和重复利用性，程序显得非常简洁。
2. Service层里面的方法相较于dao层中的方法进行了一层包装，例如通过id查找用户，通过用户名查找用户，是在基础的操作上又增加了一层包装的，实现的是相对高级的操作，最后将这些操作在ServiceImpl类中实现。

Service层作用

1. 主要负责业务模块的逻辑应用设计，也就是项目中你看到的Service包
2. Service层负责业务模块的逻辑应用设计
3. 主要负责业务模块的逻辑应用设计。可以细分为Service接口和ServiceImpl实现类
4. Service层（接口类）为controller层的类提供接口进行调用,一般就是自己写的方法封装起来，具体实现在ServiceImpl中
5. Service的Impl是把Mapper和Service进行整合的文件 封装Service层的业务逻辑有利于业务逻辑的独立性和重复利用性。

Service层的设计步骤

1. Service层的设计首先是设计接口，再设计其实现的类。也就是项目中你看到的Service+Impl包。
2. 接着再在Spring的xml配置文件中配置其实现的关联(业务逻辑层的实现具体要调用到自己已经定义好的Dao的接口上)。这样我们就可以在应用中调用Service接口来进行业务处理。
3. 每个模型都有一个Service接口，每个接口分别封装各自的业务处理的方法。
4. Service层的业务实现，具体要调用到已定义的DAO层的接口，最后通过调用DAO层已定义的接口，去实现Service具体的实现类。

package com.dvms.service;
import com.dvms.entity.User;
import java.util.List;
public interface UserService {
    //新增用户
    void save(User user);
    //登录
    User login(String username, String password);
    //查询所有用户
    List<User> findAlluser();
    //删除用户
    void delete(String id);
    //修改用户信息
    User update(String id);
    void add(User user);
}

servicedmpl（实现service层，整合service和dao、接口实现类）

package com.dvms.service.Impl;
import com.dvms.dao.UserDao;
import com.dvms.entity.User;
import com.dvms.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.UUID;
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
    @Override
    public void save(User user) {
        user.setId(UUID.randomUUID().toString());
        userDao.save(user);
    }
    @Override
    public User login(String username, String password) {
        return userDao.login(username,password);
    }
    @Override
    public List<User> findAlluser() {
        return userDao.findAlluser();
    }
    @Override
    public void delete(String id) {
        userDao.delete(id);
    }
    @Override
    public User update(String id) {
        return userDao.update(id);
    }
    @Override
    public void add(User user) {
        userDao.add(user);
    }
}

7、View层（属于SpringMVC模块）

视图层—>数据显示–>html—>jsp/php asp

View层作用

主要和控制层紧密结合，负责前台jsp页面的展示，此层需要与Controller层结合起来开发，实现service接口的所有方法，整合service和dao。

Jsp发送请求，controller接收请求，处理，返回，jsp回显数据。

DataBase ====> Entity ====> Mapper.xml ====> Dao.Java ====> Service.java ====> Controller.java ====> html css js（thymeleaf）

8、控制层/表现层：Controller层（Handler层）（属于SpringMVC模块）(web)

控制器Controller一般使用Servlet来实现，处理前台发送的请求。

配置也同样是在Spring的xml配置文件里面进行
针对具体的业务流程，会有不同的控制器。在具体的开发中可以将我们的流程进行抽象的归纳，设计出可以重复利用的子单元流程模块。
通俗讲就是展现给用户的界面，即用户在使用一个系统的时候他的所见所得。

Controller层作用

1. 控制层，控制业务逻辑Service，控制请求和响应，负责前后端交互
2. 负责具体模块的业务流程控制（获取参数（前端传过来）返回响应（前端或数据库或一个指定路径）），需要调用service逻辑设计层的接口来控制业务流程（导入Service层）
3. 主要负责具体的业务模块流程的控制，也就是你看到的Controller包
4. 控制层—实现模型的视图之间的数据交互处理—中间协调作用Servlet
5. 调用Service层里面的接口控制具体的业务流程，控制的配置也要在配置文件中进行

package com.dvms.controller;
import com.dvms.entity.Emp;
.....
@Controller
public class EmpController {
    @Autowired
    private EmpService empService;
    @GetMapping("emp/findAll")
    public String findAll(@RequestParam(defaultValue = "1") int pageNum,
                          @RequestParam(defaultValue = "5") int pageSize,
                          Model model){
        PageHelper.startPage(pageNum,pageSize);//
        PageInfo<Emp> pageInfo = new PageInfo<>(empService.findAll());
        model.addAttribute("pageInfo",pageInfo);
//        List<Emp> emps = empService.findAll();
//        model.addAttribute("emps",emps);
        return "ems/tables";
    }
    @RequestMapping("/emp/save")
    public String save(Emp emp){
        empService.save(emp);
        return "redirect:/emp/findAll";
    }
}

Controller层调用了Service层的接口方法，Service层调用Dao层的方法，其中调用的参数是使用Entity层进行传递的。View层与Controller层协同工作,主要负责界面展示。

9、面向对象——三层架构（表现层、业务层、持久层）

三层架构：即表现层、业务层、持久层。

持久层：采用 DAO 模式，建立实体类和数据库表映射（ORM 映射）。也就是哪个类对应哪个表，哪个属性对应哪个列。持久层的目的就是，完成对象数据和关系数据的转换。

业务层：采用事务脚本模式。将一个业务中所有的操作封装成一个方法，同时保证方法中所有的数据库更新操作，即保证同时成功或同时失败。避免部分成功部分失败引起的数据混乱操作。

表现层：采用 MVC 模式。

M 称为模型，也就是实体类。用于数据的封装和数据的传输。
V 为视图，也就是 GUI 组件，用于数据的展示。
C 为控制，也就是事件，用于流程的控制

业务层接口和持久层接口的设计原则

业务层接口的设计原则：一个实体类一个接口，一次提交一个业务方法。业务方法的参数自表现层。
持久层接口的设计原则：一个实体类一个接口，一次数据库操作一个持久方法。

10、开发项目的时候，需要完成一个功能模块：

1. 先写实体类entity，定义对象的属性，（可以参照数据库中表的字段来设置，数据库的设计应该在所有编码开始之前）。

2. 写Mapper.xml（Mybatis），其中定义你的功能，对应要对数据库进行的那些操作，比如 insert、selectAll、selectByKey、delete、update等。

3. 写Mapper.java/Dao.java，将Mapper.xml中的操作按照id映射成Java函数。实际上就是Dao接口，二者选一即可。

4. 写Service.java，为控制层提供服务，接受控制层的参数，完成相应的功能，并返回给控制层。

5. 写Controller.java，连接页面请求和服务层，获取页面请求的参数，通过自动装配，映射不同的URL到相应的处理函数，并获取参数，对参数进行处理，之后传给服务层。

6. 写JSP页面调用，请求哪些参数，需要获取什么数据。

总结

以上就是今天要讲的内容，本文简单介绍了SSM框架下各层关系，通过SSM框架能使我们快速便捷地开发项目，提高开发效率。文章来源地址https://www.toymoban.com/news/detail-445195.html

到了这里，关于SSM框架下各层的示例分析（详细版）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！