1、Aware和InitializingBean
Aware和InitializingBean都与Bean的生命周期管理相关。
Aware接口:
- 概念: Aware接口是Spring框架中的一个标记接口,它表示一个类能够感知到(aware of)Spring容器的存在及其特定的环境。Spring框架提供了多个Aware接口,如ApplicationContextAware、BeanFactoryAware、BeanNameAware等。
- 区别:Aware接口通过回调方法的方式,让实现了该接口的类能够获取到Spring容器的一些资源或信息,比如ApplicationContextAware可以获取到Spring应用上下文,BeanFactoryAware可以获取到Bean工厂,BeanNameAware可以获取到Bean的名称等。
- 联系:Aware接口可以与InitializingBean接口一起使用,通过Aware接口获取到Spring容器的资源后,可以在初始化Bean时使用这些资源。
InitializingBean接口:
- 概念: InitializingBean接口是Spring框架中的一个接口,实现该接口的类可以在Bean初始化完成后执行特定的逻辑。
- 区别:InitializingBean接口中定义了一个初始化方法afterPropertiesSet(),当Bean的所有属性被设置后,Spring容器会调用该方法。在这个方法中,可以执行一些初始化操作,比如数据加载、资源初始化等。
- 联系:InitializingBean接口可以与Aware接口一起使用,通过Aware接口获取到Spring容器的资源后,在InitializingBean的afterPropertiesSet()方法中进行必要的初始化操作。
1.1、案例一
下面的MyBean类分别实现了BeanNameAware, ApplicationContextAware,InitializingBean三个接口:
public class MyBean implements BeanNameAware, ApplicationContextAware,InitializingBean {private static final Logger log = LoggerFactory.getLogger(MyBean.class);/*** 重写BeanNameAware的方法,可以获取当前bean的名称*/@Overridepublic void setBeanName(String name) {log.info("bean is {},bean name is:{}", this,name);}/*** 重写ApplicationContext的方法,允许Bean实现类获取对Spring应用上下文(ApplicationContext)的引用。*/@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {log.info("bean is {},bean applicationContext is:{}", this,applicationContext);}/*** 重写InitializingBean的方法用于在Bean初始化完成后执行特定的逻辑。*/@Overridepublic void afterPropertiesSet() throws Exception {log.info("bean is {},init", this);}
}
public class A05 {public static void main(String[] args) {GenericApplicationContext context = new GenericApplicationContext();context.registerBean("mybean", MyBean.class);context.refresh();context.close();}
}
上面的功能,通过@Autowired @PostConstruct 等注解也可以实现,为什么还要实现接口?原因是因为,解析@Autowired @PostConstruct 等注解需要通过后处理器,而Aware等接口属于Spring的内置功能,不需要任何扩展(在上述案例的主类中,使用的是GenericApplicationContext,不会加任何后处理器)。扩展在某些时候可能会失效,而内置功能不会失效。
演示使用@Autowired @PostConstruct 等注解实现同等功能:
public class MyBean2 {private static final Logger log = LoggerFactory.getLogger(MyBean2.class);@Autowiredpublic void getApplicationContext(ApplicationContext applicationContext) {log.info("bean is {},bean applicationContext is:{}", this,applicationContext);}@PostConstructpublic void init(){log.info("init bean");}
}
在主类中需要加入后处理器:
public class A05 {public static void main(String[] args) {GenericApplicationContext context = new GenericApplicationContext();context.registerBean("mybean2", MyBean2.class);context.registerBean(AutowiredAnnotationBeanPostProcessor.class);context.registerBean(CommonAnnotationBeanPostProcessor.class);context.refresh();context.close();}
}
运行结果与实现ApplicationContextAware,InitializingBean相同。
1.2、注解失效分析
演示一种注解失效的情况:
/*** 演示后处理器扩展失效的情况*/
@Configuration
public class MyConfig1 {private static final Logger log = LoggerFactory.getLogger(MyConfig1.class);@Autowiredpublic void setApplicationContext(ApplicationContext applicationContext){log.info("注入 Application Context");}@PostConstructpublic void init(){log.info("init");}/*** 想要获取MyConfig1中的BeanFactoryPostProcessor,就先要把MyConfig1类先创建好* 提前创建导致扩展功能失效 因为1、beanFactory后处理器 2、bean后处理器 这样的顺序* @return*/@Beanpublic BeanFactoryPostProcessor beanPostProcessor(){return beanFactory -> {log.info("beanPostProcessor");};}
}
public class A05Application {public static void main(String[] args) {/*@AutoWired等注解是spring的扩展功能,需要通过后处理器实现而实现BeanNameAware, ApplicationContextAware,InitializingBean 等接口是spring的内置功能为了防止扩展功能失效*/GenericApplicationContext context = new GenericApplicationContext();context.registerBean("myConfig", MyConfig1.class);context.registerBean(AutowiredAnnotationBeanPostProcessor.class);context.registerBean(CommonAnnotationBeanPostProcessor.class);context.registerBean(ConfigurationClassPostProcessor.class);//执行顺序:1、beanFactory后处理器 2、bean后处理器 3、初始化所有单例context.refresh();context.close();}
}
此时发现,只有beanPostProcessor()成功执行
原因在于,调用GenericApplicationContext的.refresh(); 方法初始化时,其执行顺序是:
1、beanFactory后处理器
2、bean后处理器
3、初始化所有单例
如下图所示:
如果要初始化BeanFactoryPostProcessor,首先要把 MyConfig1类创建完成。相当于下图的顺序:
很明显此时是先执行了类的初始化,最后再注册后处理器。这样就导致了无法解析@Autowired @PostConstruct 等注解。但是在创建类及初始化时,会执行Aware和InitializingBean相关接口:
/*** 演示后处理器扩展失效的情况解决方案* 使用实现接口的方式*/
@Configuration
public class MyConfig2 implements ApplicationContextAware, InitializingBean {private static final Logger log = LoggerFactory.getLogger(MyConfig2.class);/*** 想要获取MyConfig1中的BeanFactoryPostProcessor,就先要把MyConfig1类先创建好* 提前创建导致扩展功能失效 因为1、beanFactory后处理器 2、bean后处理器 这样的顺序* @return*/@Beanpublic BeanFactoryPostProcessor beanPostProcessor(){return beanFactory -> {log.info("beanPostProcessor");};}@Overridepublic void afterPropertiesSet() throws Exception {log.info("init");}@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {log.info("注入 Application Context");}
}
此时可以观察到,初始化和注入Application Context的操作都成功执行。
2、初始化和销毁
2.1、初始化和销毁的方式
Bean初始化和销毁通常有三种方式:
- 通过特定的生命周期回调方法来实现。主要涉及到以下两个接口:InitializingBean: 这是 Spring 框架提供的一个接口,其中定义了afterPropertiesSet()方法,该方法会在 Bean 的所有属性都被设置之后进行回调,用于执行自定义的初始化逻辑。DisposableBean: 这也是 Spring 框架提供的接口,其中定义了一个destroy()方法,该方法会在 Spring 容器销毁该 Bean 之前进行回调,用于执行自定义的销毁逻辑。
- 使用 @PostConstruct 和 @PreDestroy 注解
- 通过设置@Bean注解的initMethod和destroyMethod
初始化的三种方式:
/*** 演示三种初始化的执行顺序*/
public class Bean1 implements InitializingBean {private static final Logger log = LoggerFactory.getLogger(Bean1.class);@PostConstructpublic void init1(){log.info(" @PostConstruct方式");}/*** Invoked by the containing {@code BeanFactory} after it has set all bean properties* and satisfied {@link BeanFactoryAware}, {@code ApplicationContextAware} etc.* <p>This method allows the bean instance to perform validation of its overall* configuration and final initialization when all bean properties have been set.** @throws Exception in the event of misconfiguration (such as failure to set an* essential property) or if initialization fails for any other reason*/@Overridepublic void afterPropertiesSet() throws Exception {log.info("实现InitializingBean接口方式");}public void init3(){log.info("@Bean设置initMethod方式");}
}
销毁的三种方式:
/*** 演示三种销毁方法的执行顺序*/
public class Bean2 implements DisposableBean {private static final Logger log = LoggerFactory.getLogger(Bean2.class);@PreDestroypublic void destory1(){log.info("@PreDestroy方式");}/*** Invoked by the containing {@code BeanFactory} on destruction of a bean.** @throws Exception in case of shutdown errors. Exceptions will get logged* but not rethrown to allow other beans to release their resources as well.*/@Overridepublic void destroy() throws Exception {log.info("实现DisposableBean接口方式");}public void destory3(){log.info("@Bean设置destroyMethod方式");}
}
2.2、初始化和销毁的顺序
@SpringBootApplication
public class A06Application {public static void main(String[] args) {ConfigurableApplicationContext context = SpringApplication.run(A06Application.class, args);context.close();}@Bean(initMethod = "init3")public Bean1 bean1(){return new Bean1();}@Bean(destroyMethod = "destory3")public Bean2 bean2(){return new Bean2();}
}
三种方式的先后顺序:
3、Bean的Scope
在 Spring 中,Scope(作用域)是指 Bean 的生命周期范围,即在应用程序中创建的 Bean 对象在何时被创建、存在多久以及何时被销毁。Spring 框架提供了多种作用域,每种作用域都决定了 Bean 实例的生命周期和可见性。
列举一下常见的作用域:
- Singleton(单例):在 Singleton 作用域下,Spring 容器中的每个 Bean 都只有一个实例,这个实例在整个应用程序的生命周期中都是共享的。默认情况下,所有在 Spring 容器中声明的 Bean 都是 Singleton 作用域,Spring的Bean默认是单例的。
- Prototype(多例):在 Prototype 作用域下,每次向 Spring 容器请求该 Bean 时,都会创建一个新的实例。每次请求都会返回一个新的 Bean 实例,这些实例彼此之间互不影响。
- Request(请求):在 Web 应用程序中,每个 HTTP 请求都会创建一个新的 Bean 实例,该实例仅在当前 HTTP 请求内有效。这意味着每个请求都会拥有一个独立的 Bean 实例,适用于 Web 应用程序中需要与请求相关联的 Bean。
- Session(会话):在 Web 应用程序中,每个 HTTP 会话(Session)都会创建一个新的 Bean 实例,该实例在整个会话期间都是有效的。这意味着在同一个会话中,多个请求共享相同的 Bean 实例。此外还有一个全局会话,但仅在使用基于portlet的Web环境时才有意义。
- Application(应用):该作用域是在一个 ServletContext 范围内有效,它将 Spring Bean 的生命周期绑定到 ServletContext 的生命周期,一个应用中的所有请求都共享同一个 Bean 实例。
下面通过案例演示Application、Request、Session三种作用域:
@Scope("application")
@Component
public class BeanForApplication {private static final Logger log = LoggerFactory.getLogger(BeanForApplication.class);@PreDestroypublic void destory(){log.info("destory");}
}
@Scope("request")
@Component
public class BeanForRequest {private static final Logger log = LoggerFactory.getLogger(BeanForRequest.class);@PreDestroypublic void destory(){log.info("Destory");}
}
@Component
@Scope("session")
public class BeanForSession {private static final Logger log = LoggerFactory.getLogger(BeanForSession.class);@PreDestroypublic void destroy() {log.info("destory");}
}
@Controller
public class TestController {@Autowired@Lazyprivate BeanForApplication beanForApplication;@Autowired@Lazyprivate BeanForRequest beanForRequest;@Autowired@Lazyprivate BeanForSession beanForSession;/*** 在同一个浏览器内,每次请求beanForRequest都会不一样* 在不同的浏览器中,每次请求beanForRequest都不一样,第一次请求时beanForSession不一样* 同一个程序下,beanForApplication都是一样的** 每次请求beanForRequest创建 销毁* beanForSession 到期时销毁* @param req* @param httpSession*/@GetMapping("/test")public void test(HttpServletRequest req, HttpSession httpSession) {System.out.println("BeanForApplication:"+beanForApplication);System.out.println("BeanForRequest:"+beanForRequest);System.out.println("BeanForSession:"+beanForSession);}
}
主启动类:
@SpringBootApplication
public class A07Application {public static void main(String[] args) {ConfigurableApplicationContext context = SpringApplication.run(A07Application.class, args);}
}
使用同一浏览器,第一次执行:
第二次执行:
可以得出结论:同一浏览器(http会话)中,每次请求都会创建一个新的 Bean 实例,该实例仅在当前 HTTP 请求内有效。
使用不同浏览器,浏览器一:
浏览器二:
可以得出结论:不同浏览器(http会话)都会产生一个新的实例,并且在每个会话中,每次请求都会创建一个新的 Bean 实例,该实例仅在当前 HTTP 请求内有效。
3.1、Scope失效现象
定义两个多例Bean:
@Component
@Scope("prototype")
public class F1 {
}
@Component
@Scope("prototype")
public class F2 {
}
在配置类中通过@Autowired注入F1和F2
@Component
public class E {@Autowiredprivate F1 f1;@Autowiredprivate F2 f2;public F1 getF1() {return f1;}public F2 getF2() {return f2;}
}
在主类中获取三次F1和F2
@ComponentScan("com.itbaima.a08_1")
public class A08Test {private static final Logger log = LoggerFactory.getLogger(A08Test.class);public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(A08Application.class);E e = context.getBean(E.class);log.info("{}",e.getF1());log.info("{}",e.getF1());log.info("{}",e.getF1());System.out.println("<<<<<<<<<<<<<<<<<<<<<");log.info("{}",e.getF2());log.info("{}",e.getF2());log.info("{}",e.getF2());}
}
期望的结果是每次获取到的F1和F2都是不同的实例:
与预期结果不符。为什么定义的Bean是多例,每次却获取到了同一个实例?
当我们将一个 Prototype Bean 注入到一个 Singleton Bean 中时, Prototype Bean 注入的是该 Prototype Bean 的实例,而不是一个代理对象。这意味着,虽然 Prototype Bean 是多例的,但在 Singleton Bean 中的引用始终是同一个实例,导致 Prototype Bean 的多例特性失效。
@Autowiredprivate F1 f1;@Autowiredprivate F2 f2;
这就是单例注入多例Bean失效问题
3.1.1、解决方法一
使用@Lazy 注解。 @Lazy 注解可以延迟 Bean 的初始化,即在第一次被请求时才进行初始化,而不是在容器启动时就创建。
Spring 容器在初始化 Singleton Bean 时不会立即初始化注入的 Prototype Bean,而是在首次使用 Prototype Bean 时才进行初始化,从而保证每次获取的都是新的实例。
@Autowired@Lazyprivate F1 f1;
F1每次都是不同的实例:
3.1.2、解决方法二
在声明多例时:
@Scope(value = "prototype",proxyMode = ScopedProxyMode.TARGET_CLASS)
告诉 Spring 在注入 Prototype Bean 时使用代理对象,而不是直接注入 Prototype Bean 的实例。这样,每次从 Singleton Bean 中获取 Prototype Bean 时,实际上会通过代理对象获取一个新的 Prototype Bean 实例,从而保证了 Prototype Bean 的多例特性。
3.1.3、解决方法三
在 Singleton Bean 中通过 ApplicationContext 手动获取 Prototype Bean。每次需要使用 Prototype Bean 时,都通过 ApplicationContext 获取新的实例。
//通过applicationContext 的 getBean@Autowiredprivate ApplicationContext applicationContext;public F4 getF4(){return applicationContext.getBean(F4.class);}
3.1.4、解决方法四
使用ObjectFactory。ObjectFactory是 Spring 提供的一种工厂模式,它的实现是延迟加载的,所以每次调用 getObject()方法都会返回一个新的 Prototype Bean 实例,其原理与@Lazy类似,都是实现延迟加载。
//通过对象工厂的方式
@Autowired
private ObjectFactory<F3> f3;public F3 getF3(){return f3.getObject();
}
4、动态代理
Spring 中的动态代理是指在运行时生成代理对象,而不是在编译时就确定代理对象的类型。Spring 中常用的动态代理有两种方式:基于 JDK 的动态代理和基于 CGLIB 的动态代理。
- 基于 JDK 的动态代理:JDK 动态代理是通过 Java 的反射机制来实现的。当目标类实现了接口时,Spring 就会使用 JDK 动态代理来创建代理对象。在运行时,Spring 创建一个实现了目标接口的代理类,并且这个代理类会持有一个InvacationHandler对象,通过 InvacationHandler 的invoke()方法来实现对目标方法的增强。在invoke()方法中,可以在目标方法执行前后插入额外的逻辑,实现 AOP 的功能。(AOP是基于动态代理的)
- 基于 CGLIB 的动态代理:当目标类没有实现接口时,Spring 会使用 CGLIB(Code Generation Library)来创建代理对象。它可以在运行时动态生成一个目标类的子类,并重写目标类中的方法。在子类中,可以在目标方法执行前后插入额外的逻辑,实现 AOP 的功能。
两者之间的区别与联系:
实现方式:
- JDK 动态代理是基于 Java 的反射机制来实现的,它要求目标类必须实现至少一个接口。
- CGLIB 动态代理则是通过生成目标类的子类来实现的,因此不要求目标类实现接口。
即:JDK动态代理需要目标类和代理类实现同一个接口,CGLIB动态代理时会生成目标类的子类。
性能:
- 通常情况下,JDK 动态代理的性能比 CGLIB 动态代理略高,因为它不需要生成子类,直接利用接口来进行代理。
- CGLIB 动态代理的性能略低,因为它需要生成目标类的子类,并且在运行时对目标类的方法进行重写。
但是从是否反射的角度上,CGLIB因为无需反射,性能是高于JDK动态代理的
适用范围:
- JDK 动态代理适用于那些实现了接口的类,因为 JDK 动态代理是基于接口的。
- CGLIB 动态代理则适用于那些没有实现接口的类,它可以直接对类进行代理。
两者的共同点:
JDK 动态代理和 CGLIB 动态代理的目的都是为了实现对目标类的增强,例如实现 AOP(面向切面编程)。在 Spring 中,无论是使用 JDK 动态代理还是 CGLIB 动态代理,开发者都是通过配置来决定使用哪种代理方式。Spring 会根据目标类是否实现接口来自动选择使用 JDK 动态代理还是 CGLIB 动态代理。JDK 动态代理和 CGLIB 动态代理都是在运行时生成代理对象,动态地在目标方法的执行前后插入额外的逻辑,实现对目标方法的增强。
补充:动态代理与静态代理的区别:
静态代理:在编译时就已经确定代理类和被代理类的关系,代理类是通过手动编写代码或者工具生成的,代理类和被代理类在编译时就确定了。
动态代理:在运行时动态生成代理对象,不需要预先知道代理类和被代理类的关系,可以动态地在运行时创建代理对象,使得代理类的生成更加灵活。
4.1、JDK动态代理
首先创建一个接口:
public interface Inter {void foo();
}
实现类:
public class InterImpl implements Inter {private static final Logger log = LoggerFactory.getLogger(InterImpl.class);@Overridepublic void foo() {log.info("foo");}
}
测试类:
public class JdkProxyDemo {private static final Logger log = LoggerFactory.getLogger(JdkProxyDemo.class);public static void main(String[] args) {InterImpl inter = new InterImpl();//模拟jdk动态代理ClassLoader classLoader = JdkProxyDemo.class.getClassLoader();//加载运行期间动态生成的字节码Inter instance = (Inter) Proxy.newProxyInstance(classLoader, new Class[]{Inter.class}, (o, method, objects) -> {System.out.println("before");//通过反射调用 参数一:调用方法所在的对象 参数二:调用方法所需的参数Object invoke = method.invoke(inter, args);System.out.println("after");return invoke;});instance.foo();}
}
newProxyInstance( ClassLoader loader, Class<?>[] interfaces,InvocationHandler h ) 是Proxy类下的一个静态方法:
- 参数一:类加载器,用于加载动态生成的代理类。在 Java 中,类加载器负责将类的字节码加载到 JVM 中,并生成对应的 Class 对象。动态代理需要动态生成代理类,因此需要一个类加载器来加载这些类。
- 参数二:代理对象需要实现的接口列表。动态代理只能代理接口,因此这个参数是一个接口数组,指定了代理对象需要实现的接口列表。代理对象将会实现这些接口,并且在调用接口方法时会委托给 InvacationHandler 处理。
- 参数三:调用处理器,用于处理代理对象的方法调用。InvacationHandler 是一个接口,它包含一个 invoke()方法,用于在代理对象上调用方法时执行的逻辑。当代理对象的方法被调用时,invoke()方法会被调用,传入代理对象、被调用方法和方法参数,开发者可以在这个方法中实现自定义的逻辑,比如记录日志、执行额外的操作等。
简而言之,可以用目标类获取一个类加载器,还需要传入被代理对象所实现的接口,并且在InvacationHandler内编写被代理类方法增强的逻辑,以及通过反射调用被代理类中的某个方法。
4.1.1、JDK动态代理的模拟实现
模拟JDK动态代理的实现,首先创建一个待增强的目标类及接口:
public interface Foo {void foo();int bar();
}
public class Target implements Foo{private static final Logger log = LoggerFactory.getLogger(Target.class);@Overridepublic void foo() {log.info("foo");}@Overridepublic int bar() {log.info("bar");return 100;}
}
上面提到过,当目标类实现了接口时,Spring 就会使用 JDK 动态代理来创建代理对象。在运行时,Spring 创建一个实现了目标接口的代理类。 所以创建一个代理类实现Foo接口:
/*** 实现Foo接口,重写foo()和bar()方法*/
public class $Proxy0 implements Foo {@Overridepublic void foo() {//foo方法增强逻辑//调用目标方法}@Overridepublic int bar() {//bar方法增强逻辑//调用目标方法return 0;}
}
在测试类中:
/*** 模拟jdk动态代理的实现*/
public class A11Application {private static final Logger log = LoggerFactory.getLogger(A11Application.class);public static void main(String[] args) {//在创建$Proxy0对象时,通过有参构造指定 增强的具体逻辑$Proxy0 proxy0 = new $Proxy0();proxy0.bar();proxy0.foo();}}
这样写已经可以简单的实现Target中foo()方法和bar()方法的增强,但是,此时的增强逻辑是在编译时就写死的,很显然不符合动态代理的概念。我们需要的是,在运行期间动态的对目标类中的方法进行增强。
引入一个InvacationHandler接口:
public interface InvacationHandler {/*** @param proxy 代理类对象* @param method 需要增强的方法* @param objects 需要增强的方法的参数* @return* @throws Throwable*/Object invoke($Proxy0 proxy, Method method, Object[] objects) throws Throwable;}
应该在测试类创建$Proxy0对象时,将InvacationHandler作为参数传入,在InvacationHandler中动态的编写增强的逻辑,在$Proxy0中加入构造:
InvacationHandler invacationHandler;public $Proxy0(InvacationHandler invacationHandler) {this.invacationHandler = invacationHandler;
}
foo()方法和bar()方法中调用invacationHandler的invoke()方法,其中第二个参数,需要我们在$Proxy0类加载时,初始化带增强的方法:
static Method foo;static Method bar;static {try {foo = Foo.class.getMethod("foo");bar = Foo.class.getMethod("bar");} catch (NoSuchMethodException e) {throw new NoSuchMethodError(e.getMessage());}}
$Proxy0类改造完成:
public class $Proxy0 implements Foo {InvacationHandler invacationHandler;public $Proxy0(InvacationHandler invacationHandler) {this.invacationHandler = invacationHandler;}static Method foo;static Method bar;static {try {foo = Foo.class.getMethod("foo");bar = Foo.class.getMethod("bar");} catch (NoSuchMethodException e) {throw new NoSuchMethodError(e.getMessage());}}@Overridepublic void foo() {try {invacationHandler.invoke(this,foo,new Object[0]);} catch (RuntimeException | Error e) {throw e;}catch (Throwable throwable){throw new UndeclaredThrowableException(throwable);}}@Overridepublic int bar() {try {Object result = invacationHandler.invoke(this, bar, new Object[]{100});return ((int) result);} catch (RuntimeException | Error e) {throw e;}catch (Throwable throwable){throw new UndeclaredThrowableException(throwable);}}
}
在创建 $Proxy0对象时,就需要通过创建invacationHandler匿名内部类的方式传递一段逻辑:
最终测试类:
public class A11Application {private static final Logger log = LoggerFactory.getLogger(A11Application.class);public static void main(String[] args) {//在创建$Proxy0对象时,通过有参构造指定 增强的具体逻辑$Proxy0 proxy0 = new $Proxy0(new InvacationHandler() {@Overridepublic Object invoke($Proxy0 proxy, Method method, Object[] objects) throws Throwable {System.out.println("before");//通过反射调用Target中的方法,objectsObject invoke = method.invoke(new Target(), objects);return invoke;}});proxy0.bar();proxy0.foo();}}
4.1.2、JDK动态代理源码
下面我们借助arthas工具查看JDK动态代理的源码实现:
安装工具:cmd打开终端->curl -O https://alibaba.github.io/arthas/arthas-boot.jar
运行工具:java -jar arthas-boot.jar
注意:使用工具时保持程序处在运行状态,且需要获取要查看类的类名信息
选择对应的类:
得到生成代理类的源码:
/** Decompiled with CFR.** Could not load the following classes:* com.itbaima.a10.jdkproxy.Inter*/
package com.sun.proxy;import com.itbaima.a10.jdkproxy.Inter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;public final class $Proxy2
extends Proxy
implements Inter {private static Method m1;private static Method m2;private static Method m3;private static Method m0;public $Proxy2(InvocationHandler invocationHandler) {super(invocationHandler);}static {try {m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);m3 = Class.forName("com.itbaima.a10.jdkproxy.Inter").getMethod("foo", new Class[0]);m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);return;}catch (NoSuchMethodException noSuchMethodException) {throw new NoSuchMethodError(noSuchMethodException.getMessage());}catch (ClassNotFoundException classNotFoundException) {throw new NoClassDefFoundError(classNotFoundException.getMessage());}}public final boolean equals(Object object) {try {return (Boolean)this.h.invoke(this, m1, new Object[]{object});}catch (Error | RuntimeException throwable) {throw throwable;}catch (Throwable throwable) {throw new UndeclaredThrowableException(throwable);}}public final String toString() {try {return (String)this.h.invoke(this, m2, null);}catch (Error | RuntimeException throwable) {throw throwable;}catch (Throwable throwable) {throw new UndeclaredThrowableException(throwable);}}public final int hashCode() {try {return (Integer)this.h.invoke(this, m0, null);}catch (Error | RuntimeException throwable) {throw throwable;}catch (Throwable throwable) {throw new UndeclaredThrowableException(throwable);}}public final void foo() {try {this.h.invoke(this, m3, null);return;}catch (Error | RuntimeException throwable) {throw throwable;}catch (Throwable throwable) {throw new UndeclaredThrowableException(throwable);}}
}
与JDK动态代理的模拟实现类似。不同点在于,源码中加上了方法中共有的.equals()、.hashCode()、.toString()方法。
4.1.3、JDK动态代理字节码生成(了解)
JDK生成代理类,并没有经历源码阶段,编译阶段,而是直接生成了字节码(ASM)。ASM技术是在运行期间动态生成字节码。
可以通过插件查看生成的字节码:
准备一个继承了反射包下Proxy类的代理类和接口:
public class $Proxy0 extends Proxy implements Foo {protected $Proxy0(InvocationHandler h) {super(h);}@Overridepublic void foo(){try {h.invoke(this,foo,null);} catch (Throwable e) {throw new UndeclaredThrowableException(e);}}static Method foo;static {try {foo = Foo.class.getMethod("foo");} catch (NoSuchMethodException e) {throw new NoSuchMethodError(e.getMessage());}}
}
public interface Foo {void foo() throws Throwable;
}
然后将代理类和接口进行编译(Ctrl+Shift+F9)
右键如图所示,生成文件。
文件中一些字节码指令的简单理解:
构建一个类:
cw.visit(52, ACC_PUBLIC + ACC_SUPER, "com/itheima/$Proxy0", null, "java/lang/reflect/Proxy", new String[]{"com/itheima/Foo"});
定义类中的方法和成员变量:
{fv = cw.visitField(ACC_STATIC, "foo", "Ljava/lang/reflect/Method;", null, null);fv.visitEnd();
}
生成byte字节码数组:
return cw.toByteArray();
然后我们将$Proxy0Dump字节码写入$Proxy0.class文件:
public class TestProxy {public static void main(String[] args) throws Exception {//将$Proxy0Dump字节码写入$Proxy0.class文件byte[] dump = $Proxy0Dump.dump();FileOutputStream fileOutputStream = new FileOutputStream("$Proxy0.class");fileOutputStream.write(dump,0,dump.length);fileOutputStream.close();}
}
发现字节码文件和$Proxy0一样:
整体流程:
public class TestProxy {public static void main(String[] args) throws Throwable {//生成$Proxy0Dump字节码byte[] dump = $Proxy0Dump.dump();//加载$Proxy0Dump字节码ClassLoader classLoader = new ClassLoader(){@Overrideprotected Class<?> findClass(String name) throws ClassNotFoundException {return super.defineClass(name,dump,0,dump.length);}};//得到类对象Class<?> loadClass = classLoader.loadClass("com.itheima.$Proxy0");//利用反射创建对象Constructor<?> constructor = loadClass.getConstructor(InvacationHandler.class);Foo foo = (Foo) constructor.newInstance(new InvacationHandler() {@Overridepublic Object invoke($Proxy0 proxy, Method method, Object[] objects) throws Throwable {System.out.println("before invoke");System.out.println("调用方法");return null;}});foo.foo();}
}
4.1.4、JDK反射优化
JDK动态代理中,当调用invoke() 方法到达一定次数时(17)次,会触发反射优化。(类似于JUC锁批量重偏向)
public class TestMethodInvoke {public static void main(String[] args) throws Exception {Method foo = TestMethodInvoke.class.getMethod("foo", int.class);for (int i = 0; i < 17; i++) {foo.invoke(null,i);show(i,foo);System.in.read();}}// 方法反射调用时, 底层 MethodAccessor 的实现类private static void show(int i, Method foo) throws Exception {Method getMethodAccessor = Method.class.getDeclaredMethod("getMethodAccessor");getMethodAccessor.setAccessible(true);Object invoke = getMethodAccessor.invoke(foo);if (invoke == null) {System.out.println(i + ":" + null);return;}Field delegate = Class.forName("jdk.internal.reflect.DelegatingMethodAccessorImpl").getDeclaredField("delegate");delegate.setAccessible(true);System.out.println(i + ":" + delegate.get(invoke));}public static void foo(int i){System.out.println("第"+i+"次调用");}
}
前16次反射调用的是JDK本地的api,效率较低。
第十七次优化成了正常调用方法,没有通过反射,所以性能较高:
4.2、CGLIB 动态代理
4.2.1、CGLIB 动态代理的模拟实现
编写目标类:
/*** 待增强的目标类*/
public class Target {public void save1(){System.out.println("save1 ...");}public void save2(int i){System.out.println("save2 ..."+ i);}public void save3(long j){System.out.println("save3 ..."+ j);}
}
编写代理类,CGLIB 动态代理则是通过生成目标类的子类来实现的,不需要目标类和代理类实现一个共同的接口:
/*** CGLIB 动态代理则是通过生成目标类的子类来实现的*/
public class MockCglibProxy extends Target{MethodInterceptor interceptor;public void setInterceptor(MethodInterceptor interceptor) {this.interceptor = interceptor;}static Method save1;static Method save2;static Method save3;static {try {save1 = Target.class.getMethod("save1");save2 = Target.class.getMethod("save2", int.class);save3 = Target.class.getMethod("save3", long.class);} catch (NoSuchMethodException e) {throw new NoSuchMethodError(e.getMessage());}}@Overridepublic void save1() {try {interceptor.intercept(this,save1,new Object[0],null);} catch (Throwable e) {throw new RuntimeException(e);}}@Overridepublic void save2(int i) {try {interceptor.intercept(this,save2,new Object[]{10},null);} catch (Throwable e) {throw new RuntimeException(e);}}@Overridepublic void save3(long j) {try {interceptor.intercept(this,save3,new Object[]{20L},null);} catch (Throwable e) {throw new RuntimeException(e);}}}
测试类:
public class TestProxy {public static void main(String[] args) {Target target = new Target();MockCglibProxy mockCglibProxy = new MockCglibProxy();mockCglibProxy.setInterceptor(new MethodInterceptor() {@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("before");return method.invoke(target,objects);}});target.save1();target.save2(0);target.save3(0);}
}
而CGLIB和JDK动态代理最大的区别在于:
方法代理参数,可以保证每次方法都是正常调用,而不是通过反射。
4.2.2、CGLIB 动态代理的原理
首先我们将interceptor.intercept() 方法中所需的MethodProxy方法参数进行补充创建:
定义原有方法:
public void saveSuper1(){super.save1();}public void saveSuper2(int i){super.save2(i);}public void saveSuper3(long j){super.save3(j);}
初始化MethodProxy:
//初始化methodProxystatic MethodProxy saveSuper1;static MethodProxy saveSuper2;static MethodProxy saveSuper3;
创建对象:
static {try {save1 = Target.class.getMethod("save1");save2 = Target.class.getMethod("save2", int.class);save3 = Target.class.getMethod("save3", long.class);//创建methodProxy对象//参数一:目标类 参数二:代理类 参数三:方法参数 参数四:增强方法 参数五:原有方法saveSuper1 = MethodProxy.create(Target.class, MockCglibProxy.class,"()V","save1","saveSuper1");saveSuper2 = MethodProxy.create(Target.class, MockCglibProxy.class,"(I)V","save2","saveSuper2");saveSuper3 = MethodProxy.create(Target.class, MockCglibProxy.class,"(J)V","save3","saveSuper3");} catch (NoSuchMethodException e) {throw new NoSuchMethodError(e.getMessage());}}
将创建的MethodProxy对象传入增强方法中:
//以下是带增强的方法。。。。@Overridepublic void save1() {try {interceptor.intercept(this,save1,new Object[0],saveSuper1);} catch (Throwable e) {throw new RuntimeException(e);}}@Overridepublic void save2(int i) {try {interceptor.intercept(this,save2,new Object[]{10},saveSuper2);} catch (Throwable e) {throw new RuntimeException(e);}}@Overridepublic void save3(long j) {try {interceptor.intercept(this,save3,new Object[]{20L},saveSuper3);} catch (Throwable e) {throw new RuntimeException(e);}}
在主类中,使用
- methodProxy.invoke(); 内部无反射,结合目标使用
- methodProxy.invokeSuper() 内部无反射,结合代理使用
在调用methodProxy.invoke();methodProxy.invokeSuper() 时,又会产生一个新的代理类,从而避免反射:
生成的代理类的父类是FastClass类型:
简单来说,FastClass的作用:为代理类中的每个方法生成一个索引,并将方法的调用逻辑封装在一个数组中。当代理类的方法被调用时,CGLIB 会根据方法的索引直接定位到对应的调用逻辑,从而避免了每次都要通过反射查找方法的开销。
所以FastClass是CGLIB避免反射的关键。
下面同样通过模拟FastClass实现类的方式进行分析,首先模拟结合目标使用的methodProxy.invoke(); 对应的FastClass实现类:
- public int getIndex(Signature signature) 方法:目的是为了获取方法的编号,是在代理类中MethodProxy.create()创建时执行。
- public Object invoke(int index, Object target, Object[] args)方法:目的是执行对应编号的方法,在主类调用method.invoke()时执行
在public Object invoke(int index, Object target, Object[] args)方法中,没有使用反射的方式。
/*** 模拟FastClass的子类实现,配合目标使用,对应 method.invoke*/
public class TargetFastClass {Signature s1 = new Signature("save1","()V");Signature s2 = new Signature("save2","(I)V");Signature s3 = new Signature("save3","(J)V");/*** 获取方法的编号* 执行时机: 代理类中 MethodProxy.create创建时* @param signature* @return*/public int getIndex(Signature signature){if (s1.equals(signature)){return 0;}else if (s2.equals(signature)){return 1;}else if (s3.equals(signature)){return 2;}return -1;}/*** 执行编号对应的方法* 执行时机 调用method.invoke* @param index* @param target* @param args* @return*/public Object invoke(int index, Object target, Object[] args){if (index == 0){//正常调用目标的方法,没有通过反射((Target) target).save1();}else if (index == 1){((Target) target).save2(((int) args[0]));}else if (index == 2){((Target) target).save3(((long) args[0]));}return null;}}
然后模拟结合目标使用的methodProxy.invokeSuper(); 对应的FastClass实现类:
/*** 模拟FastClass的子类实现,配合代理类使用,对应 methodProxy.invokeSuper* 生成时机:代理对象中MethodProxy.create的执行*/
public class ProxyFastClass {Signature s1 = new Signature("saveSuper1","()V");Signature s2 = new Signature("saveSuper2","(I)V");Signature s3 = new Signature("saveSuper3","(J)V");/*** 获取代理类中方法的编号(有三个增强方法,三个原始方法)* 获取的都是原始方法的编号* 执行时机: 代理类中 MethodProxy.create创建时* @param signature* @return*/public int getIndex(Signature signature){if (s1.equals(signature)){return 0;}else if (s2.equals(signature)){return 1;}else if (s3.equals(signature)){return 2;}return -1;}/*** 执行编号对应的方法* 执行时机 调用method.invoke* @param index* @param proxy* @param args* @return*/public Object invoke(int index, Object proxy, Object[] args){if (index == 0){//正常调用目标的方法,没有通过反射((MockCglibProxy) proxy).saveSuper1();}else if (index == 1){((MockCglibProxy) proxy).saveSuper2(((int) args[0]));}else if (index == 2){((MockCglibProxy) proxy).saveSuper3(((long) args[0]));}return null;}public static void main(String[] args) {ProxyFastClass fastClass = new ProxyFastClass();int index = fastClass.getIndex(new Signature("saveSuper1","()V"));System.out.println(index);fastClass.invoke(index,new MockCglibProxy(),new Object[0]);}
}
此时public int getIndex(Signature signature) 方法获取的是代理类中三个原始方法的序号。(代理类中一共有六个方法,三个原始方法,三个增强方法),原因是增强的逻辑在主类中已经通过.setInterceptor() 传入,不需要再次调用代理中的增强方法。并且如果再次调用代理中的增强方法,会发生interceptor.intercept() 循环调用的问题。
4.2.3、与JDK动态代理对比
CGLIB与JDK动态代理性能上的区别在于,JDK动态代理是在达到一定的次数后取消反射机制,正常调用方法。而CGLIB运用methodProxy.invoke()和methodProxy.invokeSuper() 进行了优化,保证方法无需反射。
JDK调用一个方法就对应一个代理。而CGLIB是一个代理类对应两个FastClass(配合目标、配合代理),每个FastClass可以对应多个方法。