001: /*
002: * JBoss, Home of Professional Open Source.
003: * Copyright 2006, Red Hat Middleware LLC, and individual contributors
004: * as indicated by the @author tags. See the copyright.txt file in the
005: * distribution for a full listing of individual contributors.
006: *
007: * This is free software; you can redistribute it and/or modify it
008: * under the terms of the GNU Lesser General Public License as
009: * published by the Free Software Foundation; either version 2.1 of
010: * the License, or (at your option) any later version.
011: *
012: * This software is distributed in the hope that it will be useful,
013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
015: * Lesser General Public License for more details.
016: *
017: * You should have received a copy of the GNU Lesser General Public
018: * License along with this software; if not, write to the Free
019: * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
021: */
022: package org.jboss.ejb3.test.clusteredentity.classloader;
023:
024: import java.util.HashSet;
025: import java.util.Iterator;
026: import java.util.List;
027: import java.util.Set;
028:
029: import javax.ejb.Remote;
030: import javax.ejb.Remove;
031: import javax.ejb.Stateful;
032: import javax.management.MBeanServer;
033: import javax.management.ObjectName;
034: import javax.persistence.EntityManager;
035: import javax.persistence.PersistenceContext;
036: import javax.persistence.Query;
037:
038: import org.jboss.cache.AbstractTreeCacheListener;
039: import org.jboss.cache.Fqn;
040: import org.jboss.cache.TreeCache;
041: import org.jboss.cache.TreeCacheMBean;
042: import org.jboss.logging.Logger;
043: import org.jboss.mx.util.MBeanProxyExt;
044: import org.jboss.mx.util.MBeanServerLocator;
045:
046: /**
047: * Comment
048: *
049: * @author Brian Stansberry
050: * @version $Revision: 60233 $
051: */
052: @Stateful
053: @Remote(EntityQueryTest.class)
054: public class EntityQueryTestBean implements EntityQueryTest {
055: private static final Logger log = Logger
056: .getLogger(EntityQueryTestBean.class);
057:
058: @PersistenceContext
059: private EntityManager manager;
060:
061: private String cacheObjectName;
062:
063: private MyListener listener;
064:
065: public EntityQueryTestBean() {
066: }
067:
068: public void getCache(boolean optimistic) {
069: if (optimistic)
070: cacheObjectName = "jboss.cache:service=OptimisticEJB3EntityTreeCache";
071: else
072: cacheObjectName = "jboss.cache:service=EJB3EntityTreeCache";
073:
074: try {
075: //Just to initialise the cache with a listener
076: TreeCache cache = getCache();
077: listener = new MyListener();
078: cache.addTreeCacheListener(listener);
079: } catch (Exception e) {
080: throw new RuntimeException(e);
081: }
082: }
083:
084: public void updateAccountBranch(Integer id, String branch) {
085: Account account = (Account) manager.find(Account.class, id);
086: account.setBranch(branch);
087: }
088:
089: public int getCountForBranch(String branch, boolean useNamed,
090: boolean useRegion) {
091: if (useNamed)
092: return getCountForBranchViaNamedQuery(branch, useRegion);
093: else
094: return getCountForBranchViaLocalQuery(branch, useRegion);
095: }
096:
097: private int getCountForBranchViaLocalQuery(String branch,
098: boolean useRegion) {
099: Query query = manager
100: .createQuery("select account from Account as account where account.branch = ?1");
101: query.setParameter(1, branch);
102: if (useRegion) {
103: query.setHint("org.hibernate.cacheRegion", "AccountRegion");
104: }
105: query.setHint("org.hibernate.cacheable", Boolean.TRUE);
106: return query.getResultList().size();
107:
108: }
109:
110: private int getCountForBranchViaNamedQuery(String branch,
111: boolean useRegion) {
112: String queryName = useRegion ? "account.bybranch.namedregion"
113: : "account.bybranch.default";
114: Query query = manager.createNamedQuery(queryName);
115: query.setParameter(1, branch);
116: return query.getResultList().size();
117: }
118:
119: /* (non-Javadoc)
120: * @see org.jboss.ejb3.test.clusteredentity.EntityQueryTest#createAccount(org.jboss.ejb3.test.clusteredentity.AccountHolderPK, Integer, Integer)
121: */
122: public void createAccount(AccountHolderPK pk, Integer id,
123: Integer openingBalance, String branch) {
124: Account account = new Account();
125: account.setId(id);
126: account.setAccountHolder(pk);
127: account.setBalance(openingBalance);
128: account.setBranch(branch);
129: manager.persist(account);
130: }
131:
132: public void updateAccountBalance(Integer id, Integer newBalance) {
133: Account account = (Account) manager.find(Account.class, id);
134: account.setBalance(newBalance);
135: }
136:
137: public String getBranch(AccountHolderPK pk, boolean useNamed,
138: boolean useRegion) {
139: if (useNamed)
140: return getBranchViaNamedQuery(pk, useRegion);
141: else
142: return getBranchViaLocalQuery(pk, useRegion);
143: }
144:
145: private String getBranchViaLocalQuery(AccountHolderPK pk,
146: boolean useRegion) {
147: Query query = manager
148: .createQuery("select account.branch from Account as account where account.accountHolder = ?1");
149: query.setParameter(1, pk);
150: if (useRegion) {
151: query.setHint("org.hibernate.cacheRegion", "AccountRegion");
152: }
153: query.setHint("org.hibernate.cacheable", Boolean.TRUE);
154: return (String) query.getResultList().get(0);
155: }
156:
157: /* (non-Javadoc)
158: * @see org.jboss.ejb3.test.clusteredentity.EntityQueryTest#getPostCodeViaNamedQuery(org.jboss.ejb3.test.clusteredentity.AccountHolderPK, boolean)
159: */
160: private String getBranchViaNamedQuery(AccountHolderPK pk,
161: boolean useRegion) {
162: String queryName = useRegion ? "account.branch.namedregion"
163: : "account.branch.default";
164: Query query = manager.createNamedQuery(queryName);
165: query.setParameter(1, pk);
166: return (String) query.getResultList().get(0);
167: }
168:
169: public int getTotalBalance(AccountHolderPK pk, boolean useNamed,
170: boolean useRegion) {
171: if (useNamed)
172: return getTotalBalanceViaNamedQuery(pk, useRegion);
173: else
174: return getTotalBalanceViaLocalQuery(pk, useRegion);
175: }
176:
177: private int getTotalBalanceViaLocalQuery(AccountHolderPK pk,
178: boolean useRegion) {
179: Query query = manager
180: .createQuery("select account.balance from Account as account where account.accountHolder = ?1");
181: query.setParameter(1, pk);
182: query.setHint("org.hibernate.cacheable", Boolean.TRUE);
183: return totalBalances(query);
184: }
185:
186: private int getTotalBalanceViaNamedQuery(AccountHolderPK pk,
187: boolean useRegion) {
188: String queryName = useRegion ? "account.totalbalance.namedregion"
189: : "account.totalbalance.default";
190: Query query = manager.createNamedQuery(queryName);
191: query.setParameter(1, pk);
192: return totalBalances(query);
193: }
194:
195: private int totalBalances(Query balanceQuery) {
196: List results = balanceQuery.getResultList();
197: int total = 0;
198: if (results != null) {
199: for (Iterator it = results.iterator(); it.hasNext();) {
200: total += ((Integer) it.next()).intValue();
201: System.out.println("Total = " + total);
202: }
203: }
204: return total;
205: }
206:
207: public boolean getSawRegionModification(String regionName) {
208: return getSawRegion(regionName, listener.modified);
209: }
210:
211: public boolean getSawRegionAccess(String regionName) {
212: return getSawRegion(regionName, listener.accessed);
213: }
214:
215: private boolean getSawRegion(String regionName, Set sawEvent) {
216: boolean saw = false;
217: Fqn fqn = Fqn.fromString(regionName);
218: for (Iterator it = sawEvent.iterator(); it.hasNext();) {
219: Fqn modified = (Fqn) it.next();
220: if (modified.isChildOf(fqn)) {
221: it.remove();
222: saw = true;
223: }
224: }
225: return saw;
226:
227: }
228:
229: public void cleanup() {
230: Query query = manager
231: .createQuery("select account from Account as account");
232: List accts = query.getResultList();
233: if (accts != null) {
234: for (Iterator it = accts.iterator(); it.hasNext();) {
235: try {
236: Account acct = (Account) it.next();
237: log.info("Removing " + acct);
238: manager.remove(acct);
239: } catch (Exception ignored) {
240: }
241: }
242: }
243: }
244:
245: @Remove
246: public void remove() {
247: cleanup();
248: listener.clear();
249: try {
250: getCache().removeTreeCacheListener(listener);
251: } catch (Exception e) {
252: e.printStackTrace();
253: }
254: }
255:
256: private TreeCache getCache() throws Exception {
257: MBeanServer server = MBeanServerLocator.locateJBoss();
258: TreeCacheMBean proxy = (TreeCacheMBean) MBeanProxyExt.create(
259: TreeCacheMBean.class, new ObjectName(cacheObjectName),
260: server);
261: TreeCache cache = proxy.getInstance();
262:
263: return cache;
264: }
265:
266: class MyListener extends AbstractTreeCacheListener {
267: HashSet modified = new HashSet();
268: HashSet accessed = new HashSet();
269:
270: public void clear() {
271: modified.clear();
272: accessed.clear();
273: }
274:
275: @Override
276: public void nodeModified(Fqn fqn) {
277: System.out.println("MyListener - Modified node "
278: + fqn.toString());
279: modified.add(fqn);
280: }
281:
282: @Override
283: public void nodeCreated(Fqn fqn) {
284: System.out.println("MyListener - Created node "
285: + fqn.toString());
286: modified.add(fqn);
287: }
288:
289: @Override
290: public void nodeVisited(Fqn fqn) {
291: System.out.println("MyListener - Visited node "
292: + fqn.toString());
293: accessed.add(fqn);
294: }
295:
296: }
297: }
|