一次讲清Spring

问：Java中最重要的框架是哪个？
Spring是Java领域的第一框架！
SpringFremawork并不是完成某个具体方向业务的，他的功能是利用IoC容器，将其他框架进行整合，从而非常方便的集成到我们的项目中。

1.1 两大机制之 IoC
Spring 框架的两大核心机制 IoC 和 AOP。
IoC：控制反转，Inverse of Controll
1.2 是什么IoC？
控制反转指的是对象的创建方式进行了反转，传统的开发方式是程序员自己 new 对象，IoC 就是将这一过程进行了反转，程序员不需要自己 new 对象，而是交给 IoC 容器来创建对象，程序员只需要使用这些对象即可。
1.3控制反转的好处
解耦合
因为项目设计时候是采用MVC设计模式，如果我们的需求发生变动，更改了数据库，则需要修改数据库 repository 代码，java代码进行了修改，类需要重新编译，效率很低，所以提出了一种新思路，不修改java代码。
思路：
借助于配置文件+反射的机制，将需求对应的 bean 写到配置文件中，Java 代码只需要写通过反射机制读取配置文件，创建对应的 bean 即可。Java 代码是不需要修改的，修改配置文件之后，配置文件是不用重新编译的，达到了目的。
做到了解耦合，将 Repository 从 Service 中进行了解耦合。这就是 IoC 的思想，控制反转，将创建对象的控制权进行了反转，之前是直接 new 的，现在是接收工厂方法返回的对象，无法控制对象的创建，将对象创建的权力进行了反转，所以叫控制反转。
1.4 IoC 创建对象有两种方式
1)基于XML
a 、创建一个 XML 文件，在文件中将程序中需要用的对象进行配置。
b、加载 IoC 容器，Spring 框架会自动读取 XML 文件，根据 XML 的配置，自动创建各种对象，放入到缓冲池中。
c、开发者只需要根据需求从缓冲池中取出相应对象使用即可。
spring.xml

@Data
public class Student {
    public Integer id;
    public String name;
    public Integer age;
}

public class Test {
    public static void main(String[] args) {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("spring.xml");
        Student student = (Student) ioc.getBean("student");
        Student bean = ioc.getBean(Student.class);
        System.out.println(bean);
    }
}

2）基于注解
a、在需要注入的 IoC 的类处添加注解，标注一下，告诉 Spring 框架，这个类是需要注入的 bean。
b、加载 IoC 容器，Spring 框架会自动读取到所有添加了注解的类，通过反射机制创建 bean，注入到 IoC 容器中，指定要扫描的包。
c、开发者从 IoC 容器中取出需要的 bean。

@Data
@Component
public class Account {
    @Value("1")
    private Integer id;
    @Value("张三")
    private String name;
    @Value("22")
    private Integer age;
}

public class Test2 {
    public static void main(String[] args) {
        ApplicationContext ioc = new AnnotationConfigApplicationContext("com.entity");
        Account bean = ioc.getBean(Account.class);
        System.out.println(bean);
    }
}

2.两大机制之AOP
AOP：Aspect Oriented Programming 面向切面编程
程序运行时动态地将非业务代码切入到业务代码中，从而实现代码的解耦合。
举个栗子：

public class CalImpl implements Cal {
    @Override
    public int add(int num1, int num2) {
        System.out.println("add方法的参数是[" + num1 + "," + num2 + "]");
        int result = num1+num2;
        System.out.println("add方法的结果是" + result);
        return result;
    }

    @Override
    public int sub(int num1, int num2) {
        System.out.println("sub方法的参数是[" + num1 + "," + num2 + "]");
        int result = num1-num2;
        System.out.println("sub方法的结果是" + result);
        return result;
    }
 }

缺点：
a、代码复用性很差。
b、非业务代码（日志）和业务代码（计算）耦合度太高。
使用 Spring 的 AOP 可以完美解决上面的两个问题。AOP 是基于 IoC，AOP 需要用到的对象（切面对象）是通过 IoC 来生成的。抽象出来一个切面，封装成对象，对该对象进行编程（打印日志），让该切面对象作用于目标方法。
步骤：
1）创建切面类

@Component
@Aspect
public class LoggerAspect {

    @Before("execution(public int com.aop.CalImpl.add(..))")
    public void before(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        System.out.println(name + "方法的参数是" + Arrays.toString(joinPoint.getArgs()));
    }
}

2）创建 spring.xml

3）测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Cal calImpl = (Cal) applicationContext.getBean("calImpl");
        System.out.println(calImpl.add(10, 3));
    }
}