SSM整合之MyBatis和Spring

最新推荐文章于 2023-08-26 07:49:55 发布

Toxic️

最新推荐文章于 2023-08-26 07:49:55 发布

阅读量470

点赞数

文章标签： mybatis java spring

本文链接：https://blog.csdn.net/m0_46488789/article/details/127938189

版权

一、1. MyBatis简介

MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录

1.1 MyBatis历史

原是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation 迁移到了Google Code，随着开发团队转投Google Code
旗下， iBatis3.x正式更名为MyBatis ，代码于2013年11月迁移到Github（下载地址见后）。https://github.com/mybatis/mybatis-3/
iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。 iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）

1.2 MyBatis特性

MyBatis是支持定制化SQL,存储过程以及高级映射的优秀的持久层框架
MyBatis避免了几乎所有的JDBC代码和手动设置参数以及候去结果集
MyBatis可以使用简单的XML或注解用于配置和原始映射,将接口和Java的POJO映射成数据库中的记录
MyBatis是一个半自动的ORM框架

定制化SQL：即可以自己手写SQL语句。
支持存储过程
支持高级映射：即POJO和数据库字段的映射方式可以自定义哦。
封装了JDBC代码，和结果集的处理过程 → 不用手写JDBC代码和结果集处理的过程
官方下载&文档

https://github.com/mybatis/mybatis-3

3. VS其他持久层框架

JDBC：

对于已经打包部署的项目，需要重新编辑代码再打包部署，非常麻烦。

-Hibernate 和 JPA
在这里插入图片描述

MyBatis

xml 中编写SQL语句。

4. 快速开始（简单介绍各个部分）

4.1 开发环境

IDE：IDEA: 2022.1。
构建工具：maven 3.8.5
MySQL版本：MySQL8
MyBatis 版本：MyBatis 3.5.7

4.2 Maven

根据你自己项目的类型创建具体Maven项目即可 (参考 IDEA 2022.1 中 Maven 项目的创建)

<dependencies>
   
    <!-- mybatis 核心 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>

    <!-- junit 测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.10</version>
    </dependency>
</dependencies>

创建数据库SSM

t_user表:
在这里插入图片描述

创建实体类User

public class User {
    
    private Integer id;
    
    private String username;
    
    private String password;
    
    private Integer age;
    
    private String sex;
    
    private String email;

    public User() {
        
    }

    public User(Integer id, String username, String password, Integer age, String sex, String email) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
        this.sex = sex;
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", email='" + email + '\'' +
                '}';
    }

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

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

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

4.3 创建MyBatis的核心配置文件

习惯上命名：mybatis-config.xml，非强制。将来整合Spring的时候可以省略。将来整合Spring之后,这个配置文件可以省略,所以操作时可以直接复制

作用：1. 配置链接数据库的环境 2. 配置MyBatis

放置位置：src/main/resources

<?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="com.qq.mybatis.POJO"/>
    </typeAliases>

    <!--配置连接数据库的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url"
                          value="jdbc:mysql://localhost:3306/ssm?characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="数据库密码"/>
            </dataSource>
        </environment>
    </environments>

<!--引入mybatis的映射文件-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>

</configuration>

4.4创建mapper接口

MyBatis中的mapper接口相当于以前的dao。但是区别在于mapper仅仅是接口，我们不需要提供实现类。

public interface UserMapper {
    
    //添加用户信息
    int insertUser();
    
}

4.5创建MyBatis的映射文件

Java概念	数据库概念
类	表
属性·	字段/列
对象	记录/行

4.6测试功能

下方代码：从开始到创建 SqlSessionFactory 只用创建一次即可，因此可以单独封装即可。
openSession() 获得 SqlSession默认是不自动提交事务，因此需要自己手动提交。

@Test
    public void InsertTest(){
        try {
            //配置核心配置文件的输入流
            InputStream is= Resources.getResourceAsStream("mybatis-config.xml");
            //获取SqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder=new SqlSessionFactoryBuilder();
            //获取SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory=sqlSessionFactoryBuilder.build(is);
            //获取sql的会话对象SqlSession,是Mybatis提供的操作数据库的对象
            SqlSession sqlSession=sqlSessionFactory.openSession(true);
            //获取UserMapper的代理实现类
            UserMapper mapper=sqlSession.getMapper(UserMapper.class);
            int result=mapper.insertUser();
            System.out.println(result);
            // 关闭资源
            sqlSession.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

4.7加入log4j日志功能

1.加入依赖

<!--log4j日志-->
       <dependency>
           <groupId>log4j</groupId>
           <artifactId>log4j</artifactId>
           <version>1.2.17</version>
       </dependency>

2.加入log4j的配置文件

log4j的配置文件名为log4j.xml存放位置为src/main/resources目录下

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8"/>
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5d %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n"/>
        </layout>
    </appender>

    <logger name="java.sql">
        <level value="debug"/>
    </logger>
    <logger name="org.apache.ibatis" >
        <level value="info"/>
    </logger>

    <!-- 默认配置，级别为debug 且根据name为log.console和 log.file两个appender输出-->
    <root>
        <level value="debug"/>
        <appender-ref ref="STDOUT"/>
    </root>
</log4j:configuration>

FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)
从左到右打印的内容越来越详细

4.8测试修改和删除用户的功能

1.创建utils文件下SqlSessionUtil.java

public class SqlSessionUtil {

    public  static SqlSession getSqlSession(){
        SqlSession sqlSession=null;
        try {
            //配置核心配置文件的输入流
            InputStream is= Resources.getResourceAsStream("mybatis-config.xml");
            //获取SqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder=new SqlSessionFactoryBuilder();
            //获取SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory=sqlSessionFactoryBuilder.build(is);
            //获取sql的会话对象SqlSession,是Mybatis提供的操作数据库的对象
            sqlSession=sqlSessionFactory.openSession(true);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sqlSession;
    }
}

(1)修改用户信息

Mapper/UserMapper接口:

//修改用户信息
    void updateUser();

Usermapper.xml

<!--void updateUser();-->
    <update id="updateUser">
        update t_user set username='root',password='1238' where id=3
    </update>

测试类:

//根据id修改用户信息
    @Test
    public void UpdateTest(){
        SqlSession sqlSession=SqlSessionUtil.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        mapper.updateUser();
        sqlSession.close();
    }

(2)删除用户信息

Mapper/UserMapper接口:

//根据id删除用户信息
    int deleteUser();

UserMapper.xml

 <!--int deleteUser();-->
    <delete id="deleteUser">
        delete from t_user where id=2
    </delete>

测试类:

 //根据id删除用户信息
    @Test
    public void DeleteTest(){
        SqlSession sqlSession=SqlSessionUtil.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        int result=mapper.deleteUser();
        System.out.println("result:"+result);
        sqlSession.close();
    }

4.9测试查询功能

(1)根据id查询用户信息
mapper/UserMapper接口:

//根据id查询用户信息
    User getUserById(@Param("id")Integer id);

UserMapper.xml

<!--User getUserById(@Param("id")Integer id);-->
    <!--
        resultMap:自定义映射,处理多对一或一对多的映射关系
        resultType:设置结果映射,即查询的数据要转换为java类型
    -->
    <select id="getUserById" resultType="User">
        select * from t_user where id=#{id}
    </select>

测试类:

//根据id查询用户信息
    @Test
    public void SelectTest(){
        SqlSession sqlSession=SqlSessionUtil.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        User user=mapper.getUserById(3);
        System.out.println(user);
    }

(2)查询所有用户
mapper/UserMapper接口:

//查询所有用户信息
    List<User> getAllUser();

mapper/UserMapper.xml

    <!--List<User> getAllUser();-->
    <select id="getAllUser" resultType="User">
        select * from t_user
    </select>

测试类:

//查询所用用户信息
    @Test
    public void SelectAllUserTest(){
        SqlSession sqlSession=SqlSessionUtil.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        List<User>list =mapper.getAllUser();
        System.out.println(list);
    }

5.核心配置文件详解

核心配置文件中的标签必须按照固定的顺序:
properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseldProvider?,mappers?

5.1核心配置文件之environments

可以配置多个环境,使用id区分,不能重复

<?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="com.qq.mybatis.POJO" />
    </typeAliases>

    <!--配置连接数据库的环境
        属性:
        default:设置默认使用环境的id
    -->
    <environments default="development">
        <!--
            environment:设置一个具体的连接数据库的环境
                属性:
                id:设置环境的唯一标识,不能重复
        -->
        <environment id="development">
            <!--
                transactionManager:设置事务管理器
                属性:
                type:设置事务管理的方式
                type:"JDBC|MANAGED"
                    JDBC:表示使用JDBC中原生的事务管理方式
                    MANAGED:被管理,例如:spring
            -->
            <transactionManager type="JDBC"/>
            <!--
                dataSource:设置数据源
                属性:
                    type:设置数据源的类型
                    type="POOLED|UNPOOLED|JNDI"
                        POOLED:表示使用数据连接池
                        UNPOOLED:表示不使用数据库连接池
                        JNDI:表示使用上下文中的数据源
            -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url"
                          value="jdbc:mysql://localhost:3306/ssm?characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>

        <environment id="test">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url"
                          value="jdbc:mysql://localhost:3306/ssm?characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>

    </environments>

    <!--引入mybatis的映射文件-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>

</configuration>

5.2核心配置文件之properties

创建位置src/main/resources/jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8
jdbc.username=root
jdbc.password=数据库密码

使用引入文件jdbc.properties

<?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>

   <!--引入jdbc.properties,此后就可以再当前文件中使用${key}的方式访问value-->
    <properties resource="jdbc.properties"/>

    <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.user}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="mappers/UserMapper.xml"></mapper>
    </mappers>
</configuration>

5.3核心配置文件之typeAliases

类型别名，在 Mapper 的 resultType 属性中可以使用简单类型别名

<?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:设置类型别名,即为某个具体的类型设置一个别名
    	在Mybatis的范围中,就可以使用别名表示一个具体的类型
     -->
    <typeAliases>
    	<!--
    		type:设置需要起别名的类型
    		alias:设置某个类型的别名
    	-->
        <!--<typeAlias type="com.atguigu.mybatis.pojo.User" alias="user"></typeAlias>-->
        
        <!-- 也可以指定一个包下面的别名, 且不区分大小写, 跟上方 typeLias 不能同时使用 -->
         <package name="com.atguigu.mybatis.pojo"></package>
    </typeAliases>
  
    <!-- ... -->
</configuration>

5.4核心配置文件之mappers

 <!--引入mybatis的映射文件-->
    <mappers>
        <!--<mapper resource="mapper/UserMapper.xml"/>-->
        <!--
            以包的方式引入映射文件,但是必须满足两个条件:
                1.mapper接口和映射文件所在的包必须一致
                2.mapper接口的名字和映射文件的名字必须一致
        -->
        <package name="com.qq.mybatis.Mapper"></package>
    </mappers>

5.5核心配置文件和映射文件的模板

File->Setting->Editor->File and Code Templates
在这里插入图片描述
核心配置文件mybatis-config.xml模板

<?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 resource="jdbc.properties"/>
    <typeAliases>
        <package name="实体类所在的包"/>
    </typeAliases>
    
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <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="映射文件所在的包"/>
    </mappers>

</configuration>

映射文件的模板mybatis-mapper.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=" ">

</mapper>

6.MyBatis获取参数值的两种方式

MyBatis获取参数的两种方式:${}和#{}
${}的本质就是字符串拼接,#{}的本质就是占位符赋值
${}使用字符串拼接的方式拼接sql,若为字符串类型或者日期类型的字段进行赋值时,需要手动加单引号;但是#{}使用占位符赋值的方式拼接sql,此时为字符串类型或者日期类型的字段进行赋值时,可以自动添加单引号

6.1单个字面量类型参数

若mapper接口中的方法参数为单个的字面量类型
此时可以使用 $KaTeX parse error: Expected 'EOF', got '#' at position 4: {}和#̲{}以任意的名称获取参数的值,\dots$ {}需要手动加单引号
UserMapper接口:

//根据用户名进行查询用户信息
    User getUserByUsername(String username);

UserMapper.xml代码:

<!-- 占位符方式 -->
<!--User getUserByUsername(String username);-->
    <select id="getUserByUsername" resultType="User">
        select * from t_user where username=#{username}
    </select>
<!-- 字符串拼接方式 -->
<!--User getUserByUsername(String username);-->
    <select id="getUserByUsername" resultType="User">
        select * from t_user where username='${username}'
    </select>

测试类:

//根据用户名进行查询用户信息
    @Test
    public void SelectUserTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        User user=mapper.getUserByUsername("admin");
        System.out.println(user);
    }

6.2多个字面量类型的参数

若mapper接口中的方法参数为多个时
此时MyBatis会自动将这些参数放在一个map集合中,以arg0,arg1…为键,以参数为值;以param1,param2…为键,以参数为值;因此只需要通过 $KaTeX parse error: Expected 'EOF', got '#' at position 4: {}和#̲{}访问map集合的键就可以获\dots$ {}需要手动单引号
UserMapper接口:

//验证登录
    User checkLogin(String username,String password);

mapper/UserMapper.xml:

<!--
    User checkLogin(String username,String password);
    -->
    <select id="checkLogin" resultType="User">
        select * from t_user where username=#{arg0} and password=#{arg1}
    </select>

测试类:

 //检验登录
    @Test
    public void CheckLoginTest(){
        SqlSession sqlSession=SqlSessionUtil.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        User user=mapper.checkLogin("admin","123456");
        System.out.println(user);
    }

6.3map集合类型的参数

只需要通过 $KaTeX parse error: Expected 'EOF', got '#' at position 4: {}和#̲{}访问map集合的键就可以获\dots$ {}需要手动单引号
UserMapper接口:

 //验证登录(以map集合作为参数)
    User checckLoginByMap(Map<String,Object> map);

mapper/UserMapper.xml:

<!--User checckLoginByMap(Map<String,Object> map);-->
    <select id="checckLoginByMap" resultType="User">
        select * from t_user where username=#{username} and password=#{password}
    </select>

测试类:

 @Test
    public void CheckLoginByMapTest(){
        SqlSession sqlSession=SqlSessionUtil.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map=new HashMap<String, Object>();
        map.put("username","admin");
        map.put("password","123456");
        User user=mapper.checckLoginByMap(map);
        System.out.println(user);
    }

6.4单个POJO（最常用）

若mapper接口方法的参数为实体类类型参数
只需要通过#{}和 ${}访问实体类中的属性名,就可以获取相对应的属性值, 一定要注意$ {}的单引号问题
UserMapper接口:

//添加用户信息
    void insertUser(User user);

UserMapper.xml

 <!--
    void insertUser(User user);
    -->
    <insert id="insertUser" >
        insert into t_user values (null ,#{username},#{password},#{age},#{gender},#{email})
    </insert>

测试类:

 //添加用户信息
    @Test
    public void InsertUserTest(){
        SqlSession sqlSession=SqlSessionUtil.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        User user=new User(null,"jack","1256",12,"女","456@qq.com");
        mapper.insertUser(user);
    }

6.5 @Param （最常用）

可以在mapper接口方法的参数上设置@Param注解
此时MyBatis会将这些参数放在map中,以两种方式进行存储
(1)以@Param注解的value属性值围为键,以参数为值
(2)以param1,[aram2…为键,以参数为值;
只需要通过#{}和 ${}访问实体类中的属性名,就可以获取相对应的属性值 **注意$ {}需要手动单引号**

UserMapper接口:

User checkLoginParam(@Param("username")String username,@Param("password")String password);

mapper/UserMapper.xml

<!--User checkLoginParam(@Param("username")String username,@Param("password")String password);-->
    <select id="checkLoginParam" resultType="User">
        select * from t_user where username=#{username} and password=#{password}
    </select>

测试类:

@Test
    public void CheckLoginParamTest(){
        SqlSession sqlSession=SqlSessionUtil.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        User user=mapper.checkLoginParam("admin","123456");
        System.out.println(user);
    }

7.MyBatis的各种查询功能

7.1查询一个实体类对象

创建SelectMapper接口

执行SelectMapper相对应的测试类前,如果mapper映射文件为<mapper resource="Mapper/UserMapper.xml"/>,则在mybatis-config.xml中配置映射文件中加入<mapper resource="Mapper/SelectMapper.xml"/>,如果为packepage则不需要加入

//根据id查询用户信息
    User getUserById(@Param("id")Integer id);

mapper/SelectMapper.xml

<!--User getUserById(@Param("id")Integer id);-->
    <select id="getUserById" resultType="User">
        select * from t_user where id=#{id}
    </select>

测试类:

@Test
    public void SelectTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        SelectMapper mapper=sqlSession.getMapper(SelectMapper.class);
        User user=mapper.getUserById(3);
        System.out.println(user);
    }

7.2查询一个list集合

若sql语句查询的结果为多条时,一定不能以实体类类型作为方法的返回值
否则会抛出异常TooManyResultsException
若sql语句查询的结果为1条时,此时可以使用实体类类型或list集合类型作为方法的返回值

SelectMapper接口:

//查询所有的用户信息
    List<User> getAllUser();

mapper/SelectMapper.xml

 <!--List<User> getAllUser();-->
    <select id="getAllUser" resultType="User">
        select * from t_user
    </select>

测试类:

@Test
    public void GetAllUserTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        SelectMapper mapper=sqlSession.getMapper(SelectMapper.class);
        List<User> list=mapper.getAllUser();
        list.forEach(System.out::println);
    }

7.3查询单个数据

MyBatis 为 java中常用的类型设置了类型别名.
int → java.lang.Integer
string → java.lang.String
_int → int
map → java.utils.Map;

SelectMapper接口:

//查询用户信息的总数量
    Integer getCount();

mapper/SelectMapper.xml

<!--Integer getCount();-->
    <select id="getCount" resultType="int">
        select count(*) from t_user
    </select>

测试类:

 @Test
    public void GetCountTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        SelectMapper mapper=sqlSession.getMapper(SelectMapper.class);
        int result=mapper.getCount();
        System.out.println("result:"+result);
    }

7.4查询一条数据为map集合

查询的结果没有对应的实体类的时候，就可以使用Map集合。
resultType 设置成 map 即可.

‼️ 查询为null 的字段是不会放到Map集合里面。
SelectMapper接口:

//根据id查询用户信息为map集合
    Map<String,Object> getUserByIdToMap(@Param("id")Integer id);

mapper/SelectMapper.xml

<!--Map<String,Object> getUserByIdToMap(@Param("id")Integer id);-->
    <select id="getUserByIdToMap" resultType="map">
        select * from t_user where id=#{id}
    </select>

测试类:

 //根据id查询用户信息为map集合
    @Test
    public void GetUserByIdToMapTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        SelectMapper mapper=sqlSession.getMapper(SelectMapper.class);
        Map<String,Object> map=mapper.getUserByIdToMap(1);
        System.out.println(map);
    }

7.5查询多条数据为map集合

若查询的数据有多条时,并且要将每条数据转换为map集合

方式一

将mapper接口方法的返回值设置为泛型是map的list集合
SelectMapper接口:

//查询所有的用户信息为map集合
    List<Map<String,Object>> getAllUserToMap();

mapper/SelectMapper.xml

 <!--List<Map<String,Object>> getAllUserToMap();-->
    <select id="getAllUserToMap" resultType="map">
        select * from t_user
    </select>

测试类:

//查询所有的用户信息为map集合
    @Test
    public void GetAllUserToMapTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        SelectMapper mapper=sqlSession.getMapper(SelectMapper.class);
        List<Map<String,Object>> map=mapper.getAllUserToMap();
        System.out.println(map);
    }

结果:{password=123456, gender=男, id=1, age=23, email=12345@qq.com, username=admin},
{password=1238, gender=男, id=3, age=23, email=12345@qq.com, username=root},
{password=123, gender=女, id=4, age=10, email=123@qq.com, username=root},
{password=1256, gender=女, id=5, age=12, email=456@qq.com, username=jack}

方式二

可以将每条数据转换的map集合放在一个大的map中,但是必须通过@MapKey注解,将查询的某个字段的值作为大的map集合

SelectMapper接口:

@MapKey("id")
    Map<String,Object> getAllUserMap();

mapper/SelectMapper.xml

<!--Map<String,Object> getAllUserMap();-->
    <select id="getAllUserMap" resultType="map">
        select * from t_user
    </select>

测试类:

 @Test
    public void GetAllUserMapTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        SelectMapper mapper=sqlSession.getMapper(SelectMapper.class);
        Map<String,Object> map=mapper.getAllUserMap();
        System.out.println(map);
    }

结果:{
1={password=123456, gender=男, id=1, age=23, email=12345@qq.com, username=admin},
3={password=1238, gender=男, id=3, age=23, email=12345@qq.com, username=root},
4={password=123, gender=女, id=4, age=10, email=123@qq.com, username=root},
5={password=1256, gender=女, id=5, age=12, email=456@qq.com, username=jack}
}

8.特殊SQL的执行

8.1模糊查询

SpecialSQLMapper接口:

//通过用户名模糊查询用户信息
    List<User> getUserByLike(@Param("username")String username);

mapper/SpecialSQLMapper.xml

 <!-- List<User> getUserByLike(@Param("username")String username);-->
    <select id="getUserByLike" resultType="User">
--         select * from t_user where username like "%"#{username}"%"
        select * from t_user where username like concat('%',#{username},'%')
--         select * from t_user where username like '%${username}%'
    </select>

测试类:

//通过用户名模糊查询用户信息
    @Test
    public void GetUserByLikeTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        SpecialSQLMapper mapper=sqlSession.getMapper(SpecialSQLMapper.class);
        List<User> list=mapper.getUserByLike("a");
        System.out.println(list);
    }

8.2批量删除

SpecialSQLMapper接口:

//批量删除
    int deleteMore(@Param("ids")String ids);

mapper/SpecialSQLMapper.xml

<!--int deleteMore(@Param("id")Integer id);-->
    <delete id="deleteMore">
        delete from t_user where id in (${ids})
    </delete>

测试类:

 //批量删除
    @Test
    public  void DeleteMoreTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        SpecialSQLMapper mapper=sqlSession.getMapper(SpecialSQLMapper.class);
        int result=mapper.deleteMore("4,5");
        System.out.println(result);
    }

8.3动态设置表名

SpecialSQLMapper接口:

//动态设置表名,查询所有的用户信息
    List<User> getUserList(@Param("tableName")String tableName);

mapper/SpecialSQLMapper.xml:

 <!--List<User> getAllUser(@Param("tableName")String tableName);-->
    <select id="getUserList" resultType="User">
        select * from ${tableName}
    </select>

测试类:

//动态设置表名,查询所有的用户信息
    @Test
    public void GetUserListTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        SpecialSQLMapper mapper=sqlSession.getMapper(SpecialSQLMapper.class);
        List<User> list=mapper.getUserList("t_user");
        System.out.println(list);
    }

8.4添加功能获取自增的主键

场景模拟:
t_clazz(clazz_id,clazz_name)
t_student(student_id,student_name,clazz_id)
1.添加班级信息
2.获取新添加的班级id
3.为班级分配学生,即将某学的班级id修改为添加的班级的id
TestJDBC:

  @Test
    public void TestJDBC(){
        try {
            Class.forName("");
            Connection connection= DriverManager.getConnection("","","");
            String sql="insert into t_user values()";
            PreparedStatement ps=connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            ps.executeUpdate();
            ResultSet resultSet=ps.getGeneratedKeys();
            resultSet.next();
            int id=resultSet.getInt(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

SpecialSQLMapper接口:

//添加用户信息并获取自增的主键
    void insertUser(User user);

SpecialSQLMapper.xml

<!--void insertUser(User user);-->
    <!--
        useGeneratedKeys:表示当前添加功能使用自增的主键
        keyProperty:将添加的数据的自增主键为实体类类型的参数的属性赋值
    -->
    <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
        insert into t_user values (null ,#{username},#{password},#{age},#{gender},#{email})
    </insert>

测试类:

 //添加用户信息并获取自增的主键
    @Test
    public void InsertUserTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        SpecialSQLMapper mapper=sqlSession.getMapper(SpecialSQLMapper.class);
        User user=new User(null,"小明","1234",23,"男","1234@qq.comm");
        mapper.insertUser(user);
        System.out.println(user);
    }

9.自定义映射resultMap

9.1resultMap处理字段和属性的映射关系

若字段名和实体类中的属性不一致,则可以通过resultMap设置自定义映射\

搭建一个新的MyBatis框架
创建两个表:
(1)t_emp:
在这里插入图片描述

(2)t_dept:
在这里插入图片描述
实体类:
(1)Emp

package com.mybatis.POJO;

public class Emp {

    private Integer empId;

    private String empName;

    private Integer age;

    private String gender;

    public Emp() {

    }

    @Override
    public String toString() {
        return "Emp{" +
                "empId=" + empId +
                ", empName='" + empName + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }

    public Integer getEmpId() {
        return empId;
    }

    public void setEmpId(Integer empId) {
        this.empId = empId;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public Integer getAge() {
        return age;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Emp(Integer empId, String empName, Integer age, String gender) {
        this.empId = empId;
        this.empName = empName;
        this.age = age;
        this.gender = gender;
    }
}

(2)Dept

package com.mybatis.POJO;

public class Dept {

    private Integer deptId;

    private String deptName;

    public Dept() {

    }

    @Override
    public String toString() {
        return "Dept{" +
                "deptId=" + deptId +
                ", deptName='" + deptName + '\'' +
                '}';
    }

    public Integer getDeptId() {
        return deptId;
    }

    public void setDeptId(Integer deptId) {
        this.deptId = deptId;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    public Dept(Integer deptId, String deptName) {
        this.deptId = deptId;
        this.deptName = deptName;
    }
}

EmpMapper接口:

//根据id查询员工信息
    Emp getEmpByEmpId(@Param("empId")Integer empId);

mapper/EmpMapper.xml:

  <!--Emp getEmpByEmpId(@Param("empId")Integer empId);-->
    <select id="getEmpByEmpId" resultType="Emp">
        select * from t_emp where emp_id=#{empId};
    </select>

测试类:

 //根据id查询用户信息
    @Test
    public void GetEmpByEmpIdTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        EmpMapper mapper=sqlSession.getMapper(EmpMapper.class);
        Emp emp=mapper.getEmpByEmpId(4);
        System.out.println(emp);
    }

执行结果:
Emp{empId=null, empName=null, age=18, gender=‘女’}

为什么为null?

字段名和属性名不一致的情况,如何处理映射关系
1.为查询的字段设置别名,和属性名保持一致
2.当字段符合MySQL的要求适应_,而属性符合java的要求使用驼峰
此时可以在MyBatis的核心配置文件中设置一个全局配置,可以自动将下划线映射为驼峰

mybatis-config.xml

<!--将下划线映射为驼峰-->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

执行结果:
Emp{empId=4, empName=‘爱丽丝’, age=18, gender=‘女’}

3.使用resultMap自定义映射文件
mapper/EmpMapper.xml:

<!--
        resultMap:设置自定义的映射关系
        	id:唯一标识
        	type:处理映射关系的实体类的类型
        常用标签:
        	id:处理主键和实体类中属性的映射关系
        	result:处理普通字段和实体类中属性的映射关系
        		column:设置映射关系中的字段名,必须是sql查询出的某个字段
       		 	property:设置映射关系中的属性的属性名,必须是处理的实体类类型中的属性名
    -->
    <resultMap id="EmpByEmpId" type="Emp">
        <id property="empId" column="emp_id"/>
        <result property="empName" column="emp_name"/>
    </resultMap>
    <!--Emp getEmpByEmpId(@Param("empId")Integer empId);-->
    <select id="getEmpByEmpId" resultMap="EmpByEmpId">
        select * from t_emp where emp_id=#{empId};
    </select>

9.2多对一映射处理

9.2.1级联方式处理映射关系

Emp.java中添加:

private Dept dept;

    @Override
    public String toString() {
        return "Emp{" +
                "empId=" + empId +
                ", empName='" + empName + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", dept=" + dept +
                '}';
    }

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

EmpMapper接口:

//根据id获取员工信息和部门信息
    Emp getEmpAndDeptByEmpId(@Param("empId") Integer empId);

mapper/EmpMapper.xml:

  <resultMap id="empAndDeptByEmpId" type="Emp">
        <id property="empId" column="emp_id"/>
        <result property="empName" column="emp_name"/>
        <result property="age" column="age"/>
        <result property="gender" column="gender"/>
        <result property="dept.deptId" column="dept_id"/>
        <result property="dept.deptName" column="dept_name"/>
    </resultMap>
    <!--Emp getEmpAndDeptByEmpId(@Param("empId") Integer empId);-->
    <select id="getEmpAndDeptByEmpId" resultMap="empAndDeptByEmpId">
        select
        t_emp.*,t_dept.*
        from t_emp
        left join t_dept
        on t_emp.dept_id=t_dept.dept_id
        where t_emp.emp_id=#{empId}
    </select>

测试类:

 //根据id获取员工信息和部门信息
    @Test
    public void GetEmpAndDeptByEmpIdTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        EmpMapper mapper=sqlSession.getMapper(EmpMapper.class);
        Emp emp=mapper.getEmpAndDeptByEmpId(1);
        System.out.println(emp);
    }

9.2.2使用association处理映射关系

<resultMap id="empAndDeptByEmpId" type="Emp">
        <id property="empId" column="emp_id"/>
        <result property="empName" column="emp_name"/>
        <result property="age" column="age"/>
        <result property="gender" column="gender"/>
        <!--
            association:处理多对一的映射关系(处理实体类类型的属性)
                property:设置需要处理映射关系的属性的属性名
                javaType:设置要处理的属性的类型
        -->
        <association property="dept" javaType="Dept">
            <id property="deptId" column="dept_id"/>
            <result property="deptName" column="dept_name"/>
        </association>
    </resultMap>
    <!--Emp getEmpAndDeptByEmpId(@Param("empId") Integer empId);-->
    <select id="getEmpAndDeptByEmpId" resultMap="empAndDeptByEmpId">
        select
        t_emp.*,t_dept.*
        from t_emp
        left join t_dept
        on t_emp.dept_id=t_dept.dept_id
        where t_emp.emp_id=#{empId}
    </select>

9.2.3分步查询

1.查询员工信息

EmpMapper接口:

//通过分步查询查询员工信息和部门信息第一步
    Emp getEmpAndDeptByStepOne(@Param("empId")Integer empId);

mapper/EmpMapper.xml:

   <resultMap id="EmpAndDeptByStepOne" type="Emp">
        <id property="empId" column="emp_id"/>
        <result property="empName" column="emp_name"/>
        <result property="age" column="age"/>
        <result property="gender" column="gender"/>
        <!--
            property:设置需要处理映射关系的属性的属性名
            select:设置分步查询的sql的唯一标识
            column:将出啊寻出的某个字段作为分步查询得sql的条件
        -->
        <association property="dept"
                     select="com.mybatis.Mapper.DeptMapper.getEmpAndDeptByStepTwo"
                     column="dept_id">
        </association>
    </resultMap>
    <!--Emp getEmpAndDeptByStepOne(@Param("empId")Integer empId);-->
    <select id="getEmpAndDeptByStepOne" resultMap="EmpAndDeptByStepOne">
        select * from t_emp where emp_id=#{empId}
    </select>

DepteaMapper接口

public interface DeptMapper {

    //通过分步查询查询员工信息和部门信息第二步
    Dept getEmpAndDeptByStepTwo(@Param("deptId") Integer deptId);
}

mapper/DeptMapper.xml:

<!--Dept getEmpAndDeptByStepTwo(@Param("deptId") Integer deptId);-->
    <select id="getEmpAndDeptByStepTwo" resultType="Dept">
        select * from t_dept where dept_id=#{deptId}
    </select>

测试类:

//分步查询
    @Test
    public void GetEmpAndDeptByStepTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        EmpMapper mapper=sqlSession.getMapper(EmpMapper.class);
        Emp emp=mapper.getEmpAndDeptByStepOne(1);
        System.out.println(emp);
    }
}

2.根据员工所对应的部门id查询部门信息

//根据id查询员工信息
    Emp getEmpByEmpId(@Param("empId")Integer empId);

<!--Emp getEmpByEmpId(@Param("empId")Integer empId);-->
    <select id="getEmpByEmpId" resultMap="EmpByEmpId">
        select * from t_emp where emp_id=#{empId};
    </select>

延迟加载:

<settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--按需加载-->
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

 <!--
            association:处理多对一的映射关系(处理实体类类型的属性)
                property:设置需要处理映射关系的属性的属性名
                javaType:设置要处理的属性的类型
                select:设置分步查询的sql的唯一标识
                column:将发出的某个字段作为分步查询的sql的条件
                fetchType:在开启了延迟加载的环境中,通过该属性设置当前的分步查询是否使用延迟加载
                fetchType="eager(立即加载)|lazy(延迟加载)"
        -->
        <association property="dept" fetchType="eager"
                     select="com.mybatis.Mapper.DeptMapper.getEmpAndDeptByStepTwo"
                     column="dept_id">
        </association>

9.3一对多映射处理

9.3.1 collection

POJO：一个 Dept 对应多个 Emp

public class Dept {
    private Integer deptId;
    private String deptName;

    private List<Emp> emps;
  
    // getter/setter/toString
}

DeptMapper接口:

 //查询部门以及部门中的员工信息
    Dept getDeptAndEmpByDeptId(@Param("deptId")Integer deptId);

mapper/DeptMapper.xml

  <resultMap id="deptAndEmpResultMap" type="Dept">
        <id property="deptId" column="dept_id"/>
        <result property="deptName" column="dept_name"/>
        <!--
            collection:处理一对多的映射关系(处理集合类型的属性)
            ofType:设置集合类型的属性中存储的数据的类型
        -->
        <collection property="emps" ofType="Emp">
            <id property="empId" column="emp_id"/>
            <result property="empName" column="emp_name"/>
            <result property="age" column="age"/>
            <result property="gender" column="gender"/>
        </collection>
    </resultMap>
    <!--Dept getDeptAndEmpByDeptId(@Param("deptId")Integer deptId);-->
    <select id="getDeptAndEmpByDeptId" resultMap="deptAndEmpResultMap">
        select *
        from t_dept
        left join t_emp
        on t_dept.dept_id=t_emp.dept_id
        where t_dept.dept_id=#{deptId}
    </select>

测试类:

//查询部门以及部门中的员工信息
    @Test
    public void GetDeptAndEmpByDeptIdTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        DeptMapper mapper=sqlSession.getMapper(DeptMapper.class);
        Dept dept=mapper.getDeptAndEmpByDeptId(1);
        System.out.println(dept);
    }

9.3.2 分步查询

1.查询员工信息

实体类:

public class Dept {

    private Integer deptId;

    private String deptName;

    private List<Emp> emps;
}

DeptMapper接口:

//通过分步查询查询部门以及所在部门的员工信息第一步
    Dept getDeptAndEmpStepOne(@Param("deptId") Integer deptId);

mapper/DeptMapper.xml

<resultMap id="deptAneEmpResultMapByStep" type="Dept">
        <id property="deptId" column="dept_id"/>
        <result property="deptName" column="dept_name"/>
        <collection property="emps" fetchType="eager"
                    select="com.mybatis.Mapper.EmpMapper.getDeptAndEmpStepTwo"
                    column="dept_id"
                    ></collection>
    </resultMap>
    <!--Dept getDeptAndEmpByStepOne(@Param("deptId")Integer deptId);-->
    <select id="getDeptAndEmpStepOne" resultMap="deptAneEmpResultMapByStep">
        select * from t_dept where dept_id=#{deptId}
    </select>

EmpMapper接口:

//通过分步查询查询部门以及所在部门的员工信息第二步
    Emp getDeptAndEmpStepTwo(@Param("deptId") Integer deptId);

mapper/EmpMapper.xml

<!-- Emp getDeptAndEmpStepTwo(@Param("empId") Integer empId);-->
    <select id="getDeptAndEmpStepTwo" resultType="Emp">
    SELECT *
    FROM t_emp
    WHERE dept_id = #{deptId};
</select>

测试类:

//通过分步查询查询部门以及所在部门的员工信息
    @Test
    public void GetDeptAndEmpByStepTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        DeptMapper mapper=sqlSession.getMapper(DeptMapper.class);
        Dept dept=mapper.getDeptAndEmpStepOne(1);
        System.out.println(dept);
        System.out.println("获取部门"+dept.getDeptName());
    }

2.根据员工所对应的部门id查询部门信息

//根据id查询员工信息
    Emp getEmpByEmpId(@Param("empId")Integer empId);

<!--Emp getEmpByEmpId(@Param("empId")Integer empId);-->
    <select id="getEmpByEmpId" resultMap="EmpByEmpId">
        select * from t_emp where emp_id=#{empId};
    </select>

分布查询的优点:可以实现延迟加载
但是必须在核心配置文件中设置全局配置信息
lazyLoadingEnabled:延迟加载的全局开关。当开启时,所有关联对象都会延迟加载
aggressiveLazyLoading:当开启时,任何方法的调动都会加载该对象的所有属性,否则,每个属性会按需加载。
此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql，此时可通过association和collection中的fetchType属性设置当前的分步查询是否使用延迟加载，fetchType=“lazy（延迟加载）|eager（立即加载）”

10.动态SQL

MyBatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能,他存在的意义是为了解决拼接SQL语句字符串时的痛点问题。

10.1 if

if标签可通过test属性的表达式进行判断,若表达式的结果为true,则标签中的内容会执行;反之标签中的内容不会执行
DynamicSQLMapper接口:

//根据条件查询员工信息
    List<Emp> getEmpByCondition(Emp emp);

mapper/DynamicSQLMapper.xml

 <!--
        动态标签:
            if:通过test属性中的表达式判断标签中的内容是否有效(是否会拼接到sql中)
    -->
    <!--List<Emp> getEmpByCondition(Emp emp);-->
    <select id="getEmpByCondition" resultType="Emp">
        select * from t_emp where
        <if test="empName!= null and empName!=''">
            emp_name=#{empName}
        </if>
        <if test="age !=null and age!=''">
            and age=#{age}
        </if>
        <if test="gender !=null and gender!=''">
            and gender=#{gender}
        </if>
    </select>

测试类:

//根据条件查询员工信息
    @Test
    public void GetEmpByConditionTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        DynamicSQLMapper mapper=sqlSession.getMapper(DynamicSQLMapper.class);
        Emp emp=new Emp(null,"张三",23,"男");
        List<Emp> list=mapper.getEmpByCondition(emp);
        System.out.println(list);
    }

10.2 where

List<Emp> getEmpByConditionOne(Emp emp);

<select id="getEmpByConditionOne" resultType="Emp">
        select * from t_emp
        <!--
            where:
            1.若where标签中有条件成立,会自动生成where关键字
            2.会自动将where标签中内容前多余的and去掉,但是其中内容后多余的and无法去掉
            3.若where标签中没有任何一个条件成立,则where没有任何功能
        -->
        <where>
            <if test="empName!= null and empName!=''">
                emp_name=#{empName}
            </if>
            <if test="age !=null and age!=''">
                and age=#{age}
            </if>
            <if test="gender !=null and gender!=''">
                and gender=#{gender}
            </if>
        </where>
    </select>

测试类:

 @Test
    public void GetEmpByConditionOneTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        DynamicSQLMapper mapper=sqlSession.getMapper(DynamicSQLMapper.class);
        List<Emp> list=mapper.getEmpByConditionOne(new Emp(null,"张三",20,"男"));
        System.out.println(list);
    }

10.3 trim

DynamicSQLMapper接口:

List<Emp> getEmpByConditionTwo(Emp emp);

mapper/DynamicSQLMapper.xml

<select id="getEmpByConditionTwo" resultType="Emp">
        select * from t_emp
        <!--
            trim:
                prefix,suffix:在标签中内容前面或后面添加指定内容
                prefixOverrides,suffixOverrides:在标签中内容前面或后面去掉指定内容
        -->
        <trim prefix="where" suffixOverrides="and">
            <if test="empName!= null and empName!=''">
                emp_name=#{empName} and
            </if>
            <if test="age !=null and age!=''">
                age=#{age} and
            </if>
            <if test="gender !=null and gender!=''">
               gender=#{gender}
            </if>
        </trim>
    </select>

测试类:

 @Test
    public void GetEmpByConditionTwoTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        DynamicSQLMapper mapper=sqlSession.getMapper(DynamicSQLMapper.class);
        List<Emp> list=mapper.getEmpByConditionTwo(new Emp(null,"张三",20,"男"));
        System.out.println(list);
    }

10.4 choose、when、otherwise

//使用choose查询员工信息
    List<Emp> getEmpByChoose(Emp emp);

 <!--
        choose.when,otherwise
        相当于java中的if...else,if...else
        when至少设置一个,otherwise最多设置一个
    -->
    <!--List<Emp> getEmpByChoose(Emp emp);-->
    <select id="getEmpByChoose" resultType="Emp">
        select * from t_emp
        <where>
            <choose>
                <when test="empName!= null and empName!=''">
                    emp_name=#{empName}
                </when>
                <when test="age !=null and age!=''">
                    age=#{age}
                </when>
                <when test="gender !=null and gender!=''">
                    gender=#{gender}
                </when>
                <otherwise></otherwise>
            </choose>
        </where>
    </select>

@Test
    public void GetEmpByChooseTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        DynamicSQLMapper mapper=sqlSession.getMapper(DynamicSQLMapper.class);
        List<Emp> list=mapper.getEmpByChoose(new Emp(null,"张三",20,"男"));
        System.out.println(list);
    }

10.5 foreach

1.批量添加

//批量添加员工信息
    void insertMoreEmp(@Param("emps") List<Emp> emps);

<!-- void insertMoreEmp(@Params("emps") List<Emp> emps); -->
    <insert id="insertMoreEmp">
        INSERT INTO t_emp
        VALUES
        <foreach collection="emps" item="emp" separator=",">
            (NULL, #{emp.empName}, #{emp.age}, #{emp.gender}, null)
        </foreach>
    </insert>

测试类:

  //批量添加
    @Test
    public void InsertMoreTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        DynamicSQLMapper mapper=sqlSession.getMapper(DynamicSQLMapper.class);
        Emp emp1=new Emp(null,"张三",20,"男");
        Emp emp2=new Emp(null,"王伟",23,"男");
        Emp emp3=new Emp(null,"小琼",24,"女");
        List<Emp> list= Arrays.asList(emp1,emp2,emp3);
        mapper.insertMoreEmp(list);
    }

2.批量删除

 //批量删除
    void deleteMoreEmp(@Param("empIds") Integer[] empIds);

 <!--
        foreach:
            collection:设置要循环的数组或集合
            item:用一个字符串表示数组或集合中的每一个数据
            separator:设置每次循环的数据之间的分隔符
            open:循环的所有内容以什么开始
            close:循环的所有内容以什么结束
    -->
    <!--void deleteMoreEmp(@Param("empIds") Integer[] empIds);-->
    <delete id="deleteMoreEmp">
        <!--delete from t_emp where emp_id in-->
        <!--<foreach collection="empIds" item="empId" separator="," open="(" close=")">-->
            <!--#{empId}-->
        <!--</foreach>-->
        delete from t_emp where
        <foreach collection="empIds" item="empId" separator="or">
            emp_id=#{empId}
        </foreach>
    </delete>

测试类:

 //批量删除
    @Test
    public void DeleteMoreTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        DynamicSQLMapper mapper=sqlSession.getMapper(DynamicSQLMapper.class);
        Integer [] empIds=new Integer[]{6,7};
        mapper.deleteMoreEmp(empIds);
    }

10.6 SQL片段

可以记录一段sql,在需要用的地方使用include标签进行使用

<sql id="empColumns">
        emp_id,emp_name,age,gender,dept_id
    </sql>

<select id="getEmpByCondition" resultType="Emp">
        select <include refid="empColumns"></include>
        from t_emp
</select>

11.MyBatis的缓存

11.1MyBatis的一级缓存

一级缓存时SqlSession级别的,通过同一个SqlSession查询的数据会被缓存,下次查询相同的数据,就会从缓存中直接获取,不会从数据库中重新访问

//根据员工id查询员工信息
    Emp getEmpById(@Param("empId") Integer empId);

<!--Emp getEmpById(@Param("empId") Integer empId);-->
    <select id="getEmpById" resultType="Emp">
        select * from t_emp where emp_id=#{empId}
    </select>

测试类:

 //根据员工id查询员工信息
    @Test
    public void GetEmpByIdTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        CacheMapper mapper=sqlSession.getMapper(CacheMapper.class);
        Emp emp1=mapper.getEmpById(1);
        System.out.println(emp1);
        Emp emp2=mapper.getEmpById(1);
        System.out.println(emp2);
    }

使用一级缓存失效的四种情况:
(1)不同的SqlSession对应不同的一级缓存
(2)同一个SqlSession但是查询条件不同
(3)同一个SqlSession两次查询期间执行了任何一次增删查改
(4)同一个SqlSession两次查询期间手动`清空了缓存

 //添加员工信息
    void insertEmp(Emp emp);

<!--void insertEmp(Emp emp);-->
    <insert id="insertEmp">
        insert into t_emp values (null ,#{empName},#{age},#{gender},null);
    </insert>

 //添加员工信息
    @Test
    public void InsertEmpTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        CacheMapper mapper=sqlSession.getMapper(CacheMapper.class);
        Emp emp1=mapper.getEmpById(1);
        System.out.println(emp1);
        sqlSession.clearCache();//清空
        mapper.insertEmp(new Emp(null,"小工",25,"男"));
        Emp emp2=mapper.getEmpById(1);
        System.out.println(emp2);
    }

11.2MyBatis的二级缓存

二级缓存时SqlSessionFactory级别,通过同一个SqlSessionFactory创建的SqlSession查询得结果会被缓存,此后若再次执行相同的查询语句,结果就会从缓存中获取
二级缓存开启的条件:
(1)在核心配置文件中,设置全局配置属性cacheEnabled=“true”,默认为true,不需要设置
(2)在映射文件中设置标签
(3)二级缓存必须在SqlSession关闭或提交之后有效
(4)查询的数据所转换的实体类类型必须实现序列化的接口
二级缓存失效的情况:
两次查询之间执行了什么的增删改,会使一级和二级缓存同使失效

 @Test
    public void CacheTest() throws IOException {
        InputStream is= Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder=new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory=sqlSessionFactoryBuilder.build(is);
        SqlSession sqlSession=sqlSessionFactory.openSession(true);
        CacheMapper mapper1=sqlSession.getMapper(CacheMapper.class);
        Emp emp1=mapper1.getEmpById(1);
        System.out.println(emp1);
        sqlSession.close();
        SqlSession sqlSession2=sqlSessionFactory.openSession(true);
        CacheMapper mapper2=sqlSession2.getMapper(CacheMapper.class);
        Emp emp2=mapper2.getEmpById(1);
        System.out.println(emp2);
    }

11.3二级缓存的相关配置

在mapper配置文件中添加的cache标签可以设置一些属性:
1.eviction属性:缓存回收策略,默认是LRU
LRU(Least Recently Used)-最近最少使用的:移除最长时间不被使用的对象。
FIFO（First in First out）-先进先出：按对象进入缓存的顺序来一处它们
SOFT-软引用：一处基于垃圾回收器状态和软引用规则的对象
WEAK-弱引用：更积极地一处基于垃圾收集器状态和弱引用规则的对象
2.flushInterval属性：刷新间隔，单位毫秒
默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新
3.size属性：引用数目，正整数
代表缓存最多可以存储多少个对象，太大容易导致内存溢出
4.readOnly属性：只读，true|false
true：只读存储缓存，会给所有调用者返回缓存对象的相同实例，因此这些对象不能被修改，这提供了很重要的性能优势。
false：读写缓存，会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false。

11.4MyBatis缓存查询的顺序

先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用。
如果二级缓存没有命中，在查询一级缓存
如果一级缓存也没有命中，则查询数据库
SqlSession关闭之后，一级缓存中的数据会写入二级缓存

11.5整合第三方缓存EHCache

11.5.1添加依赖

   <!--Mybatis EHCache整合包-->
        <dependency>
            <groupId>org.mybatis.caches</groupId>
            <artifactId>mybatis-ehcache</artifactId>
            <version>1.2.1</version>
        </dependency>

        <!--slf4j日志门面的一个具体实现-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

11.5.2各jar包功能

jar包名称	作用
mybatis-ehcache	Mybatis和EHCache的整合包
ehcache	EHCache核心包
logback-classic	支持SLF4J门面接口的一个具体实现
slf4j-api	SLF4J日志门面包

10.5.3创建EHCache的配置文件ehcache.xml

resources/ehcache.xml

<?xml version="1.0" encoding="utf-8" ?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    <!-- 磁盘保存路径 -->
    <diskStore path="D:\qq\ehcache"/>
    <defaultCache
            maxElementsInMemory="1000"
            maxElementsOnDisk="10000000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>
</ehcache>

10.5.4设置二级缓存的类型

mapper/CacheMapper.xml

<!--开启二级缓存-->
    <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

10.5.5加入logback日志

resources/logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true"> <!-- 指定日志输出的位置 -->
    <appender name="STDOUT">
        class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- 日志输出的格式 -->
            <!-- 按照顺序分别是:时间、日志级别、线程名称、打印日志的类、日志主体内容、换行 -->
            <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern>
        </encoder>
    </appender>
    <!-- 设置全局日志级别。日志级别按顺序分别是:DEBUG、INFO、WARN、ERROR -->
    <!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
    <root level="DEBUG">
        <!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender -->
        <appender-ref ref="STDOUT" />
    </root>
    <!-- 根据特殊需求指定局部日志级别 -->
    <logger name="com.mybatis.mapper" level="DEBUG"/>
</configuration>

12.Mybatis的逆向工程

正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表,Hibernate 是支持正向工程的。
逆向工程：先创建数据库表，由框架负责根据数据库表反向生成如下资源：

Java实体类。
Mapper接口。
Mapper映射文件

12.1创建逆向工程的步骤

1.添加依赖和插件

 <!-- 依赖MyBatis核心包 -->
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.3</version>
        </dependency>
        <!-- log4j日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

    </dependencies>
    <!-- 控制Maven在构建过程中相关配置 -->
    <build>
        <!-- 构建过程中用到的插件 -->
        <plugins>
            <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.0</version>
                <!-- 插件的依赖 -->
                <dependencies>
                    <!-- 逆向工程的核心依赖 -->
                    <dependency>
                        <groupId>org.mybatis.generator</groupId>
                        <artifactId>mybatis-generator-core</artifactId>
                        <version>1.3.2</version>
                    </dependency>
                    <!-- 数据库连接池 -->
                    <dependency>
                        <groupId>com.mchange</groupId>
                        <artifactId>c3p0</artifactId>
                        <version>0.9.2</version>
                    </dependency>
                    <!-- MySQL驱动 -->
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>5.1.8</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

2.创建MyBatis的核心配置文件

mybatis-config.xml

<?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 resource="jdbc.properties"/>
<!--将下划线映射为驼峰-->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    
    <typeAliases>
        <package name="com.mybatis.POJO"/>
    </typeAliases

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <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="Mapper/DeptMapper.xml"/>
        <mapper resource="Mapper/EmpMapper.xml"/>
    </mappers>

</configuration>

3.创建逆向工程的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>

    <!--
    targetRuntime: 执行生成的逆向工程的版本
        MyBatis3Simple: 生成基本的CRUD(清新简洁版)
        MyBatis3: 生成带条件的CRUD(奢华尊享版)
    -->
    <context id="DB2Tables" targetRuntime="MyBatis3Simple">
        <!-- 数据库的连接信息 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis"
                        userId="root"
                        password="数据库连接密码">
        </jdbcConnection>
        <!-- javaBean的生成策略-->
        <javaModelGenerator targetPackage="com.mybatis.POJO"
                            targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true"/>
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>
        <!-- SQL映射文件的生成策略 -->
        <sqlMapGenerator targetPackage="Mapper"
                         targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>
        <!-- Mapper接口的生成策略 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.mybatis.Mapper"
                             targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>
        <!-- 逆向分析的表 -->
        <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName --> <!-- domainObjectName属性指定生成出来的实体类的类名 -->
        <table tableName="t_emp" domainObjectName="Emp"/>
        <table tableName="t_dept" domainObjectName="Dept"/>
    </context>
</generatorConfiguration>

4.执行MBG插件的generate目标

在这里插入图片描述

5.逆向工程之奢华尊享版

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>

    <!--
    targetRuntime: 执行生成的逆向工程的版本
        MyBatis3Simple: 生成基本的CRUD(清新简洁版)
        MyBatis3: 生成带条件的CRUD(奢华尊享版)
    -->
    <context id="DB2Tables" targetRuntime="MyBatis3">
        <!-- 数据库的连接信息 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis"
                        userId="root"
                        password="123456">
        </jdbcConnection>
        <!-- javaBean的生成策略-->
        <javaModelGenerator targetPackage="com.mybatis.POJO"
                            targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true"/>
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>
        <!-- SQL映射文件的生成策略 -->
        <sqlMapGenerator targetPackage="Mapper"
                         targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>
        <!-- Mapper接口的生成策略 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.mybatis.Mapper"
                             targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>
        <!-- 逆向分析的表 -->
        <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName --> <!-- domainObjectName属性指定生成出来的实体类的类名 -->
        <table tableName="t_emp" domainObjectName="Emp"/>
        <table tableName="t_dept" domainObjectName="Dept"/>
    </context>
</generatorConfiguration>

测试类:

    @Test
    public void MBGTest(){
        try {
            InputStream is= Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactory sqlSessionFactory= new SqlSessionFactoryBuilder().build(is);
            SqlSession sqlSession=sqlSessionFactory.openSession(true);
            EmpMapper mapper=sqlSession.getMapper(EmpMapper.class);
            //查询所有数据
            List<Emp> emps=mapper.selectByExample(null);
            System.out.println(emps);
            //根据条件查询
            EmpExample empExample=new EmpExample();
            empExample.createCriteria().andEmpNameEqualTo("张三").andAgeGreaterThanOrEqualTo(12);
            empExample.or().andDidIsNotNull();
            List<Emp> emp=mapper.selectByExample(empExample);
            System.out.println(emp);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //修改
    @Test
    public void UpdateTest(){
        try {
            InputStream is= Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactory sqlSessionFactory= new SqlSessionFactoryBuilder().build(is);
            SqlSession sqlSession=sqlSessionFactory.openSession(true);
            EmpMapper mapper=sqlSession.getMapper(EmpMapper.class);
            int result=mapper.updateByPrimaryKey(new Emp(1,"sadmin",22,"女","4569@qq.com",3));
            System.out.println(result);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

13.分页插件

limit index,pageSize
pageSize:每页显示的条数
pageNum:当前页的页码
index:当前页的起始索引
index=(pageNum-1) x pageSize
count:总记录数
totalPage:总页数
totalPage=count/pageSize
if(count%pageSize!=0){
totalPage+=1;
}

首页上一页 2 3 4 5 6 下一页末页

13.1分页插件的使用步骤

1.添加依赖

 <!--分页插件-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.2.0</version>
        </dependency>

2.配置分页插件

<plugins>
        <!--设置分页插件-->
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>

13.2分页插件的使用

在查询功能之前使用PageHelper.startPage(int pageNum,int pageSize)开启分页功能

pageNum:当前页的页码
pageSize:每一页显示的条数

在查询获取list集合之后,使用PageInfo pageinfo=new PageInfo<>(Lstlist,int navigatePages)获取分页相关的数据

list:分页之后的数据
navigatePages:导航分页的页码数
isFirstPage/isLastPage:是否为第一页/最后一页
hasPreviousPage/hasNextPage:是否存在上一页/下一页
navigatePageNums:单反分页的页码[1,2,3,4,5]

 //分页插件
    @Test
    public void GetPageHelperTest(){
            SqlSession sqlSession= SqlSessionUtils.getSqlSession();
            EmpMapper mapper=sqlSession.getMapper(EmpMapper.class);
            System.out.println("\n查询功能前开启分页");
            PageHelper.startPage(2, 4);
            List<Emp> emps = mapper.selectByExample(null);
            System.out.println(emps);
            //查询功能之后可以获取分页相关的所有数据
            System.out.println("\n");
            PageInfo<Emp> pages = new PageInfo<Emp>(emps, 5);
            System.out.println("PageInfo----->"+pages);
            System.out.println("当前页的页码："+pages.getPageNum());
            System.out.println("每页显示的条数："+pages.getPageSize());
            System.out.println("总记录数："+pages.getTotal());
            System.out.println("总页数："+pages.getPages());
            System.out.println("上一页的页码："+pages.getPrePage());
            System.out.println("下一页的页码"+pages.getNextPage());
    }

二、1.Spring简介

1.1Spring概述

1、Spring 是轻量级的开源的 JavaEE 框架
2、Spring 可以解决企业应用开发的复杂性
3、Spring 有两个核心部分：IOC 和 Aop
（1）IOC：控制反转，把创建对象过程交给 Spring 进行管理
（2）Aop：面向切面，不修改源代码进行功能增强
4、Spring 特点
（1）方便解耦，简化开发
（2）Aop 编程支持
（3）方便程序测试
（4）方便和其他框架进行整合
（5）方便进行事务操作
（6）降低 API 开发难度

1.2Spring家族

项目列表:https://spring.io/projects

1.3Spring Framework

Spring基础框架,可以视为Spring基础设施,基本上任何其他spring项目都是以Spring Framework为基础的

1.3.1Spring Framework特性

•非侵入式：使用 Spring Framework 开发应用程序时，Spring 对应用程序本号的结构影啊非常小。对领域模型可以做到零污染;对功能性组件也只需要使用几个简单的注解进行标记，完全不会破坏原有结构，反而能将组件结构进一步简化。这就使得基于 Spring Framework 开发应用程序时结构清晰、简洁优雅。
•控制反转：1OC一Inversion of Control，翻转资源获取方向。把目己创建资源、向环境获取资源变成环境将资源准备好，我们享受资源入注。
•自回功面编程：AOP–Aspect Oriented Programming，在不修改源代码的基础上增强代码功能。
•容器：Spring lOC是一个容器，因为它包含并且管理组件对家的生命周期。组件享受到了容器化的管理，程序员屏蔽了组件创建过程中的大量细节，极大的降低了使用门槛，大幅度提高了开发双率。
•组件化：Spring 实现了使用简单的组件配置组合成一个复杂的应用。在Spring 中可以使用XML和Java注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不絮的搭建超大型复杂应用系统
•声明式：很多以前需要编写代码才能实现的功能,现在只需要声明需求即可由框架代为实现。
•一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库。而且Spring旗下的项目已经覆盖了广泛的领域，很多方面的功能性需求可以在Spring Framework的基础上全部使用Spring来实现。

1.3.2Spring Framework五大功能模块

功能模块	功能介绍
Core Container	核心容器，在Spring环境下使用任何功能都必须基于IOC容器
AOP&Aspects	面向切面编程
Testing	提供了对junit或TestNG测试框架的整合
Data Access/Integration	提供了对数据访问/集成的功能
Spring MVC	提供了面向Web应用程序的集成功能

2.IOC

2.1 IOC容器

2.1.1 IOC思想

IOC:Inversion of Control,翻译过来死反转控制。

获取资源的传统方式
在应用程序中的组件需要获取资源时，传统的方式时组件主动的从容器中获取所需要的资源，在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同使降低了开发效率。
反转控制方式获取资源
反转的控制思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向–改变容器主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的，只需要提供接收资源的方式即可，极大的降低了学习成本，提高了开发的效率。这种行为也称为查找的被动形式。
DI
DI:Dependency Injection,翻译过来是依赖注入
DI是IOC的另一种表达方式：即组件以一些预先定义好的方式（例如：setter方法）接受来自容器的资源注入。相对宇IOC而言，这种表述更直接。
所以结论是：IOC就是一种反转控制的思想，而DI是对IOC的一种具体实现。

2.1.2IOC容器在Spring中的实现

Spring的IOC容器就是IOC实现的一个落地的产品实现。IOC容器中的管理的组件也叫做bean。在创建bean之前，首先需要创建IOC容器。Spring提供了IOC容器的两种实现方式：

1. BeanFactory

这是IOC容器的基本实现，是Spring内部使用的接口。面向Spring本身，不提供给开发人员使用。

2. ApplicationContext

BeanFactory的子接口，提供了更多高级特性。面向Spring得使用者，几乎所有场合都使用 ApplicationContext，而不是底层的BeanFactory。

3. ApplicationContext的主要实现类

在这里插入图片描述

2.2基于XML管理bean

2.2.1实验一：入门案列

1.创建Meven Module

2.引入依赖

<dependencies>
        <!--基于Maven依赖传递性,导入spring-context依赖即可导入当前所需要所有jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>

        <!--junit测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

在这里插入图片描述

3.创建类HelloWorld

在这里插入图片描述

4.创建Spring的配置文件

在resources目录创建Spring配置文件
在这里插入图片描述
点击Spring Config创建applicationContext.xml

5.在Spring的配置文件中配置

   <?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--
        bean:配置一个bean对象,将对象交给IOC容器管理
        属性:
            id:bean的唯一表示,不能重复
            class:设置bean对象所对应的类型
     -->
    <bean id="helloworld" class="com.spring.POJO.HelloWorld"></bean>

</beans>

6.创建测试类测试

 @Test
    public void test(){
        //获取IOC容器
        ApplicationContext ioc=new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取IOC容器中的bean
        HelloWorld helloWorld=(HelloWorld) ioc.getBean("helloworld");
        helloWorld.sayHello();
    }

2.2.2 实验二：获取bean

创建实体类Student：

public class Student{

    private Integer sid;

    private String sname;

    private Integer age;

    private String gender;
    
    /*get/set/toString。。。*/
    }

获取bean的三种方式:

1. 方式一:根据bean的id获取

  @Test
    public void IOCTest(){
        //获取IOC
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        //获取bean
        Student student=(Student) ioc.getBean("studentOne");
        System.out.println(student);
    }
}

2.方式二:根据bean的类型获取

@Test
    public void IOCTest(){
        //获取IOC
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        //获取bean
        Student student=ioc.getBean(Student.class);
        System.out.println(student);
    }

3.方式三:根据bean的id和类型获取

/*
        获取bean的三种方式:
        1.根据bean的id获取
        2.根据bean的类型获取
        注意:根据类型获取bean时,要求IOC容器中有且只有一个类型匹配的bean
        若没有任何一个类型匹配的bean,此时抛出异常:NoSuchBeanDefinitionException
        若有多个类型匹配的bean,此时抛出异常:NoUniqueBeanDefinitionException
        3.根据bean的id和类型获取
     */

    @Test
    public void IOCTest(){
        //获取IOC
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        //获取bean
//        Student student=(Student) ioc.getBean("studentOne");
//        Student student=ioc.getBean(Student.class);
        Student student=ioc.getBean("studentOne",Student.class);
        System.out.println(student);
    }

4.注意

当根据类型获取bean时，要求IOC容器中指定类型的bean有且只有一个
当IOC容器中一共配置了两个：

 <bean id="studentOne" class="com.spring.POJO.Student"/>
    <bean id="studentTwo" class="com.spring.POJO.Student"/>

根据类型获取时会抛出异常：

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type ‘com.spring.POJO.Student’ available: expected single matching bean but found 2: studentOne,studentTwo

5.扩展

如果组件实现了接口,根据接口类型可以获取bean吗?

可以,前提是bean唯一
创建Person接口：

public interface Person {
}

public class Student implements Person{

    private Integer sid;

    private String sname;

    private Integer age;

    private String gender;

    public Student() {

    }
    /*get/set/toString。。。*/

测试类：

  @Test
    public void IOCTest(){
        //获取IOC
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        //获取bean
        Student student=ioc.getBean(Student.class);
        System.out.println(student);
        Person person=ioc.getBean(Person.class);
        System.out.println(person);
    }

如果一个接口有多个实现类,这些实现类都配置了bean,根据接口类型可以获取bean吗?

不行,因为bean不唯一

6.结论

根据类型来获取bean时,在满足bean唯一性的前提下,其实只是看:[对象instanceof指定的类型]的返回结果,只要返回的是true就可以认定为和类型匹配,能够获取到。

2.2.3实验三：依赖注入setter注入

1.创建学生类Student

public class Student{

    private Integer sid;

    private String sname;

    private Integer age;

    private String gender;

    public Student() {

    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", sname='" + sname + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }

    public Integer getSid() {
        return sid;
    }

    public void setSid(Integer sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Student(Integer sid, String sname, Integer age, String gender) {
        this.sid = sid;
        this.sname = sname;
        this.age = age;
        this.gender = gender;
    }
}

2.配置bean时为属性赋值

<bean id="studentOne" class="com.spring.POJO.Student"/>
    <bean id="studentTwo" class="com.spring.POJO.Student">
        <!--
            property:通过成员变量的set方法进行赋值
                name:设置需要赋值的属性名(和set方法有关)
                value:设置属性所赋的值
        -->
        <property name="sid" value="1001"/>
        <property name="sname" value="小明"/>
        <property name="age" value="23"/>
        <property name="gender" value="男"/>
    </bean>

3.测试

    @Test
    public void DITest(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        Student student=ioc.getBean("studentTwo",Student.class);
        System.out.println(student);
    }

2.2.4实验四：依赖注入之构造器注入

1.在Student类中添加有参构

public Student(Integer sid, String sname, Integer age, String gender) {
        this.sid = sid;
        this.sname = sname;
        this.age = age;
        this.gender = gender;
    }

2.配置bean

  <!--
        constructor-arg标签还有两个属性可以进一步描述构造参数
            index属性:指定参数所在的位置的索引(从0开始)
            name属性:指定参数名
    -->
    <bean id="studentThree" class="com.spring.POJO.Student">
        <constructor-arg value="1002"/>
        <constructor-arg value="爱丽丝"/>
        <constructor-arg value="女"/>
        <constructor-arg value="24" name="score"/>
    </bean>

3.测试

  @Test
    public void DI1Test(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        Student student=ioc.getBean("studentThree",Student.class);
        System.out.println(student);
    }

2.2.5实验五：特殊值处理

1.字面量赋值

什么是字面量?
int a=10;
声明一个变量a,初始化为10,此时a就不代表字母a了,而是作为一个变量的名字。当我们引用a的时候，我们实际上拿到的值是10。
而如果a是带引号的：‘a’，那么它现在不是一个变量，它就是嗲表a这个字母本身，这就是字面量。所以字面量没有引申含义，就是我们看到的这个数据本身。

<!--使用value属性给bean的属性赋值时,Spring会把value属性的值看做字面量-->
        <property name="sname" value="小明"/>

2.null值

<property name="sname">
            <null/>
        </property>

注意:
<property name="sname" value="null"/>
以上写法,为name所赋的值是字符串null

3.xml实体

<!--解决方案一:使用XML实体来代替(a<b)-->
        <property name="expression" value="a &lt; b"/>

4.CDATA节

 <!--
        CDATA节其中的内容会原样解析
        XML解析器看到CDATA节就知道这里是纯文本,就不会当作XML标签或属性来解析
    -->
<property name="sname">
            <value><![CDATA[<Tom>]]></value>
        </property>

2.2.6实验六：为类类型属性赋值

1.创建班级类Clazz

public class Clazz {

    private Integer clazzId;

    private String clazzName;

    public Clazz() {

    }

    public Clazz(Integer clazzId, String clazzName) {
        this.clazzId = clazzId;
        this.clazzName = clazzName;
    }

    @Override
    public String toString() {
        return "Clazz{" +
                "clazzId=" + clazzId +
                ", clazzName='" + clazzName + '\'' +
                '}';
    }

    public Integer getClazzId() {
        return clazzId;
    }

    public void setClazzId(Integer clazzId) {
        this.clazzId = clazzId;
    }

    public String getClazzName() {
        return clazzName;
    }

    public void setClazzName(String clazzName) {
        this.clazzName = clazzName;
    }
}

2.修改Student类

public class Student{

    private Integer sid;

    private String sname;

    private Integer age;

    private String gender;

    private Double score;

    private Clazz clazz;
   /* get/set/toString...*/
}

3.方式一：引用外部已声明的bean

<bean id="StudentFive" class="com.spring.POJO.Student">
        <property name="sid" value="100"/>
        <property name="sname" value="小琼"/>
        <property name="age" value="22"/>
        <property name="gender" value="女"/>
        <property name="score" value="100"/>
        <!--
            ref:引用IOC容器中的某个bean的id
        -->
        <property name="clazz" ref="clazzOne"></property>
    </bean>
    <bean id="clazzOne" class="com.spring.POJO.Clazz">
        <property name="clazzId" value="11"/>
        <property name="clazzName" value="奥赛班"/>
    </bean>

4.方式二：内部bean

<bean id="StudentFive1" class="com.spring.POJO.Student">
        <property name="sid" value="100"/>
        <property name="sname" value="小琼"/>
        <property name="age" value="22"/>
        <property name="gender" value="女"/>
        <property name="score" value="100"/>
        <!--
            内部bean,只能在当前bean的内部使用,不能直接通过IOC容器获取
        -->
        <property name="clazz">
            <bean id="clazzInner" class="com.spring.POJO.Clazz">
                <property name="clazzId" value="33"/>
                <property name="clazzName" value="普通班"/>
            </bean>
        </property>

    </bean>

测试类:

 @Test
    public void DITest1(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        Student student=ioc.getBean("StudentFive1",Student.class);
        System.out.println(student);
    }

5.方式三：级联属性赋值

  <bean id="StudentFive" class="com.spring.POJO.Student">
        <property name="sid" value="100"/>
        <property name="sname" value="小琼"/>
        <property name="age" value="22"/>
        <property name="gender" value="女"/>
        <property name="score" value="100"/>
        <!--
            ref:引用IOC容器中的某个bean的id
        -->
        <property name="clazz" ref="clazzOne"></property>
        <!--级联方式,要保证提前为clazz属性赋值或者实例化-->
        <property name="clazz.clazzId" value="22"/>
        <property name="clazz.clazzName" value="重点班"/>
    </bean>
    
    <bean id="clazzOne" class="com.spring.POJO.Clazz">
        <property name="clazzId" value="11"/>
        <property name="clazzName" value="奥赛班"/>
    </bean>

2.2.7实验七：为数组类型属性赋值

1.修改Student类

在Student类中添加以下代码:

 private String[] hobbies;

    public String[] getHobbies() {
        return hobbies;
    }

    public void setHobbies(String[] hobbies) {
        this.hobbies = hobbies;
    }
    /*重写toString*/

2.配置bean

<property name="hobbies">
            <array>
                <value>足球</value>
                <value>篮球</value>
                <value>羽毛球</value>
            </array>
        </property>

2.2.8实验八：为集合类型属性赋值

1.为List集合类型属性赋值

public class Clazz {

    private Integer clazzId;

    private String clazzName;
    
    private List<Student> students;
    /*get/set/toString*/
}

方法一:

 <bean id="clazz1" class="com.spring.POJO.Clazz">
        <property name="clazzId" value="11"/>
        <property name="clazzName" value="奥赛班"/>
        <property name="students">
            <list>
                <ref bean="studentOne"/>
                <ref bean="studentTwo"/>
            </list>
        </property>
    </bean>

方法二:

 <bean id="clazz2" class="com.spring.POJO.Clazz">
        <property name="clazzId" value="11"/>
        <property name="clazzName" value="奥赛班"/>
        <property name="students" ref="studentList"/>
    </bean>
    <!--配置一个集合类型的bean,需要使用util的约束-->
    <util:list id="studentList">
        <ref bean="studentOne"/>
        <ref bean="studentTwo"/>
    </util:list>

测试类:

  @Test
    public void DIClazz1Test(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        Clazz clazz=ioc.getBean("clazz1",Clazz.class);
        System.out.println(clazz);
    }

    @Test
    public void DIClazz2Test(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        Clazz clazz=ioc.getBean("clazz2",Clazz.class);
        System.out.println(clazz);
    }

2.为Map集合类型属性赋值

创建Teache实体类:

public class Teacher {
    
    private Integer tid;
    
    private String tname;

    public Teacher() {
        
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "tid=" + tid +
                ", tname='" + tname + '\'' +
                '}';
    }

    public Integer getTid() {
        return tid;
    }

    public void setTid(Integer tid) {
        this.tid = tid;
    }

    public String getTname() {
        return tname;
    }

    public void setTname(String tname) {
        this.tname = tname;
    }

    public Teacher(Integer tid, String tname) {
        this.tid = tid;
        this.tname = tname;
    }
}

在Student实体类中添加:

  private Map<String ,Teacher> teacherMap;
  /*get/set/toStrign...*/

bean.xml

<property name="teacherMap">
            <map>
                <entry key="1008" value-ref="teacherOne"/>
                <entry key="1009" value-ref="teacherTwo"/>
            </map>
</property>

 <bean id="teacherOne" class="com.spring.POJO.Teacher">
        <property name="tid" value="1008"/>
        <property name="tname" value="万教授"/>
    </bean>
    <bean id="teacherTwo" class="com.spring.POJO.Teacher">
        <property name="tid" value="1008"/>
        <property name="tname" value="王教授"/>
    </bean>

3.引用集合类型的bean

<property name="teacherMap" ref="teacherMap"/>

 <util:map id="teacherMap">
        <entry key="1008" value-ref="teacherOne"/>
        <entry key="1009" value-ref="teacherTwo"/>
    </util:map

2.2.9实验九:p命名空间

 <bean id="studentSix" class="com.spring.POJO.Student"
          p:sid="1005" p:sname="小黑" p:teacherMap-ref="teacherMap"/>

测试类:

@Test
    public void DIstudentSixTest(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        Student student=ioc.getBean("studentSix",Student.class);
        System.out.println(student);
    }

2.2.10实验十:引入外部属性文件

1.加入依赖

<!-- 数据源依赖 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.10</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.0.31</version>
</dependency>

2.创建外部属性文件

创建spring-datasource.xml
在这里插入图片描述

3.引入属性文件

jdbc.properties:

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
jdbc.username=root
jdbc.password=数据库密码

spring-datasource.xml:

    <!--引入jdbc.properties,之后可以通过${key}的方式访问value-->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

4.配置bean

  <?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--引入jdbc.properties,之后可以通过${key}的方式访问value-->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

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

</beans>

5.测试

//测试是否连接数据库
    @Test
    public void DataSourceTest() throws SQLException {
        ApplicationContext ioc=new ClassPathXmlApplicationContext("spring-datasource.xml");
        DruidDataSource dataSource=ioc.getBean(DruidDataSource.class);
        System.out.println(dataSource.getConnection());
    }

2.2.11实验十一:bean的作用域

1.概念

在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围,个取值含义参加下表:


取值	含义	创建对象时机
singleton（默认）	在IOC容器中，这个bean的对象始终为单例	容器初始化的时候创建
prototype	原型模式，获取创建的都是新的对象	从容器当中获取的时候创建

如果是在WebApplicationContext环境下还会有另外两个作用域(但不常用):


取值	含义
request	在一个请求范围内有效
prototype	在一个会话范围内有效

2.创建User类

package com.spring.POJO;

public class User {
    private Integer id;

    private String username;

    private String password;

    private Integer age;

    public User() {

    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

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

    public User(Integer id, String username, String password, Integer age) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
    }
}

3.配置bean

 <!--
        scope:设置bean的作用域
        scope="singleton|prototype"
    -->
    <bean id="user" class="com.spring.POJO.User" scope="singleton">
        <property name="id" value="1001"/>
        <property name="username" value="管理"/>
        <property name="age" value="23"/>
    </bean>

4.测试

    @Test
    public void ScopeTest(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("spring-scop.xml");
        User user1=ioc.getBean("user",User.class);
        User user2=ioc.getBean("user",User.class);
        System.out.println(user1==user2);
    }

2.2.12实验十二:bean的生命周期

1.具体的生命周期过程

bean对象创建(调用无参构造器)
给bean对象设置属性
bean对象初始化之前操作(由bean的后置处理器负责)
bean对象初始化(需在配置bean时指定初始化方法)
bean对象初始化之后操作(由bean的后置处理器负责)
bean对象就绪可以使用
bean对象销毁(需在配置bean时指定销毁方法)
IOC容器关闭

2.修改User类

public class User {
    private Integer id;

    private String username;

    private String password;

    private Integer age;

    public User() {
        System.out.println("生命周期1:实例化");
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        System.out.println("声明周期2:依赖注入");
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

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

    public User(Integer id, String username, String password, Integer age) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
    }

    public void initMethod(){
        System.out.println("生命周期3:初始化");
    }

    public void destroyMethod(){
        System.out.println("生命周期4:销毁");
    }
}

3.配置bean


    <bean id="user" class="com.spring.POJO.User" init-method="initMethod" destroy-method="destroyMethod">
        <property name="id" value="1001"/>
        <property name="username" value="admin"/>
        <property name="password" value="123456"/>
        <property name="age" value="23"/>
    </bean>

4.测试

  /*
        1.实例化
        2.依赖注入
        3.初始化,需要通过bean的init-method属性指定初始化的方法
        4.IOC容器关闭时销毁,需要通过bean的destroy-method属性指定销毁的方法
        注意:
            若bean的作用域为单例时,生命周期的前三个步骤会在获取IOC容器时执行
            若bean的作用域为多例时,生命周期的前三个步骤会在获取bean时执行
     */
    @Test
    public void test(){
        //ConfigurableApplicationContext是ApplicationContext的子接口,其中扩展了刷新和关闭容器的方法
        ConfigurableApplicationContext ioc=new ClassPathXmlApplicationContext("spring-lifecycle.xml");
        User user=ioc.getBean(User.class);
        System.out.println(user);
        ioc.close();
    }

5.bean的后置处理器

bean的后置处理器会在生命周期的初始化前后添加额外的操作,需要实现BeanPostProcessor接口,且配置到IOC容器中,需要注意的是,bean后置处理器不是单独针对某一个bean生效,而是针对IOC容器种所有bean都会执行
创建bean的后置处理器:

public class MyBeanPostProcessor implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之前调用 --> postProcessBeforeInitialization");
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之后调用 --> postProcessAfterInitialization");
        return bean;
    }
}

<bean id="myBeanPostProcessor" class="com.spring.Process.MyBeanPostProcessor">

    </bean>

2.2.13实验十三:FactoryBean

1.简介

FactoryBean是Spring提供的一种整合第三方框架的常用机制。和普通的bean不同，配置一个FactoryBean类型的bean，在获取bean的时候得到的并不是class属性配置的这个类的对象，而是getObject（）方法的返回值。通过这种机制，Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。
将来我们整合Mybatis时，Spring就是通过FactoryBean机制来帮我们创建SqlSessionFactory对象的。

ublic interface FactoryBean<T> {
    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

    @Nullable
    T getObject() throws Exception;

    @Nullable
    Class<?> getObjectType();

    default boolean isSingleton() {
        return true;
    }
}

2.创建UserFactoryBean类

public class UserFactoryBean implements FactoryBean<User> {
    @Override
    public User getObject() throws Exception {
        return new User();
    }

    @Override
    public Class<?> getObjectType() {
        return User.class;
    }
}

3.配置bean

<bean class="com.spring.factory.UserFactoryBean"></bean>

4.测试

/*
    FactoryBean是一个接口,需要创建一个类实现该接口
    其中有三个方法:
        getObject():通过一个对象交给IOC容器管理
        getObjectType():设置所提供的类型
        isSingleton():所提供的对象是否单例
        当把FactoryBean的实现类配置为bean时,会将当前类中的getObject()所返回的对象交给IOC容器管理
 */
    @Test
    public void FactoryBeanTest(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("spring-factory.xml");
        User user=ioc.getBean(User.class);
        System.out.println(user);
    }

2.2.14实验十四：基于XML的自动装配

1.创建模拟

自动装配:
根据指定的策略,在IOC容器中匹配某一个bean,自动为指定的bean中所依赖的类类型或接口类型的赋值属性

创建UserController:

public class UserController {

    private UserService userService;

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    
	public void saveUser(){
        userService.saveUser();
    }
}

Service/UserService接口:

public interface UserService {

    void saveUser();
}

Service/impl/UserServiceImpl:

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void saveUser() {
        userDao.saveUser();
    }
}

Dao/UserDao接口:

public interface UserDao {

    void saveUser();
}

Dao/impl/UserDaoImpl:

public class UserDaoImpl implements UserDao {

    @Override
    public void saveUser() {
        System.out.println("保存成功!");
    }
}

在这里插入图片描述

2.配置bean

<?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-4.2.xsd">

    <bean id="userController" class="com.spring.Controller.UserController">
        <property name="userService" ref="userService"/>
    </bean>

    <bean id="userService" class="com.spring.Service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

    <bean id="userDao" class="com.spring.Dao.impl.UserDaoImpl">

    </bean>

</beans>

3.测试

    @Test
    public  void AutoWireTest(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("spring-autowire-xml.xml");
        UserController userController=ioc.getBean(UserController.class);
        userController.saveUser();
    }

自动装配:
根据指定的策略,在IOC容器中匹配某个bean,自动为bean中的类类型的属性或接口的属性赋值
可以通过bean标签中的autowire属性设置自动装配的策略
自动装配的策略:
1. no,default:表示不装配,即bean中的属性不会自动匹配某个bean为属性赋值,此时属性使用默认值
2.byType,byName:根据要赋值的属性的类型,在IOC容器中匹配某个bean,为属性赋值
注意:
1.若通过类型没有找到任何一个类型匹配的bean,此时不装配,属性使用默认值
2.若通过类型找到了很多个类型匹配的bean,此时会抛出异常
3.byName:将要赋值的属性的属性名作位bean的id在IOC容器中匹配某个bean,为属性赋值
总结:但匹配类型的bean有多个时,此时可以使用byName实现自动装配

总结:但是用byType实现自动装配时,IOC容器中有且只有一个匹配类型的bean能够为属性赋值

自动装配之byType:

    <bean id="userController" class="com.spring.Controller.UserController" autowire="byType">
        <!--<property name="userService" ref="userService"/>-->
    </bean>

    <bean id="userService" class="com.spring.Service.impl.UserServiceImpl" autowire="byType">
        <!--<property name="userDao" ref="userDao"/>-->
    </bean>

    <bean id="userDao" class="com.spring.Dao.impl.UserDaoImpl">

    </bean>

自动装配之byName

   <bean id="userController" class="com.spring.Controller.UserController" autowire="byName">
        <!--<property name="userService" ref="userService"/>-->
    </bean>

    <bean id="userService" class="com.spring.Service.impl.UserServiceImpl" autowire="byName">
        <!--<property name="userDao" ref="userDao"/>-->
    </bean>

    <bean id="userDao" class="com.spring.Dao.impl.UserDaoImpl" autowire="byName">

    </bean>

2.3基于注解管理bean

2.3.1实验一：标记与扫描

1.注解

和XML配置文件一样,注解本身并不能执行,注解本身仅仅只是一个标记,具体的功能是框架检测到注解标记的位置,然后针对这个位置按照注解标记的功能来执行具体操作。
本质上：所有一切的操作都是java代码来完成的，XML和注解只是告诉框架中的java代码如何执行。

2.扫描

Spring为了知道程序员在那些地方标记了什么注解，就需要通过扫描的方式，来进行检测，然后根据注解进行后续操作。

3.新建Maven Module

 <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>

        <!--junit测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

4.创建Spring配置文件

在这里插入图片描述

5.标识组件的常用注解

@Component : 将类标识为普通组件
@Controller：将类标识为控制层组件
@Service：将类标识为业务层组件
@Repository: 将类标识为持久层组件

问:以上四个注解有什么关系和区别?

在这里插入图片描述
通过查看源码我们得知,@Controller,@Service,@Repository者三个注解只是在@Component注解的基础上起的三个新名字。
对于Spring使用IOC容器管理这些组件莱说没有区别。所以@Controller,@Service,@Repository这三个注解只是给开发人员看的，让我们能够便于分辨组件的作用。
注意：虽然它们本质上一致，但是为了代码的可读性，为了程序结构严谨我们肯定不能随便胡乱标记。

6.创建组件

创建控制层组件

@Controller
public class UserController {
    
}

创建接口UserService

public interface UserService {
    
}

创建UserServiceImpl

package com.spring.Service.impl;

import com.spring.Service.UserService;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

}

创建UserDao接口

public interface UserDao {
    
}

创建UserDaoImpl

@Repository
public class UserDaoImpl implements UserDao {

}

7.扫描组件

情况一：最基本的扫描方式

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

情况二：指定要排除的组件

<context:component-scan base-package="com.spring">
        <!--context:exclude-filter标签:指定排除规定-->
        <!--
            type:设置排除或包含的依据
            type="annotation",根据注解排除,expression中设置要排除的注解的全类名
            type="assignable",根据类型排除,expression中设置派出的类型的全类名
        -->
        <context:exclude-filter type="annotation" 
                                expression="org.springframework.stereotype.Controller"/>
        <!--<context:exclude-filter type="assignable" expression="com.spring.Controller.UserController"/>-->
    </context:component-scan>

情况三：仅扫描指定组件

<?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-4.2.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--扫描组件-->
    <context:component-scan base-package="com.spring" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        <!--context:exclude-filter标签:指定排除规定-->
        <!--
            type:设置排除或包含的依据
            type="annotation",根据注解排除,expression中设置要排除的注解的全类名
            type="assignable",根据类型排除,expression中设置派出的类型的全类名

            context:include-filter:包含扫描
            注意:需要在context:component-scan标签中设置use-default-filters="false"
            use-default-filters="false",所设置的包下所有的类都需要扫描,此时可以使用排除扫描
            use-default-filters="true",所设置的包下所有的类都不需要扫描,此时可以使用包含扫描
        -->
        <!--<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>-->
        <!--<context:exclude-filter type="assignable" expression="com.spring.Controller.UserController"/>-->

    </context:component-scan>

</beans>

8.测试

    @Test
    public void IOCByAnnotationTest(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        UserController userController=ioc.getBean(UserController.class);
        System.out.println(userController);
        UserService service=ioc.getBean(UserService.class);
        System.out.println(service);
        UserDao dao=ioc.getBean(UserDao.class);
        System.out.println(dao);
    }

9.组件所对应的bean的id

可以通过标识组件的注解的value属性值设置bean的自定义的id

@Controller("controller")
public class UserController {
}

2.3.2实验二：基于注解的自动装配

1.场景模拟

创建service/dao/controller和impl层

2.@Autowried注解

@AutoWired:实现自动装配功能的注解
1.@AutoWired注解能够标识的位置
a>标识在成员变量上,此时不需要设置成员变量的set方法
b>标识在set方法上
c>为当前成员变量赋值的有参构造上
2.@AutoWired注解的原理
a>默认通过byType的方式,在IOC容器中通过类型匹配某个bean为属性赋值
b>若有多个类型匹配的bean,此时会自动转换为byName的方式实现自动装配的效果
即将要赋值的属性的属性名作为bean的id匹配某个bean为属性赋值
c>若byType和byName的方式都无法实现自动装配,即IOC容器中有多个类型匹配的bean
且这些bean的id和要赋值的属性的属性名都不一致,此时抛出异常
d>此时可以在要复制的属性上,添加一个注解@Qualifier
通过该注解的value属性值,指定某个bean的id,将这个bean为属性赋值

@ Qualifier 注解原理
当发生 @Autowired 的情况的时候，可以自己指定bean的id

@Controller
public class UserController {
    @Autowired
    @Qualifier("userService")
    private UserService service;

}

@Autowired中有属性required,默认值为true,因此在自动装配无法找到相应的bean时,会装配失败,可以将属性required的值设置为true,则表示能装就装,装不上就不装,此时自动装配的属性为默认值,但是实际开发时,基本上所有需要装配组件的地方都是必须装配的,用不上这个属性。

3.AOP

3.1场景模拟

3.1.1声明接口

声明计算机接口Calculator，包含加减乘除的抽象方法

public interface Calculator {
    
    int add(int i,int j);

    int sub(int i,int j);

    int mul(int i,int j);

    int div(int i,int j);
    
}

3.1.2创建实现类

public class CalculatorImpl implements Calculator {

    @Override
    public int add(int i, int j) {
        int result=i+j;
        System.out.println("内部方法,result:"+result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result=i-j;
        System.out.println("内部方法,result:"+result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result=i*j;
        System.out.println("内部方法,result:"+result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result=i/j;
        System.out.println("内部方法,result:"+result);
        return result;
    }
}

3.1.3创建带日志功能的实现类


public class CalculatorImpl implements Calculator {

    @Override
    public int add(int i, int j) {
        System.out.println("日志,方法:add,参数:"+i+","+j);
        int result=i+j;
        System.out.println("内部方法,result:"+result);
        System.out.println("日志,方法:add,结果:"+result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        System.out.println("日志,方法:sub,参数:"+i+","+j);
        int result=i-j;
        System.out.println("内部方法,result:"+result);
        System.out.println("日志,方法:sub,结果:"+result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        System.out.println("日志,方法:mul,参数:"+i+","+j);
        int result=i*j;
        System.out.println("内部方法,result:"+result);
        System.out.println("日志,方法:mul,结果:"+result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        System.out.println("日志,方法:div,参数:"+i+","+j);
        int result=i/j;
        System.out.println("内部方法,result:"+result);
        System.out.println("日志,方法:div,结果:"+result);
        return result;
    }
}

3.1.4提出问题

1.现有代码缺陷
针对带日志功能的实现类，我们发现有如下缺陷：
(1)对核心业务功能有干扰，导致程序员在开发核心业务功能时分散了精力
(2)附加功能分散在各个业务功能方法中，不利于统一维护
2.解决思路
解决这两个问题，核心就是：解耦。我们需要把附加功能从业务功能代码中抽取出来。
3.困难
解决问题的困难，要抽取的代码在方法内部，靠以前把子类中的重复代码抽取到父类的方法设法解决，所以要引入新的技术。

3.2代理模式

3.2.1概念

1.介绍

二十三种设计模式的一种,属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标进行调试，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法种剥离出来一一解耦。调用目标方法时先调用呆莉对象的方法，减少对目标方法的调用和打扰，同使让附加功能能够集中在一起也有利于统一维护。
在这里插入图片描述

2.相关术语

代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类，对象，方法。
目标：被代理“套用”了非核心逻辑代码的类，对象，方法。

3.2.2静态代理

创建静态代理类：

package com.spring.Proxy;

import com.spring.Proxy.impl.CalculatorImpl;

public class CalculatorStaticProxy implements Calculator{

    private CalculatorImpl target;

    public CalculatorStaticProxy(CalculatorImpl target) {
        this.target = target;
    }

    @Override
    public int add(int i, int j) {
        System.out.println("日志,方法:add,参数:"+i+","+j);
        int result=target.add(i,j);
        System.out.println("日志,方法:add,结果:"+result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        System.out.println("日志,方法:sub,参数:"+i+","+j);
        int result=target.sub(i,j);
        System.out.println("日志,方法:sub,结果:"+result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        System.out.println("日志,方法:mul,参数:"+i+","+j);
        int result=target.mul(i,j);
        System.out.println("日志,方法:mul,结果:"+result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        System.out.println("日志,方法:div,参数:"+i+","+j);
        int result=target.div(i,j);
        System.out.println("日志,方法:div,结果:"+result);
        return result;
    }
}

静态代理确实实现了解耦,但是由于代码都写死了,完全不具备任何的灵活性.就拿日志功能来说,将来其他地方需要附加日志,那还得在声明多个静态代理类,那就产生了大量重复代码,日志功能还是分散的,没有统一管理。
提出进一步的需求：将日志功能集中到一个代理类中，将来有任何的日志需求，都通过这一个代理类来实现。这就需要使用动态代理技术了。

测试类：

 @Test
    public void ProxyTest(){
        CalculatorStaticProxy proxy=new CalculatorStaticProxy(new CalculatorImpl());
        proxy.add(1,2);
        proxy.div(2,5);
        proxy.mul(4,2);
        proxy.sub(8,2);
    }

3.2.3动态代理

生产代理对象的工厂类：

public class ProxyFactory {

    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getTarget(){
        /*
            ClassLoader classLoader:指定加载动态生成的代理类的类加载器
            Class[] interfaces:获取目标对象实现的所有接口的class对象的数组
            InvocationHandler handler:设置迪阿尼内中的抽象方法如何重写
         */
        ClassLoader classLoader=this.getClass().getClassLoader();
        Class<?>[] interfaces=target.getClass().getInterfaces();
        InvocationHandler handler=new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("日志,方法:"+method.getName()+"参数:"+ Arrays.toString(args));
                //proxy:表示代理对象,method表示要执行的方法,args表示要执行的方法的参数列表
                Object result=method.invoke(target,args);
                System.out.println("日志,方法:"+method.getName()+"结果:"+result);
                return result;
            }
        };
        return Proxy.newProxyInstance(classLoader,interfaces,handler);
    }
}

3.2.4测试

  /*
        动态代理有两种:
        1.jdk动态代理:要求必须要有接口,最终生成的代理类和目标类实现相同的接口
        2.cglib动态代理,最终生成的代理类会继承目标类,并且和目标类在相同的包下
     */
    @Test
    public void testProxy(){
        ProxyFactory proxyFactory=new ProxyFactory(new CalculatorImpl());
        Calculator calculator=(Calculator)proxyFactory.getTarget();
        calculator.add(1,2);
    }

3.3AOP概念及相关术语

3.3.1概述

AOP是一种设计思想，时软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现现在不修改代码的情况下给程序动态统一添加额外功能的一种技术。

3.3.2相关术语

1.横切关注点

从那个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。
这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

2.通知

每个横切关注点都需要对应一个方法实现, 这样的切面类方法就叫通知方法。
在这里插入图片描述

3.切面

封装通知方法的类。

4.目标

被代理的目标对象。

5.代理

向目标对象引用通知之后创建的代理对象。

6.连接点

这也是一个纯逻辑概念，不是语法定义。
把方法排成一排，每一个横切位置看成X轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。
在这里插入图片描述

7.切入点

定位连接点的方式。
每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事务。
如果把连接点看作数据库中的记录，那么切入点就是查询记录的SQL语句。
Spring的AOP技术可以通过切入点定位到特定的连接点。
切点通过org.springframework.aop.Pointcut接口进行描述,它使用类和方法作位连接点的查询条件。

3.3.3作用

简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。
代码增强：把特定的功能封装到切面类中，看哪里需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。

3.4基于注解的AOP

3.4.1技术说明

动态代理:JDK原生的实现方式,需要被代理的目标类必须实现接口,因为这个技术要求代理对象和目标对象实现同样的接口
cglib:通过继承被代理的目标类实现代理,所以不需要目标实现接口
AspectJ:本质上是静态代理,将代理逻辑"织入""被代理的目标类编译得到的字节码文件,所以最终效果是动态的,weaver就是织入器,Spring只是借用了Aspect中的注解

3.4.2准备工作

1.添加依赖

在IOC所需依赖基础上再加入下面依赖即可:

  <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.15.RELEASE</version>
        </dependency>

2.准备被代理的目标资源

接口:

public interface Calculator {

    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);

}

实现类:

public class CalculatorImpl implements Calculator {

    @Override
    public int add(int i, int j) {
        int result=i+j;
        System.out.println("内部方法,result:"+result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result=i-j;
        System.out.println("内部方法,result:"+result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result=i*j;
        System.out.println("内部方法,result:"+result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        System.out.println("日志,方法:div,参数:"+i+","+j);
        int result=i/j;
        System.out.println("内部方法,result:"+result);
        System.out.println("日志,方法:div,结果:"+result);
        return result;
    }
}

3.4.3创建切面类并配置

/*
    在切面中,需要通过指定得注解将方法标识为通知方法
    @Before:前置通知,在目标对象方法执行之前执行
 */
@Component
@Aspect //将当前组件标识为切面
public class LoggerAspect {

    @Before("execution(public int com.spring.aop.Annotation.Calculator.add(int,int))")
    public void beforeAdviceMethod(){
        System.out.println("LoggerAspect ,前置通知");
    }


}

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">


    <!--
        AOP的注意事项:
            切面类和注意事项都需要交给IOC容器管理
            切面类必须通过@Aspect注解标识为一个切面
            在Spring的配置文件中设置<aop:aspectj-autoproxy/>开启基于注解的AOP
    -->
    <context:component-scan base-package="com.spring.aop.Annotation"/>

    <!--开启基于注解的AOP-->
    <aop:aspectj-autoproxy/>

</beans>

3.4.4各种通知

public class AOPTest {

    @Test
    public void AOPByAnnotationTest(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        Calculator calculator=ioc.getBean(Calculator.class);
        calculator.add(1,1);
    }
}

执行结果:

LoggerAspect ,前置通知
内部方法,result:2

在切面中,需要通过指定得注解将方法标识为通知方法
@Before:前置通知,在目标对象方法执行之前执行
@After:后置通知,在目标对象方法的finally子句中执行
@AfterReturning:返回通知,在目标对象方法返回值之后执行
@AfterThrowing:异常通知,在目标对象方法的catch字句中执行

各种通知的执行顺序:

Spring版本5.3.x以前:

前置通知
目标操作
后置通知
返回通知或异常通知

Spring版本5.3.x以后:

前置通知
目标通知
返回通知或异常通知
后置通知

3.4.5切入点表达式语法

1.作用

切入点表达式:设置在标识通知的注解的value属性中
execution(public int com.spring.aop.Annotation.CalculatorImpl.add(int,int))
execution(* com.spring.aop.Annotation.CalculatorImpl.*(…))
第一个✳表示任意的访问修饰符和返回值类型
第二个✳表示类中任意的方法
…表示任意的参数列表
内的地方也可以使用✳,表示包下所有的类

2.语法细节

@Before("execution(* com.spring.aop.Annotation.Calculator.*(..))")
    public void beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature=joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args=joinPoint.getArgs();
        System.out.println("LoggerAspect ,方法:"+signature.getName()+"参数,"+ Arrays.toString(args));
    }

3.4.6重用切入点表达式

1.声明

@Pointcut("execution(* com.spring.aop.Annotation.Calculator.*(..))")
    public  void pointCut(){

    }

2.在同一个切面中使用

 @Before("pointCut()")
    public void beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature=joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args=joinPoint.getArgs();
        System.out.println("LoggerAspect ,方法:"+signature.getName()+"参数,"+ Arrays.toString(args));
    }

3.在不同切面中使用

@Component
@Aspect
public class validateAspect {

    //@Before("execution(* com.spring.aop.Annotation.*(..))")
    @Before("com.spring.aop.Annotation.LoggerAspect.pointCut()")
    public void beforeMethod(){
        System.out.println("validateAspect-->前置通知");
    }
}

3.4.7获取通知的相关信息

返回通知获得返回值

  /*
        在返回通知中若要获取目标对象方法的返回值
        只需要通过@AfterReturning注解的returning属性
        就可以将通知方法的某个参数指定为接收目标对象方法的返回值的参数
     */
    @AfterReturning(value = "pointCut()",returning = "result")
    public void AfterReturningAdviceMethod(JoinPoint joinPoint,Object result){
        Signature signature=joinPoint.getSignature();
        System.out.println("LoggerAspect ,方法:"+signature.getName()+",结果:"+result);
    }

异常通知获取异常

    /*
        在返回通知中若要获取目标对象方法的异常
        只需要通过@AfterThrowing注解的throwing属性
        就可以将通知方法的某个参数指定为接收目标对象方法出现的异常的参数
     */
    @AfterThrowing(value = "pointCut()",throwing = "ex")
    public void AfterThrowingAdviceMethod(JoinPoint joinPoint,Throwable ex){
        Signature signature=joinPoint.getSignature();
        System.out.println("LoggerAspect ,方法:"+signature.getName()+",异常通知"+ex);
    }

环绕通知

   @Around("pointCut()")
    //环绕通知的方法一定要和目标对象方法的返回值一致
    public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint){
        Object result=null;
        try {
            System.out.println("环绕通知-->前置通知");
            //表示目标对象方法的执行
            result=joinPoint.proceed();
            System.out.println("环绕通知-->返回通知");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("环绕通知-->异常通知");
        }finally {
            System.out.println("环绕通知-->后置通知");
        }
        return result;
    }

3.4.8切面的优先级:

可以通过@Order注解的value属性设置优先级,默认值Interger的最大值
@Order注解的value属性值越小,优先级越高

@Component
@Aspect
@Order(1)      //优先级(数字越小优先级越高)
public class validateAspect {

    //@Before("execution(* com.spring.aop.Annotation.*(..))")
    @Before("com.spring.aop.Annotation.LoggerAspect.pointCut()")
    public void beforeMethod(){
        System.out.println("validateAspect-->前置通知");
    }
}

3.5基于Xml的AOP实现

LoggerAspect类:

@Component
public class LoggerAspect {

    public void beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature=joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args=joinPoint.getArgs();
        System.out.println("LoggerAspect ,方法:"+signature.getName()+"参数,"+ Arrays.toString(args));
    }

    public void AfterAdviceMethod(JoinPoint joinPoint){
        Signature signature=joinPoint.getSignature();
        System.out.println("LoggerAspect ,方法:"+signature.getName()+",执行完毕!");
    }

    /*
        在返回通知中若要获取目标对象方法的返回值
        只需要通过@AfterReturning注解的returning属性
        就可以将通知方法的某个参数指定为接收目标对象方法的返回值的参数
     */
    public void AfterReturningAdviceMethod(JoinPoint joinPoint,Object result){
        Signature signature=joinPoint.getSignature();
        System.out.println("LoggerAspect ,方法:"+signature.getName()+",结果:"+result);
    }


    /*
        在返回通知中若要获取目标对象方法的异常
        只需要通过@AfterThrowing注解的throwing属性
        就可以将通知方法的某个参数指定为接收目标对象方法出现的异常的参数
     */
    public void AfterThrowingAdviceMethod(JoinPoint joinPoint,Throwable ex){
        Signature signature=joinPoint.getSignature();
        System.out.println("LoggerAspect ,方法:"+signature.getName()+",异常通知"+ex);
    }

    //环绕通知的方法一定要和目标对象方法的返回值一致
    public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint){
        Object result=null;
        try {
            System.out.println("环绕通知-->前置通知");
            //表示目标对象方法的执行
            result=joinPoint.proceed();
            System.out.println("环绕通知-->返回通知");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("环绕通知-->异常通知");
        }finally {
            System.out.println("环绕通知-->后置通知");
        }
        return result;
    }

}

bean_xml.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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--扫描组件-->
    <context:component-scan base-package="com.spring.aop.xml"></context:component-scan>

    <aop:config>
        <!--设置一个公共的切入点表达式-->
        <aop:pointcut id="pointCut" expression="execution(* com.spring.aop.xml.CalculatorImpl.*(..))"/>
        <!--将IOC容器中的某个bean设置为切面-->
        <aop:aspect ref="loggerAspect">
            <aop:before method="beforeAdviceMethod" pointcut-ref="pointCut"></aop:before>
            <aop:after method="AfterAdviceMethod" pointcut-ref="pointCut"/>
            <aop:after-returning method="AfterReturningAdviceMethod" returning="result" pointcut-ref="pointCut"/>
            <aop:after-throwing method="AfterThrowingAdviceMethod" throwing="ex" pointcut-ref="pointCut"/>
            <aop:around method="aroundAdviceMethod" pointcut-ref="pointCut"/>
        </aop:aspect>

        <aop:aspect ref="validateAspect" order="1">
            <aop:after method="beforeMethod" pointcut-ref="pointCut"></aop:after>
        </aop:aspect>
        
    </aop:config>


</beans>

测试类:

@Test
    public void AOPByXMLTest(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean-xml.xml");
        Calculator calculator=ioc.getBean(Calculator.class);
        calculator.add(1,1);
    }

4.声明式事务

4.1JdbcTemplate

4.1.1简介

Spring框架对JDBC进行封装,使用JdbcTempate方便实现对数据库操操作

4.1.2准备工作

1.加入依赖

<dependencies>
        <!-- spring 核心: IOC 的依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>

        <!-- 数据源 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.10</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.31</version>
        </dependency>

        <!-- Spring jdbc 和 spring-tx 事务 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.1</version>
        </dependency>

        <!-- Spring 整合Junit 的包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.1</version>
        </dependency>
    </dependencies>

2.创建jdbc.properties

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

3.配置Spring的配置文件

<?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-4.2.xsd 
       http://www.springframework.org/schema/context 
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 引入jdbc.properties -->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <!-- 数据源 : 其实添加的是其一个实现类  -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">

        <!-- 数据库信息 -->
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>

        <!-- 连接池设置 -->
        <property name="initialSize" value="10"></property>
        <property name="maxActive" value="16"></property>  <!-- 连接池最大活跃连接数 -->
    </bean>

    <!-- 注册 JDBCTemplate : 第三方Jar包使用不了注解 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>

4.1.3测试

@RunWith(SpringJUnit4ClassRunner.class)
//设置Spring测试环境的配置文件
@ContextConfiguration("classpath:spring-jdbc.xml")
public class JdbcTemplateTest {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Test
    public void testInsert(){
        String sql="insert into t_user values (null,?,?,?,?,?)";
        jdbcTemplate.update(sql,"root","123",23,"女","123@qq.com");
    }
}

1.在测试类装配JdbcTemplate

@Autowired
    private JdbcTemplate jdbcTemplate;

2.测试增删改功能

   //添加
    @Test
    public void testInsert(){
        String sql="insert into t_user values (null,?,?,?,?,?)";
        jdbcTemplate.update(sql,"root","123",23,"女","123@qq.com");
    }

3.查询一条数据为实体类对象

    @Test
    public void TestGetUserById(){
        String sql="select * from t_user where id=?";
        User user=jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<User>(User.class),1);
        System.out.println(user);
    }

4.查询多条数据为一个list集合

    @Test
    public void TestGetUserAll(){
        String sql="select * from t_user";
        List<User> users =jdbcTemplate.query(sql,new BeanPropertyRowMapper<User>(User.class));
        System.out.println(users);
    }

5.查询单行单列的值

    //count(*)
    @Test
    public void GetCountTest(){
        String sql="select count(id) from t_user";
        Integer count=jdbcTemplate.queryForObject(sql,Integer.class);
        System.out.println(count);
    }

4.2声明式事务概念

4.2.1编程式事务

事务功能的相关操纵全部通过自己编写代码来实现

Connection con=....;
try{
	//开启事务:关闭事务的自动提交
	conn.setAutoCommit(false);
	//核心操作
	//提交事务
	conn.commit();
}catch(Exception e){
	//回滚事务
	conn.rollBack();
}finally{
	//释放数据库连接
	conn.close();
}

编程式的实现方式存在缺陷:
细节没有屏蔽:具体操作过程中,所有细节都需要程序员自己来完成,比较繁琐
代码复用性不高:如果没有有效抽取出来,每次实现功能都需要自己编写代码,代码就没有得到复用

4.2.2声明式事务

既然事务控制的代码有规律可循,代码的结构基本是确定的,所以框架就可以将固定模式的代码收取出来,进行相关的封装
封装起来后,我们只需要在配置文件中进行简单的配置即可完成操作

好处1:提高开发效率
好处2:消除了冗余的代码
好处3:框架会综合考虑相关领域中在实际开发环境下有可能遇到的各种问题,进行了健壮性,性能等各个方面的优化

所以,我们可以总结下面两个概念:

编程式:自己写代码实现功能
声明式:通过配置让框架实现功能

4.3基于注解的声明式事务

4.3.1准备工作

1.加入依赖

<dependencies>
        <!-- spring 核心: IOC 的依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>

        <!-- 数据源 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.10</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.31</version>
        </dependency>

        <!-- Spring jdbc 和 spring-tx 事务 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.1</version>
        </dependency>

        <!-- Spring 整合Junit 的包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.1</version>
        </dependency><dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    </dependencies>

2.创建jdbc.properties

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

3.配置Spring的配置文件

 <!--扫描组件-->
    <context:component-scan base-package="com.spring"></context:component-scan>

    <!-- 引入jdbc.properties -->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <!-- 数据源 : 其实添加的是其一个实现类  -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <!-- 注册 JDBCTemplate : 第三方Jar包使用不了注解 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

4.创建表

t_book表:
在这里插入图片描述
t_user1表:

5.创建组件

创建BookController:


@Controller
public class BookController {

    @Autowired
    private BookService bookService;

    public void BuyBook(Integer userId,Integer bookId){
        bookService.BuyBook(userId,bookId);
    }
}

创建BookDaoImpl:

@Repository
public class BookDaoImpl implements BookDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public Integer getPriceByBookId(Integer bookId) {
        String sql="select price from t_book where book_id=?";
        return jdbcTemplate.queryForObject(sql,Integer.class,bookId);
    }

    @Override
    public void updateStock(Integer bookId) {
        String sql="update t_book set stock=stock-1 where book_id=?";
        jdbcTemplate.update(sql,bookId);
    }

    @Override
    public void updateBalance(Integer userId, Integer price) {
        String sql="update t_user1 set balance=balance-? where user_id=?";
        jdbcTemplate.update(sql,price,userId);
    }
}

4.3.2测试无事务情况

1.创建测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring-jdbc.xml")
public class TxByAnnotationTest {

    @Autowired
    private BookController bookController;

    @Test
    public void TestBuyBook(){
        bookController.BuyBook(1,1);
    }
}

2.模拟场景

@Service
public class BookServiceImpl implements BookService {

    @Autowired
    private BookDao bookDao;

    @Override
    public void BuyBook(Integer userId, Integer bookId) {
        //查询图书价格
        Integer price=bookDao.getPriceByBookId(bookId);
        //更新图书的库存
        bookDao.updateStock(bookId);
        //更新用户的余额
        bookDao.updateBalance(userId,price);
    }
}

4.3.3加入事务

1.添加事务配置

<?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:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
        http://www.alibaba.com/schema/stat http://www.alibaba.com/schema/stat.xsd">

    <!--扫描组件-->
    <context:component-scan base-package="com.spring"></context:component-scan>

    <!-- 引入jdbc.properties -->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <!-- 数据源 : 其实添加的是其一个实现类  -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <!-- 注册 JDBCTemplate : 第三方Jar包使用不了注解 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 开启事务的注解驱动 ：
    将环绕通知作用到连接点上，即 @Transactional 标记的类 或 方法使用事务管理 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>


</beans>

2.添加事务注解

@Service
public class BookServiceImpl implements BookService {

    @Autowired
    private BookDao bookDao;

    @Override
    @Transactional
    public void BuyBook(Integer userId, Integer bookId) {
        //查询图书价格
        Integer price=bookDao.getPriceByBookId(bookId);
        //更新图书的库存
        bookDao.updateStock(bookId);
        //更新用户的余额
        bookDao.updateBalance(userId,price);
    }
}

4.3.4@Transactional注解标识的位置

声明式事务的配置步骤:
1.在Spring的配置文件中配置事务管理器
2.开启事务注解驱动
在需要被事务管理的方法上,添加@Transactional注解,该方法就会被事务管理器
@Transactional注解标识的位置:
1.标识在方法上
2.标识在类上,则类中所有的方法都会被事务管理

4.3.5事务属性:只读

1.介绍

对一个查询操作来说,如果我们把它设置成只读,就能够明确告诉数据库,这个操作不涉及写操作,这样数据库就能够针对查询操作来进行优化

2.使用方式

 @Transactional(readOnly = true)
    public void BuyBook(Integer userId, Integer bookId) {
        //查询图书价格
        Integer price=bookDao.getPriceByBookId(bookId);
        //更新图书的库存
        bookDao.updateStock(bookId);
        //更新用户的余额
        bookDao.updateBalance(userId,price);
    }

3.注意

对增删改操作设置只读会出现异常

4.3.6事务属性:超时

1.介绍

事务在执行过程中,有可能因为遇到某些问题,导致程序卡住,从而长时间占用数据库资源,而长时间占用资源,大概率是因为程序运行出现了为标题(可能是java程序或MySQL数据库或望楼连接等等)此时这个很可能出现问题的程序应该被回滚,撤销它已做的操作,事务结束,把资源让出来,让其他正常程序可以执行
概括来说就是一句话:超时回滚,释放资源

2.使用方式

   @Transactional(timeout = 3)
    public void BuyBook(Integer userId, Integer bookId) {
        //查询图书价格
        Integer price=bookDao.getPriceByBookId(bookId);
        //更新图书的库存
        bookDao.updateStock(bookId);
        //更新用户的余额
        bookDao.updateBalance(userId,price);
    }

4.3.7事务属性:回滚策略

1.介绍

声明式事务默认只针对运行时异常回滚,编译时异常不回滚
可以通过@Transactional中相关属性设置回滚策略
rollbackFor属性:需要设置一个Class类型的对象
rollbackForClassName属性:需要设置一个字符串类型的全类名
noRollbackFor属性:需要设置一个Class类型的对象
rollbackFor属性:需要设置一个字符串类型的全类名

2.使用方式

  @Transactional(noRollbackFor = ArithmeticException.class)
    public void BuyBook(Integer userId, Integer bookId) {
        //查询图书价格
        Integer price=bookDao.getPriceByBookId(bookId);
        //更新图书的库存
        bookDao.updateStock(bookId);
        //更新用户的余额
        bookDao.updateBalance(userId,price);
    }

3.观察结果

虽然购买图书功能中出现了数学运算异常(ArithmeticException),但是我们设置的回滚策略是,当出现ArithmeticException不发生回滚,因此购买图书的操作正常执行

4.3.8事务属性:事务隔离级别

1.介绍

数据库系统必须具有隔离并发运行各个事务的能力,使它们不会相互影响,避免各种并发问题,一个事务与其他事务隔离的程度称为隔离级别,SQL标准中规定了多种事务隔离级别,不同隔离级别对应不同的干扰程度,隔离级别越高,数据一致性就越好,当并发性越弱。

隔离级别一共有四种：

读未提交：READ UNCOMMITTED
读已提交：READ COMMITTED
可重复读：REPEATABLE READ
串行化：SERIALIZABLE

在这里插入图片描述

2.使用方法

@Transactional(isolation = Isolation.DEFAULT)//使用数据库默认的隔离级别
@Transactional(isolation = Isolation.READ_UNCOMMITTED)//读未提交
@Transactional(isolation = Isolation.READ_COMMITTED)//读已提交
@Transactional(isolation = Isolation.REPEATABLE_READ)//可重复读
@Transactional(isolation = Isolation.SERIALIZABLE)//串行化

4.3.9事务属性:事务传播行为

1.介绍

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。

2.测试

创建接口CheckoutService：

public interface CheckoutService {

    //结账
    void checkout(Integer userId, Integer[] bookIds);
}

创建实现类CheckoutServiceImpl：

@Service
public class CheckoutServiceImpl implements CheckoutService {

    @Autowired
    private BookService bookService;

    @Override
    @Transactional
    //一次购买多本图书
    public void checkout(Integer userId, Integer[] bookIds) {
        for(Integer bookId:bookIds){
            bookService.BuyBook(userId,bookId);
        }
    }
}

在BookController中添加方法：

@Controller
public class BookController {

    @Autowired
    private CheckoutService checkoutService;

    public void checkout(Integer userId,Integer[] bookIds){
        checkoutService.checkout(userId,bookIds);
    }

}

在数据库中将用户的余额修改为100元

3.观察结果

可以通过@Transactional中的propagation属性设置事务传播方式
修改BookServiceImpl中BuyBook（）上，注解@Transactional的propagation属性
@Transactional（propagation=Propagation.REQUIRED）,默认情况,表示如果当前线程上有已经开启的事务可用,那么就在这个事务中运行。经过观察，购买图书馆的方法BuyBook（）在CheckOut（）中被调用，CheckOut（）上有事务注解，因此在此事务中执行。所购买的里昂本书的价格为80和50，而用户的余额为100，因此在购买第二本图书时余额不足失败，导致整个CheckOut（）中回滚，即只要有一本书买不了，就都买不了。
@Transactional（propagation=Propagation.REQUIRES_NEW),表示不管当前线程上是否已经开启的事务，都要开启新事务。同样的场景，每次购买图书都是在BuyBook（）的事务中执行，因此第一本书购买成功，事务结束，第二本图书购买失败，只在第二次的BuyBook（）中回滚，购买第一本图书不受影响，即能买基本就买几本

4.4基于XML的声明式事务

4.3.1修改Spring配置文件

将Spring配置文件中去点tx：annotation-driven标签，并添加配置：


<!-- 配置事务的切面 -->
<aop:config>
    <!-- 考虑到后面整合 SpringSecurity, 避免把 UserDetialsService 扫描到事务控制，因此让切入点表达式定位到 impl  -->
    <aop:pointcut id="txPointcut" expression="execution(* *..*ServiceImpl.*(..))"/>

    <!-- 将切入点表达式 和 事务的通知关联起来 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut" />
</aop:config>

<!-- 配置事务通知 -->
<tx:advice id="txAdvice" transaction-manager="txManager">
    <!-- 配置事务的属性 -->
    <tx:attributes>
        <!-- 查询方法：配置只读属性，让数据库知道这是一个查询操作 -->
        <tx:method name="get*" read-only="true"/>
        <tx:method name="find*" read-only="true"/>
        <tx:method name="query*" read-only="true"/>

        <!-- 增删改查方法：配置下事务的传播行为、回滚异常
            rollbackfor:
            默认：运行时异常
            建议：编译时异常和运行时异常都回滚.
        -->
        <tx:method name="save*" propagation="REQUIRED" rollback-for="Exception"/>
        <tx:method name="update*" propagation="REQUIRED" rollback-for="Exception"/>
        <tx:method name="remove*" propagation="REQUIRED" rollback-for="Exception"/>
        <tx:method name="batch*" propagation="REQUIRED" rollback-for="Exception"/>
    </tx:attributes>
</tx:advice>

注意:基于XMl实现的声明事务,必须引入aspectj的依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.15.RELEASE</version>
        </dependency>

四、SSM整合

Toxic️

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SSM整合之MyBatis和Spring

一、1. MyBatis简介MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录1.1 MyBatis历史原是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Found
复制链接

扫一扫