一、beanpostprocessor
beanpostprocessor 接口是 spring 提供的众多接口之一，他的作用主要是如果需要在spring 容器完成 bean 的实例化、配置和其他的初始化前后添加一些自己的逻辑处理，可以通过实现 beanpostprocessor 来完成。
public interface beanpostprocessor {
@nullable
default object postprocessbeforeinitialization(object bean, string beanname) throws beansexception {
// bean初始化方法调用前被调用
return bean;
}
@nullable
default object postprocessafterinitialization(object bean, string beanname) throws beansexception {
// bean初始化方法调用后被调用
return bean;
}
}
运行顺序：
----------------spring ioc容器实例化bean ----------------调用beanpostprocessor的postprocessbeforeinitialization方法 ----------------调用bean实例的初始化方法 ----------------调用beanpostprocessor的postprocessafterinitialization方法
二、beanfactorypostprocessor
beanfactorypostprocessor 接口与 beanpostprocessor 接口类似，可以对bean的定义(配置元数据)进行处理；也就是spring ioc运行beanfactorypostprocessor 在容器实例化任何其他的bean之前读取配置元数据，并有可能修改它；
如果业务需要，可以配置多个beanfactorypostprocessor 的实现类，通过 ”order” 控制执行次序(要实现 ordered 接口)。
@component
public class mybeanfactorypostprocessor implements beanfactorypostprocessor {
public mybeanfactorypostprocessor() {
system.out.println("----------------execute mybeanfactorypostprocessor constructor");
}
@override
public void postprocessbeanfactory(configurablelistablebeanfactory configurablelistablebeanfactory) throws beansexception {
system.out.println("----------------execute mybeanfactorypostprocessor postprocessbeanfactory");
}
}
打印输出：
—————-execute mybeanfactorypostprocessor constructor
—————-execute mybeanfactorypostprocessor postprocessbeanfactory
postprocessbeanfactory 方法在构造函数方法之后执行。
三、initialingbean和disposablebean
initializingbean 接口为bean提供了初始化方法的方式，它只包括afterpropertiesset 方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。
public interface initializingbean {
void afterpropertiesset() throws exception;
}
disposablebean 也是一个接口，提供了一个唯一的方法destory()，凡是继承该接口的类，在bean生命周期结束前都会执行该方法。
public interface disposablebean {
void destroy() throws exception;
}
这里借用网上的一张bean生命周期的过程图片：
四、factorybean
factorybean 是一个接口，当在 ioc 容器中的 bean 实现了 factorybean 后，通过 getbean(string beanname) 获取到的bean对象并不是 factorybean 的实现类对象，而是这个实现类中的 getobject() 方法返回的对象。
public interface factorybean<t> {
// 获取类对象
@nullable
t getobject() throws exception;
// 获取类类型
@nullable
class<?> getobjecttype();
// 是否单例
default boolean issingleton() {
return true;
}
}
五、beandefinitionregistrypostprocessor
beandefinitionregistrypostprocessor 可以完成新的 beandefinition 注册，对已有 beandefinition 进行修改等操作。
public interface beandefinitionregistrypostprocessor extends beanfactorypostprocessor {
/**
* 在spring的标准初始化完成之后，此时所有的符合 spring 规则的beandefinition已经全部完成加载，但是还没有任何一个 bean 被初始化，
* spring允许在下一个post-processing开始处理之前通过此接口添加更多的beandefinition
*/
void postprocessbeandefinitionregistry(beandefinitionregistry registry) throws beansexception;
}
写一个类实现 beandefinitionregistrypostprocessor 往容器中手动注册一个beandefinition。
@component
public class mybeandefinitionregistrypostprocessor implements beandefinitionregistrypostprocessor {
@override
public void postprocessbeandefinitionregistry(beandefinitionregistry beandefinitionregistry) throws beansexception {
// 创建一个bean的定义类的对象
rootbeandefinition rootbeandefinition = new rootbeandefinition(mymapperfactorybean.class);
// 将bean 的定义注册到spring环境
beandefinitionregistry.registerbeandefinition("mymapperfactorybean", rootbeandefinition);
}
@override
public void postprocessbeanfactory(configurablelistablebeanfactory beanfactory) throws beansexception {// bean的名字为key, bean的实例为value
}
}
mymapperfactorybean ：
public class mymapperfactorybean implements factorybean {
@override
public object getobject() throws exception {
// 创建一个代理对象
return proxy.newproxyinstance(this.getclass().getclassloader(), new class[]{testbeandefregpostpromapper.class},
new invocationhandler() {
@override
public object invoke(object proxy, method method, object[] args) throws throwable {
system.out.println("----------execute：" + method.getname());
class<?> returntype = method.getreturntype();
return "xxxxxxxxxxxx";
}
});
}
@override
public class<?> getobjecttype() {
return testbeandefregpostpromapper.class;
}
}
testbeandefregpostpromapper 接口：
public interface testbeandefregpostpromapper {
string exexute();
}
测试：
@springbootapplication
public class springbootapplication implements commandlinerunner {
@autowired
private testbeandefregpostpromapper testbeandefregpostpromapper;
public static void main(string[] args) {
springapplication.run(springbootapplication.class, args);
}
@override
public void run(string... args) throws exception {
system.out.println(testbeandefregpostpromapper.exexute());
}
}
测试结果：
———-execute：exexute
xxxxxxxxxxxx
最经典的案例就是mybatis与spring集成中的 mapperscannerconfigurer 和 mapperfactorybean
mapperscannerconfigurer ：
public class mapperscannerconfigurer implements beandefinitionregistrypostprocessor, initializingbean, applicationcontextaware, beannameaware {
@override
public void postprocessbeandefinitionregistry(beandefinitionregistry registry) {
if (this.processpropertyplaceholders) {
processpropertyplaceholders();
}
classpathmapperscanner scanner = new classpathmapperscanner(registry);
scanner.setaddtoconfig(this.addtoconfig);
scanner.setannotationclass(this.annotationclass);
scanner.setmarkerinterface(this.markerinterface);
scanner.setsqlsessionfactory(this.sqlsessionfactory);
scanner.setsqlsessiontemplate(this.sqlsessiontemplate);
scanner.setsqlsessionfactorybeanname(this.sqlsessionfactorybeanname);
scanner.setsqlsessiontemplatebeanname(this.sqlsessiontemplatebeanname);
scanner.setresourceloader(this.applicationcontext);
scanner.setbeannamegenerator(this.namegenerator);
scanner.registerfilters();
// 扫描mybatis配置mapperscan包，进行注册，将每一个mapper接口都注册为一个mapperfactorybean对象
scanner.scan(stringutils.tokenizetostringarray(this.basepackage, configurableapplicationcontext.config_location_delimiters));
}
}
mapperfactorybean：
public class mapperfactorybean<t> extends sqlsessiondaosupport implements factorybean<t> {
@override
public t getobject() throws exception {
// 返回一个代理对象，用于执行sql
return getsqlsession().getmapper(this.mapperinterface);
}
}
六、beannameaware、applicationcontextaware 和 beanfactoryaware
1、实现 beannameaware 接口的 bean，在 bean 加载的过程中可以获取到该 bean 的 id。
public interface beannameaware extends aware {
void setbeanname(string beanname);
}
2、实现 applicationcontextaware 接口的 bean，在 bean 加载的过程中可以获取到 spring的applicationcontext，applicationcontext 是 spring 应用上下文，从 applicationcontext 中可以获取包括任意的 bean 在内的大量 spring 容器内容和信息。
public interface applicationcontextaware extends aware {
void setapplicationcontext(applicationcontext applicationcontext) throws beansexception;
}
3、实现 beanfactoryaware 接口的 bean，在 bean 加载的过程中可以获取到加载该 bean的beanfactory。
public interface beanfactoryaware extends aware {
void setbeanfactory(beanfactory beanfactory) throws beansexception;
}
到此这篇关于spring扩展接口知识总结的文章就介绍到这了,更多相关spring扩展接口内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！
