覆盖重写jar中SpringBean的⼏种⽅式
⽅法1 直接在⾃⼰⼯程中建同包同类名的类进⾏替换
⽅法2 采⽤@Primary注解
⽅法3 排除需要替换的jar包中的类
⽅法4 @Bean 覆盖
⽅法5 使⽤BeanDefinitionRegistryPostProcessor
场景
什么情况下要覆写原有的Spring Bean ？例如引⼊的第三⽅jar包中的某个类有些问题，然有没有源码提供或者嫌编译源码太费事，这个时间可以考虑覆写原有的类。
⽅法1 直接在⾃⼰⼯程中建同包同类名的类进⾏替换
⽅式简单粗暴，可以直接覆盖掉jar包中的类，spring项⽬会优先加载⾃定义的类。
下⾯是覆盖 flowable框架中的⼀个类 FlowableCookieFilter，主要是想修改它⾥⾯的redirectToLogin⽅法的业务逻辑。包路径为 org.flowable.uimon.filter，直接⼯程⾥⾯新建⼀样路径⼀样类名FlowableCookieFilter即可。
⽅法2 采⽤@Primary注解
该⽅法适⽤于接⼝实现类，⾃⼰创建⼀个原jar包接⼝的实现类，然后类上加上@Primary注解，spring则默认加载该类实例化出的Bean。
下⾯的例⼦：⼀个接⼝ RemoteIdmService，原先jar包中只有⼀个实现类 RemoteIdmServiceImpl，现在⾃⼰⼯程⾥⾯创建⼀个 CustomRemoteIdmServiceImpl 继承RemoteIdmService接⼝，然后发现所有调⽤RemoteIdmService接⼝⾥⾯的⽅法实际调⽤⾛的是CustomRemoteIdmServiceImpl ⾥⾯的⽅法。
⽅法3 排除需要替换的jar包中的类
使⽤ @ComponentScan ⾥⾯的 excludeFilters 功能排除调⽤要替换的类，然后⾃⼰写个类继承替换的类即可。
下⾯的例⼦是替换掉 jar包中的PersistentTokenServiceImpl类
@SpringBootApplication
@ComponentScan(excludeFilters = {@ComponentScan.Filter(type =
spring ioc注解FilterType.ASSIGNABLE_TYPE, classes = {PersistentTokenServiceImpl.class})})
public class Application {
public static void main(String[] args) {
new SpringApplication(Test.class).run(args);
}
}
@Service
public class MyPersistentTokenServiceImpl extends PersistentTokenServiceImpl{
@Override
public Token saveAndFlush(Token token) {
// 覆写该⽅法的业务逻辑
tokenCache.Id(), token);
idmIdentityService.saveToken(token);
return token;
}
@Override
public void delete(Token token) {
// 覆写该⽅法的业务逻辑
tokenCache.Id());
idmIdentityService.Id());
}
@Override
public Token getPersistentToken(String tokenId) {
// 覆写该⽅法的业务逻辑
return getPersistentToken(tokenId, false);
}
}
⽅法4 @Bean 覆盖
该场景针对，框架jar包中有@ConditionalOnMissingBean注解，这种注解是说明如果你也创建了⼀个⼀样的Bean则框架就不⾃⼰再次创建这个bean了，这样你可以覆写⾃⼰的bean。
原jar包中的配置类：
直接继承要覆盖的类，⾃⼰重写⾥⾯⽅法，使⽤@Component注⼊到spring中去
⽅法5 使⽤BeanDefinitionRegistryPostProcessor BeanDefinitionRegistryPostProcessor 说⽩了就是可以在初始化Bean之前修改Bean的属性，甚⾄替换原先准备要实例化的bean。实战演⽰：
假设jar包中有⼀个类 MyTestService，正常情况下它会被spring⾃动扫描到注⼊IOC容器中去。
package st.ister.jar;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
/**
* @author guzt
*/
@Service("myTestService")
public class MyTestService {
private String name1;
private String name2;
private String name3;
public MyTestService() {
this.name1 = "";
this.name2 = "";
this.name3 = "";
public MyTestService(String name1, String name2, String name3) {
this.name1 = name1;
this.name2 = name2;
this.name3 = name3;
}
@PostConstruct
public void init() {
System.out.println("MyTestService init");
}
@PreDestroy
public void destory() {
System.out.println("MyTestService destroy");
}
public void show() {
System.out.println("------------------------");
System.out.println("我是jar中通过注解@Service主动加⼊Spring的IOC⾥⾯的");
System.out.println("------------------------");
}
public String getName1() {
return name1;
}
public void setName1(String name1) {
this.name1 = name1;
}
public String getName2() {
return name2;
}
public void setName2(String name2) {
this.name2 = name2;
}
public String getName3() {
return name3;
}
public void setName3(String name3) {
this.name3 = name3;
}
}
⾃⼰⼯程中继承该类，并且覆写⾥⾯的show中的⽅法
package st.ister;
import st.ister.jar.MyTestService;
/**
* @author guzt
*/
public class MyTestServiceIpml extends MyTestService {
public MyTestServiceIpml() {
}
public MyTestServiceIpml(String name1, String name2, String name3) {
super(name1, name2, name3);
}
@Override
public void show() {
System.out.println("------------------------");
System.out.println("我是被BeanDefinitionRegistry⼿动注册到Spring的IOC⾥⾯的");
System.out.println("------------------------");
}
}
然后实现 BeanDefinitionRegistryPostProcessor 接⼝，修改原来bean定义，主要查看postProcessBeanDefinitionRegistry⽅法的实现，先清空原bean定义，注册我们⾃⼰的bean定义来达到替换的⽬的。
package st.ister;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.fig.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
/**
* @author amdin
*/
@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
private Logger logger = Class());
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
logger.info("bean 定义查看和修改...");
String beanName = "myTestService";
// 先移除原来的bean定义
// 注册我们⾃⼰的bean定义
BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinition(MyTestServiceIpml.class);
// 如果有构造函数参数, 有⼏个构造函数的参数就设置⼏个没有就不⽤设置
beanDefinitionBuilder.addConstructorArgValue("构造参数1");
beanDefinitionBuilder.addConstructorArgValue("构造参数2");
beanDefinitionBuilder.addConstructorArgValue("构造参数3");
// 设置 init⽅法没有就不⽤设置
beanDefinitionBuilder.setInitMethodName("init");
// 设置 destory⽅法没有就不⽤设置
beanDefinitionBuilder.setDestroyMethodName("destory");
// 将Bean 的定义注册到Spring环境
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
// bean的名字为key, bean的实例为value
Map<String, Object> beanMap = BeansWithAnnotation(RestController.class);
logger.info("所有 RestController 的bean {}", beanMap);
}
}
写⼀个业务类BusinessTestService测试⼀下，期望结果：所有⽤到 MyTestService的地⽅实际调⽤的变成了MyTestServiceIpml⾥⾯的⽅法。
package st.ister;
import st.ister.jar.MyTestService;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
/**
* @author guzt
*/
@Service
public class BusinessTestService {
@Resource
private MyTestService myTestService;
@PostConstruct
public void init() {
System.out.Name1());
System.out.Name2());
System.out.Name3());
// 看看到底是哪⼀个Bean
myTestService.show();
}
}
控制台打印如下：
可以发现，和我们期望的结果的⼀样：所有⽤到 MyTestService的地⽅实际调⽤的变成了MyTestServiceIpml⾥⾯的⽅法！
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论