Java Transaction.success方法代码示例

import org.neo4j.graphdb.Transaction; //导入方法依赖的package包/类
/**
 * Ends and closes a transaction.
 */
public void close() {
    CurrentTransaction currentTransaction = transactions.removeLast();
    Transaction transaction = currentTransaction.transaction;

    if (currentTransaction.success) {
        logger.debug("[close] Transaction success");
        transaction.success();
    }
    else {
        logger.debug("[close] Transaction failure");
        transaction.failure();
    }

    transaction.close();

    logger.debug("[close] Transaction closed");
}
 

import org.neo4j.graphdb.Transaction; //导入方法依赖的package包/类
private void analyseDb() {
	Transaction tx = graphDb.beginTx();
	try {
		PathFinder<Path> finder = GraphAlgoFactory.allPaths(//
				PathExpanders.forTypeAndDirection(RelTypes.KNOWS, Direction.BOTH), -1);
		Iterable<Path> paths = finder.findAllPaths(firstNode, secondNode);
		for (Path path : paths) {
			for (Node node : path.nodes()) {
				for (String prop : node.getPropertyKeys())
					System.out.print(prop);
				System.out.print(node.toString());
			}

			for (Relationship relationship : path.relationships())
				System.out.print(relationship.toString());
		}
		tx.success();
	} finally {
		tx.finish();
	}
}
 

import org.neo4j.graphdb.Transaction; //导入方法依赖的package包/类
@SuppressWarnings("deprecation")
/***
 * Sets significanceBit field of node to significanceBit.
 * @param node
 * @param significanceBit
 */
public void setSignificanceBit(Node node, int significanceBit)
{
	String tempString = serializer.serialize(significanceBit);
	Transaction tx = graphDB.beginTx();
	try
	{
		node.setProperty("__significanceBit", tempString);
		tx.success();
	}finally
	{
		tx.finish();
	}
}
 

import org.neo4j.graphdb.Transaction; //导入方法依赖的package包/类
@Override
public void storeShortUrl(ShortUrl shortUrl) {
    Transaction tx = db.beginTx();
    try {
        Node node = template.createNode(new Property(KEY, shortUrl.getKey()));
        node.setProperty(LONG_URL, shortUrl.getLongUrl());
        node.setProperty(USER_ID, shortUrl.getUser().getId());
        index.index(node, KEY, shortUrl.getKey());
        tx.success();
    } catch (Exception ex) {
        logger.error("Problem shortening url in the graph", ex);
        tx.failure();
    } finally {
        tx.finish();
    }

}
 

import org.neo4j.graphdb.Transaction; //导入方法依赖的package包/类
@Test
public void followingTest() throws Exception {
    Transaction tx = db.beginTx();
    User user = new User();
    user.setId("foo");
    user.setUsername("ufoo");
    User followed = new User();
    followed.setId("bar");
    followed.setUsername("ubar");
    Following f = new Following();
    f.setFollower(user);
    f.setFollowed(followed);
    try {
        dao.saveFollowing(f);
        tx.success();
    } catch (Exception ex) {
        tx.failure();
        throw ex;
    } finally {
        tx.finish();
    }
}
 

import org.neo4j.graphdb.Transaction; //导入方法依赖的package包/类
public static void main(String[] args) {

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = Utils.parseCommandLine(getOptions(), args);

        String graphDbPath = cmd.getOptionValue("d", Owl2Neo4jLoader.GRAPH_DB_PATH);
        GraphDatabaseService graphDb = new GraphDatabaseFactory().newEmbeddedDatabase(new File(graphDbPath));
        String query = "MATCH (n) RETURN n ORDER BY ID(n) DESC LIMIT 30;";
        Transaction tx = graphDb.beginTx();
        try {
            Result result = graphDb.execute(query);
            while (result.hasNext()) {
                Map<String, Object> row = result.next();
                for (String key : result.columns()) {
                    Node node = (Node) row.get(key);
                    Object name = node.getProperty("name");
                    System.out.printf("%s = %s; name = %s%n", key, row.get(key), name);
                }

            }
            tx.success();
        }
        catch (Exception e) {
            System.err.println("Exception caught: " + e.getMessage());
            e.printStackTrace();
            System.exit(ERR_STATUS);
        }
        finally {
            tx.close();
        }
        System.out.println("Exiting with success...");
        System.exit(OK_STATUS);

    }
 

import org.neo4j.graphdb.Transaction; //导入方法依赖的package包/类
/**
 * First off we start a graphDB. then we go over all valid assignments and add them all to undecided keys.
 * We have nodeDic to keep track of all entered nodes, one for each assignment which we also do in the 
 * while loop (enter a node with it's relevant matadata using json and Gson, for each assignment)
 * @param TupleQueryResult validAssignments, int suppToMakeSig, int usersToMakeSig.
 */
@SuppressWarnings("deprecation")
public NaiveAlgorithm(TupleQueryResult validAssignments, int suppToMakeSig, int usersToMakeSig) 
{
	/*first off we start a graphDB. then we go over all valid assignments and add them all to undecided keys.
	 * We have nodeDic to keep track of all entered nodes, one for each assignment which we also do in the 
	 * while loop (enter a node with it's relevant matadata using json and Gson, for each assignment) */
	super(validAssignments);
	this.nodeDic = new HashMap<BindingSet, Node>();
	this.MSP = new ArrayList<BindingSet>();
	this.undecidedKeys = new ArrayList<BindingSet>();
	this.suppToMakeSig =suppToMakeSig;
	this.usersToMakeSig = usersToMakeSig;
	
	BindingSet tempBindingSet = null;
	Node node = null;
	Transaction tx = graphDB.beginTx();
	try
	{
		while(validAssignments.hasNext())
		{ 
			tempBindingSet = validAssignments.next();
			node = graphDB.createNode();
			setBindingSet(node, tempBindingSet);
			setSupportDic(node, new HashMap<String,Integer>());
			setSignificanceBit(node, 0);
			nodeDic.put(tempBindingSet, node);
			this.undecidedKeys.add(tempBindingSet);
		}
		tx.success();
	}catch (QueryEvaluationException e)
	{
		e.printStackTrace();
	}finally
	{
		tx.finish();
	}
}
 

import org.neo4j.graphdb.Transaction; //导入方法依赖的package包/类
@SuppressWarnings("deprecation")
/**
 * input: assignment and userID and his support for said assignment.
 * @param assignment, userID, suuport.
 */
public void update(BindingSet assignment, int userID, int support)
{
	/* input: assignment and userID and his support for said assignment.
	 */
	String userIDString = new Integer(userID).toString();
	int aggAnswer;
	Map<String, Integer> tempDic = null;
	Transaction tx = graphDB.beginTx();
	try
	{
		Node tempNode = nodeDic.get(assignment);
		tempDic = getSupportDic(tempNode);		
		tempDic.put(userIDString, support);
		setSupportDic(tempNode, tempDic);
		aggAnswer = aggregator(assignment);	

		if (aggAnswer == 2) 
		{
			
			undecidedKeys.remove(assignment);
			MSP.add(assignment);
			setSignificanceBit(tempNode, 2);
		}else if (aggAnswer == 1)
		{
			setSignificanceBit(tempNode, 1);
			undecidedKeys.remove(assignment);
		}
		tx.success();
	}finally
	{
		tx.finish();
	}

}
 

import org.neo4j.graphdb.Transaction; //导入方法依赖的package包/类
/***
 * Sets SupportDic field of node to supportDic.
 * @param node
 * @param supportDic
 */
@SuppressWarnings("deprecation")
public void setSupportDic(Node node, Map<String,Integer> supportDic){
	String tempString = serializer.deepSerialize(supportDic);
	Transaction tx = graphDB.beginTx();
	try
	{
		node.setProperty("__supportDic", tempString);
		tx.success();
	}finally
	{
		tx.finish();
	}
}
 

import org.neo4j.graphdb.Transaction; //导入方法依赖的package包/类
/***
 * Sets BindingSet field of node to bindingSet.
 * @param node
 * @param bindingSet
 */
@SuppressWarnings("deprecation")
public void setBindingSet(Node node, BindingSet bindingSet)
{
	String tempString = serializer.serialize(bindingSet);
	Transaction tx = graphDB.beginTx();
	try
	{
		node.setProperty("__bindingSet", tempString);
		tx.success();
	}finally
	{
		tx.finish();
	}
}
 

import org.neo4j.graphdb.Transaction; //导入方法依赖的package包/类
@Async
public void migrateFollowingGraph() {
    // the jpa dao only needed here, no need to live in the context
    FollowingDaoJpa dao = new FollowingDaoJpa();
    ctx.getAutowireCapableBeanFactory().autowireBean(dao);

    List<User> users = userDao.list(User.class);

    Transaction tx = graphDb.beginTx();
    try {
        for (User user : users) {
            List<User> followers = dao.getFollowers(user);
            for (User follower : followers) {
                if (follower.equals(user)) {
                    continue;
                }
                Following following = dao.findFollowing(follower, user, false);
                if (following.getDateTime() == null) {
                    following.setDateTime(new DateTime().minusMonths(2));
                }
                if (following != null && followingDao.findFollowing(follower, user, false) == null) {
                    followingDao.saveFollowing(following);
                }
            }
        }
        tx.success();
    } catch (RuntimeException ex) {
        tx.failure();
        logger.error("GraphDB transaction problem", ex);
        throw ex;
    } finally {
        tx.finish();
    }
}
 

import org.neo4j.graphdb.Transaction; //导入方法依赖的package包/类
/***
 * @param userID
 * @return next assignment to query this user, null if none are left.
 */
@SuppressWarnings("deprecation")
@Override
public BindingSet next(int userID) 
{
	/*TODO: maybe make the node making lazy, that is only make the node when the assignment is first asked.
	 * input: userID
	 * output: next assignment to query this user, null if none are left.*/
	String userIDString = new Integer(userID).toString();
	Random random = new Random();
	BindingSet randomKey = null;
	Node tempNode = null;
	Map<String, Integer> tempDic = null;
	Transaction tx = graphDB.beginTx();
	List<BindingSet> listOfAssignments = new ArrayList<BindingSet>(undecidedKeys.size());
	int index;
	
	
	for (BindingSet bindingSet: undecidedKeys)
	{ /*makes a copy of undecidedkeys so that when we iterate over it we can 
												  delete those this userID has answered even though they aren't significant yet. 
												  Remember these two lists contain the same elements and not copies of the elements!*/
		listOfAssignments.add(bindingSet);
	}
	
	try
	{
		while (!listOfAssignments.isEmpty()) 
		{ // iterates over random assignments until an undiscovered one is found.
			index = random.nextInt(listOfAssignments.size());
			randomKey = listOfAssignments.get(index);
			tempNode = nodeDic.get(randomKey);
			tempDic = getSupportDic(tempNode);
			//System.out.println(tempDic.containsKey(userIDString));
			
			if (!tempDic.containsKey(userIDString))
			{ //if user hasn't been asked this assignment before then return it.
				break;
			}else
			{
				listOfAssignments.remove(index);
			}
		}
		tx.success();
	}finally
	{
		tx.finish();
	}
	if (listOfAssignments.isEmpty())
	{
		return null;
	}else
	{
		return randomKey;
	}
}