SSM框架编程技术期末复习内容

Love The Way You Lie 2023-10-12 14:02 37阅读 0赞

![在这里插入图片描述][4ba4515eb3204a37b9a45f8c71df177c.png_pic_center]

考试题型：简答题+编程题

#### SSM框架编程技术期末复习 ####

*   *  一、代码干货
     *   *  Mybatis实现查询用户表记录数
         *  Mybatis根据用户名对用户表进行模糊查询
         *  Mybatis使用resultMap实现用户信息查询(用户表和角色表查询)
         *  Mybatis根据用户角色id获取用户列表
         *  Mybatis获取指定用户的相关信息及其地址列表
         *  Mybatis实现用户表的增删改查操作
         *  SpringMVC参数传递的例子
     *  二、框架编程概念
     *   *  后端框架
         *  前端框架
         *  其他可关注的框架及中间件
         *  协同开发工具Git
         *  SpringBoot
         *  SprngBoot:POM.XML
     *  三、MyBatis
     *   *  MyBatis基本要素
         *  核心接口和类的结构
         *  mybatis-config.xml 系统核心配置文件
         *  SQL映射的XML文件
         *   *  select是MyBatis中最常用的元素之一
             *  select 的结果映射resultMap
             *  resultMap详解
             *  resultMap中的关联association
             *  resultMap集合collection
             *  insert元素
             *  update元素
             *  delete元素
         *  动态SQL
     *  四、Spring
     *   *  控制反转IoC
         *  依赖注入的方式
         *   *  构造器注入
             *  使用注解实现IOC
         *  SpringAOP
         *   *  常用增强处理类型
             *  SpringAOP配置元素
             *  Spring切面配置
     *  五、SpringMVC
     *   *  Spring MVC请求处理流程
         *  Spring MVC体系结构
         *  参数传递
         *   *  @RequestMapping
             *  @RequestParam
     *  六、SSM框架整合
     *   *  1.SSM整合流程
         *  2.SSM整合配置
         *   *  2.1 创建工程，添加依赖和插件
             *  2.2 Spring整合Mybatis
             *  2.3 Spring整合SpringMVC

### 一、代码干货 ###

#### Mybatis实现查询用户表记录数 ####

Mapper接口(UserMapper.java)：

public interface UserMapper {
        
        int count();
    }

MapperXML文件(UserMapper.xml):

<?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.example.UserMapper">
        <select id="count" resultType="int">
            SELECT count(*) FROM user
        </select>
    </mapper>
    首先声明了Mapper的DTD文件，然后定义了一个名为"count"的查询语句，它用于查询用户表的记录数，返回类型为int。

MyBatis的配置文件中配置Mapper接口和XML文件的路径(mybatis-config.xml):

<mappers>
        <mapper class="com.example.UserMapper"/>
    </mappers>
    
    <typeAliases>
        <typeAlias type="int" alias="integer"/>
    </typeAliases>
    第一个配置用于告诉MyBatis去扫描和加载UserMapper.java这个Mapper接口，第二个配置用于把int类型的结果别名为integer，这可以让我们在查询结果中获取结果，而不用使用数字下标。

在Service代码中调用查询方法:

@Autowired
    private UserMapper userMapper;
    
    public int getUserCount() {
        
        return userMapper.count();
    }
    在自己的业务代码中注入了UserMapper接口，并使用count()方法执行数据库查询，获取用户表的记录数。

#### Mybatis根据用户名对用户表进行模糊查询 ####

使用Mybatis对用户表进行根据用户名的模糊查询，可以使用如下的XML映射语句：

<select id="findUserByName" resultType="User">
        SELECT * FROM user
        WHERE username LIKE CONCAT('%', #{username}, '%')
    </select>

在这个查询语句中，id属性指定了该查询语句的唯一标识符，在此为“findUserByName”。resultType属性指定了查询结果的类型，这里为“User”类型。  
在查询语句中，使用了WHERE子句并且通过LIKE关键字进行模糊查询。使用CONCAT函数拼接了查询字符串，将%分别添加到字符串的头尾，\#\{username\}表示使用参数进行查询。  
然后，在Java代码中调用该查询语句，例如：

public interface UserMapper {
        
        List<User> findUserByName(String username);
    }

在这个接口中定义了一个findUserByName()方法，它将会调用XML映射文件中的查询语句。在调用该方法时，可以传递一个用户名的字符串作为参数，然后Mybatis将会根据参数执行模糊查询并返回结果List。

#### Mybatis使用resultMap实现用户信息查询(用户表和角色表查询) ####

创建两个实体类 User 和 Role

public class User {
        
        private Integer id;
        private String username;
        private String password;
        private Integer roleId;
        private Role role;
        // getter、setter省略...
    }
    
    public class Role {
        
        private Integer id;
        private String roleName;
        // getter、setter省略...
    }
    上面代码中，User实体类中包含一个角色ID和一个角色对象，其中角色对象通过roleId关联到Role实体类的ID。一般情况下，在进行关联查询时，需要将User实体类中的roleId与Role实体类中的ID关联起来。

配置映射文件

1.定义resultMap

<resultMap id="UserResultMap" type="User">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="roleId" property="roleId"/>
        <association property="role" javaType="Role">
            <id column="roleId" property="id"/>
            <result column="roleName" property="roleName"/>
        </association>
    </resultMap>
    在上面的映射文件中，定义了一个id为UserResultMap的resultMap，它将User实体类与Role实体类进行关联。使用标签指定了User实体类中的主键ID，标签指定了User实体类中的其他属性，标签则指定了角色关联的属性，并使用了一个内嵌的和标签分别指定了Role实体类中的主键ID和属性。

2.编写查询语句

<select id="getUserWithRole" resultMap="UserResultMap">
        SELECT u.*, r.roleName
        FROM user u
        LEFT JOIN role r ON u.roleId = r.id
        WHERE u.id = #{id}
    </select>
    在上面的映射文件中，定义了一个id为getUserWithRole的查询语句，它通过LEFT JOIN操作来将用户表和角色表进行关联查询，并根据用户ID对其进行查询。

3.编写DAO接口

public interface UserMapper {
        
        User getUserWithRole(Integer id);
    }
    在上述代码中，定义了一个getUserWithRole方法，它将执行映射文件中定义的getUserWithRole查询语句，并通过resultMap进行结果映射。

4.调用查询方法

User user = userMapper.getUserWithRole(100);
    System.out.println("用户ID：" + user.getId() + "；用户名：" + user.getUsername() + "；所属角色：" + user.getRole().getRoleName());

#### Mybatis根据用户角色id获取用户列表 ####

1.首先，在数据库中创建一个“user”表和一个“role”表。可以在“user”表中包含一个“role\_id”列，用于表示用户所属的角色。在“role”表中，需要有“id”和“name”两列。  
2.接下来，在Java中创建一个“User”类，该类包含用于表示用户的各个字段。同时，应该也创建一个“Role”类，该类用于表示角色。

public class User {
        
        private Long id;
        private String name;
        private String email;
        private Long roleId;
        private Role role;
        // getter、setter省略...
    }
    
    public class Role {
        
        private Long id;
        private String name;
        // getter、setter省略...
    }

在上面的定义中，“User”类包含一个“roleId”字段，该字段用于将“role\_id”列与“Role”对象关联起来。由于一个用户只能属于一个角色，因此需要在“User”类中包含一个“Role”对象。

3.然后，在Mybatis中创建一个映射文件，该文件应该包含一个“select”语句，用于按照用户角色ID获取用户列表。以下是示例代码：

<select id="getUsersByRoleId" resultMap="UserResultMap">
      SELECT u.*, r.name AS roleName
      FROM user u
      INNER JOIN role r ON u.role_id = r.id
      WHERE u.role_id = #{roleId}
    </select>
    
    <resultMap type="com.example.User" id="UserResultMap">
      <result property="id" column="id"/>
      <result property="name" column="name"/>
      <result property="email" column="email"/>
      <result property="roleId" column="role_id"/>
      <association property="role" javaType="com.example.Role">
        <result property="id" column="id"/>
        <result property="name" column="roleName"/>
      </association>
    </resultMap>

在上面的代码中，定义了一个名为“getUsersByRoleId”的查询语句，该语句获取具有指定角色ID的所有用户。在“resultMap”元素中，为“User”类定义一个“resultMap”子元素。

4.最后，在Mybatis中创建一个DAO接口，该接口定义“getUsersByRoleId”方法。查询方法使用添加了@Param注解的roleId参数来表示输入的用户角色ID。以下是示例代码：

public interface UserMapper {
        
        List<User> getUsersByRoleId(@Param("roleId") Long roleId);
    }

在上面的代码中，定义了一个名为“getUsersByRoleId”的查询方法，该方法接受一个Long类型的参数，用于表示输入的用户角色ID。

#### Mybatis获取指定用户的相关信息及其地址列表 ####

1.首先，需要在数据库中创建两张表：一个用于存储用户信息的“user”表和一个用于存储地址信息的“address”表。在“user”表中，至少需要包含一个表示用户ID的列。在“address”表中，需要至少有一个表示地址ID的列以及一个表示与用户相关联的列（通常是“user\_id”列）。  
2.接下来，在Java中创建一个“User”类和一个“Address”类，用于表示用户和地址的各个字段。以下是示例代码：

public class User {
        
        private Long id;
        private String name;
        private String email;
        private List<Address> addresses;
        // getter、setter省略...
    }
    
    public class Address {
        
        private Long id;
        private String address1;
        private String address2;
        private String city;
        private String country;
        private String zipCode;
        // getter、setter省略...
    }

在上面的定义中，“User”类包含一个“addresses”字段，该字段用于将用户与其地址列表相关联。由于一个用户可以有多个地址，因此需要在“User”类中包含一个“List”对象。

3.然后，在Mybatis中创建一个映射文件，该文件应该包含一个“select”语句，用于按照用户ID获取用户信息和其地址列表。以下是示例代码：

<select id="getUserWithAddresses" resultMap="UserResultMap">
      SELECT u.*, a.*
      FROM user u
      LEFT OUTER JOIN address a ON u.id = a.user_id
      WHERE u.id = #{id}
    </select>
    
    <resultMap type="com.example.User" id="UserResultMap">
      <id property="id" column="id"/>
      <result property="name" column="name"/>
      <result property="email" column="email"/>
      <collection property="addresses" ofType="com.example.Address">
        <id property="id" column="address_id"/>
        <result property="address1" column="address1"/>
        <result property="address2" column="address2"/>
        <result property="city" column="city"/>
        <result property="country" column="country"/>
        <result property="zipCode" column="zipCode"/>
      </collection>
    </resultMap>

在上面的代码中，定义了一个名为“getUserWithAddresses”的查询语句，该语句获取具有指定ID的用户以及与该用户相关联的所有地址。在“resultMap”元素中，为“User”类定义一个“resultMap”子元素以及一个包含“addresses”字段的“collection”元素。

4.最后，在Mybatis中创建一个DAO接口，该接口定义“getUserWithAddresses”方法。查询方法使用添加了@Param注解的id参数来表示输入的用户ID。以下是示例代码：

public interface UserMapper {
        
        User getUserWithAddresses(@Param("id") Long id);
    }

在上面的代码中，定义了一个名为“getUserWithAddresses”的查询方法，该方法接受一个Long类型的参数，用于表示输入的用户ID。  
现在就可以使用该DAO方法来查询指定用户的所有信息，包括相关的地址信息。只需调用该方法并传递用户ID作为参数即可。

#### Mybatis实现用户表的增删改查操作 ####

1.在数据库中创建一个用户表，包含用户ID、用户名、密码等基本信息。  
2.在Java中创建一个User类，用于表示用户信息。User类应该包含与数据库表中的每个字段对应的属性以及相应的getter和setter方法。以下是示例代码：

public class User {
        
        private Long id;
        private String username;
        private String password;
        // getter、setter省略...
    }

3.在Mybatis的映射文件中，创建一个命名空间，并定义一个查询语句和一个插入语句。以下是示例代码：

<mapper namespace="com.example.UserMapper">
    
      
      <select id="getUserById" resultType="com.example.User">
        SELECT * FROM user WHERE id = #{id}
      </select>
    
      
      <insert id="insertUser" parameterType="com.example.User">
        INSERT INTO user (username, password) VALUES (#{username}, #{password})
      </insert>
    
      
      <update id="updateUser" parameterType="com.example.User">
        UPDATE user SET username = #{username}, password = #{password} WHERE id = #{id}
      </update>
    
      
      <delete id="deleteUser" parameterType="Long">
        DELETE FROM user WHERE id = #{id}
      </delete>
    
    </mapper>

在上面的代码中，定义了一个命名空间“com.example.UserMapper”，用于包含用户表的所有查询和操作。其中，“getUserById”语句用于查询指定ID的用户信息，“insertUser”语句用于将新用户插入到数据库，“updateUser”语句用于更新现有用户的信息，“deleteUser”语句用于删除指定ID的用户。

4.在Java中创建一个UserMapper接口，用于定义查询和操作User表的方法。以下是示例代码：

public interface UserMapper {
        
        User getUserById(Long id);  // 根据ID查询用户
        void insertUser(User user);  // 插入用户
        void updateUser(User user);  // 更新用户
        void deleteUser(Long id);  // 删除用户
    }

在上面的代码中，定义了一个包含四个方法的UserMapper接口，分别用于查询、插入、更新和删除用户。每个方法都对应于Mybatis映射文件中的一个语句。

5.在应用程序中，通过Mybatis的SqlSessionFactory获取SqlSession对象，然后使用UserMapper接口执行各种查询和操作。以下是示例代码：

// 创建SqlSessionFactory对象，通常只需要创建一次
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    
    // 创建SqlSession对象
    try (SqlSession session = sqlSessionFactory.openSession()) {
        
    
        // 获取UserMapper接口的实现
        UserMapper userMapper = session.getMapper(UserMapper.class);
    
        // 查询用户信息
        User user = userMapper.getUserById(1L);
        System.out.println(user.getId() + ", " + user.getUsername() + ", " + user.getPassword());
    
        // 插入新用户
        User newUser = new User();
        newUser.setUsername("test");
        newUser.setPassword("123456");
        userMapper.insertUser(newUser);
        session.commit();
    
        // 更新用户信息
        user.setUsername("张三");
        userMapper.updateUser(user);
        session.commit();
    
        // 删除用户
        userMapper.deleteUser(1L);
        session.commit();
    }

在上面的代码中，首先创建了SqlSessionFactory对象，然后创建了一个SqlSession对象。通过SqlSession对象，获取UserMapper接口的实现，然后使用该接口执行查询和各种操作。执行完毕后，需要调用session.commit()方法来提交修改，或者使用try-with-resources语句来自动关闭SqlSession对象。

#### SpringMVC参数传递的例子 ####

1.定义Controller

@Controller
    public class HelloController {
        
    
       @RequestMapping("/hello")
       public ModelAndView hello(@RequestParam(value = "name", defaultValue = "World") String name) {
        
          ModelAndView model = new ModelAndView("hello");
          model.addObject("name", name);
          return model;
       }
    }

上面的代码定义了一个HelloController类，它包含了一个@RequestMapping注解的hello方法，该方法使用了@RequestParam注解来获取name参数，并将参数值传递给ModelAndView对象。其中，defaultValue参数指定了在请求中没有提供参数时的默认值。

2.定义View

<html>
       <head>
          <title>Hello Page</title>
       </head>
       
       <body>
          <h1>Hello ${name}!</h1>
       </body>
    </html>

上面的代码定义了一个hello.jsp视图，它通过EL表达式$\{name\}来显示传递的参数值。

3.配置视图解析器

上面的代码定义了一个InternalResourceViewResolver视图解析器，它将JSP文件作为视图。prefix属性指定了视图文件的前缀，suffix属性指定了视图文件的后缀。

### 二、框架编程概念 ###

*  框架实现了设计模式，不用自己去实现MVC等模式
 *  框架提供了多种插件
 *  让开发者专注于业务逻辑本身，而不是系统的通用性的事务。
 *  框架封装好了类库，并能很好地管理这些类及相互关系，对外隐藏了其实现细节，降低了使用者的学习和维护成本。
 *  程序员按照框架的规范和要求编写程序。

#### 后端框架 ####

*  Java：Spring Boot
 *  Python：Django, Flask
 *  .NET: ASP.NET core
 *  PHP: Laravel, CakePHP
 *  Scala: Play
 *  Ruby: Ruby on Rails
 *  Golang: Fiber

#### 前端框架 ####

*  Vue
    
     *  用于构建用户界面的渐进式框架
     *  Vue 的核心库只关注视图层，可与elementUI配合
 *  React
    
     *  Facebook：用于构建 Web 和原生交互界面的库
 *  Angular：可以把静态页面与动态数据绑定起来的mvc框架，移动应用程序开发。
 *  uni-app：基于Vue.js，一套代码，可编译到iOS、Android、H5、小程序等多个平台
 *  Flutter：谷歌的移动UI框架，可快速在iOS和Android上构建高质量的原生用户界面

#### 其他可关注的框架及中间件 ####

*  Maven：项目构建；Jar包的依赖管理；版本管理
 *  JUint：单元测试工具
 *  Shiro、SpringSecurity：关于安全认证的框架，用于用户身份认证，权限授权、加密、会话管理等；
 *  Redis：缓存，高性能的key-value数据库
 *  SpringCloud：微服务框架
 *  RabbitMQ、Kafka：消息队列，保存消息的容器，也用于系统间解耦
 *  Zookeeper：分布式协调服务
 *  Nginx：负载均衡软件
 *  Docker：容器技术

#### 协同开发工具Git ####

*  基于git的代码托管协助平台
 *  支持Git，提供免费的私有仓库托管
 *  码云（Gitee）：国内最大的代码托管平台
 *  面向个人、团队、企业，用Gitee实现代码托管、项目管理、协作开发

#### SpringBoot ####

*  SSM：web.xml，spring配置，mybatis配置
 *  采用大量默认的配置来简化我们的spring开发过程,能够快速创建基于spring的程序
 *  直接使用Java main方法启动内嵌的Tomcat服务器运行springboot程序，不需要部署war包
 *  提供约定的starter POM来简化Maven配置，让Maven的配置变得简单
 *  自动化配置，根据项目的Maven依赖配置，springboot自动配置spring、springmvc等
 *  基本可以完全不使用xml配合文件，采用注解配置

#### SprngBoot:POM.XML ####

<parent>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-parent</ artifactId>
        <version>2.2.1.RELEASE</version>
    	<relativePath/> 
    </parent>
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-web</ artifactId>
    </dependency>
    
    <dependency>
    	<groupId>org.mybatis.spring.boot</groupId>
    	<artifactId>mybatis-spring-boot-starter</ artifactId>
        <version>2.0.o</version>
    </dependency>
    
    <dependency>
    	<groupId>mysql</groupId>
    	<artifactId>mysql-connector-java</ artifactId>
    </dependency>

### 三、MyBatis ###

MyBatis前身是iBatis，本是Apache的一个开源的项目，是一个ORM(持久化与对象关系映射)框架。

*  基于SQL语法，简单易学
 *  能了解底层封装过程
 *  SQL语句封装在配置文件中，便于统一管理与维护，降低程序的耦合度
 *  方便程序代码调试

搭建Mybatis开发环境的步骤

*  下载mybatis-3.2.2.jar包并导入工程或使用maven引入mybatis依赖
 *  编写MyBatis核心配置文件(configuration.xml)
 *  创建实体类-POJO
 *  DAO层-SQL映射文件(mapper.xml)
 *  创建测试类
    
     *  读取核心配置文件mybatis-config.xml
     *  创建SqlSessionFactory对象，读取配置文件
     *  创建SqlSession对象
     *  调用mapper文件进行数据操作

#### MyBatis基本要素 ####

*  MyBatis的核心对象
    
     *  SqlSessionFactoryBuilder
     *  SqlSessionFactory
     *  SqlSession
 *  mybatis-config.xml 系统核心配置文件
 *  mapper.xml SQL映射文件

#### 核心接口和类的结构 ####

![image-20230611120650050][]

#### mybatis-config.xml 系统核心配置文件 ####

![image-20230611120725377][]

#### SQL映射的XML文件 ####

*  MyBatis 真正的强大在于映射语句，专注于SQL，功能强大，SQL映射的配置却是相当简单
 *  SQL映射文件的几个顶级元素(按照定义的顺序)
    
     *  mapper – namespace
     *  cache – 配置给定命名空间的缓存
     *  cache-ref – 从其他命名空间引用缓存配置
     *  resultMap –用来描述数据库结果集和对象的对应关系
     *  sql – 可以重用的SQL块，也可以被其他语句引用
     *  insert – 映射插入语句
     *  update – 映射更新语句
     *  delete – 映射删除语句
     *  select – 映射查询语句
     *

##### select是MyBatis中最常用的元素之一 #####

select语句有很多属性可以详细配置每一条语句

*  id
    
     *  命名空间中唯一的标识符
     *  接口中的方法与映射文件中的SQL语句id一一对应
 *  parameterType
    
     *  传入SQL语句的参数类型
 *  resultType
    
     *  SQL语句返回值类型的完整类名或别名

##### select 的结果映射resultMap #####

![image-20230611123007711][]

##### resultMap详解 #####

resultMap属性

*  id：resultMap的唯一标识
 *  type：Java实体类

resultMap子元素

*  id 一般对应数据库中该行的主键id，设置此项可提高MyBatis性能
 *  result 映射到JavaBean的某个“简单类型”属性
 *  association 映射到JavaBean的某个“复杂类型”属性，比如JavaBean类
 *  collection 映射到JavaBean的某个“复杂类型”属性，比如集合

##### resultMap中的关联association #####

association

*  复杂的类型关联，一对一
 *  内部嵌套：映射一个嵌套JavaBean属性
 *  属性
    
     *  property：映射数据库列的实体对象的属性
     *  javaType：完整Java类名或者别名
     *  resultMap：引用外部resultMap
 *  子元素
    
     *  id
     *  result
     *  property：映射数据库列的实体对象的属性
     *  column：数据库列名或者别名

![image-20230611123326830][]

##### resultMap集合collection #####

collection

*  复杂类型集合，一对多
 *  内部嵌套：映射一个嵌套结果集到一个列表
 *  属性
    
     *  property：映射数据库列的实体对象的属性
     *  ofType：完整Java类名或者别名(集合所包括的类型)
     *  resultMap：引用外部resultMap
 *  子元素
    
     *  id
     *  result
     *  property：映射数据库列的实体对象的属性
     *  column：数据库列名或者别名

![image-20230611123454205][]

##### insert元素 #####

<insert  id="add" parameterType="User" >
     insert into  smbms_user (userCode,userName,userPassword) 
    		values ( #{userCode},#{userName},#{userPassword})
    </insert>

##### update元素 #####

<update id ="modify" parameterType="User">
    update smbms_user set userCode = #{userCode},
    	         userName = #{userName},
                  userPassword = #{userPassword}  where id = #{id}
    </update>

##### delete元素 #####

<delete id ="deleteUserById" parameterType="int">
    	delete from smbms_user where id = #{id}
    </delete>

#### 动态SQL ####

*  基于OGNL表达式
 *  完成多条件查询等逻辑实现
 *  用于实现动态SQL的元素主要有
    
     *  if
     *  trim
     *  where
     *  set
     *  choose（when、otherwise）
     *  foreach

![image-20230611123750885][]

### 四、Spring ###

Spring是一个开源的企业级Java开发框架，它提供了一系列轻量级的解决方案和最佳实践，帮助开发人员快速构建可扩展和可维护的应用程序。Spring的核心原则是轻量级、松耦合、面向切面编程（AOP）和依赖注入（DI）。

*  轻量级：Spring 是非侵入性的 - 基于 Spring 开发的应用中的对象可以不依赖于 Spring 的 API
 *  依赖注入(DI — dependency injection、IOC)
 *  面向切面编程(AOP — aspect oriented programming)
 *  容器: Spring 是一个容器, 因为它包含并且管理应用对象的生命周期
 *  框架: Spring 实现了使用简单的组件配置组合成一个复杂的应用. 在 Spring 中可以使用 XML 和 Java 注解组合这些对象
 *  一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 （实际上 Spring 自身也提供了展现层的 SpringMVC 和 持久层的 Spring JDBC）

#### 控制反转IoC ####

\*\*IOC(Inversion of Control)：\*\*其思想是反转资源获取的方向. 传统的资源查找方式要求组件向容器发起请求查找资源. 作为回应, 容器适时的返回资源. 而应用了 IOC 之后, 则是容器主动地将资源推送给它所管理的组件, 组件所要做的仅是选择一种合适的方式来接受资源. 这种行为也被称为查找的被动形式  
控制反转：由容器决定何时和如何提供组件需要的资源。而不是组件自身创建资源  
**DI(Dependency Injection)** — IOC 的另一种表述方式：即组件以一些预先定义好的方式(例如: setter 方法)接受来自如容器的资源注入. 相对于 IOC 而言，这种表述更直接  
依赖注入：容器负责将所需资源自动注入

#### 依赖注入的方式 ####

##### 构造器注入 #####

在Spring配置文件中通过`<constructor-arg>`元素为构造方法传参

1、一个`<constructor-arg>`元素表示构造方法的一个参数，且使用时不区分顺序。

2、通过`<constructor-arg>`元素的index 属性可以指定该参数的位置索引，位置从0 开始。

3、`<constructor-arg>`元素还提供了type 属性用来指定参数的类型，避免字符串和基本数据类型的混淆。

##### 使用注解实现IOC #####

注解方式将Bean的定义信息和Bean实现类结合在一起，Spring提供的注解有

*  @Component：实现Bean组件的定义
 *  @Repository ：用于标注DAO类
 *  @Service ：用于标注业务类
 *  @Controller ：用于标注控制器类

#### SpringAOP ####

面向切面编程（AOP）原理

*  将复杂的需求分解出不同方面，将散布在系统中的公共功能集中解决
 *  采用代理机制组装起来运行，在不改变原程序的基础上对代码段进行增强处理，增加新的功能

**AOP相关术语**

*  增强处理（Advice）
    
     *  前置增强
     *  后置增强
     *  环绕增强、异常抛出增强、最终增强等类型
 *  切入点（Pointcut）
 *  连接点（Join Point）
 *  切面（Aspect）
 *  目标对象（Target object）
 *  AOP代理（AOP proxy）
 *  织入（Weaving）

##### 常用增强处理类型 #####

![image-20230611124640315][]

##### SpringAOP配置元素 #####

![image-20230611124711334][]

织入增强处理(织入：在切入点插入增强处理)

![image-20230611124755012][]

##### Spring切面配置 #####

*  使用注解方式定义切面可以简化配置工作量
 *  常用注解有@Aspect、@Before、@AfterReturning、@Around、@AfterThrowing、@After等
 *  在配置文件中添加<aop:aspectj-autoproxy />元素，启用对于@AspectJ注解的支持

![image-20230611124836452][]

### 五、SpringMVC ###

#### Spring MVC请求处理流程 ####

Spring Web MVC框架是一个基于请求驱动的Web框架，使用前端控制器根据请求映射规则找到对应的控制器进行处理。

![image-20230611124928578][]

**1.前端控制器 DispatcherServlet 接收请求**

DispatcherServlet 是 Spring MVC 的核心组件，在 web.xml 中配置了所有请求都会经过该组件。DispatcherServlet 接收到请求后，根据请求 URL 映射到对应的 Controller 进行处理。

**2.HandlerMapping 进行请求映射**

HandlerMapping 是 Spring MVC 的 Handler 映射器组件，用于将请求 URL 映射到对应的 Handler(Controller)。它通过扫描应用程序上下文中的Controller容器注册的所有Controller，找到最佳匹配的Handler，并返回给 DispatcherServlet 进行处理。

**3.HandlerAdapter 执行 Handler**

HandlerAdapter 是 Spring MVC 的处理程序适配器组件，用于根据Handler的类型和方法的参数类型来调用Handler进行处理。HandlerAdapter 调用Handler之后生成ModelAndView，包含了 Handler 执行后的结果和需要渲染的视图。

**4.执行 Handler 中的业务逻辑**

这个阶段 Handler(Controller) 执行具体的业务逻辑，对请求进行处理。例如从数据库中取出数据，对数据进行增删改查等操作。

**5.生成 Model 并返回 ModelAndView**

Model 是处理请求后生成的数据模型，包含了 Handler 处理后的结果。Controller 通过将 Model 放置在 ModelAndView 中，并指定需要渲染的视图名称，将视图和数据集成到了一起。

**6.渲染视图并返回响应**

DispatcherServlet 将 ModelAndView 传递给 ViewResolver 进行视图解析和渲染，最终将视图展示在浏览器中。

**7.视图渲染完成，响应流返回给客户端**

在视图渲染完成后，DispatcherServlet 将响应流返回给客户端，请求处理流程结束。

#### Spring MVC体系结构 ####

**DispatcherServlet（前端控制器）**

*  Spring MVC最核心的类
 *  web.xml中配置

**Handler（处理器）：对应MVC中C(Controller层)**

*  类型：Object
 *  作用：实际处理请求
 *  标注了@RequestMapping的所有方法都可以看作是一个Handler
 *  ModelAndView
 *  逻辑视图名
 *  模型对象

#### 参数传递 ####

##### @RequestMapping #####

@RequestMapping是Spring MVC框架中最常用的注解之一，用于将HTTP请求映射到控制器的处理方法上。它可以用于类级别和方法级别注解。  
@RequestMapping注解可以用来指定多种请求方式，如GET, POST, PUT, DELETE等，也可以指定请求的URI路径。例如，以下注解将映射GET请求并且URI为“/user”到UserController中的getUser()方法上：

@Controller
    @RequestMapping(value = "/user", method = RequestMethod.GET)
    public class UserController {
        
        @RequestMapping(value = "/getUser")
        public String getUser(ModelMap model) {
        
            // ...
            return "user";
        }
    }

在这个例子中，UserController类被注解为@Controller，它的URI路径为“/user”，并且它的GET请求将会映射到getUser()方法上。其中，method参数指定了请求方式为GET。在getUser()方法中，ModelMap参数用于传递数据到前端视图，返回值为“user”，它将作为视图名被解析器解析成相应的视图。  
另一种使用方式是使用@RequestParam注解来获取请求参数，例如：

@RequestMapping(value = "/login", method = RequestMethod.POST)
    public String login(@RequestParam("username") String username, @RequestParam("password") String password, ModelMap model) {
        
        // ...
        return "home";
    }

在这个例子中，我们使用了POST请求方式，并通过@RequestParam注解来获取请求参数“username”和“password”。这些参数可以直接传递给方法中的参数，而不需要手动解析获取。

##### @RequestParam #####

@RequestParam是Spring MVC框架中的一个注解，用于从HTTP请求中获取参数值并将其传递给控制器的处理方法。可以将它添加到方法参数上。  
@RequestParam注解有多个属性，用于指定参数的名称、默认值、是否必需、以及如何将参数转换为特定类型的值。例如，以下代码从GET请求中获取名为“id”的参数并将其转换为long类型：

@RequestMapping("/user")
    public String getUser(@RequestParam("id") long userId, Model model) {
        
        // ...
    }

在这个例子中，我们使用@RequestParam注解将HTTP请求中的“id”参数映射到getUser()方法的userId参数上。Spring MVC将自动将字符串表示的参数值转换为long类型，并将其传递给控制器方法。  
除了指定参数的名称，还可以使用@RequestParam注解来指定其他属性，例如：

required：指定参数是否为必需的，默认为true。  
defaultValue：指定当请求中不存在该参数时使用的默认值。  
value / name：value属性可以用于和@RequestParam(name=) 进行同样的操作。

例如，以下代码指定了一个名为“age”的可选参数，如果该参数不存在，则使用默认值18：

@RequestMapping("/user")
    public String getUser(@RequestParam(value = "age", defaultValue = "18") int age, Model model) {
        
        // ...
    }

### 六、SSM框架整合 ###

#### 1.SSM整合流程 ####

1.  创建工程
2.  SSM整合
    
     *  Spring
        
         *  SpringConfig
     *  MyBatis
        
         *  MybatisConfig
         *  JdbcConfig
         *  jdbc.properties
     *  SpringMVC
        
         *  ServletConfig
         *  SpringMvcConfig
3.  功能模块
    
     *  表与实体类
     *  dao（接口+自动代理）
     *  service（接口+实现类）
        
         *  业务层接口测试（整合JUnit）
     *  controller
        
         *  表现层接口测试（PostMan）

#### 2.SSM整合配置 ####

##### 2.1 创建工程，添加依赖和插件 #####

![image-20230506213228172][]

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
    
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
    
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
    
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
    
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
    
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
    
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
    
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
    
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>

##### 2.2 Spring整合Mybatis #####

*  创建数据库和表

-- 创建ssm_db数据库
    CREATE DATABASE IF NOT EXISTS ssm_db CHARACTER SET utf8;
    
    -- 使用ssm_db数据库
    USE ssm_db;
    
    -- 创建tbl_book表
    CREATE TABLE tbl_book(
        id INT PRIMARY KEY AUTO_INCREMENT, -- 图书编号
        TYPE VARCHAR(100), -- 图书类型
        NAME VARCHAR(100), -- 图书名称
        description VARCHAR(100) -- 图书描述
    );
    -- 添加初始化数据
    INSERT INTO tbl_book VALUES(NULL,'计算机理论','Spring实战 第5版','Spring入门经典教材，深入理解Spring原理技术内幕');
    INSERT INTO tbl_book VALUES(NULL,'计算机理论','Spring 5核心原理与30个类手写实战','十年沉淀之作,手写Spring精华思想');
    INSERT INTO tbl_book VALUES(NULL,'计算机理论','Spring 5设计模式','深入Spring源码剖析,Spring源码蕴含的10大设计模式');
    INSERT INTO tbl_book VALUES(NULL,'市场营销','直播就该这么做:主播高效沟通实战指南','李子柒、李佳琦、薇娅成长为网红的秘密都在书中');
    INSERT INTO tbl_book VALUES(NULL,'市场营销','直播销讲实战一本通','和秋叶一起学系列网络营销书籍');
    INSERT INTO tbl_book VALUES(NULL,'市场营销','直播带货:淘宝、天猫直播从新手到高手','一本教你如何玩转直播的书,10堂课轻松实现带货月入3W+');

*  jdbc.properties属性文件

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

*  JdbcConfig配置类

public class JdbcConfig {
        
        @Value("${jdbc.driver}")
        private String driver;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String username;
        @Value("${jdbc.password}")
        private String password;
    	//配置连接池
        @Bean
        public DataSource dataSource(){
        
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setDriverClassName(driver);
            dataSource.setUrl(url);
            dataSource.setUsername(username);
            dataSource.setPassword(password);
            return   dataSource;
        }
    	//Spring事务管理需要的平台事务管理器对象
        @Bean
        public PlatformTransactionManager transactionManager(DataSource dataSource){
        
            DataSourceTransactionManager ds = new DataSourceTransactionManager();
            ds.setDataSource(dataSource);
            return ds;
        }
    }

*  MybatisConfig配置类

public class MybatisConfig {
        
    
        @Bean
        public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
        
            SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
            factoryBean.setDataSource(dataSource);
            // typeAliasesPackage属性的作用是，搜索指定包别名
            // 配置了以后xml文件中的resultType和parameterType就不需要指定全类名
            factoryBean.setTypeAliasesPackage("com.sun.domain");
            return factoryBean;
        }
        @Bean
        public MapperScannerConfigurer mapperScannerConfigurer() {
        
            MapperScannerConfigurer msc = new MapperScannerConfigurer();
            // setBasePackage用于设置Mapper接口所在的基本包名，是实现自动扫描的关键方法
            msc.setBasePackage("com.sun.dao");
            return msc;
        }
    }

*  SpringConfig配置类

@Configuration
    @ComponentScan({
        "com.sun.service"})
    @PropertySource("classpath:jdbc.properties")
    @Import({
        JdbcConfig.class,MyBatisConfig.class})
    @EnableTransactionManagement //开启Spring事务管理
    public class SpringConfig {
        
    }

##### 2.3 Spring整合SpringMVC #####

*  SpringMvcConfig配置类

@Configuration
    @ComponentScan("com.sun.controller")
    @EnableWebMvc
    public class SpringMvcConfig {
        
    }

*  ServletConfig配置类，加载SpringMvcConfig和SpringConfig配置类

public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
        
        protected Class<?>[] getRootConfigClasses() {
        
            return new Class[]{
        SpringConfig.class};
        }
    
        protected Class<?>[] getServletConfigClasses() {
        
            return new Class[]{
        SpringMvcConfig.class};
        }
    
        protected String[] getServletMappings() {
        
            return new String[]{
        "/"};
        }
    }

[4ba4515eb3204a37b9a45f8c71df177c.png_pic_center]: https://img-blog.csdnimg.cn/4ba4515eb3204a37b9a45f8c71df177c.png#pic_center
[image-20230611120650050]: https://sunmingtypora.oss-cn-qingdao.aliyuncs.com/image-20230611120650050.png
[image-20230611120725377]: https://sunmingtypora.oss-cn-qingdao.aliyuncs.com/image-20230611120725377.png
[image-20230611123007711]: https://img-blog.csdnimg.cn/img_convert/fe6332991f8636bb8924b4b6e01e6d7c.png
[image-20230611123326830]: https://img-blog.csdnimg.cn/img_convert/a653bccd1d9e7e37d5721ac15b724cbc.png
[image-20230611123454205]: https://img-blog.csdnimg.cn/img_convert/130f5225f81ec9fe8df4c4270a7834a9.png
[image-20230611123750885]: https://img-blog.csdnimg.cn/img_convert/0e45f026a98142964aa46526de29a06d.png
[image-20230611124640315]: https://img-blog.csdnimg.cn/img_convert/69e2fe086d4de1dde2ef97e88f0c303b.png
[image-20230611124711334]: https://img-blog.csdnimg.cn/img_convert/59fad2e5a93da0448f305748fd73fadd.png
[image-20230611124755012]: https://img-blog.csdnimg.cn/img_convert/ea74c149133fb5c853132462b113f151.png
[image-20230611124836452]: https://img-blog.csdnimg.cn/img_convert/92cff410e2a7806563fc9f0a30c7a50f.png
[image-20230611124928578]: https://sunmingtypora.oss-cn-qingdao.aliyuncs.com/image-20230611124928578.png
[image-20230506213228172]: https://img-blog.csdnimg.cn/img_convert/9df03b520a4ef7e5bae09fb7ce1abec5.png