Spring IoC 和AOP
具体代码详情
http://F:\WorkSpace\springIoc
Bean是一个注解pojo指对象 是一个概念性的东西，他俩其实都是描述对象的
把不影响业务的非业务代码抽离出来：AOP
如果是函数，需要在业务代码中调用。AOP不需要在业务代码中调用，直接在切面类中配置就可以
代码的扩展性和维护下提高
切面类只能和一个实现类生成代理，不能同时对两个实现类生成代理
Spring 框架 Java 开发的行业标准
Spring 全家桶
Web：Spring Web MVC/Spring MVC、Spring Web Flux
持久层：Spring Data/ Spring Data JPA、Spring Data
Redis、Spring Data MongoDB
安全校验：Spring Security
构建工程脚手架：Spring Boot
微服务：Spring Cloud
IoC 是 Spring 全家桶各个功能模块的基础，创建对象的容器。
AOP 也是以 IoC 为基础，AOP 是面向切面编程，抽象化的面向对象
1、打印日志
2、事务
3、权限处理
1.1 IoC
控制反转，将对象的创建进行反转，常规情况下，对象都是开发者手动创建的，使用 IoC 开发者不再需要创建对象，而是由 IoC 容器根据需求自动创建项目所需要的对象。
不用 IoC：所有对象开发者自己创建
使用 IoC：对象不用开发者创建，而是交给 Spring 框架来完成
1、pom.xml
org.springframework
spring-context
5.3.15
基于 XML 和基于注解
基于 XML：开发者把需要的对象在 XML 中进行配置，Spring 框架读取这个配置文件，根据配置文件的内容来创建对象
package com.southwind.ioc;
import
org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXm
lApplicationContext;
public class Test {
public static void main(String[] args) {
// DataConfig dataConfig = new
DataConfig();
// dataConfig.setDriverName("Driver");
//
dataConfig.setUrl("localhost:3306/dbname");
// dataConfig.setUsername("root");
// dataConfig.setPassword("root");
ApplicationContext context = new
ClassPathXmlApplicationContext("spring.xml");
System.out.println(context.getBean("config"));
}
}基于注解
1、配置类
用一个 Java 类来替代 XML 文件，把在 XML 中配置的内容放到配置类中。
package com.southwind.configuration;
import com.southwind.ioc.DataConfig;
import
org.springframework.context.annotation.Bean;
import
org.springframework.context.annotation.Configur
ation;
@Configuration
public class BeanConfiguration {
@Bean(value = "config")
public DataConfig dataConfig(){
DataConfig dataConfig = new
DataConfig();
dataConfig.setDriverName("Driver");
dataConfig.setUrl("localhost:3306/dbname");
dataConfig.setUsername("root");
dataConfig.setPassword("root");
return dataConfig;
}
}ApplicationContext context = new
AnnotationConfigApplicationContext(BeanConfigur
ation.class);
System.out.println(context.getBean("config"));2、扫包+注解
更简单的方式，不再需要依赖于 XML 或者配置类，而是直接将 bean 的创建交给目标类，在目标类添加注解来创建
package com.southwind.ioc;
import lombok.Data;
import
org.springframework.beans.factory.annotation.Va
lue;
import
org.springframework.stereotype.Component;
@Data
@Component
public class DataConfig {
@Value("localhost:3306")
private String url;
@Value("Driver")
private String driverName;
@Value("root")
private String username;
@Value("root")
private String password;
}ApplicationContext context = new
AnnotationConfigApplicationContext("com.southwi
nd.ioc");
System.out.println(context.getBean(DataConfig.c
lass));自动创建对象，完成依赖注入
package com.southwind.ioc;
import lombok.Data;
import
org.springframework.beans.factory.annotation.Au
towired;
import
org.springframework.beans.factory.annotation.Va
lue;
import
org.springframework.stereotype.Component;
@Data
@Component
public class GlobalConfig {
@Value("8080")
private String port;
@Value("/")
private String path;
@Autowired
private DataConfig dataConfig;
}@Autowired 通过类型进行注入，如果需要通过名称取值，
通过 @Qualifier 注解完成名称的映射
package com.southwind.ioc;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Data
@Component
public class GlobalConfig {
@Value("8080")
private String port;
@Value("/")
private String path;
@Autowired
@Qualifier("config")
private DataConfig config;
}package com.southwind.ioc;
import lombok.Data;
import
org.springframework.beans.factory.annotation.Va
lue;
import
org.springframework.stereotype.Component;
@Data
@Component("config")
public class DataConfig {
@Value("localhost:3306")
private String url;
@Value("Driver")
private String driverName;
@Value("root")
private String username;
@Value("root")
private String password;
}1.2 AOP
面向切面编程，是一种抽象化的面向对象编程，对面向对象
编程的一种补充，底层使用动态代理机制来实现
1、打印日志
2、事务
3、权限处理
打印日志
业务代码和打印日志耦合起来
计算器方法中，日志和业务混合在一起，AOP 要做的就是将日志代码全部抽象出去统一进行处理，计算器方法中只保留核心的业务代码。
做到核心业务和非业务代码的解耦合
1、创建切面类
package com.southwind.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.springframework.stereotype.Component;
import java.util.Arrays;
@Component
@Aspect
public class LoggerAspect {
@Before("execution(public int com.southwind.aop.CalImpl.*(..))")
public void before(JoinPoint joinPoint){
String name = joinPoint.getSignature().getName();
System.out.println(name+"方法的参数是"+ Arrays.toString(joinPoint.getArgs()));
}
@AfterReturning(value = "execution(public int com.southwind.aop.CalImpl(..))",returning
= "result")
public void afterReturning(JoinPoint joinPoint,Object result){
String name = joinPoint.getSignature().getName();
System.out.println(name+"方法的结果是"+result);
}
}2、实现类添加 @Component 注解
package com.southwind.aop;
import
org.springframework.stereotype.Component;
@Component
public class CalImpl implements Cal {
@Override
public int add(int num1, int num2) {
int result = num1 + num2;
return result;
}
@Override
public int sub(int num1, int num2) {
int result = num1 - num2;
return result;
}
@Override
public int mul(int num1, int num2) {
int result = num1 * num2;
return result;
}
@Override
public int div(int num1, int num2) {
int result = num1 / num2;
return result;
}
}3、配置自动扫包，开启自动生成代理对象
4、使用
package com.southwind.aop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
ApplicationContext context = new
ClassPathXmlApplicationContext("spring.xml");
Cal bean = context.getBean(Cal.class);
System.out.println(bean.add(9, 8));
System.out.println(bean.sub(9, 8));
System.out.println(bean.mul(9, 8));
System.out.println(bean.div(9, 8));
}
}Spring 官方文档对 bean 的解释是：
In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container.
翻译过来就是：
在 Spring 中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。bean是一个由Spring IoC容器实例化、组装和管理的对象。
我们总结如下：
1.bean是对象，一个或者多个不限定
2.bean由Spring中一个叫IoC的东西管理
3.我们的应用程序由一个个bean构成
2 控制反转（IoC）
控制反转英文全称：Inversion of Control，简称就是IoC。
控制反转通过依赖注入（DI）方式实现对象之间的松耦合关系。
程序运行时，依赖对象由【辅助程序】动态生成并注入到被依赖对象中，动态绑定两者的使用关系。
Spring IoC容器就是这样的辅助程序，它负责对象的生成和依赖的注入，让后在交由我们使用。
简而言之，就是：IoC就是一个对象定义其依赖关系而不创建它们的过程。
这里我们可以细分为两个点。
2.1 私有属性保存依赖
第1点：使用私有属性保存依赖对象，并且只能通过构造函数参数传入，
构造函数的参数可以是工厂方法、保存类对象的属性、或者是工厂方法返回值。
假设我们有一个Computer类：
我们有另一个Person类依赖于Computer类，符合IoC的做法是这样：
不符合IoC的做法如下：
2.2 让Spring控制类构建过程
第2点：不用new，让Spring控制new过程。
在Spring中，我们基本不需要 new 一个类，这些都是让 Spring 去做的。
Spring 启动时会把所需的类实例化成对象，如果需要依赖，则先实例化依赖，然后实例化当前类。
因为依赖必须通过构建函数传入，所以实例化时，当前类就会接收并保存所有依赖的对象。
这一步也就是所谓的依赖注入。
2.3 这就是IoC
在 Spring 中，类的实例化、依赖的实例化、依赖的传入都交由 Spring Bean 容器控制，
而不是用new方式实例化对象、通过非构造函数方法传入依赖等常规方式。
实质的控制权已经交由程序管理，而不是程序员管理，所以叫做控制反转。
3 Bean？
至于bean，则是几个概念。
概念1：Bean容器，或称spring ioc容器，主要用来管理对象和依赖，以及依赖的注入。
概念2：bean是一个Java对象，根据bean规范编写出来的类，并由bean容器生成的对象就是一个bean。
bean规范如下：
1.所有属性为private
2.提供默认构造方法
3.提供getter和setter
4.实现serializable接口
1.什么是AOP
AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。
在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录），同样的代码仍然会分散到各个方法中。这样，如果想要关闭某个功能，或者对其进行修改，就必须要修改所有的相关方法。这不但增加了开发人员的工作量，而且提高了代码的出错率。
为了解决这一问题，AOP思想随之产生。AOP采取横向抽取机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方。这种采用横向抽取机制的方式，采用传统的OOP思想显然是无法办到的，因为OOP只能实现父子关系的纵向的重用。虽然AOP是一种新的编程思想，但却不是OOP的替代品，它只是OOP的延伸和补充。
AOP的使用，使开发人员在编写业务逻辑时可以专心于核心业务，而不用过多的关注于其他业务逻辑的实现，这不但提高了开发效率，而且增强了代码的可维护性。
1、Advice（通知/增强处理）：AOP框架在特定的切入点执行的增强处理，即在定义好的切入点处所要执行的程序代码。可以将其理解为切面类中的方法。
2、Target Object（目标对象）：指所有被通知的对象，也被称为被增强对象。如果AOP框架采用的是动态的AOP实现，那么该对象就是一个被代理对象。
3、Proxy（代理）：将通知应用到目标对象之后，被动态创建的对象。
4、Weaving（织入）：将切面代码插入到目标对象上，从而生成代理对象的过程。
JDK动态代理是通过java.lang.reflect.Proxy 类来实现的，我们可以调用Proxy类的newProxyInstance()方法来创建代理对象。对于使用业务接口的类，Spring默认会使用JDK动态代理来实现AOP。