SSM学习：从零开始到初步掌握

SSM学习主要涉及Spring、Spring MVC和MyBatis的整合框架，该框架在Java Web开发中占据重要地位，适用于企业级Web应用和管理后台系统。本文将从零开始介绍SSM框架的基础知识，包括开发环境搭建和各模块的基本教程。

SSM框架是什么

SSM框架是指Spring、Spring MVC和MyBatis的整合框架。它在Java Web开发中占据重要的地位，主要用于处理Web请求、业务逻辑处理以及持久化操作。Spring框架负责整个应用的依赖注入和生命周期管理；Spring MVC负责Web层的请求分发和视图解析；MyBatis则处理持久层的数据库操作。

SSM框架的优势和应用场景

SSM框架的优势主要体现在以下几个方面：

1. 轻量级框架：Spring和MyBatis都是轻量级框架，易于学习和使用，不会增加项目不必要的负担。
2. 依赖注入：Spring的依赖注入特性使得代码松耦合，更容易进行单元测试。
3. 强大的事务管理：Spring提供了强大的事务管理功能，可以方便地进行事务控制。
4. 丰富的AOP功能：Spring的AOP功能可以用于日志记录、安全控制、事务处理等领域。
5. MyBatis的SQL映射：MyBatis的SQL映射功能使得数据库操作更加灵活和强大。

应用场景包括但不限于：

• 企业级Web应用开发
• 管理后台系统
• 数据处理和分析系统

SSM框架的组成部分

SSM框架由以下几个部分组成：

1. Spring：Spring框架提供了依赖注入、AOP功能、事务处理、JDBC模板等功能。
2. Spring MVC：Spring MVC是Spring框架的一个Web应用开发框架，提供了请求处理、视图解析等特性。
3. MyBatis：MyBatis是一个持久层框架，可以方便地进行数据库操作。

安装Java开发环境

1. 安装JDK：下载并安装JDK，JDK版本建议使用Java 8或更高版本。
2. 安装IDE：推荐使用IDEA或Eclipse等IDE，以便更方便地进行代码编写和调试。
3. 配置环境变量：确保环境变量配置正确，包括JAVA_HOME和PATH。

   export JAVA_HOME=/path/to/jdk
   export PATH=$JAVA_HOME/bin:$PATH

安装并配置Spring、Spring MVC和MyBatis

1. 安装Spring：

   • 下载Spring框架的jar包，可以从Spring的官方网站下载。
   • 配置Spring的依赖，通常使用Maven或Gradle进行依赖管理。

2. 安装并配置Spring MVC：

   • Spring MVC是Spring的一部分，下载Spring框架时会包含Spring MVC。
   • 在web.xml中配置Spring MVC的前端控制器DispatcherServlet。
3. 安装并配置MyBatis：
   • 下载MyBatis的jar包，可以从MyBatis的官方网站下载。
   • 配置MyBatis的SQL映射文件和配置文件。

导入并配置SSM相关依赖

使用Maven进行依赖配置：

<dependencies>
    <!-- Spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</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>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.23</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>javax.servlet.jsp-api</artifactId>
        <version>2.3.3</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp.jstl</groupId>
        <artifactId>javax.servlet.jsp.jstl-api</artifactId>
        <version>1.2.1</version>
    </dependency>
    <dependency>
        <groupId>taglibs</groupId>
        <artifactId>standard</artifactId>
        <version>1.1.2</version>
    </dependency>
</dependencies>

Spring核心概念介绍

Spring框架的核心概念包括依赖注入（DI）、控制反转（IoC）和AOP（面向切面编程）。

1. 依赖注入（DI）：通过外部配置将依赖的实例传递给需要的对象，而不是对象自己创建依赖实例。
2. 控制反转（IoC）：容器控制对象的生命周期和依赖关系，而不是由对象自己管理。
3. 面向切面编程（AOP）：将横切关注点（如日志记录、事务管理）织入到业务逻辑中。

Bean的定义和管理

Bean的定义

在Spring配置文件中定义Bean，如下示例：

<bean id="exampleBean" class="com.example.ExampleBean">
    <property name="exampleProperty" value="exampleValue"/>
</bean>

Bean的管理

通过Spring的IoC容器管理Bean的生命周期和依赖关系。IoC容器负责创建和管理Bean的实例。

public class ExampleBean {
    private String exampleProperty;

    public String getExampleProperty() {
        return exampleProperty;
    }

    public void setExampleProperty(String exampleProperty) {
        this.exampleProperty = exampleProperty;
    }
}

IoC容器的使用

创建一个简单的Spring应用程序，使用IoC容器管理Bean。

<beans xmlns="http://www.springframework.org/schema/beans"
       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">

    <bean id="exampleBean" class="com.example.ExampleBean">
        <property name="exampleProperty" value="exampleValue"/>
    </bean>

</beans>

使用Java代码访问IoC容器：

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
ExampleBean exampleBean = (ExampleBean) context.getBean("exampleBean");
System.out.println(exampleBean.getExampleProperty());

Spring MVC的基本概念

Spring MVC是一个基于Java的Web框架，用于构建Web应用。它通过请求-响应模型处理HTTP请求。Spring MVC的主要组件包括DispatcherServlet、HandlerMapping、Controller、ViewResolver等。

1. DispatcherServlet：前端控制器，处理所有HTTP请求。
2. HandlerMapping：负责查找处理请求的Controller。
3. Controller：处理业务逻辑，响应请求。
4. ViewResolver：解析视图，将请求转发到适当的视图。

Controller的创建与配置

创建一个简单的Controller，处理HTTP GET请求。

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

@Controller
public class ExampleController {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String sayHello(ModelMap modelMap) {
        modelMap.addAttribute("message", "Hello World");
        return "hello";
    }
}

请求处理方法和视图解析器

请求处理方法

使用@RequestMapping注解来映射HTTP请求到Controller的方法。

@RequestMapping(value = "/hello", method = RequestMethod.GET)
public String sayHello(ModelMap modelMap) {
    modelMap.addAttribute("message", "Hello World");
    return "hello";
}

视图解析器

配置视图解析器，解析视图路径。

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

MyBatis的入门知识

MyBatis是一个持久层框架，用于处理数据库操作。它通过SQL映射文件将Java代码和SQL语句关联起来，使得数据库操作更加灵活和强大。

简单的CRUD操作

<mapper namespace="com.example.mapper.ExampleMapper">
    <select id="selectExample" resultType="com.example.Example">
        SELECT * FROM example WHERE id = #{id}
    </select>
</mapper>

使用Mapper XML文件操作数据库

创建一个简单的Mapper XML文件，定义SQL语句，例如：

<configuration>
    <mappers>
        <mapper resource="com/example/mapper/ExampleMapper.xml"/>
    </mappers>
</configuration>

MyBatis与Spring整合

使用Spring的SqlSessionFactoryBean创建SqlSessionFactory。

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

创建DataSource。

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <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>

通过MapperScannerConfigurer自动扫描Mapper接口。

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.mapper"/>
</bean>

创建SSM整合的项目结构

项目目录结构如下：

src/
└── main/
    ├── java/
    │   └── com/
    │       └── example/
    │           ├── controller/
    │           ├── dao/
    │           └── service/
    └── resources/
        ├── applicationContext.xml
        ├── mybatis-config.xml
        └── dispatcher-servlet.xml

Spring配置文件详解

applicationContext.xml

定义Spring的Bean。

<beans xmlns="http://www.springframework.org/schema/beans"
       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">

    <bean id="exampleBean" class="com.example.ExampleBean">
        <property name="exampleProperty" value="exampleValue"/>
    </bean>
</beans>

dispatcher-servlet.xml

配置Spring MVC。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="com.example.controller"/>

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

实战案例：增删改查操作

创建一个简单的Mapper接口

package com.example.mapper;

import com.example.entity.Example;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface ExampleMapper {
    @Select("SELECT * FROM example WHERE id = #{id}")
    Example selectExampleById(int id);

    @Insert("INSERT INTO example (name, age) VALUES (#{name}, #{age})")
    void insertExample(Example example);

    @Update("UPDATE example SET name = #{name}, age = #{age} WHERE id = #{id}")
    void updateExample(Example example);

    @Delete("DELETE FROM example WHERE id = #{id}")
    void deleteExample(int id);

    @Select("SELECT * FROM example")
    List<Example> selectAllExamples();
}

实现Mapper接口

<mapper namespace="com.example.mapper.ExampleMapper">
    <select id="selectExampleById" resultType="com.example.entity.Example">
        SELECT * FROM example WHERE id = #{id}
    </select>

    <insert id="insertExample">
        INSERT INTO example (name, age) VALUES (#{name}, #{age})
    </insert>

    <update id="updateExample">
        UPDATE example SET name = #{name}, age = #{age} WHERE id = #{id}
    </update>

    <delete id="deleteExample">
        DELETE FROM example WHERE id = #{id}
    </delete>

    <select id="selectAllExamples" resultType="com.example.entity.Example">
        SELECT * FROM example
    </select>
</mapper>

创建DAO和Service层

package com.example.dao;

import com.example.entity.Example;
import com.example.mapper.ExampleMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ExampleService {
    @Autowired
    private ExampleMapper exampleMapper;

    public Example selectExampleById(int id) {
        return exampleMapper.selectExampleById(id);
    }

    public void insertExample(Example example) {
        exampleMapper.insertExample(example);
    }

    public void updateExample(Example example) {
        exampleMapper.updateExample(example);
    }

    public void deleteExample(int id) {
        exampleMapper.deleteExample(id);
    }

    public List<Example> selectAllExamples() {
        return exampleMapper.selectAllExamples();
    }
}

创建Controller层

package com.example.controller;

import com.example.entity.Example;
import com.example.service.ExampleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
public class ExampleController {
    @Autowired
    private ExampleService exampleService;

    @GetMapping("/example/{id}")
    public Example getExampleById(@PathVariable int id) {
        return exampleService.selectExampleById(id);
    }

    @PostMapping("/example")
    public void insertExample(@RequestBody Example example) {
        exampleService.insertExample(example);
    }

    @PutMapping("/example")
    public void updateExample(@RequestBody Example example) {
        exampleService.updateExample(example);
    }

    @DeleteMapping("/example/{id}")
    public void deleteExample(@PathVariable int id) {
        exampleService.deleteExample(id);
    }

    @GetMapping("/examples")
    public List<Example> getAllExamples() {
        return exampleService.selectAllExamples();
    }
}

总结

通过以上步骤，我们完成了SSM框架的开发环境搭建、Spring和Spring MVC的基础教程、MyBatis的基础教程以及SSM整合实践。希望本教程能够帮助你从零开始掌握SSM框架，并能够进行简单的Web应用开发。更多深入的学习和实践可以参考M慕课网。