Spring基础笔记

  1. 云栖社区>
  2. 博客>
  3. 正文

Spring基础笔记

推荐码发放 2019-08-15 13:23:15 浏览165
展开阅读全文

Spring基础笔记
Spring带给了我们什么便利?
注解版本的IOC如何玩?
组件注册
组件注册的过程中有哪些过滤规则?
如何控制组件的作用域(单例多例)?
六种注册组件的方式?
生命周期
什么是bean的生命周期
在bean的生命周期的各个阶段我们可以插手做什么?
属性赋值
我们有哪些手段给bean的属性赋值?
自动装配
什么是自动装配?
Spring提供哪些注解可以帮我们实现自动装配?
java规范提供了哪些注解帮助我们实现了自动装配?
Spring提供的@Profile实现适配多环境?
注解版本的AOP如何玩?
Spring带给了我们什么?
假如我们是第一次学习Spirng,我们大可不必关心spring带给我了我们什么便利,因为spring大概是web阶段筑基需要学习的第一个主流框架,初学难免会遇见各种各样的错误,所以尽管放心大胆的去学习如何使用就行了.先会用,其它的不用多想

过几天,用着熟悉了如何使用,再考虑spring究竟带给了我们什么便利也不迟, 那么,spring究竟带给了我们什么便利呢?

IOC(Inverse of Control),把对象的创建权反转给Spring容器,实现了解耦

我们使用Spring提供给我们的注解,把bean注册进IOC容器,进而把bean之间的依赖关系全部交给Spring管理,现在想想这绝对是一件超级赞的事情,可能原来的我会想,我自己可以new对象,干嘛非让Spring插一脚,是,假如我的项目就是个小demo全文一共三对象,完全顾的上来,那么spring对我来说就是累赘,但是!慢慢的接触的工程大了就会发现,离开了Spring,自己去管理那些对象之间的依赖会累死人的,而且SpringIOC的诞生也应正了bean的管理,完全不需要我们关系,我们关心的就是,我们如何向Spring索取依赖的Bean就行了,所以说Spring真的是web爱好者的小春天.

AOP(Aspect Oriented Programming),spring的aop

面向切面编程,aop说白了就是代码复用,把大量的重复代码从我们的业务逻辑中抽取出去,等程序运行的时候再动态的植入抽取出去的代码,这是件要多优雅就多优雅的事情!

声明式事务

后端天天和数据库打交道,事务安全这样的不可能遇不见,我们这一代学习的人还真的是幸运,因为spring提供的声明式事务,我们不用再去苦苦的去写编程式事务,而且,现在spring4全面支持注解开发,我们甚至连配置文件都不用写,加一个注解就引入了spring的事务模块,激动不?

方便集成其他开源框架

spring最擅长的事情就是整合这使它的生态变的超级庞大

例外给大家推荐一篇很棒的博客,里面详细图文论述了,spring究竟带给了我们什么?

spring实现解耦论述

注解版Spring-IOC怎么玩?
组件注册
只使用IOC,导入Spring-Context就可以

<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.7.RELEASE</version>


这个过程,我们要注意IOC以下几点

组件注册的过程中有哪些过滤规则?
如何控制组件的作用域(单例多例)?
六种注册组件的方式?
组件注册及其过滤规则我串联在下面相邻的两部分里,这里先提一下Spring提供的所有过滤规则类型

在spring启动,开始扫描包,注册组件时,如果我们想按照我们的需求往IOC里面添加组件,就需要指定过滤规则,下面这五种类型的过滤规则,都源于我们在主配置类(相当于配置文件)上添加的@ComponentScan()包扫描注解

按照注解过滤ANNOTATION
@ComponentScan(// 这个注解替换了原来配置文件中的包扫描

value="com.changwu.tryspring",
useDefaultFilters=false,
includeFilters = {
  @Filter(type = FilterType.ANNOTATION, classes = Service.class)}
  )

按照给定的类型过滤
@Configuration
@ComponentScan(// 这个注解替换了原来配置文件中的包扫描

    value="com.changwu.tryspring",
    useDefaultFilters=false,
    includeFilters = {
     //只要是给定的类型的类,就可以加载进IOC,包括它的子类
      @Filter(type = FilterType.ASSIGNABLE_TYPE,classes = BookDao.class)
    }
    )

按照切面 (ASPECTJ) 基本不用

按照正则 REGEX

自定义规则 CUSTOM

@Configuration
@ComponentScan(// 这个注解替换了原来配置文件中的包扫描

value="com.changwu.tryspring",
useDefaultFilters=false,
includeFilters = {
       // 只要是给定的类型的类,就可以加载进IOC,包括它的子类
        @Filter(type = FilterType.CUSTOM,classes = MyTypeFilter.class)
}

)
注解版本中,配置类替换了原来的配置文件
@Configuration 注解标记本类为配置类

那么我不加@Configuration注解,这个类就不能成为配置类吗? 里面通过@Bean注解就添加不进bean来了? 不是的, @Configuration标记会被Spring使用Cglib技术拦截下来,换言之我们得到的bean,不再是我们自己new 的那种小白bean,而是被代理过的Bean

那么什么才是百分百的配置类呢? 配置类是我们调用如下代码所需要的那个类

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();

    applicationContext.register(配置类.class);

如下代码! 原来的包扫描被@ComponentScan 取代!!! 里面可以配置多个信息

基础包信息value="com.XXX"
排除被哪个注解标记的类excludeFilters = @Filter(type... classes...)
只要被哪个注解标记的类,(配置文件版本的分两步!第一步禁用掉默认的过滤器),注解版同样分两步useDefaultFilters=false, includeFilters = @Filter(classes= Service.class)
excludeFilters 把bean排除出IOC容器!!! 一般都是按照注解, 后面是 !!注解!!的Class数组,
另外,过滤器Filter的过滤类型,默认为按照注解过滤!!!

还可以在配置类中往IOC容器中组成对象!!!@Bean,用的时候 @Autowired

默认情况下,无论获取多少次,都是单实例的!!!

/**

  • 配置类,等同于原来的配置文件
    *
  • @Author: Changwu
  • @Date: 2019/3/31 16:57
    */

@Configuration
@ComponentScan(// 这个注解替换了原来配置文件中的包扫描

    value="com.changwu.tryspring",
     excludeFilters = @Filter( type =FilterType.ANNOTATION, classes = Repository.class)
    )

// excludeFilters 把bean排除出IOC容器!!! 一般都是按照注解, 后面是 !!注解!!的Class数组,

public class MainConfig {

/**
 * 给容器注册bean
 * 类型: 为返回值的类型
 * id 默认使用方法名
 * @return
 */
@Bean(value = "stu")  // value可以自定义名字
public Student getStu(){
    return  new Student("张三",23);
}

}
此外在java8中,有如下代码,@ComponentSacn的倒数第二个注解是@Repeatble 意味着我们可以在主配置类上写多个@ComponentScan

*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {...}
自定义TypeFilter的过滤规则
自定义注解,要求实现FilterType接口,实现他的match(),该方法里面的两个参数都是接口类型的,我们可以从它里面取出关于IOC所扫描到的所有类的源信息,满足我们的预期,返回true,表示允许注册进IOC

public class MyTypeFilter implements TypeFilter {
/**
*

  • @param metadataReader // 获取到当前的正在扫描的类的信息
  • @param metadataReaderFactory // 可以获取到,其他任何类的信息
  • @return
  • @throws IOException
    */

@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {

AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();//获取当前类的注解信息
ClassMetadata classMetadata = metadataReader.getClassMetadata();// 获取当前正在扫描类的 类信息, 比如实现了什么接口,有什么方法
Resource resource = metadataReader.getResource();// 获取类的资源信息, 比如在那个盘,路径

String className = classMetadata.getClassName();
System.out.println("---->"+className);
// 自定义,如果有@Repository注解,注入进去
Set<String> annotationTypes = annotationMetadata.getAnnotationTypes();

for (String annotationType : annotationTypes) {
    System.out.println("++++++"+annotationType);
}
if (annotationMetadata.hasAnnotation("org.springframework.stereotype.Service")){
    return true;
}

/* if (className.contains("er")){

return true;

}*/

return false;

}
}
@Scope, 设置组件的作用域
容器中的对象默认都是单实例的!!!,我们使用@Scope 注解改变这种状态

/*
String SCOPE_SINGLETON = "singleton";  单例
String SCOPE_PROTOTYPE = "prototype";  多例

*/

@Scope(scopeName = "prototype")
@Bean(value = "stu2")
public Student getStu2(){
    return new Student("李四",24);
}

}
观察在单实例和多实例情况下,bean创建的时机

默认在单实例的情况下,ioc容器创建完,直接加载bean

但是以后每次获取都会都是从IOC容器中获取

懒加载@Lazy! 针对单实例Bean,我们知道,容器启动的时候,就会创建一个唯一的bean,我们使用懒加载可以做到,在第一次使用的时候加载bean

多实例情况下,只有在获取类时,IOC容器才会创建bean,!!!

以后每次获取Bean,ioc容器都会调用那个方法去new Bean

六种给容器注册组件的方法
着重看一种,按照条件注册bean @Conditional springboot底层大量的使用!!!
它的实现方式和自定义过滤条件相似
@Conditional : 按照条件注册bean

// 既可以标在类上,也可以标在方法上
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Conditional {

/**
 * 所有的条件,都必须是注册过的!!!.
 */
Class<? extends Condition>[] value();

}
解释一下怎么用:

它是个接口,需要的属性名为 value, 值是Class数组 ,可以进一步看到它的泛型是Condition接口 我们自己实现接口,重写里面的方法match(),根据方法提供的参数可以获取到我们想要的任何信息,返回true表示满足条件,注册bean,否则不注册
其他注册组件的方法

方式1: 包扫描+注解 (@Cotroller @Service @Repository等等注解的类可以被IOC扫描到,添加进容器)
这种方法有局限性!!!, 只能是我们自己写的类, id为首字母小写的类名

方式2: 在配置类内部 使用: @Bean注解,
更多的使用它注册第三方bean

方式3: 在配置类头上使用  @Import(XXX.class,YYY.class)
解放了第二种通过@Bean还的自己new的缺陷!!! 组册进IOC中的组件的默认id,是组件的全类名

方式4: @Import({Color.class, MyImportSelector.class})

实现ImportSelector接口: 返回需要导入的组件的全类名数组,完成批量导入

方式5: 手动注册@Import({Color.class,MyImportSelector.class, MyImportBeanDefinitionRegisrar.class})

实现ImportBeanDefinitionRegistrar接口: 它里面的registerBeanDefinitions()方法的第二个参数就是BeanDefinitionRegistry, 所有bean注册进IOC容器都经由他完成,因此我们可以手动注册bean, 还可以通过第一个参数获取当前标注@Import注解的类的全部注解信息,加上第二个参数可以获取当前IOC容器的全部信息,动态判断是否要注入类到IOC

同时,第五种在SpringBoot中得到了大量的使用,实现SpringBoot的自动配置

方式6 : 使用Spring提供的FactoryBean (工厂bean)
自己实现FactoryBean接口,重写三个方法
@Bean,把自己实现的工厂bean添加到IOC
测试自己实现的BeanFactory的类型,是我们指定的泛型的类型的!!!
想获取到工厂的话, 需要添加前缀&
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig02.class);
Object getFB1 = applicationContext.getBean("&getFB");
Object getFB2 = applicationContext.getBean("getFB");
Bean的生命周期
通过第一阶段的学习,我们顺利把bean的创建权反转给了Spring,下面就来看看,IOC是如何控制Bean的生命周期的!

什么是bean的生命周期?

其实,就是下面的过程

Bean创建------> 初始化------> 销毁

在IOC管理bean生命周期的过程中,我们可以插手做什么?

我们可以自定义bean的初始化和销毁方法,bean在到达相应的生命周期时,ioc会调用我们指定的方法,施加在bean上

原来的配置文件版本,需要我们写 init-method 和distroy-method

如何实现?

方法1: 使用@Bean注解完成
@Bean(initMethod="init",destroyMethod = "destory")
测试类

@Test

public void text6(){
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(LifeConfig.class);
    Object car = applicationContext.getBean("car");
    System.out.println(car);
    applicationContext.close();
}

单实例情况下: 对象创建后并赋值好了后,执行init方法,容器关闭对象销毁

多实例情况下: 对象创建后并赋值好了后,执行init方法,IOC不会管理bean,需要我们自己去销毁bean

用处?

在配置数据源是大量使用,对象创建后需要初始话很多的数据,对象销毁了,很多资源要释放

方法2: 让Bean实现spring提供的两个接口InitializingBean和DisposableBean,重写这两个接口的方法
public interface InitializingBean {

// Bean初始化后调用
void afterPropertiesSet() throws Exception;

}

public interface DisposableBean {
// Bean销毁后调用

void destroy() throws Exception;

}
单例模式下: 在IOC一初始化就进行bean构造,并且执行完了的afterPropertiesSet()初始化,容器关闭,bean执行销毁DisposableBean()
方法3: 使用JS205规范提供的两个注解@PostConstruct和@PreDestory完成
@PostConstruct :在bean创建完成并且属性赋值好了后执行本初始化方法
@PreDestory: 在容器销毁bean之前,通知我们进行清理工作
这两个注解都是标注在方法上的!!!

@Documented
@Retention (RUNTIME)
@Target(METHOD)
public @interface PostConstruct {
}

@Documented
@Retention (RUNTIME)
@Target(METHOD)
public @interface PreDestroy {
}
方法4: 使用Spring提供给我们的组件,接口BeanPostProcessor
这个组件很重要,Spring的底层,尤其是AOP底层大量使用它
里面有两个方法

public interface BeanPostProcessor {

// 该方法,会在我们说的前三种初始化方法调用之前, 提前调用!!!
// 返回值,可以是我们新创建好的这个bean,也可以包装一下bean 再返回

/* Apply this BeanPostProcessor to the given new bean instance <i>before</i> any bean
 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
 * or a custom init-method). The bean will already be populated with property values.
 * The returned bean instance may be a wrapper around the original.
 */
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

// 在上面我们所说的三种初始化方法调用之后,立刻调用!!!

Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

}
实现自己的BeanPostprocessor

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

System.out.println("postProcessBeforeInitialization执行了!!!"+"    beanname=="+beanName+"  bean=="+bean);
return bean;

}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

System.out.println("postProcessAfterInitialization执行了!!!"+"    beanname=="+beanName+"  bean=="+bean);
return bean;

}
}
测试结果如下图

划重点!!! --- BeanPostprocessor意味bean的后置处理器,前面也说了,它是spring提供给我们的一个辅助类型的组件,我们可以自定义BeanPostProcessor,在所有满足加入IOC容器的bean初始化方法前后执行BeanPostProcessor接口里的postProcessAfterInitialization() 和 postProcessBeforeInitialization()方法,完成对bean的增强,AOP的底层使用的 后置处理器 是spring自动给我们加载进来的,他的这种特性,为AOP,动态植入代码的实现,提供的前提

接口BeanPostProcessor运行原理
遍历得到容器中所有的BeanPostProcessor,挨个执行beforeInitialization,一旦返回值为null,说明ioc在没有这个对象,直接跳出for循环,不会执行BeanPostProcessor.postProcessBeforeInitialization()方法进行处理
populateBean(beanName,mdb,instanceWrapper);给bean的属性赋值

initlizeBean // 初始化
{

applyBeanPostProcessorBeforeInitialization()  // 前置处理
invokeInitMethods(beanName,wrappedBean,mdb); // 执行初始化方法
applyBeanPostProcessorAfterInitialization() ; // 后置处理

}

通过这个继承图,可以看到,BeanPostProcessor作为后置处理器的顶级接口存在,程序运行打上断点,也能看到我们自定义的MyBeanPostProcessor,另外需要我们关心的一个实现是 InstantiationAwareBeanPosProcessor这个子接口,AOP的实现,就应用到了它(第二篇博客会记录)

使用配置文件给bean赋值

<property name="age" value="18"/>
<property name="name" value="zhangsan"/>


使用注解的方法,给bean赋值
@Value

  1. 基本数值
    @Value("changwu")

private String name;

  1. {} SPEL表达式

    @Value(value ="#{2*2}")

private int age;

  1. ${} 取出配置文件中的值
    @Value(value ="${student.age}")

private int age;
其中取出配置文件中的值,要在主配置类上添加@PropertySource(value = "classpath:/bean.properties")指明配置文件的路径

@Value+@PropertySource
前者使用${} 取出环境变量中的属性(程序运行后配置文件会加载进环境变量),后者给前者提供定位

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(PropertySources.class) // 可以写多个
public @interface PropertySource {

String name() default "";

//支持同时加载多个配置文件
String[] value();

// 忽略文件找不到
boolean ignoreResourceNotFound() default false;

//设置编码
String encoding() default "";

/**

  • Specify a custom {@link PropertySourceFactory}, if any.
  • By default, a default factory for standard resource files will be used.

  • @since 4.3
  • @see org.springframework.core.io.support.DefaultPropertySourceFactory
  • @see org.springframework.core.io.support.ResourcePropertySource
    */

Class<? extends PropertySourceFactory> factory() default PropertySourceFactory.class;
}
自动装配?
什么是自动装配?
自动装配就是,Spring利用依赖注入DI,完成对IOC容器中的各个组件依赖关系的赋值

@Autowired & @Qualifier & @Primary
@Autowired是Spring自己的注解

那些Bean,都在IOC中,通过@Autowired注解可以完成自动装配

默认按照类型(XXX.class)去IOC中找到对应的组件
如果存在多个bean,就按照id找( @Autowired标记的引用名)
使用@Autowired,默认如果IOC中不存在该bean,就会报错

通过设置@Autowired(required=false) 设置组件不必需存在于,IOC
@Autowired+@Qualifier 明确指定装配的bean的id

@Qualifier("bookDao2")
@Autowired
private BookDao bookDao;
再强调一遍,如果是包扫描的话,Bean在IOC的id是类名首字母小写,@Qualifier("XXX")不能乱写,要么是类名首字母小写,要么是我们通过@Bean("XXX")指定的id

@Primary 标记在我们手动添加进去的bean上,强制,首选注入!!!
但是,如果同时存在@Primary和@Qualifier 依然会装配我们明确指定的Bean

// 构造器, 方法,参数,属性,全能!!!
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {

/**
 * Declares whether the annotated dependency is required.
 * <p>Defaults to {@code true}.
 */
boolean required() default true;

}
@Autowired标注在方法上,方法的参数,默认从容器中获取
@Autowired标注在构造器上,构造器需要的参数,默认从容器中获取
@Bean标注的方法,方法的参数,默认从容器中获取,在参数位置的@Autowired可以省略不写
@Resources(JSR205) & @Inject(JSR330)
java规范注解

@Resources

作用: 默认按照组件名称装配
缺点: 不能和@Qulifier和@Primary一起使用
@Inject

还麻烦! 需要我们导入依赖

<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>


@Profile
Spring为我们提供的可以根据当前的环境,动态的激活和切换一系列组件的功能

比如在开发环境下,我们使用A数据库, 测试环境使用B数据库, 生产环境使用C数据库

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@Documented
@Conditional(ProfileCondition.class)
public @interface Profile {

/**
 * The set of profiles for which the annotated component should be registered.
 */
String[] value();

}
支持写到方法上!满足@profile指定的环境下,方法的中组件的注入才会生效

支持写到类上!满足@profile指定的环境下,整个类的中组件的注入才会生效

准备工作,注册三个数据源
@Configuration
@PropertySource("classpath:/dbProperlies.properties")
public class MainConfiguration {

@Value("${db.user}")
private String user;

@Value("${db.driverClass}")
private String driverClass;
@Profile("text")
@Bean("TextDBSource")
public DataSource dataSourceText(@Value("${db.password}") String pwd) {
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setUser(user);
    dataSource.setPassword(pwd);
    dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/text");
    try {
        dataSource.setDriverClass(driverClass);
    } catch (PropertyVetoException e) {
        e.printStackTrace();
    }
    return dataSource;
}

@Profile("dev")
@Bean("DevDBSource")
public DataSource dataSourceDev(@Value("${db.password}") String pwd) {
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setUser(user);
    dataSource.setPassword(pwd);
    dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/person");
    try {
        dataSource.setDriverClass(driverClass);
    } catch (PropertyVetoException e) {
        e.printStackTrace();
    }
    return dataSource;
}

@Profile("pro")
@Bean("ProductDBSource")
public DataSource dataSourceProduct(@Value("${db.password}") String pwd) {
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setUser(user);
    dataSource.setPassword(pwd);
    dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/ssh1");
    try {
        dataSource.setDriverClass(driverClass);
    } catch (PropertyVetoException e) {
        e.printStackTrace();
    }
    return dataSource;
}

}
2 . 结合@Profile注解,在组件上做一个标识,只有满足@Profile标识条件的才会被注册进IOC

加了环境标识的bean,只有那个环境被激活,才会注册到容器中,默认是@Profile("default")
没有环境标识的bean,任何条件下都会加载进容器
如何改变环境?
使用代码的方法
@Test

public void text13(){
    // 创建上下文
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
    // 设置需要激活的环境
    applicationContext.getEnvironment().setActiveProfiles("dev");    // 开发环境下注册组件
    // 加载主配置类
    applicationContext.register(MainConfiguration.class);
    // 启动刷新容器
    applicationContext.refresh();
    String[] names = applicationContext.getBeanDefinitionNames();
    for (String name : names) {
        System.out.println(name);
    }
    applicationContext.close();
}

注解版AOP怎么玩?
AOP面向切面编程,指的是在程序运行期间,动态的将某段代码,切入到指定方法的指定位置额运行的编程方式 

导入AOP模块

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


创建业务逻辑类
我们要做的就是在动态的在div运行前,运行后,出现异常时,正常结束,异常结束等不同情况下打印日志
public class MathAop {

public int div(int a,int b){
    return  a-b;
}

}
定义一个日志切面类
切面类上的方法会动态的感知到,切入点div的状态,在其指定的状态上,做出不同的反应而无序更改仍和div的代码

五种通知方法,对应五种不同的注解,具体的细节,在下面的代码中有注释

@Component
@Aspect
public class AopLog {
抽取切入表达式
注解@Pointcut
表达式可以使用* 通配
execution(pulbic com.changwu.tryspring.aop.MathAop.*(int,int))
execution(* com.changwu.tryspring.aop.MathAop.div(..))
本类使用 : 直接用方法名--> pointCut()
其他类使用: 使用带包名的全路径--> com.changwu.tryspring.aop.AopLog.pointCut()

@Pointcut("execution(* com.changwu.tryspring.aop.MathAop.div(..))")
public void pointCut(){}

前置通知
注解@Before("切入点表达式")
调用时机: 在目标方法执行前执行
可选参数: JoinPoint,里面封装着切入点方法的全部信息,比如方法名,参数等等

@Before("com.changwu.tryspring.aop.AopLog.pointCut()")
public void before(JoinPoint joinPoint){
    Object[] args = joinPoint.getArgs();  // 获取参数
    String name = joinPoint.getSignature().getName();  //  获取方法名
    System.out.println("前置通知....参数:"+ Arrays.asList(args)+"  方法名: "+name);
}

后置通知
注解@After("切入点表达式")
调用时机:无论方法正常结束还是异常结束,都调用

@After("execution(* com.changwu.tryspring.aop.MathAop.div(..))")
public void after(){
    System.out.println("后置通知执行了!!!");
}

返回通知
注解@AfterReturning(value="切入点表达式",returning="XXX")
调用时机: 方法正常返回执行
注意点: 函数的入参,参数名和注解中的XXX要相同,里面封装着,函数的返回值结果

@AfterReturning(value = "com.changwu.tryspring.aop.AopLog.pointCut()",returning = "result")
public void returning(Object result){
    System.out.println("切入点正常执行...运行结果..{"+result+"}");
}

异常通知
注解@AfterThrowing(value="切入点表达式",throwing="XXX")
调用时机: 切入点出现异常
注意点:函数的入参,参数名和注解中的XXX要相同,里面封装着,函数的返回值结果
XXX里面封装着方法的异常信息

@AfterThrowing(value = "com.changwu.tryspring.aop.AopLog.pointCut()",throwing = "expection")
public void afterThrowing(Exception expection){
    System.out.println("切入点出现异常,异常结果..{"+expection+"}..");
}

环绕通知
注解@Around("切入点表达式")
调用时机: 切入点执行前后都会执行
参数:ProceedingJoinPoint里面封装了关于切入点的所有信息
proceedingJoinPoint.proceed();返回值: 为切入点的返回值, 必须返回
环绕通知里面的所有异常全部抛出去,,一旦我们try起来了,异常通知就获取不到异常,进而返回通知就认为方法是正常结束的,结果为NULL

@Around("com.changwu.tryspring.aop.AopLog.pointCut()")
public Object arounding(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {

    System.out.println("环绕通知开始:  方法名:  "+
            proceedingJoinPoint.getSignature().getName() +
            "将要被执行   参数为:  "+Arrays.asList(proceedingJoinPoint.getArgs()));
    Object result = proceedingJoinPoint.proceed();// 代理调用方法,如过调用方法add抛出异常,就不会执行后面的代码(所以要抛出去!)
    // 调用方法之后执行
    System.out.println("环绕通知,调用方法之后执行,获取的结果是:"+result);
    return result;

}

}
注意点: 业务逻辑类,切面类都要添加进IOC

注意点: 切面类都要添加注解@Aspects

补充: JointPoint 可以获取的切入点的信息 而且,必须在参数的第一位

好继续准备,回顾xml版本的spring开发方式需要我们添加如下的配置


基于注解,开启切面--->@EnableAspectjAutoProxy
@Configuration
@EnableAspectJAutoProxy
@ComponentScan("com.changwu.tryspring.aop")
public class MainAopConfig {
}
测试:
@Test
public void text14(){

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainAopConfig.class);
// 根据类型获取bean
MathAop mathAop = applicationContext.getBean(MathAop.class);
mathAop.div(2,1);
applicationContext.close();

}
原文地址https://www.cnblogs.com/ZhuChangwu/p/11356665.html

网友评论

作者关闭了评论
推荐码发放
+ 关注