欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

SSM框架解析-springmvc+spring+mybatis

程序员文章站 2022-07-15 11:57:12
...

1、前言

现在用java进行web开发,最主流的框架有SSH和SSM其分别为struts+spring+hibernate和Spring+Springmvc+Mybatis,他们都是经典的MVC框架,对于项目的复用与代码的分离有着不错的效果。相比于SSH,SSM的交互是出于方法上的,比起action更加的灵活,今天我们主要说说SSM。

2、MVC

说起MVC很多人都听过,那SSM,SSH与MVC的关系是怎么样的,mvc是一种软件设计的典范,它主要由模型(model)-视图(view)-控制器(controller)组成,主要实现了对逻辑、视图、数据的分离。这样做的好处就是代码可以实现复用,而且项目也更易于管理与维护,耦合性大大降低,程序员们不用再花太多的精力去组织代码。下面是对MVC的组成部分的介绍:
Model(模型)是应用程序中用于处理应用程序数据逻辑的部分。
  通常模型对象负责在数据库中存取数据。
View(视图)是应用程序中处理数据显示的部分。
  通常视图是依据模型数据创建的。
Controller(控制器)是应用程序中处理用户交互的部分。
  通常控制器负责从视图读取数据,控制用户输入,并向模型发送数据。
在SSM中我们主要分为表示层、业务逻辑层、数据持久层,在对应到MVC中,控制器由Springmvc的controller来承担,视图层主要由jsp来实现,而模型层主要由Mybatis操作数据库表来实现,Spring通过依赖注入管理各层组件。

3、SSM

要理解SSM,我们需要理解组成他们的每一个技术的作用,只有这样三者结合起来才能实现整体的项目构建。下面我们先说Springmvc,再说spring,最后讲解mybatis。

3.1 springmvc

首先我们要明白一点springmvc是实现了一个连接器的作用,它接收来自页面用户的请求,解析参数并传给服务层进行下一步业务逻辑处理,因此它承担了一个中转站的作用,如果你用过servlet那么一定知道用户请求是给到servlet来处理的,在springmvc中用户的请求会全部由DispatcherServlet来进行处理,根据url的不同会分发给不同的controller,与servlet不同,我们在一个controller中可以定义多个方法用于实现一个模块中多个不同的的请求,比如登录注册模块只需要写一个controller,在其下写多个方法,分别来执行登录和注册的请求,这样我们就把对请求的处理细化到了方法上。下面我们用一个小例子来实现一下springmvc
(1)首先新建一个Dynamic web project,我们命名为springmvcTest001,第一步先添加我们需要用到的jar包,如下图所示:

SSM框架解析-springmvc+spring+mybatis
接下来在src下建立包并建立HelloController.java,如下所示:
package com.example;

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

/**
* @author zhaoshaopeng
* @version 创建时间:2017年9月13日 下午2:45:13
* 类说明
*/
@Controller
public class HelloController {
	
	@RequestMapping(value="test1")
	public String test1(){
		System.out.println("test1");
		return "test1";
		
	}
	@RequestMapping(value="test2")
	public String test2(){
		System.out.println("test2");
		return "test2";

	}

}

在上面的代码中出现了@controller和@RequestMapping这两个注解,第一个的意思就是告诉容器目前所标注的类是一个controller,系统将会把当前类加入到DispatcherServlet的候选列表,第二个注解的意思是响应请求的,里面的value内容就是在页面写请求的url。
(2)在WEB-INF文件夹下写我们的springmvc配置文件,Spring-mvc.xml
<beans xmlns="http://www.springframework.org/schema/beans"  
	xmlns:context="http://www.springframework.org/schema/context"  
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
	xmlns:mvc="http://www.springframework.org/schema/mvc"  
	xsi:schemaLocation="    
	http://www.springframework.org/schema/mvc   
	http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd  
	http://www.springframework.org/schema/beans         
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd    
	http://www.springframework.org/schema/context     
	http://www.springframework.org/schema/context/spring-context-3.0.xsd">  
	
	<!-- 把标记了@Controller注解的类转换为bean -->  
	<context:component-scan base-package="com.example" />

	<!-- 启动Spring MVC的注解功能,完成请求和注解POJO的映射 -->  
	<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />  
	<!-- 对模型视图名称的解析,即在模型视图名称添加前后缀 -->  
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"  
		p:prefix="/" p:suffix=".jsp"/>  
	
</beans>  

在配置文件中,首先要扫描我们标注的java文件所在的包,其次还要开启注解功能,最后一个是对页面的映射,当在标注了@RequestMapping的方法中返回了字符串后,首先会在这个地方进行匹配,后缀为.jsp,如果匹配到了就跳转到相应的页面。
接下来,我们得在web.xml中注册我们的springmvc配置文件,如下:
<?xml version="1.0" encoding="UTF-8"?>
<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" id="WebApp_ID" version="3.0">
	<display-name>springmvcTest001</display-name>
	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
	<servlet>
		<servlet-name>applicationContextServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>/WEB-INF/Spring-mvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>applicationContextServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
	<servlet-mapping>
		<servlet-name>default</servlet-name>
		<url-pattern>*.jpg</url-pattern>
	</servlet-mapping>
	<servlet-mapping>
		<servlet-name>default</servlet-name>
		<url-pattern>*.png</url-pattern>
	</servlet-mapping>
	<servlet-mapping>
		<servlet-name>default</servlet-name>
		<url-pattern>*.js</url-pattern>
	</servlet-mapping>
	<servlet-mapping>
		<servlet-name>default</servlet-name>
		<url-pattern>*.css</url-pattern>
	</servlet-mapping>
</web-app>

接下来,再创建三个jsp页面,index.jsp,test1.jsp,test2.jsp,按顺序代码如下:
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
	<a href="/test1">test1</a>
	<a href="/test2">test2</a>
</body>
</html>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
	this is test1!
</body>
</html>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
this is test2!

</body>
</html>

最终实现的就是处理用户请求,并跳转到页面的简单功能。在这里还要注意一点,如果创建的jsp头部有错,那是没有导入包的原因,在buildpath中addlibary,点击server Running 下点击tomcat导入包就可以了。通过这个例子希望能对springmvc有一个认识。

3.2、Spring

说到Spring最熟悉的就是依赖注入和控制反转了,很多不了解的人会觉得很高深,其实实现起来很简单,没有那么神秘。首先我们应该理解这两个词是什么意思。我们拆开来看:
依赖是什么意思,谁依赖谁;
注入什么意思,谁注入谁;
谁控制了谁;
为什么叫反转;
下面解释一下:
依赖就是一个物体依托于一个物体而去完成一件事,这里是应用程序依赖于容器
注入是指把某个东西注入到另一个事务中,这里是Ioc容器注入对象
   Ioc容器控制了对象
   依赖对象的获取被反转了,由主动创建变成了被动接受
这里依赖注入(DI)和控制反转(IOC)是同一事物在不同角度的描述,依赖注入是从对象(应用程序)角度出发的,对象依赖容器创建并注入所需的外部资源;控制反转是从容器角度来说的,容器控制对象,由容器反向向对象中注入所需要的外部资源。下面我们通过一个例子来体会spring的作用。
(1)首先我们创建工程GSpringIOC,并引入相应的包,如下:
SSM框架解析-springmvc+spring+mybatis
(2)接下来创建接口:
package com.ioc.zhujie;
/**
* @author zhaoshaopeng
* @version 创建时间:2017年8月29日 下午4:57:34
* 类说明
*/
public interface IBookDAO {
	
	public String addBook(String bookname);

}

(3)去实现这个接口:
package com.ioc.zhujie;

import org.springframework.stereotype.Component;

/**
* @author zhaoshaopeng
* @version 创建时间:2017年8月29日 下午4:58:23
* 类说明
*/
@Component("bookdaoObj")
public class BookDAO_zhujie implements IBookDAO{

	@Override
	public String addBook(String bookname) {
		// TODO Auto-generated method stub
		return "添加图书"+bookname+"成功!";
	}
	

}

这里@Component("bookdaoObj")注解的作用是将当前类注入到spring容器,名称为bookdaoObj。
(4)下面写一个具体的业务逻辑类
package com.ioc.zhujie;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;

/**
* @author zhaoshaopeng
* @version 创建时间:2017年8月29日 下午5:02:24
* 使用xml实现ioc
*/
@Component
public class BookService_zhujie {
	IBookDAO bookDAO;

	public void storeBook(String bookname){
		 //容器
        ApplicationContext ctx=new ClassPathXmlApplicationContext("IOCBeans02.xml");
        //从容器中获得id为bookdao的bean
        bookDAO=(IBookDAO)ctx.getBean("bookdaoObj");
        System.out.println("图书上货");
        String result=bookDAO.addBook(bookname);
        System.out.println(result);
    }
	

}

这里我们没有去实例化bookDAO,而是在容器中取出。
(5)接下来在WEB-INF下创建spring的配置文件IOCBeans02.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"
    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-4.3.xsd">
        <context:component-scan base-package="com.ioc.zhujie"></context:component-scan>
</beans>

这里写了自动扫描添加了注解的包
(6)最后我们写一个测试类来测试一下
package com.ioc.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ioc.zhujie.BookService_zhujie;

/**
* @author zhaoshaopeng
* @version 创建时间:2017年8月29日 下午5:32:01
* 类说明
*/
public class test_zhujie {
	@org.junit.Test
    public void testStoreBook()
    {
        //容器
        ApplicationContext ctx=new ClassPathXmlApplicationContext("IOCBeans02.xml");
        BookService_zhujie bookservice=ctx.getBean(BookService_zhujie.class);
        bookservice.storeBook("《Spring MVC权威指南 第二版》");
    }

}

通过上面的例子,我们可以看出,通过spring我们的对象不再由类去主动创建,而是通过spring容器来完成,这就减少了类间的耦合度,同时在开发中也通过spring实现对对象外部资源的注入,比如sql操作等。

3.2Mybatis

MyBatis是一个支持普通SQL查询,存储过程和高级映射的优秀持久层框架。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装。MyBatis
可以使用简单的XML或注解用于配置和原始映射,将接口和Java的POJO(Plain Old Java Objects,普通的Java对象)映射成数据库中的记录。
下面用一个例子说明Mybatis的使用。
(1)建立工程,加入包
SSM框架解析-springmvc+spring+mybatis
并创建实体类GAdmin
package com.example.model;

import java.io.Serializable;

/**
* @author zhaoshaopeng
* @version 创建时间:2017年8月21日 下午5:25:58
* 类说明
*/

public class GAdmin implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 2534721862170815266L;
	private int id;
	private String name="";
	private String password="";
	private String sex="";
	private String tel="";
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public String getTel() {
		return tel;
	}
	public void setTel(String tel) {
		this.tel = tel;
	}
	@Override
    public String toString() {
        return "Admin [id=" + id + ", name=" + name + ", password=" + password + "]";
    }

}

(2)创建映射文件admapper.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.example.mapper.admapper">
    <select id="getAdmin" parameterType="int" 
        resultType="com.example.model.GAdmin">
        select * from admin where id=#{id}
    </select>
</mapper>

在这个文件中我们写了一个查询语句,参数为int,输出为一个对象。
(3)创建mybatis配置文件conf.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="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <!-- 配置数据库连接信息 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/gstudb" />
                <property name="username" value="root" />
                <property name="password" value="1234" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/mapper/admapper.xml"/>
    </mappers>
    
</configuration>

在文件中我们配置了连接数据库的信息,并把刚才写的mapper文件加载进来
(4)写一个测试类去测试一下
package com.example.test;

import java.io.InputStream;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import com.example.model.GAdmin;

/**
* @author zhaoshaopeng
* @version 创建时间:2017年9月13日 下午5:25:41
* 类说明
*/

public class test {
	@org.junit.Test
	public void testmybatis(){
		//mybatis的配置文件
        String resource = "conf.xml";
        //使用类加载器加载mybatis的配置文件(它也加载关联的映射文件)
        InputStream is = test.class.getClassLoader().getResourceAsStream(resource);
        //构建sqlSession的工厂
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);     
        SqlSession session = sessionFactory.openSession();
        String statement = "com.example.mapper.admapper.getAdmin";//映射sql的标识字符串
        //执行查询返回一个唯一user对象的sql
        GAdmin user = session.selectOne(statement, 1);
        System.out.println(user.toString());
		
	}

}
最后附上例子的结构图:
SSM框架解析-springmvc+spring+mybatis
由于数据库每个人的情况不同,因此需要自己手动修改才能跑通。

4、结束语

本文通过对MVC的简单梳理,紧接着讲解了springmvc、spring、mybatis的基本用法,在这里并没有进行三者的整合,因此在使用时可能感受并不是那么深刻,但这里讲的都是基本用法,掌握了这些后续的环节才能灵活运用,在后续我也会附上整合的理解,希望大家共同进步!