用spring的 InitializingBean 的 afterPropertiesSet 来初始化

秒速五厘米 2022-02-05 03:07 338阅读 0赞

void afterPropertiesSet() throws Exception;

这个方法将在所有的属性被初始化后调用。

但是会在init前调用。

但是主要的是如果是延迟加载的话，则马上执行。

所以可以在类上加上注解：

import org.springframework.context.annotation.Lazy;

@Lazy(false)

这样spring容器初始化的时候afterPropertiesSet就会被调用。

只需要实现InitializingBean接口就行。

public class MessageRecvExecutor implements ApplicationContextAware, InitializingBean \{

private String serverAddress;  
    private final static String DELIMITER = ":";

private Map<String, Object> handlerMap = new ConcurrentHashMap<String, Object>();

private static ThreadPoolExecutor threadPoolExecutor;

public MessageRecvExecutor(String serverAddress) \{  
        this.serverAddress = serverAddress;  
    \}

public static void submit(Runnable task) \{  
        if (threadPoolExecutor == null) \{  
            synchronized (MessageRecvExecutor.class) \{  
                if (threadPoolExecutor == null) \{  
                    threadPoolExecutor = (ThreadPoolExecutor) RpcThreadPool.getExecutor(16, -1);  
                \}  
            \}  
        \}  
        threadPoolExecutor.submit(task);  
    \}

public void setApplicationContext(ApplicationContext ctx) throws BeansException \{  
        try \{  
            MessageKeyVal keyVal = (MessageKeyVal) ctx.getBean(Class.forName("newlandframework.netty.rpc.model.MessageKeyVal"));  
            Map<String, Object> rpcServiceObject = keyVal.getMessageKeyVal();

Set s = rpcServiceObject.entrySet();  
            Iterator<Map.Entry<String, Object>> it = s.iterator();  
            Map.Entry<String, Object> entry;

while (it.hasNext()) \{  
                entry = it.next();  
                handlerMap.put(entry.getKey(), entry.getValue());  
            \}  
        \} catch (ClassNotFoundException ex) \{  
            java.util.logging.Logger.getLogger(MessageRecvExecutor.class.getName()).log(Level.SEVERE, null, ex);  
        \}  
    \}

public void afterPropertiesSet() throws Exception \{  
        //netty的线程池模型设置成主从线程池模式，这样可以应对高并发请求  
        //当然netty还支持单线程、多线程网络IO模型，可以根据业务需求灵活配置  
        ThreadFactory threadRpcFactory = new NamedThreadFactory("NettyRPC ThreadFactory");  
          
        //方法返回到Java虚拟机的可用的处理器数量  
        int parallel = Runtime.getRuntime().availableProcessors() \* 2;  
      
        EventLoopGroup boss = new NioEventLoopGroup();  
        EventLoopGroup worker = new NioEventLoopGroup(parallel,threadRpcFactory,SelectorProvider.provider());  
          
        try \{  
            ServerBootstrap bootstrap = new ServerBootstrap();  
            bootstrap.group(boss, worker).channel(NioServerSocketChannel.class)  
                    .childHandler(new MessageRecvChannelInitializer(handlerMap))  
                    .option(ChannelOption.SO\_BACKLOG, 128)  
                    .childOption(ChannelOption.SO\_KEEPALIVE, true);

String\[\] ipAddr = serverAddress.split(MessageRecvExecutor.DELIMITER);

if (ipAddr.length == 2) \{  
                String host = ipAddr\[0\];  
                int port = Integer.parseInt(ipAddr\[1\]);  
                ChannelFuture future = bootstrap.bind(host, port).sync();  
                System.out.printf("\[author tangjie\] Netty RPC Server start success ip:%s port:%d\\n", host, port);  
                future.channel().closeFuture().sync();  
            \} else \{  
                System.out.printf("\[author tangjie\] Netty RPC Server start fail!\\n");  
            \}  
        \} finally \{  
            worker.shutdownGracefully();  
            boss.shutdownGracefully();  
        \}  
    \}  
\}