IOC容器初尝试

先来看这样一段代码
详情类依赖动物主类

package com.example.IOC;
public class animalJava {
        private String did;
        private String kind;
        private AnimalDetail animalDetail;
        public Animal(AnimalDetail animalDetail){
            this.animalDetail = animalDetail;
        }
        @Override
        public String toString() {
            return "Animal{" +
                    "did='" + did + '\'' +
                    ", kind='" + kind + '\'' +
                    ", animalDetail=" + animalDetail +
                    '}';
        }
}

详情类

package com.example.IOC;

public class animalDetailJava {
    private Long id;
    private String age;
    private String name;

    @Override
    public String toString() {
        return "AnimalDetail{" +
                "id=" + id +
                ", age='" + age + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

测试类

运行结果

可以看到，我们的动物类animal在定义构造器时，需要传入一个animalDetail类型的对象，这就形成了对象间的依赖关系，在没有引入ioc容器（控制反转）这个概念时，我们只能像在测试类中见到的，手动创建一个animalDetail的对象进去，这样操作不仅需要我们手动的维护对象的声明周期，还加大了代码量

我们新建一个springboot项目工程

1.创建动物类，动物详情类
2.在测试单元编写测试代码

package com.example.IOC;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class IocApplicationTests {
	@Autowired
	private AnimalDetail animalDetail;
	@Autowired
	private Animal animal;
	@Test
	void contextLoads() {
		System.out.println(animal);
	}
}

解释说明

1.和没有使用框架前不同，我们需要在实体类里加入注解@Component来告诉容器这是一个需要被管理的bean
（两个都需要加）

package com.example.IOC;
import org.springframework.stereotype.Component;
@Component
public class Animal {
    private String did;
    private String kind;
    private AnimalDetail animalDetail;
    public Animal(AnimalDetail animalDetail){
        this.animalDetail = animalDetail;
    }
    @Override
    public String toString() {
        return "Animal{" +
                "did='" + did + '\'' +
                ", kind='" + kind + '\'' +
                ", animalDetail=" + animalDetail +
                '}';
    }
}

2.将bean从容器中注入到当前类，这里使用@Autowired注解，这一步操作也就是前文提到的控制反转 - 将对象的创建和生命周期从类本身交给容器管理

这样不仅减少了代码量，而且你在编写其他方法时如果需要该对象也不需要重复创建了，依赖注入的方式有很多种，可以找其他文章看

AOP切面对象实现
package com.example.Aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import java.util.Arrays;
@Component
声明为切面对象,才能与目标方法生成为代理对象
@Aspect
public class LogAspect {
//    JoinPoint 连接点
//    指定目标方法，在我调用指定类名放法之前调用如下方法
//    表达式返回值类型要写对，或者通配符“ * ”表示
    @Before("execution(public Integer com.example.Aop.cal.*(..))")
    public void before(JoinPoint joinPoint){
//        数组转字符串
        System.out.println("s");
        System.out.println(joinPoint.getSignature().toString()+"方法的参数是["+ Arrays.toString(joinPoint.getArgs()));
    }
    @AfterReturning(value = "execution(public Integer com.example.Aop.cal.*(..))",returning = "result")
    public void result(JoinPoint joinPoint, Object result){
//        数组转字符串
        System.out.println(joinPoint.getSignature().toString()+"方法的结果为"+result);
    }

//    表达式返回值类型要写对，或者通配符“ * ”表示

//    @Pointcut(value = "execution(* com.example.Aop.cal.*(..))")
//    public void pointCut(){}

//    @Before(value =  "pointCut()")
//    public void around(JoinPoint joinPoint) {
//        System.out.println("通知老板开始统计了");
//        System.out.println("告诉老板统计结果");
//    }
}

一些时区的拓展

中国采用的北京时间是东八区的标准时间，比世界标准时UTC要快上八个小时