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

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

• @PostConstruct 用于修饰初始化方法。
• @PreDestroy 用于修饰销毁方法。

package com.czxy.demo13_lifecycle.domain;

import org.springframework.stereotype.Component;

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


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


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


@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo13Configuration.class)
public class TestDemo13 {
    @Resource
    private Dog dog;

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

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

package com.czxy.demo14_lifecycle_bean.domain;

import org.springframework.stereotype.Component;

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


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;


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


@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo14Configuration.class)
public class TestDemo14 {
    @Resource
    private Dog dog;

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

释放资源：

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

目标类：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;


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


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


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


@Component	//将当前类，添加到spring容器中
@Aspect     //切面编程注解
public class MyAspect {

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

目标类：

package com.czxy.demo16_aop.dao;

import org.springframework.stereotype.Repository;


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


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


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


@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 可以在不修改原来代码的基础上，对已有方法进行增强。
不错，离工作又进了一天!!!