Java Code Examples for org.springframework.web.context.WebApplicationContext#getBean()

@Override
public void sessionCreated( HttpSessionEvent httpSessionEvent )
{
    // ensure the map is here to avoid NPE
    if ( httpSessionEvent.getSession().getAttribute( TEMPORARY_INDEX_SESSION_KEY ) == null )
    {
        httpSessionEvent.getSession().setAttribute( TEMPORARY_INDEX_SESSION_KEY,
                                                    new HashMap<>() );
    }

    if ( indexMerger == null )
    {
        WebApplicationContext webApplicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(
            httpSessionEvent.getSession().getServletContext() );
        indexMerger = webApplicationContext.getBean( IndexMerger.class );
    }
}
 

public void init(ServletConfig config) {
	try {
		super.init(config);
		ServletContext context = getServletContext();
		Logger.log.info("ReasonableSakaiServlet starting up for context " + context.getRealPath(""));

		WebApplicationContext wac = WebApplicationContextUtils.getWebApplicationContext(context);
		if (wac == null) {
			throw new IllegalStateException(
					"Error acquiring web application context " + "- servlet context not configured correctly");
		}
		rsacbl = (RSACBeanLocator) wac.getBean(RSACBeanLocator.RSAC_BEAN_LOCATOR_NAME);
	} catch (Throwable t) {
		Logger.log.warn("Error initialising SakaiRSF servlet: ", t);
	}
}
 

/**
 * Find the registered {@link RequestDataValueProcessor}, if any, and allow
 * it to update the redirect target URL.
 * @param targetUrl the given redirect URL
 * @return the updated URL or the same as URL as the one passed in
 */
protected String updateTargetUrl(String targetUrl, Map<String, Object> model,
		HttpServletRequest request, HttpServletResponse response) {

	WebApplicationContext wac = getWebApplicationContext();
	if (wac == null) {
		wac = RequestContextUtils.findWebApplicationContext(request, getServletContext());
	}

	if (wac != null && wac.containsBean(RequestContextUtils.REQUEST_DATA_VALUE_PROCESSOR_BEAN_NAME)) {
		RequestDataValueProcessor processor = wac.getBean(
				RequestContextUtils.REQUEST_DATA_VALUE_PROCESSOR_BEAN_NAME, RequestDataValueProcessor.class);
		return processor.processUrl(request, targetUrl);
	}

	return targetUrl;
}
 

@Deprecated
public void attack(Task task, ExecutorService exec) {
    WebApplicationContext context = getAppContext();
    Map<String, AbstractPOC> beans = context.getBeansOfType(AbstractPOC.class);
    AbstractPlugin simpleVul = (AbstractPlugin) context.getBean("simpleVulRule");
    SysLog.info("开始漏洞检测");

    for (String targeturl : task.getTargets()) {

        simpleVul.setParam(new HashMap<String,Object>(){{put("target",targeturl);put("task",task);}});
        exec.submit(simpleVul);

        for (Map.Entry<String, AbstractPOC> entry : beans.entrySet()) {
            AbstractPOC exp = entry.getValue();
            exp.setTask(task);
            exp.setTarget(targeturl);
            String bean = entry.getKey();
            SysLog.info(bean+" exploit executeing...");
            exec.execute(exp);
        }
    }


}
 

@Test
public void testSessionScope() {
	WebApplicationContext ac = initApplicationContext(WebApplicationContext.SCOPE_SESSION);
	MockRenderRequest request = new MockRenderRequest();
	PortletRequestAttributes requestAttributes = new PortletRequestAttributes(request);
	RequestContextHolder.setRequestAttributes(requestAttributes);
	try {
		assertNull(request.getPortletSession().getAttribute(NAME));
		DerivedTestBean bean = ac.getBean(NAME, DerivedTestBean.class);
		assertSame(bean, request.getPortletSession().getAttribute(NAME));
		assertSame(bean, ac.getBean(NAME));
		request.getPortletSession().invalidate();
		assertTrue(bean.wasDestroyed());
	}
	finally {
		RequestContextHolder.setRequestAttributes(null);
	}
}
 

/**
 * Look up the EntityManagerFactory that this filter should use.
 * <p>The default implementation looks for a bean with the specified name
 * in Spring's root application context.
 * @return the EntityManagerFactory to use
 * @see #getEntityManagerFactoryBeanName
 */
protected EntityManagerFactory lookupEntityManagerFactory() {
	WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
	String emfBeanName = getEntityManagerFactoryBeanName();
	String puName = getPersistenceUnitName();
	if (StringUtils.hasLength(emfBeanName)) {
		return wac.getBean(emfBeanName, EntityManagerFactory.class);
	}
	else if (!StringUtils.hasLength(puName) && wac.containsBean(DEFAULT_ENTITY_MANAGER_FACTORY_BEAN_NAME)) {
		return wac.getBean(DEFAULT_ENTITY_MANAGER_FACTORY_BEAN_NAME, EntityManagerFactory.class);
	}
	else {
		// Includes fallback search for single EntityManagerFactory bean by type.
		return EntityManagerFactoryUtils.findEntityManagerFactory(wac, puName);
	}
}
 

/**
 * Look up the SessionFactory that this filter should use.
 * <p>The default implementation looks for a bean with the specified name
 * in Spring's root application context.
 * @return the SessionFactory to use
 * @see #getSessionFactoryBeanName
 */
protected SessionFactory lookupSessionFactory() {
	if (logger.isDebugEnabled()) {
		logger.debug("Using SessionFactory '" + getSessionFactoryBeanName() + "' for OpenSessionInViewFilter");
	}
	WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
	return wac.getBean(getSessionFactoryBeanName(), SessionFactory.class);
}
 

@Override
public void init() throws ServletException {

    super.init();
    WebApplicationContext webApplicationContext =
            WebApplicationContextUtils.getWebApplicationContext(getServletContext());
    configService = (ConfigService) webApplicationContext.getBean("configService");
    this.diskService = (DiskService) webApplicationContext.getBean("diskService");
    configController = new ConfigController();
    this.configController.setConfigService(configService);
    this.configController.setDiskService(diskService);
}
 

@Override
public void contextInitialized(ServletContextEvent sce) {
     // TODO add ability to configure non default values via serveltContexParams
    ServletContext servletContext = sce.getServletContext();
     WebApplicationContext context = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
    ExposablePropertyPlaceholderConfigurer configurer =
            (ExposablePropertyPlaceholderConfigurer) context.getBean(propertiesBeanName);
    sce.getServletContext().setAttribute(contextProperty, configurer.getResolvedProps());
}
 

@Override
protected boolean checkEnforce(ServletContext servletContext) throws IOException
{
    /*
    * Get the secureComms setting from the global properties bean.
    */

    WebApplicationContext wc = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
    Properties globalProperties = (Properties) wc.getBean(BEAN_GLOBAL_PROPERTIES);
    String prop = globalProperties.getProperty(SECURE_COMMS);

    if(logger.isDebugEnabled())
    {
        logger.debug("secureComms:"+prop);
    }

    /*
     * Return true or false based on the property. This will switch on/off X509 enforcement in the X509ServletFilterBase.
     */

    if (prop == null || "none".equals(prop))
    {
        return false;
    }
    else
    {
        return true;
    }
}
 

protected String process(String url, HttpServletRequest request) {
    Map<String, String> parameters = getParameters(url);

    WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext());

    CacheTemplate cacheTemplate = context.getBean(CacheTemplate.class);
    String name = parameters.get("name");
    String key = parameters.get("key");
    url = Strings.subString(url, null, ".json");
    if (url.equals("/get")) {
        if ((null != name && name.length() > 0) && (null != key && key.length() > 0)) {
            return returnJSONResultSuccess(RESULT_CODE_SUCCESS, cacheTemplate.get(name, key));
        }
    }
    //
    else if (url.equals("/del")) {
        if ((null != name && name.length() > 0) && (null != key && key.length() > 0)) {
            cacheTemplate.del(name, key);
            return returnJSONResultSuccess(RESULT_CODE_SUCCESS, null);
        }
    }
    //
    else if (url.equals("/rem")) {
        if (null != name && name.length() > 0) {
            cacheTemplate.rem(name);
            return returnJSONResultSuccess(RESULT_CODE_SUCCESS, null);
        }
    }
    //
    else if (url.equals("/names")) {
        return returnJSONResultSuccess(RESULT_CODE_SUCCESS, cacheTemplate.names());
    }
    //
    else if (url.equals("/keys")) {
        if (null != name && name.length() > 0) {
            return returnJSONResultSuccess(RESULT_CODE_SUCCESS, cacheTemplate.getKeysData(name));
        }
    }
    //
    else if (url.equals("/fetch")) {
        if ((null != name && name.length() > 0) && (null != key && key.length() > 0)) {
            return returnJSONResultSuccess(RESULT_CODE_SUCCESS, cacheTemplate.fetch(name, key));
        }
    }
    //
    else if (url.equals("/cls")) {
        cacheTemplate.cls();
        return returnJSONResultSuccess(RESULT_CODE_SUCCESS, null);
    }
    //
    return returnJSONResultFailure(RESULT_CODE_FALIURE, "Do not support this request, please contact with administrator.");

}
 

public static PolitenessOptions getAggressivePolitenessOptions() {
    WebApplicationContext ctx = ApplicationContextFactory.getWebApplicationContext();
    return (PolitenessOptions) ctx.getBean("aggressivePolitenessOptions");
}
 

protected PermissionCheck getPermissionCheck() {
	WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(getServletContext());
	return (PermissionCheck)applicationContext.getBean("unitimePermissionCheck");
}
 

@Override
protected ViewPreparer getPreparer(String name, WebApplicationContext context) throws TilesException {
	return context.getBean(name, ViewPreparer.class);
}
 

protected IToolContentFullHandler getToolContentHandler(String toolContentHandlerName) {
WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
return (IToolContentFullHandler) wac.getBean(toolContentHandlerName);
   }
 

@Override
public void init() throws ServletException {
	WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
	this.target = wac.getBean(getServletName(), HttpRequestHandler.class);
}
 

/**
 * @param storeValue String
 * @param rootPath String
 * @param context WebApplicationContext
 * @param nodeService NodeService
 * @param searchService SearchService
 * @param namespaceService NamespaceService
 * @param tenantService TenantService
 * @param m_transactionService TransactionService
 */
private void initializeRootNode(String storeValue, String rootPath, WebApplicationContext context, NodeService nodeService, SearchService searchService,
        NamespaceService namespaceService, TenantService tenantService, TransactionService m_transactionService)
{

    // Use the system user as the authenticated context for the filesystem initialization

    AuthenticationContext authComponent = (AuthenticationContext) context.getBean("authenticationContext");
    authComponent.setSystemUserAsCurrentUser();

    // Wrap the initialization in a transaction

    UserTransaction tx = m_transactionService.getUserTransaction(true);

    try
    {
        // Start the transaction

        if (tx != null)
            tx.begin();
        
        StoreRef storeRef = new StoreRef(storeValue);
        
        if (nodeService.exists(storeRef) == false)
        {
            throw new RuntimeException("No store for path: " + storeRef);
        }
        
        NodeRef storeRootNodeRef = nodeService.getRootNode(storeRef);
        
        List<NodeRef> nodeRefs = searchService.selectNodes(storeRootNodeRef, rootPath, null, namespaceService, false);
        
        if (nodeRefs.size() > 1)
        {
            throw new RuntimeException("Multiple possible children for : \n" + "   path: " + rootPath + "\n" + "   results: " + nodeRefs);
        }
        else if (nodeRefs.size() == 0)
        {
            throw new RuntimeException("Node is not found for : \n" + "   root path: " + rootPath);
        }
        
        defaultRootNode = nodeRefs.get(0);
        
        // Commit the transaction
        if (tx != null)
        	tx.commit();
    }
    catch (Exception ex)
    {
        logger.error(ex);
    }
    finally
    {
        // Clear the current system user

        authComponent.clearCurrentSecurityContext();
    }
}
 

public static PolitenessOptions getPolitePolitenessOptions() {
    WebApplicationContext ctx = ApplicationContextFactory.getWebApplicationContext();
    return (PolitenessOptions) ctx.getBean("politePolitenessOptions");
}
 

private <T> T beanForName(String beanName, WebApplicationContext wac, Class<T> clazz) {
    return (T) wac.getBean(beanName, clazz);
}
 

/**
 * Restituisce un bean di sistema.
 * Il seguente metodo è in uso ai tag jsp del sistema.
 * @param beanName Il nome del servizio richiesto.
 * @param request La request.
 * @return Il servizio richiesto.
 */
public static Object getBean(String beanName, HttpServletRequest request) {
	WebApplicationContext wac = getWebApplicationContext(request);
	return wac.getBean(beanName);
}