SSM教程：从入门到实践详解

本文详细介绍了Spring、Spring MVC和MyBatis这三个框架的整合，旨在提供企业级开发解决方案。文章涵盖了框架的组成、优势和应用场景，并指导如何搭建开发环境、配置Spring和Spring MVC以及操作数据库。

SSM框架简介

SSM框架是由Spring、Spring MVC和MyBatis三个技术框架整合而成，旨在提供一个高效、稳定且易于维护的企业级开发解决方案。Spring框架主要负责依赖注入和控制反转（IoC），Spring MVC框架提供基于MVC模式的Web应用开发支持，而MyBatis则专注于数据持久层的开发。

框架组成

1. Spring框架：Spring框架的核心功能是依赖注入（DI）和控制反转（IoC），它通过配置Bean之间的依赖关系来简化Java应用的开发。Spring还提供了一系列的企业级服务，如事务管理、邮件服务、定时任务等。
2. Spring MVC框架：Spring MVC是一个基于Model-View-Controller模式的Web应用开发框架，它通过DispatcherServlet来处理HTTP请求，提供了一种统一的机制来处理Web请求和响应。
3. MyBatis框架：MyBatis是一个持久层框架，它通过XML配置文件或注解来映射SQL语句到Java对象。MyBatis提供了强大的动态SQL功能，支持复杂的数据查询和更新操作。

SSM框架的优势和应用场景

1. 解耦性强：通过Spring框架的依赖注入功能，可以将系统中的不同模块解耦，提高了模块的独立性和可维护性。
2. 易用性和扩展性：Spring MVC提供了一套标准的Web应用开发规范，使得开发人员能够快速上手。同时，Spring的AOP功能可以方便地进行日志记录、权限控制等。
3. 高性能和灵活性：MyBatis提供了灵活的SQL映射方式，支持自定义查询，大大提高了应用的性能和灵活性。
4. 广泛使用：SSM框架因其高效、稳定和易维护的特点，在企业级应用开发中被广泛使用，特别是在需要与数据库进行频繁交互的应用中。

开发环境搭建

开发工具选择

常用的Java开发工具包括IDEA、Eclipse和STS（Spring Tool Suite）。其中IDEA和Eclipse是最受欢迎的选择。IDEA提供了强大的代码分析和重构功能，而Eclipse则有更丰富的插件支持。

搭建Java开发环境

1. 安装JDK：首先下载并安装最新版本的JDK，确保安装完成后配置环境变量。
2. 配置环境变量：
   • 设置JAVA_HOME为JDK安装路径；
   • 将%JAVA_HOME%\bin添加到PATH环境变量中。
3. 验证安装：通过命令行输入java -version，确保能正确显示Java版本信息。

引入SSM框架所需依赖库

1. 添加Spring依赖：在项目的pom.xml文件中，添加Spring核心和Spring MVC的依赖。

   <dependencies>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-core</artifactId>
           <version>5.3.10</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-webmvc</artifactId>
           <version>5.3.10</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-tx</artifactId>
           <version>5.3.10</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-jdbc</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>
   </dependencies>

2. 添加MyBatis依赖：同样在pom.xml文件中添加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>

3. 配置数据库连接：在resources目录下创建一个application.properties文件，配置数据库连接信息。

   spring.datasource.url=jdbc:mysql://localhost:3306/ssm
   spring.datasource.username=root
   spring.datasource.password=root
   spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

Spring基础配置

Spring核心配置文件的编写

Spring的核心配置文件通常是一个XML文件，用于定义和配置Bean。在resources目录下创建一个名为applicationContext.xml的文件。

<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 -->
    <bean id="myBean" class="com.example.demo.MyBean">
        <property name="property1" value="value1"/>
        <property name="property2" value="value2"/>
    </bean>
</beans>

IoC容器的使用

IoC（Inversion of Control）是一种软件设计模式，它将对象的创建和依赖管理交给外部容器，从而实现控制反转。Spring的IoC容器负责创建和管理Bean的生命周期。

Bean的定义与管理

1. Bean的定义：在applicationContext.xml文件中定义一个Bean。

   <bean id="myBean" class="com.example.demo.MyBean">
       <property name="property1" value="value1"/>
       <property name="property2" value="value2"/>
   </bean>

2. Bean的管理：通过Spring容器获取Bean。

   import org.springframework.context.ApplicationContext;
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   
   public class BeanManagementExample {
       public static void main(String[] args) {
           ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
           MyBean myBean = (MyBean) context.getBean("myBean");
           System.out.println(myBean.getProperty1());
           System.out.println(myBean.getProperty2());
       }
   }

Spring MVC配置与使用

DispatcherServlet配置

DispatcherServlet是Spring MVC中的一个核心组件，负责处理所有的HTTP请求。需要在web.xml中配置DispatcherServlet。

<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/spring/dispatcher-servlet.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

Controller的创建与使用

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

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

@Controller
public class MyController {

    @RequestMapping("/hello")
    @ResponseBody
    public String hello() {
        return "Hello, Spring MVC!";
    }
}

常见注解解析

1. @RequestMapping：用于映射HTTP请求到控制器的方法。
2. @Controller：用于标记一个类为Spring MVC的控制器。
3. @ResponseBody：用于标记方法的返回值直接写入HTTP响应体。

MyBatis操作数据库

MyBatis核心配置文件编写

MyBatis的核心配置文件通常位于resources目录下，名为mybatis-config.xml。

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/demo/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

SQL映射文件配置

在resources目录下创建一个UserMapper.xml文件，定义SQL语句和映射。

<mapper namespace="com.example.demo.mapper.UserMapper">
    <select id="selectUser" resultType="com.example.demo.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
    <insert id="insertUser">
        INSERT INTO users (id, name, email) VALUES (#{id}, #{name}, #{email})
    </insert>
    <update id="updateUser">
        UPDATE users SET name=#{name}, email=#{email} WHERE id=#{id}
    </update>
    <delete id="deleteUser">
        DELETE FROM users WHERE id=#{id}
    </delete>
</mapper>

CRUD操作实例

1. 创建操作：

   import org.apache.ibatis.session.SqlSession;
   import org.apache.ibatis.session.SqlSessionFactory;
   import org.apache.ibatis.session.SqlSessionFactoryBuilder;
   
   public class UserMapperTest {
       public static void main(String[] args) {
           SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config.xml"));
           try (SqlSession session = factory.openSession()) {
               UserMapper mapper = session.getMapper(UserMapper.class);
               User user = new User(1, "John Doe", "john.doe@example.com");
               mapper.insertUser(user);
               session.commit();
           }
       }
   }

2. 查询操作：

   import org.apache.ibatis.session.SqlSession;
   import org.apache.ibatis.session.SqlSessionFactory;
   import org.apache.ibatis.session.SqlSessionFactoryBuilder;
   
   public class UserMapperTest {
       public static void main(String[] args) {
           SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config.xml"));
           try (SqlSession session = factory.openSession()) {
               UserMapper mapper = session.getMapper(UserMapper.class);
               User user = mapper.selectUser(1);
               System.out.println(user);
           }
       }
   }

3. 更新操作：

   import org.apache.ibatis.session.SqlSession;
   import org.apache.ibatis.session.SqlSessionFactory;
   import org.apache.ibatis.session.SqlSessionFactoryBuilder;
   
   public class UserMapperTest {
       public static void main(String[] args) {
           SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config.xml"));
           try (SqlSession session = factory.openSession()) {
               UserMapper mapper = session.getMapper(UserMapper.class);
               User user = new User(1, "Jane Doe", "jane.doe@example.com");
               mapper.updateUser(user);
               session.commit();
           }
       }
   }

4. 删除操作：

   import org.apache.ibatis.session.SqlSession;
   import org.apache.ibatis.session.SqlSessionFactory;
   import org.apache.ibatis.session.SqlSessionFactoryBuilder;
   
   public class UserMapperTest {
       public static void main(String[] args) {
           SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config.xml"));
           try (SqlSession session = factory.openSession()) {
               UserMapper mapper = session.getMapper(UserMapper.class);
               mapper.deleteUser(1);
               session.commit();
           }
       }
   }

整合SSM框架

Spring与Spring MVC的整合

在applicationContext.xml文件中配置Spring MVC的Bean。

<bean id="myController" class="com.example.demo.controller.MyController"/>
<bean id="myService" class="com.example.demo.service.MyService"/>
<bean id="myMapper" class="com.example.demo.mapper.MyMapper"/>

Spring与MyBatis的整合

在applicationContext.xml文件中配置MyBatis的SqlSessionFactory。

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

实战案例：简单CRUD应用

1. 创建数据模型：

   public class User {
       private int id;
       private String name;
       private String email;
   
       // Getter and Setter methods
   }

2. 创建Mapper接口：

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

3. 创建Service层：

   public class UserService {
       private UserMapper userMapper;
   
       public UserService(UserMapper userMapper) {
           this.userMapper = userMapper;
       }
   
       public User getUserById(int id) {
           return userMapper.selectUser(id);
       }
   
       public void addUser(User user) {
           userMapper.insertUser(user);
       }
   
       public void updateUser(User user) {
           userMapper.updateUser(user);
       }
   
       public void deleteUser(int id) {
           userMapper.deleteUser(id);
       }
   }

4. 创建Controller层：

   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Controller;
   import org.springframework.web.bind.annotation.*;
   
   @Controller
   public class UserController {
   
       @Autowired
       private UserService userService;
   
       @GetMapping("/users/{id}")
       @ResponseBody
       public User getUser(@PathVariable int id) {
           return userService.getUserById(id);
       }
   
       @PostMapping("/users")
       @ResponseBody
       public void addUser(@RequestBody User user) {
           userService.addUser(user);
       }
   
       @PutMapping("/users")
       @ResponseBody
       public void updateUser(@RequestBody User user) {
           userService.updateUser(user);
       }
   
       @DeleteMapping("/users/{id}")
       @ResponseBody
       public void deleteUser(@PathVariable int id) {
           userService.deleteUser(id);
       }
   }

通过以上步骤，你已经成功搭建了一个基于SSM框架的简单CRUD应用。这个应用包括了基本的增删改查操作，并且通过Spring、Spring MVC和MyBatis的整合，实现了高效和灵活的数据处理能力。