When you have a @ManyToMany one side will be the side that “ownes” the relationship and the other side does not. This means which side of the Many-To-Many will be in charge of updating the join table on the add or remove of the relationship.

Here are my simplified test Entities.

public class MyUser {
    @ManyToMany(cascade = CascadeType.PERSIST, fetch = FetchType.EAGER)
    private Set<Auth> roles = new HashSet<Auth>();
}
public class Auth {
    @ManyToMany(fetch = FetchType.LAZY, mappedBy = "roles")
    private Set<MyUser> users = new HashSet<MyUser>();
}

So when you remove the “owner” Entity MyUser it will remove the row in the relationship table that relates to Auth. But I was having a hard time figuring out the best way to get the relationships to MyUser instances severed (not deleted) when my code removes the “not owning” Entity MyAuth.

The way to do it is removing the relationship manually with a @PreRemove JPA lifecycle callback annotation on the Auth Class.

    @PreRemove
    @SuppressWarnings("unused")
    private void removeUsers() {
    	for (MyUser user: users) {
    		user.getRoles().remove(this);
    	}
    }

This will get called right before the Auth object is removed and clear out the MyUser references to this Auth object.

Is there a better way to do this?

Here is a quick walk through of my first attempt to have a domain object’s properties saved to a database via Hibernate and to Neo4j database.

All we’re going to do to start is have a single property called “nickname” stored in a Neo4J datastore. Nothing very useful or interesting about this but I’ll use that as a way to show the minimal setup for getting the Object properties stored in multiple databases and combined on save/access.

In a future post I’ll hopefully do something more interesting with this very cool/useful technique.

Let’s start with a very simple Roo script to build a full enterprise java app.

project --topLevelPackage com.ex --projectName Neo4jTest --java 6 --packaging JAR
jpa setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY

entity jpa --class ~.domain.UserAccount --activeRecord false
field string --fieldName firstName
field string --fieldName nickname

repository jpa --interface ~.repository.UserAccountRepository --entity ~.domain.UserAccount
service --interface ~.service.UserAccountService --entity ~.domain.UserAccount

web mvc setup
web mvc all --package ~.web

This will output a spring configured webapp that saves to a SQL database via Hibernate. You can run the app with the following to try it out.

mvn jetty:run

So now the plan is to set it up so that the nickname property of the UserAccount domain object is saved to a neo4j database while the firstname property is saved to the SQL database.

The first step is to update the maven pom.xml file with some additional dependencies.

Add the following to the <properties> section for the versions to use

<spring-data-neo4j.version>2.1.0.BUILD-SNAPSHOT</spring-data-neo4j.version>
<neo4j.version>1.6</neo4j.version>

Add the dependencies for the neo4j database and the spring-data connector.

<dependency>
<groupId>org.neo4j</groupId>
<artifactId>neo4j-kernel</artifactId>
<version>${neo4j.version}</version>
<type>test-jar</type>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-neo4j-cross-store</artifactId>
<version>${spring-data-neo4j.version}</version>
</dependency>

You might have some dependency conflicts (like I did) which will necessitate the following exclusion change to the existing spring-data-jpa dependency.

<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.0.3.RELEASE</version>
<exclusions>
<exclusion>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-commons-core</artifactId>
</exclusion>
</exclusions>
</dependency>

Lastly in order to get the neo4j aspect4j weaving done when the project build is called you need to add the following to the aspectj-maven-plugin plugin under the <aspectLibraries> section.

<aspectLibrary>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-neo4j-aspects</artifactId>
</aspectLibrary>

Now we need to setup the Neo4j database. Spring makes this very simple via the neo4j namespace.

Add the namespace to applicationContext.xml

xmlns:neo4j="http://www.springframework.org/schema/data/neo4j"

and the schema location

http://www.springframework.org/schema/data/neo4j http://www.springframework.org/schema/data/neo4j/spring-neo4j-2.0.xsd

then setting up the db is just the following one line config.

<neo4j:config storeDirectory="target/db-test" entityManagerFactory="entityManagerFactory"/>

Now add a couple Java Annotations (which adds some more aspect code) we can get the nickname property saved to the graph Database and the firstname property saved to the SQL database.

Add the following annotations to the UserAccount.java file.

@NodeEntity(partial = true)
public class UserAccount {

private String firstName;

@GraphProperty
String nickname;
}

This marks the Java Bean as to be “partially” saved to the Neo4j database and specifically the nickname property is not saved to the SQL database.

the last piece to do is override the default service code that Roo created that saves the Entity via Hibernate. We need to add code to also save the Entity to Neo4J.

Add the following to UserAccountServiceImpl.java.

public class UserAccountServiceImpl implements UserAccountService {

	public void saveUserAccount(UserAccount userAccount) {
		userAccountRepository.save(userAccount);
		userAccount.persist();
	}

	public UserAccount updateUserAccount(UserAccount userAccount) {
		if (userAccount != null) {
			userAccount.persist();
		}
		return userAccountRepository.save(userAccount);
	}

	public UserAccount findUserAccount(Long id) {
		if (id == null) return null;
			final UserAccount userAccount = userAccountRepository.findOne(id);
		if (userAccount != null) {
			userAccount.persist();
		}
		return userAccount;
	}
}

Once you add these methods Roo will automatically remove the same generated methods from the .aj aspect files.

Next time I will add some relationships and code to do things that take advantage of the Graph structure of the Neo4j database. Also a useful tool is Neoclipse for visualizing the saved Neo4j data.

It turned out that the issue was a bug in the auto-generated JSPX files that Spring Roo MVC created.

This is one of the big problems with code generators. When you rely on others code it is sometimes a lot harder to debug and track down silly issues.

I added a JIRA issue for this and hopefully the fix will make it into the next Roo release. The quick answer is to remove the following unnecessary code from the generated display.jspx file.

<c:set var="sec_object" value="${fn:escapeXml(object)}" />

So if you are in STS and try to get a Spring Roo GWT app to you might see errors like -

The import
javax.validation.ConstraintViolation cannot be resolved...

...did you forget to inherit a required
module?

The fix was to uninstall and upgrade the “m2e project configurators for Eclipse WTP” to version 0.15 from 0.14.

Hope that helps someone.

Might also need to use a Document database for the web-snapshots. Any suggestions?

Now have to work on the inevitable Hibernate mapping issues. So now I have an issue where viewing a single bookmark loads the entire User graph. This is obviously some JPA screwup in my @manyto… annotations.

To debug I’ll start by changing the FetchType to LAZY and see if that helps. Then maybe start removing some links and see if I can get to the bottom of this issue.

Strange because the call to fetch all of a users bookmarks is instantaneous but viewing a single bookmark takes like 20 seconds… something is very messed up

Spring Security 3.0 introduced the ability to use Spring EL expressions as an authorization mechanism in addition to the simple use of configuration attributes and access-decision voters which have seen before. Expression-based access control is built on the same architecture but allows complicated boolean logic to be encapsulated in a single expression.

With Spring Security you can use an EL statement to limit accessibility via some property of the method parameter.

@PreAuthorize("#contact.name == authentication.name")
public void doSomething(Contact contact);

Here we are accessing another built-in expression, “authentication”, which is the Authentication stored in the security context.

Another option is to filter the Method’s returned List and only return object that meet ACL criteria.

This is done using the @PostFilter annotation, Spring Security iterates through the returned collection and removes any elements for which the supplied expression is false. The name filterObject refers to the current object in the collection.

@PostFilter("filterObject.owners.email == principal.username or hasRole('ROLE_ADMIN')")
List findAll();

The downside to this is the query to the database will return all the Account objects so the DB performance will be impacted.

Hibernate Filters

Filters are a way to combat this potential Database performance issue.

A filter criteria allows you to define a restriction clause similar to the existing “where” attribute available on the class and various collection elements.

You define a filter with @FilterDef giving it a name and named parameters with @ParamDef. Then you can specify usage of that filter on fields of an Entity to limit the returned values.

So to limit entity access you could have a filter like this -

// Define a filter
@FilterDef(name="restrictToUserIdFilter", parameters={@ParamDef(name="userId", type="String")}

// Add a filter to an Entity
@Filter(
name = "restrictToUserIdFilter",
condition="userId = :currentUserId"
)

// Then you enable the filter on the session you make the Criteria query in

Session session = sessionFactory.getCurrentSession();
Filter filter = session.enableFilter("restrictToUserIdFilter");
filter.setParameter("currentUserId", SecurityContextHolder.getContext().getAuthentication().getPrincipal().getUsername());

List results = session.createQuery("from Employee as e where e.salary > :targetSalary")
.setLong("targetSalary", new Long(1000000))
.list();

This will basically wrap your Hibernate generated SQL in a WHERE clause so that only Employee entities with userId = the logged in user will be shown.

• Remove the importance of money in politics.
• Allow people to evangelize issues and candidates to their connections.
• Promote “real world” actions by motivated groups of people to affect their representative government at all levels.
• Make Government more responsive to the wishes of their real constituents. Not the narrow interest groups.

Here are some interesting startups working on Socializing Politics. I think there is still much work and opportunity to be explored in this area.

Votizen is an online network of real voters who have expressed their commitment to be engaged citizens. A free service, Votizen allows you to see your real voting history, learn the issues, endorse candidates, write open letters, and take collective action.

Yatterbox is a political social media website that presents and archives all the social media output of MPs (UK version) and Senators, Representatives, Governors and Congressional Committees (US version). This includes updates from Twitter, Facebook, Flickr, YouTube, RSS feeds.

We all are conditioned to the mythology of the “instant success” story. The kid with the idea on a Monday and the IPO in a couple short months. But deep down we all know that is never the case.

“Instant success takes time” is one of my favorite truisms. New startups, amazing polished products, or ideas that just rocket to success out of nowhere and have often been preceded by a long period of preparation, rehearsal, and trial-and-error experimentation.

Matt Hendrick has a poignant post titled On Perseverance that speaks to the attitude needed to make it in a new venture.

“It won’t be easy. Taking this path requires sacrifice. Humble yourself. We all need money to survive in this world. Do you think you’re “above” being a waiter, or working a pizza delivery job on the side to keep the lights on? Just how badly do you want to succeed? There’s a famous saying that my friends and I latched onto some years ago: “Successful people do what unsuccessful people won’t do, even when they don’t want to do it.” You might not want to get up at 5:30 in the morning to work a second job, but your situation may require it. Are you up to the challenge?”

Winning and the courage to see your dreams through is no mystery. Successful people have invested in three underpinnings of their confidence.

First is responsibility.

They’ve already confronted facts truthfully and taken accountability for his or her personal decisions.

Next is collaboration.

They’ve created allies and associates, not adversaries in all their relationships.

Finally there is initiative thinking.

They try to make continuous small-scale improvements instead of counting only on the periodic smash hit success.

During the last decade, Online marketing has observed a superb growth when it comes to its growth and from numerous techniques it’s banner ad campaigns that is in the best position.

Keyword focusing on happens when you produce a specific page or pages to become a fitting response for any internet search engine query. It’s crafting your page to ensure that search engines like Google can certainly discern the page matches a particular search query. Keyword focusing on is really a popular term among online marketer’s. The following factor to see in keyword focusing on is when frequently phrase seems in your body in comparison with other words in your body. You would like top listing about the search engines like Google, and you have to target key phrases, so you receive a #1 listing.

Actually, determining which technique to choose is really a complex problem and is dependent on the keyword and who’s searching for this.