import org.springframework.expression.BeanResolver; //导入依赖的package包/类
@Override
public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
	BeanResolver beanResolver = state.getEvaluationContext().getBeanResolver();
	if (beanResolver==null) {
		throw new SpelEvaluationException(getStartPosition(),
				SpelMessage.NO_BEAN_RESOLVER_REGISTERED, this.beanname);
	}

	try {
		TypedValue bean = new TypedValue(beanResolver.resolve(
				state.getEvaluationContext(), this.beanname));
	   return bean;
	}
	catch (AccessException ae) {
		throw new SpelEvaluationException( getStartPosition(), ae, SpelMessage.EXCEPTION_DURING_BEAN_RESOLUTION,
			this.beanname, ae.getMessage());
	}
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
@Override
public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
	BeanResolver beanResolver = state.getEvaluationContext().getBeanResolver();
	if (beanResolver == null) {
		throw new SpelEvaluationException(
				getStartPosition(), SpelMessage.NO_BEAN_RESOLVER_REGISTERED, this.beanName);
	}

	try {
		return new TypedValue(beanResolver.resolve(state.getEvaluationContext(), this.beanName));
	}
	catch (AccessException ex) {
		throw new SpelEvaluationException(getStartPosition(), ex, SpelMessage.EXCEPTION_DURING_BEAN_RESOLUTION,
			this.beanName, ex.getMessage());
	}
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
private void initResolverObjectFactory() {
    BeanResolver proto = findInjectedBean(RESOLVER, BeanResolver.class);

    if (proto != null) {
        LOG.debug("Using plugged " + RESOLVER);

        beanResolver = proto;

        return;
    }

    beanResolver = new ProtocolResolver();

    try {
        ((ProtocolResolver) beanResolver).setApplicationContext(applicationContext);
        ((ProtocolResolver) beanResolver).afterPropertiesSet();
    } catch (Exception e) {
        LOG.error("Oops", e);
        throw new IllegalArgumentException("Oops", e);
    }
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
/**
 * JAVADOC Method Level Comments
 */
@Test
public void testCreate()
    throws Exception {
    BeanResolver res1 = mock(BeanResolver.class);

    Foo f1 = new Foo(1L);
    Foo f2 = new Foo(2L);

    when(res1.resolve(null, "bean:/aa/bb")).thenReturn(f1);
    when(res1.resolve(null, "class:/cc/dd")).thenReturn(f2);

    ProcessEnvironmentFactory.buildEnvironment(res1, null, null, null, null);

    ResolverObjectCreationFactory factory = new ResolverObjectCreationFactory();
    Attributes attributes = mock(Attributes.class);

    when(attributes.getValue("path")).thenReturn("bean:/aa/bb");
    when(attributes.getValue("id")).thenReturn("1");

    Foo foo = (Foo) factory.createObject(attributes);

    assertEquals(f1, foo);
    when(attributes.getValue("path")).thenReturn("class:/cc/dd");
    when(attributes.getValue("id")).thenReturn("2");
    foo = (Foo) factory.createObject(attributes);
    assertEquals(f2, foo);
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
/**
 * Creates a new ResolverObjectFactoryImpl object.
 *
 * @param resolverRegistry
 *            JAVADOC.
 */
public ProtocolResolver(Map<String, BeanResolver> resolvers) {
    this();

    if (resolvers != null) {
        this.resolvers.putAll(resolvers);
    }
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
/**
 * JAVADOC Method Level Comments
 *
 * @param context
 *            JAVADOC.
 * @param beanName
 *            JAVADOC.
 *
 * @return JAVADOC.
 *
 * @throws AccessException
 *             JAVADOC.
 */
@Override
public Object resolve(EvaluationContext context, String beanName)
    throws AccessException {
    int index = beanName.indexOf(PROTOCOL_SEPARATOR);

    String protocol = DEFAULT_PROTOCOL;

    if (index >= 0) {
        protocol = beanName.substring(0, index);
    }

    BeanResolver resolver = resolvers.get(protocol);

    if (resolver == null) {
        LOG.error("There is no resolver registered for protocol '" + protocol + "]");

        throw new IllegalArgumentException("There is no resolver registered for protocol '" +
            protocol + "]");
    }

    String componentPath = beanName;

    if (index >= 0) {
        componentPath = beanName.substring(index + 1);
    }

    Object result = resolver.resolve(context, componentPath);

    if (result == null) {
        LOG.error("Failed to resolve object referred by protocol '" + protocol +
            "' and path '" + componentPath + "'.");

        throw new IllegalArgumentException("Failed to resolve object referred by protocol '" +
            protocol + "' and path '" + componentPath + "'.");
    }

    return result;
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
@Override
public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
	BeanResolver beanResolver = state.getEvaluationContext().getBeanResolver();
	if (beanResolver==null) {
		throw new SpelEvaluationException(getStartPosition(),SpelMessage.NO_BEAN_RESOLVER_REGISTERED, beanname);
	}
	try {
	   TypedValue bean = new TypedValue(beanResolver.resolve(state.getEvaluationContext(),beanname));
	   return bean;
	} catch (AccessException ae) {
		throw new SpelEvaluationException( getStartPosition(), ae, SpelMessage.EXCEPTION_DURING_BEAN_RESOLUTION,
			beanname, ae.getMessage());
	}
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
public void setBeanResolver(BeanResolver beanResolver) {
	this.beanResolver = beanResolver;
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
@Override
public BeanResolver getBeanResolver() {
	return this.beanResolver;
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
/**
 * JAVADOC Method Level Comments
 *
 * @param resolverRegistry JAVADOC.
 *
 * @return JAVADOC.
 */
public static ProcessEnvironment buildEnvironment(BeanResolver beanResolver,
    ProcessDefinitionRegistry definitionRegistry, ProcessDefinitionParser definitionParser,
    ProcessService processService, Collection<Resource> resources)
    throws Exception {
    DefaultProcessEnvironment defaultProcessEnvironment = new DefaultProcessEnvironment();
    ApplicationContext applicationContext = mock(ApplicationContext.class);

    when(applicationContext.containsBean("beanResolver")).thenReturn(true);

    if (beanResolver == null) {
        beanResolver = mock(BeanResolver.class);
    }

    when(applicationContext.getBean("beanResolver")).thenReturn(beanResolver);
    when(applicationContext.containsBean("processDefinitionRegistry")).thenReturn(true);

    if (definitionRegistry == null) {
        definitionRegistry = mock(ProcessDefinitionRegistry.class);
    }

    when(applicationContext.getBean("processDefinitionRegistry")).thenReturn(definitionRegistry);
    when(applicationContext.containsBean("processDefinitionParser")).thenReturn(true);

    if (definitionParser == null) {
        definitionParser = mock(ProcessDefinitionParser.class);
    }

    when(applicationContext.getBean("processDefinitionParser")).thenReturn(definitionParser);
    when(applicationContext.containsBean("processSessionFactory")).thenReturn(true);

    defaultProcessEnvironment.setTokenFactory(mock(TokenFactory.class));

    ProcessDriverFactory executorFactory = mock(ProcessDriverFactory.class);

    when(executorFactory.getExecutor()).thenReturn(new LocalProcessDriver());

    ProcessSessionFactory sessionFactory = new DefaultProcessSessionFactory(definitionRegistry,
            Collections.singletonList((WorkflowListener) new StandardOutputWorkflowListener()),
            executorFactory);

    when(applicationContext.getBean("processSessionFactory")).thenReturn(sessionFactory);
    when(applicationContext.containsBean("processService")).thenReturn(true);

    if (processService == null) {
        processService = mock(ProcessService.class);
    }

    when(applicationContext.getBean("processService")).thenReturn(processService);
    when(applicationContext.containsBean("processDefinitionHelper")).thenReturn(true);

    ProcessDefinitionHelper processDefinitionHelper = mock(ProcessDefinitionHelper.class);

    when(applicationContext.getBean("processDefinitionHelper"))
        .thenReturn(processDefinitionHelper);

    when(applicationContext.containsBean("expressionExecutor")).thenReturn(true);

    ExpressionExecutor exex = new ELExpressionExecutor();

    when(applicationContext.getBean("expressionExecutor")).thenReturn(exex);
    defaultProcessEnvironment.setApplicationContext(applicationContext);
    defaultProcessEnvironment.setDefinitionResources(resources);
    defaultProcessEnvironment.setDefinitionRegistry(definitionRegistry);
    defaultProcessEnvironment.start();

    return defaultProcessEnvironment;
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
public BeanResolver getBeanResolver() {
	return this.beanResolver;
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
/**
 * Creates a new DtoOperationConverter object.
 *
 * @param beanResolver .
 */
public DtoOperationConverter(BeanResolver beanResolver) {
    this.beanResolver = beanResolver;
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
/**
 * Creates a new DtoCheckConverter object.
 *
 * @param beanResolver .
 */
public DtoCheckConverter(BeanResolver beanResolver) {
    this.beanResolver = beanResolver;
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
/**
 * JAVADOC Method Level Comments
 *
 * @return JAVADOC.
 */
@Override
public BeanResolver getBeanResolver() {
    return beanResolver;
}
 

import org.springframework.expression.BeanResolver; //导入依赖的package包/类
/**
 * JAVADOC Method Level Comments
 *
 * @return JAVADOC.
 */
BeanResolver getBeanResolver();