SSM框架简单讲解,内含代码加注释,详细

新城已无旧少年_

已于 2022-10-26 15:46:37 修改

阅读量3.1k

点赞数 12

分类专栏： ssm 文章标签： java mybatis spring

于 2022-10-26 11:57:37 首次发布

本文链接：https://blog.csdn.net/qq_59002046/article/details/127526751

版权

ssm 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

前言：

虽然现在的ssm市面上大多数公司已经不用了，除了一些个别公司的老项目还再用，甚至有的项目还在用ssh这种更古老的框架，但是我们要想学习更高级的框架比如springboot那么ssm肯定是要学的，学到ssm的同学肯定是把javaee（javaweb）学完的了，这应该也是我们接触的第一个框架，所以什么是框架？

我们学完javaee+jsp就可以写一个简陋的网页了，但是你有没有发现你的代码及其的冗余，举个简单例子那么连接数据库的时候的jdbc是不是每次方法调用的时候都要去写，可能有人会说了那你不会把它写到一个方法里面去吗减少冗余不就好了，想法很好后面的mybatis就为我们封装好了，好了废话不多说了大家先看看框架定义：

框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法;另一种认为，框架是可被应用开发者定制的应用骨架、模板。简单的说，框架其实是半成品软件，就是一组组件，供你使用完成你自己的系统。从另一个角度来说框架一个舞台，你在舞台上做表演。在框架基础上加入你要完成的功能。框架安全的，可复用的，不断升级的软件。

首先ssm其实通俗来讲就是spring+springmvc+mybatis，利用其整合起来的效果来进行项目软件开发，那么说到项目开发我们就不得不提到三层架构了

三层架构：

三层架构包含的三层：

界面层（User Interface layer）、业务逻辑层（Business Logic Layer）、数据访问层（Data access layer）

三层的职责：

界面层（表示层，视图层） :主要功能是接受用户的数据，显示请求的处理结果。使用 web 页面和用户交互，手机 app 也就是表示层的，用户在 app 中操作，业务逻辑在服务器端处理。
业务逻辑层：接收表示传递过来的数据，检查数据，计算业务逻辑，调用数据访问层获取数据。
数据访问层：与数据库打交道。主要实现对数据的增、删、改、查。将存储在数据库中的数据提交给业务层，同时将业务层处理的数据保存到数据库.

那么为什么要构成三层架构呢？

结构清晰、耦合度低, 各层分工明确
可维护性高，可扩展性高
有利于标准化
开发人员可以只关注整个结构中的其中某一层的功能实现
有利于各层逻辑的复用

其次我们来解析一下ssm到底是什么：

首先是mybatis：

MyBatis 是一个优秀的基于 java 的持久层框架，内部封装了 jdbc，开发者只需要关注 sql 语句本身，而不需要处理加载驱动、创建连接、创建 statement、关闭连接，资源等繁杂的过程。

MyBatis 通过 xml 或注解两种方式将要执行的各种 sql 语句配置起来，并通过 java 对象和 sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并返回。

其次是Spring：

Spring 框架为了解决软件开发的复杂性而创建的。Spring 使用的是基本的 JavaBean 来完成以前非常复杂的企业级开发。Spring 解决了业务对象，功能模块之间的耦合，不仅在 javase,web 中使用，大部分 Java 应用都可以从 Spring 中受益。

Spring 是一个轻量级控制反转(IoC)和面向切面(AOP)的容器。

再下来是springmvc：

Spring MVC 属于 SpringFrameWork 3.0 版本加入的一个模块，为 Spring 框架提供了构建 Web 应用程序的能力。现在可以 Spring 框架提供的 SpringMVC 模块实现 web 应用开发，在 web 项目中可以无缝使用 Spring 和 Spring MVC 框架。

到这里呢其实我们就已经大概了解了ssm的工作过程，正常你去学ssm开始都是这样，先给你介绍ssm是什么？什么是三大框架？三层架构又是什么？所以下面我们深入来了解一下什么ssm！！！

mybatis：

我们先来回顾一下jdbc的连接过程：

//假设我们数据库有student这张表我们现在查询里面的数据
public void Student() {

    Connection conn = null; 
    Statement stmt = null;       //或者防止sql注入的PreparedStatement
    ResultSet rs = null;

    try {
    //注册 mysql 驱动，这里根据版本不同mysql5.6之后中间要加cj 
      Class.forName("com.mysql.jdbc.Driver");

    //连接数据的基本信息 url ，username，password

    String url = "jdbc:mysql://localhost:3306/...."; 
    String username = "***";
    String password = "***";

    //创建连接对象 
    conn = DriverManager.getConnection(url, username, password);

    //保存查询结果 
    List<Student> stuList = new ArrayList<>();

    //创建 Statement, 用来执行 sql 语句 
    stmt = conn.createStatement();

    //这里我们执行查询，创建记录集， 
    rs = stmt.executeQuery("select * from student");

    while (rs.next()) {

        Student stu = new Student();
 
        stu.setId(rs.getInt("id"));
        stu.setName(rs.getString("name"));
        stu.setAge(rs.getInt("age"));

        //从数据库取出数据转为 Student 对象，封装到 List 集合
        stuList.add(stu);
    }

    }catch(Exception e){
          e.printStackTrace();
    }finally{

    //这里关闭流防止资源泄露
    try{
        if(rs != null)
           rs.lose();
        if(pstm != null)
           pstm.close();
        if(con != null)
           con.close();
        
    }catch(Exception e){
      e.printStackTrace();
    }

}

所以缺点还是很明显的：

1. 代码比较多，开发效率低

2. 需要关注 Connection ,Statement, ResultSet 对象创建和销毁

3. 对 ResultSet 查询的结果，需要自己封装为 List

4. 重复的代码比较多些（当然了你可以包装一个方法）

5. 业务代码和数据库的操作混在一起（不好看）

那么mybatis到底是怎么做的？

减轻使用 JDBC 的复杂性，不用编写重复的创建 Connetion , Statement ; 不用编写关闭资源代码。直接使用 java 对象，表示结果数据。让开发者专注 SQL的处理。其他分心的工作由 MyBatis 代劳。

那我们要怎么实现mybatis呢？我们这里使用的是idea，首先我们的需要会使用maven（简化jar包的配置，我们就不用想jdbc那样去引入jar包了，maven可以直接从仓库引，没有的话配置阿里的镜像下载也很快的），不会用的朋友可以先去学一下使用，很简单的，配置好仓库后，就可以用了。

首先我们创建一个新的project命名随便起一个，我们打开这个project后就去创建一个普通maven项目，就像这样：

1.创建好之后我们进入pom.xml把build里面的依赖可以删了，因为那里面的依赖删不删都一样看着不顺眼就删了，然后我们在dependencies里面导入mybatis需要的依赖就可以了：

<!--添加MyBatis框架的依赖-->

<!--maven爆红的话，刷新maven即可，一般爆红就是仓库里面没有，刷新下载一下即可-->

<dependency>

<groupId>org.mybatis</groupId>

<artifactId>mybatis</artifactId>

<version>3.5.6</version>      <!--这里面的版本根据自己选择即可，可以去官网查看-->

</dependency>

<!--添加mysql依赖-->



<dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>  

<version>5.1.32</version>

</dependency>

然后我们另其一行加上bulid，不加的话xml文件会扫描不到

<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>       <!--**表示所有目录，*.表示所有文件-->
<include>**/*.properties</include>
</includes>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.xml</include>
<include>**/*.properties</include>
</includes>
</resource>
</resources>
</build>

为了方便使用我们可以直接连接idea里面官方自己带的数据库：

然后输入自己的账号密码和需要连接的数据库，先点击下面的Test Connection进行连接测试，如果通过就可以连接了。

连接之后就是这样了，我们双击里面的表就可以在idea里面看到数据了。

然后我们先创建我们的pojo层，也就是数据层，student的映射类，注意这里面的命名的名字要和我们数据库里面的名字一致要不然后面还得改比较麻烦，set，get，有参无参，tostring方便我们后期打印数据观看：

package mybatis_001.pojo;

public class Student {
    private String id;
    private String sname;
    private String sex;
    private String age;

    public Student(String id, String sname, String sex, String age) {
        this.id = id;
        this.sname = sname;
        this.sex = sex;
        this.age = age;
    }

    public Student(String sname, String sex, String age) {
        this.sname = sname;
        this.sex = sex;
        this.age = age;
    }

    public String getId() {
        return id;
    }

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

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "student{" +
                "id='" + id + '\'' +
                ", sname='" + sname + '\'' +
                ", sex='" + sex + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
}

2.在src/main目录下面创建resources文件（并且带有文件标识不是普通的resources文件（如果已经有的就可以不用创建了）

然后再这个文件下面去创建jdbc.properties（properties前面的jdbc可以随便起）配置文件，mysql版本再5.6以上的需要咋driverclassname中间加上cj，然后url如果不行的话加上时区试试

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf8
jdbc.username=***
jdbc.password=***

然后我们写mapper.xml起名字叫StudentMapper.xml，里面就是用xml写的增删改查，删去了原本很复杂的jdbc的过程，简化了jdbc一目了然，我们可以直接编写sql语句，利用这些select，delet，update，insert这些标签就很大程度的简化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:是整个文件的大标签,用来开始和结束xml文件
  属性:
     namespace:指定命名空间(相当于包名),用来区分不同mapper.xml文件中相同的id属性

-->
<mapper namespace="zar">
    <!--
      完成查询全部学生的功能
      List<Student> getALL();
         resultType:指定查询返回的结果集的类型,如果是集合,则必须是泛型的类型
         parameterType:如果有参数,则通过它来指定参数的类型
    -->
    <select id="getAll" resultType="student" >
       select id,sname,sex,age
       from t_student
    </select>

    <!--
      按主键id查询学生信息
      Student getById(Integer id);
    -->
    <select id="getById" parameterType="int" resultType="student">
        select id,sname,sex,age
        from t_student
        where id=#{id}
    </select>

    <!--
      按学生名称模糊查询
      List<Student> getByName(String sname);
    -->
    <select id="getByName" parameterType="string" resultType="student">
        select id,sname,sex,age
        from t_student
        where name like '%${name}%'
    </select>

    <!--
      增加学生
      int insert(Student stu);
      实体类:
        private Integer id;
        private String sname;
        private String sex;
        private String age;
    -->
    <insert id="insert" parameterType="student">
        insert into t_student (sname,sex,age) values(#{name},#{sex},#{age})
    </insert>
    <!--
      按主键删除学生
      int delete(Integer id);
    -->
    <delete id="delete" parameterType="int" >
        delete from t_student where id=#{id}
    </delete>
    <!--
      更新学生
      int update(Student stu);
    -->
    <update id="update" parameterType="student">
        update t_student set sname=#{name},sex=#{sex},age=#{age}
        where id=#{id}
    </update>
</mapper>

至此呢我们的mybatis基础算是写完了，接下来我们在text里面测试一下，测试之前我想问一下我们studentStudent.xml文件里面的方法怎么用呢？这时候我们需要引进一个对象叫sqlsession

sqlsession：获取映射器，让映射器通过命名空间和方法名称找到对应的SQL，发送给数据库执行后返回结果
直接通过命名信息去执行SQL返回结果，这是IBatis版本留下的方式。在sqlSession层我们可以通过update、insert、select、delete等方法，带上SQL的id来操作XML中配置好的SQL，从而完成我的工作；与此同时它也支持事物，通过commit、rollback方法提交或者回滚事务。

然而使用sqlsession的步骤有五步骤，其中创建和关闭都是必须进行的，所以我们就可以利用将他们放到一个方法里面整合起来这个思路，我们在test里面设置before和after注解来进行方法实现

        //使用文件流读取核心配置文件SqlMapConfig.xml
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //创建SqlSessionFactory工厂
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

        //取出sqlSession的对象
        sqlSession = factory.openSession();

        //使用sqlsesion进行sql语句的使用
        sqlSession.selectList("zar.getAll");

        //关闭sqlSession
        sqlSession.close();

下面我们来看完整的测试代码：

package org.example;


import com.sun.org.apache.bcel.internal.generic.FADD;
import mybatis_001.pojo.Student;
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.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 *
 */
public class MyTest {
    SqlSession sqlSession;

    @Before  //在所有的@Test方法执行前先执行的代码
    public void openSqlSession() throws IOException {
        //使用文件流读取核心配置文件SqlMapConfig.xml
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory工厂
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //取出sqlSession的对象
        sqlSession = factory.openSession();
    }

    @After
    public void closeSqlSession(){
        //关闭sqlSession
        sqlSession.close();
    }

    @Test
    public void testGetAll() throws IOException {
        //完成查询操作
        List<Student> list = sqlSession.selectList("zar.getAll");
        list.forEach(student -> System.out.println(student));
    }

    @Test
    public void testGetById() throws IOException {
        //按主键查学生
        Student stu = sqlSession.selectOne("zar.getById",3);
        System.out.println(stu);
    }

    @Test
    public void testGetByName()throws IOException{

        //4.调用方法
        List<Student> list = sqlSession.selectList("zar.getByName","李");
        list.forEach(student -> System.out.println(student));

    }

    @Test
    public void testInsert()throws IOException{

        //4.调用方法
       int num = sqlSession.insert("zar.insert",new Student("haha666","haha@126.com","23"));
       //切记切记切记:在所有的增删改后必须手工提交事务!!!
        sqlSession.commit();

    }

    @Test
    public void testDelete()throws IOException {

        //4.调用方法
        int num = sqlSession.delete("zar.delete",1);
        System.out.println(num);
        //切记切记切记:在所有的增删改后必须手工提交事务!!!
        sqlSession.commit();

    }

    @Test
    public void testUpdate()throws IOException {

        //4.调用方法
        int num = sqlSession.update("zar.update",new Student("3","hehe","hehe@126.com","30"));
        System.out.println(num);
        sqlSession.commit();

    }
}

查询成功后会打出日志：

至此我们一个简单的mybatis就写好了

spring：

1.什么是Spring框架
它是一个容器.它是整合其它框架的框架.它的核心是IOC和AOP.它由20多个模块构成.它在很多领域都提供优秀的解决方案.

2.Spring的特点
1)轻量级
由20多个模块构成,每个jar包都很小,小于1M,核心包也就3M左右.对代码无污染.

2)面向接口编程
使用接口,就是面向灵活,项目的可扩展性,可维护性都极高.接口不关心实现类的类型.使用时接口指向实现类,切换实现类即可切换整个功能.

3)AOP:面向切面编程
就是将公共的,通用的,重复的代码单独开发,在需要的时候反织回去.底层的原理是动态代理.

4)整合其它框架
它整合后使其它框架更易用.

3.什么是IOC
控制反转IoC(Inversion of Control)是一个概念，是一种思想。由Spring容器进行对象的创建和依赖注入.程序员在使用时直接取出使用.

正转:由程序员进行对象的创建和依赖注入称为正转.程序员说了算.
Student stu = new Student(); ===>程序员创建对象
stu.setName("xxx"); ===>程序员进行赋值
stu.setAge(22);

反转:由Spring容器创建对象和依赖注入称为反转,将控制权从程序员手中夺走,由给Spring 容器,称为反转. 容器说了算.
<bean id="stu" class="my.pojo.Student"> ===>Spring容器负责对象的创建
<property name="name" value="张三"> ===>Spring容器依赖注入值
<property name="age" value="22">
</bean>

切记:Spring容器在启动时,就创建所有的对象stu....

那我们看一下基于xml下的ioc是什么样子的：

1)创建对象
<bean id="stu" class="my.pojo.Student"></bean>

2)给创建的对象赋值
使用setter注入
注入分为简单类型注入和引用类型注入
简单类型注入值使用value属性
引用类型注入值使用ref属性
必须要注意:使用setter注入必须提供无参的构造方法,必须提供setXXX()方法.


<bean id="stu" class="my.pojo2.Student">
<property name="name" value="郭**"></property> ===>简单类型注入
<property name="age" value="20"></property>
<property name="school" ref="school"></property> ===>引用类型注入
</bean>

<bean id="school" class="my.pojo2.School">
<property name="name" value="西安工程大学"></property>
<property name="address" value="临潼区"></property>
</bean>

使用构造方法注入
Student stu = new Student("郭**",20);
a.使用构造方法的参数名称进行注入值
<bean id="school" class="my.pojo3.School">
       <constructor-arg name="name1" value="西安工程大学"></constructor-arg>
       <constructor-arg name="address1" value="临潼区"></constructor-arg>
       </bean>
b.使用构造方法参数的下标注入值
            <bean id="stu" class="my.pojo3.Student">
       <constructor-arg index="0" value="郭**"></constructor-arg>
       <constructor-arg index="1" value="20"></constructor-arg>
       <constructor-arg index="2" ref="school"></constructor-arg>
       </bean>
c.使用默认的构造方法的参数的顺序注入值
        <bean id="stuSequence" class="my.pojo3.Student">
       <constructor-arg value="郭**"></constructor-arg>
       <constructor-arg value="20"></constructor-arg>
       <constructor-arg ref="school"></constructor-arg>
       </bean>
当然我们一般选用的是用名字进行注入

到了spring的话我们就需要用三层架构来写了

使用三层架构进行用户的插入操作.
界面层,业务逻辑层,数据访问层(模拟).

Spring会接管三层架构中哪些对象的创建?界面层的对象,业务逻辑层的对象,数据访问层的对象.

非Spring接管下的三层项目构建:

实体类
com.my.pojo Users
数据访问层
com.my.dao UsersMapper.java(接口)
UsersMapperImpl.java(实现类)
业务逻辑层
com.my.service UsersService.java(接口)
UsersServiceImpl.java(实现类 )
界面层
com.my.controller UsersController.java

而后呢基于注解的ioc我们还需要进行在spring的核心配置文件下面增加包的扫描,推荐单个包扫描

<context:component-scan base-package="com.my.xxx"></context:component-scan>

1)创建对象的注解
   @Component:可以创建任意对象.创建的对象的默认名称是类名的驼峰命名法.也可以指定对象的名称@Component("指定名称").
   @Controller:专门用来创建控制器的对象(Servlet),这种对象可以接收用户的请求,可以返回处理结果给客户端.
   @Service:专门用来创建业务逻辑层的对象,负责向下访问数据访问层,处理完毕后的结果返回给界面层.
   @Repository:专门用来创建数据访问层的对象,负责数据库中的增删改查所有操作.

   案例:
   @Component("stu") //交给Spring去创建对象,就是在容器启动时创建
   public class Student {
   @Value("张三") ===>简单类型的值注入
   private String name;
   @Value("22")
   private int age;
...}

2)依赖注入的注解
简单类型(8种基本类型+String)的注入
   @Value:用来给简单类型注入值

引用类型的注入
@Autowired:使用类型注入值,从整个Bean工厂中搜索同源类型的对象进行注入.
同源类型也可注入.

先向pom.xml文件里面加入spring依赖，版本还是看自己选择

<dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-context</artifactId>

    <version>5.2.5.RELEASE</version>

  </dependency>

例如：我们依靠bean工厂创建对象实现程序解耦合，在resource里面创建applicaionContext.xml并编写如下代码，与上面的student是结合在一起的：

<?xml version="1.0" encoding="UTF-8"?>
<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
http://www.springframework.org/schema/beans ">

    <!--创建学生对象
      等同于 Student stu = new Student();
      id:就是创建的对象的名称
      class:就是创建的对象的类型,底层通过反射构建对象
      启动容器的同时,创建对象
    -->
    <bean id="stu" class="mybatis_001.pojo.Student">
        <property name="id" value="12"></property>
        <property name="sname" value="张三"></property>
        <property name="sex" value="男"></property>
        <property name="age" value="21"></property>
    </bean>

</beans>

下来我们实现三层架构模式;

首先的pojo层我们已经写过了，里面存放的也就是数据库中对象的映射类，我们先写dao层里面的Mapper接口，我们可以先简单一点只写一个增加类，返回结果是1的话我们认为方法执行成功

public interface UsersMappr {
    //增加用户
    int insert(Student student);
}

然后我们顺便在dao写一个类来实现这个接口，我们一般的命名习惯就是在其接口的后面加上impl即可，则我们的usermapperimpl类如下，实现方法并且返回结果为1：

public class UsersMapperImpl implements UsersMappr {
    @Override
    public int insert(Student u) {
        System.out.println(u.getSname()+"用户增加成功!");
        return 1;
    }
}

然后我们编写service层，这是服务层，dao是对接数据库的，所以这两个层实现的方法都是一样的，controller去调用service然后service去调用dao层然后dao层去调用数据库实现数据变化。

所以我们的service层还是只实现一个insert方法

public interface UsersService {

    //增加用户
    int insert(Student student);
}

然后它的impl层跟上面的不一样，我们是实现service的接口但调用的是mapperimpl的方法具体看下面，刚开始的单独spring需要写set方法后面ssm整合在一起的时候直接加一个autowired注解就可以一键注入：

public class UsersServiceImpl implements UsersService {

    //切记切记:在所有的业务逻辑层中都必定有数据访问层的对象
    private UsersMappr usersMappr ;//= new UsersMapperImpl();

    //交给Spring去依赖注入值,必须提供setXXX()方法

    public void setUsersMappr(UsersMappr usersMappr) {
        this.usersMappr = usersMappr;
    }

    @Override
    public int insert(Student student) {
        //添加更复杂的业务,但是我们现在没有复杂业务
        return usersMappr.insert(student);
    }
}

最后我们实现controller层

public class UsersController {

    //如何去访问业务逻辑层,就是创建对象
    //切记切记:所有的界面层都会有业务逻辑层的对象
    public UsersService usersService ; //不用手动去new UsersServiceImpl();交给容器即可

    //交给Spring去注入值,必须提供setXXX()方法

    public void setUsersService(UsersService usersService) {
        this.usersService = usersService;
    }

    //界成层的功能实现,对外提供访问的功能
    public int insert(Student student){
        return usersService.insert(student);
    }
}

我们把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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean id="uController" class="mybatis_001.my.controller.UsersController">
        <property name="usersService"  ref="uService"></property>
    </bean>

    <!--创建各种对象-->
    <!--创建数据访问层的对象-->
    <bean id="uMapper" class="mybatis_001.my.dao.UsersMapperImpl">
    </bean>

    <!--创建业务逻辑层的对象-->
    <bean id="uService" class="mybatis_001.my.service.impl.UsersServiceImpl">
        <property name="usersMappr" ref="uMapper"></property>
    </bean>

</beans>

最后我们编写test类进行测试：

@Test
    public void testInsertUsers(){
        //创建容器并启动
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //取出对象
        UsersController usersController = (UsersController) ac.getBean("uController");
        //测试功能
        int num = usersController.insert(new Student("郭**","男","20"));
        System.out.println(num);
    }

运行之后的结果如下则证明成功，当然我们没有连接数据库则这个数据是没有增加到数据库里面的

springmvc：

1.什么是SpringMVC
它是基于MVC开发模式的框架,用来优化控制器.它是Spring家族的一员.它也具备IOC和AOP.

2.什么是MVC?
它是一种开发模式,它是模型视图控制器的简称.所有的web应用都是基于MVC开发.
M:模型层,包含实体类,业务逻辑层,数据访问层
V:视图层,html,javaScript,vue等都是视图层,用来显现数据
C:控制器,它是用来接收客户端的请求,并返回响应到客户端的组件,Servlet就是组件

3.SpringMVC框架的优点
1)轻量级,基于MVC的框架
2)易于上手,容易理解,功能强大
3)它具备IOC和AOP
4)完全基于注解开发

步骤

3.基于注解的SpringMVC框架开发的步骤
1)新建项目,选择webapp模板.
2)修改目录,添加缺失的test,java,resources(两套),并修改目录属性
3)修改pom.xml文件,添加SpringMVC的依赖,添加Servlet的依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>

4)在resources添加springmvc.xml配置文件,指定包扫描,添加视图解析器.

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

<bean class="my.web.servlet.view.InternalResourceViewResolver">

<property name="prefix" value="/admin/"></property>

<property name="suffix" value=".jsp"></property>
</bean>
5)删除web.xml文件,新建web.xml
6)在web.xml文件中注册springMVC框架(所有的web请求都是基于servlet的)

<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>my.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>

<url-pattern>*.action</url-pattern>
</servlet-mapping>
7)在webapp目录下新建admin目录,在admin目录下新建main.jsp页面,删除index.jsp页面,并新建,发送请求给服务器
8)开发控制器(Servlet),它是一个普通的类.
   @Controller //交给Spring去创建对象
   public class DemoAction {
   /**
   * 以前的Servlet的规范
   * protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {}
   * action中所有的功能实现都是由方法来完成的
   * action方法的规范
   * 1)访问权限是public
   * 2)方法的返回值任意
   * 3)方法名称任意
   * 4)方法可以没有参数,如果有可是任意类型
   * 5)要使用@RequestMapping注解来声明一个访问的路径(名称)
   *
   */
   @RequestMapping("/demo")
   public String demo(){
   System.out.println("服务器被访问到了.......");
   return "main"; //可以直接跳到/admin/main.jsp页面上
   }
   }
9)添加tomcat进行测试功能

我们先创建一个webapp的maven，其他不变

引入依赖并且补齐文件：

在resources下面编写springmvc.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">

    <!--添加包扫描-->
    <context:component-scan base-package="my.controller"></context:component-scan>
    <!--添加视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--配置前缀-->
        <property name="prefix" value="/admin/"></property>
        <!--配置后缀-->
        <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

然后我们删除web.xml文件，因为系统给我们的web.xml文件根本就不可用，我们需要创建一个webapp4.0版本的才可以用

<?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">
    <!--注册SpringMVC框架-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--
          指定拦截什么样的请求
          http://localhost:8080/one
          http://localhost:8080/index.jsp
          http://localhost:8080/demo.action
          <a href="${pageContext.request.contextPath}/demo.action">访问服务器</a>
        -->
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>
</web-app>

然后我们去webapp下面创建一个main文件夹，并且在下面创建一个main.jsp

然后新建一个servlet进行请求测试，需要夹requestmapping注解进行匹配

package my.controller;

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

/**
 *
 */
@Controller  //交给Spring去创建对象
@RequestMapping("/zar")
public class DemoAction {
    /**
     * 以前的Servlet的规范
     * protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {}
     * action中所有的功能实现都是由方法来完成的
     * action方法的规范
     * 1)访问权限是public
     * 2)方法的返回值任意
     * 3)方法名称任意
     * 4)方法可以没有参数,如果有可是任意类型
     * 5)要使用@RequestMapping注解来声明一个访问的路径(名称)
     *
     */
    @RequestMapping("/demo")
    public String demo(){
        System.out.println("zar服务器被访问到了.......");
        return "main";  //可以直接跳到/admin/main.jsp页面上
    }
}

然后我们写一个index.jsp方便启动之后可以直接访问我们的controller

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<br><br><br>
<a href="${pageContext.request.contextPath}/zar/demo.action">访问服务器zar</a>
<a href="${pageContext.request.contextPath}/user/demo.action">访问服务器user</a>
</body>
</html>

然后我们配置tomcat，注意这里尽量用8或者9，因为用10的话容易出现500错误。

配置好了之后我我们进行启动：

这样就说明你访问成功了，然后点击任意一个路径它都会通过springmvc的过滤器进行跳转到main.jsp里面

主要看上面的路径

至此我们就访问成功了，ssm初级认识也算告一段落了，我将ssm整合的步骤放在下方大家可以自己观看：

SSM整合的步骤
0)建库,建表
1)新建Maven项目,选择webapp模板
2)修改目录
3)修改pom.xml文件

4)添加jdbc.properties属性文件
5)添加SqlMapConfig.xml文件(使用模板)
6)添加applicationContext_mapper.xml文件(数据访问层的核心配置文件)
7)添加applicationContext_service.xml文件(业务逻辑层的核心配置文件)
8)添加spirngmvc.xml文件
9)删除web.xml文件,新建,改名,设置中文编码,并注册spirngmvc框架,并注册Spring框架
10)新建实体类user
11)新建UserMapper.java接口
12)新建UserMapper.xml实现增删查所有功能,没有更新
13)新建service接口和实现类
14)新建测试类,完成所有功能的测试
15)新建控制器,完成所有功能
16)浏览器测试功能

新城已无旧少年_

关注

12
点赞
踩
61

收藏

觉得还不错? 一键收藏
打赏
2
评论
SSM框架简单讲解,内含代码加注释,详细

虽然现在的ssm市面上大多数公司已经不用了，除了一些个别公司的老项目还再用，甚至有的项目还在用ssh这种更古老的框架，但是我们要想学习更高级的框架比如springboot那么ssm肯定是要学的。
复制链接

扫一扫