推荐基于Lombok的Spring注入方式（基于构造器注入）及快速获取Spring容器中管理的对象

最新推荐文章于 2024-07-25 10:49:03 发布

Duktig丶

最新推荐文章于 2024-07-25 10:49:03 发布

阅读量4.1k

点赞数 4

分类专栏： springboot 文章标签： Sping注入 Lombok的spring注入快速获取Spring的对象 Spring注入对比

本文链接：https://blog.csdn.net/qq_42937522/article/details/110791736

版权

springboot 专栏收录该内容

20 篇文章 3 订阅

订阅专栏

背景

Java的一大特性是封装，我们经常在实际开发中会封装工具类，甚至是慢慢积累自己的通用工具类，然后用于之后的项目开发。

我们在封装工具类的时候，常常会将工具方法设置为static，方便我们使用类名.方法名快速调用。但有些时候，工具方法封装为static会出现问题，最常见的空指针异常（稍后举例）。所以我们不能那样封装。

如果使用普通方法，正常情况下我们想要去调用的话，就要先实例化类的对象，然后使用对象.方法名去调用方法。这样的话会引发一些问题。

每次都要实例化对象，然后调用，在代码层面上不够简洁
如果方法使用的比较频繁，会实例化很多的对象，影响整个系统的效率

解决上述的问题，我们可能会想到单例模式来解决。手写单例模式是比较麻烦的，Spring的IOC容器管理对象，正是用到了单例模式的思想，可以将我们的对象交由Spring来管理。

源码

出自于我和小伙伴们搭建的开源框架：SMPE-ADMIN
参考地址：https://github.com/shiwei-Ren/smpe-admin/blob/main/smpe-common/src/main/java/marchsoft/utils/SpringContextHolder.java

Spring注入方式对比

Spring Bean 的注入方式一般分为三种：

构造器注入
Setter注入
基于注解的 @Autowired 自动装配（Field 注入）

Spring官方推荐使用构造器注入。在IDEA中使用@Autowired注入时会进行提示：

Field injection is not recommended.
Inspection info: Spring Team recommends: “Always use constructor based dependency injection in your beans. Always use assertions for mandatory dependencies”

自动装配（Field 注入）

使用方法

该种注入方式是使用开发中最常见的注入方式。

@RestController
@RequestMapping("/api/users")
public class UserController {

	@Autowired
	private IUserService userService;

}

优点

注入方式简单，只需要使用 @Autowired注解或者 @Resource 注解
整体代码简洁明了
新增依赖十分方便，不需要修改原有代码

缺点

容易出现空指针异常，Field 注入允许构建对象实例的时候依赖的示例对象为空。对于IOC容器以外的环境，除了使用反射来提供它需要的依赖之外，无法复用该实现类。而且将一直是个潜在的隐患，因为你不调用将一直无法发现NullPointException的存在
对单元测试不友好，如果使用 Field 注入，那么进行单元测试就需要初始化整个Spring 环境，将所有 Bean 实例化
会出现循环依赖的隐患

public class A {
    @Autowired
    private B b;
}

public class B {
    @Autowired
    private A a;
}

容易破坏单一职责原则

构造器注入

在Spring4.x版本中推荐的注入方式就是这种

The Spring team generally advocates constructor injection as it enables one to implement application components as immutable objects and to ensure that required dependencies are not null. Furthermore constructor-injected components are always returned to client (calling) code in a fully initialized state.

简单的翻译一下：这个构造器注入的方式啊，能够保证注入的组件不可变，并且确保需要的依赖不为空。此外，构造器注入的依赖总是能够在返回客户端（组件）代码的时候保证完全初始化的状态。

使用方法

@RestController
@RequestMapping("/api/users")
public class UserController {

	private final IUserService userService;
    private final IDeptService deptService;
    private final IRoleService roleService;
    private final UserCacheClean userCacheClean;

	public UserController(IUserService userService, IDeptService deptService,
                          IRoleService roleService, UserCacheClean userCacheClean) {
        this.userService = userService;
        this.deptService = deptService;
        this.roleService = roleService;
        this.userCacheClean = userCacheClean;
    }

}

优点

依赖不可变 components as immutable objects ，即注入对象为final
依赖不可为空required dependencies are not null，省去对注入参数的检查。当要实例化FooController的时候，由于只有带参数的构造函数，spring注入时需要传入所需的参数，所以有两种情况：1) 有该类型的参数传入 => ok; 2) 无该类型参数传入，报错
提升了代码的可复用性：非IOC容器环境可使用new实例化该类的对象。
避免循环依赖：如果使用构造器注入，在spring项目启动的时候，就会抛出：BeanCurrentlyInCreationException：Requested bean is currently in creation: Is there an unresolvable circular reference？从而提醒你避免循环依赖，如果是field注入的话，启动的时候不会报错，在使用那个bean的时候才会报错。
保证返回客户端（调用）的代码的时候是完全初始化的状态

缺点

当注入参数较多时，代码臃肿，降低了可读性。（可参看上文代码，可能开发中需要注入更多的类）

setter注入

在Spring3.x刚推出的时候，推荐使用注入的就是这种：

The Spring team generally advocates setter injection, because large numbers of constructor arguments can get unwieldy, especially when properties are optional. Setter methods also make objects of that class amenable to reconfiguration or re-injection later. Management through JMX MBeans is a compelling use case.

Some purists favor constructor-based injection. Supplying all object dependencies means that the object is always returned to client (calling) code in a totally initialized state. The disadvantage is that the object becomes less amenable to reconfiguration and re-injection.

简单翻译：构造器注入参数太多了，显得很笨重，另外setter的方式能用让类在之后重新配置或者重新注入。

使用方法

@RestController
@RequestMapping("/api/users")
public class UserController {

	private IUserService userService;
	
	@Autowired
    public void setUserService(IUserService userService) {
        this.userService = userService;
    }
    
}

优点

相比构造器注入，当注入参数太多或存在非必须注入的参数时，不会显得太笨重
允许在类构造完成后重新注入

缺点

产生了大量的set方法

快速获取Spring容器中管理的对象

上述文章说明了该怎么选用Spring的注入方式。但很多情况下，我们也并不想使用使用注入的方式，可能这个对象我也就在本类的一个方法中使用。

不采用注入的方式，如何可以快速地获取容器的对象？

封装方法：

/**
 * 通过SpringContextHolder获取bean对象的工具类
 * <p>
 * 需要将SpringContextHolder注入到bean容器中，所以加@Configuration注解
 *
 */
@Slf4j
@Configuration
public class SpringContextHolder implements ApplicationContextAware, DisposableBean {

    private static ApplicationContext applicationContext = null;

    /**
     * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) {
        assertContextInjected();
        return (T) applicationContext.getBean(name);
    }

    /**
     * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
     */
    public static <T> T getBean(Class<T> requiredType) {
        assertContextInjected();
        return applicationContext.getBean(requiredType);
    }

    /**
     * 检查ApplicationContext不为空.
     */
    private static void assertContextInjected() {
        if (applicationContext == null) {
            throw new IllegalStateException("applicaitonContext属性未注入, 请在applicationContext" +
                    ".xml中定义SpringContextHolder或在SpringBoot启动类中注册SpringContextHolder.");
        }
    }

    /**
     * 清除SpringContextHolder中的ApplicationContext为Null.
     */
    private static void clearHolder() {
        log.debug("清除SpringContextHolder中的ApplicationContext:"
                + applicationContext);
        applicationContext = null;
    }

    @Override
    public void destroy() {
        SpringContextHolder.clearHolder();
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (SpringContextHolder.applicationContext != null) {
            log.warn("SpringContextHolder中的ApplicationContext被覆盖, 原有ApplicationContext为:" + SpringContextHolder.applicationContext);
        }
        SpringContextHolder.applicationContext = applicationContext;
    }
}

使用示例

封装自定义的工具类TicketUtil，使用@Component注入到Spring的Bean容器中。

/**
 * description:Ticket工具类
 *
 * @author RenShiWei
 * Date: 2020/12/4 21:07
 **/
@Component
public class TicketUtil {

    @Value("${ticket.header}")
    private String ticketHead;

    @Value("${ticket.start-with}")
    private String ticketStartWith;

    /**
     * description:从请求中获取ticket
     *
     * @param request /
     * @return ticket
     */
    public String getTicket(HttpServletRequest request) {
        return request.getHeader(ticketHead);
    }

    /**
     * description: 判断ticket是否正确
     *
     * @param request 请求
     * @return token
     */
    public boolean isTicketAllow(HttpServletRequest request) {
        RedisUtils redisUtils = SpringContextHolder.getBean(RedisUtils.class);
        final String requestTicket = getTicket(request);
        if (requestTicket != null && requestTicket.startsWith(ticketStartWith)) {
            return redisUtils.hasKey(requestTicket);
        }
        return false;
    }
    
}

分析

因为需要从请求头中拿出ticket信息，所以方法不能封装成stattic，否则HttpServletRequest为null，不能接收到。

又为了方便使用、管理，就像前文说的将工具类对象交由Spring管理，使用@Component将TicketUtil注入到Spring容器中。

使用

@ApiOperation(value = "根据ticket获取当前用户信息", notes = "获取ticket \n author：RenShiWei 2020/12/3")
@PostMapping("/user")
public Void getUserByTicket(HttpServletRequest request) {
    TicketUtil ticketUtil = SpringContextHolder.getBean(TicketUtil.class);
    ticketUtil.getTicket(request);
}