day2021-10-06(Spring IOC生命周期，AOP入门)

最新推荐文章于 2022-08-14 22:49:40 发布
最新推荐文章于 2022-08-14 22:49:40 发布
阅读量114 收藏
点赞数
文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TIM_Zhang1122/article/details/120629119
版权

2. IoC详解

2.5 生命周期

2.5.1 自定义Bean

  • 目标类：需要完成初始化、销毁功能的类

    • @PostConstruct 用于修饰初始化方法。
    • @PreDestroy 用于修饰销毁方法。
    package com.czxy.demo13_lifecycle.domain;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@Component
public class Dog {
    @PostConstruct  //初始化
    public void init() {
        System.out.println("小狗 出生了");
    }

    public void eat() {
        System.out.println("正在吃...");
    }

    @PreDestroy     //销毁
    public void destroy() {
        System.out.println("小狗 挂了");
    }
}

  • 配置类：

    package com.czxy.demo13_lifecycle.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@Configuration
@ComponentScan(basePackages = "com.czxy.demo13_lifecycle.domain")
public class Demo13Configuration {

}

  • 测试类：

    package com.czxy.demo13_lifecycle;

import com.czxy.demo13_lifecycle.config.Demo13Configuration;
import com.czxy.demo13_lifecycle.domain.Dog;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo13Configuration.class)
public class TestDemo13 {
    @Resource
    private Dog dog;

    @Test
    public void testDemo13() {
        dog.eat();
    }
}

2.5.2 工厂bean （第三方类型）

  • 目录类（有第三方jar提供，模拟的数据不允许有注解）

    package com.czxy.demo14_lifecycle_bean.domain;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
public class Dog {
    public void init() {
        System.out.println("小狗14 出生了");
    }

    public void eat() {
        System.out.println("14正在吃...");
    }

    public void destroy() {
        System.out.println("小狗14 挂了");
    }
}

  • 配置类，使用@Bean注册第三方对象，通过 initMethod 和 destroyMethod 两个属性设置初始化和销毁

    package com.czxy.demo14_lifecycle_bean.config;

import com.czxy.demo14_lifecycle_bean.domain.Dog;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@Configuration
public class Demo14Configuration {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Dog dog() {
        return new Dog();
    }
}

  • 测试类

    package com.czxy.demo14_lifecycle_bean;

import com.czxy.demo14_lifecycle_bean.config.Demo14Configuration;
import com.czxy.demo14_lifecycle_bean.domain.Dog;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo14Configuration.class)
public class TestDemo14 {
    @Resource
    private Dog dog;

    @Test
    public void testDemo14() {
        dog.eat();
    }
}

2.5.3 生命周期函数有什么用？

  • 释放资源：

    public class 类名 {
    @Bean(destroyMethod="close")
    public DataSource datasource() {
        return new DruidDataSource();
    }
}

3.AOP

3.1 介绍

  • AOP：面向切面编程
  • 什么是AOP ? 使用代理技术，在不修改代码的基础上，对已有方法进行增强。

3.2 入门案例

  • 目标类：Dog

    package com.czxy.demo15_aop.domain;

import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@Component
public class Dog {

    public void eat() {
        System.out.println(" aop dog 正在吃...");
    }

}

  • 配置类：

    package com.czxy.demo15_aop.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@Configuration
@ComponentScan(basePackages = {"com.czxy.demo15_aop.domain","com.czxy.demo15_aop.aop"})
public class Demo15Configuration {

}

  • 测试类

    package com.czxy.demo15_aop;

import com.czxy.demo15_aop.config.Demo15Configuration;
import com.czxy.demo15_aop.domain.Dog;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo15Configuration.class)
public class TestDemo15 {
    @Resource
    private Dog dog;

    @Test
    public void testDemo15() {
        dog.eat();
    }
}

  • 修改配置类，开启AOP编程

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Rgm8YQaR-1633523164711)(assets/image-20211006093536279.png)]

    @EnableAspectJAutoProxy         //开启AOP

  • 编写切面类 MyAspect，对目标类的方法进行增强

    package com.czxy.demo15_aop.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@Component	//将当前类，添加到spring容器中
@Aspect     //切面编程注解
public class MyAspect {

    // 切入点表达式： 方法签名
    // @注解("execution(返回值类型  包名.类名.方法名(参数类型))")
    @Before("execution(void com.czxy.demo15_aop.domain.Dog.eat())")
    public void init() {
        System.out.println(" 15 初始化");
    }
}

3.3 入门案例2

  • 目标类：

    package com.czxy.demo16_aop.dao;

import org.springframework.stereotype.Repository;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@Repository
public class UserDao {

    public void insertUser() {
        System.out.println("添加");
    }

    public void updateUser() {
        System.out.println("更新");
    }
}

  • 配置类

    package com.czxy.demo16_aop.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@Configuration
@ComponentScan(basePackages = {"com.czxy.demo16_aop"})
@EnableAspectJAutoProxy         //开启AOP
public class Demo16Configuration {

}

  • 测试类

    package com.czxy.demo16_aop;

import com.czxy.demo15_aop.config.Demo15Configuration;
import com.czxy.demo15_aop.domain.Dog;
import com.czxy.demo16_aop.config.Demo16Configuration;
import com.czxy.demo16_aop.dao.UserDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo16Configuration.class)
public class TestDemo16 {
    @Resource
    private UserDao userDao;

    @Test
    public void testDemo15() {
        userDao.insertUser();
        System.out.println("----------");
        userDao.updateUser();
    }
}

  • 切面类

    package com.czxy.demo16_aop.aop;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@Component
@Aspect
public class MyAspect {

    @Before("execution(void com.czxy.demo16_aop.dao.UserDao.*User())")
    public void start() {
        System.out.println("开启事务");
    }

    @After("execution(void com.czxy.demo16_aop.dao.UserDao.*User())")
    public void commit() {
        System.out.println("提交事务");
    }
}

    总结：
    1，AOP 全称是Aspect Oriented Programming即：面向切面编程。
    面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
    2，AOP 可以在不修改原来代码的基础上，对已有方法进行增强。
    不错，离工作又进了一天!!!

TIM_Zhang1122
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
细说Spring——IoC详解（Bean的生命周期）
啦啦啦的博客
05-13 1361
我们在细说Spring——IoC详解（一）和细说Spring——IoC详解（二）中了解了容器启动阶段所做的事情，还有在容器启动阶段我们可以做的扩展，同时笼统的了解了一下容器是怎么创造出一个对象之后，我们接下来就要进入Bean的实例化阶段，同时学习一下在Bean的实例化阶段我们可以做哪些扩展。 首先我们先来看一个图： 这个图是《Spring揭秘》中的一个图，我们接下来就可以对照这个图来了解B...
day2-Spring IOC 和 DI 注解开发.md
10-15
IOC容器负责管理对象的生命周期，当一个对象需要另一个对象时，由容器来注入这些依赖的对象，而非对象自身去创建或查找依赖对象。Spring框架中的核心容器就是基于这种理念设计的。 ##### 2.2 IOC容器的实现方式 ...
Spring IOC 生命周期LifeCycle
05-21 25
lazy-init (不重要)  init-method destroy-methd 不要和prototype一起用（了解）   lazy-init=true延迟加载类在Spring容器初始化时，不初始化该bean，很少用当new ClassPathXmlContext时，Spring容器初始化时会加载全部Bean放到内存 当Spring容器中配置了很多个Bean，而经常需要重启时，...
spring ioc 生命周期-1
u012222011的博客
02-18 120
ClassPathXmlApplicationContext acx = new ClassPathXmlApplicationContext("spring.xml"); 这行代码执行完整个ioc生命周期就结束了。 public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
Spring - IoC(10): 生命周期
weixin_30294709的博客
05-17 70
Spring 容器可以管理 singleton 作用域 Bean 的生命周期，容器能够跟踪 Bean 实例的创建、销毁。管理 Bean 生命周期行为主要有两个时机： 　　注入 Bean 的依赖关系之后 　　即将销毁 Bean 之间 依赖关系注入之后的行为 有三种方式可以在 Bean 的所有属性设置成功后执行特定的行为：　　实现 org.springframework.beans.fact...
Spring IOC 对象生命周期
maodou95838的专栏
02-02 413
在bean对象创建到销毁的过程中，可以添加初始化方法和销毁方法。spring提供了四种方式： 1、initMethod（）、destroyMethod（） @Component public class Car { public Car(){ System.out.println("car constructor..."); } public void init(){ Sys...
day-Spring IoC & DI.md
10-15
- **Core Container**：核心容器，提供 BeanFactory 和 ApplicationContext，用于管理 Bean 的生命周期。 - **Data Access/Integration**：数据访问/集成，提供 Jdbc、ORM、OXM、JMS 等子模块，用于数据库操作和...
day06-10（FRAMEWORK进阶-V1.01）1
08-08
Spring 的核心是 IoC 容器，它管理着应用对象的生命周期和依赖关系： - **Bean 容器的初始化**：通过读取配置文件来初始化 Bean 容器。 - **两大 map 对象**：beanDefinitionMap 存储 Bean 的定义，beanInstanceMap ...
【框架源码篇 01】Spring源码-手写IOC
最新发布
10-21
5. **Bean管理**：最后，容器会管理Bean的生命周期，包括初始化、使用和销毁。 在实际开发中，Spring使用了更加高效和灵活的方式来实现这些功能，比如使用`ApplicationContext`接口作为IOC容器的入口，以及`...
【IoC】Spring IoC容器生命周期内容梳理
MarkusZhang的博客
08-14 2494
Spring IoC容器生命周期整体看下来比较简单，但细节还是比较多的，其中最核心的方法就是AbstractApplicationContext#refresh了，除此方法外，还有AbstractApplicationContext#start、stop、close方法。下面是整个IoC容器生命周期的概览图，接下来我们依次去分析其中的细节项。......
Spring IOC -bean对象的生命周期详解
yingfeng612的专栏
03-21 288
生命周期执行的过程如下:1)spring对bean进行实例化,默认bean是单例2)spring对bean进行依赖注入3)如果bean实现了BeanNameAware接口,spring将bean的id传给setBeanName()方法4)如果bean实现了BeanFactoryAware接口,spring将调用setBeanFactory方法,将BeanFactory实例传进来5)如果bean实现...
全注解下的spring IOC之生命周期
一个人的江湖
10-26 818
Bean的生命周期：Bean的定义，Bean的初始化，Bean的生存期，Bean的销毁。 Bean的初始化 SpringBean的生命周期
Spring IOC容器生命周期阶段总结
抱愚守拙，持之以恒；不问结果，相信过程.
01-19 8520
Spring容器的生命周期是面试的高频题目，但是这个生命周期非常复杂，想要完全说清楚几乎不可能。但对全局有个把控，知道每个阶段大概所做的事情是很重要的，尤其在编写框架或者扩展Spring的时候尤其重要。
[Spring]Bean在IOC容器的生命周期
Konaji
10-21 5462
[Spring]Bean在IOC容器的生命周期
Spring 注解开发 1.2 IOC容器（生命周期）
glass__sky的博客
11-14 536
2、生命周期 ​ 通常意义上讲的bean的生命周期，指的是bean从创建到初始化，经过一系列的流程，最终销毁的过程。只不过，在Spring中，bean的生命周期是由Spring容器来管理的。在Spring中，我们可以自己来指定bean的初始化和销毁的方法。我们指定了bean的初始化和销毁方法之后，当容器在bean进行到当前生命周期的阶段时，会自动调用我们自定义的初始化和销毁方法。 ​ 以前在XML文件中我们要定义bean的生命周期方法可以直接在bean标签上加上相应的属性，这样就可以为该bean组件添加
Spring IOC容器中Bean的生命周期
fenqingxingpeiyue的博客
01-23 220
Spring IOC容器中Bean的生命周期 Spring IOC容器可以管理Bean的生命周期，Spring允许在Bean的生命周期的特定点执行定制的任务。 Spring IOC容器对Bean的生命周期进行管理的过程： -通过构造器或工厂方法创建Bean实例。 -为Bean的属性设置值和对其他Bean的引用。 -调用Bean的初始化方法。 -Bean可以使用了。 -当容器关闭时，调
spring Bean生命周期（IOC）
qq_25271459的博客
11-10 259
创建过程 Spring提供了5个接口用来扩展创建Bean的过程，按照执行顺序排序如下 1.BeanNameAware：只有一个抽象方法setBeanName，实现该接口可以重写设置Bean名称 2.BeanClassLoaderAware：只有一个抽象方法setBeanClassLoader 3.BeanFactoryAware：只有一个抽象方法setBeanFactory，实现该接口可以获取BeanFactory（前提是Bean需要有一个BeanFactory类型的属性） 4.Initializing
Spring IOC中bean的生命周期
雪落无痕
03-23 1397
Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务。Spring IOC 容器中 Bean 的生命周期如下： ① 通过构造器或工厂方法创建 Bean 实例 ： 调用构造器 ② 为 Bean 的属性设置值和对其他 Bean 的引用 ： 调用 setter ③ 将 将 Bean 给 实 例
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值