Spring注入外部 工厂类Bean

已于 2023-10-23 11:28:01 修改
阅读量217 收藏
点赞数
文章标签： spring java 后端
于 2023-08-24 23:20:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lhg_55/article/details/132484108
版权

问题

对于一些使用建造者模式的 Bean，我们往往不能直接 new 出来，这些 Bean 如果需要注册到 Spring 容器中，我们就需要使用工厂类。

比如我们项目中经常使用的okhttp: 如果我们想把OkHttpClient注册到Spring容器中，该怎么做?

public class App {
    public static void main(String[] args) {
        //通过建造者模式去创建 OkHttpClient 对象
        OkHttpClient client = new OkHttpClient.Builder()
                .connectTimeout(5, TimeUnit.SECONDS)
                .readTimeout(5, TimeUnit.SECONDS)
                .build();
        //构建一个具体的请求
        Request getRequest = new Request.Builder()
                .get()
                .url("https://www.baidu.com")
                .build();
        Call call = client.newCall(getRequest);
        CountDownLatch countDownLatch = new CountDownLatch(1);
        //异步执行网络请求，处理请求结果；如果直接调用call.execute()就是同步，会阻塞
        call.enqueue(new Callback() {
            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                countDownLatch.countDown();
            }
            // 这个就是请求成功的回调函数
            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                countDownLatch.countDown();
                System.out.println("response.body().string() = " + response.body().string());
            }
        });
        //会判断计数器是否为 0，如果为 0，才会继续执行后续的代码，否则就暂停在这里
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

又比如GSON: 这里的Gson对象也不是直接 new 出来的，而是通过一个GsonBuilder对象建造出来的。

public class App {
    public static void main(String[] args) {
       User user = new User();
        user.setName("hogen");
        user.setBirthday(new Date());
        Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
        String toJson = gson.toJson(user);
        System.out.println(toJson);
}

解决方案

方法一 静态工厂

通过一个工厂方法，将 Bean 构建好之后，注入到 Spring 容器中，需要注意的是，这个工厂方法是一个静态方法

// 静态工厂，顾名思义，可以直接通过类名.方法名调用
public class OkHttpClientStaticFactory {
    private static OkHttpClient okHttpClient;

    static {
        okHttpClient = new OkHttpClient.Builder()
                .connectTimeout(5, TimeUnit.SECONDS)
                .readTimeout(5, TimeUnit.SECONDS)
                .build();
    }

    public static OkHttpClient getInstance() {
        return okHttpClient;
    }
}

然后在 XML 文件中配置静态工厂：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context
		https://www.springframework.org/schema/context/spring-context.xsd">

    <bean class="org.example.OkHttpClientStaticFactory" id="okHttpClient" factory-method="getInstance"/>
</beans>

XML 中配置的时候，需要注意，虽然我们看起来向 Spring 容器中注册的是一个静态工厂类的对象，但是实际上，最终会调用对应的方法 factory-method，向 Spring 容器中注册一个 OkHttpClient 对象，而且该对象还是单例的。

public class App {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        OkHttpClient client1 = ctx.getBean("okHttpClient", OkHttpClient.class);
        OkHttpClient client2 = ctx.getBean("okHttpClient", OkHttpClient.class);
        System.out.println("client2 = " + client2);
        System.out.println(client2 == client1);
    }
}

输出：

client2 = okhttp3.OkHttpClient@41fecb8b
true
方法一 实例工厂

此种情况，工厂方法是一个实例方法(得先有对象，再调用方法)。

public class OkHttpClientStaticFactory {
    private static OkHttpClient okHttpClient;

    static {
        okHttpClient = new OkHttpClient.Builder()
                .connectTimeout(5, TimeUnit.SECONDS)
                .readTimeout(5, TimeUnit.SECONDS)
                .build();
    }

    public static OkHttpClient getInstance() {
        return okHttpClient;
    }
}

然后在 XML 文件中进行配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean class="org.example.OkHttpClientInstanceFactory" id="okHttpClientInstanceFactory"/>
    <bean class="org.example.OkHttpClientInstanceFactory" factory-bean="okHttpClientInstanceFactory" factory-method="getInstance" id="okHttpClient"/>
</beans>

那么需要注意的是，实例工厂中，工厂方法无法直接调用，必须先有一个实例对象，然后才能调用工厂方法。当然，最终注册到 Spring 容器中的 Bean 也是单例的。

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
OkHttpClient client1 = ctx.getBean("okHttpClient", OkHttpClient.class);
OkHttpClient client2 = ctx.getBean("okHttpClient", OkHttpClient.class);
System.out.println("client2 = " + client2);
System.out.println(client2 == client1);
方法一 FactoryBean（推荐)

这种是开发中使用较多的一种方案。SqlSessionFactoryBean 、 ShiroFilterFactoryBean 。。。
首先，我们需要创建一个 OkHttpClientFactoryBean：

/**
 * 注意这个命名是有规则的，一般叫做 xxxFactoryBean，看到这个名字，就知道最终生成的 Bean 实际上是 xxx
 */
public class OkHttpClientFactoryBean implements FactoryBean<OkHttpClient> {
    /**
     * 返回具体的实例对象
     *
     * @return
     * @throws Exception
     */
    @Override
    public OkHttpClient getObject() throws Exception {
        return new OkHttpClient.Builder()
                .connectTimeout(5, TimeUnit.SECONDS)
                .readTimeout(5, TimeUnit.SECONDS)
                .build();
    }

    /**
     * 返回的实例对象的类型
     *
     * @return
     */
    @Override
    public Class<?> getObjectType() {
        return OkHttpClient.class;
    }

    /**
     * 是否是单例模式
     * 如果为 false，就相当于 scope 为 prototype，默认该值为 true
     *
     * @return
     */
    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

然后在 XML 文件中进行配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean class="org.example.OkHttpClientFactoryBean" id="okHttpClient"/>
</beans>

当然最终获取到的还是okHttpClient对象

public class App {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        OkHttpClient okHttpClient = ctx.getBean("okHttpClient", OkHttpClient.class);
        System.out.println(okHttpClient);
    }
}

输出：

okhttp3.OkHttpClient@693fe6c9

那么如何获取到这个工厂 Bean 呢？只需要 id 前面添加一个 & 符号，就可以获取到 FactoryBean。

public class App {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        Object bean = ctx.getBean("&okHttpClient");
        System.out.println(bean.getClass());
    }
}

输出：

class org.example.OkHttpClientFactoryBean

也可以用注解，像下面这样：

public class JavaConfig {
    @Bean("okhttpclient3")
    public OkHttpClientFactoryBean okHttpClientFactoryBean() {
        return new OkHttpClientFactoryBean();
    }
    @Bean("okhttpclient3")
    public OkHttpClient okHttpClientInstanceFactory() {
        return new OkHttpClientInstanceFactory().getInstance();
    }
    @Bean("okhttpclient3")
    public OkHttpClient okHttpClientStaticFactory() {
        return OkHttpClientStaticFactory.getInstance();
    }
}

public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(JavaConfig.class);
        Object bean = ctx.getBean("okhttpclient3"); // 获取okhttp对象
        Object factbean = ctx.getBean("&okhttpclient3"); // 获取 okHttpClientFactoryBean
        System.out.println(factbean.getClass());
    }
}

FactoryBean 和 BeanFactory 区别

详情查看链接：https://mp.weixin.qq.com/s/r3rnVhU8vr58Cw__UWOVLA
在这里插入图片描述

hogenlaw
关注
Spring学习笔记（二）注入外部bean
无
12-24 369
示例：使用Spring框架通过service调用dao Project结构如下图所示： 只是个简单的示例，代码比较简单，如下： UserDAO接口： package dao; public interface UserDAO { public void QueryAll(); } UserDAOImpl类： package dao; public class UserDAOImpl implements UserDAO{ @Override public vo
Spring注入Bean的七种方式
2401_83817122的博客
04-18 765
笔者已经把面试题和答案整理成了面试专题文档《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！” />笔者已经把面试题和答案整理成了面试专题文档[外链图片转存中…(img-U8TEOmap-1713426769216)][外链图片转存中…(img-H75wIfMC-1713426769216)][外链图片转存中…(img-R50OF4Mu-1713426769216)][外链图片转存中…(img-DXG7i4j9-1713426769217)]
Spring-注入外部值
weixin_34015860的博客
10-25 75
 Spring注入需要初始化，但前面均使用硬编码注入，如： JavaConfig配置： 1 package soundSystem; 2 3 import org.springframework.stereotype.Component; 4 5 /** 6 * CompactDisc接口的实现类，此类中定义了CD的名字和作者以及打印相关信息的方法 7 * @author ...
(十三)Spring教程——依赖注入之工厂方法注入
最新发布
07-24 1203
工厂方法是在应用中被经常使用的设计模式，它也是控制反转和单例设计思想的主要实现方法。由于Spring IoC容器以框架的方式提供工厂方法的功能，并以透明的方式开放给开发者，所以很少需要手工编写基于工厂方法的类。正是因为工厂方法已经成为底层设施的一部分，因此工厂方法对于实际编码的重要性就降低了。不过在一些遗留系统或第三方类库中，我们还是会遇到工厂方法，这时可以使用Spring工厂方法注入的方式进行配置。
Spring 注入外部bean
health的博客
10-23 1038
一、新建类 1.dao层 UserDao.java public interface UserDao { public void update(); } UserDaoImpl.java public class UserDaoImpl implements UserDao{ @Override public void update() { System.out.println("dao update............"); } } ..
【Spring框架】注入外部bean
汤圆小丸叽的博客
08-10 229
创建一个service包，建立一个UserService类 public class UserService { //创建UserDao类型属性，生成set方法 private UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void add () { System.out.pri
Spring 运行时注入外部值
qq_42378514的博客
12-18 164
Spring 运行时注入外部值 外部值，指的是针对Spring容器而言。前面几篇我们讲的是针对Spring容器Bean的各种方式的装配。而本篇，将讲述一下Spring如何在运行时注入外部值。 属性占位符 Spring表达式语言（SpEL） 属性占位符 使用@PropertySource 注解和Environment @Configuration @PropertySo...
spring基础——普通bean xml注入
cc_xxo的博客
03-19 962
一、基本类型注入 1、set注入，前提是类中声明了属性的set方法 使用\ 2、有参构造器注入，前提是类中声明了有参构造器 使用<constructor-arg name=“参数名” value=“参数值”> 3、注入含特殊符号值，使用<![CDATA[<<南京>>]]> 实际值为<<南京>> 4、p标签注入，需引入p名称空间 xmlns:p=“http://www.springframework.org/schema/p” <
Spring实战之使用静态工厂方法创建Bean操作示例
08-25
在Spring框架中，静态工厂方法是一种创建Bean对象的方式，它允许我们通过调用类中的静态方法来实例化对象，而不是直接使用new关键字。这种方式在某些特定场景下非常有用，例如当我们需要控制对象的创建过程或者对象...
Spring注入属性中的外部bean、内部bean和级联赋值（超详细）
2401_83817148的博客
04-18 903
由于文案过于长，在此就不一一介绍了，这份Java后端架构进阶笔记内容包括：Java集合，JVM、Java并发、微服务、SpringNetty与 RPC 、网络、日志 、Zookeeper 、Kafka 、RabbitMQ 、Hbase 、MongoDB、Cassandra 、Java基础、负载均衡、数据库、一致性算法、Java算法、数据结构、分布式缓存等等知识详解。本知识体系适合于所有Java程序员学习，关于以上目录中的知识点都有详细的讲解及介绍，掌握该知识点的所有内容对你会有一个质的提升，
Spring注入属性-外部bean
weixin_46543456的博客
05-24 154
1.创建两个类 public class UserService { private UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void add(){ System.out.println("add...."); userDao.update(); } } publ
spring工厂属性注入
04-14
在spring中，当属性是由工厂方法创造的，而不是用new关键字实例化的，就需要在applicationContext.xml配置工厂方法，是spring容器为我们自动注入属性
spring-实例工厂注入
12-23
关于spring-工厂注入的实例代码，可以下载学习
Spring依赖注入使用静态工厂设注入demo
03-27
Spring依赖注入使用静态工厂设注入demo。完整可运行。
Spring 外部注入Bean
FeAndZn的博客
12-03 594
Spring 外部注入Bean （JAX-WS） 博客分类： Springbeanwebservicespringmvc 最近在SpringMvc中通过JAX-WS 来实现webservice，但是由于webservice没有在Spring容器中，所以需要Spring的dao，通过标签@Autowired 等方式得到的都是null 那么可以使用以下两种方式得到bean： 第一种方法（spring4...
Spring 注入方式之工厂方法注入
一只未入门的程序猿
09-03 4071
有时候，静态工厂方法是实例化对象的唯一方法，Spring支持通过&lt;bean&gt;元素的factory-method属性来装配工厂创建的Bean。 单例模式（设计模式） public class DBUtil { //构造方法私有化 private DBUtil(){} //创建一个对象实例 private static DBUtil instance ...
spring三种注入方式
紫蝶侠的博客
10-20 2645
设置Spring的作用域 或者使用枚举值设置 单例和多里使用场景 自动注入 @Primary 一个接口有多个实现被spring管理吗，在依赖注入式，spring会不知道注入哪个实现类就会抛出NoUniqueBeanDefinitionException异常 使用@Primary 来告诉Spring 注入哪个实现类 Qualifier @ComponentScan不同的配置对性能的影响 优化bean配置对spring应用程序的性能影响 在Spring中我们可以通过设置哦组件的扫描范围来简化jav
spring IoC——工厂方法注入
Bruce_Json的博客
09-03 324
有时候，静态工厂方法是实例化对象的唯一方法，Spring支持通过&lt;bean&gt;元素的factory-method属性来装配工厂创建的Bean。 单例模式（设计模式）： public class DbUtilsSingleton {     private DbUtilsSingleton(){}     private static class DbUtilsSingleton...
Spring工厂方法注入属性
长不大的大灰狼
11-29 1077
1 静态工厂注入 在 Spring 中，也可以使用静态工厂的方式实例化 Bean。此种方式需要提供一个静态工厂方法创建 Bean 的实例。 ① 创建实体类 public class Person{ String name; public void setName(String name){ this.name = name; } } ② 创建静态工厂类 创建一个名为 MyBeanFactory 的类，并在该类中创建一个名为 createBean() 的静态方法，用于创建 Bean 的实
spring中注入外部bean是不是就是注入对象
05-22
是的，Spring中注入外部bean就是将对象注入到另一个对象中使用。Spring的核心思想之一就是依赖注入（Dependency Injection），通过注入对象来实现对象之间的解耦。在Spring中，我们可以通过@Autowired或@Qualifier等注解来完成依赖注入。注入的对象可以是Spring容器中已经管理的bean，也可以是由第三方库提供的对象，甚至可以是我们自己手动创建的对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值