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

在这里插入图片描述

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

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&lt;Address&gt; 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.配置视图解析器

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

上面的代码定义了一个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

<!--继承SpringBoot框架的一个父项目，所有自己开发的spring Boot都必须的继承-->
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</ artifactId>
    <version>2.2.1.RELEASE</version>
	<relativePath/> <!-- Lookup parent from repository -->
</parent>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</ artifactId>
</dependency>
<!--MyBatis整合SpringBoot的起步依赖-->
<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-starter</ artifactId>
    <version>2.0.o</version>
</dependency>
<!--MySQL的驱动依赖-->
<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映射文件

核心接口和类的结构

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

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

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：数据库列名或者别名

resultMap集合collection

collection

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

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

四、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>元素为构造方法传参

<bean id="userDao" class="dao.impl.UserDaoImpl" />
<bean id="userService" class="service.impl.UserServiceImpl">         
	<constructor-arg><ref bean="userDao" /></constructor-arg>
</bean>

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）

常用增强处理类型

SpringAOP配置元素

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

Spring切面配置

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

五、SpringMVC

Spring MVC请求处理流程

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

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整合流程

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

2.SSM整合配置

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

<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[]{"/"};
    }
}