SSM框架解析-springmvc+spring+mybatis

最新推荐文章于 2024-06-01 23:06:52 发布

置顶梦在当下

最新推荐文章于 2024-06-01 23:06:52 发布

阅读量2k

点赞数 1

本文链接：https://blog.csdn.net/qq_18463729/article/details/77964822

版权

java web 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

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包，如下图所示：

接下来在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，并引入相应的包，如下：

（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）建立工程，加入包

并创建实体类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());
		
	}

}

最后附上例子的结构图：

由于数据库每个人的情况不同，因此需要自己手动修改才能跑通。

4、结束语

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

梦在当下

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
SSM框架解析-springmvc+spring+mybatis

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

扫一扫