最详细SSM整合，从0到原理再到实现

一，原理

（1）Spring（对象工厂）：平时开发接触最多的估计就是IOC容器，它可以装载bean（也就是Java中的类，当然也包括service dao里面的），有了这个机制，就不用在每次使用这个类的时候为它初始化，很少看到关键字new。另外spring的aop，事务管理等等都是人们经常用到的。

（2）SpringMVC（视图控制器）：

1）客户端发送请求到DispacherServlet（分发器）；

2）由DispacherServlet（核心servlet）控制器查询HanderMapping，找到处理请求的Controller；

3）Controller层调用业务逻辑处理后，返回ModelAndView；

4）DispacherSerclet查询视图解析器，找到ModelAndView指定的视图；

5）视图负责将结果显示到客户端。

（3）Mybatis（持久层框架）：mybatis是对jdbc的封装，它让数据库底层操作变的透明。mybatis的操作都是围绕一个sqlSessionFactory实例展开的。mybatis通过配置文件关联到各实体类的Mapper文件，Mapper文件中配置了每个类对数据库所需进行的sql语句映射。在每次与数据库交互时，通过sqlSessionFactory拿到一个sqlSession，再执行sql命令。

众所周知，ssm三大框架核心原理：AOP IOC 最后还有个DI

1，AOP 面向切面编程（AOP）提供另外一种角度来思考程序结构，通过这种方式弥补了面向对象编程（OOP）的不足。
除了类（classes）以外，AOP提供了切面。切面对关注点进行模块化，例如横切多个类型和对象的事务管理。Spring的一个关键的组件就是AOP框架，可以自由选择是否使用AOP。
提供声明式企业服务，特别是为了替代EJB声明式服务。最重要的服务是声明性事务管理，这个服务建立在Spring的抽象事物管理之上。
允许用户实现自定义切面，用AOP来完善OOP的使用可以把Spring AOP看作是对Spring的一种增强。
2，IOC IoC不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，所以相较于传统的java servlet需要自己request.getParamiter等需要一系列取值，转换中文，转换值类型的繁琐，更重要的是使得程序的整个体系结构变得非常灵活。
3，DI 依赖注入，是组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态地将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

一.开发的主要流程概括为三大部分：第一个是创建数据库；第二个是在开发环境中创建与数据库对应的接口，业务接口，web接口dao层，service层，controller层；第三是创建配置文件文件xml,properties等

创建数据库和对应的接口层

1.创建数据库，创建表比如account表

2.根据数据库中的表在IDEA中创建com.lzm.domain.account实体类

3.创建com.lzm.mapper.AccountMapper的Dao接口这里是与数据库打交道的接口，这里不用创建相应的实现类是因为可以使用代理的方式来实现，但是需要满足一些条件：后期的AccountMapper.xml文件中的mapper标签的namespace要为com.lzm.mapper.AccountMapper，service里调用的方法名参数也要与AccountMapper接口相同

4.创建com.lzm.service.AccountService接口及com.lzm.service.impl.AccountServiceImpl实现类，这里写业务代码

5.创建com.lzm.controller.AccountController类，主要是与web层对接，返回数据，页面跳转等。

一，基本创建

1.applicationContext.xml---关于spring的bean对象管理的文件，一般用注解开发的话只需要配置包扫描

2.spring-mvc.xml---关于springmvc相关的配置：包扫描；mvc注解驱动；内部资源视图解析器resourceViewResolver；开放静态资源访问权限

前两个是关于spring和springmvc的配置，下面是关于mybatis的配置

3.accountMapper.xml---映射文件，数据库字段与java实体类映射关系，里面主要写sql语句

4.sqlMapConfig.xml---核心配置文件，主要配置别名，环境，加载mapper映射(accountMapper.xml)文件

5.jdbc.properties---数据库相关的配置driver，url，usename，password等

6.web.xml---web相关的配置，spring监听器，springmvc前端控制器，乱码过滤器等

================================================================

1.创建数据库，创建表比如account表

2.创建对应的controller层，service层，dao层，实体类，注意service和mapper交给spring的applicationContext.xml扫描，controll层交给spring-mvc扫描

 3.创建对应的xml文件和properties文件

 

二.上述创建和配置的文件基本搭建好了框架，接下来就是在创建的部分编写对应的代码，这里为了突出重点，以简单的模块不涉及复杂业务，为了能更好理解。

1.数据库中的表创建id，name，money字段

2.Account实体类中的内容，根据数据库中的字段映射，然后生成getter和setter方法

package com.lzm.domain;
 
public class Account {
    private Integer id;
    private String name;
    private Double money;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Double getMoney() {
        return money;
    }
 
    public void setMoney(Double money) {
        this.money = money;
    }
 
    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

3.dao层的AccountMapper接口定义save和findAll方法

package com.lzm.mapper;
 
import com.lzm.domain.Account;
 
import java.util.List;
 
public interface AccoutMapper {
    public void save(Account account);
    public List<Account> findAll();
}

4.service层下的AccountService和AccountServiceImpl编写具体的逻辑代码，这里编写的是mybatis的具体步骤

AccountService接口

package com.lzm.service;
 
import com.lzm.domain.Account;
 
import java.util.List;
 
public interface AccountService {
    public void save(Account account);
 
    public List<Account> findAll();
}

AccountServiceImpl

package com.lzm.service.impl;
 
import com.lzm.domain.Account;
import com.lzm.mapper.AccoutMapper;
import com.lzm.service.AccountService;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.springframework.stereotype.Service;
 
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Override
    public void save(Account account) {
        try{
            InputStream resourseAsStream =  Resources.getResourceAsStream("sqlMapConfig.xml");//加载核心配置文件
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourseAsStream);//创建SqlSessionFactory 
            SqlSession sqlSession = sqlSessionFactory.openSession();//创建sqlsessionfactory
            AccoutMapper mapper = sqlSession.getMapper(AccoutMapper.class);//使用代理的方式
            mapper.save(account);//调用dao中mapper的save方法
            sqlSession.commit();//事务提交 如果openSession(true)则可以自动提交
            sqlSession.close();//关闭资源
        }catch (IOException e){
            e.printStackTrace();
        }
    }
 
    @Override
    public List<Account> findAll() {
        try{
            InputStream resourseAsStream =  Resources.getResourceAsStream("sqlMapConfig.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourseAsStream);
            SqlSession sqlSession = sqlSessionFactory.openSession();
            AccoutMapper mapper = sqlSession.getMapper(AccoutMapper.class);
            List<Account> accountList=mapper.findAll();
            sqlSession.commit();
            sqlSession.close();
            return accountList;
        }catch (IOException e){
            e.printStackTrace();
        }
        return null;
    }
}

5.编写controller层代码

package com.lzm.controller;
 
import com.lzm.domain.Account;
import com.lzm.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
 
import java.util.List;
@Controller//交给spring管理
@RequestMapping("/account")//与客户端的映射地址
public class AccountController {
    @Autowired
    private AccountService accountService;
    //保存
    @RequestMapping("/save")//页面跳转地址
    @ResponseBody//表示只需要回显数据 不进行页面跳转
    public String save(Account account){
        accountService.save(account);
        return "保持成功";
    }
 
    //查询
   // @RequestMapping("/findAll")
    public ModelAndView findAll(){
        List<Account> accountList=accountService.findAll();
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("accountList",accountList);
        modelAndView.setViewName("accountList");
        return modelAndView;
    }
}

二.xml和properties配置文件

1.applicationContext.xml主要进行包扫描配置，管理service和mapper

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 组件扫描 扫描service和mapper-->
    <context:component-scan base-package="com.lzm">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
</beans>

2.spring-mvc.xml文件主要配置组件扫描controller层，mvc注解注册驱动，内部视图资源解析器，开放静态资源

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
 
    <!-- 组件扫描 Controller-->
    <context:component-scan base-package="com.lzm.controller"></context:component-scan>
    <!-- 配置mvc注解驱动-->
    <mvc:annotation-driven></mvc:annotation-driven>
    <!-- 内部资源视图解析器-->
    <bean id="resourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
    <!-- 开放静态资源访问权限-->
    <mvc:default-servlet-handler></mvc:default-servlet-handler>
</beans>

3.accountMapper.xml，mybatis的映射文件，映射数据库中的字段和java实体类，编写sql语句

<?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.lzm.mapper.AccoutMapper">
    <insert id="save" parameterType="account">
        insert into account values (#{id},#{name},#{money})
    </insert>
 
    <select id="findAll" resultType="account">
        select * from account
    </select>
</mapper>

4.sqlMapConfig.xml，mybatis核心配置文件，可以配置类别名，环境，mapper映射文件

<?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>
    <!-- 加载properties文件-->
    <properties resource="jdbc.properties"></properties>
    <!-- 定义别名-->
    <typeAliases>
<!--        <typeAlias type="com.lzm.domain.Account" alias="account"></typeAlias>-->
        <!-- 也可以使用扫包的方式 默认是Account或者account-->
        <package name="com.lzm.domain"></package>
    </typeAliases>
 
    <!-- 环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 加载映射-->
    <mappers>
<!--        <mapper resource="com/lzm/mapper/accountMapper.xml"></mapper>-->
        <!-- 也可以使用扫包的方式-->
        <package name="com.lzm.mapper"></package>
    </mappers>
</configuration>

5.jdbc.properties文件数据库相关的配置

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.username=root
jdbc.password=123456

6.web.xml文件配置spring监听器，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_2_5.xsd" id="WebApp_ID" version="2.5">
 
        <!-- spring监听器-->
        <context-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:applicationContext.xml</param-value>
        </context-param>
        <listener>
                <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
        <!-- springmvc前端控制器-->
        <servlet>
                <servlet-name>DispatcherServlet</servlet-name>
                <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
                <init-param>
                        <param-name>contextConfigLocation</param-name>
                        <param-value>classpath:spring-mvc.xml</param-value>
                </init-param>
                <load-on-startup>1</load-on-startup>
        </servlet>
 
        <servlet-mapping>
                <servlet-name>DispatcherServlet</servlet-name>
                <url-pattern>/</url-pattern>
        </servlet-mapping>
        <!-- 乱码过滤器-->
        <filter>
                <filter-name>CharacterEncodingFilter</filter-name>
                <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
                <init-param>
                        <param-name>encoding</param-name>
                        <param-value>UTF-8</param-value>
                </init-param>
        </filter>
        <filter-mapping>
                <filter-name>CharacterEncodingFilter</filter-name>
                <url-pattern>/*</url-pattern>
        </filter-mapping>
</web-app>

7.log4j日志文件

#
# Hibernate, Relational Persistence for Idiomatic Java
#
# License: GNU Lesser General Public License (LGPL), version 2.1 or later.
# See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
#
 
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
 
### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
 
### set log levels - for more verbose logging change 'info' to 'debug' ###
 
log4j.rootLogger=all, stdout

总体来说开发的具体思路是：创建数据库，创建表，然后在开发环境中创建数据库对应的实体类进行映射，接下来就是创建controller层，service层，dao层，里面编写代码，最后创建各种xml配置文件。其实我创建文件的思路就是根据客户端从发出请求到收到响应的过程创建的，它是这么一个过程，客户端发送请求，通过tomcat服务器，在服务器中进行地址解析，生成request，response对象等操作，交给springmvc的前端控制器DispatchServlet，然后根据前端控制器找到各种handle，返回ModelAndView给DispatchServlet，最后通过视图解析器ViewResolver生成View返回给客户端。这个是spingmvc工作大致流程。

从另外的角度可以这样理解：客户端发送请求给服务器，在controller层接受请求，然后调用service层，service层具体代码会调用dao层的mapper方法，然后dao层访问数据库拿到数据返回，将其封装成java对象返回给service层，在返回给controller层，最后返回给客户端。

巩固加深

一、概述

SpringMVC:视图层，界面层，负责接收请求，显示处理结果
Spring:业务层，管理 Service ，dao，工具类对象
Mybatis:持久层，访问数据库

用户发起请求 — SpringMVC 接收 — Spring中的Service对象 — Mybatis 处理数据

**ssm 整合也叫做ssi，整合中有容器

第一个容器SpringMVC，管理Controller 控制器对象
第二个容器Spring容器，管理Service，Dao，工具类对象等
我们要做的就是吧使用的对象交给合适的容器创建，管理。把Controller还有web开发的相关对象
交给SpringMVC 容器，这些 web 用的对象在SpringMVC 配置中
Service，dao 对象定义在 spring 的配置文件中，让spring 管理这些对象。

SpringMVC 容器和 Spring 容器是有关系的，关系以及确定好了
SpringMVC 容器是 Spring 的子容器，类似java 中的继承。子可以访问父的容器
在子容器中的Controller 可以访问父容器中的 Service 对象，就可以实现Controller 使用Service对象**

二、实现步骤

0. 使用 SpringDB 的 mysql
1. 新建maven web 项目
2. 加入依赖
    ssm 三个框架的依赖，jackson依赖，mysql，druid 连接池
    jsp，servlet
3. 写web.xml 
    1. 注册 DispatcherServlet，目的：1.创建springmvc 容器对象，才能创建Controller 对象，创建的是Servlet才能接受用户请求
    2. 注册spring 监听器：ContextLoaderListener，目的：创建 spring 的容器对象，才能创建 Service dao等对象
    3. 字符集过滤器，解决post 请求乱码问题
4. 创建包，Controller包，Service 包， Dao 包，实体类包
5. 写springmvc，spring，Mybatis 的配置文件

三、配置文件及其代码

1. 首先创建 mysql 表

create table student(
    id int primary key auto_increment,
    name varchar(30) not null ,
    age int not null 
) 

2. 创建好数据库表之后，就在idea 里面创建一个 JavaWeb 项目

将MVC三层构建所对应的包创建好：Controller，dao，service，domain，utils

3. maven 依赖：pom.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.lcx</groupId>
  <artifactId>SSM</artifactId>
  <version>1.0-SNAPSHOT</version>
  <name>SSM</name>
  <packaging>war</packaging>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.source>1.8</maven.compiler.source>
      <junit.version>5.7.1</junit.version>
  </properties>

  <dependencies>
    <dependency>
      <!--      servlet-->
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
      <scope>provided</scope>
    </dependency>                                                                        
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-engine</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
<!--      jsp 依赖-->
      <dependency>
          <groupId>javax.servlet.jsp</groupId>
          <artifactId>jsp-api</artifactId>
          <version>2.2.1-b03</version>
          <scope>provided</scope>
      </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.9</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>
  </dependencies>
  <build>
    <resources>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
  </build>

</project>

4. 在 web.xml 文件中注册中央处理器，spring 监听器，全局过滤器（设置post请求 字符编码为 utf-8）

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--    web.xml 中注册中央调度器-->
    <servlet>
        <servlet-name>MyWeb</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--        初始化参数-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:config/dispatcherServlet.xml</param-value>
        </init-param>
        <!--        设置优先级-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>MyWeb</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

    <!--spring的上下文-->


    <!--    注册 Spring 的监听器 服务器启动就创建 spring 容器-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:config/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!--    注册监听器-->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

5. SpringMVC 配置文件，声明组件扫描器，注解开发支持，以及WEB-INF路径 dispatcherServlet.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: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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!--    SpringMVC 配置文件 -->

<!--    组件扫描器-->
    <context:component-scan base-package="ssm.lcx.controller"/>

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <mvc:annotation-driven/>
<!--
    1. 响应 ajax 请求，返回 json
    2. 解决静态访问资源
-->

</beans>

6. 创建 Spring 配置文件：applicationContext.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: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 https://www.springframework.org/schema/context/spring-context.xsd">
<!--    spring 配置文件 声明 Service dao util-->

<!--    声明数据源，连接数据库-->
    <context:property-placeholder location="classpath:config/jdbc.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.psw}"/>
    </bean>

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

    </bean>

<!--    声明 mybatis 扫描器-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <property name="basePackage" value="ssm.lcx.dao"/>
    </bean>
<!--    Service 所在位置-->
    <context:component-scan base-package="ssm.lcx.service"/>

<!--    事务配置：注解的配置，aspect 的配置-->

</beans>

7. 含有数据库连接信息的 jdbc.properties 文件

# 加上 characterEncoding=utf-8 可以防止乱码错误
jdbc.url=jdbc:mysql://localhost:3306/test?characterEncoding=utf8&useSSL=false&serverTimezone=UTC
jdbc.username=root
jdbc.psw=123

8. mybatis配置文件

<?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>
<!--    实体类的包名-->
    <typeAliases>
        <package name="ssm.lcx.domain"/>
    </typeAliases>

    <mappers>
<!--        使用package 的要求
            1. 文件名和dao 接口必须完全一致
            2. 文件名和接口名称比较一样
-->
        <package name="ssm.lcx.dao"/>
    </mappers>
</configuration>

9. 编写domain（实体类）代码，dao 层代码，service 层代码，Controller 层代码

domain

package ssm.lcx.domain;

import java.util.Objects;

public class Student {
    private Integer id;
    private String name;
    private Integer age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return Objects.equals(getId(), student.getId()) && Objects.equals(getName(), student.getName()) && Objects.equals(getAge(), student.getAge());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getId(), getName(), getAge());
    }

    public Student() {
    }

    public Student(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

dao 接口以及对应的 mybatis—mapper 文件

package ssm.lcx.dao;

import ssm.lcx.domain.Student;

import java.util.List;

public interface StudentDao {
    int insertStudent(Student student);
    List<Student> selectStudent();


}

<?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="ssm.lcx.dao.StudentDao">
    <select id="selectStudent" resultType="ssm.lcx.domain.Student">
        select id,name,age from student order by id
    </select>
    <insert id="insertStudent" parameterType="ssm.lcx.domain.Student">
        insert into student(name,age) value (#{name},#{age})
    </insert>

</mapper>

service 接口和实现类

package ssm.lcx.service;

import ssm.lcx.domain.Student;

import java.util.List;

public interface StudentService {
    int addStudent(Student student);
    List<Student> findStudent();
}

package ssm.lcx.service.impl;

import org.springframework.stereotype.Service;
import ssm.lcx.dao.StudentDao;
import ssm.lcx.domain.Student;
import ssm.lcx.service.StudentService;

import javax.annotation.Resource;
import java.util.List;

@Service
public class StudentServiceImpl implements StudentService {
    // 引用类型的自动注入
    @Resource
    private StudentDao studentDao;
    @Override
    public int addStudent(Student student) {
        int num = studentDao.insertStudent(student);
        return num;
    }

    @Override
    public List<Student> findStudent() {
        List<Student> list = studentDao.selectStudent();
        return list;
    }
}

controller 代码实现

package ssm.lcx.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import ssm.lcx.domain.Student;
import ssm.lcx.service.StudentService;

import javax.annotation.Resource;
import java.util.List;

@Controller
@RequestMapping("/student")
public class StudentController {
    @Resource
    private StudentService service;
    // 注册学生
    @RequestMapping("/addStudent.do")
    public ModelAndView addStudent(Student student){
        String tips = "注册失败";
        ModelAndView mv = new ModelAndView();
        int nums = service.addStudent(student);
        if (nums > 0) {
            // 注册成功
            tips = "学生 " +student.getName()+ " 注册成功";
        }
        mv.addObject("tips",tips);
        mv.setViewName("result");
        return mv;
    }
    // 处理查询，响应 ajax
    @RequestMapping("/queryStudent.do")
    @ResponseBody
    public List<Student> queryStudent(){
        List<Student> students = service.findStudent();
        return students;
    }
}

完工，哦也