Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2012 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.faces.flow;
import com.sun.faces.util.FacesLogger;
import com.sun.faces.util.Util;
import java.io.Serializable;
import javax.faces.flow.FlowScoped;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.enterprise.context.ContextNotActiveException;
import javax.enterprise.context.spi.Context;
import javax.enterprise.context.spi.Contextual;
import javax.enterprise.context.spi.CreationalContext;
import javax.enterprise.event.Observes;
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.inject.spi.BeanManager;
import javax.enterprise.inject.spi.BeforeShutdown;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.flow.Flow;
import javax.faces.flow.FlowHandler;
import javax.faces.lifecycle.ClientWindow;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
public class FlowCDIContext implements Context, Serializable {
private static final long serialVersionUID = -7144653402477623609L;
private static final FlowScopeMapKey FLOW_SCOPE_MAP_KEY = new FlowScopeMapKey();
private static final Logger LOGGER = FacesLogger.FLOW.getLogger();
private transient Map, FlowBeanInfo> flowIds;
static class FlowBeanInfo {
String definingDocumentId;
String id;
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final FlowBeanInfo other = (FlowBeanInfo) obj;
if ((this.definingDocumentId == null) ? (other.definingDocumentId != null) : !this.definingDocumentId.equals(other.definingDocumentId)) {
return false;
}
if ((this.id == null) ? (other.id != null) : !this.id.equals(other.id)) {
return false;
}
return true;
}
@Override
public int hashCode() {
int hash = 7;
hash = 79 * hash + (this.definingDocumentId != null ? this.definingDocumentId.hashCode() : 0);
hash = 79 * hash + (this.id != null ? this.id.hashCode() : 0);
return hash;
}
@Override
public String toString() {
return "FlowBeanInfo{" + "definingDocumentId=" + definingDocumentId + ", id=" + id + '}';
}
}
// This should be vended from a factory for decoration purposes.
FlowCDIContext(Map, FlowBeanInfo> flowIds) {
this.flowIds = new ConcurrentHashMap, FlowBeanInfo>(flowIds);
}
private static final String PER_SESSION_BEAN_MAP_LIST = FlowCDIContext.class.getPackage().getName() + ".PER_SESSION_BEAN_MAP_LIST";
private static final String PER_SESSION_CREATIONAL_LIST = FlowCDIContext.class.getPackage().getName() + ".PER_SESSION_CREATIONAL_LIST";
// -------------------------------------------------------- Private Methods
//
private static Map, Object> getFlowScopedBeanMapForCurrentFlow() {
Map, Object> result;
FacesContext context = FacesContext.getCurrentInstance();
ExternalContext extContext = context.getExternalContext();
Map sessionMap = extContext.getSessionMap();
Flow currentFlow = getCurrentFlow(context);
if (null == currentFlow) {
return null;
}
ClientWindow curWindow = context.getExternalContext().getClientWindow();
if (null == curWindow) {
throw new IllegalStateException("Unable to obtain current ClientWindow. Is the ClientWindow feature enabled?");
}
String flowBeansForClientWindow = currentFlow.getClientWindowFlowId(curWindow) + "_beans";
result = (Map, Object>) sessionMap.get(flowBeansForClientWindow);
if (null == result) {
result = new ConcurrentHashMap, Object>();
sessionMap.put(flowBeansForClientWindow, result);
ensureBeanMapCleanupOnSessionDestroyed(sessionMap, flowBeansForClientWindow);
}
return result;
}
private static Map, CreationalContext> getFlowScopedCreationalMapForCurrentFlow() {
Map, CreationalContext> result;
FacesContext context = FacesContext.getCurrentInstance();
ExternalContext extContext = context.getExternalContext();
Map sessionMap = extContext.getSessionMap();
Flow currentFlow = getCurrentFlow(context);
ClientWindow curWindow = context.getExternalContext().getClientWindow();
if (null == curWindow) {
throw new IllegalStateException("Unable to obtain current ClientWindow. Is the ClientWindow feature enabled?");
}
String creationalForClientWindow = currentFlow.getClientWindowFlowId(curWindow) + "_creational";
result = (Map, CreationalContext>) sessionMap.get(creationalForClientWindow);
if (null == result) {
result = new ConcurrentHashMap, CreationalContext>();
sessionMap.put(creationalForClientWindow, result);
ensureCreationalCleanupOnSessionDestroyed(sessionMap, creationalForClientWindow);
}
return result;
}
private static void ensureBeanMapCleanupOnSessionDestroyed(Map sessionMap, String flowBeansForClientWindow) {
List beanMapList = (List) sessionMap.get(PER_SESSION_BEAN_MAP_LIST);
if (null == beanMapList) {
beanMapList = new ArrayList();
sessionMap.put(PER_SESSION_BEAN_MAP_LIST, beanMapList);
}
beanMapList.add(flowBeansForClientWindow);
}
private static void ensureCreationalCleanupOnSessionDestroyed(Map sessionMap, String creationalForClientWindow) {
List beanMapList = (List) sessionMap.get(PER_SESSION_CREATIONAL_LIST);
if (null == beanMapList) {
beanMapList = new ArrayList();
sessionMap.put(PER_SESSION_CREATIONAL_LIST, beanMapList);
}
beanMapList.add(creationalForClientWindow);
}
@SuppressWarnings({"FinalPrivateMethod"})
private final void assertNotReleased() {
if (!isActive()) {
throw new IllegalStateException();
}
}
private Flow getCurrentFlow() {
Flow result = null;
FacesContext context = FacesContext.getCurrentInstance();
result = getCurrentFlow(context);
return result;
}
private static Flow getCurrentFlow(FacesContext context) {
FlowHandler flowHandler = context.getApplication().getFlowHandler();
if (null == flowHandler) {
return null;
}
Flow result = flowHandler.getCurrentFlow(context);
return result;
}
private static class FlowScopeMapKey implements Contextual
//
/*
* Called from WebappLifecycleListener.sessionDestroyed()
*/
public static void sessionDestroyed(HttpSessionEvent hse) {
HttpSession session = hse.getSession();
List beanMapList = (List) session.getAttribute(PER_SESSION_BEAN_MAP_LIST);
if (null != beanMapList) {
for (String cur : beanMapList) {
Map, Object> beanMap =
(Map, Object>) session.getAttribute(cur);
beanMap.clear();
session.removeAttribute(cur);
}
session.removeAttribute(PER_SESSION_BEAN_MAP_LIST);
beanMapList.clear();
}
List creationalList = (List) session.getAttribute(PER_SESSION_CREATIONAL_LIST);
if (null != creationalList) {
for (String cur : creationalList) {
Map, CreationalContext> beanMap =
(Map, CreationalContext>) session.getAttribute(cur);
beanMap.clear();
session.removeAttribute(cur);
}
session.removeAttribute(PER_SESSION_CREATIONAL_LIST);
creationalList.clear();
}
}
//
//
static Map getCurrentFlowScope() {
Map, Object> flowScopedBeanMap = getFlowScopedBeanMapForCurrentFlow();
Map result = null;
if (null != flowScopedBeanMap) {
result = (Map) flowScopedBeanMap.get(FLOW_SCOPE_MAP_KEY);
if (null == result) {
result = new ConcurrentHashMap();
flowScopedBeanMap.put(FLOW_SCOPE_MAP_KEY, result);
}
}
return result;
}
static void flowExited() {
Map, Object> flowScopedBeanMap = getFlowScopedBeanMapForCurrentFlow();
Map, CreationalContext> creationalMap = getFlowScopedCreationalMapForCurrentFlow();
assert(!flowScopedBeanMap.isEmpty());
assert(!creationalMap.isEmpty());
List> flowScopedBeansToRemove = new ArrayList>();
for (Entry, Object> entry : flowScopedBeanMap.entrySet()) {
Contextual owner = entry.getKey();
Object bean = entry.getValue();
CreationalContext creational = creationalMap.get(owner);
owner.destroy(bean, creational);
flowScopedBeansToRemove.add(owner);
}
for (Contextual cur : flowScopedBeansToRemove) {
flowScopedBeanMap.remove(cur);
creationalMap.remove(cur);
}
if (Util.isCdiOneOneOrGreater()) {
Class flowCDIEventFireHelperImplClass = null;
try {
flowCDIEventFireHelperImplClass = Class.forName("com.sun.faces.flow.FlowCDIEventFireHelperImpl");
} catch (ClassNotFoundException ex) {
if (LOGGER.isLoggable(Level.SEVERE)) {
LOGGER.log(Level.SEVERE, "CDI 1.1 events not enabled", ex);
}
}
if (null != flowCDIEventFireHelperImplClass) {
FacesContext facesContext = FacesContext.getCurrentInstance();
BeanManager beanManager = (BeanManager) Util.getCDIBeanManager(facesContext.getExternalContext().getApplicationMap());
Set> availableBeans = beanManager.getBeans(flowCDIEventFireHelperImplClass);
if (null != availableBeans && !availableBeans.isEmpty()) {
Bean bean = beanManager.resolve(availableBeans);
CreationalContext creationalContext =
beanManager.createCreationalContext(null);
FlowCDIEventFireHelper eventHelper =
(FlowCDIEventFireHelper) beanManager.getReference(bean, bean.getBeanClass(),
creationalContext);
eventHelper.fireDestroyedEvent(getCurrentFlow(facesContext));
}
}
}
}
static void flowEntered() {
getFlowScopedBeanMapForCurrentFlow();
getFlowScopedCreationalMapForCurrentFlow();
getCurrentFlowScope();
if (Util.isCdiOneOneOrGreater()) {
Class flowCDIEventFireHelperImplClass = null;
try {
flowCDIEventFireHelperImplClass = Class.forName("com.sun.faces.flow.FlowCDIEventFireHelperImpl");
} catch (ClassNotFoundException ex) {
if (LOGGER.isLoggable(Level.SEVERE)) {
LOGGER.log(Level.SEVERE, "CDI 1.1 events not enabled", ex);
}
}
if (null != flowCDIEventFireHelperImplClass) {
FacesContext facesContext = FacesContext.getCurrentInstance();
BeanManager beanManager = (BeanManager) Util.getCDIBeanManager(facesContext.getExternalContext().getApplicationMap());
Set> availableBeans = beanManager.getBeans(flowCDIEventFireHelperImplClass);
if (null != availableBeans && !availableBeans.isEmpty()) {
Bean bean = beanManager.resolve(availableBeans);
CreationalContext creationalContext =
beanManager.createCreationalContext(null);
FlowCDIEventFireHelper eventHelper =
(FlowCDIEventFireHelper) beanManager.getReference(bean, bean.getBeanClass(),
creationalContext);
eventHelper.fireInitializedEvent(getCurrentFlow(facesContext));
}
}
}
}
//
//
@Override
public T get(Contextual contextual, CreationalContext creational) {
assertNotReleased();
T result = get(contextual);
if (null == result) {
Map, Object> flowScopedBeanMap = getFlowScopedBeanMapForCurrentFlow();
Map, CreationalContext> creationalMap = getFlowScopedCreationalMapForCurrentFlow();
synchronized (flowScopedBeanMap) {
result = (T) flowScopedBeanMap.get(contextual);
if (null == result) {
FacesContext facesContext = FacesContext.getCurrentInstance();
FlowHandler flowHandler = facesContext.getApplication().getFlowHandler();
if (null == flowHandler) {
return null;
}
FlowBeanInfo fbi = flowIds.get(contextual);
if (!flowHandler.isActive(facesContext, fbi.definingDocumentId, fbi.id)) {
throw new ContextNotActiveException("Request to activate bean in flow '" + fbi + "', but that flow is not active.");
}
result = contextual.create(creational);
if (null != result) {
flowScopedBeanMap.put(contextual, result);
creationalMap.put(contextual, creational);
}
}
}
}
return result;
}
@Override
public T get(Contextual contextual) {
assertNotReleased();
return (T) getFlowScopedBeanMapForCurrentFlow().get(contextual);
}
@Override
public Class getScope() {
return FlowScoped.class;
}
@Override
public boolean isActive() {
return null != getCurrentFlow();
}
void beforeShutdown(@Observes final BeforeShutdown event, BeanManager beanManager) {
}
//
}