java后端系统学习总结 04_Spring基础学习

是归人不是过客

 关注

阅读 70

2022-03-13

猿猿正在系统的学习一些计算机知识，和后端技术栈，目前阶段主要在系统学习java。此专栏，为我学习过程中的学习笔记，便于日后复习回顾来看，也很适合新人学习参考。
以下是猿猿对Spring的第一遍学习笔记哦。

文章目录


Spring框架

one

注解

一、Spring简介

1 Spring课程介绍

问题导入

我们为什么要学习Spring框架？

1.1 为什么要学

  • Spring技术是JavaEE开发必备技能，企业开发技术选型命中率>90%

  • 专业角度

    • 简化开发，降低企业级开发的复杂性

    • 框架整合，高效整合其他技术，提高企业级应用开发与运行效率

      学过的：MyBatis，Junit

image-20210729171139088

1.2 学什么

  • 简化开发

    • IOC(控制反转)
    • AOP(面向切面编程)
    • 事务处理

  • 框架整合

    • MyBatis
    • MyBatis-plus
    • SpringMVC
    • Struts
    • Struts2
    • Hibernate
    • ……

1.3 怎么学

  • 学习Spring框架设计思想
  • 学习基础操作，思考操作与思想间的联系
  • 学习案例，熟练应用操作的同时，体会思想

image-20210729171346022

2 初识Spring

问题导入

目前我们使用的是Spring几版本？

2.1 Spring家族

  • 官网：https://spring.io/why-spring
  • Spring发展到今天已经形成了一种开发的生态圈，Spring提供了若干个项目，每个项目用于完成特定的功能。

image-20210729171850181

  • 源码：https://github.com/spring-projects/spring-framework

2.2 Spring发展史

image-20210729171926576

3 Spring体系结构

问题导入

通过系统架构图，Spring能不能进行数据层开发？Spring能不能进行web层开发？

3.1 Spring Framework系统架构图

  • Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基

image-20210729172153796

image-20210729172352627

  • Aop：教你程序应该怎么做设计型概念，在不惊动原始程序的基础上增强功能
  • Aspects:比AOP做的更好，AOP思想的实现

3.2 Spring Framework课程学习路线

image-20210729172513669

4 Spring核心概念

问题导入

问题1：目前我们的代码存在什么问题以及怎么解决这些问题？

问题2：请描述什么是IOC，什么是DI？

4.1 目前我们代码存在的问题

image-20210729173516149

  • 代码书写现状
    • 耦合度偏高
  • 解决方案
    • 使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象

4.2 核心概念

  • IOC（Inversion of Control）控制反转 ------------------解耦

    使用对象时，由主动new产生对象转换为由==外部（Spring）==提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。

    通俗的讲就是：“将new对象的权利交给Spring，我们从Spring中获取对象使用即可”

  • Spring技术对IoC思想进行了实现

    • Spring提供了一个容器，称为IOC容器，用来充当IoC思想中的“外部”
    • IOC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为Bean

  • DI（Dependency Injection）依赖注入

    • 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入。

image-20210729174148134

  • 目标：充分解耦
    • 使用IoC容器管理bean（IOC)
    • 在IoC容器内将有依赖关系的bean进行关系绑定（DI）
  • 最终效果
    • 使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

IoC和DI原理。IoC管理的Service与dao的详细实现步骤，bean，DI的详细实现步骤

二、IOC和DI入门案例【重点】

1 IOC入门案例【重点】-12’25

问题导入

<bean>标签中id属性和class属性的作用是什么？

1.1入门案例思路分析

  1. 管理什么？(Service与Dao)
  2. 如何将被管理的对象告知IOC容器？(配置文件applicationContext.xml)
  3. 被管理的对象交给IOC容器，如何获取到IoC容器？(接口)
  4. IOC容器得到后，如何从容器中获取bean？(接口方法getBean())
  5. 使用Spring导入哪些坐标？(pom.xml: spring-context)

1.2 实现步骤

【第一步】导入Spring坐标
【第二步】定义Spring管理的类（接口）
【第三步】创建Spring配置文件，配置对应类作为Spring管理的bean对象
【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取bean对象

1.3 实现代码

【第一步】导入Spring坐标

<dependencies>
    <!--导入spring的坐标spring-context，对应版本是5.2.10.RELEASE-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
</dependencies>

【第二步】定义Spring管理的类（接口）

  • BookDao接口和BookDaoImpl实现类
public interface BookDao {
    public void save();
}

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}
  • BookService接口和BookServiceImpl实现类
public interface BookService {
    public void save();
}

public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

【第三步】创建Spring配置文件，配置对应类作为Spring管理的bean对象

  • 定义applicationContext.xml配置文件并配置BookServiceImpl
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <!--
		bean标签：表示配置bean
    	id属性：表示给bean起名字
    	class属性：表示给bean定义类型
	-->
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" />

</beans>

注意事项：bean定义时id属性在同一个上下文中(IOC容器中)不能重复

【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取Bean对象

public class App {
    public static void main(String[] args) {
        //1.创建IoC容器对象，加载spring核心配置文件   把这个配置文件作为参数告诉它，来加载配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2 从IOC容器中获取Bean对象(BookService对象)
        BookService bookService= (BookService)ctx.getBean("bookService");
        //3 调用Bean对象(BookService对象)的方法
        bookService.save();
    }
}

1.4 运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eilxqX71-1647160767866)(Spring%E5%AD%A6%E4%B9%A0.assets/image-20210729184337603.png)]

2 DI入门案例【重点】-06’45

IoC管理bean前提下。service和dao的联系删除new创建对象的方法，没有new之后dao对象怎么进入service，<property>标签配置寻找路径

问题导入

<property>标签中name属性和ref属性的作用是什么？

2.1 DI入门案例思路分析

  1. 基于IOC管理bean
  2. Service中使用new形式创建的Dao对象是否保留？(否)
  3. Service中需要的Dao对象如何进入到Service中？(让Spring从IoC容器中给予)
  4. Service与Dao间的关系如何描述？(配置)

2.2 实现步骤

【第一步】删除使用new的形式创建对象的代码
【第二步】提供依赖对象对应的setter方法
【第三步】配置service与dao之间的关系

2.3 实现代码

【第一步】删除使用new的形式创建对象的代码

public class BookServiceImpl implements BookService {
    private BookDao bookDao;  //【第一步】删除使用new的形式创建对象的代码
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

【第二步】提供依赖对象对应的setter方法

public class BookServiceImpl implements BookService {
    // private BookDao bookDao = new BookDaoImpl();
    private BookDao bookDao;//【第一步】删除使用new的形式创建对象的代码
    
    //【第二步】提供依赖对象对应的setter方法    容器在执行这个set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
    
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }

}

【第三步】配置service与dao之间的关系

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
		bean标签：表示配置bean
    	id属性：表示给bean起名字
    	class属性：表示给bean定义类型
	-->
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <!--配置server与dao的关系
			property标签：表示配置当前bean的属性
        	name属性：表示配置哪一个具体的属性，set方法对应的bookDao
        	ref属性：表示参照哪一个bean    当前bean属性对应的bookDao
		-->
        <!--property代表当前bean的属性    name中 代表BookServiceImpl  private BookDao bookDao-->
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

2.4 图解演示

image-20210729183104748

三、Bean的基础配置

id class

问题导入

问题1：在<bean>标签上如何配置别名？

问题2：Bean的默认作用范围是什么？如何修改？

1 Bean基础配置【重点】

配置说明

image-20210729183500978

代码演示

<!--
	bean标签：表示配置bean
	id属性：表示给bean起名字
	class属性：表示给bean定义类型
-->
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" />

运行结果

image-20210729184337603

2 Bean别名配置【不建议用】

配置说明

name和id是等同的

name配置多个别名，可以用”，“、”；“、” “ 分割

image-20210729183558051

代码演示

image-20210729191924626

打印结果

image-20210729191954870

3 Bean作用范围配置【重点】

单列：获取的值一样，获取的对象一样。 非单列则相反

配置说明

image-20210729183628138

代码演示

image-20210729192420048

打印结果

image-20210729192730871

4 bean作用范围说明

image-20220223201308037

四、Bean的实例化

（与service层无关，换句话 与DI无关，主要讲解IoC创建bean的原理）

Spring创建bean时调用的是无参构造方法，而私有方法能被调用 因为底层用了反射。用构造方法来实例化对象。

对于Spring的报错，从下往上看

问题导入

Bean的实例化方式有几种？

1 Bean是如何创建的【理解】

bean本质上就是对象，创建bean使用构造方法完成

2 实例化Bean的三种方式

2.1 构造方法方式【重点】

  • BookDaoImpl实现类
public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor is running ....");
    }
    public void save() {
        System.out.println("book dao save ...");
    }
}
  • applicationContext.xml配置
<!--方式一：构造方法实例化bean-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
  • AppForInstanceBook测试类
public class AppForInstanceBook {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");

        bookDao.save();
    }
}
  • 运行结果

image-20210729194137151

注意：**无参构造方法如果不存在，将抛出异常BeanCreationException**

2.2 静态工厂方式实例化bean【了解】

我们需要的是工厂里面的OrderDao对象===>配置工厂类名和方法名

  • OrderDao接口和OrderDaoImpl实现类
public interface OrderDao {
    public void save();
}
public class OrderDaoImpl implements OrderDao {
    public void save() {
        System.out.println("order dao save ...");
    }
}
  • OrderDaoFatory工厂类
//静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println("static factory setup....");
        return new OrderDaoImpl();
    }
}
  • applicationContext.xml配置
<!--方式二：使用静态工厂实例化bean-->
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>

image-20210729195248948

  • AppForInstanceOrder测试类
public class AppForInstanceOrder {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");

        orderDao.save();
    }
}
  • 运行结果

image-20210729195009198

2.3 实例工厂方式【了解】

和静态工厂类似，多一个配置步骤 factory-bean="userFactory

  • UserDao接口和UserDaoImpl实现类
public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}
  • UserDaoFactory工厂类
//实例工厂创建对象
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}
  • applicationContext.xml配置
<!--方式三：使用实例工厂实例化bean-->
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>

<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

image-20210729200203249

  • AppForInstanceUser测试类
public class AppForInstanceUser {
    public static void main(String[] args) {
        //        //创建实例工厂对象
        //        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //        //通过实例工厂对象创建对象
        //        UserDao userDao = userDaoFactory.getUserDao();
        //        userDao.save();
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) ctx.getBean("userDao");
        userDao.save();
    }
}
  • 运行结果

image-20210729200240820

2.4 实现FactoryBean<T>方式【扩展,了解】

  • 定义UserDaoFactoryBean实现FactoryBean<UserDao>
//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    public Class<?> getObjectType() {
        return UserDao.class;
    }
}
  • applicationContext.xml配置
<!--方式四：使用FactoryBean实例化bean-->
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>
代码
package com.itheima;

import com.itheima.dao.OrderDao;
import com.itheima.dao.UserDao;
import com.itheima.factory.OrderDaoFactory;
import com.itheima.factory.UserDaoFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForInstanceOrder {
    //使用工厂创建对象
    public static void main(String[] args) {
        //方法二  静态工厂
                //造对象不要直接new 用工厂的方式做适当的解耦
/*        OrderDao orderDao = OrderDaoFactory.getOrderDao();
        orderDao.save();*/
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        OrderDao orderDao =(OrderDao) ctx.getBean("orderDao");
        orderDao.save();

/*        //方法三    实例工厂  先找到工厂的对象，再用对象调用方法
        UserDaoFactory userDaoFactory = new UserDaoFactory();
        UserDao userDao = userDaoFactory.getUserDao();

        userDao.save();*/


        //Spring 的形式来运行
/*        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserDao userDao =(UserDao) ctx.getBean("userDao");

        userDao.save();*/
    }
}


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--1.导入Spring坐标spring-context，对应的版本号是5.2.10.RELEASE    -->
<!--2.配置bean      id随便起-->
<!--方式一   构造方法实例化bean    构造方法默认时无参构造，写不写均可-->
                <!--使用IoC   和   DI    -->
<!--    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        &lt;!&ndash;7.配置server与dao的关系    把dao放到server中&ndash;&gt;
        &lt;!&ndash;property代表当前bean的属性    name中 代表BookServiceImpl  private BookDao bookDao&ndash;&gt;
        &lt;!&ndash;关系绑定&ndash;&gt;
        <property name="bookDao" ref="bookDao" />
    </bean>-->

    <!--方式二：静态工厂实例化bean-->
            <!--这样造出来的对象时factory对象而不是到对象   需要进一步进缩小范围（factory中的dao对象）-getOrderDao() -->
    <bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>


    <!--方式三：实例工厂实例化bean  -->
        <!--工厂的bean造出来    -->
   <!-- <bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
        &lt;!&ndash;静态工厂直接写class类名，实例化工厂不写class   &ndash;&gt;
    <bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>-->
        <!--方式三的变种   去掉了 <bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>   的臃肿-->
    <!--方式四：使用FactoryBean实例bean    -->
        <!--id给个名称，class写定义新的UserFactoryBean       造非单例对象时，接口方法isSingleton  false -->
    <!--<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>-->



</beans>

五、Bean的生命周期【了解】

<!--两种控制生命周期的方法    配置文件中指定方法名。使用接口的方法-->

问题导入-14’30

问题1：多例的Bean能够配置并执行销毁的方法？

问题2：如何做才执行Bean销毁的方法？

1 生命周期相关概念介绍

  • 生命周期：从创建到消亡的完整过程
  • bean生命周期：bean从创建到销毁的整体过程
  • bean生命周期控制：在bean创建后到销毁前做一些事情

2 代码演示

2.1 Bean生命周期控制

  • 提供生命周期控制方法
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
    //表示bean初始化对应的操作
    public void init(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void destroy(){
        System.out.println("destroy...");
    }
}
  • applicationContext.xml配置
<!--init-method：设置bean初始化生命周期回调函数,此处填写init方法名-->
<!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象，此处填写destory方法名-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>
  • 测试类
public class AppForLifeCycle {
    public static void main( String[] args ) {
        //此处需要使用实现类类型，接口类型没有close方法
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //关闭容器，执行销毁的方法
        ctx.close();
    }
}

2.2 Bean生命周期控制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nb6tD6op-1647160767870)(Spring%E5%AD%A6%E4%B9%A0.assets/image-20220228210324999.png)]

  • 实现InitializingBean, DisposableBean接口
public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        System.out.println("set .....");
        this.bookDao = bookDao;
    }
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //等同于init-method
    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }

    //等同于destroy-method
    public void destroy() throws Exception {
        System.out.println("service destroy");
    }
}

3 Bean销毁时机

  • 容器关闭前触发bean的销毁
  • 关闭容器方式：
    • 手工关闭容器
      ConfigurableApplicationContext接口close()操作
    • 注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机
      ConfigurableApplicationContext接口registerShutdownHook()操作
public class AppForLifeCycle {
    public static void main( String[] args ) {
        //此处需要使用实现类类型，接口类型没有close方法
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();

        //关闭容器
        //ctx.close();
        
        //注册关闭钩子函数，在虚拟机退出之前回调此函数，关闭容器
        //ctx.registerShutdownHook();
    }
}

image-20220228210156784image-20220228210512838

六、依赖注入(DI配置)

1 依赖注入方式【重点】

问题导入

依赖注入有几种方式？

1.1 依赖注入的两种方式

  • setter注入

    • 简单类型

    • 引用类型(很常用)

  • 构造方法注入

1.2 setter方式注入

问题导入

setter方式注入使用什么子标签？

引用类型

image-20210729203626540

  • 标签中：使用ref

  • 完整代码：

    public class BookServiceImpl implements BookService{
    private BookDao bookDao;

    //setter注入需要提供要注入对象的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

    <!--注入引用类型-->
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    <!--property标签：设置注入属性-->
    <!--name属性：设置注入的属性名，实际是set方法对应的名称-->
    <!--ref属性：设置注入引用类型bean的id或name-->
    <property name="bookDao" ref="bookDao"/>
</bean>

  • 测试

    public class AppForDISet {
    public static void main( String[] args ) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}
简单类型
  • 简单类型包含：基本类型（int, char, long…）+ 特殊类型String

image-20210729203728173

  • 标签中：使用value

  • 完整代码

    public class BookDaoImpl implements BookDao {

    private int connectionNum;
    //setter注入需要提供要注入对象的set方法
    public void setConnectionNum(int connectionNum) {
        this.connectionNum = connectionNum;
    }

    public void save() {
        System.out.println("book dao save ..."+connectionNum);
    }
}

    <!--注入简单类型-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
    <!--property标签：设置注入属性-->
    <!--name属性：设置注入的属性名，实际是set方法对应的名称-->
    <!--value属性：设置注入简单类型数据值-->
    <property name="connectionNum" value="100"/>
</bean>
总结
#简单类型使用value，引用类型使用ref

1.3 构造方式注入-14’40

问题导入

构造方式注入使用什么子标签？

引用类型

image-20210729203859855

  • 完整代码

    public class BookServiceImpl implements BookService{
    private BookDao bookDao;

    public BookServiceImpl(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" />

<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    <constructor-arg name="bookDao" ref="bookDao"/>
</bean>

  • 测试

    public class AppForDIConstructor {
    public static void main( String[] args ) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}
简单类型

image-20210729204006542

  • 完整代码

    public class BookDaoImpl implements BookDao {

    private int connectionNum;
    private String databaseName;

    public BookDaoImpl(String databaseName, int connectionNum) {
        this.databaseName = databaseName;
        this.connectionNum = connectionNum;
    }

    public void save() {
        System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}

    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
    <!--根据构造方法参数名称注入-->
    <constructor-arg name="connectionNum" value="10"/>
    <constructor-arg name="databaseName" value="mysql"/>
</bean>

<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    <constructor-arg name="bookDao" ref="bookDao"/>
</bean>
参数适配【了解】

image-20210729204117697

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
    <!--根据构造方法参数名称注入-->
    <!--<constructor-arg name="connectionNum" value="10"/>-->
    <!--<constructor-arg name="databaseName" value="mysql"/>-->

    <!--根据构造方法参数类型注入-->
    <!--<constructor-arg type="int" value="10"/>-->
    <!--<constructor-arg type="java.lang.String" value="mysql"/>-->

    <!--根据构造方法参数位置注入-->
    <!--<constructor-arg index="0" value="mysql"/>-->
    <!--<constructor-arg index="1" value="100"/>-->
</bean>

1.4 依赖注入方式选择

  1. 强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
  2. 可选依赖使用setter注入进行，灵活性强
  3. Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
  4. 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
  5. 实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
  6. 自己开发的模块推荐使用setter注入
代码
BookDaoImpl

package com.itheima.dao.impl;
import com.itheima.dao.BookDao;
public class BookDaoImpl implements BookDao {
    private int connectionNum;
    private String databaseName;


    //注入一：set注入
/*    public void setConnectionNum(int connectionNum) {
        this.connectionNum = connectionNum;
    }

    public void setDatabaseName(String databaseName) {
        this.databaseName = databaseName;
    }*/

    //注入二：构造器注入
    public BookDaoImpl(int connectionNum, String databaseName) {
        this.connectionNum = connectionNum;
        this.databaseName = databaseName;
    }

    public void save() {
        System.out.println("book dao..."+ databaseName+","+connectionNum);
    }
}

BookServiceImpl

package com.itheima.service.impl;
import com.itheima.dao.BookDao;
import com.itheima.dao.UserDao;
import com.itheima.service.BookService;

public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    private UserDao userDao;
    
    //注入方法一：set注入
/*    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }*/
    //注入方法二：构造器注入
    public BookServiceImpl(BookDao bookDao, UserDao userDao) {
        this.bookDao = bookDao;
        this.userDao = userDao;
    }

    public void save() {
        System.out.println("book service...");
        bookDao.save();
        userDao.save();
    }
}

AppForDISet

package com.itheima;
import com.itheima.service.BookService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForDISet {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx= new ClassPathXmlApplicationContext("applicationContext.xml");

        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();

        ctx.close();
    }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

        <!--注入一：set注入   -->
    <!--     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" >
          <property name="connectionNum" value="10"/>
          <property name="databaseName" value="mySql"/>
       </bean>
     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
            <property name="bookDao" ref="bookDao" />
        </bean>-->

    <!--注入二：构造器注入   标准书写  推荐使用。其他方法会存在问题-->
<!--    <bean name="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <constructor-arg name="connectionNum" value="10"/>
        <constructor-arg name="databaseName" value="MySql"/>
    </bean>
    <bean name="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>-->
    <!--注入二-1：进一步解耦，消除参数捆绑  与形参名不耦合了-->
<!--    <bean name="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <constructor-arg type="int" value="10"/>
        <constructor-arg type="java.lang.String" value="MySql"/>
    </bean>
    <bean name="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>-->
    <!--注入二-2：参数位置注入，消除二-1出现两个同类型的数据-->
    <bean name="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <constructor-arg index="0" value="10"/>
        <constructor-arg index="1" value="MySql"/>
    </bean>
    <bean name="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>
</beans>

2 依赖自动装配【理解】

问题导入

如何配置按照类型自动装配？

2.1 自动装配概念

  • IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配

  • 自动装配方式

    按类型（常用）

    按名称：

    按构造方法

    不启用自动装配

2.2 自动装配类型

依赖自动装配
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>
依赖自动装配特征
  1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作
  2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
  3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
  4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--手动注入-->
<!--    <bean name="bookDao" class="com.itheima.dao.impl.BookDaoImpl" />
    <bean name="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
    </bean>-->
    <!--自动注入    -->
    <bean name="bookDao" class="com.itheima.dao.impl.BookDaoImpl" />
    <!--那边无论写了多少，set方法给够，这边一个autowire 结束-->
    <bean name="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>
</beans>

3 集合注入-07’32

准备工作

在类中添加集合类型属性：添加get，set方法

public class BookDaoImpl implements BookDao {

    private int[] array;

    private List<String> list;

    private Set<String> set;

    private Map<String,String> map;

    private Properties properties;

    public void setArray(int[] array) {
        this.array = array;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void save() {
        System.out.println("book dao save ...");

        System.out.println("遍历数组:" + Arrays.toString(array));

        System.out.println("遍历List" + list);

        System.out.println("遍历Set" + set);

        System.out.println("遍历Map" + map);

        System.out.println("遍历Properties" + properties);
    }
}

3.1 注入数组类型数据

<property name="array">
    <array>
        <value>100</value>
        <value>200</value>
        <value>300</value>
    </array>
</property>

3.2 注入List类型数据

<property name="list">
    <list>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>chuanzhihui</value>
    </list>
</property>

3.3 注入Set类型数据

<property name="set">
    <set>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>boxuegu</value>
    </set>
</property>

3.4 注入Map类型数据

<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    </map>
</property>

3.5 注入Properties类型数据

<property name="properties">
    <props>
        <prop key="country">china</prop>
        <prop key="province">henan</prop>
        <prop key="city">kaifeng</prop>
    </props>
</property>

3.6 验证结果

public class AppForDICollection {
    public static void main( String[] args ) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");

        bookDao.save();
    }
}

image-20220301140315199

two

一、第三方资源配置管理

1 管理DataSource连接池对象

问题导入

配置数据库连接参数时，注入驱动类名是用driverClassName还是driver？

1.1 管理Druid连接池【重点】

数据库准备

create database if not exists spring_db character set utf8;
use spring_db;
create table if not exists tbl_account(
    id int primary key auto_increment,
    name varchar(20),
    money double
);
insert into tbl_account values(null,'Tom',1000);
insert into tbl_account values(null,'Jerry',1000);

【第一步】添加Druid连接池依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

【第二步】配置DruidDataSource连接池Bean对象

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/spring_db"/>
    <property name="username" value="root"/>
    <property name="password" value="root"/>
</bean>

【第三步】在测试类中从IOC容器中获取连接池对象并打印

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) ctx.getBean("dataSource");
        System.out.println(dataSource);
    }
}

1.2 管理c3p0连接池

【第一步】添加c3p0连接池依赖

<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>

【第二步】配置c3p0连接池Bean对象

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_db"/>
    <property name="user" value="root"/>
    <property name="password" value="root"/>
    <property name="maxPoolSize" value="1000"/>
</bean>

【第三步】在测试类中从IOC容器中获取连接池对象并打印

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) ctx.getBean("dataSource");
        System.out.println(dataSource);
    }
}

2 加载properties文件【重点】

问题导入

问题1：如何解决使用EL表达式读取属性文件中的值结果读取到了系统属性问题？

问题2：加载properties文件写法标准写法该怎么写？

2.1 基本用法

【第一步】编写jdbc.properties属性文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=root

【第二步】在applicationContext.xml中开启开启context命名空间，加载jdbc.properties属性文件

image-20210730101826913

小技巧：如果同学们觉得上述复制粘贴方式不好改或者容易改错，其实idea是有提示功能的，注意不要选错就行了。

image-20210730102053281

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

【第三步】在配置连接池Bean的地方使用EL表达式获取jdbc.properties属性文件中的值

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

2.2 配置不加载系统属性

问题

如果属性文件中配置的不是jdbc.username，而是username=root666，那么使用${username}获取到的不是root666，而是计算机的名称。

原因

系统属性的优先级比我们属性文件中的高，替换了我们的username=root666。

解决

解决1：换一个名称，例如不叫username，叫jdbc.username。

解决2：使用system-properties-mode="NEVER"属性表示不使用系统属性。

<context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>

2.3 加载properties文件写法

  • 不加载系统属性
<context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>
  • 加载多个properties文件
<context:property-placeholder location="jdbc.properties,msg.properties"/>
  • 加载所有properties文件
<context:property-placeholder location="*.properties"/>
  • 加载properties文件**标准格式**
<context:property-placeholder location="classpath:*.properties"/>
  • 加载当前工程类路径和当前工程所依赖的所有jar包中的所有properties文件
<context:property-placeholder location="classpath*:*.properties"/>

二、Spring容器【了解】

1 Spring核心容器介绍

问题导入

问题：按照Bean名称获取Bean有什么弊端，按照Bean类型获取Bean有什么弊端？

1.1 创建容器

  • 方式一：类路径加载配置文件
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  • 方式二：文件路径加载配置文件
ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\applicationContext.xml");
  • 加载多个配置文件
ApplicationContext ctx = new ClassPathXmlApplicationContext("bean1.xml", "bean2.xml");

1.2 获取bean对象

  • 方式一：使用bean名称获取
BookDao bookDao = (BookDao) ctx.getBean("bookDao");
  • 方式二：使用bean名称获取并指定类型（推荐使用）
BookDao bookDao = ctx.getBean("bookDao", BookDao.class);
  • 方式三：使用bean类型获取
BookDao bookDao = ctx.getBean(BookDao.class);

1.3 容器类层次结构

image-20210730102842030

1.4 BeanFactory

  • 类路径加载配置文件
Resource resources = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new XmlBeanFactory(resources);
BookDao bookDao = bf.getBean("bookDao", BookDao.class);
bookDao.save();
  • BeanFactory创建完毕后，所有的Bean均为延迟加载，也就是说我们调用getBean()方法获取Bean对象时才创建Bean对象并返回给我们

2 Spring核心容器总结

2.1 容器相关

  • BeanFactory是IoC容器的顶层接口，初始化BeanFactory对象时，加载的bean延迟加载

  • ApplicationContext接口是Spring容器的核心接口，初始化时bean立即加载

  • ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能

  • ApplicationContext接口常用初始化类

    • ClassPathXmlApplicationContext(常用)
    • FileSystemXmlApplicationContext
    /** BeanFactory  用最顶层接口创建容器    延迟加载bean
 * 与ApplicationContext(立即加载bean) 的加载时机不一样
 *立即加载：即使不调用，也被加载，构造器方法执行。延迟加载则不执行
 */

2.2 bean相关

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r3wrgJMC-1647160767873)(Spring%E5%AD%A6%E4%B9%A0.assets/image-20210730103438742.png)]

2.3 依赖注入相关

image-20210730103701525

三、Spring注解开发【重点】

1 注解定义Bean对象-08’32

问题导入

问题1：使用什么标签进行Spring注解包扫描？

问题2：@Component注解和@Controller、@Service、@Repository三个衍生注解有什么区别？

1.1 基本使用

【第一步】在applicationContext.xml中开启Spring注解包扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
	 <!--扫描com.itheima包及其子包下的类中注解-->
    <context:component-scan base-package="com.itheima"/>
</beans>

【第二步】在类上使用@Component注解定义Bean。

//@Component定义bean
@Component("bookDao")
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}

@Component
public class BookServiceImpl implements BookService {

    public void save() {
        System.out.println("book service save ...");
    }
}

【第三步】在测试类中获取Bean对象

public class AppForAnnotation {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao);
        //按类型获取bean
        BookService bookService = ctx.getBean(BookService.class);
        System.out.println(bookService);
    }
}

运行结果

image-20210730104835746

1.2 @Component三个衍生注解

  • Spring提供**@Component**注解的三个衍生注解
    • @Controller：用于表现层bean定义
    • @Service：用于业务层bean定义
    • @Repository：用于数据层bean定义
@Repository("bookDao")
public class BookDaoImpl implements BookDao {
}

@Service
public class BookServiceImpl implements BookService {
}

2 纯注解开发模式【重点】

问题导入

问题1：配置类上使用什么注解表示该类是一个配置类？

问题2：配置类上使用什么注解进行Spring注解包扫描？

2.1 纯注解开发模式介绍

  • Spring3.0开启了纯注解开发模式，使用Java类替代配置文件，开启了Spring快速开发赛道
  • Java类代替Spring核心配置文件

image-20210803192052811

  • @Configuration注解用于设定当前类为配置类
  • @ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式
@ComponentScan({com.itheima.service","com.itheima.dao"})
  • 读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象
//加载配置文件初始化容器
//ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//加载配置类初始化容器
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

2.2 代码演示

【第一步】定义配置类代替配置文件

//声明当前类为Spring配置类
@Configuration
//Spring注解扫描，相当于<context:component-scan base-package="com.itheima"/>
@ComponentScan("com.itheima")
//设置bean扫描路径，多个路径书写为字符串数组格式
//@ComponentScan({"com.itheima.service","com.itheima.dao"})
public class SpringConfig {
}

【第二步】在测试类中加载配置类，获取Bean对象并使用

public class AppForAnnotation {
    public static void main(String[] args) {
        //AnnotationConfigApplicationContext加载Spring配置类初始化Spring容器
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao);
        //按类型获取bean
        BookService bookService = ctx.getBean(BookService.class);
        System.out.println(bookService);
    }
}

注解开发转换：从核心配置文件初始化容器对象切换为读取java配置类初始化容器对象

image-20220302215826458

3 注解开发Bean作用范围和生命周期管理【了解】

问题导入

在类上使用什么注解定义Bean的作用范围？

3.1 bean作用范围注解配置

  • 使用@Scope定义bean作用范围
@Repository
@Scope("singleton")//单例
@Scope("prototype")//非单例
public class BookDaoImpl implements BookDao {
}

3.2 bean生命周期注解配置

  • 使用@PostConstruct、@PreDestroy定义bean生命周期
@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor ...");
    }
    @PostConstruct
    public void init(){
        System.out.println("book init ...");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("book destory ...");
    }
}

#注意：@PostConstruct和@PreDestroy注解是jdk中提供的注解，从jdk9开始，jdk中的javax.annotation包被移除了，也就是说这两个注解就用不了了，可以额外导入一下依赖解决这个问题。

<dependency>
  <groupId>javax.annotation</groupId>
  <artifactId>javax.annotation-api</artifactId>
  <version>1.3.2</version>
</dependency>

4 注解开发依赖注入【重点】

问题导入

问题1：请描述@Autowired注解是如何进行自动装配的？

问题2：请描述@Qualifier注解的作用

4.1 使用@Autowired注解开启自动装配模式（按类型）

@Service
public class BookServiceImpl implements BookService {
    
    @Autowired //注入引用类型，自动装配模式，默认按类型装配
    private BookDao bookDao;

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

image-20220303094646350

4.2 使用@Qualifier注解指定要装配的bean名称

@Service
public class BookServiceImpl implements BookService {
    @Autowired  //注入引用类型，自动装配模式，默认按类型装配。不加这个装配，bookDao 是空对象

    @Qualifier("bookDao2")  //自动装配bean时按bean名称装配  装配哪个dao
    private BookDao bookDao;

    public void save() {
        System.out.println("book service...");
        bookDao.save();
    }
}

注意：@Qualifier注解无法单独使用，必须配合@Autowired注解使用

4.3 使用@Value实现简单类型注入

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    //@Value：注入简单类型（无需提供set方法）
    @Value("${name}")
    private String name;

    public void save() {
        System.out.println("book dao save ..." + name);
    }
}

以上@Value注解中使用${name}从属性文件中读取name值，那么就需要在配置类中加载属性文件。

@PropertySource加载properties配置文件

@Configuration
@ComponentScan("com.itheima")
//@PropertySource加载properties配置文件
@PropertySource({"classpath:jdbc.properties"}) //单个配置文件{}可以省略不写
//@PropertySource("classpath:jdbc.properties") 
public class SpringConfig {
}

==注意：@PropertySource()中加载多文件请使用数组格式配置，不允许使用通配符==*

image-20220303164102763

5 注解开发第三方Bean【重点】

问题导入

导入自己定义的配置类有几种方式？

【第一步】单独定义配置类

public class JdbcConfig {
    //@Bean：表示当前方法的返回值是一个bean对象，添加到IOC容器中
    @Bean("dataSource") //不写名称，则使用方法名作为对象id：<bean id="dataSource"
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

【第二步】将独立的配置类加入核心配置

方式1：@Import注解导入式
@Configuration
@ComponentScan("com.itheima")
//@Import:导入配置信息
@Import({JdbcConfig.class})
public class SpringConfig {
}
方式2：JdbcConfig上使用@Configuration
@Configuration
public class JdbcConfig {
    //省略...
}

测试：

public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        DataSource dataSource = ctx.getBean(DataSource.class);
        System.out.println(dataSource);
    }
}

image-20220303180314618

image-20220303180330729

6 注解开发为第三方Bean注入资源【重点】

问题导入

配置类中如何注入简单类型数据，如何注入引用类型数据？

6.1 简单类型依赖注入

public class JdbcConfig {
    //1.定义一个方法获得要管理的对象
    @Value("com.mysql.jdbc.Driver")
    private String driver;
    @Value("jdbc:mysql://localhost:3306/spring_db")
    private String url;
    @Value("root")
    private String userName;
    @Value("root")
    private String password;
    //2.@Bean：表示当前方法的返回值是一个bean对象，添加到IOC容器中
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

6.2 引用类型依赖注入

//Spring会自动从IOC容器中找到BookDao对象赋值给参数bookDao变量，如果没有就会报错。
@Bean 
public DataSource dataSource(BookDao bookDao){
    System.out.println(bookDao);
    DruidDataSource ds = new DruidDataSource();
    ds.setDriverClassName(driver);
    ds.setUrl(url);
    ds.setUsername(userName);
    ds.setPassword(password);
    return ds;
}

7 注解开发总结

常用：@Service @ComponentScan @Autowired @bean

image-20220303195738280

四、Spring整合其他技术【重点】

1 Spring整合mybatis【重点】

1.1 思路分析

问题导入

mybatis进行数据层操作的核心对象是谁？

1.1.1 MyBatis程序核心对象分析

SqlSessionFactory 最核心的对象，在这一步 对象已经造好了

image-20210730114303147

image-20220303211805949

1.1.2 整合MyBatis

mybatis管理的是sqlsessionfactory对象

  • 使用SqlSessionFactoryBean封装SqlSessionFactory需要的环境信息

image-20210730114342060

  • 使用MapperScannerConfigurer加载Dao接口，创建代理对象保存到IOC容器中

image-20210730114356175

1.2 代码实现

问题导入

问题1：Spring整合mybatis的依赖叫什么？

问题2：Spring整合mybatis需要管理配置哪两个Bean，这两个Bean作用分别是什么？

【前置工作】
  <dependencies>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.6</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.16</version>
    </dependency>

    <!--Spring操作数据库专用的包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <!--spring整合mybatis 需要的jar包-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>
  </dependencies>

  1. 在pom.xml中添加spring-context、druid、mybatis、mysql-connector-java等基础依赖。

    <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.10.RELEASE</version>
</dependency>
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.1.16</version>
</dependency>

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.6</version>
</dependency>

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.47</version>
</dependency>

  2. 准备service和dao层基础代码

    public interface AccountService {

    void save(Account account);

    void delete(Integer id);

    void update(Account account);

    List<Account> findAll();

    Account findById(Integer id);

}

public interface AccountDao {

    @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    void save(Account account);

    @Delete("delete from tbl_account where id = #{id} ")
    void delete(Integer id);

    @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    void update(Account account);

    @Select("select * from tbl_account")
    List<Account> findAll();

    @Select("select * from tbl_account where id = #{id} ")
    Account findById(Integer id);
}

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public void save(Account account) {
        accountDao.save(account);
    }

    public void update(Account account){
        accountDao.update(account);
    }

    public void delete(Integer id) {
        accountDao.delete(id);
    }

    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

    public List<Account> findAll() {
        return accountDao.findAll();
    }
}
【第一步】导入Spring整合Mybatis依赖
    <!--Spring操作数据库专用的包-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

    <!--spring整合mybatis 需要的jar包-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
</dependency>
【第二步】创建JdbcConfig配置DataSource数据源
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}
【第三步】创建MybatisConfig整合mybatis
/**   mybatis整合spring
 * SqlSessionFactory  需要做大量的东西,而spring的SqlSessionFactoryBean帮他快速做完了
 */
public class MybatisConfig {
    //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象        //初始化dataSource
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);//注入引用类型的对象   形参上传入
        return ssfb;
    }
    //定义bean，返回MapperScannerConfigurer对象         //初始化映射配置  mapper
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}
【第四步】创建SpringConfig主配置类进行包扫描和加载其他配置类
@Configuration
@ComponentScan("com.itheima")
//@PropertySource：加载类路径jdbc.properties文件
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}
【第五步】定义测试类进行测试
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

        AccountService accountService = ctx.getBean(AccountService.class);

        Account ac = accountService.findById(1);
        System.out.println(ac);
    }
}

两个bean需要配置

image-20220304095935363 image-20220304095841006

2 Spring整合Junit单元测试【重点】

问题导入

Spring整合Junit的两个注解作用分别是什么？

【第一步】导入整合的依赖坐标spring-test

<!--junit-->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
</dependency>
<!--spring整合junit-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>>5.2.10.RELEASE</version>
</dependency>

【第二步】使用Spring整合Junit专用的类加载器

【第三步】加载配置文件或者配置类

//【第二步】使用Spring整合Junit专用的类加载器
@RunWith(SpringJUnit4ClassRunner.class)
//【第三步】加载配置文件或者配置类
@ContextConfiguration(classes = {SpringConfiguration.class}) //加载配置类
//@ContextConfiguration(locations={"classpath:applicationContext.xml"})//加载配置文件
public class AccountServiceTest {
    //支持自动装配注入bean
    @Autowired
    private AccountService accountService;

    @Test
    public void testFindById(){
        System.out.println(accountService.findById(1));
    }

    @Test
    public void testFindAll(){
        System.out.println(accountService.findAll());
    }
}

注意：junit的依赖至少要是4.12版本,可以是4.13等版本,否则出现如下异常：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nX8SlOgB-1647160767877)(Spring%E5%AD%A6%E4%B9%A0.assets/image-20200831155517797.png)]

//第一步设定类运行器.  spring整合junit的专用类运行器
@RunWith(SpringJUnit4ClassRunner.class)
//告知spring环境
@ContextConfiguration(classes = SpringConfig.class)  //spring整合junit的环境已经搭建好了
public class AccountServiceTest {
//    测试业务层接口

    //保证能用,自动装配
    @Autowired
    private AccountService accountService;
    //测试方法
    @Test
    public void  testFindById() {
        System.out.println(accountService.findById(1));
    }

    @Test
    public void testFindAll() {
        System.out.println(accountService.findAll());
    }
}
image-20220304105718044

three

一、AOP

image-20220305144335747

1 AOP简介

问题导入

做无侵入式功能增强

问题1：AOP的作用是什么？

问题2：连接点和切入点有什么区别，二者谁的范围大？

问题3：请描述什么是切面？

1.1 AOP简介和作用【理解】

  • AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构

    回顾：OOP(Object Oriented Programming)面向对象编程

  • 作用：在改动原始设计的基础上为其进行功能增强。简单的说就是在不改变方法源代码的基础上对方法进行功能增强。

  • Spring理念：无入侵式/无侵入式

1.2 AOP中的核心概念【理解】

image-20210730144903209

  • 连接点（JoinPoint）：正在执行的方法，例如：update()、delete()、select()等都是连接点。连接点包含切入点
  • 切入点（Pointcut）：进行功能增强了的方法，例如:update()、delete()方法，select()方法没有被增强所以不是切入点，但是是连接点。
    • 在SpringAOP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法
      • 一个具体方法：com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法
      • 匹配多个方法：所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法
  • 通知（Advice）：在切入点前后执行的操作，也就是增强的共性功能
    • 在SpringAOP中，功能最终以方法的形式呈现
  • 通知类：通知方法所在的类叫做通知类
  • 切面（Aspect）：描述通知与切入点的对应关系，也就是哪些通知方法对应哪些切入点方法。
  • image-20220304141846174

人消费-AOP核心概念理解

2 AOP入门案例【重点】-11’45

问题导入

问题1：在通知方法中如何定义切入点表达式？

问题2：如何配置切面？

问题3：在配置类上如何开启AOP注解功能？

2.1 AOP入门案例思路分析

  • 案例设定：测定接口执行效率
  • 简化设定：在接口执行前输出当前系统时间
  • 开发模式：XML or 注解
  • 思路分析：
    1. 导入坐标（pom.xml） ** **
    2. 制作连接点方法（原始操作，dao接口与实现类）
    3. 制作共性功能（通知类与通知）
    4. 定义切入点
    5. 绑定切入点与通知关系（切面）

2.2 AOP入门案例实现

【第一步】导入aop相关坐标
<dependencies>
    <!--spring核心依赖，会将spring-aop传递进来-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    <!--切入点表达式依赖，目的是找到切入点方法，也就是找到要增强的方法-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
</dependencies>

image-20210730150138448

【第二步】定义dao接口与实现类
public interface BookDao {
    public void save();
    public void update();
}

@Repository
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save ...");
    }
    public void update(){
        System.out.println("book dao update ...");
    }
}
【第三步】定义通知类，制作通知方法
/**
 * 1.扫描这个文件 加载到spring中
 * 2.设置当前类的为切面类
 * 3.定义切入点
 * 4.定义通知
 * 5.关联切入点与通知
 */

//通知类必须配置成Spring管理的bean
@Component
public class MyAdvice {
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
【第四步】定义切入点表达式、配置切面(绑定切入点与通知关系)
/**
 * 1.扫描这个文件 加载到spring中
 * 2.设置当前类的为切面类
 * 3.定义切入点
 * 4.定义通知
 * 5.关联切入点与通知
 */
@Component
@Aspect
public class Aop {
    @Pointcut("execution(* com..AccountService.save())")
    private void pt(){}

    @Around("pt()")
    public Object method(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("before");
        Object proceed = pjp.proceed();
        System.out.println("after");
        return proceed;
    }
}

//通知类必须配置成Spring管理的bean
@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
    //设置切入点，@Pointcut注解要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

    //设置在切入点pt()的前面运行当前操作(前置通知)
    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

/**aop开发第三步  创建aop通知类
 *第四步  定义切入点
 * 第五步 绑定切入点与共性方法的关系----》设置切面
 *第六步  让这个通知类被spring控制
 * 第七步  配置类里面加载这个通知类
 */

@Component  //1.扫描到这个文件，加载到spring中
@Aspect     //2.当作AoP来操作
public class MyAdvice {
    //3.第四步  先写一个私有方法，定义为切入点
            //execution执行  括号内描述连接点
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

    //5.切入点与共性方法的关系，共性方法在切入点之前执行   绑定切入点与通知
    @Before("pt()")
    //4.定义通知
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

image-20210730154740528

【第五步】在配置类中进行Spring注解包扫描和开启AOP功能
@Configuration
@ComponentScan("com.itheima")
//开启注解开发AOP功能
@EnableAspectJAutoProxy
public class SpringConfig {
}

@Configuration
@ComponentScan("com.itheima")

@EnableAspectJAutoProxy   //告诉spring 我这里面有用注解开发的aop    启动了通知类里面的Aspect，而通知类中的aspect告诉了spring进入后要识别通知
public class SpringConfig {
}
测试类和运行结果
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }
}

image-20210730151347354

3 AOP工作流程【理解】-07’24

AOP内部是用代理模式进行工作的

问题导入

什么是目标对象？什么是代理对象？

3.1 AOP工作流程

匹配失败，还没有进入aop模式

  1. Spring容器启动
  2. 读取所有切面配置中的切入点
  3. 初始化bean，判定bean对应的类中的方法是否匹配到任意切入点
    • 匹配失败，创建原始对象
    • 匹配成功，创建原始对象（目标对象）的代理对象
  4. 获取bean执行方法
    • 获取的bean是原始对象时，调用方法并执行，完成操作
    • 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

3.2 AOP核心概念

目标对象（Target）：被代理的对象，也叫原始对象，该对象中的方法没有任何功能增强。
代理对象（Proxy）：代理后生成的对象，由Spring帮我们创建代理对象。

3.3 在测试类中验证代理对象

@Component  //1.扫描到这个文件，加载到spring中
@Aspect     //2.当作AoP来操作
public class MyAdvice {
    //3.第四步  先写一个私有方法，定义为切入点
            //execution执行  括号内描述连接点
            //        更改为update1  就比配不到了，就不会走代理模式的路径 bean.getClass()打印出的是 com.itheima.dao.impl.BookDaoImpl
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

    //5.切入点与共性方法的关系，共性方法在切入点之前执行   绑定切入点与通知
    @Before("pt()")
    //4.定义通知
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
		//打印对象的类名
        System.out.println(bookDao.getClass());
    }
}

image-20210730152631741

image-20220305094738315

4 AOP切入点表达式-19’29

问题导入

在切入点表达式中如何简化包名和参数类型书写？

4.1 语法格式

  • 切入点：要进行增强的方法

  • 切入点表达式：要进行增强的方法的描述方式

    • 描述方式一：执行com.itheima.dao包下的BookDao接口中的无参数update方法
    execution(void com.itheima.dao.BookDao.update())
    • 描述方式二：执行com.itheima.dao.impl包下的BookDaoImpl类中的无参数update方法
    execution(void com.itheima.dao.impl.BookDaoImpl.update())

  • 切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）

    execution(public User com.itheima.service.UserService.findById(int))
    • image-20220305095822743
    • 动作关键字：描述切入点的行为动作，例如execution表示执行到指定切入点
    • 访问修饰符：public，private等，可以省略
    • 返回值：写返回值类型
    • 包名：多级包使用点连接
    • 类/接口名：
    • 方法名：
    • 参数：直接写参数的类型，多个类型用逗号隔开
    • 异常名：方法定义中抛出指定异常，可以省略

4.2 通配符

  • ：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
execution（public * com.itheima.*.UserService.find*(*))

没有参数的 加*，加载不出来 加 … 都可以加载出来

  • … ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
execution（public User com..UserService.findById(..))
  • +：专用于匹配子类类型
execution(* *..*Service+.*(..))
//*任意返回值类型 *..任意包下的  以service结尾的类或接口的+（子类）   .*的任意方法  （..）任意参数

@Component
@Aspect
public class MyAdvice {
    //定义切入点
    //@Pointcut("execution(* com.itheima.dao.BookDao.update(*))")  //no
    //@Pointcut("execution(void com.*.*.*.update())")
    //@Pointcut("execution(void *..update())")
    //@Pointcut("execution(* *..*(..))")   //匹配所有，但是一般不这样写
    //@Pointcut("execution(* *..u*(..))")   //范围匹配，u开头的
    //@Pointcut("execution(* *..*e(..))")   //范围匹配，e结尾的都能匹配
    //@Pointcut("execution(* *..*(..))")  //星星代表什么不知道的时候倒着看
    //@Pointcut("execution(* com.itheima.*.*Service.find*(..))")   //给所有业务层的查询方法加aop
    @Pointcut("execution(* com.itheima.*.*Service.save(..))")   //给所有业务层的save方法加aop
    private void pt(){}

    //定义通知类
    //确定和切入点的关系
    @Before("pt()")
    public void method() {
        System.out.println(System.currentTimeMillis());
    }
}

4.3 书写技巧

  • 所有代码按照标准规范开发，否则以下技巧全部失效
  • 描述切入点通**常描述接口，而不描述实现类 （可以但是不建议，会发生紧耦合**）
  • 访问控制修饰符针对接口开发均采用public描述（可省略访问控制修饰符描述）
  • 返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用*****通配快速描述
  • 包名书写尽量不使用…匹配，效率过低，常用*做单个包描述匹配，或精准匹配
  • 接口名/类名书写名称与模块相关的采用*匹配，例如UserService书写成*Service，绑定业务层接口名
  • 方法名书写以动词进行精准匹配，名词采用匹配，例如getById书写成getBy,selectAll书写成selectAll
  • 参数规则较为复杂，根据业务方法灵活调整
  • 通常**不使用异常作为匹配**规则

5 AOP通知类型【重点】-15’53

问题导入

请描述一下如何定义环绕通知方法？

5.1 AOP通知分类

  • AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置
  • AOP通知共分为5种类型
    • 前置通知：在切入点方法执行之前执行
    • 后置通知：在切入点方法执行之后执行，无论切入点方法内部是否出现异常，后置通知都会执行。
    • **环绕通知(重点)：**手动调用切入点方法并对其进行增强的通知方式。
    • 返回后通知(了解)：在切入点方法执行之后执行，如果切入点方法内部出现异常将不会执行。
    • 抛出异常后通知(了解)：在切入点方法执行之后执行，只有当切入点方法内部出现异常之后才执行。

5.2 AOP通知详解

5.2.1 前置通知
  • 名称：@Before
  • 类型：方法注解
  • 位置：通知方法定义上方
  • 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行
  • 范例：
@Before("pt()")
public void before() {
    System.out.println("before advice ...");
}
5.2.2 后置通知
  • 名称：@After
  • 类型：方法注解
  • 位置：通知方法定义上方
  • 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行
  • 范例：
@After("pt()")
public void after() {
    System.out.println("after advice ...");
}
5.2.3 返回后通知
  • 名称：@AfterReturning（了解）
  • 类型：方法注解
  • 位置：通知方法定义上方
  • 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法正常执行完毕后运行
  • 范例：
@AfterReturning("pt()")
public void afterReturning() {
    System.out.println("afterReturning advice ...");
}
5.2.4 抛出异常后通知
  • 名称：@AfterThrowing（了解）
  • 类型：方法注解
  • 位置：通知方法定义上方
  • 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行
  • 范例：
@AfterThrowing("pt()")
public void afterThrowing() {
    System.out.println("afterThrowing advice ...");
}
5.2.5 环绕通知
  • 名称：@Around（重点，常用）
  • 类型：方法注解
  • 位置：通知方法定义上方
  • 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行
  • 范例：：
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("around before advice ...");
    Object ret = pjp.proceed();
    System.out.println("around after advice ...");
    return ret;
}

环绕通知注意事项

  1. 环绕通知方法形参必须是ProceedingJoinPoint，表示正在执行的连接点，使用该对象的proceed()方法表示对原始对象方法进行调用，返回值为原始对象方法的返回值。
  2. 环绕通知方法的返回值建议写成Object类型，用于将原始对象方法的返回值进行返回，哪里使用代理对象就返回到哪里。
@Component  //1.扫描到这个文件，加载到spring中
@Aspect   //2.当作Aop来操作   设置当前类为切面类
public class MyAdvice {

//    写一个私有方法定义为切入点
    @Pointcut("execution(* com..BookDao.select())")
    private void pt(){}

//    设置切入点与通知关系
//    定义通知
//    @Before("pt()")
    public void method() {
        System.out.println("before...");
    }

    @After("pt()")
    public void after() {
        System.out.println("after...");
    }

    //@Around("pt()")  //环绕  前后都有    注意返回值类型时object，通过ProceedingJoinPoint对原始方法进行调用。获得一个返回值最终把返回结果送出去
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around1...");
        Object proceed = pjp.proceed();
        System.out.println("around2...");
        return proceed;
    }

    @AfterReturning("pt()")    //只有在这个方法没有抛出异常 正常结束的时候这个方法才会执行
    public void afterReturning() {
        System.out.println("afterreturning");
    }

    @AfterThrowing("pt()")   //抛出异常后才会运行的
    public void afterThrowing() {
        System.out.println("afterthrowing...");
    }
}

二、AOP案例

1 案例-测量业务层接口万次执行效率-16’25

问题导入

能不能描述一下环绕通知里面的实现步骤？

1.1 需求和分析

需求：任意业务层接口执行均可显示其执行效率（执行时长）

分析：

​ ①：业务功能：业务层接口执行前后分别记录时间，求差值得到执行效率
​ ②：通知类型选择前后均可以增强的类型——环绕通知

1.2 代码实现

【前置工作】环境准备

  1. Spring整合mybatis对spring_db数据库中的Account进行CRUD操作

  2. Spring整合Junit测试CRUD是否OK。

  3. 在pom.xml中添加aspectjweaver切入点表达式依赖

  4. … …

【第一步】编写通知类

getSignature(); singnature 执行的签名信息

@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}

    //设置环绕通知，在原始操作的运行前后记录执行时间
    @Around("ProjectAdvice.servicePt()") //本类类名可以省略不写
    public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
        //获取执行的签名对象
        Signature signature = pjp.getSignature();
        //获取接口/类全限定名
        String className = signature.getDeclaringTypeName();
        //获取方法名
        String methodName = signature.getName();
        //记录开始时间
        long start = System.currentTimeMillis();
        //执行万次操作
        for (int i = 0; i < 10000; i++) {
           pjp.proceed();
        }
        //记录结束时间
        long end = System.currentTimeMillis();
        //打印执行结果
        System.out.println("万次执行："+ className+"."+methodName+"---->" +(end-start) + "ms");
    }
}
【第二步】在SpringConfig配置类上开启AOP注解功能
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableAspectJAutoProxy //开启AOP注解功能
public class SpringConfig {
}
【第三步】运行测试类，查看结果
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCase {
    @Autowired
    private AccountService accountService;
    @Test
    public void testFindById(){
        Account account = accountService.findById(2);
    }
    @Test
    public void testFindAll(){
        List<Account> list = accountService.findAll();
    }
}

image-20210730164219555

2 AOP通知获取数据-14’42

image-20220313153208070

  • 获取切入点方法的参数

    • JoinPoint：适用于前置、后置、返回后、抛出异常后通知
    • ProceedJointPoint：适用于环绕通知

  • 获取切入点方法返回值

    • 返回后通知
    • 环绕通知

  • 获取切入点方法运行异常信息

    • 抛出异常后通知
    • 环绕通知

问题导入

在环绕通知中可以获取到哪些数据？

2.1 获取参数

  • 原始方法
@Repository
public class BookDaoImpl implements BookDao {

    public String findName(int id, String password) {
        System.out.println("id:" + id);
        if (true) {
            throw new NullPointerException();
        }
        return "itcast";
    }
}
  • JoinPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数
@Before("pt()")
public void before(JoinPoint jp) {
    Object[] args = jp.getArgs(); //获取连接点方法的参数们
    System.out.println(Arrays.toString(args));
}
  • ProccedJointPoint是JoinPoint的子类
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    Object[] args = pjp.getArgs(); //获取连接点方法的参数们
    System.out.println(Arrays.toString(args));
    Object ret = pjp.proceed();
    return ret;
}

2.2 获取返回值

//变量名要和returning="ret"的属性值一致

  • 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象
@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(String ret) { //变量名要和returning="ret"的属性值一致
    System.out.println("afterReturning advice ..."+ret);
}
  • 如果两个参数都存在，两个参数的顺序不能反
    //设置返回后通知获取原始方法的返回值，要求returning属性值必须与方法形参名相同
    @AfterReturning(value = "pt()",returning = "ret")
    public void afterReturning(JoinPoint jp, String ret) {
        System.out.println("afterReturning advice ..."+ret+" "+jp);
    }
  • 环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    // 手动调用连接点方法，返回值就是连接点方法的返回值
    Object ret = pjp.proceed();
    return ret;
}

2.3 获取异常

  • 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象
@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(Throwable t) {//变量名要和throwing = "t"的属性值一致
    System.out.println("afterThrowing advice ..."+ t);
}
  • 抛出异常后通知可以获取切入点方法运行的异常信息，使用形参可以接收运行时抛出的异常对象
@Around("pt()")
public Object around(ProceedingJoinPoint pjp)  {
    Object ret = null;
    //此处需要try...catch处理，catch中捕获到的异常就是连接点方法中抛出的异常
    try {
        ret = pjp.proceed();
    } catch (Throwable t) {
        t.printStackTrace();
    }
    return ret;
}

    //设置抛出异常后通知获取原始方法运行时抛出的异常对象，要求throwing属性值必须与方法形参名相同
    //@AfterThrowing(value = "pt()",throwing = "t")
    public void afterThrowing(Throwable t) {
        System.out.println("afterThrowing advice ..."+t);
    }
image-20220305172438889

3 案例-百度网盘密码数据兼容处理-10’48

问题导入

请说出我们该使用什么类型的通知来完成这个需求？

3.1 需求和分析

需求：对百度网盘分享链接输入密码时尾部多输入的空格做兼容处理

image-20210731193059709

分析：
①：在业务方法执行之前对所有的输入参数进行格式处理——trim()
②：使用处理后的参数调用原始方法——环绕通知中存在对原始方法的调用

3.2 代码实现

【前置工作】环境准备
//-------------service层代码-----------------------
public interface ResourcesService {
    public boolean openURL(String url ,String password);
}
@Service
public class ResourcesServiceImpl implements ResourcesService {
    @Autowired
    private ResourcesDao resourcesDao;

    public boolean openURL(String url, String password) {
        return resourcesDao.readResources(url,password);
    }
}
//-------------dao层代码-----------------------
public interface ResourcesDao {
    boolean readResources(String url, String password);
}
@Repository
public class ResourcesDaoImpl implements ResourcesDao {
    public boolean readResources(String url, String password) {
        System.out.println(password.length());
        //模拟校验
        return password.equals("root");
    }
}
【第一步】编写通知类
@Component
@Aspect
public class DataAdvice {
    
    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}

    @Around("DataAdvice.servicePt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            //判断参数是不是字符串
            if(args[i].getClass().equals(String.class)){
                args[i] = args[i].toString().trim();
            }
        }
        Object ret = pjp.proceed(args);//更改完之后给它放回去
        return ret;
    }
}
【第二步】在SpringConfig配置类上开启AOP注解功能
@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}
【第三步】运行测试类，查看结果
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
        boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root ");
        System.out.println(flag);
    }
}

4 AOP开发总结-06’32

4.1 AOP的核心概念

  • 概念：AOP(Aspect Oriented Programming)面向切面编程，一种编程范式
  • 作用：在不惊动原始设计的基础上为方法进行功能增强
  • 核心概念
    • 代理（Proxy）：SpringAOP的核心本质是采用代理模式实现的
    • 连接点（JoinPoint）： 在SpringAOP中，理解为任意方法的执行
    • 切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
    • 通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法
    • 切面（Aspect）：描述通知与切入点的对应关系
    • 目标对象（Target）：被代理的原始对象成为目标对象

4.2 切入点表达式语法

  • 切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名（参数）异常名)

    • execution(* com.itheima.service.Service.(…))

  • 切入点表达式描述通配符：

    • 作用：用于快速描述，范围描述
    • *：匹配任意符号（常用）
    • … ：匹配多个连续的任意符号（常用）
    • +：匹配子类类型

  • 切入点表达式书写技巧

    1.按标准规范开发
    2.查询操作的返回值建议使用*匹配
    3.减少使用…的形式描述包
    4.对接口进行描述，使用*表示模块名，例如UserService的匹配描述为*Service
    5.方法名书写保留动词，例如get，使用*表示名词，例如getById匹配描述为getBy*
    6.参数根据实际情况灵活调整

4.3 五种通知类型

  • 前置通知
  • 后置通知
    • 环绕通知（重点）
    • 环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用
    • 环绕通知可以隔离原始方法的调用执行
    • 环绕通知返回值设置为Object类型
    • 环绕通知中可以对原始方法调用过程中出现的异常进行处理
  • 返回后通知
  • 抛出异常后通知

三、Spring事务管理

1 Spring事务简介【重点】-13’

问题导入

Spring提供的事务管理是数据层的事务还是业务层的事务?

1.1 Spring事务作用

  • 事务作用：在数据层保障一系列的数据库操作同成功同失败
  • Spring事务作用：在数据层或**业务层**保障一系列的数据库操作同成功同失败

image-20210801190820853

1.2 需求和分析

  • 需求：实现任意两个账户间转账操作
  • 需求微缩：A账户减钱，B账户加钱
  • 分析：
    ①：数据层提供基础操作，指定账户减钱（outMoney），指定账户加钱（inMoney）
    ②：业务层提供转账操作（transfer），调用减钱与加钱的操作
    ③：提供2个账号和操作金额执行转账操作
    ④：基于Spring整合MyBatis环境搭建上述操作
  • 结果分析：
    ①：程序正常执行时，账户金额A减B加，没有问题
    ②：程序出现异常后，转账失败，但是异常之前操作成功，异常之后操作失败，整体业务失败

1.3 代码实现

【前置工作】环境准备
public interface AccountDao {

    @Update("update tbl_account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name") String name, @Param("money") Double money);

    @Update("update tbl_account set money = money - #{money} where name = #{name}")
    void outMoney(@Param("name") String name, @Param("money") Double money);
}

public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    public void transfer(String out,String in ,Double money) ;
}

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        //int i = 1/0;
        accountDao.inMoney(in,money);
    }
}
【第一步】在业务层接口上添加Spring事务管理
public interface AccountService {
    //配置当前接口方法具有事务
    @Transactional
    public void transfer(String out,String in ,Double money) ;
}

注意事项

  1. Spring注解式事务通常添加在业务层接口中而不会添加到业务层实现类中，降低耦合
  2. @Transactional可以添加到业务方法上表示当前方法开启事务，也可以添加到接口上表示当前接口所有方法开启事务
【第二步】设置事务管理器(将事务管理器添加到IOC容器中)
//配置事务管理器，mybatis使用的是jdbc事务
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
    DataSourceTransactionManager dtm = new DataSourceTransactionManager();
    transactionManager.setDataSource(dataSource);
    return transactionManager;
}

注意事项

  1. 事务管理器要根据实现技术进行选择
  2. MyBatis框架使用的是JDBC事务
【第三步】开启注解式事务驱动
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}
【第四步】运行测试类，查看结果
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",100D);
    }
}

2 Spring事务角色【理解】

问题导入

什么是事务管理员，什么是事务协调员？

2.1 Spring事务角色

  • 事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法
  • 事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法
  • 三个事务变为一个事务 用来管理。所有操作同成功同失败

image-20210801192453227

他们用了同一个datasource 事务源相同，所以合并成了同一个事务

image-20220305205504891

3 Spring事务相关配置-18’43

问题导入

什么样的异常，Spring事务默认是不进行回滚的？

3.1 事务配置

运行时异常，溢出error异常能回滚，除此之外不支持回滚

image-20210802151553053

3.2 案例：转账业务追加日志

需求和分析
  • 需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕
  • 需求微缩：A账户减钱，B账户加钱，数据库记录日志
  • 分析：
    ①：基于转账操作案例添加日志模块，实现数据库中记录日志
    ②：业务层转账操作（transfer），调用减钱、加钱与记录日志功能
  • 实现效果预期：
    无论转账操作是否成功，均进行转账操作的日志留痕
  • 存在的问题：
    日志的记录与转账操作隶属同一个事务，同成功同失败
  • 实现效果预期改进：
    无论转账操作是否成功，日志必须保留
  • 事务传播行为：事务协调员对事务管理员所携带事务的处理态度

image-20210802153216460

【准备工作】环境整备
USE spring_db;
CREATE TABLE tbl_log(
	id INT PRIMARY KEY AUTO_INCREMENT,
	info VARCHAR(255),
	createDate DATE
);

public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional
    void log(String out, String in, Double money);
}

@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

public interface LogDao {
    @Insert("insert into tbl_log (info,createDate) values(#{info},now())")
    void log(String info);
}
【第一步】在AccountServiceImpl中调用logService中添加日志的方法
@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Autowired
    private LogService logService;

    public void transfer(String out,String in ,Double money) {
        try{
            accountDao.outMoney(out,money);
            int i = 1/0;
            accountDao.inMoney(in,money);
        }finally {
            logService.log(out,in,money);
        }
    }
}
【第二步】在LogService的log()方法上设置事务的传播行为 分离绑定事务
public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out, String in, Double money);
}
【第三步】运行测试类，查看结果
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",50D);
    }
}

3.3 事务传播行为

image-20210802153014296

eTransactionManager dtm = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
return transactionManager;
}


注意事项

1. 事务管理器要根据实现技术进行选择
2. MyBatis框架使用的是JDBC事务

##### 【第三步】开启注解式事务驱动

```java
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}
【第四步】运行测试类，查看结果
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",100D);
    }
}

2 Spring事务角色【理解】

问题导入

什么是事务管理员，什么是事务协调员？

2.1 Spring事务角色

  • 事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法
  • 事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法
  • 三个事务变为一个事务 用来管理。所有操作同成功同失败

[外链图片转存中…(img-DRU2w4HL-1647160767880)]

他们用了同一个datasource 事务源相同，所以合并成了同一个事务

[外链图片转存中…(img-KspsMrTX-1647160767880)]

3 Spring事务相关配置-18’43

问题导入

什么样的异常，Spring事务默认是不进行回滚的？

3.1 事务配置

运行时异常，溢出error异常能回滚，除此之外不支持回滚

[外链图片转存中…(img-Sf2Z16En-1647160767881)]

3.2 案例：转账业务追加日志

需求和分析
  • 需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕
  • 需求微缩：A账户减钱，B账户加钱，数据库记录日志
  • 分析：
    ①：基于转账操作案例添加日志模块，实现数据库中记录日志
    ②：业务层转账操作（transfer），调用减钱、加钱与记录日志功能
  • 实现效果预期：
    无论转账操作是否成功，均进行转账操作的日志留痕
  • 存在的问题：
    日志的记录与转账操作隶属同一个事务，同成功同失败
  • 实现效果预期改进：
    无论转账操作是否成功，日志必须保留
  • 事务传播行为：事务协调员对事务管理员所携带事务的处理态度

[外链图片转存中…(img-t3416Ir2-1647160767881)]

【准备工作】环境整备
USE spring_db;
CREATE TABLE tbl_log(
	id INT PRIMARY KEY AUTO_INCREMENT,
	info VARCHAR(255),
	createDate DATE
);

public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional
    void log(String out, String in, Double money);
}

@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

public interface LogDao {
    @Insert("insert into tbl_log (info,createDate) values(#{info},now())")
    void log(String info);
}
【第一步】在AccountServiceImpl中调用logService中添加日志的方法
@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Autowired
    private LogService logService;

    public void transfer(String out,String in ,Double money) {
        try{
            accountDao.outMoney(out,money);
            int i = 1/0;
            accountDao.inMoney(in,money);
        }finally {
            logService.log(out,in,money);
        }
    }
}
【第二步】在LogService的log()方法上设置事务的传播行为 分离绑定事务
public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out, String in, Double money);
}
【第三步】运行测试类，查看结果
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",50D);
    }
}

3.3 事务传播行为

[外链图片转存中…(img-RzQxh5hZ-1647160767881)]

image-20220305211941959
以上内容来自黑马学习笔记

相关推荐

java系统学习日常总结

寒羽鹿 43 0 0

JAVA系统学习

吓死我了_1799 129 0 0

java系统学习

caoxingyu 77 0 0

Dart基础系统学习

Mezereon 90 0 0

如何系统学习Spring框架

十里一走马 90 0 0

【JAVA基础】重新系统学习Java（五）案例

双井暮色 68 0 0

Java 系统学习梳理_【All】

兵部尚输 84 0 0

【JAVA基础】重新系统学习Java(八)案例二

eelq 67 0 0

spring系统学习之控制反转 ioc

无聊到学习 106 0 0

Docker系统学习

源码之路 94 0 0

精彩评论（0）

0 0 举报