初学者认识和书写Spring IoC 和AOP
一、认识Spring
spring框架Java开发行业的标准
spring全家桶
例如:Web:Spring WebMVC/Spring MVC
持久层:Spring Data/Spring Data JPA、Spring Data Redis 、Spring Data MongoDB
安全校验:Spring Security
构建工程脚手架:Spring Boot
微服务:Spring Cloud
IoC是Spring全家桶各个功能模块基础, 创建对象的容器。
AOP也是以IoC为基础的,AOP是面向切面编程,抽象化的面向对象
用AOP思想做的应用有:(1)打印日志 (2)事务 (3)权限处理等
以打印日志为例:比如有很多的方法,在每个方法的开口会输出日志,在结尾我们也要输出一个日志,如果我们在每个方法上去写的话,我们代码的复用性就会很差,维护性、扩展性就不高,所以我们就会想到将输出日志的操作进行统一处理,也就是对这三个方法的位置进行统一处理(也就是面向切面的形式),就相当于用一把长的刀将三个西瓜横切一刀,这是就会切出一个水平面,然后我们将三个水平面抽象成一个对象,对这个对象进行编程,就相当于对这三个方法同时进行编辑。
二、认识Spring IoC
1.概念:
控制反转,将对象的创建进行反转,常规情况下,对象都是开发者手动创建的,使用IoC开发者不再需要创建对象,而是由IoC容器更具需求自动创建项目所需要的对象。(也就是说我们不用创建对象了,往大的说就是我们在使用框架的时候所有的组件都是自动创建、组装好的,我们直接用就可以了)
不用IoC:所有对象开发者自己创建
使用IoC:对象不用开发者创建,而是交给Spring框架来完成
2.举例说明:
2.1创建工程,在pom.xml中引入依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.6</version>
</dependency>
//作用:在类中加入@Data注解它自动生成类的get/set方法以及toString方法等
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.22</version>
</dependency>
2.2创建一个类DataConfig
package com.gcxy.ioc;
import lombok.Data;
@Data
public class DataConfig {
private String url;
private String driverName;
private String userName;
private String password;
}
使用Spring创建对象有两种方式:基于注解和XML的方式(大部分是注解)
基于XML:
开发者把需要的对象在XML中进行配置,Spring矿界读取这个文件,根据文件的内容来创建对象
(1)在resources包中创建配置文件,命名为spring.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
<bean class="com.gcxy.ioc.DataConfig" id="config">
<property name="driverName" value="Driver"></property>
<property name="url" value="localhost:8888"></property>
<property name="userName" value="root"></property>
<property name="password" value="123456"></property>
</bean>
</beans>
(2)创建一个Test类
package com.gcxy.ioc;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] arg){
//DataConfig dataConfig = new DataConfig();
//dataConfig.setUrl("localhost:3306/dbname");
//dataConfig.setUserName("root");
//dataConfig.setDriverName("druver");
//dataConfig.setPassword("123456");
ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
System.out.println(context.getBean("config"));
}
}
Spring在启动的时候通过xml解析首先把配置文件的数据拿出来(也就是xml中的<bean>中的数据),然后通过反射机制也就是DataConfig创建对象,再通过<property>方式将属性值赋进去(通过set/get方法)
结果如下:
基于注解
(一)配置类:用一个java类来替代xml文件,把在XML配置的内容放到配置类中
(1)创建一个名为BeanConfiguration的类,这个类就相当于xml文件中的配置
package com.gcxy.configuration;
import com.gcxy.ioc.DataConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
@Configuration
public class BeanConfiguration {
@Bean
public DataConfig dataConfig(){
DataConfig dataConfig = new DataConfig();
dataConfig.setUrl("localhost:3306/dbname");
dataConfig.setUserName("root");
dataConfig.setDriverName("druver");
dataConfig.setPassword("123456");
return dataConfig;
}
}
(2)将Test类改为
ApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);
//System.out.println(context.getBean(DataConfig.class));
System.out.println(context.getBean("dataConfig"));
其中BeanConfiguration中的默认值是dataConfig方法名,也可以直接在BeanConfiguration中定义,直接在@Bean后面加一个方法名变为@Bean(value="config")或@Bean(name="config")
然后将Test类改为
ApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);
System.out.println(context.getBean("config"));
当配置类很多时我们就指定包名就可以了
ApplicationContext context = new AnnotationConfigApplicationContext("com.gcxy.configuration");
System.out.println(context.getBean("dataConfig"));
运行后得到的结果与上图一样
(二)扫包+注解:更简单,不再依赖于XML文件或者配置类,而是直接将bean的创建交给目标类,在目标类中添加注解来创建
(1)将DataConfig类改为
package com.gcxy.ioc;
import lombok.Data;
import org.springframework.stereotype.Component;
@Data
@Component
public class DataConfig {
private String url;
private String driverName;
private String userName;
private String password;
}
其中@Component注解的作用就是告诉Spring框架现在这个DataConfig类是需要被注入到IoC的,当Spring读到这个类的时候发现这个注解他就会创建这个类对象,放到IoC里面。
@Component注解就相当于BeanConfiguration类中的代码都有了,它自己创建的。
(2)将Test类改为
ApplicationContext context = new AnnotationConfigApplicationContext("com.gcxy.ioc");
System.out.println(context.getBean(DataConfig.class));
但是这样运行之后没有值
那么我们应该怎样赋值呢,当然也是加注解
(3)在DataConfig类中加入@value("值")
package com.gcxy.ioc;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Data
@Componentpublic class DataConfig {
@Value("localhost:3306/dbname")
private String url;
@Value("driver")
private String driverName;
@Value("root")
private String userName;
@Value("123456")
private String password;
}
赋值后再运行结果就变为
IoC不仅可以自动创建对象,还可以完成依赖注入
(三)IoC的依赖注入:如:A里面有个B的对象,我们创建A和B两个对象,然后自动的将B装入A里面
(1)创建一个GlobalConfig类
package com.gcxy.ioc;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
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
private DataConfig dataConfig;
}
其中@Autowired自动装载,自动从IoC中去找DataConfig的bean,如果能找到就会将值赋给dataConfig
(2)再改变Test
ApplicationContext context = new AnnotationConfigApplicationContext("com.gcxy.ioc");
System.out.println(context.getBean(GlobalConfig.class));
这时候运行就能够将dataConfig类的值赋到GlobalConfig中
@Autowired通过类型进行注入,如果需要通过名称取值,则需要加入另外的注解@Qualifier("名称")以及在DataConfig类中@Component后进行命名,通过@Qualifier注解来完成名称的映射
(3)将GlobalConfig类改为
package com.gcxy.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 dataConfig;
}
三、认识Spring AOP
1.概念:
面向切面编程,是一种抽象化的面向对象编程,对面向对象编程的一种补充,底层使用动态代理
AOP的思想是把很多类对象中的横切问题点从业务逻辑中分离出来,从而达到解耦的目的,增强代码的重用性、提高代码的开发效率。
AOP最早由AOP组织联盟提出
2.AOP
2.1AOP的产生
很多类对象和Logger仍然存在依赖关系,甚至每个类的所有方法都需要调用Logger,如果修改了方法,需要修改N遍,不能一次性修改完成改变,为了解决这一问题,所以才有了AOP的产生
2.2AOP的应用场景
日志记录、异常处理、权限验证、缓存处理、事务处理、数据持久化、效率检查、内容分发
2.3AOP中术语主要的概念和理解
●aspect: 切面,切面有切点和通知组成,即包括横切逻辑的定义 也包括连接点的定义pointcut:切点,每个类都拥有多个连接点,可以理解是连接点的集合
●joinpoint: 连接点,程序执行的某个特定位置,如某个方法调用前后等
●weaving:织入,将增强添加到目标类的具体连接点的过程
●advice: 通知,是织入到目标类连接点上的一段代码,就是增强到什么地方?增强什么内容?target:目标对象,通知织入的目标类
●aop Proxy:代理对象,即增强后产生的对象
Spring AOP底层实现,是通过JDK动态代理或CGLib代理在运行时期在对象初始化阶段织入代码的。 JDK动态代理:基于接口
CGLib代理:基于类的继承
2.4通知
Before advice
前置通知:在目标方法调用前执行,注意:无论方法是否遇到异常都执行
After returning advice
后置通知:在目标方法调用后执行,前提是目标方法没有遇到异常,否则不执行
After throwing advice
异常通知,在目标方法抛出异常时执行,可以获取异常信息
After finally advice
最终通知,在目标方法执行后执行,无论是否异常都执行
Around advice
环绕通知,最强大的通知类型,可以控制目标方法执行(通过调用ProceedingJoinPoint.proceed()),可在目标执行全过程中执行。
3.举例说明:
例如打印日志
业务代码和打印日志耦合起来
计算机方法中,日志和业务混合在一起,AOP要做的就是将日志代码全部抽象出去统一进行处理,计算机方法中只保留核心的业务代码,做到核心业务和非核心业务代码的解耦合
从此图中可以看出一个计算器(目标类)与一个切面对象组成一个代理对象,我们可以直接在这个代理对象中进行编码,得到想要的结果
未解耦合时,日志和业务是合在一起的
package com.gcxy.aop;
public class CalImp implements Cal{
@Override
public int add(int num1, int num2) {
System.out.println("add方法的参数是["+num1 + "," +num2 +"]");
int reult = num1 + num2;
System.out.println("add方法的结果是" +reult);
return reult;
}
@Override
public int sub(int num1, int num2) {
System.out.println("sub方法的参数是["+num1 + "," +num2 +"]");
int reult = num1 - num2;
System.out.println("sub方法的结果是" +reult);
return reult;
}
@Override
public int mul(int num1, int num2) {
System.out.println("mul方法的参数是["+num1 + "," +num2 +"]");
int reult = num1 * num2;
System.out.println("mul方法的结果是" +reult);
return reult;
}
@Override
public int div(int num1, int num2) {
System.out.println("div方法的参数是["+num1 + "," +num2 +"]");
int reult = num1 / num2;
System.out.println("div方法的结果是" +reult);
return reult;
}
}
下面我们来创建解耦后的代码
(1)在pom.xml中加入切面依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.3.6</version>
</dependency>
(2)创建切面类LoggerAspect
package com.gcxy.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.gcxy.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.gcxy.aop.CalImpl.*(..))",returning = "result")
public void afterReturn(JoinPoint joinPoint,Object result){
String name = joinPoint.getSignature().getName();
System.out.println(name+"方法的结果是"+result);
}
}
(3)实现类添加@Component注解
package com.gcxy.aop;
import org.springframework.stereotype.Component;
@Component
public class CalImpl implements Cal{
@Override
public int add(int num1, int num2) {
int reult = num1 + num2;
return reult;
}
@Override
public int sub(int num1, int num2) {
int reult = num1 - num2;
return reult;
}
@Override
public int mul(int num1, int num2) {
int reult = num1 * num2;
return reult;
}
@Override
public int div(int num1, int num2) {
int reult = num1 / num2;
return reult;
}
}
(4)配置自动扫包,开启自动生成代理对象
在pom.xml中添加
<!-- 自动扫包 -->
<context:component-scan base-package="com.gcxy.aop"></context:component-scan>
<!-- 开启自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
(5)使用:创建测试类Test
package com.gcxy.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));
}
}
(6)运行结果:
因为一个目标对象对应一个切面类,当有多个目标对象时想要输出结果则需要只保留一个目标对象,可以将其余目标对象的@Component注解注释掉就可以正常运行得到你想要的结果