当前位置: 首页 > news >正文

Spring基本使用及核心技术

文章目录

  • Spring
      • 介绍
        • 背景
        • spring
        • 使用
        • 优点
        • 体系结构
    • IoC
      • 概念
      • DI
      • 基于 XML
        • 创建对象
        • 属性赋值
          • set 注入
          • 构造注入
          • 自动注入
          • 集合类型
          • 命名空间
      • 基于注解
        • 创建对象
          • @Component
          • component-scan
        • 属性赋值
          • @Value
          • @Autowired
          • @Resource
          • 注解 + 配置文件
        • 配置文件
          • 多配置文件
      • Java Config
        • @Configuration
        • @ImportResource
        • @PropertyResource
        • @Import
        • @ComponentScan
        • 手动获取对象
        • 简单使用
      • Bean 作用域
        • 分类
        • 设置
    • AOP
      • AOP
        • 面向切面
        • 动态代理
        • 术语
        • 实现框架
      • aspectj
        • 执行时间
        • 执行位置
        • 基本流程
        • 切面类
          • @Aspect
          • 通知方法
            • 要求
            • 方法参数
            • @Before
            • @AfterReturning
            • @After
            • @AfterThrowing
            • @Around
            • @Pointcut
          • 示例
            • 切面类
            • spring 配置文件
            • autoproxy

Spring

介绍

Spring 全家桶

  • Spring
  • Spring MVC
  • Spring Boot
  • Spring Cloud

背景

出现在 2002 年左右,解决企业开发难度

  • 减轻项目模块间的管理
  • 帮助创建对象、管理对象间的关系

spring

一个框架,一个存放Java 对象的容器

  • 核心技术
    • IoC:控制反转
    • AOP:面向切面编程
  • 实现模块、类之间的解耦合

依赖:使用一个类的属性或方法叫做依赖这个类

使用

  • 将项目中使用的对象放到容器中

    • 容器完成对象的创建、对象间关系管理(属性赋值)

    • 程序中从容器获取对象

  • 放入容器的对象

    • dao 类、service 类、controller 类、工具类

    • spring 中对象默认都是单例的

      • 容器中不存在同名对象
  • 不放入的对象

    • 实体类对象

      • 数据来自数据库,可以放但没意义
      • 在查询过程中创建对象
    • servlet、listener、filter 等

      • 由 Tomcat 容器创建对象
  • 简单流程

    1. 创建 Maven 项目

      • 添加相关依赖
        • 添加 spring-context 依赖
    2. 创建类

      • 接口、实现类
        • 简单 Java 类
    3. 创建 Spring 配置文件

      • 配置文件公认名 applicationContext.xml

      • 使用 <bean> 标签声明对象

      • 通过 spring 语法完成属性赋值

    4. 获取对象进行使用

    5. 测试

优点

  1. 轻量
    • Spring 框架使用的 jar 都比较小
      • 核心功能所需框架 jar 总共 3M 左右
    • 运行占用资源少,运行效率高,不依赖其他 jar 包
  2. 针对接口编程、解耦合
    • Spring 提供了 IoC 控制反转
      • 由容器管理对象、对象的依赖关系
      • 代码中的对象创建方式由容器完成,对象间依赖解耦
  3. AOP 编程支持
    • 进行面向切面的编程
      • 不容易通过传统 OOP 实现的功能可以通过 AOP 进行
    • 开发人员可以从繁杂的事务管理代码中解脱出来,通过声明方式灵活进行事务管理,提高开发效率和质量
  4. 方便集成各种优秀框架
    • Spring 不排斥各种开源框架,并且可以降低框架使用难度
    • 提供了对各种优秀框架的直接支持,简化使用
      • 如 Struct 、Hibernate、MyBatis

体系结构

  • 数据访问/集成:Date Access/Integration
  • Web 开发:Web
  • 面向切面编程:AOP、Aspects
  • JVM 代理:Instrumentation、消息发送:Messaging
  • 核心容器:Core Container
    • 存放 Java对象
  • 测试:Test

在这里插入图片描述

IoC

概念

  • IoC:Inversion of Control,控制反转

    • 一种理论、概念、思想

      • 对象的创建、赋值、管理由代码之外的容器实现
      • 对象创建由外部资源完成
    • 指导开发人员在容器中,代码之外管理对象,属性赋值、管理依赖

  • 容器:服务器软件、框架(Spring)

  • 控制:创建对象、对象的属性赋值、对象间的关系管理

  • 反转:创建对象的权限交给代码外的容器实现,由容器代替来创建对象、管理对象、给属性赋值

    • 正转:直接在代码中 new 对象、主动管理对象
  • 使用原因:减少对代码的改动也能实现不同的功能

    • 解耦合:实现业务对象之间的解耦合
      • 例如 service 和 dao 对象间的解耦合
  • 体现:例如 servlet

    1. 创建类继承 HttpServlet

    2. 在 web.xml 注册 servlet

      <seevlet-name>myservlet</servlet-name>
      <servlet-class>demo.myservlet</servlet-class>
      
    3. 无需创建 Servlet 对象,由 Tomcat 服务器创建

      • Tomcat 也是容器
        • 存放有 Servlet、Listener、Filter 对象

DI

  • DI:Dependency Injection,依赖注入

    • 只需要在程序中给提供要使用的对象名称,对象创建、赋值、查找由容器内部实现
  • Spring 使用 DI 实现 IoC 的功能

    • Spring 底层创建对象使用反射机制
    • IoC 是理论基础,DI 实现 Ioc,底层实现使用反射机制
  • 实现方式

    1. 在 spring 配置文件中使用标签和属性实现

      • 基于 XML 的实现
        • 经常修改时使用配置文件更方便
        • 优:与源文件完全分离,便于修改
        • 劣:代码量较大,且使用不太直观
    2. 使用 spring 中的注解完成属性赋值

      • 基于注解的 DI 实现
        • 不经常改动时便于使用
        • 优:代码量较少,使用便捷直观,信息
          • 获取信息可读性较好
        • 劣:侵入源代码,不便于修改
          • 使用 注解 + 配置文件引用赋值解耦合

基于 XML

创建对象

  • 在 spring 配置文件添加 bean 信息

    • 声明 JavaBean 实例对象
      • 自定义类或系统类
    • 在 spring 底层自动创建对象
      • 默认使用无参构造
      • 创建的对象存在 Map 中
        • key 是自定义 bean 的 id,value 是自动创建的对象
    <!-- 一个 bean 标签声明一个对象 -->
    <bean id="demo" name="demo" class="demo.bean.Demo"/>
    
    • id:对象名,唯一标识
    • name:对象别名,相当于 id
  • 获取对象

    // 读取配置文件创建容器对象,此时 demo 对象已经创建
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
    // 从容器获取对象,使用 id 从 map 获取对象,获取对象类型为 Object,需要强转为目标类型
    Demo demo = (Demo)context.getBean("demo")
    
  • 创建对象的时间

    • 创建容器对象时创建配置文件中所有对象
      • 可多次创建同一类的对象
      • 可声明 Java 系统类,同样可以创建
      • 创建默认使用无参构造
  • 获取容器中定义的对象数量

    int count = context.getBeanDefinitionCount();
    
  • 获取容器中定义的所有 bean 的 id

    String[] names = context.getBeanDefinitionNames();
    

属性赋值

  • 按语法分类

    • set 注入:设值注入

      • spring 调用类的 set 方法实现属性赋值
    • 构造注入

      • spring 调用类的有参构造创建对象
      • 构造方法中完成赋值
set 注入
  • 简单类型:基本数据类型 和 String 类型
    • 语法:<property name="demo01" value="demo01"/>
      • name:属性名,value:属性值
  • 引用类型
    • 语法:<property name="demo01" ref="demo01"/>
      • ref:属性值,即对应对象的 bean 标签 id
    • bean 标签顺序不影响结果
<bean id="demo" class="demo.bean.Demo">
    <!-- 简单类型赋值 -->
    <property name="name" value="二狗"/>
    <property name="age" value="20"/>
    <!-- 引用类型赋值 -->
    <property name="demo01" ref="demo01"/>
</bean>
<bean id="demo01" class="demo.bean.Demo01" >
    <property name="address" value="沙雕中心"/>
    <property name="telNumber" value="110"/>
</bean>
  • 调用无参构造创建对象,调用 set 方法进行赋值

    • 类中必须有与 name 值相同的的 set 方法

    • 无论该方法对应的属性是否存在,无论该方法如何实现

构造注入
  • 调用有参构造方法创建对象,同时进行赋值
  • 使用 <constructor-arg> 标签
<bean id="demo" class="demo.bean.Demo">
    <!-- 一个标签表示一个构造方法参数 -->
    <!-- 属性名赋值 -->
    <constructor-arg name="name" value="二狗"/>
    <constructor-arg name="age" value="18"/>
    <constructor-arg name="demo01" ref="demo01"/>
    
<!--
	<!-- 索引赋值:根据指定构造器对应参数的索引进行赋值 -->
	<constructor-arg index="0" value="二狗"/>
	<constructor-arg index="1" value="18"/>
	<constructor-arg index="2" ref="demo01"/>
-->
<!--
	<!-- 省略属性名、索引赋值,必须保证赋值顺序和参数顺序一直 -->
    <constructor-arg value="二狗"/>
    <constructor-arg value="18"/>
    <constructor-arg ref="demo01"/>
-->
</bean>
<bean id="demo01" class="demo.bean.Demo01" >
    <property name="address" value="沙雕中心"/>
    <property name="telNumber" value="110"/>
</bean>
  • 标签属性

    • name:构造方法中形参名

    • index:构造方法参数索引,从 0 开始

    • value:简单类型赋值

    • ref:引用类型赋值

自动注入
  • 引用类型的自动注入,仅对于引用类型有效
    • spring 框架根据某些规则给引用类型自动赋值
  • 使用规则
    • byName:按名称注入
      • Java 类中引用类型属性名和 spring 容器中 <bean> 标签 id 值相同、数据类型一致
      • <bean> 中添加 autowire="byName"
    • byType:按类型注入
      • Java 类中引用类型的数据类型和 spring 容器中 <bean> 的 class 值属于同源关系
        • class 类型和属性类型是相同类
        • class 类型是属性类型继承类
        • class 类型是属性类型接口实现类
      • 同时存在多个同源类型无法使用 byType
        • 会检测到多个同源类造成冲突无法赋值
      • <bean> 中添加 autowire="byType"
<!-- byName 自动注入 -->
<bean id="demo" class="demo.bean.Demo" autowire="byName">
<!--
byType 自动注入
<bean id="demo" class="demo.bean.Demo" autowire="byType">
-->
    <property name="name" value="二狗"/>
    <property name="age" value="20"/>
</bean>
<!-- id 和 demo 类中属性名相同可通过 byName 赋值 -->
<!-- class 和 demo 类中属性类型同源可通过 byType 赋值-->
<bean id="demo01" class="demo.bean.Demo01" >
    <property name="address" value="沙雕中心"/>
    <property name="telNumber" value="110" />
</bean>
集合类型
  • 简单类型、引用对象类型、赋值 null
  • 数组、List集合、Set集合、Map、Properties 类型
<bean id="demo" class="demo.domain.Demo">
    <!-- String 类型赋值 -->
    <property name="name" value="二狗"/>
    
    <!-- Integer 类型赋值 null -->
    <property name="age"> <null/> </property>
    
    <!-- String[] 赋值, -->
    <property name="array">
        <array>
            <value>废物1</value>
            <value>废物2</value>
        </array>
    </property>
    
    <!-- 引用类型 Goods 赋值 -->
    <property name="goods" ref="goods"/>
    
    <!-- List<Goods> 赋值 -->
    <property name="list">
        <list>
            <ref bean="goods"/>
        </list>
    </property>
    
    <!-- Set<Goods> 赋值 -->
    <property name="set">
        <set>
            <ref bean="goods"/>
        </set>
    </property>
    
    <!-- Map<String, String> 赋值 -->
    <property name="map">
        <map>
            <entry key="name" value=""/>
        </map>
    </property>
    
    <!-- Properties 类型赋值,key=value -->
    <property name="properties">
        <props>
            <prop key="name">张三</prop>
        </props>
    </property>
</bean>
命名空间
  • 导入命名空间约束才能使用

    • p:根据属性注入
    • c:构造器注入
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:p="http://www.springframework.org/schema/p" 
           xmlns:c="http://www.springframework.org/schema/c"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
                               https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 约束文件中添加了 p、c 命名空间 -->
        
        <!-- 命名空间p:通过 p:属性名=value 直接进行赋值,set 注入 -->
        <bean id="p-namespace" class="com.example.ExampleBean" p:email="someone@somewhere.com"/>
        <bean id="beanTwo" class="x.y.ThingTwo"/>
        <bean id="beanThree" class="x.y.ThingThree"/>
        <!-- 命名空间 c: 通过 c:参数名称=参数值 使用构造器进行赋值 -->
        <bean id="beanOne" class="x.y.ThingOne" c:thingTwo-ref="beanTwo"
              c:thingThree-ref="beanThree" c:email="something@somewhere.com"/>
    </beans>
    

基于注解

  • 使用步骤

    1. 加入 maven 依赖

      • 加入 spring-context 依赖会自动导入 spring-aop 依赖
        • 注解必须使用 spring-aop 依赖 jar 包
    2. 在类中加入 spring 注解

      • 多个不同功能的注解
    3. 在 spring 配置文件中加入组件扫描器标签

      • 说明注解在项目中的位置

      • <!-- 组件扫描器:声明要扫描注解的包 -->
        <context:component-scan base-package="demo.bean"/>
        <!-- 注解支持,在注解扫描器中已经包含此声明 -->
        <context:annotation-config/>
        
  • 基本注解

    • @Component:创建通用对象,下面三个作用一样,但用于特定类型

      • @Repository:简单java实体类对象
      • @Service:服务层对象
      • @Controller:控制层对象
    • @Scope:作用域,声明类的声明周期

    • @Value:简单类型赋值,对类中简单类型属性赋值

    • @Autowired:引用类型赋值,对类中引用类型属性赋值

      • 基于 Spring 框架实现,不推荐直接使用在字段上
      • @Qualifier(value = "id"):指定属性名赋值
    • @Resource:引用类型赋值,基于 javax 实现

创建对象

@Component
  • @Component 注解用来创建对象

    • 等同于 <bean> 标签的作用
    • 在 MVC 项目分层之外的类使用;通用类型,例如工具类等
  • 和 @Component 基本功能相同的注解

    • @Repository
      • 用在持久层类,dao 实现类上面
      • 表示创建 dao 对象,能访问数据库
    • @Service
      • 用在业务层类,service 实现类上面
      • 创建 service 对象,做业务处理,可以有事务等功能
    • @Controller
      • 用在控制器,控制器(处理器)类上面
      • 创建控制器对象,接收用户提交的参数,显示请求的处理结果
    • 使用语法和 @Component 相同
    • 此三个注解还有不同的额外功能:给项目对象分层
  • 属性

    • value:对象名,即 <bean> 的 id
    • value 值唯一,创建的对象在 spring 容器中只有一个
  • 位置:类定义的上面添加注解

  • 定义注解

    • // @Component(value = "demo") 	// 最准确的写法
      // @Component					// 使用 spring 提供默认名:类名首字母小写;最常用
      @Component("demo")  			// 省略 value 写法
      public class Demo { /* 类内容 */ }
      
component-scan
  • 组件扫描器:组件就是 Java 对象
  • base-package:指定注解在项目中的包名
  • 内置了 <context:annotation-config/> 注解支持驱动
  • 工作方式
    1. spring 扫描 base-package 指定的包及子包中所有类
    2. 找到类中的注解
    3. 按注解功能创建对象或给属性赋值
<!-- 声明组件扫描器后会添加新约束文件 -->
<!--
xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context 
https://www.springframework.org/schema/context/spring-context.xsd">
-->

<!-- 定义组件扫描器:context 是约束文件的命名空间,即扫描器定义在约束文件中 -->
<!-- 三种使用方式 -->
<!-- 指定一个包 -->
<context:component-scan base-package="demo.bean"/>
<!-- 分隔符 ; 或 , 来分隔多个包名 -->
<context:component-scan base-package="demo.bean;demo.utils"/>
<!-- 指定父包,自动扫描子包 -->
<context:compontext-scan base-package="demo">

属性赋值

  • 创建对象时组件扫描器包路径必须保证正确
    • 否则无法扫描到类,无法根据注解进行操作
  • @Component 注解必须添加
    • 对象必须先创建才能赋值属性
@Value
  • 对简单类型属性赋值

    • 在属性上或在 setter 方法上使用注解 @Value
      • 注解的 value 值指定要注入的值
  • 使用该注解完成属性注入时类中无需 setter 方法

// @Value(value = "二狗")  	// 完整写法
@Value("二狗")  				// 直接赋值
private String name;

@Value("22")
public void setAge(int age){
    this.age = age;
}
@Autowired
  • 对引用类型赋值

    • 使用自动注入原理:byTypebyName

      • 默认使用 byType
        • 同时存在多个同源对象会发生冲突
    • 强制使用 byName 自动注入

      • 添加 @Autowired 注解
      • 添加 @Qualifier(value = "id") 注解
        • 存在多个同源类型时必须指定使用 byName 赋值
          • 否则会有冲突
        • id 值错误时报异常
      • 两个注解顺序不影响结果
  • 需要先声明引用类型对象

  • 属性 required:通过 byName 注入时产生作用

    • 默认 true:id 值找不到时报错
    • 设为 false:id 值找不到时自动赋值 null,不报错
/*
直接声明在属性上,不建议使用
通过 byType 自动注入,有多个同源对象会产生冲突
*/
@Autowired
private Demo01 demo01;

@Autowired
public void setDemo01(Demo01 demo01) {
    this.demo01 = demo01;
}

/*
通过 byName 自动注入,默认 id 值找不到时报错
*/
@Qualifier("demo01")
@Autowired
public void setDemo01(Demo01 demo01) {
    this.demo01 = demo01;
}

// 赋值前需要已经声明 demo01 对象
@Component(value = "demo01")
public class Demo01 {
    @Value("北京")
    private String address;
    @Value("110")
    private long telNumber;
}
@Resource
  • 由 JDK 提供,spring 提供对该注解功能的支持
  • 通过自动注入原理赋值
    • 使用方式类似 @Autowired
    • 默认是 byName 方式找跟属性同名对象
      • byName 找不到时自动使用 byType 注入
        • buType 找到多个同源对象报错
      • 指定 name 属性强制使用 byName 方式注入
// 默认使用 byName 注入,失败后自动使用 byType 方注入
@Resource
private Demo11 demo11;
/*
指定 name 属性强制使用 byName 方式找同名对象
@Resource(name = "demo10")
private Demo11 demo11;
*/
注解 + 配置文件
<!-- 在 spring 配置文件中加载外部属性配置文件 -->
<context:property-placeholder location="classpath:filed.properties" />
# 配置文件中记录属性值
name=张三
age=18
resourceName=demo01			# 引用类型对象,使用注解生成对象指定的 id 
// 引用配置文件中的内容赋值
@Value("${name}")
private String name;
@Value("${age}")
private int age;
// 引用类型,使用 @Resource 注解
@Resource(name = "${resourceName}")
private Demo11 demo11;

配置文件

  • 配置文件通用公认名 applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- spring 配置文件标准内容 -->
<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">
<!--
    约束:对使用的标签和语法格式的限制
    spring-beans.xsd:约束文件;xsd 是文件类型;beans 是根标签
-->

<!--
    声明 bean,告诉 spring 要创建对象的类
    class:类全限定名,不能是接口;spring使用反射机制创建对象必须使用类
    id:自定义类的实例化对象名
    创建好的对象放到 map 中,spring 框架有 map 存放对象:springMap.put(demo, Demo demo = new Demo())
-->
<!-- 一个 bean 标签声明一个对象 -->
<bean id="demo" class="demo.bean.Demo" autowire="byName">
	<property name="name" value="二狗"/>
	<property name="age" value="20"/>
    <property name="demo01" ref="demo01"/>

    <!-- 构造注入 -->
    <!-- <constructor-arg name="name" value="二狗"/> -->
    <!-- <constructor-arg name="age" value="18"/> -->
    <!-- <constructor-arg type="demo.bean.Demo01" name="demo01" ref="demo01"/> -->

    <!-- 缺省构造注入 -->
    <!-- <constructor-arg value="二狗"/> -->
    <!-- <constructor-arg value="18"/> -->
    <!-- <constructor-arg ref="demo01"/> -->
    </bean>
    <!-- 声明另一个 bean,同时此对象被引用 -->
    <bean id="demo01" class="demo.bean.Demo01" >
        <property name="address" value="沙雕中心"/>
        <property name="telNumber" value="110" />
    </bean>
</beans>
多配置文件
  • 较大规模项目使用多个配置文件

  • 优势

    • 多文件大小比单一文件较小,效率更高

    • 避免多人开发的文件资源竞争

    • 避免多模块功能配置混乱

  • 分类

    • 按功能模块:一个模块一个配置文件

    • 按类的功能

      • 数据库相关一个配置文件
      • service 功能一个配置文件 等
  • 使用

    • 主配置文件

      • 用来包含其他配置文件,一般不定义对象
    • 加载包含关系的配置文件

      <!-- 在主配置文件导入其他配置文件 -->
      <import resource="classpath:demo/demo-config.xml"/>
      <import resource="classpath:demo/demo01-config.xml"/>
      <!-- 使用通配符加载所有符合 *-config.xml 的文件 -->
      <import resource="classpath:demo/*-config.xml"/>
      
      • classpath:表示类路径,即 .class 文件所在目录路径
        • spring 配置文件中要指定其他文件位置需要使用 classpath 来加载文件
      • 使用通配符 * 表示任意字符
        • 通配符加载的文件需要在同一个目录下且必须有目录
          • 不能直接在 resources
        • 通配符文件名不能将主配置文件包含
          • 会造成死循环

Java Config

  • JavaConfig 是 Spring 的子项目,在 Spring 4 成为核心功能

    • @Configuration:注解在类上将此类作为配置类使用
    • @Bean:注解在方法上使方法返回的对象放入 Spring 容器
  • Spring 使用 Xml 作为容器配置文件需要写大量配置文件

    • 还要配置各种对象,将使用的对象放到 Spring 容器才能使用
    • 需要了解其他框架配置规则
  • 在 3.0 之后加入 JavaConfig,使用 Java 类做配置文件使用

@Configuration

  • Spring 提供的使用 Java 类配置容器
    • 使用 Java 类作为 xml 配置文件的替代
      • 在类中可创建对象,将对象注入容器
    • 配置 Spring IOC 容器的纯 Java 方法
  • 优点
    • 可使用面向对象方式:一个配置类可以继承配置类,可以重写方法
    • 避免繁琐的 xml 配置
  • 使用注解
    • @Configuration
      • 注解在类上面,表示该类作为配置文件使用
    • @Bean
      • 声明对象,把对象注入到容器
      • 通过 name 或 value 属性指定对象名
        • 默认对象名是 方法名
/**
 * @Configuration 表示当前类作为配置文件使用,相当于 配置文件
 */
@Configuration
public class Conf {

    /**
     * 创建方法,返回值是对象
     * @Bean 将对象注入到 Spring 容器,相当于 <bean></bean> 的作用
     * 默认对象名是方法名
     * 使用注解属性 name 或 value 指定对象名,即指定 <bean> 的 id
     *
     * @return 返回对象,注入到容器
     */
    @Bean(name = "demo")
    public Demo getDemo(){
        Demo demo = new Demo();
        demo.setName("李四");
        demo.setAge(18);
        demo.setBirthday(new Date());
        demo.setHobby("篮球");
        return demo;
    }
}

@ImportResource

  • 导入配置文件,等同于 xml 文件的 <import resource=""/>
  • 注解在类定义上
  • 导入配置文件中的 bean 对象
    • 属性 value 和 location 作用一样,都是指定配置文件位置
    • 属性为数组类型,多个配置文件使用数组添加
@Configuration
@ImportResource({"classpath:applicationContext.xml", "classpath:bean.xml"})
public class Conf {}

@PropertyResource

  • 读取 properties 类型属性配置文件
    • 例:数据路连接信息的配置文件
  • 实现外部化配置,在程序代码之外提供数据
  • @PropertySource
    • 属性 value 指定配置文件路径,数组类型,可以指定多个文件
// 配置类
@Configuration
@PropertySource(value = "classpath:pro.properties", encoding = "UTF-8")		// 以 UTF-8 编码加载外部配置文件
@ComponentScan(basePackages = "demo.domain")				// 组件扫描,扫描通过注解创建的对象
public class Conf {}

@Import

  • 导入其他配置类
  • 注解在类定义上
  • 属性值:要导入的配置类的 Class 对象
@Configuration
@ImportResource("classpath:applicationContext.xml")
@PropertySource(value = "classpath:filed.properties", encoding = "utf-8")
@Import(BeanConf2.class)				// 通过类的  Class 对象查找
public class BeanConf {
	@Bean
    public Dmeo getDemo(){
        return new Demo();
    }
}

@ComponentScan

  • 组件扫描驱动
  • @ComponentScan
    • 该注解类似组件扫描器
      • 扫描通过注解创建的对象
    • 属性 value、basePackages 指定注解所在包
      • 找到注解创建对象并放到 Spring 容器中
  • @Value
    • 给类中属性赋值
    • ${}:占位符,通过配置文件赋值
@Configuration
@ImportResource("classpath:applicationContext.xml")
@PropertySource(value = "classpath:filed.properties", encoding = "utf-8")
@Import(BeanConf2.class)
@ComponentScan("demo.bean")
public class BeanConf {}

// 普通Java类,注解创建对象并赋值
@Component("demo03")
public class Demo03 {
    @Value("${name}") 				// ${} 占位符,引用配置文件中值进行赋值
    private String name;
    @Value("${age}")
    private int age;
    @Autowired
    private Date birthday;
    @Value("${hobby}")
    private String hobby;

手动获取对象

  • Spring 中手动获取容器对象
@Test
public void demo(){
    // 通过 AnnotationConfigApplicationContext 类获取容器中的对象
    ApplicationContext context = new AnnotationConfigApplicationContext(BeanConf.class);
    Demo demo = (Demo)context.getBean("getDemo");
}

简单使用

@Configuration											// 表示当前类作为配置文件使用
@ImportResource("classpath:applicationContext.xml")		// 导入外部 xml 配置文件中的 bean 对象
@PropertySource(value = "classpath:pro.properties", encoding = "UTF-8")		// 导入属性配置文件,指定配置文件路径
@ComponentScan(basePackages = "demo.domain")			// 组件扫描器,扫描注解,创建对象;指定注解所在包
public class Conf {

    /**
     * 创建方法,返回值是对象
     * @Bean 将对象注入到 Spring 容器,相当于 <bean></bean> 作用
     * 默认对象名是方法名
     * 使用注解属性 name 或 value 指定对象名:指定 <bean> 的 id
     *
     * @return 返回对象,注入到容器
     */
    @Bean(name = "demo02")
    public Demo02 getDemo(){
        Demo02 demo = new Demo02();
        demo.setName("张二");
        demo.setAge(19);
        demo.setHobby("rap");
        demo.setBirthday(new Date());
        return demo;
    }
}

Bean 作用域

分类

  • singleton:单例模式,默认机制
    • 将单个 bean 定义的范围限定为每个 Spring IoC 容器的单个对象实例
  • prototype:原型模式
    • 每次获取都产生新的实例
    • 创建容器的时候不进行实例化,获取对象的时候才实例化
  • request:请求作用域
    • 每个 HTTP request 请求都有自己的 bean 实例
      • 该实例是在单个 bean 定义后创建的
    • 仅适用于 web 的 Spring WebApplicationContext 环境
  • session:会话作用域
    • 同一个 HTTP Session 中的请求共享一个 Bean
      • 不同 Session 使用不同的 Bean
    • 仅适用于 web 的 Spring WebApplicationContext 环境
  • application:全局作用域
    • 限定一个 Bean 的作用域为 ServletContext 的生命周期
    • 仅适用于 web 的 Spring WebApplicationContext 环境
  • websocket:全局作用域

设置

<bean id="" class="" scope="作用域">

AOP

AOP

  • Aspect Oriented Programming,面向切面编程
    • 通过运行期动态代理实现程序功能的统一维护的一种技术
  • Spring 框架的重要内容
    • 利用 AOP 可以对业务逻辑各部分进行隔离
      • 降低业务逻辑各部分耦合度,提高程序可重用性
      • 提高开发效率
  • 底层通过动态代理实现
  • 使用场景
    1. 给原本的类修改完善功能
    2. 给项目中多个类增加相同功能
    3. 给业务方法增加事务、日志输出等

面向切面

  • 将交叉业务逻辑封装成切面;利用 AOP 容器将切面织入到主业务逻辑中
    • 交叉业务逻辑:通用的、与主业务逻辑无关的代码
      • 例如:安全检查、事务、日志等
    • 不使用 AOP 则会出现代码纠缠
      • 交叉业务逻辑和主业务逻辑混合在一起,使主业务逻辑混杂不清
  • 理解面向切面编程
    • 分析项目功能时找出切面
    • 合理安排切面执行时间
      • 在目标方法之前、之后
    • 合理安排切面执行的位置
      • 在哪个类、哪个方法增加增强功能

动态代理

  • 面向切面编程基于动态代理
    • 可使用 JDKCGLIB 两种代理方式
  • AOP 就是动态代理的规范化
    • 定义动态代理的实现步骤、方式
    • 开发使用统一的方式,即动态代理
  • 动态代理两种方式
    1. 基于接口实现
      • 利用 ProxyInovcationHandlerMethon 等系统类创建代理对象执行业务方法
      • 基于接口的实现机制
    2. 无需接口:CGLIB 实现动态代理
      • 基于类的继承机制,所以相关类和方法不能是 final
  • 作用
    • 不改变业务实现类源码情况下增加新功能能
    • 减少代码重复
    • 专注业务逻辑实现
    • 解耦合,使业务功能和非业务功能分离

术语

  • Aspect:切面,表示增强的功能:非业务功能

    • 通知方法所在的类
      • 一个 Aspect 类可有多个通知方法
    • 常见切面:日志、事务、统计、参数检查、权限验证等
  • JoinPoint:连接点

    • 连接业务功能和切面的位置,即某类的业务方法
  • PointCut:切入点

    • JoinPoint 的集合
    • 为要添加 advice 的方法划定范围
  • target:目标对象

    • 要增加功能的类、对象 即 目标对象
    • JoinPoint 方法所在对象
  • Advice:通知

    • 通知方法,表示切面功能执行的时间
    • 已存在业务方法前、后、异常、最终处加入的通知方法
  • Weave:织入

    • advice 方法放在 JoinPoint 的前、后、异常、最终处
    • 只有植入后 advice 才会有效
  • 切面关键三要素

    • 功能代码:切面能执行的功能;Aspect

    • 执行位置:PointCut 表示切面执行的位置;连接点集合

    • 执行时间: Advice 表示时间;在目标方法之前、之后

实现框架

  • AOP 是规范,动态代理的规范化标准

    • AOP 技术实现框架
  • Spring

    • Spring 内部实现了 AOP 规范,可以使用
    • 主要在事务处理时使用 AOP
      • 实际很少使用 Spring 的 AOP 实现,使用过于笨重
  • aspectj:开源的专门做 AOP 的框架

    • Spring 集成了 aspectj 框架,通过 Spring 可以使用

    • 实现 AOP 方式

      1. 使用 xml 配置文件
        • 配置全局事务
      2. 使用注解
        • 通常使用注解
        • 5 个注解

aspectj

执行时间

  • 切面执行时间:Advice(通知、增强)
  • aspectj 中使用注解表示
    • @Before
    • @AfterReturning
    • @Around
    • @AfterThorwing
    • @After
  • 或使用 xml 配置文件标签表示

执行位置

  • 切面执行位置使用切入点表达式 execution()

    execution(
        modifiers-pattern? 
        ret-type-pattern 
        declaring-type-pattern?
        name-pattern(param-pattern) 
        throws-pattern?
    )
    
    • 参数说明
      • modifiers-pattern:访问类型权限
      • ret-type-pattern:返回值类型
      • declaring-type-pattern:包名类名
      • name-pattern(param-pattern):方法名(参数类型和个数)
      • throws-pattern:抛出异常类型
      • ?:可选部分
  • 切入点表达式要匹配的对象是目标方法的方法名

    • 表达式中就是方法签名
    • execution(访问权限 方法返回值 方法声明(参数) 异常类型)
      • 访问权限、异常类型 可忽略
    • 各部分用空格分开,可使用通配符
      • * :0 ~ 任意多个字符
      • ..
        • 在方法参数中表示任意多参数
        • 在包名后表示当前包及子包路径
        • 在类名中出现时后面必须跟 *
          • 表示包、子包下所有类
      • +
        • 类名后表示当前类及子类
        • 接口后表示当前接口及实现类
  • 示例

    1. execution(public * *(..))
      • 指定切入点:所有公共方法
    2. execution(* set*(..))
      • 指定切入点:所有以 set 开始的方法
    3. execution(* com.xyz.service.*.*(..))
      • 指定切入点:com.xyz.service 包中所有类的所有方法
    4. execution(* com.xyz.service..*.*(..))
      • 指定切入点:com.xyz.service 包或子包中所有类的所有方法
    5. execution(* *..service.*.*(..))
      • 指定切入点:所有包下的 service 子包中所有类、接口的所有方法

基本流程

  • 使用 aspectj 实现 AOP 的基本流程

    1. 创建 Maven 项目
    2. 添加依赖
      • spring 依赖
      • aspectj 依赖
    3. 创建目标类:接口和实现类
    4. 创建切面类:普通 Java 类
      • 类上面添加 @Aspect 注解
      • 类中定义方法
        • 方法上添加 aspectj 中的中的通知注解
          • 例如:@Before
        • 指定执行位置(execution()
    5. 创建 Spring 配置文件
      • 声明对象,并把对象交给容器统一管理
        • 使用 xml 配置文件或注解
      • 声明目标对象
      • 声明切面类对象
      • 声明 aspectj 框架中的自动代理生成器标签
        • 自动代理生成器
          • 完成代理对象的自动创建功能
    6. 创建测试类
      • 从 spring 容器中获取目标对象(即 代理对象)
        • 通过代理执行方法实现 AOP 的功能增强

切面类

@Aspect
  • aspectj 框架中的注解
  • 表示当前类是切面类
    • 用来给业务方法增加功能的类,类中有切面的功能代码
  • 写在类定义上面
通知方法
要求
  • 切面类的功能方法

    • 方法用来实现切面功能
    • 添加注解:执行时间
    • 注解属性 value:执行位置
  • 定义要求

    • 公共方法:public 访问权限
    • 无返回值
      • 环绕通知必须有一个返回值
    • 名称自定义
    • 参数可有可无
      • 有参数时不能是自定义类型
    /*
    @Before:执行时间
    execution():执行位置
    */
    @Before("execution(void send())")
    public void startTime() {
        // 功能代码
    }
    
方法参数
  • 指定通知方法中的参数:JoinPoint

    • JoinPoint:要加入切面功能的业务方法
  • 作用:可以在通知方法中获取方法执行时的信息

    • 例如:方法名、方法实参
  • 切面功能需要用到目标方法方法信息时使用参数

    • 参数由框架赋值,必须是第一个位置
    @Before(void send())
    public void start(JoinPoint jp){
        /* 获取目标方法信息 */
        // 完整方法定义
        jp.getSignature();
        // 方法名
        jp.getSignature().getName();
        // 获取方法所有参数
        Object[] obj = jp.getArgs();
        // 目标对象
        jp.getTarget();
        // 代理对象
        jp.getThis();
        // 完整切入点表达式
        jp.toLongString();
        // 简单切入点表达式
        jp.toShortString();
    }
    
@Before
  • 前置通知,写在方法上面;目标方法之前执行
  • 属性 value:切入点表达式,表示功能执行位置
  • 特点
    • 不会改变目标方法执行结果
    • 不会影响目标方法执行
@AfterReturning
  • 后置通知,目标方法返回后调用

  • 属性

    • value:切入点表达式
    • returning:自定义变量名,表示目标方法的返回值
      • 必须和通知方法形参名一致
  • 特点

    • 能获取目标方法返回值,根据不同返回值做不同处理
    • 可修改返回值
      • 类似传参,将目标方法返回值传到后置通知方法
      • 引用类型返回值被修改后影响原结果
// 自定义变量名必须和通知方法形参名一致,jp必须是第一个参数
@AfterReturning(value = "execution(int[] send())", returning = "obj")
public void endTime(JoinPoint jp, Object obj) {
    // 参数类型为引用类型的数组
    // 修改数组数据会影响原返回值结果
    int[] re = (int[])obj;
}
@After
  • 最终通知,最终总会执行,即使目标方法异常
  • 属性 value:切入点表达式
  • 特点:总是会执行
    • 在目标方法之后执行
    • 一般进行资源清除工作
@AfterThrowing
  • 异常通知,目标方法抛出异常后调用
  • 属性
    • value:切入点表达式
    • throwing:自定义变量
      • 表示目标方法抛出的异常对象
      • 变量名必须和方法形参名保持一致
  • 特点
    • 可以做异常的监控程序
      • 监控目标方法执行时是否有异常
      • 有异常时可以发送邮件、短信进行通知
@Around
  • 环绕通知,将目标方法封装
  • 属性 value:切入点表达式
  • 特点:功能最强的通知
    • 在目标方法前后都能增强功能
    • 可以控制目标方法是否被调用
    • 修改目标方法执行结果,影响最后调用结果
  • 类似 JDK 动态代理中的 invoke 方法
  • 方法定义格式
    • public,方法名自定义
    • 必须有返回值,推荐使用 Object
      • 目标方法返回结果,可被修改
    • 固定方法参数:ProceedingJoinPoint
      • 用来执行目标方法
      • 获取目标方法信息
        • 继承了 JoinPoint 类
@Around("execution(int[] send())")					// 加强返回值 int[] 类型的 所有 send() 方法
public Object time(ProceedingJoinPoint point){
    int[] obj;
    try {
        //获取目标方法实参集合
        Objec[] args = point.getArgs();
        if(args != null && argds.length > 1){
            // 可以根据参数结果决定如何执行方法
            Object name = args[0];
        }
        System.out.println("在目标方法之前执行方法");
        obj = (int[]) point.proceed();					// 执行目标方法,获取方法返回值
        System.out.println("在目标方法之后执行方法");
        // 修改返回值
        obj[0] = 0;
        obj[1] = 0;
        obj[2] = 0;
    } catch (Throwable e) {
        throw new RuntimeException(e);
    }
    return obj;
}
@Pointcut
  • @Pointcut:定义切入点

    • 当较多通知方法使用相同的 execution() 表达式时编写维护比较麻烦
  • @Pointcut 注解用于定义 execution() 切入点表达式

  • 注解在方法之上,之后所有的 execution() 的 value 属性值都可以使用该方法名作为切入点

    • 包括括号

    • 代表 @Pointcut 定义的切入点

    • @Pointcut 注解的方法一般使用 private 方法

      • 该方法没有实际作用,仅作为通用切入点表达式存在
示例
切面类
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

// @Aspect 注解表示这是切面类
@Aspect
public class AspectDemo {

    /*
     * 在目标方法之前执行,输出执行时时间
     * 目标方法:public void demo.bean.Demo01.send()
     */
    @Before("execution(public void demo.bean.Demo01.send())")
    public void startTime() {
        System.out.println("开始执行:" + System.currentTimeMillis());
    }

    /*
     * 在目标方法后执行,输出执行时时间
     * 目标方法:所有无返回值、无参数的 send 方法
     */
    @After("execution(void send())")
    public void endTime() {
        System.out.println("执行完毕:" + System.currentTimeMillis());
    }
}
spring 配置文件
  • 声明自动代理生成器
<!-- 声明自动代理生成器需要添加新约束文件 -->
<!--
xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop 
https://www.springframework.org/schema/aop/spring-aop.xsd">
-->
<!-- 使用注解生成了目标类对象 -->
<!-- 声明切面类对象,或者直接使用 @Component 注解声明 -->
<bean id="aspectDemo" class="demo.utils.AspectDemo"/>
	
<!-- 
声明自动代理生成器:使用 aspectj 框架的内部功能
aop 是新约束文件命名空间
-->
<!-- 默认使用 JDK 动态代理,当代理对象没有接口时使用 CGLIB -->
<aop:aspectj-autoproxy/>
autoproxy

<aop:aspectj-autoproxy/>

  • 声明自动代理生成器,创建目标对象的代理对象
  • 在内存中实现创建代理对象
    • 先创建了目标对象和切面类对象
    • 修改目标对象在的内存中结构,创建为代理对象
      • 即 目标对象就是修改后的 代理对象
  • 目标类有接口时默认使用 JDK 动态代理
    • 没有接口时使用 CGLIB 动态代理
    • 有接口时也可以选择使用 CGLIB 动态代理
<!-- 有接口时默认使用 JDK 动态代理,无接口使用 CGLIB -->
<aop:aspectj-autoproxy/>
<!-- 声明使用 CGLIB 动态代理 -->
<aop:aspectj-autoproxy proxy-target-class="true"/>

相关文章:

  • 2022研究生电子设计竞赛总结(东北赛区一等奖、国家二等奖)
  • 秋招面试- - -Java体系最新面试题(8)
  • Spring5详解
  • 基于PLC四层电梯模型控制系统
  • 编译原理笔记
  • vue中如何监听localStorage值的变化
  • Acwing算法基础课总结
  • Libgdx游戏开发(1)——环境配置及demo运行
  • ESB产品调用场景分析
  • 【微机原理】微处理器与总线
  • 【youcans 的图像处理学习课】11. 形态学图像处理(下)
  • Day19NAT
  • ARMv9新特性:虚拟内存系统架构 (VMSA) 的增强功能
  • 大数据入门之 Hadoop,HDFS,Hbase,Hive
  • 令人头秃的js隐式转换面试题,你能做对吗
  • 信号(软件中断)编程
  • django基于python的酒店预订管理系统--宾馆管理系统-计算机毕业设计
  • Google 翻译插件不能用了怎么办
  • OpenJudge NOI 1.5 编程基础之循环控制(41-45题)C++ 解题思路
  • 硬件设计基础----通信协议UART