如何在Spring中自定义scope的方法示例
大家对于 spring 的 scope 应该都不会默认。所谓 scope，字面理解就是“作用域”、“范围”，如果一个 bean 的 scope 配置为 singleton，则从容器中获取 bean 返回的对象都是相同的；如果 scope 配置为prototype，则每次返回的对象都不同。
一般情况下，spring 提供的 scope 都能满足日常应用的场景。但如果你的需求极其特殊，则本文所介绍自定义 scope 合适你。
spring 内置的 scope
默认时，所有 spring bean 都是的单例的，意思是在整个 spring 应用中，bean的实例只有一个。可以在 bean 中添加 scope 属性来修改这个默认值。scope 属性可用的值如下：
| 范围 | 描述 |
|---|---|
| singleton | 每个 spring 容器一个实例（默认值） |
| prototype | 允许 bean 可以被多次实例化（使用一次就创建一个实例） |
| request | 定义 bean 的 scope 是 http 请求。每个 http 请求都有自己的实例。只有在使用有 web 能力的 spring 上下文时才有效 |
| session | 定义 bean 的 scope 是 http 会话。只有在使用有 web 能力的 spring applicationcontext 才有效 |
| application | 定义了每个 servletcontext 一个实例 |
| websocket | 定义了每个 websocket 一个实例。只有在使用有 web 能力的 spring applicationcontext 才有效 |
如果上述 scope 仍然不能满足你的需求，spring 还预留了接口，允许你自定义 scope。
scope 接口
org.springframework.beans.factory.config.scope接口用于定义scope的行为：
package org.springframework.beans.factory.config;
import org.springframework.beans.factory.objectfactory;
import org.springframework.lang.nullable;
public interface scope {
object get(string name, objectfactory<?> objectfactory);
@nullable
object remove(string name);
void registerdestructioncallback(string name, runnable callback);
@nullable
object resolvecontextualobject(string key);
@nullable
string getconversationid();
}
一般来说，只需要重新 get 和 remove 方法即可。
自定义线程范围内的scope
现在进入实战环节。我们要自定义一个spring没有的scope，该scope将bean的作用范围限制在了线程内。即，相同线程内的bean是同个对象，跨线程则是不同的对象。
1. 定义scope
要自定义一个spring的scope，只需实现 org.springframework.beans.factory.config.scope接口。代码如下：
package com.waylau.spring.scope;
import java.util.hashmap;
import java.util.map;
import org.springframework.beans.factory.objectfactory;
import org.springframework.beans.factory.config.scope;
/**
* thread scope.
*
* @since 1.0.0 2019年2月13日
* @author <a href="https://waylau.com" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" >way lau</a>
*/
public class threadscope implements scope {
private final threadlocal<map<string, object>> threadloacal = new threadlocal<map<string, object>>() {
@override
protected map<string, object> initialvalue() {
return new hashmap<string, object>();
}
};
public object get(string name, objectfactory<?> objectfactory) {
map<string, object> scope = threadloacal.get();
object obj = scope.get(name);
// 不存在则放入threadlocal
if (obj == null) {
obj = objectfactory.getobject();
scope.put(name, obj);
system.out.println("not exists " + name + "; hashcode: " + obj.hashcode());
} else {
system.out.println("exists " + name + "; hashcode: " + obj.hashcode());
}
return obj;
}
public object remove(string name) {
map<string, object> scope = threadloacal.get();
return scope.remove(name);
}
public string getconversationid() {
return null;
}
public void registerdestructioncallback(string arg0, runnable arg1) {
}
public object resolvecontextualobject(string arg0) {
return null;
}
}
在上述代码中，threadloacal用于做线程之间的数据隔离。换言之，threadloacal实现了相同的线程相同名字的bean是同一个对象；不同的线程的相同名字的bean是不同的对象。
同时，我们将对象的hashcode打印了出来。如果他们是相同的对象，则hashcode是相同的。
2. 注册scope
定义一个appconfig配置类，将自定义的scope注册到容器中去。代码如下：
package com.waylau.spring.scope;
import java.util.hashmap;
import java.util.map;
import org.springframework.beans.factory.config.customscopeconfigurer;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.componentscan;
import org.springframework.context.annotation.configuration;
/**
* app config.
*
* @since 1.0.0 2019年2月13日
* @author <a href="https://waylau.com" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" >way lau</a>
*/
@configuration
@componentscan
public class appconfig {
@bean
public static customscopeconfigurer customscopeconfigurer() {
customscopeconfigurer customscopeconfigurer = new customscopeconfigurer();
map<string, object> map = new hashmap<string, object>();
map.put("threadscope", new threadscope());
// 配置scope
customscopeconfigurer.setscopes(map);
return customscopeconfigurer;
}
}
“threadscope”就是自定义threadscope的名称。
3. 使用scope
接下来就根据一般的scope的用法，来使用自定义的scope了。代码如下：
package com.waylau.spring.scope.service;
import org.springframework.context.annotation.scope;
import org.springframework.stereotype.service;
/**
* message service impl.
*
* @since 1.0.0 2019年2月13日
* @author <a href="https://waylau.com" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" >way lau</a>
*/
@scope("threadscope")
@service
public class messageserviceimpl implements messageservice {
public string getmessage() {
return "hello world!";
}
}
其中@scope("threadscope")中的“threadscope”就是自定义threadscope的名称。
4. 定义应用入口
定义spring应用入口：
package com.waylau.spring.scope;
import org.springframework.context.applicationcontext;
import org.springframework.context.annotation.annotationconfigapplicationcontext;
import com.waylau.spring.scope.service.messageservice;
/**
* application main.
*
* @since 1.0.0 2019年2月13日
* @author <a href="https://waylau.com" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" >way lau</a>
*/
public class application {
public static void main(string[] args) {
@suppresswarnings("resource")
applicationcontext context =
new annotationconfigapplicationcontext(appconfig.class);
messageservice messageservice = context.getbean(messageservice.class);
messageservice.getmessage();
messageservice messageservice2 = context.getbean(messageservice.class);
messageservice2.getmessage();
}
}
运行应用观察控制台输出如下：
not exists messageserviceimpl; hashcode: 2146338580
exists messageserviceimpl; hashcode: 2146338580
输出的结果也就验证了threadscope“相同的线程相同名字的bean是同一个对象”。
如果想继续验证threadscope“不同的线程的相同名字的bean是不同的对象”，则只需要将application改造为多线程即可。
package com.waylau.spring.scope;
import java.util.concurrent.completablefuture;
import java.util.concurrent.executionexception;
import org.springframework.context.applicationcontext;
import org.springframework.context.annotation.annotationconfigapplicationcontext;
import com.waylau.spring.scope.service.messageservice;
/**
* application main.
*
* @since 1.0.0 2019年2月13日
* @author <a href="https://waylau.com" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" >way lau</a>
*/
public class application {
public static void main(string[] args) throws interruptedexception, executionexception {
@suppresswarnings("resource")
applicationcontext context =
new annotationconfigapplicationcontext(appconfig.class);
completablefuture<string> task1 = completablefuture.supplyasync(()->{
//模拟执行耗时任务
messageservice messageservice = context.getbean(messageservice.class);
messageservice.getmessage();
messageservice messageservice2 = context.getbean(messageservice.class);
messageservice2.getmessage();
//返回结果
return "result";
});
completablefuture<string> task2 = completablefuture.supplyasync(()->{
//模拟执行耗时任务
messageservice messageservice = context.getbean(messageservice.class);
messageservice.getmessage();
messageservice messageservice2 = context.getbean(messageservice.class);
messageservice2.getmessage();
//返回结果
return "result";
});
task1.get();
task2.get();
}
}
观察输出结果;
not exists messageserviceimpl; hashcode: 1057328090
not exists messageserviceimpl; hashcode: 784932540
exists messageserviceimpl; hashcode: 1057328090
exists messageserviceimpl; hashcode: 784932540
上述结果验证threadscope“相同的线程相同名字的bean是同一个对象；不同的线程的相同名字的bean是不同的对象”
源码
见 的 s5-ch02-custom-scope-annotation项目。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。