SSM资料入门教程：快速掌握Spring、Spring MVC和MyBatis集成-原创手记-慕课网

概述

SSM资料涵盖了Spring、Spring MVC和MyBatis三个框架的集成，提供了强大的企业级Java应用开发解决方案。本文详细介绍了SSM框架的优势、基本架构以及环境搭建的步骤，包括Java开发环境的配置和所需库文件的安装。同时，还探讨了Spring和MyBatis的基础知识，并提供了SSM整合实践和简单的CRUD操作示例。

SSM框架简介

什么是SSM框架

SSM框架是指Spring、Spring MVC和MyBatis这三个框架的集成，其中Spring是核心框架，主要负责依赖注入和控制反转（IoC）；Spring MVC则是Spring提供的一个基于Java的Web框架，简化了Web应用程序的开发；而MyBatis则是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。通过这种组合，SSM能够提供一个完整的、高效的企业级Java应用开发解决方案。

SSM框架的优势

依赖注入和控制反转（IoC）: Spring框架的核心功能之一。依赖注入使代码更加解耦，减少了类间的依赖关系，使得各个组件之间的交互更加灵活。同时，IoC模式也使得测试和维护变得更加容易。
AOP编程: Spring框架支持面向切面编程，提供了事务管理、日志记录等功能。
MVC架构: Spring MVC提供了清晰的MVC架构，有利于开发人员快速构建Web应用。
数据操作: MyBatis可以方便地进行数据库操作，同时提供丰富的映射功能，使得数据库操作更加灵活。

SSM框架的基本架构

Spring: 提供了IoC容器，使得对象之间的依赖关系更加清晰，并且可以方便地进行管理。
Spring MVC: 是Spring框架的一部分，提供了Web MVC框架，负责请求的分发、视图解析等。
MyBatis: 专注于数据操作，提供了强大的SQL映射功能，使得数据库操作更加灵活。

环境搭建

安装Java开发环境

要开始使用SSM框架，首先需要安装Java开发环境。Java开发环境主要包括JDK的安装和配置。以下是安装JDK的步骤：

下载JDK：从Oracle官方网站下载JDK安装包。
安装JDK：根据安装向导进行安装。
配置环境变量：
- 变量名：JAVA_HOME
- 变量值：JDK的安装路径
- PATH：添加%JAVA_HOME%\bin到PATH环境变量中

# 设置JAVA_HOME
set JAVA_HOME=C:\Program Files\Java\jdk-17.0.1
# 添加到PATH
set PATH=%JAVA_HOME%\bin;%PATH%

验证安装：打开命令行窗口，输入java -version，如果显示Java版本，则说明安装成功。

下载和安装所需库文件（Spring、Spring MVC、MyBatis）

下载Spring、Spring MVC和MyBatis的库文件。
将这些库文件添加到项目的ClassPath中。

以下是将库文件添加到IDEA项目中的步骤：

打开IDEA，创建一个新的Java项目。
右键点击项目，选择“Open Module Settings”。
点击“Libraries”标签，点击“+”，选择“Java”，然后选择下载的库文件。
添加完成后，点击“OK”保存设置。

以下是将库文件添加到Eclipse项目中的步骤：

打开Eclipse，创建一个新的Java项目。
在项目中右键点击“Properties”。
点击“Java Build Path”，点击“Libraries”标签，点击“Add Jars”或“Add External Jars”，选择下载的库文件。
添加完成后，点击“OK”保存设置。

配置开发工具（IDEA、Eclipse等）

安装IDEA或Eclipse。
创建一个新的Java项目。
配置项目依赖：
- IDEA：在项目目录下的pom.xml文件中添加相关依赖。
- Eclipse：在项目的“Properties”页面中添加依赖。

以下是IDEA中添加依赖的示例：

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>ssm-tutorial</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.10</version>
        </dependency>
        <!-- Spring MVC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.10</version>
        </dependency>
        <!-- MyBatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
    </dependencies>
</project>

Spring框架基础

Spring框架概述

Spring是一个轻量级的企业级Java开发框架，它提供了IoC容器、AOP编程、事务管理等功能，可以极大地简化Java应用的开发。Spring框架的核心功能是依赖注入（Dependency Injection）和控制反转（Inversion of Control）。Spring框架通过配置文件来管理对象之间的依赖关系，从而降低了各个组件之间的耦合度。

Spring的核心功能和组件介绍

依赖注入（DI）

依赖注入是一种设计模式，它通过将对象的依赖关系从代码中抽取出来，通过配置文件或构造函数来实现依赖关系的注入。这样可以使得代码更加解耦，更加灵活。

public class User {
    private Address address;

    public User(Address address) {
        this.address = address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public Address getAddress() {
        return address;
    }
}

public class Address {
    private String city;
    private String state;

    public Address(String city, String state) {
        this.city = city;
        this.state = state;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getCity() {
        return city;
    }

    public String getState() {
        return state;
    }
}

控制反转（IoC）

控制反转是一种设计模式，它将对象的创建和依赖注入控制权从调用者转移到容器。容器负责管理对象的生命周期和依赖关系，使得代码更加解耦。

public class User {
    private Address address;

    public User(Address address) {
        this.address = address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public Address getAddress() {
        return address;
    }
}

public class Address {
    private String city;
    private String state;

    public Address(String city, String state) {
        this.city = city;
        this.state = state;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getCity() {
        return city;
    }

    public String getState() {
        return state;
    }
}

AOP编程

Spring框架提供了AOP编程的支持，可以方便地进行事务管理、日志记录等功能。

public interface Logger {
    void log(String msg);
}

public class ConsoleLogger implements Logger {
    public void log(String msg) {
        System.out.println("Console Logger: " + msg);
    }
}

public class MyService {
    private Logger logger;

    public MyService(Logger logger) {
        this.logger = logger;
    }

    public void doSomething() {
        logger.log("Doing something...");
    }
}

public class Main {
    public static void main(String[] args) {
        MyService myService = new MyService(new ConsoleLogger());
        myService.doSomething();
    }
}

创建第一个Spring Bean

定义一个简单的Java类。
在Spring配置文件中定义该类为Bean。
创建Spring IoC容器并获取Bean。

public class User {
    private String name;

    public User() {}

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

<bean id="user" class="com.example.User">
    <property name="name" value="John Doe"/>
</bean>

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = (User) context.getBean("user");
        System.out.println(user.getName());
    }
}

Spring MVC基础

Spring MVC的工作流程

Spring MVC的工作流程如下：

客户端发送请求到服务器，服务器将请求转发到Spring DispatcherServlet。
DispatcherServlet调用HandlerMapping处理器映射器，找到处理请求的Controller。
HandlerMapping将请求的URL映射到Handler。
DispatcherServlet调用HandlerAdapter处理器适配器，处理请求。
HandlerAdapter调用对应的处理器（Controller）。
Controller执行业务逻辑处理后，返回ModelAndView对象。
HandlerAdapter将ModelAndView对象返回给DispatcherServlet。
DispatcherServlet调用ViewResolver视图解析器，解析视图。
ViewResolver将逻辑视图解析为物理视图。
DispatcherServlet将模型数据传给视图。
视图负责将模型数据渲染给用户。

创建第一个Spring MVC项目

创建一个Spring MVC项目。
配置Spring MVC相关的配置文件。
创建Controller类处理请求。
创建视图文件。

配置Spring MVC的DispatcherServlet

<web-app>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/dispatcher-servlet.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

创建Controller类

@Controller
public class MyController {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String handleRequest() {
        return "hello";
    }
}

创建视图文件

在WEB-INF目录下创建hello.jsp文件。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello World</title>
</head>
<body>
<h1>Hello World!</h1>
</body>
</html>

处理请求和响应

使用@RequestMapping注解处理请求。
使用@PathVariable注解获取请求参数。
使用@ModelAttribute注解绑定表单数据。
使用@ResponseBody注解返回JSON数据。

@Controller
public class MyController {
    @RequestMapping(value = "/hello/{name}", method = RequestMethod.GET)
    public String handleRequest(@PathVariable String name, Model model) {
        model.addAttribute("name", name);
        return "hello";
    }

    @RequestMapping(value = "/login", method = RequestMethod.POST)
    public String handleLogin(@ModelAttribute LoginForm form, Model model) {
        // 处理登录逻辑
        return "login";
    }

    @RequestMapping(value = "/api/data", method = RequestMethod.GET)
    @ResponseBody
    public Map<String, Object> getData() {
        Map<String, Object> data = new HashMap<>();
        data.put("name", "John Doe");
        data.put("age", 30);
        return data;
    }
}

MyBatis基础

MyBatis框架概述

MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的XML或注解进行配置和原始映射，将接口与数据库表格相关联。

配置MyBatis环境

创建MyBatis配置文件（mybatis-config.xml）。
配置数据源。
配置SqlSessionFactory。

<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/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/UserMapper.xml"/>
    </mappers>
</configuration>

编写MyBatis映射文件

创建映射文件（UserMapper.xml）。
定义SQL语句。
使用<resultMap>标签定义结果映射。
使用<select>标签定义查询语句。

<mapper namespace="com.example.UserMapper">
    <resultMap id="userResultMap" type="com.example.User">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
    </resultMap>

    <select id="selectUser" resultMap="userResultMap">
        SELECT id, name FROM users WHERE id = #{id}
    </select>
</mapper>

SSM整合实践

整合Spring、Spring MVC和MyBatis

创建Spring配置文件（applicationContext.xml）。
配置Spring IoC容器。
配置Spring MVC相关的配置文件（dispatcher-servlet.xml）。
配置MyBatis相关的配置文件（mybatis-config.xml）。
创建Controller类处理请求。
创建Service类进行业务逻辑处理。
创建Mapper接口和映射文件。

配置Spring IoC容器

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="root"/>
    <property name="password" value="password"/>
</bean>

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
</bean>

<bean id="userMapper" class="com.example.mapper.UserMapper"/>

配置Spring MVC

<bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/>
<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/>

<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>
</bean>

<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
    <property name="basename" value="messages"/>
</bean>

配置MyBatis

<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/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/UserMapper.xml"/>
    </mappers>
</configuration>

创建Controller类

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping(value = "/users", method = RequestMethod.GET)
    public ModelAndView getUserList() {
        List<User> users = userService.getAllUsers();
        ModelAndView modelAndView = new ModelAndView("userList");
        modelAndView.addObject("users", users);
        return modelAndView;
    }
}

创建Service类

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public List<User> getAllUsers() {
        return userMapper.getAllUsers();
    }
}

创建Mapper接口

public interface UserMapper {
    List<User> getAllUsers();
}

创建Mapper映射文件

<mapper namespace="com.example.UserMapper">
    <resultMap id="userResultMap" type="com.example.User">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
    </resultMap>

    <select id="getAllUsers" resultMap="userResultMap">
        SELECT id, name FROM users
    </select>
</mapper>

实现简单的CRUD操作

创建用户表（users）。
在Mapper接口中定义CRUD操作。
在Mapper映射文件中定义SQL语句。
在Service类中实现CRUD操作。
在Controller类中调用Service类的方法进行CRUD操作。

创建用户表

CREATE TABLE users (
    id INT PRIMARY KEY,
    name VARCHAR(255)
);

在Mapper接口中定义CRUD操作

public interface UserMapper {
    void insertUser(User user);
    User getUserById(int id);
    void updateUser(User user);
    void deleteUser(int id);
}

在Mapper映射文件中定义SQL语句

<mapper namespace="com.example.UserMapper">
    <resultMap id="userResultMap" type="com.example.User">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
    </resultMap>

    <insert id="insertUser" parameterType="com.example.User">
        INSERT INTO users (id, name) VALUES (#{id}, #{name})
    </insert>

    <select id="getUserById" resultMap="userResultMap" parameterType="int">
        SELECT id, name FROM users WHERE id = #{id}
    </select>

    <update id="updateUser" parameterType="com.example.User">
        UPDATE users SET name = #{name} WHERE id = #{id}
    </update>

    <delete id="deleteUser" parameterType="int">
        DELETE FROM users WHERE id = #{id}
    </delete>
</mapper>

在Service类中实现CRUD操作

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public void insertUser(User user) {
        userMapper.insertUser(user);
    }

    public User getUserById(int id) {
        return userMapper.getUserById(id);
    }

    public void updateUser(User user) {
        userMapper.updateUser(user);
    }

    public void deleteUser(int id) {
        userMapper.deleteUser(id);
    }
}

在Controller类中调用Service类的方法进行CRUD操作

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping(value = "/users", method = RequestMethod.POST)
    public String insertUser(@ModelAttribute User user) {
        userService.insertUser(user);
        return "redirect:/users";
    }

    @RequestMapping(value = "/users/{id}", method = RequestMethod.GET)
    public ModelAndView getUserById(@PathVariable int id) {
        User user = userService.getUserById(id);
        ModelAndView modelAndView = new ModelAndView("user");
        modelAndView.addObject("user", user);
        return modelAndView;
    }

    @RequestMapping(value = "/users/{id}", method = RequestMethod.PUT)
    public String updateUser(@PathVariable int id, @ModelAttribute User user) {
        user.setId(id);
        userService.updateUser(user);
        return "redirect:/users";
    }

    @RequestMapping(value = "/users/{id}", method = RequestMethod.DELETE)
    public String deleteUser(@PathVariable int id) {
        userService.deleteUser(id);
        return "redirect:/users";
    }
}

测试SSM集成项目

将项目部署到Tomcat服务器。
访问项目，测试CRUD操作是否正常。

部署项目到Tomcat服务器

mvn clean install
mvn tomcat7:run

访问项目测试CRUD操作

访问/users，查看用户列表。
访问/users/new，添加新用户。
访问/users/{id}，查看用户详情。
访问/users/{id}/edit，编辑用户信息。
访问/users/{id}/delete，删除用户。

通过以上步骤，可以构建和测试一个完整的SSM集成项目，实现用户信息的CRUD操作。这不仅有助于理解SSM框架的工作原理，也为实际项目开发提供了基础。