转载自:https://blog.csdn.net/qq_38505969/article/details/123739542
介绍
代码仓库地址:https://gitee.com/CandyWall/spring-source-study
跟着黑马满一航老师的spring高级49讲做的学习笔记,本笔记跟视频内容的项目名称和代码略有不同,我将49讲的代码每一讲的代码都拆成了独立的springboot项目,并且项目名称尽量做到了见名知意,都是基于我自己的考量,代码都已经过运行验证过的,仅供参考。
视频教程地址:https://www.bilibili.com/video/BV1P44y1N7QG
注:
1. 每一讲对应一个二级标题,每一个三级标题是使用子项目名称命名的,和我代码仓库的项目是一一对应的;
2. 代码里面用到了lombok插件来简化了Bean中的get()、set()方法,以及日志的记录的时候用了lombok的@Slf4j注解。
笔记中如有不正确的地方,欢迎在评论区指正,非常感谢!!!
每个子项目对应的视频链接以及一些重要内容的笔记
第六讲 Aware和InitializingBean接口以及@Autowired注解失效分析
spring_06_aware_initializingbean
p26 025-第六讲-Aware与InitializingBean接口
Aware
接口用于注入一些与容器相关信息,例如:
a. BeanNameAware
注入 Bean
的名字
b. BeanFactoryAware
注入 BeanFactory
容器
c. ApplicationContextAware
注入 ApplicationContext
容器
d. EmbeddedValueResolverAware
注入 解析器,解析${}
定义一个MyBean
类,实现BeanNameAware
、ApplicationContextAware
和InitializingBean
接口并实现其方法,再定义两个方法,其中一个加@Autowired注解,注入ApplicationContext容器,另一个加@PostConstruct注解,具体代码如下:
public class MyBean implements BeanNameAware, ApplicationContextAware, InitializingBean {
@Override
public void setBeanName(String name) {
log.debug("当前bean:" + this + ",实现 BeanNameAware 调用的方法,名字叫:" + name);
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
log.debug("当前bean:" + this + ",实现 ApplicationContextAware 调用的方法,容器叫:" + applicationContext);
}
@Override
public void afterPropertiesSet() throws Exception {
log.debug("当前bean:" + this + ",实现 InitializingBean 调用的方法,初始化");
}
@Autowired
public void aaa(ApplicationContext applicationContext) {
log.debug("当前bean:" + this +",使用 @Autowired 容器是:" + applicationContext);
}
@PostConstruct
public void init() {
log.debug("当前bean:" + this + ",使用 @PostConstruct 初始化");
}
}
测试代码:
public class TestAwareAndInitializingBean {
@Test
public void testAware1() throws Exception {
GenericApplicationContext context = new GenericApplicationContext();
context.registerBean("myBean", MyBean.class);
context.refresh();
context.close();
}
}
运行结果:
加了@Autowired
和@PostConstruct
注解的方法并没有被执行,而Aware
和InitializingBean
接口方法都被执行了。
修改测试代码,把解析@Autowired
和@PostConstruct
注解的Bean
后处理加进来,然后再运行一下
public class TestAwareAndInitializingBean {
@Test
public void testAware1() throws Exception {
GenericApplicationContext context = new GenericApplicationContext();
context.registerBean("myBean", MyBean.class);
// 解析 @Autowired 注解的Bean后处理器
context.registerBean(AutowiredAnnotationBeanPostProcessor.class);
// 解析 @PostConstruct 注解的Bean后处理器
context.registerBean(CommonAnnotationBeanPostProcessor.class);
context.refresh();
context.close();
}
}
运行结果:
可以看到这下都执行了
有人可能会问:b
、c
、d
的功能用 @Autowired
注解就能实现啊,为啥还要用 Aware
接口呢?
InititalizingBean
接口可以用 @PostConstruct
注解实现,为啥还要用InititalizingBean
呢?
简单地说:
-
@Autowired
和@PostConstruct
注解的解析需要用到Bean
后处理器,属于扩展功能,而Aware
接口属于内置功能,不加任何扩展,Spring
就能识别; -
某些情况下,扩展功能会失效,而内置功能不会失效
-
例1:比如没有把解析
@Autowired
和@PostStruct
注解的Bean
的后处理器加到Bean
工厂中,你会发现用Aware
注入ApplicationContext
成功, 而@Autowired
注入ApplicationContext
失败 -
例2:定义两个
Java Config
类(类上加@Configuration
注解),名字分别叫MyConfig1
和MyConfig2
,都实现注入ApplicationContext
容器和初始化功能,MyConfig1
用@Autowired
和@PostConstruct
注解实现,MyConfig2
用实现Aware
和InitializingBean
接口的方式实现,另外,两个Config
类中都通过@Bean
注解的方式注入一个BeanFactoryPostProcessor
,代码如下:MyConfig1
:@Slf4j public class MyConfig1 { @Autowired public void setApplicationContext(ApplicationContext applicationContext) { log.debug("注入 ApplicationContext"); } @PostConstruct public void init() { log.debug("初始化"); } @Bean public BeanFactoryPostProcessor processor1() { return beanFactory -> { log.debug("执行 processor1"); }; } }
测试代码:
@Slf4j public class TestAwareAndInitializingBean { @Test public void testAware_MyConfig1() { GenericApplicationContext context = new GenericApplicationContext(); // MyConfig1没有加上@ context.registerBean("myConfig1", MyConfig1.class); // 解析 @Autowired 注解的Bean后处理器 context.registerBean(AutowiredAnnotationBeanPostProcessor.class); // 解析 @PostConstruct 注解的Bean后处理器 context.registerBean(CommonAnnotationBeanPostProcessor.class); // 解析@ComponentScan、@Bean、@Import、@ImportResource注解的后处理器 // 这个后处理器不加出不来效果 context.registerBean(ConfigurationClassPostProcessor.class); // 1. 添加beanfactory后处理器;2. 添加bean后处理器;3. 初始化单例。 context.refresh(); context.close(); }
运行结果:
MyConfig2
:@Slf4j public class MyConfig2 implements ApplicationContextAware, InitializingBean { @Override public void setApplicationContext(ApplicationContext applicationContext) { log.debug("注入 ApplicationContext"); } @Override public void afterPropertiesSet() throws Exception { log.debug("初始化"); } @Bean public BeanFactoryPostProcessor processor1() { return beanFactory -> { log.debug("执行 processor1"); }; } }
测试代码:
@Slf4j public class TestAwareAndInitializingBean { @Test public void testAutowiredAndInitializingBean_MyConfig2() { GenericApplicationContext context = new GenericApplicationContext(); context.registerBean("myConfig2", MyConfig2.class); // 1. 添加beanfactory后处理器;2. 添加bean后处理器;3. 初始化单例。 context.refresh(); context.close(); } }
运行结果:
Java配置类在添加了
bean
工厂后处理器后,你会发现用传统接口方式的注入和初始化依然成功,而@Autowired
和@PostConstruct
的注入和初始化失败。那是什么原因导致的呢?
配置类
@Autowired
注解失效分析-
Java 配置类不包含
BeanFactoryPostProcessor
的情况
-
-
总结:
Aware
接口提供了一种【内置】 的注入手段,可以注入BeanFactory
,ApplicationContext
;InitializingBean
接口提供了一种 【内置】 的初始化手段;- 内置的注入和初始化不收扩展功能的影响,总会被执行,因此
spring
框架内部的类常用它们。
第七讲 Bean的初始化与销毁
spring_07_init_destroy
定义Bean1
类,实现InitializingBean
接口和对应的接口方法afterPropertiesSet()
,再定义init1()
方法,在方法上加@PostConstruct
注解,最后定义init3()
@Slf4j
public class Bean1 implements InitializingBean {
@PostConstruct
public void init1() {
log.debug("初始化1,@PostConstruct");
}
@Override
public void afterPropertiesSet() throws Exception {
log.debug("初始化2,InitializingBean接口");
}
public void init3() {
log.debug("初始化3,@Bean的initMethod");
}
}
定义Bean2
类,实现DisposableBean
接口和对应的接口方法destroy()
,再定义destroy1()
方法,在方法上加@PreDestroy
注解,最后定义init3()
@Slf4j
public class Bean2 implements DisposableBean {
@PreDestroy
public void destroy1() {
log.debug("销毁1,@PreDestory");
}
@Override
public void destroy() throws Exception {
log.debug("销毁2,DisposableBean接口");
}
public void destroy3() {
log.debug("销毁3,@Bean的destroyMethod");
}
}
定义Config
类,类上加@Configuration
注解,类中通过@Bean
注解把Bean1
和Bean2
加到Bean
工厂中,分别在@Bean
注解中指定initMethod = "init3"
,destroyMethod = "destroy"
@Configuration
public class Config {
@Bean(initMethod = "init3")
public Bean1 bean1() {
return new Bean1();
}
@Bean(destroyMethod = "destroy3")
public Bean2 bean2() {
return new Bean2();
}
}
编写测试代码,观察三个初始化方法和三个销毁方法的执行顺序
@Slf4j
public class TestInitAndDestroy {
@Test
public void testInitAndDestroy() throws Exception {
// ⬇️GenericApplicationContext 是一个【干净】的容器,这里只是为了看初始化步骤,就不用springboot启动类进行演示了
GenericApplicationContext context = new GenericApplicationContext();
context.registerBean("config", Config.class);
// 解析@PostConstruct注解的bean后处理器
context.registerBean(CommonAnnotationBeanPostProcessor.class);
// 解析@Configuration、@Component、@Bean注解的bean工厂后处理器
context.registerBean(ConfigurationClassPostProcessor.class);
context.refresh();
context.close();
}
}
运行结果:
可以看到,spring提供了多种初始化和销毁手段
-
对于
init
,三个初始化方法的执行顺序是@PostConstruct
->InitializingBean
接口 ->@Bean
的initMethod
-
对于
destory
, 三个销毁方法的执行顺序是@PreDestroy
->DisposableBean
接口 ->@Bean
的destroy
第八讲 Scope类型、注意事项、销毁和失效分析
spring_08_scope
spring
的scope
类型:
singleton
:单例prototype
:多例request
:web
请求session
:web
的会话application
:web
的ServletContext
测试scope
类型中的request
、session
、application
定义**BeanForRequest
类,加上@Component
和@Scope
注解,指定Scope
类型为request
**,在类型中定义destroy()
方法,方法上加@PreDestory
注解,代码如下:
@Slf4j
@Scope("request")
@Component
public class BeanForRequest {
@PreDestroy
public void destory() {
log.debug("destroy");
}
}
定义**BeanForSession
类,加上@Component
和@Scope
注解,指定Scope
类型为session
**,在类型中定义destroy()
方法,方法上加@PreDestory
注解,代码如下:
@Slf4j
@Scope("request")
@Component
public class BeanForRequest {
@PreDestroy
public void destory() {
log.debug("destroy");
}
}
定义**BeanForApplication
类,加上@Component
和@Scope
注解,指定Scope
类型为application
**,在类型中定义destroy()
方法,方法上加@PreDestory
注解,代码如下:
@Slf4j
@Scope("request")
@Component
public class BeanForRequest {
@PreDestroy
public void destory() {
log.debug("destroy");
}
}
编写一个MyController
类,加上@RestController
注解,在该类中通过@Autowired
注解注入BeanForRequest
、BeanForSession
和BeanForApplication
的实例,需要注意,这里还需要加@Lazy
注解(至于原因后面会解释),否则会导致@Scope
域失效,再定义一个方法tes()
,加上@GetMapping
注解,用于响应一个http
请求,在test()
方法中,打印beanForRequest
、beanForSession
和beanForApplication
,代码如下:
@RestController
public class MyController {
@Lazy
@Autowired
private BeanForRequest beanForRequest;
@Lazy
@Autowired
private BeanForSession beanForSession;
@Lazy
@Autowired
private BeanForApplication beanForApplication;
@GetMapping(value = "/test", produces = "text/html")
public String test(HttpServletRequest request, HttpSession session) {
// ServletContext sc = request.getServletContext();
String result = "<ul>" +
"<li>request scope: " + beanForRequest + "</li>" +
"<li>session scope: " + beanForSession + "</li>" +
"<li>application scope: " + beanForApplication + "</li>" +
"</ul>";
return result;
}
}
springboot
启动类
@Slf4j
@SpringBootApplication
public class ScopeApplicationContext {
public static void main(String[] args) throws InterruptedException {
testRequest_Session_Application_Scope();
}
// 演示 request, session, application作用域
private static void testRequest_Session_Application_Scope() throws InterruptedException {
ConfigurableApplicationContext context = SpringApplication.run(ScopeApplicationContext.class);
}
}
启动后,用谷歌浏览器访问 http://localhost:8080/test,
浏览器运行结果如下:
再刷新一下当前页,查看运行结果:
控制台运行结果如下:
可以看到两次刷新只有BeanForRequest
对象发生了改变,这是由于scope
为request
类型的对象,会在请求结束后销毁,再来一次请求就会重新创建,请求结束后又会销毁。
接下来我们换个Edge
浏览器访问 http://localhost:8080/test,对比两个浏览器的显示结果:
可以看到这回除了BeanForRequest
对象不同,BeanForSession
对象也不同了,这是因为开一个新的浏览器会创建一个新的会话,所以BeanForSession
对象也不同了。
继续进行测试,在application.properties
配置一个属性server.servlet.session.timeout=10s
,这个属性的默认值为30
分钟,这样10s
没有操作浏览器的话就会销毁对应session
,不过经过测试这个这个属性最少为1
分钟,低于1分钟一律按照1分钟算。具体原理看这篇博客:https://www.jianshu.com/p/9d91cca74082,里面进行了源码级别的分析。
设置好之后,重启项目, 然后去浏览器访问,1分钟后控制台会打印session
被销毁,如下图所示:
那什么时候scope
为application
的对象BeanForApplication
会销毁呢?按理说应该是在SpringBoot
程序结束,也即内置的Tomcat
服务器停止的时候调用,但是经过测试:无论是在控制台停止SpringBoot
项目,还是调用ApplicationContext
的close()
方法,都没有调用BeanForApplication
的销毁方法,有知道什么方法可以让它调用的,请评论区告知,谢谢!!!
定义1个单例类SingletonBean
,指定它的Scope
为singleton
,定义5
个多例类,PrototypeBean
、PrototypeBean1
、PrototypeBean2
、PrototypeBean3
、PrototypeBean4
,将这5
个多例类的对象注入到SingletonBean
的5
个属性中,其中PrototypeBean
用来演示多例对象注入到单例对象中Scope
失效的情况,其他四个类的对象用来演示四种解决Scope
失效的方法。相关类的定义如下:
SingletonBean
@Scope("singleton")
@Component
public class SingletonBean {
@Autowired
private PrototypeBean prototypeBean;
@Lazy
@Autowired
private PrototypeBean1 prototypeBean1;
@Autowired
private PrototypeBean2 prototypeBean2;
@Autowired
private ObjectFactory<PrototypeBean3> factory;
@Autowired
private ApplicationContext context;
public PrototypeBean getPrototypeBean() {
return prototypeBean;
}
public PrototypeBean1 getPrototypeBean1() {
return prototypeBean1;
}
public PrototypeBean2 getPrototypeBean2() {
return prototypeBean2;
}
public PrototypeBean3 getPrototypeBean3() {
return factory.getObject();
}
public PrototypeBean4 getPrototypeBean4() {
return context.getBean(PrototypeBean4.class);
}
}
PrototypeBean
@Scope("prototype")
@Component
public class PrototypeBean {
}
PrototypeBean1
@Scope("prototype")
@Component
public class PrototypeBean1 {
}
PrototypeBean2
@Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
@Component
public class PrototypeBean2 {
}
PrototypeBean3
@Scope("prototype")
@Component
public class PrototypeBean3 {
}
PrototypeBean4
@Scope("prototype")
@Component
public class PrototypeBean4 {
}
测试代码:
@Slf4j
@SpringBootApplication
public class ScopeApplicationContext {
public static void main(String[] args) throws Exception {
testSingletonPrototypeInvalidAndSolve();
}
// 演示单例中注入多例失效的情况,以及解决失效问题的方法
private static void testSingletonPrototypeInvalidAndSolve() {
ConfigurableApplicationContext context = SpringApplication.run(ScopeApplicationContext.class);
SingletonBean singletonBean = context.getBean(SingletonBean.class);
// 单例中注入多例失效的情况
log.debug("{}", singletonBean.getPrototypeBean().getClass());
log.debug("{}", singletonBean.getPrototypeBean());
log.debug("{}", singletonBean.getPrototypeBean());
log.debug("{}", singletonBean.getPrototypeBean());
System.out.println("------------------------------------");
// 解决方法1:在SingletonBean的PrototypeBean1属性上加@Lazy注解
log.debug("{}", singletonBean.getPrototypeBean1().getClass());
log.debug("{}", singletonBean.getPrototypeBean1());
log.debug("{}", singletonBean.getPrototypeBean1());
log.debug("{}", singletonBean.getPrototypeBean1());
System.out.println("------------------------------------");
// 解决方法2:在PrototypeBean2的类上的@Scope注解多配置一个属性,如,@Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
log.debug("{}", singletonBean.getPrototypeBean2().getClass());
log.debug("{}", singletonBean.getPrototypeBean2());
log.debug("{}", singletonBean.getPrototypeBean2());
log.debug("{}", singletonBean.getPrototypeBean2());
System.out.println("------------------------------------");
// 解决方法3:使用ObjectFactory<PrototypeBean3>工厂类,在每次调用getProtypeBean3()方法中返回factory.getObject()
log.debug("{}", singletonBean.getPrototypeBean3().getClass());
log.debug("{}", singletonBean.getPrototypeBean3());
log.debug("{}", singletonBean.getPrototypeBean3());
log.debug("{}", singletonBean.getPrototypeBean3());
System.out.println("------------------------------------");
// 解决方法4:在SingletonBean中注入一个ApplicationContext,使用context.getBean(PrototypeBean4.class)获取对应的多例
log.debug("{}", singletonBean.getPrototypeBean4().getClass());
log.debug("{}", singletonBean.getPrototypeBean4());
log.debug("{}", singletonBean.getPrototypeBean4());
log.debug("{}", singletonBean.getPrototypeBean4());
System.out.println("------------------------------------");
}
}
运行结果如下:
第九讲 aop之ajc增强
aop
是spring
框架中非常重要的功能,其主要实现通常情况下是动态代理,但是这个说法并不全面,还有另外两种实现:
ajc
编译器agent
类加载
spring_09_aop_ajc
先看aop
的第一种实现ajc
编译器代码增强,这是一种编译时的代码增强。
新建一个普通的maven项目
-
添加依赖
使用
ajc
编译器进行代码增强,首先需要在pom.xml
文件中加入ajc
编译器插件依赖<build> <plugins> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>aspectj-maven-plugin</artifactId> <version>1.11</version> <configuration> <complianceLevel>1.8</complianceLevel> <source>8</source> <target>8</target> <showWeaveInfo>true</showWeaveInfo> <verbose>true</verbose> <Xlint>ignore</Xlint> <encoding>UTF-8</encoding> </configuration> <executions> <execution> <goals> <!-- use this goal to weave all your main classes --> <goal>compile</goal> <!-- use this goal to weave all your test classes --> <goal>test-compile</goal> </goals> </execution> </executions> </plugin> </plugins> </build>
加入
aspectjweaver
的依赖<dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.7</version> </dependency>
加入日志和单元测试的依赖
<dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.36</version> </dependency> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>1.2.10</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> </dependency>
-
需要增强的类
MyService
public class MyService { private static final Logger log = LoggerFactory.getLogger(MyAspect.class); public void foo() { log.debug("foo()"); } }
-
切面类
MyAspect
,编写execution
表达式,对MyService
类的foo()
方法进行增强@Aspect // ⬅️注意此切面并未被 Spring 管理,本项目pom文件中根本没有引入spring的相关类 public class MyAspect { private static final Logger log = LoggerFactory.getLogger(MyAspect.class); @Before("execution(* top.jacktgq.service.MyService.foo())") public void before() { log.debug("before()"); } }
-
测试代码
public class Aop_Aspectj_Test { @Test public void testAopAjc() { new MyService().foo(); } }
-
编译项目,这里需要使用
maven
来编译,打开idea
中的maven
面板,点击compile
然后再运行测试代码,可以看到创建
MyService
对象并调用foo()
方法会先执行切面类中的before()
方法注:
-
有些小伙伴可能会遇到问题:明明按照一样的步骤来操作,可是运行以后代码并没有增强。这是由于
idea
中在执行代码之前会默认编译一遍代码,这本来是正常的,可是,如果使用maven
来编译代码,会在执行代码前将maven
编译的代码覆盖,这就会导致maven
的ajc
编译器增强的代码被覆盖,所以会看不到最终的运行效果。 -
解决办法:在设置中将自动构建项目的选项勾上,就不会出现多次编译覆盖的问题了。
-
总结:
-
可以看到没有引入任何跟
spring
框架相关的包,MyService
类是通过直接new()
的方式获得的,所以也就不存在使用了动态代理的说法了 -
打开编译后的
MyService.class
文件,双击以后idea会反编译该字节码文件,可以看到foo()
方法体的开头加了一行代码,这就是增强的代码,这是ajc
编译器在编译MyService
类的时候为我们添加的代码,这是一种编译时的增强。
第十讲 aop之agent增强
spring_10_aop_agent
现在来看aop
的另外一种实现agent
增强,这是一种类加载时的代码增强。
-
新建一个普通的maven项目
-
加入
aspectjweaver
的依赖<dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.7</version> </dependency>
加入日志和单元测试的依赖
<dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.36</version> </dependency> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>1.2.10</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.22</version> </dependency>
-
需要增强的类
MyService
@Slf4j public class MyService { public void foo() { log.debug("foo()"); bar(); } public void bar() { log.debug("bar()"); } }
-
切面类
MyAspect
,编写execution
表达式,对MyService
类的foo()
方法进行增强@Aspect // ⬅️注意此切面并未被 Spring 管理,本项目pom文件中根本没有引入spring的相关类 @Slf4j public class MyAspect { @Before("execution(* top.jacktgq.service.MyService.*())") public void before() { log.debug("before()"); } }
-
测试代码
public class Aop_agent_Test { @Test public void testAopAgent() throws Exception { MyService myService = new MyService(); myService.foo(); System.in.read(); } }
运行时需要在 VM options 里加入
-javaagent:D:\同步空间\repository\org\aspectj\aspectjweaver\1.9.7\aspectjweaver-1.9.7.jar
把其中D:\同步空间\repository
改为你自己maven
仓库起始地址注:还需要在
resources/META-INF
目录下建一个aop.xml
配置文件,内容如下,aspectj
会自动扫描到这个配置文件,不加这个配置文件不会出效果。<aspectj> <aspects> <aspect name="top.jacktgq.aop.MyAspect"/> <weaver options="-verbose -showWeaveInfo"> <include within="top.jacktgq.service.MyService"/> <include within="top.jacktgq.aop.MyAspect"/> </weaver> </aspects> </aspectj>
运行测试代码,可以看到创建
MyService
对象并调用foo()
方法会先执行切面类中的before()
方法注:
-
有些小伙伴可能会遇到问题:明明按照一样的步骤来操作,可是运行以后代码并没有增强。这是由于
idea
中在执行代码之前会默认编译一遍代码,这本来是正常的,可是,如果使用maven
来编译代码,会在执行代码前将maven
编译的代码覆盖,这就会导致maven
的ajc
编译器增强的代码被覆盖,所以会看不到最终的运行效果。 -
解决办法:在设置中将自动构建项目的选项勾上,就不会出现多次编译覆盖的问题了。
-
总结:
-
可以看到没有引入任何跟
spring
框架相关的包,MyService
类是通过直接new()
的方式获得的,所以也就不存在使用了动态代理的说法了 -
打开编译后的
MyService.class
文件,双击以后idea会反编译该字节码文件,可以看到foo()
方法体中并没有添加多余的代码,所以就不是编译时增强了,而是类加载的时候增强的,这里可以借助阿里巴巴的Arthas工具,下载地址:https://arthas.aliyun.com/doc/en/download.html,解压以后进入到arthas的bin目录下,启动黑窗口,输入java -jar .\arthas-boot.jar
,在输出的java
进程列表里面找到我们要连接的进程,输入对应进程的序号,我这里是4
,连接上以后会打印ARTHAS
的logo
再输入
jad top.jacktgq.service.MyService
反编译内存中的MyService
类可以看到
foo()
和bar()
方法体的第一行都加了一行代码,这就说明通过添加虚拟机参数-javaagent
的方式可以在类加载的时候对代码进行增强。
-
第十一讲 aop之proxy增强-jdk和cglib
spring_11_aop_proxy_jdk_cglib
测试代码
public class AopJdkProxyTest {
@Test
public void testJdkProxy() {
// jdk的动态代理,只能针对接口代理
// 目标对象
Target target = new Target();
// 用来加载在运行期间动态生成的字节码
ClassLoader loader = AopJdkProxyTest.class.getClassLoader();
Foo fooProxy = (Foo) Proxy.newProxyInstance(loader, new Class[]{Foo.class}, (proxy, method, args) -> {
System.out.println("before...");
Object result = method.invoke(target, args);
System.out.println("after...");
return result; // 让代理也返回目标方法执行的结果
});
fooProxy.foo();
}
}
interface Foo {
void foo();
}
@Slf4j
final class Target implements Foo {
public void foo() {
log.debug("target foo");
}
}
运行结果
jdk
动态代理总结:
- 代理对象和目标对象是兄弟关系,都实现了
Foo
接口,代理对象类型不能强转成目标对象类型; - 目标类定义的时候可以加
final
修饰。
p35 034-第十一讲-aop之proxy增强-cglib
public class AopCglibProxyTest {
@Test
public void testCglibProxy1() {
// 目标对象
Target target = new Target();
Foo fooProxy = (Foo) Enhancer.create(Target.class, (MethodInterceptor) (obj, method, args, proxy) -> {
System.out.println("before...");
Object result = method.invoke(target, args); // 用方法反射调用目标
System.out.println("after...");
return result;
});
System.out.println(fooProxy.getClass());
fooProxy.foo();
}
@Test
public void testCglibProxy2() {
// 目标对象
Target target = new Target();
Foo fooProxy = (Foo) Enhancer.create(Target.class, (MethodInterceptor) (obj, method, args, proxy) -> {
System.out.println("before...");
// proxy 它可以避免反射调用
Object result = proxy.invoke(target, args); // 需要传目标类
System.out.println("after...");
return result;
});
System.out.println(fooProxy.getClass());
fooProxy.foo();
}
@Test
public void testCglibProxy3() {
// 目标对象
Foo fooProxy = (Foo) Enhancer.create(Target.class, (MethodInterceptor) (obj, method, args, proxy) -> {
System.out.println("before...");
// proxy 它可以避免反射调用
Object result = proxy.invokeSuper(obj, args); // 不需要目标类,需要代理自己
System.out.println("after...");
return result;
});
System.out.println(fooProxy.getClass());
fooProxy.foo();
}
}
interface Foo {
void foo();
}
@Slf4j
class Target implements Foo {
public void foo() {
log.debug("target foo");
}
}
运行结果
cglib
动态代理总结:
-
MethodInterceptor
的intercept()
方法的第2个参数是method
,可以通过反射对目标方法进行调用Object result = method.invoke(target, args); // 用方法反射调用目标
-
第4个参数
proxy
,可以不用反射就能对目标方法进行调用;Object result = proxy.invoke(target, args); // 需要传目标类 (spring用的是这种) // 或者 Object result = proxy.invokeSuper(obj, args); // 不需要目标类,需要代理自己
-
代理类不需要实现接口;
-
代理对象和目标对象是父子关系,代理类继承于目标类;
-
目标类定义的时候不能加
final
修饰,否则代理类就无法继承目标类了,会报java.lang.IllegalArgumentException: Cannot subclass final class top.jacktgq.proxy.cglib.Target
异常; -
目标类方法定义的时候不能加
final
修饰,否则代理类继承目标类以后就不能重写目标类的方法了。
第十二讲 jdk代理原理
spring_12_aop_proxy_jdk_cglib_principle
为了更好地探究jdk
动态代理原理,先用代码显式地模拟一下这个过程。
先定义一个Foo
接口,里面有一个foo()
方法,再定义一个Target
类来实现这个接口,代码如下所示:
public interface Foo {
void foo();
}
@Slf4j
public final class Target implements Foo {
public void foo() {
log.debug("target foo");
}
}
public class $Proxy0 implements Foo {
@Override
public void foo() {
// 1. 功能增强
System.out.println("before...");
// 2. 调用目标
new Target().foo();
}
}
public class Main {
public static void main(String[] args) {
Foo proxy = new $Proxy0();
proxy.foo();
}
}
接下来对Target
类中的foo()
方法进行增强
-
首先想到的是,再定义一个类也同样地实现一下
Foo
接口,然后在foo()
方法中编写增强代码,接着再new
一个Target
对象,调用它的foo()
方法,代码如下所示:public class $Proxy0 implements Foo { @Override public void foo() { // 1. 功能增强 System.out.println("before..."); // 2. 调用目标 new Target().foo(); } } // 测试运行 public class Main { public static void main(String[] args) { Foo proxy = new $Proxy0(); proxy.foo(); } }
-
上面的代码把功能增强的代码和调用目标的代码都固定在了代理类的内部,不太灵活。因此可以通过定义一个
InvocationHandler
接口的方式来将这部分代码解耦出来,代码如下:public interface InvocationHandler { void invoke(); } public interface Foo { void foo(); } @Slf4j public final class Target implements Foo { public void foo() { System.out.println("target foo"); } } public class $Proxy0 implements Foo { private InvocationHandler h; public $Proxy0(InvocationHandler h) { this.h = h; } @Override public void foo() { h.invoke(); } } public class Main { public static void main(String[] args) { Foo proxy = new $Proxy0(new InvocationHandler() { @Override public void invoke() { // 1. 功能增强 System.out.println("before..."); // 2. 调用目标 new Target().foo(); } }); proxy.foo(); } }
-
第2个版本的代码虽然将功能增强的代码和调用目标的代码通过接口的方式独立出来了,但还是有问题,如果此时接口中新增了一个方法
bar()
,Target
类和$Proxy0
类中都要实现bar()
方法,那么调用proxy
的foo()
和bar()
方法都将间接调用目标对象的foo()
方法,因为在InvocationHandler
的invoke()
方法中调用的是target.foo()
方法,代码如下:public interface InvocationHandler { void invoke(); } public interface Foo { void foo(); void bar(); } @Slf4j public final class Target implements Foo { public void foo() { System.out.println("target foo"); } @Override public void bar() { log.debug("target bar"); } } public class $Proxy0 implements Foo { private InvocationHandler h; public $Proxy0(InvocationHandler h) { this.h = h; } @Override public void foo() { h.invoke(); } @Override public void bar() { h.invoke(); } } public class Main { public static void main(String[] args) { Foo proxy = new $Proxy0(new InvocationHandler() { @Override public void invoke() { // 1. 功能增强 System.out.println("before..."); // 2. 调用目标 new Target().foo(); } }); proxy.foo(); proxy.bar(); } }
改进方法是,代理类中调用方法的时候,通过反射把接口中对应的方法
Method
对象作为参数传给InvocationHandler
,代码如下:public interface InvocationHandler { void invoke(Method method, Object[] args) throws Throwable; } public interface Foo { void foo(); void bar(); } public final class Target implements Foo { public void foo() { System.out.println("target foo"); } @Override public void bar() { System.out.println("target bar"); } } public class $Proxy0 implements Foo { private InvocationHandler h; public $Proxy0(InvocationHandler h) { this.h = h; } @Override public void foo() { try { Method foo = Foo.class.getDeclaredMethod("foo"); h.invoke(foo, new Object[0]); } catch (Throwable e) { e.printStackTrace(); } } @Override public void bar() { try { Method bar = Foo.class.getDeclaredMethod("bar"); h.invoke(bar, new Object[0]); } catch (Throwable e) { e.printStackTrace(); } } } public class Main { public static void main(String[] args) { Foo proxy = new $Proxy0(new InvocationHandler() { @Override public void invoke(Method method, Object[] args) throws InvocationTargetException, IllegalAccessException { // 1. 功能增强 System.out.println("before..."); // 2. 调用目标 method.invoke(new Target(), args); } }); proxy.foo(); proxy.bar(); } }
-
第3个版本的代码其实已经离jdk动态代理生成的代码很相近了,为了更好地学习底层,更近一步,修改
Foo
接口的中bar()
方法,使其具有int
类型的返回值,因此InvocationHandler
的invoke()
方法也得有返回值,同时将代理对象本身作为第一个参数,具体代码如下:public interface InvocationHandler { Object invoke(Object proxy, Method method, Object[] args) throws Throwable; } public interface Foo { void foo(); int bar(); } public final class Target implements Foo { public void foo() { System.out.println("target foo"); } @Override public int bar() { System.out.println("target bar"); return 1; } } public class $Proxy0 implements Foo { static Method foo; static Method bar; static { try { foo = Foo.class.getDeclaredMethod("foo"); bar = Foo.class.getDeclaredMethod("bar"); } catch (NoSuchMethodException e) { throw new NoSuchMethodError(e.getMessage()); } } private InvocationHandler h; public $Proxy0(InvocationHandler h) { this.h = h; } @Override public void foo() { try { h.invoke(this, foo, new Object[0]); } catch (RuntimeException | Error e) { throw e; } catch (Throwable e) { throw new UndeclaredThrowableException(e); } } @Override public int bar() { try { return (int) h.invoke(this, bar, new Object[0]); } catch (RuntimeException | Error e) { throw e; } catch (Throwable e) { throw new UndeclaredThrowableException(e); } } } public class Main { public static void main(String[] args) { Foo proxy = new $Proxy0(new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException { // 1. 功能增强 System.out.println("before..."); // 2. 调用目标 return method.invoke(new Target(), args); } }); proxy.foo(); System.out.println("bar()方法返回值:" + proxy.bar()); } }
-
到这里跟jdk的动态代理只有些微差距了,
jdk
的动态代码会让代理类再继承一个Proxy
类,里面定义了一个InvocationHandler
接口的对象,代理类中会通过super(h)
调用父类Proxy的构造,这里建议结合视频教程理解。
p42 041-第十三讲-cglib代理原理-MethodProxy
p51 050-第十七讲-findEligibleAdvisors
p64 063-第廿讲-DispatcherServlet初始化时机
p65 064-第廿讲-DispatcherServlet初始化时机
p66 065-第廿讲-DispatcherServlet初始化执行的操作
p67 066-第廿讲-RequestMappingHandlerMapping
p68 067-第廿讲-RequestMappingHandlerAdapter
p69 068-第廿讲-RequestMappingHandlerAdapter-参数和返回值解析器
p70 069-第廿讲-RequestMappingHandlerAdapter-自定义参数解析器
p71 070-第廿讲-RequestMappingHandlerAdapter-自定义返回值解析器
p74 073-第廿一讲-参数解析器-@RequestParam 0-4
p85 084-第廿三讲-绑定器工厂-@InitBinder扩展
p86 085-第廿三讲-绑定器工厂-ConversionService扩展
p87 086-第廿三讲-绑定器工厂-默认ConversionService
p89 088-第廿四讲-@ControllerAdvice-@InitBinder
p90 089-第廿四讲-@ControllerAdvice-@InitBinder
p94 093-第廿六讲-@ControllerAdvice-@ModelAttribute
p100 099-第廿八讲-MessageConverter
p101 100-第廿九讲-@ControllerAdvice-ResponseBodyAdvice
p102 101-第廿九讲-@ControllerAdvice-ResponseBodyAdvice
p105 104-第卅一讲-@ControllerAdvice-@ExceptionHandler
p107 106-第卅二讲-tomcat异常处理-自定义错误地址
p108 107-第卅二讲-tomcat异常处理-BasicErrorController
p109 108-第卅二讲-tomcat异常处理-BasicErrorController
p110 109-第卅三讲-HandlerMapping与HandlerAdapter-1
p111 110-第卅三讲-HandlerMapping与HandlerAdapter-自定义
p112 111-第卅四讲-HandlerMapping与HandlerAdapter-2
p113 112-第卅五讲-HandlerMapping与HandlerAdapter-3
p114 113-第卅五讲-HandlerMapping与HandlerAdapter-3-优化
p115 114-第卅五讲-HandlerMapping与HandlerAdapter-3-优化
p116 115-第卅五讲-HandlerMapping与HandlerAdapter-4-欢迎页
p117 116-第卅五讲-HandlerMapping与HandlerAdapter-总结
p122 121-第卅八讲-构建boot war项目-用外置tomcat测试
p123 122-第卅八讲-构建boot war项目-用内嵌tomcat测试
p131 130-第卅九讲-boot执行流程-run-8-11
p132 131-第卅九讲-boot执行流程-run-2,12
p142 141-第卌讲-内嵌Tomcat与Spring整合
p145 144-第卌一讲-AopAutoConfiguration
p146 145-第卌一讲-AopAutoConfiguration
p148 147-第卌一讲-自动配置类2-DataSource
p162 161-第卌七讲-@Autowired注入底层-doResolveDependency外1
p163 162-第卌七讲-@Autowired注入底层-doResolveDependency外2
p164 163-第卌七讲-@Autowired注入底层-doResolveDependency内1
p165 164-第卌七讲-@Autowired注入底层-doResolveDependency内2
p166 165-第卌七讲-@Autowired注入底层-doResolveDependency内3