Spring进阶（一）SpringBoot替换上下文中的Bean

最新推荐文章于 2024-05-31 11:42:01 发布

iRich_全栈

最新推荐文章于 2024-05-31 11:42:01 发布

阅读量1.1w

点赞数 2

分类专栏： SpringCloud SpringBoot学习笔记文章标签： spring cglib

本文链接：https://blog.csdn.net/weixin_37910453/article/details/90081929

版权

SpringBoot学习笔记同时被 2 个专栏收录

6 篇文章 3 订阅

订阅专栏

SpringCloud

1 篇文章 0 订阅

订阅专栏

文章目录

业务场景
- - 一、使用AOP为使用到方法添加自定义注解
  - 二、在系统启动时直接替换
实现方式
- 思路
具体代码

业务场景

已经写好业务入库的代码，现在要在数据库添加了一个公共字段，需要所有在业务处理的时候为实体类为这个字段赋值。

我们的业务场景：

所有的实体类都继承一个BasicBean
业务类都是通过Spring进行管理的

解决方案有多种，现在列举两种：

一、使用AOP为使用到方法添加自定义注解

这种对代码的侵入性大，需要业务方配合，再说了这样做需要业务代码人员配合

二、在系统启动时直接替换

使用SpringBoot的启动事件监听机制，通过修改注册的Bean，这样业务方可以无感知的实用

实现方式

这里简化了实现的业务，提供一个简单demo，在方法执行前执行一段代码（不是通过判断参数是否时BasicBean来做了）

思路

在这里插入图片描述

监听器创建
通过实现接口ApplicationListener来创建监听器

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.core.Ordered;

import java.util.Map;

public class DemoApplicationListener implements ApplicationListener<ApplicationEvent>, Ordered {

    /**
     * The default order for the LoggingApplicationListener.
     */
    public static final int DEFAULT_ORDER = Ordered.HIGHEST_PRECEDENCE + 20;

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ContextRefreshedEvent) {
            System.out.println("==========ContextRefreshedEvent==========");
            //处理逻辑
           test((ContextRefreshedEvent)event);
        }

    }

    @Override
    public int getOrder() {
        return DEFAULT_ORDER;
    }

其中test方法就是具体的处理逻辑实现

指定Bean获取

ConfigurableApplicationContext applicationContext = (ConfigurableApplicationContext)e.getApplicationContext();

Map<String, Object> beansWithAnnotation = applicationContext.getBeansWithAnnotation(DemoAnnotaion.class);

DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory)applicationContext.getBeanFactory();

新对象创建

			Object obj = beansWithAnnotation.get(key);

            System.out.println(beansWithAnnotation.keySet());

            // 创建一个代理类
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(obj.getClass());
            // 设置回调方法
            enhancer.setCallback(new DemoMethodInterceptor());
            
            Object o = enhancer.create();

这里动态代理使用cglib来实现

替换老对象

 			// 消除原先的bean
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(key);

            beanFactory.removeBeanDefinition(key);

            beanDefinition.setBeanClassName(o.getClass().getCanonicalName());

            beanFactory.registerBeanDefinition(key, beanDefinition);

            beanFactory.registerSingleton(key, o);

监听器注册
在resources目录下创建META-INF/spring.factories

spring.factories

# Application Listeners
org.springframework.context.ApplicationListener=\
com.example.demo.frame.DemoApplicationListener

具体代码

目录结构

在这里插入图片描述

DemoAnnotaion

import java.lang.annotation.*;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DemoAnnotaion {
    String[] value();
}

DemoApplicationListener

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.core.Ordered;

import java.util.Map;

public class DemoApplicationListener implements ApplicationListener<ApplicationEvent>, Ordered {

    /**
     * The default order for the LoggingApplicationListener.
     */
    public static final int DEFAULT_ORDER = Ordered.HIGHEST_PRECEDENCE + 20;

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ContextRefreshedEvent) {
            System.out.println("==========ContextRefreshedEvent==========");
           test((ContextRefreshedEvent)event);
        }

    }

    @Override
    public int getOrder() {
        return DEFAULT_ORDER;
    }

    private void test(ContextRefreshedEvent e){
        ConfigurableApplicationContext applicationContext = (ConfigurableApplicationContext)e.getApplicationContext();

        Map<String, Object> beansWithAnnotation = applicationContext.getBeansWithAnnotation(DemoAnnotaion.class);

        DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory)applicationContext.getBeanFactory();

        for(String key : beansWithAnnotation.keySet()) {

            Object obj = beansWithAnnotation.get(key);

            System.out.println(beansWithAnnotation.keySet());

            // 创建一个代理类
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(obj.getClass());
            // 设置回调方法
            enhancer.setCallback(new DemoMethodInterceptor());

            Object o = enhancer.create();

            // 消除原先的bean
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(key);

            beanFactory.removeBeanDefinition(key);

            beanDefinition.setBeanClassName(o.getClass().getCanonicalName());

            beanFactory.registerBeanDefinition(key, beanDefinition);

            beanFactory.registerSingleton(key, o);
        }
    }
}

DemoMethodInterceptor

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;


public class DemoMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("******cglib======");
        Object result = methodProxy.invokeSuper(o, args);
        return result;
    }
}

TestService

import org.springframework.stereotype.Component;

@Component
@DemoAnnotaion("save")
public class TestService {

    public void test(){
        System.out.println("test");
    }

    public void save(){
        System.out.println("save");
    }

}

DemoController

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DemoController {

    @Autowired
    private TestService testService;

    @RequestMapping("/test")
    public Object test(){
        testService.save();
        testService.test();
        return testService.getClass();
    }
}

DemoApplication

import org.springframework.boot.SpringApplication;

public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

不要忘记配置监听器
在resources目录下创建META-INF/spring.factories
在这里插入图片描述

也可以在类上直接加@Component注解，这样有些springBoot的启动事件就没法使用了，例如：ApplicationStartingEvent、ApplicationEnvironmentPreparedEvent、ApplicationPreparedEvent等
spring.factories 可以监听的事件范围更广

启动测试

启动项目直接运行DemoApplication .main

在浏览器上输入http://127.0.0.1:8080/test

返回"com.example.demo.frame.TestService$ $E n h a n c e r B y C G L I B$ xxxxx"

控制台输出
在这里插入图片描述

完成了！！！！！

iRich_全栈

关注

2
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
Spring进阶（一）SpringBoot替换上下文中的Bean

文章目录业务场景一、使用AOP为使用到方法添加自定义注解二、在系统启动时直接替换实现方式思路业务具体代码业务场景已经写好业务入库的代码，现在要在数据库添加了一个公共字段，需要所有在业务处理的时候为实体类为这个字段赋值。我们的业务场景：所有的实体类都继承一个BasicBean业务类都是通过Spring进行管理的解决方案有多种，现在列举两种：一、使用AOP为使用到方法添加自定义注解...
复制链接

扫一扫

专栏目录