Spring源代码分析（17)---JndiObjectFactoryBean分析（小样，花名册上有你）

在此之前，我已经接触到了DataSource和JTA事务了，我们都应用到了JNDI技术；在Spring中提供了JNDI技术的整合支持，JNDI如何使用，我就不累赘了，具体我们来看一下整合的源代码：

代码类结构：



我们从上而下进行分析;
首先是：

JndiTemplate:

jndiTemplate提供了对JNDI服务器的vjndi对象的绑定，查询，撤销绑定和重新绑定，从一定意义上来说他跟JdbcTemplate等是同意概念的类，直接与资源管理器进行交互，并且同样的是采用的回调机制，我们可以看见其依赖了JndiCallbake接口：

其对绑定，差性能，撤销，重新绑定的实现的源代码如下：

1. public Object execute(JndiCallback contextCallback) throws NamingException {
2.         Context ctx = createInitialContext();
3.         try {
4.             return contextCallback.doInContext(ctx);
5.         }
6.         finally {
7.             try {
8.                 ctx.close();
9.             }
10.             catch (NamingException ex) {
11.                 logger.debug("Could not close JNDI InitialContext", ex);
12.             }
13.         }
14.     }

1.     protected Context createInitialContext() throws NamingException {
2.         return new InitialContext(getEnvironment());
3.     }

这段代码生成了上下文，进而把上下文传递给了JndiCallBack,在这个接口的回调方法，我们直接使用context对资源管理器进行curd交互；

绑定对象：

1. public Object lookup(final String name) throws NamingException {
2.         if (logger.isDebugEnabled()) {
3.             logger.debug("Looking up JNDI object with name [" + name + "]");
4.         }
5.         return execute(new JndiCallback() {
6.             public Object doInContext(Context ctx) throws NamingException {
7.                 Object located = ctx.lookup(name);
8.                 if (located == null) {
9.                     throw new NameNotFoundException(
10.                             "JNDI object with [" + name + "] not found: JNDI implementation 
12. returned null");
13.                 }
14.                 return located;
15.             }
16.         });
17.     }

1.     public void bind(final String name, final Object object) throws NamingException {
2.         if (logger.isDebugEnabled()) {
3.             logger.debug("Binding JNDI object with name [" + name + "]");
4.         }
5.         execute(new JndiCallback() {
6.             public Object doInContext(Context ctx) throws NamingException {
7.                 ctx.bind(name, object);
8.                 return null;
9.             }
10.         });
11.     }

重新绑定：

1. public void rebind(final String name, final Object object) throws NamingException {
2.         if (logger.isDebugEnabled()) {
3.             logger.debug("Rebinding JNDI object with name [" + name + "]");
4.         }
5.         execute(new JndiCallback() {
6.             public Object doInContext(Context ctx) throws NamingException {
7.                 ctx.rebind(name, object);
8.                 return null;
9.             }
10.         });
11.     }

撤销绑定：

2. public void unbind(final String name) throws NamingException {
3.         if (logger.isDebugEnabled()) {
4.             logger.debug("Unbinding JNDI object with name [" + name + "]");
5.         }
6.         execute(new JndiCallback() {
7.             public Object doInContext(Context ctx) throws NamingException {
8.                 ctx.unbind(name);
9.                 return null;
10.             }
11.         });
12.     }
13.     
14. }

通过JndiTemplate,我们实现了底层访问代码;形成了具体实现层；与上层开来；

JndiAccessor:只是单纯的对JndiTemplate进行了包装，隔离了底层的实现细节；

JndiLocatorSupport的主要扩展的功能是，如果我们在配置JndiObjectFactoryBean的时候，配置了参数：resourceRef为true的话，那么就会如果我们查找的资源中间不包含:或者java:等前缀，我们会自动的会该路径加上java:comp/env,主要是匹配在j2ee容器里面的jndi资源的查找；

1.     protected String convertJndiName(String jndiName) {
2.         // Prepend container prefix if not already specified and no other scheme given.
3.         if (isResourceRef() && !jndiName.startsWith(CONTAINER_PREFIX) && jndiName.indexOf(':') == -1) {
4.             jndiName = CONTAINER_PREFIX + jndiName;
5.         }
6.         return jndiName;
7.     }

最后，我们再来看一下：

在JndiObjectFactoryBean我们实际上得到的是：

   jndiObject :
初始化生成如下：

1. public void afterPropertiesSet() throws IllegalArgumentException, NamingException {
2.         super.afterPropertiesSet();
4.         if (this.proxyInterface != null) {
5.             if (this.defaultObject != null) {
6.                 throw new IllegalArgumentException(
7.                         "'defaultObject' is not supported in combination with 'proxyInterface'");
8.             }
9.             // We need a proxy and a JndiObjectTargetSource.
10.             this.jndiObject = JndiObjectProxyFactory.createJndiObjectProxy(this);
11.         }
13.         else {
14.             if (!this.lookupOnStartup || !this.cache) {
15.                 throw new IllegalArgumentException(
16.                     "Cannot deactivate 'lookupOnStartup' or 'cache' without specifying a 'proxyInterface'");
17.             }
18.             if (this.defaultObject != null && getExpectedType() != null &&
19.                     !getExpectedType().isInstance(this.defaultObject)) {
20.                 throw new IllegalArgumentException("Default object [" + this.defaultObject +
21.                         "] of type [" + this.defaultObject.getClass().getName() +
22.                         "] is not of expected type [" + getExpectedType().getName() + "]");
23.             }
24.             // Locate specified JNDI object.
25.             this.jndiObject = lookupWithFallback();
26.         }
27.     }

当proxyTnterface不为空的时候
this .jndiObject = JndiObjectProxyFactory.createJndiObjectProxy( this );
生成了一个从Jndi目录中取得了的对象的代理类：

1. private static class JndiObjectProxyFactory {
3.         private static Object createJndiObjectProxy(JndiObjectFactoryBean jof) throws NamingException {
4.             // Create a JndiObjectTargetSource that mirrors the JndiObjectFactoryBean's configuration.
5.             JndiObjectTargetSource targetSource = new JndiObjectTargetSource();
6.             targetSource.setJndiTemplate(jof.getJndiTemplate());
7.             targetSource.setJndiName(jof.getJndiName());
8.             targetSource.setExpectedType(jof.getExpectedType());
9.             targetSource.setResourceRef(jof.isResourceRef());
10.             targetSource.setLookupOnStartup(jof.lookupOnStartup);
11.             targetSource.setCache(jof.cache);
12.             targetSource.afterPropertiesSet();
14.             // Create a proxy with JndiObjectFactoryBean's proxy interface and the JndiObjectTargetSource.
15.             ProxyFactory proxyFactory = new ProxyFactory();
16.             proxyFactory.addInterface(jof.proxyInterface);
17.             proxyFactory.setTargetSource(targetSource);
18.             return proxyFactory.getProxy();
19.         }
20.     }

否则直接将从目录服务器中得到的对象暴露出来；如果查找出现异常，将会把DefaultObject暴露出来；